@loompad/cli 1.1.2 → 1.2.1

package/dist/cli/index.js

@@ -26,15 +26,16 @@ import qrcode from "qrcode-terminal";
         process.exit(1);
     }
 }
+import { exitCodeFor, turnOutcome } from "../core/turn-wait.js";
 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, loomHome } from "../core/registry.js";
+import { ensureLoomHome, findProject, loomHome, readDaemonConfig } 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 { allModels, fetchModels, forgetProvider, listProviders, resolveProvider, setProvider, mergeProviderViews, providerOfModel } 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";
@@ -271,6 +272,8 @@ program
     .command("init")
     .description("make the current directory a Loom project")
     .option("--name <name>", "project name (default: directory name)")
+    .option("--gitignore", "add .loom/ to .gitignore without asking")
+    .option("--no-gitignore", "leave .gitignore alone")
     .action(async (opts) => {
     const client = await ensureDaemon();
     const dir = process.cwd();
@@ -279,6 +282,7 @@ program
     console.log(pc.green(`✓ project "${project.name}" (${project.id})`));
     for (const a of project.agents)
         console.log(formatAgentRow(a));
+    await offerGitignore(dir, opts.gitignore);
     console.log(pc.dim("\nedit .loom/config.json to add/remove agents or change roles"));
     console.log(pc.dim("then: loom chat"));
 });
@@ -330,16 +334,36 @@ program
 });
 program
     .command("providers")
-    .description("where model agents send their turns, and whether each has a key")
-    .action(() => {
-    const rows = listProviders();
+    .description("where model agents send their turns, and whether each has a key — as the daemon sees it")
+    .action(async () => {
+    // the daemon makes the calls, so its view is the true one; a key only this shell has is called out (#249)
+    const local = listProviders();
+    const cfg = await daemonRunning();
+    let rows = local;
+    if (cfg) {
+        try {
+            rows = mergeProviderViews((await new DaemonClient(cfg).providers()).providers, local);
+        }
+        catch {
+            console.log(pc.yellow("couldn't ask the daemon — showing this shell's view"));
+        }
+    }
+    else
+        console.log(pc.dim("the daemon isn't running — this is this shell's view; a daemon started elsewhere (the desktop app) may see different keys"));
+    let shellOnly = 0;
     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");
+        const mark = p.configured ? pc.green("\u2713") : p.shellOnly ? pc.yellow("!") : pc.dim("\u00b7");
+        const key = p.configured ? pc.dim(p.hint ? `${p.hint} (${p.source})` : "no key needed")
+            : p.shellOnly ? pc.yellow(`${p.hint} in your shell, not in the daemon`) : 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}`));
+        if (p.shellOnly)
+            shellOnly++;
     }
+    if (shellOnly)
+        console.log(pc.yellow(`\n${shellOnly === 1 ? "a key is" : `${shellOnly} keys are`} set in this shell but not in the daemon, so its calls fail with "no key".`) +
+            pc.dim(`\n    Save it where the daemon reads it: loom providers:set <id> --key …   (or restart the daemon from this shell: loom up --restart)`));
     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" })}`) : "") +
@@ -405,6 +429,18 @@ program
     }
     if (!models.length)
         fail('which models? e.g. loom ask --models "a,b" "your question"');
+    // every provider these models need must have a key in the daemon — check once, before sending any (#258)
+    try {
+        const keyed = new Map((await client.providers()).providers.map((p) => [p.id, p.configured]));
+        const missing = [...new Set(models.map((m) => providerOfModel(m, keyed)))].filter((p) => keyed.has(p) && !keyed.get(p));
+        if (missing.length)
+            fail(`${missing.join(", ")} ${missing.length === 1 ? "has" : "have"} no key in the daemon — nothing was sent. loom providers:set ${missing[0]} --key …  (loom providers shows what the daemon sees)`);
+    }
+    catch (err) {
+        if (err instanceof DaemonError) { /* an older daemon without /api/providers: let the asks say it */ }
+        else
+            throw err;
+    }
     try {
         const { asked } = await client.askModels(project.id, words.join(" "), models, {
             ...(opts.title ? { title: opts.title } : {}),
@@ -1142,6 +1178,182 @@ program
         process.exitCode = 1;
     }
 });
