diff --git a/src/lib/api/mutations/grid.mutations.ts b/src/lib/api/mutations/grid.mutations.ts
index edb38f78..70ca02cf 100644
--- a/src/lib/api/mutations/grid.mutations.ts
+++ b/src/lib/api/mutations/grid.mutations.ts
@@ -14,7 +14,8 @@ import {
 	type CreateGridCharacterParams,
 	type CreateGridSummonParams,
 	type UpdateUncapParams,
-	type ResolveConflictParams
+	type ResolveConflictParams,
+	type SwapPositionsParams
 } from '$lib/api/adapters/grid.adapter'
 import { partyKeys } from '$lib/api/queries/party.queries'
 import type { Party, GridWeapon, GridCharacter, GridSummon } from '$lib/types/api/party'
@@ -214,6 +215,23 @@ export function useResolveWeaponConflict() {
 	}))
 }
 
+/**
+ * Swap weapon positions mutation
+ *
+ * Swaps the positions of two weapons in the grid.
+ */
+export function useSwapWeapons() {
+	const queryClient = useQueryClient()
+
+	return createMutation(() => ({
+		mutationFn: (params: SwapPositionsParams & { partyShortcode: string }) =>
+			gridAdapter.swapWeapons(params),
+		onSuccess: (_data, { partyShortcode }) => {
+			queryClient.invalidateQueries({ queryKey: partyKeys.detail(partyShortcode) })
+		}
+	}))
+}
+
 // ============================================================================
 // Character Mutations
 // ============================================================================
@@ -374,6 +392,23 @@ export function useResolveCharacterConflict() {
 	}))
 }
 
+/**
+ * Swap character positions mutation
+ *
+ * Swaps the positions of two characters in the grid.
+ */
+export function useSwapCharacters() {
+	const queryClient = useQueryClient()
+
+	return createMutation(() => ({
+		mutationFn: (params: SwapPositionsParams & { partyShortcode: string }) =>
+			gridAdapter.swapCharacters(params),
+		onSuccess: (_data, { partyShortcode }) => {
+			queryClient.invalidateQueries({ queryKey: partyKeys.detail(partyShortcode) })
+		}
+	}))
+}
+
 // ============================================================================
 // Summon Mutations
 // ============================================================================
@@ -566,3 +601,20 @@ export function useUpdateQuickSummon() {
 		}
 	}))
 }
+
+/**
+ * Swap summon positions mutation
+ *
+ * Swaps the positions of two summons in the grid.
+ */
+export function useSwapSummons() {
+	const queryClient = useQueryClient()
+
+	return createMutation(() => ({
+		mutationFn: (params: SwapPositionsParams & { partyShortcode: string }) =>
+			gridAdapter.swapSummons(params),
+		onSuccess: (_data, { partyShortcode }) => {
+			queryClient.invalidateQueries({ queryKey: partyKeys.detail(partyShortcode) })
+		}
+	}))
+}
diff --git a/src/lib/components/grids/CharacterGrid.svelte b/src/lib/components/grids/CharacterGrid.svelte
index c98b9de4..fee9db0a 100644
--- a/src/lib/components/grids/CharacterGrid.svelte
+++ b/src/lib/components/grids/CharacterGrid.svelte
@@ -4,7 +4,7 @@
 	import type { GridCharacter } from '$lib/types/api/party'
 	import type { Job } from '$lib/types/api/entities'
 	import { getContext } from 'svelte'
-	import type { PartyContext } from '$lib/services/party.service'
+	import type { PartyContext } from '$lib/types/party-context'
 	import type { DragDropContext } from '$lib/composables/drag-drop.svelte'
 	import DraggableItem from '$lib/components/dnd/DraggableItem.svelte'
 	import DropZone from '$lib/components/dnd/DropZone.svelte'
diff --git a/src/lib/components/grids/SummonGrid.svelte b/src/lib/components/grids/SummonGrid.svelte
index 3cfbb771..3ed8ffa6 100644
--- a/src/lib/components/grids/SummonGrid.svelte
+++ b/src/lib/components/grids/SummonGrid.svelte
@@ -3,7 +3,7 @@
 <script lang="ts">
 	import type { GridSummon } from '$lib/types/api/party'
 	import { getContext } from 'svelte'
-	import type { PartyContext } from '$lib/services/party.service'
+	import type { PartyContext } from '$lib/types/party-context'
 	import type { DragDropContext } from '$lib/composables/drag-drop.svelte'
 	import DraggableItem from '$lib/components/dnd/DraggableItem.svelte'
 	import DropZone from '$lib/components/dnd/DropZone.svelte'
diff --git a/src/lib/components/grids/WeaponGrid.svelte b/src/lib/components/grids/WeaponGrid.svelte
index 702fd11d..26c4fcb6 100644
--- a/src/lib/components/grids/WeaponGrid.svelte
+++ b/src/lib/components/grids/WeaponGrid.svelte
@@ -3,7 +3,7 @@
 <script lang="ts">
 	import type { GridWeapon } from '$lib/types/api/party'
 	import { getContext } from 'svelte'
-	import type { PartyContext } from '$lib/services/party.service'
+	import type { PartyContext } from '$lib/types/party-context'
 	import type { DragDropContext } from '$lib/composables/drag-drop.svelte'
 	import DraggableItem from '$lib/components/dnd/DraggableItem.svelte'
 	import DropZone from '$lib/components/dnd/DropZone.svelte'
diff --git a/src/lib/components/party/Party.svelte b/src/lib/components/party/Party.svelte
index c9b59216..0c72ea16 100644
--- a/src/lib/components/party/Party.svelte
+++ b/src/lib/components/party/Party.svelte
@@ -2,8 +2,11 @@
 	import { onMount, getContext, setContext } from 'svelte'
 	import type { Party, GridCharacter, GridWeapon, GridSummon } from '$lib/types/api/party'
 
-	// TanStack Query mutations
+	// TanStack Query mutations - Grid
 	import {
+		useCreateGridWeapon,
+		useCreateGridCharacter,
+		useCreateGridSummon,
 		useDeleteGridWeapon,
 		useDeleteGridCharacter,
 		useDeleteGridSummon,
@@ -12,13 +15,24 @@
 		useUpdateGridSummon,
 		useUpdateWeaponUncap,
 		useUpdateCharacterUncap,
-		useUpdateSummonUncap
+		useUpdateSummonUncap,
+		useSwapWeapons,
+		useSwapCharacters,
+		useSwapSummons
 	} from '$lib/api/mutations/grid.mutations'
 
-	// Legacy services - kept only for swap/move operations and edit keys
-	// TODO: Remove once swap/move mutations are implemented
-	import { PartyService } from '$lib/services/party.service'
-	import { GridService } from '$lib/services/grid.service'
+	// TanStack Query mutations - Party
+	import {
+		useUpdateParty,
+		useDeleteParty,
+		useRemixParty,
+		useFavoriteParty,
+		useUnfavoriteParty
+	} from '$lib/api/mutations/party.mutations'
+
+	// Utilities
+	import { getLocalId } from '$lib/utils/localId'
+	import { getEditKey, storeEditKey, computeEditability } from '$lib/utils/editKeys'
 
 	import { createDragDropContext, type DragOperation } from '$lib/composables/drag-drop.svelte'
 	import WeaponGrid from '$lib/components/grids/WeaponGrid.svelte'
