@loompad/cli 0.1.0 → 1.1.1

package/dist/cli/index.js

@@ -5,20 +5,40 @@
  * Weaves Claude Code, OpenCode (and bridges like Antigravity) into a single
  * shared thread per project: one conversation, one baton, shared memory.
  */
-import { spawn } from "node:child_process";
+import { spawn } from "../core/process.js";
 import fs from "node:fs";
+import { freeUsage } from "../core/free-pool.js";
 import path from "node:path";
+import os from "node:os";
 import readline from "node:readline";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 import pc from "picocolors";
 import qrcode from "qrcode-terminal";
+// package.json says node >=22.5, but npm doesn't enforce engines at run time.
+// Below that there is no node:sqlite, so every project's history would read
+// as empty — say so up front instead of looking like the data is gone.
+{
+    const [maj, min] = process.versions.node.split(".").map(Number);
+    if (maj < 22 || (maj === 22 && min < 5)) {
+        console.error(`loom needs Node 22.5 or newer — this is Node ${process.versions.node} (${process.execPath}).\n` +
+            `If you use nvm, \`nvm use 22\` (or newer) — or put a newer node first on your PATH.`);
+        process.exit(1);
+    }
+}
 import { DaemonClient, DaemonError, daemonRunning, ensureDaemon, stopDaemon, } from "../daemon/client.js";
 import { installCrashGuards } from "../daemon/guards.js";
 import { LoomDaemon, DEFAULT_PORT } from "../daemon/server.js";
-import { ensureLoomHome } from "../core/registry.js";
+import { ensureLoomHome, loomHome } from "../core/registry.js";
+import { VERSION } from "../version.js";
+import { makeBackup } from "../core/backup.js";
+import { threadMarkdown } from "../core/thread-md.js";
+import { EventLog } from "../core/eventlog.js";
+import { allModels, fetchModels, forgetProvider, listProviders, resolveProvider, setProvider, } from "../core/providers.js";
+import { serviceFile, tokenFindings } from "../core/runner-setup.js";
+import { readRunnerConfig, readRunnerToken, scrubEnv, writeRunnerToken } from "../daemon/runner.js";
 import { NoProjectError, currentProjectDir, resolveCurrentProject } from "./common.js";
