nolo-cli 0.1.38 → 0.1.39

package/cli/agentRunCommand.ts

@@ -4,13 +4,7 @@ import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "./agent
 import { existsSync, readFileSync } from "node:fs";
 import { extname, resolve } from "node:path";
 import { parseSkillDocProtocol, type WorkflowReferenceConfig } from "../ai/skills/skillDocProtocol";
-import { resolveCliAgentKeyInput } from "./agentAliases";
-import {
-  ensureWorkspacePackageLinks,
-  formatPreparedTaskWorktree,
-  prepareTaskWorktree,
-  type PreparedTaskWorktree,
-} from "./client/taskWorktree";
+import { MIMO_MONTH_AGENT_KEY, resolveCliAgentKeyInput } from "./agentAliases";
 import type { TaskRunPromptContext } from "./client/taskRunPrompt";
 
 type EnvLike = Record<string, string | undefined>;
@@ -25,8 +19,6 @@ type AgentRunCommandDeps = {
   output?: OutputLike;
   runner?: typeof runAgentTurn;
   localRuntimeAdapterFactory?: (env: EnvLike, options?: { cwd?: string }) => AgentRuntimeHostAdapter;
-  prepareTaskWorktree?: typeof prepareTaskWorktree;
-  ensureWorkspacePackageLinks?: typeof ensureWorkspacePackageLinks;
   inspectLocalRunWorkspace?: typeof inspectLocalRunWorkspace;
   resolveWorkflowReference?: typeof resolveWorkflowReference;
 };
@@ -63,7 +55,7 @@ type ParsedAgentRunArgs = {
   maxToolRounds?: number;
   timeoutMs?: number;
   traceTools: boolean;
-  useTaskWorktree: boolean;
+  injectFeatureWorktreeInstruction: boolean;
   taskRunContext?: TaskRunPromptContext;
   workflowRef?: string;
 };
@@ -102,6 +94,21 @@ function runtimeModeFromArgs(args: string[]): AgentRuntimeRequestedMode | undefi
   return undefined;
 }
 
