nolo-cli 0.1.40 → 0.1.42

package/client/localRuntimeAdapter.ts

@@ -42,8 +42,14 @@ import {
   type HybridRecordStore,
 } from "./hybridRecordStore";
 import { executeLocalToolWithPolicy } from "./localToolPolicy";
-import { taskRunFunctionSchema } from "../ai/tools/agent/taskRunTool";
+import { inferCaptureIntent } from "../ai/policy/runtimePolicy";
+import { TOOL_PACKS } from "../ai/tools/toolPacks";
+import { prepareTools } from "../ai/tools/prepareTools";
 import {
+  LOCAL_CODEX_AGENT_ID,
+  LOCAL_CODEX_AGENT_KEY,
+  LOCAL_QODER_AGENT_ID,
+  LOCAL_QODER_AGENT_KEY,
   MIMO_MONTH_AGENT_KEY,
   NOLO_DEFAULT_AGENT_ID,
   NOLO_DEFAULT_AGENT_KEY,
@@ -56,6 +62,14 @@ import {
 } from "../agent-runtime/noloWorkspaceTools";
 import { executeCli as defaultExecuteCli, type CliExecuteResult, type CliImageInput } from "../ai/agent/cliExecutor";
 import { buildCliPrompt } from "../ai/agent/cliPrompt";
+import {
+  readXhsProfileFunc,
+  readXhsProfileFunctionSchema,
+} from "../ai/tools/readXhsProfileTool";
+import {
+  readXPostFunc,
+  readXPostFunctionSchema,
+} from "../ai/tools/readXPostTool";
 
 type EnvLike = Record<string, string | undefined>;
 type FetchInput = Parameters<typeof fetch>[0];
@@ -78,6 +92,14 @@ 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");
+const LOCAL_SERVER_TABLE_TOOL_NAMES = [
+  "createTable",
+  "addTableRow",
+  "addTableRows",
+  "updateTableRow",
+  "updateTableRows",
+] as const;
+const LOCAL_SERVER_TABLE_TOOL_NAME_SET = new Set<string>(LOCAL_SERVER_TABLE_TOOL_NAMES);
 
 export type CliLocalRuntimeDb = CliKvDb;
 
@@ -91,6 +113,8 @@ export type CliLocalRuntimeAdapterDeps = {
   cwd?: string;
   output?: { write(chunk: string): unknown };
   localToolExecutors?: Record<string, (call: any) => Promise<{ content: string; metadata?: Record<string, unknown> }>>;
+  readXPost?: typeof readXPostFunc;
+  readXhsProfile?: typeof readXhsProfileFunc;
   executeCli?: LocalCliExecutor;
   sleep?: (ms: number) => Promise<void>;
   loopbackRequest?: (input: FetchInput, init?: FetchInit) => Promise<Response>;
@@ -108,6 +132,55 @@ function resolveLocalUserId(env: EnvLike) {
   return env.NOLO_LOCAL_USER_ID || env.NOLO_USER_ID || "local";
 }
 
+function resolveBuiltinLocalCliAgentConfig(agentRef: string, userId: string): AgentRuntimeAgentConfig | null {
+  const normalized = agentRef.trim();
+  if (normalized === LOCAL_CODEX_AGENT_KEY || normalized === LOCAL_CODEX_AGENT_ID) {
+    return {
+      key: LOCAL_CODEX_AGENT_KEY,
+      name: "Local Codex",
+      prompt: "You are a local Codex CLI coding agent. Use the workspace and dialog evidence available to you, keep changes scoped, run relevant checks, and report worktree, branch, commit or dirty diff, tests, and blockers.",
+      apiSource: "cli",
+      provider: "cli",
+      cliProvider: "codex",
+      toolNames: ["readFile", "searchFiles", "execShell"],
+      rawRecord: {
+        dbKey: LOCAL_CODEX_AGENT_KEY,
+        id: LOCAL_CODEX_AGENT_ID,
+        userId,
+        type: "agent",
+        name: "Local Codex",
+        apiSource: "cli",
+        provider: "cli",
+        cliProvider: "codex",
+      },
+    };
+  }
+  if (normalized === LOCAL_QODER_AGENT_KEY || normalized === LOCAL_QODER_AGENT_ID) {
+    return {
+      key: LOCAL_QODER_AGENT_KEY,
+      name: "Local Qoder",
+      prompt: "You are a local Qoder CLI coding agent. Use the workspace and dialog evidence available to you, keep changes scoped, run relevant checks, and report worktree, branch, commit or dirty diff, tests, and blockers.",
+      apiSource: "cli",
+      provider: "cli",
+      cliProvider: "qoder",
+      model: "Qwen3.7-Max",
+      toolNames: ["readFile", "searchFiles", "execShell"],
+      rawRecord: {
+        dbKey: LOCAL_QODER_AGENT_KEY,
+        id: LOCAL_QODER_AGENT_ID,
+        userId,
+        type: "agent",
+        name: "Local Qoder",
+        apiSource: "cli",
+        provider: "cli",
+        cliProvider: "qoder",
+        model: "Qwen3.7-Max",
+      },
+    };
+  }
+  return null;
+}
+
 function parseLocalToolBudgets(env: EnvLike) {
   const raw = env.NOLO_LOCAL_TOOL_BUDGETS?.trim();
   if (!raw) return {};
@@ -235,12 +308,14 @@ 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;
+  const timeout = setTimeout(() => {
+    controller.abort(new Error(`request timed out after ${timeoutMs}ms`));
+  }, timeoutMs);
+  return {
+    signal: controller.signal,
+    clear: () => clearTimeout(timeout),
+  };
 }
 
 function summarizeEndpoint(value: unknown) {
@@ -353,6 +428,25 @@ function shouldExposeLocalPlatformTools(agentKey?: string) {
   return agentKey !== MIMO_MONTH_AGENT_KEY;
 }
 
+function addDefaultLightWebToolsForConfiguredAgents(
+  toolNames: string[],
+  agentConfig?: AgentRuntimeAgentConfig | null,
+) {
+  const explicitToolNames = Array.isArray((agentConfig as any)?.toolSurface?.explicitToolNames)
+    ? (agentConfig as any).toolSurface.explicitToolNames
+    : agentConfig?.toolNames;
+  if (!Array.isArray(explicitToolNames) || explicitToolNames.length === 0) return toolNames;
+  const webCapable = explicitToolNames.some((toolName) =>
+    toolName === "fetchWebpage" ||
+    toolName === "exa_search" ||
+    toolName === "read_x_post" ||
+    toolName === "read_xhs_profile" ||
+    toolName.startsWith("browser_")
+  );
+  if (!webCapable) return toolNames;
+  return [...new Set([...toolNames, ...TOOL_PACKS.LIGHT_WEB])];
+}
+
 function buildOpenAiTools(args: { agentKey?: string; toolNames?: string[]; env: EnvLike }) {
   const toolset = buildLocalWorkspaceToolsetForEnv(args);
   const exposePlatformTools = shouldExposeLocalPlatformTools(args.agentKey);
@@ -360,6 +454,14 @@ function buildOpenAiTools(args: { agentKey?: string; toolNames?: string[]; env:
     ...buildLocalWorkspaceOpenAiTools({
       toolNames: toolset.toolNames,
       exposeShellTools: toolset.exposeShellTools,
+      listFilesDescriptionVariant: resolveListFilesDescriptionVariant(args.env),
+      listFilesParameterVariant: resolveListFilesParameterVariant(args.env),
+      readFileDescriptionVariant: resolveReadFileDescriptionVariant(args.env),
+      readFileParameterVariant: resolveReadFileParameterVariant(args.env),
+      globFilesDescriptionVariant: resolveGlobFilesDescriptionVariant(args.env),
+      globFilesParameterVariant: resolveGlobFilesParameterVariant(args.env),
+      searchFilesDescriptionVariant: resolveSearchFilesDescriptionVariant(args.env),
+      searchFilesParameterVariant: resolveSearchFilesParameterVariant(args.env),
     }),
     ...(exposePlatformTools ? buildServerPlatformOpenAiTools({ toolNames: args.toolNames }) : []),
     ...(exposePlatformTools ? buildNoloWorkspaceOpenAiTools({ toolNames: args.toolNames }) : []),
@@ -367,35 +469,94 @@ function buildOpenAiTools(args: { agentKey?: string; toolNames?: string[]; env:
 }
 
 function buildLocalWorkspaceToolsetForEnv(args: { toolNames?: string[]; env: EnvLike }) {
-  void args.env;
   const toolset = buildLocalWorkspaceToolset({
     declaredToolNames: args.toolNames,
     exposeShellTools: true,
+    useDeclaredToolNamesOnly: shouldUseDeclaredOnlyLocalWorkspaceTools(args.env),
   });
   return toolset;
 }
 
 function buildLocalPolicyToolNames(args: { toolNames?: string[]; env: EnvLike }) {
-  void args.env;
   return [
     ...buildLocalWorkspacePolicyToolNames({
       declaredToolNames: args.toolNames,
       exposeShellTools: true,
+      useDeclaredToolNamesOnly: shouldUseDeclaredOnlyLocalWorkspaceTools(args.env),
     }),
-    ...((args.toolNames ?? []).includes("taskRun") ? ["taskRun"] : []),
+    ...((args.toolNames ?? []).includes("read_x_post") ? ["read_x_post"] : []),
+    ...((args.toolNames ?? []).includes("read_xhs_profile") ? ["read_xhs_profile"] : []),
+    ...(args.toolNames ?? []).filter((name) => LOCAL_SERVER_TABLE_TOOL_NAME_SET.has(name)),
     ...filterNoloWorkspaceToolNames(args.toolNames),
   ];
 }
 
+function shouldUseDeclaredOnlyLocalWorkspaceTools(env: EnvLike) {
+  const value = env.NOLO_LOCAL_WORKSPACE_TOOLSET || env.NOLO_LOCAL_TOOLSET_MODE || "";
+  return value === "declared-only" || value === "declared";
+}
+
+function resolveGlobFilesDescriptionVariant(env: EnvLike) {
+  return resolveLocalWorkspaceDescriptionVariant(env.NOLO_GLOBFILES_DESCRIPTION_VARIANT);
+}
+
+function resolveListFilesDescriptionVariant(env: EnvLike) {
+  return resolveLocalWorkspaceDescriptionVariant(env.NOLO_LISTFILES_DESCRIPTION_VARIANT);
+}
+
+function resolveListFilesParameterVariant(env: EnvLike) {
+  return resolveLocalWorkspaceParameterVariant(env.NOLO_LISTFILES_PARAMETER_VARIANT);
+}
+
+function resolveReadFileDescriptionVariant(env: EnvLike) {
+  return resolveLocalWorkspaceDescriptionVariant(env.NOLO_READFILE_DESCRIPTION_VARIANT);
+}
+
+function resolveReadFileParameterVariant(env: EnvLike) {
+  return resolveLocalWorkspaceParameterVariant(env.NOLO_READFILE_PARAMETER_VARIANT);
+}
+
+function resolveGlobFilesParameterVariant(env: EnvLike) {
+  return resolveLocalWorkspaceParameterVariant(env.NOLO_GLOBFILES_PARAMETER_VARIANT);
+}
+
+function resolveSearchFilesDescriptionVariant(env: EnvLike) {
+  return resolveLocalWorkspaceDescriptionVariant(env.NOLO_SEARCHFILES_DESCRIPTION_VARIANT);
+}
+
+function resolveSearchFilesParameterVariant(env: EnvLike) {
+  return resolveLocalWorkspaceParameterVariant(env.NOLO_SEARCHFILES_PARAMETER_VARIANT);
+}
+
+function resolveLocalWorkspaceDescriptionVariant(value: string | undefined) {
+  return value === "brief" || value === "strategy" || value === "workflow" || value === "antiShell"
+    ? value
+    : "strategy";
+}
+
+function resolveLocalWorkspaceParameterVariant(value: string | undefined) {
+  return value === "minimal" || value === "scoped" || value === "rich" ? value : "rich";
+}
+
 function buildServerPlatformOpenAiTools(args: { toolNames?: string[] }) {
   const toolNames = new Set(args.toolNames ?? []);
+  const tableTools = prepareTools(
+    (args.toolNames ?? []).filter((name) => LOCAL_SERVER_TABLE_TOOL_NAME_SET.has(name)),
+  );
   return [
-    ...(toolNames.has("taskRun")
+    ...(toolNames.has("read_xhs_profile")
       ? [{
           type: "function",
-          function: taskRunFunctionSchema,
+          function: readXhsProfileFunctionSchema,
         }]
       : []),
+    ...(toolNames.has("read_x_post")
+      ? [{
+          type: "function",
+          function: readXPostFunctionSchema,
+        }]
+      : []),
+    ...tableTools,
   ];
 }
 
@@ -467,30 +628,65 @@ function buildServerPlatformToolExecutors(args: {
   env: EnvLike;
   fetchImpl: typeof fetch;
 }) {
-  return {
-    taskRun: async (call: any) => {
-      const serverUrl = resolveRuntimeServerUrl(args.env);
-      const authToken = resolveRuntimeAuthToken(args.env);
-      if (!serverUrl) throw new Error("taskRun requires NOLO_SERVER_URL, NOLO_SERVER, or BASE_URL.");
-      if (!authToken) throw new Error("taskRun requires AUTH_TOKEN or NOLO_MACHINE_API_KEY.");
-      const response = await args.fetchImpl(`${serverUrl}/api/task-run`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${authToken}`,
-        },
-        body: JSON.stringify(parseNoloWorkspaceToolArguments(call.arguments)),
-      });
-      const text = await response.text().catch(() => "");
-      if (!response.ok) {
-        throw new Error(`taskRun bridge failed: HTTP ${response.status} ${text.slice(0, 500)}`);
-      }
-      return {
-        content: text,
-        metadata: { serverPlatformTool: true },
-      };
-    },
+  const postServer = async (path: string, body: object) => {
+    const serverUrl = resolveRuntimeServerUrl(args.env);
+    const authToken = resolveRuntimeAuthToken(args.env);
+    if (!serverUrl) throw new Error("server platform tools require NOLO_SERVER_URL, NOLO_SERVER, or BASE_URL.");
+    if (!authToken) throw new Error("server platform tools require AUTH_TOKEN or NOLO_MACHINE_API_KEY.");
+    const response = await args.fetchImpl(`${serverUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${authToken}`,
+      },
+      body: JSON.stringify(body),
+    });
+    const text = await response.text().catch(() => "");
+    if (!response.ok) {
+      throw new Error(`server platform tool bridge failed: HTTP ${response.status} ${text.slice(0, 500)}`);
+    }
+    return text;
+  };
+  const guardExplicitTableCapture = (call: any) => {
+    if (inferCaptureIntent(String(call.userInput ?? "")) === "strong") return null;
+    return JSON.stringify({
+      error: "knowledge_capture_requires_confirmation",
+      message:
+        "当前本地运行不允许自动写入表格。只有当用户在当前请求里明确要求保存、建表、写入 table 或做成数据集时，才能继续；否则请先询问用户。",
+      policy: {
+        capability: "knowledge_capture",
+        target: "table",
+        mode: "explicit-only-local",
+      },
+    });
   };
+  const tableExecutors = Object.fromEntries(
+    LOCAL_SERVER_TABLE_TOOL_NAMES.map((toolName) => [
+      toolName,
+      async (call: any) => {
+        const blocked = guardExplicitTableCapture(call);
+        if (blocked) {
+          return {
+            content: blocked,
+            metadata: { serverPlatformTool: true, tableWriteBlocked: true },
+          };
+        }
+        const parsed = parseNoloWorkspaceToolArguments(call.arguments);
+        const path =
+          toolName === "createTable" ? "/api/table/create"
+          : toolName === "addTableRow" ? "/api/table/add-row"
+          : toolName === "addTableRows" ? "/api/table/add-rows"
+          : toolName === "updateTableRow" ? "/api/table/update-row"
+          : "/api/table/update-rows";
+        const content = await postServer(path, parsed);
+        return {
+          content,
+          metadata: { serverPlatformTool: true, tableWrite: true },
+        };
+      },
+    ]),
+  );
+  return tableExecutors;
 }
 
 function buildLocalToolExecutors(args: {
@@ -498,6 +694,8 @@ function buildLocalToolExecutors(args: {
   env: EnvLike;
   fetchImpl: typeof fetch;
   localToolExecutors?: CliLocalRuntimeAdapterDeps["localToolExecutors"];
+  readXPost?: CliLocalRuntimeAdapterDeps["readXPost"];
+  readXhsProfile?: CliLocalRuntimeAdapterDeps["readXhsProfile"];
   commandTimeoutMs?: number;
   commandOutputLimit?: number;
 }) {
@@ -514,6 +712,38 @@ function buildLocalToolExecutors(args: {
     ...buildCliWorkspaceToolExecutors({
       env: args.env,
     }),
+    read_x_post: async (call: any) => {
+      const parsedArgs = (() => {
+        try { return JSON.parse(call.arguments || "{}"); } catch { return {}; }
+      })();
+      const result = await (args.readXPost ?? readXPostFunc)(
+        parsedArgs,
+        undefined,
+      );
+      return {
+        content: JSON.stringify(result.rawData),
+        metadata: {
+          xPostLocalBridge: true,
+          displayData: result.displayData,
+        },
+      };
+    },
+    read_xhs_profile: async (call: any) => {
+      const parsedArgs = (() => {
+        try { return JSON.parse(call.arguments || "{}"); } catch { return {}; }
+      })();
+      const result = await (args.readXhsProfile ?? readXhsProfileFunc)(
+        parsedArgs,
+        undefined,
+      );
+      return {
+        content: JSON.stringify(result.rawData),
+        metadata: {
+          xhsLocalBridge: true,
+          displayData: result.displayData,
+        },
+      };
+    },
     ...(args.localToolExecutors ?? {}),
   };
 }
@@ -599,6 +829,8 @@ export function createCliLocalRuntimeAdapter(
     env: deps.env,
     fetchImpl,
     localToolExecutors: deps.localToolExecutors,
+    readXPost: deps.readXPost,
+    readXhsProfile: deps.readXhsProfile,
     ...runtimeToolExecutionLimits,
   });
 
@@ -606,16 +838,22 @@ export function createCliLocalRuntimeAdapter(
     host: "cli",
     capabilities: ["leveldb-agent-config", "local-provider", "leveldb-persistence", "local-tools"],
     loadAgentConfig: async (agentRef) => {
+      const storedAgentConfig = await readAgentFromStore({
+        agentRef,
+        store: await resolveStore(deps),
+        userId,
+      });
+      const fallbackLocalCliAgentConfig =
+        storedAgentConfig ? null : resolveBuiltinLocalCliAgentConfig(agentRef, userId);
       const agentConfig = withResolvedRuntimeToolSurface(
-        await readAgentFromStore({
-          agentRef,
-          store: await resolveStore(deps),
-          userId,
-        }),
+        storedAgentConfig ?? fallbackLocalCliAgentConfig,
         deps.env
       );
       const requestedToolNames = agentConfig
-        ? resolveRequestedRuntimeToolNames({ agentConfig })
+        ? addDefaultLightWebToolsForConfiguredAgents(
+            resolveRequestedRuntimeToolNames({ agentConfig }),
+            agentConfig,
+          )
         : [];
       activeAgentToolNames = buildLocalPolicyToolNames({
         toolNames: requestedToolNames,
@@ -629,6 +867,8 @@ export function createCliLocalRuntimeAdapter(
         env: deps.env,
         fetchImpl,
         localToolExecutors: deps.localToolExecutors,
+        readXPost: deps.readXPost,
+        readXhsProfile: deps.readXhsProfile,
         ...runtimeToolExecutionLimits,
       });
       return agentConfig;
@@ -712,9 +952,10 @@ export function createCliLocalRuntimeAdapter(
         return {
           model: providerConfig.model,
           complete: async (messages, options) => {
-            const requestedToolNames = resolveRequestedRuntimeToolNames({
+            const requestedToolNames = addDefaultLightWebToolsForConfiguredAgents(
+              resolveRequestedRuntimeToolNames({ agentConfig }),
               agentConfig,
-            });
+            );
             const tools = buildOpenAiTools({
               agentKey: agentConfig.key,
               toolNames: requestedToolNames,
@@ -725,7 +966,7 @@ export function createCliLocalRuntimeAdapter(
               messages,
               tools,
             });
-            const signal = buildRequestTimeoutSignal(options?.timeoutMs);
+            const timeoutSignal = buildRequestTimeoutSignal(options?.timeoutMs);
             logLocalRuntimeDiagnostic("provider.request.start", {
               agentKey: agentConfig.key,
               transport: "platform-proxy",
@@ -740,11 +981,11 @@ export function createCliLocalRuntimeAdapter(
             });
             const res = await fetchWithTransientRetry(fetchImpl, request.url, {
               ...request.init,
-              ...(signal ? { signal } : {}),
+              ...(timeoutSignal ? { signal: timeoutSignal.signal } : {}),
             }, {
               sleep: deps.sleep,
               loopbackRequest,
-            });
+            }).finally(() => timeoutSignal?.clear());
             const raw = await res.text().catch(() => "");
             logLocalRuntimeDiagnostic("provider.request.result", {
               agentKey: agentConfig.key,
@@ -785,9 +1026,10 @@ export function createCliLocalRuntimeAdapter(
       return {
         model: providerConfig.model,
         complete: async (messages, options) => {
-          const requestedToolNames = resolveRequestedRuntimeToolNames({
+          const requestedToolNames = addDefaultLightWebToolsForConfiguredAgents(
+            resolveRequestedRuntimeToolNames({ agentConfig }),
             agentConfig,
-          });
+          );
           const tools = buildOpenAiTools({
             agentKey: agentConfig.key,
             toolNames: requestedToolNames,
@@ -798,7 +1040,7 @@ export function createCliLocalRuntimeAdapter(
             messages,
             tools,
           });
-          const signal = buildRequestTimeoutSignal(options?.timeoutMs);
+          const timeoutSignal = buildRequestTimeoutSignal(options?.timeoutMs);
           logLocalRuntimeDiagnostic("provider.request.start", {
             agentKey: agentConfig.key,
             transport: "direct-openai-compatible",
@@ -812,11 +1054,11 @@ export function createCliLocalRuntimeAdapter(
           });
           const res = await fetchWithTransientRetry(fetchImpl, request.url, {
             ...request.init,
-            ...(signal ? { signal } : {}),
+            ...(timeoutSignal ? { signal: timeoutSignal.signal } : {}),
           }, {
             sleep: deps.sleep,
             loopbackRequest,
-          });
+          }).finally(() => timeoutSignal?.clear());
           const raw = await res.text().catch(() => "");
           logLocalRuntimeDiagnostic("provider.request.result", {
             agentKey: agentConfig.key,

package/commandRegistry.ts

@@ -14,6 +14,7 @@ export const COMMANDS: CommandEntry[] = [
 ];
 
 export const GROUP_ORDER = [
+  "run",
   "chat",
   "doc",
   "skill-doc",
@@ -21,9 +22,9 @@ export const GROUP_ORDER = [
   "agent",
   "doctor",
   "dialog",
+  "memory",
   "space",
   "table",
-  "task-run",
   "llama",
   "model-runtime",
   "dev",
@@ -55,23 +56,25 @@ export function renderHelpText() {
     "  nolo doctor",
     "  nolo doctor runtime",
     "  nolo update",
+    '  nolo run "review this repository"  # no Nolo login required; uses local Codex CLI',
     '  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",
-    "  nolo agent read agent-pub-01APPBUILDER00000001YAII3I",
-    '  nolo agent run frontend-implementer --msg "polish notifications"',
+  "  nolo agent read agent-pub-01APPBUILDER00000001YAII3I",
+    "  nolo agent usage qoder",
+  '  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-current agent-user-1-agent-1 --msg "ping"',
     '  nolo chat --agent agent-pub-01APPBUILDER00000001YAII3I --msg "你好"',
+    "  nolo memory delete --source-dialog 01ABC... --yes --json",
     "  nolo space read 01KKY77TT0DA9NY7TNW3R7255N --content-key page-user-id --brief",
     "  nolo space delete --name-prefix rn_owner_verify_0504 --yes",
     "  nolo table query --table 01ABCXYZ",
     '  nolo table query --table meta-0e95801d90-NOLOTASKBOARD --columns \'["title","status","owner","priority","codeStatus"]\' --no-base-fields --output items',
     '  nolo table update-row --table meta-0e95801d90-NOLOTASKBOARD --row 01ROWID --changes \'{"status":"已完成"}\'',
-    "  nolo task-run read-context --row-dbkey row-user-table-row",
     "  nolo llama status",
   ];
 

package/connector-experimental/capabilities.ts

@@ -17,19 +17,20 @@ type CommandProbe = {
   args: string[];
 };
 
-const COMMAND_CAPABILITIES: Array<[probes: CommandProbe[], capability: string]> = [
-  [[{ command: "codex", args: ["--version"] }], "codex-cli"],
-  [[{ command: "claude", args: ["--version"] }], "claude-code"],
+const COMMAND_CAPABILITIES: Array<[probes: CommandProbe[], capabilities: string[]]> = [
+  [[{ command: "codex", args: ["--version"] }], ["codex-cli"]],
+  [[{ command: "claude", args: ["--version"] }], ["claude-code"]],
   [
     [
       { command: "gh", args: ["--version"] },
       { command: "gh", args: ["copilot", "--", "--help"] },
     ],
-    "copilot-cli",
+    ["copilot-cli"],
   ],
-  [[{ command: "gemini", args: ["--version"] }], "gemini-cli"],
-  [[{ command: "kimi", args: ["--version"] }], "kimi-cli"],
-  [[{ command: "agy", args: ["--help"] }], "agy-cli"],
+  [[{ command: "gemini", args: ["--version"] }], ["gemini-cli"]],
+  [[{ command: "kimi", args: ["--version"] }], ["kimi-cli"]],
+  [[{ command: "agy", args: ["--help"] }], ["agy-cli"]],
+  [[{ command: "qoder", args: ["--version"] }], ["qoder-cli", "qoder-usage"]],
 ];
 
 function defaultCommandExists(command: string) {
@@ -58,12 +59,12 @@ export function detectRuntimeCapabilities(
   const env = options.env ?? process.env;
   const capabilities: string[] = [];
 
-  for (const [probes, capability] of COMMAND_CAPABILITIES) {
+  for (const [probes, detectedCapabilities] of COMMAND_CAPABILITIES) {
     if (!probes.every((probe) => commandExists(probe.command))) continue;
     if (options.probeLaunchable && !probes.every((probe) => commandLaunchable(probe.command, probe.args))) {
       continue;
     }
-    capabilities.push(capability);
+    capabilities.push(...detectedCapabilities);
   }
 
   if (env.NOLO_LOCAL_LLM_ENDPOINT || env.LLAMA_SERVER_URL) {