-import { fmtUsd, formatAgentRow, formatEvent, formatProjectRow } from "./ui.js";
+import { fmtUsd, formatAgentRosterRow, formatAgentRow, formatEvent, formatProjectRow } from "./ui.js";
 const LOG_MAX_BYTES = 5 * 1024 * 1024;
 /**
  * Where a background daemon's output goes: ~/.loom/daemon.log, appended.
@@ -43,7 +63,7 @@ const program = new Command();
 program
     .name("loom")
     .description("one CLI for all your coding agents — shared thread, shared memory, one baton")
-    .version("0.1.0");
+    .version(VERSION);
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -51,6 +71,33 @@ function fail(message) {
     console.error(pc.red(`✗ ${message}`));
     process.exit(1);
 }
+/** A hosted-hub session: a local browser (loopback), or --paste for machines without one (D74). */
+async function hostedSession(supabaseUrl, publishableKey, paste) {
+    const { hostedSignIn, openInBrowser, pasteSignIn } = await import("../hub/supabase-client.js");
+    if (paste) {
+        return pasteSignIn({
+            supabaseUrl,
+            publishableKey,
+            ask: async (url) => {
+                console.log(`${pc.bold("sign in with GitHub")} — open this on any device:\n\n  ${url}\n`);
+                console.log(pc.dim("you'll land on a page that won't load; copy its whole address and paste it here."));
+                const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+                const line = await new Promise((resolve) => rl.question("address: ", resolve));
+                rl.close();
+                return line;
+            },
+        });
+    }
+    console.log(pc.dim("signing in to the hosted Loom Team Hub with GitHub…"));
+    return hostedSignIn({
+        supabaseUrl,
+        publishableKey,
+        openBrowser: (url) => {
+            console.log(`${pc.dim("  if your browser didn't open:")} ${url}`);
+            openInBrowser(url);
+        },
+    });
+}
 async function currentProject(client) {
     try {
         return await resolveCurrentProject(client);
@@ -103,6 +150,18 @@ program
         console.error(pc.red(`✗ invalid --port "${opts.port}"`));
         process.exit(1);
     }
+    // A runner box's agents don't inherit its secrets (Loom Teams D70).
+    if (readRunnerConfig().enabled) {
+        const { env, removed } = scrubEnv(process.env);
+        for (const k of Object.keys(process.env))
+            if (!(k in env))
+                delete process.env[k];
+        if (removed.length)
+            console.log(pc.dim(`runner: kept ${removed.length} secret-looking variable${removed.length === 1 ? "" : "s"} away from agents`));
+    }
+    const token = readRunnerToken();
+    if (readRunnerConfig().enabled && token && !process.env.GH_TOKEN)
+        process.env.GH_TOKEN = token;
     const daemon = new LoomDaemon({ host: opts.host, port });
     let bound;
     try {
@@ -124,7 +183,10 @@ program
         console.log(pc.dim("bound to the tailnet — pair your phone with `loom pair`"));
     }
     const shutdown = () => {
-        void daemon.close().then(() => process.exit(0));
+        // A shutdown that can't finish in a few seconds is stuck on something it
+        // shouldn't wait for; leave rather than linger as a headless daemon.
+        setTimeout(() => process.exit(0), 5000).unref();
+        void daemon.close().then(() => process.exit(0), () => process.exit(1));
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
@@ -155,90 +217,2080 @@ program
         while (Date.now() < gone && (await daemonRunning())) {
             await new Promise((r) => setTimeout(r, 200));
         }
-    }
-    const self = fileURLToPath(import.meta.url);
-    const args = [self, "daemon", ...(opts.tailnet ? ["--tailnet"] : [])];
-    // Keep the daemon's output. It used to be stdio:"ignore", which meant a
-    // background daemon threw away every byte it ever wrote — a crash left you
-    // with nothing to read. Appended, and rolled once it gets big, so it can't
-    // quietly eat the disk either.
-    const log = openDaemonLog();
-    const child = spawn(process.execPath, args, { detached: true, stdio: ["ignore", log, log] });
-    child.unref();
-    const deadline = Date.now() + 15_000;
-    while (Date.now() < deadline) {
-        await new Promise((r) => setTimeout(r, 300));
-        const cfg = await daemonRunning();
-        if (cfg) {
-            console.log(pc.green(`✓ daemon up on http://${cfg.host}:${cfg.port}`));
+    }
+    const self = fileURLToPath(import.meta.url);
+    const args = [self, "daemon", ...(opts.tailnet ? ["--tailnet"] : [])];
+    // Keep the daemon's output. It used to be stdio:"ignore", which meant a
+    // background daemon threw away every byte it ever wrote — a crash left you
+    // with nothing to read. Appended, and rolled once it gets big, so it can't
+    // quietly eat the disk either.
+    const log = openDaemonLog();
+    const child = spawn(process.execPath, args, { detached: true, stdio: ["ignore", log, log] });
+    child.unref();
+    const deadline = Date.now() + 15_000;
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 300));
+        const cfg = await daemonRunning();
+        if (cfg) {
+            console.log(pc.green(`✓ daemon up on http://${cfg.host}:${cfg.port}`));
+            return;
+        }
+    }
+    fail("daemon did not become healthy — try `loom daemon` in the foreground");
+});
+program
+    .command("down")
+    .description("stop the background daemon")
+    .action(async () => {
+    if (await stopDaemon())
+        console.log(pc.green("✓ daemon stopped"));
+    else
+        console.log(pc.dim("no running daemon found"));
+});
+program
+    .command("status")
+    .description("daemon health and project board")
+    .action(async () => {
+    const cfg = await daemonRunning();
+    if (!cfg) {
+        console.log(pc.dim("daemon: not running (loom up)"));
+        return;
+    }
+    console.log(pc.green(`daemon: http://${cfg.host}:${cfg.port}`));
+    const client = new DaemonClient(cfg);
+    const { projects } = await client.listProjects();
+    if (!projects.length)
+        console.log(pc.dim("no projects yet — loom init"));
+    for (const p of projects)
+        console.log(formatProjectRow(p));
+});
+// ---------------------------------------------------------------------------
+// init / projects / agents
+// ---------------------------------------------------------------------------
+program
+    .command("init")
+    .description("make the current directory a Loom project")
+    .option("--name <name>", "project name (default: directory name)")
+    .action(async (opts) => {
+    const client = await ensureDaemon();
+    const dir = process.cwd();
+    const res = await client.addProject(dir, opts.name);
+    const { project } = await client.project(res.project.id);
+    console.log(pc.green(`✓ project "${project.name}" (${project.id})`));
+    for (const a of project.agents)
+        console.log(formatAgentRow(a));
+    console.log(pc.dim("\nedit .loom/config.json to add/remove agents or change roles"));
+    console.log(pc.dim("then: loom chat"));
+});
+program
+    .command("projects")
+    .description("board of all projects")
+    .option("--forget <idOrName>", "stop tracking a project (its .loom/ stays on disk)")
+    .action(async (opts) => {
+    const client = await ensureDaemon();
+    if (opts.forget) {
+        const { projects } = await client.listProjects();
+        const hit = projects.find((p) => p.id === opts.forget || p.name === opts.forget);
+        if (!hit) {
+            console.error(pc.red(`no project "${opts.forget}"`));
+            process.exitCode = 1;
+            return;
+        }
+        const r = await client.forgetProject(hit.id);
+        console.log(`forgot ${pc.bold(hit.name)} — ${pc.dim(hit.dir)}`);
+        // Say what was kept. "Removed" against a tool that also owns your event
+        // log reads as "deleted", and someone who believes that will not go
+        // looking for the history that is still sitting there.
+        console.log(pc.dim(`its ${r.keptOnDisk} is untouched — add the directory again to restore it`));
+        return;
+    }
+    const { projects } = await client.listProjects();
+    if (!projects.length)
+        console.log(pc.dim("no projects yet — loom init"));
+    for (const p of projects)
+        console.log(formatProjectRow(p));
+});
+program
+    .command("agents")
+    .description("list agent ids, kinds, roles, models, and baton eligibility")
+    .option("--json", "print the agent roster as JSON")
+    .action(async (opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    if (opts.json) {
+        console.log(JSON.stringify(project.agents));
+        return;
+    }
+    if (!project.agents.length) {
+        console.log(pc.dim("no agents configured — edit .loom/config.json or run loom init"));
+        return;
+    }
+    for (const a of project.agents)
+        console.log(formatAgentRosterRow(a));
+});
+program
+    .command("providers")
+    .description("where model agents send their turns, and whether each has a key")
+    .action(() => {
+    const rows = listProviders();
+    for (const p of rows) {
+        const mark = p.configured ? pc.green("\u2713") : pc.dim("\u00b7");
+        const key = p.configured ? pc.dim(p.hint ? `${p.hint} (${p.source})` : "no key needed") : pc.dim("not configured");
+        console.log(`${mark} ${pc.bold(p.id.padEnd(13))} ${pc.dim(p.baseUrl.padEnd(34))} ${key}`);
+        if (p.note)
+            console.log(pc.dim(`    ${p.note}`));
+    }
+    const fu = freeUsage();
+    console.log(`\n${pc.bold("free models")} ${fu.used} request${fu.used === 1 ? "" : "s"} from this machine today (UTC)` +
+        (fu.cappedUntil ? pc.yellow(` · daily cap hit, resets ${new Date(fu.cappedUntil).toLocaleTimeString([], { hour: "numeric", minute: "2-digit" })}`) : "") +
+        pc.dim("\n    OpenRouter allows 50 free requests a day per account (1000 with $10 of credits), shared by every :free model." +
+            "\n    Spread the work: give model agents `pool:free` and each turn takes the next free model — `loom agents:add model --model openrouter/pool:free`"));
+    console.log(pc.dim("\nkeys live in ~/.loom/providers.json (0600) or the environment \u2014 never in a project"));
+});
+program
+    .command("providers:set <id>")
+    .description("set a provider's key, base URL or headers (a key is never printed back)")
+    .option("--key <key>", "the API key; prefer the environment on a shared machine")
+    .option("--base-url <url>", "for a custom provider, or to override a known one")
+    .option("--label <label>", "what to call it")
+    .option("--header <kv...>", "extra header, as name=value")
+    .action((id, opts) => {
+    const headers = {};
+    for (const kv of opts.header ?? []) {
+        const at = kv.indexOf("=");
+        if (at < 1)
+            fail(`--header wants name=value, not "${kv}"`);
+        headers[kv.slice(0, at).trim()] = kv.slice(at + 1).trim();
+    }
+    try {
+        setProvider(id, {
+            ...(opts.key ? { key: opts.key } : {}),
+            ...(opts.baseUrl ? { baseUrl: opts.baseUrl } : {}),
+            ...(opts.label ? { label: opts.label } : {}),
+            ...(Object.keys(headers).length ? { headers } : {}),
+        });
+    }
+    catch (err) {
+        fail(err instanceof Error ? err.message : String(err));
+    }
+    const row = listProviders().find((p) => p.id === id.toLowerCase());
+    console.log(`${pc.green("\u2713")} ${id}: ${row?.baseUrl ?? ""} ${pc.dim(row?.hint ?? "")}`);
+});
+program
+    .command("providers:rm <id>")
+    .description("forget a provider's key and settings")
+    .action((id) => {
+    console.log(forgetProvider(id) ? `${pc.red("-")} ${id} forgotten` : pc.dim(`nothing stored for ${id}`));
+});
+program
+    .command("ask <words...>")
+    .description("ask several models the same thing at once, a thread each")
+    .option("--models <list>", "comma-separated model ids (provider/model, or just the model)")
+    .option("--free", "every free model the providers have, up to --limit")
+    .option("--limit <n>", "how many models --free may use", "3")
+    .option("--title <title>", "what to call the threads")
+    .option("--no-briefing", "don't send the project's memory brief with it")
+    .action(async (words, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    let models = (opts.models ?? "").split(",").map((m) => m.trim()).filter(Boolean);
+    if (opts.free) {
+        // The point of --free: spend nothing, and let the providers say what
+        // that means today rather than a list going stale in this file.
+        const { models: all } = await allModels();
+        const limit = Math.max(1, Number(opts.limit) || 3);
+        models = all.filter((m) => m.free).slice(0, limit).map((m) => `${m.provider}/${m.id}`);
+        if (!models.length)
+            fail("no free models — loom models --refresh, or name them with --models");
+    }
+    if (!models.length)
+        fail('which models? e.g. loom ask --models "a,b" "your question"');
+    try {
+        const { asked } = await client.askModels(project.id, words.join(" "), models, {
+            ...(opts.title ? { title: opts.title } : {}),
+            ...(opts.briefing === false ? { briefing: false } : {}),
+        });
+        console.log(pc.cyan(`\u279c asked ${asked.length} model${asked.length === 1 ? "" : "s"}:`));
+        for (const a of asked)
+            console.log(`  ${pc.bold(a.model)} ${pc.dim(a.chat)}`);
+        console.log(pc.dim("answers stream into their own threads \u2014 loom watch, or open the app"));
+    }
+    catch (err) {
+        fail(err instanceof Error ? err.message : String(err));
+    }
+});
+program
+    .command("routes:save <name> <steps...>")
+    .description('define a named route, e.g. loom routes:save ship planner executor reviewer\n' +
+    "  a step may carry a condition on the previous turn: 'reviewer?lines>200'\n" +
+    "  (changed>N, changed<N, lines>N, lines<N, touched:<glob>, !touched:<glob>)")
+    .action(async (name, steps) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    try {
+        await client.saveRoute(project.id, name, steps);
+        console.log(`${pc.green("✓")} ${name}: ${steps.join(" → ")}`);
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
+});
+program
+    .command("routes:rm <name>")
+    .description("remove a named route")
+    .action(async (name) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    try {
+        await client.deleteRoute(project.id, name);
+        console.log(`${pc.red("-")} ${name} removed`);
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
+});
+program
+    .command("retry <agentId>")
+    .description("re-run the last failed turn on a different agent, failure attached as context")
+    .action(async (agentId) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    try {
+        const { retried } = await client.retryTurn(project.id, agentId);
+        console.log(`${pc.green("↻")} ${pc.bold(agentId)} retrying: ${pc.dim(retried.slice(0, 80))}`);
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
+});
+program
+    .command("version")
+    .description("CLI build vs the daemon's — the mismatch loom up --restart fixes")
+    .action(async () => {
+    const { BUILD_REV } = await import("../daemon/server.js");
+    console.log(`cli     ${BUILD_REV}`);
+    try {
+        const client = await ensureDaemon();
+        const v = await client.version();
+        const stale = v.rev !== BUILD_REV;
+        console.log(`daemon  ${v.rev}  ${pc.dim(`node ${v.node} · up ${Math.round(v.uptimeSec / 60)}m`)}`);
+        if (stale)
+            console.log(pc.yellow("daemon is running an older build — loom up --restart"));
+    }
+    catch {
+        console.log(pc.dim("daemon  not running"));
+    }
+});
+program
+    .command("brain:forget <memoryId>")
+    .description("forget one memory unit (its history stays in the log)")
+    .action(async (memoryId) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    try {
+        await client.forgetMemory(project.id, memoryId);
+        console.log(`${pc.red("-")} ${memoryId} forgotten`);
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
+});
+program
+    .command("open")
+    .description("open this machine's Loom app in the browser")
+    .action(async () => {
+    const client = await ensureDaemon();
+    const url = `${client.baseUrl}/app`;
+    console.log(url);
+    const { spawn: sp } = await import("node:child_process");
+    const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd.exe" : "xdg-open";
+    const child = sp(opener, process.platform === "win32" ? ["/d", "/c", "start", "", url] : [url], { detached: true, windowsHide: true, stdio: "ignore" });
+    child.on("error", () => console.error(`Open ${url} in your browser.`));
+    child.unref();
+});
+program
+    .command("rename <name...>")
+    .description("rename this project (the id never moves, so nothing orphans)")
+    .action(async (words) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const name = words.join(" ");
+    await client.renameProject(project.id, name);
+    console.log(`${pc.green("✓")} ${project.name} → ${pc.bold(name)}`);
+});
+program
+    .command("find <query...>")
+    .description("search this project's thread — messages, decisions, questions")
+    .action(async (words) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const { hits } = await client.searchEvents(project.id, words.join(" "));
+    if (!hits.length)
+        return void console.log(pc.dim("nothing matches"));
+    for (const e of hits) {
+        const t = new Date(e.ts).toISOString().slice(0, 16).replace("T", " ");
+        const who = e.agentId ? pc.cyan(e.agentId) : pc.dim("you");
+        console.log(`${pc.dim(t)} ${who}  ${String(e.payload.text ?? e.payload.question ?? "").slice(0, 110)}`);
+    }
+});
+program
+    .command("specs")
+    .description("the project's Playwright specs, and whether one is running")
+    .action(async () => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const { specs, running } = await client.listSpecs(project.id);
+    if (!specs.length)
+        return void console.log(pc.dim("no *.spec.* / *.e2e.* files here"));
+    for (const s of specs) {
+        const live = running?.file === s.path ? pc.green("  ← running") : "";
+        console.log(`${s.path}${live}`);
+    }
+});
+program
+    .command("specs:run <file>")
+    .description("run one Playwright spec through the daemon")
+    .option("--wait", "block until the verdict lands, and exit 1 on failure")
+    .action(async (file, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    try {
+        const { run } = await client.runSpec(project.id, file);
+        if (!opts.wait) {
+            console.log(`${pc.cyan("▶")} ${run.file} ${pc.dim(`run ${run.id} — reporter streams to the app; result lands in the Console`)}`);
+            return;
+        }
+        // Poll the runner state; the verdict is in the Console either way, but
+        // --wait exists so scripts and CI get an exit code, not a suggestion.
+        console.log(`${pc.cyan("▶")} ${run.file} ${pc.dim("waiting for the verdict…")}`);
+        for (;;) {
+            await new Promise((r) => setTimeout(r, 1000));
+            const { running } = await client.listSpecs(project.id);
+            if (!running || running.id !== run.id)
+                break;
+        }
+        const { logs } = await client.logs({ level: undefined });
+        const verdict = [...logs].reverse().find((l) => l.scope === "specs" && l.message.includes(run.file));
+        if (verdict?.message.includes("passed")) {
+            console.log(`${pc.green("✓")} ${verdict.message}`);
+        }
+        else {
+            console.error(pc.red(`✗ ${verdict?.message ?? "no verdict recorded"}`));
+            if (verdict?.detail)
+                console.error(pc.dim(verdict.detail.split("\n").slice(-12).join("\n")));
+            process.exitCode = 1;
+        }
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
+});
+program
+    .command("stale")
+    .description("sessions that look hung — busy far longer than any plausible turn")
+    .action(async () => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const { stale } = await client.staleSessions(project.id);
+    if (!stale.length)
+        return void console.log(pc.dim("nothing looks hung"));
+    for (const s of stale) {
+        console.log(`${pc.red(s.agentId)}  busy ${Math.round(s.busyMs / 60000)}m  ${pc.dim(`— loom reap ${s.agentId}`)}`);
+    }
+});
+program
+    .command("reap <agentId>")
+    .description("put a hung session out of its misery and respawn it fresh")
+    .action(async (agentId) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    try {
+        await client.reapSession(project.id, agentId);
+        console.log(`${pc.green("✓")} ${agentId} respawned — baton released if it held it`);
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
+});
+program
+    .command("brain:migrate [directory]")
+    .description("offline, backed-up JSONL → SQLite history import; conflicting IDs abort")
+    .action(async (directory) => {
+    if (await daemonRunning())
+        throw new Error("stop the Loom daemon before migrating history");
+    const dir = path.resolve(directory ?? process.cwd());
+    const result = await EventLog.migrateJsonl(path.join(dir, ".loom"));
+    console.log(`Imported ${result.imported}; already known ${result.known}. Original JSONL retained. Backup: ${result.backup}`);
+});
+program
+    .command("brain:search <query...>")
+    .description("retrieval, exactly as a briefing would see it — scores and all")
+    .option("--explain", "show the arithmetic per hit (bm25, entity, fuzzy, dense, recency)")
+    .action(async (words, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const { hits } = await client.searchBrain(project.id, words.join(" "), {
+        explain: Boolean(opts.explain),
+    });
+    if (!hits.length)
+        return void console.log(pc.dim("nothing retrieved — the briefing would carry no memories for this"));
+    for (const h of hits) {
+        console.log(`${pc.bold((h.score.toFixed(2)))} ${pc.magenta(h.memory.kind.padEnd(10))} ${h.memory.text.slice(0, 100)}`);
+        if (opts.explain && h.detail)
+            console.log(pc.dim(`      ${JSON.stringify(h.detail)}`));
+    }
+});
+program
+    .command("brain:conflicts")
+    .description("units that likely contradict each other, for you to resolve")
+    .action(async () => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const { conflicts } = await client.brainConflicts(project.id);
+    if (!conflicts.length)
+        return void console.log(pc.dim("no likely contradictions"));
+    for (const c of conflicts) {
+        console.log(`${pc.yellow(c.signal)} ${pc.dim(`(${Math.round(c.similarity * 100)}% same topic)`)}`);
+        console.log(`  A: ${c.a.text.slice(0, 90)}`);
+        console.log(`  B: ${c.b.text.slice(0, 90)}`);
+    }
+});
+program
+    .command("mcp:health")
+    .description("each MCP server's live state, from the background poll")
+    .action(async () => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const { health } = await client.mcpHealth(project.id);
+    const rows = Object.entries(health);
+    if (!rows.length)
+        return void console.log(pc.dim("no MCP servers configured (or none probed yet)"));
+    for (const [name, h] of rows) {
+        const age = Math.round((Date.now() - h.probedAt) / 1000);
+        console.log(`${name.padEnd(20)} ${h.up ? pc.green("up") : pc.red(`down ×${h.failures}`)}  ${pc.dim(`${age}s ago`)}`);
+    }
+});
+/** "KEY=VAL" / "Header: value" pairs from repeated flags. */
+function kv(list, sep) {
+    const out = {};
+    for (const item of list ?? []) {
+        const m = sep.exec(item);
+        if (!m || m.index === 0)
+            throw new Error(`"${item}" isn't a pair`);
+        out[item.slice(0, m.index).trim()] = item.slice(m.index + m[0].length).trim();
+    }
+    return out;
+}
+const collect = (v, prev = []) => [...prev, v];
+program
+    .command("prompts [action] [args...]")
+    .description("saved prompts, shared with the app: list [query] | save <text> | show <id> | send <id> | pin <id> | unpin <id> | rename <id> <title> | rm <id>")
+    .option("-t, --title <title>", "save: a title (else the first words)")
+    .option("-a, --agent <id>", "send: address a specific agent")
+    .action(async (action, args, opts) => {
+    const client = await ensureDaemon();
+    const a = (action ?? "list").toLowerCase();
+    const rest = (args ?? []).join(" ").trim();
+    const find = async (ref) => {
+        const { saved } = await client.prompts();
+        const hit = saved.find((p) => p.id === ref) ?? saved.find((p) => p.id.startsWith(ref)) ??
+            saved.find((p) => p.title.toLowerCase() === ref.toLowerCase());
+        if (!hit)
+            throw new Error(`no saved prompt "${ref}" — loom prompts lists them`);
+        return hit;
+    };
+    if (a === "list" || a === "ls") {
+        const { saved } = await client.prompts(rest);
+        if (!saved.length)
+            return void console.log(pc.dim(rest ? `no saved prompt matches "${rest}"` : "no saved prompts yet — loom prompts save \"…\" (or ⌘⇧V in the app)"));
+        for (const p of saved) {
+            console.log(`${pc.dim(p.id.slice(0, 8))}  ${p.pinned ? pc.yellow("★ ") : ""}${pc.bold(p.title)}  ${pc.dim(`${p.uses}×`)}`);
+            console.log(`          ${pc.dim(p.text.replace(/\s+/g, " ").slice(0, 90))}`);
+        }
+        return;
+    }
+    if (a === "save" || a === "add") {
+        const text = rest || (process.stdin.isTTY ? "" : fs.readFileSync(0, "utf8"));
+        if (!text.trim())
+            throw new Error("what should it say? loom prompts save \"review this diff for…\" (or pipe it in)");
+        const { prompt } = await client.savePrompt({ text, ...(opts.title ? { title: opts.title } : {}) });
+        return void console.log(`${pc.green("✓")} saved ${pc.bold(prompt.title)} ${pc.dim(prompt.id.slice(0, 8))}`);
+    }
+    if (!["show", "cat", "send", "use", "pin", "unpin", "rename", "rm", "delete"].includes(a)) {
+        throw new Error(`unknown action "${a}" — list | save | show | send | pin | unpin | rename | rm`);
+    }
+    if (!rest)
+        throw new Error(`which prompt? loom prompts ${a} <id or title>`);
+    const [ref, ...more] = rest.split(/\s+/);
+    const p = await find(a === "rename" ? ref : rest);
+    if (a === "show" || a === "cat")
+        return void process.stdout.write(p.text + "\n");
+    if (a === "send" || a === "use") {
+        const project = await currentProject(client);
+        const now = new Date();
+        const text = p.text
+            .replace(/\{\{date\}\}/g, now.toLocaleDateString())
+            .replace(/\{\{time\}\}/g, now.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" }))
+            .replace(/\{\{project\}\}/g, project.name)
+            .replace(/\{\{(?:selection|branch|chat|agent|last_reply|file)\}\}/g, "");
+        const result = await sendWithHandoffConfirm(client, project.id, text, opts.agent);
+        await client.updatePrompt(p.id, { used: true }).catch(() => { });
+        if (result)
+            console.log(pc.dim(`→ sent "${p.title}" to ${result.agentId} (loom log --follow to watch)`));
+        return;
+    }
+    if (a === "pin" || a === "unpin") {
+        await client.updatePrompt(p.id, { pinned: a === "pin" });
+        return void console.log(`${pc.green("✓")} ${a === "pin" ? "pinned" : "unpinned"} ${p.title}`);
+    }
+    if (a === "rename") {
+        const title = more.join(" ").trim();
+        if (!title)
+            throw new Error("loom prompts rename <id> <new title>");
+        await client.updatePrompt(p.id, { title });
+        return void console.log(`${pc.green("✓")} renamed to ${pc.bold(title)}`);
+    }
+    if (a === "rm" || a === "delete") {
+        await client.deletePrompt(p.id);
+        return void console.log(`${pc.green("✓")} removed ${p.title}`);
+    }
+    throw new Error(`unknown action "${a}" — list | save | show | send | pin | unpin | rename | rm`);
+});
+program
+    .command("skills [action] [args...]")
+    .description("skills for this project: list [query] | on <id> | off <id> | install <git-url|dir>[#name|#all] | rm <id>")
+    .option("--all", "list: every skill found on this machine, not just the ones on")
+    .option("--force", "install: replace a skill with the same name")
+    .action(async (action, args, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const a = (action ?? "list").toLowerCase();
+    const rest = (args ?? []).join(" ").trim();
+    if (a === "list" || a === "ls") {
+        const { skills } = await client.skillsCatalog(project.id);
+        const q = rest.toLowerCase();
+        const rows = skills.filter((k) => (opts.all || q || k.enabled) && (!q || `${k.id} ${k.name ?? ""} ${k.description ?? ""}`.toLowerCase().includes(q)));
+        const on = skills.filter((k) => k.enabled).length;
+        console.log(pc.dim(`${on} on · ${skills.length} found${opts.all || q ? "" : " — loom skills list --all shows them all"}`));
+        for (const k of rows) {
+            console.log(`${k.enabled ? pc.green("●") : pc.dim("○")} ${pc.bold(k.id)}${k.installed ? pc.dim(" (this project)") : k.origin ? pc.dim(` (${k.origin})`) : ""}`);
+            if (k.description)
+                console.log(`  ${pc.dim(k.description.replace(/\s+/g, " ").slice(0, 96))}`);
+        }
+        return;
+    }
+    if (!["on", "off", "install", "add", "rm", "remove"].includes(a))
+        throw new Error(`unknown action "${a}" — list | on | off | install | rm`);
+    if (!rest)
+        throw new Error(`loom skills ${a} <${a === "install" ? "git url or folder" : "skill id"}>`);
+    if (a === "on" || a === "off") {
+        await client.setSkill(project.id, rest, a === "on");
+        return void console.log(`${pc.green("✓")} ${rest} ${a === "on" ? "on" : "off"} for ${project.name}`);
+    }
+    if (a === "install" || a === "add") {
+        const local = !/^(https?:|git@|ssh:)/.test(rest) && fs.existsSync(rest.replace(/#.*$/, ""));
+        const { skill } = await client.installSkill(project.id, local
+            ? { dir: path.resolve(rest), ...(opts.force ? { force: true } : {}) }
+            : { gitUrl: rest, ...(opts.force ? { force: true } : {}) });
+        const names = [skill.id, ...(skill.also ?? [])];
+        for (const n of names)
+            await client.setSkill(project.id, n, true).catch(() => { });
+        return void console.log(`${pc.green("✓")} installed and turned on ${names.map((n) => pc.bold(n)).join(", ")}`);
+    }
+    if (a === "rm" || a === "remove") {
+        await client.removeSkill(project.id, rest);
+        return void console.log(`${pc.green("✓")} removed ${rest} from ${project.name}`);
+    }
+    throw new Error(`unknown action "${a}" — list | on | off | install | rm`);
+});
+program
+    .command("mcp [action] [args...]")
+    .description("MCP servers for this project: list | add <name> (--url <url> | --command <cmd> [args…]) | on <name> | off <name> | rm <name>")
+    .option("--url <url>", "add: a remote server's endpoint")
+    .option("--command <cmd>", "add: a local server to run (args follow the name)")
+    .option("-H, --header <header>", "add: 'Name: value', repeatable", collect)
+    .option("-e, --env <pair>", "add: KEY=VALUE for a local server, repeatable", collect)
+    // the server's own flags (npx -y …) ride along as its args; put them after -- if they clash with ours
+    .allowUnknownOption()
+    .action(async (action, args, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const a = (action ?? "list").toLowerCase();
+    const [name, ...more] = args ?? [];
+    if (a === "list" || a === "ls") {
+        const { mcps } = await client.mcps(project.id);
+        const rows = mcps.filter((m) => m.url || m.command);
+        if (!rows.length)
+            return void console.log(pc.dim("no MCP servers yet — loom mcp add github --url https://api.githubcopilot.com/mcp/ (or Skills & MCP in the app)"));
+        for (const m of rows) {
+            const state = m.enabledForSession === false ? pc.dim("off") : m.command ? pc.cyan("local") : m.connected ? pc.green("up") : pc.red("unreachable");
+            console.log(`${m.name.padEnd(20)} ${state.padEnd(20)} ${pc.dim(m.url || [m.command, ...(m.args ?? [])].join(" "))}`);
+        }
+        console.log(pc.dim("Claude Code and Codex load these; other agents don't speak MCP."));
+        return;
+    }
+    if (!["add", "install", "on", "off", "rm", "remove"].includes(a))
+        throw new Error(`unknown action "${a}" — list | add | on | off | rm`);
+    if (!name)
+        throw new Error(`loom mcp ${a} <name>`);
+    if (a === "add" || a === "install") {
+        if (!opts.url && !opts.command)
+            throw new Error("add needs --url <endpoint> or --command <program>");
+        const { installed } = await client.installMcp(project.id, {
+            name,
+            ...(opts.url ? { url: opts.url } : {}),
+            ...(opts.command ? { command: opts.command, ...(more.length ? { args: more } : {}) } : {}),
+            ...(opts.header?.length ? { headers: kv(opts.header, /:\s*/) } : {}),
+            ...(opts.env?.length ? { env: kv(opts.env, /=/) } : {}),
+        });
+        const note = opts.command ? "it starts when an agent needs it" : installed?.connected ? "it answered" : "it didn't answer yet — check the URL, or it may need sign-in headers (-H)";
+        return void console.log(`${pc.green("✓")} added ${pc.bold(name)} — ${note}`);
+    }
+    if (a === "on" || a === "off") {
+        const { mcps } = await client.mcps(project.id, false);
+        const row = mcps.find((m) => m.name === name);
+        if (!row)
+            throw new Error(`no MCP server "${name}" — loom mcp lists them`);
+        const { connected: _c, ...keep } = row;
+        await client.patchMcp(project.id, { ...keep, enabledForSession: a === "on" });
+        return void console.log(`${pc.green("✓")} ${name} ${a}`);
+    }
+    if (a === "rm" || a === "remove") {
+        await client.removeMcp(project.id, name);
+        return void console.log(`${pc.green("✓")} removed ${name}`);
+    }
+    throw new Error(`unknown action "${a}" — list | add | on | off | rm`);
+});
+program
+    .command("snapshot [file]")
+    .description("checkpoint this project's brain + board + config to a file")
+    .action(async (file) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const doc = await client.snapshot(project.id);
+    const out = file ?? `loom-snapshot-${project.name}.json`;
+    const fs = await import("node:fs");
+    fs.writeFileSync(out, JSON.stringify(doc, null, 2) + "\n");
+    const mems = (doc.brain?.memories ?? []).length;
+    const tasks = (doc.tasks ?? []).length;
+    console.log(`${pc.green("✓")} ${out} ${pc.dim(`· ${mems} memories · ${tasks} cards`)}`);
+});
+program
+    .command("restore <file>")
+    .description("bring a snapshot back — board and config replace, the brain merges")
+    .action(async (file) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const fs = await import("node:fs");
+    let doc;
+    try {
+        doc = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (err) {
+        console.error(pc.red(`could not read ${file}: ${err instanceof Error ? err.message : err}`));
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const out = await client.restore(project.id, doc);
+        console.log(`${pc.green("✓")} restored ${pc.dim(`· brain +${out.brain.added} (${out.brain.known} known) · ${out.tasks} cards`)}`);
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
+});
+/**
+ * Rewind (#101). Deliberately a sibling of snapshot/restore above and not a
+ * flag on it: that pair moves the brain, the board and the config and leaves
+ * files to git. This one is the files, and leaves those alone. One command
+ * that did both would be a command nobody could predict.
+ */
+program
+    .command("rewind [checkpoint]")
+    .description("put the working tree back to a checkpoint (no argument lists them)")
+    .option("-y, --yes", "don't ask")
+    .action(async (checkpoint, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const { checkpoints } = await client.checkpoints(project.id);
+    if (!checkpoints.length) {
+        console.log(pc.dim("no checkpoints yet — one is taken before every turn, in a git repository"));
+        return;
+    }
+    if (!checkpoint) {
+        for (const c of checkpoints.slice(0, 20)) {
+            console.log(`  ${pc.bold(c.id)}  ${pc.dim(new Date(c.at).toLocaleString())}  ${c.label}`);
+        }
+        console.log(pc.dim(`
+  loom rewind <id>   ·  ${checkpoints.length} checkpoint${checkpoints.length === 1 ? "" : "s"}`));
+        return;
+    }
+    const target = checkpoints.find((c) => c.id === checkpoint);
+    if (!target) {
+        console.error(pc.red(`no checkpoint "${checkpoint}" — run \`loom rewind\` to see them`));
+        process.exitCode = 1;
+        return;
+    }
+    if (!opts.yes) {
+        console.log(`${pc.yellow("!")} this puts the files back to ${pc.bold(target.label)}`);
+        console.log(pc.dim("  anything written since is removed; commits, history and ignored files are untouched"));
+        console.log(pc.dim("  the rewind is itself saved, so it can be undone"));
+        const ok = await confirm("rewind?");
+        if (!ok)
+            return;
+    }
+    try {
+        const out = await client.rewind(project.id, target.id);
+        console.log(`${pc.green("✓")} rewound ${pc.dim(`· ${out.changed.length} file${out.changed.length === 1 ? "" : "s"} · undo with \`loom rewind ${out.undo.id}\``)}`);
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
+});
+program
+    .command("task <title...>")
+    .description("put a card on the board")
+    .option("--agent <id>", "who it's for")
+    .option("--column <col>", "working | needs-you | in-review | ready", "needs-you")
+    .option("--blocked-by <ids>", "comma-separated task ids this one waits on")
+    .action(async (words, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const { task } = await client.createTask(project.id, words.join(" "), {
+        column: opts.column,
+        ...(opts.agent ? { agent: opts.agent } : {}),
+        ...(opts.blockedBy ? { blockedBy: opts.blockedBy.split(",").map((s) => s.trim()) } : {}),
+    });
+    console.log(`${pc.green("+")} ${task.id} ${pc.dim(task.column)}  ${task.title}`);
+});
+program
+    .command("tasks")
+    .description("the cards you wrote, by column")
+    .option("--json", "print as JSON")
+    .action(async (opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const { tasks } = await client.listTasks(project.id);
+    if (opts.json)
+        return void console.log(JSON.stringify(tasks, null, 2));
+    if (!tasks.length)
+        return void console.log(pc.dim("no cards — loom task <title> makes one"));
+    for (const t of tasks) {
+        const blocked = t.blockedBy?.length ? pc.red(` ⛔${t.blockedBy.join(",")}`) : "";
+        console.log(`${t.id}  ${t.column.padEnd(9)} ${t.agent ? pc.cyan(t.agent.padEnd(14)) : "".padEnd(14)} ${t.title}${blocked}`);
+    }
+});
+program
+    .command("budgets")
+    .description("each agent's daily USD cap and today's real spend against it")
+    .action(async () => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const { status } = await client.budgets(project.id);
+    const rows = Object.entries(status);
+    if (!rows.length) {
+        console.log(pc.dim("no caps set — loom budget <agentId> <usd> to add one"));
+        return;
+    }
+    for (const [agentId, s] of rows) {
+        const bar = s.over ? pc.red("OVER — paused") : pc.dim(`${Math.round((s.spentTodayUsd / s.budgetUsd) * 100)}%`);
+        console.log(`${agentId.padEnd(18)} $${s.spentTodayUsd.toFixed(2)} / $${s.budgetUsd.toFixed(2)}  ${bar}`);
+    }
+});
+program
+    .command("budget <agentId> [usd]")
+    .description("cap an agent's daily spend in USD — agentId 'all' caps every adapter (0 clears)")
+    .action(async (agentId, usd) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const value = usd === undefined ? 0 : Number(usd);
+    if (Number.isNaN(value) || value < 0) {
+        console.error(pc.red(`"${usd}" is not a dollar amount`));
+        process.exitCode = 1;
+        return;
+    }
+    if (agentId === "all") {
+        const adapters = project.agents.filter((a) => a.tier === "adapter");
+        for (const a of adapters)
+            await client.setBudget(project.id, a.id, value);
+        console.log(value > 0
+            ? `${pc.green("✓")} ${adapters.length} adapters capped at $${value.toFixed(2)}/day each`
+            : `${pc.green("✓")} ${adapters.length} adapters uncapped`);
+        return;
+    }
+    await client.setBudget(project.id, agentId, value);
+    console.log(value > 0
+        ? `${pc.green("✓")} ${agentId} capped at $${value.toFixed(2)}/day — over the cap it pauses, hard`
+        : `${pc.green("✓")} ${agentId} uncapped`);
+});
+program
+    .command("watch")
+    .description("tail this project's events live — turns, handoffs, memory, subtasks")
+    .option("--all", "watch every project, prefixed with the project id")
+    .option("--json", "one JSON event per line, for piping")
+    .action(async (opts) => {
+    const client = await ensureDaemon();
+    const project = opts.all ? null : await currentProject(client);
+    /**
+     * One line per event, shaped for a human at a terminal. Everything else in
+     * the log still flows — this names the kinds worth a glance and lets the
+     * rest pass as a dim one-liner rather than pretending they don't exist.
+     */
+    const line = (e) => {
+        const t = new Date(e.ts).toTimeString().slice(0, 8);
+        const who = e.agentId ? pc.cyan(e.agentId) : pc.dim("you");
+        const p = e.payload;
+        switch (e.kind) {
+            case "message":
+                return `${t} ${who} ${String(p.text ?? "").slice(0, 100)}`;
+            case "handoff":
+                return `${t} ${pc.yellow("baton")} ${String(p.from ?? "—")} → ${String(p.to ?? "—")}`;
+            case "run_complete":
+                return `${t} ${who} ${pc.green("turn done")}`;
+            case "needs_input":
+                return `${t} ${who} ${pc.red("needs you")}: ${String(p.question ?? "").slice(0, 80)}`;
+            case "decision":
+                return `${t} ${who} ${pc.magenta("decision")} ${String(p.text ?? "").slice(0, 90)}`;
+            case "memory_add":
+                return `${t} ${who} ${pc.magenta("learned")} ${String(p.memory?.text ?? "").slice(0, 90)}`;
+            case "subtask_started":
+                return `${t} ${who} ${pc.cyan("subtask")} for ${String(p.parent)}: ${String(p.task ?? "").slice(0, 70)}`;
+            case "subtask_done":
+                return `${t} ${who} ${pc.green("subtask done")}`;
+            case "subtask_failed":
+                return `${t} ${who} ${pc.red("subtask failed")}: ${String(p.message ?? "").slice(0, 80)}`;
+            case "error":
+                return `${t} ${who} ${pc.red("error")} ${String(p.message ?? "").slice(0, 90)}`;
+            case "route_started":
+            case "route_step":
+            case "route_completed":
+            case "route_failed":
+                return `${t} ${pc.yellow(e.kind.replace("route_", "route "))} ${String(p.route ?? p.name ?? "")}`;
+            default:
+                return pc.dim(`${t} ${e.kind}`);
+        }
+    };
+    console.log(pc.dim(project
+        ? `watching ${project.name} — ^C to stop`
+        : "watching every project — ^C to stop"));
+    const close = client.subscribe((pid, e) => {
+        if (opts.json) {
+            console.log(JSON.stringify(opts.all ? { project: pid, ...e } : e));
+            return;
+        }
+        const prefix = opts.all ? pc.dim(`[${pid.slice(0, 8)}] `) : "";
+        console.log(prefix + line(e));
+    }, project?.id);
+    // Keep the process alive until ^C; close the socket on the way out so the
+    // daemon isn't left holding a dead subscriber.
+    await new Promise((resolve) => {
+        process.on("SIGINT", () => {
+            close();
+            console.log();
+            resolve();
+        });
+    });
+});
+program
+    .command("brain:export [file]")
+    .description("write this project's brain to a file (or stdout) so it can travel")
+    .action(async (file) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const doc = await client.exportBrain(project.id);
+    const json = JSON.stringify(doc, null, 2);
+    if (file) {
+        const fs = await import("node:fs");
+        fs.writeFileSync(file, json + "\n");
+        const n = doc.memories?.length ?? 0;
+        console.log(`${pc.green("✓")} ${n} memor${n === 1 ? "y" : "ies"} → ${file}`);
+    }
+    else {
+        console.log(json);
+    }
+});
+program
+    .command("brain:import <file>")
+    .description("bring an exported brain into this project (dedupes what's already known)")
+    .action(async (file) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const fs = await import("node:fs");
+    let doc;
+    try {
+        doc = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (err) {
+        console.error(pc.red(`could not read ${file}: ${err instanceof Error ? err.message : err}`));
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const { added, known } = await client.importBrain(project.id, doc);
+        console.log(`${pc.green("✓")} ${added} learned${known ? pc.dim(` · ${known} already known`) : ""}`);
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
+});
+program
+    .command("spawn <task>")
+    .description("fan a subtask out to a child agent — the parent keeps the baton")
+    .option("--agent <id>", "which agent runs the subtask")
+    .option("--parent <id>", "the agent asking (default: whoever holds the baton)")
+    .action(async (task, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const parent = opts.parent ?? project.holder ?? project.agents[0]?.id;
+    if (!parent) {
+        console.error(pc.red("this project has no agents to parent a subtask"));
+        process.exitCode = 1;
+        return;
+    }
+    // Default the child to an agent that isn't the parent — the whole point is
+    // another pair of hands, so borrowing the parent's own would just be a turn.
+    const child = opts.agent ??
+        project.agents.find((a) => a.id !== parent && a.tier === "adapter" && a.enabled !== false)?.id;
+    if (!child) {
+        console.error(pc.red("no other adapter available to run the subtask — add one, or pass --agent"));
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const out = await client.spawnSubtask(project.id, parent, child, task);
+        console.log(`${pc.cyan("↳")} ${pc.bold(out.agentId)} ${pc.dim(`subtask ${out.id}`)}\n` +
+            pc.dim(`  ${parent} keeps the baton; the result lands in the thread under its turn`));
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
+});
+// ── orchestra: one orchestrator, many parallel workers (core/orchestra.ts) ──
+const RUN_DONE = new Set(["completed", "failed", "aborted", "waiting_human"]);
+const TASK_COLOR = {
+    done: pc.green,
+    running: pc.cyan,
+    pending: pc.dim,
+    failed: pc.red,
+    conflict: pc.yellow,
+    needs_input: pc.yellow,
+    cancelled: pc.dim,
+};
+function printRun(run) {
+    const done = run.tasks.filter((t) => t.status === "done").length;
+    console.log(run.race
+        ? `${pc.magenta("🏁")} ${pc.bold(run.id)} ${pc.dim(run.status)}  race · ${done}/${run.tasks.length} finished · ${fmtUsd(run.costUsd)}`
+        : `${pc.magenta("🎼")} ${pc.bold(run.id)} ${pc.dim(run.status)}  ${done}/${run.tasks.length} tasks · ` +
+            `round ${run.round}/${run.maxRounds} · ${fmtUsd(run.costUsd)} · ${pc.dim(run.branch)}`);
+    console.log(`   ${pc.dim("goal")} ${run.goal}`);
+    if (run.race)
+        console.log(`   ${pc.dim("entrants")} ${run.workers.join(", ")}`);
+    else
+        console.log(`   ${pc.dim("orchestrator")} ${run.orchestrator.agent}  ${pc.dim("workers")} ${run.workers.join(", ")}`);
+    for (const t of run.tasks) {
+        const color = TASK_COLOR[t.status] ?? ((x) => x);
+        const deps = t.dependsOn.length ? pc.dim(` after ${t.dependsOn.join(",")}`) : "";
+        const files = t.files?.length ? pc.dim(` · ${t.files.length} file${t.files.length === 1 ? "" : "s"}`) : "";
+        console.log(`   ${color(t.status.padEnd(11))} ${pc.bold(t.id)} ${t.title} ${pc.dim(`→ ${t.agent}`)}${deps}${files}`);
+        if (t.hold)
+            console.log(`               ${pc.yellow(`held (${t.hold.kind}):`)} ${t.hold.reason.slice(0, 200)}`);
+        if (t.error)
+            console.log(`               ${pc.red(t.error.split("\n")[0].slice(0, 160))}`);
+    }
+    if (run.question)
+        console.log(`   ${pc.yellow("asks:")} ${run.question}  ${pc.dim(`(loom orchestra:reply ${run.id} "…")`)}`);
+    if (run.summary)
+        console.log(`   ${pc.green("summary:")} ${run.summary}`);
+    if (run.error)
+        console.log(`   ${pc.red("error:")} ${run.error}`);
+    if (run.status === "completed" && !run.applied) {
+        if (run.race) {
+            const ok = run.tasks.filter((t) => t.status === "done").map((t) => t.id);
+            if (ok.length)
+                console.log(pc.dim(`   keep one: loom orchestra:apply ${run.id} --task ${ok.join(" | ")}`));
+        }
+        else
+            console.log(pc.dim(`   apply it: loom orchestra:apply ${run.id}`));
+    }
+    if (run.race && run.applied?.task)
+        console.log(`   ${pc.green("kept:")} ${run.applied.task} → ${run.applied.into}`);
+}
+async function watchRun(client, projectId, runId) {
+    let last = "";
+    for (;;) {
+        const { run } = await client.orchestraRun(projectId, runId);
+        const line = `${run.status}|${run.tasks.map((t) => `${t.id}:${t.status}`).join(",")}`;
+        if (line !== last) {
+            last = line;
+            const stamp = new Date().toLocaleTimeString();
+            console.log(pc.dim(stamp) + " " + pc.bold(run.status) + "  " +
+                run.tasks.map((t) => (TASK_COLOR[t.status] ?? ((x) => x))(`${t.id}[${t.agent}]`)).join(" "));
+        }
+        if (RUN_DONE.has(run.status)) {
+            console.log("");
+            printRun(run);
+            if (run.status === "failed" || run.status === "aborted")
+                process.exitCode = 1;
+            return;
+        }
+        await new Promise((r) => setTimeout(r, 1500));
+    }
+}
+program
+    .command("orchestrate <goal>")
+    .description("one orchestrator plans the goal; many worker agents build it in parallel, each in its own worktree")
+    .option("-o, --orchestrator <agent>", "who plans and reviews (default: claude-code if present)")
+    .option("-w, --workers <agents>", "comma-separated worker agents (default: every agent in the project)")
+    .option("-p, --parallel <n>", "tasks running at once (1-12, default 4)")
+    .option("--rounds <n>", "orchestrator review rounds before giving up (default 10)")
+    .option("--plan", "plan mode: write the plan as markdown specs under plans/<run>/ that any agent can pick up")
+    .option("--max-usd <n>", "stop this goal when it has spent this much, and say so")
+    .option("--race", "race: every worker takes the whole goal in its own worktree; pick one with orchestra:apply <run> --task race-<agent>")
+    .option("--no-watch", "start it and return instead of following it to the end")
+    .action(async (goal, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    try {
+        const { run } = await client.startOrchestra(project.id, {
+            goal,
+            ...(opts.orchestrator ? { orchestrator: opts.orchestrator } : {}),
+            ...(opts.workers ? { workers: opts.workers.split(",").map((w) => w.trim()).filter(Boolean) } : {}),
+            ...(opts.parallel ? { maxParallel: Number(opts.parallel) } : {}),
+            ...(opts.rounds ? { maxRounds: Number(opts.rounds) } : {}),
+            ...(opts.plan ? { plan: true } : {}),
+            ...(opts.maxUsd ? { maxUsd: Number(opts.maxUsd) } : {}),
+            ...(opts.race ? { race: true } : {}),
+        });
+        console.log(run.race
+            ? `${pc.magenta("🏁")} ${pc.bold(run.id)} started — ${run.workers.join(", ")} racing on the same goal`
+            : `${pc.magenta("🎼")} ${pc.bold(run.id)} started — ${pc.bold(run.orchestrator.agent)} orchestrating ` +
+                `${run.workers.join(", ")} (${run.maxParallel} in parallel) on ${pc.dim(run.branch)}`);
+        if (opts.watch)
+            await watchRun(client, project.id, run.id);
+        else
+            console.log(pc.dim(`  follow it: loom orchestra ${run.id} --watch`));
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
+});
+program
+    .command("orchestra [runId]")
+    .description("orchestra runs in this project — or one run in detail")
+    .option("--watch", "follow the run until it finishes")
+    .action(async (runId, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    try {
+        if (runId) {
+            if (opts.watch)
+                return void (await watchRun(client, project.id, runId));
+            return void printRun((await client.orchestraRun(project.id, runId)).run);
+        }
+        const { runs } = await client.orchestraRuns(project.id);
+        if (!runs.length)
+            return void console.log(pc.dim('no orchestra runs yet — loom orchestrate "<goal>"'));
+        for (const r of runs.slice(0, 15)) {
+            const done = r.tasks.filter((t) => t.status === "done").length;
+            console.log(`${pc.bold(r.id)}  ${r.status.padEnd(13)} ${String(done).padStart(2)}/${String(r.tasks.length).padEnd(2)} ` +
+                `${pc.dim(new Date(r.createdAt).toLocaleString())}  ${r.goal.slice(0, 70)}`);
+        }
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
+});
+for (const action of ["abort", "apply", "cleanup", "resume"]) {
+    const blurb = {
+        abort: "stop a run — every worker is interrupted",
+        resume: "carry on a run Loom stopped by restarting — its interrupted tasks pick up where they left off",
+        apply: "merge a run's integration branch into your current branch (a race: --task <entrant>)",
+        cleanup: "remove a finished run's worktrees (its branch stays)",
+    }[action];
+    program
+        .command(`orchestra:${action} <runId>`)
+        .description(blurb)
+        .option("--task <id>", "apply: which race entrant to keep (race-<agent>)")
+        .action(async (runId, opts) => {
+        const client = await ensureDaemon();
+        const project = await currentProject(client);
+        try {
+            const out = await client.orchestraAction(project.id, runId, action, action === "apply" && opts.task ? { task: opts.task } : undefined);
+            if (action === "apply")
+                console.log(`${pc.green("✓")} merged ${pc.bold(String(out.merged))} into ${pc.bold(String(out.into))}`);
+            else
+                console.log(`${pc.green("✓")} ${action} ${runId}`);
+        }
+        catch (err) {
+            console.error(pc.red(err instanceof Error ? err.message : String(err)));
+            process.exitCode = 1;
+        }
+    });
+}
+program
+    .command("orchestra:reply <runId> <text>")
+    .description("answer the orchestrator's question, or steer a running orchestra")
+    .action(async (runId, text) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    try {
+        await client.orchestraAction(project.id, runId, "reply", { text });
+        console.log(`${pc.green("✓")} sent to the orchestrator`);
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
+});
+// ── Loom Teams (docs/teams-architecture.md, daemon/team.ts) ──
+program
+    .command("hub")
+    .description("run a self-hosted Team Hub for your team (no Supabase needed)")
+    .option("--port <n>", "port", "7430")
+    .option("--host <ip>", "interface to bind (use your LAN/tailnet IP so teammates can reach it)", "127.0.0.1")
+    .option("--secret <s>", "join secret every member must present (or LOOM_HUB_SECRET)")
+    .action(async (opts) => {
+    const secret = opts.secret || process.env.LOOM_HUB_SECRET;
+    const loopback = opts.host === "127.0.0.1" || opts.host === "localhost";
+    if (!loopback && !secret) {
+        console.error(pc.red("a hub reachable by others needs a join secret: --secret <s> (or LOOM_HUB_SECRET)"));
+        process.exitCode = 1;
+        return;
+    }
+    const { startHubServer } = await import("../hub/server.js");
+    const hub = await startHubServer({ port: Number(opts.port), host: opts.host, ...(secret ? { secret } : {}) });
+    console.log(`${pc.green("●")} Loom Team Hub on ${pc.bold(hub.url)}`);
+    console.log(pc.dim(`  members sign in with: loom team signin ${hub.url}${secret ? " --secret <secret>" : ""}`));
+    console.log(pc.dim("  state is in memory: members' daemons re-join on their own after a restart"));
+    const stop = async () => {
+        await hub.close();
+        process.exit(0);
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+});
+function printTeam(t) {
+    if (!t.signedIn) {
+        console.log(pc.dim("not on a team hub — `loom team signin <hub-url>`, or join with an invite link"));
+        return;
+    }
+    console.log(`${pc.bold(String(t.github))} on ${pc.dim(String(t.hub))}`);
+    const teams = t.teams ?? [];
+    if (!teams.length)
+        console.log(pc.dim("  no teams yet — `loom team create <name>` or `loom team join <link>`"));
+    for (const tm of teams) {
+        const members = tm.members ?? [];
+        console.log(`\n${pc.magenta("◆")} ${pc.bold(String(tm.name))} ${pc.dim(`(${String(tm.role)} · key v${String(tm.keyVersion)})`)}`);
+        console.log(`  members  ${members.map((m) => (m.role === "owner" ? `${m.github}★` : m.github)).join(", ")}`);
+        console.log(`  repos    ${(tm.repos ?? []).join(", ") || pc.dim("none shared yet — `loom team share` in a project")}`);
+        const presence = tm.presence ?? [];
+        if (presence.length)
+            console.log("  live");
+        for (const p of presence) {
+            const intent = (p.intent ?? {});
+            const what = intent.task ? `${intent.task} ${pc.dim(`(${intent.goal ?? ""})`)}` : intent.goal ?? intent.thread ?? "";
+            const touches = p.touches ?? [];
+            console.log(`    ${pc.cyan(String(p.github).padEnd(12))} ${String(p.agent).padEnd(22)} ${String(p.state).padEnd(10)} ${what}` +
+                (touches.length ? pc.dim(`  ${touches.slice(0, 3).join(" ")}`) : ""));
+        }
+        const leases = (tm.leases ?? []).filter((l) => !l.stale);
+        if (leases.length)
+            console.log("  leases");
+        for (const l of leases) {
+            const intent = (l.intent ?? {});
+            const globs = (l.globs ?? []).slice(0, 3).join(" ");
+            console.log(`    ${pc.cyan(String(l.github).padEnd(12))} ${String(l.runId)}/${String(l.taskId)} ${pc.dim(String(l.state).padEnd(8))} ${globs}` +
+                (intent.task ? pc.dim(`  ${intent.task}`) : ""));
+        }
+        const feed = (tm.feed ?? []).slice(-8);
+        if (feed.length)
+            console.log("  recent");
+        for (const e of feed) {
+            const c = (e.content ?? {});
+            const meta = (e.meta ?? {});
+            const label = c.goal ?? c.title ?? (meta.number ? `#${String(meta.number)}` : "");
+            const detail = label || String(meta.repo ?? (meta.version ? `v${String(meta.version)}` : ""));
+            // membership events are posted by the hub itself; the person is in meta
+            const who = String(e.github ?? meta.github ?? (String(e.type).startsWith("pr_") || String(e.type).startsWith("check_") ? "github" : "team"));
+            console.log(`    ${pc.dim(new Date(Number(e.ts)).toLocaleTimeString())} ${who.padEnd(10)} ${String(e.type).padEnd(14)} ${detail}`);
+        }
+    }
+}
+program
+    .command("invite")
+    .description("invite a teammate to this project: one link sets up the team, the repo, their agents and your crews")
+    .option("--team <id>", "which team, when you're in several")
+    .option("--no-grant", "don't give them push access to the repo when they join")
+    .option("--paste", "hosted sign-in without a local browser")
+    .action(async (opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const invite = () => client.inviteTeammate(project.id, { ...(opts.team ? { teamId: opts.team } : {}), ...(opts.grant === false ? { grant: false } : {}) });
+    let out;
+    try {
+        out = await invite();
+    }
+    catch (err) {
+        if (!/sign in to a team hub/.test(err.message))
+            throw err;
+        // not on a hub yet: the hosted one, with GitHub, then try again
+        const { hostedHubUrl, hostedSupabaseUrl, publishableKeyFor } = await import("../core/hosted.js");
+        const supabaseUrl = hostedSupabaseUrl("hosted");
+        const session = await hostedSession(supabaseUrl, publishableKeyFor(supabaseUrl), Boolean(opts.paste));
+        await client.teamAction("signin", { hub: hostedHubUrl(supabaseUrl), token: session.refreshToken });
+        out = await invite();
+    }
+    console.log(`${pc.green("✓")} ${pc.bold(out.repo)} on ${pc.bold(out.team.name)} — send this to your teammate:\n`);
+    console.log(`  ${pc.cyan(out.link)}\n`);
+    qrcode.generate(out.link, { small: true });
+    console.log(pc.dim(`  one click: GitHub sign-in, the team, the repo, their agents${out.grant ? ", push access" : ""} and your crews`));
+    if (out.grantNote)
+        console.log(pc.yellow(`  ${out.grantNote}`));
+    console.log(pc.dim(`  works once, until ${new Date(out.expiresAt).toLocaleString()} · it carries the team key — send it like a password`));
+    console.log(pc.dim("  no Loom yet on their side? the link shows the one command that installs it and joins"));
+});
+program
+    .command("join <link>")
+    .description("join a team from an invite link: sign in, clone the repo, open it with your agents, set up the crews")
+    .option("--into <dir>", "clone here (default ~/loom-projects/<repo>)")
+    .option("--github <login>", "your GitHub login, for a self-hosted hub")
+    .option("--secret <s>", "a self-hosted hub's join secret")
+    .option("--paste", "hosted sign-in without a local browser")
+    .option("--no-open", "don't open the project in the browser after")
+    .action(async (link, opts) => {
+    const client = await ensureDaemon();
+    const p = await client.previewInvite(link);
+    console.log(`${pc.bold(p.team ?? "a Loom team")}${p.repo ? ` · ${p.repo}` : ""}${p.from ? pc.dim(` — from @${p.from}`) : ""}`);
+    let token;
+    if (!p.signedIn) {
+        const { hostedSupabaseUrl, publishableKeyFor } = await import("../core/hosted.js");
+        const sb = hostedSupabaseUrl(p.hub);
+        if (sb !== null)
+            token = (await hostedSession(sb, publishableKeyFor(sb), Boolean(opts.paste))).refreshToken;
+    }
+    let { job } = await client.startJoin({
+        link,
+        dir: process.cwd(),
+        ...(opts.into ? { into: opts.into } : {}),
+        ...(opts.github ? { github: opts.github } : {}),
+        ...(opts.secret ? { secret: opts.secret } : {}),
+        ...(token ? { token } : {}),
+    });
+    const said = new Map();
+    const mark = { done: pc.green("✓"), skipped: pc.dim("·"), failed: pc.red("✗"), waiting: pc.yellow("…"), running: pc.cyan("→") };
+    for (;;) {
+        for (const s of job.steps) {
+            const line = `${s.state}|${s.detail ?? ""}`;
+            if (s.state === "pending" || said.get(s.id) === line)
+                continue;
+            said.set(s.id, line);
+            if (s.state === "running" && !s.detail)
+                continue;
+            console.log(`  ${mark[s.state] ?? " "} ${s.label}${s.detail ? pc.dim(` — ${s.detail}`) : ""}`);
+        }
+        if (job.state !== "running")
+            break;
+        await new Promise((r) => setTimeout(r, 400));
+        job = (await client.joinStatus(job.id)).job;
+    }
+    if (job.state === "failed") {
+        console.error(pc.red(`couldn't finish: ${job.error}`));
+        console.error(pc.dim("  run the same command again once it's fixed — finished steps are skipped"));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(`\n${pc.green("✓")} you're in${job.project ? ` — ${pc.bold(job.project.name)} at ${job.project.dir}` : ""}`);
+    if (job.project) {
+        console.log(pc.dim(`  cd ${job.project.dir} && loom`));
+        if (opts.open !== false) {
+            const url = `${client.baseUrl}/app#p/${job.project.id}`;
+            const { spawn: sp } = await import("node:child_process");
+            const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+            sp(opener, [url], { detached: true, stdio: "ignore" }).on("error", () => { }).unref();
+        }
+    }
+});
+program
+    .command("proof")
+    .description("is \"done\" true? check the newest finished turn: its claims, what it ran, and the tests again in a clean checkout")
+    .option("--chat <id>", "which chat (default: main)")
+    .option("--test <command>", "test with this instead of the project's own command")
+    .action(async (opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    process.stdout.write(pc.dim("checking… (it runs the tests again, so it takes as long as they do)\n"));
+    const r = await client.proof(project.id, { ...(opts.chat ? { chat: opts.chat } : {}), ...(opts.test ? { testCommand: opts.test } : {}) });
+    const mark = r.verdict === "verified" ? pc.green("✓ verified") : r.verdict === "contradicted" ? pc.red("✗ didn't hold") : pc.yellow("? unverified");
+    console.log(`${mark}  ${r.headline}`);
+    for (const c of r.claims ?? [])
+        console.log(`  ${c.status === "supported" ? pc.green("●") : c.status === "contradicted" ? pc.red("●") : pc.dim("●")} “${c.text}” ${pc.dim(`— ${c.why}`)}`);
+    if (r.rerun) {
+        console.log(pc.dim(`  ${r.rerun.command} · exit ${r.rerun.exitCode ?? "?"} · ${(r.rerun.ms / 1000).toFixed(1)}s${r.rerun.clean === false ? " · in place" : " · clean checkout"}`));
+        if (!r.rerun.ok)
+            console.log(pc.dim(String(r.rerun.tail).split("\n").slice(-12).map((l) => `    ${l}`).join("\n")));
+    }
+    if (r.verdict === "contradicted")
+        process.exitCode = 1;
+});
+const SHIFT_MARK = {
+    verified: (s) => pc.green(s), done: (s) => s, didnt_hold: (s) => pc.red(s), failed: (s) => pc.red(s),
+    needs_you: (s) => pc.yellow(s), not_started: (s) => pc.dim(s), running: (s) => pc.dim(s),
+};
+const SHIFT_WORD = { verified: "verified", done: "done", didnt_hold: "didn't hold", failed: "failed", needs_you: "needs you", not_started: "not started", running: "running" };
+const shiftLine = (t) => {
+    const why = t.question ? `asks: ${t.question}` : t.error ?? t.headline ?? "";
+    return `  ${(SHIFT_MARK[t.status] ?? ((x) => x))(String(SHIFT_WORD[t.status] ?? t.status).padEnd(11))} ${t.text}${why ? pc.dim(` — ${why}`) : ""}`;
+};
+program
+    .command("shift [tasks...]")
+    .description("Night Shift: run these tasks one after another while you're away, a chat each, then one report. No tasks: show the running shift or the last report")
+    .option("--to <agent>", "who takes them (default: the router picks)")
+    .option("--until <time>", "start no new task after this (7:00, 6:30am, an ISO time)")
+    .option("--max <usd>", "stop starting new tasks once the shift has spent this")
+    .option("--file <path>", "read the tasks from a file, one per line")
+    .option("--stop", "stop the running shift: the current task finishes, then the report")
+    .action(async (tasks, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    if (opts.stop) {
+        await client.stopShift(project.id);
+        console.log("night shift stopping — no new tasks start; the report follows the one running");
+        return;
+    }
+    const list = [...(tasks ?? []), ...(opts.file ? fs.readFileSync(opts.file, "utf8").split("\n") : [])].map((t) => t.trim()).filter(Boolean);
+    if (list.length) {
+        const r = await client.startShift(project.id, { tasks: list, ...(opts.to ? { to: opts.to } : {}), ...(opts.until ? { until: opts.until } : {}), ...(opts.max ? { maxUsd: Number(opts.max) } : {}) });
+        console.log(`🌙 night shift started — ${r.shift.tasks.length} task${r.shift.tasks.length === 1 ? "" : "s"}${opts.to ? ` for ${opts.to}` : ""}. \`loom shift\` shows how it's going; the report lands in the thread and on your phone.`);
+        return;
+    }
+    const s = await client.shift(project.id);
+    if (s.active) {
+        console.log(`🌙 night shift running${s.shift.stopped ? pc.yellow(` (stopping: ${s.shift.stopped})`) : ""}`);
+        for (const t of s.tasks)
+            console.log(shiftLine(t));
+    }
+    else if (s.last) {
+        console.log(`🌙 last night shift: ${s.last.summary}${s.last.stopped ? pc.dim(` — stopped: ${s.last.stopped}`) : ""}`);
+        for (const t of s.last.tasks)
+            console.log(shiftLine(t));
+    }
+    else
+        console.log(pc.dim("no night shift yet — `loom shift \"task one\" \"task two\" --to codex --until 7:00`"));
+});
+program
+    .command("crew [action] [args...]")
+    .description("Agent Teams: status | create | goal | say | approve | pause | stop | resume | pick | refresh | budget | overlap | deliver | apply | diff | remove")
+    .option("--crew <id>", "which crew, when the project has several")
+    .option("--to <teammate>", "say: to one teammate")
+    .option("--no-approval", "create: the Lead's plan starts without your OK")
+    .option("--play <play>", "ship, fanout or race")
+    .option("--parallel <n>", "create: maximum concurrent builders (1–4)")
+    .option("--amount <usd>", "budget: new goal budget in USD")
+    .option("--card <id>", "overlap: held card id")
+    .option("--decision <decision>", "overlap: narrow, wait:<goal>, or proceed:<reason>")
+    .option("--touches <globs>", "overlap: comma-separated revised paths")
+    .action(async (action, args, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const a = (action ?? "status").toLowerCase();
+    const words = (args ?? []).join(" ").trim();
+    const { crews, templates } = await client.crews(project.id);
+    if (a === "create") {
+        const [first, ...rest] = args ?? [];
+        const template = first && templates.includes(first.toLowerCase()) ? first.toLowerCase() : "ship";
+        const name = (first && templates.includes(first.toLowerCase()) ? rest : args ?? []).join(" ");
+        const { crew } = await client.createCrew(project.id, { template, ...(name ? { name } : {}), ...(opts.approval === false ? { planApproval: false } : {}),
+            ...(opts.play ? { play: opts.play } : {}), ...(opts.parallel ? { maxParallel: Number(opts.parallel) } : {}) });
+        console.log(`${pc.green("✓")} ${pc.bold(crew.name)} (${crew.id}) — ${crew.teammates.map((t) => `${t.id}=${t.agent}`).join(", ")}`);
+        console.log(pc.dim(`  give it a goal: loom crew goal "…"${crews.length ? ` --crew ${crew.id}` : ""}`));
+        return;
+    }
+    if (!crews.length) {
+        console.log(pc.dim(`no crews here yet — loom crew create [${templates.join("|")}] [name]`));
+        return;
+    }
+    const crew = opts.crew ? crews.find((c) => c.id === opts.crew || c.name === opts.crew) : crews.length === 1 ? crews[0] : undefined;
+    if (!crew)
+        throw new Error(`which crew? --crew ${crews.map((c) => c.id).join(" | ")}`);
+    if (a === "status") {
+        for (const c of opts.crew ? [crew] : crews)
+            printCrew(c);
+        return;
+    }
+    if (a === "diff") {
+        const out = await client.crewDiff(project.id, crew.id);
+        process.stdout.write(out.diff || pc.dim("no changes yet\n"));
+        return;
+    }
+    if (a === "remove") {
+        await client.removeCrew(project.id, crew.id);
+        console.log(`${pc.green("✓")} removed ${crew.name}`);
+        return;
+    }
+    if ((a === "goal" || a === "say") && !words)
+        throw new Error(`loom crew ${a} "<text>"`);
+    const out = await client.crewAction(project.id, crew.id, a, { ...(words ? { text: words } : {}), ...(opts.to ? { to: opts.to } : {}), ...(opts.play ? { play: opts.play } : {}),
+        ...(opts.amount ? { amount: Number(opts.amount) } : {}), ...(opts.card ? { card: opts.card } : {}), ...(opts.decision ? { decision: opts.decision } : {}),
+        ...(opts.touches ? { touches: opts.touches.split(",").map(s => s.trim()).filter(Boolean) } : {}) });
+    if (a === "say")
+        console.log(`${pc.green("✓")} ${out.routed === "goal" ? "new goal" : out.routed === "answer" ? "answered" : out.routed === "replan" ? "the Lead replans with that" : `noted for ${out.to}`}`);
+    else if (a === "apply")
+        console.log(`${pc.green("✓")} merged ${pc.bold(out.merged)} into ${pc.bold(out.into)}`);
+    else
+        printCrew(out.crew);
+});
+function printCrew(c) {
+    const g = c.state?.goal;
+    console.log(`${pc.bold(c.name)} ${pc.dim(`(${c.id})`)}${c.busy ? pc.cyan(" working") : ""}`);
+    console.log(`  ${c.teammates.map((t) => `${t.id}${pc.dim(`:${t.role}=${t.agent}`)}`).join("  ")}`);
+    if (!g)
+        return void console.log(pc.dim("  no goal yet — loom crew goal \"…\""));
+    const color = g.status === "completed" ? pc.green : g.status === "failed" ? pc.red : g.status.startsWith("waiting") || g.status === "awaiting_approval" ? pc.yellow : pc.cyan;
+    console.log(`  ${color(g.status)} ${g.text.split("\n")[0].slice(0, 80)} ${pc.dim(g.branch)}`);
+    for (const card of g.cards ?? []) {
+        const m = card.stage === "done" ? pc.green("✓") : card.stage === "failed" ? pc.red("✗") : card.stage === "planned" ? pc.dim("·") : pc.cyan("→");
+        console.log(`   ${m} ${card.title}${card.builder ? pc.dim(` ${card.builder}`) : ""}${card.stage !== "done" && card.stage !== "planned" ? pc.dim(` [${card.stage}]`) : ""}${card.error ? pc.red(` ${card.error.slice(0, 80)}`) : ""}`);
+    }
+    if (g.question)
+        console.log(pc.yellow(`  ${g.question.teammate} asks: ${g.question.text}`) + pc.dim("  (loom crew say \"…\")"));
+    if (g.status === "awaiting_approval")
+        console.log(pc.dim("  loom crew approve — or loom crew say \"…\" to change the plan"));
+    if (g.status === "completed" && !g.applied)
+        console.log(pc.dim("  loom crew apply — merge it into your branch · loom crew diff"));
+    if (g.summary && g.status === "completed")
+        console.log(`  ${g.summary.split("\n")[0].slice(0, 120)}`);
+}
+program
+    .command("team [action] [args...]")
+    .description("Loom Teams: status | signin [hub] | create <name> | invite | join <link> | share | unshare | brain [inbox|promote|resolve|correct|trust|private] | landing | doctor [fix] | adopt <pr> | deploys | release-notes <since> | webhook [--repo r] [--install] | remove <github> | leave")
+    .option("--github <login>", "your GitHub login (defaults to the gh CLI's)")
+    .option("--repo <owner/name>", "webhook: which repo (defaults to this project's)")
+    .option("--install", "webhook: create it on the repo with gh (needs repo admin)")
+    .option("--rotate", "webhook: replace the secret (update the repo's webhook after)")
+    .option("--secret <s>", "the hub's join secret")
+    .option("--team <id>", "which team, when you're in several")
+    .option("--paste", "hosted sign-in without a local browser: open the link anywhere, paste back where you land")
+    .action(async (action, args, opts) => {
+    const client = await ensureDaemon();
+    const a = (action ?? "status").toLowerCase();
+    const arg = args?.[0];
+    const extra = { ...(opts.github ? { github: opts.github } : {}), ...(opts.secret ? { secret: opts.secret } : {}), ...(opts.team ? { teamId: opts.team } : {}) };
+    try {
+        if (a === "status")
+            return void printTeam(await client.team());
+        if (a === "signin") {
+            const { hostedHubUrl, hostedSupabaseUrl, publishableKeyFor } = await import("../core/hosted.js");
+            const supabaseUrl = hostedSupabaseUrl(arg);
+            if (supabaseUrl !== null) {
+                // The hosted hub: GitHub sign-in in the browser, run here (it can take
+                // minutes); the daemon only receives the resulting session.
+                const session = await hostedSession(supabaseUrl, publishableKeyFor(supabaseUrl), Boolean(opts.paste));
+                const out = await client.teamAction("signin", { hub: hostedHubUrl(supabaseUrl), token: session.refreshToken, ...extra });
+                return void printTeam(out.team);
+            }
+            const out = await client.teamAction("signin", { hub: arg, ...extra });
+            return void printTeam(out.team);
+        }
+        if (a === "create") {
+            if (!arg)
+                throw new Error("name it: loom team create <name>");
+            const out = await client.teamAction("create", { name: arg });
+            console.log(`${pc.green("✓")} created ${pc.bold(String(out.result.name))} — you're its owner`);
+            console.log(pc.dim("  invite teammates: loom team invite · share this project: loom team share"));
+            return;
+        }
+        if (a === "invite") {
+            const out = await client.teamAction("invite", extra);
+            const { link, expiresAt } = out.result;
+            console.log(`${pc.bold("invite link")} ${pc.dim(`(single use, until ${new Date(expiresAt).toLocaleString()})`)}\n\n  ${link}\n`);
+            console.log(pc.yellow("  it carries the team key — send it like a password"));
+            qrcode.generate(link, { small: true });
+            return;
+        }
+        if (a === "join") {
+            if (!arg)
+                throw new Error("paste the invite: loom team join '<link>'");
+            const out = await client.teamAction("join", { link: arg, ...extra });
+            console.log(`${pc.green("✓")} joined ${pc.bold(String(out.result.name))}`);
+            return void printTeam(out.team);
+        }
+        if (a === "share" || a === "unshare") {
+            const project = await currentProject(client);
+            if (a === "share") {
+                const out = await client.shareProject(project.id, opts.team);
+                console.log(`${pc.green("✓")} ${pc.bold(out.repo)} is shared — teammates see this project's agents and goals`);
+            }
+            else {
+                await client.unshareProject(project.id);
+                console.log(`${pc.green("✓")} ${project.name} is private — nothing from it reaches the team`);
+            }
+            return;
+        }
+        if (a === "remove") {
+            if (!arg)
+                throw new Error("who? loom team remove <github-login>");
+            const st = await client.team();
+            const teams = st.teams ?? [];
+            const team = opts.team ? teams.find((t) => t.id === opts.team) : teams[0];
+            const m = team?.members.find((x) => x.github === arg.toLowerCase());
+            if (!team || !m)
+                throw new Error(`no member "${arg}"`);
+            const out = await client.teamAction("remove", { userId: m.id, teamId: team.id });
+            console.log(`${pc.green("✓")} removed ${arg}; team key rotated to v${String(out.result.keyVersion)}`);
+            return;
+        }
+        if (a === "brain") {
+            // loom team brain [inbox|sync|promote <id,id>|resolve <winner> --loser <id>|trust <id>|private <id>]
+            const project = await currentProject(client);
+            const sub = (arg ?? "").toLowerCase();
+            const rest = (args ?? []).slice(1);
+            let view;
+            if (!sub || sub === "inbox" || sub === "status")
+                view = await client.teamBrain(project.id, { sync: true });
+            else if (sub === "sync")
+                view = await client.teamBrainAction(project.id, "sync");
+            else if (sub === "promote") {
+                if (!rest[0])
+                    throw new Error("which memories? loom team brain promote <id>[,<id>…]");
+                const out = await client.teamBrainAction(project.id, "promote", { ids: rest[0].split(",") });
+                const r = out.result;
+                console.log(`${pc.green("✓")} ${r.added ? `proposed ${r.added} as canon on ${r.branch}` : "already canon"}${r.prUrl ? ` — ${r.prUrl}` : ""}`);
+                if (r.note)
+                    console.log(pc.yellow(`  ${r.note}`));
+                return;
+            }
+            else if (sub === "resolve" || sub === "merge") {
+                if (!rest[0] || !rest[1])
+                    throw new Error(`loom team brain ${sub} <keep-id> <drop-id> [reason]`);
+                view = await client.teamBrainAction(project.id, "resolve", { winner: rest[0], loser: rest[1], reason: rest.slice(2).join(" ") || sub });
+            }
+            else if (sub === "correct") {
+                if (!rest[0] || !rest[1])
+                    throw new Error("loom team brain correct <id> <the corrected sentence>");
+                view = await client.teamBrainAction(project.id, "correct", { id: rest[0], text: rest.slice(1).join(" ") });
+            }
+            else if (sub === "trust" || sub === "private") {
+                if (!rest[0])
+                    throw new Error(`loom team brain ${sub} <id>`);
+                view = await client.teamBrainAction(project.id, sub, { id: rest[0] });
+            }
+            else
+                throw new Error(`unknown brain action "${sub}" — inbox, sync, promote, resolve, merge, correct, trust, private`);
+            const st = view.status;
+            if (!st.shared)
+                return void console.log(pc.dim("this project isn't shared with a team — `loom team share`"));
+            console.log(`${pc.bold("team brain")}  ${String(st.repo)}  ${pc.dim(`${String(st.canon)} canon · ${String(st.team)} team · ${String(st.confirmed)} confirmed · ${String(st.mine)} yours`)}`);
+            if (st.lastError)
+                console.log(pc.red(`  ${String(st.lastError)}`));
+            const tag = { canon: pc.green("canon"), confirmed: pc.cyan("confirmed"), own: pc.dim("yours"), proposed: pc.yellow("proposed") };
+            for (const m of view.memories.slice(0, 40)) {
+                console.log(`  ${(tag[m.tier] ?? m.tier).padEnd(20)} ${m.text}${m.author && !m.mine ? pc.dim(`  — ${m.author}`) : ""}  ${pc.dim(m.id)}`);
+            }
+            if (view.inbox.length) {
+                console.log(`\n${pc.bold("inbox")} ${pc.dim(`(${view.inbox.length})`)}`);
+                for (const i of view.inbox) {
+                    console.log(`  ${pc.magenta(i.type.padEnd(13))} ${i.detail}`);
+                    console.log(`    ${pc.dim(i.a.id)} ${i.a.text}`);
+                    if (i.b)
+                        console.log(`    ${pc.dim(i.b.id)} ${i.b.text}`);
+                }
+            }
+            return;
+        }
+        if (a === "release-notes" || a === "deploys") {
+            const project = await currentProject(client);
+            if (a === "release-notes") {
+                if (!arg)
+                    throw new Error("since which tag? loom team release-notes v1.2.0");
+                process.stdout.write((await client.releaseNotes(project.id, arg)).markdown);
+                return;
+            }
+            const { deployments } = await client.deploys(project.id);
+            if (!deployments.length)
+                return void console.log(pc.dim("no deployments on this repo"));
+            for (const d of deployments) {
+                const st = String(d.state);
+                const col = st === "success" ? pc.green : st === "failure" || st === "error" ? pc.red : pc.yellow;
+                console.log(`  ${col(st.padEnd(12))} ${String(d.environment).padEnd(14)} ${String(d.sha).slice(0, 8)}  ${pc.dim(String(d.url ?? ""))}`);
+            }
+            return;
+        }
+        if (a === "landing" || a === "doctor" || a === "adopt") {
+            const project = await currentProject(client);
+            if (a === "doctor") {
+                if ((args ?? []).includes("--fix") || arg === "fix") {
+                    const out = await client.teamDoctorFix(project.id);
+                    console.log(out.prUrl ? `${pc.green("✓")} opened ${out.prUrl} (${out.files.join(", ")})` : pc.dim("nothing to fix in the workflows"));
+                    return;
+                }
+                const d = await client.teamDoctor(project.id);
+                console.log(`${pc.bold("landing doctor")}  ${d.repo ?? pc.dim("(no GitHub repo)")} · ${d.branch}`);
+                const icon = { ok: pc.green("✓"), warn: pc.yellow("!"), error: pc.red("✗") };
+                for (const f of d.findings) {
+                    console.log(`  ${icon[f.level] ?? "·"} ${f.what}`);
+                    if (f.fix)
+                        console.log(pc.dim(`      ${f.fix}`));
+                }
+                if (d.fixable.length)
+                    console.log(pc.dim(`\n  loom team doctor fix — opens a PR adding merge_group to ${d.fixable.join(", ")}`));
+                return;
+            }
+            if (a === "adopt") {
+                const pr = Number(String(arg ?? "").replace(/^#/, ""));
+                if (!pr)
+                    throw new Error("which PR? loom team adopt <number>");
+                const out = await client.landingAction(project.id, "adopt", { pr });
+                console.log(`${pc.green("✓")} adopted PR #${pr} — goal ${String(out.result.id)} is making it green; it's handed back when it is`);
+                return;
+            }
+            const v = await client.landing(project.id, { poll: true });
+            if (!v.goals.length && !v.adoptable.length)
+                return void console.log(pc.dim("no goal PRs in flight"));
+            for (const g of v.goals) {
+                const l = g.landing;
+                const col = l.state === "green" || l.state === "merged" ? pc.green : l.state === "needs_human" || l.state === "failing" ? pc.red : pc.yellow;
+                console.log(`  ${col(l.state.padEnd(12))} #${l.pr}  ${String(g.goal)}  ${pc.dim(`${String(g.runId)} · fixes ${l.fixAttempts} · $${Number(g.costUsd ?? 0).toFixed(2)}`)}`);
+                if (l.checks?.failing.length)
+                    console.log(pc.red(`      failing: ${l.checks.failing.join(", ")}`));
+                if (l.review)
+                    console.log(pc.dim(`      review: ${l.review.state}${l.review.high ? ` (${l.review.high} high)` : ""}`));
+                if (l.reason)
+                    console.log(pc.yellow(`      ${l.reason}`));
+            }
+            if (v.adoptable.length) {
+                console.log(`\n${pc.bold("needs someone")}`);
+                for (const p of v.adoptable)
+                    console.log(`  #${String(p.pr)} ${String(p.owner)} — ${String(p.reason)}  ${pc.dim(`loom team adopt ${String(p.pr)}`)}`);
+            }
+            return;
+        }
+        if (a === "webhook") {
+            // Phase 6 (D83): GitHub events pushed to the hub instead of polled
+            const project = await currentProject(client).catch(() => null);
+            const out = await client.teamAction("webhook", {
+                ...extra,
+                ...(opts.repo ? { repo: opts.repo } : {}),
+                ...(project ? { projectId: project.id } : {}),
+                ...(opts.install ? { install: "1" } : {}),
+                ...(opts.rotate ? { rotate: "1" } : {}),
+            });
+            const w = out.result;
+            console.log(`${pc.bold("payload URL")}   ${w.url}`);
+            console.log(`${pc.bold("secret")}        ${w.secret}  ${pc.yellow("(treat it like a password)")}`);
+            console.log(`${pc.bold("content type")}  application/json`);
+            console.log(`${pc.bold("events")}        ${w.events.join(", ")}`);
+            if (w.warning)
+                console.log(pc.yellow(`  ${w.warning}`));
+            if (w.installed)
+                console.log(`${pc.green("✓")} webhook created on ${w.installed.repo}${w.installed.id ? pc.dim(` (id ${w.installed.id})`) : ""}`);
+            else
+                console.log(pc.dim(`\n  install it: loom team webhook --install${w.repo ? ` --repo ${w.repo}` : " --repo owner/name"}  (or GitHub → Settings → Webhooks)`));
+            return;
+        }
+        if (a === "leave") {
+            await client.teamAction("leave", extra);
+            console.log(`${pc.green("✓")} left the team`);
+            return;
+        }
+        throw new Error(`unknown action "${a}"`);
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
+});
+program
+    .command("runner [action] [args...]")
+    .description("Loom runners: status | pair | join <link> | start | stop | token <PAT> | doctor | install | revoke <device> | goal \"<goal>\" | move <runId> | back <runId> | jobs | exec")
+    .option("--github <login>", "your GitHub login (self-hosted hub)")
+    .option("--secret <s>", "the self-hosted hub's join secret")
+    .option("--token <refresh>", "hosted hub: a session refresh token (from the paste-the-URL sign-in)")
+    .option("--shared", "take teammates' goals too (when their repo's policy allows)")
+    .option("--runner <id>", "which runner (device id or label)")
+    .option("--job <id>", "exec: the claimed job to run")
+    .option("--team <id>", "exec: the job's team")
+    .option("--browser", "join: sign in with a local browser instead of pasting the address back")
+    .action(async (action, args, opts) => {
+    const a = (action ?? "status").toLowerCase();
+    const arg = args?.[0];
+    try {
+        if (a === "install") {
+            const loomBin = fileURLToPath(new URL("./index.js", import.meta.url));
+            const f = serviceFile({ platform: process.platform, home: os.homedir(), node: process.execPath, loom: loomBin, ...(process.env.LOOM_HOME ? { loomHome: process.env.LOOM_HOME } : {}), ...(process.env.APPDATA ? { appData: process.env.APPDATA } : {}) });
+            fs.mkdirSync(path.dirname(f.path), { recursive: true });
+            // Windows Script Host reads Unicode reliably as UTF-16 with a BOM.
+            fs.writeFileSync(f.path, process.platform === "win32" ? Buffer.from("\uFEFF" + f.content, "utf16le") : f.content);
+            console.log(`${pc.green("✓")} wrote ${f.path}`);
+            for (const cmd of f.enable) {
+                await new Promise((resolve, reject) => spawn(cmd[0], cmd.slice(1), { stdio: "inherit" })
+                    .on("error", reject).on("exit", (code) => code === 0 ? resolve() : reject(new Error(`${cmd[0]} failed (exit ${code})`))));
+            }
+            console.log(pc.dim(process.platform === "win32"
+                ? "  the daemon now starts at login; `loom runner status` to check, `loom up` to restart after a failure"
+                : "  the daemon now starts at login and restarts if it stops; `loom runner status` to check"));
+            return;
+        }
+        if (a === "token") {
+            if (!arg)
+                throw new Error("paste a fine-grained PAT: loom runner token github_pat_…");
+            writeRunnerToken(arg);
+            console.log(`${pc.green("✓")} saved (0600, ${path.join(loomHome(), "runner-token")}) — it never goes through the hub. Check it: loom runner doctor`);
+            return;
+        }
+        if (a === "exec") {
+            // Inside a runner's container: run one claimed job, then exit (D70).
+            if (!opts.job || !opts.team)
+                throw new Error("runner exec needs --job and --team");
+            const daemon = new LoomDaemon({ host: "127.0.0.1", port: 0, runnerExec: { teamId: opts.team, jobId: opts.job, done: (ok) => process.exit(ok ? 0 : 1) } });
+            await daemon.listen();
+            return;
+        }
+        const client = await ensureDaemon();
+        if (a === "status") {
+            const s = await client.runner();
+            const c = s.config;
+            console.log(`runner  ${s.running ? pc.green("running") : c?.enabled ? pc.yellow("enabled, not running") : pc.dim("off")}${c ? pc.dim(`  · ${c.shared ? "shared" : "personal"} · ${c.capacity ?? 1} at a time · isolation ${c.isolation ?? "auto"}`) : ""}`);
+            for (const j of s.active ?? [])
+                console.log(`  ${String(j.kind).padEnd(9)} ${String(j.repo)}  ${pc.dim(`${String(j.owner)} · job ${String(j.jobId)}${j.runId ? ` · goal ${String(j.runId)}` : ""}`)}`);
+            if (!s.token)
+                console.log(pc.dim("  no runner token — `loom runner token <PAT>` (see `loom runner doctor`)"));
+            if (s.lastError)
+                console.log(pc.red(`  ${String(s.lastError)}`));
+            return;
+        }
+        if (a === "pair") {
+            const out = await client.runnerAction("pair");
+            const { link } = out.result;
+            console.log(`${pc.bold("runner pairing link")} — on the box: ${pc.cyan("loom runner join '<link>'")}\n\n  ${link}\n`);
+            console.log(pc.yellow("  it carries your team keys — send it like a password, to a machine you control"));
+            return;
+        }
+        if (a === "join") {
+            if (!arg)
+                throw new Error("paste the link from `loom runner pair`");
+            let token = opts.token;
+            if (!token && !opts.secret) {
+                // A hosted hub: sign in as yourself here (a runner box usually has no browser — D74).
+                const hubUrl = (() => {
+                    try {
+                        return String(JSON.parse(Buffer.from(arg.replace(/^loom-runner:/, ""), "base64url").toString("utf8")).hub ?? "");
+                    }
+                    catch {
+                        return "";
+                    }
+                })();
+                const { hostedSupabaseUrl, publishableKeyFor } = await import("../core/hosted.js");
+                const sbUrl = hostedSupabaseUrl(hubUrl);
+                if (sbUrl !== null)
+                    token = (await hostedSession(sbUrl, publishableKeyFor(sbUrl), !opts.browser)).refreshToken;
+            }
+            const out = await client.runnerAction("join", { link: arg, ...(opts.github ? { github: opts.github } : {}), ...(opts.secret ? { secret: opts.secret } : {}), ...(token ? { token } : {}), ...(opts.shared ? { shared: true } : {}) });
+            console.log(`${pc.green("✓")} this machine is now a runner`, pc.dim(JSON.stringify(out.result.registered ?? {})));
+            console.log(pc.dim("  keep it running: loom runner install · check it: loom runner doctor"));
+            return;
+        }
+        if (a === "start" || a === "stop") {
+            await client.runnerAction(a, a === "start" && opts.shared ? { shared: true } : {});
+            console.log(`${pc.green("✓")} runner ${a === "start" ? "started" : "stopped"}`);
+            return;
+        }
+        if (a === "revoke") {
+            if (!arg)
+                throw new Error("which runner device? see `loom runner jobs`");
+            await client.runnerAction("revoke", { deviceId: arg });
+            console.log(`${pc.green("✓")} revoked ${arg}; team keys rotated`);
+            return;
+        }
+        if (a === "doctor") {
+            const token = readRunnerToken();
+            const repos = {};
+            let scopes = [];
+            if (token) {
+                const env = { ...process.env, GH_TOKEN: token };
+                const run = (argv) => new Promise((resolve) => {
+                    const p = spawn("gh", argv, { env });
+                    let out = "";
+                    p.stdout.on("data", (d) => (out += String(d)));
+                    p.on("exit", () => resolve(out));
+                    p.on("error", () => resolve(""));
+                });
+                const head = await run(["api", "-i", "user"]);
+                scopes = (/^x-oauth-scopes:\s*(.*)$/im.exec(head)?.[1] ?? "").split(",").map((x) => x.trim()).filter(Boolean);
+                const team = await client.team();
+                for (const t of team.teams ?? []) {
+                    for (const r of t.repos) {
+                        try {
+                            repos[r] = JSON.parse(await run(["api", `repos/${r}`])).permissions ?? null;
+                        }
+                        catch {
+                            repos[r] = null;
+                        }
+                    }
+                }
+            }
+            const s = await client.runner();
+            const items = [
+                ...(s.running ? [{ level: "ok", what: "runner is running" }] : [{ level: "warn", what: "runner isn't running", fix: "loom runner start" }]),
+                ...tokenFindings({ present: Boolean(token), scopes, repos }),
+            ];
+            const icon = { ok: pc.green("✓"), warn: pc.yellow("!"), error: pc.red("✗") };
+            for (const f of items) {
+                console.log(`  ${icon[f.level]} ${f.what}`);
+                if ("fix" in f && f.fix)
+                    console.log(pc.dim(`      ${f.fix}`));
+            }
+            return;
+        }
+        const project = await currentProject(client);
+        if (a === "goal") {
+            const goal = (args ?? []).join(" ").trim();
+            if (!goal)
+                throw new Error('what\'s the goal? loom runner goal "Add rate limiting"');
+            const out = await client.runnersAction(project.id, "start", { goal, ...(opts.runner ? { runner: opts.runner } : {}) });
+            console.log(`${pc.green("✓")} queued for your runner — job ${String(out.result.jobId)}; watch it: loom runner jobs`);
+            return;
+        }
+        if (a === "move" || a === "back") {
+            if (!arg)
+                throw new Error(`which goal? loom runner ${a} <runId>`);
+            const out = await client.runnersAction(project.id, a === "move" ? "continue" : "bring-back", { runId: arg, ...(opts.runner ? { runner: opts.runner } : {}) });
+            console.log(`${pc.green("✓")} ${a === "move" ? "moving the goal to your runner" : "asked the runner to hand it back"} — job ${String(out.result.jobId)}`);
+            return;
+        }
+        if (a === "jobs") {
+            const v = await client.runners(project.id);
+            for (const r of v.runners)
+                console.log(`  ${r.online ? pc.green("●") : pc.dim("○")} ${String(r.label)}  ${pc.dim(`${String(r.github)} · ${r.kinds.join(", ")}${r.shared ? " · shared" : ""} · ${String(r.deviceId)}`)}`);
+            if (!v.runners.length)
+                console.log(pc.dim("  no runners — `loom runner pair`, then `loom runner join <link>` on an always-on box"));
+            for (const j of v.jobs.slice(-15)) {
+                const p = j.progress;
+                console.log(`  ${String(j.state).padEnd(9)} ${String(j.kind).padEnd(8)} ${String(j.goal || j.runId || "")}  ${pc.dim(`${p?.status ?? ""}${p?.tasks ? ` · ${p.tasks.length} tasks` : ""}${p?.costUsd ? ` · $${p.costUsd}` : ""}${j.error ? ` · ${String(j.error)}` : ""}`)}`);
+            }
             return;
         }
+        throw new Error(`unknown runner action "${a}"`);
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
     }
-    fail("daemon did not become healthy — try `loom daemon` in the foreground");
 });
 program
-    .command("down")
-    .description("stop the background daemon")
-    .action(async () => {
-    if (await stopDaemon())
-        console.log(pc.green("✓ daemon stopped"));
-    else
-        console.log(pc.dim("no running daemon found"));
+    .command("land [runId]")
+    .description("land a goal's PR: fresh main in, fast tests, push, merge when GitHub's rules pass (Loom Teams D56)")
+    .action(async (runId) => {
+    const client = await ensureDaemon();
+    try {
+        const project = await currentProject(client);
+        let id = runId;
+        if (!id) {
+            const v = await client.landing(project.id);
+            const ready = v.goals.filter((g) => !["merged", "closed"].includes(String(g.landing.state)));
+            if (ready.length !== 1)
+                throw new Error(ready.length ? `several goals have PRs — say which: ${ready.map((g) => String(g.runId)).join(", ")}` : "no goal PR to land");
+            id = String(ready[0].runId);
+        }
+        const out = await client.landingAction(project.id, "land", { runId: id });
+        const l = out.result;
+        console.log(l.state === "landing" ? `${pc.green("✓")} PR #${l.pr} will merge when its checks and approvals pass` : `PR #${l.pr}: ${l.state}${l.reason ? ` — ${l.reason}` : ""}`);
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
 });
+// ── Loom Cloud: reach this daemon from any network (daemon/relay.ts) ──
 program
-    .command("status")
-    .description("daemon health and project board")
+    .command("cloud [action]")
+    .description("Loom Cloud relay: status | enable | disable | rotate — reach your agents from anywhere, end-to-end encrypted")
+    .option("--url <supabaseUrl>", "Supabase project URL (or LOOM_SUPABASE_URL)")
+    .option("--key <anonKey>", "Supabase anon key (or LOOM_SUPABASE_ANON_KEY)")
+    .action(async (action, opts) => {
+    const client = await ensureDaemon();
+    try {
+        const a = (action ?? "status").toLowerCase();
+        let s;
+        if (a === "status")
+            s = await client.cloud();
+        else if (a === "enable" || a === "disable" || a === "rotate") {
+            s = await client.cloudAction(a, {
+                ...(opts.url ? { supabaseUrl: opts.url } : {}),
+                ...(opts.key ? { anonKey: opts.key } : {}),
+            });
+        }
+        else
+            throw new Error(`unknown action "${a}" — status, enable, disable or rotate`);
+        const on = s.connected ? pc.green("connected") : s.enabled ? pc.yellow("enabled, not connected") : pc.dim("off");
+        console.log(`Loom Cloud  ${on}${s.supabaseUrl ? pc.dim(`  via ${String(s.supabaseUrl)}`) : ""}`);
+        if (s.connected)
+            console.log(pc.dim(`  ${String(s.clients)} phone(s) on the relay · end-to-end encrypted — Supabase relays ciphertext only`));
+        if (s.error)
+            console.log(pc.red(`  ${String(s.error)}`));
+        if (!s.configured)
+            console.log(pc.dim("  set a Supabase project: loom cloud enable --url https://<ref>.supabase.co --key <anon key>"));
+        if (a === "enable" && s.connected)
+            console.log(pc.dim("  pair a phone with `loom pair` — its QR now works from any network"));
+        if (a === "rotate")
+            console.log(pc.dim("  new key minted — phones paired through the cloud must pair again"));
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
+});
+program
+    .command("subtasks")
+    .description("subtasks running right now")
     .action(async () => {
-    const cfg = await daemonRunning();
-    if (!cfg) {
-        console.log(pc.dim("daemon: not running (loom up)"));
-        return;
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const { subtasks } = await client.subtasks(project.id);
+    if (!subtasks.length)
+        return void console.log(pc.dim("nothing running"));
+    for (const s of subtasks) {
+        console.log(`${pc.cyan(s.agentId)} ${pc.dim("for " + s.parent)}  ${s.task.slice(0, 60)}`);
     }
-    console.log(pc.green(`daemon: http://${cfg.host}:${cfg.port}`));
-    const client = new DaemonClient(cfg);
-    const { projects } = await client.listProjects();
-    if (!projects.length)
-        console.log(pc.dim("no projects yet — loom init"));
-    for (const p of projects)
-        console.log(formatProjectRow(p));
 });
-// ---------------------------------------------------------------------------
-// init / projects / agents
-// ---------------------------------------------------------------------------
 program
-    .command("init")
-    .description("make the current directory a Loom project")
-    .option("--name <name>", "project name (default: directory name)")
-    .action(async (opts) => {
+    .command("agents:add <kind>")
+    .description("add an agent session to this project (repeat for a second session of the same kind)")
+    .option("--as <name>", "name this instance (default: the kind, then kind-2, kind-3…)")
+    .option("--role <role>", "what this instance is for, e.g. planner or reviewer")
+    .option("--model <model>", "for --kind model: which model it runs (loom models)")
+    .option("--provider <id>", "for --kind model: which provider (default openrouter)")
+    .option("--tools", "for --kind model: let it read the project (read-only)")
+    .option("--write", "for --kind model: let it write files too (every write asks you first)")
+    .option("--run <list>", 'for --kind model: commands it may run, comma-separated, e.g. "npm test"')
+    .action(async (kind, opts) => {
     const client = await ensureDaemon();
-    const dir = process.cwd();
-    const res = await client.addProject(dir, opts.name);
-    const { project } = await client.project(res.project.id);
-    console.log(pc.green(`✓ project "${project.name}" (${project.id})`));
-    for (const a of project.agents)
-        console.log(formatAgentRow(a));
-    console.log(pc.dim("\nedit .loom/config.json to add/remove agents or change roles"));
-    console.log(pc.dim("then: loom chat"));
+    const project = await currentProject(client);
+    // A model agent with no model refuses every turn, so it's set here rather
+    // than in a second step nobody mentions.
+    const allowed = (opts.run ?? "").split(",").map((c) => c.trim()).filter(Boolean);
+    // Writing and running are read-and-then-some: neither is reachable at all
+    // without --tools, so asking for one without it is a mistake worth naming.
+    if ((opts.write || allowed.length) && !opts.tools) {
+        fail("--write and --run need --tools as well — they're the writing half of it");
+    }
+    const options = {
+        ...(opts.model ? { model: opts.model } : {}),
+        ...(opts.provider ? { provider: opts.provider } : {}),
+        ...(opts.tools ? { tools: true } : {}),
+        ...(opts.write ? { write: true } : {}),
+        ...(allowed.length ? { run: allowed } : {}),
+    };
+    if (kind === "model" && !opts.model) {
+        fail('a model agent needs a model: --model "<id>" (see loom models)');
+    }
+    try {
+        const added = await client.addAgent(project.id, kind, {
+            ...opts,
+            ...(Object.keys(options).length ? { options } : {}),
+        });
+        const siblings = project.agents.filter((a) => a.kind === kind).length;
+        console.log(`${pc.green("+")} ${pc.bold(added.id)} ${pc.dim(`(${added.kind} · ${added.role})`)}` +
+            (siblings ? pc.dim(`  — session ${siblings + 1} of ${kind}, sharing this project's brain`) : ""));
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
 });
 program
-    .command("projects")
-    .description("board of all projects")
-    .action(async () => {
+    .command("agents:rm <agentId>")
+    .description("remove an agent session from this project")
+    .action(async (agentId) => {
     const client = await ensureDaemon();
-    const { projects } = await client.listProjects();
-    if (!projects.length)
-        console.log(pc.dim("no projects yet — loom init"));
-    for (const p of projects)
-        console.log(formatProjectRow(p));
+    const project = await currentProject(client);
+    try {
+        await client.removeAgent(project.id, agentId);
+        console.log(`${pc.red("-")} ${agentId} removed`);
+    }
+    catch (err) {
+        console.error(pc.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
 });
 program
-    .command("agents")
-    .description("agents in the current project")
-    .action(async () => {
+    .command("agents:available")
+    .description("which agents this machine can drive, and how many sessions are here")
+    .option("--json", "print as JSON")
+    .action(async (opts) => {
     const client = await ensureDaemon();
     const project = await currentProject(client);
-    for (const a of project.agents)
-        console.log(formatAgentRow(a));
+    const { ades } = await client.availableAgents(project.id);
+    if (opts.json)
+        return void console.log(JSON.stringify(ades, null, 2));
+    for (const a of ades) {
+        const state = a.installed === false
+            ? pc.dim("not installed")
+            : a.instances
+                ? pc.green(`${a.instances} session${a.instances === 1 ? "" : "s"} here`)
+                : pc.dim("available");
+        console.log(`${a.kind.padEnd(18)} ${a.label.padEnd(20)} ${state}`);
+    }
+});
+program
+    .command("models [agentId]")
+    .description("with an agent: the models it reports. Without: what every configured provider has")
+    .option("--provider <id>", "just this provider")
+    .option("--refresh", "ask again instead of trusting the cache")
+    .option("--free", "only the ones that cost nothing")
+    .action(async (agentId, opts) => {
+    // An agent named means "what can THIS agent run" — a CLI reports its own.
+    if (agentId) {
+        const client = await ensureDaemon();
+        const project = await currentProject(client);
+        const { kind, models } = await client.models(project.id, agentId);
+        if (!models.length) {
+            console.log(pc.dim(`${agentId} (${kind}) reports no selectable models`));
+            return;
+        }
+        console.log(pc.bold(`${agentId} (${kind}) · ${models.length} model${models.length === 1 ? "" : "s"}`));
+        for (const model of models)
+            console.log(model);
+        return;
+    }
+    // No agent: the provider catalogue, which needs no daemon and no project.
+    const refresh = Boolean(opts.refresh);
+    let models;
+    let errors = [];
+    if (opts.provider) {
+        const p = resolveProvider(opts.provider);
+        if (!p)
+            fail(`no provider "${opts.provider}" — loom providers`);
+        const got = await fetchModels(p, refresh ? { refresh: true } : {});
+        models = got.models;
+        if (got.error)
+            errors = [{ provider: p.id, error: got.error }];
+    }
+    else {
+        const got = await allModels(refresh ? { refresh: true } : {});
+        models = got.models;
+        errors = got.errors;
+    }
+    const shown = opts.free ? models.filter((m) => m.free) : models;
+    if (!shown.length)
+        console.log(pc.dim("no models — configure a provider with loom providers:set"));
+    for (const m of shown) {
+        console.log(`${pc.bold(m.id)} ${pc.dim(m.provider)}${m.free ? " " + pc.green("free") : ""}` +
+            (m.endpoints ? pc.dim(`  [${m.endpoints.join(", ")}]`) : ""));
+    }
+    for (const e of errors)
+        console.log(pc.yellow(`⚠ ${e.provider}: ${e.error}`));
 });
 // ---------------------------------------------------------------------------
 // send / chat / handoff / interrupt / decision / log
@@ -385,6 +2437,339 @@ program
     const { interrupted } = await client.interrupt(project.id);
     console.log(pc.dim(interrupted ? `interrupted ${interrupted}` : "nothing running"));
 });
+program
+    .command("digest")
+    .description("what happened in this project while you were away")
+    .option("--since <hours>", "how far back to look, in hours", "12")
+    .action(async (opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const hours = Math.max(0.1, Number(opts.since) || 12);
+    const d = await client.digest(project.id, Date.now() - hours * 3_600_000);
+    if (!d.lines.length) {
+        console.log(pc.dim(`nothing in the last ${hours} hour${hours === 1 ? "" : "s"}`));
+        return;
+    }
+    const paint = {
+        question: pc.yellow,
+        failed: pc.red,
+        landed: pc.green,
+        goal: pc.cyan,
+        server: pc.red,
+        cost: pc.dim,
+        turn: pc.dim,
+    };
+    for (const line of d.lines) {
+        const when = new Date(line.at).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+        console.log(`${pc.dim(when)}  ${(paint[line.kind] ?? ((x) => x))(line.text)}`);
+    }
+    if (d.waiting.length)
+        console.log(pc.yellow(`\nwaiting on you: ${d.waiting.join(", ")}`));
+});
+/**
+ * The project's dev servers — the thing the Browser tab previews.
+ *
+ * `loom servers` says what each one is doing, and "running" means a port
+ * answered rather than a process existing. Starting and stopping are explicit:
+ * nothing here runs a command because it guessed you wanted it.
+ */
+const serversCmd = program
+    .command("servers")
+    .description("this project's dev servers: what they are and what they're doing")
+    .action(async () => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const { servers, suggested } = await client.servers(project.id);
+    if (!servers.length) {
+        console.log(pc.dim("no servers configured for this project"));
+        if (suggested.length) {
+            console.log(pc.dim("package.json suggests:"));
+            for (const s of suggested)
+                console.log(`  ${pc.cyan(s.name.padEnd(10))} ${s.command}${s.port ? pc.dim(`  :${s.port}`) : ""}`);
+            console.log(pc.dim('add them under "servers" in .loom/config.json'));
+        }
+        return;
+    }
+    const paint = (s) => s.state === "running" ? pc.green("running") : s.state === "starting" ? pc.yellow("starting") : s.state === "crashed" ? pc.red("crashed") : pc.dim("stopped");
+    for (const s of servers) {
+        const up = s.startedAt ? pc.dim(` up ${Math.max(1, Math.round((Date.now() - s.startedAt) / 1000))}s`) : "";
+        const why = s.state === "crashed" && s.exitCode !== null ? pc.dim(` (exit ${s.exitCode})`) : "";
+        console.log(`${pc.cyan(s.name.padEnd(12))} ${paint(s).padEnd(18)} ${s.port ? pc.dim(":" + s.port) : ""}${up}${why}`);
+        console.log(`${" ".repeat(13)}${pc.dim(s.command)}`);
+    }
+});
+for (const action of ["start", "stop", "restart"]) {
+    serversCmd
+        .command(`${action} <name>`)
+        .description(`${action} a dev server`)
+        .action(async (name) => {
+        const client = await ensureDaemon();
+        const project = await currentProject(client);
+        const { server } = await client.serverAction(project.id, name, action);
+        console.log(pc.dim(`${server.name}: ${server.state}${server.port ? ` on :${server.port}` : ""}`));
+    });
+}
+serversCmd
+    .command("logs <name>")
+    .description("a dev server's recent output")
+    .option("-n, --lines <n>", "how many lines", "80")
+    .action(async (name, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const { lines } = await client.serverLog(project.id, name, Math.max(1, Number(opts.lines) || 80));
+    for (const l of lines) {
+        const mark = l.stream === "err" ? pc.red("!") : l.stream === "loom" ? pc.dim("\u00b7") : " ";
+        console.log(`${mark} ${l.text}`);
+    }
+    if (!lines.length)
+        console.log(pc.dim("nothing yet"));
+});
+/**
+ * Is there a newer Loom, and fetch it.
+ *
+ * `--check` only looks. Without it, the update runs the same commands the
+ * daemon would print: a checkout pulls and rebuilds, a global install
+ * reinstalls itself, and anything else is told where the release is rather
+ * than having a command guessed at and run over it.
+ */
+program
+    .command("update")
+    .description("check for a newer Loom and install it")
+    .option("--check", "only say whether an update exists")
+    .option("--yes", "don't ask before updating")
+    .action(async (opts) => {
+    const client = await ensureDaemon();
+    const u = await client.updates(true);
+    console.log(`installed ${u.version}${u.latest ? `   latest ${u.latest}` : ""}   ${pc.dim(u.install)}`);
+    if (!u.behindRelease) {
+        console.log(pc.dim(u.latest ? "up to date" : "no published release to compare with"));
+        if (u.git?.behind)
+            console.log(pc.yellow(`the checkout is ${u.git.behind} commit(s) behind ${u.git.branch}`));
+        return;
+    }
+    console.log(pc.yellow(`Loom ${u.latest} is out`) + (u.release?.url ? pc.dim(`  ${u.release.url}`) : ""));
+    if (opts.check)
+        return;
+    if (!u.canApply) {
+        console.log(pc.dim(u.refusal ?? "this install can't update itself"));
+        return;
+    }
+    console.log("this will run:");
+    for (const step of u.steps)
+        console.log(`  ${pc.cyan(step)}`);
+    if (!opts.yes) {
+        const ok = await confirm("update now?");
+        if (!ok)
+            return console.log(pc.dim("left as it is"));
+    }
+    await client.applyUpdate();
+    console.log(pc.dim("updating — the daemon restarts on the new build when it finishes (loom log -f to watch)"));
+});
+/**
+ * The prompt queue: what you've lined up for this project, run one at a time.
+ *
+ * `loom queue` shows it; `loom queue add` puts one at the back; the rest edit
+ * what's waiting. Positions are what you see in the list (1 is next to run), so
+ * `loom queue rm 2` removes the one printed as 2 — ids work too.
+ */
+const queueCmd = program
+    .command("queue")
+    .description("prompts lined up for this project — see, edit, reorder, pause")
+    .action(async () => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const view = await client.queue(project.id);
+    if (!view.queue.length) {
+        console.log(pc.dim("nothing queued — loom queue add \"…\" puts one in line"));
+        return;
+    }
+    const where = (t) => t.kind === "orchestra" ? "orchestrate" : t.kind === "auto" ? "auto" : t.agentId;
+    view.queue.forEach((item, i) => {
+        const head = `${pc.dim(String(i + 1).padStart(2))} ${pc.cyan(where(item.target).padEnd(12))}`;
+        const lines = item.text.split("\n");
+        console.log(`${head} ${lines[0]}${lines.length > 1 ? pc.dim(` +${lines.length - 1} more lines`) : ""}`);
+        console.log(`${" ".repeat(15)}${pc.dim(item.id + (item.editedAt ? " · edited" : "") + (item.plan ? " · plan mode" : ""))}`);
+    });
+    const note = view.paused ? pc.yellow(view.reason ?? "paused") : view.waitingFor ? pc.dim(view.waitingFor) : pc.dim("next one goes as soon as it can");
+    console.log(`\n${view.queue.length} queued${view.paused ? pc.yellow(" · paused") : ""} · ${note}`);
+});
+/** "15:00", "2026-09-21T03:00", "+90m" — the ways a person says when. */
+function readWhen(when) {
+    const rel = /^\+(\d+)\s*([smhd])$/i.exec(when.trim());
+    if (rel) {
+        const n = Number(rel[1]);
+        const unit = { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[rel[2].toLowerCase()];
+        return Date.now() + n * unit;
+    }
+    const clock = /^(\d{1,2}):(\d{2})$/.exec(when.trim());
+    if (clock) {
+        const d = new Date();
+        d.setHours(Number(clock[1]), Number(clock[2]), 0, 0);
+        // a time already past today means tomorrow — nobody queues for the past
+        if (d.getTime() <= Date.now())
+            d.setDate(d.getDate() + 1);
+        return d.getTime();
+    }
+    const parsed = Date.parse(when);
+    if (Number.isFinite(parsed))
+        return parsed;
+    throw new Error(`I can't read "${when}" as a time — try 15:00, +90m, or 2026-09-21T03:00`);
+}
+/** The item you meant: a position from the printed list, or an id. */
+async function queueItemId(client, projectId, which) {
+    const { queue } = await client.queue(projectId);
+    const n = Number(which);
+    if (Number.isInteger(n) && n >= 1 && n <= queue.length)
+        return queue[n - 1].id;
+    const hit = queue.find((i) => i.id === which);
+    if (!hit)
+        throw new Error(`no queued prompt "${which}" — loom queue lists them`);
+    return hit.id;
+}
+queueCmd
+    .command("add <text...>")
+    .description("line a prompt up behind whatever is running")
+    .option("--to <target>", 'who takes it: an agent id, "orchestrate" for a new goal, or "auto"', "auto")
+    .option("--plan", "queue it in plan mode")
+    .action(async (text, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const target = opts.to === "orchestrate" ? "orchestra" : opts.to;
+    const res = await client.queueAdd(project.id, { text: text.join(" "), target, ...(opts.plan ? { plan: true } : {}) });
+    console.log(pc.dim(`queued ${res.item.id} · ${res.queue.length} waiting`));
+});
+queueCmd
+    .command("edit <which> <text...>")
+    .description("rewrite a queued prompt (by position or id)")
+    .action(async (which, text) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const id = await queueItemId(client, project.id, which);
+    await client.queueEdit(project.id, id, { text: text.join(" ") });
+    console.log(pc.dim(`edited ${id}`));
+});
+queueCmd
+    .command("to <which> <target>")
+    .description('send a waiting prompt somewhere else: an agent id, "orchestrate" or "auto"')
+    .action(async (which, target) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const id = await queueItemId(client, project.id, which);
+    await client.queueEdit(project.id, id, { target: target === "orchestrate" ? "orchestra" : target });
+    console.log(pc.dim(`${id} → ${target}`));
+});
+queueCmd
+    .command("move <which> <position>")
+    .description("move a queued prompt (1 is next to run)")
+    .action(async (which, position) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const id = await queueItemId(client, project.id, which);
+    await client.queueEdit(project.id, id, { to: Math.max(0, Number(position) - 1) });
+    console.log(pc.dim(`moved ${id} to ${position}`));
+});
+queueCmd
+    .command("rm <which>")
+    .description("drop a queued prompt before it runs")
+    .action(async (which) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const id = await queueItemId(client, project.id, which);
+    const res = await client.queueRemove(project.id, id);
+    console.log(pc.dim(`removed ${id} · ${res.queue.length} waiting`));
+});
+queueCmd
+    .command("at <when> <text...>")
+    .description('queue a prompt for later — "15:00", "2026-09-21T03:00", or "+90m"')
+    .option("--to <target>", 'who takes it: an agent id, "orchestrate" or "auto"', "auto")
+    .action(async (when, text, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const at = readWhen(when);
+    const res = await client.queueAdd(project.id, {
+        text: text.join(" "),
+        target: opts.to === "orchestrate" ? "orchestra" : opts.to,
+        when: { kind: "at", at },
+    });
+    console.log(pc.dim(`queued ${res.item.id} for ${new Date(at).toLocaleString()}`));
+});
+queueCmd
+    .command("after <what> <text...>")
+    .description('queue a prompt until a goal lands or its checks go green: "landed:<runId>" or "green:<runId>"')
+    .option("--to <target>", "who takes it", "auto")
+    .action(async (what, text, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const [kind, runId] = what.split(":");
+    if (!runId || (kind !== "landed" && kind !== "green")) {
+        throw new Error('say landed:<runId> or green:<runId> — loom orchestra lists the runs');
+    }
+    const res = await client.queueAdd(project.id, {
+        text: text.join(" "),
+        target: opts.to === "orchestrate" ? "orchestra" : opts.to,
+        when: { kind: kind === "landed" ? "landed" : "checks-green", runId },
+    });
+    console.log(pc.dim(`queued ${res.item.id}, waiting for ${runId}`));
+});
+queueCmd
+    .command("save <name>")
+    .description("save what's queued as a recipe you can run anywhere")
+    .action(async (name) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const { recipe } = await client.saveQueueRecipe(project.id, name);
+    console.log(pc.dim(`saved "${recipe.name}" — ${recipe.steps.length} step(s)`));
+});
+queueCmd
+    .command("run <name>")
+    .description("queue a saved recipe on this project")
+    .action(async (name) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const res = await client.runQueueRecipe(project.id, name);
+    console.log(pc.dim(`queued ${res.added} step(s) — ${res.queue.length} waiting`));
+});
+queueCmd
+    .command("recipes")
+    .description("the recipes saved on this machine")
+    .action(async () => {
+    const client = await ensureDaemon();
+    const { recipes } = await client.recipes();
+    if (!recipes.length)
+        return console.log(pc.dim("none saved — loom queue save <name>"));
+    for (const r of recipes) {
+        console.log(`${pc.cyan(r.name)} ${pc.dim(`${r.steps.length} step(s)${r.fromProject ? ` · from ${r.fromProject}` : ""}`)}`);
+        for (const s of r.steps)
+            console.log(`  ${pc.dim(s.to.padEnd(12))} ${s.text.split("\n")[0].slice(0, 80)}`);
+    }
+});
+queueCmd
+    .command("clear")
+    .description("drop everything that's waiting")
+    .action(async () => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const res = await client.queueClear(project.id);
+    console.log(pc.dim(`dropped ${res.dropped}`));
+});
+queueCmd
+    .command("pause")
+    .description("hold the queue where it is")
+    .action(async () => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    await client.queuePause(project.id, true);
+    console.log(pc.dim("paused — loom queue resume lets it run"));
+});
+queueCmd
+    .command("resume")
+    .description("let the queue run again")
+    .action(async () => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const view = await client.queuePause(project.id, false);
+    console.log(pc.dim(`running · ${view.queue.length} waiting`));
+});
 const memoryCmd = program
     .command("memory")
     .description("the unified brain — one memory across every connected ADE")
@@ -410,9 +2795,23 @@ memoryCmd
 program
     .command("costs")
     .description("what this project has spent, per agent")
-    .action(async () => {
+    .option("--series [days]", "daily breakdown instead of totals (default 14 days)")
+    .action(async (opts) => {
     const client = await ensureDaemon();
     const project = await currentProject(client);
+    if (opts.series) {
+        const days = typeof opts.series === "string" ? Number(opts.series) || 14 : 14;
+        const { series } = await client.costSeries(project.id, days);
+        if (!series.length)
+            return void console.log(pc.dim("no spend in this window"));
+        for (const d of series) {
+            const agents = Object.entries(d.byAgent)
+                .map(([id, a]) => `${id} ${fmtUsd(a.usd)}`)
+                .join("  ");
+            console.log(`${d.day}  ${fmtUsd(d.usd).padStart(9)}  ${String(d.turns).padStart(4)} turns  ${pc.dim(agents)}`);
+        }
+        return;
+    }
     const { costs } = await client.costs(project.id);
     console.log(pc.bold(`${project.name}`) +
         pc.dim(`  total ${fmtUsd(costs.totalUsd)} · ${costs.turns} turns · ${(costs.totalMs / 1000).toFixed(0)}s agent time`));
@@ -491,7 +2890,9 @@ program
         return;
     }
     if (!spec || !words.length) {
-        fail('usage: loom route <name|steps> "<task>"   e.g. loom route planner,executor "add dark mode"\n  (or: loom route --status / --abort)');
+        fail('usage: loom route <name|steps> "<task>"   e.g. loom route planner,executor "add dark mode"\n' +
+            "  a step runs only if the previous turn meets its condition: 'planner,executor,reviewer?lines>200'\n" +
+            "  (or: loom route --status / --abort)");
     }
     const { route } = await client.startRoute(project.id, words.join(" "), spec, {
         ...(opts.router ? { router: opts.router } : {}),
@@ -547,33 +2948,51 @@ program
 program
     .command("doctor")
     .description("diagnose the environment, daemon, and current project")
-    .action(async () => {
-    const { envChecks, projectChecks } = await import("./doctor.js");
-    const checks = await envChecks();
+    .option("--json", "print machine-readable diagnostic results")
+    .option("--fix", "repair what has exactly one safe repair; report the rest")
+    .action(async (opts) => {
+    const { doctorReport, envChecks, projectChecks, fixProject } = await import("./doctor.js");
     const dir = currentProjectDir();
+    if (opts.fix) {
+        if (!dir) {
+            console.error(pc.red("not inside a Loom project — nothing to fix"));
+            process.exitCode = 1;
+            return;
+        }
+        const { fixed, unfixable } = fixProject(dir);
+        for (const f of fixed)
+            console.log(` ${pc.green("✓")} ${f}`);
+        for (const u of unfixable)
+            console.log(` ${pc.yellow("⚠")} ${u}`);
+        if (!fixed.length && !unfixable.length)
+            console.log(pc.dim("nothing needed fixing"));
+        // fall through to a fresh diagnosis, so the report reflects the repairs
+    }
+    const checks = await envChecks();
     if (dir)
         checks.push(...projectChecks(dir));
     else
         checks.push({ name: "project", status: "warn", detail: "not inside a Loom project (loom init)" });
-    let failures = 0;
-    let warnings = 0;
+    const report = doctorReport(checks);
+    if (opts.json) {
+        console.log(JSON.stringify(report));
+        if (report.summary.failures)
+            process.exitCode = 1;
+        return;
+    }
     for (const c of checks) {
         const icon = c.status === "ok" ? pc.green("✓") : c.status === "warn" ? pc.yellow("⚠") : pc.red("✗");
-        if (c.status === "fail")
-            failures++;
-        if (c.status === "warn")
-            warnings++;
         console.log(` ${icon} ${pc.bold(c.name.padEnd(11))} ${c.status === "ok" ? pc.dim(c.detail) : c.detail}`);
     }
-    if (failures) {
-        console.log(pc.red(`\n${failures} problem${failures > 1 ? "s" : ""} found`));
+    if (report.summary.failures) {
+        console.log(pc.red(`\n${report.summary.failures} problem${report.summary.failures > 1 ? "s" : ""} found`));
         process.exit(1);
     }
     // "all clear" over a screen of warnings is a lie, and it's the lie that
     // teaches people to stop reading this command. Nothing is broken; several
     // things aren't set up. Those are different sentences.
-    if (warnings) {
-        console.log(pc.yellow(`\nnothing broken · ${warnings} thing${warnings > 1 ? "s" : ""} not set up (see above)`));
+    if (report.summary.warnings) {
+        console.log(pc.yellow(`\nnothing broken · ${report.summary.warnings} thing${report.summary.warnings > 1 ? "s" : ""} not set up (see above)`));
         return;
     }
     console.log(pc.green("\nall clear"));
@@ -625,15 +3044,160 @@ program
             "  testing on this machine only? loom pair --allow-local"));
         process.exit(1);
     }
-    const { token, expiresAt, url } = await client.newPairingToken();
+    const minted = await client.newPairingToken();
+    const { token, expiresAt, url } = minted;
     // Deep link: scanning with any camera opens the phone app, which claims
     // the (single-use, 10-min) token from the URL fragment and pairs itself.
-    const link = `${url}/app#pair=${token}`;
+    // The daemon's own link carries the Loom Cloud route when Cloud is on, so
+    // a phone paired from the terminal can reach home from any network too.
+    const link = minted.link ?? `${url}/app#pair=${token}`;
     qrcode.generate(link, { small: true }, (qr) => console.log(qr));
     console.log(pc.bold(`  ${link}`));
     console.log(pc.dim(`  scan with your phone camera · single use · expires ${new Date(expiresAt).toLocaleTimeString()}`));
     console.log(pc.dim(`  (manual claim: POST ${url}/api/pair/claim {"token":"${token.slice(0, 6)}…"})`));
 });
+program
+    .command("backup")
+    .description("everything Loom knows — settings, pairings, prompts, every project's log and brain — in one .tar.gz")
+    .option("--out <file>", "where to write it (default: ~/loom-backup-<time>.tar.gz)")
+    .action((opts) => {
+    const r = makeBackup(opts.out);
+    const mb = (r.bytes / 1024 / 1024).toFixed(1);
+    console.log(pc.green(`✓ backed up ${r.projects} project${r.projects === 1 ? "" : "s"} and ~/.loom → ${r.file} (${mb} MB)`));
+    console.log(pc.dim("  left out: orchestra worktrees (their branches are in your repos) and the model cache"));
+    console.log(pc.yellow("  it holds your pairing tokens and cloud keys — keep it somewhere private"));
+});
+program
+    .command("export")
+    .description("write a chat as Markdown — prompts, replies, what was done, what changed")
+    .option("--chat <chat>", "the chat's id or title (default: main)", "main")
+    .option("--out <file>", "write to a file instead of printing")
+    .action(async (opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const { chats } = await client.chats(project.id);
+    const want = opts.chat.trim().toLowerCase();
+    const chat = chats.find((c) => c.id === opts.chat) ?? chats.find((c) => c.title.toLowerCase() === want);
+    if (!chat)
+        fail(`no chat "${opts.chat}" in ${project.name} — try one of: ${chats.map((c) => c.title).join(", ")}`);
+    let events = [];
+    let before;
+    for (let page = 0; page < 20; page++) {
+        const { events: evs } = await client.chatEvents(project.id, chat.id, { ...(before ? { before } : {}), limit: 500 });
+        events = [...evs, ...events];
+        if (evs.length < 500)
+            break;
+        before = evs[0].id;
+    }
+    const md = threadMarkdown(events, `${project.name} — ${chat.title}`);
+    if (!opts.out)
+        return void process.stdout.write(md);
+    fs.writeFileSync(opts.out, md);
+    console.error(pc.green(`✓ ${events.length} events → ${opts.out}`));
+});
+program
+    .command("replay")
+    .description("a chat as one self-contained HTML page to share — prompts, replies, what ran, what changed, what Loom checked")
+    .option("--chat <chat>", "the chat's id or title (default: main)", "main")
+    .option("--out <file>", "where to write it (default: <project>-<chat>.replay.html)")
+    .option("--open", "open it in your browser")
+    .action(async (opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const want = opts.chat.trim().toLowerCase();
+    let chat = { id: "main", title: "Main" };
+    if (want !== "main") {
+        const { chats } = await client.chats(project.id);
+        const found = chats.find((c) => c.id === opts.chat) ?? chats.find((c) => c.title.toLowerCase() === want) ?? chats.find((c) => c.title.toLowerCase().includes(want));
+        if (!found)
+            fail(`no chat "${opts.chat}" in ${project.name} — try one of: ${chats.map((c) => c.title).join(", ")}`);
+        chat = found;
+    }
+    const html = await client.replay(project.id, chat.id);
+    const out = opts.out ?? `${project.name}-${chat.title}`.replace(/[^\w.-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase() + ".replay.html";
+    fs.writeFileSync(out, html);
+    console.log(pc.green(`✓ ${out}`) + pc.dim(` — opens in any browser, nothing to install`));
+    if (opts.open) {
+        const { spawn: sp } = await import("node:child_process");
+        sp(process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open", [out], { detached: true, stdio: "ignore", shell: process.platform === "win32" }).on("error", () => { }).unref();
+    }
+});
+program
+    .command("scorecard")
+    .description("each agent's record here: turns, how often it finished, how often its \"done\" held up when Proof checked, circles, shield trips, and cost per verified result")
+    .option("--days <n>", "only the last n days (default: everything)")
+    .action(async (opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const since = opts.days ? Date.now() - Math.max(1, Number(opts.days) || 1) * 86_400_000 : undefined;
+    const t = await client.turnStats(project.id, { ...(since ? { since } : {}), days: 7 });
+    if (!t.leaderboard.length)
+        return void console.log(pc.dim("no finished turns yet — the scorecard fills in as agents work"));
+    const pct = (x) => (x == null ? "—" : `${Math.round(x * 100)}%`);
+    console.log(pc.bold(`${project.name}${opts.days ? ` · last ${opts.days} days` : ""}`));
+    console.log(pc.dim(`  ${"agent".padEnd(16)}${"turns".padStart(6)}${"finished".padStart(10)}${"held up".padStart(10)}${"circles".padStart(9)}${"shield".padStart(8)}  per verified`));
+    for (const a of t.leaderboard) {
+        const tr = a.trust ?? {};
+        const checked = (tr.verified ?? 0) + (tr.contradicted ?? 0);
+        const held = checked ? `${tr.verified}/${checked}` : "—";
+        const tone = tr.holdRate == null ? (x) => x : tr.holdRate >= 0.9 ? pc.green : tr.holdRate >= 0.7 ? pc.yellow : pc.red;
+        console.log(`  ${String(a.agentId).padEnd(16)}${String(a.turns).padStart(6)}${pct(a.successRate).padStart(10)}${tone(held.padStart(10))}${String(tr.loops ?? 0).padStart(9)}${String(tr.shield ?? 0).padStart(8)}  ${tr.costPerVerifiedUsd != null ? `$${Number(tr.costPerVerifiedUsd).toFixed(2)}` : "—"}`);
+    }
+});
+program
+    .command("stats")
+    .description("today across every project: turns, how many finished cleanly, spend, busiest agent")
+    .option("--days <n>", "look back this many days instead of just today", "1")
+    .action(async (opts) => {
+    const client = await ensureDaemon();
+    const days = Math.max(1, Math.min(90, Number(opts.days) || 1));
+    const since = new Date();
+    since.setHours(0, 0, 0, 0);
+    since.setDate(since.getDate() - (days - 1));
+    const { projects } = await client.listProjects();
+    let turns = 0, errors = 0, cost = 0;
+    const byAgent = new Map();
+    const rows = [];
+    for (const p of projects) {
+        const t = await client.turnStats(p.id, { since: since.getTime(), days: 7 }).catch(() => null);
+        if (!t)
+            continue;
+        const pt = t.leaderboard.reduce((a, x) => a + x.turns, 0);
+        if (!pt)
+            continue;
+        const pe = t.leaderboard.reduce((a, x) => a + x.errors, 0);
+        const pc$ = t.leaderboard.reduce((a, x) => a + x.totalCostUsd, 0);
+        turns += pt;
+        errors += pe;
+        cost += pc$;
+        for (const x of t.leaderboard)
+            byAgent.set(x.agentId, (byAgent.get(x.agentId) ?? 0) + x.turns);
+        rows.push(`  ${pc.bold(p.name.padEnd(18))} ${String(pt).padStart(4)} turns  ${pe ? pc.red(`${pe} failed`) : pc.green("all clean")}  ${fmtUsd(pc$)}`);
+    }
+    const label = days === 1 ? "today" : `the last ${days} days`;
+    if (!turns)
+        return void console.log(pc.dim(`no turns ${label}`));
+    const busiest = [...byAgent.entries()].sort((a, b) => b[1] - a[1])[0];
+    const clean = Math.round(((turns - errors) / turns) * 100);
+    console.log(pc.bold(`${label}: ${turns} turn${turns === 1 ? "" : "s"} · ${clean}% finished cleanly · ${fmtUsd(cost)} · busiest ${busiest[0]} (${busiest[1]})`));
+    for (const r of rows)
+        console.log(r);
+});
+program
+    .command("completion")
+    .description("print a shell completion script: loom completion zsh >> ~/.zshrc (or bash >> ~/.bashrc)")
+    .argument("<shell>", "zsh or bash")
+    .action((shell) => {
+    const names = program.commands.map((c) => c.name()).filter((n) => n && n !== "completion").sort();
+    if (shell === "bash") {
+        console.log(`complete -W "${names.join(" ")} completion" loom`);
+    }
+    else if (shell === "zsh") {
+        console.log(`_loom() { compadd -- ${names.join(" ")} completion; }\ncompdef _loom loom 2>/dev/null || { autoload -Uz compinit && compinit && compdef _loom loom; }`);
+    }
+    else
+        fail(`unknown shell "${shell}" — zsh or bash`);
+});
 program.parseAsync().catch((err) => {
     console.error(pc.red(`✗ ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);