@loompad/cli 1.2.4 → 1.2.6

package/dist/cli/index.js

@@ -27,7 +27,7 @@ import qrcode from "qrcode-terminal";
     }
 }
 import { exitCodeFor, turnOutcome } from "../core/turn-wait.js";
-import { DaemonClient, DaemonError, daemonRunning, desktopOwnsDaemon, ensureDaemon, stopDaemon, } from "../daemon/client.js";
+import { DaemonClient, DaemonError, daemonRunning, desktopOwnsDaemon, ensureDaemon, stopDaemon, turnsInFlight, } from "../daemon/client.js";
 import { installCrashGuards } from "../daemon/guards.js";
 import { LoomDaemon, DEFAULT_PORT } from "../daemon/server.js";
 import { ensureLoomHome, findProject, loomHome, readDaemonConfig } from "../core/registry.js";
@@ -200,7 +200,7 @@ program
     .description("start the loom daemon in the background")
     .option("--tailnet", "bind to this machine's Tailscale IP", false)
     .option("--restart", "restart even if a daemon is already running", false)
-    .option("--force", "with --restart: replace even Loom Desktop's daemon with this CLI's")
+    .option("--force", "with --restart: replace even Loom Desktop's daemon with this CLI's, and restart even with turns running")
     .action(async (opts) => {
     const running = await daemonRunning();
     if (running && !opts.force && (await desktopOwnsDaemon(running))) {
@@ -218,6 +218,14 @@ program
             console.log(pc.dim("daemon already running (loom up --restart to bounce it)"));
             return;
         }
+        // a restart kills turns in flight: say whose, and leave them be unless told otherwise
+        const busy = opts.force ? [] : await turnsInFlight(new DaemonClient(running));
+        if (busy.length) {
+            console.log(pc.yellow(`${busy.length} turn${busy.length === 1 ? " is" : "s are"} running (${busy.slice(0, 4).join(", ")}${busy.length > 4 ? ", …" : ""}) — ` +
+                `a restart would kill ${busy.length === 1 ? "it" : "them"}. Try again when they finish, or loom up --restart --force.`));
+            process.exitCode = 1;
+            return;
+        }
         console.log(pc.dim(stale ? "daemon is running an older build — restarting" : "restarting daemon"));
         await stopDaemon();
         const gone = Date.now() + 6000;
@@ -274,9 +282,27 @@ program
         return void console.log(JSON.stringify(projects)); // #315
     if (!projects.length)
         console.log(pc.dim("no projects yet — loom init"));
-    for (const p of projects)
-        console.log(formatProjectRow(p));
+    // inside a project, it comes first and says so: "is my turn running here?" is the usual question
+    const here = await resolveCurrentProject(client).catch(() => null);
+    const ordered = here ? [...projects.filter((p) => p.id === here.id), ...projects.filter((p) => p.id !== here.id)] : projects;
+    for (const p of ordered)
+        console.log(formatProjectRow(p) + (here && p.id === here.id ? pc.bold(pc.cyan("  ← here")) : ""));
 });
+/**
+ * Outside a project there's no roster, but the question "what can I run?" still has an
+ * answer: the agents installed on this machine (#feedback: agents outside a project).
+ */
+async function printMachineAgents(json) {
+    const { ADES, detectAdes } = await import("../core/ades.js");
+    const found = await detectAdes();
+    const rows = ADES.map((a) => ({ kind: a.kind, label: a.label, tier: a.tier, installed: a.tier === "adapter" ? Boolean(found[a.kind]) : null }));
+    if (json)
+        return void console.log(JSON.stringify({ project: null, machine: rows }));
+    console.log(pc.dim("not in a Loom project — this machine can drive:"));
+    for (const r of rows)
+        console.log(`  ${r.kind.padEnd(18)} ${r.label.padEnd(20)} ${r.installed === false ? pc.dim("not installed") : r.installed ? pc.green("installed") : pc.dim("app (launch it)")}`);
+    console.log(pc.dim("\nloom init here to make this folder a project with them"));
+}
 // ---------------------------------------------------------------------------
 // init / projects / agents
 // ---------------------------------------------------------------------------
