@robzilla1738/agentswarm 0.3.0 → 0.6.0

package/dist/executor.js

@@ -40,12 +40,14 @@ const agent_1 = require("./agent");
 const config_1 = require("./config");
 const control_1 = require("./control");
 const deepseek_1 = require("./deepseek");
+const journal_1 = require("./journal");
 const tools_1 = require("./tools");
 const prompts_1 = require("./prompts");
+const memory_1 = require("./memory");
+const report_1 = require("./report");
 const sandbox_1 = require("./sandbox");
 const types_1 = require("./types");
 const util_1 = require("./util");
-const VERIFY_MAX_ATTEMPTS = 2;
 class Executor {
     cfg;
     meta;
@@ -59,6 +61,7 @@ class Executor {
     inflight = new Map();
     settledSinceUpdate = [];
     notes = [];
+    phase = null;
     conductorMessages = [];
     spentTokens = 0;
     cost = 0;
@@ -67,19 +70,43 @@ class Executor {
     finishReason = "";
     fatal = null;
     lastConductorAction = "none";
+    conductorFailures = 0;
+    /** True when the last conductor turn ended in a call error, not a decision. */
+    lastConductorErrored = false;
     resumed = false;
     sandbox;
-    constructor(cfg, meta, journal) {
+    mode;
+    teamId;
+    opts;
+    /** Team-mode result: the consolidated report handed back to the parent task. */
+    teamReport = "";
+    constructor(cfg, meta, journal, opts = {}) {
         this.cfg = cfg;
         this.meta = meta;
-        this.runDirPath = (0, config_1.runDir)(meta.id);
+        this.runDirPath = opts.runDirPath ?? (0, config_1.runDir)(meta.id);
         this.journal = journal;
         this.control = new control_1.ControlReader(this.runDirPath);
+        this.mode = opts.mode ?? "root";
+        this.teamId = opts.teamId;
+        this.opts = opts;
+        if (opts.sharedNotes)
+            this.notes = opts.sharedNotes;
         (0, util_1.ensureDir)(path.join(this.runDirPath, "artifacts"));
-        // "A directory on disk" runs always execute on the host — touching the
-        // operator's real files is the entire point of that mode.
-        const kind = meta.sandbox ? meta.options.sandboxRuntime ?? "host" : "host";
-        this.sandbox = (0, sandbox_1.createSandbox)(kind, { runId: meta.id, hostDir: meta.cwd, cfg });
+        if (opts.sandbox) {
+            this.sandbox = opts.sandbox;
+        }
+        else {
+            // "A directory on disk" runs always execute on the host — touching the
+            // operator's real files is the entire point of that mode.
+            const kind = meta.sandbox ? meta.options.sandboxRuntime ?? "host" : "host";
+            this.sandbox = (0, sandbox_1.createSandbox)(kind, { runId: meta.id, hostDir: meta.cwd, cfg });
+        }
+        if (opts.parentSignal) {
+            if (opts.parentSignal.aborted)
+                this.ac.abort();
+            else
+                opts.parentSignal.addEventListener("abort", () => this.ac.abort(), { once: true });
+        }
     }
     cancel() {
         this.finishing = true;
@@ -107,18 +134,52 @@ class Executor {
             const n = Number(/^T(\d+)$/.exec(copy.id)?.[1] ?? 0);
             this.taskCounter = Math.max(this.taskCounter, n);
         }
-        this.notes = state.notes.map((n) => ({ taskId: n.taskId, key: n.key, text: n.text }));
+        // Drop claims held by settled tasks — they were released on task end and
+        // must not resurrect across a restart.
+        const settled = new Set(state.taskList().filter((t) => ["done", "failed", "blocked"].includes(t.status) && !reset.has(t.id)).map((t) => t.id));
+        this.notes = state.notes
+            .map((n) => ({ taskId: n.taskId, key: n.key, kind: n.kind, text: n.text, url: n.url }))
+            .filter((n) => !(n.kind === "claim" && n.taskId && settled.has(n.taskId)));
+        const lastPhase = state.phases[state.phases.length - 1];
+        if (lastPhase)
+            this.phase = { name: lastPhase.name, goal: lastPhase.goal, exitCriteria: lastPhase.exitCriteria };
         this.spentTokens = state.totalUsage.promptTokens + state.totalUsage.completionTokens;
         this.cost = state.cost;
+        try {
+            // The living plan survives restarts from disk, not from the journal.
+            this.planDoc = fs.readFileSync(path.join(this.runDirPath, "artifacts", this.planFileName()), "utf8");
+        }
+        catch {
+            /* no plan yet */
+        }
         this.resumed = true;
     }
     setStatus(status, reason) {
+        // A team is one task of the parent run, not a run of its own.
+        if (this.mode === "team")
+            return;
         this.journal.append("run.status", { status, reason });
     }
+    budgetWarned = new Set();
     onUsage = (model, usage) => {
         this.spentTokens += usage.promptTokens + usage.completionTokens;
         this.cost += (0, types_1.usageCost)(usage, this.cfg.pricing[model]);
         this.journal.append("usage", { model, usage, cost: this.cost });
+        // Team spend also counts against the parent's (authoritative) budget.
+        this.opts.onUsageForward?.(model, usage);
+        const cap = this.meta.options.maxTokens;
+        if (cap > 0) {
+            const pct = (this.spentTokens / cap) * 100;
+            for (const threshold of [50, 80, 95]) {
+                if (pct >= threshold && !this.budgetWarned.has(threshold)) {
+                    this.budgetWarned.add(threshold);
+                    this.journal.append("log", {
+                        level: threshold >= 95 ? "warn" : "info",
+                        msg: `budget: ${threshold}% of the run's token cap used (est. $${this.cost.toFixed(2)})`,
+                    });
+                }
+            }
+        }
     };
     budgetExceeded() {
         return this.spentTokens >= this.meta.options.maxTokens;
@@ -126,39 +187,69 @@ class Executor {
     blackboardDigest(max = 1800) {
         if (!this.notes.length)
             return "";
-        const lines = this.notes
-            .slice(-40)
-            .map((n) => `• ${n.key ? `[${n.key}] ` : ""}${(0, util_1.oneLine)(n.text, 160)}${n.taskId ? ` (${n.taskId})` : ""}`);
-        let out = lines.join("\n");
-        if (out.length > max)
-            out = out.slice(out.length - max);
-        return out;
+        const fmt = (n) => `• ${n.kind && n.kind !== "finding" ? `[${n.kind}] ` : ""}${n.key ? `[${n.key}] ` : ""}${(0, util_1.oneLine)(n.text, 160)}${n.url ? ` <${n.url}>` : ""}${n.taskId ? ` (${n.taskId})` : ""}`;
+        // Decisions and conflicts anchor mission-wide coherence and are never
+        // trimmed out of the digest; everything else shows only its recent tail.
+        const pinned = this.notes.filter((n) => n.kind === "decision" || n.kind === "conflict").map(fmt);
+        const rest = this.notes.filter((n) => n.kind !== "decision" && n.kind !== "conflict").slice(-80).map(fmt);
+        let tail = rest.join("\n");
+        const budget = Math.max(400, max - pinned.join("\n").length);
+        if (tail.length > budget)
+            tail = tail.slice(tail.length - budget);
+        return [pinned.join("\n"), tail].filter(Boolean).join("\n");
+    }
+    searchNotes(query) {
+        const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+        if (!terms.length)
+            return "empty query";
+        const scored = this.notes
+            .map((n) => {
+            const hay = `${n.key ?? ""} ${n.kind ?? ""} ${n.text}`.toLowerCase();
+            const score = terms.reduce((s, t) => s + (hay.includes(t) ? 1 : 0), 0);
+            return { n, score };
+        })
+            .filter((x) => x.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 12);
+        if (!scored.length)
+            return "no notes matched";
+        return scored
+            .map(({ n }) => `• ${n.kind ? `[${n.kind}] ` : ""}${n.key ? `[${n.key}] ` : ""}${(0, util_1.clip)(n.text, 400)}${n.taskId ? ` (${n.taskId})` : ""}`)
+            .join("\n");
     }
     // ---------------------------------------------------------------- main
     async run() {
         this.setStatus("planning");
-        // Preflight: validate auth before doing any work so the operator gets an
-        // instant, clear error instead of a phantom "done" run.
-        const auth = await (0, deepseek_1.validateAuth)(this.cfg);
-        if (auth.status === "invalid") {
-            this.fatal = `Provider authentication failed — ${auth.message || "invalid API key"}. Set a valid key in Settings (or: swarm config set apiKey <...>).`;
-            this.finishReason = this.fatal;
-            this.journal.append("log", { level: "error", msg: this.fatal });
-            await this.fail(this.fatal);
-            return;
-        }
-        // Boot the sandbox before any work — a dead Docker daemon or a bad cloud
-        // key must fail the run instantly with a clear reason, not mid-mission.
-        try {
-            await this.sandbox.start((msg) => this.journal.append("log", { level: "info", msg }));
-            this.journal.append("log", { level: "info", msg: `sandbox: ${this.sandbox.label}` });
-        }
-        catch (e) {
-            this.fatal = `Sandbox failed to start — ${(0, util_1.errMsg)(e)}`;
-            this.finishReason = this.fatal;
-            this.journal.append("log", { level: "error", msg: this.fatal });
-            await this.fail(this.fatal);
-            return;
+        if (this.mode === "root") {
+            // Surface AIMD limiter adjustments (429 pressure) in the journal/UI.
+            (0, deepseek_1.gateFor)(this.cfg).onState = (s) => {
+                this.journal.append("limiter.state", { ceiling: s.ceiling, active: s.active, queued: s.queued });
+            };
+            // Preflight: validate auth before doing any work so the operator gets an
+            // instant, clear error instead of a phantom "done" run. (Teams inherit a
+            // parent that already passed.)
+            const auth = await (0, deepseek_1.validateAuth)(this.cfg);
+            if (auth.status === "invalid") {
+                this.fatal = `Provider authentication failed — ${auth.message || "invalid API key"}. Set a valid key in Settings (or: swarm config set apiKey <...>).`;
+                this.finishReason = this.fatal;
+                this.journal.append("log", { level: "error", msg: this.fatal });
+                await this.fail(this.fatal);
+                return;
+            }
+            // Boot the sandbox before any work — a dead Docker daemon or a bad cloud
+            // key must fail the run instantly with a clear reason, not mid-mission.
+            // (Teams share the parent's already-running sandbox.)
+            try {
+                await this.sandbox.start((msg) => this.journal.append("log", { level: "info", msg }));
+                this.journal.append("log", { level: "info", msg: `sandbox: ${this.sandbox.label}` });
+            }
+            catch (e) {
+                this.fatal = `Sandbox failed to start — ${(0, util_1.errMsg)(e)}`;
+                this.finishReason = this.fatal;
+                this.journal.append("log", { level: "error", msg: this.fatal });
+                await this.fail(this.fatal);
+                return;
+            }
         }
         // Operator control must land while agents are mid-task, not only when the
         // scheduler wakes up — a Stop click aborts in-flight work within ~1s.
@@ -170,13 +261,18 @@ class Executor {
                 /* control polling must never kill the run */
             }
         }, 750);
+        // Real-directory runs remember: prior missions in the same workspace feed
+        // the conductor so it builds on settled decisions instead of starting cold.
+        const memory = this.mode === "root" && !this.meta.sandbox ? (0, memory_1.memoryBlock)(this.meta.cwd) : "";
         this.conductorMessages = [
-            { role: "system", content: (0, prompts_1.conductorSystem)(this.meta) },
+            { role: "system", content: (0, prompts_1.conductorSystem)(this.meta) + (memory ? `\n\n${memory}` : "") },
             {
                 role: "user",
                 content: this.resumed
                     ? (0, prompts_1.conductorUpdate)({
                         blackboard: this.blackboardDigest(),
+                        phase: this.phaseLine(),
+                        plan: this.planPin(),
                         nextId: this.nextId(),
                         taskTable: (0, prompts_1.taskTable)(this.taskList()),
                         budgetLine: (0, prompts_1.budgetLine)({ total: this.spentTokens, cost: this.cost }, this.meta.options.maxTokens),
@@ -188,56 +284,23 @@ class Executor {
                     : (0, prompts_1.conductorInitialUpdate)(this.meta, this.nextId()),
             },
         ];
+        if (this.resumed) {
+            // The conductor's reasoning history died with the old process. Re-seed
+            // the durable facts into the same slot trimConductorHistory() maintains,
+            // so a resumed conductor knows what settled and what was decided.
+            this.conductorMessages.splice(1, 0, {
+                role: "user",
+                content: this.missionLedger("This run was resumed — prior orchestration history is gone."),
+            });
+        }
         try {
             await this.conductorTurn();
             this.setStatus("running");
-            while (!this.finishing) {
-                this.drainControl();
-                if (this.finishing)
-                    break;
-                if (this.budgetExceeded()) {
-                    this.finishing = true;
-                    this.finishReason = "token budget reached";
-                    break;
-                }
-                this.startReadyTasks();
-                if (this.inflight.size === 0) {
-                    const runnable = this.runnableTasks();
-                    if (runnable.length > 0)
-                        continue; // loop starts them
-                    // Nothing running, nothing runnable. Include any reports that
-                    // settled while the conductor was mid-turn — they must not be lost.
-                    this.blockStuckTasks();
-                    const reports = this.drainSettled();
-                    if (!this.hasOpenWork()) {
-                        // Everything is terminal. Ask the conductor for a final decision.
-                        this.appendConductorUpdate("All tasks have settled and no tasks are runnable.", reports);
-                        await this.conductorTurn();
-                        if (this.lastConductorAction !== "spawn") {
-                            this.finishing = true;
-                            this.finishReason = this.finishReason || "all tasks settled";
-                        }
-                    }
-                    else {
-                        // Stuck: pending tasks exist but can't run (failed/blocked deps).
-                        this.appendConductorUpdate("Some tasks cannot run because their dependencies failed or were blocked. Re-plan around them or finish.", reports);
-                        await this.conductorTurn();
-                        if (this.lastConductorAction === "wait") {
-                            this.finishing = true;
-                            this.finishReason = "stalled: dependencies unmet and conductor chose to wait";
-                        }
-                    }
-                    continue;
-                }
-                // Tasks are running — wait for at least one to settle.
-                await Promise.race([...this.inflight.values()]);
-                this.drainControl();
-                const reports = this.drainSettled();
-                if (reports.length && !this.finishing) {
-                    this.appendConductorUpdate(undefined, reports);
-                    await this.conductorTurn();
-                }
-            }
+            await this.mainLoop();
+            // Strict verification: one completeness review before synthesis; if it
+            // finds real gaps the conductor gets one chance to fill them.
+            if (await this.completenessPass())
+                await this.mainLoop();
         }
         catch (e) {
             if (!this.ac.signal.aborted) {
@@ -251,12 +314,231 @@ class Executor {
             await Promise.allSettled([...this.inflight.values()]);
         }
         this.drainSettled();
+        if (this.mode === "team") {
+            await this.consolidateTeam();
+            return; // the parent owns the sandbox, final flush, and run status
+        }
         await this.synthesize();
-        await this.sandbox.destroy().catch(() => {
-            /* container/sandbox teardown is best-effort */
-        });
+        // Teardown is best-effort AND bounded — a wedged container must not hang
+        // the engine after the report is already written.
+        await Promise.race([
+            this.sandbox.destroy().catch(() => { }),
+            new Promise((r) => setTimeout(r, 15_000).unref()),
+        ]);
         await this.journal.flush();
     }
+    // ---------------------------------------------------------------- teams
+    /** All artifacts reported by this (team) executor's tasks. */
+    teamArtifacts() {
+        return [...new Set(this.taskList().flatMap((t) => t.artifacts))];
+    }
+    /** Whether any task here actually completed. */
+    anyTaskDone() {
+        return this.taskList().some((t) => t.status === "done");
+    }
+    /** Team-mode finale: one consolidated report instead of run synthesis. */
+    async consolidateTeam() {
+        const tasks = this.taskList();
+        const reports = tasks.length ? tasks.map(prompts_1.reportBlock).join("\n\n") : "(no tasks were completed)";
+        try {
+            const res = await (0, deepseek_1.chat)(this.cfg, {
+                model: this.meta.options.conductorModel,
+                priority: "high",
+                messages: [
+                    {
+                        role: "user",
+                        content: `You led a sub-team inside a larger agent swarm. Consolidate your team's work into ONE report for the parent conductor: what was accomplished (with evidence and exact paths), what failed or remains open, and the key facts the rest of the mission needs.\n\nTEAM OBJECTIVE\n${this.meta.mission}\n\nOUTCOME: ${this.finishReason || "completed"}\nLead's closing notes: ${this.finishNotes || "(none)"}\n\nTASK REPORTS\n${(0, util_1.truncateMiddle)(reports, 60_000, "chars")}\n\nReply with the consolidated report only.`,
+                    },
+                ],
+                thinking: false,
+                maxTokens: 4096,
+                signal: new AbortController().signal, // consolidation runs even when cancelled
+            });
+            this.onUsage(this.meta.options.conductorModel, res.usage);
+            this.teamReport = (res.content || "").trim();
+        }
+        catch (e) {
+            this.journal.append("log", { level: "warn", msg: `team consolidation failed: ${(0, util_1.errMsg)(e)}` });
+        }
+        if (!this.teamReport) {
+            this.teamReport = tasks
+                .map((t) => `${t.id} [${t.status}] ${t.title}: ${(0, util_1.oneLine)(t.report ?? t.error ?? "(no output)", 200)}`)
+                .join("\n");
+        }
+    }
+    /** Run a team:true task as a sub-swarm sharing this run's everything. */
+    async runTeam(task) {
+        const remaining = Math.max(0, this.meta.options.maxTokens - this.spentTokens);
+        const childMeta = {
+            ...this.meta,
+            mission: `${task.objective}${task.context ? `\n\nContext from the parent conductor:\n${task.context}` : ""}`,
+            options: {
+                ...this.meta.options,
+                maxWorkers: task.teamMaxWorkers || Math.max(2, Math.min(16, Math.floor(this.meta.options.maxWorkers / 2))),
+                maxTokens: Math.min(remaining, task.teamBudgetTokens || Math.max(50_000, Math.floor(remaining / 4))),
+                maxTasks: Math.min(this.meta.options.maxTasks, 24),
+            },
+        };
+        this.journal.append("team.created", {
+            taskId: task.id,
+            maxWorkers: childMeta.options.maxWorkers,
+            budgetTokens: childMeta.options.maxTokens,
+        });
+        const child = new Executor(this.cfg, childMeta, new journal_1.TeamJournal(this.journal, task.id), {
+            mode: "team",
+            teamId: task.id,
+            sandbox: this.sandbox,
+            runDirPath: this.runDirPath,
+            onUsageForward: (model, usage) => {
+                // Absorb tokens/cost only — the child already journaled the usage event.
+                this.spentTokens += usage.promptTokens + usage.completionTokens;
+                this.cost += (0, types_1.usageCost)(usage, this.cfg.pricing[model]);
+            },
+            parentSignal: this.ac.signal,
+            sharedNotes: this.notes,
+        });
+        await child.run();
+        if (this.ac.signal.aborted) {
+            this.finalizeTask(task, "failed", "run cancelled");
+            return;
+        }
+        const report = child.teamReport || "(team produced no consolidated report)";
+        for (const a of child.teamArtifacts())
+            if (!task.artifacts.includes(a))
+                task.artifacts.push(a);
+        task.report = report;
+        task.reportStatus = "done";
+        this.journal.append("team.report", { taskId: task.id, report, artifacts: task.artifacts });
+        this.journal.append("task.report", { taskId: task.id, status: "done", report, artifacts: task.artifacts });
+        this.finalizeTask(task, child.anyTaskDone() ? "done" : "failed", report);
+    }
+    async mainLoop() {
+        while (!this.finishing) {
+            this.drainControl();
+            if (this.finishing)
+                break;
+            if (this.budgetExceeded()) {
+                this.finishing = true;
+                this.finishReason = "token budget reached";
+                break;
+            }
+            if (this.journal.degraded) {
+                // The journal is the source of truth; if it can't be written, the
+                // run must stop loudly rather than burn tokens on unrecorded work.
+                this.finishing = true;
+                this.finishReason = "journal writes are failing — run state is no longer durable";
+                this.ac.abort();
+                break;
+            }
+            this.startReadyTasks();
+            if (this.inflight.size === 0) {
+                const runnable = this.runnableTasks();
+                if (runnable.length > 0)
+                    continue; // loop starts them
+                // Nothing running, nothing runnable. Include any reports that
+                // settled while the conductor was mid-turn — they must not be lost.
+                this.blockStuckTasks();
+                const reports = this.drainSettled();
+                if (!this.hasOpenWork()) {
+                    // Everything is terminal. Ask the conductor for a final decision.
+                    this.appendConductorUpdate("All tasks have settled and no tasks are runnable.", reports);
+                    await this.conductorTurn();
+                    // An errored turn is not a decision — keep looping so the breaker
+                    // can retry (and eventually trip) instead of misreading the error
+                    // as "the conductor chose to stop".
+                    if (this.lastConductorAction !== "spawn" && !this.lastConductorErrored) {
+                        this.finishing = true;
+                        this.finishReason = this.finishReason || "all tasks settled";
+                    }
+                }
+                else {
+                    // Stuck: pending tasks exist but can't run (failed/blocked deps).
+                    this.appendConductorUpdate("Some tasks cannot run because their dependencies failed or were blocked. Re-plan around them or finish.", reports);
+                    await this.conductorTurn();
+                    if (this.lastConductorAction === "wait" && !this.lastConductorErrored) {
+                        this.finishing = true;
+                        this.finishReason = "stalled: dependencies unmet and conductor chose to wait";
+                    }
+                }
+                continue;
+            }
+            // Tasks are running — wait for at least one to settle, then debounce:
+            // at 100 agents, settles arrive constantly, and waking the conductor
+            // for every one of them serializes the whole swarm on its turns.
+            await Promise.race([...this.inflight.values()]);
+            const debounceMs = Number(process.env.SWARM_SETTLE_DEBOUNCE_MS ?? "2000");
+            const settleCap = Math.max(3, Math.ceil(this.activeWorkerCount() / 8));
+            while (debounceMs > 0 && this.inflight.size > 0 && this.settledSinceUpdate.length < settleCap) {
+                const before = this.settledSinceUpdate.length;
+                await Promise.race([...this.inflight.values(), (0, util_1.sleep)(debounceMs)]);
+                if (this.settledSinceUpdate.length === before)
+                    break; // quiet period — flush to the conductor
+                this.drainControl();
+                if (this.finishing)
+                    break;
+                this.startReadyTasks(); // settles free dep chains; don't idle workers during the debounce
+            }
+            this.drainControl();
+            const reports = this.drainSettled();
+            if (reports.length && !this.finishing) {
+                this.appendConductorUpdate(undefined, reports);
+                await this.conductorTurn();
+            }
+        }
+    }
+    /**
+     * Strict-mode gap review before synthesis. Returns true when the conductor
+     * accepted gap-filling work (the main loop must run again).
+     */
+    gapPassDone = false;
+    async completenessPass() {
+        if (this.mode === "team")
+            return false; // the root run owns gap review
+        if (this.cfg.verification !== "strict" || this.gapPassDone)
+            return false;
+        if (this.fatal || this.ac.signal.aborted || this.budgetExceeded())
+            return false;
+        if (this.finishReason.includes("cancel") || this.finishReason.includes("conductor unavailable"))
+            return false;
+        if (!this.taskList().some((t) => t.status === "done"))
+            return false;
+        this.gapPassDone = true;
+        let verdict = "";
+        try {
+            const res = await (0, deepseek_1.chat)(this.cfg, {
+                model: this.meta.options.conductorModel,
+                messages: [
+                    {
+                        role: "user",
+                        content: (0, prompts_1.completenessPrompt)(this.meta.mission, (0, prompts_1.taskTable)(this.taskList()), (0, util_1.truncateMiddle)(this.taskList().map(prompts_1.reportBlock).join("\n\n"), 80_000, "chars")),
+                    },
+                ],
+                thinking: false,
+                maxTokens: 2048,
+                signal: this.ac.signal,
+            });
+            this.onUsage(this.meta.options.conductorModel, res.usage);
+            verdict = (res.content || "").trim();
+        }
+        catch (e) {
+            this.journal.append("log", { level: "warn", msg: `completeness review failed: ${(0, util_1.errMsg)(e)}` });
+            return false;
+        }
+        if (!verdict || /^COMPLETE\b/i.test(verdict)) {
+            this.journal.append("log", { level: "info", msg: "completeness review: no gaps found" });
+            return false;
+        }
+        this.journal.append("log", { level: "info", msg: `completeness review found gaps:\n${(0, util_1.clip)(verdict, 1500)}` });
+        this.finishing = false;
+        this.appendConductorUpdate(`COMPLETENESS REVIEW found gaps before final synthesis:\n${(0, util_1.clip)(verdict, 2000)}\n` +
+            "Spawn focused tasks to close the REAL gaps (or finish if you judge them immaterial). This is the final round.");
+        await this.conductorTurn();
+        if (this.lastConductorAction === "spawn")
+            return true;
+        this.finishing = true;
+        this.finishReason = this.finishReason || "all tasks settled";
+        return false;
+    }
     // ---------------------------------------------------------------- conductor
     nextId() {
         return this.taskCounter + 1;
@@ -267,7 +549,7 @@ class Executor {
         // Re-bound the history every turn — the nudge loop and tool-result pushes
         // below grow it outside appendConductorUpdate's trim.
         this.trimConductorHistory();
-        const tools = [tools_1.SPAWN_TASKS_TOOL, tools_1.WAIT_TOOL, tools_1.FINISH_TOOL];
+        const tools = [tools_1.SPAWN_TASKS_TOOL, tools_1.SET_PHASE_TOOL, tools_1.UPDATE_PLAN_TOOL, tools_1.CONDUCTOR_READ_REPORT_TOOL, tools_1.WAIT_TOOL, tools_1.FINISH_TOOL];
         for (let attempt = 0; attempt < 3; attempt++) {
             let res;
             try {
@@ -278,6 +560,9 @@ class Executor {
                     // "auto" rather than "required" for cross-provider safety; the prompt
                     // mandates a tool call and the no-tool nudge loop below enforces it.
                     toolChoice: "auto",
+                    // The conductor is the swarm's brain: it must never queue behind a
+                    // hundred worker streams.
+                    priority: "high",
                     thinking: this.meta.options.thinking,
                     reasoningEffort: this.meta.options.reasoningEffort,
                     // Generous: with thinking enabled, reasoning + a large spawn_tasks
@@ -297,11 +582,26 @@ class Executor {
                     this.fatal = `Provider authentication failed — ${msg}. Set a valid key in Settings.`;
                     this.finishing = true;
                     this.finishReason = this.fatal;
+                    return;
+                }
+                // Circuit breaker: a transient failure degrades to "wait" so the loop
+                // keeps draining tasks, but repeated consecutive failures must end the
+                // run with a clear reason rather than spin forever.
+                this.conductorFailures++;
+                if (this.conductorFailures >= 5) {
+                    this.finishing = true;
+                    this.finishReason = `conductor unavailable: ${this.conductorFailures} consecutive call failures (last: ${msg})`;
+                    return;
                 }
-                // Treat a transient conductor failure as a wait so the loop keeps draining tasks.
+                const scale = Number(process.env.SWARM_BACKOFF_SCALE || "1") || 1;
+                const backoff = [2_000, 5_000, 15_000, 30_000][Math.min(this.conductorFailures - 1, 3)] * scale;
+                await new Promise((r) => setTimeout(r, backoff));
                 this.lastConductorAction = "wait";
+                this.lastConductorErrored = true;
                 return;
             }
+            this.conductorFailures = 0;
+            this.lastConductorErrored = false;
             this.onUsage(this.meta.options.conductorModel, res.usage);
             if (res.content.trim())
                 this.journal.append("conductor.say", { text: (0, util_1.clip)(res.content, 4000) });
@@ -334,6 +634,41 @@ class Executor {
                     toolResult = "Acknowledged. Synthesizing the final deliverable.";
                     acted = "finish";
                 }
+                else if (call.function.name === "update_plan") {
+                    const md = String(args.markdown ?? "");
+                    if (md.trim()) {
+                        this.planDoc = md;
+                        try {
+                            fs.writeFileSync(path.join(this.runDirPath, "artifacts", this.planFileName()), md, "utf8");
+                        }
+                        catch (e) {
+                            this.journal.append("log", { level: "warn", msg: `plan write failed: ${(0, util_1.errMsg)(e)}` });
+                        }
+                        this.journal.append("plan.updated", { teamScoped: this.mode === "team" || undefined, excerpt: (0, util_1.clip)(md, 1200) });
+                        toolResult = `Plan saved to artifacts/${this.planFileName()}.`;
+                    }
+                    else {
+                        toolResult = "Plan was empty — not saved.";
+                    }
+                    // Bookkeeping, not a scheduling decision — falls through to the nudge.
+                }
+                else if (call.function.name === "read_report") {
+                    toolResult = (0, util_1.truncateMiddle)(this.readReportText(String(args.task_id ?? "")), 8000, "chars");
+                    // Information lookup, not a scheduling decision — falls through to
+                    // the nudge loop if the conductor stopped here.
+                }
+                else if (call.function.name === "set_phase") {
+                    const name = (0, util_1.clip)(String(args.name ?? ""), 80);
+                    this.phase = {
+                        name,
+                        goal: args.goal ? String(args.goal) : undefined,
+                        exitCriteria: args.exit_criteria ? String(args.exit_criteria) : undefined,
+                    };
+                    this.journal.append("phase.set", { name, goal: this.phase.goal, exit_criteria: this.phase.exitCriteria });
+                    toolResult = `Phase set: ${name}. Now also call spawn_tasks, wait, or finish.`;
+                    // Not a scheduling decision by itself — fall through to the nudge
+                    // loop if the conductor stopped here.
+                }
                 else if (call.function.name === "wait") {
                     toolResult = "Waiting for running tasks to report.";
                     if (acted === "none")
@@ -344,6 +679,12 @@ class Executor {
                 }
                 this.conductorMessages.push({ role: "tool", tool_call_id: call.id, content: toolResult });
             }
+            if (acted === "none") {
+                // set_phase (or an unknown tool) alone is not a scheduling decision —
+                // ask again rather than letting the run misread it as "wait"/"finish".
+                this.conductorMessages.push({ role: "user", content: "Now call spawn_tasks, wait, or finish." });
+                continue;
+            }
             this.lastConductorAction = acted;
             this.journal.append("conductor.action", { kind: acted });
             return;
@@ -380,6 +721,7 @@ class Executor {
                 warnings.push(`${id}: dropped dep "${d}" (${idx >= i ? "same-batch later task — would deadlock" : "unknown task"})`);
                 return false;
             });
+            const rawSpec = spec;
             const task = {
                 id,
                 title: (0, util_1.clip)(String(spec.title ?? "task"), 120),
@@ -388,6 +730,10 @@ class Executor {
                 deps,
                 verify: Boolean(spec.verify) && this.cfg.verification !== "off",
                 context: spec.context ? String(spec.context) : undefined,
+                modelTier: ["cheap", "strong"].includes(String(spec.model)) ? spec.model : undefined,
+                team: Boolean(spec.team) && this.mode === "root",
+                teamMaxWorkers: Number(rawSpec.team_max_workers ?? rawSpec.teamMaxWorkers) || undefined,
+                teamBudgetTokens: Number(rawSpec.team_budget_tokens ?? rawSpec.teamBudgetTokens) || undefined,
                 status: "pending",
                 attempt: 1,
                 wave,
@@ -415,14 +761,46 @@ class Executor {
             w = Math.max(w, t.wave);
         return w + 1;
     }
+    /** The conductor's living plan document (mission-plan.md). */
+    planDoc = "";
+    planFileName() {
+        return this.mode === "team" ? `mission-plan-${this.teamId}.md` : "mission-plan.md";
+    }
+    planPin() {
+        if (!this.planDoc)
+            return undefined;
+        return `MISSION PLAN (artifacts/${this.planFileName()}, maintained via update_plan):\n${(0, util_1.clip)(this.planDoc, 1500)}`;
+    }
+    phaseLine() {
+        if (!this.phase)
+            return undefined;
+        return `CURRENT PHASE: ${this.phase.name}${this.phase.goal ? ` — ${this.phase.goal}` : ""}${this.phase.exitCriteria ? ` (exit: ${this.phase.exitCriteria})` : ""}`;
+    }
+    /** Full text for the reports that matter, one-liners past the cap. */
+    digestReports(reports) {
+        const CAP = 12;
+        if (reports.length <= CAP)
+            return reports.map(prompts_1.reportBlock);
+        const important = reports.filter((t) => t.status !== "done");
+        const done = reports.filter((t) => t.status === "done");
+        const fullDone = done.slice(-Math.max(0, CAP - important.length));
+        const briefDone = done.slice(0, done.length - fullDone.length);
+        return [
+            ...important.map(prompts_1.reportBlock),
+            ...fullDone.map(prompts_1.reportBlock),
+            ...briefDone.map((t) => `── ${t.id} (${t.role}) "${(0, util_1.clip)(t.title, 60)}" → DONE — ${(0, util_1.oneLine)(t.report ?? "", 140)} (full text: read_report)`),
+        ];
+    }
     appendConductorUpdate(extra, reports) {
         const ops = this.consumeOperatorNotes();
         this.conductorMessages.push({
             role: "user",
             content: (0, prompts_1.conductorUpdate)({
-                reports: reports?.map(prompts_1.reportBlock),
+                reports: reports ? this.digestReports(reports) : undefined,
                 operatorNotes: ops,
                 blackboard: this.blackboardDigest(),
+                phase: this.phaseLine(),
+                plan: this.planPin(),
                 nextId: this.nextId(),
                 taskTable: (0, prompts_1.taskTable)(this.taskList()),
                 budgetLine: (0, prompts_1.budgetLine)({ total: this.spentTokens, cost: this.cost }, this.meta.options.maxTokens),
@@ -432,26 +810,84 @@ class Executor {
         // Keep the conductor's own history from growing without bound.
         this.trimConductorHistory();
     }
+    /**
+     * One-screen summary of everything durable about the run so far. Replaces
+     * trimmed history so the conductor never loses the plot on long missions —
+     * rebuilt fresh each trim from current state, so it also survives resume.
+     */
+    missionLedger(intro = "Earlier orchestration history was trimmed.") {
+        const lines = [`[${intro} MISSION LEDGER — durable state so far:]`];
+        if (this.phase)
+            lines.push(this.phaseLine());
+        const settled = this.taskList().filter((t) => ["done", "failed", "blocked"].includes(t.status));
+        if (settled.length) {
+            lines.push("Settled tasks:");
+            const failures = settled.filter((t) => t.status !== "done");
+            const done = settled.filter((t) => t.status === "done");
+            // Failures stay itemized forever; done tasks collapse by wave once the
+            // run gets big (a 500-task ledger must still fit on one screen).
+            if (done.length > 30) {
+                const waves = [...new Set(done.map((t) => t.wave))].sort((a, b) => a - b);
+                for (const w of waves) {
+                    const ws = done.filter((t) => t.wave === w);
+                    lines.push(`- wave ${w}: ${ws.length} done (${ws.map((t) => t.id).join(",")})`);
+                }
+            }
+            else {
+                for (const t of done)
+                    lines.push(`- ${t.id} [done] ${(0, util_1.clip)(t.title, 60)}${t.report ? ` — ${(0, util_1.oneLine)(t.report, 120)}` : ""}`);
+            }
+            for (const t of failures) {
+                lines.push(`- ${t.id} [${t.status}] ${(0, util_1.clip)(t.title, 60)}${t.error ? ` — ${(0, util_1.oneLine)(t.error, 80)}` : ""}`);
+            }
+        }
+        const decisions = this.notes.filter((n) => n.kind === "decision");
+        if (decisions.length) {
+            lines.push("Decisions:");
+            for (const d of decisions.slice(-20))
+                lines.push(`- ${(0, util_1.oneLine)(d.text, 140)}`);
+        }
+        return (0, util_1.clip)(lines.join("\n"), 8000);
+    }
     trimConductorHistory() {
         const MAX = 60;
-        const TRIM_NOTICE = "[Earlier orchestration history was trimmed. Current swarm state is below.]";
+        const LEDGER_MARK = "MISSION LEDGER";
+        const setLedger = () => {
+            const msg = { role: "user", content: this.missionLedger() };
+            if (this.conductorMessages[1]?.content?.includes(LEDGER_MARK))
+                this.conductorMessages[1] = msg;
+            else
+                this.conductorMessages.splice(1, 0, msg);
+        };
+        // Old conductor turns carry the bulk in thinking traces and verbose prose;
+        // the durable decisions live in the ledger and the plan pin. Compact them
+        // in place before resorting to dropping whole messages. (sanitizeMessages
+        // backfills reasoning_content with "" for DeepSeek tool-call turns.)
+        for (let i = 1; i < this.conductorMessages.length - 6; i++) {
+            const m = this.conductorMessages[i];
+            if (m.role !== "assistant")
+                continue;
+            if (m.reasoning_content)
+                m.reasoning_content = "";
+            if (m.content && m.content.length > 400)
+                m.content = (0, util_1.clip)(m.content, 400);
+        }
         if (this.conductorMessages.length > MAX) {
             const system = this.conductorMessages[0];
             const tail = this.conductorMessages.slice(-(MAX - 2));
             // Don't begin the tail on an orphic tool result.
             while (tail.length && tail[0].role === "tool")
                 tail.shift();
-            this.conductorMessages = [system, { role: "user", content: TRIM_NOTICE }, ...tail];
+            this.conductorMessages = [system, ...tail];
+            setLedger();
         }
         // Count alone doesn't bound size: every update embeds the full task table,
         // so a deep run can blow the model window long before 60 messages. The
         // mission itself lives in the system message and always survives.
-        const budget = Math.floor(this.cfg.contextTokenLimit * 0.75);
+        const budget = Math.floor((0, config_1.contextLimitFor)(this.cfg, this.meta.options.conductorModel) * 0.75);
         if ((0, agent_1.estimateMessages)(this.conductorMessages) <= budget)
             return;
-        if (this.conductorMessages[1]?.content !== TRIM_NOTICE) {
-            this.conductorMessages.splice(1, 0, { role: "user", content: TRIM_NOTICE });
-        }
+        setLedger();
         while ((0, agent_1.estimateMessages)(this.conductorMessages) > budget && this.conductorMessages.length > 10) {
             this.conductorMessages.splice(2, 1);
             // Never leave tool results whose assistant turn was dropped.
@@ -469,25 +905,62 @@ class Executor {
     hasOpenWork() {
         return this.taskList().some((t) => ["pending", "running", "verifying"].includes(t.status));
     }
+    /** Walk a failed/blocked dep chain down to the task that actually failed. */
+    rootFailure(id) {
+        let cur = this.tasks.get(id);
+        const seen = new Set();
+        while (cur && !seen.has(cur.id)) {
+            seen.add(cur.id);
+            const next = cur.deps
+                .map((d) => this.tasks.get(d))
+                .find((t) => !!t && (t.status === "failed" || t.status === "blocked"));
+            if (!next)
+                return cur;
+            cur = next;
+        }
+        return cur;
+    }
     blockStuckTasks() {
-        for (const t of this.taskList()) {
-            if (t.status !== "pending")
-                continue;
-            const bad = t.deps.find((d) => {
-                const s = this.tasks.get(d)?.status;
-                return s === "failed" || s === "blocked";
-            });
-            if (bad) {
+        // Fixpoint: a failed dep chain T1→T2→T5 must block the whole chain in one
+        // pass, not one level per conductor turn.
+        for (let changed = true; changed;) {
+            changed = false;
+            for (const t of this.taskList()) {
+                if (t.status !== "pending")
+                    continue;
+                const bad = t.deps.find((d) => {
+                    const s = this.tasks.get(d)?.status;
+                    return s === "failed" || s === "blocked";
+                });
+                if (!bad)
+                    continue;
+                // Carry the root cause so the conductor re-plans around the actual
+                // failure, not a chain of "dependency did not complete".
+                const root = this.rootFailure(bad);
+                const cause = root ? (0, util_1.oneLine)(root.feedback ?? root.error ?? "unknown failure", 160) : "";
                 t.status = "blocked";
-                t.error = `dependency ${bad} did not complete`;
+                t.error =
+                    root && root.id !== bad
+                        ? `dependency ${bad} did not complete (root cause ${root.id}: ${cause})`
+                        : `dependency ${bad} did not complete${cause ? ` (${cause})` : ""}`;
                 t.endedAt = Date.now();
                 this.journal.append("task.status", { taskId: t.id, status: "blocked", attempt: t.attempt, reason: t.error });
                 this.settledSinceUpdate.push(t.id);
+                changed = true;
             }
         }
     }
+    /** Tasks occupying a worker slot: running, not those awaiting verification. */
+    activeWorkerCount() {
+        let n = 0;
+        for (const id of this.inflight.keys()) {
+            if (this.tasks.get(id)?.status === "running")
+                n++;
+        }
+        return n;
+    }
     startReadyTasks() {
-        while (this.inflight.size < this.meta.options.maxWorkers && !this.finishing) {
+        while (this.activeWorkerCount() < this.meta.options.maxWorkers && !this.finishing) {
             const next = this.runnableTasks()[0];
             if (!next)
                 break;
@@ -516,12 +989,14 @@ class Executor {
     depReportsFor(task) {
         if (!task.deps.length)
             return "";
+        // Excerpts, not full reports: a fan-in task with many deps must not blow
+        // its context window on day one. Workers fetch full text with read_report.
         return task.deps
             .map((d) => {
             const dep = this.tasks.get(d);
             if (!dep)
                 return `(${d}: missing)`;
-            return (0, prompts_1.reportBlock)(dep);
+            return (0, prompts_1.depReportBlock)(dep);
         })
             .join("\n\n");
     }
@@ -535,13 +1010,39 @@ class Executor {
             agentId,
             taskId: task?.id,
             signal: this.ac.signal,
-            addNote: (text, key) => {
-                this.notes.push({ taskId: task?.id, key, text });
+            addCheckpoint: task ? (summary) => this.recordCheckpoint(task, agentId, summary) : undefined,
+            addNote: (text, key, kind, url) => {
+                this.notes.push({ taskId: task?.id, key, kind, text, url });
                 // Only the recent tail ever feeds digests; without a cap a multi-day
-                // run accumulates every note in memory.
-                if (this.notes.length > 2000)
-                    this.notes.splice(0, this.notes.length - 2000);
-                this.journal.append("note.added", { taskId: task?.id, agentId, key, text: (0, util_1.clip)(text, 1200) });
+                // run accumulates every note in memory. Decisions and conflicts are
+                // kept regardless. In-place splice: teams share this array by reference.
+                if (this.notes.length > 4000) {
+                    const keep = (n) => n.kind === "decision" || n.kind === "conflict";
+                    const pinnedCount = this.notes.filter(keep).length;
+                    let toDrop = this.notes.length - Math.max(pinnedCount, 4000);
+                    for (let i = 0; i < this.notes.length && toDrop > 0;) {
+                        if (!keep(this.notes[i])) {
+                            this.notes.splice(i, 1);
+                            toDrop--;
+                        }
+                        else
+                            i++;
+                    }
+                }
+                this.journal.append("note.added", { taskId: task?.id, agentId, key, kind, url, text: (0, util_1.clip)(text, 1200) });
+            },
+            searchNotes: (q) => this.searchNotes(q),
+            readReport: (taskId) => this.readReportText(taskId),
+            checkClaim: (rel) => {
+                const norm = rel.replace(/^\.\//, "");
+                const claim = this.notes.find((n) => n.kind === "claim" &&
+                    n.key === norm &&
+                    n.taskId &&
+                    n.taskId !== task?.id &&
+                    ["running", "verifying"].includes(this.tasks.get(n.taskId)?.status ?? ""));
+                return claim
+                    ? `⚠ ${claim.taskId} holds a claim on ${norm} ("${(0, util_1.oneLine)(claim.text, 80)}") — coordinate via the blackboard before further edits.`
+                    : null;
             },
             addArtifact: (rel) => {
                 if (task && !task.artifacts.includes(rel))
@@ -553,7 +1054,33 @@ class Executor {
             },
         };
     }
+    readReportText(taskId) {
+        const t = this.tasks.get(taskId.trim().toUpperCase());
+        if (!t)
+            return `no such task: ${taskId}`;
+        if (!t.report)
+            return `${t.id} has not reported yet (status: ${t.status})`;
+        return `${t.id} "${t.title}" → ${t.status}\n${t.report}${t.artifacts.length ? `\nartifacts: ${t.artifacts.join(", ")}` : ""}`;
+    }
+    recordCheckpoint(task, agentId, summary) {
+        task.lastCheckpoint = (0, util_1.clip)(summary, 4000);
+        this.journal.append("task.checkpoint", {
+            taskId: task.id,
+            agentId,
+            attempt: task.attempt,
+            summary: task.lastCheckpoint,
+        });
+    }
     async runTaskPipeline(task) {
+        if (task.team) {
+            try {
+                await this.runTeam(task);
+            }
+            catch (e) {
+                this.finalizeTask(task, "failed", `team error: ${(0, util_1.errMsg)(e)}`);
+            }
+            return;
+        }
         for (;;) {
             try {
                 const outcome = await this.runWorker(task);
@@ -566,10 +1093,15 @@ class Executor {
                         this.finalizeTask(task, "failed", task.feedback || task.error || "not retried: run is winding down");
                         return;
                     }
-                    if (task.attempt < VERIFY_MAX_ATTEMPTS) {
+                    if (task.attempt < this.cfg.verifyMaxAttempts) {
                         task.attempt++;
                         task.status = "running";
-                        this.journal.append("task.status", { taskId: task.id, status: "running", attempt: task.attempt });
+                        this.journal.append("task.status", {
+                            taskId: task.id,
+                            status: "running",
+                            attempt: task.attempt,
+                            reason: task.feedback || task.error,
+                        });
                         continue;
                     }
                     this.finalizeTask(task, "failed", task.feedback || task.error || "verification failed after retries");
@@ -582,22 +1114,31 @@ class Executor {
                     this.finalizeTask(task, "failed", "run cancelled");
                     return;
                 }
-                if (task.attempt < VERIFY_MAX_ATTEMPTS && !this.finishing && !this.budgetExceeded()) {
+                if (task.attempt < this.cfg.verifyMaxAttempts && !this.finishing && !this.budgetExceeded()) {
                     task.attempt++;
-                    task.error = (0, util_1.errMsg)(e);
+                    task.error = `${(0, util_1.errMsg)(e)}${task.lastToolError ? ` (last tool failure: ${task.lastToolError})` : ""}`;
                     task.status = "running";
                     this.journal.append("task.status", { taskId: task.id, status: "running", attempt: task.attempt, reason: task.error });
                     continue;
                 }
-                this.finalizeTask(task, "failed", `worker error: ${(0, util_1.errMsg)(e)}`);
+                this.finalizeTask(task, "failed", `worker error: ${(0, util_1.errMsg)(e)}${task.lastToolError ? ` (last tool failure: ${task.lastToolError})` : ""}`);
                 return;
             }
         }
     }
+    resolveModel(tier) {
+        if (tier === "cheap")
+            return this.cfg.cheapModel || this.meta.options.model;
+        if (tier === "strong")
+            return this.cfg.strongModel || this.meta.options.model;
+        return this.meta.options.model;
+    }
     /** Returns "retry" to request another attempt, or "done" when finalized. */
     async runWorker(task) {
         const agentId = (0, util_1.rid)("w");
+        const model = this.resolveModel(task.modelTier);
         task.agentIds.push(agentId);
+        task.lastToolError = undefined; // diagnostics are per-attempt
         const dirListing = this.topListing();
         const system = (0, prompts_1.workerSystem)({
             agentId,
@@ -614,23 +1155,26 @@ class Executor {
             agentId,
             taskId: task.id,
             role: task.role,
-            model: this.meta.options.model,
+            model,
             purpose: task.title,
         });
         const outcome = await (0, agent_1.runAgent)({
             cfg: this.cfg,
             agentId,
-            model: this.meta.options.model,
+            model,
             thinking: this.meta.options.thinking,
             reasoningEffort: this.meta.options.reasoningEffort,
             system,
             kickoff: prompts_1.WORKER_KICKOFF,
-            tools: (0, tools_1.workerToolset)(),
+            tools: (0, tools_1.workerToolset)(this.cfg),
             terminal: [tools_1.REPORT_TOOL],
             maxSteps: this.meta.options.maxStepsPerTask,
             signal: this.ac.signal,
             ctx: this.makeToolCtx(agentId, task),
-            hooks: this.agentHooks(agentId, task.id),
+            hooks: {
+                ...this.agentHooks(agentId, task.id, task),
+                onCheckpoint: (summary) => this.recordCheckpoint(task, agentId, summary),
+            },
             stop: this.agentStop,
         });
         this.flushDeltas(agentId);
@@ -638,7 +1182,11 @@ class Executor {
         if (this.ac.signal.aborted)
             return "done";
         if (!outcome.terminal) {
-            task.error = "worker ended without reporting";
+            const lastWords = (0, util_1.oneLine)(outcome.finalText ?? "", 200);
+            task.error =
+                "worker ended without reporting" +
+                    (task.lastToolError ? ` — last tool failure: ${task.lastToolError}` : "") +
+                    (lastWords ? `; last words: ${lastWords}` : "");
             return "retry";
         }
         const a = outcome.terminal.args;
@@ -650,11 +1198,33 @@ class Executor {
                 task.artifacts.push(art);
         task.report = report;
         task.reportStatus = reportStatus;
+        const strList = (v, max) => Array.isArray(v) ? v.map((x) => (0, util_1.clip)(String(x), 300)).slice(0, max) : undefined;
+        task.keyFacts = strList(a.key_facts, 8);
+        task.openQuestions = strList(a.open_questions, 6);
+        task.filesTouched = strList(a.files_touched, 40);
+        // Structured sources: the citation pipeline's entry point. Only real
+        // http(s) URLs survive; they flow into dep handoffs and the bibliography.
+        const sources = Array.isArray(a.sources)
+            ? a.sources
+                .filter((s) => s && typeof s === "object" && /^https?:\/\//.test(String(s.url ?? "")))
+                .slice(0, 40)
+                .map((s) => ({
+                url: (0, util_1.clip)(String(s.url), 500),
+                title: s.title ? (0, util_1.clip)(String(s.title), 200) : undefined,
+                date: s.date ? (0, util_1.clip)(String(s.date), 40) : undefined,
+                note: s.note ? (0, util_1.clip)(String(s.note), 300) : undefined,
+            }))
+            : [];
+        task.sources = sources.length ? sources : undefined;
         this.journal.append("task.report", {
             taskId: task.id,
             status: reportStatus,
             report,
             artifacts: task.artifacts,
+            keyFacts: task.keyFacts,
+            openQuestions: task.openQuestions,
+            filesTouched: task.filesTouched,
+            sources: task.sources,
         });
         if (reportStatus === "blocked") {
             this.finalizeTask(task, "blocked", report);
@@ -663,6 +1233,14 @@ class Executor {
         if (task.verify && this.cfg.verification !== "off") {
             task.status = "verifying";
             this.journal.append("task.status", { taskId: task.id, status: "verifying", attempt: task.attempt });
+            // Mechanical checks first: free, instant, and they catch the most common
+            // fabrications (claimed artifacts that don't exist) without an LLM call.
+            const mech = this.preVerify(task);
+            if (mech) {
+                task.feedback = mech;
+                this.journal.append("verify.result", { taskId: task.id, pass: false, feedback: mech, mechanical: true });
+                return "retry";
+            }
             const pass = await this.runVerifier(task);
             if (!pass)
                 return "retry";
@@ -670,43 +1248,147 @@ class Executor {
         this.finalizeTask(task, "done", report);
         return "done";
     }
-    async runVerifier(task) {
+    /** Zero-token sanity checks before the LLM verifier. Returns failure feedback or null. */
+    preVerify(task) {
+        const report = task.report ?? "";
+        if (report.trim().length < 40) {
+            return "Report is too thin to verify. Re-do the task and report concretely: what was done, what was verified, exact paths.";
+        }
+        const missing = [];
+        const malformed = [];
+        // Remote sandboxes own their filesystem — only check host-visible paths.
+        if (this.sandbox.localFs) {
+            const okAt = (p) => {
+                try {
+                    return fs.statSync(p).size > 0;
+                }
+                catch {
+                    return false;
+                }
+            };
+            for (const rel of task.artifacts) {
+                const inArtifacts = path.join(this.runDirPath, "artifacts", rel);
+                const inWorkdir = path.resolve(this.meta.cwd, rel);
+                if (!okAt(inArtifacts) && !okAt(inWorkdir)) {
+                    missing.push(rel);
+                    continue;
+                }
+                // Structural format check (json parses, csv is rectangular, html is
+                // not a stub) — free, and catches what the LLM verifier wastes a whole
+                // agent run discovering.
+                const problem = (0, util_1.validateArtifactFormat)(okAt(inArtifacts) ? inArtifacts : inWorkdir);
+                if (problem)
+                    malformed.push(`${rel}: ${problem}`);
+            }
+        }
+        if (missing.length) {
+            return `Claimed artifact(s) do not exist or are empty: ${missing.join(", ")}. Actually create them (use save_artifact), then report again.`;
+        }
+        if (malformed.length) {
+            return `Claimed artifact(s) are malformed — fix them and report again: ${malformed.join("; ")}`;
+        }
+        return null;
+    }
+    /** One verifier agent pass; returns the outcome plus how many evidence-gathering tool calls it made. */
+    async verifierAgent(task, kickoff) {
         const agentId = (0, util_1.rid)("v");
+        // Verification gets the strong tier when configured — a weak verifier
+        // rubber-stamps exactly the tasks that most need scrutiny.
+        const model = this.cfg.strongModel || this.meta.options.model;
         task.agentIds.push(agentId);
         this.journal.append("agent.spawned", {
             agentId,
             taskId: task.id,
             role: "verifier",
-            model: this.meta.options.model,
+            model,
             purpose: `verify ${task.id}`,
         });
+        let evidenceCalls = 0;
+        const baseHooks = this.agentHooks(agentId, task.id);
         const outcome = await (0, agent_1.runAgent)({
             cfg: this.cfg,
             agentId,
-            model: this.meta.options.model,
+            model,
             thinking: this.meta.options.thinking,
             reasoningEffort: this.meta.options.reasoningEffort,
-            system: (0, prompts_1.verifierSystem)(this.meta, task),
-            kickoff: prompts_1.VERIFIER_KICKOFF,
+            system: (0, prompts_1.verifierSystem)(this.meta, task, this.depReportsFor(task)),
+            kickoff,
             tools: (0, tools_1.verifierToolset)(),
             terminal: [tools_1.VERDICT_TOOL],
             maxSteps: Math.min(14, this.meta.options.maxStepsPerTask),
             signal: this.ac.signal,
-            ctx: this.makeToolCtx(agentId, task),
-            hooks: this.agentHooks(agentId, task.id),
+            // Blind verification: the verifier judges deliverables against the
+            // objective with its own tools — it must not inherit the swarm's shared
+            // beliefs (blackboard) or the worker's narrative beyond the claims.
+            // (Dep reports are settled upstream outputs, not the worker's story.)
+            ctx: { ...this.makeToolCtx(agentId, task), readBlackboard: () => "", searchNotes: undefined },
+            hooks: {
+                ...baseHooks,
+                onToolCall: (callId, name, args) => {
+                    if (name !== "verdict")
+                        evidenceCalls++;
+                    baseHooks.onToolCall(callId, name, args);
+                },
+            },
             stop: this.agentStop,
         });
         this.flushDeltas(agentId);
         this.journal.append("agent.done", { agentId, taskId: task.id, steps: outcome.steps });
+        return { outcome, evidenceCalls };
+    }
+    async runVerifier(task) {
+        const strict = this.cfg.verification === "strict";
+        let { outcome, evidenceCalls } = await this.verifierAgent(task, prompts_1.VERIFIER_KICKOFF);
         if (this.ac.signal.aborted)
             return true;
+        // Strict mode: a pass verdict backed by zero tool calls is an opinion,
+        // not a verification. One re-run demanding evidence; if that also passes
+        // tool-free, accept but say so in the journal.
+        if (strict && outcome.terminal && Boolean(outcome.terminal.args.pass) && evidenceCalls === 0) {
+            this.journal.append("log", {
+                level: "info",
+                msg: `verifier passed ${task.id} without evidence — re-running with a tools-required kickoff`,
+            });
+            const second = await this.verifierAgent(task, "A previous verdict on this task cited no tool-gathered evidence. Verify concretely NOW — read the claimed files, run the commands — then call verdict(...).");
+            if (this.ac.signal.aborted)
+                return true;
+            if (second.outcome.terminal) {
+                if (second.evidenceCalls === 0) {
+                    this.journal.append("log", { level: "warn", msg: `verifier passed ${task.id} without gathering evidence` });
+                }
+                outcome = second.outcome;
+            }
+        }
         const v = (outcome.terminal?.args ?? {});
-        const strict = this.cfg.verification === "strict";
         // No verdict returned: in strict mode fail closed, otherwise accept.
         const pass = outcome.terminal ? Boolean(v.pass) : !strict;
-        const feedback = String(v.feedback ?? (outcome.terminal ? "" : "verifier produced no verdict"));
+        let feedback = String(v.feedback ?? (outcome.terminal ? "" : "verifier produced no verdict"));
+        // Structured issues become the retry's worklist — numbered, with evidence.
+        const issues = Array.isArray(v.issues)
+            ? v.issues
+                .filter((i) => i && typeof i === "object" && i.problem)
+                .slice(0, 5)
+                .map((i) => ({
+                problem: (0, util_1.oneLine)(String(i.problem), 300),
+                evidence: i.evidence ? (0, util_1.oneLine)(String(i.evidence), 300) : undefined,
+                fix: i.fix ? (0, util_1.oneLine)(String(i.fix), 300) : undefined,
+            }))
+            : [];
+        if (!pass && issues.length) {
+            feedback = [
+                feedback,
+                ...issues.map((i, n) => `${n + 1}. ${i.problem}${i.evidence ? `\n   evidence: ${i.evidence}` : ""}${i.fix ? `\n   fix: ${i.fix}` : ""}`),
+            ]
+                .filter(Boolean)
+                .join("\n");
+        }
         task.feedback = feedback;
-        this.journal.append("verify.result", { taskId: task.id, pass, feedback });
+        this.journal.append("verify.result", {
+            taskId: task.id,
+            pass,
+            feedback,
+            ...(issues.length ? { issues } : {}),
+        });
         return pass;
     }
     finalizeTask(task, status, reason) {
@@ -714,8 +1396,80 @@ class Executor {
         task.endedAt = Date.now();
         if (reason && status !== "done")
             task.error = reason;
+        // A settled task holds no file claims — release them so the digest and
+        // search_notes don't accumulate dead claims on long runs. In-place splice:
+        // teams share this array by reference.
+        for (let i = this.notes.length - 1; i >= 0; i--) {
+            const n = this.notes[i];
+            if (n.kind === "claim" && n.taskId === task.id)
+                this.notes.splice(i, 1);
+        }
         this.journal.append("task.status", { taskId: task.id, status, attempt: task.attempt, reason });
         this.settledSinceUpdate.push(task.id);
+        this.maybeSnapshot();
+    }
+    // ---------------------------------------------------------------- progress snapshots
+    snapshotCounter = 0;
+    settledSinceSnapshot = 0;
+    snapshotInflight = false;
+    /**
+     * Periodic partial deliverable: every N settled tasks, write a cheap-tier
+     * progress report to artifacts/. Fire-and-forget — a multi-day run always
+     * has something readable, and a snapshot failure never blocks scheduling.
+     */
+    maybeSnapshot() {
+        if (this.mode !== "root" || this.finishing || this.snapshotInflight)
+            return;
+        const every = Number(process.env.SWARM_SNAPSHOT_EVERY ?? "25");
+        if (!every || every < 1)
+            return;
+        if (++this.settledSinceSnapshot < every)
+            return;
+        this.settledSinceSnapshot = 0;
+        this.snapshotInflight = true;
+        const n = ++this.snapshotCounter;
+        const model = this.cfg.cheapModel || this.meta.options.conductorModel;
+        const tasks = this.taskList();
+        const settled = tasks.filter((t) => ["done", "failed", "blocked"].includes(t.status));
+        (0, deepseek_1.chat)(this.cfg, {
+            model,
+            messages: [
+                {
+                    role: "user",
+                    content: `Write a concise interim progress report (markdown) for an in-flight agent-swarm mission. Cover: what has been accomplished so far (with concrete results/paths from the reports), what failed, what is currently running, and what remains. This is a partial deliverable for the operator — informative, no filler.\n\nMISSION\n${this.meta.mission}\n\nTASKS\n${(0, prompts_1.taskTable)(tasks)}\n\nSETTLED REPORTS\n${(0, util_1.truncateMiddle)(settled.map(prompts_1.reportBlock).join("\n\n"), 50_000, "chars")}`,
+                },
+            ],
+            thinking: false,
+            maxTokens: 4096,
+            signal: this.ac.signal,
+        })
+            .then((res) => {
+            this.onUsage(model, res.usage);
+            if (!res.content.trim())
+                return;
+            const rel = `progress-report-${n}.md`;
+            fs.writeFileSync(path.join(this.runDirPath, "artifacts", rel), res.content, "utf8");
+            this.journal.append("log", { level: "info", msg: `progress snapshot written: artifacts/${rel}` });
+            // Interim memory: a multi-day run that dies before synthesis still
+            // leaves the next swarm in this workspace something to build on.
+            if (!this.meta.sandbox) {
+                (0, memory_1.appendMemory)(this.meta.cwd, {
+                    runId: this.meta.id,
+                    mission: this.meta.mission,
+                    finishedAt: Date.now(),
+                    status: "in-progress",
+                    summary: (0, util_1.clip)(res.content, 600),
+                    keyDecisions: this.notes.filter((nt) => nt.kind === "decision").slice(-10).map((nt) => nt.text),
+                });
+            }
+        })
+            .catch((e) => {
+            if (!this.ac.signal.aborted)
+                this.journal.append("log", { level: "warn", msg: `progress snapshot failed: ${(0, util_1.errMsg)(e)}` });
+        })
+            .finally(() => {
+            this.snapshotInflight = false;
+        });
     }
     topListing() {
         // Remote sandboxes own their filesystem; a host listing would be a lie.
@@ -750,18 +1504,31 @@ class Executor {
      */
     deltaBuf = new Map();
     deltaTimer = null;
+    thinkDropLogged = false;
     queueDelta(agentId, taskId, channel, text) {
+        // Deltas are UI sugar, never state — thin them under load so a 100-agent
+        // swarm doesn't write gigabytes of streaming chatter into the journal.
+        const load = this.activeWorkerCount();
+        if (channel === "think" && load > 48) {
+            if (!this.thinkDropLogged) {
+                this.thinkDropLogged = true;
+                this.journal.append("log", { level: "info", msg: `thinking streams muted above 48 active agents (currently ${load})` });
+            }
+            return;
+        }
+        const flushChars = load > 24 ? 2000 : 480;
+        const flushMs = load > 24 ? 1000 : 200;
         const key = `${agentId}:${channel}`;
         const buf = this.deltaBuf.get(key);
         if (buf)
             buf.text += text;
         else
             this.deltaBuf.set(key, { agentId, taskId, channel, text });
-        if (this.deltaBuf.get(key).text.length >= 480) {
+        if (this.deltaBuf.get(key).text.length >= flushChars) {
             this.flushDeltas(agentId);
         }
         else if (!this.deltaTimer) {
-            this.deltaTimer = setTimeout(() => this.flushDeltas(), 200);
+            this.deltaTimer = setTimeout(() => this.flushDeltas(), flushMs);
         }
     }
     flushDeltas(onlyAgent) {
@@ -781,7 +1548,7 @@ class Executor {
             });
         }
     }
-    agentHooks(agentId, taskId) {
+    agentHooks(agentId, taskId, trackErrorsOn) {
         return {
             onDelta: (channel, text) => {
                 this.queueDelta(agentId, taskId, channel, text);
@@ -791,6 +1558,8 @@ class Executor {
                 this.journal.append("tool.call", { agentId, taskId, callId, name, args });
             },
             onToolResult: (callId, name, ok, summary) => {
+                if (!ok && trackErrorsOn)
+                    trackErrorsOn.lastToolError = `${name}: ${(0, util_1.oneLine)(summary, 200)}`;
                 this.journal.append("tool.result", { agentId, taskId, callId, name, ok, summary });
             },
             onUsage: this.onUsage,
@@ -802,6 +1571,10 @@ class Executor {
     // ---------------------------------------------------------------- operator control
     operatorQueue = [];
     drainControl() {
+        // Only the root executor consumes operator control; teams are cancelled
+        // via the parent's abort signal and would otherwise steal queued notes.
+        if (this.mode === "team")
+            return;
         for (const msg of this.control.poll()) {
             if (msg.kind === "cancel") {
                 this.journal.append("operator.note", { text: "⛔ Cancel requested by operator." });
@@ -830,8 +1603,25 @@ class Executor {
         const reportPath = path.join(this.runDirPath, "artifacts", "final-report.md");
         (0, util_1.ensureDir)(path.dirname(reportPath));
         fs.writeFileSync(reportPath, reportMarkdown, "utf8");
+        // Always ship a readable, shareable HTML rendering alongside the raw
+        // markdown; a rendering bug must never block run finalization.
+        let htmlPath;
+        try {
+            htmlPath = path.join(this.runDirPath, "artifacts", "final-report.html");
+            fs.writeFileSync(htmlPath, (0, report_1.renderFinalHtml)({
+                markdown: reportMarkdown,
+                mission: this.meta.mission,
+                runId: this.meta.id,
+                status,
+                finishedAt: Date.now(),
+            }), "utf8");
+        }
+        catch (e) {
+            htmlPath = undefined;
+            this.journal.append("log", { level: "warn", msg: `final-report.html render failed: ${(0, util_1.errMsg)(e)}` });
+        }
         this.setStatus(status, reason);
-        this.journal.append("run.final", { summary, reportPath, reason, status });
+        this.journal.append("run.final", { summary, reportPath, htmlPath, reason, status });
         await this.journal.flush();
     }
     /** Terminate the run as failed without any further model calls. */
@@ -862,10 +1652,14 @@ class Executor {
             ? tasks.map(prompts_1.reportBlock).join("\n\n")
             : "(no tasks were completed)";
         const artifactList = this.listArtifacts().join("\n") || "(none)";
+        // The citation pipeline's last hop: every source any worker reported,
+        // deduplicated and numbered, becomes the synthesizer's bibliography.
+        const allSources = (0, report_1.aggregateSources)(tasks);
+        const sourcesText = allSources.length ? (0, util_1.truncateMiddle)((0, report_1.sourcesBlock)(allSources), 40_000, "chars") : "";
         const agentId = (0, util_1.rid)("synth");
         let summary = "";
         let reportMarkdown = "";
-        try {
+        const synthOnce = async (extraNote) => {
             const outcome = await (0, agent_1.runAgent)({
                 cfg: this.cfg,
                 agentId,
@@ -874,17 +1668,18 @@ class Executor {
                 reasoningEffort: this.meta.options.reasoningEffort,
                 system: (0, prompts_1.synthSystem)({
                     meta: this.meta,
-                    finishNotes: this.finishNotes,
-                    reports: (0, util_1.truncateMiddle)(reports, 120_000, "chars"),
-                    blackboard: this.blackboardDigest(4000),
+                    finishNotes: [this.finishNotes, extraNote].filter(Boolean).join("\n\n"),
+                    reports: (0, util_1.truncateMiddle)(reports, 300_000, "chars"),
+                    blackboard: this.blackboardDigest(6000),
                     artifactList,
                     reason: this.finishReason || "completed",
+                    sources: sourcesText,
                 }),
                 kickoff: prompts_1.SYNTH_KICKOFF,
                 tools: (0, tools_1.synthToolset)(),
                 terminal: [tools_1.SUBMIT_FINAL_TOOL],
-                maxSteps: 12,
-                maxTokensOut: 16384,
+                maxSteps: 24,
+                maxTokensOut: 32000,
                 signal: new AbortController().signal, // synthesis should finish even if run was cancelled
                 ctx: this.makeToolCtx(agentId, null),
                 hooks: this.agentHooks(agentId, ""),
@@ -892,6 +1687,36 @@ class Executor {
             const a = (outcome.terminal?.args ?? {});
             reportMarkdown = String(a.report_markdown ?? outcome.finalText ?? "");
             summary = String(a.summary ?? "");
+        };
+        try {
+            await synthOnce();
+            // Strict mode: check the final report's claims against the task reports
+            // (the ground truth) and re-synthesize once if it misrepresents them.
+            if (this.cfg.verification === "strict" && reportMarkdown.trim() && tasks.length) {
+                try {
+                    const res = await (0, deepseek_1.chat)(this.cfg, {
+                        model: this.meta.options.conductorModel,
+                        messages: [
+                            {
+                                role: "user",
+                                content: (0, prompts_1.synthCheckPrompt)(this.meta.mission, (0, util_1.truncateMiddle)(reports, 60_000, "chars"), (0, util_1.truncateMiddle)(reportMarkdown, 60_000, "chars"), sourcesText ? (0, util_1.truncateMiddle)(sourcesText, 20_000, "chars") : undefined),
+                            },
+                        ],
+                        thinking: false,
+                        maxTokens: 2048,
+                        signal: new AbortController().signal,
+                    });
+                    this.onUsage(this.meta.options.conductorModel, res.usage);
+                    const check = (res.content || "").trim();
+                    if (check && !/^OK\b/i.test(check)) {
+                        this.journal.append("log", { level: "warn", msg: `synthesis check found discrepancies:\n${(0, util_1.clip)(check, 1500)}` });
+                        await synthOnce(`A faithfulness review of your previous draft found these discrepancies — fix them, claiming only what the task reports support:\n${(0, util_1.clip)(check, 2000)}`);
+                    }
+                }
+                catch (e) {
+                    this.journal.append("log", { level: "warn", msg: `synthesis check failed: ${(0, util_1.errMsg)(e)}` });
+                }
+            }
         }
         catch (e) {
             this.journal.append("log", { level: "error", msg: `synthesis failed: ${(0, util_1.errMsg)(e)}` });
@@ -920,9 +1745,24 @@ class Executor {
             reason = `All ${tasks.length} task(s) failed or were blocked.`;
         }
         await this.writeFinal(status, reason, reportMarkdown, summary || (0, util_1.clip)(reportMarkdown, 600));
+        // Cross-run memory: real-directory runs leave a trace for the next swarm.
+        if (!this.meta.sandbox && status !== "cancelled") {
+            (0, memory_1.appendMemory)(this.meta.cwd, {
+                runId: this.meta.id,
+                mission: this.meta.mission,
+                finishedAt: Date.now(),
+                status,
+                summary: (0, util_1.clip)(summary || reportMarkdown, 600),
+                keyDecisions: this.notes.filter((n) => n.kind === "decision").slice(-10).map((n) => n.text),
+            });
+        }
     }
     fallbackReport(tasks) {
         const lines = [`# ${this.meta.mission}`, ``, `_Run ${this.meta.id} — ${this.finishReason}_`, ``];
+        // Even without a synthesizer, surface the cross-task essentials first.
+        const facts = tasks.flatMap((t) => (t.keyFacts ?? []).map((f) => `- ${f} _(${t.id})_`));
+        if (facts.length)
+            lines.push(`## Key facts`, ...facts.slice(0, 60), "");
         for (const t of tasks) {
             lines.push(`## ${t.id} ${t.title} (${t.status})`);
             lines.push(t.report || t.error || "(no output)");
@@ -930,6 +1770,15 @@ class Executor {
                 lines.push(`Artifacts: ${t.artifacts.join(", ")}`);
             lines.push("");
         }
+        const sources = (0, report_1.aggregateSources)(tasks);
+        if (sources.length) {
+            lines.push(`## Sources`);
+            for (const s of sources.slice(0, 100)) {
+                lines.push(`${s.n}. [${s.title || s.url}](${s.url})${s.date ? ` (${s.date})` : ""}`);
+            }
+            if (sources.length > 100)
+                lines.push(`…and ${sources.length - 100} more in the task reports.`);
+        }
         return lines.join("\n");
     }
     listArtifacts() {