@swarmclawai/swarmclaw 1.2.8 → 1.2.9

package/src/lib/server/storage.ts

@@ -24,8 +24,6 @@ import type {
   GuardianCheckpoint,
   LearnedSkill,
   Message,
-  Mission,
-  MissionEvent,
   ProtocolTemplate,
   ProtocolRun,
   ProtocolRunEvent,
@@ -138,9 +136,6 @@ const COLLECTIONS = [
   'webhook_retry_queue',
   'notifications',
   'chatrooms',
-  'wallets',
-  'wallet_transactions',
-  'wallet_balance_history',
   'moderation_logs',
   'connector_health',
   'connector_outbox',
@@ -152,8 +147,6 @@ const COLLECTIONS = [
   'watch_jobs',
   'delegation_jobs',
   'external_agents',
-  'missions',
-  'mission_events',
   'protocol_templates',
   'protocol_runs',
   'protocol_run_events',
@@ -162,6 +155,8 @@ const COLLECTIONS = [
   'main_loop_states',
   'working_states',
   'daemon_status',
+  'wallets',
+  'wallet_transactions',
 ] as const
 
 export type StorageCollection = (typeof COLLECTIONS)[number]
@@ -545,8 +540,6 @@ const JSON_FILES: Record<string, string> = {
   documents: path.join(DATA_DIR, 'documents.json'),
   webhooks: path.join(DATA_DIR, 'webhooks.json'),
   external_agents: path.join(DATA_DIR, 'external-agents.json'),
-  missions: path.join(DATA_DIR, 'missions.json'),
-  mission_events: path.join(DATA_DIR, 'mission-events.json'),
   protocol_templates: path.join(DATA_DIR, 'protocol-templates.json'),
   protocol_runs: path.join(DATA_DIR, 'protocol-runs.json'),
   protocol_run_events: path.join(DATA_DIR, 'protocol-run-events.json'),
@@ -1208,25 +1201,6 @@ export const loadProjects = projectsStore.load
 export const saveProjects = projectsStore.save
 export const deleteProject = projectsStore.deleteItem
 
-// --- Missions ---
-const missionsStore = createCollectionStore('missions')
-export const loadMissions = missionsStore.load as () => Record<string, Mission>
-export const saveMissions = missionsStore.save as (items: Record<string, Mission>) => void
-export const loadMission = missionsStore.loadItem as (id: string) => Mission | null
-export const upsertMission = missionsStore.upsert as (id: string, value: Mission) => void
-export const patchMission = missionsStore.patch as (
-  id: string,
-  updater: (current: Mission | null) => Mission | null,
-) => Mission | null
-export const deleteMission = missionsStore.deleteItem
-
-const missionEventsStore = createCollectionStore('mission_events')
-export const loadMissionEvents = missionEventsStore.load as () => Record<string, MissionEvent>
-export const saveMissionEvents = missionEventsStore.save as (items: Record<string, MissionEvent>) => void
-export const loadMissionEvent = missionEventsStore.loadItem as (id: string) => MissionEvent | null
-export const upsertMissionEvent = missionEventsStore.upsert as (id: string, value: MissionEvent) => void
-export const upsertMissionEvents = missionEventsStore.upsertMany as (entries: Array<[string, MissionEvent]>) => void
-
 const protocolTemplatesStore = createCollectionStore('protocol_templates')
 export const loadProtocolTemplates = protocolTemplatesStore.load as () => Record<string, ProtocolTemplate>
 export const saveProtocolTemplates = protocolTemplatesStore.save as (items: Record<string, ProtocolTemplate>) => void
@@ -1541,23 +1515,6 @@ export function markNotificationRead(id: string) {
   }
 }
 
-// --- Wallets ---
-const walletsStore = createCollectionStore('wallets')
-export const loadWallets = walletsStore.load
-export const upsertWallet = walletsStore.upsert
-export const deleteWallet = walletsStore.deleteItem
-
-// --- Wallet Transactions ---
-const walletTransactionsStore = createCollectionStore('wallet_transactions')
-export const loadWalletTransactions = walletTransactionsStore.load
-export const upsertWalletTransaction = walletTransactionsStore.upsert
-export const deleteWalletTransaction = walletTransactionsStore.deleteItem
-
-// --- Wallet Balance History ---
-const walletBalanceHistoryStore = createCollectionStore('wallet_balance_history')
-export const loadWalletBalanceHistory = walletBalanceHistoryStore.load
-export const upsertWalletBalanceSnapshot = walletBalanceHistoryStore.upsert
-
 // --- Moderation Logs ---
 const moderationLogsStore = createCollectionStore('moderation_logs')
 export const loadModerationLogs = moderationLogsStore.load
@@ -1613,6 +1570,22 @@ export const loadPersistedWorkingState = workingStatesStore.loadItem
 export const upsertPersistedWorkingState = workingStatesStore.upsert
 export const deletePersistedWorkingState = workingStatesStore.deleteItem
 
+// --- Wallets ---
+const walletsStore = createCollectionStore('wallets')
+export const loadWallets = walletsStore.load
+export const saveWallets = walletsStore.save
+export const loadWallet = walletsStore.loadItem
+export const upsertWallet = walletsStore.upsert
+export const deleteWalletItem = walletsStore.deleteItem
+
+// --- Wallet Transactions ---
+const walletTransactionsStore = createCollectionStore('wallet_transactions')
+export const loadWalletTransactions = walletTransactionsStore.load
+export const saveWalletTransactions = walletTransactionsStore.save
+export const loadWalletTransaction = walletTransactionsStore.loadItem
+export const upsertWalletTransaction = walletTransactionsStore.upsert
+export const deleteWalletTransaction = walletTransactionsStore.deleteItem
+
 export function getSessionMessages(sessionId: string): Message[] {
   const session = loadSession(sessionId)
   return Array.isArray(session?.messages) ? session.messages : []

package/src/lib/server/tasks/task-checkout.ts

@@ -0,0 +1,59 @@
+import type { BoardTask } from '@/types'
+import { withTransaction } from '@/lib/server/persistence/transaction'
+import { loadTasks, saveTasks } from '@/lib/server/tasks/task-repository'
+
+/**
+ * Atomically transition a task from queued → running with a checkout run ID.
+ *
+ * Uses a SQLite IMMEDIATE transaction to prevent two runners from starting the
+ * same task concurrently (Paperclip-inspired atomic checkout pattern).
+ *
+ * Returns the checked-out task on success, or null if the task was already
+ * taken, missing, or no longer in queued status.
+ */
+export function checkoutTask(
+  taskId: string,
+  runId: string,
+): BoardTask | null {
+  return withTransaction(() => {
+    const tasks = loadTasks() as Record<string, BoardTask>
+    const task = tasks[taskId]
+    if (!task || task.status !== 'queued') return null
+    if (task.checkoutRunId) return null // already checked out
+
+    const now = Date.now()
+    task.status = 'running'
+    task.checkoutRunId = runId
+    task.startedAt = now
+    task.lastActivityAt = now
+    task.retryScheduledAt = null
+    task.deadLetteredAt = null
+    task.error = null
+    task.validation = null
+    task.updatedAt = now
+
+    saveTasks(tasks)
+    return { ...task }
+  })
+}
+
+/**
+ * Release a checkout after task completion or failure.
+ * Only the holder of the checkout (matching runId) can release it.
+ */
+export function releaseCheckout(
+  taskId: string,
+  runId: string,
+): boolean {
+  return withTransaction(() => {
+    const tasks = loadTasks() as Record<string, BoardTask>
+    const task = tasks[taskId]
+    if (!task) return false
+    if (task.checkoutRunId !== runId) return false
+
+    task.checkoutRunId = null
+    task.updatedAt = Date.now()
+    saveTasks(tasks)
+    return true
+  })
+}

package/src/lib/server/tasks/task-lifecycle.ts

@@ -176,6 +176,7 @@ export function markValidatedTaskCompleted(
   task.completedAt = options.preserveCompletedAt ? (task.completedAt || options.now) : options.now
   task.updatedAt = options.now
   task.error = null
+  task.checkoutRunId = null
   return task
 }
 
@@ -187,6 +188,7 @@ export function markInvalidCompletedTaskFailed(
   task.status = 'failed'
   task.completedAt = null
   task.updatedAt = options.now
+  task.checkoutRunId = null
   task.error = formatValidationFailure(validation.reasons).slice(0, 500)
   if (options.comment) {
     if (!task.comments) task.comments = []

package/src/lib/server/tasks/task-route-service.ts

@@ -6,11 +6,6 @@ import { logActivity } from '@/lib/server/activity/activity-log'
 import { createNotification } from '@/lib/server/create-notification'
 import { validateDag, cascadeUnblock } from '@/lib/server/dag-validation'
 import { getExtensionManager } from '@/lib/server/extensions'
-import {
-  enrichTaskWithMissionSummary,
-  ensureMissionForTask,
-  noteMissionTaskFinished,
-} from '@/lib/server/missions/mission-service'
 import {
   disableSessionHeartbeat,
   enqueueTask,
@@ -64,9 +59,7 @@ export function prepareTasksForListing() {
   validateCompletedTasksQueue()
   recoverStalledRunningTasks()
   const allTasks = loadTasks()
-  return Object.fromEntries(
-    Object.entries(allTasks).map(([id, task]) => [id, enrichTaskWithMissionSummary(task)]),
-  )
+  return allTasks
 }
 
 export function updateTaskFromRoute(id: string, body: Record<string, unknown>): ServiceResult<BoardTask> {
@@ -128,10 +121,6 @@ export function updateTaskFromRoute(id: string, body: Record<string, unknown>):
   }
 
   saveTask(id, tasks[id])
-  const mission = ensureMissionForTask(tasks[id], { source: 'manual' })
-  if (tasks[id].status === 'completed' || tasks[id].status === 'failed' || tasks[id].status === 'cancelled') {
-    noteMissionTaskFinished(tasks[id], tasks[id].status, tasks[id].id)
-  }
   logActivity({ entityType: 'task', entityId: id, action: 'updated', actor: 'user', summary: `Task updated: "${tasks[id].title}" (${prevStatus} → ${tasks[id].status})` })
   if (prevStatus !== tasks[id].status) {
     pushMainLoopEventToMainSessions({
@@ -143,10 +132,7 @@ export function updateTaskFromRoute(id: string, body: Record<string, unknown>):
   if (prevStatus !== tasks[id].status && tasks[id].status === 'cancelled') {
     disableSessionHeartbeat(tasks[id].sessionId)
     notify('tasks')
-    return serviceOk(enrichTaskWithMissionSummary({
-      ...tasks[id],
-      missionId: mission?.id || tasks[id].missionId || null,
-    }))
+    return serviceOk(tasks[id])
   }
 
   if (prevStatus !== tasks[id].status && (tasks[id].status === 'completed' || tasks[id].status === 'failed')) {
@@ -216,10 +202,7 @@ export function updateTaskFromRoute(id: string, body: Record<string, unknown>):
   }
 
   notify('tasks')
-  return serviceOk(enrichTaskWithMissionSummary({
-    ...tasks[id],
-    missionId: mission?.id || tasks[id].missionId || null,
-  }))
+  return serviceOk(tasks[id])
 }
 
 export function archiveTaskFromRoute(id: string): ServiceResult<BoardTask> {
@@ -346,11 +329,6 @@ export function createTaskFromRoute(body: Record<string, unknown>): ServiceResul
   }
 
   saveTask(id, task)
-  const mission = ensureMissionForTask(task, { source: 'manual' })
-  const finalTask = enrichTaskWithMissionSummary({
-    ...task,
-    missionId: mission?.id || task.missionId || null,
-  })
   logActivity({ entityType: 'task', entityId: id, action: 'created', actor: 'user', summary: `Task created: "${task.title}"` })
   pushMainLoopEventToMainSessions({
     type: 'task_created',
@@ -360,7 +338,7 @@ export function createTaskFromRoute(body: Record<string, unknown>): ServiceResul
     enqueueTask(id)
   }
   notify('tasks')
-  return serviceOk(finalTask)
+  return serviceOk(task)
 }
 
 export function bulkUpdateTasksFromRoute(body: Record<string, unknown>): ServiceResult<{ updated: number; ids: string[] }> {

package/src/lib/server/tasks/task-service.ts

@@ -106,13 +106,6 @@ export function applyTaskContinuationDefaults(
     if (!Object.prototype.hasOwnProperty.call(explicit, 'cwd') && typeof sourceTask.cwd === 'string' && sourceTask.cwd.trim()) {
       parsed.cwd = sourceTask.cwd.trim()
     }
-    if (
-      !Object.prototype.hasOwnProperty.call(explicit, 'missionId')
-      && typeof sourceTask.missionId === 'string'
-      && sourceTask.missionId.trim()
-    ) {
-      parsed.missionId = sourceTask.missionId.trim()
-    }
     const sourceSessionId = typeof sourceTask.checkpoint?.lastSessionId === 'string' && sourceTask.checkpoint.lastSessionId.trim()
       ? sourceTask.checkpoint.lastSessionId.trim()
       : typeof sourceTask.sessionId === 'string' && sourceTask.sessionId.trim()

package/src/lib/server/tool-aliases.ts

@@ -22,7 +22,6 @@ const EXTENSION_ALIAS_GROUPS: string[][] = [
   ['schedule_wake', 'schedule'],
   // http_request/http now aliased into web group above
   ['memory', 'memory_tool', 'memory_search', 'memory_get', 'memory_store', 'memory_update'],
-  ['wallet', 'wallet_tool'],
   ['monitor', 'monitor_tool'],
   ['context_mgmt', 'context_status', 'context_summarize'],
   ['openclaw_workspace'],

package/src/lib/server/tool-capability-policy-advanced.test.ts

@@ -423,17 +423,17 @@ describe('compound scenarios', () => {
     assert.match(tasksBlock.reason, /task management is disabled/)
   })
 
-  it('20 tools requested: correctly partitioned into enabled vs blocked', () => {
+  it('19 tools requested: correctly partitioned into enabled vs blocked', () => {
     const tools = [
       'shell', 'files', 'web', 'web_search', 'web_fetch', 'browser',
       'memory', 'delegate', 'manage_platform', 'manage_tasks',
-      'manage_schedules', 'wallet', 'delete_file', 'canvas',
+      'manage_schedules', 'wallet', 'delete_file',
       'manage_connectors', 'git', 'sandbox', 'claude_code',
       'monitor', 'http_request',
     ]
     const d = resolveSessionToolPolicy(tools, { capabilityPolicyMode: 'strict' })
-    assert.equal(d.requestedExtensions.length, 20)
-    assert.equal(d.enabledExtensions.length + d.blockedExtensions.length, 20)
+    assert.equal(d.requestedExtensions.length, 19)
+    assert.equal(d.enabledExtensions.length + d.blockedExtensions.length, 19)
 
     // memory, web, web_search, web_fetch should be enabled
     assert.ok(d.enabledExtensions.includes('memory'))

package/src/lib/server/tool-capability-policy.ts

@@ -60,8 +60,6 @@ const TOOL_DESCRIPTORS: Record<string, ToolDescriptor> = {
   gemini_cli: { categories: ['delegation', 'execution'], concreteTools: ['delegate_to_gemini_cli'] },
   memory: { categories: ['memory'], concreteTools: ['memory', 'memory_tool', 'memory_search', 'memory_get', 'memory_store', 'memory_update', 'context_status', 'context_summarize'] },
   // http_request consolidated into web 'api' action — no separate descriptor
-  canvas: { categories: ['filesystem'], concreteTools: ['canvas'] },
-  wallet: { categories: ['outbound'], concreteTools: ['wallet', 'wallet_tool'] },
   monitor: { categories: ['execution'], concreteTools: ['monitor', 'monitor_tool'] },
   openclaw_workspace: { categories: ['filesystem', 'platform'], concreteTools: ['openclaw_workspace'] },
   openclaw_nodes: { categories: ['platform'], concreteTools: ['openclaw_nodes'] },

package/src/lib/server/tool-planning.ts

@@ -13,8 +13,6 @@ export const TOOL_CAPABILITY = {
   deliveryMessage: 'delivery.message',
   deliveryMedia: 'delivery.media',
   deliveryVoiceNote: 'delivery.voice_note',
-  walletInspect: 'wallet.inspect',
-  walletExecute: 'wallet.execute',
 } as const
 
 export interface ToolPlanningEntry {
@@ -373,16 +371,6 @@ const CORE_TOOL_PLANNING: Record<string, LegacyToolPlanningEntry[]> = {
       requestMatchers: [],
     },
   ],
-  wallet: [
-    {
-      toolName: 'wallet_tool',
-      capabilities: [TOOL_CAPABILITY.walletInspect, TOOL_CAPABILITY.walletExecute],
-      disciplineGuidance: [
-        'Inspect wallet state once, then act. Use `simulate_transaction` to validate before executing. Do not re-inspect balances between each operation unless the operation changes them.',
-      ],
-      requestMatchers: [],
-    },
-  ],
   image_gen: [
     {
       toolName: 'generate_image',

package/src/lib/server/universal-tool-access.ts

@@ -22,7 +22,6 @@ const UNIVERSAL_CORE_EXTENSION_IDS = [
   'manage_secrets',
   'manage_chatrooms',
   'spawn_subagent',
-  'canvas',
   'http_request',
   'wallet',
   'monitor',

package/src/lib/server/wallets/wallet-crypto.ts

@@ -0,0 +1,33 @@
+import { encryptKey, decryptKey } from '@/lib/server/storage'
+
+/**
+ * Generate a new Ethereum wallet (Base L2 compatible) with an encrypted private key.
+ * Uses ethers v6 for keypair generation and the existing AES-256-GCM encryption
+ * from storage.ts (CREDENTIAL_SECRET env var).
+ */
+export async function generateEthereumWallet(): Promise<{ address: string; encryptedPrivateKey: string }> {
+  const { Wallet } = await import('ethers')
+  const wallet = Wallet.createRandom()
+  const encryptedPrivateKey = encryptKey(wallet.privateKey)
+  return {
+    address: wallet.address,
+    encryptedPrivateKey,
+  }
+}
+
+export async function normalizeEthereumAddress(address: string): Promise<string | null> {
+  const { getAddress } = await import('ethers')
+  try {
+    return getAddress(address.trim())
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Decrypt a wallet's private key for server-side use only.
+ * Never expose the result to API responses or the frontend.
+ */
+export function decryptWalletPrivateKey(encrypted: string): string {
+  return decryptKey(encrypted)
+}

package/src/lib/server/wallets/wallet-repository.ts

@@ -0,0 +1,24 @@
+import {
+  loadWallets as loadWalletsStore,
+  saveWallets as saveWalletsStore,
+  loadWallet as loadWalletItem,
+  upsertWallet,
+  deleteWalletItem,
+} from '@/lib/server/storage'
+import type { AgentWallet } from '@/types/swarmdock'
+
+export function loadWallets(): Record<string, AgentWallet> {
+  return loadWalletsStore() as Record<string, AgentWallet>
+}
+
+export function loadWallet(id: string): AgentWallet | null {
+  return loadWalletItem(id) as AgentWallet | null
+}
+
+export function saveWallet(id: string, wallet: AgentWallet): void {
+  upsertWallet(id, wallet)
+}
+
+export function deleteWallet(id: string): void {
+  deleteWalletItem(id)
+}

package/src/lib/server/wallets/wallet-service.ts

@@ -0,0 +1,119 @@
+import { genId } from '@/lib/id'
+import { loadWallets, loadWallet, saveWallet, deleteWallet } from './wallet-repository'
+import { generateEthereumWallet, normalizeEthereumAddress } from './wallet-crypto'
+import { logActivity } from '@/lib/server/activity/activity-log'
+import { loadAgent } from '@/lib/server/agents/agent-repository'
+import type { AgentWallet, SafeWallet } from '@/types/swarmdock'
+
+export class WalletServiceError extends Error {
+  status: number
+
+  constructor(status: number, message: string) {
+    super(message)
+    this.name = 'WalletServiceError'
+    this.status = status
+  }
+}
+
+function stripPrivateKey(wallet: AgentWallet): SafeWallet {
+  const { encryptedPrivateKey: _, ...safe } = wallet
+  return safe
+}
+
+function requireAgent(agentId: string): string {
+  const normalizedAgentId = agentId.trim()
+  if (!normalizedAgentId) {
+    throw new WalletServiceError(400, 'agentId is required')
+  }
+  if (!loadAgent(normalizedAgentId)) {
+    throw new WalletServiceError(404, `Agent not found: ${normalizedAgentId}`)
+  }
+  return normalizedAgentId
+}
+
+async function requireWalletAddress(walletAddress: string): Promise<string> {
+  const normalizedAddress = walletAddress.trim()
+  if (!normalizedAddress) {
+    throw new WalletServiceError(400, 'walletAddress is required')
+  }
+  const checksumAddress = await normalizeEthereumAddress(normalizedAddress)
+  if (!checksumAddress) {
+    throw new WalletServiceError(400, 'walletAddress must be a valid Base/Ethereum address')
+  }
+  return checksumAddress
+}
+
+export function listWalletsSafe(): Record<string, SafeWallet> {
+  const wallets = loadWallets()
+  const safe: Record<string, SafeWallet> = {}
+  for (const [id, w] of Object.entries(wallets)) {
+    safe[id] = stripPrivateKey(w)
+  }
+  return safe
+}
+
+export function getWalletSafe(id: string): SafeWallet | null {
+  const wallet = loadWallet(id)
+  return wallet ? stripPrivateKey(wallet) : null
+}
+
+/** Generate a new Base L2 Ethereum wallet with encrypted private key storage. */
+export async function generateWallet(params: { agentId: string; label?: string }): Promise<SafeWallet> {
+  const agentId = requireAgent(params.agentId)
+  const { address, encryptedPrivateKey } = await generateEthereumWallet()
+  const id = genId()
+  const wallet: AgentWallet = {
+    id,
+    agentId,
+    walletAddress: address,
+    chain: 'base',
+    label: params.label || 'Base L2 Wallet',
+    encryptedPrivateKey,
+    requireApproval: true,
+    createdAt: Date.now(),
+  }
+  saveWallet(id, wallet)
+  logActivity({ entityType: 'wallet', entityId: id, action: 'created', actor: 'user', summary: `Wallet generated: ${address}` })
+  return stripPrivateKey(wallet)
+}
+
+/** Create a wallet from an existing address (no key generation). */
+export async function createWallet(params: { agentId: string; walletAddress: string; label?: string }): Promise<SafeWallet> {
+  const agentId = requireAgent(params.agentId)
+  const walletAddress = await requireWalletAddress(params.walletAddress)
+  const id = genId()
+  const wallet: AgentWallet = {
+    id,
+    agentId,
+    walletAddress,
+    chain: 'base',
+    label: params.label,
+    createdAt: Date.now(),
+  }
+  saveWallet(id, wallet)
+  logActivity({ entityType: 'wallet', entityId: id, action: 'created', actor: 'user', summary: `Wallet created: ${walletAddress}` })
+  return stripPrivateKey(wallet)
+}
+
+/** Update wallet settings (label, limits, approval). */
+export function updateWallet(
+  id: string,
+  patch: Partial<Pick<AgentWallet, 'label' | 'spendingLimitUsdc' | 'dailyLimitUsdc' | 'requireApproval'>>,
+): SafeWallet | null {
+  const wallet = loadWallet(id)
+  if (!wallet) return null
+  if (patch.label !== undefined) wallet.label = patch.label
+  if (patch.spendingLimitUsdc !== undefined) wallet.spendingLimitUsdc = patch.spendingLimitUsdc
+  if (patch.dailyLimitUsdc !== undefined) wallet.dailyLimitUsdc = patch.dailyLimitUsdc
+  if (patch.requireApproval !== undefined) wallet.requireApproval = patch.requireApproval
+  saveWallet(id, wallet)
+  return stripPrivateKey(wallet)
+}
+
+export function removeWallet(id: string): boolean {
+  const wallet = loadWallet(id)
+  if (!wallet) return false
+  deleteWallet(id)
+  logActivity({ entityType: 'wallet', entityId: id, action: 'deleted', actor: 'user', summary: `Wallet deleted: ${wallet.walletAddress}` })
+  return true
+}

package/src/lib/server/working-state/extraction.ts

@@ -22,7 +22,6 @@ import type {
 import {
   EXTRACTION_TIMEOUT_MS,
   WorkingStatePatchSchema,
-  missionStatusToWorkingStateStatus,
   normalizeEvidenceIds,
   now,
 } from '@/lib/server/working-state/normalization'
@@ -268,9 +267,9 @@ export function buildWorkingStatePatchPrompt(input: WorkingStateExtractionInput)
     'You maintain a structured working-state object for an autonomous agent.',
     'Return JSON only.',
     '',
-    'Update the state using only evidence from the latest turn, tool results, and mission snapshot.',
+    'Update the state using only evidence from the latest turn and tool results.',
     'Rules:',
-    '- Facts must be confirmed by explicit user text, mission state, or tool evidence. Do not turn guesses into facts.',
+    '- Facts must be confirmed by explicit user text or tool evidence. Do not turn guesses into facts.',
     '- Put uncertain leads into hypotheses, not facts.',
     '- Use blockers for approvals, credentials, human input, external waits, and explicit execution failures.',
     '- nextAction must be one concrete immediate action, not a broad plan.',
@@ -288,7 +287,7 @@ export function buildWorkingStatePatchPrompt(input: WorkingStateExtractionInput)
       status: 'idle|progress|blocked|waiting|completed',
       nextAction: 'optional',
       planSteps: [{ id: 'optional', text: 'step', status: 'active|resolved|superseded' }],
-      factsUpsert: [{ id: 'optional', statement: 'confirmed fact', source: 'user|tool|assistant|mission|system', status: 'active|resolved|superseded', evidenceIds: ['optional'] }],
+      factsUpsert: [{ id: 'optional', statement: 'confirmed fact', source: 'user|tool|assistant|system', status: 'active|resolved|superseded', evidenceIds: ['optional'] }],
       artifactsUpsert: [{ id: 'optional', label: 'artifact', kind: 'file|url|approval|message|other', path: 'optional', url: 'optional', sourceTool: 'optional', status: 'active|resolved|superseded', evidenceIds: ['optional'] }],
       decisionsAppend: [{ summary: 'decision', rationale: 'optional', status: 'active|resolved|superseded', evidenceIds: ['optional'] }],
       blockersUpsert: [{ summary: 'blocker', kind: 'approval|credential|human_input|external_dependency|error|other', nextAction: 'optional', status: 'active|resolved|superseded', evidenceIds: ['optional'] }],
@@ -298,21 +297,6 @@ export function buildWorkingStatePatchPrompt(input: WorkingStateExtractionInput)
     }),
     '',
     `source: ${JSON.stringify(cleanText(input.source, 80) || 'chat')}`,
-    `mission: ${JSON.stringify(input.mission ? {
-      id: input.mission.id,
-      objective: cleanMultiline(input.mission.objective, 600),
-      status: input.mission.status,
-      phase: input.mission.phase,
-      currentStep: cleanText(input.mission.currentStep, 240) || null,
-      plannerSummary: cleanText(input.mission.plannerSummary, 280) || null,
-      verifierSummary: cleanText(input.mission.verifierSummary, 280) || null,
-      blockerSummary: cleanText(input.mission.blockerSummary, 240) || null,
-      waitState: input.mission.waitState ? {
-        kind: input.mission.waitState.kind,
-        reason: cleanText(input.mission.waitState.reason, 240),
-        approvalId: cleanText(input.mission.waitState.approvalId, 120) || null,
-      } : null,
-    } : null)}`,
     `current_state:\n${renderStateForExtraction(input.currentState)}`,
     `user_message: ${JSON.stringify(cleanMultiline(input.message, 1200) || null)}`,
     `assistant_text: ${JSON.stringify(cleanMultiline(input.assistantText, 1200) || null)}`,
@@ -398,7 +382,6 @@ export function deterministicEvidencePatch(input: WorkingStateDeterministicUpdat
       value: input.runId,
       runId: input.runId,
       sessionId: input.sessionId,
-      missionId: input.mission?.id || null,
       createdAt: nowTs,
     })
   }
@@ -420,7 +403,6 @@ export function deterministicEvidencePatch(input: WorkingStateDeterministicUpdat
         toolCallId: cleanText(event.toolCallId, 120) || null,
         runId: input.runId || null,
         sessionId: input.sessionId,
-        missionId: input.mission?.id || null,
         createdAt: nowTs + index,
       })
 
@@ -428,7 +410,7 @@ export function deterministicEvidencePatch(input: WorkingStateDeterministicUpdat
         blockersUpsert.push({
           summary: output || `Tool ${toolName} failed.`,
           kind: 'error',
-          nextAction: cleanText(input.mission?.currentStep, 240) || null,
+          nextAction: null,
           status: 'active',
           evidenceIds: [evidenceId],
         })
@@ -521,7 +503,6 @@ export function deterministicEvidencePatch(input: WorkingStateDeterministicUpdat
       value: cleanText(input.error, 240) || null,
       runId: input.runId || null,
       sessionId: input.sessionId,
-      missionId: input.mission?.id || null,
       createdAt: nowTs + 100,
     })
     blockersUpsert.push({
@@ -531,26 +512,11 @@ export function deterministicEvidencePatch(input: WorkingStateDeterministicUpdat
     })
   }
 
-  if (input.mission) {
-    evidenceAppend.push({
-      id: genId(12),
-      type: 'mission',
-      summary: `Mission state updated: ${input.mission.status}/${input.mission.phase}.`,
-      value: cleanText(input.mission.currentStep || input.mission.objective, 240) || null,
-      runId: input.runId || null,
-      sessionId: input.sessionId,
-      missionId: input.mission.id,
-      createdAt: nowTs + 200,
-    })
-  }
-
   return {
     status: input.error
       ? 'blocked'
-      : input.mission
-        ? missionStatusToWorkingStateStatus(input.mission)
-        : undefined,
-    nextAction: cleanText(input.mission?.currentStep, 240) || undefined,
+      : undefined,
+    nextAction: undefined,
     factsUpsert: factsUpsert.length > 0 ? factsUpsert : undefined,
     artifactsUpsert: artifactsUpsert.length > 0 ? artifactsUpsert : undefined,
     blockersUpsert: blockersUpsert.length > 0 ? blockersUpsert : undefined,
@@ -608,7 +574,7 @@ export function shouldExtractStructuredPatch(input: SynchronizeWorkingStateForTu
   const hasAssistantText = cleanMultiline(input.assistantText, 400).length > 0
   const hasError = cleanText(input.error, 120).length > 0
   if (cleanText(input.source, 80) === 'heartbeat') {
-    return hasToolEvents || hasError || Boolean(input.mission)
+    return hasToolEvents || hasError
   }
-  return hasToolEvents || hasAssistantText || hasMessage || hasError || Boolean(input.mission)
+  return hasToolEvents || hasAssistantText || hasMessage || hasError
 }