+program
+    .command("review <agents...>")
+    .description("several agents review the same change at once — read-only, off the baton — and their findings land in one place")
+    .option("--file <path>", "review this file")
+    .option("--diff", "review the uncommitted changes (the default)")
+    .option("--text <ask>", "review something you describe instead")
+    .option("--focus <what>", "what to look hardest at, e.g. \"error handling\"")
+    .option("--no-wait", "start it and return; the summary lands in the thread")
+    .option("--json", "print the finished review as JSON")
+    .option("--timeout <seconds>", "stop waiting after this long", "1800")
+    .action(async (agentArgs, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const agents = agentArgs.flatMap((a) => a.split(",")).map((a) => a.trim()).filter(Boolean);
+    let review;
+    try {
+        ({ review } = await client.startReview(project.id, { agents, ...(opts.file ? { file: opts.file } : {}), ...(opts.text ? { text: opts.text } : {}), ...(opts.focus ? { focus: opts.focus } : {}) }));
+    }
+    catch (err) {
+        if (opts.json) {
+            process.exitCode = 1;
+            return void console.log(JSON.stringify({ status: "error", error: err instanceof Error ? err.message : String(err) }));
+        }
+        return fail(err instanceof Error ? err.message : String(err));
+    }
+    if (!opts.json)
+        console.error(pc.cyan(`🔍 ${agents.join(", ")} reviewing ${review.target.kind === "file" ? review.target.file : review.target.kind === "diff" ? "the uncommitted changes" : `“${review.target.label ?? "your request"}”`} · read-only, nobody takes the baton`));
+    if (!opts.wait)
+        return void console.log(pc.dim(`review ${review.reviewId} — the summary lands in its chat (loom reviews ${review.reviewId})`));
+    const deadline = Date.now() + Math.max(1, Number(opts.timeout) || 1800) * 1000;
+    while (review.status !== "done" && Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 1500));
+        review = (await client.review(project.id, review.reviewId)).review;
+    }
+    if (review.status !== "done") {
+        process.exitCode = 124;
+        // valid JSON on every exit path: who has answered so far, and who hasn't (#291)
+        if (opts.json)
+            return void console.log(JSON.stringify({ ...review, status: "timeout", waitingOn: review.agents }));
+        return void console.error(pc.yellow(`still reviewing after ${opts.timeout}s — loom reviews ${review.reviewId} later`));
+    }
+    if (opts.json)
+        return void console.log(JSON.stringify(review));
+    printReview(review);
+});
+program
+    .command("council <goal...>")
+    .description("one planner, several reviewers: plan → backtest → decide → build → prove → forward-test → fix; only the planner writes")
+    .requiredOption("--planner <id>", "the agent that plans, decides and builds")
+    .requiredOption("--reviewers <ids>", "comma-separated agents that test the plan and the diff, read-only")
+    .option("--no-watch", "start it and return; follow it in the app or with loom council:status")
+    .action(async (words, opts) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    let council;
+    try {
+        ({ council } = await client.startCouncil(project.id, { goal: words.join(" "), planner: opts.planner, reviewers: opts.reviewers.split(",").map((r) => r.trim()).filter(Boolean) }));
+    }
+    catch (err) {
+        return fail(err instanceof Error ? err.message : String(err));
+    }
+    console.log(pc.cyan(`🏛 council ${council.councilId}: ${council.planner} plans and builds; ${council.reviewers.join(", ")} review — in its own chat`));
+    if (!opts.watch)
+        return void console.log(pc.dim(`loom council:status ${council.councilId} · loom council:stop`));
+    const shown = new Map();
+    while (true) {
+        council = (await client.council(project.id, council.councilId)).council;
+        for (const st of council.stages) {
+            const key = `${st.status}:${st.detail ?? ""}`;
+            if (st.status === "waiting" || shown.get(st.key) === key)
+                continue;
+            shown.set(st.key, key);
+            console.log(`${councilMark(st.status)} ${pc.bold(st.name.padEnd(13))}${st.detail ? pc.dim(st.detail) : st.status === "running" ? pc.dim("…") : ""}`);
+        }
+        if (council.status !== "running")
+            break;
+        await new Promise((r) => setTimeout(r, 1500));
+    }
+    console.log((council.status === "done" ? pc.green : council.status === "stopped" ? pc.yellow : pc.red)(`\n${council.summary ?? council.status}`));
+    if (council.status === "failed")
+        process.exitCode = 1;
+});
+program
+    .command("council:status [councilId]")
+    .description("where a council is, stage by stage (default: the latest)")
+    .action(async (councilId) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const council = councilId ? (await client.council(project.id, councilId)).council : (await client.councils(project.id)).councils[0];
+    if (!council)
+        return void console.log(pc.dim('no councils yet — loom council "<goal>" --planner <id> --reviewers <ids>'));
+    console.log(pc.bold(`council ${council.councilId}`) + pc.dim(` · ${council.goal} · ${council.planner} → ${council.reviewers.join(", ")}`));
+    for (const st of council.stages)
+        console.log(`${councilMark(st.status)} ${st.name.padEnd(13)}${st.detail ? pc.dim(st.detail) : ""}`);
+    if (council.summary)
+        console.log(pc.dim(`\n${council.summary}`));
+});
+program
+    .command("council:stop")
+    .description("stop the running council after its current stage")
+    .action(async () => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    try {
+        const { council } = await client.stopCouncil(project.id);
+        console.log(pc.yellow(`stopping council ${council.councilId}`));
+    }
+    catch (err) {
+        fail(err instanceof Error ? err.message : String(err));
+    }
+});
+function councilMark(status) {
+    return status === "done" ? pc.green("✓") : status === "running" ? pc.cyan("◐") : status === "failed" ? pc.red("✗") : status === "unverified" ? pc.yellow("?") : status === "skipped" ? pc.dim("–") : pc.dim("·");
+}
+program
+    .command("reviews [reviewId]")
+    .description("the latest reviews, or one review's findings")
+    .action(async (reviewId) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    if (reviewId) {
+        try {
+            return void printReview((await client.review(project.id, reviewId)).review);
+        }
+        catch (err) {
+            return fail(err instanceof Error ? err.message : String(err));
+        }
+    }
+    const { reviews } = await client.reviews(project.id);
+    if (!reviews.length)
+        return void console.log(pc.dim("no reviews yet — loom review <agents…>"));
+    for (const r of reviews) {
+        const open = (r.findings ?? []).filter((f) => !f.decision).length;
+        console.log(`${pc.bold(r.reviewId)}  ${r.status === "done" ? r.summary : pc.yellow("running…")}  ${pc.dim(r.agents.join(", "))}${open ? pc.dim(` · ${open} undecided`) : ""}`);
+    }
+});
+for (const [verb, decision] of [["accept", "accepted"], ["reject", "rejected"]]) {
+    program
+        .command(`review:${verb} <findings...>`)
+        .description(verb === "accept" ? "accept review findings — each becomes a project decision every agent is briefed with" : "reject review findings")
+        .option("--note <why>", "say why")
+        .action(async (ids, opts) => {
+        const client = await ensureDaemon();
+        const project = await currentProject(client);
+        for (const id of ids) {
+            try {
+                const { finding } = await client.decideFinding(project.id, id, decision, opts.note);
+                console.log(`${verb === "accept" ? pc.green("✓ accepted") : pc.red("✕ rejected")} ${pc.dim(id)} ${finding.text.slice(0, 100)}`);
+            }
+            catch (err) {
+                console.error(pc.red(`${id}: ${err instanceof Error ? err.message : String(err)}`));
+                process.exitCode = 1;
+            }
+        }
+    });
+}
+function printReview(review) {
+    if (review.status !== "done")
+        return void console.log(pc.yellow(`review ${review.reviewId} is still running (${review.agents.join(", ")})`));
+    console.log(pc.bold(`review ${review.reviewId}`) + pc.dim(` · ${review.summary}`));
+    const sev = (s) => (s === "high" ? pc.red("high  ") : s === "medium" ? pc.yellow("medium") : pc.dim((s ?? "note").padEnd(6)));
+    for (const f of review.findings ?? []) {
+        const mark = f.decision === "accepted" ? pc.green(" ✓") : f.decision === "rejected" ? pc.red(" ✕") : "";
+        console.log(`  ${sev(f.severity)} ${pc.dim(f.id.padEnd(10))} ${pc.cyan([f.agent, ...(f.agreed ?? []).map((a) => a.agent)].join("+").padEnd(12))} ${f.file ? pc.bold(`${f.file}${f.line ? `:${f.line}` : ""}`) + " — " : ""}${f.text}${mark}`);
+    }
+    for (const r of review.results ?? []) {
+        if (r.edited?.length)
+            console.log(pc.yellow(`  ⚠ ${r.agent} changed files in a read-only review: ${r.edited.join(", ")}`));
+        if (r.status === "failed")
+            console.log(pc.red(`  ✗ ${r.agent} didn't finish: ${r.error}`));
+        else if (!(review.findings ?? []).some((f) => f.agent === r.agent || (f.agreed ?? []).some((a) => a.agent === r.agent)))
+            console.log(pc.dim(`  ${r.agent}: ${r.reply.split("\n").find((l) => l.trim())?.slice(0, 160) ?? "(no reply)"}`));
+    }
+    if ((review.findings ?? []).some((f) => !f.decision))
+        console.log(pc.dim(`\naccept or reject: loom review:accept <id…>  ·  loom review:reject <id…> [--note why]  ·  or on the card in the app`));
+}
 program
     .command("spawn <task>")
     .description("fan a subtask out to a child agent — the parent keeps the baton")
