@dench.com/cli 0.4.4 → 0.4.6

package/agent.ts

@@ -1,473 +1,37 @@
-/**
- * `dench agent <subcommand>` — CLI surface for the subagent + peer
- * messaging system.
- *
- * Used inside sandboxes (where DENCH_API_KEY + DENCH_INTERNAL_BASE +
- * DENCH_INTERNAL_TOKEN are already present in env) to:
- *   - spawn parallel subagents
- *   - await their completion
- *   - send / wait on peer messages
- *   - pause / resume / continue runs
- *   - list run trees
- *
- * Routes hit:
- *   POST /api/runs/spawn-child     (internal token)
- *   POST /api/runs/notify-parent   (internal token)
- *   POST /api/runs/send-message    (internal token)
- *   POST /api/runs/continue        (Bearer Dench API key)
- *   POST /api/runs                 (existing legacy route — kept for
- *                                   compatibility; new runs prefer /start)
- *   POST /api/runs/start           (Bearer Dench API key, the new flow)
- */
 import type { ConvexHttpClient } from "convex/browser";
-import { makeFunctionReference } from "convex/server";
-import {
-  CliArgError,
-  getFlag,
-  hasFlag,
-  shift as shiftRaw,
-} from "./lib/cli-args";
 
 class AgentCliError extends Error {}
 
-type CliCtx = {
-  convex: ConvexHttpClient;
-  args: string[];
-  jsonOutput: boolean;
-  /**
-   * Bearer token forwarded by the dispatcher in `cli/dench.ts`. Either a
-   * `dch_agent_*` agent session minted by `dench login` or a unified
-   * Dench API key (`DENCH_API_KEY`) when the CLI is running inside a
-   * sandbox. Used by `runAwait` to authenticate against
-   * `runs:getChildRunStatusForCli`.
-   */
-  sessionToken?: string;
-  /**
-   * Convex `runs._id` of the caller's own run, when authenticated via
-   * an API key (sandbox path). Required by `getChildRunStatusForCli`
-   * to scope the API key's reach to a specific organization.
-   */
-  callerRunId?: string;
-};
-
-// Args helpers moved to cli/lib/cli-args.ts; we adapt shift to throw
-// AgentCliError so existing catch blocks don't need updating.
-function shift(args: string[], expected: string): string {
-  try {
-    return shiftRaw(args, expected);
-  } catch (error) {
-    if (error instanceof CliArgError) throw new AgentCliError(error.message);
-    throw error;
-  }
-}
-
-function out(ctx: CliCtx, value: unknown): void {
-  if (ctx.jsonOutput) {
-    console.log(JSON.stringify(value, null, 2));
-    return;
-  }
-  if (value === null || value === undefined) {
-    console.log("(empty)");
-    return;
-  }
-  console.log(JSON.stringify(value, null, 2));
-}
-
-function getInternalBase(): string {
-  const base = (
-    process.env.DENCH_INTERNAL_BASE ??
-    process.env.DENCH_API_URL ??
-    ""
-  ).replace(/\/+$/, "");
-  if (!base) {
-    throw new AgentCliError(
-      "DENCH_INTERNAL_BASE (or DENCH_API_URL) is not configured in this sandbox",
-    );
-  }
-  return base;
-}
-
-function getApiBase(): string {
-  const base = (process.env.DENCH_API_URL ?? "").replace(/\/+$/, "");
-  if (!base) {
-    throw new AgentCliError("DENCH_API_URL is not configured in this sandbox");
-  }
-  return base;
-}
+function agentHelp(): void {
+  console.log(`Usage: dench agent <subcommand>
 
-function internalHeaders(): Record<string, string> {
-  const token = process.env.DENCH_INTERNAL_TOKEN?.trim();
-  if (!token) {
-    throw new AgentCliError(
-      "DENCH_INTERNAL_TOKEN is not configured in this sandbox",
-    );
-  }
-  return {
-    "content-type": "application/json",
-    "x-dench-internal-token": token,
-  };
-}
+Agent sessions are normal chat-turn workflows, the same path used by the web UI:
+  dench agent new "<prompt>" [--model <m>] [--file-context <path>] [--visibility private|shared] [--title T] [--yolo] [--follow] [--json]
+  dench agent send <thread-id> "<message>" [--model <m>] [--yolo] [--follow] [--json]
+  dench agent follow <thread-id> [--json]
 
-function apiKeyHeaders(): Record<string, string> {
-  const key = process.env.DENCH_API_KEY?.trim();
-  if (!key) {
-    throw new AgentCliError(
-      "DENCH_API_KEY is not configured in this sandbox",
-    );
-  }
-  return {
-    "content-type": "application/json",
-    authorization: `Bearer ${key}`,
-  };
-}
+These are aliases for:
+  dench chat new
+  dench chat send
+  dench chat follow
 
-async function postJson(
-  url: string,
-  headers: Record<string, string>,
-  body: unknown,
-): Promise<unknown> {
-  const response = await fetch(url, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body ?? {}),
-  });
-  const text = await response.text();
-  let json: unknown;
-  try {
-    json = text ? JSON.parse(text) : null;
-  } catch {
-    json = { raw: text };
-  }
-  if (!response.ok) {
-    throw new AgentCliError(
-      `${url} failed with ${response.status}: ${
-        typeof json === "object" ? JSON.stringify(json) : String(json)
-      }`,
-    );
-  }
-  return json;
+Use spawn_agent from inside a running chat to create child agents. Child agents
+are also normal chat threads and can be followed with dench agent follow.
+`);
 }
 
