humanish 0.104.3 → 0.106.0

package/dist/cli/commands/lab.js

@@ -0,0 +1,193 @@
+import { formatAutomaticAnalysisBudget } from "../../analysis/automatic-config.js";
+import { resolve } from "node:path";
+import { Command, Option } from "commander";
+import { inspectLabManifest, listLabManifests } from "../../lab/discover.js";
+import { runLabPreflight, } from "../../lab/preflight.js";
+import { runLabCommand } from "./lab-run.js";
+import { applyEnvFileOption, JSON_OPTION_DESCRIPTION, parsePositiveInteger, writeResult, } from "../io.js";
+export function registerLabCommands(parent, io) {
+    const lab = parent
+        .command("lab")
+        .description("List, inspect, and run humanish lab manifests.")
+        .summary("List, inspect, and run humanish lab manifests.");
+    lab
+        .command("list")
+        .description("List committed and ignored humanish lab manifests.")
+        .option("--cwd <path>", "Target project directory.", ".")
+        .option("--json", JSON_OPTION_DESCRIPTION)
+        .action((options, command) => handleLabList(io, options, command));
+    lab
+        .command("inspect")
+        .argument("<lab>", "Lab id or .yaml path.")
+        .description("Inspect a humanish lab manifest without running it.")
+        .option("--cwd <path>", "Target project directory.", ".")
+        .option("--json", JSON_OPTION_DESCRIPTION)
+        .action((labName, options, command) => handleLabInspect(io, labName, options, command));
+    lab
+        .command("preflight")
+        .argument("<lab>", "Lab id or .yaml path.")
+        .description("Check lab metadata or explicitly probe reachability. Metadata mode does not verify setup; use doctor --lab <lab> first.")
+        .option("--cwd <path>", "Target project directory.", ".")
+        .addOption(new Option("--reachability <mode>", "Reachability mode.")
+        .choices(["metadata", "public-preview", "sandbox-loopback", "prepared-host"])
+        .default("metadata"))
+        .option("--timeout-ms <ms>", "Target reachability timeout.", String(30_000))
+        .option("--env-file <path>", "Load a local env file for this preflight without persisting values.")
+        .option("--json", JSON_OPTION_DESCRIPTION)
+        .action((labName, options, command) => handleLabPreflight(io, labName, options, command));
+    lab
+        .command("run")
+        .argument("<lab>", "Lab id or .yaml path.")
+        .description("Run a humanish lab manifest. Same as `humanish run <lab>`, grouped under `lab`.")
+        .option("--env-file <path>", "Load a local env file for this lab without persisting values.")
+        .option("--dry-run", "Render contract evidence without live provider spend.")
+        .option("--open", "Open the observer in the default browser.")
+        .option("--no-open", "Render without opening a browser.")
+        .option("--detach", "Render/open once and exit without attached watch server.")
+        .option("--port <port>", "Local observer server port when following.", "0")
+        .option("--sims <count>", "Override the synthetic or headed desktop participant count.")
+        .option("--count <count>", "Computer-use only: override the headed desktop participant count.")
+        .option("--rerun-failed-from <run>", "CUA fan-out only: create a new run for failed participants from a prior run.")
+        .option("--lanes <participant-ids>", "CUA rerun only: comma-separated participant ids to rerun from the source run.")
+        .option("--run-id <id>", "Explicit lab run id; refused when that run already exists.")
+        .option("--cwd <path>", "Target project directory.", ".")
+        .option("--scorer <path>", "Terminal/computer-use/shared-world labs only: repo-relative adopter scorer module (.mjs). Overrides review.scorer.ref. Executable code: review it as code.")
+        .option("--json", JSON_OPTION_DESCRIPTION)
+        .addHelpText("after", [
+        "",
+        "Examples:",
+        "  humanish lab run first-run",
+        "  humanish lab run fanout-demo --rerun-failed-from latest --lanes lane-02,lane-04",
+        "  humanish lab run my-terminal-lab --scorer scorers/product.mjs",
+        "  humanish lab run .humanish/labs/private-dogfood.yaml --env-file .humanish/local/provider.env",
+        "",
+        "Human watch path:",
+        "  humanish watch first-run",
+        "  humanish watch --lab .humanish/labs/local.yaml",
+    ].join("\n"))
+        .action((labName, options, command) => handleLabRun(io, labName, options, command));
+}
+async function handleLabList(io, options, command) {
+    const result = await listLabManifests(options.cwd);
+    writeResult(command, io, result, formatLabListHuman);
+    io.setExitCode(0);
+}
+async function handleLabInspect(io, labName, options, command) {
+    const result = await inspectLabManifest(options.cwd, labName);
+    writeResult(command, io, result, formatLabInspectHuman);
+    io.setExitCode(result.ok ? 0 : 2);
+}
+async function handleLabPreflight(io, labName, options, command) {
+    if (!(await applyEnvFileOption({
+        command,
+        cwd: options.cwd,
+        envFile: options.envFile,
+        io,
+    }))) {
+        return;
+    }
+    const timeoutMs = parsePositiveInteger(options.timeoutMs);
+    if (timeoutMs === null) {
+        const result = {
+            schema: "humanish.lab-preflight-result.v1",
+            ok: false,
+            cwd: resolve(options.cwd),
+            lab: labName,
+            reachability: options.reachability,
+            checks: [{ name: "timeout", ok: false, message: "--timeout-ms must be a positive integer." }],
+            targets: [],
+            sandbox: { created: false },
+            spend: { e2bDesktop: false, model: false },
+            warnings: [],
+            error: {
+                code: "HUMANISH_LAB_PREFLIGHT_INVALID_OPTION",
+                message: "--timeout-ms must be a positive integer.",
+            },
+        };
+        writeResult(command, io, result, formatLabPreflightHuman);
+        io.setExitCode(2);
+        return;
+    }
+    const result = await runLabPreflight({
+        cwd: options.cwd,
+        lab: labName,
+        reachability: options.reachability,
+        timeoutMs,
+    });
+    writeResult(command, io, result, formatLabPreflightHuman);
+    io.setExitCode(result.ok ? 0 : 2);
+}
+async function handleLabRun(io, labName, options, command) {
+    if (!(await applyEnvFileOption({
+        command,
+        cwd: options.cwd,
+        envFile: options.envFile,
+        io,
+        // runLabCommand discovers keys once the lab resolves to a live run.
+        discoverKeys: false,
+    }))) {
+        return;
+    }
+    await runLabCommand({
+        command,
+        io,
+        lab: labName,
+        mode: "run",
+        options,
+    });
+}
+function formatLabListHuman(result) {
+    if (result.labs.length === 0) {
+        return ([
+            `No humanish labs found in ${result.cwd}`,
+            "Create one under humanish/labs/*.yaml, .humanish/labs/*.yaml, or pass a .yaml path.",
+            ...result.warnings.map((warning) => `warning: ${warning}`),
+        ].join("\n") + "\n");
+    }
+    return ([
+        "humanish labs",
+        ...result.labs.map((lab) => `- ${lab.id} ${lab.source} ${lab.origin} ${lab.path}${lab.title ? ` (${lab.title})` : ""}`),
+        ...result.warnings.map((warning) => `warning: ${warning}`),
+    ].join("\n") + "\n");
+}
+function formatLabInspectHuman(result) {
+    if (!result.ok || !result.config) {
+        return `${result.error?.code}: ${result.error?.message}\n`;
+    }
+    const config = result.config;
+    return ([
+        "humanish lab",
+        `id: ${config.id}`,
+        `subject: ${config.subject.source}`,
+        ...(config.execution?.target ? [`execution: ${config.execution.target}`] : []),
+        `actors: ${config.actors.map((actor) => actor.type).join(", ")}`,
+        ...(config.title ? [`title: ${config.title}`] : []),
+        ...(config.description ? [`description: ${config.description}`] : []),
+        ...(result.path ? [`path: ${result.path}`] : []),
+        ...(result.origin ? [`origin: ${result.origin}`] : []),
+        ...(config.subject.repos?.length ? [`repos: ${config.subject.repos.join(", ")}`] : []),
+        ...(result.personas ?? []).map((persona) => `persona ${persona.id}: ${persona.brief ? `authored context (before runtime additions)\n${persona.brief.text}` : "unresolved; id only"}`),
+        ...result.warnings.map((warning) => `warning: ${warning}`),
+    ].join("\n") + "\n");
+}
+function formatLabPreflightHuman(result) {
+    const checkedTargets = result.targets.filter((target) => target.checked);
+    const reachableTargets = checkedTargets.filter((target) => target.reachable === true);
+    const blockedTargets = result.targets.filter((target) => target.status === "blocked");
+    return ([
+        `humanish lab preflight ${result.ok ? "passed" : "failed"}`,
+        `lab: ${result.labId ?? result.lab}`,
+        ...(result.backend ? [`backend: ${result.backend}`] : []),
+        `reachability: ${result.reachability}`,
+        `targets: ${checkedTargets.length ? `${reachableTargets.length}/${checkedTargets.length} reachable` : `${result.targets.length} declared, not checked`}`,
+        ...(blockedTargets.length ? [`blocked-targets: ${blockedTargets.length}`] : []),
+        `spend: ${result.spend.e2bDesktop ? "one e2b desktop, no model calls" : "none"}`,
+        ...(result.analysis ? [formatAutomaticAnalysisBudget(result.analysis)] : []),
+        ...(result.sandbox.created
+            ? [`sandbox: created=yes killed=${result.sandbox.killed === true ? "yes" : "no"}`]
+            : []),
+        ...result.checks.map((check) => `- ${check.ok ? "ok" : "fail"} ${check.name}: ${check.message}`),
+        ...(result.error ? [`error: ${result.error.code}: ${result.error.message}`] : []),
+        ...result.warnings.map((warning) => `warning: ${warning}`),
+    ].join("\n") + "\n");
+}

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

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+import { type CliIo } from "../io.js";
+export declare function registerObserveCommand(parent: Command, io: CliIo): void;
+export declare function registerServeCommand(parent: Command, io: CliIo): void;