@@ -1597,6 +1809,10 @@ program
     .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("--lead <agent>", "create: who leads")
+    .option("--builders <agents>", "create: comma-separated agents that build")
+    .option("--reviewer <agent>", "create: who reviews")
+    .option("--tester <agent>", "create: who tests")
     .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>")
@@ -1612,7 +1828,10 @@ program
         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) } : {}) });
+            ...(opts.play ? { play: opts.play } : {}), ...(opts.parallel ? { maxParallel: Number(opts.parallel) } : {}),
+            ...(opts.lead || opts.builders || opts.reviewer || opts.tester ? { seats: { ...(opts.lead ? { lead: opts.lead } : {}),
+                    ...(opts.builders ? { builders: opts.builders.split(",").map((x) => x.trim()).filter(Boolean) } : {}),
+                    ...(opts.reviewer ? { reviewer: opts.reviewer } : {}), ...(opts.tester ? { tester: opts.tester } : {}) } } : {}) });
         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;
@@ -1648,6 +1867,8 @@ program
         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 if (a === "budget" && !out.goal?.status?.match(/running|planning|awaiting|waiting|paused/))
+        console.log(`${pc.green("✓")} the next goal starts with a $${Number(opts.amount).toFixed(2)} budget`);
     else
         printCrew(out.crew);
 });