-export async function runAgentCommand(opts: {
+export async function runAgentCommand(_opts: {
   convex: ConvexHttpClient;
   args: string[];
   sessionToken?: string;
   callerRunId?: string;
 }): Promise<void> {
-  const args = [...opts.args];
-  const jsonOutput = hasFlag(args, "--json");
-  const ctx: CliCtx = {
-    convex: opts.convex,
-    args,
-    jsonOutput,
-    sessionToken: opts.sessionToken,
-    callerRunId: opts.callerRunId,
-  };
-  const subcommand = args.shift();
+  const subcommand = _opts.args[0];
   if (!subcommand || subcommand === "help" || subcommand === "--help") {
     agentHelp();
     return;
   }
-  switch (subcommand) {
-    case "spawn":
-      return await runSpawn(ctx);
-    case "await":
-      return await runAwait(ctx);
-    case "message":
-      return await runMessage(ctx);
-    case "wait-message":
-      return await runWaitMessage(ctx);
-    case "pause":
-      return await runPause(ctx);
-    case "resume":
-      return await runResume(ctx);
-    case "continue":
-      return await runContinue(ctx);
-    case "tree":
-      return await runTree(ctx);
-    default:
-      throw new AgentCliError(
-        `Unknown agent subcommand: ${subcommand}. Run 'dench agent help'.`,
-      );
-  }
-}
-
-async function runPause(ctx: CliCtx): Promise<void> {
-  const runId = shift(ctx.args, "run id");
-  const result = await postJson(
-    `${getApiBase()}/api/runs/pause`,
-    apiKeyHeaders(),
-    { runId },
-  );
-  out(ctx, result);
-}
-
-async function runResume(ctx: CliCtx): Promise<void> {
-  const runId = shift(ctx.args, "run id");
-  const prompt = ctx.args.length > 0 ? ctx.args.join(" ").trim() : undefined;
-  const result = await postJson(
-    `${getApiBase()}/api/runs/resume`,
-    apiKeyHeaders(),
-    { runId, prompt },
-  );
-  out(ctx, result);
-}
-
-async function runSpawn(ctx: CliCtx): Promise<void> {
-  const goal = ctx.args.filter((arg) => !arg.startsWith("--")).join(" ").trim();
-  if (!goal) throw new AgentCliError("Goal required: dench agent spawn '...'");
-  const parentRunId =
-    getFlag(ctx.args, "--parent-run-id") ?? process.env.DENCH_RUN_ID;
-  if (!parentRunId) {
-    throw new AgentCliError(
-      "--parent-run-id required (or set DENCH_RUN_ID inside a sandbox)",
-    );
-  }
-  const sandboxStrategy = getFlag(ctx.args, "--sandbox") as
-    | "own"
-    | "share_parent"
-    | undefined;
-  const timeBudgetMs = parseInt(
-    getFlag(ctx.args, "--time-budget-ms") ?? "0",
-    10,
-  );
-
-  // Step 1: createChildRun via Convex (mutation requires admin auth, so we
-  // hop through the spawn-child route which has CONVEX_DEPLOY_KEY).
-  // For the v1 plan, we ship a single internal-route hop: the route owns
-  // the createChildRun + setRunLinkAwaitToken + start() sequence.
-  const result = await postJson(
-    `${getInternalBase()}/api/runs/spawn-child`,
-    internalHeaders(),
-    {
-      // The route currently expects a pre-created childRunId. To support
-      // the CLI flow we'll pass the raw goal and let the route create
-      // the child row + start the workflow. (Route extension lands in
-      // the next commit.)
-      parentRunId,
-      goal,
-      sandboxStrategy,
-      timeBudgetMs: timeBudgetMs > 0 ? timeBudgetMs : undefined,
-    },
+  throw new AgentCliError(
+    `Unknown agent subcommand: ${subcommand}. Use dench agent new, send, or follow.`,
   );
-  out(ctx, result);
-}
-
-async function runAwait(ctx: CliCtx): Promise<void> {
-  const hookToken = getFlag(ctx.args, "--hook");
-  if (hookToken) {
-    out(ctx, { hookToken, status: "registered" });
-    return;
-  }
-  const childIdsCsv = getFlag(ctx.args, "--children");
-  if (!childIdsCsv) {
-    throw new AgentCliError(
-      "dench agent await requires --hook <token> or --children <csv>",
-    );
-  }
-  if (!ctx.sessionToken) {
-    throw new AgentCliError(
-      "dench agent await --children needs an authenticated session " +
-        "(run `dench login`, or set DENCH_API_KEY in a sandbox)",
-    );
-  }
-
-  const childIds = childIdsCsv
-    .split(",")
-    .map((id) => id.trim())
-    .filter(Boolean);
-  if (childIds.length === 0) {
-    throw new AgentCliError("--children requires at least one run id");
-  }
-  const start = Date.now();
-  const timeoutMs = parseInt(
-    getFlag(ctx.args, "--timeout-ms") ?? "3600000",
-    10,
-  );
-  const intervalMs = parseInt(
-    getFlag(ctx.args, "--interval-ms") ?? "2000",
-    10,
-  );
-
-  type ChildSnapshot = {
-    runId: string;
-    status: string;
-    summary: string | null;
-    threadId: string | null;
-    terminal: boolean;
-  };
-  const getStatus = makeFunctionReference<"query">(
-    "functions/runs:getChildRunStatusForCli",
-  );
-
-  // Poll each child's status until it reaches a terminal state. The
-  // server uses sessionToken auth (mirrors `dench chat list`) so this
-  // works both for `dch_agent_*` sessions (local dev) and for unified
-  // `DENCH_API_KEY`s (sandbox, must include `--caller-run-id`).
-  const completed: Record<string, ChildSnapshot> = {};
-  while (Object.keys(completed).length < childIds.length) {
-    if (Date.now() - start > timeoutMs) {
-      throw new AgentCliError(
-        `dench agent await timed out after ${timeoutMs}ms with ${
-          Object.keys(completed).length
-        }/${childIds.length} children completed`,
-      );
-    }
-    for (const childId of childIds) {
-      if (completed[childId]) continue;
-      try {
-        const snap = (await ctx.convex.query(getStatus, {
-          sessionToken: ctx.sessionToken,
-          runId: ctx.callerRunId ?? undefined,
-          childRunId: childId as never,
-        })) as ChildSnapshot | null;
-        if (snap?.terminal) {
-          completed[childId] = snap;
-        }
-      } catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        // Treat "not found" / access errors as terminal-with-error so
-        // we don't poll forever on a typo'd id.
-        completed[childId] = {
-          runId: childId,
-          status: "error",
-          summary: msg,
-          threadId: null,
-          terminal: true,
-        };
-      }
-    }
-    if (Object.keys(completed).length < childIds.length) {
-      await new Promise((resolve) => setTimeout(resolve, intervalMs));
-    }
-  }
-  out(ctx, { children: completed });
-}
-
-async function runMessage(ctx: CliCtx): Promise<void> {
-  const toRunId = shift(ctx.args, "target run id");
-  const fromRunId =
-    getFlag(ctx.args, "--from-run-id") ?? process.env.DENCH_RUN_ID;
-  if (!fromRunId) {
-    throw new AgentCliError(
-      "--from-run-id required (or set DENCH_RUN_ID inside a sandbox)",
-    );
-  }
-  const text = ctx.args.join(" ").trim();
-  if (!text) {
-    throw new AgentCliError(
-      "Message body required: dench agent message <toRunId> 'text...'",
-    );
-  }
-  const result = await postJson(
-    `${getInternalBase()}/api/runs/send-message`,
-    internalHeaders(),
-    { fromRunId, toRunId, payload: { text } },
-  );
-  out(ctx, result);
-}
-
-async function runWaitMessage(ctx: CliCtx): Promise<void> {
-  // v1 stub: print a message + exit. The real implementation lives in
-  // the agent loop's `wait_for_message` tool, which calls the workflow
-  // step that registers an await-message hook and durably sleeps.
-  out(ctx, {
-    note:
-      "wait-message is intended to be called by the agent loop, not from a one-shot CLI. Use the agent's wait_for_message tool inside a Long Session.",
-  });
-}
-
-async function runContinue(ctx: CliCtx): Promise<void> {
-  const prevRunId = shift(ctx.args, "previous run id");
-  const prompt = ctx.args.join(" ").trim();
-  if (!prompt) {
-    throw new AgentCliError(
-      "Continuation prompt required: dench agent continue <prevRunId> '...'",
-    );
-  }
-  const result = await postJson(
-    `${getApiBase()}/api/runs/continue`,
-    apiKeyHeaders(),
-    { prevRunId, prompt },
-  );
-  out(ctx, result);
-}
-
-async function runTree(ctx: CliCtx): Promise<void> {
-  const rootRunId =
-    ctx.args[0] ??
-    process.env.DENCH_ROOT_RUN_ID ??
-    process.env.DENCH_RUN_ID;
-  if (!rootRunId) {
-    throw new AgentCliError(
-      "dench agent tree <rootRunId> (or set DENCH_ROOT_RUN_ID inside a sandbox)",
-    );
-  }
-  const getRunTree = makeFunctionReference<"query">(
-    "functions/runs:getRunTree",
-  );
-  const flat = (await ctx.convex.query(getRunTree, {
-    rootRunId: rootRunId as never,
-  })) as Array<{
-    _id: string;
-    parentRunId?: string;
-    goal: string;
-    status: string;
-  }>;
-  if (ctx.jsonOutput) {
-    out(ctx, flat);
-    return;
-  }
-  // Tree-pretty-print, depth-first.
-  const byParent = new Map<string | null, typeof flat>();
-  for (const node of flat) {
-    const key = node.parentRunId ?? null;
-    const list = byParent.get(key) ?? [];
-    list.push(node);
-    byParent.set(key, list);
-  }
-  function print(node: (typeof flat)[number], depth: number): void {
-    const indent = "  ".repeat(depth);
-    const goalLine = node.goal.split("\n")[0].slice(0, 60);
-    process.stdout.write(
-      `${indent}- [${node.status}] ${node._id} ${goalLine}\n`,
-    );
-    for (const child of byParent.get(node._id) ?? []) print(child, depth + 1);
-  }
-  for (const root of byParent.get(null) ?? []) print(root, 0);
-}
-
-function agentHelp(): void {
-  console.log(`Usage: dench agent <subcommand>
-
-Spawn a chat-turn workflow (same as the web UI's chat panel):
-  dench agent new "<prompt>" [--model <m>] [--file-context <path>] [--visibility private|shared] [--title T] [--yolo] [--follow] [--json]
-  dench agent send <thread-id> "<message>" [--model <m>] [--yolo] [--follow] [--json]
-  dench agent follow <thread-id> [--json]
-  These are aliases for \`dench chat new\` / \`dench chat send\` / \`dench chat follow\`.
-  Use \`follow\` to tail the live stream of an existing thread (e.g.
-  a subagent spawned by \`spawn_agent\`) without sending a new message.
-
-Subagents (autonomous Long Sessions, NOT chat threads):
-  dench agent spawn '<goal>' [--parent-run-id <id>] [--sandbox own|share_parent] [--time-budget-ms N]
-  dench agent await --hook <token>
-  dench agent await --children id1,id2,id3 [--timeout-ms N] [--interval-ms N]
-                                            (polls runs:getChildRunStatusForCli
-                                             with the active session token until
-                                             every child is terminal)
-
-Peer messaging:
-  dench agent message <toRunId> '<text...>' [--from-run-id <id>]
-  dench agent wait-message            (intended for use inside the agent loop)
-
-Lifecycle:
-  dench agent pause <runId>
-  dench agent resume <runId> ['optional prompt to inject on resume']
-  dench agent continue <prevRunId> '<prompt>'   (creates a new run from a completed one)
-  dench agent tree                    (see <RunTreeView> in dench.com UI)
-
-Global flags:
-  --json    Emit raw JSON instead of pretty-printed text.
-  --follow  After spawning a chat (new/send), stream the response to stdout.
-`);
 }

package/crm.ts

@@ -1082,56 +1082,9 @@ async function runActionsCommand(ctx: CrmCliContext): Promise<void> {
       return;
     }
     case "run": {
-      // Two-step happy path: insert crmActionRuns row → POST run-action
-      // route which creates the workflow run + starts agentRunWorkflow.
-      const actionId = shift(ctx.args, "action id");
-      const fieldId = getFlag(ctx.args, "--field-id");
-      const entryId = getFlag(ctx.args, "--entry-id");
-      const goal = getFlag(ctx.args, "--goal") ?? "";
-      const wait = hasFlag(ctx.args, "--wait");
-      assertNoUnknownFlags(ctx.args, "crm actions run");
-      if (!fieldId || !entryId) {
-        throw new CrmCliError(
-          "dench crm actions run requires --field-id and --entry-id",
-        );
-      }
-      const created = (await callMutation(ctx, api.actions.startActionRun, {
-        actionId,
-        fieldId: fieldId as any,
-        entryId: entryId as any,
-      })) as { id: string };
-      // Hop through /api/crm/run-action so the workflow actually starts.
-      const apiBase = (
-        process.env.DENCH_API_URL ?? "http://localhost:3000"
-      ).replace(/\/+$/, "");
-      const apiKey =
-        process.env.DENCH_API_KEY?.trim() ??
-        process.env.DENCH_FALLBACK_API_KEY?.trim() ??
-        "";
-      if (!apiKey) {
-        throw new CrmCliError(
-          "DENCH_API_KEY required to fire the action workflow",
-        );
-      }
-      const response = await fetch(`${apiBase}/api/crm/run-action`, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          authorization: `Bearer ${apiKey}`,
-        },
-        body: JSON.stringify({ actionRunId: created.id, goal }),
-      });
-      const json = (await response.json().catch(() => ({}))) as {
-        runId?: string;
-        error?: string;
-      };
-      if (!response.ok) {
-        throw new CrmCliError(
-          `run-action failed (${response.status}): ${json.error ?? ""}`,
-        );
-      }
-      out(ctx, { actionRunId: created.id, runId: json.runId, wait });
-      return;
+      throw new CrmCliError(
+        "dench crm actions run has been removed. Start a normal agent with `dench agent new --follow` and ask it to perform the CRM action.",
+      );
     }
     default:
       throw new CrmCliError(`Unknown crm actions verb: ${verb ?? "<none>"}`);

