feat(mothership): sim_cli and run_code execute sim-side; agent CLI augmentations

Live dev incident (elder's chats): run_code faked success against a route
that does not exist, sim's pickup ghost-claimed worker tools off the stale
catalog, and a mid-turn deploy downgraded the toolset (CLI "Not logged in",
AI_NoSuchToolError). Root fixes, all on the right layer:

- sim/embed: the CLI's own command tree runs in-process (AsyncLocalStorage
  identity + output capture, no profiles/config/env, process.exit shimmed).
  The worker stops spawning a vendored CLI binary; no credential crosses the
  wire — sim mints the delegation identity inside the handler per call.
- sim_cli handler routes each invocation: agent-only augmentations first
  (agent-cli/ registry — workflow blocks/edges views, workflow-scoped and
  cross-workflow grep, typed over the v2 surface via the CLI's SimClient),
  else the embedded real CLI; root --help merges both surfaces.
- run_code + function-execute handlers restored from the pre-revamp tree
  (same sandbox as workflow Function blocks), registered again.
- Pickup guard: a frame whose executor is 'go' is never dispatched here,
  whatever the stale catalog says; registry handlers are authoritative for
  worker-declared tools outside the catalog.
- Lanes: the task dispatch row is absorbed by its titled lane (id-precise),
  'task' agentId gets a sane fallback label.
- Resume delegation-token threading removed — obsolete by design.

Claude-Session: https://claude.ai/code/session_01CgaxNAaeD3taGdghbXn17w

Author: Sg312

apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.tsx

@@ -129,6 +129,9 @@ const SUBAGENT_KEYS = new Set(Object.keys(SUBAGENT_LABELS))
  */
 const SUBAGENT_DISPATCH_TOOLS: Record<string, string> = {
   [FILE_SUBAGENT_ID]: PrepareFileEdit.id,
+  // The worker's general subagent: the `task` tool row is the dispatch; the lane
+  // (titled by the model) replaces it.
+  task: 'task',
 }
 
 function isToolResultRead(params?: Record<string, unknown>): boolean {
@@ -287,12 +290,27 @@ function parseBlocksWithSpanTree(blocks: ContentBlock[]): MessageSegment[] {
   // When a subagent spawns, drop the dispatch tool that triggered it (e.g.
   // workspace_file -> file) from whichever container it landed in so it does not
   // render as a separate entry beside the agent group.
-  const absorbDispatchTool = (toolName: string, parentSpanId: string | undefined): void => {
+  const absorbDispatchTool = (
+    toolName: string,
+    parentSpanId: string | undefined,
+    dispatchToolCallId?: string
+  ): void => {
     const container =
       parentSpanId && parentSpanId !== SPAN_ROOT
         ? groupsBySpanId.get(parentSpanId)
         : tailMothershipGroup()
     if (!container) return
+    // Prefer the precise id match anywhere in the container — parallel sibling
+    // tools can push the dispatch row off the tail position.
+    if (dispatchToolCallId) {
+      const idx = container.items.findIndex(
+        (it) => it.type === 'tool' && it.data.id === dispatchToolCallId
+      )
+      if (idx >= 0) {
+        container.items.splice(idx, 1)
+        return
+      }
+    }
     const last = container.items[container.items.length - 1]
     if (last?.type === 'tool' && last.data.toolName === toolName) {
       container.items.pop()
@@ -379,7 +397,9 @@ function parseBlocksWithSpanTree(blocks: ContentBlock[]): MessageSegment[] {
       // Absorb a trailing dispatch tool (e.g. workspace_file -> file) so it does
       // not render as a separate entry alongside the agent group.
       const dispatchToolName = SUBAGENT_DISPATCH_TOOLS[block.content]
-      if (dispatchToolName) absorbDispatchTool(dispatchToolName, block.parentSpanId)
+      if (dispatchToolName) {
+        absorbDispatchTool(dispatchToolName, block.parentSpanId, block.parentToolCallId)
+      }
       const g = ensureSpanGroup(block.content, block.spanId, block.parentSpanId)
       if (block.subagentName) g.agentLabel = block.subagentName
       if (block.endedAt !== undefined) {

apps/sim/app/workspace/[workspaceId]/home/types.ts

@@ -198,6 +198,9 @@ export const SUBAGENT_LABELS: Record<string, string> = {
   // `extensions` is its current model-facing trigger tool name.
   agent: 'Extensions Agent',
   extensions: 'Extensions Agent',
+  // The worker's general subagent; the lane header normally carries the
+  // model-chosen title, this label is only the pre-start race fallback.
+  task: 'Subagent',
   // `job` retained as a backward-compat alias so historical transcripts still render a label.
   job: 'Job Agent',
   file: 'File Agent',

apps/sim/lib/mothership/generated/protocol.ts

@@ -32,7 +32,8 @@ export interface ChatRequest {
   integrationTools?: unknown[] | undefined;
   /** User-configured MCP tool schemas — same shape as integrationTools. */
   mothershipTools?: unknown[] | undefined;
-  /** D23: sim-minted run-scoped credential. In-memory only on the worker (S44). */
+  /** Deprecated: unused since the CLI moved to sim-side in-process execution (no
+   * credential crosses the wire); accepted so current senders keep validating. */
   delegationToken?: string | undefined;
   /** Enterprise BYOK: customer's own key; per-run instance, zero retention (S27). */
   byokApiKey?: string | undefined;
@@ -42,7 +43,7 @@ export interface ChatRequest {
   /**
    * What the CALLER can execute client-side. PRESENT = an explicit declaration — an
    * empty array means "I pick up nothing", so sim-side dispatch must skip client-pickup
-   * grace windows and run tools server-side immediately. ABSENT = legacy/unknown caller —
+   * grace windows and run tools server-side immediately. ABSENT = older/unknown caller —
    * dispatch keeps its conservative grace (deploy-skew safe: a stale tab that predates
    * this field still gets waited on). Known capability: "workflow-tool-pickup".
    */

apps/sim/lib/mothership/request/handlers/tool.ts

@@ -516,7 +516,11 @@ async function handleCallPhase(
   const { clientExecutable, simExecutable, internal, inbandOwned } = ui
   const catalogEntry = getToolEntry(toolName)
   const isInternal = internal || catalogEntry?.internal === true
-  const staticSimExecuted = isSimExecuted(toolName)
+  // The frame's executor is authoritative over the static catalog: a backend-executed
+  // ('go') frame must never be dispatched here even when the catalog lists the name as
+  // sim-routed — the worker runs some legacy-named tools in-process, and a stale-catalog
+  // dispatch raced them with a second, handlerless execution ("No handler for tool").
+  const staticSimExecuted = isSimExecuted(toolName) && data.executor !== 'go'
   // Go executes inband-owned calls itself via /api/copilot/tools/execute
   // (background lanes, and the main lane while background agents run); the
   // event exists only to draw the row. Dispatching it here would run the

apps/sim/lib/mothership/tool-executor/executor.ts

@@ -73,8 +73,13 @@ export async function executeTool(
 
   const normalizedParams = normalizeToolParams(toolId, params, context)
 
+  // A registered handler is authoritative for worker-declared tools OUTSIDE the catalog
+  // (sim_cli, run_code's successors): the catalog gate below would otherwise misroute
+  // them into the app-tool registry and fail with "Tool not found". Catalog-known tools
+  // keep the routing the catalog declares.
   const canUseRegisteredHandler =
-    isKnownTool(toolId) && (isSimExecuted(toolId) || usesHeadlessClientFallback)
+    hasHandler(toolId) &&
+    (!isKnownTool(toolId) || isSimExecuted(toolId) || usesHeadlessClientFallback)
   if (!canUseRegisteredHandler) {
     const appParams = buildAppToolParams(normalizedParams, context)
     const options = {

apps/sim/lib/mothership/tool-executor/register-handlers.ts

@@ -7,6 +7,8 @@ import {
 } from '@/lib/mothership/generated/tool-catalog-v1'
 import { createServerToolHandler } from '@/lib/mothership/tools/registry/server-tool-adapter'
 import { getRegisteredServerToolNames } from '@/lib/mothership/tools/server/router'
+import { executeRunCode } from '../tools/handlers/run-code'
+import { executeSimCli } from '../tools/handlers/sim-cli'
 import {
   executeRunBlock,
   executeRunFromBlock,
@@ -48,6 +50,13 @@ function buildHandlerMap(): Record<string, ToolHandler> {
     [RunWorkflowUntilBlock.id]: h(executeRunWorkflowUntilBlock),
     [RunFromBlock.id]: h(executeRunFromBlock),
     [RunBlock.id]: h(executeRunBlock),
+    // The worker's sandboxed code execution — deferred here because the sandbox
+    // (E2B/VM, mounts, secret materialization) lives on this side, same as the
+    // workflow Function block. Compute-only: the handler rejects write vectors.
+    run_code: h(executeRunCode),
+    // The worker's CLI surface, executed in-process via the CLI's own command
+    // tree (sim/embed) against this deployment's internal API base.
+    sim_cli: h(executeSimCli),
     ...buildServerToolHandlers(),
   }
 }

apps/sim/lib/mothership/tools/handlers/agent-cli/agent-cli.test.ts

@@ -0,0 +1,142 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  agentCliHelpSection,
+  executeAgentCliCommand,
+  isRootHelpInvocation,
+  matchAgentCliCommand,
+} from '@/lib/mothership/tools/handlers/agent-cli'
+import type { AgentCliRuntime } from '@/lib/mothership/tools/handlers/agent-cli/types'
+
+const WORKFLOW_STATE = {
+  blocks: {
+    'block-1': { type: 'starter', name: 'Start', enabled: true },
+    'block-2': { type: 'agent', name: 'Summarize emails', enabled: true },
+  },
+  edges: [{ source: 'block-1', target: 'block-2', sourceHandle: 'source', id: 'edge-1' }],
+  variables: { apiBase: 'https://api.example.com' },
+}
+
+function runtimeWith(responses: Record<string, unknown>): AgentCliRuntime {
+  return {
+    workspaceId: 'ws-1',
+    client: {
+      request: async <T>(path: string): Promise<T> => {
+        const hit = responses[path]
+        if (hit === undefined) throw new Error(`Unexpected request: ${path}`)
+        return hit as T
+      },
+    },
+  }
+}
+
+const EXPORT_PATH = '/api/v2/workflows/wf-1/export'
+const exportResponse = { data: { state: WORKFLOW_STATE } }
+
+describe('agent-cli routing', () => {
+  it('matches agent commands through leading global flags', () => {
+    const match = matchAgentCliCommand(['--output', 'json', 'workflow', 'edges', 'wf-1'])
+    expect(match?.command.path).toEqual(['workflow', 'edges'])
+    expect(match?.rest).toEqual(['wf-1'])
+  })
+
+  it('leaves real CLI commands unmatched', () => {
+    expect(matchAgentCliCommand(['workflows', 'list'])).toBeNull()
+    expect(matchAgentCliCommand(['tables', 'get', 'tbl_1'])).toBeNull()
+  })
+
+  it('detects root help invocations only', () => {
+    expect(isRootHelpInvocation(['--help'])).toBe(true)
+    expect(isRootHelpInvocation(['--output', 'json', 'help'])).toBe(true)
+    expect(isRootHelpInvocation(['workflows', '--help'])).toBe(false)
+  })
+
+  it('lists every registered command in the help section', () => {
+    const section = agentCliHelpSection()
+    for (const usage of ['workflow blocks', 'workflow edges', 'workflow grep', 'workflows grep']) {
+      expect(section).toContain(usage)
+    }
+  })
+})
+
+describe('workflow views', () => {
+  it('projects just the blocks', async () => {
+    const match = matchAgentCliCommand(['workflow', 'blocks', 'wf-1'])
+    const result = await executeAgentCliCommand(
+      match!,
+      runtimeWith({ [EXPORT_PATH]: exportResponse })
+    )
+    expect(result.exitCode).toBe(0)
+    const blocks = JSON.parse(result.stdout)
+    expect(blocks).toEqual([
+      { id: 'block-1', type: 'starter', name: 'Start', enabled: true },
+      { id: 'block-2', type: 'agent', name: 'Summarize emails', enabled: true },
+    ])
+  })
+
+  it('projects just the edges', async () => {
+    const match = matchAgentCliCommand(['workflow', 'edges', 'wf-1'])
+    const result = await executeAgentCliCommand(
+      match!,
+      runtimeWith({ [EXPORT_PATH]: exportResponse })
+    )
+    expect(result.exitCode).toBe(0)
+    expect(JSON.parse(result.stdout)).toEqual([
+      { source: 'block-1', target: 'block-2', sourceHandle: 'source' },
+    ])
+  })
+
+  it('fails usefully without a workflow id', async () => {
+    const match = matchAgentCliCommand(['workflow', 'blocks'])
+    const result = await executeAgentCliCommand(match!, runtimeWith({}))
+    expect(result.exitCode).toBe(1)
+    expect(result.stderr).toContain('Usage:')
+  })
+})
+
+describe('workflow grep', () => {
+  it('reports matches as path: value lines', async () => {
+    const match = matchAgentCliCommand(['workflow', 'grep', 'wf-1', 'Summarize'])
+    const result = await executeAgentCliCommand(
+      match!,
+      runtimeWith({ [EXPORT_PATH]: exportResponse })
+    )
+    expect(result.exitCode).toBe(0)
+    expect(result.stdout).toContain('.blocks.block-2.name: Summarize emails')
+  })
+
+  it('falls back to literal search on an invalid regex', async () => {
+    const match = matchAgentCliCommand(['workflow', 'grep', 'wf-1', 'api.example.com['])
+    const result = await executeAgentCliCommand(
+      match!,
+      runtimeWith({ [EXPORT_PATH]: exportResponse })
+    )
+    expect(result.exitCode).toBe(0)
+    expect(result.stdout).toBe('No matches.')
+  })
+
+  it('searches across all workspace workflows', async () => {
+    const match = matchAgentCliCommand(['workflows', 'grep', 'Summarize'])
+    const result = await executeAgentCliCommand(
+      match!,
+      runtimeWith({
+        '/api/v2/workflows': {
+          data: [{ id: 'wf-1', name: 'Email digest' }],
+          nextCursor: null,
+        },
+        [EXPORT_PATH]: exportResponse,
+      })
+    )
+    expect(result.exitCode).toBe(0)
+    expect(result.stdout).toContain('Email digest (wf-1).blocks.block-2.name: Summarize emails')
+  })
+
+  it('surfaces execution errors as a failed result, never a throw', async () => {
+    const match = matchAgentCliCommand(['workflow', 'grep', 'wf-missing', 'x'])
+    const result = await executeAgentCliCommand(match!, runtimeWith({}))
+    expect(result.exitCode).toBe(1)
+    expect(result.stderr).toContain('Unexpected request')
+  })
+})

apps/sim/lib/mothership/tools/handlers/agent-cli/commands/grep.ts

@@ -0,0 +1,125 @@
+import type { ListWorkflowsResponse } from 'sim/embed'
+import { fetchWorkflowState } from '@/lib/mothership/tools/handlers/agent-cli/commands/workflow-views'
+import {
+  type AgentCliCommand,
+  type AgentCliRuntime,
+  agentCliFail,
+  agentCliOk,
+} from '@/lib/mothership/tools/handlers/agent-cli/types'
+
+/**
+ * Structural grep over workflow state. Matches walk the exported JSON tree and
+ * report `path: value` lines, so a hit names exactly where in the workflow it
+ * lives (block param, edge handle, variable) instead of a rendered blob.
+ */
+
+const MAX_MATCHES = 200
+const SNIPPET_CHARS = 200
+const EXPORT_CONCURRENCY = 5
+
+function compilePattern(raw: string): (value: string) => boolean {
+  try {
+    const regex = new RegExp(raw, 'i')
+    return (value) => regex.test(value)
+  } catch {
+    const needle = raw.toLowerCase()
+    return (value) => value.toLowerCase().includes(needle)
+  }
+}
+
+function grepTree(
+  node: unknown,
+  matches: (value: string) => boolean,
+  path: string,
+  out: string[]
+): void {
+  if (out.length >= MAX_MATCHES) return
+  if (typeof node === 'string' || typeof node === 'number' || typeof node === 'boolean') {
+    const text = String(node)
+    if (matches(text)) {
+      const snippet = text.length > SNIPPET_CHARS ? `${text.slice(0, SNIPPET_CHARS)}…` : text
+      out.push(`${path}: ${snippet.replaceAll('\n', '\\n')}`)
+    }
+    return
+  }
+  if (Array.isArray(node)) {
+    node.forEach((child, index) => grepTree(child, matches, `${path}[${index}]`, out))
+    return
+  }
+  if (typeof node === 'object' && node !== null) {
+    for (const [key, child] of Object.entries(node)) {
+      // Keys are searchable too: a block id or param name is often the target.
+      if (matches(key) && out.length < MAX_MATCHES) out.push(`${path}.${key}`)
+      grepTree(child, matches, `${path}.${key}`, out)
+    }
+  }
+}
+
+function renderMatches(lines: string[]): string {
+  if (lines.length === 0) return 'No matches.'
+  const capped =
+    lines.length >= MAX_MATCHES ? [...lines, `[capped at ${MAX_MATCHES} matches]`] : lines
+  return capped.join('\n')
+}
+
+export const workflowGrepCommand: AgentCliCommand = {
+  path: ['workflow', 'grep'],
+  summary: 'Search one workflow state (blocks, params, edges) for a pattern',
+  usage: 'workflow grep <workflowId> <pattern>',
+  async execute(rest, runtime) {
+    const [workflowId, ...patternParts] = rest
+    const pattern = patternParts.join(' ')
+    if (!workflowId || !pattern)
+      return agentCliFail('Usage: sim workflow grep <workflowId> <pattern>')
+    const state = await fetchWorkflowState(runtime, workflowId)
+    const out: string[] = []
+    grepTree(state, compilePattern(pattern), '', out)
+    return agentCliOk(renderMatches(out))
+  },
+}
+
+async function listAllWorkflows(runtime: AgentCliRuntime): Promise<ListWorkflowsResponse['data']> {
+  const rows: ListWorkflowsResponse['data'] = []
+  let cursor: string | null = null
+  do {
+    const page: ListWorkflowsResponse = await runtime.client.request<ListWorkflowsResponse>(
+      '/api/v2/workflows',
+      { query: { workspaceId: runtime.workspaceId, ...(cursor ? { cursor } : {}) } }
+    )
+    rows.push(...page.data)
+    cursor = page.nextCursor
+  } while (cursor)
+  return rows
+}
+
+export const workflowsGrepCommand: AgentCliCommand = {
+  path: ['workflows', 'grep'],
+  summary: 'Search every workflow in the workspace for a pattern',
+  usage: 'workflows grep <pattern>',
+  async execute(rest, runtime) {
+    const pattern = rest.join(' ')
+    if (!pattern) return agentCliFail('Usage: sim workflows grep <pattern>')
+    const matches = compilePattern(pattern)
+    const workflows = await listAllWorkflows(runtime)
+    const out: string[] = []
+    for (let i = 0; i < workflows.length && out.length < MAX_MATCHES; i += EXPORT_CONCURRENCY) {
+      const batch = workflows.slice(i, i + EXPORT_CONCURRENCY)
+      const states = await Promise.all(
+        batch.map(async (workflow) => {
+          try {
+            return { workflow, state: await fetchWorkflowState(runtime, workflow.id) }
+          } catch {
+            // One unexportable workflow must not sink the whole search.
+            return { workflow, state: null }
+          }
+        })
+      )
+      for (const { workflow, state } of states) {
+        const label = `${workflow.name} (${workflow.id})`
+        if (matches(workflow.name) && out.length < MAX_MATCHES) out.push(`${label}: name matches`)
+        if (state) grepTree(state, matches, label, out)
+      }
+    }
+    return agentCliOk(renderMatches(out))
+  },
+}