nolo-cli 0.1.32 → 0.1.34

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,9 @@ import {
   parseOpenAiCompatibleChatCompletionResponse,
   parsePlatformChatCompletionData,
   parsePlatformChatCompletionResponse,
-  resolveHostRuntimeConfigFromEnv,
   resolvePlatformChatProviderConfig,
   resolveRequestedRuntimeToolNames,
   shouldUsePlatformChatProvider,
-  type HostRuntimeConfig,
 } from "../agentRuntimeLocal";
 import type { AgentRuntimeChatMessage } from "../agent-runtime";
 import { getDefaultCliLocalRuntimeDb } from "../localRuntimeDb";
@@ -52,29 +49,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 +56,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 +74,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 +82,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 {};
@@ -202,6 +170,12 @@ async function defaultLoopbackRequest(input: FetchInput, init?: FetchInit) {
       });
     });
     req.on("error", reject);
+    init?.signal?.addEventListener("abort", () => {
+      req.destroy(
+        init.signal?.reason instanceof Error ? init.signal.reason : new Error("request aborted")
+      );
+      reject(init.signal?.reason ?? new Error("request aborted"));
+    }, { once: true });
     if (body) req.write(body);
     req.end();
   });
@@ -224,6 +198,7 @@ async function fetchWithTransientRetry(
       }
       return await fetchImpl(input, init);
     } catch (error) {
+      if (init?.signal?.aborted) throw error;
       if (!isTransientFetchError(error)) throw error;
       lastError = error;
       if (attempt < TRANSIENT_FETCH_MAX_ATTEMPTS) {
@@ -234,52 +209,44 @@ async function fetchWithTransientRetry(
   throw lastError;
 }
 
-function buildOpenAiTools(args: {
-  requestedToolNames?: string[];
-  platformToolNames?: string[];
-  hostRuntimeConfig: HostRuntimeConfig;
-}) {
-  const toolset = buildLocalWorkspaceToolsetForHost(args);
+function buildRequestTimeoutSignal(timeoutMs?: number) {
+  if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return undefined;
+  }
+  if (typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function") {
+    return AbortSignal.timeout(timeoutMs);
+  }
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(new Error(`request timed out after ${timeoutMs}ms`)), timeoutMs);
+  return controller.signal;
+}
+
+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 +332,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 +402,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 }
   );
