nolo-cli 0.1.23 → 0.1.26

package/client/localRuntimeAdapter.ts

@@ -34,6 +34,7 @@ import {
   type HybridRecordStore,
 } from "./hybridRecordStore";
 import { executeLocalToolWithPolicy } from "./localToolPolicy";
+import { taskRunFunctionSchema } from "../ai/tools/agent/taskRunTool";
 import { prepareTaskWorktree } from "./taskWorktree";
 import {
   activateWorkspaceSession,
@@ -144,10 +145,13 @@ async function fetchWithTransientRetry(
 
 function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
   const toolset = buildLocalWorkspaceToolsetForEnv(args);
-  return buildLocalWorkspaceOpenAiTools({
-    toolNames: toolset.toolNames,
-    exposeShellTools: toolset.exposeShellTools,
-  });
+  return [
+    ...buildLocalWorkspaceOpenAiTools({
+      toolNames: toolset.toolNames,
+      exposeShellTools: toolset.exposeShellTools,
+    }),
+    ...buildServerPlatformOpenAiTools({ toolNames: args.toolNames }),
+  ];
 }
 
 function buildLocalWorkspaceToolsetForEnv(args: { toolNames?: string[]; env: EnvLike }) {
@@ -159,18 +163,86 @@ function buildLocalWorkspaceToolsetForEnv(args: { toolNames?: string[]; env: Env
 }
 
 function buildLocalPolicyToolNames(args: { toolNames?: string[]; env: EnvLike }) {
-  return buildLocalWorkspacePolicyToolNames({
-    declaredToolNames: args.toolNames,
-    exposeShellTools: shellModeEnabled(args.env),
-  });
+  return [
+    ...buildLocalWorkspacePolicyToolNames({
+      declaredToolNames: args.toolNames,
+      exposeShellTools: shellModeEnabled(args.env),
+    }),
+    ...((args.toolNames ?? []).includes("taskRun") ? ["taskRun"] : []),
+  ];
+}
+
+function buildServerPlatformOpenAiTools(args: { toolNames?: string[] }) {
+  const toolNames = new Set(args.toolNames ?? []);
+  return [
+    ...(toolNames.has("taskRun")
+      ? [{
+          type: "function",
+          function: taskRunFunctionSchema,
+        }]
+      : []),
+  ];
+}
+
+function parseToolArguments(raw: string) {
+  try {
+    const parsed = JSON.parse(raw || "{}");
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function resolveRuntimeServerUrl(env: EnvLike) {
+  return (env.NOLO_SERVER_URL || env.NOLO_SERVER || env.BASE_URL || "").replace(/\/+$/, "");
+}
+
+function resolveRuntimeAuthToken(env: EnvLike) {
+  return env.AUTH_TOKEN || env.AUTH || env.NOLO_MACHINE_API_KEY || "";
+}
+
+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(parseToolArguments(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 },
+      };
+    },
+  };
 }
 
 function buildLocalToolExecutors(args: {
   workspaceRoot: string;
+  env: EnvLike;
+  fetchImpl: typeof fetch;
   localToolExecutors?: CliLocalRuntimeAdapterDeps["localToolExecutors"];
 }) {
   return {
     ...createLocalWorkspaceToolExecutors({ workspaceRoot: args.workspaceRoot }),
+    ...buildServerPlatformToolExecutors({
+      env: args.env,
+      fetchImpl: args.fetchImpl,
+    }),
     ...(args.localToolExecutors ?? {}),
   };
 }
@@ -262,6 +334,8 @@ export function createCliLocalRuntimeAdapter(
   );
   let localToolExecutors = buildLocalToolExecutors({
     workspaceRoot: workspaceSession.workspaceRoot,
+    env: deps.env,
+    fetchImpl,
     localToolExecutors: deps.localToolExecutors,
   });
 
@@ -279,6 +353,8 @@ export function createCliLocalRuntimeAdapter(
     if (workspaceSession.workspaceRoot === previousWorkspaceRoot) return;
     localToolExecutors = buildLocalToolExecutors({
       workspaceRoot: workspaceSession.workspaceRoot,
+      env: deps.env,
+      fetchImpl,
       localToolExecutors: deps.localToolExecutors,
     });
     deps.output?.write(formatWorkspaceSessionActivation(workspaceSession));

package/client/localRuntimeDryRun.test.ts

@@ -4,7 +4,6 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { runLocalAgentTurn } from "../agent-runtime/localLoop";
-import { buildLocalWorkspaceToolset } from "../agent-runtime/localWorkspaceTools";
 import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
 
 describe("CLI local runtime dry run", () => {
@@ -54,7 +53,11 @@ describe("CLI local runtime dry run", () => {
           completeCount += 1;
           if (completeCount === 1) {
             expect(body.tools.map((tool: any) => tool.function.name)).toEqual([
-              ...buildLocalWorkspaceToolset({}).toolNames,
+              "writeWorkspaceFile",
+              "listFiles",
+              "readFile",
+              "editFile",
+              "searchFiles",
             ]);
             return Response.json({
               model: "qwen-coder",

package/client/taskRunPrompt.ts

@@ -16,6 +16,7 @@ export function prependTaskRunPrompt(message: string, context?: TaskRunPromptCon
     ...(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.",

package/commandRegistry.ts

@@ -1,66 +1,16 @@
-export type CommandEntry = {
-  path: string[];
-  script: string;
-  description: string;
-  fixedArgs?: string[];
-};
+export type { CliPackageInfo, CliRuntimeContext, CommandEntry } from "./cliCommandTypes";
+export {
+  createCliRuntimeContext,
+  looksLikeDaemonShortcut,
+  runResolvedCommand,
+} from "./cliCommandDispatch";
+import type { CommandEntry } from "./cliCommandTypes";
+import { getInternalCommandEntries } from "./internalCommandEntries";
+import { getScriptCommandEntries } from "./scriptCommandEntries";
 
 export const COMMANDS: CommandEntry[] = [
-  { path: ["chat"], script: "", description: "Chat with an agent" },
-
-  { path: ["doc", "create"], script: "createDoc.ts", description: "Create a normal doc" },
-  { path: ["doc", "read"], script: "readDoc.ts", description: "Read a normal doc" },
-  { path: ["doc", "update"], script: "updateDoc.ts", description: "Update a normal doc" },
-  { path: ["doc", "delete"], script: "deleteDoc.ts", description: "Delete a normal doc" },
-
-  { path: ["skill-doc", "create"], script: "createSkillDoc.ts", description: "Create a skill doc" },
-  { path: ["skill-doc", "read"], script: "readSkillDoc.ts", description: "Read a skill doc" },
-  { path: ["skill-doc", "update"], script: "updateSkillDoc.ts", description: "Update a skill doc" },
-  { path: ["skill-doc", "delete"], script: "deleteSkillDoc.ts", description: "Delete a skill doc" },
-  { path: ["skill", "create-doc"], script: "createSkillDoc.ts", description: "Create a skill-backed doc" },
-
-  { path: ["dialog", "read"], script: "readDialog.ts", description: "Read a dialog" },
-  { path: ["dialog", "status"], script: "dialogStatus.ts", description: "Read compact dialog status" },
-  { path: ["space", "list"], script: "listSpaces.ts", description: "List joined spaces" },
-  { path: ["space", "read"], script: "readSpace.ts", description: "Read a space" },
-  { path: ["space", "delete"], script: "deleteSpaces.ts", description: "Delete spaces by safe filters" },
-  { path: ["space", "category"], script: "upsertSpaceCategory.ts", description: "Create or update a space category" },
-  { path: ["space", "content-category"], script: "setSpaceContentCategory.ts", description: "Move content into a space category" },
-
-  { path: ["table", "query"], script: "tableData.ts", fixedArgs: ["--action", "query"], description: "Query table rows" },
-  { path: ["table", "add-column"], script: "tableData.ts", fixedArgs: ["--action", "add-column"], description: "Add one table column" },
-  { path: ["table", "add-row"], script: "tableData.ts", fixedArgs: ["--action", "add-row"], description: "Add one table row" },
-  { path: ["table", "add-rows"], script: "tableData.ts", fixedArgs: ["--action", "add-rows"], description: "Add table rows" },
-  { path: ["table", "update-row"], script: "tableData.ts", fixedArgs: ["--action", "update-row"], description: "Update one table row" },
-  { path: ["table", "update-rows"], script: "tableData.ts", fixedArgs: ["--action", "update-rows"], description: "Update table rows" },
-  { path: ["table", "delete-row"], script: "tableData.ts", fixedArgs: ["--action", "delete-row"], description: "Delete one table row" },
-  { path: ["table", "delete-rows"], script: "tableData.ts", fixedArgs: ["--action", "delete-rows"], description: "Delete table rows" },
-  { path: ["table", "data"], script: "tableData.ts", description: "Low-level table row script bridge" },
-  { path: ["table", "meta"], script: "upsertTableMeta.ts", description: "Create or update table metadata" },
-  { path: ["task-run"], script: "", description: "Update durable task-run state through the runner bridge" },
-
-  { path: ["agent", "list"], script: "listMyAgents.ts", description: "List owned agents" },
-  { path: ["agent", "pull"], script: "", description: "Cache an agent for local runs" },
-  { path: ["agent", "read"], script: "", description: "Read a single agent" },
-  { path: ["agent", "run"], script: "", description: "Run an agent" },
-  { path: ["agent", "update"], script: "updateAgent.ts", description: "Update agent fields" },
-  { path: ["agent", "bind-current"], script: "", description: "Bind an agent to this machine" },
-  { path: ["agent", "smoke-current"], script: "", description: "Smoke test a bound agent through this machine" },
-  { path: ["agent", "runtime-doctor"], script: "", description: "Diagnose current machine runtime compatibility" },
-  { path: ["agent", "unpublish"], script: "unpublishAgent.ts", description: "Remove an agent's public record" },
-  { path: ["agent", "chat"], script: "", description: "Chat with an agent" },
-  { path: ["agent", "dialogs"], script: "queryAgentDialogs.ts", description: "Inspect recent dialogs for an agent" },
-  { path: ["agent", "doctor"], script: "doctorAgentWorkspace.ts", description: "Audit agent workspace health" },
-  { path: ["agent", "create-custom"], script: "createCustomCodingAgent.ts", description: "Create a custom coding agent" },
-  { path: ["agent", "create-space"], script: "createSpaceAgents.ts", description: "Create or attach shared-space agents" },
-  { path: ["agent", "setup-demo"], script: "setupDemoAgent.ts", description: "Bootstrap demo publisher agents" },
-  { path: ["agent", "supervise"], script: "runAutonomousAgent.ts", description: "Run an agent in autonomous cycles" },
-
-  { path: ["doctor", "runtime"], script: "", description: "Diagnose local-first agent runtime selection" },
-
-  { path: ["llama"], script: "llamaServerSupervisor.ts", description: "Manage the llama.cpp runtime" },
-  { path: ["model-runtime"], script: "localModelRuntimeSupervisor.ts", description: "Manage local model runtime processes" },
-  { path: ["dev"], script: "devControl.ts", description: "Manage the local dev environment" },
+  ...getInternalCommandEntries(renderHelpText),
+  ...getScriptCommandEntries(),
 ];
 
 export const GROUP_ORDER = [

package/connector-experimental/capabilities.ts

@@ -29,6 +29,7 @@ const COMMAND_CAPABILITIES: Array<[probes: CommandProbe[], capability: string]>
   ],
   [[{ command: "gemini", args: ["--version"] }], "gemini-cli"],
   [[{ command: "kimi", args: ["--version"] }], "kimi-cli"],
+  [[{ command: "agy", args: ["--help"] }], "agy-cli"],
 ];
 
 function defaultCommandExists(command: string) {

package/database/server/coreDataProxy.ts

@@ -9,7 +9,7 @@ const normalizeOrigin = (value: string | URL | null | undefined): string => {
   }
 };
 
-const getDbKeyForOperation = (args: {
+const getDbKeyForOperation = (args: {
   operation: string;
   pathname: string;
   req: { body?: Record<string, any> };
@@ -26,10 +26,32 @@ const getDbKeyForOperation = (args: {
       return typeof req.body?.customKey === "string" ? req.body.customKey : null;
     default:
       return null;
-  }
-};
-
-export async function maybeProxyDatabaseRequestToCore(args: {
+  }
+};
+
+export function resolveCoreDataProxyTarget(args: {
+  dbKey: string;
+  requestUrl?: string | URL | null;
+  coreBaseUrl?: string | null;
+}): string | null {
+  const coreBaseUrl = normalizeOrigin(args.coreBaseUrl);
+  if (!coreBaseUrl) {
+    return null;
+  }
+
+  const requestOrigin = normalizeOrigin(args.requestUrl);
+  if (requestOrigin && requestOrigin === coreBaseUrl) {
+    return null;
+  }
+
+  if (classifyCoreDataKey(args.dbKey).owner !== "core") {
+    return null;
+  }
+
+  return coreBaseUrl;
+}
+
+export async function maybeProxyDatabaseRequestToCore(args: {
   req: {
     method?: string;
     url?: string | URL;
@@ -40,27 +62,22 @@ export async function maybeProxyDatabaseRequestToCore(args: {
   search: string;
   coreBaseUrl?: string | null;
   fetchImpl?: typeof fetch;
-}): Promise<Response | null> {
-  const { req, pathname, search, fetchImpl = fetch } = args;
-  const coreBaseUrl = normalizeOrigin(args.coreBaseUrl);
-  if (!coreBaseUrl) {
-    return null;
-  }
-
-  const requestOrigin = normalizeOrigin(req.url);
-  if (requestOrigin && requestOrigin === coreBaseUrl) {
-    return null;
-  }
-
-  const operation = pathname.slice("/api/v1/db/".length).split("/")[0] ?? "";
-  const dbKey = getDbKeyForOperation({ operation, pathname, req });
-  if (!dbKey) {
-    return null;
-  }
-
-  if (classifyCoreDataKey(dbKey).owner !== "core") {
-    return null;
-  }
+}): Promise<Response | null> {
+  const { req, pathname, search, fetchImpl = fetch } = args;
+  const operation = pathname.slice("/api/v1/db/".length).split("/")[0] ?? "";
+  const dbKey = getDbKeyForOperation({ operation, pathname, req });
+  if (!dbKey) {
+    return null;
+  }
+
+  const coreBaseUrl = resolveCoreDataProxyTarget({
+    dbKey,
+    requestUrl: req.url,
+    coreBaseUrl: args.coreBaseUrl,
+  });
+  if (!coreBaseUrl) {
+    return null;
+  }
 
   const headers = new Headers(req.headers ?? {});
   const init: RequestInit = {

package/index.ts

@@ -1,54 +1,37 @@
 #!/usr/bin/env bun
-
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-import { renderHelpText, resolveCommand } from "./commandRegistry";
-import { runLoginCommand, runLogoutCommand, runWhoamiCommand } from "./authCommands";
+
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
 import {
-  runAgentBindCurrentCommand,
-  runAgentReadCommand,
-  runAgentRuntimeDoctorCommand,
-  runAgentSmokeCurrentCommand,
-  runDoctorRuntimeCommand,
-} from "./agentRuntimeCommands";
-import { runAgentRunCommand } from "./agentRunCommand";
-import { runAgentPullCommand } from "./agentPullCommand";
+  createCliRuntimeContext,
+  looksLikeDaemonShortcut,
+  renderHelpText,
+  resolveCommand,
+  runResolvedCommand,
+} from "./commandRegistry";
 import { buildEnvFromProfile, loadProfileConfig } from "./client/profileConfig";
 import { resolveTuiLaunchMode } from "./runtimeModeArgs";
-import {
-  runMachineConnectCommand,
-  runMachineStatusCommand,
-} from "./machineCommands";
-import { runTaskRunCommand } from "./taskRunCommand";
-import { runTableQueryCommand } from "./tableCommands";
-import { startTuiWorkspace } from "./tui/readlineWorkspace";
-import {
-  buildCliDoctorText,
-  buildCliVersionText,
-  readPackageInfo,
-  runSelfUpdate,
-} from "./updateCommands";
-import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
-
-const CLI_DIR = dirname(fileURLToPath(import.meta.url));
-const ROOT_DIR = join(CLI_DIR, "..", "..");
-const SCRIPT_DIR = join(ROOT_DIR, "scripts");
-const packageInfo = readPackageInfo();
-
-async function runScript(script: string, forwardedArgs: string[], env: NodeJS.ProcessEnv) {
-  const scriptPath = join(SCRIPT_DIR, script);
-  const proc = Bun.spawn({
-    cmd: [process.execPath, scriptPath, ...forwardedArgs],
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
-    env,
-  });
-  const exitCode = await proc.exited;
-  process.exit(exitCode);
-}
-
+import { startTuiWorkspace } from "./tui/readlineWorkspace";
+import { readPackageInfo } from "./updateCommands";
+
+const CLI_DIR = dirname(fileURLToPath(import.meta.url));
+const ROOT_DIR = join(CLI_DIR, "..", "..");
+const SCRIPT_DIR = join(ROOT_DIR, "scripts");
+const packageInfo = readPackageInfo();
+
+async function runScript(script: string, forwardedArgs: string[], env: NodeJS.ProcessEnv) {
+  const scriptPath = join(SCRIPT_DIR, script);
+  const proc = Bun.spawn({
+    cmd: [process.execPath, scriptPath, ...forwardedArgs],
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+    env,
+  });
+  return proc.exited;
+}
+
 const args = process.argv.slice(2);
 const profileEnv = buildEnvFromProfile(loadProfileConfig());
 const explicitServerUrl = process.env.NOLO_SERVER || process.env.NOLO_SERVER_URL || process.env.BASE_URL;
@@ -58,35 +41,23 @@ const runtimeEnv = {
   ...(explicitServerUrl ? { NOLO_SERVER: explicitServerUrl, BASE_URL: explicitServerUrl } : {}),
   NOLO_CLI_VERSION: packageInfo.version,
 };
-
-function readOption(args: string[], flag: string) {
-  const index = args.indexOf(flag);
-  return index >= 0 ? args[index + 1] : undefined;
-}
-
-function buildDaemonEnv(args: string[]) {
-  const serverUrl = readOption(args, "--server-url") || readOption(args, "--server");
-  const apiKey = readOption(args, "--api-key") || readOption(args, "--token");
-  return {
-    ...runtimeEnv,
-    ...(serverUrl ? { NOLO_SERVER: serverUrl } : {}),
-    ...(apiKey ? { AUTH_TOKEN: apiKey } : {}),
-  };
-}
-
-function looksLikeDaemonShortcut(args: string[]) {
-  return args.includes("--server-url") || args.includes("--api-key");
-}
-
-if (args.length === 0) {
-  if (process.stdin.isTTY) {
-    await startTuiWorkspace({ scriptDir: SCRIPT_DIR, env: runtimeEnv });
-  } else {
-    console.log(renderHelpText());
-  }
-  process.exit(0);
-}
-
+
+const runtimeContext = createCliRuntimeContext({
+  env: runtimeEnv,
+  scriptDir: SCRIPT_DIR,
+  entrypointPath: fileURLToPath(import.meta.url),
+  packageInfo,
+});
+
+if (args.length === 0) {
+  if (process.stdin.isTTY) {
+    await startTuiWorkspace({ scriptDir: SCRIPT_DIR, env: runtimeEnv });
+  } else {
+    console.log(renderHelpText());
+  }
+  process.exit(0);
+}
+
 const tuiLaunchMode = resolveTuiLaunchMode(args);
 if (tuiLaunchMode.shouldStartTui) {
   await startTuiWorkspace({
@@ -95,125 +66,17 @@ if (tuiLaunchMode.shouldStartTui) {
   });
   process.exit(0);
 }
-
-if (args[0] === "login") {
-  process.exit(await runLoginCommand(args.slice(1)));
-}
-
-if (args[0] === "whoami") {
-  process.exit(runWhoamiCommand());
-}
-
-if (args[0] === "logout") {
-  process.exit(runLogoutCommand());
-}
-
-if (args[0] === "connect") {
-  process.exit(await runMachineConnectCommand(args.slice(1), {
-    env: runtimeEnv,
-    cliEntrypointPath: fileURLToPath(import.meta.url),
-  }));
-}
-
-if (args[0] === "task-run") {
-  process.exit(await runTaskRunCommand(args.slice(1), { env: runtimeEnv }));
-}
-
-if (args[0] === "table" && args[1] === "query") {
-  process.exit(await runTableQueryCommand(args.slice(2), { env: runtimeEnv }));
-}
-
-if (args[0] === "daemon" || looksLikeDaemonShortcut(args)) {
-  const daemonArgs = args[0] === "daemon" ? args.slice(1) : args;
-  process.exit(await runMachineConnectCommand(["--ws"], {
-    env: buildDaemonEnv(daemonArgs),
-    cliEntrypointPath: fileURLToPath(import.meta.url),
-  }));
-}
-
-if (args[0] === "machine" && args[1] === "status") {
-  process.exit(await runMachineStatusCommand(args.slice(2), { env: runtimeEnv }));
-}
-
-if (args[0] === "agent" && args[1] === "bind-current") {
-  process.exit(await runAgentBindCurrentCommand(args.slice(2), { env: runtimeEnv }));
-}
-
-if (args[0] === "agent" && args[1] === "smoke-current") {
-  process.exit(await runAgentSmokeCurrentCommand(args.slice(2), { env: runtimeEnv }));
-}
-
-if (args[0] === "agent" && args[1] === "run") {
-  process.exit(await runAgentRunCommand(args.slice(2), {
-    env: runtimeEnv,
-    scriptDir: SCRIPT_DIR,
-  }));
-}
-
-if (args[0] === "agent" && args[1] === "chat") {
-  process.exit(await runAgentRunCommand(args.slice(2), {
-    env: runtimeEnv,
-    scriptDir: SCRIPT_DIR,
-  }));
-}
-
-if (args[0] === "chat") {
-  process.exit(await runAgentRunCommand(args.slice(1), {
-    env: runtimeEnv,
-    scriptDir: SCRIPT_DIR,
-  }));
-}
-
-if (args[0] === "agent" && args[1] === "pull") {
-  process.exit(await runAgentPullCommand(args.slice(2), { env: runtimeEnv }));
-}
-
-if (args[0] === "agent" && args[1] === "read") {
-  process.exit(await runAgentReadCommand(args.slice(2), { env: runtimeEnv }));
-}
-
-if (args[0] === "agent" && args[1] === "runtime-doctor") {
-  process.exit(await runAgentRuntimeDoctorCommand(args.slice(2), { env: runtimeEnv }));
-}
-
-if (args[0] === "doctor" && args[1] === "runtime") {
-  process.exit(await runDoctorRuntimeCommand(args.slice(2), { env: runtimeEnv }));
-}
 
-if (args[0] === "--version" || args[0] === "-v" || args[0] === "version") {
-  console.log(buildCliVersionText(packageInfo));
-  process.exit(0);
-}
-
-if (args[0] === "doctor") {
-  console.log(
-    buildCliDoctorText({
-      packageName: packageInfo.name,
-      version: packageInfo.version,
-      entrypoint: fileURLToPath(import.meta.url),
-      serverUrl: runtimeEnv.NOLO_SERVER || runtimeEnv.BASE_URL || DEFAULT_NOLO_SERVER_URL,
-      profileName: runtimeEnv.NOLO_PROFILE || "local",
-    })
-  );
-  process.exit(0);
-}
-
-if (args[0] === "update") {
-  process.exit(await runSelfUpdate());
-}
-
-if (args[0] === "--help" || args[0] === "-h") {
-  console.log(renderHelpText());
-  process.exit(0);
-}
-
-const command = resolveCommand(args);
+const commandArgs = looksLikeDaemonShortcut(args) ? ["daemon", ...args] : args;
+const command = resolveCommand(commandArgs);
 if (!command) {
   console.error(`Unknown command: ${args.join(" ")}`);
   console.error("");
   console.log(renderHelpText());
-  process.exit(1);
+  process.exit(1);
 }
 
-const forwardedArgs = [...(command.fixedArgs ?? []), ...args.slice(command.path.length)];
-await runScript(command.script, forwardedArgs, runtimeEnv);
+const exitCode = await runResolvedCommand(command, commandArgs, runtimeContext, {
+  runScript,
+});
+process.exit(exitCode);

package/internalCommandEntries.ts

@@ -0,0 +1,12 @@
+import { getAgentInternalCommandEntries } from "./agentInternalCommandEntries";
+import type { CommandEntry } from "./cliCommandTypes";
+import { getSystemInternalCommandEntries } from "./systemInternalCommandEntries";
+import { getWorkflowInternalCommandEntries } from "./workflowInternalCommandEntries";
+
+export function getInternalCommandEntries(renderHelpText: () => string): CommandEntry[] {
+  return [
+    ...getAgentInternalCommandEntries(),
+    ...getWorkflowInternalCommandEntries(),
+    ...getSystemInternalCommandEntries(renderHelpText),
+  ];
+}