nolo-cli 0.1.32 → 0.1.34

package/cli/tui/session.ts

@@ -1,50 +1,379 @@
-import {
-  type TuiInterpreterAction,
-  type TuiInterpreterResult,
-  type TuiCommandInterpreterDeps,
-  handleTuiInput as handleTuiInputWithDeps,
-} from "./tuiCommandInterpreter";
-import {
-  DEFAULT_TUI_SERVER_URL,
-  type EnvLike,
-  type TuiState,
-  createInitialTuiState,
-  renderContextPanel,
-  renderKnownAgents,
-  renderPrompt,
-  renderStatusLine,
-  renderTuiHelp,
-  renderWelcome,
-  resolveDialogLabel,
-} from "./tuiPresentation";
-import { DEFAULT_TUI_AGENT_KEY, KNOWN_AGENTS, KNOWN_AGENT_ALIASES } from "./tuiCatalog";
-
-export { DEFAULT_TUI_AGENT_KEY, DEFAULT_TUI_SERVER_URL, KNOWN_AGENTS, KNOWN_AGENT_ALIASES };
-export type { EnvLike, TuiState } from "./tuiPresentation";
-
-export type TuiAction = TuiInterpreterAction;
-export type TuiInputResult = TuiInterpreterResult;
-
-function createInterpreterDeps(): TuiCommandInterpreterDeps {
+import { DEFAULT_NOLO_SERVER_URL } from "../defaultServer";
+import type { AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
+
+export const DEFAULT_TUI_AGENT_KEY = "agent-pub-01NOLOAPPBLD000000019KCKT0";
+export const DEFAULT_TUI_SERVER_URL = DEFAULT_NOLO_SERVER_URL;
+
+const KNOWN_AGENTS: Array<{
+  name: string;
+  key: string;
+  description: string;
+}> = [
+  {
+    name: "nolo",
+    key: "agent-pub-01NOLOAPPBLD000000019KCKT0",
+    description: "one assistant that routes work across your agents and data",
+  },
+  {
+    name: "app-builder",
+    key: "agent-pub-01APPBUILDER00000001YAII3I",
+    description: "builds web apps, tools, charts, and product prototypes",
+  },
+];
+
+const KNOWN_AGENT_ALIASES: Record<string, { name: string; key: string }> =
+  Object.fromEntries(KNOWN_AGENTS.map((agent) => [agent.name, agent]));
+
+function shortenDialogId(dialogId: string) {
+  return dialogId.length > 12
+    ? `${dialogId.slice(0, 6)}...${dialogId.slice(-4)}`
+    : dialogId;
+}
+
+export function resolveDialogLabel(
+  state: Pick<TuiState, "dialogId" | "dialogLabel">
+) {
+  return state.dialogId ? shortenDialogId(state.dialogId) : state.dialogLabel;
+}
+
+export type TuiState = {
+  agentKey: string;
+  agentName: string;
+  dialogId?: string;
+  dialogLabel: string;
+  profileName: string;
+  serverUrl: string;
+  cliVersion?: string;
+  attachedDocs: string[];
+  runtimeMode: AgentRuntimeRequestedMode;
+};
+
+export type TuiAction =
+  | {
+      type: "chat";
+      message: string;
+      agentKey: string;
+      runtimeMode: AgentRuntimeRequestedMode;
+      continueDialogId?: string;
+    }
+  | {
+      type: "compact";
+      dialogId: string;
+    }
+  | {
+      type: "self-update";
+    }
+  | {
+      type: "exit";
+    };
+
+export type TuiInputResult = {
+  nextState: TuiState;
+  output: string;
+  action?: TuiAction;
+};
+
+type EnvLike = Record<string, string | undefined>;
+
+export function createInitialTuiState(env: EnvLike = process.env): TuiState {
+  const agentKey = env.NOLO_AGENT?.trim() || DEFAULT_TUI_AGENT_KEY;
+  const agentName = env.NOLO_AGENT_NAME?.trim() || "nolo";
+
   return {
-    knownAgents: KNOWN_AGENTS,
-    renderHelp: renderTuiHelp,
-    renderContextPanel,
-    renderKnownAgents,
+    agentKey,
+    agentName,
+    dialogId: env.NOLO_DIALOG_ID?.trim() || undefined,
+    dialogLabel: env.NOLO_DIALOG?.trim() || "new",
+    profileName: env.NOLO_PROFILE?.trim() || "local",
+    serverUrl: (env.NOLO_SERVER || env.BASE_URL || DEFAULT_TUI_SERVER_URL).replace(
+      /\/+$/,
+      ""
+    ),
+    cliVersion: env.NOLO_CLI_VERSION?.trim() || undefined,
+    attachedDocs: [],
+    runtimeMode: env.NOLO_RUNTIME_MODE === "local" || env.NOLO_RUNTIME_MODE === "server"
+      ? env.NOLO_RUNTIME_MODE
+      : "auto",
   };
 }
 
-export {
-  createInitialTuiState,
-  renderContextPanel,
-  renderKnownAgents,
-  renderPrompt,
-  renderStatusLine,
-  renderTuiHelp,
-  renderWelcome,
-  resolveDialogLabel,
-};
+export function renderStatusLine(state: TuiState) {
+  const docs =
+    state.attachedDocs.length > 0
+      ? String(state.attachedDocs.length)
+      : "0";
+
+  return [
+    `agent ${state.agentName}`,
+    `dialog ${resolveDialogLabel(state)}`,
+    `docs ${docs}`,
+    `runtime ${state.runtimeMode}`,
+    `profile ${state.profileName}`,
+  ].join(" | ");
+}
+
+export function renderWelcome(state: TuiState) {
+  const docs = state.attachedDocs.length > 0
+    ? `${state.attachedDocs.length} attached`
+    : "none";
+  return [
+    "",
+    `Nolo workspace${state.cliVersion ? `  nolo ${state.cliVersion}` : ""}`,
+    `agent ${state.agentName} | dialog ${resolveDialogLabel(state)} | docs ${docs} | profile ${state.profileName}`,
+    `server ${state.serverUrl}`,
+    "",
+    "Tell nolo what you want. Use /help for commands. Use /version if this install feels stale.",
+    "",
+  ].join("\n");
+}
+
+export function renderPrompt(_state: TuiState) {
+  return "you > ";
+}
+
+export function renderTuiHelp() {
+  return [
+    "Commands:",
+    "  /help                 Show this help",
+    "  /new                  Start a fresh dialog",
+    "  /compact              Compact current dialog and fork a new one",
+    "  /context              Show workspace context and next actions",
+    "  /runtime <mode>       Use auto, local, or server runtime",
+    "  /agent                Show the current agent",
+    "  /agents               List built-in agent shortcuts",
+    "  /switch <agent>       Switch the current agent",
+    "  /dialog               Show the current dialog",
+    "  /doc                  List attached docs",
+    "  /doc attach <doc>     Attach a doc to this workspace",
+    "  /customize            Describe how you want to tune nolo",
+    "  /login                Show login/profile hint",
+    "  /profile              Show active profile",
+    "  /update               Update the global nolo install",
+    "  /version              Show version/update hint",
+    "  /exit                 Leave the workspace",
+    "",
+    "You can also type normally. nolo will send it to the current agent.",
+  ].join("\n");
+}
+
+export function renderContextPanel(state: TuiState) {
+  const docs = state.attachedDocs.length
+    ? state.attachedDocs.join(", ")
+    : "none";
+  return [
+    "Workspace context",
+    "-----------------",
+    `agent   ${state.agentName}`,
+    `dialog  ${resolveDialogLabel(state)}`,
+    `docs    ${docs}`,
+    `profile ${state.profileName}`,
+    `runtime ${state.runtimeMode}`,
+    `server  ${state.serverUrl}`,
+    "",
+    "Next:",
+    "  /agents              see specialist shortcuts",
+    "  /doc attach <doc>    add working context",
+    "  /new                 start a clean dialog",
+  ].join("\n");
+}
+
+export function renderKnownAgents() {
+  return [
+    "Agents:",
+    ...KNOWN_AGENTS.map(
+      (agent, index) =>
+        `  ${index + 1}  ${agent.name.padEnd(11)} ${agent.description}`
+    ),
+    "",
+    "Tip: stay on nolo for the one-assistant feel; switch only when you want a specialist directly.",
+  ].join("\n");
+}
+
+function resolveSwitchTarget(rawTarget: string) {
+  const target = rawTarget.trim();
+  if (/^\d+$/.test(target)) {
+    const agent = KNOWN_AGENTS[Number(target) - 1];
+    return agent ? { name: agent.name, key: agent.key } : null;
+  }
+  const alias = KNOWN_AGENT_ALIASES[target.toLowerCase()];
+  if (alias) return alias;
+  if (target.startsWith("agent-") || target.startsWith("agent-pub-")) {
+    return { name: target, key: target };
+  }
+  return null;
+}
 
 export function handleTuiInput(input: string, state: TuiState): TuiInputResult {
-  return handleTuiInputWithDeps(input, state, createInterpreterDeps());
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return { nextState: state, output: "" };
+  }
+
+  if (!trimmed.startsWith("/")) {
+    return {
+      nextState: state,
+      output: "",
+      action: {
+        type: "chat",
+        message: trimmed,
+        agentKey: state.agentKey,
+        runtimeMode: state.runtimeMode,
+        ...(state.dialogId ? { continueDialogId: state.dialogId } : {}),
+      },
+    };
+  }
+
+  const [command = "", ...rest] = trimmed.split(/\s+/);
+  const argText = rest.join(" ").trim();
+
+  switch (command) {
+    case "/help":
+      return { nextState: state, output: renderTuiHelp() };
+    case "/context":
+    case "/ctx":
+      return { nextState: state, output: renderContextPanel(state) };
+    case "/runtime": {
+      if (argText !== "auto" && argText !== "local" && argText !== "server") {
+        return {
+          nextState: state,
+          output: "Usage: /runtime <auto|local|server>",
+        };
+      }
+      return {
+        nextState: { ...state, runtimeMode: argText },
+        output: `Runtime: ${argText}`,
+      };
+    }
+    case "/exit":
+    case "/quit":
+      return { nextState: state, output: "Bye.", action: { type: "exit" } };
+    case "/new":
+      return {
+        nextState: {
+          ...state,
+          dialogId: undefined,
+          dialogLabel: "new",
+          attachedDocs: [],
+        },
+        output: "Started a fresh dialog.",
+      };
+    case "/compact":
+      if (argText) {
+        return {
+          nextState: state,
+          output: `Unknown command: ${trimmed}\n\n${renderTuiHelp()}`,
+        };
+      }
+      if (!state.dialogId) {
+        return {
+          nextState: state,
+          output: "Current dialog: new (nothing to compact yet)",
+        };
+      }
+      return {
+        nextState: state,
+        output: "Compacting current dialog...",
+        action: { type: "compact", dialogId: state.dialogId },
+      };
+    case "/agent":
+      return {
+        nextState: state,
+        output: `Current agent: ${state.agentName} (${state.agentKey})`,
+      };
+    case "/agents":
+      return {
+        nextState: state,
+        output: renderKnownAgents(),
+      };
+    case "/switch": {
+      if (!argText) {
+        return {
+          nextState: state,
+          output: "Usage: /switch <agent-key|alias>",
+        };
+      }
+      const resolvedTarget = resolveSwitchTarget(argText);
+      if (!resolvedTarget) {
+        return {
+          nextState: state,
+          output:
+            `I don't know agent shortcut "${argText}" yet.\n` +
+            "Use /switch nolo, /switch app-builder, or a full agent key like agent-pub-...",
+        };
+      }
+      return {
+        nextState: {
+          ...state,
+          agentName: resolvedTarget.name,
+          agentKey: resolvedTarget.key,
+        },
+        output: `Switched to ${resolvedTarget.name}.`,
+      };
+    }
+    case "/dialog":
+      return {
+        nextState: state,
+        output: state.dialogId
+          ? `Current dialog: ${state.dialogId}`
+          : "Current dialog: new",
+      };
+    case "/doc": {
+      if (rest[0] === "attach") {
+        const docName = rest.slice(1).join(" ").trim();
+        if (!docName) {
+          return { nextState: state, output: "Usage: /doc attach <doc>" };
+        }
+        const attachedDocs = state.attachedDocs.includes(docName)
+          ? state.attachedDocs
+          : [...state.attachedDocs, docName];
+        return {
+          nextState: { ...state, attachedDocs },
+          output: `Attached doc: ${docName}`,
+        };
+      }
+      return {
+        nextState: state,
+        output:
+          state.attachedDocs.length > 0
+            ? `Attached docs: ${state.attachedDocs.join(", ")}`
+            : "No docs attached. Use /doc attach <doc>.",
+      };
+    }
+    case "/customize":
+      return {
+        nextState: state,
+        output:
+          "Tell nolo what to change, for example: /customize make my default agent more concise.",
+      };
+    case "/login":
+      return {
+        nextState: state,
+        output:
+          "MVP login uses profile/env auth. Set AUTH_TOKEN, NOLO_SERVER, or NOLO_PROFILE before starting nolo.",
+      };
+    case "/profile":
+      return {
+        nextState: state,
+        output: `Profile: ${state.profileName}`,
+      };
+    case "/update":
+      return {
+        nextState: state,
+        output: "Starting self-update...",
+        action: { type: "self-update" },
+      };
+    case "/version":
+      return {
+        nextState: state,
+        output:
+          `nolo ${state.cliVersion || "unknown version"}\n` +
+          "Update this install with: nolo update\n" +
+          "If repo-local output differs, publish/install the latest npm package first.",
+      };
+    default:
+      return {
+        nextState: state,
+        output: `Unknown command: ${command}\n\n${renderTuiHelp()}`,
+      };
+  }
 }

package/cli/workflowInternalCommandEntries.ts

@@ -1,31 +1,11 @@
 import { createEnvCommand } from "./cliCommandFactories";
 import type { CommandEntry } from "./cliCommandTypes";
-import { runTableMetaCommand } from "./tableMetaCommands";
-import {
-  runTableAddColumnCommand,
-  runTableAddRowCommand,
-  runTableAddRowsCommand,
-  runTableDataCommand,
-  runTableDeleteRowCommand,
-  runTableDeleteRowsCommand,
-  runTableUpdateRowCommand,
-  runTableUpdateRowsCommand,
-} from "./tableMutationCommands";
 import { runTableQueryCommand } from "./tableCommands";
 import { runTaskRunCommand } from "./taskRunCommand";
 
 export function getWorkflowInternalCommandEntries(): CommandEntry[] {
   return [
     createEnvCommand(["table", "query"], "Query table rows", runTableQueryCommand),
-    createEnvCommand(["table", "meta"], "Create or update table metadata", runTableMetaCommand),
-    createEnvCommand(["table", "add-column"], "Add one table column", runTableAddColumnCommand),
-    createEnvCommand(["table", "add-row"], "Add one table row", runTableAddRowCommand),
-    createEnvCommand(["table", "add-rows"], "Add table rows", runTableAddRowsCommand),
-    createEnvCommand(["table", "update-row"], "Update one table row", runTableUpdateRowCommand),
-    createEnvCommand(["table", "update-rows"], "Update table rows", runTableUpdateRowsCommand),
-    createEnvCommand(["table", "delete-row"], "Delete one table row", runTableDeleteRowCommand),
-    createEnvCommand(["table", "delete-rows"], "Delete table rows", runTableDeleteRowsCommand),
-    createEnvCommand(["table", "data"], "Low-level table row command", runTableDataCommand),
     createEnvCommand(["task-run"], "Update durable task-run state through the runner bridge", runTaskRunCommand),
   ];
 }

package/cliCommandDispatch.ts

@@ -31,7 +31,7 @@ function readOption(args: string[], flag: string) {
 
 function buildDaemonEnv(args: string[], runtimeEnv: NodeJS.ProcessEnv) {
   const serverUrl = readOption(args, "--server-url") || readOption(args, "--server");
-  const apiKey = readOption(args, "--api-key") || readOption(args, "--token");
+  const apiKey = readOption(args, "--machine-key") || readOption(args, "--token");
   return {
     ...runtimeEnv,
     ...(serverUrl ? { NOLO_SERVER: serverUrl } : {}),
@@ -40,7 +40,7 @@ function buildDaemonEnv(args: string[], runtimeEnv: NodeJS.ProcessEnv) {
 }
 
 export function looksLikeDaemonShortcut(args: string[]) {
-  return args.includes("--server-url") || args.includes("--api-key");
+  return args.includes("--server-url") || args.includes("--machine-key");
 }
 
 export function createCliRuntimeContext(args: {

package/cliEnvHelpers.ts

@@ -3,63 +3,13 @@ import { NOLO_CLUSTER_SERVERS } from "./database/config";
 
 export type EnvLike = Record<string, string | undefined>;
 
-function trimTrailingSlashes(value: string) {
-  return value.trim().replace(/\/+$/, "");
-}
-
-function firstDefinedEnvValue(env: EnvLike, keys: string[]) {
-  for (const key of keys) {
-    const value = env[key];
-    if (typeof value === "string" && value.length > 0) return value;
-  }
-  return "";
-}
-
-export function hasFlag(args: string[], flag: string) {
-  return args.includes(flag);
-}
-
-export function readCliOptionValue(args: string[], flag: string): string {
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = args[i];
-    if (arg === flag) {
-      const next = args[i + 1];
-      if (typeof next === "string" && !next.startsWith("-")) return next;
-      return "";
-    }
-    if (arg.startsWith(`${flag}=`)) return arg.slice(flag.length + 1);
-  }
-  return "";
-}
-
-export function hasExplicitServerOverride(args: string[]) {
-  return Boolean(
-    readCliOptionValue(args, "--server-url") ||
-      readCliOptionValue(args, "--server") ||
-      readCliOptionValue(args, "--base-url")
-  );
-}
-
 export function resolveServerUrlFromEnv(env: EnvLike) {
-  return trimTrailingSlashes(
-    firstDefinedEnvValue(env, ["NOLO_SERVER_URL", "NOLO_SERVER", "BASE_URL"]) ||
-      DEFAULT_NOLO_SERVER_URL,
-  );
+  return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
 }
 
-export function resolveServerUrlFromArgs(args: string[], env: EnvLike) {
-  return trimTrailingSlashes(
-    readCliOptionValue(args, "--server-url") ||
-      readCliOptionValue(args, "--server") ||
-      readCliOptionValue(args, "--base-url") ||
-      firstDefinedEnvValue(env, ["NOLO_SERVER_URL", "NOLO_SERVER", "BASE_URL"]) ||
-      DEFAULT_NOLO_SERVER_URL,
-  );
-}
-
-type ServerResolverInput = string[] | EnvLike;
+type ResolverInput = string[] | EnvLike;
 
-function isCliArgs(value: ServerResolverInput): value is string[] {
+function isCliArgs(value: ResolverInput): value is string[] {
   return Array.isArray(value);
 }
 
@@ -73,9 +23,12 @@ function buildServerCandidates(values: Array<string | null | undefined>) {
 
 export function resolveServerUrl(env: EnvLike): string;
 export function resolveServerUrl(args: string[], env: EnvLike): string;
-export function resolveServerUrl(input: ServerResolverInput, env?: EnvLike) {
+export function resolveServerUrl(input: ResolverInput, env?: EnvLike) {
   if (isCliArgs(input)) {
-    return resolveServerUrlFromArgs(input, env ?? {});
+    const explicit =
+      readOption(input, "--server-url") ||
+      readOption(input, "--server");
+    return explicit?.replace(/\/+$/, "") || resolveServerUrlFromEnv(env ?? {});
   }
   return resolveServerUrlFromEnv(input);
 }
@@ -87,13 +40,13 @@ export function resolveServerCandidates(
   preferred?: string | null,
 ): string[];
 export function resolveServerCandidates(
-  input: ServerResolverInput,
+  input: ResolverInput,
   envOrPreferred?: EnvLike | string | null,
   preferred?: string | null,
 ) {
   if (isCliArgs(input)) {
     const env = (envOrPreferred ?? {}) as EnvLike;
-    const explicitServer = resolveServerUrlFromArgs(input, env);
+    const explicitServer = resolveServerUrl(input, env);
     return buildServerCandidates([
       explicitServer,
       preferred?.trim(),
@@ -104,6 +57,7 @@ export function resolveServerCandidates(
       ...NOLO_CLUSTER_SERVERS,
     ]);
   }
+
   const env = input;
   return buildServerCandidates([
     typeof envOrPreferred === "string" ? envOrPreferred.trim() : undefined,
@@ -115,71 +69,44 @@ export function resolveServerCandidates(
   ]);
 }
 
+export function resolveAuthTokenFromEnv(env: EnvLike, extraEnvKeys: string[] = []) {
+  for (const key of ["AUTH_TOKEN", "AUTH", ...extraEnvKeys]) {
+    const value = env[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return "";
+}
+
 export function resolveAuthToken(env: EnvLike, extraEnvKeys?: string[]): string;
 export function resolveAuthToken(args: string[], env: EnvLike, extraEnvKeys?: string[]): string;
 export function resolveAuthToken(
-  input: ServerResolverInput,
+  input: ResolverInput,
   envOrExtraEnvKeys?: EnvLike | string[],
   extraEnvKeys: string[] = [],
 ) {
   if (isCliArgs(input)) {
-    return resolveAuthTokenFromArgs(input, (envOrExtraEnvKeys ?? {}) as EnvLike, extraEnvKeys);
+    const env = (envOrExtraEnvKeys ?? {}) as EnvLike;
+    return (
+      readOption(input, "--token") ||
+      readOption(input, "--machine-key") ||
+      resolveAuthTokenFromEnv(env, extraEnvKeys)
+    );
   }
   return resolveAuthTokenFromEnv(input, (envOrExtraEnvKeys as string[] | undefined) ?? []);
 }
 
-export function resolveAuthTokenFromEnv(env: EnvLike, extraEnvKeys: string[] = []) {
-  return (
-    firstDefinedEnvValue(env, [...extraEnvKeys, "BENCHMARK_AUTH_TOKEN", "AUTH_TOKEN", "AUTH"]) ||
-    ""
-  );
-}
-
-export function resolveAuthTokenFromArgs(
-  args: string[],
-  env: EnvLike,
-  extraEnvKeys: string[] = [],
-) {
-  return (
-    readCliOptionValue(args, "--api-key") ||
-    readCliOptionValue(args, "--token") ||
-    firstDefinedEnvValue(env, [
-      ...extraEnvKeys,
-      "BENCHMARK_AUTH_TOKEN",
-      "NOLO_TASK_RUN_TOKEN",
-      "NOLO_MACHINE_API_KEY",
-      "AUTH_TOKEN",
-      "AUTH",
-    ]) ||
-    ""
-  );
-}
-
-export function decodeJwtPayload(token: string): Record<string, unknown> | null {
-  const trimmed = token.trim();
-  if (!trimmed) return null;
-  const parts = trimmed.split(".").filter(Boolean);
-  const payloadCandidates = parts.length >= 3 ? [parts[1], parts[0]] : [parts[0]];
-  for (const payload of payloadCandidates) {
-    try {
-      return JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-
 export function parseUserIdFromAuthToken(token: string) {
-  const parsed = decodeJwtPayload(token);
-  return typeof parsed?.userId === "string" ? parsed.userId : "";
+  const payload = token.trim().split(".")[0];
+  if (!payload) return "";
+  try {
+    const parsed = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
+    return typeof parsed?.userId === "string" ? parsed.userId : "";
+  } catch {
+    return "";
+  }
 }
 
 export function readOption(args: string[], flag: string) {
   const index = args.indexOf(flag);
   return index >= 0 ? args[index + 1] : undefined;
 }
-
-export function readOptionValue(args: string[], flag: string) {
-  return readCliOptionValue(args, flag);
-}

package/client/agentConfigResolver.test.ts

@@ -17,6 +17,7 @@ describe("agent config resolver", () => {
       toolNames: ["legacyTool", "readFile"],
       tools: ["readFile", "applyEdit"],
       runtimeBinding: { machineId: "machine-1", localWorkspaceMode: "task-worktree" },
+      delegation: { target: "local" },
       temperature: 0.2,
       top_p: 0.9,
       max_tokens: 4096,
@@ -35,6 +36,7 @@ describe("agent config resolver", () => {
       toolNames: ["legacyTool", "readFile", "applyEdit"],
       runtimeBinding: { machineId: "machine-1", localWorkspaceMode: "task-worktree" },
       localWorkspaceMode: "task-worktree",
+      delegation: { target: "local" },
       temperature: 0.2,
       top_p: 0.9,
       max_tokens: 4096,