minimal-agent 0.11.0 → 0.12.0

package/plugins/workflow-runner/test/context-files.test.ts

@@ -15,11 +15,19 @@
  * ============================================================
  */
 
-import { afterAll, beforeAll, beforeEach, describe, expect, it, mock } from 'bun:test';
-
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  mock,
+} from 'bun:test';
+
+import type { Provider, Tool } from '../../../src/types.js';
 import { execLlmStep } from '../src/stepExecutors/llm.js';
 import { VarStack } from '../src/types.js';
-import type { Provider } from '../../../src/types.js';
 import type { RunContext, StepDef } from '../src/types.js';
 
 const fakeProvider: Provider = {
@@ -67,8 +75,11 @@ interface ExecuteToolCall {
 }
 const capturedExecuteToolCalls: ExecuteToolCall[] = [];
 /** mock executeTool 返回值脚本（按调用顺序）；用尽则回退到 { ok:true, content:'OK' } */
-let mockToolResults: Array<{ ok: true; content: string } | { ok: false; error: string }> = [];
+let mockToolResults: Array<
+  { ok: true; content: string } | { ok: false; error: string }
+> = [];
 
+import { chat as realChatImport } from '../../../src/llm/client.js';
 // 复用真实的 ALL_TOOLS / getToolByName（llm.ts 的白名单过滤要用），
 // 只把 executeTool 替换成 mock 版本。
 //
@@ -80,7 +91,6 @@ import {
   executeTool as realExecuteTool,
   getToolByName as realGetToolByName,
 } from '../../../src/tools/index.js';
-import { chat as realChatImport } from '../../../src/llm/client.js';
 
 // 在 mock 安装前把真实 chat 函数引用拷到值变量，避免 ESM live binding
 // 在 mock.module 后跟着变成 mock 版本（afterAll 复原才能拿到真函数）
@@ -140,7 +150,10 @@ function installChatMock(): void {
           argumentsDelta: turn.argsJson,
         };
       }
-      yield { type: 'done', stopReason: turn.kind === 'tool_call' ? 'tool_calls' : 'stop' };
+      yield {
+        type: 'done',
+        stopReason: turn.kind === 'tool_call' ? 'tool_calls' : 'stop',
+      };
     },
   }));
 }