package/dist/cli/commands/observe.js

@@ -0,0 +1,345 @@
+import { Command, Option } from "commander";
+import { openTarget, renderObserver, serveObserver } from "../../observer/render.js";
+import { SERVE_SCHEMA, serveObserverLibrary } from "../../observer/serve.js";
+import { startExposedObserver, validateExposure } from "../../observer/exposure.js";
+import { ServeTunnelError } from "../../observer/tunnel.js";
+import { collectRepeated, formatRunHuman, JSON_OPTION_DESCRIPTION, parseObserverPort, wantsJson, writeResult, } from "../io.js";
+import { exitCodeForSignal, formatObserverHuman, } from "../observer-follow.js";
+export function registerObserveCommand(parent, io) {
+    parent
+        .command("observe")
+        .description("Follow a run's saved evidence in Observer over loopback http://127.0.0.1.")
+        .summary("Follow a run's saved evidence over loopback http.")
+        .option("--run <id>", "Run id or latest pointer.", "latest")
+        .option("--port <port>", "Loopback port to bind on 127.0.0.1. Defaults to an ephemeral port.", "0")
+        .option("--cwd <path>", "Target project directory.", ".")
+        .option("--open", "Open the observer in the default browser.")
+        .option("--no-open", "Serve without opening a browser.")
+        .option("--json", JSON_OPTION_DESCRIPTION)
+        .addHelpText("after", [
+        "",
+        "Examples:",
+        "  humanish observe",
+        "  humanish observe --run latest",
+        "  humanish observe --run <runId> --port 8732",
+        "  humanish observe --no-open --json",
+        "",
+        "The server binds 127.0.0.1 only and exposes just the run's bundle directory.",
+        "It stays attached until Ctrl-C; file:// security policy and live refresh are why",
+        "loopback http is preferred over opening the index.html path directly.",
+    ].join("\n"))
+        .action(async (options, command) => {
+        const port = parseObserverPort(options.port);
+        if (port === null) {
+            const result = {
+                schema: "humanish.run-result.v1",
+                ok: false,
+                cwd: options.cwd,
+                warnings: [],
+                error: {
+                    code: "HUMANISH_INVALID_PORT",
+                    message: "--port must be an integer between 0 and 65535.",
+                },
+            };
+            writeResult(command, io, result, formatRunHuman);
+            io.setExitCode(2);
+            return;
+        }
+        const rendered = await renderObserver(options.cwd, options.run, { open: false });
+        if (!rendered.ok || !rendered.observerPath) {
+            writeResult(command, io, rendered, formatObserverHuman);
+            io.setExitCode(2);
+            return;
+        }
+        // Reuse the contained current-data projection, scoped to this run. A raw static
+        // server would miss runtime status and could replay stored iframe grants.
+        const wantsMachine = wantsJson(command);
+        const shouldOpen = options.open === false
+            ? false
+            : options.open === true
+                ? true
+                : !wantsMachine && process.stdout.isTTY === true;
+        const server = await serveObserver(rendered, { open: false, port, scope: "run" });
+        const openResult = shouldOpen
+            ? openTarget(server.url)
+            : { opened: false };
+        const result = {
+            ...rendered,
+            observerUrl: server.url,
+            serverUrl: server.url,
+            opened: openResult.opened,
+            ...(openResult.command ? { openCommand: openResult.command } : {}),
+            warnings: [
+                ...rendered.warnings,
+                "Observer is served read-only over loopback http on 127.0.0.1; only this run's bundle directory is exposed.",
+                ...(openResult.warning ? [openResult.warning] : []),
+            ],
+        };
+        writeResult(command, io, result, formatObserverHuman);
+        io.setExitCode(0);
+        await serveObserveUntilSignal(io, server, { json: wantsMachine });
+    });
+}
+async function serveObserveUntilSignal(io, server, options) {
+    // Keep the JSON envelope on stdout clean: route attach/stop chatter to stderr
+    // for machine output, and to stdout for humans.
+    const note = options.json ? io.writeErr : io.writeOut;
+    note(`serving: ${server.url}\n`);
+    note("serving: press Ctrl-C to stop\n");
+    await new Promise((resolveWait) => {
+        const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+        const handlers = new Map();
+        let stopping = false;
+        const stop = (signal) => {
+            if (stopping) {
+                return;
+            }
+            stopping = true;
+            for (const [registeredSignal, handler] of handlers.entries()) {
+                process.removeListener(registeredSignal, handler);
+            }
+            io.setExitCode(exitCodeForSignal(signal));
+            void (async () => {
+                try {
+                    await server.close();
+                }
+                catch (error) {
+                    io.writeErr(`observe cleanup failed: ${error instanceof Error ? error.message : String(error)}\n`);
+                }
+                note("observe stopped\n");
+                resolveWait();
+            })();
+        };
+        for (const signal of signals) {
+            const handler = () => stop(signal);
+            handlers.set(signal, handler);
+            process.once(signal, handler);
+        }
+    });
+}
+export function registerServeCommand(parent, io) {
+    parent
+        .command("serve")
+        .description("Serve the local run library over loopback http, with optional tunnel-edge authenticated exposure.")
+        .summary("Serve the run library; optional tunnel-edge exposure.")
+        .option("--cwd <path>", "Target project directory.", ".")
+        .option("--port <port>", "Loopback port to bind on 127.0.0.1. Defaults to an ephemeral port.", "0")
+        .option("--run <id>", "Land on this run id (or latest) instead of the library index.")
+        .option("--safe", "Serve only runs whose verify shareSafety is share_ready; everything else is absent (fail-closed).")
+        .option("--expose", "Declare exposure intent. Requires edge auth (--oauth or --public-url) OR --safe.")
+        .addOption(new Option("--tunnel <provider>", "Spawn the external tunnel binary against the loopback port.").choices(["ngrok"]))
+        .option("--tunnel-domain <domain>", "Reserved domain passed to ngrok as --url (e.g. observer.example.com). Requires --tunnel.")
+        .addOption(new Option("--oauth <provider>", "Turn on ngrok edge OAuth. Requires --tunnel.").choices([
+        "google",
+    ]))
+        .option("--allow-email <addr>", "Edge OAuth allow rule: permit this email. Repeatable. Requires --oauth.", collectRepeated, [])
+        .option("--allow-domain <domain>", "Edge OAuth allow rule: permit this domain. Repeatable. Requires --oauth.", collectRepeated, [])
+        .option("--public-url <origin>", "Bring-your-own authed edge (e.g. https://observer.example.com). Requires --expose; never affects binding.")
+        .option("--open", "Open the library in the default browser.")
+        .option("--no-open", "Serve without opening a browser.")
+        .option("--json", JSON_OPTION_DESCRIPTION)
+        .addHelpText("after", [
+        "",
+        "Happy path:",
+        "  humanish serve",
+        "  humanish serve --expose --tunnel ngrok --oauth google --allow-email you@example.com",
+        "  humanish serve --safe --expose --tunnel ngrok",
+        "  humanish serve --expose --public-url https://observer.example.com",
+        "",
+        "Agent/CI path:",
+        "  humanish serve --json --no-open",
+        "",
+        "The server always binds 127.0.0.1; exposure only ever happens through an authenticated",
+        "edge (ngrok --oauth google, or an operator --public-url you secure) forwarding to the",
+        "loopback port. The server carries no in-process auth; the gate lives at the edge. Live",
+        "desktop stream URLs are never served here; remote viewers see persisted evidence only.",
+        "--safe composes with any exposure for defense in depth.",
+    ].join("\n"))
+        .action((options, command) => handleServe(io, options, command));
+}
+async function handleServe(io, options, command) {
+    const fail = (code, message) => refuseServe(command, io, options, code, message);
+    const port = parseObserverPort(options.port);
+    if (port === null) {
+        fail("HUMANISH_INVALID_PORT", "--port must be an integer between 0 and 65535.");
+        return;
+    }
+    // Fail-closed exposure matrix (shared validator; tunnel-edge auth only). All guards run before
+    // any bind/spawn.
+    const exposeValidation = validateExposure("serve", {
+        expose: options.expose === true,
+        ...(options.tunnel === undefined ? {} : { tunnel: options.tunnel }),
+        ...(options.tunnelDomain === undefined ? {} : { tunnelDomain: options.tunnelDomain }),
+        ...(options.oauth === undefined ? {} : { oauth: options.oauth }),
+        allowEmails: options.allowEmail,
+        allowDomains: options.allowDomain,
+        ...(options.publicUrl === undefined ? {} : { publicUrl: options.publicUrl }),
+        safe: options.safe === true,
+    });
+    if (!exposeValidation.ok) {
+        fail(exposeValidation.error.code, exposeValidation.error.message);
+        return;
+    }
+    const plan = exposeValidation.plan;
+    const started = await serveObserverLibrary(options.cwd, {
+        port,
+        safe: options.safe === true,
+        expose: plan.exposed,
+        edgeAuthed: plan.edgeAuthed,
+        ...(plan.publicOrigin ? { publicOrigin: plan.publicOrigin.origin } : {}),
+        ...(options.run ? { entryRunId: options.run } : {}),
+    });
+    if (!started.ok) {
+        fail(started.error.code, started.error.message);
+        return;
+    }
+    const edge = await startServeEdge(started.server, plan, fail);
+    if (edge === undefined)
+        return;
+    await reportServe(io, command, options, started.server, plan, edge);
+}
+function refuseServe(command, io, options, code, message) {
+    const result = {
+        schema: SERVE_SCHEMA,
+        ok: false,
+        cwd: options.cwd,
+        mode: "loopback",
+        safe: options.safe === true,
+        host: "127.0.0.1",
+        runsListed: 0,
+        warnings: [],
+        error: { code, message },
+    };
+    writeResult(command, io, result, formatServeHuman);
+    io.setExitCode(2);
+}
+/**
+ * Puts the planned edge in front of the loopback server. Resolves to undefined after closing the
+ * server and reporting the failure when the edge does not start.
+ */
+async function startServeEdge(server, plan, fail) {
+    if (!plan.exposed)
+        return { warnings: [] };
+    try {
+        return await startExposedObserver(server, plan);
+    }
+    catch (error) {
+        await server.close();
+        if (error instanceof ServeTunnelError) {
+            fail(error.code, error.message);
+        }
+        else {
+            fail("HUMANISH_SERVE_TUNNEL_START_FAILED", `Tunnel startup failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return undefined;
+    }
+}
+function serveExposureWarnings(server, safe, publicUrl) {
+    const warnings = [];
+    if (server.mode === "exposed" && !safe) {
+        warnings.push(`edge-authed exposure grants read access to all ${server.runsListed} local runs, including any not verified share_ready (local_only raw screenshots, blocked bundles); anyone who clears the edge auth can view them; add --safe to restrict to share_ready`);
+    }
+    if (server.mode === "exposed" && safe) {
+        warnings.push(`edge-authed exposure grants read access to ${server.shareReadyCount ?? 0} share_ready runs; non-share_ready runs are absent even behind the edge`);
+    }
+    if (server.mode === "share-safe-open") {
+        warnings.push(`serving ${server.shareReadyCount ?? 0} share_ready runs to anyone who can reach ${publicUrl ?? server.url}; non-share_ready runs are absent and their URLs 404`);
+    }
+    warnings.push("live desktop stream URLs are never served here; remote viewers see persisted evidence (screenshots, events, terminal tails) only");
+    return warnings;
+}
+/** Opens the library when asked, writes the result, and serves until a signal closes the edge. */
+async function reportServe(io, command, options, server, plan, edge) {
+    const wantsMachine = wantsJson(command);
+    const { tunnel, publicUrl } = edge;
+    const warnings = [
+        ...edge.warnings,
+        ...serveExposureWarnings(server, options.safe === true, publicUrl),
+    ];
+    // Auto-open is suppressed under --expose so the public URL is not shoved into a local opener's
+    // argv unasked — the exposure target is a remote device anyway. Explicit --open still honors
+    // intent and opens the loopback library.
+    const shouldOpen = options.open === false
+        ? false
+        : options.open === true
+            ? true
+            : !wantsMachine && process.stdout.isTTY === true && plan.exposed !== true;
+    const openResult = shouldOpen
+        ? openTarget(server.url)
+        : { opened: false };
+    if (openResult.warning) {
+        warnings.push(openResult.warning);
+    }
+    const result = {
+        schema: SERVE_SCHEMA,
+        ok: true,
+        cwd: options.cwd,
+        mode: server.mode,
+        safe: options.safe === true,
+        host: "127.0.0.1",
+        port: server.port,
+        url: server.url,
+        ...(publicUrl ? { publicUrl } : {}),
+        ...(tunnel ? { tunnel: { provider: "ngrok", url: tunnel.url } } : {}),
+        ...(plan.oauth
+            ? {
+                oauth: {
+                    provider: plan.oauth.provider,
+                    allowEmails: plan.oauth.allowEmails,
+                    allowDomains: plan.oauth.allowDomains,
+                },
+            }
+            : {}),
+        runsListed: server.runsListed,
+        ...(server.shareReadyCount !== undefined ? { shareReadyCount: server.shareReadyCount } : {}),
+        ...(server.entryRunId ? { entryRunId: server.entryRunId } : {}),
+        opened: openResult.opened,
+        ...(openResult.command ? { openCommand: openResult.command } : {}),
+        warnings,
+    };
+    writeResult(command, io, result, formatServeHuman);
+    io.setExitCode(0);
+    await serveObserveUntilSignal(io, {
+        url: server.url,
+        close: async () => {
+            if (tunnel) {
+                await tunnel.close();
+            }
+            await server.close();
+        },
+    }, { json: wantsMachine });
+}
+function formatServeHuman(result) {
+    if (!result.ok) {
+        return ([
+            "humanish serve failed",
+            ...(result.error ? [`error: ${result.error.code} ${result.error.message}`] : []),
+            ...result.warnings.map((warning) => `warning: ${warning}`),
+        ].join("\n") + "\n");
+    }
+    const modeSuffix = result.safe ? " (share_ready only)" : "";
+    const lines = [
+        "humanish serve",
+        `mode: ${result.mode}${modeSuffix}`,
+        `library: ${result.url ?? ""}`,
+        `runs: ${result.runsListed}`,
+    ];
+    if (result.publicUrl) {
+        lines.push(`public: ${result.publicUrl}`);
+    }
+    if (result.tunnel) {
+        lines.push(`tunnel: ${result.tunnel.provider} ${result.tunnel.url}`);
+    }
+    if (result.oauth) {
+        const rules = [...result.oauth.allowEmails, ...result.oauth.allowDomains];
+        lines.push(`edge auth: ${result.oauth.provider} oauth${rules.length > 0 ? ` (allow: ${rules.join(", ")})` : " (no allow rule — any Google account)"}`);
+    }
+    if (result.entryRunId) {
+        lines.push(`entry: ${result.entryRunId}`);
+    }
+    lines.push(`opened: ${result.opened === true ? "yes" : "no"}`);
+    for (const warning of result.warnings) {
+        lines.push(`warning: ${warning}`);
+    }
+    return lines.join("\n") + "\n";
+}

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

@@ -0,0 +1,11 @@
+import { Command } from "commander";
+import { type CliIo } from "../io.js";
+export declare function registerRunCommand(parent: Command, io: CliIo): void;
+export declare function registerVerifyCommand(parent: Command, io: CliIo): void;
+export declare function registerCleanupCommand(parent: Command, io: CliIo): void;
+export declare function registerReviewCommand(parent: Command, io: CliIo): void;
+export declare function registerExportCommand(parent: Command, io: CliIo): void;
+export declare function registerStatsCommand(parent: Command, io: CliIo): void;
+export declare function registerRunsCommand(parent: Command, io: CliIo): void;
+export declare function registerRuntimeCommands(parent: Command, io: CliIo): void;
+export declare function registerReclaimCommand(parent: Command, io: CliIo): void;