@@ -335,7 +361,10 @@ program
     .option("--json", "print the agent roster as JSON")
     .action(async (opts) => {
     const client = await ensureDaemon();
-    const project = await currentProject(client);
+    const project = await resolveCurrentProject(client).catch((err) => { if (err instanceof NoProjectError)
+        return null; throw err; });
+    if (!project)
+        return void (await printMachineAgents(Boolean(opts.json)));
     if (opts.json) {
         console.log(JSON.stringify(project.agents));
         return;
@@ -1436,11 +1465,34 @@ const TASK_COLOR = {
     needs_input: pc.yellow,
     cancelled: pc.dim,
 };
+/**
+ * A run's tasks by outcome (#342: "completed 9/13" said nothing about the other four — dropped,
+ * merged elsewhere, failed?). Only the non-zero ones, done first.
+ */
+function taskCounts(run) {
+    const order = ["done", "running", "pending", "needs_input", "conflict", "failed", "cancelled"];
+    const n = {};
+    for (const t of run.tasks)
+        n[t.status] = (n[t.status] ?? 0) + 1;
+    return Object.fromEntries(order.filter((k) => n[k]).map((k) => [k, n[k]]).concat(Object.entries(n).filter(([k]) => !order.includes(k))));
+}
+const countsLine = (run) => {
+    const c = taskCounts(run);
+    return Object.keys(c).length ? Object.entries(c).map(([k, v]) => `${v} ${k.replace("_", " ")}`).join(" · ") : "no tasks";
+};
+/** What `loom orchestra --json` says about a run — status is one of OrchestraStatus (#341). */
+function runJson(run) {
+    return {
+        id: run.id, goal: run.goal, status: run.status, ...(run.status === "aborted" && run.interrupted ? { resumable: true } : {}),
+        terminal: isTerminalStatus(run.status), tasks: { total: run.tasks.length, ...taskCounts(run) }, branch: run.branch, costUsd: run.costUsd,
+        ...(run.landing?.pr ? { pr: run.landing.pr } : {}), ...(run.question ? { question: run.question } : {}), createdAt: run.createdAt, updatedAt: run.updatedAt,
+    };
+}
+const isTerminalStatus = (s) => s === "completed" || s === "failed" || s === "aborted" || s === "moved";
 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(runStatus(run))}  race · ${done}/${run.tasks.length} finished · ${fmtUsd(run.costUsd)}`
-        : `${pc.magenta("🎼")} ${pc.bold(run.id)} ${pc.dim(runStatus(run))}  ${done}/${run.tasks.length} tasks · ` +
+        ? `${pc.magenta("🏁")} ${pc.bold(run.id)} ${pc.dim(runStatus(run))}  race · ${countsLine(run)} · ${fmtUsd(run.costUsd)}`
+        : `${pc.magenta("🎼")} ${pc.bold(run.id)} ${pc.dim(runStatus(run))}  ${countsLine(run)} · ` +
             `round ${run.round}/${run.maxRounds} · ${fmtUsd(run.costUsd)} · ${pc.dim(run.branch)}`);
     console.log(`   ${pc.dim("goal")} ${run.goal}`);
     if (run.race)
@@ -1475,6 +1527,58 @@ function printRun(run) {
     if (run.race && run.applied?.task)
         console.log(`   ${pc.green("kept:")} ${run.applied.task} → ${run.applied.into}`);
 }
+/**
+ * #340: wait for a run to end; if it completed, scan everything it changed for secrets, merge it
+ * into the project's current branch, and (asked to) push. Stops at the first thing that's wrong,
+ * and says what — a run that failed, a key in the diff, a merge or push that didn't go.
+ */
+async function waitScanApply(client, projectId, dir, runId, opts) {
+    let run = (await client.orchestraRun(projectId, runId)).run;
+    while (!isTerminalStatus(run.status) && run.status !== "waiting_human") {
+        await new Promise((r) => setTimeout(r, 3000));
+        run = (await client.orchestraRun(projectId, runId)).run;
+    }
+    if (run.status !== "completed")
+        return { ok: false, runId, status: run.status, error: run.status === "waiting_human" ? `it's waiting on you: ${run.question ?? "a question"}` : (run.error ?? run.status) };
+    const { execFileSync } = await import("node:child_process");
+    const git = (...args) => execFileSync("git", args, { cwd: dir, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+    let diff = "";
+    try {
+        diff = git("diff", `${run.baseCommit}..${run.branch}`);
+    }
+    catch (e) {
+        return { ok: false, runId, status: run.status, error: `couldn't read the run's changes: ${e.message.split("\n")[0]}` };
+    }
+    const { findSecrets } = await import("../core/secret-scan.js");
+    const secrets = findSecrets(diff);
+    if (secrets.length)
+        return { ok: false, runId, status: run.status, secrets, error: "secrets in the run's changes — not applied" };
+    let out;
+    try {
+        out = await client.orchestraAction(projectId, runId, "apply");
+    }
+    catch (e) {
+        return { ok: false, runId, status: run.status, error: `merge failed: ${e.message}` };
+    }
+    const res = { ok: true, runId, status: run.status, merged: String(out.merged ?? run.branch), into: String(out.into ?? "") };
+    if (opts.push) {
+        try {
+            git("push", "origin", "HEAD");
+            res.pushed = true;
+        }
+        catch (e) {
+            return { ...res, ok: false, pushed: false, error: `merged, but the push failed: ${e.message.split("\n")[0]}` };
+        }
+    }
+    return res;
+}
+function printApplyResult(r) {
+    if (r.ok)
+        return void console.log(`${pc.green("✓")} ${r.runId} merged into ${pc.bold(r.into || "your branch")}${r.pushed ? " and pushed" : ""} — no secrets in its changes`);
+    console.log(`${pc.red("✗")} ${r.runId} (${r.status}): ${r.error}`);
+    for (const s of r.secrets ?? [])
+        console.log(pc.red(`    ${s.file}${s.line ? `:${s.line}` : ""} — ${s.what}`));
+}
 async function watchRun(client, projectId, runId) {
     let last = "";
     for (;;) {
@@ -1507,6 +1611,8 @@ program
     .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("--solo", "keep every task on this machine, even when teammates' runners could take some")
+    .option("--apply", "when the run completes, scan its changes for secrets and merge it into your branch (#340)")
+    .option("--push", "with --apply: push the branch after merging")
     .option("--no-watch", "start it and return instead of following it to the end")
     .action(async (goal, opts) => {
     const client = await ensureDaemon();
@@ -1532,8 +1638,14 @@ program
                 `${run.workers.join(", ")} (${run.maxParallel} in parallel) on ${pc.dim(run.branch)}`);
         if (opts.watch)
             await watchRun(client, project.id, run.id);
-        else
+        else if (!opts.apply)
             console.log(pc.dim(`  follow it: loom orchestra ${run.id} --watch`));
+        if (opts.apply) {
+            const res = await waitScanApply(client, project.id, project.dir, run.id, { push: Boolean(opts.push) });
+            printApplyResult(res);
+            if (!res.ok)
+                process.exitCode = 1;
+        }
     }
     catch (err) {
         console.error(pc.red(err instanceof Error ? err.message : String(err)));
@@ -1542,24 +1654,41 @@ program
 });
 program
     .command("orchestra [runId]")
-    .description("orchestra runs in this project — or one run in detail")
+    .description("orchestra runs in this project — or one run in detail. Status: starting | planning | running | reviewing | waiting_human | completed | failed | aborted | moved")
     .option("--watch", "follow the run until it finishes")
+    .option("--json", "print runs (or one run) as JSON")
+    .option("--wait", "with a run id: wait until it's completed, failed or aborted (or asks you something); exit 0 completed, 1 failed/aborted, 2 waiting on you")
+    .option("--timeout <seconds>", "with --wait: give up after this long (exit 124)", "7200")
     .action(async (runId, opts) => {
     const client = await ensureDaemon();
     const project = await currentProject(client);
     try {
         if (runId) {
+            if (opts.wait) {
+                // "reviewing" is the orchestrator reading results, not the end (#341) — only these are
+                const deadline = Date.now() + Math.max(1, Number(opts.timeout) || 7200) * 1000;
+                let run = (await client.orchestraRun(project.id, runId)).run;
+                while (!isTerminalStatus(run.status) && run.status !== "waiting_human" && Date.now() < deadline) {
+                    await new Promise((r) => setTimeout(r, 2000));
+                    run = (await client.orchestraRun(project.id, runId)).run;
+                }
+                const done = isTerminalStatus(run.status) || run.status === "waiting_human";
+                process.exitCode = !done ? 124 : run.status === "completed" ? 0 : run.status === "waiting_human" ? 2 : 1;
+                return void (opts.json ? console.log(JSON.stringify(runJson(run))) : printRun(run));
+            }
             if (opts.watch)
                 return void (await watchRun(client, project.id, runId));
-            return void printRun((await client.orchestraRun(project.id, runId)).run);
+            const { run } = await client.orchestraRun(project.id, runId);
+            return void (opts.json ? console.log(JSON.stringify(runJson(run))) : printRun(run));
         }
         const { runs } = await client.orchestraRuns(project.id);
+        if (opts.json)
+            return void console.log(JSON.stringify(runs.map(runJson)));
         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)}  ${runStatus(r).padEnd(13)} ${String(done).padStart(2)}/${String(r.tasks.length).padEnd(2)} ` +
-                `${pc.dim(new Date(r.createdAt).toLocaleString())}  ${r.goal.slice(0, 70)}`);
+            console.log(`${pc.bold(r.id)}  ${runStatus(r).padEnd(13)} ${countsLine(r).padEnd(30)} ` +
+                `${pc.dim(new Date(r.createdAt).toLocaleString())}  ${r.goal.slice(0, 60)}`);
         }
     }
     catch (err) {
@@ -2528,13 +2657,175 @@ program
         process.exitCode = 1;
     }
 });
+program
+    .command("share [chat]")
+    .description("a read-only link to a chat (default: main) for a teammate: prompts, replies, what ran and changed. It expires; --list shows yours, --revoke ends one (#199)")
+    .option("--hours <n>", "how long the link works (1 to 720, default 24)")
+    .option("--list", "the links that still work")
+    .option("--revoke <id>", "end a link now")
+    .option("--json", "print as JSON")
+    .action(async (chat, opts) => {
+    const client = await ensureDaemon();
+    if (opts.revoke) {
+        const { revoked } = await client.revokeShare(opts.revoke);
+        if (!revoked)
+            fail(`no link ${opts.revoke} — loom share --list`);
+        return void console.log(`${pc.green("✓")} link ${opts.revoke} no longer opens`);
+    }
+    if (opts.list) {
+        const { shares } = await client.shares();
+        if (opts.json)
+            return void console.log(JSON.stringify(shares));
+        if (!shares.length)
+            return void console.log(pc.dim("no links open — loom share [chat]"));
+        for (const s of shares)
+            console.log(`${pc.bold(s.id)}  ${s.title}  ${pc.dim(`until ${new Date(s.expiresAt).toLocaleString()}`)}`);
+        return;
+    }
+    const project = await currentProject(client);
+    let chatId = "main";
+    if (chat && chat !== "main") {
+        const { chats } = await client.chats(project.id);
+        const hit = chats.find((c) => c.id === chat || c.title.toLowerCase() === chat.toLowerCase());
+        if (!hit)
+            fail(`no chat "${chat}" here — ${chats.slice(0, 6).map((c) => c.title).join(", ") || "only main"}`);
+        chatId = hit.id;
+    }
+    const out = await client.shareChat(project.id, chatId, opts.hours ? Number(opts.hours) : undefined);
+    if (opts.json)
+        return void console.log(JSON.stringify(out));
+    console.log(`${pc.green("✓")} ${out.title} — read-only, until ${new Date(out.expiresAt).toLocaleString()}\n\n  ${out.url}\n`);
+    console.log(pc.dim(`anyone who can reach this machine with the link can read it (on another computer: start the daemon with loom up --tailnet). loom share --revoke ${out.id} ends it`));
+});
+program
+    .command("chain [file]")
+    .description("run goals in several projects, one after another: each line is `<project> :: <goal>` (project = name or folder). Each completed run is scanned for secrets and merged before the next starts (#340)")
+    .option("--push", "push each project's branch after merging its run")
+    .option("--keep-going", "carry on to the next project when one fails")
+    .option("--json", "print a JSON summary at the end")
+    .action(async (file, opts) => {
+    const text = file && file !== "-" ? fs.readFileSync(file, "utf8") : await new Promise((resolve) => {
+        let buf = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (d) => (buf += d));
+        process.stdin.on("end", () => resolve(buf));
+    });
+    const steps = text.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#")).map((l) => {
+        const at = l.indexOf("::");
+        if (at < 0)
+            fail(`each line is "<project> :: <goal>" — got: ${l}`);
+        return { project: l.slice(0, at).trim(), goal: l.slice(at + 2).trim() };
+    });
+    if (!steps.length)
+        fail("nothing to run — one `<project> :: <goal>` per line");
+    const client = await ensureDaemon();
+    const { projects } = await client.listProjects();
+    const results = [];
+    for (const step of steps) {
+        const p = projects.find((x) => x.name === step.project || x.id === step.project || path.resolve(x.dir) === path.resolve(step.project));
+        if (!p) {
+            results.push({ project: step.project, ok: false, runId: "-", status: "not started", error: `no project "${step.project}" — loom projects` });
+            if (!opts.keepGoing)
+                break;
+            continue;
+        }
+        if (!opts.json)
+            console.log(`${pc.magenta("▶")} ${pc.bold(p.name)} — ${step.goal.slice(0, 80)}`);
+        try {
+            const { run } = await client.startOrchestra(p.id, { goal: step.goal });
+            const r = { project: p.name, ...(await waitScanApply(client, p.id, p.dir, run.id, { push: Boolean(opts.push) })) };
+            results.push(r);
+            if (!opts.json)
+                printApplyResult(r);
+            if (!r.ok && !opts.keepGoing)
+                break;
+        }
+        catch (e) {
+            results.push({ project: p.name, ok: false, runId: "-", status: "not started", error: e.message });
+            if (!opts.json)
+                console.log(`${pc.red("✗")} ${p.name}: ${e.message}`);
+            if (!opts.keepGoing)
+                break;
+        }
+    }
+    const failed = results.filter((r) => !r.ok).length;
+    if (opts.json)
+        console.log(JSON.stringify({ ok: failed === 0, steps: results }));
+    else
+        console.log(pc.dim(`\n${results.length - failed}/${steps.length} merged${failed ? ` · ${failed} failed` : ""}${results.length < steps.length ? ` · ${steps.length - results.length} not run` : ""}`));
+    if (failed || results.length < steps.length)
+        process.exitCode = 1;
+});
+program
+    .command("limits")
+    .description("how many agent turns run at once across every project, and how much memory stays free — past either, turns queue (#339)")
+    .option("--turns <n>", "turns at once across all projects (0 = no cap)")
+    .option("--min-free <pct>", "don't start a turn while less than this % of memory is free (0 = off)")
+    .option("--json", "print as JSON")
+    .action(async (opts) => {
+    const { readLimits, writeLimits, availableMemoryPct, defaultLimits } = await import("../core/turn-gate.js");
+    const patch = {};
+    if (opts.turns !== undefined) {
+        const n = Number(opts.turns);
+        if (!Number.isInteger(n) || n < 0)
+            fail("--turns takes a whole number (0 = no cap)");
+        patch.maxTurns = n;
+    }
+    if (opts.minFree !== undefined) {
+        const n = Number(opts.minFree);
+        if (!(n >= 0 && n < 100))
+            fail("--min-free takes a % from 0 to 99");
+        patch.minFreePct = n;
+    }
+    const limits = Object.keys(patch).length ? writeLimits(patch) : readLimits();
+    const free = Math.round(availableMemoryPct());
+    const cfg = await daemonRunning();
+    const running = cfg ? await turnsInFlight(new DaemonClient(cfg)) : [];
+    if (opts.json)
+        return void console.log(JSON.stringify({ ...limits, freePct: free, running, defaults: defaultLimits() }));
+    if (Object.keys(patch).length)
+        console.log(pc.green("✓ saved — the daemon picks it up within a few seconds"));
+    console.log(`turns at once   ${limits.maxTurns ? pc.bold(String(limits.maxTurns)) : pc.dim("no cap")}  ${pc.dim(`(running now: ${running.length}${running.length ? ` — ${running.slice(0, 4).join(", ")}` : ""})`)}`);
+    console.log(`memory kept free ${limits.minFreePct ? pc.bold(`${limits.minFreePct}%`) : pc.dim("off")}  ${pc.dim(`(free now: ${free}%)`)}`);
+    console.log(pc.dim("past either, a new turn waits for a slot and says so in its thread; one that waits 10 min starts anyway"));
+});
+program
+    .command("agents:mode <agentId> [mode]")
+    .description("an agent's access: bypass (no sandbox — can commit, push, use the network), auto (the default), or ask. No mode: show what each means for it")
+    .action(async (agentId, mode) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const agent = project.agents.find((a) => a.id === agentId);
+    if (!agent)
+        fail(`no agent "${agentId}" here — loom agents`);
+    const { PERMISSION_PROFILES } = await import("../core/permissions.js");
+    const profile = PERMISSION_PROFILES[agent.kind];
+    if (!profile)
+        fail(`${agent.kind} has no access modes to choose from`);
+    const now = (agent.permissions ?? profile.default);
+    if (!mode) {
+        for (const [m, cell] of Object.entries(profile.modes)) {
+            const off = cell.unsupported;
+            console.log(`${m === now ? pc.green("●") : pc.dim("○")} ${pc.bold(m.padEnd(6))} ${off ? pc.dim(`${cell.label} — unavailable: ${off}`) : cell.label}`);
+        }
+        return void console.log(pc.dim(`\nloom agents:mode ${agentId} <bypass|auto|ask>`));
+    }
+    const res = await client.setAgentPermissions(project.id, agentId, mode);
+    const cell = profile.modes[(res.agent.permissions ?? mode)];
+    console.log(`${pc.green("✓")} ${agentId}: ${cell?.label ?? mode}`);
+    if (mode === "bypass")
+        console.log(pc.yellow("  no sandbox: it can commit, push, reach the network and run anything — on this machine, as you"));
+});
 program
     .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);
+    const project = await resolveCurrentProject(client).catch((err) => { if (err instanceof NoProjectError)
+        return null; throw err; });
+    if (!project)
+        return void (await printMachineAgents(Boolean(opts.json)));
     const { ades } = await client.availableAgents(project.id);
     if (opts.json)
         return void console.log(JSON.stringify(ades, null, 2));
@@ -2615,26 +2906,31 @@ async function offerGitignore(dir, choice) {
         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"))));
+    // in a terminal, ask; in a script (no one to ask), do it — .loom/ is never meant for the repo
+    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"));
+    console.log(pc.green("✓ added .loom/ to .gitignore") + (process.stdin.isTTY ? "" : pc.dim(" (loom init --no-gitignore to leave it alone)")));
 }
-async function sendWithHandoffConfirm(client, projectId, text, agentId, interactive = true, fresh = false) {
+async function sendWithHandoffConfirm(client, projectId, text, agentId, interactive = true, fresh = false, handoff = false) {
     try {
         return await client.send(projectId, text, agentId, { fresh });
     }
     catch (err) {
         if (err instanceof DaemonError && err.status === 409 && agentId) {
             const holder = String(err.body?.holder ?? "another agent");
-            if (!interactive)
-                fail(`${agentId} doesn't hold the baton (holder: ${holder}) — loom handoff ${agentId}`);
-            const yes = await confirm(pc.yellow(`⟶ ${holder} holds the baton. Hand off to ${agentId} (interrupts current work)?`));
-            if (!yes)
+            // no one to ask (a script, --json) and no --handoff: fail loudly, never a quiet exit 0
+            if (!handoff && !interactive)
+                fail(`${agentId} doesn't hold the baton (holder: ${holder}) — add --handoff, or loom handoff ${agentId}`);
+            const yes = handoff || (await confirm(pc.yellow(`⟶ ${holder} holds the baton. Hand off to ${agentId} (interrupts current work)?`)));
+            if (!yes) {
+                process.exitCode = 1;
+                console.error(pc.dim(`not sent — ${holder} keeps the baton (--handoff hands it over without asking)`));
                 return null;
+            }
             await client.handoff(projectId, agentId);
             return await client.send(projectId, text, agentId, { fresh });
         }
@@ -2645,10 +2941,11 @@ 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("--wait", "wait for the turn to end; print the reply and cost; exit 0 done, 1 failed, 2 asked a question, 75 interrupted (the daemon restarted), 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")
+    .option("--handoff", "with --agent: take the baton from whoever holds it, without asking")
     .action(async (words, opts) => {
     const client = await ensureDaemon();
     const project = await currentProject(client);
@@ -2670,23 +2967,49 @@ program
     }
     // 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));
+    // a question needs a person at a terminal — not a script, and never --json output
+    const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY) && !opts.json;
+    const result = await sendWithHandoffConfirm(client, project.id, words.join(" "), opts.agent, interactive, Boolean(opts.fresh), Boolean(opts.handoff));
     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;
+    // the daemon this turn runs in: if it goes away or comes back as another process, the turn is gone
+    const daemonPid = await client.version().then((v) => v.pid).catch(() => null);
+    let lastPidCheck = Date.now(), interrupted = false;
     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;
+        try {
+            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 && daemonPid && Date.now() - lastPidCheck > 5000) {
+                lastPidCheck = Date.now();
+                if ((await client.version()).pid !== daemonPid)
+                    interrupted = true;
+            }
         }
-        outcome = turnOutcome(seen, result.agentId, since);
+        catch {
+            interrupted = true; // the daemon stopped answering (or answered "event log is closed") mid-turn
+        }
+        if (interrupted)
+            break;
         if (!outcome)
             await new Promise((r) => setTimeout(r, 400));
     }
+    if (interrupted && !outcome) {
+        // EX_TEMPFAIL: not the agent's failure, and worth trying again
+        process.exitCode = 75;
+        const again = `loom send -a ${result.agentId} --wait "continue where you left off"`;
+        if (opts.json)
+            return void console.log(JSON.stringify({ status: "interrupted", agent: result.agentId, reason: "the Loom daemon restarted or stopped during the turn", resume: again }));
+        return void console.error(pc.yellow(`⚠ the Loom daemon restarted or stopped while ${result.agentId} was working — the turn was interrupted. ` +
+            `What it did so far is still in the working tree. To carry on: ${again}`));
+    }
     process.exitCode = exitCodeFor(outcome);
     if (opts.json)
         return void console.log(JSON.stringify(outcome ?? { status: "timeout", agent: result.agentId }));