@@ -42,7 +56,6 @@
 	import { extractErrorMessage } from '$lib/utils/errors'
 	import { transformSkillsToArray } from '$lib/utils/jobSkills'
 	import { findNextEmptySlot, SLOT_NOT_FOUND } from '$lib/utils/gridHelpers'
-	import { executeGridOperation } from '$lib/utils/gridOperations'
 
 	interface Props {
 		party?: Party
@@ -74,11 +87,10 @@
 	let editDialogOpen = $state(false)
 	let editingTitle = $state('')
 
-	// Legacy services - only for swap/move and edit keys
-	const partyService = new PartyService()
-	const gridService = new GridService()
-
-	// TanStack Query mutations
+	// TanStack Query mutations - Grid
+	const createWeapon = useCreateGridWeapon()
+	const createCharacter = useCreateGridCharacter()
+	const createSummon = useCreateGridSummon()
 	const deleteWeapon = useDeleteGridWeapon()
 	const deleteCharacter = useDeleteGridCharacter()
 	const deleteSummon = useDeleteGridSummon()
@@ -88,6 +100,16 @@
 	const updateWeaponUncap = useUpdateWeaponUncap()
 	const updateCharacterUncap = useUpdateCharacterUncap()
 	const updateSummonUncap = useUpdateSummonUncap()
+	const swapWeapons = useSwapWeapons()
+	const swapCharacters = useSwapCharacters()
+	const swapSummons = useSwapSummons()
+
+	// TanStack Query mutations - Party
+	const updatePartyMutation = useUpdateParty()
+	const deletePartyMutation = useDeleteParty()
+	const remixPartyMutation = useRemixParty()
+	const favoritePartyMutation = useFavoriteParty()
+	const unfavoritePartyMutation = useUnfavoriteParty()
 
 	// Create drag-drop context
 	const dragContext = createDragDropContext({
@@ -152,14 +174,23 @@
 			throw new Error('Cannot swap items in unsaved party')
 		}
 
-		return executeGridOperation(
-			'swap',
-			source,
-			target,
-			{ partyId: party.id, shortcode: party.shortcode, editKey },
-			gridService,
-			partyService
-		)
+		// Use appropriate swap mutation based on item type
+		const swapParams = {
+			partyId: party.id,
+			partyShortcode: party.shortcode,
+			sourceId: source.itemId,
+			targetId: target.itemId
+		}
+
+		if (source.type === 'weapon') {
+			await swapWeapons.mutateAsync(swapParams)
+		} else if (source.type === 'character') {
+			await swapCharacters.mutateAsync(swapParams)
+		} else if (source.type === 'summon') {
+			await swapSummons.mutateAsync(swapParams)
+		}
+
+		return party
 	}
 
 	async function handleMove(source: any, target: any): Promise<Party> {
@@ -167,14 +198,22 @@
 			throw new Error('Cannot move items in unsaved party')
 		}
 
-		return executeGridOperation(
-			'move',
-			source,
-			target,
-			{ partyId: party.id, shortcode: party.shortcode, editKey },
-			gridService,
-			partyService
-		)
+		// Move is swap with empty target - use update mutation to change position
+		const updateParams = {
+			id: source.itemId,
+			partyShortcode: party.shortcode,
+			updates: { position: target.position }
+		}
+
+		if (source.type === 'weapon') {
+			await updateWeapon.mutateAsync(updateParams)
+		} else if (source.type === 'character') {
+			await updateCharacter.mutateAsync(updateParams)
+		} else if (source.type === 'summon') {
+			await updateSummon.mutateAsync(updateParams)
+		}
+
+		return party
 	}
 
 	// Localized name helper: accepts either an object with { name: { en, ja } }
@@ -198,7 +237,7 @@
 		if (canEditServer) return true
 
 		// Re-compute on client with localStorage values
-		const result = partyService.computeEditability(party, authUserId, localId, editKey)
+		const result = computeEditability(party, authUserId, localId, editKey)
 		return result.canEdit
 	})
 
