@cruxy/cli 0.24.0 → 0.26.0

package/dist/agent/session.d.ts

@@ -4,6 +4,7 @@ import type { StreamRenderer } from "../render/index.js";
 import { type Router } from "../routing/index.js";
 import type { ToolContext } from "../tools/index.js";
 import type { ToolRegistry } from "../tools/index.js";
+import type { JobManager } from "../jobs/index.js";
 import { type RequestUsage, type UsageRecord } from "../usage/index.js";
 import { type AgentResult, type LifecycleHookRunner } from "./loop.js";
 /**
@@ -67,6 +68,14 @@ export interface SessionArgs {
      * persists it locally — it never transmits. Omitted → no persistence.
      */
     onRunUsage?: (record: UsageRecord) => void;
+    /**
+     * Session-scoped background jobs (C.28): the manager the `run_in_background`
+     * tool dispatches onto. Exposed on the session so the REPL can service pending
+     * job approvals between turns and drive `/jobs`/`/logs`/`/cancel`, and so
+     * `cruxy run` can cancel every live job on session exit. Present only when
+     * `jobs.enabled`; omitted → no background jobs (unchanged behaviour).
+     */
+    jobs?: JobManager;
 }
 /**
  * Estimate the token footprint of a message list with a cheap chars/4 heuristic
@@ -106,6 +115,10 @@ export declare class Session {
     /** The ambient tool capabilities (gate + sandbox + cwd/config). Exposed so a
      * shell-bound custom slash command (C.19) runs through the SAME gated path. */
     get toolContext(): ToolContext;