package/cron.ts

@@ -356,14 +356,9 @@ async function runCreate(ctx: CronCliContext): Promise<void> {
   }
   const disabled = hasFlag(ctx.args, "--disabled");
   const deleteAfterRun = hasFlag(ctx.args, "--delete-after-run");
-  const target = getFlag(ctx.args, "--target") as
-    | "chat_turn"
-    | "agent_run"
-    | undefined;
-  if (target && !["chat_turn", "agent_run"].includes(target)) {
-    throw new CronCliError(
-      `--target must be chat_turn|agent_run (got "${target}")`,
-    );
+  const target = getFlag(ctx.args, "--target") as "chat_turn" | undefined;
+  if (target && target !== "chat_turn") {
+    throw new CronCliError(`--target must be chat_turn (got "${target}")`);
   }
   const schedule = consumeScheduleFlags(ctx.args);
   if (!schedule) {
@@ -523,7 +518,7 @@ Create / update (one of --every / --cron / --at is required for create):
       [--overlap skip|queue|kill_old]     # default: skip
       [--disabled]                        # default: enabled
       [--delete-after-run]                # one-shot at-schedule; default false
-      [--target chat_turn|agent_run]      # default: chat_turn (fires a fresh chat thread)
+      [--target chat_turn]                # default: chat_turn (fires a fresh chat thread)
       [--json]
 
   dench cron update <jobId> [--name N] [--prompt P] [--description D] \\

package/dench.ts

@@ -197,16 +197,6 @@ const api = {
 };
 const CONFIG_DIR = join(homedir(), ".dench");
 const CONFIG_PATH = join(CONFIG_DIR, "config.json");
-const AUTONOMOUS_DEFAULT_API_BASE = "http://localhost:3000";
-const SAFE_LONG_SESSION_CONSTRAINTS = [
-  "do not edit files",
-  "publish",
-  "deploy",
-  "spend money",
-  "send external messages",
-  "access secrets",
-  "or change production data unless the user explicitly approves it",
-];
 const args = process.argv.slice(2);
 const json = args.includes("--json");
 const filteredArgs = args.filter((arg) => arg !== "--json");
@@ -442,8 +432,6 @@ Usage:
   dench tool connect <toolkit> [--json]
   dench tool search "create github issue" [--toolkit github] [--limit 20] [--compact] [--json]
   dench tool run <composio_tool_slug> --args '{"key":"value"}' [--account <connected_account_id>] [--approval <approvalId>] [--json]
-  dench autonomous run "Inspect this repo and summarize the relevant feature. Do not edit files, publish, deploy, spend money, send external messages, access secrets, or change production data." [--duration 1h] [--model <model>] [--api-base http://localhost:3000] [--yolo] [--json]
-
 CRM (Daytona-native rewrite):
   dench crm objects <list|get|create|update|rename|delete> ...
   dench crm fields <list|create|update|delete|reorder> <object> ...
@@ -602,26 +590,6 @@ Notes:
 `);
 }
 
-function autonomousHelp() {
-  console.log(`Dench Long Session commands
-
-Usage:
-  dench autonomous run "Inspect this repo and summarize the relevant feature. Do not edit files, publish, deploy, spend money, send external messages, access secrets, or change production data." [--duration 1h] [--model <model>] [--api-base http://localhost:3000] [--yolo] [--json]
-
-Notes:
-  Starts a Long Session through /api/runs.
-  Duration supports 30m, 1h, 3h, 5h, or until-done.
-  API base defaults to ${AUTONOMOUS_DEFAULT_API_BASE}.
-  Override with --api-base, --host, DENCH_AUTONOMOUS_API_BASE, or DENCH_HOST.
-  If needed, run dench login --host <api-base> once so the CLI can authenticate.
-  Omit --model to use the server default.
-  Approval flags: --ask-before-publishing --ask-before-spending --ask-before-external-messages --ask-before-production-changes --ask-before-secrets.
-  --yolo: skip every approval gate (overrides --ask-before-* / --approval-rules). Equivalent to the workspace's YOLO mode in /<slug>/settings -> Approvals.
-  Without any approval flags, the run inherits the workspace's Approvals policy from /<slug>/settings.
-  Safe goals should explicitly say: ${SAFE_LONG_SESSION_CONSTRAINTS.join(", ")}.
-`);
-}
-
 function contextHelp() {
   console.log(`Dench context
 
@@ -653,8 +621,8 @@ Usage:
   dench suggested-work [--json]
   dench suggested-work task <artifactId> [--json]
 
-Artifacts are durable Long Session outputs for human or agent review.
-Suggested work can be converted into a workspace task.
+Artifacts are durable outputs for human or agent review. Suggested work can
+be converted into a workspace task.
 `);
 }
 
@@ -667,8 +635,8 @@ Usage:
   dench what-can-i-do [--kind <kind>] [--name "AI Agent - Project"] [--no-open] [--json]
 
 Logs in if needed, then shows what this agent can do here: workspace rules,
-open work, suggested work, Long Session options, connected-tool commands,
-memory, approvals, and next actions.
+open work, suggested work, connected-tool commands, memory, approvals, and
+next actions.
 `);
 }
 
@@ -1395,176 +1363,6 @@ function normalizeApiBase(input: string) {
   return new URL(withProtocol).origin;
 }
 
-function resolveAutonomousApiBase() {
-  const explicit =
-    option("--api-base") ??
-    option("--host") ??
-    process.env.DENCH_AUTONOMOUS_API_BASE ??
-    process.env.DENCH_HOST;
-  return explicit ? normalizeApiBase(explicit) : AUTONOMOUS_DEFAULT_API_BASE;
-}
-
-async function resolveAutonomousSessionToken(apiBase: string) {
-  const config = await loadConfig();
-  const scope = resolveSessionScope({ args: filteredArgs });
-  const stored = await getStoredSession(apiBase, scope);
-  if (stored.status === "found") {
-    return stored.session.sessionToken;
-  }
-  if (stored.status === "ambiguous") {
-    throw new Error(ambiguousSessionMessage(config, scope, apiBase));
-  }
-  return undefined;
-}
-
-function formatAutonomousRunResult(value: unknown) {
-  const record = asRecord(value);
-  if (!record) {
-    return typeof value === "string" ? value : JSON.stringify(value, null, 2);
-  }
-
-  const runId = stringField(record, "runId", "id");
-  const workflowRunId = stringField(record, "workflowRunId");
-  const status = stringField(record, "status");
-  const url = stringField(record, "url", "runUrl");
-
-  if (!runId && !workflowRunId && !status && !url) {
-    return JSON.stringify(value, null, 2);
-  }
-
-  const lines = ["Started Long Session"];
-  if (runId) lines.push(`Run ID: ${runId}`);
-  if (workflowRunId) lines.push(`Workflow Run ID: ${workflowRunId}`);
-  if (status) lines.push(`Status: ${status}`);
-  if (url) lines.push(`URL: ${url}`);
-  return lines.join("\n");
-}
-
-function autonomousRunUrl(apiBase: string, runId: string) {
-  return `${apiBase.replace(/\/+$/, "")}/labs/autonomous/${encodeURIComponent(runId)}`;
-}
-
-function withAutonomousRunUrl(payload: unknown, apiBase: string) {
-  const record = asRecord(payload);
-  const runId = stringField(record, "runId", "id");
-  if (!record || !runId || stringField(record, "runUrl", "url")) {
-    return payload;
-  }
-  return { ...record, runUrl: autonomousRunUrl(apiBase, runId) };
-}
-
-function formatAutonomousRunError(args: {
-  status: number;
-  payload: unknown;
-  apiBase: string;
-  hasSession: boolean;
-  statusText: string;
-}) {
-  const record = asRecord(args.payload);
-  const error =
-    stringField(record, "error", "message") ??
-    (typeof args.payload === "string" && args.payload.trim()
-      ? args.payload.trim()
-      : args.statusText);
-  const nextActions = stringArrayField(record, "nextActions");
-  if (args.status === 401 && !args.hasSession) {
-    nextActions.unshift(`Run: dench login --host ${args.apiBase}`);
-  } else if (args.status === 401) {
-    nextActions.push(
-      "Run dench sessions --json to inspect saved sessions.",
-      `Run dench login --host ${args.apiBase} if this session is expired.`,
-    );
-  } else if (args.status === 402 && nextActions.length === 0) {
-    nextActions.push(
-      "Top up AI credits in Dench usage/billing.",
-      "Retry the same Long Session command after credits update.",
-    );
-  }
-  if (stringField(record, "topUpUrl")) {
-    nextActions.unshift(`Top up: ${stringField(record, "topUpUrl")}`);
-  }
-  return new CliError(`Long Session failed (${args.status}): ${error}`, {
-    status: args.status,
-    code: stringField(record, "code") ?? `http_${args.status}`,
-    apiBase: args.apiBase,
-    topUpUrl: stringField(record, "topUpUrl"),
-    nextActions: [...new Set(nextActions)],
-  });
-}
-
-function safeLongSessionExample() {
-  return 'dench autonomous run "Inspect this repo and summarize the relevant feature. Do not edit files, publish, deploy, spend money, send external messages, access secrets, or change production data." --duration 30m';
-}
-
-function parseDurationMs(rawDuration?: string) {
-  const raw = rawDuration?.trim().toLowerCase();
-  if (!raw) return undefined;
-  if (["until-done", "until_done", "done", "max"].includes(raw)) {
-    return 24 * 60 * 60 * 1000;
-  }
-  const match = raw.match(
-    /^(\d+(?:\.\d+)?)(m|min|mins|minute|minutes|h|hr|hrs|hour|hours)$/,
-  );
-  if (!match) {
-    throw new CliError(
-      "--duration must look like 30m, 1h, 3h, 5h, or until-done",
-      {
-        code: "invalid_duration",
-        nextActions: [
-          "Use one of: 30m, 1h, 3h, 5h, until-done.",
-          safeLongSessionExample(),
-        ],
-      },
-    );
-  }
-  const value = Number(match[1]);
-  const unit = match[2];
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new CliError("--duration must be positive", {
-      code: "invalid_duration",
-      nextActions: ["Use a positive duration like 30m or 1h."],
-    });
-  }
-  const minutes = unit.startsWith("h") ? value * 60 : value;
-  return Math.round(minutes * 60 * 1000);
-}
-
-function durationPreset(rawDuration?: string) {
-  const raw = rawDuration?.trim().toLowerCase();
-  if (!raw) return undefined;
-  return raw.replace("-", "_");
-}
-
-function parseApprovalRules() {
-  // --yolo wins over everything else: every approval gate is off,
-  // mirroring the org-level YOLO mode (settings -> Approvals).
-  if (hasFlag("--yolo")) return [];
-  const explicit = option("--approval-rules")
-    ?.split(",")
-    .map((rule) => rule.trim())
-    .filter(Boolean);
-  if (explicit && explicit.length > 0) return explicit;
-  const rules: string[] = [];
-  if (hasFlag("--ask-before-publishing")) rules.push("publishing");
-  if (hasFlag("--ask-before-spending")) rules.push("spending");
-  if (hasFlag("--ask-before-external-messages")) {
-    rules.push("external_messages");
-  }
-  if (hasFlag("--ask-before-production-changes")) {
-    rules.push("production_changes");
-  }
-  if (hasFlag("--ask-before-secrets")) rules.push("secrets");
-  return rules.length > 0
-    ? rules
-    : [
-        "publishing",
-        "spending",
-        "external_messages",
-        "production_changes",
-        "secrets",
-      ];
-}
-
 async function parseResponseBody(response: Response) {
   const text = await response.text();
   if (!text) return {};
@@ -1575,65 +1373,6 @@ async function parseResponseBody(response: Response) {
   }
 }
 
-async function startAutonomousRun() {
-  const goal = positionalsFrom(2).join(" ").trim();
-  if (!goal) {
-    throw new CliError("Missing goal", {
-      code: "missing_goal",
-      nextActions: [
-        safeLongSessionExample(),
-        "Keep the goal specific and include safety constraints for risky actions.",
-      ],
-    });
-  }
-
-  const model = option("--model")?.trim();
-  const duration = option("--duration");
-  const body: JsonRecord = {
-    goal,
-    metadata: {
-      sessionKind: "long_session",
-      approvalRules: parseApprovalRules(),
-      safetyConstraints: SAFE_LONG_SESSION_CONSTRAINTS,
-      ...(duration ? { durationPreset: durationPreset(duration) } : {}),
-    },
-  };
-  if (model) body.model = model;
-  const timeBudgetMs = parseDurationMs(duration);
-  if (timeBudgetMs) body.timeBudgetMs = timeBudgetMs;
-
-  const apiBase = resolveAutonomousApiBase();
-  const agentSessionToken = await resolveAutonomousSessionToken(apiBase);
-  const headers: Record<string, string> = {
-    accept: "application/json",
-    "content-type": "application/json",
-  };
-  if (agentSessionToken) {
-    headers.authorization = `Bearer ${agentSessionToken}`;
-  }
-
-  const response = await fetch(`${apiBase}/api/runs`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body),
-  });
-  const payload = await parseResponseBody(response);
-
-  if (!response.ok) {
-    throw formatAutonomousRunError({
-      status: response.status,
-      payload,
-      apiBase,
-      hasSession: Boolean(agentSessionToken),
-      statusText: response.statusText,
-    });
-  }
-
-  const output = withAutonomousRunUrl(payload, apiBase);
-  throwIfCliError(output);
-  print(json ? output : formatAutonomousRunResult(output));
-}
-
 function formatUsd(cents: number | undefined) {
   const value = typeof cents === "number" && Number.isFinite(cents) ? cents : 0;
   return `$${(value / 100).toFixed(2)}`;
@@ -3198,18 +2937,6 @@ async function main() {
     return;
   }
 
-  if (command === "autonomous") {
-    if (!subcommand || subcommand === "help" || hasFlag("--help")) {
-      autonomousHelp();
-      return;
-    }
-    if (subcommand === "run") {
-      await startAutonomousRun();
-      return;
-    }
-    throw new Error(`Unknown autonomous command: ${filteredArgs.join(" ")}`);
-  }
-
   if (command === "crm") {
     const subArgs = stripRuntimeFlags(args.slice(args.indexOf("crm") + 1));
     const sub = subArgs[0];

package/fs-daemon.ts

@@ -68,6 +68,12 @@ import {
   readMountInfo,
 } from "./fs-daemon-mount";
 
+type FileTreeSyncRow = {
+  path: string;
+  contentHash?: string;
+  isDir: boolean;
+};
+
 type Args = {
   orgId?: string;
   workspace: string;
@@ -302,6 +308,9 @@ const api = {
     ),
     deleteFile: makeFunctionReference<"mutation">("functions/files:deleteFile"),
     listTree: makeFunctionReference<"query">("functions/files:listTree"),
+    listTreeSnapshot: makeFunctionReference<"query">(
+      "functions/files:listTreeSnapshot",
+    ),
     resolveApiKeyOrganization: makeFunctionReference<"query">(
       "functions/files:resolveApiKeyOrganization",
     ),
@@ -404,13 +413,11 @@ class DenchFileClient {
    * fs status` to recursively crawl the canonical tree and diff
    * against the local FS snapshot.
    */
-  async listTree(
-    prefix: string,
-  ): Promise<Array<{ path: string; contentHash?: string; isDir: boolean }>> {
+  async listTree(prefix: string): Promise<FileTreeSyncRow[]> {
     const rows = (await this.http.query(api.files.listTree, {
       prefix,
       apiKey: this.apiKey,
-    })) as Array<{ path: string; contentHash?: string; isDir: boolean }>;
+    })) as FileTreeSyncRow[];
     return Array.isArray(rows) ? rows : [];
   }
 
@@ -468,25 +475,26 @@ class DenchFileClient {
    */
   subscribeFileTree(
     convexUrl: string,
-    onChange: (
-      rows: Array<{ path: string; contentHash?: string; isDir: boolean }>,
-    ) => void,
+    onChange: (rows: FileTreeSyncRow[]) => void,
   ): () => void {
     if (!this.realtime) {
       this.realtime = new ConvexClient(convexUrl);
     }
     const unsubscribe = this.realtime.onUpdate(
-      api.files.listTree,
-      { prefix: "/", apiKey: this.apiKey },
-      (rows: unknown) => {
-        const list = Array.isArray(rows)
-          ? (rows as Array<{
-              path: string;
-              contentHash?: string;
-              isDir: boolean;
-            }>)
-          : [];
-        onChange(list);
+      api.files.listTreeSnapshot,
+      { apiKey: this.apiKey },
+      (snapshot: unknown) => {
+        // Remote writes may land deep in the tree (for example seeded
+        // `/skills/<slug>/SKILL.md` files). A root-only `listTree`
+        // subscription only sees the `/skills` directory row, so it
+        // never pulls the actual file bytes down to the volume.
+        const rows =
+          snapshot &&
+          typeof snapshot === "object" &&
+          Array.isArray((snapshot as { rows?: unknown }).rows)
+            ? (snapshot as { rows: FileTreeSyncRow[] }).rows
+            : [];
+        onChange(rows);
       },
     );
     return unsubscribe;

package/home-sync.ts

@@ -9,9 +9,11 @@
  * symlink/rename limitations while keeping future sandboxes restorable.
  */
 import { spawn } from "node:child_process";
-import { cp, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { createReadStream, createWriteStream } from "node:fs";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { pipeline } from "node:stream/promises";
 import {
   buildSnapshotName,
   buildTarCreateArgs,
@@ -61,6 +63,16 @@ function runCommand(command: string, args: string[]): Promise<void> {
   });
 }
 
+async function copyBytesOnly(
+  source: string,
+  destination: string,
+): Promise<void> {
+  await pipeline(
+    createReadStream(source),
+    createWriteStream(destination, { flags: "wx" }),
+  );
+}
+
 async function writeStatus(
   path: string,
   status: HomeSyncStatus,
@@ -178,7 +190,7 @@ class HomeSyncDaemon {
         "tar",
         buildTarCreateArgs({ liveHome: this.args.liveHome, archivePath }),
       );
-      await cp(archivePath, durablePath, { force: false });
+      await copyBytesOnly(archivePath, durablePath);
       await pruneHomeSnapshots({
         snapshotDir: this.args.snapshotDir,
         keepSnapshots: this.args.keepSnapshots,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dench.com/cli",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Dench agent workspace CLI.",
   "type": "module",
   "bin": {