@loompad/cli 0.1.0 → 1.1.1

package/dist/daemon/runtime.js

@@ -1,57 +1,278 @@
-/**
- * ProjectRuntime — one live project inside the daemon: its event log, its
- * agents, and its baton. All mutations flow through here so the log stays
- * the single source of truth.
- */
+import { execSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-import { isAdapter, MAIN_CHAT } from "../types.js";
-import { createAgent, knownAgentKinds } from "../adapters/index.js";
-import { BatonManager, NotHolderError } from "../core/baton.js";
-import { Brain, CONFIDENCE_FLOOR } from "../core/brain.js";
-import { compileBrief, retrieve } from "../core/brain-index.js";
-import { extractFromTurn } from "../core/brain-extract.js";
-import { claudeText } from "../core/claude-cli.js";
-import { EventLog } from "../core/eventlog.js";
+import { createAgent, isWithdrawnKind, knownAgentKinds, tierForKind } from "../adapters/index.js";
+import { ModelAdapter } from "../adapters/model.js";
+import { ADES, detectAdes } from "../core/ades.js";
+import { BatonManager } from "../core/baton.js";
+import { Brain } from "../core/brain.js";
+import { helperText } from "../core/provider-text.js";
+import { ConversationStore } from "../core/conversations.js";
+import * as checkpoints from "../core/checkpoint.js";
 import { renderProjection } from "../core/distill.js";
-import { buildUnifiedMemory, hashContent, readNativeMemory, } from "../core/memory.js";
+import { EventLog } from "../core/eventlog.js";
+import { ensureBranch, addWorktree as gitAddWorktree, readOut, worktreePath } from "../core/git.js";
+import { logbook } from "../core/logbook.js";
+import { probeMcpServer, probeMcpServers, writeMcpSession } from "../core/mcp.js";
+import { NativeUsage } from "./runtime/native-usage.js";
 import { notify } from "../core/notify.js";
-import { RouteEngine } from "../core/routes.js";
-import { buildBriefing, buildProjection } from "../core/projection.js";
-import { newId, projectLoomDir, readProjectConfig, readProjectState, writeProjectConfig, writeProjectState, writeMemoryFile, } from "../core/registry.js";
+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 { QuotaRelay } from "./runtime/relay.js";
+import { ProofRunner } from "./proof.js";
+import { NightShift } from "./shift.js";
+import { isPermissionMode, permissionFor, unsupportedReason } from "../core/permissions.js";
+import { startPreviewProxy } from "../core/preview-proxy.js";
+import { PromptQueue } from "../core/prompt-queue.js";
+import { newId, projectLoomDir, readProjectConfig, readProjectState, writeMemoryFile, writeProjectConfig, writeProjectState, } from "../core/registry.js";
+import { RouteEngine, resolveSteps } from "../core/routes.js";
+import { SemanticIndex } from "../core/semantic.js";
+import { Servers } from "../core/servers.js";
+import { SkillInstallError, installSkillFromDir, installSkillFromGit, } from "../core/skill-install.js";
+import { buildSkillsBlock, discoverSkillRoots, loadSkills, } from "../core/skills.js";
 import { suggestHandoff } from "../core/suggestions.js";
-import { diffSinceSnapshot, porcelainStatus, workingTree, } from "../core/worktree.js";
-const PROJECTION_WINDOW = 400; // recent events distilled on handoff
+import { cappedPermission } from "../core/team-policy.js";
+import { capCrewPermission, DEFAULT_CREW_POLICY } from "../core/crew-policy.js";
+import { describeMerge, mergeAgentWork } from "../core/worktree-merge.js";
+import { workingTree } from "../core/worktree.js";
+import { decisionStats, extractDecisions, normalizeStoredDecision, } from "../observability/decisions.js";
+import { turnTraceId } from "../observability/index.js";
+import { GIT_DELIVERIES, MAIN_CHAT, isAdapter } from "../types.js";
+import { MAX_FANOUT, activityLine, configMtimeOf, withLoomAskTimeout } from './runtime-support.js';
+import { RuntimeAccounting } from './runtime/accounting.js';
+import { RuntimeAgents } from './runtime/agents.js';
+import { RuntimeBriefings } from './runtime/briefings.js';
+import { RuntimeQueue } from './runtime/queue.js';
+import { RuntimeTurns } from './runtime/turns.js';
+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 { 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';
+/**
+ * Priority and due date on a card: set when given, cleared by null, refused
+ * in words when they don't make sense.
+ */
+function applyCardMeta(task, p) {
+    if (p.priority !== undefined) {
+        if (p.priority === null || p.priority === "")
+            delete task.priority;
+        else if (p.priority === "high" || p.priority === "medium" || p.priority === "low")
+            task.priority = p.priority;
+        else
+            throw new Error("priority is high, medium or low");
+    }
+    if (p.due !== undefined) {
+        if (p.due === null || p.due === "")
+            delete task.due;
+        else if (/^\d{4}-\d{2}-\d{2}$/.test(p.due) && !Number.isNaN(new Date(`${p.due}T00:00:00`).getTime()))
+            task.due = p.due;
+        else
+            throw new Error("due is a date: YYYY-MM-DD");
+    }
+}
+/** A model agent's sampling settings, for its status (empty for everything else). */
+function sampling(cfg) {
+    if (cfg.kind !== "model")
+        return {};
+    const o = (cfg.options ?? {});
+    const out = {};
+    if (typeof o.temperature === "number")
+        out.temperature = o.temperature;
+    if (typeof o.maxTokens === "number")
+        out.maxTokens = o.maxTokens;
+    return { sampling: out };
+}
 export class ProjectRuntime {
+    accounting;
+    briefings;
+    queueCoordinator;
+    turns;
     info;
     config;
     log;
+    conversations;
     baton;
     routes;
+    /** One orchestrator, many parallel workers — see core/orchestra.ts. */
+    orchestra;
+    /** Agent Teams: crews of agents with roles, one goal at a time (core/crew.ts). */
+    crews;
+    /** Loop watch: an agent stuck re-running the same failing command (core/loops.ts). */
+    loops = new LoopWatch();
+    /** agent × chat already nudged since a person last spoke there: a second loop is only reported. */
+    nudged = new Set();
+    /** agent × chat × command already flagged this turn by the shield. */
+    shielded = new Set();
+    /** Quota Relay: an agent out of quota mid-task hands its work to the next. */
+    relay;
+    /** Proof: checks an agent's "done" against what ran and a clean re-run of the tests. */
+    proofs;
+    /** Night Shift: a line of tasks run while you're away, then one report (daemon/shift.ts). */
+    shifts;
+    /** Adapter kinds installed on this machine, probed once at open. */
+    installedKinds = [];
     /** Memory as units — see core/brain.ts. Reads and writes through `log`. */
     brain;
-    agents = new Map();
-    startedAgents = new Set();
+    continuity = null;
+    /** Native harness reachability, polled while native continuity is on. */
+    harnesses;
+    /** Latest context and usage-limit readings from native harnesses. */
+    nativeUsage = new NativeUsage();
+    agentLifecycle = new RuntimeAgents();
+    get agents() { return this.agentLifecycle.agents; }
     configMtime = 0;
-    /**
-     * Which conversation each agent's current turn belongs to. Set when a turn
-     * starts and left in place afterwards — an agent's trailing events (a late
-     * run_complete, a diff) still belong to the chat that prompted them.
-     */
-    turnChat = new Map();
+    journalFailure = null;
+    /** What you've lined up, run one at a time — see core/prompt-queue.ts. */
+    queue;
+    /** This project's dev servers — see core/servers.ts. */
+    servers;
+    /** One preview proxy per server — see core/preview-proxy.ts. */
+    proxies = new Map();
+    serverListeners = new Set();
+    streamListeners = new Set();
+    liveListeners = new Set();
+    /** Streamed text and tool progress from provider agents, coalesced for clients. Not persisted. */
+    live = new LiveDeltaThrottle((d) => { for (const cb of this.liveListeners)
+        cb(d); });
     constructor(info, config, log) {
         this.info = info;
         this.config = config;
         this.log = log;
+        if (config.brain?.continuity === true)
+            this.continuity = new ContinuityEngine(log, info.id);
+        this.harnesses = new HarnessMonitor(() => this.config.agents.filter(a => a.enabled !== false && isNativeKind(a.kind)).map(a => ({ id: a.id, kind: a.kind, options: this.policyOptions(a) })), (id, next, previous) => {
+            if (!next.available)
+                logbook.warn("harness", `${id} CLI is not reachable — native turns are refused until it answers`, next.error, info.id);
+            else if (previous && !previous.available)
+                logbook.info("harness", `${id} CLI is reachable again (${next.version ?? "unknown version"})`, undefined, info.id);
+        });
+        if (this.continuity)
+            this.harnesses.start();
+        // The last readings survive a restart: replay the recent reports.
+        for (const e of log.list({ kinds: ["status", "run_complete", "error"], limit: 500 }))
+            this.nativeUsage.observe(e);
+        this.conversations = new ConversationStore(info.dir);
+        const runtime = this;
+        this.accounting = new RuntimeAccounting({
+            get log() { return runtime.log; },
+            appendIfOpen: (...args) => this.appendIfOpen(...args),
+            get info() { return runtime.info; },
+        });
+        this.briefings = new RuntimeBriefings({
+            get info() { return runtime.info; },
+            get config() { return runtime.config; },
+            get log() { return runtime.log; },
+            get teamBrain() { return runtime.teamBrain; },
+            get brain() { return runtime.brain; },
+            activeSkillsBlock: (...args) => this.activeSkillsBlock(...args),
+            get turnChat() { return runtime.turns.turnChat; },
+            // a provider/model (ollama/qwen3:4b, openrouter/pool:free) runs there; anything else is a Claude alias
+            extractionEngine: (model) => (prompt) => helperText(model, `${prompt.system}\n\n${prompt.user}`, { timeoutMs: 60_000 }),
+            renderProjection: (input) => renderProjection(input, this.config.projection),
+            createSemanticIndex: () => new SemanticIndex(path.join(this.info.dir, ".loom")),
+            noteMemoriesUsed: (ids) => this.noteMemoriesUsed(ids),
+        });
+        this.queueCoordinator = new RuntimeQueue({
+            get queue() { return runtime.queue; },
+            get agents() { return runtime.agents; },
+            routeState: (...args) => this.routeState(...args),
+            validHolder: (...args) => this.validHolder(...args),
+            get orchestra() { return runtime.orchestra; },
+            get config() { return runtime.config; },
+            get busySince() { return runtime.turns.busySince; },
+            get closed() { return runtime.closed; },
+            appendIfOpen: (...args) => this.appendIfOpen(...args),
+            startRoute: (...args) => this.startRoute(...args),
+            handoff: (...args) => this.handoff(...args),
+            sendMessage: (...args) => this.sendMessage(...args),
+        });
+        this.turns = new RuntimeTurns({
+            get continuity() { return runtime.continuity; },
+            harness: (id) => this.harnesses.ensure(id),
+            kickQueue: () => this.kickQueue(),
+            nativeOptions: (id) => this.policyOptions(this.config.agents.find(a => a.id === id)),
+            chatExists: (chat) => this.conversations.chats().some(c => c.id === chat),
+            staleTurnMs: ProjectRuntime.STALE_TURN_MS,
+            get closed() { return runtime.closed; },
+            agentDir: (...args) => this.agentDir(...args),
+            get log() { return runtime.log; },
+            get info() { return runtime.info; },
+            extractMemory: (...args) => this.extractMemory(...args),
+            get config() { return runtime.config; },
+            chatBinding: (...args) => this.chatBinding(...args),
+            validHolder: (...args) => this.validHolder(...args),
+            defaultAdapterId: (...args) => this.defaultAdapterId(...args),
+            agent: (...args) => this.agent(...args),
+            enforceQuarantine: (...args) => {
+                if (this.journalFailure)
+                    throw this.journalFailure;
+                this.enforceQuarantine(...args);
+            },
+            enforceBudget: (...args) => this.enforceBudget(...args),
+            get teamPolicy() { return runtime.teamPolicy; },
+            get baton() { return runtime.baton; },
+            releaseQuestionHold: (...args) => this.releaseQuestionHold(...args),
+            openQuestion: (agentId) => this.openQuestions.get(agentId),
+            answerQuestion: (...args) => this.answerQuestion(...args),
+            get queue() { return runtime.queue; },
+            get routes() { return runtime.routes; },
+            ensureStarted: (...args) => this.ensureStarted(...args),
+            isCurrentAgent: (agent) => !this.closed && this.agents.get(agent.id) === agent,
+            dispatchFailed: (agent, chat, error) => {
+                if (this.closed || this.agents.get(agent.id) !== agent)
+                    return;
+                if (!this.continuity || !isAdapter(agent) || !agent.busy())
+                    this.turns.busySince.delete(agent.id);
+                const event = this.log.append({ kind: "error", agentId: agent.id, chat,
+                    payload: { message: error instanceof Error ? error.message : String(error) } });
+                this.afterAgentEvent(event);
+                this.kickQueue();
+            },
+            consumePendingBriefing: (...args) => this.consumePendingBriefing(...args),
+            activeSkillsBlock: (...args) => this.activeSkillsBlock(...args),
+            agentInstructions: (id) => this.agentInstructions(id),
+            healthyMcps: (...args) => this.healthyMcps(...args),
+            appendIfOpen: (...args) => this.appendIfOpen(...args),
+            get agents() { return runtime.agents; },
+            handoff: (...args) => this.handoff(...args),
+            get pendingBriefings() { return runtime.briefings.pendingBriefings; },
+        });
+        // What each agent has typed since its last finished message, so a window
+        // opened (or reloaded) mid-reply can show the reply so far, not just the
+        // words that arrive after it. A finished message supersedes its typing;
+        // a turn's end drops it.
+        log.onEvent((e) => {
+            const s = e.agentId ? this.liveSoFar.get(e.agentId) : undefined;
+            if (!s || !e.agentId)
+                return;
+            const p = e.payload;
+            if (e.kind === "message") {
+                if (p.reasoning)
+                    s.think = "";
+                else
+                    s.text = "";
+            }
+            else if (e.kind === "run_complete" || e.kind === "error" || e.kind === "needs_input" ||
+                (e.kind === "status" && (p.state === "interrupted" || p.state === "stopped"))) {
+                this.liveSoFar.delete(e.agentId);
+            }
+        });
         this.baton = new BatonManager(info.dir, log);
         this.brain = new Brain(log);
+        void this.briefings.configureSemantic(!this.continuity && config.brain?.semantic === true);
         // Same path as addAgent: an agent added at runtime must behave exactly like
         // one that was here at open, and two copies of this loop would drift.
         // (An agent streams events long after send() returns and has no idea which
         // conversation prompted it — spawnAgent tags them with the chat that started
         // the turn, so a reply lands where the question was asked.)
         for (const agentCfg of config.agents)
-            this.spawnAgent(agentCfg);
+            if (agentCfg.enabled !== false)
+                this.spawnAgent(agentCfg);
         this.routes = new RouteEngine({
             projectName: info.name,
             projectDir: info.dir,
@@ -60,19 +281,207 @@ export class ProjectRuntime {
             handoff: (to) => this.handoff(to, { source: "route" }),
             send: (text, agentId) => this.sendMessage(text, agentId, { source: "route" }),
             interrupt: () => this.interrupt({ source: "route" }),
-            costTotal: () => this.costs.totalUsd,
+            costTotal: () => this.accounting.costs.totalUsd,
+            turnFacts: (agentId) => this.turnFacts(agentId),
             isAdapterId: (id) => {
                 const agent = this.agents.get(id);
                 return Boolean(agent && isAdapter(agent));
             },
         });
+        this.orchestra = new OrchestraEngine({
+            projectId: info.id,
+            projectName: info.name,
+            projectDir: info.dir,
+            roster: () => this.config.agents.filter((a) => a.enabled !== false && tierForKind(a.kind) === "adapter" && !isWithdrawnKind(a.kind)),
+            installedKinds: () => this.installedKinds,
+            makeAgent: (cfg, dir) => {
+                if (this.continuity)
+                    throw new ContinuityError("unsupported", "parallel orchestra execution is outside sequential native continuity");
+                const agent = createAgent({ ...cfg, options: { ...this.policyOptions(cfg), loomProject: info.id } }, dir);
+                if (!isAdapter(agent))
+                    throw new Error(`"${cfg.id}" is a bridge — it cannot run orchestra work`);
+                return agent;
+            },
+            append: (e) => (this.closed ? { ...e, id: -1, ts: Date.now() } : this.log.append(e)),
+            // A task thread is pinned to its worker, so the sidebar says who it is
+            // and a reply there reaches that agent. A worker that can't be pinned
+            // (none can't, today — but a roster can change mid-run) still gets its
+            // thread, just unpinned.
+            createChat: (title, opts) => {
+                try {
+                    return this.createChat(title, opts?.agentId ? { agentId: opts.agentId } : {});
+                }
+                catch {
+                    return this.createChat(title);
+                }
+            },
+            // Asked before a run is told to answer in a thread: an id from a client
+            // is a claim about this machine, and Main is real without being stored.
+            chatExists: (id) => this.conversations.chats().some((c) => c.id === id),
+            briefingFor: async (query, agentId, files) => [
+                this.activeSkillsBlock(),
+                await this.brainBriefFor({ query, agent: agentId, limit: 6 }),
+                this.teamBrain?.context(files ?? []) ?? "",
+            ]
+                .filter(Boolean)
+                .join("\n\n"),
+            gate: (agentId) => {
+                if (this.continuity)
+                    throw new ContinuityError("unsupported", "parallel orchestra execution is outside sequential native continuity");
+                this.enforceQuarantine(agentId);
+                this.enforceBudget(agentId);
+            },
+            observe: (event) => this.trackCost(event),
+            stream: (f) => this.liveText(f),
+            gitDelivery: () => this.config.git?.delivery ?? "none",
+            goalBudgetUsd: () => this.config.budgets?.perGoalUsd ?? null,
+            maxConcurrentGoals: () => this.config.maxConcurrentGoals ?? null,
+            member: () => this.memberLogin,
+            coordinator: () => this.coordinator,
+        });
+        this.relay = new QuotaRelay({
+            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),
+            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" }),
+            holder: () => this.validHolder(),
+            setBriefing: (id, text) => {
+                const prior = this.briefings.pendingBriefings.get(id);
+                this.briefings.pendingBriefings.set(id, [prior, text].filter(Boolean).join("\n"));
+            },
+            send: (text, id, chat) => this.sendMessage(text, id, { chat, source: "route" }),
+            enqueue: (input) => this.enqueue(input),
+            list: (opts) => this.log.list(opts),
+            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.proofs = new ProofRunner({
+            projectId: info.id,
+            dir: info.dir,
+            config: () => this.config.proof ?? {},
+            list: (opts) => this.log.list(opts),
+            append: (e) => (this.closed ? { ...e, id: -1, ts: Date.now() } : this.log.append(e)),
+        });
+        this.shifts = new NightShift({
+            dir: info.dir,
+            hasAgent: (id) => this.config.agents.some((a) => a.id === id),
+            createChat: (title, agentId) => this.createChat(title, agentId ? { agentId } : {}),
+            enqueue: (input) => this.enqueue(input),
+            queued: () => this.queue.snapshot().items,
+            removeQueued: (id) => this.queue.remove(id),
+            busy: () => this.turns.busySince.size > 0 || [...this.agents.values()].some((a) => isAdapter(a) && a.busy()),
+            proofsBusy: () => this.proofs.busy,
+            resumeAfterRestart: () => {
+                const q = this.queue.snapshot();
+                if (!q.paused || !q.reason?.startsWith("the daemon restarted"))
+                    return;
+                this.queue.setPaused(false);
+                void this.drainPromptQueue();
+            },
+            list: (opts) => this.log.list(opts),
+            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.crews = new CrewEngine({
+            projectId: info.id,
+            projectName: info.name,
+            projectDir: info.dir,
+            crews: () => this.config.crews ?? [],
+            saveCrews: (crews) => {
+                if (crews.length)
+                    this.config.crews = crews;
+                else
+                    delete this.config.crews;
+                this.saveConfig();
+            },
+            roster: () => this.config.agents.filter((a) => a.enabled !== false && tierForKind(a.kind) === "adapter" && !isWithdrawnKind(a.kind)),
+            makeAgent: (cfg, dir) => {
+                const agent = createAgent({ ...cfg, options: { ...this.policyOptions(cfg), loomProject: info.id } }, dir);
+                if (!isAdapter(agent))
+                    throw new Error(`"${cfg.id}" is a bridge — it can't be on a crew`);
+                return agent;
+            },
+            append: (e) => (this.closed ? { ...e, id: -1, ts: Date.now() } : this.log.append(e)),
+            createChat: (title, opts) => this.createChat(title, opts?.agentId ? { agentId: opts.agentId } : {}),
+            // The decorated sidebar list calls crews.list() to discover groups.
+            // Using it to validate a crew's channel recurses back into crew state.
+            chatExists: (id) => this.conversations.chats().some((c) => c.id === id),
+            native: () => this.continuity,
+            nativeOptions: (cfg) => this.policyOptions(cfg),
+            nativeHealth: (id) => this.harnesses.ensure(id),
+            coordinator: () => this.coordinator,
+            policy: () => this.teamPolicy,
+            spentToday: (crew) => this.crewSpendToday(crew),
+            gitDelivery: () => this.config.git?.delivery ?? "none",
+            // agent-asserted, so below a human's word, and private to the crew until promoted
+            remember: (m) => {
+                this.brain.add({ kind: m.kind, text: m.text, scope: { crew: m.crewId }, confidence: 0.85, evidence: m.text,
+                    provenance: { agentId: m.agentId, eventId: m.eventId, ts: Date.now() } });
+            },
+            briefingFor: async (query, agentId, crewId) => [this.activeSkillsBlock(), await this.brainBriefFor({ query, agent: agentId, crew: crewId, limit: 6 }), this.teamBrain?.context([]) ?? ""]
+                .filter(Boolean)
+                .join("\n\n"),
+            gate: (agentId) => {
+                this.enforceQuarantine(agentId);
+                this.enforceBudget(agentId);
+            },
+            observe: (event) => this.trackCost(event),
+            stream: (f) => this.liveText(f),
+            createTask: (input) => this.createTask(input),
+            updateTask: (id, patch) => this.updateTask(id, patch),
+            member: () => this.memberLogin,
+        });
+        this.queue = new PromptQueue(path.join(projectLoomDir(info.dir), "queue.json"), (q) => {
+            for (const cb of this.queueCoordinator.queueListeners)
+                cb(q);
+            this.watchClockConditions(q);
+        });
+        this.servers = new Servers({
+            projectDir: info.dir,
+            configs: () => this.config.servers ?? [],
+            onChange: (name, status) => {
+                for (const cb of this.serverListeners)
+                    cb({ kind: "state", name, status });
+                // A server that died while an agent worked against it is the answer to
+                // "why is the page blank?" — it belongs in the thread, not only a pane.
+                if (status.state === "crashed") {
+                    this.appendIfOpen({
+                        kind: "status",
+                        payload: { state: "server_crashed", server: name, exitCode: status.exitCode },
+                    });
+                }
+            },
+            onLine: (name, line) => {
+                for (const cb of this.serverListeners)
+                    cb({ kind: "line", name, line });
+            },
+        });
+        // a goal or a route that ends frees the head of the queue
+        log.onEvent((e) => {
+            if (e.kind === "orchestra" || e.kind === "route_completed" || e.kind === "route_failed")
+                this.kickQueue();
+        });
     }
     static async open(info) {
         const config = readProjectConfig(info.dir);
-        if (!config)
+        if (!config) {
+            // Say which: a folder that's gone (moved, deleted, a temp dir a reboot
+            // cleared) is a different fix from a folder that was never initialised.
+            if (!fs.existsSync(info.dir))
+                throw new Error(`this project's folder is gone: ${info.dir} — it was moved or deleted`);
             throw new Error(`project at ${info.dir} has no .loom/config.json — run loom init`);
+        }
         const log = await EventLog.open(projectLoomDir(info.dir));
-        const rt = new ProjectRuntime(info, config, log);
+        let rt;
+        try {
+            rt = new ProjectRuntime(info, config, log);
+        }
+        catch (error) {
+            log.close();
+            throw error;
+        }
         rt.configMtime = configMtimeOf(info.dir);
         rt.rehydrateCosts();
         // Pull each connected ADE's native memory into the shared brain on open.
@@ -82,49 +491,42 @@ export class ProjectRuntime {
         catch {
             // Memory import is best-effort; never block opening a project.
         }
-        return rt;
-    }
-    // -------------------------------------------------------------------------
-    // Cost telemetry — O(1) incremental, rehydrated from the log on open
-    // -------------------------------------------------------------------------
-    costs = { totalUsd: 0, turns: 0, totalMs: 0 };
-    costsByAgent = new Map();
-    rehydrateCosts() {
-        for (const event of this.log.list({ kinds: ["status", "run_complete"] })) {
-            this.trackCost(event);
-        }
-    }
-    trackCost(event) {
-        const agentId = event.agentId ?? "unknown";
-        const entry = this.costsByAgent.get(agentId) ?? { usd: 0, turns: 0, ms: 0 };
-        if (event.kind === "status" && event.payload.state === "turn_cost") {
-            const usd = Number(event.payload.costUsd ?? 0);
-            if (usd > 0) {
-                this.costs.totalUsd += usd;
-                entry.usd += usd;
-                this.costsByAgent.set(agentId, entry);
+        // Watch the project's MCP servers, if it has any — see mcpHealth.
+        rt.startMcpHealthLoop();
+        void detectAdes()
+            .then((found) => (rt.installedKinds = Object.keys(found).filter((k) => found[k])))
+            .catch(() => { });
+        // Worktree-per-agent: prepare each adapter's checkout and respawn it there.
+        // Safe pre-start — agents are constructed lazily-started, so replacing the
+        // instance before its first turn loses nothing.
+        if (config.git?.worktreePerAgent) {
+            for (const cfg of config.agents) {
+                if (cfg.enabled === false)
+                    continue;
+                const live = rt.agents.get(cfg.id);
+                if (!live || live.capabilities.tier !== "adapter")
+                    continue;
+                await rt.ensureAgentWorktree(cfg.id);
+                await rt.agentLifecycle.retire(cfg.id);
+                rt.spawnAgent(cfg);
             }
         }
-        else if (event.kind === "run_complete") {
-            const ms = Number(event.payload.durationMs ?? 0);
-            this.costs.turns += 1;
-            this.costs.totalMs += ms;
-            entry.turns += 1;
-            entry.ms += ms;
-            this.costsByAgent.set(agentId, entry);
-        }
-    }
-    costSummary() {
-        const byAgent = [...this.costsByAgent.entries()]
-            .map(([agentId, c]) => ({ agentId, ...c }))
-            .sort((a, b) => b.usd - a.usd || b.turns - a.turns);
-        return {
-            totalUsd: this.costs.totalUsd,
-            turns: this.costs.turns,
-            totalMs: this.costs.totalMs,
-            byAgent,
-        };
+        return rt;
     }
+    rehydrateCosts() { return this.accounting.rehydrateCosts(); }
+    trackCost(event) { return this.accounting.trackCost(event); }
+    costSummary() { return this.accounting.costSummary(); }
+    budgets() { return this.accounting.budgets(); }
+    setBudget(agentId, usdPerDay) { return this.accounting.setBudget(agentId, usdPerDay); }
+    spendTodayFor(agentId, now = Date.now()) { return this.accounting.spendTodayFor(agentId, now); }
+    costSeries(days = 30, now = Date.now()) { return this.accounting.costSeries(days, now); }
+    budgetStatus(now = Date.now()) { return this.accounting.budgetStatus(now); }
+    enforceQuarantine(agentId) { return this.accounting.enforceQuarantine(agentId); }
+    enforceBudget(agentId, now = Date.now()) { return this.accounting.enforceBudget(agentId, now); }
+    liftBudgetPause(agentId, now = Date.now()) { return this.accounting.liftBudgetPause(agentId, now); }
+    quarantined() { return this.accounting.quarantined(); }
+    quarantine(agentId, reason, displaced, now = Date.now()) { return this.accounting.quarantine(agentId, reason, displaced, now); }
+    unquarantine(agentId) { return this.accounting.unquarantine(agentId); }
     /** Has .loom/config.json changed since this runtime was opened? */
     configStale() {
         return configMtimeOf(this.info.dir) > this.configMtime;
@@ -136,6 +538,64 @@ export class ProjectRuntime {
      * on an agent's turn to finish. Nothing is torn down: a role is a name, not
      * a capability, so no adapter needs restarting.
      */
+    /** An agent's picture: a small PNG/JPEG/WebP data URL, or null to clear. */
+    setAgentAvatar(agentId, dataUrl) {
+        const cfg = this.config.agents.find((a) => a.id === agentId);
+        if (!cfg)
+            return null;
+        if (dataUrl === null || dataUrl === "")
+            delete cfg.avatar;
+        else {
+            if (!/^data:image\/(png|jpeg|webp);base64,[A-Za-z0-9+/=]+$/.test(dataUrl))
+                throw new Error("a picture is a PNG, JPEG or WebP image");
+            if (dataUrl.length > 120_000)
+                throw new Error("that picture is too big — Loom keeps them small (about 96px)");
+            cfg.avatar = dataUrl;
+        }
+        this.saveConfig();
+        return { id: agentId, avatar: cfg.avatar ?? null };
+    }
+    /**
+     * Ask an agent whether it's ready — installed, signed in, model listed —
+     * without sending it a prompt (see AdapterBase.selfCheck).
+     */
+    async checkAgent(agentId) {
+        const cfg = this.config.agents.find((a) => a.id === agentId);
+        if (!cfg)
+            return null;
+        const started = Date.now();
+        if (cfg.enabled === false)
+            return { ok: false, ms: 0, checks: [{ name: "switched on", ok: false, detail: "this agent is switched off in the roster" }] };
+        const live = this.agents.get(agentId);
+        let checks;
+        if (live && live instanceof AdapterBase)
+            checks = await live.selfCheck();
+        else if (live) {
+            const ok = await live.available();
+            checks = [{ name: "available", ok, detail: ok ? "running" : "not available on this machine" }];
+        }
+        else
+            checks = [{ name: "loaded", ok: false, detail: "Loom hasn't loaded this agent — is its CLI installed?" }];
+        return { ok: checks.every((c) => c.ok), ms: Date.now() - started, checks };
+    }
+    /** Standing instructions for an agent; empty clears them. */
+    setAgentInstructions(agentId, text) {
+        const cfg = this.config.agents.find((a) => a.id === agentId);
+        if (!cfg)
+            return null;
+        const clean = text.trim().slice(0, 4000);
+        if (clean)
+            cfg.instructions = clean;
+        else
+            delete cfg.instructions;
+        this.saveConfig();
+        return { id: agentId, instructions: clean };
+    }
+    /** The block an agent's standing instructions ride in, ahead of its turn. */
+    agentInstructions(agentId) {
+        const text = this.config.agents.find((a) => a.id === agentId)?.instructions?.trim();
+        return text ? `Standing instructions for you in this project, from the person you work for:\n${text}\n` : "";
+    }
     setAgentRole(agentId, role) {
         const cfg = this.config.agents.find((a) => a.id === agentId);
         if (!cfg)
@@ -160,30 +620,115 @@ export class ProjectRuntime {
         if (wantsDefault && defaultId && !this.config.agents.some((a) => a.id === defaultId)) {
             throw new Error(`no agent "${defaultId}" in this project`);
         }
-        if (patch.brain) {
-            const b = { ...(this.config.brain ?? {}) };
-            if (patch.brain.extractor === "auto" || patch.brain.extractor === "off")
-                b.extractor = patch.brain.extractor;
-            if (typeof patch.brain.model === "string")
-                b.model = patch.brain.model.trim() || undefined;
-            this.config.brain = b;
-        }
-        if (patch.projection) {
-            const pr = { ...(this.config.projection ?? {}) };
-            if (patch.projection.mode === "template" || patch.projection.mode === "llm")
-                pr.mode = patch.projection.mode;
-            if (typeof patch.projection.model === "string")
-                pr.model = patch.projection.model.trim() || undefined;
-            this.config.projection = pr;
-        }
-        if (wantsDefault) {
-            // empty clears it; a real value was checked against the roster above
-            if (!defaultId)
-                delete this.config.defaultAgent;
-            else
-                this.config.defaultAgent = defaultId;
+        if (patch.git?.delivery !== undefined && !GIT_DELIVERIES.includes(patch.git.delivery))
+            throw new Error(`git.delivery must be one of ${GIT_DELIVERIES.join(", ")}`);
+        const previousConfig = { ...this.config }, previousContinuity = this.continuity;
+        const changingContinuity = typeof patch.brain?.continuity === "boolean" && patch.brain.continuity !== Boolean(this.config.brain?.continuity);
+        try {
+            if (patch.brain) {
+                if (changingContinuity) {
+                    if (this.anyBusy() || this.continuity?.store.activeReceipts().length || this.queue.length)
+                        throw new ContinuityError("conflict", "finish or reconcile native turns before changing continuity mode; also clear queued prompts");
+                    if (patch.brain.continuity) {
+                        this.continuity = new ContinuityEngine(this.log, this.info.id);
+                        this.harnesses.start();
+                    }
+                    else {
+                        this.continuity?.store.releaseOwner();
+                        this.continuity = null;
+                        this.harnesses.stop();
+                    }
+                }
+                const b = { ...(this.config.brain ?? {}) };
+                if (typeof patch.brain.continuity === "boolean")
+                    b.continuity = patch.brain.continuity;
+                if (patch.brain.extractor === "auto" || patch.brain.extractor === "off")
+                    b.extractor = patch.brain.extractor;
+                if (typeof patch.brain.semantic === "boolean") {
+                    if (patch.brain.semantic)
+                        b.semantic = true;
+                    else
+                        delete b.semantic;
+                }
+                if (typeof patch.brain.model === "string")
+                    b.model = patch.brain.model.trim() || undefined;
+                this.config.brain = b;
+            }
+            if (patch.projection) {
+                const pr = { ...(this.config.projection ?? {}) };
+                if (patch.projection.mode === "template" || patch.projection.mode === "llm")
+                    pr.mode = patch.projection.mode;
+                if (typeof patch.projection.model === "string")
+                    pr.model = patch.projection.model.trim() || undefined;
+                this.config.projection = pr;
+            }
+            if (wantsDefault) {
+                // empty clears it; a real value was checked against the roster above
+                if (!defaultId)
+                    delete this.config.defaultAgent;
+                else
+                    this.config.defaultAgent = defaultId;
+            }
+            if (patch.git) {
+                const g = { ...(this.config.git ?? {}) };
+                for (const k of [
+                    "commitPerTurn",
+                    "branchPerTask",
+                    "worktreePerAgent",
+                    "mergeOnHandoff",
+                ]) {
+                    if (typeof patch.git[k] === "boolean") {
+                        if (patch.git[k])
+                            g[k] = true;
+                        else
+                            delete g[k];
+                    }
+                }
+                if (patch.git.delivery !== undefined) {
+                    if (patch.git.delivery === "none")
+                        delete g.delivery;
+                    else
+                        g.delivery = patch.git.delivery;
+                }
+                if (Object.keys(g).length)
+                    this.config.git = g;
+                else
+                    delete this.config.git;
+                // worktreePerAgent takes effect for agents spawned from here on; the
+                // Settings screen says so rather than pretending it's instant.
+            }
+            if (patch.safety) {
+                if (typeof patch.safety.snapshotBeforeRoutes === "boolean") {
+                    if (patch.safety.snapshotBeforeRoutes)
+                        this.config.safety = { snapshotBeforeRoutes: true };
+                    else
+                        delete this.config.safety;
+                }
+            }
+            this.saveConfig();
         }
-        this.saveConfig();
+        catch (error) {
+            if (this.continuity !== previousContinuity) {
+                this.continuity?.store.releaseOwner();
+                this.continuity = previousContinuity;
+                previousContinuity?.store.claimOwner();
+                if (previousContinuity)
+                    this.harnesses.start();
+                else
+                    this.harnesses.stop();
+            }
+            for (const key of Object.keys(this.config))
+                delete this.config[key];
+            Object.assign(this.config, previousConfig);
+            throw error;
+        }
+        if (changingContinuity) {
+            this.briefings.cancelExtraction();
+            this.turns.turnText.clear();
+            this.briefings.pendingBriefings.clear();
+        }
+        if (changingContinuity || typeof patch.brain?.semantic === "boolean")
+            void this.briefings.configureSemantic(!this.continuity && this.config.brain?.semantic === true);
         return this.config;
     }
     /**
@@ -196,13 +741,23 @@ export class ProjectRuntime {
     settings() {
         return {
             brain: {
+                continuity: Boolean(this.config.brain?.continuity),
                 extractor: this.config.brain?.extractor === "off" ? "off" : "auto",
                 model: this.config.brain?.model ?? "",
+                semantic: Boolean(this.config.brain?.semantic),
             },
             projection: {
                 mode: this.config.projection?.mode === "llm" ? "llm" : "template",
                 model: this.config.projection?.model ?? "",
             },
+            git: {
+                commitPerTurn: Boolean(this.config.git?.commitPerTurn),
+                branchPerTask: Boolean(this.config.git?.branchPerTask),
+                worktreePerAgent: Boolean(this.config.git?.worktreePerAgent),
+                mergeOnHandoff: Boolean(this.config.git?.mergeOnHandoff),
+                delivery: this.config.git?.delivery ?? "none",
+            },
+            safety: { snapshotBeforeRoutes: Boolean(this.config.safety?.snapshotBeforeRoutes) },
             defaultAgent: this.config.defaultAgent ?? "",
             agents: this.config.agents.map((a) => ({ id: a.id, kind: a.kind, role: a.role })),
         };
@@ -222,13 +777,40 @@ export class ProjectRuntime {
         if (!knownAgentKinds().includes(kind)) {
             throw new Error(`unknown agent kind "${kind}" (known: ${knownAgentKinds().join(", ")})`);
         }
-        const id = (opts.id ?? kind).trim().slice(0, 40);
+        // Known is not the same as offered. This is the endpoint the "add agent"
+        // rail drives, and the rail only ever lists ADES. Accepting a kind that no
+        // view offers meant a withdrawn agent could be put in a roster by guessing
+        // its name, and then sat there unadvertised and unexplained. Refuse it
+        // here, and name what replaced it.
+        if (isWithdrawnKind(kind)) {
+            const replacement = kind === "antigravity" ? ' — use "antigravity-cli"' : "";
+            throw new Error(`"${kind}" is no longer offered${replacement}`);
+        }
+        // A second session of the same kind is a feature, not a mistake.
+        //
+        // The roster has always been keyed by instance id with kind alongside it, so
+        // two Claude Code sessions in one project were representable — but adding
+        // one threw, because the id defaulted to the kind and the kind was taken. A
+        // caller who names the instance gets that name; a caller who doesn't gets
+        // the next free suffix, so "add another" needs no ceremony. Both sessions
+        // read and write the one project brain: memory import dedupes by file path,
+        // and units are project-scoped, so nothing has to change for them to share.
+        const explicit = opts.id?.trim().slice(0, 40);
+        if (explicit && this.config.agents.some((a) => a.id === explicit)) {
+            throw new Error(`"${explicit}" is already in this project`);
+        }
+        const id = explicit || this.nextInstanceId(kind);
         if (!id)
             throw new Error("an agent needs an id");
-        if (this.config.agents.some((a) => a.id === id)) {
-            throw new Error(`"${id}" is already in this project`);
-        }
-        const cfg = { id, kind, role: (opts.role ?? kind).trim().slice(0, 40) || kind };
+        // A `model` agent with no model is an agent that refuses every turn, so
+        // the options that make it work are settable as it's added rather than in
+        // a second step nobody is told about.
+        const cfg = {
+            id,
+            kind,
+            role: (opts.role ?? kind).trim().slice(0, 40) || kind,
+            ...(opts.options && Object.keys(opts.options).length ? { options: opts.options } : {}),
+        };
         // Build it before saving. A config entry with no live agent behind it makes
         // status() throw the moment anything asks — this.agent(id) doesn't find it —
         // so the project 500s on every poll and the roster you just changed becomes
@@ -239,6 +821,73 @@ export class ProjectRuntime {
         this.saveConfig();
         return cfg;
     }
+    /**
+     * The next free instance id for a kind: `codex`, then `codex-2`, `codex-3`.
+     *
+     * The bare kind stays the first instance's id so existing projects, configs
+     * and route specs that name `codex` keep meaning what they meant.
+     */
+    nextInstanceId(kind) {
+        const taken = new Set(this.config.agents.map((a) => a.id));
+        if (!taken.has(kind))
+            return kind;
+        for (let n = 2; n < 100; n++) {
+            const candidate = `${kind}-${n}`;
+            if (!taken.has(candidate))
+                return candidate;
+        }
+        throw new Error(`too many ${kind} sessions in this project`);
+    }
+    /** How many instances of each kind the roster holds. */
+    instanceCounts() {
+        const counts = {};
+        for (const a of this.config.agents)
+            counts[a.kind] = (counts[a.kind] ?? 0) + 1;
+        return counts;
+    }
+    /**
+     * Where this agent works: its own worktree when the project opted in, the
+     * shared tree otherwise.
+     *
+     * With git.worktreePerAgent on, each adapter gets a sibling checkout on its
+     * own branch (agent/<id>), so two agents editing at once cannot collide in
+     * the filesystem. The trade is stated where it's decided: merging is
+     * MANUAL in this version — the branches are ordinary git branches and
+     * `git merge agent/<id>` is the handoff of record. Auto-merge on baton
+     * handoff is a different feature with different failure modes (conflicts
+     * mid-handoff), deliberately not smuggled in here.
+     */
+    agentDirs = new Map();
+    agentDir(agentId) {
+        return this.agentDirs.get(agentId) ?? this.info.dir;
+    }
+    async ensureAgentWorktree(agentId) {
+        const existing = this.agentDirs.get(agentId);
+        if (existing)
+            return existing;
+        const wt = worktreePath(this.info.dir, `agent-${agentId}`);
+        if (!fs.existsSync(wt)) {
+            try {
+                await gitAddWorktree(this.info.dir, {
+                    slug: `agent-${agentId}`,
+                    newBranch: `agent/${agentId}`,
+                });
+            }
+            catch (err) {
+                // Branch already exists from a previous run — attach to it instead.
+                try {
+                    await gitAddWorktree(this.info.dir, { slug: `agent-${agentId}`, branch: `agent/${agentId}` });
+                }
+                catch {
+                    logbook.warn("git", `worktree for ${agentId} could not be created — falling back to the shared tree`, String(err), this.info.id);
+                    this.agentDirs.set(agentId, this.info.dir);
+                    return this.info.dir;
+                }
+            }
+        }
+        this.agentDirs.set(agentId, wt);
+        return wt;
+    }
     /**
      * Create one agent and subscribe to it, exactly as the constructor does.
      *
@@ -247,18 +896,117 @@ export class ProjectRuntime {
      * there when the project opened.
      */
     spawnAgent(cfg) {
-        const agent = createAgent(cfg, this.info.dir);
-        this.agents.set(cfg.id, agent);
-        agent.onEvent((e) => {
-            const chat = this.turnChat.get(agent.id);
-            const event = this.log.append({
-                kind: e.kind,
-                agentId: agent.id,
-                ...(chat ? { chat } : {}),
-                payload: e.payload,
-            });
-            this.afterAgentEvent(event);
+        // The project id rides along so an adapter can file approvals ("always
+        // ask") against the right project — see core/approvals.ts.
+        const agent = createAgent({ ...cfg, options: { ...this.policyOptions(cfg), loomProject: this.info.id } }, this.agentDir(cfg.id));
+        // What this turn has typed since its last finished message. A turn that
+        // is stopped (or dies) mid-reply never sends that message, and the words
+        // you watched arrive would vanish — so they're kept, marked partial.
+        // Provider agents keep their own buffers (see providers/ingestion.ts).
+        let typed = "";
+        const keepsPartial = !(agent instanceof ProviderAgent);
+        agent.onStream?.((d) => {
+            if (!d.reasoning)
+                typed += d.text;
+            this.liveText({ agentId: agent.id, chat: this.turns.turnChat.get(agent.id) ?? MAIN_CHAT, ...d });
+        });
+        this.agentLifecycle.install(agent, (e) => {
+            try {
+                const runId = typeof e.payload.loomRunId === "string" ? e.payload.loomRunId : undefined;
+                const liveRun = runId ? this.continuity?.isLiveRun(runId) : true;
+                const chat = (runId ? this.continuity?.eventChat(runId) : undefined) ?? this.turns.turnChat.get(agent.id);
+                let payload = e.payload;
+                // Enrich the completed turn so its gen_ai span carries system + model +
+                // cost (adapters only put tokens on run_complete). The kind is known
+                // here; the model prefers what the adapter actually used, else the
+                // configured override; the cost is the turn_cost stashed a moment ago.
+                const p = e.payload;
+                if (liveRun && e.kind === "status" && p.state === "turn_cost") {
+                    const usd = Number(p.costUsd ?? 0);
+                    if (usd > 0)
+                        this.turns.pendingCost.set(agent.id, usd);
+                }
+                else if (liveRun && e.kind === "run_complete") {
+                    const model = (typeof p.model === "string" && p.model) ||
+                        (typeof cfg.options?.model === "string" ? cfg.options.model : undefined);
+                    const cost = this.turns.pendingCost.get(agent.id);
+                    this.turns.pendingCost.delete(agent.id);
+                    payload = {
+                        ...p,
+                        adapter: cfg.kind,
+                        ...(model ? { model } : {}),
+                        ...(cost !== undefined ? { costUsd: cost } : {}),
+                    };
+                }
+                // An agent that stops to ask you something is the whole reason Loom
+                // exists: the next queued prompt would answer a question you never saw,
+                // so the queue waits for you instead. Answering goes out immediately —
+                // a paused queue holds what's lined up, not what you type now.
+                if (liveRun && e.kind === "needs_input")
+                    this.holdQueueFor(agent.id);
+                // A question asked through the agent's tool blocks its turn until answered: remember it,
+                // so a reply typed in the chat reaches it (turns.ts) and status stays honest.
+                if (e.kind === "needs_input" && typeof p.requestId === "string" && p.responseMode !== "message") {
+                    const ids = Array.isArray(p.questions) ? p.questions.map((q, i) => String(q.id ?? i)) : [];
+                    this.openQuestions.set(agent.id, { requestId: p.requestId, chat: chat ?? MAIN_CHAT, ids });
+                }
+                if (e.kind === "status" && p.state === "question_answered" && this.openQuestions.get(agent.id)?.requestId === p.requestId) {
+                    this.openQuestions.delete(agent.id);
+                }
+                // Any terminal event stops the stale-session clock — a turn that ended in
+                // an error is over, not hung.
+                const turnOver = e.kind === "run_complete" || e.kind === "error" || (e.kind === "status" && p.state === "interrupted");
+                if (turnOver && !this.continuity) {
+                    this.turns.busySince.delete(agent.id);
+                }
+                if (turnOver)
+                    this.openQuestions.delete(agent.id);
+                if (keepsPartial) {
+                    if (e.kind === "message" && !p.reasoning)
+                        typed = "";
+                    if (turnOver && typed.trim()) {
+                        this.log.append({ kind: "message", agentId: agent.id, ...(chat ? { chat } : {}), payload: { text: typed, partial: true } });
+                    }
+                    if (turnOver)
+                        typed = "";
+                }
+                const event = this.log.append({
+                    kind: e.kind,
+                    agentId: agent.id,
+                    ...(chat ? { chat } : {}),
+                    payload,
+                });
+                this.continuity?.ingest(event);
+                this.nativeUsage.observe(event);
+                if (liveRun)
+                    this.afterAgentEvent(event);
+                if (liveRun && e.kind === "message" && p.proposedPlan === true)
+                    this.saveProposedPlan(agent.id, chat, String(p.text ?? ""));
+                if (turnOver && !this.continuity)
+                    this.kickQueue();
+            }
+            catch {
+                // A failed durable ingest is a project fault, not a disposable UI
+                // observer. Stop foreground work and keep its receipt uncertain.
+                this.journalFailure = new ContinuityError("recovery_required", "project journal ingest failed; native execution was interrupted; reopen and reconcile before continuing");
+                if (isAdapter(agent) && agent.busy())
+                    void agent.interrupt().catch(() => { });
+            }
         });
+        if (agent instanceof ProviderAgent) {
+            agent.onLive((d) => {
+                if (this.closed || this.agents.get(agent.id) !== agent)
+                    return;
+                this.live.push(d);
+                // The same text feeds the thread's live reply (the `stream` frames and
+                // the reload-safe snapshot), as every other agent's does.
+                if (d.streamKind === "assistant_text" || d.streamKind === "reasoning_text" || d.streamKind === "reasoning_summary_text") {
+                    this.liveText({ agentId: agent.id, chat: d.chat, text: d.delta, ...(d.streamKind === "assistant_text" ? {} : { reasoning: true }) });
+                }
+            });
+            agent.onLiveItem((i) => { if (!this.closed && this.agents.get(agent.id) === agent)
+                this.live.pushItem(i); });
+        }
         return agent;
     }
     /**
@@ -277,7 +1025,7 @@ export class ProjectRuntime {
             throw new Error(`"${agentId}" holds the baton — hand it to someone else first`);
         }
         const live = this.agents.get(agentId);
-        if (live && isAdapter(live) && live.busy()) {
+        if (live && isAdapter(live) && (live.busy() || this.turns.busySince.has(agentId))) {
             throw new Error(`"${agentId}" is mid-turn — interrupt it first`);
         }
         // Its events stay in the log: the history happened, and a roster change
@@ -285,8 +1033,7 @@ export class ProjectRuntime {
         this.config.agents = this.config.agents.filter((a) => a.id !== agentId);
         this.saveConfig();
         if (live) {
-            void Promise.resolve(live.stop()).catch(() => { });
-            this.agents.delete(agentId);
+            void this.agentLifecycle.retire(agentId);
         }
         return { removed: agentId };
     }
@@ -294,40 +1041,114 @@ export class ProjectRuntime {
      * Point an agent at a different model.
      *
      * The model is read once, when the adapter is constructed (createAgent hands
-     * it cfg.options), so changing it means building a fresh agent — which drops
-     * the CLI session the old one was resuming. That's the right behaviour for a
-     * model switch: continuing one model's conversation on another model is not a
-     * thing the underlying CLIs support anyway. Refused mid-turn, because swapping
-     * the process out from under a running turn would strand it.
+     * it cfg.options), so changing it means building a fresh adapter instance.
+     * Native resume data stays persisted; each adapter decides whether its harness
+     * can reuse it. Refused while a turn is preparing or running, because swapping
+     * the process out from under that turn would strand it.
      *
      * An empty model clears the override, so the CLI falls back to its own default
      * — the honest "Default" the picker offers.
      */
-    setAgentModel(agentId, model) {
+    setAgentModel(agentId, model, provider) {
         const cfg = this.config.agents.find((a) => a.id === agentId);
         if (!cfg)
             throw new Error(`unknown agent "${agentId}"`);
         const live = this.agents.get(agentId);
-        if (live && isAdapter(live) && live.busy()) {
+        if (live && isAdapter(live) && (live.busy() || this.turns.busySince.has(agentId))) {
             throw new Error(`"${agentId}" is mid-turn — wait for it to finish, then switch models`);
         }
-        const next = model.trim().slice(0, 80);
+        // OpenRouter ids run long ("provider/family-size-variant:free"); 80 cut
+        // real ones off mid-name.
+        const next = model.trim().slice(0, 200);
         const options = { ...(cfg.options ?? {}) };
         if (next)
             options.model = next;
         else
             delete options.model;
+        // A model agent's pick names its provider too (the list spans them all).
+        if (cfg.kind === "model" && provider?.trim())
+            options.provider = provider.trim().toLowerCase();
         cfg.options = options;
         // Rebuild so the new model actually takes: stop the old process, spawn a
         // replacement subscribed exactly as the constructor's loop does.
         if (live) {
-            void Promise.resolve(live.stop()).catch(() => { });
-            this.agents.delete(agentId);
+            void this.agentLifecycle.retire(agentId);
         }
         this.spawnAgent(cfg);
         this.saveConfig();
         return cfg;
     }
+    /**
+     * A model agent's sampling: temperature (0–2) and the reply's token cap.
+     * Null clears one back to the provider's default. Rebuilt like a model
+     * switch, because the adapter reads them when it's built.
+     */
+    setAgentSampling(agentId, s) {
+        const cfg = this.config.agents.find((a) => a.id === agentId);
+        if (!cfg)
+            throw new Error(`unknown agent "${agentId}"`);
+        if (cfg.kind !== "model")
+            throw new Error(`"${agentId}" is a ${cfg.kind} — sampling is set in its own CLI, not here`);
+        const live = this.agents.get(agentId);
+        if (live && isAdapter(live) && (live.busy() || this.turns.busySince.has(agentId)))
+            throw new Error(`"${agentId}" is mid-turn — wait for it to finish`);
+        const options = { ...(cfg.options ?? {}) };
+        if (s.temperature !== undefined) {
+            if (s.temperature === null)
+                delete options.temperature;
+            else if (!Number.isFinite(s.temperature) || s.temperature < 0 || s.temperature > 2)
+                throw new Error("temperature must be between 0 and 2");
+            else
+                options.temperature = Math.round(s.temperature * 100) / 100;
+        }
+        if (s.maxTokens !== undefined) {
+            if (s.maxTokens === null)
+                delete options.maxTokens;
+            else if (!Number.isInteger(s.maxTokens) || s.maxTokens < 16 || s.maxTokens > 200_000)
+                throw new Error("max tokens must be a whole number from 16 to 200000");
+            else
+                options.maxTokens = s.maxTokens;
+        }
+        cfg.options = options;
+        if (live)
+            void this.agentLifecycle.retire(agentId);
+        this.spawnAgent(cfg);
+        this.saveConfig();
+        return cfg;
+    }
+    /**
+     * Choose how much an agent may do without asking: bypass | auto | ask.
+     *
+     * Same shape as setAgentModel — the mode is read when the adapter is built
+     * (it becomes CLI flags, or the env of opencode's server), so the agent is
+     * rebuilt. Refused mid-turn for the same reason.
+     */
+    setAgentPermissions(agentId, mode) {
+        if (!isPermissionMode(mode))
+            throw new Error(`permissions must be bypass, auto or ask`);
+        const cfg = this.config.agents.find((a) => a.id === agentId);
+        if (!cfg)
+            throw new Error(`unknown agent "${agentId}"`);
+        const why = unsupportedReason(cfg.kind, mode);
+        if (why)
+            throw new Error(`"${mode}" isn't available for ${cfg.kind}: ${why}`);
+        // D38: a team-shared project can't go looser than loom.team.json allows.
+        if (this.teamPolicy && cappedPermission(this.teamPolicy, mode, true) !== mode) {
+            throw new Error(`team policy caps permissions at "${this.teamPolicy.permissions.ceiling}" on this repo (loom.team.json)`);
+        }
+        const live = this.agents.get(agentId);
+        if (live && isAdapter(live) && (live.busy() || this.turns.busySince.has(agentId))) {
+            throw new Error(`"${agentId}" is mid-turn — wait for it to finish, then change its permissions`);
+        }
+        cfg.options = { ...(cfg.options ?? {}), permissions: mode };
+        if (live) {
+            void this.agentLifecycle.retire(agentId);
+        }
+        if (cfg.enabled !== false)
+            this.spawnAgent(cfg);
+        this.saveConfig();
+        return cfg;
+    }
     /** Write the roster, without tripping our own staleness check. */
     saveConfig() {
         writeProjectConfig(this.info.dir, this.config);
@@ -335,6 +1156,279 @@ export class ProjectRuntime {
         // schedule a pointless reload
         this.configMtime = configMtimeOf(this.info.dir);
     }
+    // ── Skills (SKILL.md context blocks injected into the briefing) ──
+    /**
+     * Where skills live — every layout, not just ours.
+     *
+     * See core/skills.ts#discoverSkillRoots for the list and the precedence. This
+     * used to be two hardcoded directories, which meant a machine with sixty
+     * skills in `~/.claude` reported the one that shipped in this repo.
+     */
+    skillRoots() {
+        return discoverSkillRoots(this.info.dir, path.join(process.cwd(), "skills"));
+    }
+    /** The directory this project's own skills are installed into. */
+    ownSkillsDir() {
+        return path.join(this.info.dir, "skills");
+    }
+    /** All available skills with this project's enabled state. */
+    getSkills() {
+        return loadSkills(this.skillRoots(), this.config.skills ?? {});
+    }
+    /**
+     * The catalog the picker renders: every discoverable skill, without the body.
+     *
+     * The bodies are the entire point of a skill and also the reason this exists
+     * separately from `getSkills()` — a machine with sixty installed skills has
+     * megabytes of markdown, and a list screen needs none of it.
+     *
+     * `installed` means "this file is inside the project directory", which is the
+     * same question `removeSkill` asks: those are the only ones Loom put there
+     * and the only ones it may delete.
+     */
+    skillsCatalog() {
+        const own = this.ownSkillsDir();
+        return this.getSkills().map((s) => ({
+            id: s.id,
+            name: s.name,
+            description: s.description,
+            enabled: s.enabled,
+            origin: s.origin,
+            source: s.source,
+            installed: path.resolve(s.source) === path.resolve(own),
+        }));
+    }
+    /**
+     * Install a skill from a local directory or a git remote, into this project.
+     *
+     * Throws SkillInstallError for anything the user can fix (bad URL, unsafe id,
+     * a name that already exists) — the route turns those into a 400 with the
+     * message, because "invalid input" tells you nothing when the real answer is
+     * "that repo has no SKILL.md in it".
+     */
+    async installSkill(input) {
+        const gitUrl = String(input.gitUrl ?? "").trim();
+        const dir = String(input.dir ?? "").trim();
+        if (gitUrl && dir)
+            throw new SkillInstallError("give either gitUrl or dir, not both");
+        if (gitUrl)
+            return installSkillFromGit(gitUrl, this.info.dir, { force: input.force === true });
+        if (dir)
+            return installSkillFromDir(dir, this.info.dir, { force: input.force === true });
+        throw new SkillInstallError("nothing to install — pass gitUrl or dir");
+    }
+    /**
+     * Delete a project-installed skill from disk.
+     *
+     * Refused for anything outside the project. A skill in `~/.claude/skills` is
+     * the user's, shared with every other tool they run, and a project-scoped
+     * "remove" button that reached out and deleted it would be a data-loss bug
+     * dressed as a feature. The refusal says where the skill actually lives so
+     * the answer ("go delete it yourself, here") is in the message.
+     *
+     * The enabled flag goes with it: leaving `skills[id] = true` in config for a
+     * directory that no longer exists means the next turn's briefing silently
+     * loses a block the config still claims is on.
+     */
+    removeSkill(id) {
+        const skill = this.getSkills().find((s) => s.id === id);
+        if (!skill)
+            throw new SkillInstallError(`no skill "${id}"`);
+        const own = this.ownSkillsDir();
+        if (path.resolve(skill.source) !== path.resolve(own)) {
+            throw new SkillInstallError(`"${id}" lives in ${skill.source}, outside this project — Loom didn't install it and won't delete it`);
+        }
+        const dir = path.join(own, skill.id);
+        fs.rmSync(dir, { recursive: true, force: true });
+        if (this.config.skills?.[skill.id])
+            this.setSkillEnabled(skill.id, false);
+        return { removed: true, id: skill.id, path: dir };
+    }
+    /**
+     * Switch one agent off (or back on) without taking it out of the roster.
+     *
+     * Refused while it holds the baton or is mid-turn, for the same reason
+     * `removeAgent` is: stopping it there would strand the lock on something that
+     * no longer exists, and the thread would show a turn nothing is running. The
+     * refusal names the fix rather than just saying no.
+     *
+     * Off really means off — the agent is stopped and dropped from the live map,
+     * not merely hidden. A roster entry that still answers is the kind of "off"
+     * that costs money.
+     */
+    setAgentEnabled(agentId, enabled) {
+        const cfg = this.config.agents.find((a) => a.id === agentId);
+        if (!cfg)
+            throw new Error(`unknown agent "${agentId}"`);
+        const on = enabled !== false;
+        if (!on) {
+            if (this.validHolder() === agentId) {
+                throw new Error(`"${agentId}" holds the baton — hand it off before switching it off`);
+            }
+            const live = this.agents.get(agentId);
+            if (live && isAdapter(live) && (live.busy() || this.turns.busySince.has(agentId))) {
+                throw new Error(`"${agentId}" is mid-turn — interrupt it first`);
+            }
+        }
+        cfg.enabled = on;
+        this.saveConfig();
+        const live = this.agents.get(agentId);
+        if (on && !live) {
+            this.spawnAgent(cfg); // bring it back to life
+        }
+        else if (!on && live) {
+            void this.agentLifecycle.retire(agentId);
+        }
+        this.log.append({ kind: on ? "agent_join" : "agent_leave", agentId, payload: { enabled: on } });
+        return { id: agentId, enabled: on };
+    }
+    /** Enable/disable one skill for this project; returns the new enabled map. */
+    setSkillEnabled(id, on) {
+        const skills = { ...(this.config.skills ?? {}) };
+        if (on)
+            skills[id] = true;
+        else
+            delete skills[id];
+        this.config.skills = skills;
+        this.saveConfig();
+        return skills;
+    }
+    /** The ACTIVE SKILLS block to prepend to a briefing, or "" when none are on. */
+    activeSkillsBlock() {
+        return buildSkillsBlock(this.getSkills());
+    }
+    // ── MCP servers ──
+    static DEFAULT_MCPS = [
+        { name: "GitHub", url: "", description: "issues, PRs, code search", icon: "github" },
+        { name: "Supabase", url: "", description: "query, schema, migrations", icon: "database" },
+        { name: "SigNoz", url: "", description: "traces, metrics, alerts", icon: "chart" },
+        { name: "Linear", url: "", description: "issues, projects, cycles", icon: "linear" },
+        { name: "Slack", url: "", description: "messages, channels, users", icon: "slack" },
+        { name: "Filesystem", url: "", description: "read/write local files", icon: "folder" },
+    ];
+    /** Configured MCP servers, merged over the built-in suggestions (deduped by name). */
+    getMcps() {
+        const saved = this.config.mcps ?? [];
+        const byName = new Map(ProjectRuntime.DEFAULT_MCPS.map((m) => [m.name, { ...m }]));
+        for (const m of saved)
+            byName.set(m.name, { ...(byName.get(m.name) ?? {}), ...m });
+        return [...byName.values()];
+    }
+    /**
+     * The same list, with `connected` MEASURED rather than assumed.
+     *
+     * The old reading of that field was "a url is typed into this row", which the
+     * UI rendered as a green "connected" badge — a claim about a live connection
+     * made without ever opening one. Here every configured URL gets a bounded
+     * probe (see core/mcp.ts) and the answer is whatever came back. Rows with no
+     * URL aren't probed and report false, because "not configured" is not
+     * "connected".
+     */
+    // -------------------------------------------------------------------------
+    // MCP health
+    // -------------------------------------------------------------------------
+    /**
+     * Live health per configured MCP server, from the background poll.
+     *
+     * A server that died used to stay listed as connected, and its tools failed
+     * silently mid-turn — the agent just found them gone. The poll notices the
+     * transition, says so in the Console, and while a server is down it is left
+     * out of turn injection entirely: an absent tool the agent never saw beats a
+     * present tool that throws. When the server answers again it is included
+     * again automatically — that is the whole reconnect story for per-turn
+     * config files; there is no persistent connection to rebuild.
+     */
+    mcpHealth = new Map();
+    mcpTimer = null;
+    /** Poll every configured server once; log the transitions. */
+    async pollMcpHealth(timeoutMs = 2_000) {
+        const mcps = this.getMcps().filter((m) => m.enabledForSession !== false);
+        for (const m of mcps) {
+            const url = String(m.url ?? "").trim();
+            if (!url)
+                continue; // stdio servers have no probe-able endpoint
+            const up = await probeMcpServer(url, timeoutMs).catch(() => false);
+            const prev = this.mcpHealth.get(m.name);
+            const failures = up ? 0 : (prev?.failures ?? 0) + 1;
+            this.mcpHealth.set(m.name, { up, failures, probedAt: Date.now() });
+            if (prev && prev.up && !up) {
+                logbook.error("mcp", `"${m.name}" stopped answering — its tools are withheld from turns until it returns`, url, this.info.id);
+            }
+            else if (prev && !prev.up && up) {
+                logbook.info("mcp", `"${m.name}" is back — its tools rejoin the next turn`, undefined, this.info.id);
+            }
+        }
+        // Forget servers that were removed from config.
+        const names = new Set(mcps.map((m) => m.name));
+        for (const k of [...this.mcpHealth.keys()])
+            if (!names.has(k))
+                this.mcpHealth.delete(k);
+    }
+    mcpHealthReport() {
+        return Object.fromEntries(this.mcpHealth);
+    }
+    /**
+     * The servers a turn should carry: everything not known-down.
+     *
+     * Unknown (never probed — a fresh daemon, a just-added server) passes
+     * through; refusing a server nobody has measured would block first use on a
+     * poll that hasn't run yet. Only a measured, repeated failure withholds.
+     */
+    healthyMcps() {
+        return (this.config.mcps ?? []).filter((m) => {
+            const h = this.mcpHealth.get(m.name);
+            return !h || h.up || h.failures < 2;
+        });
+    }
+    startMcpHealthLoop(intervalMs = Number(process.env.LOOM_MCP_POLL_MS) || 60_000) {
+        if (this.mcpTimer || !(this.config.mcps ?? []).length)
+            return;
+        this.mcpTimer = setInterval(() => {
+            void this.pollMcpHealth().catch(() => { });
+        }, intervalMs);
+        this.mcpTimer.unref?.();
+    }
+    async getMcpsProbed(timeoutMs = 2_000) {
+        const mcps = this.getMcps();
+        const reachable = await probeMcpServers(mcps, timeoutMs).catch(() => ({}));
+        const probedAt = Date.now();
+        return mcps.map((m) => ({
+            ...m,
+            connected: reachable[m.name] ?? false,
+            ...(m.name in reachable ? { probedAt } : {}),
+        }));
+    }
+    /** Add or update one MCP (by name); persists only the real (non-default) fields. */
+    upsertMcp(mcp) {
+        const saved = (this.config.mcps ?? []).filter((m) => m.name !== mcp.name);
+        saved.push(mcp);
+        this.config.mcps = saved;
+        this.saveConfig();
+        return this.getMcps();
+    }
+    /**
+     * Remove a configured MCP server by name.
+     *
+     * `removed` is false when nothing was configured under that name, which the
+     * route answers with a 404 rather than a cheerful 200 — "deleted a thing that
+     * wasn't there" is the kind of success that hides a typo in a server name.
+     *
+     * Note what this does to a name that is also one of the built-in suggestion
+     * rows (GitHub, Slack, …): the *configuration* goes, and the suggestion comes
+     * back with an empty url, because those rows aren't installed servers, they're
+     * placeholders getMcps() merges in. That is the honest outcome — the server is
+     * gone, and what's left is an offer to add one — but a caller diffing the list
+     * for the name will still find it, so it should compare `url`/`command`.
+     */
+    removeMcp(name) {
+        const saved = this.config.mcps ?? [];
+        const kept = saved.filter((m) => m.name !== name);
+        if (kept.length === saved.length)
+            return { removed: false, mcps: this.getMcps() };
+        this.config.mcps = kept;
+        this.saveConfig();
+        return { removed: true, mcps: this.getMcps() };
+    }
     // -------------------------------------------------------------------------
     // Chats — several conversations, one brain
     // -------------------------------------------------------------------------
@@ -346,51 +1440,263 @@ export class ProjectRuntime {
      */
     chats() {
         const stored = readProjectState(this.info.dir).chats ?? [];
-        return [
-            { id: MAIN_CHAT, title: "Main", createdAt: 0 },
-            ...stored.filter((c) => c.id !== MAIN_CHAT),
-        ];
+        let last;
+        try {
+            last = this.log.lastReplyIds();
+        }
+        catch {
+            last = new Map(); // an unread dot is a nicety; the list must still load
+        }
+        const main = stored.find((c) => c.id === MAIN_CHAT);
+        const groups = this.chatGroups();
+        return this.conversations.chats().map((c) => {
+            // main is stored only once it has stars or ratings to keep
+            const withMain = c.id === MAIN_CHAT && main
+                ? { ...c, ...(main.starred ? { starred: main.starred } : {}), ...(main.ratings ? { ratings: main.ratings } : {}) }
+                : c;
+            const g = c.id === MAIN_CHAT ? undefined : groups.get(c.id);
+            const withGroup = g ? { ...withMain, group: g } : withMain;
+            return last.has(c.id) ? { ...withGroup, lastReplyId: last.get(c.id) } : withGroup;
+        });
     }
-    createChat(title) {
-        const state = readProjectState(this.info.dir);
-        const chat = {
-            id: newId(4),
-            // numbered, not "New chat" — the button already says New chat, and a
-            // sidebar of identical rows tells you nothing
-            title: title.trim().slice(0, 60) || `Chat ${(state.chats ?? []).length + 2}`,
-            createdAt: Date.now(),
-        };
-        state.chats = [...(state.chats ?? []), chat];
-        writeProjectState(this.info.dir, state);
-        return chat;
+    /** Which run, race, crew or import made each thread (ChatInfo.group). */
+    chatGroups() {
+        const out = new Map();
+        try {
+            for (const run of this.orchestra.list()) {
+                const g = { kind: run.race ? "race" : "orchestra", id: run.id, title: run.goal, status: run.status, at: run.createdAt };
+                // a run that answered in a thread you already had leaves that thread alone
+                if (!run.inPlace && run.chat)
+                    out.set(run.chat, g);
+                for (const t of run.tasks)
+                    if (t.chat)
+                        out.set(t.chat, g);
+            }
+        }
+        catch { /* no runs yet */ }
+        try {
+            for (const crew of this.crews.list()) {
+                const g = { kind: "crew", id: crew.id, title: crew.name, ...(crew.state.goal ? { status: crew.state.goal.status } : {}), at: crew.state.goal?.startedAt ?? 0 };
+                if (crew.state.channel)
+                    out.set(crew.state.channel, g);
+                for (const chat of Object.values(crew.state.threads ?? {}))
+                    out.set(chat, g);
+            }
+        }
+        catch { /* no crews yet */ }
+        for (const chat of Object.values(readProjectState(this.info.dir).imports ?? {})) {
+            if (!out.has(chat))
+                out.set(chat, { kind: "import", id: "imports", title: "Imported", at: 0 });
+        }
+        return out;
     }
-    renameChat(id, title) {
+    /** Pin, archive or file a thread. Main is always first and always there. */
+    setChatFlags(id, flags) {
         if (id === MAIN_CHAT)
-            return null; // main's name is not yours to change
+            return null;
         const state = readProjectState(this.info.dir);
         const chat = (state.chats ?? []).find((c) => c.id === id);
         if (!chat)
             return null;
-        chat.title = title.trim().slice(0, 60) || chat.title;
+        for (const k of ["pinned", "archived"]) {
+            if (flags[k] === undefined)
+                continue;
+            if (flags[k])
+                chat[k] = true;
+            else
+                delete chat[k];
+        }
+        if (flags.folder !== undefined) {
+            const name = String(flags.folder ?? "").replace(/\s+/g, " ").trim().slice(0, 40);
+            if (name)
+                chat.folder = name;
+            else
+                delete chat.folder;
+        }
         writeProjectState(this.info.dir, state);
         return chat;
     }
+    /** Rate a reply up or down (0 clears). Main included. */
+    rateMessage(chatId, eventId, agent, v) {
+        if (!Number.isInteger(eventId) || eventId <= 0 || !agent)
+            return null;
+        const state = readProjectState(this.info.dir);
+        state.chats = state.chats ?? [];
+        let chat = state.chats.find((c) => c.id === chatId);
+        if (!chat) {
+            if (chatId !== MAIN_CHAT)
+                return null;
+            chat = { id: MAIN_CHAT, title: "Main", createdAt: 0 };
+            state.chats.push(chat);
+        }
+        const ratings = { ...(chat.ratings ?? {}) };
+        if (v === 1 || v === -1)
+            ratings[String(eventId)] = { v, agent };
+        else
+            delete ratings[String(eventId)];
+        const keys = Object.keys(ratings);
+        for (const k of keys.slice(0, Math.max(0, keys.length - 500)))
+            delete ratings[k]; // bounded
+        if (Object.keys(ratings).length)
+            chat.ratings = ratings;
+        else
+            delete chat.ratings;
+        writeProjectState(this.info.dir, state);
+        return chat.ratings ?? {};
+    }
+    /** Every rating in every thread, per agent: how many up, how many down. */
+    ratingsByAgent() {
+        const out = {};
+        for (const c of readProjectState(this.info.dir).chats ?? []) {
+            for (const r of Object.values(c.ratings ?? {})) {
+                const a = (out[r.agent] ??= { up: 0, down: 0 });
+                if (r.v === 1)
+                    a.up++;
+                else
+                    a.down++;
+            }
+        }
+        return out;
+    }
+    /** Star or unstar a message in a thread (main included). */
+    starMessage(chatId, eventId, on) {
+        if (!Number.isInteger(eventId) || eventId <= 0)
+            return null;
+        const state = readProjectState(this.info.dir);
+        state.chats = state.chats ?? [];
+        let chat = state.chats.find((c) => c.id === chatId);
+        if (!chat) {
+            if (chatId !== MAIN_CHAT)
+                return null;
+            // Main isn't stored until it has something to remember
+            chat = { id: MAIN_CHAT, title: "Main", createdAt: 0 };
+            state.chats.push(chat);
+        }
+        const set = (chat.starred ?? []).filter((n) => n !== eventId);
+        if (on)
+            set.push(eventId);
+        chat.starred = set.slice(-200);
+        if (!chat.starred.length)
+            delete chat.starred;
+        writeProjectState(this.info.dir, state);
+        return chat.starred ?? [];
+    }
+    createChat(title, opts = {}) {
+        const bound = opts.agentId ? this.bindable(opts.agentId, opts.model) : {};
+        return this.conversations.createChat(title, bound);
+    }
     /**
-     * Forget a conversation. Its events stay in the log — it's append-only, and
-     * the brain is built from all of them; deleting the thread you had with an
-     * agent shouldn't quietly rewrite what the project decided. The chat just
-     * stops being listed.
+     * May this thread be bound to this agent (and model)?
+     *
+     * A model bound to an agent that bakes its model into a spawned process
+     * would be a setting that silently did nothing, so it is refused here —
+     * where the person can act on it — rather than dropped at send time.
      */
+    bindable(agentId, model) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            throw new Error(`no agent "${agentId}" in this project`);
+        if (!isAdapter(agent))
+            throw new Error(`"${agentId}" is a bridge — it can't answer in a thread`);
+        if (model && !this.switchesModelPerTurn(agentId)) {
+            throw new Error(`"${agentId}" can't change model per thread — pin the model on the agent instead (loom model ${agentId} ${model}), or use a "model" agent`);
+        }
+        return { agentId, ...(model ? { model } : {}) };
+    }
+    /** Can this agent be handed a different model for one turn? */
+    switchesModelPerTurn(agentId) {
+        const kind = this.config.agents.find((a) => a.id === agentId)?.kind;
+        return kind === "model" || Boolean(this.continuity && kind && isNativeKind(kind));
+    }
+    /** Bind (or unbind) who answers in a thread. */
+    setChatAgent(id, agentId, model) {
+        // Preserve Main's error before validating an optional target.
+        if (id !== MAIN_CHAT && agentId)
+            this.bindable(agentId, model);
+        return this.conversations.setChatAgent(id, agentId, model);
+    }
+    /**
+     * Ask several models the same thing at once, each in its own thread.
+     *
+     * With free quota, asking five models costs what asking one costs, and
+     * "which of these is right" is a judgement a person makes in ten seconds.
+     * So: one prompt, one thread per model, all running at the same time.
+     *
+     * The agents are TRANSIENT — built for the ask, not added to the roster.
+     * Adding five agents to .loom/config.json to ask five questions would leave
+     * the project's roster as a record of everything anyone ever compared. What
+     * stays behind is the threads, which are the part worth keeping.
+     */
+    async askModels(text, picks, opts = {}) {
+        if (!picks.length)
+            throw new Error("name at least one model");
+        if (picks.length > MAX_FANOUT) {
+            throw new Error(`that's ${picks.length} models — ${MAX_FANOUT} at a time is the limit`);
+        }
+        const brief = opts.briefing === false ? "" : await this.brainBriefFor({ query: text, limit: 6 });
+        const started = [];
+        for (const pick of picks) {
+            const provider = pick.provider ?? "openrouter";
+            // The model IS the name here: a thread labelled "ask-3" tells you
+            // nothing, and this is a view where which model said what is the point.
+            const short = pick.model.split("/").pop() ?? pick.model;
+            const chat = this.createChat(`${opts.title ?? "ask"} · ${short}`.slice(0, 60));
+            const agentId = `ask:${pick.model}`;
+            this.log.append({
+                kind: "message",
+                chat: chat.id,
+                payload: { text, author: "user", ask: { model: pick.model, provider } },
+            });
+            const agent = new ModelAdapter(agentId, this.info.dir, { provider, model: pick.model });
+            // Its events land in the log tagged with its own thread, exactly as a
+            // roster agent's do — which is what makes the answers readable later.
+            const offLive = agent.onStream((d) => this.liveText({ agentId, chat: chat.id, ...d }));
+            const offLog = agent.onEvent((e) => {
+                this.appendIfOpen({ ...e, agentId, chat: chat.id });
+            });
+            const off = () => {
+                offLive();
+                offLog();
+            };
+            void agent
+                .send({ text, ...(brief ? { briefing: brief } : {}) })
+                .catch((err) => {
+                this.appendIfOpen({
+                    kind: "error",
+                    agentId,
+                    chat: chat.id,
+                    payload: { message: String(err instanceof Error ? err.message : err) },
+                });
+            })
+                .finally(() => off());
+            started.push({ chat: chat.id, model: pick.model, provider, agentId });
+        }
+        this.log.append({
+            kind: "status",
+            payload: { state: "asked_models", models: picks.map((p) => p.model), chats: started.map((s) => s.chat) },
+        });
+        return started;
+    }
+    /** What a thread has pinned, if anything. */
+    chatBinding(chat) {
+        if (!chat || chat === MAIN_CHAT)
+            return {};
+        const found = this.chats().find((c) => c.id === chat);
+        if (!found?.agentId)
+            return {};
+        // A thread pinned to an agent that has since left the roster falls back to
+        // the baton rather than failing: the conversation is still readable, and
+        // the alternative is a thread nobody can type in.
+        if (!this.agents.has(found.agentId))
+            return {};
+        return { agentId: found.agentId, ...(found.model ? { model: found.model } : {}) };
+    }
+    renameChat(id, title) { return this.conversations.renameChat(id, title); }
     deleteChat(id) {
-        if (id === MAIN_CHAT)
-            return false; // there is always a main chat
-        const state = readProjectState(this.info.dir);
-        const before = (state.chats ?? []).length;
-        state.chats = (state.chats ?? []).filter((c) => c.id !== id);
-        if (state.chats.length === before)
-            return false;
-        writeProjectState(this.info.dir, state);
-        return true;
+        if (this.continuity && ([...this.turns.busySince.keys()].some(agent => this.turns.turnChat.get(agent) === id) ||
+            this.queue.snapshot().items.some(item => item.chat === id)))
+            throw new ContinuityError("conflict", "finish or remove queued/native turns before deleting their chat");
+        return this.conversations.deleteChat(id);
     }
     // -------------------------------------------------------------------------
     // Board tasks — the cards you write yourself
@@ -400,32 +1706,175 @@ export class ProjectRuntime {
     }
     createTask(input) {
         const state = readProjectState(this.info.dir);
+        const blockedBy = this.validBlockers(state.tasks ?? [], input.blockedBy);
         const task = {
             id: newId(4),
             title: input.title.trim().slice(0, 200),
             column: input.column ?? "working",
             ...(input.agent ? { agent: input.agent } : {}),
+            ...(blockedBy.length ? { blockedBy } : {}),
             createdAt: Date.now(),
         };
+        applyCardMeta(task, input);
         state.tasks = [...(state.tasks ?? []), task];
         writeProjectState(this.info.dir, state);
         return task;
     }
+    /** Only blockers that exist. A link to a deleted card blocks nothing forever. */
+    validBlockers(tasks, ids) {
+        if (!ids?.length)
+            return [];
+        const known = new Set(tasks.map((t) => t.id));
+        return [...new Set(ids)].filter((id) => known.has(id));
+    }
+    /**
+     * A card is blocked while any of its blockers is not yet `ready`.
+     *
+     * `ready` is the board's own definition of done — the last column. Deleted
+     * blockers don't count (validBlockers keeps them out, and a stale link that
+     * survived a race reads as done rather than blocking forever).
+     */
+    taskBlockers(id) {
+        const tasks = readProjectState(this.info.dir).tasks ?? [];
+        const task = tasks.find((t) => t.id === id);
+        if (!task?.blockedBy?.length)
+            return [];
+        const byId = new Map(tasks.map((t) => [t.id, t]));
+        return task.blockedBy
+            .map((bid) => byId.get(bid))
+            .filter((b) => Boolean(b) && b.column !== "ready")
+            .map((b) => ({ id: b.id, title: b.title, column: b.column }));
+    }
+    /** task/<id>-<slug>: stable id first so a retitle doesn't orphan the branch. */
+    /**
+     * What opening a PR for this card would push, and what it would run.
+     *
+     * Asked before anything happens, because pushing publishes: the person sees
+     * the branch, the commits and the exact command, and only then decides.
+     */
+    async taskPrPlan(id) {
+        const task = (readProjectState(this.info.dir).tasks ?? []).find((t) => t.id === id);
+        if (!task)
+            throw new Error(`no card "${id}"`);
+        const branch = this.taskBranchName(task);
+        const base = (await readOut(this.info.dir, ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"]))
+            .replace(/^origin\//, "")
+            .trim() || "main";
+        const exists = await readOut(this.info.dir, ["rev-parse", "--verify", "--quiet", branch]);
+        if (!exists.trim()) {
+            return { branch, base, commits: [], files: [], command: "", ready: false, why: `there's no ${branch} branch yet` };
+        }
+        const log = await readOut(this.info.dir, ["log", "--oneline", `${base}..${branch}`]);
+        const commits = log.split("\n").map((l) => l.trim()).filter(Boolean);
+        const diff = await readOut(this.info.dir, ["diff", "--name-only", `${base}...${branch}`]);
+        const files = diff.split("\n").map((l) => l.trim()).filter(Boolean);
+        const command = `gh pr create --head ${branch} --base ${base} --title ${JSON.stringify(task.title)} --body ""`;
+        return {
+            branch,
+            base,
+            commits,
+            files,
+            command,
+            ready: commits.length > 0,
+            ...(commits.length ? {} : { why: `${branch} has nothing ${base} doesn't` }),
+        };
+    }
+    /** Push the branch and open the PR — only ever from an explicit click. */
+    async openTaskPr(id) {
+        const task = (readProjectState(this.info.dir).tasks ?? []).find((t) => t.id === id);
+        if (!task)
+            throw new Error(`no card "${id}"`);
+        const plan = await this.taskPrPlan(id);
+        if (!plan.ready)
+            throw new Error(plan.why ?? "there's nothing to open a PR for");
+        await readOut(this.info.dir, ["push", "-u", "origin", plan.branch]);
+        const out = await readOut(this.info.dir, [], {
+            cmd: "gh",
+            args: ["pr", "create", "--head", plan.branch, "--base", plan.base, "--title", task.title, "--body", ""],
+        });
+        const url = (out.match(/https:\/\/\S+/) ?? [""])[0];
+        if (!url)
+            throw new Error(out.trim().slice(0, 300) || "gh didn't return a PR url");
+        this.appendIfOpen({ kind: "status", payload: { state: "task_pr", task: task.id, branch: plan.branch, url } });
+        return { url, branch: plan.branch };
+    }
+    taskBranchName(task) {
+        const slug = task.title
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, "-")
+            .replace(/^-+|-+$/g, "")
+            .slice(0, 40);
+        return `task/${task.id}${slug ? `-${slug}` : ""}`;
+    }
     /** Move or retitle a card. Yours, so this is the real state — not a hint. */
     updateTask(id, patch) {
         const state = readProjectState(this.info.dir);
         const task = (state.tasks ?? []).find((t) => t.id === id);
         if (!task)
             return null;
+        applyCardMeta(task, patch);
+        // Opt-in: dragging a card to Working checks out its branch; reaching
+        // Review logs the PR command rather than running it — pushing publishes,
+        // and publishing implicitly is a line Loom doesn't cross even under a
+        // flag. The branch name leads with the stable id so a retitle doesn't
+        // orphan it. Failures (not a repo, dirty tree) land in the Console; the
+        // drag itself always succeeds — the board must not refuse to reflect
+        // reality because git had opinions.
+        if (this.config.git?.branchPerTask && patch.column && patch.column !== task.column) {
+            const branch = this.taskBranchName(task);
+            if (patch.column === "working") {
+                void ensureBranch(this.info.dir, branch)
+                    .then(({ created }) => this.appendIfOpen({
+                    kind: "status",
+                    payload: { state: "task_branch", task: task.id, branch, created },
+                }))
+                    .catch((err) => logbook.warn("git", `couldn't switch to ${branch}`, String(err), this.info.id));
+            }
+            else if (patch.column === "in-review") {
+                logbook.info("git", `"${task.title}" reached review — open the PR with: gh pr create --head ${branch}`, undefined, this.info.id);
+            }
+        }
         if (patch.title !== undefined)
             task.title = patch.title.trim().slice(0, 200) || task.title;
         if (patch.column !== undefined)
             task.column = patch.column;
         if (patch.agent !== undefined)
             task.agent = patch.agent;
+        for (const k of ["crew", "goal", "stage", "claimedBy"])
+            if (patch[k] !== undefined)
+                task[k] = String(patch[k]).slice(0, 80);
+        if (patch.blockedBy !== undefined) {
+            // Cycles refused at write: A→B→A makes both unbecomable forever, and the
+            // person who typed it is the one who can pick which link was wrong.
+            const next = this.validBlockers(state.tasks ?? [], patch.blockedBy).filter((b) => b !== id);
+            if (this.wouldCycle(state.tasks ?? [], id, next)) {
+                throw new Error("that dependency would make a cycle — nothing in it could ever start");
+            }
+            if (next.length)
+                task.blockedBy = next;
+            else
+                delete task.blockedBy;
+        }
         writeProjectState(this.info.dir, state);
         return task;
     }
+    /** Would `id` depending on `blockers` create a loop back to `id`? */
+    wouldCycle(tasks, id, blockers) {
+        const byId = new Map(tasks.map((t) => [t.id, t]));
+        const stack = [...blockers];
+        const seen = new Set();
+        while (stack.length) {
+            const cur = stack.pop();
+            if (cur === id)
+                return true;
+            if (seen.has(cur))
+                continue;
+            seen.add(cur);
+            for (const b of byId.get(cur)?.blockedBy ?? [])
+                stack.push(b);
+        }
+        return false;
+    }
     deleteTask(id) {
         const state = readProjectState(this.info.dir);
         const before = (state.tasks ?? []).length;
@@ -437,6 +1886,10 @@ export class ProjectRuntime {
     }
     /** Any adapter mid-turn? (Hot reloads are deferred while work is in flight.) */
     anyBusy() {
+        // A live orchestra run counts: reloading the project would close it, and
+        // closing aborts the run — a config edit must not kill a fleet mid-flight.
+        if (this.orchestra.active() || this.routes.isActive() || this.turns.busySince.size > 0 || this.crews.list().some(c => c.busy))
+            return true;
         return [...this.agents.values()].some((a) => isAdapter(a) && a.busy());
     }
     agent(id) {
@@ -446,198 +1899,107 @@ export class ProjectRuntime {
         return agent;
     }
     async ensureStarted(agentId) {
-        const agent = this.agent(agentId);
-        if (!this.startedAgents.has(agentId)) {
-            await agent.start();
-            this.startedAgents.add(agentId);
-        }
-        return agent;
+        this.agent(agentId); // preserve the public unknown-agent error
+        return this.agentLifecycle.start(agentId);
     }
-    /** Pre-turn porcelain snapshots, for per-prompt diff attribution. */
-    preTurnTree = new Map();
-    /** After a turn: log which files that prompt changed (turn_diff), then learn. */
-    captureTurnDiff(agentId) {
-        const before = this.preTurnTree.get(agentId);
-        if (before === undefined) {
-            // No snapshot (e.g. a turn with no pre-tree) — still worth reading.
-            this.extractMemory(agentId, []);
-            return;
+    checkpoints() { return this.turns.checkpoints(); }
+    async rewind(id) { return this.turns.rewind(id); }
+    /** Put one file back as a checkpoint had it (see checkpoints.restoreFile). */
+    async rewindFile(id, file) {
+        const busy = [...this.turns.busySince.keys()];
+        if (busy.length) {
+            throw new Error(`${busy.join(", ")} ${busy.length === 1 ? "is" : "are"} mid-turn — stop the turn first, or the file changes underneath it`);
         }
-        this.preTurnTree.delete(agentId);
-        void diffSinceSnapshot(this.info.dir, before)
-            .then((diff) => {
-            if (diff) {
-                this.log.append({
-                    kind: "turn_diff",
-                    agentId,
-                    payload: {
-                        files: diff.files,
-                        added: diff.added,
-                        removed: diff.removed,
-                        patch: diff.patch,
-                        truncated: diff.truncated,
-                    },
-                });
-            }
-            // Learn from the turn once we know which files it touched — the files
-            // sharpen candidate retrieval. Runs after the diff so recentTurnFiles
-            // isn't needed; the files are right here.
-            this.extractMemory(agentId, (diff?.files ?? []).map((f) => f.path));
-        })
-            .catch(() => this.extractMemory(agentId, []));
+        const out = await checkpoints.restoreFile(this.info.dir, id, file);
+        this.log.append({
+            kind: "checkpoint",
+            payload: { id: out.restored.id, label: `${out.path} only`, at: Date.now(), reason: "rewound", files: 1, undo: out.undo.id, path: out.path },
+        });
+        return out;
     }
-    /**
-     * Phase 2: read a finished turn for durable memory.
-     *
-     * Fire-and-forget on purpose. A slow or missing extractor must never delay
-     * anything — extractFromTurn already swallows engine failures, and this is
-     * void-ed so even an unexpected throw can't escape into the event pipeline.
-     * Off entirely when config says so; a no-op when Claude isn't available.
-     */
+    async turnFacts(agentId) { return this.turns.turnFacts(agentId); }
+    captureTurnDiff(agentId) { return this.turns.captureTurnDiff(agentId); }
+    async commitTurn(agentId, files) { return this.turns.commitTurn(agentId, files); }
     extractMemory(agentId, files) {
-        if (this.config.brain?.extractor === "off")
-            return;
-        const chat = this.turnChat.get(agentId) ?? MAIN_CHAT;
-        const turn = this.gatherTurnText(chat);
-        if (turn.length < 40)
-            return; // nothing substantial to learn from
-        const model = this.config.brain?.model ?? "haiku";
-        const engine = (p) => claudeText(`${p.system}\n\n${p.user}`, { model, timeoutMs: 60_000 });
-        void extractFromTurn(this.brain, turn, {
-            engine,
-            agentId,
-            chat,
-            ...(files.length ? { files } : {}),
-            eventId: this.log.lastId(),
-        })
-            .then((res) => {
-            const learned = res.added.length + res.updated.length + res.forgotten.length;
-            if (learned > 0) {
-                this.log.append({
-                    kind: "status",
-                    payload: {
-                        state: "brain_extract",
-                        agentId,
-                        added: res.added.length,
-                        updated: res.updated.length,
-                        forgotten: res.forgotten.length,
-                    },
-                });
-            }
-        })
-            .catch(() => { });
-    }
-    /**
-     * The transcript of the most recent turn in a chat: from the last human
-     * message to now — the user's ask and what the agent did in reply.
-     */
-    gatherTurnText(chat) {
-        const events = this.log.list({ chat, limit: 40 });
-        let start = 0;
-        for (let i = events.length - 1; i >= 0; i--) {
-            if (events[i].kind === "message" && !events[i].agentId) {
-                start = i;
-                break;
-            }
-        }
-        const lines = [];
-        for (const e of events.slice(start)) {
-            const p = e.payload;
-            if (e.kind === "message") {
-                lines.push(`${e.agentId ?? "user"}: ${String(p.text ?? "").slice(0, 2000)}`);
-            }
-            else if (e.kind === "tool_call") {
-                lines.push(`[${e.agentId} used ${String(p.tool ?? "a tool")}] ${String(p.summary ?? "")}`.trim());
-            }
-            else if (e.kind === "file_edit") {
-                lines.push(`[${e.agentId} edited ${String(p.path ?? "")}]`);
-            }
-            else if (e.kind === "decision") {
-                lines.push(`decision: ${String(p.text ?? "")}`);
-            }
-        }
-        return lines.join("\n").trim();
+        if (!this.continuity)
+            this.briefings.extractMemory(agentId, files);
     }
     workingTree() {
         return workingTree(this.info.dir);
     }
-    // -------------------------------------------------------------------------
-    // Unified memory — "multiple memory in one"
-    // -------------------------------------------------------------------------
-    /** Freshly read every connected ADE's native memory from disk. */
-    importedMemory() {
-        return readNativeMemory(this.info.dir, this.config);
-    }
-    /** The merged brain: decisions + imported ADE memories + shared context. */
-    unifiedMemory() {
-        return buildUnifiedMemory(this.info.name, this.log.list(), this.importedMemory());
-    }
-    /**
-     * Phase 3: the brain brief for a handoff — the memories relevant to the work
-     * in flight, compiled. Query is the recent conversation plus the files recent
-     * turns touched; scoped to the incoming agent; low-confidence memories are
-     * held back from injection (they stay visible in the Brain tab). Empty string
-     * when there's nothing relevant, so callers append it unconditionally.
-     */
-    retrieveBrief(events, agentId) {
-        const query = events
-            .filter((e) => e.kind === "message")
-            .slice(-8)
-            .map((e) => String(e.payload.text ?? ""))
-            .join(" ");
-        const files = [
-            ...new Set(events
-                .filter((e) => e.kind === "turn_diff")
-                .flatMap((e) => {
-                // turn_diff stores ChangedFile[] ({status, path}); older events or
-                // other shapes may carry bare strings. Normalise to paths.
-                const raw = e.payload.files ?? [];
-                return raw.map((f) => (typeof f === "string" ? f : (f?.path ?? ""))).filter(Boolean);
-            })),
-        ].slice(-20);
-        if (!query.trim() && !files.length)
-            return "";
-        const hits = retrieve(this.brain, {
-            ...(query.trim() ? { query } : {}),
-            ...(files.length ? { files } : {}),
-            agent: agentId,
-            minConfidence: CONFIDENCE_FLOOR,
-            limit: 14,
-        });
-        return compileBrief(hits.map((h) => h.memory));
-    }
-    /**
-     * Pull each ADE's native memory into the shared log. Idempotent — a source
-     * whose content hasn't changed since its last import is skipped, so this is
-     * safe to call on connect, on demand, or on a timer.
-     */
-    importMemories() {
-        const seen = new Map(); // file -> last imported hash
-        for (const e of this.log.list({ kinds: ["memory_import"] })) {
-            seen.set(String(e.payload.file), String(e.payload.hash));
-        }
-        const sources = [];
-        let imported = 0;
-        for (const block of this.importedMemory()) {
-            const hash = hashContent(block.content);
-            if (seen.get(block.file) === hash)
-                continue;
-            this.log.append({
-                kind: "memory_import",
-                agentId: block.agentId,
-                payload: { file: block.file, kind: block.kind, chars: block.content.length, hash },
-            });
-            sources.push(block.file);
-            imported += 1;
+    unifiedMemory() { return this.briefings.unifiedMemory(); }
+    brainBrief(opts) { return this.briefings.brainBrief(opts); }
+    // How often each memory made it into a prompt — the Brain tab's "most
+    // used". Counted where briefs are compiled, so it's what agents actually
+    // got, not what a search happened to return. Written at most every few
+    // seconds; a lost count on a crash costs nothing.
+    memoryUse = null;
+    memoryUseTimer = null;
+    memoryUseFile() {
+        return path.join(this.info.dir, ".loom", "memory-usage.json");
+    }
+    memoryUsage() {
+        if (!this.memoryUse) {
+            try {
+                this.memoryUse = JSON.parse(fs.readFileSync(this.memoryUseFile(), "utf8"));
+            }
+            catch {
+                this.memoryUse = {};
+            }
         }
-        return { imported, sources };
+        return this.memoryUse;
+    }
+    noteMemoriesUsed(ids) {
+        if (!ids.length)
+            return;
+        const use = this.memoryUsage();
+        const now = Date.now();
+        for (const id of new Set(ids))
+            use[id] = { n: (use[id]?.n ?? 0) + 1, at: now };
+        if (this.memoryUseTimer)
+            return;
+        this.memoryUseTimer = setTimeout(() => {
+            this.memoryUseTimer = null;
+            try {
+                fs.writeFileSync(this.memoryUseFile(), JSON.stringify(this.memoryUse));
+            }
+            catch {
+                /* a count that didn't save is not worth a failed turn */
+            }
+        }, 3000);
+        this.memoryUseTimer.unref?.();
     }
+    async brainBriefFor(opts) { return this.briefings.brainBriefFor(opts); }
+    async searchBrain(opts) { return this.briefings.searchBrain(opts); }
+    importMemories() { return this.briefings.importMemories(); }
     /** Fire-and-notify hooks + routing + suggested handoffs, off the log. */
     afterAgentEvent(event) {
         this.trackCost(event);
-        this.routes.handleAgentEvent(event);
+        this.shield(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));
+        // an agent out of quota mid-task hands its work on (core/quota.ts, runtime/relay.ts)
+        this.relay.observe(event);
+        if (event.kind === "run_complete")
+            this.shifts.poke();
+        // The turn's diff is started before routing hears the turn ended: a step
+        // condition reads those numbers, and a route that advanced first would
+        // read the turn before this one.
         if (event.kind === "run_complete" && event.agentId) {
             this.captureTurnDiff(event.agentId);
+            // A reply that claims the tests (or build, or lint) pass gets checked —
+            // against what the turn ran, and a clean re-run — without being asked.
+            if (!event.payload.error && this.proofs.wantsAuto(event))
+                void this.proofs.prove(event.chat ?? MAIN_CHAT, { at: event.id, auto: true }).catch((err) => logbook.warn("proof", "couldn't check the turn", String(err), this.info.id));
+            if (!this.continuity)
+                void this.captureAgentDecisions(event.agentId).catch(() => { });
+        }
+        this.routes.handleAgentEvent(event);
+        // Accumulate the turn's prose so decisions can be mined when it completes.
+        if (!this.continuity && event.kind === "message" && event.agentId && !event.payload.reasoning) {
+            const prev = this.turns.turnText.get(event.agentId) ?? "";
+            this.turns.turnText.set(event.agentId, `${prev}\n${String(event.payload.text ?? "")}`.slice(-8000));
         }
         if (event.kind === "needs_input") {
             notify({
@@ -652,7 +2014,7 @@ export class ProjectRuntime {
             });
         }
         else if (event.kind === "message") {
-            if (event.agentId)
+            if (event.agentId && !this.continuity)
                 this.captureDecisions(event);
             if (!this.routes.isActive()) {
                 // A route drives its own handoffs — suggestions would be noise.
@@ -677,6 +2039,119 @@ export class ProjectRuntime {
             });
         }
     }
+    // ── Structured agent decisions (Observatory Decision Explorer + Replay) ──
+    decisionsFile() {
+        return path.join(projectLoomDir(this.info.dir), "decisions.json");
+    }
+    /** An agent's declared role from config (planner/builder/reviewer/…), else its kind. */
+    agentRole(agentId) {
+        const cfg = this.config.agents.find((a) => a.id === agentId);
+        return cfg?.role ?? cfg?.kind ?? "agent";
+    }
+    /** How many turns this agent has completed (for the decision's turnIndex). */
+    turnCountFor(agentId) {
+        return this.log.count({ kinds: ["run_complete"], agentId });
+    }
+    /**
+     * All captured decisions for this project, newest first, in today's shape —
+     * see normalizeStoredDecision for what that does to records written before
+     * a decision had to say where its confidence came from.
+     */
+    getDecisions() {
+        try {
+            const raw = fs.readFileSync(this.decisionsFile(), "utf8");
+            const arr = JSON.parse(raw);
+            if (!Array.isArray(arr))
+                return [];
+            return arr.map(normalizeStoredDecision).sort((a, b) => b.timestamp - a.timestamp);
+        }
+        catch {
+            return [];
+        }
+    }
+    decisionStats() {
+        return decisionStats(this.getDecisions());
+    }
+    /** Append decisions to the persisted store (kept oldest→newest on disk). */
+    storeDecisions(decisions) {
+        if (!decisions.length)
+            return;
+        const existing = this.getDecisions().sort((a, b) => a.timestamp - b.timestamp);
+        const all = [...existing, ...decisions].slice(-1000); // bound the file
+        try {
+            fs.mkdirSync(projectLoomDir(this.info.dir), { recursive: true });
+            fs.writeFileSync(this.decisionsFile(), JSON.stringify(all, null, 2));
+        }
+        catch {
+            /* best-effort: decisions are an enrichment, never break the loop */
+        }
+    }
+    /** Mine decisions from a completed turn, persist them, surface on the Timeline. */
+    async captureAgentDecisions(agentId) {
+        const turnText = this.turns.turnText.get(agentId) ?? "";
+        this.turns.turnText.delete(agentId);
+        if (turnText.trim().length < 100)
+            return;
+        const lastTurn = this.log.list({ kinds: ["run_complete"], agentId, limit: 1 })[0];
+        const p = (lastTurn?.payload ?? {});
+        let filesChanged = [];
+        try {
+            // stderr is dropped, not inherited: a project that isn't a repo yet, or
+            // one with no commits, makes git print a usage wall on every completed
+            // turn. The failure is already handled — it must not also be shouted
+            // into the daemon's console.
+            filesChanged = execSync("git diff --name-only HEAD", {
+                cwd: this.info.dir,
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+            })
+                .trim().split("\n").filter(Boolean);
+        }
+        catch { /* not a git repo, or nothing changed */ }
+        // The trace this turn's spans went out under, when telemetry is on.
+        // Undefined otherwise — see observability/index.ts#turnTraceId; a decision
+        // that can't link to a trace must carry no trace id rather than "".
+        const traceId = turnTraceId(agentId);
+        const decisions = await extractDecisions({
+            agentId,
+            agentRole: this.agentRole(agentId),
+            projectId: this.info.id,
+            chatId: this.turns.turnChat.get(agentId) ?? MAIN_CHAT,
+            turnIndex: this.turnCountFor(agentId),
+            ...(traceId ? { traceId } : {}),
+            ...(lastTurn ? { turnId: String(lastTurn.id) } : {}),
+            turnText,
+            // The turn's totals, carried as the TURN's — not divided between the
+            // decisions mined from it, and not stamped on each as if each cost this.
+            turnTokensUsed: Number(p.inputTokens ?? 0) + Number(p.outputTokens ?? 0),
+            turnCostUsd: Number(p.costUsd ?? 0),
+            durationMs: Number(p.durationMs ?? 0),
+            anthropicApiKey: process.env.ANTHROPIC_API_KEY,
+            filesChanged,
+        });
+        if (this.closed || !decisions.length)
+            return;
+        this.storeDecisions(decisions);
+        // Surface each on the Timeline / snapshots via a status event (no new EventKind,
+        // and no collision with the brain's memory `decision` events). `source` rides
+        // along so a renderer can say where the confidence came from — or that there
+        // isn't one, which is what a heuristic decision carries.
+        for (const d of decisions) {
+            this.log.append({
+                kind: "status",
+                agentId: d.agentId,
+                ...(d.chatId && d.chatId !== MAIN_CHAT ? { chat: d.chatId } : {}),
+                payload: {
+                    state: "agent_decision",
+                    decisionId: d.id,
+                    title: d.title,
+                    category: d.category,
+                    source: d.source,
+                    ...(d.confidence !== undefined ? { confidence: d.confidence } : {}),
+                },
+            });
+        }
+    }
     /**
      * The persisted holder, unless it refers to an agent that has since been
      * removed from the config — ghost holders are cleared, not fatal.
@@ -724,10 +2199,10 @@ export class ProjectRuntime {
             throw new Error(`agent "${agentId}" can be watched but not driven`);
         }
         await this.ensureStarted(agentId);
-        this.turnChat.set(agentId, chat);
+        this.turns.turnChat.set(agentId, chat);
         this.log.append({ kind: "message", chat, agentId, payload: { text, author: "user" } });
         try {
-            const reply = await bridge.ask(text);
+            const reply = await withLoomAskTimeout(bridge.ask(text));
             return { agentId, reply };
         }
         catch (err) {
@@ -738,47 +2213,525 @@ export class ProjectRuntime {
             throw err;
         }
     }
+    // ── the prompt queue (core/prompt-queue.ts) ──
+    /**
+     * A proxy in front of one server, so its page can talk to the app.
+     *
+     * One per server, reused while it points at the same place — restarting a
+     * dev server on the same port keeps the preview URL stable, which matters
+     * because the iframe is pointed at it.
+     */
+    async previewProxy(name, target) {
+        const live = this.proxies.get(name);
+        if (live && live.target === target)
+            return live;
+        if (live)
+            await live.close().catch(() => { });
+        const proxy = await startPreviewProxy(target);
+        this.proxies.set(name, proxy);
+        return proxy;
+    }
+    /** Live server state and output, for the socket. Returns unsubscribe. */
+    /** Replies as they're written, for the socket. Returns unsubscribe. */
+    onStream(cb) {
+        this.streamListeners.add(cb);
+        return () => this.streamListeners.delete(cb);
+    }
+    /** The replies being typed right now in one thread (or all of them). */
+    liveNow(chat) {
+        const out = [];
+        for (const [agentId, s] of this.liveSoFar) {
+            if (chat !== undefined && s.chat !== chat)
+                continue;
+            if (s.text || s.think)
+                out.push({ agentId, ...s });
+        }
+        return out;
+    }
+    liveSoFar = new Map();
+    liveText(f) {
+        if (this.closed)
+            return;
+        let s = this.liveSoFar.get(f.agentId);
+        if (!s || s.chat !== f.chat)
+            this.liveSoFar.set(f.agentId, (s = { chat: f.chat, text: "", think: "" }));
+        const off = f.reasoning ? s.think.length : s.text.length;
+        if (f.reasoning)
+            s.think += f.text;
+        else
+            s.text += f.text;
+        // a runaway reply can't grow the buffer without bound
+        if (s.text.length > 400_000)
+            s.text = "";
+        if (s.think.length > 400_000)
+            s.think = "";
+        const framed = { ...f, off };
+        for (const cb of this.streamListeners) {
+            try {
+                cb(framed);
+            }
+            catch {
+                // a viewer that breaks must not break the turn
+            }
+        }
+    }
+    /** Streamed text and tool progress as a turn produces them; what finishes lands in the log. */
+    onLiveDelta(cb) {
+        this.liveListeners.add(cb);
+        return () => this.liveListeners.delete(cb);
+    }
+    /**
+     * Answer a structured question an agent is waiting on (a needs_input event
+     * with a requestId). The turn carries on with the answer.
+     */
+    async answerQuestion(agentId, chat, requestId, answers) {
+        // a crew teammate or orchestra worker runs as its own instance; its card names that instance
+        const agent = (this.agents.get(agentId) ?? this.crews?.liveAgent?.(agentId) ?? this.orchestra?.liveAgent?.(agentId));
+        if (!agent || typeof agent.respondToUserInput !== "function")
+            throw new Error(`agent "${agentId}" can't take answers to questions`);
+        this.releaseQuestionHold(agentId);
+        await agent.respondToUserInput(chat, requestId, answers);
+        if (this.openQuestions.get(agentId)?.requestId === requestId)
+            this.openQuestions.delete(agentId);
+    }
+    /** Structured questions agents are blocked on, by agent. */
+    openQuestions = new Map();
+    /** Compact an agent's native context for a chat now, instead of waiting for the harness to. */
+    async compactAgent(agentId, chat = MAIN_CHAT) {
+        const agent = this.agents.get(agentId);
+        if (!(agent instanceof ProviderAgent))
+            throw new Error(`agent "${agentId}" can't be compacted from Loom`);
+        if (agent.busy() || this.turns.busySince.has(agentId))
+            throw new Error(`"${agentId}" is mid-turn — wait for it to finish, then compact`);
+        await this.ensureStarted(agentId);
+        this.turns.turnChat.set(agentId, chat);
+        await agent.compact(chat);
+    }
+    /**
+     * 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.
+     */
+    saveProposedPlan(agentId, chat, markdown) {
+        if (!markdown.trim())
+            return;
+        try {
+            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");
+            fs.mkdirSync(dir, { recursive: true });
+            let file = path.join(dir, `${day}-${slug}.md`);
+            for (let n = 2; fs.existsSync(file); n++)
+                file = path.join(dir, `${day}-${slug}-${n}.md`);
+            fs.writeFileSync(file, `---\ntitle: ${JSON.stringify(heading.trim())}\nstatus: proposed\nagent: ${agentId}\n---\n\n${markdown.trim()}\n`);
+            this.log.append({ kind: "status", agentId, ...(chat ? { chat } : {}),
+                payload: { state: "plan_saved", path: path.relative(this.agentDir(agentId), file) } });
+        }
+        catch (error) {
+            logbook.warn("plan", `could not save ${agentId}'s proposed plan`, String(error), this.info.id);
+        }
+    }
+    onServerEvent(cb) {
+        this.serverListeners.add(cb);
+        return () => this.serverListeners.delete(cb);
+    }
+    onQueueChange(cb) { return this.queueCoordinator.onQueueChange(cb); }
+    enqueue(input) {
+        if (this.continuity) {
+            this.queue.assertCanAdd(input);
+            if (!this.chats().some(c => c.id === (input.chat ?? MAIN_CHAT)))
+                throw new ContinuityError("invalid", "conversation is missing or deleted");
+            const bound = this.chatBinding(input.chat);
+            if (input.target?.kind === "orchestra")
+                throw new ContinuityError("unsupported", "parallel orchestra is outside sequential native continuity");
+            const target = input.target?.kind === "agent" ? input.target.agentId : bound.agentId ?? this.validHolder() ?? this.defaultAdapterId();
+            const cfg = this.config.agents.find(a => a.id === target);
+            if (!cfg || !isNativeKind(cfg.kind))
+                throw new ContinuityError("unsupported", "queued native continuity needs a supported harness (Codex, Claude Code or OpenCode)");
+            const captured = this.continuity.capture({ id: newId(16), text: input.text, conversationId: input.chat ?? MAIN_CHAT,
+                agentInstanceId: target, source: input.source ?? "user", model: bound.agentId === target ? bound.model ?? null : null,
+                plan: Boolean(input.plan), targetAddedTokens: 6000 });
+            input = { ...input, target: { kind: "agent", agentId: target }, continuity: { requestId: captured.request.id, model: captured.request.model } };
+        }
+        return this.queueCoordinator.enqueue(input);
+    }
+    editQueued(itemId, patch) {
+        if (this.continuity && (patch.text !== undefined || patch.target !== undefined || patch.plan !== undefined))
+            throw new ContinuityError("unsupported", "native queued request revisions require durable supersession; remove the unsent entry and submit a new request instead");
+        return this.queueCoordinator.editQueued(itemId, patch);
+    }
+    queueBlocker(item) { return this.queueCoordinator.queueBlocker(item); }
+    watchClockConditions(q) { return this.queueCoordinator.watchClockConditions(q); }
+    holdQueueFor(agentId) {
+        // a night shift doesn't wait on a question: it stays open for you in its chat (and the report), and the next task goes
+        if (this.shifts.active)
+            return;
+        return this.queueCoordinator.holdQueueFor(agentId);
+    }
+    releaseQuestionHold(agentId) { return this.queueCoordinator.releaseQuestionHold(agentId); }
+    kickQueue() { return this.queueCoordinator.kickQueue(); }
+    async drainPromptQueue() { return this.queueCoordinator.drainPromptQueue(); }
     async sendMessage(text, agentId, opts = {}) {
-        const source = opts.source ?? "user";
-        const chat = opts.chat ?? MAIN_CHAT;
-        let target = agentId ?? this.validHolder() ?? this.defaultAdapterId();
-        const agent = this.agent(target);
-        if (!isAdapter(agent)) {
-            throw new Error(`agent "${target}" is a bridge (read-only) — it cannot take turns`);
+        // a person speaking in a chat is a new start: nobody there is "stuck" any more
+        if ((opts.source ?? "user") === "user") {
+            const chat = opts.chat ?? MAIN_CHAT;
+            this.loops.reset(chat);
+            for (const k of [...this.nudged])
+                if (k.endsWith(`\u0000${chat}`))
+                    this.nudged.delete(k);
         }
-        const holder = this.validHolder();
-        if (holder === null) {
-            this.baton.acquire(target);
+        // a prompt for an agent that's out of quota goes to whoever is carrying its work
+        const target = agentId ?? this.validHolder() ?? undefined;
+        if (target && this.relay.holds(target)) {
+            const routed = await this.relay.route(target, opts.chat ?? MAIN_CHAT);
+            if (routed !== target)
+                agentId = routed;
+        }
+        return this.turns.sendMessage(text, agentId, opts);
+    }
+    /**
+     * An agent is re-running the same failing command (or the same call over and
+     * over). Say so in its chat — a card with Stop / Nudge / Hand off — and push;
+     * with watchdog.auto "nudge", also stop the turn and tell it to step back.
+     */
+    async onLoop(loop) {
+        // on a night shift nobody is watching: nudge by default (an explicit setting still wins)
+        const set = this.config.watchdog?.auto ?? (this.shifts.active ? "nudge" : "notify");
+        if (set === "off")
+            return;
+        // nudge once; if it's still going in circles after that, it's yours to decide
+        const key = `${loop.agentId}\u0000${loop.chat}`;
+        const mode = set === "nudge" && !this.nudged.has(key) ? "nudge" : "notify";
+        if (mode === "nudge")
+            this.nudged.add(key);
+        this.log.append({ kind: "status", agentId: loop.agentId, ...(loop.chat !== MAIN_CHAT ? { chat: loop.chat } : {}), payload: {
+                state: "loop_detected", loop: loop.kind, call: loop.call, count: loop.count, ...(loop.output ? { output: loop.output } : {}),
+                ...(mode === "nudge" ? { nudged: true } : {}),
+                text: loop.kind === "failing" ? `${loop.agentId} ran \`${loop.call}\` ${loop.count} times this turn, failing each time`
+                    : `${loop.agentId} made the same call ${loop.count} times this turn: \`${loop.call}\``,
+            } });
+        if (mode === "nudge")
+            await this.actOnLoop(loop.chat, loop.agentId, "nudge", undefined, loop);
+    }
+    /**
+     * Blast-Radius Shield (core/shield.ts): a command an agent ran that can't be
+     * taken back — a force-push, a reset --hard, a recursive delete outside the
+     * 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.
+     */
+    shield(event) {
+        if (!event.agentId)
+            return;
+        const chat = event.chat ?? MAIN_CHAT;
+        if (event.kind === "run_complete") {
+            for (const k of [...this.shielded])
+                if (k.startsWith(`${event.agentId}\u0000${chat}\u0000`))
+                    this.shielded.delete(k);
+            return;
+        }
+        if (event.kind !== "tool_call")
+            return;
+        const command = commandOf(event.payload);
+        if (!command)
+            return;
+        const mode = this.config.shield?.auto ?? (this.shifts.active ? "stop" : "notify");
+        if (mode === "off")
+            return;
+        const danger = dangerOf(command, this.agentDir(event.agentId));
+        if (!danger)
+            return;
+        const key = `${event.agentId}\u0000${chat}\u0000${command}`;
+        if (this.shielded.has(key))
+            return;
+        this.shielded.add(key);
+        const stop = mode === "stop";
+        this.log.append({ kind: "status", agentId: event.agentId, ...(chat !== MAIN_CHAT ? { chat } : {}), payload: {
+                state: "shield_tripped", command: command.slice(0, 500), what: danger.what, why: danger.why, ...(stop ? { stopped: true } : {}),
+                text: `${event.agentId} ran ${danger.what}: \`${command.replace(/\s+/g, " ").slice(0, 160)}\` — ${danger.why}`,
+            } });
+        if (stop)
+            void this.interrupt({ chat, source: "route" }).catch((err) => logbook.warn("shield", "couldn't stop the turn", String(err), this.info.id));
+    }
+    /** 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) {
+        const card = loop ?? this.lastLoop(chat, agentId);
+        await this.interrupt({ chat, source: "route" });
+        if (action === "stop")
+            return { done: "stopped" };
+        if (action === "nudge") {
+            if (!card)
+                throw new Error("no loop to nudge about in this chat");
+            await this.turns.sendMessage(nudgeText(card), agentId, { chat, source: "route" });
+            return { done: "nudged" };
+        }
+        if (!to || to === agentId)
+            throw new Error("hand it to which agent?");
+        const request = [...this.log.list({ chat, limit: 200 })].reverse().find((e) => e.kind === "message" && !e.agentId && String(e.payload.text ?? "").trim() && !String(e.payload.text).startsWith("[Loom]"));
+        if (!request)
+            throw new Error("couldn't find the request this chat was working on");
+        await this.handoff(to, { source: "user" });
+        const prior = this.briefings.pendingBriefings.get(to);
+        this.briefings.pendingBriefings.set(to, [prior, `[Loom] "${agentId}" got stuck on this${card ? `, running \`${card.call}\` ${card.count} times (${card.kind})` : ""}. Its changes are in the working tree: read them, find what it kept getting wrong, and finish the task a different way.`].filter(Boolean).join("\n"));
+        await this.turns.sendMessage(String(request.payload.text), to, { chat, source: "route" });
+        return { done: "handed off", to };
+    }
+    lastLoop(chat, agentId) {
+        const e = [...this.log.list({ chat, kinds: ["status"], limit: 100 })].reverse().find((x) => x.payload.state === "loop_detected" && x.agentId === agentId);
+        if (!e)
+            return undefined;
+        return { agentId, chat, kind: e.payload.loop === "repeating" ? "repeating" : "failing", call: String(e.payload.call ?? ""), count: Number(e.payload.count ?? 0) };
+    }
+    // -------------------------------------------------------------------------
+    // Named routes
+    // -------------------------------------------------------------------------
+    /**
+     * Define or replace a named route.
+     *
+     * Routes were config you hand-edited: `ship` was built at init and everything
+     * else meant opening .loom/config.json. Validated against the CURRENT roster
+     * before saving — a route that names an agent this project doesn't have would
+     * sit in the file looking runnable and fail at its first step. Saving through
+     * here puts the team's pipeline in a version-controllable file instead of one
+     * person's shell history.
+     */
+    saveRoute(name, steps) {
+        const clean = name.trim().slice(0, 40);
+        if (!clean)
+            throw new Error("a route needs a name");
+        resolveSteps(steps, this.config, (id) => {
+            const live = this.agents.get(id);
+            return Boolean(live && isAdapter(live));
+        });
+        this.config.routes = { ...(this.config.routes ?? {}), [clean]: steps };
+        this.saveConfig();
+        return this.config.routes;
+    }
+    deleteRoute(name) {
+        const routes = { ...(this.config.routes ?? {}) };
+        if (!(name in routes))
+            throw new Error(`no route named "${name}"`);
+        delete routes[name];
+        this.config.routes = routes;
+        this.saveConfig();
+        return routes;
+    }
+    // -------------------------------------------------------------------------
+    // Snapshots
+    // -------------------------------------------------------------------------
+    /**
+     * Checkpoint the project's Loom-owned state: brain, board, config.
+     *
+     * For the moment before letting a fleet loose on something — a restorable
+     * "before". Deliberately NOT the working tree (git owns files and does it
+     * better) and NOT the event log (history is what happened; a restore that
+     * rewrote history would be a lie with a timestamp). Restoring brings back
+     * what the project knew, what was on the board, and how it was configured.
+     */
+    snapshot() {
+        return {
+            format: "loom-snapshot",
+            version: 1,
+            project: this.info.name,
+            takenAt: Date.now(),
+            brain: this.brain.export(this.info.name),
+            tasks: readProjectState(this.info.dir).tasks ?? [],
+            config: this.config,
+        };
+    }
+    /**
+     * Restore a snapshot. Config and board are replaced (that is what "restore"
+     * means for state you own); the brain is MERGED through the same dedupe as
+     * import, because memory is an append-only fold — a restore that silently
+     * forgot what was learned since the snapshot would be data loss wearing a
+     * seatbelt. What it knew then comes back; what it learned since stays.
+     */
+    restore(snap) {
+        if (snap?.format !== "loom-snapshot")
+            throw new Error("not a loom snapshot");
+        const brain = this.brain.import(snap.brain, {
+            agentId: "restore",
+            eventId: this.log.lastId(),
+            ts: Date.now(),
+        });
+        const state = readProjectState(this.info.dir);
+        writeProjectState(this.info.dir, { ...state, tasks: snap.tasks });
+        // `config` is readonly by reference and shared with every live subsystem,
+        // so restore mutates its contents rather than swapping the object.
+        for (const k of Object.keys(this.config)) {
+            if (!(k in snap.config))
+                delete this.config[k];
+        }
+        Object.assign(this.config, snap.config);
+        this.saveConfig();
+        // Reconcile the live agents with the restored roster, the same way
+        // addAgent/removeAgent would have: drop what's gone, spawn what's missing.
+        const wanted = new Map(this.config.agents.map((a) => [a.id, a]));
+        for (const [id, live] of [...this.agents]) {
+            if (!wanted.has(id)) {
+                void this.agentLifecycle.retire(id);
+            }
+        }
+        for (const cfg of this.config.agents) {
+            if (!this.agents.has(cfg.id) && cfg.enabled !== false)
+                this.spawnAgent(cfg);
+        }
+        this.log.append({
+            kind: "status",
+            payload: { state: "restored", takenAt: snap.takenAt, tasks: snap.tasks.length },
+        });
+        return { brain, tasks: snap.tasks.length };
+    }
+    /** Turns older than this are presumed hung. Generous: real turns run long. */
+    static STALE_TURN_MS = 10 * 60 * 1000;
+    staleSessions(now = Date.now()) { return this.turns.staleSessions(now); }
+    /**
+     * Put a hung session out of its misery and bring up a fresh one.
+     *
+     * Interrupt first — a process that responds to that wasn't hung, and gets to
+     * finish dying cleanly — then stop, drop, and respawn from config, exactly as
+     * a cold start would. The baton is released if the corpse held it, because a
+     * lock owned by a session that no longer exists refuses everyone forever.
+     */
+    async reapSession(agentId) {
+        const cfg = this.config.agents.find((a) => a.id === agentId);
+        if (!cfg)
+            throw new Error(`unknown agent "${agentId}" in project "${this.info.name}"`);
+        const live = this.agents.get(agentId);
+        if (live && isAdapter(live)) {
+            await live.interrupt().catch(() => { });
+        }
+        await this.agentLifecycle.retire(agentId);
+        this.turns.busySince.delete(agentId);
+        if (this.validHolder() === agentId)
+            this.baton.release(agentId);
+        this.spawnAgent(cfg);
+        this.log.append({
+            kind: "status",
+            agentId,
+            payload: { state: "session_reaped", reason: "stale or hung session respawned" },
+        });
+        return { respawned: true };
+    }
+    // -------------------------------------------------------------------------
+    // Sub-agents
+    // -------------------------------------------------------------------------
+    /**
+     * How many subtasks may run at once in this project.
+     *
+     * A fan-out is the point of the feature and also the way to melt the machine:
+     * 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.
+     */
+    static MAX_CONCURRENT_SUBTASKS = 4;
+    /** In-flight subtasks, by the id minted when they started. */
+    subtasks = new Map();
+    /** Subtasks currently running, for the status payload and the cap. */
+    liveSubtasks() {
+        return [...this.subtasks.entries()].map(([id, s]) => ({
+            id,
+            parent: s.parent,
+            agentId: s.agentId,
+            task: s.task,
+        }));
+    }
+    /**
+     * Run a subtask on a child agent, alongside the parent's turn.
+     *
+     * A turn used to be all-or-nothing: one agent, one prompt, one result. "Audit
+     * these twelve files" wanted twelve cheap readers, and the only way to get
+     * them was twelve sequential turns, each one taking the baton off the last.
+     *
+     * What makes a child a child rather than another turn:
+     *
+     *  - **It never touches the baton.** The parent still holds it, so a fan-out
+     *    cannot steal the conversation from the agent that started it, and the
+     *    human's next message still lands where they expect.
+     *  - **Its briefing is narrowed.** It gets the task and the project's shape,
+     *    not the parent's whole thread. Handing a child the full history is how
+     *    you pay twice for context the parent already read.
+     *  - **Its result is attributed and parented**, so the thread can indent it
+     *    under the turn that asked rather than interleaving it as a peer.
+     *
+     * Everything it learns still lands in the one project brain — a child that
+     * discovered something and took it to the grave would be worse than no child.
+     */
+    async spawnSubAgent(parentAgentId, opts) {
+        if (this.continuity)
+            throw new ContinuityError("unsupported", "parallel subagents are outside sequential native continuity; finish this turn or use legacy mode");
+        const task = opts.task?.trim();
+        if (!task)
+            throw new Error("a subtask needs a task");
+        // A child's briefing is deliberately narrow; a 100KB "task" is the parent
+        // smuggling its whole context through the one field that was scoped.
+        if (task.length > 10_000) {
+            throw new Error("a subtask brief tops out at 10k chars — hand files, not transcripts");
         }
-        else if (holder !== target) {
-            throw new NotHolderError(target, holder);
+        // The parent has to be a real agent in this project, so the thread can
+        // indent under something that exists.
+        this.agent(parentAgentId);
+        const child = this.agent(opts.agentId);
+        if (!isAdapter(child)) {
+            throw new Error(`agent "${opts.agentId}" is a bridge (read-only) — it cannot run a subtask`);
         }
-        // A user reply to a paused route's question resumes the route.
-        if (source === "user")
-            this.routes.onUserMessage(target);
-        // everything this turn produces belongs to the chat you sent from
-        this.turnChat.set(target, chat);
+        if (this.subtasks.size >= ProjectRuntime.MAX_CONCURRENT_SUBTASKS) {
+            throw new Error(`${ProjectRuntime.MAX_CONCURRENT_SUBTASKS} subtasks are already running in this project`);
+        }
+        // Same gates as a turn. A child that ignored the budget would be a hole in
+        // the ceiling the parent is standing under.
+        this.enforceQuarantine(opts.agentId);
+        this.enforceBudget(opts.agentId);
+        const id = newId(5);
+        const chat = opts.chat ?? MAIN_CHAT;
+        this.subtasks.set(id, {
+            parent: parentAgentId,
+            agentId: opts.agentId,
+            task,
+            startedAt: Date.now(),
+        });
         this.log.append({
-            kind: "message",
+            kind: "subtask_started",
+            agentId: opts.agentId,
             chat,
-            payload: { text, author: source === "route" ? "loom" : "user" },
-        });
-        await this.ensureStarted(target);
-        const pendingBriefing = this.consumePendingBriefing(target);
-        const input = pendingBriefing ? { text, briefing: pendingBriefing } : { text };
-        // Snapshot the tree so this prompt's changes can be attributed to it.
-        this.preTurnTree.set(target, await porcelainStatus(this.info.dir));
-        // Fire-and-notify: the turn runs in the background; progress streams
-        // into the log and completion lands as run_complete.
-        void agent.send(input).catch((err) => {
-            this.log.append({
-                kind: "error",
-                agentId: target,
-                payload: { message: String(err instanceof Error ? err.message : err) },
-            });
+            payload: { subtaskId: id, parent: parentAgentId, task },
         });
-        return { agentId: target };
+        await this.ensureStarted(opts.agentId);
+        const mcp = child.capabilities.mcp ? writeMcpSession(this.healthyMcps()) : null;
+        const input = {
+            text: task,
+            chat,
+            briefing: this.subtaskBriefing(parentAgentId, opts.agentId, task),
+            ...(mcp ? { mcp: { configPath: mcp.configPath, servers: mcp.servers } } : {}),
+        };
+        void child
+            .send(input)
+            .then(() => {
+            this.subtasks.delete(id);
+            this.appendIfOpen({
+                kind: "subtask_done",
+                agentId: opts.agentId,
+                chat,
+                payload: { subtaskId: id, parent: parentAgentId, task },
+            });
+        })
+            .catch((err) => {
+            this.subtasks.delete(id);
+            this.appendIfOpen({
+                kind: "subtask_failed",
+                agentId: opts.agentId,
+                chat,
+                payload: {
+                    subtaskId: id,
+                    parent: parentAgentId,
+                    task,
+                    message: String(err instanceof Error ? err.message : err),
+                },
+            });
+        })
+            .finally(() => mcp?.cleanup());
+        return { id, agentId: opts.agentId };
     }
+    subtaskBriefing(parent, childId, task) { return this.briefings.subtaskBriefing(parent, childId, task); }
     defaultAdapterId() {
         const cfg = (this.config.defaultAgent &&
             this.config.agents.find((a) => a.id === this.config.defaultAgent)) ||
@@ -787,114 +2740,108 @@ export class ProjectRuntime {
             throw new Error(`project "${this.info.name}" has no full-duplex adapters`);
         return cfg.id;
     }
-    // -------------------------------------------------------------------------
-    // Handoff
-    // -------------------------------------------------------------------------
-    /** Briefings are injected with the first turn after a handoff. */
-    pendingBriefings = new Map();
-    consumePendingBriefing(agentId) {
-        const briefing = this.pendingBriefings.get(agentId);
-        this.pendingBriefings.delete(agentId);
-        return briefing;
-    }
+    consumePendingBriefing(agentId) { return this.briefings.consumePendingBriefing(agentId); }
+    async retryTurn(toAgentId) { return this.turns.retryTurn(toAgentId); }
     /**
-     * Explicit baton pass: interrupt the current holder if mid-turn, project
-     * the log into the target's namespaced memory, arm the one-shot briefing.
-     * A *manual* handoff cancels any active route — the human outranks it.
+     * Carry the outgoing agent's branch into the incoming agent's worktree.
+     *
+     * Only with both `worktreePerAgent` and `mergeOnHandoff` on, only when the
+     * two really are separate checkouts, and never when it would have to guess:
+     * see core/worktree-merge.ts for what it refuses. The outcome is a value so
+     * the handoff event and the briefing can both say what happened.
      */
+    async mergeForHandoff(from, to) {
+        if (!this.config.git?.worktreePerAgent || !this.config.git?.mergeOnHandoff)
+            return null;
+        const into = this.agentDir(to);
+        const source = this.agentDir(from);
+        if (into === this.info.dir || source === into)
+            return null;
+        try {
+            return await mergeAgentWork({
+                into,
+                branch: `agent/${from}`,
+                sourceDir: source,
+                message: `Loom: ${from} → ${to}`,
+            });
+        }
+        catch (err) {
+            // A merge that can't run must not take the handoff down with it.
+            logbook.warn("git", `merge on handoff ${from} → ${to} failed`, String(err), this.info.id);
+            return null;
+        }
+    }
     async handoff(to, opts = {}) {
+        if (this.continuity?.store.activeReceipts().some(r => r.execution === "unknown"))
+            throw new ContinuityError("recovery_required", "reconcile uncertain native writers before handoff or merge");
         const target = this.agent(to);
         if (!isAdapter(target)) {
             throw new Error(`cannot hand the baton to "${to}" — bridges are read-only by design`);
         }
+        // Handing the baton to an agent that can't afford a turn is the same
+        // refusal as sending it one — and it has to be caught HERE, before the
+        // current holder is interrupted, or a route would strand the baton on an
+        // agent that will refuse every prompt it gets.
+        this.enforceQuarantine(to);
+        this.enforceBudget(to);
         if ((opts.source ?? "user") === "user")
             this.routes.onManualHandoff();
         // Audit trail: snapshot the outgoing holder's working-tree state into the
         // handoff event, so "who left what uncommitted" is always answerable.
         let handoffMeta = { projected: true };
         const holder = this.validHolder();
+        let merge = null;
         if (holder && holder !== to) {
             const current = this.agent(holder);
             if (isAdapter(current)) {
+                if (this.continuity && this.turns.busySince.has(holder) && !current.busy())
+                    throw new ContinuityError("conflict", "outgoing turn is still preparing or finalizing; wait or stop before interrupt-switching");
                 if (current.busy())
                     await current.interrupt();
                 const diff = await current.diff().catch(() => "");
                 if (diff)
                     handoffMeta = { ...handoffMeta, dirty: true, diff: diff.slice(0, 2000) };
             }
+            // After the outgoing agent has stopped (its last commit is in), before
+            // the briefing is written — so the briefing can carry the result.
+            merge = await this.mergeForHandoff(holder, to);
+            if (merge)
+                handoffMeta = { ...handoffMeta, merge };
         }
-        // Refresh the shared brain from every ADE's native memory before handing
-        // off, so the incoming agent inherits what the others knew.
-        this.importMemories();
-        const events = this.log.list({ limit: PROJECTION_WINDOW });
-        const input = {
-            projectName: this.info.name,
-            config: this.config,
-            events,
-            targetAgentId: to,
-            fromAgentId: holder,
-        };
-        // Template by default; LLM-distilled when the project opts in — always
-        // falling back to the template so a broken Claude never blocks a handoff.
-        const distillStart = Date.now();
-        const rendered = await renderProjection(input, this.config.projection);
-        // Phase 3: the memories relevant to the work in flight, retrieved and
-        // compiled — this is the part the recency-window projection can't do. Query
-        // is the recent conversation plus the files recent turns touched; scoped to
-        // this chat and to the incoming agent; low-confidence memories are held back
-        // from injection (they're still visible in the Brain tab).
-        const brainBrief = this.retrieveBrief(events, to);
-        // Append the unified cross-ADE memory so the incoming agent sees the
-        // whole brain, not just this project's log.
-        const unified = this.unifiedMemory();
-        const parts = [rendered.content];
-        if (brainBrief)
-            parts.push(brainBrief);
-        if (unified.sources.length > 0)
-            parts.push(unified.document);
-        const enriched = parts.join("\n\n---\n");
-        await target.injectMemory(enriched);
-        writeMemoryFile(this.info.dir, to, enriched); // idempotent with default impl
-        this.pendingBriefings.set(to, buildBriefing(input));
-        if (rendered.mode === "llm") {
-            this.log.append({
-                kind: "status",
-                payload: { state: "projection", mode: "llm", ms: Date.now() - distillStart },
-            });
+        const bridgeIds = this.config.agents.map((cfg) => cfg.id).filter((id) => {
+            const agent = this.agents.get(id);
+            return agent && !isAdapter(agent) && id !== to;
+        });
+        const mergeNote = merge ? describeMerge(merge, holder ?? "the previous agent", to) : "";
+        if (this.continuity) {
+            // New context is assembled from the selected chat at dispatch, never
+            // from global history or private bridge memory on a picker click.
+            this.briefings.pendingBriefings.delete(to);
+            const { from } = this.baton.handoff(to, { ...handoffMeta, projected: false, continuity: 1 });
+            await this.ensureStarted(to);
+            return { from, ...(merge ? { merge } : {}) };
         }
-        // Bridges (GUI agents) are passive observers — keep their shared-context
-        // files fresh on every hop so e.g. Antigravity always sees the weave.
-        // (Always template views: N bridges × LLM calls per hop would be waste.)
-        for (const cfg of this.config.agents) {
-            const bystander = this.agents.get(cfg.id);
-            if (!bystander || isAdapter(bystander) || cfg.id === to)
-                continue;
-            // Bridges get the retrieved brain brief too — they can't take a system
-            // prompt, but their shared-context file is the only memory they have, so
-            // it shouldn't be the one view without the learned memories in it.
-            const bridgeBrief = this.retrieveBrief(events, cfg.id);
-            const bridgeView = bridgeBrief
-                ? `${buildProjection({ ...input, targetAgentId: cfg.id })}\n\n---\n${bridgeBrief}`
-                : buildProjection({ ...input, targetAgentId: cfg.id });
-            await bystander.injectMemory(bridgeView).catch(() => { });
+        const prepared = await this.briefings.prepareHandoff(to, holder, mergeNote, bridgeIds);
+        if (this.closed || this.agents.get(to) !== target)
+            throw new Error("handoff target is no longer active");
+        await target.injectMemory(prepared.memory);
+        if (this.closed || this.agents.get(to) !== target)
+            throw new Error("handoff target is no longer active");
+        writeMemoryFile(this.info.dir, to, prepared.memory);
+        this.briefings.pendingBriefings.set(to, prepared.briefing);
+        if (prepared.mode === "llm") {
+            this.log.append({ kind: "status", payload: { state: "projection", mode: "llm", ms: prepared.elapsedMs } });
         }
+        for (const bridge of prepared.bridges) {
+            await this.agents.get(bridge.agentId)?.injectMemory(bridge.memory).catch(() => { });
+        }
+        if (this.closed || this.agents.get(to) !== target)
+            throw new Error("handoff target is no longer active");
         const { from } = this.baton.handoff(to, handoffMeta);
         await this.ensureStarted(to);
-        return { from };
-    }
-    async interrupt(opts = {}) {
-        if ((opts.source ?? "user") === "user")
-            this.routes.onManualInterrupt();
-        const holder = this.validHolder();
-        if (!holder)
-            return { interrupted: null };
-        const agent = this.agent(holder);
-        if (isAdapter(agent) && agent.busy()) {
-            await agent.interrupt();
-            return { interrupted: holder };
-        }
-        return { interrupted: null };
+        return { from, ...(merge ? { merge } : {}) };
     }
+    async interrupt(opts = {}) { return this.turns.interrupt(opts); }
     // -------------------------------------------------------------------------
     // Routing
     // -------------------------------------------------------------------------
@@ -904,7 +2851,42 @@ export class ProjectRuntime {
      * list of agent ids/roles. Undefined → the "ship" route if defined, else
      * every adapter in config order.
      */
+    /**
+     * Opt-in: checkpoint before a route starts.
+     *
+     * A route is exactly the moment you let a fleet loose — several agents,
+     * several turns, no human between hops. With safety.snapshotBeforeRoutes on,
+     * the brain+board+config land in .loom/snapshots/pre-route-<ts>.json first,
+     * so `loom restore` has a "before" without anyone having remembered to take
+     * one. Bounded: the newest five are kept, older ones pruned — a safety net,
+     * not an archive.
+     */
+    snapshotBeforeRoute() {
+        if (!this.config.safety?.snapshotBeforeRoutes)
+            return;
+        try {
+            const dir = path.join(projectLoomDir(this.info.dir), "snapshots");
+            fs.mkdirSync(dir, { recursive: true });
+            const file = path.join(dir, `pre-route-${Date.now()}.json`);
+            fs.writeFileSync(file, JSON.stringify(this.snapshot(), null, 2) + "\n");
+            const old = fs
+                .readdirSync(dir)
+                .filter((f) => f.startsWith("pre-route-"))
+                .sort()
+                .slice(0, -5);
+            for (const f of old)
+                fs.rmSync(path.join(dir, f), { force: true });
+            logbook.info("routes", `snapshot taken before the route — ${path.basename(file)}`, undefined, this.info.id);
+        }
+        catch (err) {
+            // A safety net that blocks the route it protects is worse than none.
+            logbook.warn("routes", "pre-route snapshot failed", String(err), this.info.id);
+        }
+    }
     async startRoute(opts) {
+        if (this.continuity)
+            throw new ContinuityError("unsupported", "autonomous route continuity is not verified; select a native agent directly");
+        this.snapshotBeforeRoute();
         if (typeof opts.spec === "string" && opts.spec.trim() === "auto") {
             return this.routes.startDynamic(opts.task, {
                 ...(opts.router ? { router: opts.router } : {}),
@@ -955,18 +2937,61 @@ export class ProjectRuntime {
     async status() {
         const holder = this.validHolder();
         const agents = await Promise.all(this.config.agents.map(async (cfg) => {
-            const agent = this.agent(cfg.id);
+            // The picker shows a tick next to the active model; "" means the
+            // adapter's own default, which is the honest baseline.
+            const model = cfg.options?.model ?? "";
+            const live = this.agents.get(cfg.id);
+            if (!live) {
+                // Switched off: still in the roster, just not spawned. Its tier has
+                // to come from somewhere other than the instance, and switching an
+                // agent off must not change what it *is*. ADES first (the catalog
+                // people pick from), then the factory registry for the kinds ADES
+                // deliberately omits. Defaulting to "adapter" would be wrong for
+                // exactly those: a disabled bridge would advertise itself as an
+                // adapter to every surface that filters on this field.
+                const spec = ADES.find((a) => a.kind === cfg.kind);
+                const tier = spec?.tier ?? tierForKind(cfg.kind) ?? "adapter";
+                return {
+                    id: cfg.id,
+                    kind: cfg.kind,
+                    role: cfg.role,
+                    tier,
+                    available: false,
+                    busy: false,
+                    holdsBaton: false,
+                    model,
+                    permissions: permissionFor(cfg.kind, cfg.options),
+                    ...(cfg.instructions ? { instructions: cfg.instructions } : {}),
+                    ...sampling(cfg),
+                    ...(cfg.avatar ? { avatar: cfg.avatar } : {}),
+                    // "not spawned" is not "switched off". An agent whose CLI is missing
+                    // is still enabled in config, and reporting it as disabled made the
+                    // project-settings toggle render off — clicking it then wrote the
+                    // value it already had, so the agent could never be turned back on.
+                    enabled: cfg.enabled !== false,
+                };
+            }
             return {
                 id: cfg.id,
                 kind: cfg.kind,
                 role: cfg.role,
-                tier: agent.capabilities.tier,
-                available: await agent.available().catch(() => false),
-                busy: isAdapter(agent) ? agent.busy() : false,
+                tier: live.capabilities.tier,
+                available: this.continuity && isNativeKind(cfg.kind)
+                    ? (await this.harnesses.ensure(cfg.id)).available
+                    : await live.available().catch(() => false),
+                ...(this.continuity && isNativeKind(cfg.kind) ? { cliVersion: this.harnesses.get(cfg.id)?.version ?? null } : {}),
+                busy: isAdapter(live) ? live.busy() || Boolean(this.continuity && this.turns.busySince.has(cfg.id)) : false,
+                // 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,
-                // The picker shows a tick next to the active model; "" means the
-                // adapter's own default, which is the honest baseline.
-                model: cfg.options?.model ?? "",
+                model,
+                permissions: permissionFor(cfg.kind, cfg.options),
+                enabled: true,
+                ...(cfg.instructions ? { instructions: cfg.instructions } : {}),
+                ...sampling(cfg),
+                ...(cfg.avatar ? { avatar: cfg.avatar } : {}),
+                ...(isNativeKind(cfg.kind) ? { context: this.nativeUsage.context(cfg.id), limits: this.nativeUsage.limitsFor(cfg.kind) } : {}),
+                ...((f) => (f ? { forecast: f } : {}))(this.accounting.forecast(cfg.id)),
             };
         }));
         const recent = this.log.list({ limit: 50 });
@@ -975,11 +3000,16 @@ export class ProjectRuntime {
             .reverse()
             .find((e) => e.kind === "message" && !e.agentId);
         const lastNeedsInput = [...recent].reverse().find((e) => e.kind === "needs_input");
-        const needsInput = Boolean(lastNeedsInput && (!lastUserMsg || lastNeedsInput.id > lastUserMsg.id));
+        const reqId = lastNeedsInput && lastNeedsInput.payload.requestId;
+        // a question answered on its card (no message typed) is answered all the same
+        const answeredOnCard = Boolean(reqId && recent.some((e) => e.id > lastNeedsInput.id && e.kind === "status" &&
+            e.payload.state === "question_answered" && e.payload.requestId === reqId));
+        const needsInput = Boolean(lastNeedsInput && !answeredOnCard && (!lastUserMsg || lastNeedsInput.id > lastUserMsg.id));
         return {
             id: this.info.id,
             name: this.info.name,
             dir: this.info.dir,
+            ...(this.continuity ? { continuity: true } : {}),
             holder,
             agents,
             lastEvent,
@@ -990,27 +3020,278 @@ export class ProjectRuntime {
             chats: this.chats(),
             route: this.routes.state(),
             routeNames: ["auto", ...Object.keys(this.config.routes ?? {})],
-            costUsd: this.costs.totalUsd,
+            costUsd: this.accounting.costs.totalUsd,
+            // Paused agents belong in the status payload, not only in state on disk.
+            // Without this the UI cannot show that an alert has taken an agent out of
+            // rotation — the pause was real and completely invisible, which reads as
+            // "the self-heal did nothing".
+            quarantine: this.quarantined(),
+            orchestra: this.orchestraSummary(),
+        };
+    }
+    /**
+     * What every agent in this project is doing right now — for the fleet view.
+     *
+     * One row per roster agent (its thread, whether it's mid-turn, its last
+     * step) and one per orchestra task (worker sessions don't live in the
+     * roster). "Last step" is the newest event from that agent in that thread,
+     * summarised to a line: the tool it ran, the file it touched, what it said.
+     */
+    activity() {
+        const recent = this.log.list({ limit: 400 });
+        const chats = new Map(this.chats().map((c) => [c.id, c.title]));
+        const lastOf = (agentId, chat) => {
+            for (let i = recent.length - 1; i >= 0; i--) {
+                const e = recent[i];
+                if (e.agentId !== agentId)
+                    continue;
+                if (chat !== undefined && (e.chat ?? MAIN_CHAT) !== chat)
+                    continue;
+                return { kind: e.kind, ts: e.ts, chat: e.chat ?? MAIN_CHAT, line: activityLine(e) };
+            }
+            return null;
+        };
+        const agents = this.config.agents.map((cfg) => {
+            const live = this.agents.get(cfg.id);
+            const chat = this.turns.turnChat.get(cfg.id);
+            const last = lastOf(cfg.id, chat);
+            return {
+                id: cfg.id,
+                kind: cfg.kind,
+                role: cfg.role,
+                busy: Boolean(live && isAdapter(live) && (live.busy() || this.turns.busySince.has(cfg.id))),
+                since: this.turns.busySince.get(cfg.id) ?? null,
+                permissions: permissionFor(cfg.kind, cfg.options),
+                holdsBaton: this.validHolder() === cfg.id,
+                chat: chat ?? last?.chat ?? null,
+                chatTitle: chats.get(chat ?? last?.chat ?? "") ?? null,
+                last,
+            };
+        });
+        const run = this.orchestra.active() ?? this.orchestra.list()[0];
+        const orchestra = run
+            ? {
+                id: run.id,
+                goal: run.goal,
+                status: run.status,
+                chat: run.chat,
+                orchestrator: run.orchestrator.agent,
+                tasks: run.tasks.map((t) => ({
+                    id: t.id,
+                    title: t.title,
+                    agent: t.agent,
+                    status: t.status,
+                    chat: t.chat,
+                    attempts: t.attempts,
+                    files: t.files?.length ?? 0,
+                    last: lastOf(t.agent, t.chat),
+                })),
+            }
+            : null;
+        return {
+            project: { id: this.info.id, name: this.info.name },
+            agents,
+            orchestra,
+            crews: this.crews.list().filter(c => c.state.goal && !["completed", "failed", "stopped"].includes(c.state.goal.status)).map(c => ({
+                id: c.id, name: c.name, goal: c.state.goal.text, status: c.state.goal.status, channel: c.state.channel, active: c.active,
+                cards: c.state.goal.cards.map(card => ({ id: card.id, title: card.title, stage: card.stage, teammate: card.builder })),
+            })),
+            subtasks: this.liveSubtasks(),
+            route: this.routes.state(),
+        };
+    }
+    /** The team member running this daemon (set by Team Link), for commit trailers. */
+    memberLogin = null;
+    /** Loom Teams, Phase 2: this project's team coordinator (set by Team Link). */
+    coordinator = null;
+    /** Loom Teams, Phase 3: this project's share of the team brain (set by Team Link). */
+    teamBrain = null;
+    /** The effective loom.team.json while shared with a team (D37); null when solo. */
+    teamPolicy = null;
+    crewSpendLedger = { day: "", after: 0, total: 0, crews: new Map() };
+    crewSpendToday(crew) {
+        const day = new Date().toISOString().slice(0, 10), start = Date.parse(`${day}T00:00:00Z`);
+        if (this.crewSpendLedger.day !== day)
+            this.crewSpendLedger = { day, after: 0, total: 0, crews: new Map() };
+        const ledger = this.crewSpendLedger;
+        // a new day starts its ledger at the day's first event, not at the first event ever written
+        for (const event of this.log.list({ kinds: ["status"], since: ledger.after, ...(ledger.after === 0 ? { sinceTs: start } : {}) })) {
+            const id = event.payload.crew?.crewId;
+            const cost = Number(event.payload.costUsd);
+            if (id && event.ts >= start && event.payload.state === "turn_cost" && Number.isFinite(cost) && cost > 0) {
+                ledger.total += cost;
+                ledger.crews.set(id, (ledger.crews.get(id) ?? 0) + cost);
+            }
+        }
+        ledger.after = this.log.lastId();
+        return crew ? ledger.crews.get(crew) ?? 0 : ledger.total;
+    }
+    /**
+     * An agent's options under the team policy (D38): its permission mode capped
+     * at the ceiling. Plan mode can't be known when an agent is built, so
+     * `bypassRequiresPlan` treats it as off — the stricter reading.
+     */
+    policyOptions(cfg) {
+        const opts = { ...(cfg.options ?? {}) };
+        if (this.runnerMode) {
+            // A runner is its own trust tier (D70): agents bypass inside the sandbox,
+            // capped by the team's runners.permissions rather than the laptop ceiling.
+            const wanted = opts.permissions ? permissionFor(cfg.kind, opts) : "bypass";
+            const ceiling = this.teamPolicy?.runners.permissions ?? "bypass";
+            const rank = { ask: 0, auto: 1, bypass: 2 };
+            opts.permissions = rank[wanted] > rank[ceiling] ? ceiling : wanted;
+            if (this.teamPolicy)
+                opts.permissions = capCrewPermission(this.teamPolicy.crews ?? DEFAULT_CREW_POLICY, cfg.role, opts.permissions);
+            if (this.teamPolicy) {
+                const reason = unsupportedReason(cfg.kind, opts.permissions);
+                if (reason)
+                    throw new Error(`team policy requires ${opts.permissions} for ${cfg.id}, but ${cfg.kind} cannot enforce it: ${reason}`);
+            }
+            return opts;
+        }
+        if (!this.teamPolicy)
+            return opts;
+        const wanted = permissionFor(cfg.kind, opts);
+        const capped = cappedPermission(this.teamPolicy, wanted, false);
+        const roleCap = capCrewPermission(this.teamPolicy.crews ?? DEFAULT_CREW_POLICY, cfg.role, capped);
+        const unsupported = unsupportedReason(cfg.kind, roleCap);
+        if (unsupported)
+            throw new Error(`team policy requires ${roleCap} for ${cfg.id}, but ${cfg.kind} cannot enforce it: ${unsupported}`);
+        if (roleCap !== wanted)
+            opts.permissions = roleCap;
+        return opts;
+    }
+    /** Phase 5: this project is a runner's workspace for one goal (D70). */
+    runnerMode = false;
+    /** Adapter kinds usable on this machine: the roster's plus installed CLIs. */
+    usableKinds() {
+        const roster = this.config.agents.filter((a) => a.enabled !== false && tierForKind(a.kind) === "adapter").map((a) => a.kind);
+        return [...new Set([...roster, ...this.installedKinds])];
+    }
+    /**
+     * One question to one agent, outside any thread: the Phase 4 review (D60).
+     * Runs in `dir` (a throwaway directory, so a reviewer that forgets it's
+     * read-only can't touch the project), returns everything it said, and
+     * counts its cost like any turn.
+     */
+    async askAgent(kind, dir, text, opts = {}) {
+        const cfg = this.config.agents.find((a) => a.kind === kind) ?? { id: `${kind}-review`, kind, role: "reviewer" };
+        const agent = createAgent({ ...cfg, id: `${cfg.id}-review`, options: { ...this.policyOptions(cfg), loomProject: this.info.id } }, dir);
+        if (!isAdapter(agent))
+            throw new Error(`"${kind}" can't answer questions headless`);
+        let said = "";
+        const off = agent.onEvent((e) => {
+            const p = e.payload;
+            if (e.kind === "message" && !p.reasoning && p.role !== "user")
+                said += `\n${String(p.text ?? "")}`;
+            if (e.kind === "status" && p.state === "turn_cost") {
+                this.trackCost({ id: -1, ts: Date.now(), kind: e.kind, agentId: agent.id, payload: p });
+            }
+        });
+        const timeout = opts.timeoutMs ?? 15 * 60_000;
+        let timer;
+        try {
+            await agent.start();
+            await Promise.race([
+                agent.send({ text }),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error(`${kind} didn't answer within ${Math.round(timeout / 60_000)} min`)), timeout);
+                }),
+            ]);
+            return said.trim();
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            off();
+            if (agent.busy())
+                await agent.interrupt().catch(() => { });
+            await agent.stop().catch(() => { });
+        }
+    }
+    /** Share this project with a team, or record an explicit opt-out (null). */
+    setTeam(share) {
+        this.config.team = share ? { teamId: share.teamId, repo: share.repo } : { optOut: true };
+        this.saveConfig();
+    }
+    chatOf(agentId) { return this.turns.chatOf(agentId); }
+    /** The live (or latest) orchestra run, compact — for status payloads. */
+    orchestraSummary() {
+        const run = this.orchestra.active() ?? this.orchestra.list()[0];
+        if (!run)
+            return null;
+        return {
+            id: run.id,
+            goal: run.goal,
+            status: run.status,
+            chat: run.chat,
+            // Whether that thread is the run's own or one it borrowed \u2014 a borrowed
+            // one stops answering for the run when the run ends.
+            ...(run.inPlace ? { inPlace: true } : {}),
+            orchestrator: run.orchestrator.agent,
+            tasks: run.tasks.length,
+            done: run.tasks.filter((t) => t.status === "done").length,
+            running: run.tasks.filter((t) => t.status === "running").length,
+            /**
+             * One row per task, small enough to ride on every status poll.
+             *
+             * `tasks` above is a count, which is all the tab dot needed. It left
+             * every other surface unable to answer questions the daemon knows the
+             * answer to: which agent owns this thread (a task thread used to claim
+             * to be whoever held the baton), whether a thread is still running, and
+             * where a task's work went.
+             */
+            threads: run.tasks.map((t) => ({
+                id: t.id,
+                title: t.title,
+                chat: t.chat,
+                agent: t.agent,
+                kind: t.kind,
+                status: t.status,
+            })),
         };
     }
     async close() {
-        for (const id of this.startedAgents) {
-            await this.agent(id).stop().catch(() => { });
+        await this.orchestra.shutdown().catch(() => { });
+        this.relay.stop();
+        this.shifts.close();
+        await this.crews.shutdown().catch(() => { });
+        this.closed = true;
+        this.harnesses.stop();
+        this.live.close();
+        this.briefings.close();
+        if (this.mcpTimer) {
+            clearInterval(this.mcpTimer);
+            this.mcpTimer = null;
         }
-        this.startedAgents.clear();
+        await this.agentLifecycle.close();
+        // A dev server outlives the daemon that started it unless we say otherwise,
+        // and an orphan holding port 3000 is a bad thing to leave behind.
+        if (this.queueCoordinator.clockTimer) {
+            clearInterval(this.queueCoordinator.clockTimer);
+            this.queueCoordinator.clockTimer = null;
+        }
+        await this.servers.closeAll().catch(() => { });
+        for (const proxy of this.proxies.values())
+            await proxy.close().catch(() => { });
+        this.proxies.clear();
         this.brain.close(); // unsubscribes before the log drops its listeners
         this.log.close();
     }
-}
-export function relativeToProject(projectDir, p) {
-    return path.isAbsolute(p) ? path.relative(projectDir, p) : p;
-}
-function configMtimeOf(projectDir) {
-    try {
-        return fs.statSync(path.join(projectDir, ".loom", "config.json")).mtimeMs;
-    }
-    catch {
-        return 0;
+    closed = false;
+    /**
+     * Append unless the runtime has been closed.
+     *
+     * The async tails need this: a subtask completion or a turn error can resolve
+     * after close() — stopping an agent does not cancel a promise already in
+     * flight — and appending then throws into an unhandled rejection against a
+     * sqlite handle that no longer exists. The record is not lost so much as
+     * meaningless: the project this event belonged to is gone from memory.
+     */
+    appendIfOpen(event) {
+        if (this.closed)
+            return;
+        this.log.append(event);
     }
 }
 //# sourceMappingURL=runtime.js.map