@robzilla1738/agentswarm 0.2.0 → 0.5.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,47 @@ 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 }));
+        this.notes = state.notes.map((n) => ({ taskId: n.taskId, key: n.key, kind: n.kind, text: n.text }));
+        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 +182,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.taskId ? ` (${n.taskId})` : ""}`;
+        // Decisions anchor mission-wide coherence and are never trimmed out of the
+        // digest; everything else shows only its recent tail.
+        const decisions = this.notes.filter((n) => n.kind === "decision").map(fmt);
+        const rest = this.notes.filter((n) => n.kind !== "decision").slice(-80).map(fmt);
+        let tail = rest.join("\n");
+        const budget = Math.max(400, max - decisions.join("\n").length);
+        if (tail.length > budget)
+            tail = tail.slice(tail.length - budget);
+        return [decisions.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,8 +256,11 @@ 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
@@ -191,53 +280,11 @@ class Executor {
         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 +298,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 +533,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 +544,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 +566,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 +618,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 +663,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 +705,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 +714,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 +745,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,16 +794,63 @@ 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() {
+        const lines = ["[Earlier orchestration history was trimmed. 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);
+        };
         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
@@ -449,9 +858,7 @@ class Executor {
         const budget = Math.floor(this.cfg.contextTokenLimit * 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.
@@ -486,8 +893,17 @@ class Executor {
             }
         }
     }
+    /** 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 +932,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 +953,31 @@ 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) => {
+                this.notes.push({ taskId: task?.id, key, kind, text });
                 // 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 are kept regardless.
+                if (this.notes.length > 4000) {
+                    const decisions = this.notes.filter((n) => n.kind === "decision");
+                    const rest = this.notes.filter((n) => n.kind !== "decision");
+                    rest.splice(0, rest.length - Math.max(0, 4000 - decisions.length));
+                    this.notes = [...decisions, ...rest];
+                }
+                this.journal.append("note.added", { taskId: task?.id, agentId, key, kind, 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 +989,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,7 +1028,7 @@ 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 });
@@ -582,7 +1044,7 @@ 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.status = "running";
@@ -594,9 +1056,17 @@ class Executor {
             }
         }
     }
+    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);
         const dirListing = this.topListing();
         const system = (0, prompts_1.workerSystem)({
@@ -614,23 +1084,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),
+                onCheckpoint: (summary) => this.recordCheckpoint(task, agentId, summary),
+            },
             stop: this.agentStop,
         });
         this.flushDeltas(agentId);
@@ -650,11 +1123,18 @@ 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);
         this.journal.append("task.report", {
             taskId: task.id,
             status: reportStatus,
             report,
             artifacts: task.artifacts,
+            keyFacts: task.keyFacts,
+            openQuestions: task.openQuestions,
+            filesTouched: task.filesTouched,
         });
         if (reportStatus === "blocked") {
             this.finalizeTask(task, "blocked", report);
@@ -663,6 +1143,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,20 +1158,52 @@ class Executor {
         this.finalizeTask(task, "done", report);
         return "done";
     }
+    /** 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 = [];
+        // 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);
+            }
+        }
+        if (missing.length) {
+            return `Claimed artifact(s) do not exist or are empty: ${missing.join(", ")}. Actually create them (use save_artifact), then report again.`;
+        }
+        return null;
+    }
     async runVerifier(task) {
         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}`,
         });
         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),
@@ -692,7 +1212,10 @@ class Executor {
             terminal: [tools_1.VERDICT_TOOL],
             maxSteps: Math.min(14, this.meta.options.maxStepsPerTask),
             signal: this.ac.signal,
-            ctx: this.makeToolCtx(agentId, task),
+            // 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.
+            ctx: { ...this.makeToolCtx(agentId, task), readBlackboard: () => "", searchNotes: undefined },
             hooks: this.agentHooks(agentId, task.id),
             stop: this.agentStop,
         });
@@ -716,6 +1239,58 @@ class Executor {
             task.error = reason;
         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}` });
+        })
+            .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 +1325,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) {
@@ -802,6 +1390,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 +1422,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. */
@@ -865,7 +1474,7 @@ class Executor {
         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 +1483,17 @@ 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",
                 }),
                 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 +1501,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")),
+                            },
+                        ],
+                        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,6 +1559,16 @@ 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, {
+                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}_`, ``];