@swarmclawai/swarmclaw 1.2.6 → 1.2.9

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
 }

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

@@ -4,7 +4,6 @@ import { genId } from '@/lib/id'
 import { cleanText, cleanMultiline, normalizeList } from '@/lib/server/text-normalization'
 import type {
   EvidenceRef,
-  Mission,
   SessionWorkingState,
   WorkingArtifact,
   WorkingArtifactPatch,
@@ -56,7 +55,7 @@ export const WorkingPlanStepPatchSchema = z.object({
 export const WorkingFactPatchSchema = z.object({
   id: z.string().optional().nullable(),
   statement: z.string().optional().nullable(),
-  source: z.enum(['user', 'tool', 'assistant', 'mission', 'system']).optional().nullable(),
+  source: z.enum(['user', 'tool', 'assistant', 'system']).optional().nullable(),
   status: WorkingItemStatusSchema.optional().nullable(),
   evidenceIds: z.array(z.string()).optional().nullable(),
 })
@@ -150,7 +149,6 @@ import type { MessageToolEvent } from '@/types'
 
 export interface WorkingStateDeterministicUpdateInput {
   sessionId: string
-  mission?: Mission | null
   message?: string | null
   assistantText?: string | null
   error?: string | null
@@ -233,7 +231,6 @@ export function normalizeEvidenceRef(input: unknown): EvidenceRef | null {
   if (!summary) return null
   const type = record.type === 'tool'
     || record.type === 'message'
-    || record.type === 'mission'
     || record.type === 'task'
     || record.type === 'artifact'
     || record.type === 'error'
@@ -249,7 +246,6 @@ export function normalizeEvidenceRef(input: unknown): EvidenceRef | null {
     toolCallId: cleanText(record.toolCallId, 120) || null,
     runId: cleanText(record.runId, 120) || null,
     sessionId: cleanText(record.sessionId, 120) || null,
-    missionId: cleanText(record.missionId, 120) || null,
     taskId: cleanText(record.taskId, 120) || null,
     createdAt: typeof record.createdAt === 'number' && Number.isFinite(record.createdAt)
       ? Math.trunc(record.createdAt)
@@ -290,7 +286,6 @@ export function normalizeFact(input: unknown): WorkingFact | null {
     source: record.source === 'user'
       || record.source === 'tool'
       || record.source === 'assistant'
-      || record.source === 'mission'
       || record.source === 'system'
       ? record.source
       : 'assistant',
@@ -434,17 +429,16 @@ export function normalizeMatchKey(value: string): string {
 // defaultWorkingState & normalizeWorkingState
 // ---------------------------------------------------------------------------
 
-export function defaultWorkingState(sessionId: string, mission?: Mission | null): SessionWorkingState {
+export function defaultWorkingState(sessionId: string): SessionWorkingState {
   const nowTs = now()
   return {
     sessionId,
-    missionId: mission?.id || null,
-    objective: cleanMultiline(mission?.objective, 900) || null,
-    summary: cleanMultiline(mission?.verifierSummary || mission?.plannerSummary, 600) || null,
+    objective: null,
+    summary: null,
     constraints: [],
-    successCriteria: normalizeList(mission?.successCriteria, 12, 240),
-    status: mission ? missionStatusToWorkingStateStatus(mission) : 'idle',
-    nextAction: cleanText(mission?.currentStep, 240) || null,
+    successCriteria: [],
+    status: 'idle',
+    nextAction: null,
     planSteps: [],
     confirmedFacts: [],
     artifacts: [],
@@ -462,19 +456,17 @@ export function defaultWorkingState(sessionId: string, mission?: Mission | null)
 export function normalizeWorkingState(
   input: unknown,
   sessionId: string,
-  mission?: Mission | null,
 ): SessionWorkingState {
   if (!input || typeof input !== 'object' || Array.isArray(input)) {
-    return defaultWorkingState(sessionId, mission)
+    return defaultWorkingState(sessionId)
   }
   const record = input as Record<string, unknown>
-  const base = defaultWorkingState(sessionId, mission)
+  const base = defaultWorkingState(sessionId)
   const createdAt = typeof record.createdAt === 'number' && Number.isFinite(record.createdAt)
     ? Math.trunc(record.createdAt)
     : base.createdAt
   const normalized: SessionWorkingState = {
     sessionId: cleanText(record.sessionId, 120) || sessionId,
-    missionId: cleanText(record.missionId, 120) || mission?.id || null,
     objective: cleanMultiline(record.objective, 900) || base.objective,
     summary: cleanMultiline(record.summary, 600) || base.summary,
     constraints: normalizeList(record.constraints, 12, 240),
@@ -497,7 +489,7 @@ export function normalizeWorkingState(
       ? Math.trunc(record.lastCompactedAt)
       : null,
   }
-  return compactWorkingStateObject(syncWorkingStateWithMission(normalized, mission))
+  return compactWorkingStateObject(normalized)
 }
 
 // ---------------------------------------------------------------------------
@@ -522,89 +514,6 @@ export function compactWorkingStateObject(state: SessionWorkingState): SessionWo
 }
 
 // ---------------------------------------------------------------------------
-// missionStatusToWorkingStateStatus & syncWorkingStateWithMission
-// ---------------------------------------------------------------------------
-
-export function missionStatusToWorkingStateStatus(mission: Mission): WorkingStateStatus {
-  if (mission.status === 'completed') return 'completed'
-  if (mission.status === 'waiting') return 'waiting'
-  if (mission.status === 'failed' || mission.status === 'cancelled') return 'blocked'
-  return 'progress'
-}
-
-export function syncWorkingStateWithMission(
-  state: SessionWorkingState,
-  mission?: Mission | null,
-): SessionWorkingState {
-  if (!mission) return state
-  const next = { ...state }
-  next.missionId = mission.id
-  next.objective = cleanMultiline(mission.objective, 900) || next.objective
-  next.successCriteria = normalizeList(mission.successCriteria, 12, 240)
-  next.summary = next.summary || cleanMultiline(mission.verifierSummary || mission.plannerSummary, 600) || null
-  const missionStatus = missionStatusToWorkingStateStatus(mission)
-  if (missionStatus === 'completed' || missionStatus === 'waiting' || missionStatus === 'blocked') {
-    next.status = missionStatus
-  } else if (next.status === 'idle') {
-    next.status = missionStatus
-  }
-  next.nextAction = next.nextAction || cleanText(mission.currentStep, 240) || null
-
-  if (mission.currentStep) {
-    next.planSteps = upsertItems(next.planSteps, [{
-      id: null,
-      text: mission.currentStep,
-      status: mission.status === 'completed' ? 'resolved' : 'active',
-    } satisfies WorkingPlanStepPatch], {
-      max: MAX_PLAN_STEPS,
-      getPatchId: (patch) => cleanText(patch.id, 120) || null,
-      getPatchKey: (patch) => cleanText(patch.text, 240),
-      getItemKey: (item) => item.text,
-      create: (patch, nowTs) => ({
-        id: genId(12),
-        text: cleanText(patch.text, 240),
-        status: normalizeItemStatus(patch.status),
-        createdAt: nowTs,
-        updatedAt: nowTs,
-      }),
-      merge: (current, patch, nowTs) => ({
-        ...current,
-        text: cleanText(patch.text, 240) || current.text,
-        status: normalizeItemStatus(patch.status, current.status),
-        updatedAt: nowTs,
-      }),
-      compact: compactPlanSteps,
-    })
-  }
-
-  if (mission.waitState?.reason || mission.blockerSummary) {
-    const blockerSummary = cleanText(mission.waitState?.reason || mission.blockerSummary, 280)
-    if (blockerSummary) {
-      next.blockers = upsertItems(next.blockers, [{
-        summary: blockerSummary,
-        kind: mission.waitState?.kind === 'approval'
-          ? 'approval'
-          : mission.waitState?.kind === 'human_reply'
-            ? 'human_input'
-            : mission.waitState?.kind === 'external_dependency' || mission.waitState?.kind === 'provider'
-              ? 'external_dependency'
-              : mission.status === 'failed'
-                ? 'error'
-                : 'other',
-        nextAction: mission.currentStep || null,
-        status: mission.status === 'completed' ? 'resolved' : 'active',
-      }], blockerUpsertConfig())
-    }
-  }
-
-  if (mission.status === 'completed') {
-    next.blockers = next.blockers.map((blocker) => blocker.status === 'active'
-      ? { ...blocker, status: 'resolved', updatedAt: now() }
-      : blocker)
-  }
-
-  return next
-}
 
 // ---------------------------------------------------------------------------
 // upsertItems & upsertConfig factories
@@ -647,7 +556,6 @@ export function factUpsertConfig(): UpsertConfig<WorkingFact, WorkingFactPatch>
       source: patch.source === 'user'
         || patch.source === 'tool'
         || patch.source === 'assistant'
-        || patch.source === 'mission'
         || patch.source === 'system'
         ? patch.source
         : 'assistant',
@@ -662,7 +570,6 @@ export function factUpsertConfig(): UpsertConfig<WorkingFact, WorkingFactPatch>
       source: patch.source === 'user'
         || patch.source === 'tool'
         || patch.source === 'assistant'
-        || patch.source === 'mission'
         || patch.source === 'system'
         ? patch.source
         : current.source,

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

@@ -1,7 +1,6 @@
 import { genId } from '@/lib/id'
 import { cleanText, cleanMultiline, normalizeList } from '@/lib/server/text-normalization'
 import type {
-  Mission,
   SessionWorkingState,
   WorkingBlocker,
   WorkingPlanStepPatch,
@@ -20,7 +19,6 @@ import {
   normalizeWorkingState,
   defaultWorkingState,
   compactWorkingStateObject,
-  syncWorkingStateWithMission,
   normalizeItemStatus,
   normalizeStateStatus,
   upsertItems,
@@ -96,8 +94,6 @@ export {
   compactPlanSteps,
   defaultWorkingState,
   compactWorkingStateObject,
-  missionStatusToWorkingStateStatus,
-  syncWorkingStateWithMission,
   // Upsert
   upsertItems,
   factUpsertConfig,
@@ -142,14 +138,14 @@ export { buildWorkingStatePromptBlockFromState } from '@/lib/server/working-stat
 // CRUD / coordination layer
 // ---------------------------------------------------------------------------
 
-export function loadSessionWorkingState(sessionId: string, options?: { mission?: Mission | null }): SessionWorkingState | null {
+export function loadSessionWorkingState(sessionId: string): SessionWorkingState | null {
   const stored = loadPersistedWorkingState(sessionId)
-  if (!stored && !options?.mission) return null
-  return normalizeWorkingState(stored, sessionId, options?.mission || null)
+  if (!stored) return null
+  return normalizeWorkingState(stored, sessionId)
 }
 
-export function getOrCreateSessionWorkingState(sessionId: string, options?: { mission?: Mission | null }): SessionWorkingState {
-  return loadSessionWorkingState(sessionId, options) || defaultWorkingState(sessionId, options?.mission || null)
+export function getOrCreateSessionWorkingState(sessionId: string): SessionWorkingState {
+  return loadSessionWorkingState(sessionId) || defaultWorkingState(sessionId)
 }
 
 export function saveSessionWorkingState(state: SessionWorkingState): SessionWorkingState {
@@ -165,12 +161,10 @@ export function deleteSessionWorkingState(sessionId: string): void {
 export function applyWorkingStatePatch(
   sessionId: string,
   patch: WorkingStatePatch,
-  options?: { mission?: Mission | null },
 ): SessionWorkingState {
-  const current = getOrCreateSessionWorkingState(sessionId, options)
+  const current = getOrCreateSessionWorkingState(sessionId)
   const next: SessionWorkingState = {
     ...current,
-    missionId: options?.mission?.id || current.missionId || null,
     objective: patch.objective !== undefined ? (cleanMultiline(patch.objective, 900) || null) : current.objective,
     summary: patch.summary !== undefined ? (cleanMultiline(patch.summary, 600) || null) : current.summary,
     constraints: patch.constraints !== undefined ? normalizeList(patch.constraints, 12, 240) : current.constraints,
@@ -215,16 +209,15 @@ export function applyWorkingStatePatch(
   next.openQuestions = markSuperseded(next.openQuestions, patch.supersedeIds)
   next.hypotheses = markSuperseded(next.hypotheses, patch.supersedeIds)
 
-  const synced = compactWorkingStateObject(syncWorkingStateWithMission(next, options?.mission || null))
-  upsertPersistedWorkingState(sessionId, synced as unknown as Record<string, unknown>)
-  return synced
+  const compacted = compactWorkingStateObject(next)
+  upsertPersistedWorkingState(sessionId, compacted as unknown as Record<string, unknown>)
+  return compacted
 }
 
 export function recordWorkingStateEvidence(input: WorkingStateDeterministicUpdateInput): SessionWorkingState {
   return applyWorkingStatePatch(
     input.sessionId,
     deterministicEvidencePatch(input),
-    { mission: input.mission || null },
   )
 }
 
@@ -241,12 +234,11 @@ export async function synchronizeWorkingStateForTurn(
     currentState: deterministic,
   }, options)
   if (!patch) return deterministic
-  return applyWorkingStatePatch(input.sessionId, patch, { mission: input.mission || null })
+  return applyWorkingStatePatch(input.sessionId, patch)
 }
 
 export function syncWorkingStateFromMainLoopState(input: {
   sessionId: string
-  mission?: Mission | null
   goal?: string | null
   summary?: string | null
   status?: WorkingStateStatus | null
@@ -281,13 +273,12 @@ export function syncWorkingStateFromMainLoopState(input: {
         status: (input.status === 'completed' ? 'resolved' : 'active') as WorkingStateItemStatus,
       })).filter((fact) => fact.statement)
       : undefined,
-  }, { mission: input.mission || null })
+  })
 }
 
 export function buildWorkingStatePromptBlock(
   sessionId: string,
-  options?: { mission?: Mission | null },
 ): string {
-  const state = loadSessionWorkingState(sessionId, options)
+  const state = loadSessionWorkingState(sessionId)
   return buildWorkingStatePromptBlockFromState(state)
 }

package/src/lib/setup-defaults.ts

@@ -204,6 +204,7 @@ export const SETUP_PROVIDERS: SetupProviderOption[] = [
 export const STARTER_AGENT_TOOLS = [
   'memory',
   'files',
+  'execute',
   'web_search',
   'web_fetch',
   'browser',
@@ -363,6 +364,7 @@ export interface StarterKit {
 const PERSONAL_AGENT_TOOLS = [
   'memory',
   'files',
+  'execute',
   'web_search',
   'web_fetch',
   'browser',
@@ -374,6 +376,7 @@ const PERSONAL_AGENT_TOOLS = [
 const RESEARCH_AGENT_TOOLS = [
   'memory',
   'files',
+  'execute',
   'web_search',
   'web_fetch',
   'browser',
@@ -384,6 +387,7 @@ const RESEARCH_AGENT_TOOLS = [
 const BUILDER_AGENT_TOOLS = [
   'memory',
   'files',
+  'execute',
   'web_search',
   'web_fetch',
   'browser',
@@ -397,6 +401,7 @@ const OPERATOR_AGENT_TOOLS = STARTER_AGENT_TOOLS
 const OPENCLAW_AGENT_TOOLS = [
   'memory',
   'files',
+  'execute',
   'web_search',
   'web_fetch',
   'browser',

package/src/lib/strip-internal-metadata.test.ts

@@ -31,7 +31,7 @@ describe('stripInternalJson', () => {
   })
 
   it('removes JSON with nested objects when internal keys are present', () => {
-    const input = '{ "walletIntent": "send", "details": { "amount": 100 } }'
+    const input = '{ "isDeliverableTask": true, "details": { "amount": 100 } }'
     assert.equal(stripInternalJson(input).trim(), '')
   })
 

package/src/lib/strip-internal-metadata.ts

@@ -15,7 +15,7 @@
 // ---------------------------------------------------------------------------
 
 const INTERNAL_JSON_KEYS = [
-  'isDeliverableTask', 'quality_score', 'isBroadGoal', 'walletIntent',
+  'isDeliverableTask', 'quality_score', 'isBroadGoal',
   'hasHumanSignals', 'explicitToolRequests', 'isResearchSynthesis', 'confidence',
 ]
 

package/src/lib/tool-definitions.ts

@@ -16,13 +16,13 @@ export interface ToolDefinition {
  */
 export const AVAILABLE_TOOLS: ToolDefinition[] = [
   { id: 'shell', label: 'Shell', description: 'Execute commands in the working directory and manage background processes' },
+  { id: 'execute', label: 'Execute', description: 'Run sandboxed bash scripts with just-bash, with optional host execution when explicitly enabled' },
   { id: 'files', label: 'Files', description: 'Complete file management: read, write, list, move, copy, delete, and send' },
   { id: 'edit_file', label: 'Edit File', description: 'Surgical search-and-replace within files' },
   { id: 'web', label: 'Web', description: 'Search the web, fetch content, and make HTTP API calls' },
   { id: 'delegate', label: 'Delegate', description: 'Delegate complex tasks to specialized backends (Claude Code, Codex, OpenCode)' },
   { id: 'browser', label: 'Browser', description: 'Playwright — browse, scrape, interact with web pages' },
   { id: 'memory', label: 'Memory', description: 'Store and retrieve long-term memories across conversations' },
-  { id: 'wallet', label: 'Wallet', description: 'Manage agent crypto wallet — check balance, send SOL, view transactions', extensionId: 'wallet' },
   { id: 'monitor', label: 'Monitor', description: 'Durable watch jobs: monitor files, endpoints, tasks, and resume agents on triggers' },
   { id: 'extension_creator', label: 'Extension Creator', description: 'Design focused extensions for durable capabilities and recurring automations' },
   { id: 'image_gen', label: 'Image Generation', description: 'Generate images from text prompts using OpenAI, Stability AI, Replicate, fal.ai, and more', extensionId: 'image_gen' },

package/src/lib/validation/schemas.test.ts

@@ -57,4 +57,20 @@ describe('AgentCreateSchema', () => {
     assert.equal(parsed.orchestratorMaxCyclesPerDay, 12)
     assert.equal(parsed.sessionResetMode, 'isolated')
   })
+
+  it('accepts executeConfig for sandboxed execute defaults', () => {
+    const parsed = AgentCreateSchema.parse({
+      name: 'Builder',
+      provider: 'openai',
+      executeConfig: {
+        backend: 'sandbox',
+        network: { enabled: true },
+        timeout: 45,
+      },
+    })
+
+    assert.equal(parsed.executeConfig?.backend, 'sandbox')
+    assert.equal(parsed.executeConfig?.network?.enabled, true)
+    assert.equal(parsed.executeConfig?.timeout, 45)
+  })
 })