nolo-cli 0.1.17 → 0.1.19

package/agent-runtime/hostAdapter.ts

@@ -33,6 +33,7 @@ export type AgentRuntimeSaveTurnInput = {
   agentKey: string;
   messages: AgentRuntimeChatMessage[];
   result: AgentRuntimeResult;
+  continueDialogId?: string;
 };
 
 export type AgentRuntimeHostAdapter = {

package/agent-runtime/localLoop.ts

@@ -44,6 +44,8 @@ export async function runLocalAgentTurn(
   const history = input.continueDialogId
     ? await input.adapter.loadDialogHistory(input.continueDialogId)
     : [];
+  const promptMessageCount = agentConfig.prompt?.trim() ? 1 : 0;
+  const turnStartIndex = promptMessageCount + history.length;
   const messages = buildMessages({
     prompt: agentConfig.prompt,
     history,
@@ -76,17 +78,23 @@ export async function runLocalAgentTurn(
         role: "tool",
         content: toolResult.content,
         tool_call_id: toolCall.id,
+        ...(toolResult.metadata ? { tool_result_metadata: toolResult.metadata } : {}),
       });
     }
   }
   result = result!;
+  messages.push({
+    role: "assistant",
+    content: result.content,
+  });
   const saved = await input.adapter.saveTurn({
     agentKey: agentConfig.key,
-    messages,
+    messages: messages.slice(turnStartIndex),
     result: {
       ...result,
       ...(toolCallCount > 0 ? { toolCallCount } : {}),
     },
+    ...(input.continueDialogId ? { continueDialogId: input.continueDialogId } : {}),
   });
 
   return {

package/agent-runtime/types.ts

@@ -33,6 +33,7 @@ export interface AgentRuntimeChatMessage {
   content: AgentRuntimeMessageContent;
   tool_call_id?: string;
   tool_calls?: AgentRuntimeToolCall[];
+  tool_result_metadata?: Record<string, unknown>;
   reasoning_content?: string;
   cybotKey?: string;
   agentKey?: string;

package/agentAliases.ts

@@ -0,0 +1,26 @@
+export const PLATFORM_DEMO_USER_ID = "b2e06f801f";
+export const FRONTEND_IMPLEMENTER_AGENT_ID = "01FRONTENDAG0000000115N4E1";
+export const FRONTEND_IMPLEMENTER_AGENT_KEY =
+  `agent-${PLATFORM_DEMO_USER_ID}-${FRONTEND_IMPLEMENTER_AGENT_ID}`;
+
+const AGENT_ALIAS_TO_KEY: Record<string, string> = {
+  "frontend-implementer": FRONTEND_IMPLEMENTER_AGENT_KEY,
+  "frontend-agent": FRONTEND_IMPLEMENTER_AGENT_KEY,
+  frontend: FRONTEND_IMPLEMENTER_AGENT_KEY,
+  "front-end": FRONTEND_IMPLEMENTER_AGENT_KEY,
+  "前端": FRONTEND_IMPLEMENTER_AGENT_KEY,
+  "前端实现员": FRONTEND_IMPLEMENTER_AGENT_KEY,
+};
+
+function parseAgentKeyFromInput(raw: string): string {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+    const url = new URL(trimmed);
+    return url.pathname.replace(/^\/+/, "");
+  }
+  return trimmed;
+}
+
+export function resolveCliAgentKeyInput(raw: string): string {
+  return AGENT_ALIAS_TO_KEY[raw.trim().toLowerCase()] ?? parseAgentKeyFromInput(raw);
+}

package/agentPullCommand.ts

@@ -1,6 +1,7 @@
 import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 import { getDefaultCliLocalRuntimeDb } from "./localRuntimeDb";
 import type { CliLocalRuntimeDb } from "./client/localRuntimeAdapter";
+import { resolveCliAgentKeyInput } from "./agentAliases";
 
 type EnvLike = Record<string, string | undefined>;
 
@@ -40,7 +41,7 @@ function positionalArgs(args: string[]) {
 export function parseAgentPullArgs(args: string[]): ParsedAgentPullArgs | null {
   const agentKey = readFlagValue(args, "--agent") ?? positionalArgs(args)[0];
   if (!agentKey?.trim()) return null;
-  return { agentKey: agentKey.trim() };
+  return { agentKey: resolveCliAgentKeyInput(agentKey) };
 }
 
 function resolveServerUrl(env: EnvLike) {

package/agentRunCommand.ts

@@ -2,7 +2,8 @@ import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 import { runAgentTurn, type RunAgentTurnResult } from "./client/agentRun";
 import type { AgentRuntimeRequestedMode } from "./agentRuntimeLocal";
 import { existsSync, readFileSync } from "node:fs";
-import { extname, resolve } from "node:path";
+import { extname, join, resolve } from "node:path";
+import { resolveCliAgentKeyInput } from "./agentAliases";
 
 type EnvLike = Record<string, string | undefined>;
 
@@ -15,6 +16,7 @@ type AgentRunCommandDeps = {
   scriptDir: string;
   output?: OutputLike;
   runner?: typeof runAgentTurn;
+  prepareShellWorktree?: typeof prepareShellWorktree;
 };
 
 type ParsedAgentRunArgs = {
@@ -82,7 +84,7 @@ export function parseAgentRunArgs(args: string[]): ParsedAgentRunArgs | null {
     ...readRepeatedFlagValues(args, "--image-url"),
   ];
   return {
-    agentKey,
+    agentKey: resolveCliAgentKeyInput(agentKey),
     message: message.trim(),
     imageUrls,
     allowShell: args.includes("--dangerously-allow-shell"),
@@ -117,6 +119,49 @@ function resolveServerUrl(env: EnvLike) {
   return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
 }
 
+function safePathSegment(input: string) {
+  return input.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "agent";
+}
+
+function createTaskId() {
+  return Date.now().toString(36).toUpperCase();
+}
+
+async function runGit(args: string[], cwd: string) {
+  const proc = Bun.spawn(["git", ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "ignore",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  if (exitCode !== 0) {
+    throw new Error(stderr.trim() || stdout.trim() || `git ${args.join(" ")} failed`);
+  }
+  return stdout.trim();
+}
+
+export async function prepareShellWorktree(args: {
+  agentKey: string;
+  cwd?: string;
+  env?: EnvLike;
+}) {
+  if (args.env?.NOLO_LOCAL_WORKTREE) return args.env.NOLO_LOCAL_WORKTREE;
+  const cwd = args.cwd ?? process.cwd();
+  const root = await runGit(["rev-parse", "--show-toplevel"], cwd);
+  const parent = join(root, ".worktrees");
+  const safeAgent = safePathSegment(args.agentKey);
+  const taskId = createTaskId();
+  const worktreePath = join(parent, `nolo-agent-${safeAgent}-${taskId}`);
+  const branchName = `nolo-agent-${safeAgent}-${taskId}`;
+  await runGit(["worktree", "add", worktreePath, "-b", branchName, "HEAD"], root);
+  return worktreePath;
+}
+
 function writeUsage(output: OutputLike) {
   output.write(
     "Usage: nolo agent run <agent> <message> [--local|--server|--auto] [--continue <dialogId>]\n" +
@@ -134,8 +179,28 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
   }
 
   const runner = deps.runner ?? runAgentTurn;
+  let localRuntimeCwd: string | undefined;
+  if (parsed.allowShell) {
+    try {
+      localRuntimeCwd = await (deps.prepareShellWorktree ?? prepareShellWorktree)({
+        agentKey: parsed.agentKey,
+        env,
+      });
+    } catch (error) {
+      output.write(
+        "[nolo] Could not prepare a local shell worktree.\n" +
+          "Run from inside a git repository, or set NOLO_LOCAL_WORKTREE to an existing isolated checkout.\n" +
+          `Reason: ${error instanceof Error ? error.message : String(error)}\n`
+      );
+      return 1;
+    }
+  }
   const runEnv = parsed.allowShell
-    ? { ...env, NOLO_LOCAL_SHELL_MODE: "worktree" }
+    ? {
+        ...env,
+        NOLO_LOCAL_SHELL_MODE: "worktree",
+        ...(localRuntimeCwd ? { NOLO_LOCAL_WORKTREE: localRuntimeCwd } : {}),
+      }
     : env;
   const result: RunAgentTurnResult = await runner({
     agentName: parsed.agentKey,
@@ -146,6 +211,7 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
     scriptDir: deps.scriptDir,
     env: runEnv,
     output,
+    ...(localRuntimeCwd ? { localRuntimeCwd } : {}),
     ...(parsed.runtimeMode ? { runtimeMode: parsed.runtimeMode } : {}),
     ...(parsed.continueDialogId ? { continueDialogId: parsed.continueDialogId } : {}),
   });

package/client/agentRun.ts

@@ -24,6 +24,7 @@ type RunAgentTurnOptions = {
   runtimeMode?: AgentRuntimeRequestedMode;
   localRuntimeAdapter?: AgentRuntimeHostAdapter;
   localRuntimeAdapterFactory?: (env: EnvLike) => AgentRuntimeHostAdapter;
+  localRuntimeCwd?: string;
   scriptPathExists?: (path: string) => boolean;
   fetchImpl?: typeof fetch;
 };
@@ -61,6 +62,7 @@ function buildDefaultLocalRuntimeAdapter(options: RunAgentTurnOptions) {
   return createCliLocalRuntimeAdapter({
     env: options.env,
     fetchImpl: options.fetchImpl,
+    cwd: options.localRuntimeCwd,
   });
 }
 

package/client/localRuntimeAdapter.test.ts

@@ -81,7 +81,7 @@ describe("CLI local runtime adapter", () => {
     expect(result).toMatchObject({
       content: "local adapter ok",
       model: "gpt-4.1-mini",
-      dialogId: "01LOCAL",
+      dialogId: "dialog-existing",
     });
     expect(requests).toEqual([{
       url: "http://127.0.0.1:11434/v1/chat/completions",
@@ -97,29 +97,210 @@ describe("CLI local runtime adapter", () => {
       },
     }]);
     expect(batchOps.map((op) => op.key)).toEqual([
-      "dialog-user-1-01LOCAL",
-      "dialog-01LOCAL-msg-user",
-      "dialog-01LOCAL-msg-assistant",
+      "dialog-user-1-dialog-existing",
+      "dialog-dialog-existing-msg-1710000000000-001",
+      "dialog-dialog-existing-msg-1710000000000-002",
     ]);
-    expect(store.get("dialog-user-1-01LOCAL")).toMatchObject({
-      id: "01LOCAL",
-      dbKey: "dialog-user-1-01LOCAL",
+    expect(store.get("dialog-user-1-dialog-existing")).toMatchObject({
+      id: "dialog-existing",
+      dbKey: "dialog-user-1-dialog-existing",
       type: "dialog",
       primaryAgentKey: "agent-user-1-frontend",
       status: "done",
     });
-    expect(store.get("dialog-01LOCAL-msg-user")).toMatchObject({
-      dialogId: "01LOCAL",
+    expect(store.get("dialog-dialog-existing-msg-1710000000000-001")).toMatchObject({
+      dialogId: "dialog-existing",
       role: "user",
       content: "make it cleaner",
     });
-    expect(store.get("dialog-01LOCAL-msg-assistant")).toMatchObject({
-      dialogId: "01LOCAL",
+    expect(store.get("dialog-dialog-existing-msg-1710000000000-002")).toMatchObject({
+      dialogId: "dialog-existing",
       role: "assistant",
       content: "local adapter ok",
     });
   });
 
+  test("saves local tool call trace and shell metadata into the local dialog", async () => {
+    const store = new Map<string, any>([
+      ["agent-user-1-shell", {
+        dbKey: "agent-user-1-shell",
+        id: "shell",
+        prompt: "Use shell.",
+        model: "gpt-4.1-mini",
+      }],
+    ]);
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+        NOLO_LOCAL_SHELL_MODE: "worktree",
+      },
+      db: {
+        get: async (key) => {
+          if (!store.has(key)) throw new Error(`not found: ${key}`);
+          return store.get(key);
+        },
+        put: async (key, value) => {
+          store.set(key, value);
+        },
+        batch: async (ops) => {
+          for (const op of ops) {
+            if (op.type === "put") store.set(op.key, op.value);
+          }
+        },
+        iterator: () => (async function* () {})(),
+      },
+      cwd: import.meta.dir,
+      now: () => 1710000000000,
+      createId: () => "01TRACE",
+      fetchImpl: async (_url, init) => {
+        const body = JSON.parse(String(init?.body));
+        const hasToolResult = body.messages.some((message: any) => message.role === "tool");
+        if (!hasToolResult) {
+          return Response.json({
+            choices: [{
+              message: {
+                content: "",
+                tool_calls: [{
+                  id: "call-shell",
+                  type: "function",
+                  function: {
+                    name: "execShell",
+                    arguments: JSON.stringify({ cmd: "printf trace-ok" }),
+                  },
+                }],
+              },
+            }],
+          });
+        }
+        return Response.json({
+          choices: [{ message: { content: "done" } }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "shell",
+      input: "inspect",
+    });
+
+    expect(result.dialogId).toBe("01TRACE");
+    expect(store.get("dialog-user-1-01TRACE")).toMatchObject({
+      toolCallCount: 1,
+      localRuntime: expect.objectContaining({
+        host: "cli",
+        worktreePath: import.meta.dir,
+      }),
+    });
+    const messages = [...store.entries()]
+      .filter(([key]) => key.startsWith("dialog-01TRACE-msg-"))
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([, value]) => value);
+    expect(messages.map((message) => message.role)).toEqual([
+      "user",
+      "assistant",
+      "tool",
+      "assistant",
+    ]);
+    expect(messages[1]).toMatchObject({
+      tool_calls: [{
+        id: "call-shell",
+        function: { name: "execShell" },
+      }],
+    });
+    expect(messages[2]).toMatchObject({
+      role: "tool",
+      toolCallId: "call-shell",
+      metadata: { exitCode: 0 },
+    });
+    expect(messages[2].content).toContain("trace-ok");
+    expect(messages[3]).toMatchObject({
+      role: "assistant",
+      content: "done",
+    });
+  });
+
+  test("continues a local dialog instead of creating a new one", async () => {
+    const store = new Map<string, any>([
+      ["agent-user-1-frontend", {
+        dbKey: "agent-user-1-frontend",
+        id: "frontend",
+        prompt: "Fix UI",
+        model: "gpt-4.1-mini",
+      }],
+      ["dialog-user-1-dialog-existing", {
+        dbKey: "dialog-user-1-dialog-existing",
+        id: "dialog-existing",
+        type: "dialog",
+        userId: "user-1",
+        title: "Existing dialog",
+      }],
+      ["dialog-dialog-existing-msg-001", {
+        dbKey: "dialog-dialog-existing-msg-001",
+        id: "msg-001",
+        dialogId: "dialog-existing",
+        role: "assistant",
+        content: "previous answer",
+      }],
+    ]);
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+      db: {
+        get: async (key) => {
+          if (!store.has(key)) throw new Error(`not found: ${key}`);
+          return store.get(key);
+        },
+        put: async (key, value) => {
+          store.set(key, value);
+        },
+        batch: async (ops) => {
+          for (const op of ops) {
+            if (op.type === "put") store.set(op.key, op.value);
+          }
+        },
+        iterator: ({ gte, lte }) => (async function* () {
+          for (const entry of [...store.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+            if (entry[0] >= gte && entry[0] <= lte) yield entry;
+          }
+        })(),
+      },
+      now: () => 1710000000000,
+      createId: () => "SHOULDNOTUSE",
+      fetchImpl: async (_url, init) => {
+        const body = JSON.parse(String(init?.body));
+        expect(body.messages).toContainEqual({
+          role: "assistant",
+          content: "previous answer",
+        });
+        return Response.json({
+          choices: [{ message: { content: "continued" } }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "frontend",
+      input: "continue",
+      continueDialogId: "dialog-existing",
+    });
+
+    expect(result.dialogId).toBe("dialog-existing");
+    expect(store.has("dialog-user-1-SHOULDNOTUSE")).toBe(false);
+    expect(store.get("dialog-user-1-dialog-existing")).toMatchObject({
+      id: "dialog-existing",
+      title: "Existing dialog",
+      status: "done",
+    });
+    expect([...store.keys()].filter((key) => key.startsWith("dialog-dialog-existing-msg-"))).toContain(
+      "dialog-dialog-existing-msg-1710000000000-001"
+    );
+  });
+
   test("passes image_url message parts through to OpenAI-compatible providers", async () => {
     const requests: Array<{ body: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
@@ -215,7 +396,7 @@ describe("CLI local runtime adapter", () => {
     expect(result.content).toContain("README.md");
   });
 
-  test("advertises execShell to OpenAI-compatible providers when the agent declares it", async () => {
+  test("advertises execShell to OpenAI-compatible providers when shell mode is enabled", async () => {
     const requests: Array<{ body: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
       env: {
@@ -228,7 +409,6 @@ describe("CLI local runtime adapter", () => {
           dbKey: "agent-local-shell",
           prompt: "Use shell.",
           model: "gpt-4.1-mini",
-          toolNames: ["execShell"],
         }),
         put: async () => {},
         batch: async () => {},

package/client/localRuntimeAdapter.ts

@@ -67,8 +67,14 @@ function buildExecShellTool() {
   };
 }
 
-function buildOpenAiTools(toolNames: string[] = []) {
-  return toolNames.includes("execShell") ? [buildExecShellTool()] : [];
+function shellModeEnabled(env: EnvLike) {
+  return ["worktree", "dangerous", "1", "true"].includes(env.NOLO_LOCAL_SHELL_MODE || "");
+}
+
+function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
+  return args.toolNames?.includes("execShell") || shellModeEnabled(args.env)
+    ? [buildExecShellTool()]
+    : [];
 }
 
 function parseToolArguments(raw: string) {
@@ -155,6 +161,8 @@ function toOpenAiMessages(messages: AgentRuntimeChatMessage[]) {
   return messages.map((message) => ({
     role: message.role,
     content: message.content ?? "",
+    ...(message.tool_call_id ? { tool_call_id: message.tool_call_id } : {}),
+    ...(Array.isArray(message.tool_calls) ? { tool_calls: message.tool_calls } : {}),
   }));
 }
 
@@ -186,8 +194,9 @@ async function writeDialog(args: {
   userId: string;
   now: () => number;
   createId: () => string;
+  cwd?: string;
 }) {
-  const dialogId = args.createId();
+  const dialogId = args.input.continueDialogId || args.createId();
   const now = args.now();
   const nowIso = new Date(now).toISOString();
   const dialogKey = `dialog-${args.userId}-${dialogId}`;
@@ -200,56 +209,74 @@ async function writeDialog(args: {
           .map((part) => part.text)
           .join(" ")
       : "";
+  let existingDialog: any = null;
+  if (args.input.continueDialogId) {
+    try {
+      existingDialog = await args.db.get(dialogKey);
+    } catch {
+      existingDialog = null;
+    }
+  }
+  const messageOps = args.input.messages
+    .filter((message) => message.role !== "system")
+    .map((message, index) => {
+      const id = `${now}-${String(index + 1).padStart(3, "0")}`;
+      const key = `dialog-${dialogId}-msg-${id}`;
+      return {
+        type: "put" as const,
+        key,
+        value: {
+          id,
+          dbKey: key,
+          dialogId,
+          role: message.role,
+          content: message.content ?? "",
+          ...(message.role === "user" ? { userId: args.userId } : {}),
+          ...(message.role === "assistant" ? {
+            agentKey: args.input.agentKey,
+            cybotKey: args.input.agentKey,
+          } : {}),
+          ...(message.tool_call_id ? { toolCallId: message.tool_call_id } : {}),
+          ...(Array.isArray(message.tool_calls) ? { tool_calls: message.tool_calls } : {}),
+          ...(message.tool_result_metadata ? { metadata: message.tool_result_metadata } : {}),
+          createdAt: nowIso,
+        },
+      };
+    });
   const ops: Array<{ type: "put"; key: string; value: any }> = [
     {
       type: "put",
       key: dialogKey,
       value: {
+        ...(existingDialog && typeof existingDialog === "object" ? existingDialog : {}),
         id: dialogId,
         dbKey: dialogKey,
         type: "dialog",
         userId: args.userId,
         cybots: [args.input.agentKey],
         primaryAgentKey: args.input.agentKey,
-        title: lastUserText.trim()
-          ? lastUserText.trim().slice(0, 80)
-          : "Local agent run",
+        title: typeof existingDialog?.title === "string" && existingDialog.title.trim()
+          ? existingDialog.title
+          : lastUserText.trim()
+            ? lastUserText.trim().slice(0, 80)
+            : "Local agent run",
         status: "done",
         triggerType: "cli-local",
         executionMode: "foreground",
-        createdAt: nowIso,
+        createdAt: existingDialog?.createdAt ?? nowIso,
         updatedAt: nowIso,
         finishedAt: now,
         usage: args.input.result.usage,
+        ...(typeof args.input.result.toolCallCount === "number"
+          ? { toolCallCount: args.input.result.toolCallCount }
+          : {}),
+        localRuntime: {
+          host: "cli",
+          ...(args.cwd ? { worktreePath: args.cwd } : {}),
+        },
       },
     },
-    {
-      type: "put",
-      key: `dialog-${dialogId}-msg-user`,
-      value: {
-        id: "msg-user",
-        dbKey: `dialog-${dialogId}-msg-user`,
-        dialogId,
-        role: "user",
-        content: lastUser?.content ?? "",
-        userId: args.userId,
-        createdAt: nowIso,
-      },
-    },
-    {
-      type: "put",
-      key: `dialog-${dialogId}-msg-assistant`,
-      value: {
-        id: "msg-assistant",
-        dbKey: `dialog-${dialogId}-msg-assistant`,
-        dialogId,
-        role: "assistant",
-        content: args.input.result.content,
-        agentKey: args.input.agentKey,
-        cybotKey: args.input.agentKey,
-        createdAt: nowIso,
-      },
-    },
+    ...messageOps,
   ];
   await args.db.batch(ops);
   return { dialogId };
@@ -287,11 +314,15 @@ export function createCliLocalRuntimeAdapter(
       userId,
       now,
       createId,
+      cwd: deps.cwd,
     }),
     resolveProvider: async (agentConfig) => ({
       model: agentConfig.model || "gpt-4.1-mini",
       complete: async (messages) => {
-        const tools = buildOpenAiTools(agentConfig.toolNames ?? []);
+        const tools = buildOpenAiTools({
+          toolNames: agentConfig.toolNames,
+          env: deps.env,
+        });
         const res = await fetchImpl(`${resolveOpenAiCompatibleBaseUrl(deps.env)}/chat/completions`, {
           method: "POST",
           headers: {

package/client/localToolPolicy.test.ts

@@ -6,7 +6,7 @@ describe("CLI local tool policy", () => {
   test("allows execShell in explicit worktree shell mode", () => {
     expect(resolveLocalToolPolicy({
       env: { NOLO_LOCAL_SHELL_MODE: "worktree" },
-      agentToolNames: ["execShell"],
+      agentToolNames: [],
       toolName: "execShell",
     })).toEqual({ allowed: true, toolName: "execShell" });
   });

package/client/localToolPolicy.ts

@@ -27,17 +27,13 @@ export function resolveLocalToolPolicy(args: {
 }): LocalToolPolicyDecision {
   if (args.toolName === "execShell") {
     const shellMode = args.env.NOLO_LOCAL_SHELL_MODE || "";
-    const agentTools = new Set(args.agentToolNames ?? []);
-    if (
-      agentTools.has("execShell") &&
-      ["worktree", "dangerous", "1", "true"].includes(shellMode)
-    ) {
+    if (["worktree", "dangerous", "1", "true"].includes(shellMode)) {
       return { allowed: true, toolName: args.toolName };
     }
     return {
       allowed: false,
       toolName: args.toolName,
-      reason: "execShell requires NOLO_LOCAL_SHELL_MODE=worktree and an agent that declares execShell.",
+      reason: "execShell requires NOLO_LOCAL_SHELL_MODE=worktree.",
     };
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {
@@ -10,6 +10,7 @@
   "files": [
     "index.ts",
     "agentRuntimeLocal.ts",
+    "agentAliases.ts",
     "localRuntimeDb.ts",
     "agentRuntimeCommands.ts",
     "agentPullCommand.ts",