@swarmclawai/swarmclaw 1.2.6 → 1.2.9

package/src/lib/server/session-tools/shell.ts

@@ -10,9 +10,7 @@ import {
   removeManagedProcess,
   startManagedProcess,
   writeManagedProcessStdin,
-  type SandboxOptions,
 } from '@/lib/server/runtime/process-manager'
-import { ensureSessionSandbox, resolveSandboxWorkdir, type AgentSandboxConfig } from '@/lib/server/sandbox/session-runtime'
 import type { ToolBuildContext } from './context'
 import { safePath, truncate, coerceEnvMap, MAX_OUTPUT } from './context'
 import { checkFileAccess } from './file-access-policy'
@@ -21,7 +19,6 @@ import { registerNativeCapability } from '../native-capabilities'
 import { safeJsonParseObject } from '../json-utils'
 import { normalizeToolInputArgs } from './normalize-tool-args'
 import { errorMessage } from '@/lib/shared-utils'
-import { executeSandboxExec, executeListRuntimes, type SandboxContext } from './sandbox'
 
 function resolveShellWorkdir(baseCwd: string, requestedWorkdir?: string, scope?: 'workspace' | 'machine'): string {
   const raw = typeof requestedWorkdir === 'string' ? requestedWorkdir.trim() : ''
@@ -43,12 +40,6 @@ export function rewriteShellWorkspaceAliases(baseCwd: string, command: string):
   return rewritten
 }
 