@@ -2295,9 +2516,33 @@ program
 // ---------------------------------------------------------------------------
 // send / chat / handoff / interrupt / decision / log
 // ---------------------------------------------------------------------------
-async function sendWithHandoffConfirm(client, projectId, text, agentId, interactive = true) {
+/** A session this big, resumed cold, is worth a warning before a turn re-reads it (#280). */
+const HEAVY_SESSION = 100_000;
+/**
+ * .loom/ is this machine's runtime state — the event log, attachments, a 0600 config — not something
+ * to commit (a team's shared memory lives in AGENTS.md). In a git repo that doesn't ignore it yet,
+ * offer to (#256).
+ */
+async function offerGitignore(dir, choice) {
+    if (choice === false || !fs.existsSync(path.join(dir, ".git")))
+        return;
     try {
-        return await client.send(projectId, text, agentId);
+        const { execFileSync } = await import("node:child_process");
+        execFileSync("git", ["check-ignore", "-q", ".loom/"], { cwd: dir, stdio: "ignore" });
+        return; // already ignored
+    }
+    catch { /* not ignored (exit 1), or no git: fall through */ }
+    const yes = choice === true || (process.stdin.isTTY && (await confirm(pc.yellow("add .loom/ to .gitignore? it's this machine's state (event log, attachments) — not for the repo"))));
+    if (!yes)
+        return void console.log(pc.dim("tip: .loom/ is local state — add it to .gitignore (loom init --gitignore)"));
+    const file = path.join(dir, ".gitignore");
+    const before = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+    fs.writeFileSync(file, `${before}${before && !before.endsWith("\n") ? "\n" : ""}# Loom's local state (event log, attachments, machine config)\n.loom/\n`);
+    console.log(pc.green("✓ added .loom/ to .gitignore"));
+}
+async function sendWithHandoffConfirm(client, projectId, text, agentId, interactive = true, fresh = false) {
+    try {
+        return await client.send(projectId, text, agentId, { fresh });
     }
     catch (err) {
         if (err instanceof DaemonError && err.status === 409 && agentId) {
@@ -2308,7 +2553,7 @@ async function sendWithHandoffConfirm(client, projectId, text, agentId, interact
             if (!yes)
                 return null;
             await client.handoff(projectId, agentId);
-            return await client.send(projectId, text, agentId);
+            return await client.send(projectId, text, agentId, { fresh });
         }
         throw err;
     }
@@ -2317,12 +2562,61 @@ program
     .command("send <text...>")
     .description("send one message into the shared thread")
     .option("-a, --agent <id>", "address a specific agent (may require a handoff)")
+    .option("--wait", "wait for the turn to end; print the reply and cost; exit 0 done, 1 failed, 2 asked a question, 124 timed out")
+    .option("--json", "with --wait: print the outcome as one JSON object")
+    .option("--timeout <seconds>", "with --wait: give up after this long", "1800")
+    .option("--fresh", "start the agent's session in this chat over — a short question needn't re-read a long one")
     .action(async (words, opts) => {
     const client = await ensureDaemon();
     const project = await currentProject(client);
-    const result = await sendWithHandoffConfirm(client, project.id, words.join(" "), opts.agent);
-    if (result)
-        console.log(pc.dim(`→ sent to ${result.agentId} (loom log --follow to watch)`));
+    // a long session whose prompt cache has gone cold is re-read in full: say so before spending it (#280)
+    const target = opts.agent ?? project.holder ?? undefined;
+    if (!opts.fresh && target) {
+        const weight = await client.sessionWeight(project.id, target).then((r) => r.session).catch(() => null);
+        if (weight && weight.cold && weight.tokens >= HEAVY_SESSION) {
+            const ago = weight.ageMs >= 3_600_000 ? `${Math.round(weight.ageMs / 3_600_000)}h` : `${Math.round(weight.ageMs / 60_000)}m`;
+            console.error(pc.yellow(`⚠ ${target}'s session here is ${Math.round(weight.tokens / 1000)}k tokens, last used ${ago} ago — its cache has likely expired, so this turn re-reads all of it` +
+                `${weight.estUsd !== undefined ? ` (~${fmtUsd(weight.estUsd)} est.)` : ""}. --fresh starts a new session instead.`));
+            if (process.stdin.isTTY && !opts.wait) {
+                const go = await confirm(pc.yellow("send it to the existing session anyway?"));
+                if (!go)
+                    return void console.log(pc.dim(`not sent — loom send --fresh${opts.agent ? ` -a ${opts.agent}` : ""} "…"`));
+            }
+        }
+    }
+    // where the log is now, so the wait reads only what this send causes (#254)
+    const since = opts.wait ? ((await client.events(project.id, undefined, 1)).events.at(-1)?.id ?? 0) : 0;
+    const result = await sendWithHandoffConfirm(client, project.id, words.join(" "), opts.agent, !opts.wait || process.stdin.isTTY, Boolean(opts.fresh));
+    if (!result)
+        return;
+    if (!opts.wait)
+        return void console.log(pc.dim(`→ sent to ${result.agentId} (loom log --follow to watch)`));
+    const deadline = Date.now() + Math.max(1, Number(opts.timeout) || 1800) * 1000;
+    let seen = [], outcome = null, cursor = since;
+    while (Date.now() < deadline && !outcome) {
+        const { events } = await client.events(project.id, cursor, 500);
+        if (events.length) {
+            seen = seen.concat(events);
+            cursor = events.at(-1).id;
+        }
+        outcome = turnOutcome(seen, result.agentId, since);
+        if (!outcome)
+            await new Promise((r) => setTimeout(r, 400));
+    }
+    process.exitCode = exitCodeFor(outcome);
+    if (opts.json)
+        return void console.log(JSON.stringify(outcome ?? { status: "timeout", agent: result.agentId }));
+    if (!outcome)
+        return void console.error(pc.yellow(`timed out after ${opts.timeout}s — ${result.agentId} is still working (loom log --follow)`));
+    if (outcome.reply)
+        console.log(outcome.reply);
+    const tail = [outcome.durationMs ? `${(outcome.durationMs / 1000).toFixed(1)}s` : "", outcome.costUsd ? `$${outcome.costUsd.toFixed(4)}` : ""].filter(Boolean).join(" · ");
+    if (outcome.status === "error")
+        console.error(pc.red(`✗ ${outcome.agent}: ${outcome.error}`));
+    else if (outcome.status === "needs_input")
+        console.error(pc.yellow(`? ${outcome.agent} asks: ${outcome.question}`));
+    else
+        console.error(pc.dim(`✓ ${outcome.agent}${tail ? ` · ${tail}` : ""}`));
 });
 program
     .command("chat")
@@ -2459,9 +2753,14 @@ program
         cost: pc.dim,
         turn: pc.dim,
     };
+    // a stretch that crosses midnight says which day each moment was; the totals row has no moment (#297)
+    const day = (t) => new Date(t).toDateString();
+    const spans = d.lines.some((l) => l.kind !== "cost" && day(l.at) !== day(Date.now()));
+    const stamp = (l) => l.kind === "cost" ? "in all"
+        : `${spans ? `${new Date(l.at).toLocaleDateString([], { month: "short", day: "numeric" })} ` : ""}${new Date(l.at).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}`;
+    const width = Math.max(...d.lines.map((l) => stamp(l).length));
     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)}`);
+        console.log(`${pc.dim(stamp(line).padEnd(width))}  ${(paint[line.kind] ?? ((x) => x))(line.text)}${line.count && line.count > 1 ? pc.dim(` ×${line.count}`) : ""}`);
     }
     if (d.waiting.length)
         console.log(pc.yellow(`\nwaiting on you: ${d.waiting.join(", ")}`));
@@ -2814,10 +3113,13 @@ program
     }
     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`));
