@loompad/cli 1.1.2 → 1.2.1

package/dist/daemon/runtime.d.ts

@@ -7,6 +7,7 @@ import { NativeUsage } from "./runtime/native-usage.js";
 import { OrchestraEngine, type OrchestraCoordinator } from "../core/orchestra.js";
 import { CrewEngine } from "../core/crew.js";
 import { type Loop } from "../core/loops.js";
+import { type AutoPolicy } from "../core/auto-policy.js";
 import { QuotaRelay } from "./runtime/relay.js";
 import { ProofRunner } from "./proof.js";
 import { NightShift } from "./shift.js";
@@ -29,6 +30,9 @@ import { ServerFrame, TeamBrainHook } from './runtime-support.js';
 import { type TurnOptions, type TurnResult } from './runtime/turns.js';
 import { ContinuityEngine } from "../core/continuity/engine.js";
 import { HarnessMonitor } from "../core/continuity/capabilities.js";
+import { type ReviewTarget } from "../core/review.js";
+import { ReviewRunner } from "./review.js";
+import { CouncilRunner } from "./council.js";
 import { type LiveFrame } from "../providers/live.js";
 import { type AgentCheck } from "../adapters/base.js";
 import type { LiveText } from "../types.js";
@@ -58,8 +62,12 @@ export declare class ProjectRuntime {
     readonly relay: QuotaRelay;
     /** Proof: checks an agent's "done" against what ran and a clean re-run of the tests. */
     readonly proofs: ProofRunner;
+    /** Loom's Auto policy, registered by project id for this project's agents (core/auto-policy.ts). */
+    private readonly unregisterAutoPolicy;
     /** Night Shift: a line of tasks run while you're away, then one report (daemon/shift.ts). */
     readonly shifts: NightShift;
+    readonly reviews: ReviewRunner;
+    readonly councils: CouncilRunner;
     /** Adapter kinds installed on this machine, probed once at open. */
     private installedKinds;
     /** Memory as units — see core/brain.ts. Reads and writes through `log`. */
@@ -707,8 +715,8 @@ export declare class ProjectRuntime {
     compactAgent(agentId: string, chat?: string): Promise<void>;
     /**
      * A plan turn on a provider agent runs in the agent's own plan mode, which
-     * changes nothing; Loom keeps the plan it proposes under plans/, as its plan
-     * mode always has.
+     * changes nothing; Loom keeps the plan it proposes under .loom/plans/ — its
+     * own folder, not a new untracked one in your repo (#279).
      */
     private saveProposedPlan;
     onServerEvent(cb: (f: ServerFrame) => void): () => void;
@@ -739,12 +747,38 @@ export declare class ProjectRuntime {
      * project, a dropped table. Said at once, in its chat and as a push; with
      * shield.auto "stop" (the default on a night shift) the turn is stopped too.
      */
+    /** Agents whose last turn failed on sign-in, and the message — until a turn succeeds (#251). */
+    private readonly signedOutAgents;
+    private noteSignIn;
+    /**
+     * The size of an agent's native session in a chat — the context its last
+     * turn sent — and how long ago that was; a resumed session past the cache's
+     * life is re-read in full (#280).
+     */
+    sessionWeight(agentId: string, chat?: string): {
+        tokens: number;
+        ageMs: number;
+        model?: string;
+        cold: boolean;
+        estUsd?: number;
+    } | null;
+    /** The agents a real turn found signed out, with what the CLI said (for `loom doctor`). */
+    learnedSignOuts(): Array<{
+        agentId: string;
+        kind: string;
+        message: string;
+    }>;
+    /** What a restart would forget: each agent's latest sign-in failure that no successful turn has cleared since. */
+    private rehydrateSignIns;
+    /** What status says about an agent's sign-in: a real failure beats the CLI's own (cached) check. */
+    private signInState;
     private shield;
     /** The loop card's buttons: stop the turn, nudge the agent, or hand the task to another agent. */
     actOnLoop(chat: string, agentId: string, action: "stop" | "nudge" | "handoff", to?: string, loop?: Loop): Promise<{
         done: string;
         to?: string;
     }>;
+    private actOnLoopNow;
     private lastLoop;
     /**
      * Define or replace a named route.
@@ -814,7 +848,7 @@ export declare class ProjectRuntime {
      * each child is a real CLI process with its own model calls. The cap is per
      * project rather than global so one busy project can't starve the others.
      */
-    private static readonly MAX_CONCURRENT_SUBTASKS;
+    static readonly MAX_CONCURRENT_SUBTASKS = 4;
     /** In-flight subtasks, by the id minted when they started. */
     private subtasks;
     /** Subtasks currently running, for the status payload and the cap. */
@@ -849,10 +883,34 @@ export declare class ProjectRuntime {
         agentId: string;
         task: string;
         chat?: string;
+        /** Investigate and report, change nothing: the agent's own plan mode where it has one, and said in the brief either way (a review). */
+        readOnly?: boolean;
+        /** Told once the child's turn has ended, however it ended. */
+        onSettled?: (outcome: {
+            ok: boolean;
+            message?: string;
+        }) => void;
     }): Promise<{
         id: string;
         agentId: string;
     }>;
+    /**
+     * `loom review`: these agents read the same thing at once, read-only, off
+     * the baton (daemon/review.ts). The target is a file, free text, or —
+     * by default — the uncommitted changes.
+     */
+    startReview(input: {
+        agents: string[];
+        file?: string;
+        text?: string;
+        focus?: string;
+        chat?: string;
+    }): Promise<import("./review.js").ReviewState>;
+    /** What a review reads: a file, free text, or the uncommitted changes. Throws when there's nothing to read. */
+    reviewTarget(input: {
+        file?: string;
+        text?: string;
+    }): ReviewTarget;
     private subtaskBriefing;
     private defaultAdapterId;
     private consumePendingBriefing;
@@ -907,6 +965,8 @@ export declare class ProjectRuntime {
     abortRoute(): Promise<RouteState>;
     routeState(): RouteState | null;
     status(): Promise<ProjectStatus>;
+    /** What's in flight besides an agent's own turn — an orchestra planning, a crew, a council — so "idle" isn't said of a busy project (#294). */
+    inFlight(): string[];
     /**
      * What every agent in this project is doing right now — for the fleet view.
      *
@@ -931,6 +991,8 @@ export declare class ProjectRuntime {
      * at the ceiling. Plan mode can't be known when an agent is built, so
      * `bypassRequiresPlan` treats it as off — the stricter reading.
      */
+    /** Loom's Auto policy for this project, read live by agents (core/auto-policy.ts). */
+    autoPolicy(): AutoPolicy;
     private policyOptions;
     /** Phase 5: this project is a runner's workspace for one goal (D70). */
     runnerMode: boolean;

package/dist/daemon/runtime.js

@@ -1,4 +1,4 @@
-import { execSync } from "node:child_process";
+import { execFileSync, execSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { createAgent, isWithdrawnKind, knownAgentKinds, tierForKind } from "../adapters/index.js";
@@ -20,6 +20,11 @@ import { OrchestraEngine } from "../core/orchestra.js";
 import { CrewEngine } from "../core/crew.js";
 import { LoopWatch, nudgeText } from "../core/loops.js";
 import { commandOf, dangerOf } from "../core/shield.js";
+import { registerAutoPolicy } from "../core/auto-policy.js";
+import { detectTestCommand } from "../core/proof.js";
+import { knownAuth, signInCommand } from "../core/setup.js";
+/** What a CLI says when it isn't signed in. */
+const SIGNED_OUT = /\b(?:not signed in|not logged in|please (?:run )?\S*\s*\/?login|run `?[\w-]+ (?:auth )?login|sign in (?:first|again)|authentication (?:required|failed)|unauthori[sz]ed|invalid (?:api key|credentials)|401\b)/i;
 import { QuotaRelay } from "./runtime/relay.js";
 import { ProofRunner } from "./proof.js";
 import { NightShift } from "./shift.js";
@@ -50,6 +55,10 @@ import { ContinuityEngine } from "../core/continuity/engine.js";
 import { ContinuityError } from "../core/continuity/contracts.js";
 import { HarnessMonitor, isNativeKind } from "../core/continuity/capabilities.js";
 import { ProviderAgent } from "../providers/agent.js";
+import { READ_ONLY_RULE } from "../core/review.js";
+import { ReviewRunner } from "./review.js";
+import { CouncilRunner } from "./council.js";
+import { coldResume, priceBook } from "../core/prices.js";
 import { LiveDeltaThrottle } from "../providers/live.js";
 import { AdapterBase } from "../adapters/base.js";
 export { BudgetExceededError, CLOCK_TICK_MS, LOOM_ASK_TIMEOUT_MESSAGE, LOOM_ASK_TIMEOUT_MS, LoomAskTimeoutError, QuarantinedError, activityLine, planModeBriefing, relativeToProject, withLoomAskTimeout } from './runtime-support.js';
@@ -112,8 +121,12 @@ export class ProjectRuntime {
     relay;
     /** Proof: checks an agent's "done" against what ran and a clean re-run of the tests. */
     proofs;
+    /** Loom's Auto policy, registered by project id for this project's agents (core/auto-policy.ts). */
+    unregisterAutoPolicy;
     /** Night Shift: a line of tasks run while you're away, then one report (daemon/shift.ts). */
     shifts;
+    reviews;
+    councils;
     /** Adapter kinds installed on this machine, probed once at open. */
     installedKinds = [];
     /** Memory as units — see core/brain.ts. Reads and writes through `log`. */
@@ -292,6 +305,7 @@ export class ProjectRuntime {
             projectId: info.id,
             projectName: info.name,
             projectDir: info.dir,
+            worktreeDir: () => this.config.orchestra?.worktreeDir,
             roster: () => this.config.agents.filter((a) => a.enabled !== false && tierForKind(a.kind) === "adapter" && !isWithdrawnKind(a.kind)),
             installedKinds: () => this.installedKinds,
             makeAgent: (cfg, dir) => {
@@ -343,6 +357,7 @@ export class ProjectRuntime {
             config: () => this.config,
             busy: (id) => { const a = this.agents.get(id); return Boolean(a && isAdapter(a) && a.busy()) || this.turns.busySince.has(id); },
             turnChat: (id) => this.turns.turnChat.get(id),
+            inSubtask: (id) => [...this.subtasks.values()].some((t) => t.agentId === id),
             available: async (id) => { const a = this.agents.get(id); return Boolean(a && isAdapter(a) && (await a.available())); },
             interrupt: (chat) => this.interrupt({ chat, source: "route" }),
             handoff: (to) => this.handoff(to, { source: "route" }),
@@ -357,6 +372,7 @@ export class ProjectRuntime {
             append: (e) => (this.closed ? { ...e, id: -1, ts: Date.now() } : this.log.append(e)),
             warn: (message, detail) => logbook.warn("relay", message, String(detail), this.info.id),
         });
+        this.unregisterAutoPolicy = registerAutoPolicy(info.id, () => this.autoPolicy());
         this.proofs = new ProofRunner({
             projectId: info.id,
             dir: info.dir,
@@ -384,6 +400,67 @@ export class ProjectRuntime {
             append: (e) => (this.closed ? { ...e, id: -1, ts: Date.now() } : this.log.append(e)),
             warn: (message, detail) => logbook.warn("shift", message, String(detail), this.info.id),
         });
+        this.reviews = new ReviewRunner({
+            hasAgent: (id) => this.config.agents.some((a) => a.id === id),
+            canReview: (id) => {
+                const cfg = this.config.agents.find((a) => a.id === id);
+                return Boolean(cfg && cfg.enabled !== false && this.agents.has(id) && isAdapter(this.agent(id)));
+            },
+            holder: () => this.baton.holder() ?? undefined,
+            createChat: (title) => this.createChat(title),
+            spawn: (parent, opts) => this.spawnSubAgent(parent, opts),
+            list: (opts) => this.log.list(opts),
+            append: (e) => (this.closed ? { ...e, id: -1, ts: Date.now() } : this.log.append(e)),
+            // an accepted finding is a decision like `loom decision`: the event, and the memory every briefing carries
+            decide: (text) => {
+                if (this.closed)
+                    return;
+                const event = this.log.append({ kind: "decision", payload: { text, source: "review" } });
+                this.brain.add({ kind: "decision", text, provenance: { agentId: "user", eventId: event.id, ts: event.ts } });
+            },
+            maxReviewers: ProjectRuntime.MAX_CONCURRENT_SUBTASKS,
+            reviewerTimeoutMs: () => Math.max(1, Number(this.config.review?.timeoutMin) || 15) * 60_000,
+            stopReviewer: async (agentId) => {
+                const a = this.agents.get(agentId);
+                if (a && isAdapter(a) && a.busy())
+                    await a.interrupt();
+            },
+        });
+        this.councils = new CouncilRunner({
+            hasAgent: (id) => this.config.agents.some((a) => a.id === id),
+            canWrite: (id) => {
+                const cfg = this.config.agents.find((a) => a.id === id);
+                if (!cfg || cfg.enabled === false || !this.agents.has(id) || !isAdapter(this.agent(id)))
+                    return false;
+                return cfg.kind !== "model" || Boolean(cfg.options?.write); // a model agent without write only answers
+            },
+            createChat: (title) => this.createChat(title),
+            holder: () => this.baton.holder() ?? undefined,
+            handoff: (to) => this.handoff(to, { source: "route" }),
+            send: (agentId, text, opts) => this.sendMessage(text, agentId, { chat: opts.chat, plan: opts.plan, source: "route" }),
+            interrupt: (chat) => this.interrupt({ chat, source: "route" }),
+            checkReviewers: (ids) => this.reviews.check(ids),
+            startReview: (input) => this.reviews.start(input),
+            reviewStatus: (id) => this.reviews.status(id),
+            diffTarget: () => this.reviewTarget({}),
+            decide: (id, decision, note) => void this.reviews.decide(id, decision, note),
+            // the turn may already be being checked (Proof checks a reply that claims something by itself): use that one
+            prove: async (chat) => {
+                const t = this.proofs.turn(chat);
+                if (!t)
+                    return null;
+                for (let i = 0; i < 1200 && this.proofs.busy; i++)
+                    await new Promise((r) => setTimeout(r, 250));
+                const had = this.log.list({ kinds: ["proof"], chat }).reverse().find((e) => e.payload.turn?.done === t.done.id);
+                if (had)
+                    return { verdict: String(had.payload.verdict), headline: String(had.payload.headline) };
+                return this.proofs.prove(chat);
+            },
+            list: (opts) => this.log.list(opts),
+            append: (e) => (this.closed ? { ...e, id: -1, ts: Date.now() } : this.log.append(e)),
+            lastId: () => this.log.list({ limit: 1 }).at(-1)?.id ?? 0,
+            warn: (message, detail) => logbook.warn("council", message, String(detail), this.info.id),
+        });
         this.crews = new CrewEngine({
             projectId: info.id,
             projectName: info.name,
@@ -484,6 +561,10 @@ export class ProjectRuntime {
         }
         rt.configMtime = configMtimeOf(info.dir);
         rt.rehydrateCosts();
+        rt.rehydrateSignIns();
+        // finished orchestra runs older than a week give their disk back (#295)
+        setTimeout(() => void (rt.closed ? Promise.resolve([]) : rt.orchestra.sweep()).then((ids) => { if (ids.length)
+            logbook.info("orchestra", `removed the worktrees of ${ids.length} finished run(s)`, ids.join(", "), rt.info.id); }).catch(() => { }), 30_000).unref?.();
         // Pull each connected ADE's native memory into the shared brain on open.
         try {
             rt.importMemories();
@@ -1976,6 +2057,7 @@ export class ProjectRuntime {
     afterAgentEvent(event) {
         this.trackCost(event);
         this.shield(event);
+        this.noteSignIn(event);
         const loop = this.loops.observe(event);
         if (loop)
             void this.onLoop(loop).catch((err) => logbook.warn("loops", "couldn't act on a loop", String(err), this.info.id));
@@ -2309,8 +2391,8 @@ export class ProjectRuntime {
     }
     /**
      * A plan turn on a provider agent runs in the agent's own plan mode, which
-     * changes nothing; Loom keeps the plan it proposes under plans/, as its plan
-     * mode always has.
+     * changes nothing; Loom keeps the plan it proposes under .loom/plans/ — its
+     * own folder, not a new untracked one in your repo (#279).
      */
     saveProposedPlan(agentId, chat, markdown) {
         if (!markdown.trim())
@@ -2319,7 +2401,7 @@ export class ProjectRuntime {
             const heading = /^#+\s*(.+)$/m.exec(markdown)?.[1] ?? markdown.split("\n")[0] ?? "plan";
             const slug = heading.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "plan";
             const day = new Date().toISOString().slice(0, 10);
-            const dir = path.join(this.agentDir(agentId), "plans");
+            const dir = path.join(projectLoomDir(this.agentDir(agentId)), "plans");
             fs.mkdirSync(dir, { recursive: true });
             let file = path.join(dir, `${day}-${slug}.md`);
             for (let n = 2; fs.existsSync(file); n++)
@@ -2420,6 +2502,52 @@ export class ProjectRuntime {
      * project, a dropped table. Said at once, in its chat and as a push; with
      * shield.auto "stop" (the default on a night shift) the turn is stopped too.
      */
+    /** Agents whose last turn failed on sign-in, and the message — until a turn succeeds (#251). */
+    signedOutAgents = new Map();
+    noteSignIn(event) {
+        if (!event.agentId)
+            return;
+        if (event.kind === "run_complete" && !event.payload.error) {
+            this.signedOutAgents.delete(event.agentId);
+            return;
+        }
+        const message = event.kind === "error" ? String(event.payload.message ?? "") : event.kind === "run_complete" ? String(event.payload.error ?? "") : "";
+        if (message && SIGNED_OUT.test(message))
+            this.signedOutAgents.set(event.agentId, message.split("\n")[0].slice(0, 200));
+    }
+    /**
+     * The size of an agent's native session in a chat — the context its last
+     * turn sent — and how long ago that was; a resumed session past the cache's
+     * life is re-read in full (#280).
+     */
+    sessionWeight(agentId, chat = MAIN_CHAT) {
+        const last = this.log.list({ chat, agentId, kinds: ["run_complete"], limit: 50 }).at(-1);
+        if (!last)
+            return null;
+        const tokens = Number(last.payload.inputTokens ?? 0) || 0;
+        const model = typeof last.payload.model === "string" ? last.payload.model : undefined;
+        const ageMs = Date.now() - last.ts;
+        return { tokens, ageMs, ...(model ? { model } : {}), ...coldResume({ tokens, ageMs, ...(model ? { model } : {}) }, priceBook()) };
+    }
+    /** The agents a real turn found signed out, with what the CLI said (for `loom doctor`). */
+    learnedSignOuts() {
+        return [...this.signedOutAgents.entries()].map(([agentId, message]) => ({ agentId, kind: this.config.agents.find((a) => a.id === agentId)?.kind ?? "", message }));
+    }
+    /** What a restart would forget: each agent's latest sign-in failure that no successful turn has cleared since. */
+    rehydrateSignIns() {
+        for (const e of this.log.list({ kinds: ["error", "run_complete"], limit: 3000 }))
+            this.noteSignIn(e);
+    }
+    /** What status says about an agent's sign-in: a real failure beats the CLI's own (cached) check. */
+    signInState(agentId, kind) {
+        const learned = this.signedOutAgents.get(agentId);
+        if (learned)
+            return { signedOut: `${learned}${signInCommand(kind) ? ` — ${signInCommand(kind)}` : ""}` };
+        if (!signInCommand(kind) || process.env.LOOM_NO_AUTH_PROBE)
+            return {};
+        const auth = knownAuth(kind);
+        return auth?.authed === false ? { signedOut: `${auth.detail ?? "not signed in"} — ${signInCommand(kind)}` } : {};
+    }
     shield(event) {
         if (!event.agentId)
             return;
@@ -2455,6 +2583,18 @@ export class ProjectRuntime {
     }
     /** The loop card's buttons: stop the turn, nudge the agent, or hand the task to another agent. */
     async actOnLoop(chat, agentId, action, to, loop) {
+        if (action !== "stop") {
+            const release = this.queueCoordinator.hold();
+            try {
+                return await this.actOnLoopNow(chat, agentId, action, to, loop);
+            }
+            finally {
+                release();
+            }
+        }
+        return this.actOnLoopNow(chat, agentId, action, to, loop);
+    }
+    async actOnLoopNow(chat, agentId, action, to, loop) {
         const card = loop ?? this.lastLoop(chat, agentId);
         await this.interrupt({ chat, source: "route" });
         if (action === "stop")
@@ -2697,25 +2837,42 @@ export class ProjectRuntime {
         });
         await this.ensureStarted(opts.agentId);
         const mcp = child.capabilities.mcp ? writeMcpSession(this.healthyMcps()) : null;
+        const brief = this.subtaskBriefing(parentAgentId, opts.agentId, task);
         const input = {
             text: task,
             chat,
-            briefing: this.subtaskBriefing(parentAgentId, opts.agentId, task),
+            briefing: opts.readOnly ? `${brief}\n\n${READ_ONLY_RULE}` : brief,
+            ...(opts.readOnly && child instanceof ProviderAgent ? { interactionMode: "plan" } : {}),
             ...(mcp ? { mcp: { configPath: mcp.configPath, servers: mcp.servers } } : {}),
         };
+        const startedAt = Date.now();
+        // the child's reply belongs to the chat it was asked in, not wherever it last talked
+        this.turns.turnChat.set(opts.agentId, chat);
         void child
             .send(input)
             .then(() => {
             this.subtasks.delete(id);
+            // an adapter can report a failed turn as an error event and still resolve: that subtask
+            // failed — it isn't "done" (#247)
+            const failed = this.log.list({ chat, agentId: opts.agentId, kinds: ["error", "run_complete"], sinceTs: startedAt })
+                .reverse().find((e) => e.kind === "error" || Boolean(e.payload.error));
+            if (failed) {
+                const message = String(failed.payload.message ?? failed.payload.error ?? "the turn failed").slice(0, 500);
+                this.appendIfOpen({ kind: "subtask_failed", agentId: opts.agentId, chat, payload: { subtaskId: id, parent: parentAgentId, task, message } });
+                opts.onSettled?.({ ok: false, message });
+                return;
+            }
             this.appendIfOpen({
                 kind: "subtask_done",
                 agentId: opts.agentId,
                 chat,
                 payload: { subtaskId: id, parent: parentAgentId, task },
             });
+            opts.onSettled?.({ ok: true });
         })
             .catch((err) => {
             this.subtasks.delete(id);
+            opts.onSettled?.({ ok: false, message: String(err instanceof Error ? err.message : err) });
             this.appendIfOpen({
                 kind: "subtask_failed",
                 agentId: opts.agentId,
@@ -2731,6 +2888,51 @@ export class ProjectRuntime {
             .finally(() => mcp?.cleanup());
         return { id, agentId: opts.agentId };
     }
+    /**
+     * `loom review`: these agents read the same thing at once, read-only, off
+     * the baton (daemon/review.ts). The target is a file, free text, or —
+     * by default — the uncommitted changes.
+     */
+    async startReview(input) {
+        this.reviews.check(input.agents); // who, before reading any diff
+        const target = this.reviewTarget(input);
+        return this.reviews.start({ agents: input.agents, target, ...(input.focus ? { focus: input.focus } : {}), ...(input.chat ? { chat: input.chat } : {}) });
+    }
+    /** What a review reads: a file, free text, or the uncommitted changes. Throws when there's nothing to read. */
+    reviewTarget(input) {
+        let target;
+        if (input.file?.trim()) {
+            const rel = path.relative(this.info.dir, path.resolve(this.info.dir, input.file.trim()));
+            if (rel.startsWith("..") || path.isAbsolute(rel))
+                throw new Error(`${input.file} is outside the project`);
+            if (!fs.existsSync(path.join(this.info.dir, rel)))
+                throw new Error(`no file ${rel} in this project`);
+            target = { kind: "file", file: rel.split(path.sep).join("/") };
+        }
+        else if (input.text?.trim()) {
+            target = { kind: "text", text: input.text.trim() };
+        }
+        else {
+            const git = (...args) => execFileSync("git", args, { cwd: this.info.dir, encoding: "utf8", maxBuffer: 32 * 1024 * 1024, timeout: 15_000, stdio: ["ignore", "pipe", "ignore"] });
+            let diff = "", untracked = [];
+            try {
+                try {
+                    diff = git("diff", "HEAD");
+                }
+                catch {
+                    diff = git("diff");
+                } // no commits yet
+                untracked = git("ls-files", "--others", "--exclude-standard").split("\n").filter(Boolean);
+            }
+            catch {
+                throw new Error("--diff needs a git repository — review a --file instead");
+            }
+            if (!diff.trim() && !untracked.length)
+                throw new Error("there are no uncommitted changes to review — name a --file instead");
+            target = { kind: "diff", diff, untracked };
+        }
+        return target;
+    }
     subtaskBriefing(parent, childId, task) { return this.briefings.subtaskBriefing(parent, childId, task); }
     defaultAdapterId() {
         const cfg = (this.config.defaultAgent &&
@@ -2984,6 +3186,8 @@ export class ProjectRuntime {
                 // which chat that turn is in, so a client shows Stop only where it applies
                 ...(isAdapter(live) && (live.busy() || this.turns.busySince.has(cfg.id)) ? { chat: this.turns.turnChat.get(cfg.id) ?? MAIN_CHAT } : {}),
                 holdsBaton: holder === cfg.id,
+                ...this.signInState(cfg.id, cfg.kind),
+                ...(cfg.kind === "model" && !cfg.options?.write ? { readOnly: true } : {}),
                 model,
                 permissions: permissionFor(cfg.kind, cfg.options),
                 enabled: true,
@@ -3027,8 +3231,24 @@ export class ProjectRuntime {
             // "the self-heal did nothing".
             quarantine: this.quarantined(),
             orchestra: this.orchestraSummary(),
+            activity: this.inFlight(),
         };
     }
+    /** What's in flight besides an agent's own turn — an orchestra planning, a crew, a council — so "idle" isn't said of a busy project (#294). */
+    inFlight() {
+        const out = [];
+        if (this.orchestra.active())
+            out.push("orchestra");
+        for (const c of this.crews.workingCrews)
+            out.push(`crew ${c}`);
+        if (this.councils.active)
+            out.push("council");
+        if (this.shifts.active)
+            out.push("night shift");
+        if (this.reviews.running)
+            out.push("review");
+        return out;
+    }
     /**
      * What every agent in this project is doing right now — for the fleet view.
      *
@@ -3131,6 +3351,17 @@ export class ProjectRuntime {
      * at the ceiling. Plan mode can't be known when an agent is built, so
      * `bypassRequiresPlan` treats it as off — the stricter reading.
      */
+    /** Loom's Auto policy for this project, read live by agents (core/auto-policy.ts). */
+    autoPolicy() {
+        const dir = this.info.dir;
+        const test = this.config.proof?.testCommand ?? detectTestCommand(dir);
+        return {
+            projectDir: dir,
+            readPaths: (this.config.readPaths ?? []).filter((p) => typeof p === "string" && p.trim()).map((p) => path.resolve(dir, p)),
+            // the project's own test command always runs: an agent has to be able to check its work
+            allow: [...(this.config.permissions?.allow ?? []).filter((a) => typeof a === "string"), ...(test ? [test] : [])],
+        };
+    }
     policyOptions(cfg) {
         const opts = { ...(cfg.options ?? {}) };
         if (this.runnerMode) {
@@ -3252,9 +3483,11 @@ export class ProjectRuntime {
         };
     }
     async close() {
+        this.unregisterAutoPolicy();
         await this.orchestra.shutdown().catch(() => { });
         this.relay.stop();
         this.shifts.close();
+        this.councils.close();
         await this.crews.shutdown().catch(() => { });
         this.closed = true;
         this.harnesses.stop();