nolo-cli 0.1.32 → 0.1.33

package/client/localRuntimeAdapter.test.ts

@@ -3,7 +3,6 @@ import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { createHostRuntimeConfig } from "../agent-runtime";
 import { runLocalAgentTurn } from "../agent-runtime/localLoop";
 import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
 
@@ -23,9 +22,7 @@ describe("CLI local runtime adapter", () => {
     "searchFiles",
   ];
   const SHELL_LOCAL_CODING_TOOL_NAMES = [
-    "readFile",
-    "writeFile",
-    "editFile",
+    ...DEFAULT_LOCAL_CODING_TOOL_NAMES,
     "execShell",
   ];
 
@@ -33,14 +30,6 @@ describe("CLI local runtime adapter", () => {
     return request?.body?.tools?.map((tool: any) => tool.function.name) ?? [];
   }
 
-  function createCliHostRuntimeConfig(allowShell = false, workspaceBinding: "explicit-cwd" | "default-cwd" = "explicit-cwd") {
-    return createHostRuntimeConfig({
-      surface: "cli-local",
-      workspaceBinding,
-      allowShell,
-    });
-  }
-
   test("loads agent/history from LevelDB and saves dialog/message records back to LevelDB", async () => {
     const requests: Array<{ url: string; body: any; auth: string | null }> = [];
     const store = new Map<string, any>([
@@ -289,57 +278,6 @@ describe("CLI local runtime adapter", () => {
     });
   });
 
-  test("runs apiSource=cli agents through the local CLI executor even when direct provider env is present", async () => {
-    const executions: Array<{ provider: string; prompt: string; options: any }> = [];
-    const adapter = createCliLocalRuntimeAdapter({
-      env: {
-        OPENAI_API_KEY: "sk-local",
-        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
-      },
-      cwd: import.meta.dir,
-      db: {
-        get: async () => ({
-          dbKey: "agent-local-frontend",
-          id: "frontend",
-          apiSource: "cli",
-          cliProvider: "agy",
-          prompt: "Fix UI",
-          model: "",
-        }),
-        put: async () => {},
-        batch: async () => {},
-        iterator: () => (async function* () {})(),
-      },
-      fetchImpl: async () => {
-        throw new Error("OpenAI-compatible fetch should not run for local CLI agents");
-      },
-      executeCli: async (provider, prompt, options) => {
-        executions.push({ provider, prompt, options });
-        return { text: "cli local ok", raw: "cli local ok", elapsed: 10 };
-      },
-    });
-
-    const result = await runLocalAgentTurn({
-      adapter,
-      agentRef: "frontend",
-      input: "make it cleaner",
-    });
-
-    expect(result).toMatchObject({
-      content: "cli local ok",
-      model: "agy",
-    });
-    expect(executions).toEqual([{
-      provider: "agy",
-      prompt: "make it cleaner",
-      options: expect.objectContaining({
-        cwd: import.meta.dir,
-        yolo: true,
-        systemPrompt: "Fix UI",
-      }),
-    }]);
-  });
-
   test("uses agent customProviderUrl for local OpenAI-compatible requests", async () => {
     const requests: Array<{ url: string; auth: string | null; body: any }> = [];
     const store = new Map<string, any>([
@@ -746,10 +684,6 @@ describe("CLI local runtime adapter", () => {
         id: "shell",
         prompt: "Use shell.",
         model: "gpt-4.1-mini",
-        runtimeToolPolicy: {
-          version: 1,
-          runtimeTools: ["execShell"],
-        },
       }],
     ]);
     const adapter = createCliLocalRuntimeAdapter({
@@ -1054,28 +988,17 @@ describe("CLI local runtime adapter", () => {
     });
   });
 
-  test("rejects execShell when the host disables shell even if the agent requested it", async () => {
+  test("rejects tools unless the local tool policy allows and registers them", async () => {
     const adapter = createCliLocalRuntimeAdapter({
-      env: { NOLO_LOCAL_USER_ID: "user-1" },
-      hostRuntimeConfig: createCliHostRuntimeConfig(),
-      db: {
-        get: async () => ({
-          dbKey: "agent-user-1-shell",
-          toolNames: ["execShell"],
-        }),
-        put: async () => {},
-        batch: async () => {},
-        iterator: () => (async function* () {})(),
-      },
+      env: {},
       fetchImpl: async () => Response.json({}),
     });
 
-    await adapter.loadAgentConfig("shell");
     await expect(adapter.executeTool({
       id: "call-1",
       name: "execShell",
       arguments: "{}",
-    })).rejects.toThrow("execShell is not requested by this agent runtime.");
+    })).rejects.toThrow("execShell requires NOLO_LOCAL_SHELL_MODE");
   });
 
   test("executes explicitly allowed registered local tools declared by the agent", async () => {
@@ -1117,22 +1040,19 @@ describe("CLI local runtime adapter", () => {
     expect(result.content).toContain("README.md");
   });
 
-  test("defaults the CLI local host runtime to shell-on when runtimeToolPolicy requests execShell", async () => {
+  test("advertises execShell to OpenAI-compatible providers when shell mode is enabled", async () => {
     const requests: Array<{ body: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
       env: {
         OPENAI_API_KEY: "sk-local",
         NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+        NOLO_LOCAL_SHELL_MODE: "worktree",
       },
       db: {
         get: async () => ({
           dbKey: "agent-local-shell",
           prompt: "Use shell.",
           model: "gpt-4.1-mini",
-          runtimeToolPolicy: {
-            version: 1,
-            runtimeTools: ["execShell"],
-          },
         }),
         put: async () => {},
         batch: async () => {},
@@ -1155,81 +1075,6 @@ describe("CLI local runtime adapter", () => {
     expect(toolNamesFromRequest(requests[0])).toEqual(SHELL_LOCAL_CODING_TOOL_NAMES);
   });
 
-  test("keeps advertised fallback workspace tools executable when shell is explicitly disabled", async () => {
-    const workspaceRoot = mkdtempSync(join(tmpdir(), "nolo-cli-runtime-shell-off-"));
-    try {
-      const adapter = createCliLocalRuntimeAdapter({
-        env: {},
-        hostRuntimeConfig: createCliHostRuntimeConfig(false),
-        db: {
-          get: async () => ({
-            dbKey: "agent-local-shell-off",
-            runtimeToolPolicy: {
-              version: 1,
-              runtimeTools: ["execShell"],
-            },
-          }),
-          put: async () => {},
-          batch: async () => {},
-          iterator: () => (async function* () {})(),
-        },
-        cwd: workspaceRoot,
-        fetchImpl: async () => Response.json({}),
-      });
-
-      await adapter.loadAgentConfig("shell-off");
-      const result = await adapter.executeTool({
-        id: "call-list-files",
-        name: "listFiles",
-        arguments: JSON.stringify({ path: "." }),
-      });
-
-      expect(result.metadata).toMatchObject({ path: ".", count: 0 });
-      expect(result.content).toBe("");
-    } finally {
-      rmSync(workspaceRoot, { recursive: true, force: true });
-    }
-  });
-
-  test("does not advertise execShell when only a legacy runtimeToolPolicy.shell block is present", async () => {
-    const requests: Array<{ body: any }> = [];
-    const adapter = createCliLocalRuntimeAdapter({
-      env: {
-        OPENAI_API_KEY: "sk-local",
-        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
-      },
-      hostRuntimeConfig: createCliHostRuntimeConfig(true),
-      db: {
-        get: async () => ({
-          dbKey: "agent-local-legacy-shell",
-          prompt: "Do not get shell from legacy policy.",
-          model: "gpt-4.1-mini",
-          runtimeToolPolicy: {
-            version: 1,
-            shell: { enabled: true, mode: "worktree" },
-          },
-        }),
-        put: async () => {},
-        batch: async () => {},
-        iterator: () => (async function* () {})(),
-      },
-      fetchImpl: async (_url, init) => {
-        requests.push({ body: JSON.parse(String(init?.body)) });
-        return Response.json({
-          choices: [{ message: { content: "done" } }],
-        });
-      },
-    });
-
-    await runLocalAgentTurn({
-      adapter,
-      agentRef: "legacy-shell",
-      input: "pwd",
-    });
-
-    expect(toolNamesFromRequest(requests[0])).not.toContain("execShell");
-  });
-
   test("allows default semantic workspace tools without legacy agent tool declarations", async () => {
     const workspaceRoot = mkdtempSync(join(tmpdir(), "nolo-cli-runtime-"));
     try {
@@ -1391,17 +1236,13 @@ describe("CLI local runtime adapter", () => {
     }
   });
 
-  test("runs execShell locally when the host grants shell capability", async () => {
+  test("runs execShell locally in explicit worktree shell mode", async () => {
     const adapter = createCliLocalRuntimeAdapter({
-      env: {},
-      hostRuntimeConfig: createCliHostRuntimeConfig(true),
+      env: { NOLO_LOCAL_SHELL_MODE: "worktree" },
       db: {
         get: async () => ({
           dbKey: "agent-local-shell",
-          runtimeToolPolicy: {
-            version: 1,
-            runtimeTools: ["execShell"],
-          },
+          toolNames: ["execShell"],
         }),
         put: async () => {},
         batch: async () => {},

package/client/localRuntimeAdapter.ts

@@ -7,7 +7,6 @@ import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
 import {
   buildLocalWorkspacePolicyToolNames,
-  resolveLocalWorkspaceShellToolExposure,
   buildLocalWorkspaceToolset,
   buildLocalWorkspaceOpenAiTools,
   buildOpenAiCompatibleChatCompletionRequest,
@@ -16,11 +15,8 @@ import {
   parseOpenAiCompatibleChatCompletionResponse,
   parsePlatformChatCompletionData,
   parsePlatformChatCompletionResponse,
-  resolveHostRuntimeConfigFromEnv,
   resolvePlatformChatProviderConfig,
-  resolveRequestedRuntimeToolNames,
   shouldUsePlatformChatProvider,
-  type HostRuntimeConfig,
 } from "../agentRuntimeLocal";
 import type { AgentRuntimeChatMessage } from "../agent-runtime";
 import { getDefaultCliLocalRuntimeDb } from "../localRuntimeDb";
@@ -52,29 +48,6 @@ import {
 type EnvLike = Record<string, string | undefined>;
 type FetchInput = Parameters<typeof fetch>[0];
 type FetchInit = Parameters<typeof fetch>[1];
-type CliLocalRuntimeCliExecution = {
-  text: string;
-  raw?: string;
-  elapsed?: number;
-  warnings?: string[];
-};
-type CliLocalRuntimeCliExecutor = (
-  provider: string,
-  prompt: string,
-  options: {
-    model?: string;
-    timeout?: number;
-    cwd?: string;
-    yolo?: boolean;
-    env?: EnvLike;
-    systemPrompt?: string;
-    reasoningEffort?: "low" | "medium" | "high" | "xhigh" | "max";
-    temperature?: number;
-    topP?: number;
-    frequencyPenalty?: number;
-    maxTokens?: number;
-  }
-) => Promise<CliLocalRuntimeCliExecution>;
 const TRANSIENT_FETCH_MAX_ATTEMPTS = 8;
 const TRANSIENT_FETCH_RETRY_BASE_DELAY_MS = 250;
 
@@ -82,17 +55,16 @@ export type CliLocalRuntimeDb = CliKvDb;
 
 export type CliLocalRuntimeAdapterDeps = {
   env: EnvLike;
-  hostRuntimeConfig?: HostRuntimeConfig;
   db?: CliLocalRuntimeDb;
   store?: HybridRecordStore;
   now?: () => number;
   createId?: () => string;
   fetchImpl?: typeof fetch;
   cwd?: string;
+  useCwdAsTaskWorkspaceBase?: boolean;
   output?: { write(chunk: string): unknown };
   prepareTaskWorktree?: typeof prepareTaskWorktree;
   localToolExecutors?: Record<string, (call: any) => Promise<{ content: string; metadata?: Record<string, unknown> }>>;
-  executeCli?: CliLocalRuntimeCliExecutor;
   sleep?: (ms: number) => Promise<void>;
   loopbackRequest?: (input: FetchInput, init?: FetchInit) => Promise<Response>;
 };
@@ -101,15 +73,6 @@ async function defaultLocalRuntimeDb(): Promise<CliLocalRuntimeDb> {
   return getDefaultCliLocalRuntimeDb();
 }
 
-async function defaultExecuteCli(
-  provider: string,
-  prompt: string,
-  options: Parameters<CliLocalRuntimeCliExecutor>[2]
-) {
-  const { executeCli } = await import("../ai/agent/cliExecutor");
-  return executeCli(provider as any, prompt, options);
-}
-
 function createFallbackId() {
   return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`.toUpperCase();
 }
@@ -118,6 +81,10 @@ function resolveLocalUserId(env: EnvLike) {
   return env.NOLO_LOCAL_USER_ID || env.NOLO_USER_ID || "local";
 }
 
+function shellModeEnabled(env: EnvLike) {
+  return ["worktree", "dangerous", "1", "true"].includes(env.NOLO_LOCAL_SHELL_MODE || "");
+}
+
 function parseLocalToolBudgets(env: EnvLike) {
   const raw = env.NOLO_LOCAL_TOOL_BUDGETS?.trim();
   if (!raw) return {};
@@ -234,52 +201,32 @@ async function fetchWithTransientRetry(
   throw lastError;
 }
 
-function buildOpenAiTools(args: {
-  requestedToolNames?: string[];
-  platformToolNames?: string[];
-  hostRuntimeConfig: HostRuntimeConfig;
-}) {
-  const toolset = buildLocalWorkspaceToolsetForHost(args);
+function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
+  const toolset = buildLocalWorkspaceToolsetForEnv(args);
   return [
     ...buildLocalWorkspaceOpenAiTools({
       toolNames: toolset.toolNames,
       exposeShellTools: toolset.exposeShellTools,
     }),
-    ...buildServerPlatformOpenAiTools({ toolNames: args.platformToolNames }),
+    ...buildServerPlatformOpenAiTools({ toolNames: args.toolNames }),
   ];
 }
 
-function buildLocalWorkspaceToolsetForHost(args: {
-  requestedToolNames?: string[];
-  hostRuntimeConfig: HostRuntimeConfig;
-}) {
-  const requestedToolNames = args.requestedToolNames ?? [];
-  const exposeShellTools = resolveLocalWorkspaceShellToolExposure({
-    declaredToolNames: requestedToolNames,
-    hostRuntimeConfig: args.hostRuntimeConfig,
-  });
+function buildLocalWorkspaceToolsetForEnv(args: { toolNames?: string[]; env: EnvLike }) {
   const toolset = buildLocalWorkspaceToolset({
-    declaredToolNames: requestedToolNames,
-    exposeShellTools,
+    declaredToolNames: args.toolNames,
+    exposeShellTools: shellModeEnabled(args.env),
   });
   return toolset;
 }
 
-function buildLocalPolicyToolNames(args: {
-  requestedToolNames?: string[];
-  platformToolNames?: string[];
-  hostRuntimeConfig: HostRuntimeConfig;
-}) {
-  const exposeShellTools = resolveLocalWorkspaceShellToolExposure({
-    declaredToolNames: args.requestedToolNames,
-    hostRuntimeConfig: args.hostRuntimeConfig,
-  });
+function buildLocalPolicyToolNames(args: { toolNames?: string[]; env: EnvLike }) {
   return [
     ...buildLocalWorkspacePolicyToolNames({
-      declaredToolNames: args.requestedToolNames,
-      exposeShellTools,
+      declaredToolNames: args.toolNames,
+      exposeShellTools: shellModeEnabled(args.env),
     }),
-    ...((args.platformToolNames ?? []).includes("taskRun") ? ["taskRun"] : []),
+    ...((args.toolNames ?? []).includes("taskRun") ? ["taskRun"] : []),
   ];
 }
 
@@ -365,33 +312,6 @@ function readLocalWorkspaceMode(agentConfig: AgentRuntimeAgentConfig | null) {
   return value === "task-worktree" ? "task-worktree" : "current";
 }
 
-function extractRuntimeMessageText(content: AgentRuntimeChatMessage["content"]) {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return "";
-  return content
-    .filter((part): part is Extract<typeof part, { type: "text" }> => part?.type === "text")
-    .map((part) => part.text ?? "")
-    .join("");
-}
-
-function buildCliTaskPromptFromMessages(messages: AgentRuntimeChatMessage[]) {
-  const history = messages
-    .filter((message) => message.role === "user" || message.role === "assistant")
-    .map((message) => {
-      const text = extractRuntimeMessageText(message.content).trim();
-      if (!text) return null;
-      return `[${message.role === "user" ? "用户" : "助手"}]\n${text}`;
-    })
-    .filter((message): message is string => Boolean(message))
-    .slice(-6);
-
-  if (history.length === 0) return "";
-  if (history.length === 1 && history[0]?.startsWith("[用户]\n")) {
-    return history[0].slice("[用户]\n".length);
-  }
-  return `请基于以下最近对话继续完成当前任务。\n\n${history.join("\n\n")}`;
-}
-
 async function resolveStore(deps: CliLocalRuntimeAdapterDeps) {
   if (deps.store) return deps.store;
   return createCliHybridRecordStore({
@@ -462,18 +382,12 @@ export function createCliLocalRuntimeAdapter(
   const createId = deps.createId ?? createFallbackId;
   const fetchImpl = deps.fetchImpl ?? fetch;
   const loopbackRequest = deps.loopbackRequest ?? (deps.fetchImpl ? undefined : defaultLoopbackRequest);
-  const executeCli = deps.executeCli ?? defaultExecuteCli;
   const userId = resolveLocalUserId(deps.env);
-  const hostRuntimeConfig = deps.hostRuntimeConfig ?? resolveHostRuntimeConfigFromEnv({
-    env: deps.env,
-    surface: "cli-local",
-    workspaceBinding: "explicit-cwd",
-  });
   const localToolBudgets = parseLocalToolBudgets(deps.env);
   const localToolUsage = new Map<string, number>();
   let activeAgentToolNames: string[] = [];
   let workspaceSession: WorkspaceSession = createWorkspaceSession(
-    hostRuntimeConfig.workspaceBinding === "default-cwd"
+    deps.useCwdAsTaskWorkspaceBase
       ? { defaultCwd: deps.cwd }
       : { cwd: deps.cwd }
   );
@@ -514,13 +428,9 @@ export function createCliLocalRuntimeAdapter(
         store: await resolveStore(deps),
         userId,
       });
-      const requestedToolNames = agentConfig
-        ? resolveRequestedRuntimeToolNames({ agentConfig })
-        : [];
       activeAgentToolNames = buildLocalPolicyToolNames({
-        requestedToolNames,
-        platformToolNames: agentConfig?.toolNames,
-        hostRuntimeConfig,
+        toolNames: agentConfig?.toolNames,
+        env: deps.env,
       });
       await activateAgentWorkspaceSession({ agentRef, agentConfig });
       return agentConfig;
@@ -538,48 +448,6 @@ export function createCliLocalRuntimeAdapter(
       cwd: workspaceSession.workspaceRoot,
     }),
     resolveProvider: async (agentConfig) => {
-      if (agentConfig.apiSource === "cli") {
-        const cliProvider = String(agentConfig.cliProvider || "copilot").trim() || "copilot";
-        return {
-          model: agentConfig.model || cliProvider,
-          complete: async (messages) => {
-            const [firstMessage, ...remainingMessages] = messages;
-            const systemPrompt = firstMessage?.role === "system"
-              ? extractRuntimeMessageText(firstMessage.content).trim()
-              : "";
-            const taskPrompt = buildCliTaskPromptFromMessages(
-              firstMessage?.role === "system" ? remainingMessages : messages
-            );
-            const result = await executeCli(cliProvider, taskPrompt, {
-              ...(agentConfig.model ? { model: agentConfig.model } : {}),
-              cwd: workspaceSession.workspaceRoot,
-              yolo: true,
-              env: deps.env,
-              ...(systemPrompt ? { systemPrompt } : {}),
-              ...(typeof agentConfig.reasoning_effort === "string"
-                ? { reasoningEffort: agentConfig.reasoning_effort as "low" | "medium" | "high" | "xhigh" | "max" }
-                : {}),
-              ...(typeof agentConfig.temperature === "number"
-                ? { temperature: agentConfig.temperature }
-                : {}),
-              ...(typeof agentConfig.top_p === "number" ? { topP: agentConfig.top_p } : {}),
-              ...(typeof agentConfig.frequency_penalty === "number"
-                ? { frequencyPenalty: agentConfig.frequency_penalty }
-                : {}),
-              ...(typeof agentConfig.max_tokens === "number"
-                ? { maxTokens: agentConfig.max_tokens }
-                : {}),
-            });
-            return {
-              content: result.text,
-              model: agentConfig.model || cliProvider,
-              provider: cliProvider,
-              trace: messages,
-            };
-          },
-        };
-      }
-
       if (shouldUsePlatformChatProvider(deps.env, agentConfig)) {
         const providerConfig = resolvePlatformChatProviderConfig({
           agentConfig,
@@ -588,11 +456,9 @@ export function createCliLocalRuntimeAdapter(
         return {
           model: providerConfig.model,
           complete: async (messages) => {
-            const requestedToolNames = resolveRequestedRuntimeToolNames({ agentConfig });
             const tools = buildOpenAiTools({
-              requestedToolNames,
-              platformToolNames: agentConfig.toolNames,
-              hostRuntimeConfig,
+              toolNames: agentConfig.toolNames,
+              env: deps.env,
             });
             const request = buildPlatformChatCompletionRequest({
               providerConfig,
@@ -623,11 +489,9 @@ export function createCliLocalRuntimeAdapter(
       return {
         model: providerConfig.model,
         complete: async (messages) => {
-          const requestedToolNames = resolveRequestedRuntimeToolNames({ agentConfig });
           const tools = buildOpenAiTools({
-            requestedToolNames,
-            platformToolNames: agentConfig.toolNames,
-            hostRuntimeConfig,
+            toolNames: agentConfig.toolNames,
+            env: deps.env,
           });
           const request = buildOpenAiCompatibleChatCompletionRequest({
             providerConfig,
@@ -658,7 +522,6 @@ export function createCliLocalRuntimeAdapter(
       });
       const result = await executeLocalToolWithPolicy({
         env: deps.env,
-        hostRuntimeConfig,
         agentToolNames: activeAgentToolNames,
         call,
         executors: localToolExecutors,

package/client/localToolPolicy.test.ts

@@ -1,47 +1,24 @@
 import { describe, expect, test } from "bun:test";
 
 import { executeLocalToolWithPolicy, resolveLocalToolPolicy } from "./localToolPolicy";
-import { createHostRuntimeConfig } from "../agent-runtime";
-
-function createCliHostRuntimeConfig(allowShell = false) {
-  return createHostRuntimeConfig({
-    surface: "cli-local",
-    workspaceBinding: "explicit-cwd",
-    allowShell,
-  });
-}
 
 describe("CLI local tool policy", () => {
-  test("allows execShell when the host grants shell capability", () => {
+  test("allows execShell in explicit worktree shell mode", () => {
     expect(resolveLocalToolPolicy({
-      env: {},
-      hostRuntimeConfig: createCliHostRuntimeConfig(true),
-      agentToolNames: ["execShell"],
+      env: { NOLO_LOCAL_SHELL_MODE: "worktree" },
+      agentToolNames: [],
       toolName: "execShell",
     })).toEqual({ allowed: true, toolName: "execShell" });
   });
 
-  test("blocks execShell unless the host grants shell capability", () => {
+  test("blocks execShell unless explicit shell mode is enabled", () => {
     expect(resolveLocalToolPolicy({
       env: { NOLO_LOCAL_ALLOWED_TOOLS: "execShell" },
-      hostRuntimeConfig: createCliHostRuntimeConfig(),
       agentToolNames: ["execShell"],
       toolName: "execShell",
     })).toMatchObject({ allowed: false });
   });
 
-  test("blocks execShell when shell was not requested by the runtime", () => {
-    expect(resolveLocalToolPolicy({
-      env: {},
-      hostRuntimeConfig: createCliHostRuntimeConfig(true),
-      agentToolNames: [],
-      toolName: "execShell",
-    })).toMatchObject({
-      allowed: false,
-      reason: "execShell is not requested by this agent runtime.",
-    });
-  });
-
   test("requires both env allowlist and agent declaration", () => {
     expect(resolveLocalToolPolicy({
       env: { NOLO_LOCAL_ALLOWED_TOOLS: "readFile" },
@@ -59,7 +36,6 @@ describe("CLI local tool policy", () => {
   test("executes only registered tools after policy allows them", async () => {
     const result = await executeLocalToolWithPolicy({
       env: { NOLO_LOCAL_ALLOWED_TOOLS: "readFile" },
-      hostRuntimeConfig: createCliHostRuntimeConfig(),
       agentToolNames: ["readFile"],
       call: { id: "call-1", name: "readFile", arguments: "{\"path\":\"README.md\"}" },
       executors: {

package/client/streamingOutput.ts

@@ -1,4 +1,6 @@
-import type { OutputLike } from "../cliIoTypes";
+type OutputLike = {
+  write(chunk: string): unknown;
+};
 
 export function splitStreamingText(content: string): string[] {
   const Segmenter = Intl.Segmenter;

package/client/taskRunPrompt.ts

@@ -1,10 +1,27 @@
-import {
-  prependTaskRunPromptForRuntime,
-  type TaskRunPromptContext,
-} from "../taskRunPromptShared";
-
-export type { TaskRunPromptContext };
+export type TaskRunPromptContext = {
+  rowDbKey: string;
+  taskRunId?: string;
+  workItemId?: string;
+  artifactIds?: string[];
+};
 
 export function prependTaskRunPrompt(message: string, context?: TaskRunPromptContext): string {
-  return prependTaskRunPromptForRuntime(message, context, "cli");
+  if (!context?.rowDbKey) return message;
+  const artifactIds = context.artifactIds?.filter(Boolean) ?? [];
+  return [
+    "AI-native task-run context:",
+    "- This system is AI-native. The current task board is only the present observation and validation use case; different users, companies, and workflows may use different task owners later.",
+    "- Treat the task row meta as the durable execution context. Do not infer branch, runner, handoff, review, or blocker state from chat history alone.",
+    `- rowDbKey: ${context.rowDbKey}`,
+    ...(context.taskRunId ? [`- taskRunId: ${context.taskRunId}`] : []),
+    ...(context.workItemId ? [`- workItemId: ${context.workItemId}`] : []),
+    ...(artifactIds.length ? [`- artifactIds: ${artifactIds.join(",")}`] : []),
+    "- Handoff rule: start from the durable task context, then inspect existing refs such as workItems.dialogIds, workItems.outcome, review.dialogId, activityRefs, agentRuns.dialogId/resultSummary, and artifactRefs. Use dialog read/search for exact evidence.",
+    "- When you create, update, hand off, block, or review work, update the task context with `bun run task:run -- ...`.",
+    "- If this turn already includes a server TaskRun preflight snapshot, use that snapshot directly for read-only reporting or planning.",
+    "- Keep long reasoning and logs in the dialog; record only resumable references in task row meta.",
+    "",
+    "User task:",
+    message,
+  ].join("\n");
 }