+        pc.dim(`  total ${fmtUsd(costs.totalUsd)}${costs.estUsd !== undefined ? ` (+ ~${fmtUsd(costs.estUsd)} est.)` : ""} · ${costs.turns} turns · ${(costs.totalMs / 1000).toFixed(0)}s agent time`));
     for (const a of costs.byAgent) {
-        console.log(`  ${pc.bold(a.agentId.padEnd(14))} ${fmtUsd(a.usd).padStart(9)}  ${String(a.turns).padStart(4)} turns  ${(a.ms / 1000).toFixed(0).padStart(5)}s`);
+        const est = a.estUsd !== undefined ? pc.dim(`  ~${fmtUsd(a.estUsd)} est.`) : !a.usd && a.tokensIn + a.tokensOut ? pc.dim("  no price reported") : "";
+        console.log(`  ${pc.bold(a.agentId.padEnd(14))} ${fmtUsd(a.usd).padStart(9)}  ${String(a.turns).padStart(4)} turns  ${(a.ms / 1000).toFixed(0).padStart(5)}s${est}`);
     }
+    if (costs.estUsd !== undefined)
+        console.log(pc.dim(`  est. = tokens at the model's API price, for agents that report tokens but no cost (a subscription sign-in may bill you differently)`));
     if (!costs.byAgent.length)
         console.log(pc.dim("  no turns recorded yet"));
     console.log(pc.dim("\n(costs come from agents that report them — claude-code and opencode do)"));
