nolo-cli 0.1.32 → 0.1.34

package/cli/machineWatchCommands.ts

@@ -1,8 +1,8 @@
 import type { MachineHeartbeat } from "../connector-experimental/protocol";
 import type { HeartbeatLoopOptions } from "../connector-experimental/heartbeatLoop";
-import type { OutputLike } from "./cliIoTypes";
 
 type EnvLike = Record<string, string | undefined>;
+type OutputLike = { write(chunk: string): unknown };
 
 function resolveHeartbeatIntervalMs(env: EnvLike) {
   const raw = Number(env.NOLO_CONNECT_HEARTBEAT_MS ?? "");

package/cli/machineWsRunDispatch.ts

@@ -1,6 +1,4 @@
 import { runLocalAgentTurn, type LocalAgentToolEvent } from "../agent-runtime/localLoop";
-import { resolveHostRuntimeConfigFromEnv } from "../agent-runtime/hostRuntimeConfig";
-import { normalizeAgentRunDialogLineage } from "../ai/agent/agentRunDialogLineage";
 import {
   assertMachineRunAllowed as defaultAssertMachineRunAllowed,
   resolveMachineRunPermissionPolicy as defaultResolveMachineRunPermissionPolicy,
@@ -58,7 +56,7 @@ type ConnectorRunProgress = {
 
 type PermissionPolicy = ReturnType<typeof defaultResolveMachineRunPermissionPolicy>;
 
-export type MachineWsRunDispatchDeps = {
+type MachineWsRunDispatchDeps = {
   assertMachineRunAllowed?: typeof defaultAssertMachineRunAllowed;
   resolveMachineRunPermissionPolicy?: typeof defaultResolveMachineRunPermissionPolicy;
   resolveConnectorRunCwd?: typeof defaultResolveConnectorRunCwd;
@@ -150,7 +148,7 @@ function hasExplicitMachinePermissions(agentConfig: any) {
 
 function runtimeWorkspacePermissionPolicy(
   runtimePolicy: ConnectorRuntimePolicy | undefined,
-  hostRuntimeConfig: { capabilities: { allowShell: boolean } },
+  runtimeEnv: EnvLike,
   cwd: string
 ): PermissionPolicy | null {
   if (!requestsTaskWorktree(runtimePolicy)) return null;
@@ -159,7 +157,7 @@ function runtimeWorkspacePermissionPolicy(
     allowFilesystemRead: true,
     allowFilesystemWrite: true,
     allowShell:
-      hostRuntimeConfig.capabilities.allowShell &&
+      ["worktree", "dangerous", "1", "true"].includes(runtimeEnv.NOLO_LOCAL_SHELL_MODE || "") &&
       Array.isArray(runtimePolicy?.runtimeTools) &&
       runtimePolicy.runtimeTools.includes("execShell"),
     writableRoots: [cwd],
@@ -199,6 +197,9 @@ function mergeToolNames(...values: unknown[]) {
 function localRuntimeEnvFromPolicy(runtimeEnv: EnvLike, policy?: ConnectorRuntimePolicy): EnvLike {
   return {
     ...runtimeEnv,
+    ...(policy?.shell?.enabled && policy.shell.mode === "worktree"
+      ? { NOLO_LOCAL_SHELL_MODE: "worktree" }
+      : {}),
     ...(policy?.workspace?.cwd ? { NOLO_LOCAL_WORKTREE: policy.workspace.cwd } : {}),
   };
 }
@@ -272,12 +273,6 @@ async function defaultRunConnectorLocalRuntimeAgent(args: {
     ? args.parsed.payload.agentConfig
     : {};
   const policy = runtimePolicyFromConnectorPayload(args.parsed);
-  const wantsTaskWorktree = requestsTaskWorktree(policy);
-  const hostRuntimeConfig = resolveHostRuntimeConfigFromEnv({
-    env: args.runtimeEnv,
-    surface: "connector-local",
-    workspaceBinding: wantsTaskWorktree ? "default-cwd" : "explicit-cwd",
-  });
   const agentRecord = {
     ...payloadAgentConfig,
     dbKey: agentKey,
@@ -303,10 +298,11 @@ async function defaultRunConnectorLocalRuntimeAgent(args: {
     withForwardedUserAuthToken(args.runtimeEnv, args.parsed),
     policy
   );
+  const wantsTaskWorktree = requestsTaskWorktree(policy);
   const adapter = createCliLocalRuntimeAdapter({
     env,
-    hostRuntimeConfig,
     cwd: args.cwd,
+    useCwdAsTaskWorkspaceBase: wantsTaskWorktree,
     ...(wantsTaskWorktree
       ? {
           prepareTaskWorktree: (input) => prepareTaskWorktree({
@@ -389,20 +385,6 @@ function normalizeConnectorRunTimeoutMs(value: unknown): number | undefined {
   return Math.floor(value);
 }
 
-function normalizeConnectorRunPayloadContinueDialogId(payload: unknown) {
-  if (!isRecord(payload)) return payload;
-  const dialogLineage = normalizeAgentRunDialogLineage({
-    continueDialogId: payload.continueDialogId,
-  });
-  const normalizedPayload = { ...payload };
-  if (dialogLineage.continueDialogId) {
-    normalizedPayload.continueDialogId = dialogLineage.continueDialogId;
-  } else {
-    delete normalizedPayload.continueDialogId;
-  }
-  return normalizedPayload;
-}
-
 export async function handleConnectorRunMessage(
   message: string,
   send: (message: string) => void,
@@ -418,12 +400,6 @@ export async function handleConnectorRunMessage(
     return;
   }
   if (parsed?.type !== "agent.run" || typeof parsed.requestId !== "string") return;
-  if (isRecord(parsed)) {
-    parsed = {
-      ...parsed,
-      payload: normalizeConnectorRunPayloadContinueDialogId(parsed.payload),
-    };
-  }
   const agentConfig = parsed.payload?.agentConfig ?? {};
   const sendProgress = (progress: ConnectorRunProgress) => {
     send(JSON.stringify({
@@ -451,11 +427,6 @@ export async function handleConnectorRunMessage(
   try {
     const machinePermissionPolicy = resolveMachineRunPermissionPolicy(agentConfig);
     const runtimePolicy = runtimePolicyFromConnectorPayload(parsed);
-    const hostRuntimeConfig = resolveHostRuntimeConfigFromEnv({
-      env: runtimeEnv,
-      surface: agentConfig.apiSource === "cli" ? "connector-cli" : "connector-local",
-      workspaceBinding: requestsTaskWorktree(runtimePolicy) ? "default-cwd" : "explicit-cwd",
-    });
     const userInput = String(parsed.payload?.userInput ?? "");
     const timeout = normalizeConnectorRunTimeoutMs(parsed.payload?.timeoutMs);
     let cwd = resolveConnectorRunCwd({ env: runtimeEnv, policy: machinePermissionPolicy });
@@ -478,7 +449,7 @@ export async function handleConnectorRunMessage(
         artifactCwd = prepared.path;
       }
       const runtimePermissionPolicy = !hasExplicitMachinePermissions(agentConfig)
-        ? runtimeWorkspacePermissionPolicy(runtimePolicy, hostRuntimeConfig, cwd)
+        ? runtimeWorkspacePermissionPolicy(runtimePolicy, runtimeEnv, cwd)
         : null;
       const effectivePermissionPolicy = scopePermissionPolicyToRuntimeWorkspace(
         runtimePermissionPolicy ?? machinePermissionPolicy,
@@ -532,7 +503,7 @@ export async function handleConnectorRunMessage(
       const heartbeat = setInterval(() => {
         sendProgress({
           ...progressBase,
-          message: "cli-running",
+        message: "cli-running",
           updatedAt: Date.now(),
         });
       }, 15_000);
@@ -543,11 +514,26 @@ export async function handleConnectorRunMessage(
         cwd,
         yolo: true,
         env: {
-          NOLO_SERVER: effectiveRuntimeEnv.NOLO_SERVER || effectiveRuntimeEnv.NOLO_SERVER_URL || effectiveRuntimeEnv.BASE_URL,
-          NOLO_SERVER_URL: effectiveRuntimeEnv.NOLO_SERVER_URL || effectiveRuntimeEnv.NOLO_SERVER || effectiveRuntimeEnv.BASE_URL,
-          BASE_URL: effectiveRuntimeEnv.BASE_URL || effectiveRuntimeEnv.NOLO_SERVER || effectiveRuntimeEnv.NOLO_SERVER_URL,
-          AUTH_TOKEN: effectiveRuntimeEnv.AUTH_TOKEN || effectiveRuntimeEnv.AUTH || effectiveRuntimeEnv.NOLO_MACHINE_API_KEY,
-          NOLO_MACHINE_API_KEY: effectiveRuntimeEnv.NOLO_MACHINE_API_KEY || effectiveRuntimeEnv.AUTH_TOKEN || effectiveRuntimeEnv.AUTH,
+          NOLO_SERVER:
+            effectiveRuntimeEnv.NOLO_SERVER ||
+            effectiveRuntimeEnv.NOLO_SERVER_URL ||
+            effectiveRuntimeEnv.BASE_URL,
+          NOLO_SERVER_URL:
+            effectiveRuntimeEnv.NOLO_SERVER_URL ||
+            effectiveRuntimeEnv.NOLO_SERVER ||
+            effectiveRuntimeEnv.BASE_URL,
+          BASE_URL:
+            effectiveRuntimeEnv.BASE_URL ||
+            effectiveRuntimeEnv.NOLO_SERVER ||
+            effectiveRuntimeEnv.NOLO_SERVER_URL,
+          AUTH_TOKEN:
+            effectiveRuntimeEnv.AUTH_TOKEN ||
+            effectiveRuntimeEnv.AUTH ||
+            effectiveRuntimeEnv.NOLO_MACHINE_API_KEY,
+          NOLO_MACHINE_API_KEY:
+            effectiveRuntimeEnv.NOLO_MACHINE_API_KEY ||
+            effectiveRuntimeEnv.AUTH_TOKEN ||
+            effectiveRuntimeEnv.AUTH,
         },
       }).finally(() => clearInterval(heartbeat));
       logConnectorRun("agent.run.cli.result", {

package/cli/machineWsSession.ts

@@ -119,7 +119,6 @@ export async function runMachineWsSession(options: {
   resolveConnectorWebSocketTarget: (args: {
     serverUrl: string;
     machineId: string;
-    connectorSurface?: string;
     headers: Record<string, string>;
   }) => Promise<string>;
   connectWebSocket: (url: string, options: ConnectorWebSocketOptions) => Promise<void>;
@@ -150,7 +149,6 @@ export async function runMachineWsSession(options: {
     const wsTarget = await options.resolveConnectorWebSocketTarget({
       serverUrl: options.serverUrl,
       machineId: options.machine.machineId,
-      connectorSurface: "cli",
       headers: { Authorization: `Bearer ${options.authToken}` },
     });
     websocketPromise = options.connectWebSocket(wsTarget, {

package/cli/offlineMarxistsAgentCommand.ts

@@ -0,0 +1,314 @@
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+
+type EnvLike = Record<string, string | undefined>;
+
+type OutputLike = {
+  write(chunk: string): unknown;
+};
+
+type SetupOfflineMarxistsAgentDeps = {
+  env?: EnvLike;
+  output?: OutputLike;
+  fetchImpl?: typeof fetch;
+  now?: () => number;
+};
+
+type ParsedArgs = {
+  serverUrl: string;
+  authToken: string;
+  userId: string;
+  sourceAgentKey: string;
+  targetAgentId: string;
+  targetAgentKey: string;
+  spaceId: string;
+  name: string;
+  publicAgent: boolean;
+  json: boolean;
+};
+
+const DEFAULT_USER_ID = "b2e06f801f";
+const DEFAULT_SPACE_ID = "01KKY77TT0DA9NY7TNW3R7255N";
+const DEFAULT_SOURCE_AGENT_ID = "01MIMO25MONTH0000000NEW001";
+const DEFAULT_TARGET_AGENT_ID = "01OFFMARXBOOK000000010AHL1";
+const DEFAULT_AGENT_NAME = "离线马克思主义文库书籍转换助手";
+const TOOL_NAME = "convertMarxistsBookToOfflineHtml";
+const AGENT_TOOLS = [TOOL_NAME];
+
+function readFlagValue(args: string[], flag: string) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+function parseUserIdFromToken(token: string) {
+  const payload = token.split(".")[0];
+  if (!payload) return "";
+  try {
+    const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized + "=".repeat((4 - (normalized.length % 4)) % 4);
+    const parsed = JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+    return typeof parsed?.userId === "string" ? parsed.userId : "";
+  } catch {
+    return "";
+  }
+}
+
+function normalizeBaseUrl(value: string) {
+  return value.trim().replace(/\/+$/, "");
+}
+
+function parseArgs(args: string[], env: EnvLike): ParsedArgs | null {
+  if (args.includes("--help") || args.includes("-h")) return null;
+  const serverUrl = normalizeBaseUrl(
+    readFlagValue(args, "--server") ??
+      readFlagValue(args, "--server-url") ??
+      env.NOLO_SERVER ??
+      env.BASE_URL ??
+      DEFAULT_NOLO_SERVER_URL
+  );
+  const authToken = readFlagValue(args, "--token") ?? env.AUTH_TOKEN ?? env.NOLO_AUTH_TOKEN ?? "";
+  const userId =
+    readFlagValue(args, "--user-id") ??
+    env.NOLO_USER_ID ??
+    parseUserIdFromToken(authToken) ??
+    DEFAULT_USER_ID;
+  const sourceAgentKey =
+    readFlagValue(args, "--source-agent") ??
+    env.NOLO_MIMO_SOURCE_AGENT_KEY ??
+    `agent-${userId}-${DEFAULT_SOURCE_AGENT_ID}`;
+  const targetAgentId =
+    readFlagValue(args, "--target-agent-id") ??
+    env.NOLO_OFFLINE_MARXISTS_AGENT_ID ??
+    DEFAULT_TARGET_AGENT_ID;
+  const targetAgentKey =
+    readFlagValue(args, "--target-agent") ??
+    env.NOLO_OFFLINE_MARXISTS_AGENT_KEY ??
+    `agent-${userId}-${targetAgentId}`;
+  const spaceId =
+    readFlagValue(args, "--space") ??
+    env.NOLO_OFFLINE_MARXISTS_SPACE_ID ??
+    DEFAULT_SPACE_ID;
+
+  if (!authToken.trim()) return null;
+  return {
+    serverUrl,
+    authToken,
+    userId,
+    sourceAgentKey,
+    targetAgentId,
+    targetAgentKey,
+    spaceId,
+    name: readFlagValue(args, "--name") ?? DEFAULT_AGENT_NAME,
+    publicAgent: args.includes("--public"),
+    json: args.includes("--json"),
+  };
+}
+
+async function readDbRecord(args: {
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  authToken: string;
+  dbKey: string;
+}) {
+  const res = await args.fetchImpl(
+    `${args.serverUrl}/api/v1/db/read/${encodeURIComponent(args.dbKey)}`,
+    { headers: { Authorization: `Bearer ${args.authToken}` } }
+  );
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`read ${args.dbKey} failed (${res.status}): ${JSON.stringify(data)}`);
+  }
+  return (data as any)?.data ?? data;
+}
+
+async function writeDbRecord(args: {
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  authToken: string;
+  userId: string;
+  dbKey: string;
+  data: Record<string, any>;
+}) {
+  const res = await args.fetchImpl(`${args.serverUrl}/api/v1/db/write/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${args.authToken}`,
+    },
+    body: JSON.stringify({
+      customKey: args.dbKey,
+      userId: args.userId,
+      data: { ...args.data, dbKey: args.dbKey },
+    }),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`write ${args.dbKey} failed (${res.status}): ${JSON.stringify(data)}`);
+  }
+}
+
+function buildTargetAgent(args: {
+  parsed: ParsedArgs;
+  source: Record<string, any>;
+  now: number;
+}) {
+  const { parsed, source, now } = args;
+  if (!source.apiKey) {
+    throw new Error(`source agent ${parsed.sourceAgentKey} has no apiKey`);
+  }
+  if (!source.customProviderUrl) {
+    throw new Error(`source agent ${parsed.sourceAgentKey} has no customProviderUrl`);
+  }
+  return {
+    id: parsed.targetAgentId,
+    type: "agent",
+    name: parsed.name,
+    description:
+      "把 Marxists.org 中文旧式书籍页面转换为可离线打开的单文件 HTML，保留原 CSS、表格排版和背景纹理。",
+    prompt:
+      "你是离线书籍转换助手。用户给出 Marxists.org 中文书籍页面或要求保存离线书籍时，只能调用 convertMarxistsBookToOfflineHtml，不要使用普通网页抓取流程。最终回答必须逐字给出 rawData.fileUrl、rawData.pageCount、rawData.hasNetworkUrls、rawData.byteLength。",
+    isPublic: parsed.publicAgent,
+    model: source.model ?? "mimo-v2.5-pro",
+    provider: source.provider ?? "custom",
+    apiSource: source.apiSource ?? "custom",
+    apiKey: source.apiKey,
+    customProviderUrl: source.customProviderUrl,
+    apiKeyHeader: source.apiKeyHeader ?? "api-key",
+    tools: AGENT_TOOLS,
+    temperature: source.temperature ?? 0.2,
+    maxTokens: source.maxTokens ?? 4096,
+    category: "document-tools",
+    tags: ["offline-book", "marxists", "mimo"],
+    userId: parsed.userId,
+    createdAt: source.createdAt ?? now,
+    updatedAt: now,
+  };
+}
+
+async function attachAgentToSpace(args: {
+  fetchImpl: typeof fetch;
+  parsed: ParsedArgs;
+  contentKey: string;
+  title: string;
+  now: number;
+}) {
+  const spaceKey = `space-${args.parsed.spaceId}`;
+  const space = await readDbRecord({
+    fetchImpl: args.fetchImpl,
+    serverUrl: args.parsed.serverUrl,
+    authToken: args.parsed.authToken,
+    dbKey: spaceKey,
+  });
+  await writeDbRecord({
+    fetchImpl: args.fetchImpl,
+    serverUrl: args.parsed.serverUrl,
+    authToken: args.parsed.authToken,
+    userId: args.parsed.userId,
+    dbKey: spaceKey,
+    data: {
+      ...space,
+      contents: {
+        ...(space.contents ?? {}),
+        [args.contentKey]: {
+          ...(space.contents?.[args.contentKey] ?? {}),
+          title: args.title,
+          type: "agent",
+          contentKey: args.contentKey,
+          createdAt: space.contents?.[args.contentKey]?.createdAt ?? args.now,
+          updatedAt: args.now,
+        },
+      },
+      updatedAt: args.now,
+    },
+  });
+}
+
+function writeUsage(output: OutputLike) {
+  output.write(
+    "Usage: nolo agent setup-offline-marxists [--server https://nolo.chat] [--source-agent <key>] [--space <spaceId>] [--target-agent-id <id>] [--json]\n" +
+      "Requires AUTH_TOKEN from `nolo login` or --token.\n"
+  );
+}
+
+export async function runSetupOfflineMarxistsAgentCommand(
+  args: string[],
+  deps: SetupOfflineMarxistsAgentDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const parsed = parseArgs(args, env);
+  if (!parsed) {
+    writeUsage(output);
+    return 1;
+  }
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const now = deps.now?.() ?? Date.now();
+
+  try {
+    const source = await readDbRecord({
+      fetchImpl,
+      serverUrl: parsed.serverUrl,
+      authToken: parsed.authToken,
+      dbKey: parsed.sourceAgentKey,
+    });
+    const target = buildTargetAgent({ parsed, source, now });
+    await writeDbRecord({
+      fetchImpl,
+      serverUrl: parsed.serverUrl,
+      authToken: parsed.authToken,
+      userId: parsed.userId,
+      dbKey: parsed.targetAgentKey,
+      data: target,
+    });
+    const publicKey = `agent-pub-${parsed.targetAgentId}`;
+    if (parsed.publicAgent) {
+      await writeDbRecord({
+        fetchImpl,
+        serverUrl: parsed.serverUrl,
+        authToken: parsed.authToken,
+        userId: parsed.userId,
+        dbKey: publicKey,
+        data: target,
+      });
+    }
+    await attachAgentToSpace({
+      fetchImpl,
+      parsed,
+      contentKey: parsed.publicAgent ? publicKey : parsed.targetAgentKey,
+      title: parsed.name,
+      now,
+    });
+
+    const result = {
+      serverUrl: parsed.serverUrl,
+      sourceAgentKey: parsed.sourceAgentKey,
+      agentKey: parsed.targetAgentKey,
+      agentUrl: `${parsed.serverUrl}/${parsed.targetAgentKey}`,
+      publicKey: parsed.publicAgent ? publicKey : null,
+      spaceId: parsed.spaceId,
+      model: target.model,
+      provider: target.provider,
+      customProviderUrl: target.customProviderUrl,
+      tools: target.tools,
+    };
+    if (parsed.json) {
+      output.write(`${JSON.stringify(result, null, 2)}\n`);
+    } else {
+      output.write(
+        [
+          `created/updated: ${result.agentKey}`,
+          `url: ${result.agentUrl}`,
+          `space: ${result.spaceId}`,
+          `model: ${result.model}`,
+          `tools: ${result.tools.join(", ")}`,
+          "",
+        ].join("\n")
+      );
+    }
+    return 0;
+  } catch (error) {
+    output.write(
+      `setup-offline-marxists failed: ${error instanceof Error ? error.message : String(error)}\n`
+    );
+    return 1;
+  }
+}

package/cli/runtimeDoctorCommands.ts

@@ -1,22 +1,41 @@
+import { resolveAgentRuntimeDecision } from "../agent-runtime/runtimeDecision";
 import {
   type AgentCommandDeps,
   type LocalRuntimeProbeResult,
 } from "./agentCommandSupport";
-import {
-  buildCliRuntimeDoctorProbe,
-  buildCliRuntimeDoctorReport,
-  formatCliRuntimeDoctorReport,
-} from "./cliRuntimeDoctorReport";
 import {
   resolveAuthToken,
   resolveServerUrl,
   type EnvLike,
 } from "./cliEnvHelpers";
 
+function detectLocalAgentConfig(env: EnvLike) {
+  return Boolean(readLocalAgentKey(env) || env.NOLO_AGENT_CACHE_READY);
+}
+
 function readLocalAgentKey(env: EnvLike) {
   return env.NOLO_LOCAL_AGENT_KEY || env.NOLO_AGENT || "";
 }
 
+function detectLocalProvider(env: EnvLike) {
+  return Boolean(
+    env.OPENAI_API_KEY ||
+    env.ANTHROPIC_API_KEY ||
+    env.GOOGLE_API_KEY ||
+    env.NOLO_LOCAL_OPENAI_BASE_URL ||
+    env.OLLAMA_BASE_URL
+  );
+}
+
+function detectProviderLabel(env: EnvLike) {
+  if (env.NOLO_LOCAL_OPENAI_BASE_URL) return `openai-compatible endpoint ${env.NOLO_LOCAL_OPENAI_BASE_URL}`;
+  if (env.OLLAMA_BASE_URL) return `ollama-compatible endpoint ${env.OLLAMA_BASE_URL}`;
+  if (env.OPENAI_API_KEY) return "openai via env OPENAI_API_KEY";
+  if (env.ANTHROPIC_API_KEY) return "anthropic via env ANTHROPIC_API_KEY";
+  if (env.GOOGLE_API_KEY) return "google via env GOOGLE_API_KEY";
+  return "missing";
+}
+
 async function defaultLocalRuntimeProbe(env: EnvLike): Promise<LocalRuntimeProbeResult> {
   const { resolveCliLocalRuntimeDbPath } = await import("./localRuntimeDb");
   const dbPath = resolveCliLocalRuntimeDbPath({ env });
@@ -53,15 +72,53 @@ export async function runDoctorRuntimeCommand(
   const authToken = resolveAuthToken(args, env);
   const serverUrl = resolveServerUrl(args, env);
   const localProbe = await (deps.localRuntimeProbe ?? defaultLocalRuntimeProbe)(env);
-  const report = buildCliRuntimeDoctorReport(
-    buildCliRuntimeDoctorProbe({
-      env,
-      localProbe,
-      authToken,
-      serverUrl,
-    })
-  );
-  output.write(formatCliRuntimeDoctorReport(report));
+  const hasLocalAgentConfig = detectLocalAgentConfig(env) && localProbe.ok && localProbe.agentFound;
+  const hasLocalProvider = detectLocalProvider(env);
+  const missingLocalCapabilities = [
+    ...(localProbe.ok ? [] : ["leveldb"]),
+    ...(hasLocalAgentConfig ? [] : ["agent-config"]),
+    ...(hasLocalProvider ? [] : ["provider"]),
+  ];
+  const decision = resolveAgentRuntimeDecision({
+    requestedMode: "auto",
+    syncRequested: false,
+    host: "cli",
+    hasLocalAgentConfig,
+    hasLocalProvider,
+    hasLocalPersistence: true,
+    missingLocalCapabilities,
+    requiresServer: false,
+    serverFallbackAvailable: Boolean(
+      authToken ||
+      args.includes("--server") ||
+      args.includes("--server-url") ||
+      env.NOLO_SERVER ||
+      env.BASE_URL
+    ),
+  });
+
+  output.write(`Runtime: ${decision.mode}\n`);
+  output.write(`Reason: ${decision.reason}\n`);
+  output.write(`LevelDB: ${localProbe.ok ? "ok" : "failed"}\n`);
+  output.write(`DB path: ${localProbe.dbPath}\n`);
+  if (!localProbe.ok && localProbe.error) {
+    output.write(`DB error: ${localProbe.error}\n`);
+  }
+  if (localProbe.agentKey) {
+    output.write(`Agent config: ${localProbe.agentFound ? "found" : "missing"} (${localProbe.agentKey})\n`);
+  } else {
+    output.write("Agent config: missing (no local agent key)\n");
+  }
+  output.write(`Provider: ${hasLocalProvider ? "available" : "missing"} (${detectProviderLabel(env)})\n`);
+  output.write("Persistence: LevelDB local store\n");
+  output.write(`Sync: ${authToken ? "available" : "unavailable"}${authToken ? "" : " (not authenticated)"}\n`);
+  output.write(`Server fallback: ${decision.runnable && decision.mode === "server" ? serverUrl : authToken || env.NOLO_SERVER || env.BASE_URL ? serverUrl : "unavailable"}\n`);
+  if (decision.missingLocalCapabilities.length > 0) {
+    output.write("Missing local capabilities:\n");
+    for (const capability of decision.missingLocalCapabilities) {
+      output.write(`- ${capability}\n`);
+    }
+  }
 
-  return report.decision.runnable ? 0 : 1;
+  return decision.runnable ? 0 : 1;
 }

package/cli/scriptCommandEntries.ts

@@ -1,23 +1,63 @@
 import { createScriptCommand, type CommandEntry } from "./cliCommandTypes";
 
 function getDocScriptCommands(): CommandEntry[] {
-  return [];
+  return [
+    createScriptCommand(["doc", "create"], "createDoc.ts", "Create a normal doc"),
+    createScriptCommand(["doc", "read"], "readDoc.ts", "Read a normal doc"),
+    createScriptCommand(["doc", "update"], "updateDoc.ts", "Update a normal doc"),
+    createScriptCommand(["doc", "delete"], "deleteDoc.ts", "Delete a normal doc"),
+    createScriptCommand(["skill-doc", "create"], "createSkillDoc.ts", "Create a skill doc"),
+    createScriptCommand(["skill-doc", "read"], "readSkillDoc.ts", "Read a skill doc"),
+    createScriptCommand(["skill-doc", "update"], "updateSkillDoc.ts", "Update a skill doc"),
+    createScriptCommand(["skill-doc", "delete"], "deleteSkillDoc.ts", "Delete a skill doc"),
+    createScriptCommand(["skill", "create-doc"], "createSkillDoc.ts", "Create a skill-backed doc"),
+  ];
 }
 
 function getSpaceScriptCommands(): CommandEntry[] {
-  return [];
+  return [
+    createScriptCommand(["dialog", "read"], "readDialog.ts", "Read a dialog"),
+    createScriptCommand(["dialog", "status"], "dialogStatus.ts", "Read compact dialog status"),
+    createScriptCommand(["space", "list"], "listSpaces.ts", "List joined spaces"),
+    createScriptCommand(["space", "read"], "readSpace.ts", "Read a space"),
+    createScriptCommand(["space", "delete"], "deleteSpaces.ts", "Delete spaces by safe filters"),
+    createScriptCommand(["space", "category"], "upsertSpaceCategory.ts", "Create or update a space category"),
+    createScriptCommand(["space", "content-category"], "setSpaceContentCategory.ts", "Move content into a space category"),
+  ];
 }
 
 function getTableScriptCommands(): CommandEntry[] {
-  return [];
+  return [
+    createScriptCommand(["table", "add-column"], "tableData.ts", "Add one table column", ["--action", "add-column"]),
+    createScriptCommand(["table", "add-row"], "tableData.ts", "Add one table row", ["--action", "add-row"]),
+    createScriptCommand(["table", "add-rows"], "tableData.ts", "Add table rows", ["--action", "add-rows"]),
+    createScriptCommand(["table", "update-row"], "tableData.ts", "Update one table row", ["--action", "update-row"]),
+    createScriptCommand(["table", "update-rows"], "tableData.ts", "Update table rows", ["--action", "update-rows"]),
+    createScriptCommand(["table", "delete-row"], "tableData.ts", "Delete one table row", ["--action", "delete-row"]),
+    createScriptCommand(["table", "delete-rows"], "tableData.ts", "Delete table rows", ["--action", "delete-rows"]),
+    createScriptCommand(["table", "data"], "tableData.ts", "Low-level table row script bridge"),
+    createScriptCommand(["table", "meta"], "upsertTableMeta.ts", "Create or update table metadata"),
+  ];
 }
 
 function getAgentScriptCommands(): CommandEntry[] {
-  return [];
+  return [
+    createScriptCommand(["agent", "unpublish"], "unpublishAgent.ts", "Remove an agent's public record"),
+    createScriptCommand(["agent", "dialogs"], "queryAgentDialogs.ts", "Inspect recent dialogs for an agent"),
+    createScriptCommand(["agent", "doctor"], "doctorAgentWorkspace.ts", "Audit agent workspace health"),
+    createScriptCommand(["agent", "create-custom"], "createCustomCodingAgent.ts", "Create a custom coding agent"),
+    createScriptCommand(["agent", "create-space"], "createSpaceAgents.ts", "Create or attach shared-space agents"),
+    createScriptCommand(["agent", "setup-demo"], "setupDemoAgent.ts", "Bootstrap demo publisher agents"),
+    createScriptCommand(["agent", "supervise"], "runAutonomousAgent.ts", "Run an agent in autonomous cycles"),
+  ];
 }
 
 function getRuntimeScriptCommands(): CommandEntry[] {
-  return [];
+  return [
+    createScriptCommand(["llama"], "llamaServerSupervisor.ts", "Manage the llama.cpp runtime"),
+    createScriptCommand(["model-runtime"], "localModelRuntimeSupervisor.ts", "Manage local model runtime processes"),
+    createScriptCommand(["dev"], "devControl.ts", "Manage the local dev environment"),
+  ];
 }
 
 export function getScriptCommandEntries(): CommandEntry[] {