@@ -248,10 +287,10 @@
 		error = null
 
 		try {
-			// Use partyService for client-side updates
-			const updated = await partyService.update(party.id, updates, editKey || undefined)
-			party = updated
-			return updated
+			// Use TanStack Query mutation to update party
+			await updatePartyMutation.mutateAsync({ shortcode: party.shortcode, updates })
+			// Party will be updated via cache invalidation
+			return party
 		} catch (err: any) {
 			error = err.message || 'Failed to update party'
 			return null
@@ -268,10 +307,10 @@
 
 		try {
 			if (party.favorited) {
-				await partyService.unfavorite(party.id)
+				await unfavoritePartyMutation.mutateAsync({ shortcode: party.shortcode })
 				party.favorited = false
 			} else {
-				await partyService.favorite(party.id)
+				await favoritePartyMutation.mutateAsync({ shortcode: party.shortcode })
 				party.favorited = true
 			}
 		} catch (err: any) {
@@ -286,10 +325,15 @@
 		error = null
 
 		try {
-			const result = await partyService.remix(party.shortcode, localId, editKey || undefined)
+			const result = await remixPartyMutation.mutateAsync({
+				shortcode: party.shortcode,
+				localId,
+				editKey: editKey || undefined
+			})
 
 			// Store new edit key if returned
 			if (result.editKey) {
+				storeEditKey(result.party.shortcode, result.editKey)
 				editKey = result.editKey
 			}
 
@@ -322,8 +366,8 @@
 			deleting = true
 			error = null
 
-			// Delete the party - API expects the ID, not shortcode
-			await partyService.delete(party.id, editKey || undefined)
+			// Delete the party using mutation
+			await deletePartyMutation.mutateAsync({ shortcode: party.shortcode })
 
 			// Navigate to user's own profile page after deletion
 			if (party.user?.username) {
@@ -477,33 +521,33 @@
 			// Determine which slot to use
 			let targetSlot = selectedSlot
 
-			// Call appropriate grid service method based on current tab
+			// Call appropriate create mutation based on current tab
 			// Use granblueId (camelCase) as that's what the SearchResult type uses
 			const itemId = item.granblueId
 			if (activeTab === GridType.Weapon) {
-				await gridService.addWeapon(party.id, itemId, targetSlot, editKey || undefined, {
-					mainhand: targetSlot === -1,
-					shortcode: party.shortcode
+				await createWeapon.mutateAsync({
+					partyId: party.id,
+					weaponId: itemId,
+					position: targetSlot,
+					mainhand: targetSlot === -1
 				})
 			} else if (activeTab === GridType.Summon) {
-				await gridService.addSummon(party.id, itemId, targetSlot, editKey || undefined, {
+				await createSummon.mutateAsync({
+					partyId: party.id,
+					summonId: itemId,
+					position: targetSlot,
 					main: targetSlot === -1,
-					friend: targetSlot === 6,
-					shortcode: party.shortcode
+					friend: targetSlot === 6
 				})
 			} else if (activeTab === GridType.Character) {
-				await gridService.addCharacter(party.id, itemId, targetSlot, editKey || undefined, {
-					shortcode: party.shortcode
+				await createCharacter.mutateAsync({
+					partyId: party.id,
+					characterId: itemId,
+					position: targetSlot
 				})
 			}
 
-			// Clear cache before refreshing to ensure fresh data
-			partyService.clearPartyCache(party.shortcode)
-
-			// Refresh party data
-			const updated = await partyService.getByShortcode(party.shortcode)
-			party = updated
-
+			// Party will be updated via cache invalidation from the mutation
 			// Find next empty slot for continuous adding
 			const nextEmptySlot = findNextEmptySlot(party, activeTab)
 			if (nextEmptySlot !== SLOT_NOT_FOUND) {
@@ -520,10 +564,10 @@
 	// Client-side initialization
 	onMount(() => {
 		// Get or create local ID
-		localId = partyService.getLocalId()
+		localId = getLocalId()
 
 		// Get edit key for this party if it exists
-			editKey = partyService.getEditKey(party.shortcode) ?? undefined
+		editKey = getEditKey(party.shortcode) ?? undefined
 
 		// No longer need to verify party data integrity after hydration
 		// since $state.raw prevents the hydration mismatch
@@ -681,7 +725,6 @@
 		canEdit: () => canEdit(),
 		getEditKey: () => editKey,
 		services: {
-			partyService,
 			gridService: clientGridService // Uses TanStack Query mutations
 		},
 		openPicker: (opts: {
diff --git a/src/lib/services/conflict.service.ts b/src/lib/services/conflict.service.ts
deleted file mode 100644
index 9fa79263..00000000
--- a/src/lib/services/conflict.service.ts
+++ /dev/null
@@ -1,168 +0,0 @@
-import type { Party, GridWeapon, GridCharacter } from '$lib/types/api/party'
-import { gridAdapter } from '$lib/api/adapters/grid.adapter'
-
-export interface ConflictData {
-  conflicts: string[]
-  incoming: string
-  position: number
-}
-
-export interface ConflictResolution {
-  action: 'replace' | 'cancel'
-  removeIds: string[]
-  addId: string
-  position: number
-}
-
-/**
- * Conflict service - handles conflict resolution for weapons and characters
- */
-export class ConflictService {
-  constructor() {}
-
-  /**
-   * Resolve a conflict by choosing which items to keep
-   */
-  async resolveConflict(
-    partyId: string,
-    conflictType: 'weapon' | 'character',
-    resolution: ConflictResolution,
-    editKey?: string
-  ): Promise<Party> {
-    if (conflictType === 'weapon') {
-      return this.resolveWeaponConflict(partyId, resolution)
-    } else {
-      return this.resolveCharacterConflict(partyId, resolution)
-    }
-  }
-
-  /**
-   * Check if adding an item would cause conflicts
-   */
-  checkConflicts(
-    party: Party,
-    itemType: 'weapon' | 'character',
-    itemId: string
-  ): ConflictData | null {
-    if (itemType === 'weapon') {
-      return this.checkWeaponConflicts(party, itemId)
-    } else {
-      return this.checkCharacterConflicts(party, itemId)
-    }
-  }
-
-  /**
-   * Format conflict message for display
-   */
-  formatConflictMessage(
-    conflictType: 'weapon' | 'character',
-    conflictingItems: Array<{ name: string; position: number }>,
-    incomingItem: { name: string }
-  ): string {
-    const itemTypeLabel = conflictType === 'weapon' ? 'weapon' : 'character'
-    const conflictNames = conflictingItems.map(i => i.name).join(', ')
-
-    if (conflictingItems.length === 1) {
-      return `Adding ${incomingItem.name} would conflict with ${conflictNames}. Which ${itemTypeLabel} would you like to keep?`
-    }
-
-    return `Adding ${incomingItem.name} would conflict with: ${conflictNames}. Which ${itemTypeLabel}s would you like to keep?`
-  }
-
-  // Private methods
-
-  private async resolveWeaponConflict(
-    partyId: string,
-    resolution: ConflictResolution
-  ): Promise<Party> {
-    // Use GridAdapter's conflict resolution
-    const result = await gridAdapter.resolveWeaponConflict({
-      partyId,
-      incomingId: resolution.addId,
-      position: resolution.position,
-      conflictingIds: resolution.removeIds
-    })
-
-    // The adapter returns the weapon, but we need to return the full party
-    // This is a limitation - we should fetch the updated party
-    // For now, return a partial party object
-    return {
-      weapons: [result]
-    } as Party
-  }
-
-  private async resolveCharacterConflict(
-    partyId: string,
-    resolution: ConflictResolution
-  ): Promise<Party> {
-    // Use GridAdapter's conflict resolution
-    const result = await gridAdapter.resolveCharacterConflict({
-      partyId,
-      incomingId: resolution.addId,
-      position: resolution.position,
-      conflictingIds: resolution.removeIds
-    })
-
-    // The adapter returns the character, but we need to return the full party
-    // This is a limitation - we should fetch the updated party
-    return {
-      characters: [result]
-    } as Party
-  }
-
-  private checkWeaponConflicts(party: Party, weaponId: string): ConflictData | null {
-    // Check for duplicate weapons (simplified - actual logic would be more complex)
-    const existingWeapon = party.weapons.find(w => w.weapon.id === weaponId)
-
-    if (existingWeapon) {
-      return {
-        conflicts: [existingWeapon.id],
-        incoming: weaponId,
-        position: existingWeapon.position
-      }
-    }
-
-    // Could check for other conflict types here (e.g., same series weapons)
-
-    return null
-  }
-
-  private checkCharacterConflicts(party: Party, characterId: string): ConflictData | null {
-    // Check for duplicate characters
-    const existingCharacter = party.characters.find(c => c.character.id === characterId)
-
-    if (existingCharacter) {
-      return {
-        conflicts: [existingCharacter.id],
-        incoming: characterId,
-        position: existingCharacter.position
-      }
-    }
-
-    // Check for conflicts with other versions of the same character
-    // This would need character metadata to determine conflicts
-
-    return null
-  }
-
-  /**
-   * Get conflict constraints for a specific type
-   */
-  getConflictConstraints(itemType: 'weapon' | 'character'): {
-    allowDuplicates: boolean
-    maxPerType?: number
-    checkVariants: boolean
-  } {
-    if (itemType === 'weapon') {
-      return {
-        allowDuplicates: false,
-        checkVariants: true // Check for same series weapons
-      }
-    }
-
-    return {
-      allowDuplicates: false,
-      checkVariants: true // Check for different versions of same character
-    }
-  }
-}
\ No newline at end of file
diff --git a/src/lib/services/grid.service.ts b/src/lib/services/grid.service.ts
deleted file mode 100644
index 5e662e11..00000000
--- a/src/lib/services/grid.service.ts
+++ /dev/null
@@ -1,600 +0,0 @@
-import type { Party, GridWeapon, GridSummon, GridCharacter } from '$lib/types/api/party'
-import { gridAdapter } from '$lib/api/adapters/grid.adapter'
-import { partyAdapter } from '$lib/api/adapters/party.adapter'
-
-export type GridItemData = GridWeapon | GridSummon | GridCharacter
-
-export interface GridOperation {
-  type: 'add' | 'replace' | 'remove' | 'move' | 'swap'
-  itemId?: string
-  position?: number
-  targetPosition?: number | string  // Can be position number or gridId string for swaps
-  uncapLevel?: number
-  transcendenceLevel?: number
-  data?: GridItemData
-}
-
-export interface GridUpdateResult {
-  party: Party
-  conflicts?: {
-    conflicts: string[]
-    incoming: string
-    position: number
-  }
-}
-
-/**
- * Grid service - handles grid operations for weapons, summons, and characters
- */
-export class GridService {
-  constructor() {}
-
-  // Weapon Grid Operations
-
-  async addWeapon(
-    partyId: string,
-    weaponId: string,
-    position: number,
-    editKey?: string,
-    options?: { mainhand?: boolean; shortcode?: string }
-  ): Promise<GridUpdateResult> {
-    try {
-      // Note: The backend computes the correct uncap level based on the weapon's FLB/ULB/transcendence flags
-      const gridWeapon = await gridAdapter.createWeapon({
-        partyId,
-        weaponId,
-        position,
-        mainhand: options?.mainhand,
-        transcendenceStep: 0
-      }, this.buildHeaders(editKey))
-
-      console.log('[GridService] Created grid weapon:', gridWeapon)
-
-      // Clear party cache if shortcode provided
-      if (options?.shortcode) {
-        partyAdapter.clearPartyCache(options.shortcode)
-      }
-
-      // Return success without fetching party - the caller should refresh if needed
-      // partyId is a UUID, not a shortcode, so we can't fetch here
-      return { party: null as any }
-    } catch (error: any) {
-      console.error('[GridService] Error creating weapon:', error)
-      if (error.type === 'conflict') {
-        return {
-          party: null as any, // Will be handled by conflict resolution
-          conflicts: error
-        }
-      }
-      throw error
-    }
-  }
-
-  async replaceWeapon(
-    partyId: string,
-    gridWeaponId: string,
-    newWeaponId: string,
-    editKey?: string,
-    options?: { shortcode?: string }
-  ): Promise<GridUpdateResult> {
-    try {
-      // First remove the old weapon
-      await gridAdapter.deleteWeapon({ id: gridWeaponId, partyId }, this.buildHeaders(editKey))
-
-      // Then add the new one (pass shortcode along)
-      const result = await this.addWeapon(partyId, newWeaponId, 0, editKey, options)
-      return result
-    } catch (error: any) {
-      if (error.type === 'conflict') {
-        return {
-          party: null as any,
-          conflicts: error
-        }
-      }
-      throw error
-    }
-  }
-
-  async removeWeapon(
-    partyId: string,
-    gridWeaponId: string,
-    editKey?: string,
-    options?: { shortcode?: string }
-  ): Promise<Party | null> {
-    await gridAdapter.deleteWeapon({ id: gridWeaponId, partyId }, this.buildHeaders(editKey))
-
-    // Clear party cache if shortcode provided
-    if (options?.shortcode) {
-      partyAdapter.clearPartyCache(options.shortcode)
-    }
-
-    // Don't fetch - let caller handle refresh
-    return null
-  }
-
-  async updateWeapon(
-    partyId: string,
-    gridWeaponId: string,
-    updates: {
-      position?: number
-      uncapLevel?: number
-      transcendenceStep?: number
-      element?: number
-    },
-    editKey?: string,
-    options?: { shortcode?: string }
-  ): Promise<Party | null> {
-    await gridAdapter.updateWeapon(gridWeaponId, {
-      position: updates.position,
-      uncapLevel: updates.uncapLevel,
-      transcendenceStep: updates.transcendenceStep,
-      element: updates.element
-    }, this.buildHeaders(editKey))
-
-    // Clear party cache if shortcode provided
-    if (options?.shortcode) {
-      partyAdapter.clearPartyCache(options.shortcode)
-    }
-
-    // Don't fetch - let caller handle refresh
-    return null
-  }
-
-  async moveWeapon(
-    partyId: string,
-    gridWeaponId: string,
-    newPosition: number,
-    editKey?: string,
-    options?: { shortcode?: string }
-  ): Promise<Party | null> {
-    await gridAdapter.updateWeaponPosition({
-      partyId,
-      id: gridWeaponId,
-      position: newPosition
-    }, this.buildHeaders(editKey))
-
-    // Clear party cache if shortcode provided
-    if (options?.shortcode) {
-      partyAdapter.clearPartyCache(options.shortcode)
-    }
-
-    // Don't fetch - let caller handle refresh
-    return null
-  }
-
-  async swapWeapons(
-    partyId: string,
-    gridWeaponId1: string,
-    gridWeaponId2: string,
-    editKey?: string,
-    options?: { shortcode?: string }
-  ): Promise<Party | null> {
-    await gridAdapter.swapWeapons({
-      partyId,
-      sourceId: gridWeaponId1,
-      targetId: gridWeaponId2
-    }, this.buildHeaders(editKey))
-
-    // Clear party cache if shortcode provided
-    if (options?.shortcode) {
-      partyAdapter.clearPartyCache(options.shortcode)
-    }
-
-    // Don't fetch - let caller handle refresh
-    return null
-  }
-
-  async updateWeaponUncap(
-    partyId: string,
-    gridWeaponId: string,
-    uncapLevel?: number,
-    transcendenceStep?: number,
-    editKey?: string
-  ): Promise<any> {
-    return gridAdapter.updateWeaponUncap({
-      id: gridWeaponId,
-      partyId,
-      uncapLevel: uncapLevel ?? 3,
-      transcendenceStep
-    }, this.buildHeaders(editKey))
-  }
-
-  // Summon Grid Operations
-
-  async addSummon(
-    partyId: string,
-    summonId: string,
-    position: number,
-    editKey?: string,
-    options?: { main?: boolean; friend?: boolean; shortcode?: string }
-  ): Promise<Party> {
-    // Note: The backend computes the correct uncap level based on the summon's FLB/ULB/transcendence flags
-    const gridSummon = await gridAdapter.createSummon({
-      partyId,
-      summonId,
-      position,
-      main: options?.main,
-      friend: options?.friend,
-      transcendenceStep: 0
-    }, this.buildHeaders(editKey))
-
-    console.log('[GridService] Created grid summon:', gridSummon)
-
-    // Clear party cache if shortcode provided
-    if (options?.shortcode) {
-      partyAdapter.clearPartyCache(options.shortcode)
-    }
-
-    // Don't fetch - partyId is UUID not shortcode
-    return null as any
-  }
-
-  async replaceSummon(
-    partyId: string,
-    gridSummonId: string,
-    newSummonId: string,
-    editKey?: string,
-    options?: { shortcode?: string }
-  ): Promise<Party> {
-    // First remove the old summon
-    await gridAdapter.deleteSummon({ id: gridSummonId, partyId }, this.buildHeaders(editKey))
-
-    // Then add the new one (pass shortcode along)
-    return this.addSummon(partyId, newSummonId, 0, editKey, { ...options })
-  }
-
-  async removeSummon(
-    partyId: string,
-    gridSummonId: string,
-    editKey?: string,
-    options?: { shortcode?: string }
-  ): Promise<Party | null> {
-    await gridAdapter.deleteSummon({ id: gridSummonId, partyId }, this.buildHeaders(editKey))
-
-    // Clear party cache if shortcode provided
-    if (options?.shortcode) {
-      partyAdapter.clearPartyCache(options.shortcode)
-    }
-
-    // Don't fetch - let caller handle refresh
-    return null
-  }
-
-  async updateSummon(
-    partyId: string,
-    gridSummonId: string,
-    updates: {
-      position?: number
-      quickSummon?: boolean
-      uncapLevel?: number
-      transcendenceStep?: number
-    },
-    editKey?: string,
-    options?: { shortcode?: string }
-  ): Promise<Party | null> {
-    await gridAdapter.updateSummon(gridSummonId, {
-      position: updates.position,
-      quickSummon: updates.quickSummon,
-      uncapLevel: updates.uncapLevel,
-      transcendenceStep: updates.transcendenceStep
-    }, this.buildHeaders(editKey))
-
-    // Clear party cache if shortcode provided
-    if (options?.shortcode) {
-      partyAdapter.clearPartyCache(options.shortcode)
-    }
-
-    // Don't fetch - let caller handle refresh
-    return null
-  }
-
-  async moveSummon(
-    partyId: string,
-    gridSummonId: string,
-    newPosition: number,
-    editKey?: string,
-    options?: { shortcode?: string }
-  ): Promise<Party | null> {
-    await gridAdapter.updateSummonPosition({
-      partyId,
-      id: gridSummonId,
-      position: newPosition
-    }, this.buildHeaders(editKey))
-
-    // Clear party cache if shortcode provided
-    if (options?.shortcode) {
-      partyAdapter.clearPartyCache(options.shortcode)
-    }
-
-    // Don't fetch - let caller handle refresh
-    return null
-  }
-
-  async swapSummons(
-    partyId: string,
-    gridSummonId1: string,
-    gridSummonId2: string,
-    editKey?: string,
-    options?: { shortcode?: string }
-  ): Promise<Party | null> {
-    await gridAdapter.swapSummons({
-      partyId,
-      sourceId: gridSummonId1,
-      targetId: gridSummonId2
-    }, this.buildHeaders(editKey))
-
-    // Clear party cache if shortcode provided
-    if (options?.shortcode) {
-      partyAdapter.clearPartyCache(options.shortcode)
-    }
-
-    // Don't fetch - let caller handle refresh
-    return null
-  }
-
-  async updateSummonUncap(
-    partyId: string,
-    gridSummonId: string,
-    uncapLevel?: number,
-    transcendenceStep?: number,
-    editKey?: string
-  ): Promise<any> {
-    return gridAdapter.updateSummonUncap({
-      id: gridSummonId,
-      partyId,
-      uncapLevel: uncapLevel ?? 3,
-      transcendenceStep
-    }, this.buildHeaders(editKey))
-  }
-
-  // Character Grid Operations
-
-  async addCharacter(
-    partyId: string,
-    characterId: string,
-    position: number,
-    editKey?: string,
-    options?: { shortcode?: string }
-  ): Promise<GridUpdateResult> {
-    try {
-      // Note: The backend computes the correct uncap level based on the character's special/FLB/ULB flags
-      const gridCharacter = await gridAdapter.createCharacter({
-        partyId,
-        characterId,
-        position,
-        transcendenceStep: 0
-      }, this.buildHeaders(editKey))
-
-      console.log('[GridService] Created grid character:', gridCharacter)
-
-      // Clear party cache if shortcode provided
-      if (options?.shortcode) {
-        partyAdapter.clearPartyCache(options.shortcode)
-      }
-
-      // Don't fetch - partyId is UUID not shortcode
-      return { party: null as any }
-    } catch (error: any) {
-      if (error.type === 'conflict') {
-        return {
-          party: null as any,
-          conflicts: error
-        }
-      }
-      throw error
-    }
-  }
-
-  async replaceCharacter(
-    partyId: string,
-    gridCharacterId: string,
-    newCharacterId: string,
-    editKey?: string,
-    options?: { shortcode?: string }
-  ): Promise<GridUpdateResult> {
-    try {
-      // First remove the old character
-      await gridAdapter.deleteCharacter({ id: gridCharacterId, partyId }, this.buildHeaders(editKey))
-
-      // Then add the new one (pass shortcode along)
-      return this.addCharacter(partyId, newCharacterId, 0, editKey, options)
-    } catch (error: any) {
-      if (error.type === 'conflict') {
-        return {
-          party: null as any,
-          conflicts: error
-        }
-      }
-      throw error
-    }
-  }
-
-  async removeCharacter(
-    partyId: string,
-    gridCharacterId: string,
-    editKey?: string,
-    options?: { shortcode?: string }
-  ): Promise<Party | null> {
-    await gridAdapter.deleteCharacter({ id: gridCharacterId, partyId }, this.buildHeaders(editKey))
-
-    // Clear party cache if shortcode provided
-    if (options?.shortcode) {
-      partyAdapter.clearPartyCache(options.shortcode)
-    }
-
-    // Don't fetch - let caller handle refresh
-    return null
-  }
-
-  async updateCharacter(
-    partyId: string,
-    gridCharacterId: string,
-    updates: {
-      position?: number
-      uncapLevel?: number
-      transcendenceStep?: number
-      perpetuity?: boolean
-    },
-    editKey?: string,
-    options?: { shortcode?: string }
-  ): Promise<GridCharacter | null> {
-    const updated = await gridAdapter.updateCharacter(gridCharacterId, {
-      position: updates.position,
-      uncapLevel: updates.uncapLevel,
-      transcendenceStep: updates.transcendenceStep,
-      perpetuity: updates.perpetuity
-    }, this.buildHeaders(editKey))
-
-    // Clear party cache if shortcode provided
-    if (options?.shortcode) {
-      partyAdapter.clearPartyCache(options.shortcode)
-    }
-
-    // Return the updated character
-    return updated
-  }
-
-  async moveCharacter(
-    partyId: string,
-    gridCharacterId: string,
-    newPosition: number,
-    editKey?: string,
-    options?: { shortcode?: string }
-  ): Promise<Party | null> {
-    await gridAdapter.updateCharacterPosition({
-      partyId,
-      id: gridCharacterId,
-      position: newPosition
-    }, this.buildHeaders(editKey))
-
-    // Clear party cache if shortcode provided
-    if (options?.shortcode) {
-      partyAdapter.clearPartyCache(options.shortcode)
-    }
-
-    // Don't fetch - let caller handle refresh
-    return null
-  }
-
-  async swapCharacters(
-    partyId: string,
-    gridCharacterId1: string,
-    gridCharacterId2: string,
-    editKey?: string,
-    options?: { shortcode?: string }
-  ): Promise<Party | null> {
-    await gridAdapter.swapCharacters({
-      partyId,
-      sourceId: gridCharacterId1,
-      targetId: gridCharacterId2
-    }, this.buildHeaders(editKey))
-
-    // Clear party cache if shortcode provided
-    if (options?.shortcode) {
-      partyAdapter.clearPartyCache(options.shortcode)
-    }
-
-    // Don't fetch - let caller handle refresh
-    return null
-  }
-
-  async updateCharacterUncap(
-    partyId: string,
-    gridCharacterId: string,
-    uncapLevel?: number,
-    transcendenceStep?: number,
-    editKey?: string
-  ): Promise<any> {
-    return gridAdapter.updateCharacterUncap({
-      id: gridCharacterId,
-      partyId,
-      uncapLevel: uncapLevel ?? 3,
-      transcendenceStep
-    }, this.buildHeaders(editKey))
-  }
-
-  // Drag and Drop Helpers
-
-  /**
-   * Normalize drag and drop intent to a grid operation
-   */
-  normalizeDragIntent(
-    dragType: 'weapon' | 'summon' | 'character',
-    draggedItem: { id: string; gridId?: string },
-    targetPosition: number,
-    targetItem?: { id: string; gridId?: string }
-  ): GridOperation {
-    // If dropping on an empty slot
-    if (!targetItem) {
-      return {
-        type: 'add',
-        itemId: draggedItem.id,
-        position: targetPosition
-      }
-    }
-
-    // If dragging from grid to grid
-    if (draggedItem.gridId && targetItem.gridId) {
-      return {
-        type: 'swap',
-        itemId: draggedItem.gridId,
-        targetPosition: targetItem.gridId
-      }
-    }
-
-    // If dragging from outside to occupied slot
-    return {
-      type: 'replace',
-      itemId: targetItem.gridId,
-      targetPosition: draggedItem.id
-    }
-  }
-
-  /**
-   * Apply optimistic update to local state
-   */
-  applyOptimisticUpdate<T extends GridWeapon | GridSummon | GridCharacter>(
-    items: T[],
-    operation: GridOperation
-  ): T[] {
-    const updated = [...items]
-
-    switch (operation.type) {
-      case 'add':
-        // Add new item at position
-        break
-
-      case 'remove':
-        return updated.filter(item => item.id !== operation.itemId)
-
-      case 'move':
-        const item = updated.find(i => i.id === operation.itemId)
-        if (item && operation.targetPosition !== undefined && typeof operation.targetPosition === 'number') {
-          item.position = operation.targetPosition
-        }
-        break
-
-      case 'swap':
-        const item1 = updated.find(i => i.id === operation.itemId)
-        const item2 = updated.find(i => i.position === operation.targetPosition)
-        if (item1 && item2) {
-          const tempPos = item1.position
-          item1.position = item2.position
-          item2.position = tempPos
-        }
-        break
-    }
-
-    return updated
-  }
-
-  // Private helpers
-
-  private buildHeaders(editKey?: string): Record<string, string> {
-    const headers: Record<string, string> = {}
-    if (editKey) {
-      headers['X-Edit-Key'] = editKey
-    }
-    return headers
-  }
-}
diff --git a/src/lib/services/party.service.ts b/src/lib/services/party.service.ts
deleted file mode 100644
index ba362ccf..00000000
--- a/src/lib/services/party.service.ts
+++ /dev/null
@@ -1,303 +0,0 @@
-import type { Party } from '$lib/types/api/party'
-import { partyAdapter, type CreatePartyParams } from '$lib/api/adapters/party.adapter'
-import { authStore } from '$lib/stores/auth.store'
-import { browser } from '$app/environment'
-
-/**
- * Context type for party-related operations in components
- */
-export interface PartyContext {
-  getParty: () => Party
-  updateParty: (p: Party) => void
-  canEdit: () => boolean
-  getEditKey: () => string | null
-  services: { gridService: any; partyService: any }
-  openPicker?: (opts: { type: 'weapon' | 'summon' | 'character'; position: number; item?: any }) => void
-}
-
-export interface EditabilityResult {
-  canEdit: boolean
-  headers?: Record<string, string>
-  reason?: string
-}
-
-export interface PartyUpdatePayload {
-  name?: string | null
-  description?: string | null
-  element?: number
-  raidId?: string
-  chargeAttack?: boolean
-  fullAuto?: boolean
-  autoGuard?: boolean
-  autoSummon?: boolean
-  clearTime?: number | null
-  buttonCount?: number | null
-  chainCount?: number | null
-  turnCount?: number | null
-  jobId?: string
-  visibility?: import('$lib/types/visibility').PartyVisibility
-  localId?: string
-}
-
-/**
- * Party service - handles business logic for party operations
- */
-export class PartyService {
-  constructor() {}
-  
-  /**
-   * Get party by shortcode
-   */
-  async getByShortcode(shortcode: string): Promise<Party> {
-    return partyAdapter.getByShortcode(shortcode)
-  }
-
-  /**
-   * Clear party cache for a specific shortcode
-   */
-  clearPartyCache(shortcode: string): void {
-    partyAdapter.clearPartyCache(shortcode)
-  }
-  
-  /**
-   * Create a new party
-   */
-  async create(payload: PartyUpdatePayload, editKey?: string): Promise<{
-    party: Party
-    editKey?: string
-  }> {
-    const apiPayload = this.mapToApiPayload(payload)
-    const party = await partyAdapter.create(apiPayload)
-
-    // Note: Edit key handling may need to be adjusted based on how the API returns it
-    return { party }
-  }
-
-  /**
-   * Update party details
-   */
-  async update(id: string, payload: PartyUpdatePayload, editKey?: string): Promise<Party> {
-    const apiPayload = this.mapToApiPayload(payload)
-    return partyAdapter.update({ shortcode: id, ...apiPayload })
-  }
-  
-  /**
-   * Update party guidebooks
-   */
-  async updateGuidebooks(
-    id: string,
-    position: number,
-    guidebookId: string | null,
-    editKey?: string
-  ): Promise<Party> {
-    const payload: any = {}
-
-    // Map position to guidebook1_id, guidebook2_id, guidebook3_id
-    if (position >= 0 && position <= 2) {
-      payload[`guidebook${position + 1}Id`] = guidebookId
-    }
-
-    return partyAdapter.update({ shortcode: id, ...payload })
-  }
-
-  /**
-   * Remix a party (create a copy)
-   */
-  async remix(shortcode: string, localId?: string, editKey?: string): Promise<{
-    party: Party
-    editKey?: string
-  }> {
-    const party = await partyAdapter.remix(shortcode)
-
-    // Note: Edit key handling may need to be adjusted
-    return { party }
-  }
-  
-  /**
-   * Favorite a party
-   */
-  async favorite(id: string): Promise<void> {
-    return partyAdapter.favorite(id)
-  }
-
-  /**
-   * Unfavorite a party
-   */
-  async unfavorite(id: string): Promise<void> {
-    return partyAdapter.unfavorite(id)
-  }
-  
-  /**
-   * Delete a party
-   */
-  async delete(id: string, editKey?: string): Promise<void> {
-    // The API expects the party ID, not shortcode, for delete
-    // We need to make a direct request with the ID
-    const headers = this.buildHeaders(editKey)
-
-    // Get auth token from authStore
-    const authHeaders: Record<string, string> = {}
-    if (browser) {
-      const token = await authStore.checkAndRefresh()
-      if (token) {
-        authHeaders['Authorization'] = `Bearer ${token}`
-      }
-    }
-
-    const finalHeaders = {
-      'Content-Type': 'application/json',
-      ...authHeaders,
-      ...headers
-    }
-
-    const url = `${import.meta.env.VITE_API_BASE_URL || 'http://localhost:3000/api/v1'}/parties/${id}`
-
-    console.log('[PartyService] DELETE Request Details:', {
-      url,
-      method: 'DELETE',
-      headers: finalHeaders,
-      credentials: 'include',
-      partyId: id,
-      hasEditKey: !!editKey,
-      hasAuthToken: !!authHeaders['Authorization']
-    })
-
-    // Make direct API call since adapter expects shortcode but API needs ID
-    const response = await fetch(url, {
-      method: 'DELETE',
-      credentials: 'include',
-      headers: finalHeaders
-    })
-
-    console.log('[PartyService] DELETE Response:', {
-      status: response.status,
-      statusText: response.statusText,
-      ok: response.ok,
-      headers: Object.fromEntries(response.headers.entries())
-    })
-
-    if (!response.ok) {
-      // Try to parse error body for more details
-      let errorBody = null
-      try {
-        const contentType = response.headers.get('content-type')
-        if (contentType && contentType.includes('application/json')) {
-          errorBody = await response.json()
-        } else {
-          errorBody = await response.text()
-        }
-      } catch (e) {
-        console.error('[PartyService] Could not parse error response body:', e)
-      }
-
-      console.error('[PartyService] DELETE Failed:', {
-        status: response.status,
-        statusText: response.statusText,
-        errorBody,
-        url,
-        partyId: id
-      })
-
-      throw new Error(`Failed to delete party: ${response.status} ${response.statusText}${errorBody ? ` - ${JSON.stringify(errorBody)}` : ''}`)
-    }
-
-    console.log('[PartyService] DELETE Success - Party deleted:', id)
-  }
-  
-  /**
-   * Compute editability for a party
-   */
-  computeEditability(
-    party: Party,
-    authUserId?: string,
-    localId?: string,
-    editKey?: string
-  ): EditabilityResult {
-    // Owner can always edit
-    if (authUserId && party.user?.id === authUserId) {
-      return { canEdit: true, reason: 'owner' }
-    }
-    
-    // Local owner can edit if no server user
-    const isLocalOwner = localId && party.localId === localId
-    const hasNoServerUser = !party.user?.id
-    
-    if (isLocalOwner && hasNoServerUser) {
-      const base = { canEdit: true, reason: 'local_owner' as const }
-      return editKey ? { ...base, headers: { 'X-Edit-Key': editKey } } : base
-    }
-    
-    // Check for edit key permission
-    if (editKey && typeof window !== 'undefined') {
-      const storedKey = localStorage.getItem(`edit_key_${party.shortcode}`)
-      if (storedKey === editKey) {
-        return { canEdit: true, headers: { 'X-Edit-Key': editKey }, reason: 'edit_key' }
-      }
-    }
-    
-    return { canEdit: false, reason: 'no_permission' }
-  }
-  
-  /**
-   * Get or create local ID for anonymous users
-   */
-  getLocalId(): string {
-    if (typeof window === 'undefined') return ''
-    
-    let localId = localStorage.getItem('local_id')
-    if (!localId) {
-      localId = crypto.randomUUID()
-      localStorage.setItem('local_id', localId)
-    }
-    return localId
-  }
-  
-  /**
-   * Get edit key for a party
-   */
-  getEditKey(shortcode: string): string | null {
-    if (typeof window === 'undefined') return null
-    return localStorage.getItem(`edit_key_${shortcode}`)
-  }
-  
-  /**
-   * Store edit key for a party
-   */
-  storeEditKey(shortcode: string, editKey: string): void {
-    if (typeof window !== 'undefined') {
-      localStorage.setItem(`edit_key_${shortcode}`, editKey)
-    }
-  }
-  
-  // Private helpers
-  
-  private buildHeaders(editKey?: string): Record<string, string> {
-    const headers: Record<string, string> = {}
-    if (editKey) {
-      headers['X-Edit-Key'] = editKey
-    }
-    return headers
-  }
-  
-  private mapToApiPayload(payload: PartyUpdatePayload): CreatePartyParams {
-    const mapped: any = {}
-
-    if (payload.name !== undefined) mapped.name = payload.name
-    if (payload.description !== undefined) mapped.description = payload.description
-    if (payload.element !== undefined) mapped.element = payload.element
-    if (payload.raidId !== undefined) mapped.raidId = payload.raidId
-    if (payload.chargeAttack !== undefined) mapped.chargeAttack = payload.chargeAttack
-    if (payload.fullAuto !== undefined) mapped.fullAuto = payload.fullAuto
-    if (payload.autoGuard !== undefined) mapped.autoGuard = payload.autoGuard
-    if (payload.autoSummon !== undefined) mapped.autoSummon = payload.autoSummon
-    if (payload.clearTime !== undefined) mapped.clearTime = payload.clearTime
-    if (payload.buttonCount !== undefined) mapped.buttonCount = payload.buttonCount
-    if (payload.chainCount !== undefined) mapped.chainCount = payload.chainCount
-    if (payload.turnCount !== undefined) mapped.turnCount = payload.turnCount
-    if (payload.jobId !== undefined) mapped.jobId = payload.jobId
-    if (payload.visibility !== undefined) mapped.visibility = payload.visibility
-    if (payload.localId !== undefined) mapped.localId = payload.localId
-
-    return mapped
-  }
-}
diff --git a/src/lib/types/party-context.ts b/src/lib/types/party-context.ts
new file mode 100644
index 00000000..ebc14df2
--- /dev/null
+++ b/src/lib/types/party-context.ts
@@ -0,0 +1,19 @@
+/**
+ * Party context types
+ * Used for providing party data and operations to child components
+ */
+
+import type { Party } from '$lib/types/api/party'
+
+export interface PartyContext {
+	getParty: () => Party
+	updateParty: (p: Party) => void
+	canEdit: () => boolean
+	getEditKey: () => string | undefined
+	services: { gridService: any }
+	openPicker?: (opts: {
+		type: 'weapon' | 'summon' | 'character'
+		position: number
+		item?: any
+	}) => void
+}
diff --git a/src/lib/utils/editKeys.ts b/src/lib/utils/editKeys.ts
new file mode 100644
index 00000000..e51022ef
--- /dev/null
+++ b/src/lib/utils/editKeys.ts
@@ -0,0 +1,60 @@
+/**
+ * Edit key management utilities
+ * Handles edit keys for anonymous party editing
+ */
+
+import type { Party } from '$lib/types/api/party'
+
+const EDIT_KEY_PREFIX = 'party_edit_key_'
+
+/**
+ * Get edit key for a party from localStorage
+ */
+export function getEditKey(shortcode: string): string | null {
+	if (typeof window === 'undefined') return null
+	return localStorage.getItem(`${EDIT_KEY_PREFIX}${shortcode}`)
+}
+
+/**
+ * Store edit key for a party in localStorage
+ */
+export function storeEditKey(shortcode: string, editKey: string): void {
+	if (typeof window === 'undefined') return
+	localStorage.setItem(`${EDIT_KEY_PREFIX}${shortcode}`, editKey)
+}
+
+/**
+ * Remove edit key for a party from localStorage
+ */
+export function removeEditKey(shortcode: string): void {
+	if (typeof window === 'undefined') return
+	localStorage.removeItem(`${EDIT_KEY_PREFIX}${shortcode}`)
+}
+
+/**
+ * Compute editability of a party based on ownership and edit keys
+ */
+export function computeEditability(
+	party: Party,
+	authUserId?: string,
+	localId?: string,
+	editKey?: string
+): { canEdit: boolean; reason?: string } {
+	// User is authenticated and owns the party
+	if (authUserId && party.user?.id === authUserId) {
+		return { canEdit: true }
+	}
+
+	// Anonymous user with matching local ID
+	if (!authUserId && localId && party.localId === localId) {
+		return { canEdit: true }
+	}
+
+	// Has valid edit key
+	if (editKey && party.editKey === editKey) {
+		return { canEdit: true }
+	}
+
+	// No edit permission
+	return { canEdit: false, reason: 'Not authorized to edit this party' }
+}
diff --git a/src/lib/utils/gridOperations.ts b/src/lib/utils/gridOperations.ts
deleted file mode 100644
index 8946e4c9..00000000
--- a/src/lib/utils/gridOperations.ts
+++ /dev/null
@@ -1,207 +0,0 @@
-/**
- * Grid operation utilities
- * Consolidates duplicated grid CRUD logic
- */
-
-import type { Party } from '$lib/types/api/party'
-import type { GridService } from '$lib/services/grid.service'
-import type { PartyService } from '$lib/services/party.service'
-
-export type GridItemType = 'character' | 'weapon' | 'summon'
-export type GridCollection = 'characters' | 'weapons' | 'summons'
-
-/**
- * Maps grid item type to collection key in Party object
- *
- * @param type - Grid item type (character, weapon, or summon)
- * @returns Collection key name
- *
- * @example
- * ```typescript
- * const key = getCollectionKey('weapon') // Returns: 'weapons'
- * const items = party[key] // Access party.weapons
- * ```
- */
-export function getCollectionKey(type: GridItemType): GridCollection {
-	const map: Record<GridItemType, GridCollection> = {
-		character: 'characters',
-		weapon: 'weapons',
-		summon: 'summons'
-	}
-	return map[type]
-}
-
-/**
- * Maps operation and grid type to service method name
- *
- * @param operation - CRUD operation type
- * @param type - Grid item type
- * @returns Method name on GridService
- *
- * @example
- * ```typescript
- * const methodName = getGridMethodName('add', 'weapon') // Returns: 'addWeapon'
- * const methodName = getGridMethodName('remove', 'character') // Returns: 'removeCharacter'
- * ```
- */
-export function getGridMethodName(
-	operation: 'add' | 'move' | 'remove' | 'update',
-	type: GridItemType
-): string {
-	const typeCapitalized = type.charAt(0).toUpperCase() + type.slice(1)
-	return `${operation}${typeCapitalized}`
-}
-
-/**
- * Execute grid move/swap operation
- * Consolidates handleSwap and handleMove logic
- *
- * @param operationType - Type of operation (move or swap)
- * @param source - Source item information
- * @param target - Target position information
- * @param context - Party context (ID, shortcode, edit key)
- * @param gridService - Grid service instance
- * @param partyService - Party service instance
- * @returns Updated party data
- *
- * @example
- * ```typescript
- * const updated = await executeGridOperation(
- *   'swap',
- *   { type: 'weapon', itemId: 'abc123', position: 0 },
- *   { type: 'weapon', position: 1, itemId: 'def456' },
- *   { partyId: party.id, shortcode: party.shortcode, editKey },
- *   gridService,
- *   partyService
- * )
- * ```
- */
-export async function executeGridOperation(
-	operationType: 'move' | 'swap',
-	source: { type: GridItemType; itemId: string; position: number },
-	target: { type: GridItemType; position: number; itemId?: string },
-	context: { partyId: string; shortcode: string; editKey?: string },
-	gridService: GridService,
-	partyService: PartyService
-): Promise<Party> {
-	// Validation
-	if (operationType === 'swap' && !target.itemId) {
-		throw new Error('Swap operation requires target item')
-	}
-	if (operationType === 'move' && target.itemId) {
-		throw new Error('Move operation requires empty target')
-	}
-
-	// Call appropriate grid service method
-	const methodName = getGridMethodName('move', source.type)
-	const method = (gridService as any)[methodName]
-
-	if (!method) {
-		throw new Error(`Unknown grid method: ${methodName}`)
-	}
-
-	await method.call(
-		gridService,
-		context.partyId,
-		source.itemId,
-		target.position,
-		context.editKey,
-		{ shortcode: context.shortcode }
-	)
-
-	// Clear cache and refresh party
-	partyService.clearPartyCache(context.shortcode)
-	return await partyService.getByShortcode(context.shortcode)
-}
-
-/**
- * Generic grid item remover
- * Replaces three similar remove{Type} methods in clientGridService
- *
- * @param type - Grid item type to remove
- * @param partyId - Party UUID
- * @param gridItemId - Grid item UUID to remove
- * @param party - Current party state
- * @param shortcode - Party shortcode for cache clearing
- * @param editKey - Optional edit key for authorization
- * @param gridService - Grid service instance
- * @returns Updated party with item removed
- *
- * @example
- * ```typescript
- * const updated = await removeGridItem(
- *   'weapon',
- *   party.id,
- *   gridWeaponId,
- *   party,
- *   party.shortcode,
- *   editKey,
- *   gridService
- * )
- * ```
- */
-export async function removeGridItem(
-	type: GridItemType,
-	partyId: string,
-	gridItemId: string,
-	party: Party,
-	shortcode: string,
-	editKey: string | undefined,
-	gridService: GridService
-): Promise<Party> {
-	// Call appropriate remove method
-	const methodName = getGridMethodName('remove', type)
-	const method = (gridService as any)[methodName]
-
-	await method.call(gridService, partyId, gridItemId, editKey, { shortcode })
-
-	// Update local state by removing item
-	const collection = getCollectionKey(type)
-	const updatedParty = { ...party }
-
-	if (updatedParty[collection]) {
-		updatedParty[collection] = updatedParty[collection].filter(
-			(item: any) => item.id !== gridItemId
-		)
-	}
-
-	return updatedParty
-}
-
-/**
- * Generic grid item updater
- * Replaces three similar update{Type} methods
- *
- * @param type - Grid item type to update
- * @param partyId - Party UUID
- * @param gridItemId - Grid item UUID to update
- * @param updates - Object containing fields to update
- * @param editKey - Optional edit key for authorization
- * @param gridService - Grid service instance
- * @returns Updated grid item data
- *
- * @example
- * ```typescript
- * const updated = await updateGridItem(
- *   'weapon',
- *   party.id,
- *   gridWeaponId,
- *   { ax1: 10, ax2: 5 },
- *   editKey,
- *   gridService
- * )
- * ```
- */
-export async function updateGridItem(
-	type: GridItemType,
-	partyId: string,
-	gridItemId: string,
-	updates: any,
-	editKey: string | undefined,
-	gridService: GridService
-): Promise<any> {
-	const methodName = getGridMethodName('update', type)
-	const method = (gridService as any)[methodName]
-
-	return await method.call(gridService, partyId, gridItemId, updates, editKey)
-}
diff --git a/src/lib/utils/localId.ts b/src/lib/utils/localId.ts
new file mode 100644
index 00000000..e3a46ca1
--- /dev/null
+++ b/src/lib/utils/localId.ts
@@ -0,0 +1,20 @@
+/**
+ * Local ID utilities for anonymous users
+ */
+
+/**
+ * Get or create a local ID for anonymous users
+ * This ID persists in localStorage and allows anonymous users to manage their parties
+ *
+ * @returns Local ID string (UUID)
+ */
+export function getLocalId(): string {
+	if (typeof window === 'undefined') return ''
+
+	let localId = localStorage.getItem('local_id')
+	if (!localId) {
+		localId = crypto.randomUUID()
+		localStorage.setItem('local_id', localId)
+	}
+	return localId
+}
diff --git a/src/routes/teams/new/+page.svelte b/src/routes/teams/new/+page.svelte
index bb49d62b..3450a05e 100644
--- a/src/routes/teams/new/+page.svelte
+++ b/src/routes/teams/new/+page.svelte
@@ -10,14 +10,11 @@
   import { setContext } from 'svelte'
   import type { SearchResult } from '$lib/api/adapters'
   import { partyAdapter, gridAdapter } from '$lib/api/adapters'
-  import { PartyService } from '$lib/services/party.service'
+  import { getLocalId } from '$lib/utils/localId'
   import { Dialog } from 'bits-ui'
   import { replaceState } from '$app/navigation'
   import { page } from '$app/stores'
 
-  // Initialize party service for local ID management
-  const partyService = new PartyService()
-
   // Get authentication status from page store
   const isAuthenticated = $derived($page.data?.isAuthenticated ?? false)
   const currentUser = $derived($page.data?.currentUser)
@@ -115,8 +112,7 @@
 
         // Only include localId for anonymous users
         if (!isAuthenticated) {
-          const localId = partyService.getLocalId()
-          partyPayload.localId = localId
+          partyPayload.localId = getLocalId()
         }
 
         // Create party using the party adapter