@swarmclawai/swarmclaw 1.2.8 → 1.2.9

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/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

@@ -23,7 +23,6 @@ export const AVAILABLE_TOOLS: ToolDefinition[] = [
   { 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.ts

@@ -137,7 +137,7 @@ export const ConnectorCreateSchema = z.object({
   name: z.string().min(1, 'Connector name is required').optional(),
   platform: z.enum([
     'discord', 'telegram', 'slack', 'whatsapp', 'openclaw',
-    'bluebubbles', 'signal', 'teams', 'googlechat', 'matrix', 'email',
+    'bluebubbles', 'signal', 'teams', 'googlechat', 'matrix', 'email', 'swarmdock',
   ]),
   agentId: z.string().nullable().optional().default(null),
   chatroomId: z.string().nullable().optional().default(null),
@@ -396,7 +396,6 @@ export const ProtocolRunCreateSchema = z.object({
   participantAgentIds: z.array(z.string()).min(1, 'Select at least one participant').default([]),
   facilitatorAgentId: z.string().nullable().optional().default(null),
   observerAgentIds: z.array(z.string()).optional().default([]),
-  missionId: z.string().nullable().optional().default(null),
   taskId: z.string().nullable().optional().default(null),
   sessionId: z.string().nullable().optional().default(null),
   parentChatroomId: z.string().nullable().optional().default(null),
@@ -473,6 +472,38 @@ export const ProtocolRunActionSchema = z.object({
   workItemId: z.string().nullable().optional().default(null),
 })
 
+const PortableAgentSchema = z.object({
+  originalId: z.string().min(1),
+  name: z.string().min(1),
+  description: z.string(),
+  systemPrompt: z.string(),
+  provider: z.string().min(1),
+  model: z.string().min(1),
+  createdAt: z.number().optional(),
+  updatedAt: z.number().optional(),
+  skillIds: z.array(z.string()).optional(),
+}).passthrough()
+
+const PortableSkillSchema = z.object({
+  originalId: z.string().min(1),
+  name: z.string().min(1),
+  content: z.string(),
+}).passthrough()
+
+const PortableScheduleSchema = z.object({
+  originalId: z.string().min(1),
+  originalAgentId: z.string().min(1),
+  name: z.string().min(1),
+}).passthrough()
+
+export const PortableManifestSchema = z.object({
+  formatVersion: z.number().int().nonnegative(),
+  exportedAt: z.string().optional(),
+  agents: z.array(PortableAgentSchema),
+  skills: z.array(PortableSkillSchema),
+  schedules: z.array(PortableScheduleSchema),
+})
+
 /** Format ZodError into a 400-friendly payload */
 export function formatZodError(err: z.ZodError) {
   return { error: 'Validation failed', issues: err.issues.map((i) => ({ path: i.path.join('.'), message: i.message })) }

package/src/stores/slices/data-slice.ts

@@ -1,6 +1,6 @@
 import { StateCreator } from 'zustand'
 import type { AppState } from '../use-app-store'
-import type { NetworkInfo, Directory, ProviderInfo, Credentials, Schedule, AppSettings, StoredSecret, ProviderConfig, Skill, Connector, Webhook, McpServerConfig, ExtensionMeta, Project, ActivityEntry, AppNotification, GatewayProfile } from '../../types'
+import type { NetworkInfo, Directory, ProviderInfo, Credentials, Schedule, AppSettings, StoredSecret, ProviderConfig, Skill, Connector, Webhook, McpServerConfig, ExtensionMeta, Project, ActivityEntry, AppNotification, GatewayProfile, SafeWallet } from '../../types'
 import { api } from '@/lib/app/api-client'
 import { safeStorageGetJson, safeStorageSet } from '@/lib/app/safe-storage'
 import { fetchDirs, fetchProviders, fetchCredentials } from '@/lib/chat/chats'
@@ -24,6 +24,8 @@ export interface DataSlice {
   updateSettings: (patch: Partial<AppSettings>) => Promise<void>
   secrets: Record<string, StoredSecret>
   loadSecrets: () => Promise<void>
+  wallets: Record<string, SafeWallet>
+  loadWallets: () => Promise<void>
   providerConfigs: ProviderConfig[]
   loadProviderConfigs: () => Promise<void>
   gatewayProfiles: GatewayProfile[]
@@ -78,6 +80,8 @@ export const createDataSlice: StateCreator<AppState, [], [], DataSlice> = (set,
   },
   secrets: {},
   loadSecrets: createLoader<AppState>(set, 'secrets', () => api<Record<string, StoredSecret>>('GET', '/secrets'), {}),
+  wallets: {},
+  loadWallets: createLoader<AppState>(set, 'wallets', () => api<Record<string, SafeWallet>>('GET', '/wallets'), {}),
   providerConfigs: [],
   loadProviderConfigs: createLoader<AppState>(set, 'providerConfigs', () => api<ProviderConfig[]>('GET', '/providers/configs'), []),
   gatewayProfiles: [],

package/src/stores/slices/ui-slice.ts

@@ -95,8 +95,6 @@ export interface UiSlice {
   setFleetFilter: (filter: FleetFilter) => void
   chatFilter: 'all' | 'active' | 'recent'
   setChatFilter: (filter: 'all' | 'active' | 'recent') => void
-  walletPanelAgentId: string | null
-  setWalletPanelAgentId: (id: string | null) => void
   heartbeatHistoryOpen: boolean
   setHeartbeatHistoryOpen: (open: boolean) => void
   agentPrefill: Partial<Agent> | null
@@ -195,8 +193,6 @@ export const createUiSlice: StateCreator<AppState, [], [], UiSlice> = (set, get)
   setFleetFilter: (filter) => { safeStorageSet('sc_fleet_filter', filter); set({ fleetFilter: filter }) },
   chatFilter: 'all' as const,
   setChatFilter: (filter) => set({ chatFilter: filter }),
-  walletPanelAgentId: null,
-  setWalletPanelAgentId: (id) => set({ walletPanelAgentId: id }),
   heartbeatHistoryOpen: false,
   setHeartbeatHistoryOpen: (open) => set({ heartbeatHistoryOpen: open }),
   agentPrefill: null,

package/src/types/agent.ts

@@ -83,10 +83,6 @@ export interface Agent {
   trashedAt?: number
   openclawSkillMode?: SkillAllowlistMode
   openclawAllowedSkills?: string[]
-  walletIds?: string[]
-  activeWalletId?: string | null
-  /** @deprecated Use walletIds + activeWalletId */
-  walletId?: string | null
   responseStyle?: 'concise' | 'normal' | 'detailed' | null
   responseMaxChars?: number | null
   monthlyBudget?: number | null
@@ -171,86 +167,6 @@ export interface Agent {
   updatedAt: number
 }
 
-// --- Agent Wallets ---
-
-export type WalletChain = 'solana' | 'ethereum'
-
-export interface AgentWallet {
-  id: string
-  agentId: string
-  chain: WalletChain
-  publicKey: string
-  encryptedPrivateKey: string       // AES-256-GCM via encryptKey()
-  label?: string
-  spendingLimitAtomic?: string
-  dailyLimitAtomic?: string
-  /** @deprecated Use spendingLimitAtomic */
-  spendingLimitLamports?: number
-  /** @deprecated Use dailyLimitAtomic */
-  dailyLimitLamports?: number
-  requireApproval: boolean          // default true; can be globally overridden by app settings
-  createdAt: number
-  updatedAt: number
-}
-
-export interface WalletAssetBalance {
-  id: string
-  chain: WalletChain
-  networkId: string
-  networkLabel: string
-  symbol: string
-  name?: string
-  decimals: number
-  balanceAtomic: string
-  balanceFormatted?: string
-  balanceDisplay?: string
-  isNative: boolean
-  contractAddress?: string
-  tokenMint?: string
-  explorerUrl?: string
-}
-
-export interface WalletPortfolioSummary {
-  totalAssets: number
-  nonZeroAssets: number
-  tokenAssets: number
-  networkCount: number
-}
-
-export type WalletTransactionType = 'send' | 'receive' | 'swap'
-export type WalletTransactionStatus = 'pending_approval' | 'pending' | 'confirmed' | 'failed' | 'denied'
-
-export interface WalletTransaction {
-  id: string
-  walletId: string
-  agentId: string
-  chain: WalletChain
-  type: WalletTransactionType
-  signature: string
-  fromAddress: string
-  toAddress: string
-  amountAtomic?: string
-  feeAtomic?: string
-  /** @deprecated Use amountAtomic */
-  amountLamports?: number
-  /** @deprecated Use feeAtomic */
-  feeLamports?: number
-  status: WalletTransactionStatus
-  memo?: string                     // agent's reason for tx
-  approvedBy?: 'user' | 'auto'
-  tokenMint?: string                // null = native chain asset
-  timestamp: number
-}
-
-export interface WalletBalanceSnapshot {
-  id: string
-  walletId: string
-  balanceAtomic?: string
-  /** @deprecated Use balanceAtomic */
-  balanceLamports?: number
-  timestamp: number
-}
-
 export type AgentTool = 'browser'
 
 export interface ClaudeSkill {

package/src/types/app-settings.ts

@@ -73,7 +73,6 @@ export interface AppSettings {
   safetyRequireApprovalForOutbound?: boolean
   safetyMaxDailySpendUsd?: number | null
   safetyBlockedTools?: string[]
-  walletApprovalsEnabled?: boolean
   capabilityPolicyMode?: 'permissive' | 'balanced' | 'strict'
   capabilityBlockedTools?: string[]
   capabilityBlockedCategories?: string[]
@@ -96,7 +95,6 @@ export interface AppSettings {
   supervisorNoProgressLimit?: number
   supervisorRepeatedToolLimit?: number
   autonomyResumeApprovalsEnabled?: boolean
-  missionHumanLoopEnabled?: boolean
   reflectionEnabled?: boolean
   reflectionAutoWriteMemory?: boolean
   memoryReferenceDepth?: number

package/src/types/approval.ts

@@ -2,8 +2,6 @@
 
 export type ApprovalCategory =
   | 'tool_access'
-  | 'wallet_transfer'
-  | 'wallet_action'
   | 'extension_scaffold'
   | 'extension_install'
   | 'task_tool'

package/src/types/connector.ts

@@ -28,6 +28,7 @@ export type ConnectorPlatform =
   | 'email'
   | 'webchat'
   | 'mockmail'
+  | 'swarmdock'
 export type ConnectorStatus = 'stopped' | 'running' | 'error'
 
 export interface MessageSource {

package/src/types/index.ts

@@ -2,7 +2,6 @@ export * from './message'
 export * from './session'
 export * from './agent'
 export * from './working-state'
-export * from './mission'
 export * from './extension'
 export * from './connector'
 export * from './provider'
@@ -14,3 +13,4 @@ export * from './skill'
 export * from './run'
 export * from './approval'
 export * from './misc'
+export * from './swarmdock'

package/src/types/message.ts

@@ -15,7 +15,6 @@ export type MessageWorkType = 'coding' | 'research' | 'writing' | 'review' | 'op
 export interface MessageSemanticsSummary {
   taskIntent: MessageTaskIntent
   workType: MessageWorkType
-  walletIntent: 'none' | 'read_only' | 'transactional'
   isDeliverableTask: boolean
   isBroadGoal: boolean
   isResearchSynthesis: boolean

package/src/types/misc.ts

@@ -388,8 +388,6 @@ export interface DelegationJobRecord {
   kind: DelegationJobKind
   status: DelegationJobStatus
   backend?: 'claude' | 'codex' | 'opencode' | 'gemini' | null
-  missionId?: string | null
-  parentMissionId?: string | null
   parentSessionId?: string | null
   childSessionId?: string | null
   agentId?: string | null

package/src/types/protocol.ts

@@ -122,7 +122,6 @@ export type ProtocolSourceRef =
   | { kind: 'api' }
   | { kind: 'session'; sessionId: string }
   | { kind: 'chatroom'; chatroomId: string }
-  | { kind: 'mission'; missionId: string }
   | { kind: 'task'; taskId: string }
   | { kind: 'schedule'; scheduleId: string }
   | { kind: 'protocol_run'; runId: string; parentRunId?: string | null; stepId?: string | null; branchId?: string | null }
@@ -319,7 +318,6 @@ export interface ProtocolRun {
   participantAgentIds: string[]
   facilitatorAgentId?: string | null
   observerAgentIds?: string[]
-  missionId?: string | null
   taskId?: string | null
   sessionId?: string | null
   parentRunId?: string | null

package/src/types/run.ts

@@ -17,7 +17,6 @@ export type ExecutionOwnerType =
   | 'task'
   | 'protocol_run'
   | 'schedule'
-  | 'mission'
   | 'agent'
   | 'subagent'
 
@@ -48,7 +47,6 @@ export interface SessionRunRecoveryPayload {
 export interface SessionRunRecord {
   id: string
   sessionId: string
-  missionId?: string | null
   kind?: ExecutionKind
   ownerType?: ExecutionOwnerType | null
   ownerId?: string | null
@@ -78,7 +76,6 @@ export interface SessionRunRecord {
 export interface SessionQueuedTurn {
   runId: string
   sessionId: string
-  missionId?: string | null
   text: string
   queuedAt: number
   position: number