@@ -156,7 +169,12 @@ describe('workflow-runner context_files (ADR-05 阶段 4)', () => {
     mockTurns = [];
     mockTurnIdx = 0;
     mockToolResults = [];
-    ctx = { provider: fakeProvider, history: [], cwd: process.cwd(), tools: [] };
+    ctx = {
+      provider: fakeProvider,
+      history: [],
+      cwd: process.cwd(),
+      tools: [],
+    };
   });
 
   it('pure llm 不下发工具，避免单轮设计类步骤误调工具后撞 maxTurns=1', async () => {
@@ -175,6 +193,7 @@ describe('workflow-runner context_files (ADR-05 阶段 4)', () => {
   });
 
   it('case 1: 基本 Read 引用 — tool_call 一轮 + 纯文本一轮', async () => {
+    ctx.tools = [{ name: 'Read' } as Tool];
     mockTurns = [
       {
         kind: 'tool_call',
@@ -190,8 +209,7 @@ describe('workflow-runner context_files (ADR-05 阶段 4)', () => {
       id: 'read-and-answer',
       llm: 'please summarize',
       context_files: [{ path: '/tmp/x.txt', hint: 'source data' }],
-      // v0.9：context_files 经 runQuery(TAOR) 执行，默认下发全量工具；用 allowed_tools
-      // 白名单把下发工具收敛到 Read（验证 loop.ts 的 allowedTools 过滤 + llm.ts 透传）。
+      // context_files 经 runQuery(TAOR) 执行；步骤白名单与宿主有效工具集取交集。
       allowed_tools: ['Read'],
     };
 
@@ -212,8 +230,9 @@ describe('workflow-runner context_files (ADR-05 阶段 4)', () => {
     expect(parsedArgs.file_path).toBe('/tmp/x.txt');
 
     // 第一轮 user message 包含路径和 hint
-    const firstUserMsg = (capturedChatArgs[0].messages as Array<{ role: string; content: string }>)
-      .find((m) => m.role === 'user');
+    const firstUserMsg = (
+      capturedChatArgs[0].messages as Array<{ role: string; content: string }>
+    ).find((m) => m.role === 'user');
     expect(firstUserMsg).toBeDefined();
     expect(firstUserMsg!.content).toContain('/tmp/x.txt');
     expect(firstUserMsg!.content).toContain('source data');
@@ -225,12 +244,23 @@ describe('workflow-runner context_files (ADR-05 阶段 4)', () => {
   });
 
   it('case 2: 永不收敛（每轮都调工具）→ 被 maxTurns 严格兜住，不无限循环', async () => {
+    ctx.tools = [{ name: 'Read' } as Tool];
     // v0.9 重构移除了 miniReAct 的"重复工具调用早停"，改由主 TAOR 引擎(runQuery)的
     // maxTurns 硬上限兜底。本用例验证安全属性：模型每轮都调工具、永不收敛时，chat 调用
     // 次数被 maxTurns 严格限制（不会无限循环），不再依赖已移除的重复检测。
     mockTurns = [
-      { kind: 'tool_call', callId: 'c1', name: 'Read', argsJson: '{"file_path":"/a"}' },
-      { kind: 'tool_call', callId: 'c2', name: 'Read', argsJson: '{"file_path":"/a"}' },
+      {
+        kind: 'tool_call',
+        callId: 'c1',
+        name: 'Read',
+        argsJson: '{"file_path":"/a"}',
+      },
+      {
+        kind: 'tool_call',
+        callId: 'c2',
+        name: 'Read',
+        argsJson: '{"file_path":"/a"}',
+      },
     ];
     mockToolResults = [
       { ok: true, content: 'A' },
@@ -246,13 +276,14 @@ describe('workflow-runner context_files (ADR-05 阶段 4)', () => {
 
     // 不无限循环：chat 调用次数被 maxTurns(=2) 严格兜住。
     // 撞顶后的半截产出不可信，execLlmStep 必须抛错触发 runner retry/halt。
-    await expect(drainLlm(execLlmStep(step, new VarStack(), ctx))).rejects.toThrow(
-      '达到最大轮数 2 被截断',
-    );
+    await expect(
+      drainLlm(execLlmStep(step, new VarStack(), ctx)),
+    ).rejects.toThrow('达到最大轮数 2 被截断');
     expect(capturedChatArgs.length).toBe(2);
   });
 
   it('case 3: output_schema + tools — 走 [json+tools] 前缀', async () => {
+    ctx.tools = [{ name: 'Read' } as Tool];
     mockTurns = [
       {
         kind: 'tool_call',

package/plugins/workflow-runner/test/hostCapability.test.ts

@@ -25,6 +25,7 @@ describe('框架侧：runCommand 必须带上 host', () => {
     expect(call).toContain('host:');
     expect(call).toContain('computerRun');
     expect(call).toContain('browserRun');
+    expect(call).toContain('executeTool: options.executeTool');
   });
 
   test('PluginContext 用 Pick<ToolCallContext> 绑定，而不是重新声明', async () => {
@@ -40,9 +41,14 @@ describe('能力常量单一来源', () => {
   test('loader 的白名单与 types 的 HostCapability 一致', async () => {
     // 两处不一致的表现是：yaml 写了某个能力、loader 放行、运行时却识别不了，
     // 或反过来 loader 拦掉一个其实支持的能力。都属于静默错。
-    const types = await Bun.file(new URL('../src/types.ts', import.meta.url)).text();
-    const declared = /export type HostCapability =([^;]+);/.exec(types)?.[1] ?? '';
-    const fromTypes = [...declared.matchAll(/'([a-z]+)'/g)].map((m) => m[1]).sort();
+    const types = await Bun.file(
+      new URL('../src/types.ts', import.meta.url),
+    ).text();
+    const declared =
+      /export type HostCapability =([^;]+);/.exec(types)?.[1] ?? '';
+    const fromTypes = [...declared.matchAll(/'([a-z]+)'/g)]
+      .map((m) => m[1])
+      .sort();
     expect(fromTypes).toEqual([...VALID_HOST_CAPABILITIES].sort());
   });
 });

package/plugins/workflow-runner/test/multimodal.test.ts

@@ -5,6 +5,7 @@
 
 import { describe, expect, it } from 'bun:test';
 
+import { ALL_TOOLS } from '../../../src/tools/index.js';
 import type {
   ChatContentPart,
   LlmStreamEvent,
@@ -16,7 +17,6 @@ import { execAgentStep } from '../src/stepExecutors/agent.js';
 import { execLlmStep } from '../src/stepExecutors/llm.js';
 import { VarStack } from '../src/types.js';
 import type { RunContext, StepDef } from '../src/types.js';
-import { ALL_TOOLS } from '../../../src/tools/index.js';
 
 const provider: Provider = {
   name: 'test',
@@ -72,7 +72,11 @@ describe('workflow-runner multimodal images', () => {
     const chat = async function* (): AsyncGenerator<LlmStreamEvent> {
       if (round++ === 0) {
         yield { type: 'tool_call_delta', index: 0, id: 'hidden', name: 'Bash' };
-        yield { type: 'tool_call_delta', index: 0, argumentsDelta: '{"command":"echo no"}' };
+        yield {
+          type: 'tool_call_delta',
+          index: 0,
+          argumentsDelta: '{"command":"echo no"}',
+        };
         yield { type: 'done', stopReason: 'tool_calls' };
         return;
       }
@@ -90,15 +94,58 @@ describe('workflow-runner multimodal images', () => {
         return { ok: true, content: 'unexpected' };
       },
     };
-    const result = await drain(execAgentStep(
-      { id: 'bounded', agent: '完成任务', allowed_tools: ['Bash'] },
-      new VarStack(),
-      ctx,
-    ));
+    const result = await drain(
+      execAgentStep(
+        { id: 'bounded', agent: '完成任务', allowed_tools: ['Bash'] },
+        new VarStack(),
+        ctx,
+      ),
+    );
     expect(executed).toBe(0);
     expect(result.raw.text).toBe('已改道。');
   });
 
+  it('an empty host tool catalog remains empty instead of restoring global tools', async () => {
+    let round = 0;
+    let executed = 0;
+    const chat = async function* (): AsyncGenerator<LlmStreamEvent> {
+      if (round++ === 0) {
+        yield { type: 'tool_call_delta', index: 0, id: 'hidden', name: 'Read' };
+        yield {
+          type: 'tool_call_delta',
+          index: 0,
+          argumentsDelta: '{"file_path":"README.md"}',
+        };
+        yield { type: 'done', stopReason: 'tool_calls' };
+        return;
+      }
+      yield { type: 'text_delta', delta: '没有可用工具。' };
+      yield { type: 'done', stopReason: 'stop' };
+    };
+    const ctx: RunContext = {
+      provider,
+      history: [{ role: 'system', content: 'stable' }],
+      cwd: process.cwd(),
+      tools: [],
+      chat,
+      executeTool: async () => {
+        executed += 1;
+        return { ok: true, content: 'unexpected' };
+      },
+    };
+
+    const result = await drain(
+      execAgentStep(
+        { id: 'empty-bound', agent: '完成任务', allowed_tools: ['Read'] },
+        new VarStack(),
+        ctx,
+      ),
+    );
+
+    expect(executed).toBe(0);
+    expect(result.raw.text).toBe('没有可用工具。');
+  });
+
   it('execLlmStep 把 images 传成 image_url content block，并支持变量插值', async () => {
     const captured: Message[][] = [];
     const ctx = createContext(captured);
@@ -195,7 +242,9 @@ describe('workflow-runner multimodal images', () => {
 
     expect(result.raw.text).toBe('图片可用');
     expect(messagesContainImage(captured[0])).toBe(true);
-    expect(ctx.history).toEqual([{ role: 'system', content: 'workflow system prompt' }]);
+    expect(ctx.history).toEqual([
+      { role: 'system', content: 'workflow system prompt' },
+    ]);
   });
 
   it('isolated 多模态步骤之后的普通 agent 不会收到前一步 image_url', async () => {
@@ -262,7 +311,7 @@ describe('workflow-runner multimodal images', () => {
       provider,
       history: [{ role: 'system', content: 'workflow system prompt' }],
       cwd: process.cwd(),
-      tools: [],
+      tools: ALL_TOOLS.filter((tool) => tool.name === 'Write'),
       chat,
       executeTool: async () => {
         toolCalled = true;
@@ -285,7 +334,9 @@ describe('workflow-runner multimodal images', () => {
 
     expect(toolCalled).toBe(true);
     expect(result.raw.text).toBe('文件已写好。');
-    expect(ctx.history).toEqual([{ role: 'system', content: 'workflow system prompt' }]);
+    expect(ctx.history).toEqual([
+      { role: 'system', content: 'workflow system prompt' },
+    ]);
     expect(captured.length).toBe(2);
   });
 });

package/plugins/workflow-runner/test/toolRuntimeIntegration.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, test } from 'bun:test';
+
+import {
+  ALL_TOOLS,
+  type LoopEvent,
+  type Provider,
+  type ToolCallContext,
+  type ToolResult,
+  createAgentRuntimeContext,
+  createSessionState,
+} from '../../../src/plugin-sdk.js';
+import { execToolStep } from '../src/stepExecutors/tool.js';
+import { type RunContext, type StepResult, VarStack } from '../src/types.js';
+
+const provider: Provider = {
+  name: 'workflow-tool-test',
+  baseURL: '',
+  apiKey: '',
+  model: 'fixture',
+  contextWindow: 128_000,
+};
+
+async function collect(
+  generator: AsyncGenerator<LoopEvent, StepResult, void>,
+): Promise<{ events: LoopEvent[]; result: StepResult }> {
+  const events: LoopEvent[] = [];
+  while (true) {
+    const next = await generator.next();
+    if (next.done) return { events, result: next.value };
+    events.push(next.value);
+  }
+}
+
+function makeContext(
+  executeTool: NonNullable<RunContext['executeTool']>,
+): RunContext {
+  const sessionState = createSessionState();
+  sessionState.activeWorktree = {
+    id: 'wt_test',
+    path: '/tmp/workflow-active-worktree',
+    branch: 'workflow/test',
+    baseSha: 'deadbeef',
+    gitRoot: '/tmp/workflow-root',
+  };
+  return {
+    provider,
+    history: [],
+    cwd: '/tmp/workflow-root',
+    tools: ALL_TOOLS,
+    sessionState,
+    runtimeContext: createAgentRuntimeContext({
+      surface: 'workflow',
+      profile: 'main',
+      cwd: '/tmp/workflow-root',
+      workspaceId: 'workspace_test',
+      sessionId: 'session_test',
+      owner: 'local-owner',
+      memoryAccess: 'read-only',
+      interactiveAsk: false,
+    }),
+    promptCache: {
+      scopeKey: 'workflow-test-scope',
+      conversationKey: 'workflow-test-conversation',
+    },
+    executeTool,
+  };
+}
+
+describe('workflow deterministic tool runtime', () => {
+  test('all registered tools use the same generic deterministic node dispatcher', async () => {
+    const dispatched: string[] = [];
+    const ctx = makeContext(async (name) => {
+      dispatched.push(name);
+      return { ok: true, content: `${name} ok` };
+    });
+
+    for (const tool of ALL_TOOLS) {
+      const { result } = await collect(
+        execToolStep(
+          { id: `catalog_${tool.name}`, tool: tool.name, args: {} },
+          new VarStack(),
+          ctx,
+        ),
+      );
+      expect(result.raw).toMatchObject({ content: `${tool.name} ok` });
+    }
+
+    expect(dispatched).toEqual(ALL_TOOLS.map((tool) => tool.name));
+    expect(new Set(dispatched).size).toBe(ALL_TOOLS.length);
+  });
+
+  test('passes canonical runtime context and follows the active worktree cwd', async () => {
+    let captured: ToolCallContext | undefined;
+    const ctx = makeContext(async (_name, _args, _signal, context) => {
+      captured = context;
+      return { ok: true, content: 'ok' };
+    });
+
+    await collect(
+      execToolStep(
+        { id: 'context', tool: 'Read', args: { file_path: 'README.md' } },
+        new VarStack(),
+        ctx,
+      ),
+    );
+
+    expect(captured).toBeDefined();
+    expect(captured?.provider).toBe(provider);
+    expect(captured?.history).toBe(ctx.history);
+    expect(captured?.sessionState).toBe(ctx.sessionState);
+    expect(captured?.workspaceId).toBe('workspace_test');
+    expect(captured?.sessionId).toBe('session_test');
+    expect(captured?.memoryAccess).toBe('read-only');
+    expect(captured?.cwd).toBe('/tmp/workflow-active-worktree');
+    expect(captured?.toolCallId).toBe('wf_context');
+    expect(captured?.promptCache).toBe(ctx.promptCache);
+  });
+
+  test('streams tool progress and preserves structured result fields', async () => {
+    const metadata = {
+      kind: 'process_execution' as const,
+      shell: 'bash' as const,
+      mode: 'foreground' as const,
+      commandKind: 'test' as const,
+      status: 'completed' as const,
+      exitCode: 0,
+    };
+    const ctx = makeContext(async (_name, _args, _signal, context) => {
+      context?.reportProgress?.('running tests');
+      await Promise.resolve();
+      return {
+        ok: true,
+        content: 'tests passed',
+        metadata,
+        recovery: 'none',
+        sensitivity: 'local',
+        visionNote: 'verification image',
+      } satisfies ToolResult;
+    });
+
+    const { events, result } = await collect(
+      execToolStep(
+        { id: 'progress', tool: 'Bash', args: { command: 'bun test' } },
+        new VarStack(),
+        ctx,
+      ),
+    );
+
+    expect(events.map((event) => event.type)).toEqual([
+      'tool_start',
+      'tool_progress',
+      'tool_end',
+    ]);
+    expect(events[1]).toMatchObject({
+      type: 'tool_progress',
+      toolName: 'Bash',
+      toolCallId: 'wf_progress',
+      message: 'running tests',
+    });
+    expect(events[2]).toMatchObject({ type: 'tool_end', metadata });
+    expect(result.raw).toMatchObject({
+      metadata,
+      recovery: 'none',
+      sensitivity: 'local',
+      visionNote: 'verification image',
+    });
+  });
+});

package/src/cli/print.js

@@ -27,7 +27,9 @@ import { updateSessionMetadata } from '../context/sessionRegistry.js';
 import { workspaceIndexService } from '../context/workspaceIndex.js';
 import { normalizeImageDetail } from '../multimodal.js';
 import { runWithPlugins } from '../plugins/pluginRunner.js';
-import { buildTransientPromptBundle } from '../prompts/system.js';
+import { buildBaseSystemPrompt, buildTransientPromptBundle } from '../prompts/system.js';
+import { getOrCreateSessionState, sessionStateKey } from '../session/sessionState.js';
+import { hydrateSessionWorktree } from '../tools/worktree/sessionWorktree.js';
 import { ALL_TOOLS } from '../tools/index.js';
 import { createPromptCacheContext } from '../llm/promptCache.js';
 import { createAgentRuntimeContext, filterToolsForRuntime, memoryContextFromRuntime, } from '../runtime/agentRuntimeContext.js';
@@ -232,10 +234,16 @@ export async function runPrintMode(provider, args, initialHistory, options) {
         void finalizeOnce().finally(() => process.exit(130));
     });
     try {
-        const cwd = options.workspace?.cwd ?? process.cwd();
-        const workspace = await workspaceIndexService.findByPath(cwd).catch(() => null);
+        const workspaceRoot = options.workspace?.cwd ?? process.cwd();
+        const workspace = await workspaceIndexService.findByPath(workspaceRoot).catch(() => null);
         const sessionId = options.workspace?.sessionId ?? 'default';
-        const conversationKey = `workspace:${workspace?.id ?? cwd}:session:${sessionId}`;
+        const sessionState = getOrCreateSessionState(sessionStateKey({
+            surface: 'cli', workspaceId: workspace?.id,
+            cwd: workspace?.id ? undefined : workspaceRoot, sessionId,
+        }));
+        await hydrateSessionWorktree({ sessionState, workspaceId: workspace?.id, sessionId, cwd: workspaceRoot });
+        const cwd = sessionState.activeWorktree?.path ?? workspaceRoot;
+        const conversationKey = `workspace:${workspace?.id ?? workspaceRoot}:session:${sessionId}`;
         const computerRun = options.computerUseMode && options.computerUseMode !== 'disabled'
             ? createCliComputerRun({
                 mode: options.computerUseMode,
@@ -259,6 +267,11 @@ export async function runPrintMode(provider, args, initialHistory, options) {
             computer: computerRun,
         });
         const turnTools = filterToolsForRuntime(ALL_TOOLS, runtimeContext);
+        const stablePrompt = await buildBaseSystemPrompt(cwd, turnTools);
+        if (history[0]?.role === 'system')
+            history[0] = { ...history[0], content: stablePrompt };
+        else
+            history.unshift({ role: 'system', content: stablePrompt });
         const transientBundle = await buildTransientPromptBundle({
             cwd,
             tools: turnTools,
@@ -266,6 +279,7 @@ export async function runPrintMode(provider, args, initialHistory, options) {
                 surface: 'cli',
                 cwd,
                 workspaceId: workspace?.id,
+                sessionId,
                 interactiveAsk: false,
                 memoryAccess: runtimeContext.memoryAccess,
                 currentUserInput: prompt,
@@ -282,6 +296,7 @@ export async function runPrintMode(provider, args, initialHistory, options) {
             imageMaxLongSidePixel: imageOptions.imageMaxLongSidePixel,
             allowedTools: turnTools.map((tool) => tool.name),
             runtimeContext,
+            sessionState,
             ...(transientBundle ? { transientBundle } : {}),
             promptCache: createPromptCacheContext(`workspace:${workspace?.id ?? cwd}:session:${sessionId}`),
             memoryContext: memoryContextFromRuntime(runtimeContext),

package/src/cli/print.ts

@@ -29,7 +29,9 @@ import { workspaceIndexService } from '../context/workspaceIndex.js';
 import { normalizeImageDetail } from '../multimodal.js';
 import type { DeliverableManifest, FileActivityMetadata, HarnessDiagnostics, ImageInputSpec, LoopEvent, Message, Provider } from '../types.js';
 import { runWithPlugins } from '../plugins/pluginRunner.js';
-import { buildTransientPromptBundle } from '../prompts/system.js';
+import { buildBaseSystemPrompt, buildTransientPromptBundle } from '../prompts/system.js';
+import { getOrCreateSessionState, sessionStateKey } from '../session/sessionState.js';
+import { hydrateSessionWorktree } from '../tools/worktree/sessionWorktree.js';
 import { ALL_TOOLS } from '../tools/index.js';
 import { createPromptCacheContext } from '../llm/promptCache.js';
 import {
@@ -325,10 +327,16 @@ export async function runPrintMode(
   });
 
   try {
-    const cwd = options.workspace?.cwd ?? process.cwd();
-    const workspace = await workspaceIndexService.findByPath(cwd).catch(() => null);
+    const workspaceRoot = options.workspace?.cwd ?? process.cwd();
+    const workspace = await workspaceIndexService.findByPath(workspaceRoot).catch(() => null);
     const sessionId = options.workspace?.sessionId ?? 'default';
-    const conversationKey = `workspace:${workspace?.id ?? cwd}:session:${sessionId}`;
+    const sessionState = getOrCreateSessionState(sessionStateKey({
+      surface: 'cli', workspaceId: workspace?.id,
+      cwd: workspace?.id ? undefined : workspaceRoot, sessionId,
+    }));
+    await hydrateSessionWorktree({ sessionState, workspaceId: workspace?.id, sessionId, cwd: workspaceRoot });
+    const cwd = sessionState.activeWorktree?.path ?? workspaceRoot;
+    const conversationKey = `workspace:${workspace?.id ?? workspaceRoot}:session:${sessionId}`;
     const computerRun = options.computerUseMode && options.computerUseMode !== 'disabled'
       ? createCliComputerRun({
           mode: options.computerUseMode,
@@ -352,6 +360,9 @@ export async function runPrintMode(
       computer: computerRun,
     });
     const turnTools = filterToolsForRuntime(ALL_TOOLS, runtimeContext);
+    const stablePrompt = await buildBaseSystemPrompt(cwd, turnTools);
+    if (history[0]?.role === 'system') history[0] = { ...history[0], content: stablePrompt };
+    else history.unshift({ role: 'system', content: stablePrompt });
     const transientBundle = await buildTransientPromptBundle({
       cwd,
       tools: turnTools,
@@ -359,6 +370,7 @@ export async function runPrintMode(
         surface: 'cli',
         cwd,
         workspaceId: workspace?.id,
+        sessionId,
         interactiveAsk: false,
         memoryAccess: runtimeContext.memoryAccess,
         currentUserInput: prompt,
@@ -375,6 +387,7 @@ export async function runPrintMode(
       imageMaxLongSidePixel: imageOptions.imageMaxLongSidePixel,
       allowedTools: turnTools.map((tool) => tool.name),
       runtimeContext,
+      sessionState,
       ...(transientBundle ? { transientBundle } : {}),
       promptCache: createPromptCacheContext(
         `workspace:${workspace?.id ?? cwd}:session:${sessionId}`,

package/src/cli/streamJson.js

@@ -28,7 +28,9 @@ import { saveContext } from '../context/persistContext.js';
 import { setAskHandler } from '../askBridge.js';
 import { normalizeImageDetail } from '../multimodal.js';
 import { runWithPlugins } from '../plugins/pluginRunner.js';
-import { buildTransientPromptBundle } from '../prompts/system.js';
+import { buildBaseSystemPrompt, buildTransientPromptBundle } from '../prompts/system.js';
+import { getOrCreateSessionState, sessionStateKey } from '../session/sessionState.js';
+import { hydrateSessionWorktree } from '../tools/worktree/sessionWorktree.js';
 import { ALL_TOOLS } from '../tools/index.js';
 import { createPromptCacheContext } from '../llm/promptCache.js';
 import { createAgentRuntimeContext, filterToolsForRuntime, memoryContextFromRuntime, } from '../runtime/agentRuntimeContext.js';
@@ -267,10 +269,16 @@ export async function runStreamJsonMode(provider, args, initialHistory, options)
         void finalize().finally(() => process.exit(130));
     });
     try {
-        const cwd = options.workspace?.cwd ?? getWorkingDir();
-        const workspace = await workspaceIndexService.findByPath(cwd).catch(() => null);
+        const workspaceRoot = options.workspace?.cwd ?? getWorkingDir();
+        const workspace = await workspaceIndexService.findByPath(workspaceRoot).catch(() => null);
         const sessionId = options.workspace?.sessionId ?? 'default';
-        const conversationKey = `workspace:${workspace?.id ?? cwd}:session:${sessionId}`;
+        const sessionState = getOrCreateSessionState(sessionStateKey({
+            surface: 'headless', workspaceId: workspace?.id,
+            cwd: workspace?.id ? undefined : workspaceRoot, sessionId,
+        }));
+        await hydrateSessionWorktree({ sessionState, workspaceId: workspace?.id, sessionId, cwd: workspaceRoot });
+        const cwd = sessionState.activeWorktree?.path ?? workspaceRoot;
+        const conversationKey = `workspace:${workspace?.id ?? workspaceRoot}:session:${sessionId}`;
         const computerRun = options.computerUseMode && options.computerUseMode !== 'disabled'
             ? createCliComputerRun({
                 mode: options.computerUseMode,
@@ -294,6 +302,11 @@ export async function runStreamJsonMode(provider, args, initialHistory, options)
             computer: computerRun,
         });
         const turnTools = filterToolsForRuntime(ALL_TOOLS, runtimeContext);
+        const stablePrompt = await buildBaseSystemPrompt(cwd, turnTools);
+        if (history[0]?.role === 'system')
+            history[0] = { ...history[0], content: stablePrompt };
+        else
+            history.unshift({ role: 'system', content: stablePrompt });
         const transientBundle = await buildTransientPromptBundle({
             cwd,
             tools: turnTools,
@@ -301,6 +314,7 @@ export async function runStreamJsonMode(provider, args, initialHistory, options)
                 surface: 'headless',
                 cwd,
                 workspaceId: workspace?.id,
+                sessionId,
                 interactiveAsk: control,
                 memoryAccess: runtimeContext.memoryAccess,
                 currentUserInput: prompt,
@@ -316,6 +330,7 @@ export async function runStreamJsonMode(provider, args, initialHistory, options)
             imageDetail: cliImageOptions.imageDetail,
             imageMaxLongSidePixel: cliImageOptions.imageMaxLongSidePixel,
             runtimeContext,
+            sessionState,
             allowedTools: turnTools.map((tool) => tool.name),
             ...(transientBundle ? { transientBundle } : {}),
             promptCache: createPromptCacheContext(`workspace:${workspace?.id ?? cwd}:session:${sessionId}`),