@@ -518,9 +452,8 @@ export function createCliLocalRuntimeAdapter(
         ? resolveRequestedRuntimeToolNames({ agentConfig })
         : [];
       activeAgentToolNames = buildLocalPolicyToolNames({
-        requestedToolNames,
-        platformToolNames: agentConfig?.toolNames,
-        hostRuntimeConfig,
+        toolNames: requestedToolNames,
+        env: deps.env,
       });
       await activateAgentWorkspaceSession({ agentRef, agentConfig });
       return agentConfig;
@@ -538,48 +471,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,
@@ -587,19 +478,24 @@ export function createCliLocalRuntimeAdapter(
         });
         return {
           model: providerConfig.model,
-          complete: async (messages) => {
-            const requestedToolNames = resolveRequestedRuntimeToolNames({ agentConfig });
+          complete: async (messages, options) => {
+            const requestedToolNames = resolveRequestedRuntimeToolNames({
+              agentConfig,
+            });
             const tools = buildOpenAiTools({
-              requestedToolNames,
-              platformToolNames: agentConfig.toolNames,
-              hostRuntimeConfig,
+              toolNames: requestedToolNames,
+              env: deps.env,
             });
             const request = buildPlatformChatCompletionRequest({
               providerConfig,
               messages,
               tools,
             });
-            const res = await fetchWithTransientRetry(fetchImpl, request.url, request.init, {
+            const signal = buildRequestTimeoutSignal(options?.timeoutMs);
+            const res = await fetchWithTransientRetry(fetchImpl, request.url, {
+              ...request.init,
+              ...(signal ? { signal } : {}),
+            }, {
               sleep: deps.sleep,
               loopbackRequest,
             });
@@ -622,19 +518,24 @@ export function createCliLocalRuntimeAdapter(
       });
       return {
         model: providerConfig.model,
-        complete: async (messages) => {
-          const requestedToolNames = resolveRequestedRuntimeToolNames({ agentConfig });
+        complete: async (messages, options) => {
+          const requestedToolNames = resolveRequestedRuntimeToolNames({
+            agentConfig,
+          });
           const tools = buildOpenAiTools({
-            requestedToolNames,
-            platformToolNames: agentConfig.toolNames,
-            hostRuntimeConfig,
+            toolNames: requestedToolNames,
+            env: deps.env,
           });
           const request = buildOpenAiCompatibleChatCompletionRequest({
             providerConfig,
             messages,
             tools,
           });
-          const res = await fetchWithTransientRetry(fetchImpl, request.url, request.init, {
+          const signal = buildRequestTimeoutSignal(options?.timeoutMs);
+          const res = await fetchWithTransientRetry(fetchImpl, request.url, {
+            ...request.init,
+            ...(signal ? { signal } : {}),
+          }, {
             sleep: deps.sleep,
             loopbackRequest,
           });
@@ -658,7 +559,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");
 }

package/commandRegistry.ts

@@ -49,14 +49,14 @@ export function renderHelpText() {
     "  nolo connect",
     "  nolo connect --watch",
     "  nolo connect --ws",
-    "  nolo connect --ws --server-url https://api.nolo.chat --api-key sk_machine_xxx",
-    "  nolo connect --daemon --server-url https://api.nolo.chat --api-key sk_machine_xxx",
+    "  nolo connect --ws --server-url https://api.nolo.chat --machine-key sk_machine_xxx",
+    "  nolo connect --daemon --server-url https://api.nolo.chat --machine-key sk_machine_xxx",
     "  nolo machine status",
     "  nolo doctor",
     "  nolo doctor runtime",
     "  nolo update",
-    '  nolo doc create --title "Trip Notes" --body "hello" --space 01SPACEID --dry-run',
-    '  nolo skill-doc create --title "Agent Query Skill" --description "Inspect recent agent dialogs" --space 01SPACEID',
+    '  nolo doc create --title "Trip Notes" --body "hello" --sync local,us --dry-run',
+    '  nolo skill-doc create --title "Agent Query Skill" --description "Inspect recent agent dialogs" --sync local,main,us',
     "  nolo agent list --json",
     "  nolo space list --json",
     "  nolo agent pull agent-pub-01APPBUILDER00000001YAII3I",
@@ -64,7 +64,6 @@ export function renderHelpText() {
     '  nolo agent run frontend-implementer --msg "polish notifications"',
     "  nolo agent bind-current agent-user-1-agent-1",
     "  nolo agent runtime-doctor agent-user-1-agent-1",
-    '  nolo agent smoke-bound agent-user-1-agent-1 --msg "ping"',
     '  nolo agent smoke-current agent-user-1-agent-1 --msg "ping"',
     '  nolo chat --agent agent-pub-01APPBUILDER00000001YAII3I --msg "你好"',
     "  nolo space read 01KKY77TT0DA9NY7TNW3R7255N --content-key page-user-id --brief",

package/connectorRunArtifact.ts

@@ -24,46 +24,22 @@ function normalizePath(value: string) {
   return resolve(value.trim());
 }
 
-function resolveExistingCandidate(
-  value: string | undefined,
-  checked: string[],
-  label: string
-) {
-  const trimmed = value?.trim();
-  if (!trimmed) return null;
-  const normalized = normalizePath(trimmed);
-  if (existsSync(normalized)) return normalized;
-  checked.push(`${label}=${normalized}`);
-  return null;
-}
-
 export function resolveConnectorRunCwd(args: {
   env?: EnvLike;
   policy: MachineRunPermissionPolicy;
   fallbackCwd?: string;
 }) {
-  const checked: string[] = [];
-  const candidates: Array<[string | undefined, string]> = [
-    [args.env?.NOLO_CONNECTOR_WORKDIR, "NOLO_CONNECTOR_WORKDIR"],
-    [args.env?.NOLO_AGENT_WORKDIR, "NOLO_AGENT_WORKDIR"],
-    [args.env?.NOLO_LOCAL_WORKTREE, "NOLO_LOCAL_WORKTREE"],
-    [args.policy.writableRoots[0], "writableRoots[0]"],
-    [args.fallbackCwd, "fallbackCwd"],
-    [process.env.PWD, "PWD"],
-    [process.cwd(), "process.cwd()"],
-  ];
-
-  for (const [value, label] of candidates) {
-    const resolved = resolveExistingCandidate(value, checked, label);
-    if (resolved) return resolved;
-  }
-
-  if (checked.length > 0) {
-    throw new Error(
-      `Connector run cwd does not exist. Checked: ${checked.join(", ")}`
-    );
+  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);
+  if (!existsSync(cwd)) {
+    throw new Error(`Connector run cwd does not exist: ${cwd}`);
   }
-  throw new Error("Connector run cwd could not be resolved.");
+  return cwd;
 }
 
 async function runGit(

package/connectorWebSocketTarget.ts

@@ -49,18 +49,14 @@ function parseRetryAfterMs(response: Response, bodyRetryAfterMs?: unknown) {
 export async function resolveConnectorWebSocketTarget(input: {
   serverUrl: string;
   machineId: string;
-  connectorSurface?: string;
   headers: Record<string, string>;
   fetchImpl?: typeof fetch;
 }) {
   const directWsUrl = new URL(input.serverUrl);
   directWsUrl.protocol = directWsUrl.protocol === "https:" ? "wss:" : "ws:";
   directWsUrl.pathname = "/api/connector/ws";
-  directWsUrl.search = "";
-  directWsUrl.searchParams.set("machineId", input.machineId);
-  if (input.connectorSurface?.trim()) {
-    directWsUrl.searchParams.set("connectorSurface", input.connectorSurface.trim().toLowerCase());
-  }
+  directWsUrl.search = "";
+  directWsUrl.searchParams.set("machineId", input.machineId);
 
   const probeUrl = new URL(input.serverUrl);
   probeUrl.pathname = "/api/connector/ws";
@@ -103,7 +99,7 @@ export async function resolveConnectorWebSocketTarget(input: {
   }
 
   const json = await response.json().catch(() => null);
-  return typeof json?.wsUrl === "string" && json.wsUrl
-    ? json.wsUrl
-    : directWsUrl.toString();
-}
+  return typeof json?.wsUrl === "string" && json.wsUrl
+    ? json.wsUrl
+    : directWsUrl.toString();
+}

package/database/server/serverStoreFactory.ts

@@ -7,8 +7,6 @@ import { createLegacyServerDb, type LegacyServerDb } from "./legacyServerDb";
 import { createLevelAuthorityStore } from "./levelAuthorityStore";
 import { createMemoryAuthorityStore } from "./memoryAuthorityStore";
 
-// Keep the storage seam local-first. Cross-process sharing stays in the
-// existing core/proxy runtime layer; this factory is only for embedded drivers.
 export type ServerStoreDriver = "level" | "memory";
 
 export type ServerStoreFactoryEnv = {
@@ -66,15 +64,12 @@ export function resolveServerStoreDriver(
 
 export function createAuthorityStoreForDriver(
   driver: ServerStoreDriver,
-  dbPath: string,
-  env: ServerStoreFactoryEnv = process.env
+  dbPath: string
 ): AuthorityStore {
   switch (driver) {
     case "level":
       return createLevelBackedAuthorityStore(dbPath);
     case "memory":
-      // Test/dev-only driver that exercises the seam without changing the
-      // production single-writer runtime model.
       return createMemoryAuthorityStore(dbPath);
   }
 }
@@ -103,8 +98,7 @@ export function getOrCreateServerStoreRuntime(
   if (!globalScope.__serverAuthorityStore) {
     globalScope.__serverAuthorityStore = createAuthorityStoreForDriver(
       driver,
-      dbPath,
-      options.env
+      dbPath
     );
     globalScope.__serverAuthorityStoreDriver = driver;
   } else if (!cachedDriver) {

package/internalCommandEntries.ts

@@ -1,20 +1,12 @@
 import { getAgentInternalCommandEntries } from "./agentInternalCommandEntries";
 import type { CommandEntry } from "./cliCommandTypes";
-import { getDialogInternalCommandEntries } from "./dialogInternalCommandEntries";
-import { getDocInternalCommandEntries } from "./docInternalCommandEntries";
-import { getRuntimeInternalCommandEntries } from "./runtimeInternalCommandEntries";
-import { getSpaceInternalCommandEntries } from "./spaceInternalCommandEntries";
 import { getSystemInternalCommandEntries } from "./systemInternalCommandEntries";
 import { getWorkflowInternalCommandEntries } from "./workflowInternalCommandEntries";
 
 export function getInternalCommandEntries(renderHelpText: () => string): CommandEntry[] {
   return [
     ...getAgentInternalCommandEntries(),
-    ...getDialogInternalCommandEntries(),
-    ...getDocInternalCommandEntries(),
-    ...getSpaceInternalCommandEntries(),
     ...getWorkflowInternalCommandEntries(),
-    ...getRuntimeInternalCommandEntries(),
     ...getSystemInternalCommandEntries(renderHelpText),
   ];
 }