@robzilla1738/agentswarm 0.5.0 → 0.7.0

package/dist/executor.js

@@ -69,10 +69,9 @@ class Executor {
     finishNotes = "";
     finishReason = "";
     fatal = null;
+    /** "error" = the turn ended in a call failure, not a decision. */
     lastConductorAction = "none";
     conductorFailures = 0;
-    /** True when the last conductor turn ended in a call error, not a decision. */
-    lastConductorErrored = false;
     resumed = false;
     sandbox;
     mode;
@@ -134,7 +133,14 @@ 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, kind: n.kind, 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, teamId: n.teamId, key: n.key, kind: n.kind, text: n.text, url: n.url }))
+            // Team claims always drop: the owning child executor died with the
+            // crash, and a re-run team task re-claims from scratch.
+            .filter((n) => !(n.kind === "claim" && (n.teamId || (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 };
@@ -182,16 +188,16 @@ class Executor {
     blackboardDigest(max = 1800) {
         if (!this.notes.length)
             return "";
-        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);
+        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 - decisions.join("\n").length);
+        const budget = Math.max(400, max - pinned.join("\n").length);
         if (tail.length > budget)
             tail = tail.slice(tail.length - budget);
-        return [decisions.join("\n"), tail].filter(Boolean).join("\n");
+        return [pinned.join("\n"), tail].filter(Boolean).join("\n");
     }
     searchNotes(query) {
         const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
@@ -266,6 +272,8 @@ class Executor {
                 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),
@@ -277,6 +285,15 @@ 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");
@@ -382,6 +399,13 @@ class Executor {
             sharedNotes: this.notes,
         });
         await child.run();
+        // The sub-swarm is over: claims its tasks left behind (e.g. after a child
+        // cancellation) are no longer live and must not haunt the shared board.
+        for (let i = this.notes.length - 1; i >= 0; i--) {
+            const n = this.notes[i];
+            if (n.kind === "claim" && n.teamId === task.id)
+                this.notes.splice(i, 1);
+        }
         if (this.ac.signal.aborted) {
             this.finalizeTask(task, "failed", "run cancelled");
             return;
@@ -390,11 +414,13 @@ class Executor {
         for (const a of child.teamArtifacts())
             if (!task.artifacts.includes(a))
                 task.artifacts.push(a);
+        const ok = child.anyTaskDone();
+        const reportStatus = ok ? "done" : "blocked";
         task.report = report;
-        task.reportStatus = "done";
+        task.reportStatus = reportStatus;
         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);
+        this.journal.append("task.report", { taskId: task.id, status: reportStatus, report, artifacts: task.artifacts });
+        this.finalizeTask(task, ok ? "done" : "failed", report);
     }
     async mainLoop() {
         while (!this.finishing) {
@@ -430,7 +456,7 @@ class Executor {
                     // 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) {
+                    if (this.lastConductorAction !== "spawn" && this.lastConductorAction !== "error") {
                         this.finishing = true;
                         this.finishReason = this.finishReason || "all tasks settled";
                     }
@@ -439,7 +465,7 @@ class Executor {
                     // 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) {
+                    if (this.lastConductorAction === "wait") {
                         this.finishing = true;
                         this.finishReason = "stalled: dependencies unmet and conductor chose to wait";
                     }
@@ -580,12 +606,10 @@ class Executor {
                 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;
+                this.lastConductorAction = "error";
                 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) });
@@ -767,7 +791,8 @@ class Executor {
             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 room = Math.max(0, CAP - important.length);
+        const fullDone = room > 0 ? done.slice(-room) : []; // slice(-0) would return everything
         const briefDone = done.slice(0, done.length - fullDone.length);
         return [
             ...important.map(prompts_1.reportBlock),
@@ -799,8 +824,8 @@ class Executor {
      * 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:]"];
+    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));
@@ -843,6 +868,19 @@ class Executor {
             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));
@@ -855,7 +893,7 @@ class Executor {
         // 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;
         setLedger();
@@ -876,20 +914,48 @@ 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;
             }
         }
     }
@@ -954,27 +1020,40 @@ class Executor {
             taskId: task?.id,
             signal: this.ac.signal,
             addCheckpoint: task ? (summary) => this.recordCheckpoint(task, agentId, summary) : undefined,
-            addNote: (text, key, kind) => {
-                this.notes.push({ taskId: task?.id, key, kind, text });
+            addNote: (text, key, kind, url) => {
+                this.notes.push({ taskId: task?.id, teamId: this.teamId, key, kind, text, url });
                 // Only the recent tail ever feeds digests; without a cap a multi-day
-                // run accumulates every note in memory. Decisions are kept regardless.
+                // 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 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];
+                    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, text: (0, util_1.clip)(text, 1200) });
+                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 ?? ""));
+                const claim = this.notes.find((n) => {
+                    if (n.kind !== "claim" || n.key !== norm || !n.taskId)
+                        return false;
+                    // Another executor's claim: its tasks aren't in this.tasks, but
+                    // claims are spliced out when their task settles (and when a team
+                    // ends), so presence alone means the holder is still live.
+                    if (n.teamId !== this.teamId)
+                        return true;
+                    return 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;
@@ -1031,7 +1110,12 @@ class Executor {
                     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");
@@ -1046,12 +1130,12 @@ class Executor {
                 }
                 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;
             }
         }
@@ -1068,6 +1152,7 @@ class Executor {
         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,
@@ -1101,7 +1186,7 @@ class Executor {
             signal: this.ac.signal,
             ctx: this.makeToolCtx(agentId, task),
             hooks: {
-                ...this.agentHooks(agentId, task.id),
+                ...this.agentHooks(agentId, task.id, task),
                 onCheckpoint: (summary) => this.recordCheckpoint(task, agentId, summary),
             },
             stop: this.agentStop,
@@ -1111,7 +1196,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;
@@ -1127,6 +1216,20 @@ class Executor {
         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,
@@ -1135,6 +1238,7 @@ class Executor {
             keyFacts: task.keyFacts,
             openQuestions: task.openQuestions,
             filesTouched: task.filesTouched,
+            sources: task.sources,
         });
         if (reportStatus === "blocked") {
             this.finalizeTask(task, "blocked", report);
@@ -1165,6 +1269,7 @@ class Executor {
             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) => {
@@ -1178,16 +1283,28 @@ class Executor {
             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))
+                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;
     }
-    async runVerifier(task) {
+    /** 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.
@@ -1200,14 +1317,16 @@ class Executor {
             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,
             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),
@@ -1215,21 +1334,75 @@ class Executor {
             // 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: this.agentHooks(agentId, task.id),
+            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) {
@@ -1237,6 +1410,14 @@ 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 && n.teamId === this.teamId)
+                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();
@@ -1283,6 +1464,18 @@ class Executor {
             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)
@@ -1329,7 +1522,9 @@ class Executor {
     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();
+        // inflight.size over-counts verifying tasks slightly, but these are fuzzy
+        // thresholds and this runs per streaming token — O(1) matters here.
+        const load = this.inflight.size;
         if (channel === "think" && load > 48) {
             if (!this.thinkDropLogged) {
                 this.thinkDropLogged = true;
@@ -1369,7 +1564,7 @@ class Executor {
             });
         }
     }
-    agentHooks(agentId, taskId) {
+    agentHooks(agentId, taskId, trackErrorsOn) {
         return {
             onDelta: (channel, text) => {
                 this.queueDelta(agentId, taskId, channel, text);
@@ -1379,6 +1574,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,
@@ -1471,6 +1668,10 @@ 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 = "";
@@ -1488,6 +1689,7 @@ class Executor {
                     blackboard: this.blackboardDigest(6000),
                     artifactList,
                     reason: this.finishReason || "completed",
+                    sources: sourcesText,
                 }),
                 kickoff: prompts_1.SYNTH_KICKOFF,
                 tools: (0, tools_1.synthToolset)(),
@@ -1513,7 +1715,7 @@ class Executor {
                         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")),
+                                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,
@@ -1562,6 +1764,7 @@ class Executor {
         // 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,
@@ -1572,6 +1775,10 @@ class Executor {
     }
     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)");
@@ -1579,6 +1786,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() {