-export function rewriteShellWorkspaceAliasesForSandbox(command: string): string {
-  let rewritten = command
-  rewritten = rewritten.replace(/(^|[\s"'`(=;])workspace\//g, '$1/workspace/')
-  return rewritten
-}
-
 export function stripManagedBackgroundSuffix(command: string): string {
   return command.replace(/\s*&\s*$/, '').trim()
 }
@@ -193,60 +184,6 @@ function checkShellFileAccessPolicy(
   return null
 }
 
-async function resolveSandboxOptions(params: {
-  cwd: string
-  workdir?: string
-  session?: Session | null
-  agentId?: string | null
-  sessionId?: string | null
-  env: Record<string, string>
-  config?: AgentSandboxConfig | null
-  filesystemScope?: 'workspace' | 'machine'
-}): Promise<{
-  sandbox?: SandboxOptions
-  hostWorkdir: string
-  workspaceEnv: string
-  sessionCwdEnv: string
-}> {
-  const hostWorkdir = resolveShellWorkdir(params.cwd, params.workdir, params.filesystemScope)
-  const sandboxSession = await ensureSessionSandbox({
-    config: params.config,
-    session: params.session,
-    agentId: params.agentId,
-    sessionId: params.sessionId,
-    workspaceDir: params.cwd,
-  })
-
-  if (!sandboxSession) {
-    return {
-      hostWorkdir,
-      workspaceEnv: params.cwd,
-      sessionCwdEnv: hostWorkdir,
-    }
-  }
-
-  const sandboxHostWorkdir = fs.existsSync(hostWorkdir) && fs.statSync(hostWorkdir).isDirectory()
-    ? hostWorkdir
-    : sandboxSession.workspaceDir
-  const resolved = resolveSandboxWorkdir({
-    workspaceDir: sandboxSession.workspaceDir,
-    hostWorkdir: sandboxHostWorkdir,
-    containerWorkdir: sandboxSession.containerWorkdir,
-  })
-
-  return {
-    hostWorkdir: resolved.hostWorkdir,
-    workspaceEnv: sandboxSession.containerWorkdir,
-    sessionCwdEnv: resolved.containerWorkdir,
-    sandbox: {
-      kind: 'persistent',
-      containerName: sandboxSession.containerName,
-      containerWorkdir: resolved.containerWorkdir,
-      env: params.env,
-    },
-  }
-}
-
 async function executeShellAction(
   args: Record<string, unknown>,
   bctx: {
@@ -255,7 +192,6 @@ async function executeShellAction(
     sessionId?: string | null
     resolveCurrentSession?: () => Session | null
     fileAccessPolicy?: { allowedPaths?: string[]; blockedPaths?: string[] } | null
-    sandboxConfig?: AgentSandboxConfig | null
     filesystemScope?: 'workspace' | 'machine'
     commandTimeoutMs?: number
   },
@@ -284,37 +220,11 @@ async function executeShellAction(
           return 'Error: This command would terminate the SwarmClaw server. Use a more targeted command that only affects your project processes.'
         }
         const envMap = coerceEnvMap(env) || {}
-        let sandbox: SandboxOptions | undefined
-        let hostWorkdir = resolveShellWorkdir(bctx.cwd, workdir, bctx.filesystemScope)
-        let commandForExecution = rewriteShellWorkspaceAliases(bctx.cwd, command)
-        let sandboxMode: 'container' | 'host' | 'host-fallback' = 'host'
-        try {
-          const resolved = await resolveSandboxOptions({
-            cwd: bctx.cwd,
-            workdir,
-            session: bctx.resolveCurrentSession?.() || null,
-            agentId: bctx.agentId || null,
-            sessionId: bctx.sessionId || null,
-            env: envMap,
-            config: bctx.sandboxConfig,
-            filesystemScope: bctx.filesystemScope,
-          })
-          sandbox = resolved.sandbox
-          hostWorkdir = resolved.hostWorkdir
-          if (!envMap.WORKSPACE) envMap.WORKSPACE = resolved.workspaceEnv
-          if (!envMap.SESSION_CWD) envMap.SESSION_CWD = resolved.sessionCwdEnv
-          if (sandbox) {
-            commandForExecution = rewriteShellWorkspaceAliasesForSandbox(command)
-            if (!envMap.HOME) envMap.HOME = resolved.sessionCwdEnv
-            if (!envMap.TMPDIR) envMap.TMPDIR = '/tmp'
-            sandboxMode = 'container'
-          }
-        } catch {
-          sandboxMode = 'host-fallback'
-        }
+        const hostWorkdir = resolveShellWorkdir(bctx.cwd, workdir, bctx.filesystemScope)
+        const commandForExecution = rewriteShellWorkspaceAliases(bctx.cwd, command)
         if (!envMap.WORKSPACE) envMap.WORKSPACE = bctx.cwd
         if (!envMap.SESSION_CWD) envMap.SESSION_CWD = hostWorkdir
-        if (!envMap.SWARMCLAW_SANDBOX_MODE) envMap.SWARMCLAW_SANDBOX_MODE = sandboxMode
+        if (!envMap.SWARMCLAW_SANDBOX_MODE) envMap.SWARMCLAW_SANDBOX_MODE = 'host'
         const effectiveBackground = !!background || (typeof commandForExecution === 'string' && isLikelyServerCommand(commandForExecution))
         const managedCommand = effectiveBackground ? stripManagedBackgroundSuffix(commandForExecution) : commandForExecution
         const result = await startManagedProcess({
@@ -329,7 +239,6 @@ async function executeShellAction(
             : effectiveBackground
               ? undefined          // let process-manager use DEFAULT_TIMEOUT_MS (30 min)
               : (bctx.commandTimeoutMs || 30000),
-          sandbox,
         })
         if (result.status === 'completed') return truncate(result.output || '(no output)', MAX_OUTPUT)
         return JSON.stringify({ status: 'running', processId: result.processId, tail: result.tail || '' }, null, 2)
@@ -344,27 +253,6 @@ async function executeShellAction(
         return killManagedProcess(processId!, killSignal).ok ? `Killed ${processId}` : `Error`
       }
       case 'remove': return removeManagedProcess(processId!).ok ? `Removed ${processId}` : `Error`
-      case 'sandbox_exec': {
-        const sandboxCtx: SandboxContext = {
-          sessionId: bctx.sessionId || undefined,
-          agentId: bctx.agentId || null,
-          cwd: bctx.cwd,
-          config: bctx.sandboxConfig,
-          resolveCurrentSession: bctx.resolveCurrentSession,
-        }
-        return executeSandboxExec(normalized, sandboxCtx)
-      }
-      case 'sandbox_list_runtimes':
-      case 'list_runtimes': {
-        const sandboxCtx: SandboxContext = {
-          sessionId: bctx.sessionId || undefined,
-          agentId: bctx.agentId || null,
-          cwd: bctx.cwd,
-          config: bctx.sandboxConfig,
-          resolveCurrentSession: bctx.resolveCurrentSession,
-        }
-        return executeListRuntimes(sandboxCtx)
-      }
       default: return `Error: Unknown action "${action}"`
     }
   } catch (err: unknown) {
@@ -379,22 +267,20 @@ const ShellExtension: Extension = {
   name: 'Core Shell',
   description: 'Execute shell commands and manage background processes. Use for git, curl, and other CLI tools.',
   hooks: {
-    getCapabilityDescription: () => 'I can run shell commands with the unified `shell` tool. Use action `execute` for commands (including git, curl, and other CLI tools), `sandbox_exec` to run JS/TS in a sandboxed environment, and `list` / `status` / `poll` / `log` for long-lived processes.',
-    getOperatingGuidance: () => ['Shell: use `shell` with `{"action":"execute","command":"..."}` for servers, installs, scripts, git, and curl. Use `background=true` for long-lived processes.', 'Use `shell` with `{"action":"sandbox_exec","language":"javascript","code":"..."}` to run JS/TS in a Docker sandbox when available.', 'Verify servers with `shell` status/log actions and liveness probes before claiming success.', 'Resolve IPs/URLs via shell — never use placeholders. Retry path errors without workdir override.'],
+    getCapabilityDescription: () => 'I can run shell commands with the unified `shell` tool. Use action `execute` for commands (including git, curl, and other CLI tools) and `list` / `status` / `poll` / `log` for long-lived processes.',
+    getOperatingGuidance: () => ['Shell: use `shell` with `{"action":"execute","command":"..."}` for servers, installs, scripts, git, and curl. Use `background=true` for long-lived processes.', 'Use the separate `execute` tool for sandboxed just-bash execution.', 'Verify servers with `shell` status/log actions and liveness probes before claiming success.', 'Resolve IPs/URLs via shell — never use placeholders. Retry path errors without workdir override.'],
   } as ExtensionHooks,
   tools: [
     {
       name: 'shell',
-      description: 'Execute commands and manage processes. Use for git, curl, and other CLI tools. Includes sandbox_exec for running JS/TS in Docker.',
+      description: 'Execute commands and manage processes. Use for git, curl, long-lived servers, and other host CLI tools.',
       parameters: {
         type: 'object',
         properties: {
-          action: { type: 'string', enum: ['execute', 'list', 'status', 'poll', 'log', 'write', 'kill', 'remove', 'sandbox_exec', 'sandbox_list_runtimes'] },
+          action: { type: 'string', enum: ['execute', 'list', 'status', 'poll', 'log', 'write', 'kill', 'remove'] },
           command: { type: 'string' },
           processId: { type: 'string' },
           background: { type: 'boolean' },
-          language: { type: 'string', enum: ['javascript', 'typescript'], description: 'Language for sandbox_exec action' },
-          code: { type: 'string', description: 'Code to execute for sandbox_exec action' },
         },
         required: ['action']
       },
@@ -414,7 +300,6 @@ export function buildShellTools(bctx: ToolBuildContext) {
         cwd: bctx.cwd,
         resolveCurrentSession: bctx.resolveCurrentSession,
         fileAccessPolicy: bctx.fileAccessPolicy,
-        sandboxConfig: bctx.sandboxConfig,
         filesystemScope: bctx.filesystemScope,
         commandTimeoutMs: bctx.commandTimeoutMs,
       }),

package/src/lib/server/session-tools/skills-tool.ts

@@ -0,0 +1,396 @@
+/**
+ * skills — Lightweight skill file reader.
+ *
+ * Agents call this tool to discover and load skill files (markdown docs)
+ * that teach them how to use tools, APIs, or workflows. Two directories
+ * are scanned: `skills/` (built-in, checked into the repo) and
+ * `data/skills/` (user-created at runtime).
+ *
+ * Actions:
+ *   read   — load a skill file by name
+ *   list   — browse available skills with descriptions
+ *   search — find skills by keyword match in content
+ */
+
+import fs from 'fs'
+import path from 'path'
+import { z } from 'zod'
+import { tool } from '@langchain/core/tools'
+import type { Extension, ExtensionHooks } from '@/types'
+import { registerNativeCapability } from '../native-capabilities'
+import { errorMessage } from '@/lib/shared-utils'
+import { log } from '../logger'
+import { normalizeToolInputArgs } from './normalize-tool-args'
+import type { ToolBuildContext } from './context'
+import { truncate, MAX_OUTPUT } from './context'
+
+const TAG = 'skills-tool'
+
+// ---------------------------------------------------------------------------
+// Skill directory resolution
+// ---------------------------------------------------------------------------
+
+/** Root of the project — two levels above `src/lib/server/session-tools/` */
+function projectRoot(): string {
+  return path.resolve(__dirname, '..', '..', '..', '..')
+}
+
+function builtinSkillsDir(): string {
+  return path.join(projectRoot(), 'skills')
+}
+
+function userSkillsDir(): string {
+  return path.join(projectRoot(), 'data', 'skills')
+}
+
+// ---------------------------------------------------------------------------
+// Skill file discovery
+// ---------------------------------------------------------------------------
+
+interface SkillEntry {
+  name: string
+  description: string
+  source: 'builtin' | 'user'
+  filePath: string
+}
+
+/**
+ * Extract the first non-empty, non-frontmatter, non-heading content line
+ * from a markdown file to use as a short description.
+ */
+function extractDescription(content: string): string {
+  let inFrontmatter = false
+  for (const rawLine of content.split('\n')) {
+    const line = rawLine.trim()
+    if (line === '---') {
+      inFrontmatter = !inFrontmatter
+      continue
+    }
+    if (inFrontmatter) continue
+    if (!line || line.startsWith('#')) continue
+    return line.length > 120 ? line.slice(0, 117) + '...' : line
+  }
+  return ''
+}
+
+/**
+ * Walk a skills directory and collect all `.md` files as skill entries.
+ * Supports both flat files (`skills/swarmclaw.md`) and directory-based
+ * skills (`skills/github/SKILL.md`).
+ */
+function discoverSkillsInDir(dir: string, source: 'builtin' | 'user'): SkillEntry[] {
+  if (!fs.existsSync(dir)) return []
+
+  const entries: SkillEntry[] = []
+
+  try {
+    const items = fs.readdirSync(dir, { withFileTypes: true })
+
+    for (const item of items) {
+      if (item.name.startsWith('.')) continue
+
+      const fullPath = path.join(dir, item.name)
+
+      if (item.isFile() && item.name.endsWith('.md')) {
+        // Flat markdown file: skills/swarmclaw.md
+        const name = item.name.replace(/\.md$/i, '')
+        const content = readFileSafe(fullPath)
+        entries.push({
+          name,
+          description: extractDescription(content),
+          source,
+          filePath: fullPath,
+        })
+      } else if (item.isDirectory()) {
+        // Directory-based skill: walk subdirectory for .md files
+        const subItems = readdirSafe(fullPath)
+        for (const sub of subItems) {
+          if (sub.startsWith('.')) continue
+          const subPath = path.join(fullPath, sub)
+
+          if (sub.endsWith('.md') && fs.statSync(subPath).isFile()) {
+            const subName = sub === 'SKILL.md'
+              ? item.name
+              : `${item.name}/${sub.replace(/\.md$/i, '')}`
+            const content = readFileSafe(subPath)
+            entries.push({
+              name: subName,
+              description: extractDescription(content),
+              source,
+              filePath: subPath,
+            })
+          } else if (fs.statSync(subPath).isDirectory()) {
+            // One level deeper: skills/tools/files.md
+            const deepItems = readdirSafe(subPath)
+            for (const deep of deepItems) {
+              if (deep.startsWith('.') || !deep.endsWith('.md')) continue
+              const deepPath = path.join(subPath, deep)
+              if (!fs.statSync(deepPath).isFile()) continue
+              const deepName = `${item.name}/${sub}/${deep.replace(/\.md$/i, '')}`
+              const content = readFileSafe(deepPath)
+              entries.push({
+                name: deepName,
+                description: extractDescription(content),
+                source,
+                filePath: deepPath,
+              })
+            }
+          }
+        }
+
+        // If SKILL.md or named .md exist but weren't caught by the loop
+        // (they would have been), this is just for safety — dedup by filePath later
+      }
+    }
+  } catch (err: unknown) {
+    log.warn(TAG, `Failed to scan skill directory: ${dir}`, { error: errorMessage(err) })
+  }
+
+  return entries
+}
+
+function readdirSafe(dir: string): string[] {
+  try {
+    return fs.readdirSync(dir).filter((name) => !name.startsWith('.'))
+  } catch {
+    return []
+  }
+}
+
+function readFileSafe(filePath: string): string {
+  try {
+    return fs.readFileSync(filePath, 'utf-8')
+  } catch {
+    return ''
+  }
+}
+
+function discoverAllSkills(): SkillEntry[] {
+  const builtin = discoverSkillsInDir(builtinSkillsDir(), 'builtin')
+  const user = discoverSkillsInDir(userSkillsDir(), 'user')
+
+  // Dedup by filePath
+  const seen = new Set<string>()
+  const deduped: SkillEntry[] = []
+  for (const entry of [...builtin, ...user]) {
+    if (seen.has(entry.filePath)) continue
+    seen.add(entry.filePath)
+    deduped.push(entry)
+  }
+
+  return deduped
+}
+
+// ---------------------------------------------------------------------------
+// Action: read
+// ---------------------------------------------------------------------------
+
+function resolveSkillFile(name: string): SkillEntry | null {
+  const skills = discoverAllSkills()
+  const normalized = name.trim().toLowerCase()
+
+  // Exact match by name
+  const exact = skills.find((s) => s.name.toLowerCase() === normalized)
+  if (exact) return exact
+
+  // Partial match: name ends with the query
+  const partial = skills.find((s) => s.name.toLowerCase().endsWith(normalized))
+  if (partial) return partial
+
+  // Partial match: name contains the query
+  const contains = skills.find((s) => s.name.toLowerCase().includes(normalized))
+  if (contains) return contains
+
+  return null
+}
+
+function actionRead(name: string): string {
+  if (!name) {
+    return 'Error: `name` parameter is required for action "read". Provide the skill name to load.'
+  }
+
+  const skill = resolveSkillFile(name)
+  if (!skill) {
+    const available = discoverAllSkills().map((s) => s.name)
+    return JSON.stringify({
+      error: `Skill "${name}" not found.`,
+      available: available.slice(0, 20),
+      hint: 'Use action="list" to see all available skills, or action="search" with a query.',
+    })
+  }
+
+  const content = readFileSafe(skill.filePath)
+  if (!content) {
+    return `Error: Skill file "${skill.filePath}" exists but could not be read.`
+  }
+
+  log.info(TAG, `Read skill: ${skill.name}`, { source: skill.source, filePath: skill.filePath })
+
+  return truncate(content, MAX_OUTPUT)
+}
+
+// ---------------------------------------------------------------------------
+// Action: list
+// ---------------------------------------------------------------------------
+
+function actionList(): string {
+  const skills = discoverAllSkills()
+
+  if (skills.length === 0) {
+    return JSON.stringify({
+      skills: [],
+      message: 'No skill files found. Create .md files in skills/ or data/skills/ to add skills.',
+    })
+  }
+
+  const listing = skills.map((s) => ({
+    name: s.name,
+    description: s.description,
+    source: s.source,
+  }))
+
+  return JSON.stringify({ skills: listing, total: listing.length })
+}
+
+// ---------------------------------------------------------------------------
+// Action: search
+// ---------------------------------------------------------------------------
+
+function actionSearch(query: string): string {
+  if (!query) {
+    return 'Error: `query` parameter is required for action "search".'
+  }
+
+  const skills = discoverAllSkills()
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean)
+
+  const results: Array<{ name: string; description: string; source: string; matchCount: number }> = []
+
+  for (const skill of skills) {
+    const content = readFileSafe(skill.filePath).toLowerCase()
+    const nameAndDesc = `${skill.name} ${skill.description}`.toLowerCase()
+
+    let matchCount = 0
+    for (const term of terms) {
+      if (nameAndDesc.includes(term)) matchCount += 2
+      else if (content.includes(term)) matchCount += 1
+    }
+
+    if (matchCount > 0) {
+      results.push({
+        name: skill.name,
+        description: skill.description,
+        source: skill.source,
+        matchCount,
+      })
+    }
+  }
+
+  results.sort((a, b) => b.matchCount - a.matchCount)
+
+  return JSON.stringify({
+    query,
+    results: results.slice(0, 15),
+    total: results.length,
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Main action dispatcher
+// ---------------------------------------------------------------------------
+
+function executeSkillsAction(rawArgs: Record<string, unknown>): string {
+  const normalized = normalizeToolInputArgs(rawArgs)
+  const action = typeof normalized.action === 'string' ? normalized.action.trim().toLowerCase() : ''
+  const name = typeof normalized.name === 'string' ? normalized.name.trim() : ''
+  const query = typeof normalized.query === 'string' ? normalized.query.trim() : ''
+
+  try {
+    switch (action) {
+      case 'read':
+        return actionRead(name || query)
+      case 'list':
+        return actionList()
+      case 'search':
+        return actionSearch(query || name)
+      default:
+        return `Error: Unknown action "${action}". Supported actions: read, list, search.`
+    }
+  } catch (err: unknown) {
+    return `Error: ${errorMessage(err)}`
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Extension registration
+// ---------------------------------------------------------------------------
+
+const SkillsExtension: Extension = {
+  name: 'Core Skills',
+  description: 'Discover and load skill files that teach agents how to use tools, APIs, and workflows.',
+  hooks: {
+    getCapabilityDescription: () =>
+      'I can discover and read skill files with the `skills` tool. ' +
+      'Skills are markdown documents that teach me how to use specific tools, APIs, or workflows. ' +
+      'Built-in skills live in `skills/` and user-created skills in `data/skills/`.',
+    getOperatingGuidance: () =>
+      'Use `skills` with action="list" to see what skills are available. ' +
+      'Use action="read" with a name to load a specific skill. ' +
+      'Use action="search" with a query to find skills by keyword. ' +
+      'Load a skill before attempting unfamiliar tools or APIs.',
+  } as ExtensionHooks,
+  tools: [
+    {
+      name: 'skills',
+      description:
+        'Discover and load skill files (markdown docs) that teach how to use tools, APIs, and workflows. ' +
+        'Actions: "read" (load a skill by name), "list" (browse available skills), "search" (find by keyword). ' +
+        'Load a skill before attempting unfamiliar tools or APIs.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'string',
+            enum: ['read', 'list', 'search'],
+            description: 'The action to perform',
+          },
+          name: {
+            type: 'string',
+            description: 'Skill name for action="read" (e.g., "tools/files", "swarmclaw")',
+          },
+          query: {
+            type: 'string',
+            description: 'Search query for action="search", or alternate name for action="read"',
+          },
+        },
+        required: ['action'],
+      },
+      execute: async (args) => executeSkillsAction(args),
+    },
+  ],
+}
+
+registerNativeCapability('skills', SkillsExtension)
+
+// ---------------------------------------------------------------------------
+// Tool builder (called from session-tools/index.ts)
+// ---------------------------------------------------------------------------
+
+export function buildSkillsTools(bctx: ToolBuildContext) {
+  if (!bctx.hasExtension('skills')) return []
+
+  return [
+    tool(
+      async (args) => executeSkillsAction((args ?? {}) as Record<string, unknown>),
+      {
+        name: 'skills',
+        description: SkillsExtension.tools![0].description,
+        schema: z.object({
+          action: z.enum(['read', 'list', 'search']).describe('The action to perform'),
+          name: z.string().optional().describe('Skill name for action="read"'),
+          query: z.string().optional().describe('Search query for action="search"'),
+        }).passthrough(),
+      },
+    ),
+  ]
+}

package/src/lib/server/session-tools/team-context.ts

@@ -168,9 +168,6 @@ async function formatPeerContext(agentId: string, peerId: string): Promise<strin
     const activeSession = Object.values(sessions).find(
       (s) => s.agentId === peerId && s.active,
     )
-    if (activeSession?.missionId) {
-      result.activeMission = { missionId: activeSession.missionId }
-    }
   } catch { /* non-critical */ }
 
   // Enforce output cap — drop large fields instead of slicing mid-JSON

package/src/lib/server/session-tools/web.ts

@@ -25,7 +25,7 @@ import {
   removeBrowserSessionRecord,
   upsertBrowserSessionRecord,
 } from '../browser-state'
-import { ensureSessionSandbox } from '@/lib/server/sandbox/session-runtime'
+import { resolveSandboxSessionContext } from '@/lib/server/sandbox/session-runtime'
 import {
   destroySandboxBrowser,
   ensureSandboxBrowser,
@@ -328,7 +328,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
       if (sandboxRuntimePromise) return sandboxRuntimePromise
       sandboxRuntimePromise = (async () => {
         try {
-          const sandbox = await ensureSessionSandbox({
+          const sandbox = resolveSandboxSessionContext({
             config: bctx.sandboxConfig,
             session: currentSession,
             agentId: currentSession.agentId ?? ctx?.agentId ?? null,

package/src/lib/server/storage-normalization.ts

@@ -435,6 +435,7 @@ export function normalizeStoredRecord(
     && table !== 'schedules' && table !== 'sessions'
     && table !== 'provider_configs'
     && table !== 'runtime_runs' && table !== 'runtime_run_events'
+    && table !== 'wallets'
   ) {
     return { value, changed: false }
   }
@@ -484,6 +485,8 @@ function normalizeStoredRecordInner(
     delete agent.platformAssignScope
     delete agent.subAgentIds
     agent.sandboxConfig = normalizeAgentSandboxConfig(agent.sandboxConfig)
+    // Default executeConfig — null means not configured (falls back to defaults in execute.ts)
+    if (agent.executeConfig === undefined) agent.executeConfig = null
     // Default proactiveMemory to true for existing agents
     if (agent.proactiveMemory === undefined) agent.proactiveMemory = true
     if (!Array.isArray(agent.capabilities)) agent.capabilities = []
@@ -571,6 +574,13 @@ function normalizeStoredRecordInner(
     return normalizeStoredScheduleRecord(value, loadItem)
   }
 
+  if (table === 'wallets') {
+    const wallet = value as StoredObject
+    if (wallet.chain !== 'base') wallet.chain = 'base'
+    if (typeof wallet.createdAt !== 'number') wallet.createdAt = Date.now()
+    return wallet
+  }
+
   // sessions
   const session = value as StoredObject
   // Migrate legacy 'orchestrated' → 'delegated'