+    /** The background-job manager (C.28), or undefined when jobs are disabled.
+     * The REPL uses it to service paused-job approvals and drive `/jobs`; `cruxy
+     * run` uses it to cancel every live job on exit. */
+    get jobs(): JobManager | undefined;
     /** Whether plan mode is currently on. */
     getPlanMode(): boolean;
     /**

package/dist/agent/session.js

@@ -72,6 +72,12 @@ export class Session {
     get toolContext() {
         return this.args.ctx;
     }
+    /** The background-job manager (C.28), or undefined when jobs are disabled.
+     * The REPL uses it to service paused-job approvals and drive `/jobs`; `cruxy
+     * run` uses it to cancel every live job on exit. */
+    get jobs() {
+        return this.args.jobs;
+    }
     /** Whether plan mode is currently on. */
     getPlanMode() {
         return this.planMode;

package/dist/approval/prompt.d.ts

@@ -29,6 +29,12 @@ export interface PromptIO {
     readLine(): Promise<string>;
     /** Whether to emit ANSI color. */
     color: boolean;
+    /**
+     * Terminal columns (U.12). Optional so every existing PromptIO literal is
+     * unchanged; when absent the render resolves the width itself. Threaded so a
+     * narrow prompt reflows the command and never truncates the risk marker.
+     */
+    columns?: number;
 }
 /**
  * Render the action, read one key, and map it to a {@link PromptChoice}. `n`/`t`
@@ -37,6 +43,6 @@ export interface PromptIO {
  */
 export declare function promptForApproval(request: ApprovalRequest, io: PromptIO): Promise<PromptChoice>;
 /** Render the full prompt block: header, detail (diff or command+cwd), choices. */
-export declare function render(request: ApprovalRequest, color: boolean): string;
+export declare function render(request: ApprovalRequest, color: boolean, columns?: number): string;
 /** Build the real PromptIO: prompt to stderr, read keys/lines from stdin. */
 export declare function defaultPromptIO(color: boolean): PromptIO;

package/dist/approval/prompt.js

@@ -1,6 +1,8 @@
 import path from "node:path";
 import { readSingleKey } from "../components/input.js";
 import { renderActionPreview } from "../render/diff.js";
+import { resolveColumns } from "../render/capabilities.js";
+import { fitMiddle, reflow, visibleWidth } from "../render/layout.js";
 import { themeForColor } from "../theme/index.js";
 /**
  * Render the action, read one key, and map it to a {@link PromptChoice}. `n`/`t`
@@ -8,7 +10,7 @@ import { themeForColor } from "../theme/index.js";
  * is a reject.
  */
 export async function promptForApproval(request, io) {
-    io.write(render(request, io.color));
+    io.write(render(request, io.color, io.columns ?? resolveColumns()));
     const key = (await io.readKey()).toLowerCase();
     io.write("\n");
     switch (key) {
@@ -34,21 +36,41 @@ export async function promptForApproval(request, io) {
     }
 }
 /** Render the full prompt block: header, detail (diff or command+cwd), choices. */
-export function render(request, color) {
+export function render(request, color, columns = resolveColumns()) {
     const t = themeForColor(color);
     const destructive = request.tier === "destructive";
-    // Risk survives all three degradations (U.11): the mark carries it by *shape*
-    // (`!` vs `?`) for NO_COLOR, and the label carries it by *word*
-    // (`(destructive)` / `(mutate)` / `(read)`) — never by hue alone, and legible
-    // to a screen reader that would otherwise read `!` as "exclamation mark".
+    // Risk survives all FOUR degradations now (U.11 color/unicode/reader + U.12
+    // width): the mark carries it by *shape* (`!` vs `?`) for NO_COLOR, the label
+    // by *word* (`(destructive)` / `(mutate)` / `(read)`) — never by hue alone —
+    // and under narrow width the header line that holds both is emitted WHOLE,
+    // never passed through a right-truncating fit that could drop the label.
     const mark = destructive ? t.danger(t.strong("!")) : t.warning("?");
     const label = tierLabel(request.tier, t);
     const lines = [];
-    lines.push(`${mark} cruxy wants to ${t.strong(request.summary)}${label}`);
-    lines.push(detail(request, t));
+    lines.push(...header(request.summary, mark, label, t, columns));
+    lines.push(detail(request, t, columns));
     lines.push(choices(request.scope, t));
     return lines.filter((l) => l !== "").join("\n") + " ";
 }
+/**
+ * The header, width-aware (U.12). Wide: the one inline line `! cruxy wants to
+ * <summary> (destructive)`. Narrow: the risk (mark + tier label) stands on its
+ * own line — emitted whole, never truncated — and the summary reflows beneath
+ * it, so the security-relevant part is always visible while the description
+ * wraps rather than soft-wrapping into a torn line.
+ */
+function header(summary, mark, label, t, width) {
+    const inline = `${mark} cruxy wants to ${t.strong(summary)}${label}`;
+    if (visibleWidth(inline) <= width)
+        return [inline];
+    // The risk line (mark + tier word, e.g. `! (destructive)`) is short and is
+    // NEVER passed through fit(): if it overflows an absurdly narrow terminal it
+    // wraps (nothing dropped) rather than losing its tier. The action prose +
+    // summary reflow beneath it.
+    const riskLine = `${mark}${label}`;
+    const body = reflow(`cruxy wants to ${summary}`, Math.max(1, width - 2)).map((l) => `  ${t.strong(l)}`);
+    return [riskLine, ...body];
+}
 /** The worded risk tag, colored by tier — always present, so meaning never
  * rides on the `!`/`?` shape or its color alone. */
 function tierLabel(tier, t) {
@@ -62,17 +84,28 @@ function tierLabel(tier, t) {
     }
 }
 /** The action detail: a diff for file actions, the command + cwd for shell/test. */
-function detail(request, t) {
+function detail(request, t, width) {
     if (request.action.kind === "shell" || request.action.kind === "test") {
-        return [
-            `  ${t.muted("$")} ${request.action.command ?? ""}`,
-            `  ${t.muted(`in ${request.cwd}`)}`,
-        ].join("\n");
+        // The command is REFLOWED, never truncated (U.12): you always see the whole
+        // thing you are authorizing — it wraps across as many lines as it needs. The
+        // cwd (a path) middle-truncates so its leaf survives.
+        const command = request.action.command ?? "";
+        const wrapped = reflow(command, Math.max(1, width - 4));
+        const cmdLines = [
+            `  ${t.muted("$")} ${wrapped[0] ?? ""}`,
+            ...wrapped.slice(1).map((l) => `    ${l}`),
+        ];
+        const cwd = fitMiddle(request.cwd, Math.max(1, width - 5), t.glyph.ellipsis);
+        return [...cmdLines, `  ${t.muted(`in ${cwd}`)}`].join("\n");
     }
     if (request.action.kind === "mcp") {
         // The server runs UNSANDBOXED with the user's privileges — say so at the
-        // point of the call, not just at trust time.
-        return `  ${t.muted(`external MCP server "${request.action.server ?? ""}" — runs unsandboxed with your privileges`)}`;
+        // point of the call, not just at trust time. Reflowed so the whole warning
+        // survives narrow width (it must not be the part that gets clipped).
+        const note = `external MCP server "${request.action.server ?? ""}" — runs unsandboxed with your privileges`;
+        return reflow(note, Math.max(1, width - 2))
+            .map((l) => `  ${t.muted(l)}`)
+            .join("\n");
     }
     if (request.action.kind === "vcs" && request.action.root) {
         // C.26 Step 4 (⚖︎JC-4): name the acting root alongside the resolved owner/repo
@@ -80,12 +113,12 @@ function detail(request, t) {
         // PR acts in and the real API destination before approving.
         return [
             `  ${t.muted(`root ${request.action.root}`)}`,
-            renderActionPreview(request.action.preview, t),
+            renderActionPreview(request.action.preview, t, width),
         ]
             .filter((l) => l !== "")
             .join("\n");
     }
-    return renderActionPreview(request.action.preview, t);
+    return renderActionPreview(request.action.preview, t, width);
 }
 /** The choices line, including a short label of what an `a` grant would cover. */
 function choices(scope, t) {
@@ -117,6 +150,8 @@ export function defaultPromptIO(color) {
         readKey: () => readSingleKey(),
         readLine: readLineFromStdin,
         color,
+        // The prompt writes to stderr — width from stderr's own columns (U.12).
+        columns: resolveColumns(process.stderr),
     };
 }
 /** Read one line in cooked mode; "" on EOF. */

package/dist/checkpoint/gate-hook.d.ts

@@ -0,0 +1,28 @@
+import type { ApprovalDecision } from "../approval/types.js";
+import type { ApproveAction } from "../tools/types.js";
+import type { Workspace } from "../workspace/index.js";
+import type { CheckpointGate } from "./gate.js";
+/**
+ * Wrap an approval gate with the C.32 auto-checkpoint hook. Ordering is the whole
+ * point: a tool mutates only *after* `requestApproval` resolves, so snapshotting
+ * after an `allow` decision but before returning it means the checkpoint always
+ * lands before the run's first mutation — and a denied action never creates one.
+ * The same seam records which paths the run touched (file actions) or that
+ * attribution is lost (shell), for rollback's external-change detection.
+ *
+ * Lives in the checkpoint package (not the CLI wiring) so the SAME hook can be
+ * composed by the session factory, the subagent orchestrator, AND the C.28 job
+ * approval path without any of them importing the others.
+ */
+export declare function withCheckpointGate(requestApproval: (action: ApproveAction) => Promise<ApprovalDecision>, gate: CheckpointGate | undefined, ws: Workspace): (action: ApproveAction) => Promise<ApprovalDecision>;
+/**
+ * Group a file action's resolved absolute targets by the root that contains each
+ * (JC-G). write/edit carry an already-absolute `path`; patch preview paths are
+ * relative to the PRIMARY cwd (`path.relative(ctx.cwd, abs)` in apply_patch), so
+ * we reconstruct the absolute path from the primary root rather than trusting
+ * classify's `targets` — which also correctly handles a patch spanning roots.
+ */
+export declare function attributeFileTargets(action: ApproveAction, ws: Workspace): Map<string, {
+    rootAbsPath: string;
+    paths: string[];
+}>;

package/dist/checkpoint/gate-hook.js

@@ -0,0 +1,98 @@
+import path from "node:path";
+import { classify } from "../approval/classify.js";
+/**
+ * Wrap an approval gate with the C.32 auto-checkpoint hook. Ordering is the whole
+ * point: a tool mutates only *after* `requestApproval` resolves, so snapshotting
+ * after an `allow` decision but before returning it means the checkpoint always
+ * lands before the run's first mutation — and a denied action never creates one.
+ * The same seam records which paths the run touched (file actions) or that
+ * attribution is lost (shell), for rollback's external-change detection.
+ *
+ * Lives in the checkpoint package (not the CLI wiring) so the SAME hook can be
+ * composed by the session factory, the subagent orchestrator, AND the C.28 job
+ * approval path without any of them importing the others.
+ */
+export function withCheckpointGate(requestApproval, gate, ws) {
+    if (!gate)
+        return requestApproval;
+    return async (action) => {
+        const decision = await requestApproval(action);
+        if (!decision.allow)
+            return decision;
+        const request = classify(action, ws.primary().absPath);
+        if (request.tier === "read")
+            return decision;
+        if (action.kind === "shell" || action.kind === "test") {
+            // JC-β residual: non-primary shell/test are Step 5, so they are still
+            // hard-attributed to the primary root regardless of `action.root` (which
+            // those tools populate as the seam). They can mutate files we cannot
+            // attribute (scripts, snapshot writers) — record the lost attribution.
+            const root = ws.primary();
+            const svc = gate.serviceFor(root.name, root.absPath);
+            const checkpoint = await svc.ensureCheckpoint();
+            await svc.recordShellMutation();
+            if (checkpoint) {
+                await gate.recordMember(root.name, root.absPath, checkpoint.id);
+            }
+            return decision;
+        }
+        if (action.kind === "vcs") {
+            // C.26 Step 4: a PR now names its root (⚖︎#11), so the checkpoint is
+            // attributed to THAT selected root — its git commit stages/lands in that
+            // root's working tree, never the primary's. `recordShellMutation` because a
+            // `git add -A` + commit mutates the tree opaquely (no per-file attribution).
+            // Fall back to the primary only if a root name is somehow absent (defensive).
+            const root = (action.root ? ws.tryRootByName(action.root) : undefined) ??
+                ws.primary();
+            const svc = gate.serviceFor(root.name, root.absPath);
+            const checkpoint = await svc.ensureCheckpoint();
+            await svc.recordShellMutation();
+            if (checkpoint) {
+                await gate.recordMember(root.name, root.absPath, checkpoint.id);
+            }
+            return decision;
+        }
+        // File actions (write/edit/patch): attribute each RESOLVED target to its root
+        // (JC-G — post-confinement truth) and checkpoint every touched root. A patch
+        // may span roots; each root gets its own checkpoint + set member.
+        for (const [rootName, group] of attributeFileTargets(action, ws)) {
+            const svc = gate.serviceFor(rootName, group.rootAbsPath);
+            const checkpoint = await svc.ensureCheckpoint();
+            await svc.recordTouched(group.paths);
+            if (checkpoint) {
+                await gate.recordMember(rootName, group.rootAbsPath, checkpoint.id);
+            }
+        }
+        return decision;
+    };
+}
+/**
+ * Group a file action's resolved absolute targets by the root that contains each
+ * (JC-G). write/edit carry an already-absolute `path`; patch preview paths are
+ * relative to the PRIMARY cwd (`path.relative(ctx.cwd, abs)` in apply_patch), so
+ * we reconstruct the absolute path from the primary root rather than trusting
+ * classify's `targets` — which also correctly handles a patch spanning roots.
+ */
+export function attributeFileTargets(action, ws) {
+    const abs = [];
+    if (action.kind === "write" || action.kind === "edit") {
+        if (action.path)
+            abs.push(action.path);
+    }
+    else if (action.kind === "patch" && action.preview?.type === "patch") {
+        for (const file of action.preview.files) {
+            abs.push(path.resolve(ws.primary().absPath, file.path));
+        }
+    }
+    const byRoot = new Map();
+    for (const target of abs) {
+        const root = ws.rootContaining(target);
+        const group = byRoot.get(root.name) ?? {
+            rootAbsPath: root.absPath,
+            paths: [],
+        };
+        group.paths.push(target);
+        byRoot.set(root.name, group);
+    }
+    return byRoot;
+}

package/dist/checkpoint/gate.d.ts

@@ -44,8 +44,14 @@ export declare class CheckpointGate {
      * mutation begins a fresh run. The set is materialized lazily on the first member
      * (so its `createdAt` marks the run's first mutation, and a no-mutation run
      * writes no manifest).
+     *
+     * `runId` may be supplied to key the set manifest by a caller-chosen id (C.28: a
+     * background job passes its OWN id, so `cruxy rollback <jobId>` maps straight to
+     * that job's set and reverts exactly the job — pre- AND post-pause mutations,
+     * because a job calls this ONCE at start and never again on resume). Omitted → a
+     * fresh generated `run-…` id, unchanged from C.26.
      */
-    beginRun(summary: string): void;
+    beginRun(summary: string, runId?: string): void;
     /**
      * Get-or-create the per-root service. The first time a root is touched this
      * process, its service is constructed and joined to the current run; an untouched

package/dist/checkpoint/gate.js

@@ -28,10 +28,16 @@ export class CheckpointGate {
      * mutation begins a fresh run. The set is materialized lazily on the first member
      * (so its `createdAt` marks the run's first mutation, and a no-mutation run
      * writes no manifest).
+     *
+     * `runId` may be supplied to key the set manifest by a caller-chosen id (C.28: a
+     * background job passes its OWN id, so `cruxy rollback <jobId>` maps straight to
+     * that job's set and reverts exactly the job — pre- AND post-pause mutations,
+     * because a job calls this ONCE at start and never again on resume). Omitted → a
+     * fresh generated `run-…` id, unchanged from C.26.
      */
-    beginRun(summary) {
+    beginRun(summary, runId) {
         this.summary = summary;
-        this.runId = newRunId();
+        this.runId = runId ?? newRunId();
         this.set = null;
         for (const svc of this.services.values())
             svc.beginRun(summary);

package/dist/checkpoint/index.d.ts

@@ -7,3 +7,4 @@ export * from "./service.js";
 export * from "./set.js";
 export * from "./set-rollback.js";
 export * from "./gate.js";
+export * from "./gate-hook.js";

package/dist/checkpoint/index.js

@@ -7,3 +7,4 @@ export * from "./service.js";
 export * from "./set.js";
 export * from "./set-rollback.js";
 export * from "./gate.js";
+export * from "./gate-hook.js";

package/dist/cli/commands/rollback.d.ts

@@ -8,7 +8,10 @@ import { Command } from "commander";
  * PRs made during the run are not undone.
  *
  * Routing:
- *   • an explicit `<id>` → single-root rollback of that checkpoint (escape hatch);
+ *   • an explicit `<id>` that names a run/JOB set (C.28: a background job's id) →
+ *     set-based rollback of exactly that run, restoring every root it touched;
+ *   • an explicit `<id>` that is a checkpoint id → single-root rollback (escape
+ *     hatch; also the recovery route if the primary root's set index was removed);
  *   • no id, a set manifest exists → set-based rollback of the latest run;
  *   • no id, no set manifest → JC-F fallback to legacy single-root, logged.
  */

package/dist/cli/commands/rollback.js

@@ -81,9 +81,7 @@ async function legacyRollback(root, config, approval, interactive, id, t) {
  * one U.3 approval, then a sequential apply that stops on first failure
  * (`CHECKPOINT_SET_PARTIAL`, R3). Both coded errors propagate to the boundary.
  */
-async function setRollback(primaryRoot, config, approval, t) {
-    const sets = await listSets(primaryRoot); // newest first
-    const set = sets[0];
+async function setRollback(config, approval, t, set) {
     // Validate-all BEFORE any apply — a missing/corrupt member throws here.
     const members = await validateSet(set, config);
     if (setIsNoop(members)) {
@@ -116,14 +114,17 @@ async function setRollback(primaryRoot, config, approval, t) {
  * PRs made during the run are not undone.
  *
  * Routing:
- *   • an explicit `<id>` → single-root rollback of that checkpoint (escape hatch);
+ *   • an explicit `<id>` that names a run/JOB set (C.28: a background job's id) →
+ *     set-based rollback of exactly that run, restoring every root it touched;
+ *   • an explicit `<id>` that is a checkpoint id → single-root rollback (escape
+ *     hatch; also the recovery route if the primary root's set index was removed);
  *   • no id, a set manifest exists → set-based rollback of the latest run;
  *   • no id, no set manifest → JC-F fallback to legacy single-root, logged.
  */
 export function rollbackCommand() {
     return new Command("rollback")
         .description("restore the working tree to a checkpoint, undoing a run's file changes")
-        .argument("[id]", "checkpoint id (defaults to the most recent run)")
+        .argument("[id]", "run/job id or checkpoint id (defaults to the most recent run)")
         .action(async (id) => {
         const interactive = Boolean(process.stdin.isTTY);
         // Refuse before touching anything: rollback is a deliberate, interactive
@@ -138,20 +139,26 @@ export function rollbackCommand() {
             interactive,
             io: defaultPromptIO(shouldUseColor()),
         });
-        // Explicit id → single-root path (the per-member escape hatch; also the
-        // recovery route if the primary root — and its set index — was removed).
+        const sets = await listSets(primaryRoot); // newest first
         if (id !== undefined) {
+            // A job/run id first: if `<id>` names a set manifest (a background job's
+            // id IS its set's runId, C.28), roll back that whole run. Otherwise treat
+            // it as a single checkpoint id (the per-member escape hatch).
+            const jobSet = sets.find((s) => s.runId === id);
+            if (jobSet) {
+                await setRollback(config, approval, t, jobSet);
+                return;
+            }
             await legacyRollback(primaryRoot, config, approval, interactive, id, t);
             return;
         }
         // No set manifest → JC-F: fall back to legacy single-root, logged (never
         // silent). The primary root name matches single-root workspace naming.
-        const sets = await listSets(primaryRoot);
         if (sets.length === 0) {
             logger.info(`no set manifest — single-root rollback against ${path.basename(primaryRoot)}`);
             await legacyRollback(primaryRoot, config, approval, interactive, undefined, t);
             return;
         }
-        await setRollback(primaryRoot, config, approval, t);
+        await setRollback(config, approval, t, sets[0]);
     });
 }

package/dist/cli/commands/run.js

@@ -193,6 +193,14 @@ export function runCommand() {
                 await runInteractive(session, undefined, renderer, checkpoints, hookCommands);
             }
             finally {
+                // Background jobs (C.28): cancel every live job on session exit —
+                // kill-tree'ing each job's process group (no orphan) and reporting an
+                // honest "N job(s) cancelled". A paused job is cancelled too, but any
+                // checkpoint it took survives for review/rollback.
+                const cancelled = (await session.jobs?.cancelAll("session exit")) ?? 0;
+                if (cancelled > 0) {
+                    logger.print(t.muted(`${cancelled} background job${cancelled === 1 ? "" : "s"} cancelled on exit`));
+                }
                 // LSP (C.12) + MCP (C.27): gracefully shut down any external server
                 // processes spawned during the session (the shared process-exit
                 // kill-tree is the fail-safe for a hard kill).
@@ -216,6 +224,10 @@ export function runCommand() {
         }
         finally {
             renderer.close();
+            // Background jobs (C.28): a one-shot run has no between-turns servicing
+            // loop, so cancel every live job on exit (kill-tree, no orphan) rather
+            // than leave one paused forever. Checkpoints taken survive for rollback.
+            await session.jobs?.cancelAll("session exit");
             // LSP (C.12) + MCP (C.27): gracefully shut down any external server
             // processes spawned during the run (the shared process-exit kill-tree
             // is the fail-safe for a hard kill).

package/dist/cli/commands/skills.js

@@ -1,6 +1,7 @@
 import { Command } from "commander";
 import { getSkillService, resetSkillServices } from "../../skills/index.js";
 import { shouldUseColor } from "../../errors/index.js";
+import { kvStack, resolveColumns } from "../../render/index.js";
 import { themeForColor } from "../../theme/index.js";
 import { logger } from "../../utils/logger.js";
 /**
@@ -34,8 +35,15 @@ export function skillsCommand() {
             return;
         }
         logger.print(`\n${t.heading("sources")} ${t.muted("(precedence, high to low)")}`);
-        for (const { source, dir } of status.sources) {
-            logger.print(`  ${t.kv(source, t.muted(dir), 8)}`);
+        // Aligned `source  dir` columns when there's room; at narrow width the
+        // dir paths would collide with the key column, so kvStack stacks each
+        // pair instead (U.12) — the paths stay readable rather than truncating.
+        const rows = status.sources.map((s) => ({
+            key: s.source,
+            value: t.muted(s.dir),
+        }));
+        for (const line of kvStack(rows, resolveColumns(process.stdout) - 2, t)) {
+            logger.print(`  ${line}`);
         }
         logger.print("");
         if (status.errors.length === 0) {

package/dist/cli/repl.d.ts

@@ -7,7 +7,7 @@ import { type StreamRenderer } from "../render/index.js";
  * The REPL's slash commands — the autocomplete candidate set (U.7). Keep in
  * sync with the dispatch below and the HELP text.
  */
-export declare const REPL_COMMANDS: readonly ["/help", "/clear", "/compact", "/reload", "/plan", "/exit", "/quit"];
+export declare const REPL_COMMANDS: readonly ["/help", "/clear", "/compact", "/reload", "/plan", "/jobs", "/logs", "/cancel", "/exit", "/quit"];
 /** The stdin/stdout pair the REPL reads from and prompts on. Injectable for tests. */
 export interface ReplIO {
     input: Readable;