nolo-cli 0.1.32 → 0.1.33

package/cli/client/localRuntimeAdapter.ts

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

package/cli/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/cli/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/cli/commandRegistry.ts

@@ -55,8 +55,8 @@ export function renderHelpText() {
     "  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/cli/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/cli/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/cli/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),
   ];
 }

package/cli/localRuntimeDb.ts

@@ -20,46 +20,9 @@ export function buildCliLocalRuntimeDbEnv(env: EnvLike = process.env) {
   };
 }
 
-export function isCliLocalRuntimeDbLockError(error: unknown): boolean {
-  const queue: unknown[] = [error];
-  const seen = new Set<unknown>();
-
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (!current || seen.has(current)) continue;
-    seen.add(current);
-
-    const text = `${(current as any)?.code ?? ""} ${(current as any)?.message ?? current}`;
-    if (/LEVEL_LOCKED|Resource temporarily unavailable|\/LOCK|LOCK:|db locked|locked/i.test(text)) {
-      return true;
-    }
-
-    if ((current as any)?.cause) queue.push((current as any).cause);
-    if (Array.isArray((current as any)?.errors)) queue.push(...(current as any).errors);
-  }
-
-  return false;
-}
-
-export function formatCliLocalRuntimeDbOpenError(dbPath: string, error: unknown) {
-  if (!isCliLocalRuntimeDbLockError(error)) {
-    return error instanceof Error ? error : new Error(String(error));
-  }
-  return new Error(
-    `CLI local runtime DB is locked at ${dbPath}. Another nolo local runtime is already using it. ` +
-      "Stop the other local runtime, rerun without --local, or set NOLO_SERVER_DB_PATH to a different cache path.",
-    { cause: error instanceof Error ? error : undefined }
-  );
-}
-
 export async function getDefaultCliLocalRuntimeDb(): Promise<CliLocalRuntimeDb> {
-  const dbPath = buildCliLocalRuntimeDbEnv(process.env).NOLO_SERVER_DB_PATH;
-  process.env.NOLO_SERVER_DB_PATH = dbPath;
+  process.env.NOLO_SERVER_DB_PATH = buildCliLocalRuntimeDbEnv(process.env).NOLO_SERVER_DB_PATH;
   const { default: serverDb, ensureServerDbOpen } = await import("../database/server/db");
-  try {
-    await ensureServerDbOpen();
-  } catch (error) {
-    throw formatCliLocalRuntimeDbOpenError(dbPath, error);
-  }
+  await ensureServerDbOpen();
   return serverDb as CliLocalRuntimeDb;
 }