@swarmclawai/swarmclaw 1.2.6 → 1.2.9

package/src/lib/app/navigation.ts

@@ -13,9 +13,10 @@ const VIEW_TO_PATH: Record<AppView, string> = {
   protocols: '/protocols',
   schedules: '/schedules',
   memory: '/memory',
-  missions: '/missions',
+
   tasks: '/tasks',
   secrets: '/secrets',
+  wallets: '/wallets',
   providers: '/providers',
   skills: '/skills',
   connectors: '/connectors',
@@ -25,7 +26,6 @@ const VIEW_TO_PATH: Record<AppView, string> = {
   logs: '/logs',
   extensions: '/extensions',
   usage: '/usage',
-  wallets: '/wallets',
   runs: '/runs',
   autonomy: '/autonomy',
   settings: '/settings',
@@ -42,11 +42,6 @@ export function getViewPath(view: AppView, id?: string | null): string {
   return base
 }
 
-export function getMissionPath(missionId?: string | null): string {
-  if (!missionId) return VIEW_TO_PATH.missions
-  return `${VIEW_TO_PATH.missions}/${encodeURIComponent(missionId)}`
-}
-
 /** Map a pathname back to an AppView. Returns null for unknown paths. */
 export function pathToView(pathname: string): AppView | null {
   for (const [view, path] of Object.entries(VIEW_TO_PATH)) {

package/src/lib/app/view-constants.ts

@@ -9,9 +9,10 @@ export const VIEW_LABELS: Record<AppView, string> = {
   protocols: 'Sessions',
   schedules: 'Schedules',
   memory: 'Memory',
-  missions: 'Missions',
+
   tasks: 'Tasks',
   secrets: 'Secrets',
+  wallets: 'Wallets',
   providers: 'Providers',
   skills: 'Skills',
   connectors: 'Connectors',
@@ -21,7 +22,6 @@ export const VIEW_LABELS: Record<AppView, string> = {
   logs: 'Logs',
   extensions: 'Extensions',
   usage: 'Usage',
-  wallets: 'Wallets',
   runs: 'Runs',
   autonomy: 'Autonomy',
   settings: 'Settings',
@@ -53,9 +53,10 @@ export const VIEW_DESCRIPTIONS: Record<AppView, string> = {
   protocols: 'Temporary structured sessions and protocol-driven runs',
   schedules: 'Automated task schedules',
   memory: 'Long-term agent memory store',
-  missions: 'Durable mission control and execution state',
+
   tasks: 'Task board for agent work and queued runs',
   secrets: 'API keys, tokens, and encrypted credentials',
+  wallets: 'Crypto wallets for agent-initiated on-chain transactions',
   providers: 'LLM providers & custom endpoints',
   skills: 'Reusable instruction sets for agents',
   connectors: 'Chat platform bridges (Discord, Slack, etc.)',
@@ -65,7 +66,6 @@ export const VIEW_DESCRIPTIONS: Record<AppView, string> = {
   logs: 'Application logs & error tracking',
   extensions: 'Manage external extensions and marketplace installs',
   usage: 'Usage metrics, cost tracking & agent performance',
-  wallets: 'Agent crypto wallets — hold funds, send SOL, manage spending',
   runs: 'Live run monitoring & history',
   autonomy: 'Estops, incidents, and runtime autonomy controls',
   settings: 'Manage defaults, providers, secrets, and automation settings',
@@ -89,7 +89,7 @@ export const VIEW_EMPTY_STATES: Record<Exclude<AppView, 'agents' | 'home'>, { ic
   protocols: {
     icon: 'list',
     title: 'Structured Sessions',
-    description: 'Run temporary bounded sessions from chats, chatrooms, tasks, missions, or schedules without turning every surface into a workflow engine.',
+    description: 'Run temporary bounded sessions from chats, chatrooms, tasks, or schedules without turning every surface into a workflow engine.',
     features: ['Start one-agent or multi-agent structured sessions from context', 'Use neutral built-in templates like review, discussion, and decision rounds', 'Keep a hidden transcript plus durable run events', 'Archive the outcome and post a compact summary back when needed'],
   },
   schedules: {
@@ -104,12 +104,7 @@ export const VIEW_EMPTY_STATES: Record<Exclude<AppView, 'agents' | 'home'>, { ic
     description: 'Long-term memory store for AI agents so they can retain useful context across conversations.',
     features: ['Agents store findings and learnings automatically', 'Full-text search across all stored memories', 'Organized by categories and agents', 'Persists across conversations for continuity'],
   },
-  missions: {
-    icon: 'target',
-    title: 'Missions',
-    description: 'Track durable objectives, blockers, waits, verification, and linked work across chats, schedules, and delegation.',
-    features: ['Inspect active and waiting missions', 'Review child missions and linked tasks', 'Understand why a mission is blocked or complete', 'Resume, replan, or retry verification from one place'],
-  },
+
   tasks: {
     icon: 'clipboard',
     title: 'Task Board',
@@ -122,6 +117,12 @@ export const VIEW_EMPTY_STATES: Record<Exclude<AppView, 'agents' | 'home'>, { ic
     description: 'Manage API keys and credentials that agents and integrations can access securely.',
     features: ['Store keys for external services (Gmail, APIs, etc.)', 'Scope secrets globally or to specific agents', 'Encrypted at rest with AES-256-GCM', 'Agents retrieve secrets through configured tools'],
   },
+  wallets: {
+    icon: 'wallet',
+    title: 'Wallets',
+    description: 'Manage crypto wallets that agents use for on-chain transactions and payments.',
+    features: ['Generate wallets with encrypted private keys', 'Assign wallets to specific agents', 'Set spending and daily USDC limits', 'Require human approval for transactions'],
+  },
   providers: {
     icon: 'zap',
     title: 'Providers',
@@ -212,16 +213,10 @@ export const VIEW_EMPTY_STATES: Record<Exclude<AppView, 'agents' | 'home'>, { ic
     description: 'Audit trail of all entity mutations across the system.',
     features: ['Track agent, task, and connector changes', 'Filter by entity type and action', 'Real-time updates via WebSocket', 'Relative timestamps'],
   },
-  wallets: {
-    icon: 'wallet',
-    title: 'Wallets',
-    description: 'Agent crypto wallets for autonomous financial operations on Solana.',
-    features: ['Create Solana wallets for agents', 'Per-transaction and daily spending limits', 'User approval for transactions', 'Balance tracking and transaction history'],
-  },
 }
 
 export const FULL_WIDTH_VIEWS = new Set<AppView>([
-  'home', 'org_chart', 'inbox', 'chatrooms', 'protocols', 'schedules', 'missions', 'secrets', 'providers', 'skills',
+  'home', 'org_chart', 'inbox', 'chatrooms', 'protocols', 'schedules', 'secrets', 'wallets', 'providers', 'skills',
   'connectors', 'webhooks', 'mcp_servers', 'knowledge', 'extensions',
-  'usage', 'wallets', 'runs', 'autonomy', 'logs', 'settings', 'activity', 'projects',
+  'usage', 'runs', 'autonomy', 'logs', 'settings', 'activity', 'projects',
 ])

package/src/lib/chat/queued-message-queue.test.ts

@@ -1,9 +1,11 @@
 import assert from 'node:assert/strict'
 import { describe, it } from 'node:test'
 import {
+  buildQueuedTranscriptMessages,
   createOptimisticQueuedMessage,
   clearQueuedMessagesForSession,
   listQueuedMessagesForSession,
+  mergeQueuedTranscriptMessages,
   removeQueuedMessageById,
   replaceQueuedMessagesForSession,
   snapshotToQueuedMessages,
@@ -82,12 +84,22 @@ describe('queued-message-queue', () => {
     const queued = snapshotToQueuedMessages({
       sessionId: 'session-a',
       activeRunId: 'run-active',
+      activeTurn: {
+        runId: 'run-active',
+        sessionId: 'session-a',
+        text: 'sending now',
+        queuedAt: 4,
+        position: 0,
+      },
       queueLength: 1,
       items: [
         { runId: 'run-queued', sessionId: 'session-a', text: 'queued', queuedAt: 5, position: 1 },
       ],
     })
-    assert.deepEqual(queued.map((item) => item.runId), ['run-queued'])
+    assert.deepEqual(
+      queued.map((item) => [item.runId, item.sending === true]),
+      [['run-active', true], ['run-queued', false]],
+    )
   })
 
   it('preserves attachment and reply metadata from queue snapshots', () => {
@@ -123,6 +135,27 @@ describe('queued-message-queue', () => {
     })
   })
 
+  it('deduplicates an active turn when the snapshot also contains it in the queued items', () => {
+    const queued = snapshotToQueuedMessages({
+      sessionId: 'session-a',
+      activeRunId: 'run-active',
+      activeTurn: {
+        runId: 'run-active',
+        sessionId: 'session-a',
+        text: 'already running',
+        queuedAt: 6,
+        position: 0,
+      },
+      queueLength: 1,
+      items: [
+        { runId: 'run-active', sessionId: 'session-a', text: 'already running', queuedAt: 6, position: 1 },
+      ],
+    })
+
+    assert.deepEqual(queued.map((item) => item.runId), ['run-active'])
+    assert.equal(queued[0]?.sending, true)
+  })
+
   it('sorts queued messages by position and queued time within a session', () => {
     const unsorted: QueuedSessionMessage[] = [
       { runId: 'q4', sessionId: 'session-a', text: 'later', queuedAt: 9, position: 2 },
@@ -135,4 +168,104 @@ describe('queued-message-queue', () => {
       ['q5', 'q6', 'q4'],
     )
   })
+
+  it('builds transcript-ready user messages from sending queued turns', () => {
+    const transcript = buildQueuedTranscriptMessages([
+      { runId: 'q1', sessionId: 'session-a', text: 'sending row', queuedAt: 20, position: 0, sending: true },
+      { runId: 'q2', sessionId: 'session-a', text: 'pending row', queuedAt: 21, position: 1 },
+      { runId: 'q3', sessionId: 'session-b', text: 'other session', queuedAt: 22, position: 0, sending: true },
+    ], 'session-a')
+
+    assert.deepEqual(transcript, [
+      {
+        role: 'user',
+        text: 'sending row',
+        time: 20,
+        kind: 'chat',
+        clientRenderId: 'queued:q1',
+        imagePath: undefined,
+        imageUrl: undefined,
+        attachedFiles: undefined,
+        replyToId: undefined,
+        runId: 'q1',
+      },
+    ])
+  })
+
+  it('merges sending queued turns into the transcript ahead of later assistant output', () => {
+    const merged = mergeQueuedTranscriptMessages([
+      { role: 'assistant', text: 'Thinking...', time: 25, streaming: true, runId: 'run-active' },
+    ], [
+      { runId: 'run-active', sessionId: 'session-a', text: 'queued first', queuedAt: 20, position: 0, sending: true },
+    ], 'session-a')
+
+    assert.deepEqual(merged.map((message) => [message.role, message.text, message.runId]), [
+      ['user', 'queued first', 'run-active'],
+      ['assistant', 'Thinking...', 'run-active'],
+    ])
+  })
+
+  it('preserves existing sending items when replacing queue for a session', () => {
+    const queueWithSending: QueuedSessionMessage[] = [
+      { runId: 'sending-1', sessionId: 'session-a', text: 'already sending', queuedAt: 1, position: 0, sending: true },
+      { runId: 'q3', sessionId: 'session-a', text: 'queued', queuedAt: 2, position: 1 },
+      { runId: 'q2', sessionId: 'session-b', text: 'other', queuedAt: 3, position: 1 },
+    ]
+    const replaced = replaceQueuedMessagesForSession(queueWithSending, 'session-a', [
+      { runId: 'q4', sessionId: 'session-a', text: 'new queued', queuedAt: 4, position: 1 },
+    ], { activeRunId: null })
+
+    const forSession = listQueuedMessagesForSession(replaced, 'session-a')
+    assert.deepEqual(
+      forSession.map((item) => [item.runId, item.sending === true]),
+      [['sending-1', true], ['q4', false]],
+    )
+  })
+
+  it('deduplicates sending items that appear in nextItems', () => {
+    const queueWithSending: QueuedSessionMessage[] = [
+      { runId: 'run-active', sessionId: 'session-a', text: 'sending', queuedAt: 1, position: 0, sending: true },
+    ]
+    const replaced = replaceQueuedMessagesForSession(queueWithSending, 'session-a', [
+      { runId: 'run-active', sessionId: 'session-a', text: 'sending', queuedAt: 1, position: 0, sending: true },
+      { runId: 'q5', sessionId: 'session-a', text: 'next', queuedAt: 2, position: 1 },
+    ], { activeRunId: 'run-active' })
+
+    const forSession = listQueuedMessagesForSession(replaced, 'session-a')
+    assert.deepEqual(
+      forSession.map((item) => item.runId),
+      ['run-active', 'q5'],
+    )
+  })
+
+  it('inserts sending messages after last persisted message, not by timestamp', () => {
+    const merged = mergeQueuedTranscriptMessages([
+      { role: 'user', text: 'First', time: 100 },
+      { role: 'assistant', text: 'Reply', time: 200 },
+      { role: 'user', text: 'Second', time: 300 },
+      { role: 'assistant', text: 'Reply 2', time: 400 },
+    ], [
+      // queuedAt is earlier than the last persisted message
+      { runId: 'run-late', sessionId: 'session-a', text: 'queued early', queuedAt: 150, position: 0, sending: true },
+    ], 'session-a')
+
+    // Should appear at the END, not spliced into the middle at time=150
+    assert.deepEqual(merged.map((msg) => msg.text), [
+      'First', 'Reply', 'Second', 'Reply 2', 'queued early',
+    ])
+  })
+
+  it('skips a sending queued turn once the persisted user message is already present', () => {
+    const merged = mergeQueuedTranscriptMessages([
+      { role: 'user', text: 'queued first', time: 20, runId: 'run-active' },
+      { role: 'assistant', text: 'Thinking...', time: 25, streaming: true, runId: 'run-active' },
+    ], [
+      { runId: 'run-active', sessionId: 'session-a', text: 'queued first', queuedAt: 20, position: 0, sending: true },
+    ], 'session-a')
+
+    assert.deepEqual(merged.map((message) => [message.role, message.text, message.runId]), [
+      ['user', 'queued first', 'run-active'],
+      ['assistant', 'Thinking...', 'run-active'],
+    ])
+  })
 })

package/src/lib/chat/queued-message-queue.ts

@@ -1,4 +1,4 @@
-import type { SessionQueueSnapshot, SessionQueuedTurn } from '@/types'
+import type { Message, SessionQueueSnapshot, SessionQueuedTurn } from '@/types'
 
 export interface QueuedSessionMessage extends SessionQueuedTurn {
   optimistic?: boolean
@@ -38,7 +38,23 @@ export function createOptimisticQueuedMessage(
 }
 
 export function snapshotToQueuedMessages(snapshot: SessionQueueSnapshot): QueuedSessionMessage[] {
-  return snapshot.items.map((item) => ({ ...item }))
+  const activeRunId = typeof snapshot.activeRunId === 'string' && snapshot.activeRunId.trim()
+    ? snapshot.activeRunId
+    : null
+  const nextItems: QueuedSessionMessage[] = []
+  if (snapshot.activeTurn && activeRunId && snapshot.activeTurn.runId === activeRunId) {
+    nextItems.push({
+      ...snapshot.activeTurn,
+      sending: true,
+    })
+  }
+  const seenRunIds = new Set(nextItems.map((item) => item.runId))
+  for (const item of snapshot.items) {
+    if (seenRunIds.has(item.runId)) continue
+    nextItems.push({ ...item })
+    seenRunIds.add(item.runId)
+  }
+  return nextItems
 }
 
 interface ReplaceQueuedMessagesOptions {
@@ -60,11 +76,17 @@ export function replaceQueuedMessagesForSession(
   const activeRunId = typeof options.activeRunId === 'string' && options.activeRunId.trim()
     ? options.activeRunId
     : null
+  // Preserve existing "sending" items not covered by the new snapshot —
+  // they'll be cleaned up later by setMessages or the timeout.
+  const existingSending = queue.filter((item) =>
+    item.sessionId === sessionId && item.sending && !nextRunIds.has(item.runId),
+  )
   const consumed = previousForSession
     .filter((item) => !item.optimistic && !nextRunIds.has(item.runId) && activeRunId === item.runId)
     .map((item) => ({ ...item, sending: true }))
   return [
     ...otherSessions,
+    ...existingSending,
     ...consumed,
     ...nextItems,
   ]
@@ -80,6 +102,59 @@ export function listQueuedMessagesForSession(
     .sort((left, right) => left.position - right.position || left.queuedAt - right.queuedAt)
 }
 
+export function buildQueuedTranscriptMessages(
+  queue: QueuedSessionMessage[],
+  sessionId: string | null | undefined,
+): Message[] {
+  return listQueuedMessagesForSession(queue, sessionId)
+    .filter((item) => item.sending === true)
+    .map((item) => ({
+      role: 'user',
+      text: item.text,
+      time: item.queuedAt,
+      kind: 'chat',
+      clientRenderId: `queued:${item.runId}`,
+      imagePath: item.imagePath,
+      imageUrl: item.imageUrl,
+      attachedFiles: item.attachedFiles,
+      replyToId: item.replyToId,
+      runId: item.runId,
+    }))
+}
+
+export function mergeQueuedTranscriptMessages(
+  messages: Message[],
+  queue: QueuedSessionMessage[],
+  sessionId: string | null | undefined,
+): Message[] {
+  const queuedTranscript = buildQueuedTranscriptMessages(queue, sessionId)
+  if (queuedTranscript.length === 0) return messages
+  const merged = [...messages]
+  for (const queuedMessage of queuedTranscript) {
+    const queuedRunId = typeof queuedMessage.runId === 'string' && queuedMessage.runId.trim()
+      ? queuedMessage.runId
+      : null
+    if (queuedRunId && merged.some((message) => message.role === 'user' && message.runId === queuedRunId)) {
+      continue
+    }
+    // Place queued user message before its corresponding assistant response
+    // (same runId), otherwise append after the last persisted message.
+    const sameRunAssistantIndex = queuedRunId
+      ? merged.findIndex((msg) => msg.role === 'assistant' && msg.runId === queuedRunId)
+      : -1
+    if (sameRunAssistantIndex >= 0) {
+      merged.splice(sameRunAssistantIndex, 0, queuedMessage)
+    } else {
+      const lastPersistedIndex = merged.findLastIndex(
+        (msg) => !msg.clientRenderId?.startsWith('queued:'),
+      )
+      const insertAt = lastPersistedIndex >= 0 ? lastPersistedIndex + 1 : merged.length
+      merged.splice(insertAt, 0, queuedMessage)
+    }
+  }
+  return merged
+}
+
 export function removeQueuedMessageById(
   queue: QueuedSessionMessage[],
   id: string,

package/src/lib/server/agents/agent-service.ts

@@ -1,5 +1,6 @@
 import { genId } from '@/lib/id'
 import { resolveAgentToolSelection } from '@/lib/agent-default-tools'
+import { normalizeAgentExecuteConfig } from '@/lib/agent-execute-defaults'
 import { normalizeAgentSandboxConfig } from '@/lib/agent-sandbox-defaults'
 import { normalizeCapabilitySelection } from '@/lib/capability-selection'
 import { normalizeProviderEndpoint } from '@/lib/openclaw/openclaw-endpoint'
@@ -180,6 +181,7 @@ export function createAgent(input: {
     sessionDailyResetAt: typeof body.sessionDailyResetAt === 'string' ? body.sessionDailyResetAt : null,
     sessionResetTimezone: typeof body.sessionResetTimezone === 'string' ? body.sessionResetTimezone : null,
     sandboxConfig: normalizeAgentSandboxConfig(body.sandboxConfig),
+    executeConfig: body.executeConfig === null ? null : normalizeAgentExecuteConfig(body.executeConfig),
     createdAt: now,
     updatedAt: now,
   }
@@ -225,6 +227,9 @@ export function updateAgent(agentId: string, body: Record<string, unknown>): Age
     if (body.sandboxConfig !== undefined) {
       agent.sandboxConfig = normalizeAgentSandboxConfig(body.sandboxConfig)
     }
+    if (body.executeConfig !== undefined) {
+      agent.executeConfig = body.executeConfig === null ? null : normalizeAgentExecuteConfig(body.executeConfig)
+    }
     if (
       body.provider !== undefined
       || body.orchestratorEnabled !== undefined

package/src/lib/server/agents/agent-thread-session.ts

@@ -89,7 +89,6 @@ function buildThreadSession(agent: Agent, sessionId: string, user: string, creat
     vibe: existing?.vibe,
     theme: existing?.theme,
     avatar: existing?.avatar,
-    canvasContent: existing?.canvasContent || null,
   }
   return applyResolvedRoute(
     baseSession,

package/src/lib/server/agents/delegation-advisory.test.ts

@@ -62,7 +62,6 @@ function makeClassification(overrides: Partial<MessageClassification>): MessageC
     taskIntent: 'general',
     isDeliverableTask: false,
     isBroadGoal: false,
-    walletIntent: 'none',
     hasHumanSignals: false,
     hasSignificantEvent: false,
     isResearchSynthesis: false,

package/src/lib/server/agents/delegation-jobs.test.ts

@@ -225,73 +225,4 @@ describe('delegation-jobs', () => {
     )
   })
 
-  it('creates and syncs a child mission for delegation jobs', async () => {
-    const storage = await import('@/lib/server/storage')
-    const missions = await import('@/lib/server/missions/mission-service')
-
-    storage.saveSessions({
-      'mission-parent-session': {
-        id: 'mission-parent-session',
-        name: 'Parent Session',
-        cwd: process.cwd(),
-        user: 'tester',
-        provider: 'ollama',
-        model: 'test-model',
-        messages: [],
-        createdAt: Date.now(),
-        lastActiveAt: Date.now(),
-        agentId: 'agent-parent',
-      },
-    })
-    storage.saveAgents({
-      'agent-parent': {
-        id: 'agent-parent',
-        name: 'Parent Agent',
-        provider: 'ollama',
-        model: 'test-model',
-        systemPrompt: 'test',
-      },
-      'agent-child': {
-        id: 'agent-child',
-        name: 'Child Agent',
-        provider: 'ollama',
-        model: 'test-model',
-        systemPrompt: 'test',
-      },
-    })
-
-    const parentMission = await missions.resolveMissionForTurn({
-      session: storage.loadSessions()['mission-parent-session'],
-      message: 'Build the release pipeline and delegate the test matrix.',
-      source: 'chat',
-      internal: false,
-      runId: 'run-parent',
-      generateText: async () => JSON.stringify({
-        action: 'create_new',
-        objective: 'Build the release pipeline',
-        successCriteria: ['delegated matrix completes'],
-        currentStep: 'Delegate the test matrix',
-      }),
-    })
-
-    const job = delegationJobs.createDelegationJob({
-      kind: 'subagent',
-      parentSessionId: 'mission-parent-session',
-      parentMissionId: parentMission?.id || null,
-      childSessionId: 'child-session-1',
-      agentId: 'agent-child',
-      task: 'Run the test matrix',
-    })
-
-    const started = delegationJobs.startDelegationJob(job.id, { childSessionId: 'child-session-1' })
-    const completed = delegationJobs.completeDelegationJob(job.id, 'Matrix passed')
-    const childMission = completed?.missionId ? missions.loadMissionById(completed.missionId) : null
-    const refreshedParent = parentMission?.id ? missions.loadMissionById(parentMission.id) : null
-
-    assert.ok(started?.missionId)
-    assert.equal(started?.parentMissionId, parentMission?.id || null)
-    assert.equal(childMission?.parentMissionId, parentMission?.id || null)
-    assert.equal(childMission?.status, 'completed')
-    assert.ok(refreshedParent?.childMissionIds?.includes(childMission?.id || ''))
-  })
 })

package/src/lib/server/agents/delegation-jobs.ts

@@ -13,8 +13,6 @@ import { log } from '@/lib/server/logger'
 import { debug } from '@/lib/server/debug'
 import { createNotification } from '@/lib/server/create-notification'
 import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
-import { ensureDelegationMission, syncDelegationMissionFromJob } from '@/lib/server/missions/mission-service'
-import { loadSession } from '@/lib/server/sessions/session-repository'
 import { notify } from '@/lib/server/ws-hub'
 
 interface DelegationRuntimeHandle {
@@ -42,8 +40,6 @@ export interface CreateDelegationJobInput {
   kind: DelegationJobRecord['kind']
   task: string
   backend?: DelegationJobRecord['backend']
-  missionId?: string | null
-  parentMissionId?: string | null
   parentSessionId?: string | null
   childSessionId?: string | null
   agentId?: string | null
@@ -53,15 +49,11 @@ export interface CreateDelegationJobInput {
 
 export function createDelegationJob(input: CreateDelegationJobInput): DelegationJobRecord {
   const createdAt = Date.now()
-  const inferredParentMissionId = input.parentMissionId
-    || (input.parentSessionId ? loadSession(input.parentSessionId)?.missionId || null : null)
   const job: DelegationJobRecord = {
     id: genId(10),
     kind: input.kind,
     status: 'queued',
     backend: input.backend ?? null,
-    missionId: input.missionId ?? null,
-    parentMissionId: inferredParentMissionId,
     parentSessionId: input.parentSessionId ?? null,
     childSessionId: input.childSessionId ?? null,
     agentId: input.agentId ?? null,
@@ -85,22 +77,6 @@ export function createDelegationJob(input: CreateDelegationJobInput): Delegation
     completedAt: null,
   }
   upsertDelegationJob(job.id, job)
-  if (!job.missionId && inferredParentMissionId) {
-    const mission = ensureDelegationMission({
-      task: job.task,
-      backend: job.backend,
-      parentSessionId: job.parentSessionId || null,
-      childSessionId: job.childSessionId || null,
-      agentId: job.agentId || null,
-      parentMissionId: inferredParentMissionId,
-      jobId: job.id,
-    })
-    if (mission) {
-      job.missionId = mission.id
-      upsertDelegationJob(job.id, job)
-    }
-  }
-  syncDelegationMissionFromJob(job.id)
   notifyDelegationJobsChanged()
 
   const sid = job.childSessionId || job.parentSessionId || ''
@@ -151,7 +127,6 @@ export function updateDelegationJob(
     }
   })
   if (!result) return null
-  syncDelegationMissionFromJob(id)
   notifyDelegationJobsChanged()
   return getDelegationJob(id) || result
 }