@@ -2951,7 +3253,7 @@ program
     .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 { doctorReport, envChecks, projectChecks, fixProject, compareWithDaemon, envFacts } = await import("./doctor.js");
     const dir = currentProjectDir();
     if (opts.fix) {
         if (!dir) {
@@ -2969,10 +3271,28 @@ program
         // fall through to a fresh diagnosis, so the report reflects the repairs
     }
     const checks = await envChecks();
+    checks.push(...(await (await import("./doctor.js")).diskChecks()));
     if (dir)
         checks.push(...projectChecks(dir));
     else
         checks.push({ name: "project", status: "warn", detail: "not inside a Loom project (loom init)" });
+    // The daemon is often the desktop app's, started without this shell's PATH or keys:
+    // ask it what it sees, and say where the two differ. Its provider and free-model
+    // checks run there because its keys are the ones turns use. Never starts a daemon.
+    const dcfg = readDaemonConfig();
+    if (dcfg && checks.some((c) => c.name === "daemon" && !/not responding|never started/.test(c.detail))) {
+        try {
+            const dclient = new DaemonClient(dcfg);
+            const pid = dir ? findProject(dir)?.id : undefined;
+            const theirs = await dclient.doctor(pid);
+            if (theirs.facts)
+                checks.push(...compareWithDaemon({ checks, facts: envFacts() }, { checks: theirs.checks, facts: theirs.facts }));
+            checks.push(...theirs.checks.filter((c) => /^(provider|model):/.test(c.name)));
+        }
+        catch (err) {
+            checks.push({ name: "daemon:env", status: "warn", detail: `couldn't ask the daemon what it sees: ${err instanceof Error ? err.message : String(err)}` });
+        }
+    }
     const report = doctorReport(checks);
     if (opts.json) {
         console.log(JSON.stringify(report));
@@ -2982,7 +3302,7 @@ program
     }
     for (const c of checks) {
         const icon = c.status === "ok" ? pc.green("✓") : c.status === "warn" ? pc.yellow("⚠") : pc.red("✗");
-        console.log(` ${icon} ${pc.bold(c.name.padEnd(11))} ${c.status === "ok" ? pc.dim(c.detail) : c.detail}`);
+        console.log(` ${icon} ${pc.bold(c.name.padEnd(15))} ${c.status === "ok" ? pc.dim(c.detail) : c.detail}`);
     }
     if (report.summary.failures) {
         console.log(pc.red(`\n${report.summary.failures} problem${report.summary.failures > 1 ? "s" : ""} found`));
@@ -2997,6 +3317,23 @@ program
     }
     console.log(pc.green("\nall clear"));
 });
+program
+    .command("orchestra:clean")
+    .description("remove orchestra worktrees left by projects that are no longer registered")
+    .option("--dry-run", "only say what would go")
+    .action(async (opts) => {
+    const { orchestraOrphans, fmtBytes } = await import("./doctor.js");
+    const orphans = await orchestraOrphans();
+    if (!orphans.length)
+        return void console.log(pc.dim("no orphaned orchestra worktrees"));
+    for (const o of orphans) {
+        if (!opts.dryRun)
+            fs.rmSync(o.dir, { recursive: true, force: true });
+        console.log(`${opts.dryRun ? pc.dim("would remove") : pc.green("✓ removed")} ${o.dir} ${pc.dim(fmtBytes(o.bytes))}`);
+    }
+    if (!opts.dryRun)
+        console.log(pc.dim("their branches stay in each repo: git worktree prune there tidies git's own list"));
+});
 program
     .command("clients")
     .description("list paired devices, revoke one, or ping them with a test push")