+function isMonthlyMimoAgentRef(raw: string | undefined, resolved: string) {
+  const normalized = raw?.trim().toLowerCase();
+  return (
+    resolved === MIMO_MONTH_AGENT_KEY ||
+    normalized === "fullstack" ||
+    normalized === "full-stack" ||
+    normalized === "nolo-fullstack" ||
+    normalized === "包月mimo" ||
+    normalized === "包月mimo2.5" ||
+    normalized === "mimo-month" ||
+    normalized === "全栈" ||
+    normalized === "nolo 全栈工程师"
+  );
+}
+
 function parseNonNegativeInteger(value: string | undefined) {
   if (!value) return undefined;
   const parsed = Number(value);
@@ -123,7 +130,6 @@ function positionalArgs(args: string[]) {
     "--server",
     "--auto",
     "--dangerously-allow-shell",
-    "--worktree-task",
     "--trace-tools",
     "--bg",
     "--no-stream",
@@ -146,7 +152,8 @@ export function parseAgentRunArgs(
   args: string[],
   options: ParseAgentRunArgsOptions = {}
 ): ParsedAgentRunArgs | null {
-  const agentKey = readFlagValue(args, "--agent") ?? positionalArgs(args)[0];
+  const rawAgentKey = readFlagValue(args, "--agent") ?? positionalArgs(args)[0];
+  const agentKey = rawAgentKey ? resolveCliAgentKeyInput(rawAgentKey) : undefined;
   const explicitMsg = readFlagValue(args, "--msg");
   const msgFile = readFlagValue(args, "--msg-file");
   const fileMessage = msgFile
@@ -178,7 +185,8 @@ export function parseAgentRunArgs(
     ...readRepeatedFlagValues(args, "--image"),
     ...readRepeatedFlagValues(args, "--image-url"),
   ];
-  const useTaskWorktree = args.includes("--worktree-task");
+  const mimoLocalWorkspaceDefault =
+    isMonthlyMimoAgentRef(rawAgentKey, agentKey) && runtimeMode !== "server";
   const workflowRef = readFlagValue(args, "--workflow");
   const taskRowDbKey = readFlagValue(args, "--task-row-dbkey");
   const artifactIds = readFlagValue(args, "--artifact-ids")
@@ -186,12 +194,12 @@ export function parseAgentRunArgs(
     .map((item) => item.trim())
     .filter(Boolean);
   return {
-    agentKey: resolveCliAgentKeyInput(agentKey),
+    agentKey,
     message,
     imageUrls,
-    allowShell: args.includes("--dangerously-allow-shell"),
+    allowShell: args.includes("--dangerously-allow-shell") || mimoLocalWorkspaceDefault,
     traceTools: args.includes("--trace-tools"),
-    useTaskWorktree,
+    injectFeatureWorktreeInstruction: mimoLocalWorkspaceDefault,
     ...(workflowRef ? { workflowRef } : {}),
     ...(taskRowDbKey
       ? {
@@ -203,7 +211,11 @@ export function parseAgentRunArgs(
           },
         }
       : {}),
-    ...(runtimeMode ? { runtimeMode } : useTaskWorktree ? { runtimeMode: "local" as const } : {}),
+    ...(runtimeMode
+      ? { runtimeMode }
+      : mimoLocalWorkspaceDefault || args.includes("--dangerously-allow-shell")
+        ? { runtimeMode: "local" as const }
+        : {}),
     background: args.includes("--bg"),
     noStream: args.includes("--no-stream"),
     noDefaultTestRoot,
@@ -269,6 +281,20 @@ export function prependWorkflowReferencePrompt(message: string, workflow?: Resol
   ].join("\n");
 }
 
+function prependFeatureWorktreeInstruction(message: string, enabled: boolean) {
+  if (!enabled) return message;
+  return [
+    "Local execution rule:",
+    "- You are running in the current git checkout with shell access.",
+    "- For read-only checks, smoke tests, or answering questions, stay in the current directory.",
+    "- Before developing a new feature or making non-trivial code changes, create a separate git worktree yourself with git worktree and do the edits there.",
+    "- Commit and push only when the user explicitly asks or the task requires it.",
+    "",
+    "User task:",
+    message,
+  ].join("\n");
+}
+
 function parseDialogReference(rawInput: string) {
   const normalized = rawInput.trim();
   if (normalized.startsWith("dialog-")) {
@@ -381,19 +407,13 @@ function resolveServerUrl(env: EnvLike) {
   return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
 }
 
-function shouldPrepareTaskWorktree(parsed: ParsedAgentRunArgs) {
-  return !parsed.cwd && (parsed.useTaskWorktree || parsed.allowShell);
-}
-
-function buildTaskWorktreeEnv(args: {
+function buildLocalRunEnv(args: {
   env: EnvLike;
-  worktreePath?: string;
   allowShell: boolean;
 }) {
   return {
     ...args.env,
     ...(args.allowShell ? { NOLO_LOCAL_SHELL_MODE: "worktree" } : {}),
-    ...(args.worktreePath ? { NOLO_LOCAL_WORKTREE: args.worktreePath } : {}),
   };
 }
 
@@ -426,52 +446,24 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
     }
   }
   let localRuntimeCwd = parsed.cwd;
-  if (shouldPrepareTaskWorktree(parsed)) {
-    try {
-      const preparedWorktree = await (deps.prepareTaskWorktree ?? prepareTaskWorktree)({
-        agentKey: parsed.agentKey,
-        env,
-      });
-      localRuntimeCwd = preparedWorktree.path;
-      output.write(formatPreparedTaskWorktree(preparedWorktree));
-    } catch (error) {
-      output.write(
-        "[nolo] Could not prepare a local task 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;
-    }
+  if (!localRuntimeCwd && parsed.runtimeMode === "local") {
+    localRuntimeCwd = process.cwd();
   }
-  const shouldBindLocalWorkspace =
-    !!localRuntimeCwd &&
-    (parsed.runtimeMode === "local" || parsed.allowShell || parsed.useTaskWorktree);
-  if (shouldBindLocalWorkspace) {
-    try {
-      await (deps.ensureWorkspacePackageLinks ?? ensureWorkspacePackageLinks)(
-        localRuntimeCwd!
-      );
-    } catch (error) {
-      output.write(
-        "[nolo] Dependency preflight failed for local task worktree.\n" +
-          "The worktree may have node_modules entries that point outside the task checkout, or paths that cannot be repaired safely.\n" +
-          `Reason: ${error instanceof Error ? error.message : String(error)}\n`
-      );
-      return 1;
-    }
-  }
-  const runEnv = shouldBindLocalWorkspace
-    ? buildTaskWorktreeEnv({
-        env,
-        worktreePath: localRuntimeCwd,
-        allowShell: parsed.allowShell,
-      })
-    : env;
+  const runEnv = buildLocalRunEnv({
+    env,
+    allowShell: parsed.allowShell,
+  });
   const result: RunAgentTurnResult = await runner({
     agentName: parsed.agentKey,
     agentKey: parsed.agentKey,
     serverUrl: resolveServerUrl(env),
-    message: prependWorkflowReferencePrompt(parsed.message, workflowReference),
+    message: prependWorkflowReferencePrompt(
+      prependFeatureWorktreeInstruction(
+        parsed.message,
+        parsed.injectFeatureWorktreeInstruction
+      ),
+      workflowReference
+    ),
     imageUrls: parsed.imageUrls.map(normalizeCliImageInput),
     scriptDir: deps.scriptDir,
     env: runEnv,

package/cli/agentRuntimeLocal.ts

@@ -5,12 +5,9 @@ export {
   hasDirectOpenAiCompatibleProvider,
   createHybridRecordStore,
   executeLocalToolWithPolicy,
-  activateWorkspaceSession,
-  createWorkspaceSession,
   buildAgentRuntimeAgentLookupKeys,
   buildAgentRuntimeDialogWritePlan,
   dialogMessageRecordToAgentRuntimeMessage,
-  formatWorkspaceSessionActivation,
   pickAgentRuntimeInferenceOptions,
   parseOpenAiCompatibleChatCompletionResponse,
   parsePlatformChatCompletionData,
@@ -44,8 +41,4 @@ export type {
   HybridRecordKvDb,
   HybridRecordStore,
   LocalToolPolicyDecision,
-  PreparedTaskWorkspace,
-  PrepareTaskWorkspace,
-  WorkspaceSession,
-  WorkspaceSessionMode,
 } from "../agent-runtime";

package/cli/cliEnvHelpers.ts

@@ -96,14 +96,18 @@ export function resolveAuthToken(
 }
 
 export function parseUserIdFromAuthToken(token: string) {
-  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 "";
+  const parts = token.trim().split(".").filter(Boolean);
+  const payloadCandidates = parts.length >= 3 ? [parts[1], parts[0]] : [parts[0]];
+  for (const payload of payloadCandidates) {
+    if (!payload) continue;
+    try {
+      const parsed = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
+      if (typeof parsed?.userId === "string") return parsed.userId;
+    } catch {
+      // Try the next token shape.
+    }
   }
+  return "";
 }
 
 export function readOption(args: string[], flag: string) {

package/cli/client/agentRun.ts

@@ -9,7 +9,7 @@ import {
 } from "../agentAliases";
 import type { LocalAgentToolEvent } from "../../agent-runtime/localLoop";
 import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
-import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
+import { createCliLocalRuntimeAdapter, isBuiltinNoloAgentRef } from "./localRuntimeAdapter";
 import { createStreamingTextWriter } from "./streamingOutput";
 import { prependTaskRunPrompt, type TaskRunPromptContext } from "./taskRunPrompt";
 
@@ -180,10 +180,27 @@ function isKnownServerPlatformAgent(options: RunAgentTurnOptions) {
   const normalizedKey = normalizeAgentRef(options.agentKey);
   return Boolean(normalizedKey && KNOWN_SERVER_PLATFORM_AGENT_ALIASES.has(normalizedKey));
 }
-
-function resolveAuthToken(env: EnvLike) {
-  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
-}
+
+function isMachineBoundLocalhostCustomProvider(agentConfig: any) {
+  const machineId =
+    agentConfig?.runtimeBinding && typeof agentConfig.runtimeBinding === "object"
+      ? String(agentConfig.runtimeBinding.machineId ?? "").trim()
+      : "";
+  const providerUrl = typeof agentConfig?.customProviderUrl === "string"
+    ? agentConfig.customProviderUrl.trim()
+    : "";
+  if (!machineId || !providerUrl) return false;
+  try {
+    const hostname = new URL(providerUrl).hostname.toLowerCase();
+    return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1";
+  } catch {
+    return false;
+  }
+}
+
+function resolveAuthToken(env: EnvLike) {
+  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
+}
 
 function shouldShowUsage(env: EnvLike) {
   return env.NOLO_DEBUG === "1" || env.NOLO_SHOW_USAGE === "1";
@@ -214,6 +231,10 @@ function resolveLocalRuntimeAdapter(options: RunAgentTurnOptions) {
 }
 
 async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOptions) {
+  if (isBuiltinNoloAgentRef(options.agentKey)) return false;
+  if (options.localRuntimeCwd && options.env.NOLO_LOCAL_SHELL_MODE === "worktree") {
+    return false;
+  }
   if (isKnownServerPlatformAgent(options)) {
     options.output.write(
       `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. ` +
@@ -229,6 +250,13 @@ async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOp
   } catch {
     return false;
   }
+  if (isMachineBoundLocalhostCustomProvider(agentConfig)) {
+    options.output.write(
+      `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a machine-bound localhost custom provider. ` +
+        "Use --local explicitly to force the current machine.\n"
+    );
+    return true;
+  }
   const serverTools = resolveServerPlatformToolNames(agentConfig);
   if (serverTools.length === 0) return false;
   options.output.write(
@@ -329,6 +357,13 @@ function formatToolTraceEvent(event: LocalAgentToolEvent) {
 
 function shouldAttemptAutoLocal(options: RunAgentTurnOptions) {
   if (options.localRuntimeAdapter || options.localRuntimeAdapterFactory) return true;
+  if (
+    options.env.NOLO_DISABLE_CLI_WORKSPACE_TOOLS !== "1" &&
+    isBuiltinNoloAgentRef(options.agentKey) &&
+    resolveAuthToken(options.env)
+  ) {
+    return true;
+  }
   return Boolean(
     options.env.NOLO_LOCAL_OPENAI_API_KEY ||
       options.env.OPENAI_API_KEY ||
@@ -632,8 +667,21 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
 
   if (!res.ok) {
     options.output.write(`[nolo] Agent request failed: HTTP ${res.status}\n`);
-    if (data?.error || data?.message) {
-      options.output.write(`${data.error || data.message}\n`);
+    const errorText = typeof data?.error === "string" ? data.error.trim() : "";
+    const messageText = typeof data?.message === "string" ? data.message.trim() : "";
+    const reasonText = typeof data?.reason === "string" ? data.reason.trim() : "";
+    const codeText = typeof data?.code === "string" ? data.code.trim() : "";
+    if (errorText || messageText) {
+      options.output.write(`${errorText || messageText}\n`);
+      if (messageText && messageText !== errorText) {
+        options.output.write(`${messageText}\n`);
+      }
+      if (codeText && codeText !== errorText && codeText !== messageText) {
+        options.output.write(`code=${codeText}\n`);
+      }
+      if (reasonText && reasonText !== errorText && reasonText !== messageText) {
+        options.output.write(`reason=${reasonText}\n`);
+      }
     }
     await recordTaskRunOutcome({
       options,

package/cli/client/localRuntimeAdapter.ts

@@ -5,6 +5,8 @@ import type {
 } from "../agentRuntimeLocal";
 import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import {
   buildLocalWorkspacePolicyToolNames,
   buildLocalWorkspaceToolset,
@@ -40,19 +42,28 @@ import {
 } from "./hybridRecordStore";
 import { executeLocalToolWithPolicy } from "./localToolPolicy";
 import { taskRunFunctionSchema } from "../../ai/tools/agent/taskRunTool";
-import { prepareTaskWorktree } from "./taskWorktree";
 import {
-  activateWorkspaceSession,
-  createWorkspaceSession,
-  formatWorkspaceSessionActivation,
-  type WorkspaceSession,
-} from "./workspaceSession";
+  NOLO_DEFAULT_AGENT_ID,
+  NOLO_DEFAULT_AGENT_KEY,
+} from "../agentAliases";
+import {
+  buildNoloWorkspaceCliToolExecutors,
+  buildNoloWorkspaceOpenAiTools,
+  filterNoloWorkspaceToolNames,
+  NOLO_WORKSPACE_TOOL_NAMES,
+  NOLO_WORKSPACE_TOOL_PROMPT,
+  parseNoloWorkspaceToolArguments,
+} from "../../agent-runtime/noloWorkspaceTools";
 
 type EnvLike = Record<string, string | undefined>;
 type FetchInput = Parameters<typeof fetch>[0];
 type FetchInit = Parameters<typeof fetch>[1];
 const TRANSIENT_FETCH_MAX_ATTEMPTS = 8;
 const TRANSIENT_FETCH_RETRY_BASE_DELAY_MS = 250;
+export const BUILTIN_NOLO_AGENT_ID = NOLO_DEFAULT_AGENT_ID;
+export const BUILTIN_NOLO_AGENT_KEY = NOLO_DEFAULT_AGENT_KEY;
+const CLI_DIR = dirname(fileURLToPath(import.meta.url));
+const CLI_ENTRYPOINT = join(CLI_DIR, "..", "index.ts");
 
 export type CliLocalRuntimeDb = CliKvDb;
 
@@ -64,9 +75,7 @@ export type CliLocalRuntimeAdapterDeps = {
   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> }>>;
   sleep?: (ms: number) => Promise<void>;
   loopbackRequest?: (input: FetchInput, init?: FetchInit) => Promise<Response>;
@@ -85,7 +94,7 @@ function resolveLocalUserId(env: EnvLike) {
 }
 
 function shellModeEnabled(env: EnvLike) {
-  return ["worktree", "dangerous", "1", "true"].includes(env.NOLO_LOCAL_SHELL_MODE || "");
+  return env.NOLO_LOCAL_SHELL_MODE === "worktree";
 }
 
 function parseLocalToolBudgets(env: EnvLike) {
@@ -246,6 +255,17 @@ function logLocalRuntimeDiagnostic(event: string, fields: Record<string, unknown
   console.error(`[nolo-local-runtime] ${event} ${JSON.stringify(fields)}`);
 }
 
+function summarizeOpenAiToolNames(tools: Array<Record<string, unknown>>) {
+  return tools
+    .map((tool) => {
+      const fn = tool.function;
+      return fn && typeof fn === "object" && "name" in fn && typeof fn.name === "string"
+        ? fn.name
+        : null;
+    })
+    .filter((name): name is string => Boolean(name));
+}
+
 function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
   const toolset = buildLocalWorkspaceToolsetForEnv(args);
   return [
@@ -254,6 +274,7 @@ function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
       exposeShellTools: toolset.exposeShellTools,
     }),
     ...buildServerPlatformOpenAiTools({ toolNames: args.toolNames }),
+    ...buildNoloWorkspaceOpenAiTools({ toolNames: args.toolNames }),
   ];
 }
 
@@ -272,6 +293,7 @@ function buildLocalPolicyToolNames(args: { toolNames?: string[]; env: EnvLike })
       exposeShellTools: shellModeEnabled(args.env),
     }),
     ...((args.toolNames ?? []).includes("taskRun") ? ["taskRun"] : []),
+    ...filterNoloWorkspaceToolNames(args.toolNames),
   ];
 }
 
@@ -287,13 +309,44 @@ function buildServerPlatformOpenAiTools(args: { toolNames?: string[] }) {
   ];
 }
 
-function parseToolArguments(raw: string) {
-  try {
-    const parsed = JSON.parse(raw || "{}");
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
-  }
+function buildCliWorkspaceToolExecutors(args: {
+  env: EnvLike;
+  cliEntrypoint?: string;
+}) {
+  return buildNoloWorkspaceCliToolExecutors({
+    cliEntrypoint: args.cliEntrypoint ?? CLI_ENTRYPOINT,
+    env: args.env,
+    metadataKind: "cliWorkspaceTool",
+  });
+}
+
+export function isBuiltinNoloAgentRef(ref: unknown) {
+  if (typeof ref !== "string") return false;
+  const normalized = ref.trim();
+  return (
+    normalized === BUILTIN_NOLO_AGENT_KEY ||
+    normalized === BUILTIN_NOLO_AGENT_ID ||
+    normalized.endsWith(`-${BUILTIN_NOLO_AGENT_ID}`)
+  );
+}
+
+function isBuiltinNoloAgentConfig(agentConfig: AgentRuntimeAgentConfig | null | undefined) {
+  const key = agentConfig?.key || agentConfig?.rawRecord?.dbKey || agentConfig?.rawRecord?.agentKey;
+  const id = agentConfig?.rawRecord?.id;
+  return isBuiltinNoloAgentRef(key) || isBuiltinNoloAgentRef(id);
+}
+
+function withBuiltinNoloCliTools(agentConfig: AgentRuntimeAgentConfig | null) {
+  if (!agentConfig || !isBuiltinNoloAgentConfig(agentConfig)) return agentConfig;
+  const toolNames = [...new Set([...(agentConfig.toolNames ?? []), ...NOLO_WORKSPACE_TOOL_NAMES])];
+  return {
+    ...agentConfig,
+    toolNames,
+    prompt: [
+      agentConfig.prompt?.trim() ?? "",
+      NOLO_WORKSPACE_TOOL_PROMPT,
+    ].filter(Boolean).join("\n\n"),
+  };
 }
 
 function resolveRuntimeServerUrl(env: EnvLike) {
@@ -320,7 +373,7 @@ function buildServerPlatformToolExecutors(args: {
           "Content-Type": "application/json",
           Authorization: `Bearer ${authToken}`,
         },
-        body: JSON.stringify(parseToolArguments(call.arguments)),
+        body: JSON.stringify(parseNoloWorkspaceToolArguments(call.arguments)),
       });
       const text = await response.text().catch(() => "");
       if (!response.ok) {
@@ -352,17 +405,13 @@ function buildLocalToolExecutors(args: {
       env: args.env,
       fetchImpl: args.fetchImpl,
     }),
+    ...buildCliWorkspaceToolExecutors({
+      env: args.env,
+    }),
     ...(args.localToolExecutors ?? {}),
   };
 }
 
-function readLocalWorkspaceMode(agentConfig: AgentRuntimeAgentConfig | null) {
-  if (agentConfig?.localWorkspaceMode === "task-worktree") return "task-worktree";
-  const runtimeBinding = agentConfig?.runtimeBinding;
-  const value = runtimeBinding?.localWorkspaceMode ?? runtimeBinding?.workspaceMode;
-  return value === "task-worktree" ? "task-worktree" : "current";
-}
-
 async function resolveStore(deps: CliLocalRuntimeAdapterDeps) {
   if (deps.store) return deps.store;
   return createCliHybridRecordStore({
@@ -437,51 +486,25 @@ export function createCliLocalRuntimeAdapter(
   const localToolBudgets = parseLocalToolBudgets(deps.env);
   const localToolUsage = new Map<string, number>();
   let activeAgentToolNames: string[] = [];
-  let workspaceSession: WorkspaceSession = createWorkspaceSession(
-    deps.useCwdAsTaskWorkspaceBase
-      ? { defaultCwd: deps.cwd }
-      : { cwd: deps.cwd }
-  );
+  const workspaceRoot = deps.cwd ?? process.cwd();
   let runtimeToolExecutionLimits: ReturnType<typeof resolveLocalWorkspaceExecutorOptionsFromPolicy> = {};
   let localToolExecutors = buildLocalToolExecutors({
-    workspaceRoot: workspaceSession.workspaceRoot,
+    workspaceRoot,
     env: deps.env,
     fetchImpl,
     localToolExecutors: deps.localToolExecutors,
     ...runtimeToolExecutionLimits,
   });
 
-  async function activateAgentWorkspaceSession(args: {
-    agentRef: string;
-    agentConfig: AgentRuntimeAgentConfig | null;
-  }) {
-    const previousWorkspaceRoot = workspaceSession.workspaceRoot;
-    workspaceSession = await activateWorkspaceSession(workspaceSession, {
-      agentKey: args.agentConfig?.key ?? args.agentRef,
-      mode: readLocalWorkspaceMode(args.agentConfig),
-      env: deps.env,
-      prepareTaskWorkspace: deps.prepareTaskWorktree,
-    });
-    if (workspaceSession.workspaceRoot === previousWorkspaceRoot) return;
-    localToolExecutors = buildLocalToolExecutors({
-      workspaceRoot: workspaceSession.workspaceRoot,
-      env: deps.env,
-      fetchImpl,
-      localToolExecutors: deps.localToolExecutors,
-      ...runtimeToolExecutionLimits,
-    });
-    deps.output?.write(formatWorkspaceSessionActivation(workspaceSession));
-  }
-
   return {
     host: "cli",
     capabilities: ["leveldb-agent-config", "local-provider", "leveldb-persistence", "local-tools"],
     loadAgentConfig: async (agentRef) => {
-      const agentConfig = await readAgentFromStore({
+      const agentConfig = withBuiltinNoloCliTools(await readAgentFromStore({
         agentRef,
         store: await resolveStore(deps),
         userId,
-      });
+      }));
       const requestedToolNames = agentConfig
         ? resolveRequestedRuntimeToolNames({ agentConfig })
         : [];
@@ -492,9 +515,8 @@ export function createCliLocalRuntimeAdapter(
       runtimeToolExecutionLimits = resolveLocalWorkspaceExecutorOptionsFromPolicy(
         resolveCurrentRunRuntimeToolPolicy(agentConfig),
       );
-      await activateAgentWorkspaceSession({ agentRef, agentConfig });
       localToolExecutors = buildLocalToolExecutors({
-        workspaceRoot: workspaceSession.workspaceRoot,
+        workspaceRoot,
         env: deps.env,
         fetchImpl,
         localToolExecutors: deps.localToolExecutors,
@@ -512,7 +534,7 @@ export function createCliLocalRuntimeAdapter(
       userId,
       now,
       createId,
-      cwd: workspaceSession.workspaceRoot,
+      cwd: workspaceRoot,
     }),
     resolveProvider: async (agentConfig) => {
       if (shouldUsePlatformChatProvider(deps.env, agentConfig)) {
@@ -558,6 +580,9 @@ export function createCliLocalRuntimeAdapter(
               model: providerConfig.model,
               messageCount: messages.length,
               toolCount: tools.length,
+              requestedToolNames,
+              openAiToolNames: summarizeOpenAiToolNames(tools),
+              shellMode: deps.env.NOLO_LOCAL_SHELL_MODE ?? null,
               timeoutMs: options?.timeoutMs ?? null,
             });
             const res = await fetchWithTransientRetry(fetchImpl, request.url, {
@@ -627,6 +652,9 @@ export function createCliLocalRuntimeAdapter(
             model: providerConfig.model,
             messageCount: messages.length,
             toolCount: tools.length,
+            requestedToolNames,
+            openAiToolNames: summarizeOpenAiToolNames(tools),
+            shellMode: deps.env.NOLO_LOCAL_SHELL_MODE ?? null,
             timeoutMs: options?.timeoutMs ?? null,
           });
           const res = await fetchWithTransientRetry(fetchImpl, request.url, {
@@ -672,8 +700,8 @@ export function createCliLocalRuntimeAdapter(
         ...result,
         metadata: {
           ...(result.metadata ?? {}),
-          workspaceRoot: workspaceSession.workspaceRoot,
-          workspaceKind: workspaceSession.kind,
+          workspaceRoot,
+          workspaceKind: "current",
         },
       };
     },

package/cli/connectorRunArtifact.ts

@@ -32,7 +32,6 @@ export function resolveConnectorRunCwd(args: {
   const explicit =
     args.env?.NOLO_CONNECTOR_WORKDIR ||
     args.env?.NOLO_AGENT_WORKDIR ||
-    args.env?.NOLO_LOCAL_WORKTREE ||
     "";
   const candidate = explicit || args.policy.writableRoots[0] || args.fallbackCwd || process.cwd();
   const cwd = normalizePath(candidate);