@robzilla1738/agentswarm 0.6.0 → 0.7.0

package/dist/agent.js

@@ -59,20 +59,10 @@ async function runAgent(p) {
         if (stopReason)
             break;
         steps++;
-        let res;
-        try {
-            res = await callModel();
-        }
-        catch (e) {
-            // The chat client already retries 429/5xx; this catches the rest of the
-            // transient class (connection resets, DNS blips) once per step so a
-            // single network hiccup doesn't burn a whole task attempt.
-            if (p.signal.aborted)
-                throw e;
-            hooks.onLog?.("warn", `${p.agentId}: model call failed (${(0, util_1.errMsg)(e)}); retrying once`);
-            await new Promise((r) => setTimeout(r, 1500));
-            res = await callModel();
-        }
+        // No retry here: the chat client already retries the whole transient
+        // class (429/5xx/network) with backoff; anything that escapes it is
+        // permanent (4xx) and re-sending only doubles the doomed spend.
+        const res = await callModel();
         hooks.onUsage?.(p.model, res.usage);
         usage = (0, types_1.addUsage)(usage, res.usage);
         if (res.toolCalls.length === 0) {

package/dist/cli.js

@@ -524,7 +524,16 @@ async function cmdConfig(rest, flags) {
         const cfg = (0, config_1.loadConfig)();
         if (sub === "get" && rest[1]) {
             const key = rest[1];
-            const v = /apikey|token|secret/i.test(key) ? (0, config_1.maskKey)(String(cfg[key] ?? "")) : cfg[key];
+            if (key === "providers") {
+                // Nested per-provider creds — mask every apiKey, never dump raw.
+                const masked = Object.fromEntries(Object.entries(cfg.providers ?? {}).map(([id, c]) => [
+                    id,
+                    { ...c, ...(c?.apiKey ? { apiKey: (0, config_1.maskKey)(c.apiKey) } : {}) },
+                ]));
+                console.log(JSON.stringify(masked, null, 2));
+                return;
+            }
+            const v = (0, config_1.isSecretConfigKey)(key) ? (0, config_1.maskKey)(String(cfg[key] ?? "")) : cfg[key];
             console.log(typeof v === "object" ? JSON.stringify(v, null, 2) : String(v));
             return;
         }
@@ -533,7 +542,7 @@ async function cmdConfig(rest, flags) {
             let v = cfg[k];
             // Every secret-bearing key prints masked — `config list` output ends up
             // in terminal scrollback and pasted bug reports.
-            if (/apikey|token|secret/i.test(k)) {
+            if ((0, config_1.isSecretConfigKey)(k)) {
                 v = v ? (0, config_1.maskKey)(String(v)) : k === "apiKey" ? util_1.ansi.red("(not set)") : "(not set)";
             }
             console.log(`  ${k.padEnd(18)} ${util_1.ansi.gray(String(v))}`);
@@ -566,14 +575,15 @@ async function cmdConfig(rest, flags) {
         const key = rest[1];
         if (!key)
             throw new Error("usage: swarm config unset <key>");
-        // Only string-valued keys can sensibly clear to "" — numbers/enums keep
-        // their defaults via `set`.
-        const clearable = config_1.SETTABLE_KEYS.filter((k) => /apikey|token|secret|url|model/i.test(k));
-        if (!clearable.includes(key)) {
-            throw new Error(`not clearable. Clearable keys: ${clearable.join(", ")}`);
+        if (!config_1.SETTABLE_KEYS.includes(key)) {
+            throw new Error(`unknown key. Keys: ${config_1.SETTABLE_KEYS.join(", ")}`);
         }
-        (0, config_1.saveConfig)({ [key]: "" });
-        console.log(util_1.ansi.green("✓ ") + `cleared ${key}`);
+        // apiKey/baseUrl route into the active provider's creds, so clearing
+        // means writing "". Everything else is deleted from the file outright —
+        // the default applies again (unset model:"" would brick every run).
+        const cred = key === "apiKey" || key === "baseUrl";
+        (0, config_1.saveConfig)({ [key]: cred ? "" : undefined });
+        console.log(util_1.ansi.green("✓ ") + `cleared ${key}` + (cred ? "" : util_1.ansi.gray(" — default applies")));
         return;
     }
     if (sub === "path") {

package/dist/config.js

@@ -41,6 +41,7 @@ exports.runDir = runDir;
 exports.configPath = configPath;
 exports.loadConfig = loadConfig;
 exports.saveConfig = saveConfig;
+exports.isSecretConfigKey = isSecretConfigKey;
 exports.maskKey = maskKey;
 exports.coerceConfigValue = coerceConfigValue;
 const fs = __importStar(require("fs"));
@@ -192,6 +193,13 @@ function loadConfig() {
         apiKey: cred.apiKey || "",
         baseUrl: cred.baseUrl || info.baseUrl,
     };
+    // A cleared/hand-edited model must fall back, not brick every run with
+    // model:"" requests. (cheapModel/strongModel legitimately clear to "" —
+    // they mean "use `model`".)
+    if (!cfg.model)
+        cfg.model = info.defaultModel;
+    if (!cfg.conductorModel)
+        cfg.conductorModel = cfg.model;
     // Env overrides: provider-specific key env, plus legacy DEEPSEEK_API_KEY.
     if (info.keyEnv && process.env[info.keyEnv])
         cfg.apiKey = process.env[info.keyEnv];
@@ -249,6 +257,15 @@ function saveConfig(patch) {
     }
     return loadConfig();
 }
+/**
+ * Config keys whose values must never print in cleartext — CLI output ends up
+ * in terminal scrollback and pasted bug reports. `providers` holds nested
+ * per-provider apiKeys, so it counts too. Single source of truth for the CLI
+ * masking sites (the hub's publicConfig is a strict allowlist already).
+ */
+function isSecretConfigKey(key) {
+    return /apikey|token|secret/i.test(key) || key === "providers";
+}
 function maskKey(key) {
     if (!key)
         return "";

package/dist/crawltools.js

@@ -138,7 +138,7 @@ async function firecrawlCrawl(cfg, opts, warnings) {
             warnings.push(`crawl still running after 120s; returning ${partial.length} partial pages`);
             return partial;
         }
-        await sleep(pollMs, opts.signal);
+        await (0, util_1.sleep)(pollMs, opts.signal);
     }
     // Completed: collect pages, following `next` pagination until maxPages.
     const pages = mapFirecrawlPages(last);
@@ -206,18 +206,12 @@ function friendlyHttpError(service, status, body) {
         return new Error(`${service}: rate limited (HTTP 429) — retry later`);
     return new Error(`${service}: HTTP ${status} ${(0, util_1.truncateMiddle)(body, 300, "chars")}`);
 }
-function mergeSignal(timeoutMs, signal) {
-    const t = AbortSignal.timeout(timeoutMs);
-    if (!signal)
-        return t;
-    return typeof AbortSignal.any === "function" ? AbortSignal.any([t, signal]) : signal;
-}
 async function callJson(service, url, key, body, timeoutMs, signal) {
     const res = await fetch(url, {
         method: "POST",
         headers: { authorization: `Bearer ${key}`, "content-type": "application/json" },
         body: JSON.stringify(body),
-        signal: mergeSignal(timeoutMs, signal),
+        signal: (0, util_1.mergeSignal)(timeoutMs, signal),
     });
     if (!res.ok)
         throw friendlyHttpError(service, res.status, await res.text().catch(() => ""));
@@ -226,22 +220,9 @@ async function callJson(service, url, key, body, timeoutMs, signal) {
 async function getJson(service, url, key, signal) {
     const res = await fetch(url, {
         headers: { authorization: `Bearer ${key}` },
-        signal: mergeSignal(30_000, signal),
+        signal: (0, util_1.mergeSignal)(30_000, signal),
     });
     if (!res.ok)
         throw friendlyHttpError(service, res.status, await res.text().catch(() => ""));
     return res.json();
 }
-function sleep(ms, signal) {
-    return new Promise((resolve, reject) => {
-        const t = setTimeout(() => {
-            signal?.removeEventListener("abort", onAbort);
-            resolve();
-        }, ms);
-        const onAbort = () => {
-            clearTimeout(t);
-            reject(new Error("aborted"));
-        };
-        signal?.addEventListener("abort", onAbort, { once: true });
-    });
-}

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;
@@ -138,8 +137,10 @@ class Executor {
         // must not resurrect across a restart.
         const settled = new Set(state.taskList().filter((t) => ["done", "failed", "blocked"].includes(t.status) && !reset.has(t.id)).map((t) => t.id));
         this.notes = state.notes
-            .map((n) => ({ taskId: n.taskId, key: n.key, kind: n.kind, text: n.text, url: n.url }))
-            .filter((n) => !(n.kind === "claim" && n.taskId && settled.has(n.taskId)));
+            .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 };
@@ -398,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;
@@ -406,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) {
@@ -446,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";
                     }
@@ -455,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";
                     }
@@ -596,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) });
@@ -783,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),
@@ -1012,7 +1021,7 @@ class Executor {
             signal: this.ac.signal,
             addCheckpoint: task ? (summary) => this.recordCheckpoint(task, agentId, summary) : undefined,
             addNote: (text, key, kind, url) => {
-                this.notes.push({ taskId: task?.id, key, kind, text, 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 and conflicts are
                 // kept regardless. In-place splice: teams share this array by reference.
@@ -1035,11 +1044,16 @@ class Executor {
             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;
@@ -1401,7 +1415,7 @@ class Executor {
         // 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)
+            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 });
@@ -1508,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;

package/dist/hub.js

@@ -180,9 +180,7 @@ async function api(req, res, url, opts) {
                 return { engine, ok: false, detail: (0, util_1.errMsg)(e) };
             }
         };
-        const checks = [probe("duckduckgo", () => (0, webtools_1.ddgSearch)(q, 3)), probe("bing", () => (0, webtools_1.bingSearch)(q, 3))];
-        if (cfg.tinyfishApiKey)
-            checks.push(probe("tinyfish", () => (0, webtools_1.tinyfishSearch)(cfg, q, 3)));
+        const checks = (0, webtools_1.searchEngines)(cfg).map((e) => probe(e.name, () => e.search(q, 3)));
         const engines = await Promise.all(checks);
         return sendJson(res, 200, { ok: engines.some((e) => e.ok), engines });
     }

package/dist/journal.js

@@ -88,11 +88,14 @@ class Journal {
         }
         return ev;
     }
+    /** The chunk an async drain is writing right now — flushSync must see it. */
+    inFlight = "";
     async drain() {
         if (!this.buf)
             return;
         const chunk = this.buf;
         this.buf = "";
+        this.inFlight = chunk;
         try {
             await fs.promises.appendFile(this.file, chunk, "utf8");
             this.failures = 0;
@@ -107,16 +110,26 @@ class Journal {
                 process.stderr.write(`agentswarm: journal writes are failing (${String(e)}); run state is no longer durable\n`);
             }
         }
+        finally {
+            this.inFlight = "";
+        }
     }
     flush() {
         return this.chain.then(() => this.drain());
     }
-    /** Last-gasp synchronous flush for signal handlers and exit paths. */
+    /**
+     * Last-gasp synchronous flush for signal handlers and exit paths. Includes
+     * any chunk a pending async drain holds: process.exit would abandon that
+     * write, silently losing just-settled events. If the abandoned write did
+     * land first, the chunk appears twice — readers dedupe by seq.
+     */
     flushSync() {
-        if (!this.buf)
+        const pending = this.inFlight + this.buf;
+        if (!pending)
             return;
         try {
-            fs.appendFileSync(this.file, this.buf, "utf8");
+            fs.appendFileSync(this.file, pending, "utf8");
+            this.inFlight = "";
             this.buf = "";
         }
         catch {
@@ -136,7 +149,24 @@ function readEvents(runDirPath) {
     catch {
         return [];
     }
-    return parseLines(raw).events;
+    return dedupeBySeq(parseLines(raw).events);
+}
+/**
+ * Seq is strictly increasing in a healthy journal; a chunk can appear twice
+ * when a signal-handler flushSync raced an in-flight async append. Replays of
+ * already-seen seqs are dropped.
+ */
+function dedupeBySeq(events, lastSeq = 0) {
+    let max = lastSeq;
+    const out = [];
+    for (const ev of events) {
+        if (typeof ev.seq === "number" && ev.seq <= max)
+            continue;
+        if (typeof ev.seq === "number")
+            max = ev.seq;
+        out.push(ev);
+    }
+    return out;
 }
 function lastSeq(runDirPath) {
     const evs = readEvents(runDirPath);
@@ -155,6 +185,7 @@ function readNewEvents(file, state) {
         // Truncated/rewritten (should not happen) — start over.
         state.offset = 0;
         state.carry = "";
+        state.lastSeq = 0;
     }
     if (stat.size === state.offset)
         return [];
@@ -172,7 +203,10 @@ function readNewEvents(file, state) {
             const text = state.carry + buf.toString("utf8", 0, n);
             const parsed = parseLines(text, true);
             state.carry = parsed.carry;
-            out.push(...parsed.events);
+            const fresh = dedupeBySeq(parsed.events, state.lastSeq ?? 0);
+            if (fresh.length)
+                state.lastSeq = fresh[fresh.length - 1].seq;
+            out.push(...fresh);
         }
         state.offset += read;
         return out;

package/dist/memory.js

@@ -38,7 +38,6 @@ exports.loadMemory = loadMemory;
 exports.appendMemory = appendMemory;
 exports.memoryBlock = memoryBlock;
 const crypto = __importStar(require("crypto"));
-const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const config_1 = require("./config");
 const util_1 = require("./util");
@@ -48,13 +47,19 @@ function memoryFile(cwd) {
     return path.join((0, config_1.home)(), "memory", `${hash}.json`);
 }
 function loadMemory(cwd) {
-    try {
-        const raw = JSON.parse(fs.readFileSync(memoryFile(cwd), "utf8"));
-        return Array.isArray(raw?.entries) ? raw.entries : [];
-    }
-    catch {
+    const raw = (0, util_1.readJson)(memoryFile(cwd), {});
+    if (!Array.isArray(raw.entries))
         return [];
-    }
+    // Memory is best-effort and the file is user-editable: one malformed entry
+    // must degrade to "forgotten", never crash a run at startup.
+    return raw.entries.filter((e) => !!e &&
+        typeof e === "object" &&
+        typeof e.mission === "string" &&
+        typeof e.summary === "string" &&
+        typeof e.status === "string" &&
+        Number.isFinite(e.finishedAt) &&
+        Array.isArray(e.keyDecisions) &&
+        e.keyDecisions.every((d) => typeof d === "string"));
 }
 function appendMemory(cwd, entry) {
     try {

package/dist/report.js

@@ -16,6 +16,7 @@ exports.sourcesBlock = sourcesBlock;
 exports.mdToHtml = mdToHtml;
 exports.renderFinalHtml = renderFinalHtml;
 const searchcore_1 = require("./searchcore");
+const util_1 = require("./util");
 /**
  * Dedupe every task's reported sources (by canonical URL) into one numbered
  * bibliography for the synthesizer. First occurrence wins the number; later
@@ -278,7 +279,7 @@ function renderFinalHtml(o) {
   <span class="badge ${o.status}">${o.status}</span>
   <span>run ${esc(o.runId)}</span>
   <span>${esc(date)}</span>
-  <span title="${esc(o.mission.slice(0, 600))}">mission: ${esc(o.mission.length > 90 ? o.mission.slice(0, 90) + "…" : o.mission)}</span>
+  <span title="${esc(o.mission.slice(0, 600))}">mission: ${esc((0, util_1.clip)(o.mission, 90))}</span>
 </header>
 <main>
 ${mdToHtml(o.markdown)}

package/dist/state.js

@@ -59,6 +59,12 @@ class RunState {
                 this.cost += (0, types_1.usageCost)(u, this.pricing[model]);
                 this.pushBudgetPoint(ev.t);
             }
+            else if (ev.type === "note.added") {
+                // The blackboard is shared swarm-wide at runtime, so team notes are
+                // root facts too — without this, a resume would forget every note a
+                // team agent posted (decisions included).
+                this.pushNote(ev, teamId);
+            }
             return;
         }
         switch (ev.type) {
@@ -200,25 +206,7 @@ class RunState {
                 });
                 break;
             case "note.added":
-                this.notes.push({
-                    t: ev.t,
-                    taskId: ev.taskId,
-                    agentId: ev.agentId,
-                    key: ev.key,
-                    kind: ev.kind,
-                    text: ev.text,
-                    url: typeof ev.url === "string" ? ev.url : undefined,
-                });
-                // Reduced state is held live by the hub and the resume seed — keep
-                // only the tail that digests/views actually use. Decisions and
-                // conflicts are never dropped: they anchor long-horizon coherence.
-                if (this.notes.length > 1000) {
-                    const keep = (n) => n.kind === "decision" || n.kind === "conflict";
-                    const pinned = this.notes.filter(keep);
-                    const rest = this.notes.filter((n) => !keep(n));
-                    rest.splice(0, rest.length - Math.max(0, 1000 - pinned.length));
-                    this.notes = [...pinned, ...rest].sort((a, b) => a.t - b.t);
-                }
+                this.pushNote(ev);
                 break;
             case "conductor.say":
                 this.conductorLog.push({ t: ev.t, text: ev.text });
@@ -269,6 +257,40 @@ class RunState {
             this.budgetSeries = this.budgetSeries.filter((_, i) => i % 2 === 0 || i === this.budgetSeries.length - 1);
         }
     }
+    pushNote(ev, teamId) {
+        this.notes.push({
+            t: ev.t,
+            taskId: ev.taskId,
+            teamId,
+            agentId: ev.agentId,
+            key: ev.key,
+            kind: ev.kind,
+            text: ev.text,
+            url: typeof ev.url === "string" ? ev.url : undefined,
+        });
+        // Reduced state is held live by the hub and the resume seed — keep only
+        // the tail that digests/views actually use. Decisions and conflicts are
+        // never dropped: they anchor long-horizon coherence. Forward-pass splice
+        // (mirroring the executor's addNote): the array is permanently at the cap
+        // once a long run passes it, so this runs on every note event — no
+        // filter/sort allocations on the reducer hot path.
+        if (this.notes.length > 1000) {
+            const keep = (n) => n.kind === "decision" || n.kind === "conflict";
+            let pinnedCount = 0;
+            for (const n of this.notes)
+                if (keep(n))
+                    pinnedCount++;
+            let toDrop = this.notes.length - Math.max(pinnedCount, 1000);
+            for (let i = 0; i < this.notes.length && toDrop > 0;) {
+                if (!keep(this.notes[i])) {
+                    this.notes.splice(i, 1);
+                    toDrop--;
+                }
+                else
+                    i++;
+            }
+        }
+    }
     taskList() {
         return this.taskOrder.map((id) => this.tasks.get(id)).filter(Boolean);
     }

package/dist/tools.js

@@ -301,9 +301,21 @@ function workerToolset(cfg) {
             const excludes = ["node_modules", ".git", "dist", ".next", "out", "build", "target", "__pycache__", ".venv"]
                 .map((d) => ` --exclude-dir=${d}`)
                 .join("");
-            const cmd = `grep ${flags}${include}${excludes} -e ${shq(pattern)} ${shq(root)} | head -n ${max + 1}`;
+            // No `| head`: a pipe would mask grep's exit code, and an invalid regex
+            // or unreadable path must fail loudly, not read as "no matches".
+            // (Output volume is already bounded by the sandbox's collect cap.)
+            const cmd = `grep ${flags}${include}${excludes} -e ${shq(pattern)} ${shq(root)}`;
             const r = await ctx.sandbox.exec(cmd, { cwd: ctx.workdir, timeoutSec: 60, signal: ctx.signal });
-            const lines = r.out.split("\n").filter(Boolean);
+            // Sandbox exec merges stderr into out — separate grep's diagnostics.
+            const all = r.out.split("\n").filter(Boolean);
+            const diags = all.filter((l) => l.startsWith("grep:"));
+            const lines = all.filter((l) => !l.startsWith("grep:"));
+            // Exit 1 = clean no-match. Anything past 1 with zero matches is a real
+            // failure (bad pattern, missing path); with matches it's partial
+            // (some files unreadable) and the matches still count.
+            if (r.code !== 0 && r.code !== 1 && !lines.length) {
+                throw new Error(`grep failed (exit ${r.code}): ${diags.join("; ").slice(0, 300) || "no error detail"}`);
+            }
             if (!lines.length)
                 return "no matches";
             const shown = lines.slice(0, max);

package/dist/util.js

@@ -33,8 +33,10 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ansi = exports.sleep = void 0;
+exports.ansi = void 0;
 exports.rid = rid;
+exports.sleep = sleep;
+exports.mergeSignal = mergeSignal;
 exports.truncateMiddle = truncateMiddle;
 exports.clip = clip;
 exports.oneLine = oneLine;
@@ -62,8 +64,35 @@ function rid(prefix) {
     const c = ridCounter.toString(36).padStart(2, "0");
     return `${prefix}_${t}${r}${c}`;
 }
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-exports.sleep = sleep;
+/** Resolves after ms; rejects early if the signal aborts first. */
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (!signal) {
+            setTimeout(resolve, ms);
+            return;
+        }
+        if (signal.aborted) {
+            reject(new Error("aborted"));
+            return;
+        }
+        const t = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(t);
+            reject(new Error("aborted"));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+/** A timeout signal, combined with the caller's signal when one is given. */
+function mergeSignal(timeoutMs, signal) {
+    const t = AbortSignal.timeout(timeoutMs);
+    if (!signal)
+        return t;
+    return typeof AbortSignal.any === "function" ? AbortSignal.any([t, signal]) : signal;
+}
 // ---------- strings ----------
 function truncateMiddle(s, max, label = "bytes") {
     if (s.length <= max)