@robzilla1738/agentswarm 0.2.0 → 0.5.0

package/dist/report.js

@@ -0,0 +1,252 @@
+"use strict";
+/**
+ * Dependency-free markdown → styled HTML rendering for final reports.
+ *
+ * Every run writes artifacts/final-report.html next to final-report.md so the
+ * operator always gets a readable, shareable document — even for fallback and
+ * failure reports. This is NOT a full CommonMark implementation; it covers the
+ * subset models actually emit in reports: headings, paragraphs, lists (nested),
+ * fenced code, inline code, bold/italic, links, images, tables, blockquotes,
+ * and horizontal rules. Unknown constructs degrade to escaped text — never to
+ * broken markup.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mdToHtml = mdToHtml;
+exports.renderFinalHtml = renderFinalHtml;
+function esc(s) {
+    return s
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+/** Inline markdown on an already-escaped string. Code spans are opaque. */
+function inline(s) {
+    const out = [];
+    // Split on code spans first so no other rule fires inside them.
+    const parts = s.split(/(`+[^`]*`+)/g);
+    for (const part of parts) {
+        const code = /^(`+)([^`]*)\1$/.exec(part);
+        if (code) {
+            out.push(`<code>${code[2].trim() || "`"}</code>`);
+            continue;
+        }
+        let t = part;
+        // Images before links (same bracket syntax).
+        t = t.replace(/!\[([^\]]*)\]\((https?:[^()\s]+)\)/g, '<img src="$2" alt="$1" loading="lazy">');
+        t = t.replace(/\[([^\]]+)\]\(((?:https?:|#|\.{0,2}\/)[^()\s]*)\)/g, '<a href="$2" target="_blank" rel="noopener">$1</a>');
+        t = t.replace(/\*\*\*([^*]+)\*\*\*/g, "<strong><em>$1</em></strong>");
+        t = t.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+        t = t.replace(/(^|[\s(])\*([^*\s][^*]*)\*/g, "$1<em>$2</em>");
+        t = t.replace(/(^|[\s(])_([^_\s][^_]*)_(?=[\s.,;:!?)]|$)/g, "$1<em>$2</em>");
+        // Bare URLs become links (escaped text, so no quotes can appear inside).
+        t = t.replace(/(^|[\s(])(https?:\/\/[^\s<)]+[^\s<).,;:!?])/g, '$1<a href="$2" target="_blank" rel="noopener">$2</a>');
+        out.push(t);
+    }
+    return out.join("");
+}
+function mdToHtml(md) {
+    const lines = md.replace(/\r\n/g, "\n").split("\n");
+    const html = [];
+    const lists = [];
+    let para = [];
+    let quote = [];
+    const closeLists = (toIndent = -1) => {
+        while (lists.length && lists[lists.length - 1].indent > toIndent) {
+            html.push(`</li></${lists.pop().tag}>`);
+        }
+    };
+    const flushPara = () => {
+        if (para.length) {
+            html.push(`<p>${inline(esc(para.join(" ")))}</p>`);
+            para = [];
+        }
+    };
+    const flushQuote = () => {
+        if (quote.length) {
+            html.push(`<blockquote>${mdToHtml(quote.join("\n"))}</blockquote>`);
+            quote = [];
+        }
+    };
+    const flushAll = () => {
+        flushPara();
+        flushQuote();
+        closeLists();
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Fenced code block.
+        const fence = /^\s*(```|~~~)\s*(\S*)/.exec(line);
+        if (fence) {
+            flushAll();
+            const buf = [];
+            for (i++; i < lines.length && !lines[i].trim().startsWith(fence[1]); i++)
+                buf.push(lines[i]);
+            const lang = fence[2] ? ` class="lang-${esc(fence[2])}"` : "";
+            html.push(`<pre><code${lang}>${esc(buf.join("\n"))}</code></pre>`);
+            continue;
+        }
+        // Blockquote (grouped, recursively rendered).
+        const q = /^\s*>\s?(.*)$/.exec(line);
+        if (q) {
+            flushPara();
+            closeLists();
+            quote.push(q[1]);
+            continue;
+        }
+        flushQuote();
+        // Blank line ends the current paragraph / list run (unless the next
+        // non-blank line continues the list).
+        if (!line.trim()) {
+            flushPara();
+            if (lists.length) {
+                let j = i + 1;
+                while (j < lines.length && !lines[j].trim())
+                    j++;
+                if (j >= lines.length || !/^(\s*)([-*+]|\d+[.)])\s+/.test(lines[j]))
+                    closeLists();
+            }
+            continue;
+        }
+        // Heading.
+        const h = /^(#{1,6})\s+(.*)$/.exec(line.trim());
+        if (h) {
+            flushAll();
+            const level = h[1].length;
+            const text = h[2].replace(/\s+#+\s*$/, "");
+            html.push(`<h${level}>${inline(esc(text))}</h${level}>`);
+            continue;
+        }
+        // Horizontal rule.
+        if (/^\s*([-*_])\s*(\1\s*){2,}$/.test(line)) {
+            flushAll();
+            html.push("<hr>");
+            continue;
+        }
+        // Table: header row + |---| separator.
+        if (line.includes("|") && i + 1 < lines.length && /^\s*\|?[\s:|-]+\|[\s:|-]*$/.test(lines[i + 1]) && lines[i + 1].includes("-")) {
+            flushAll();
+            const cells = (row) => row.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((c) => inline(esc(c.trim())));
+            const head = cells(line);
+            const rows = [];
+            for (i += 2; i < lines.length && lines[i].includes("|") && lines[i].trim(); i++)
+                rows.push(cells(lines[i]));
+            i--;
+            html.push("<table><thead><tr>" +
+                head.map((c) => `<th>${c}</th>`).join("") +
+                "</tr></thead><tbody>" +
+                rows.map((r) => `<tr>${r.map((c) => `<td>${c}</td>`).join("")}</tr>`).join("") +
+                "</tbody></table>");
+            continue;
+        }
+        // List item (unordered or ordered, nested by indentation).
+        const li = /^(\s*)([-*+]|\d+[.)])\s+(.*)$/.exec(line);
+        if (li) {
+            flushPara();
+            const indent = li[1].length;
+            const tag = /\d/.test(li[2]) ? "ol" : "ul";
+            const top = lists[lists.length - 1];
+            if (!top || indent > top.indent) {
+                lists.push({ indent, tag });
+                html.push(`<${tag}><li>${inline(esc(li[3]))}`);
+            }
+            else {
+                closeLists(indent);
+                const cur = lists[lists.length - 1];
+                if (cur && cur.indent === indent && cur.tag !== tag) {
+                    html.push(`</li></${lists.pop().tag}>`);
+                }
+                if (lists.length && lists[lists.length - 1].indent === indent) {
+                    html.push(`</li><li>${inline(esc(li[3]))}`);
+                }
+                else {
+                    lists.push({ indent, tag });
+                    html.push(`<${tag}><li>${inline(esc(li[3]))}`);
+                }
+            }
+            continue;
+        }
+        // Continuation line inside a list item.
+        if (lists.length && /^\s{2,}\S/.test(line)) {
+            html.push(` ${inline(esc(line.trim()))}`);
+            continue;
+        }
+        closeLists();
+        para.push(line.trim());
+    }
+    flushAll();
+    return html.join("\n");
+}
+const CSS = `
+:root { color-scheme: light dark; }
+* { box-sizing: border-box; }
+body {
+  margin: 0; padding: 48px 24px 96px;
+  font: 16px/1.65 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", sans-serif;
+  background: #fcfcfa; color: #1c1c1a;
+}
+@media (prefers-color-scheme: dark) { body { background: #131312; color: #e8e6e1; } }
+main { max-width: 860px; margin: 0 auto; }
+header.run-meta {
+  max-width: 860px; margin: 0 auto 36px; padding-bottom: 20px;
+  border-bottom: 1px solid rgba(128,128,128,.25);
+  font-size: 13px; color: #6e6e68; display: flex; flex-wrap: wrap; gap: 8px 18px; align-items: center;
+}
+.badge { padding: 2px 10px; border-radius: 999px; font-weight: 600; font-size: 12px; letter-spacing: .02em; }
+.badge.done { background: rgba(34,160,84,.14); color: #1d8a4c; }
+.badge.failed { background: rgba(214,60,60,.14); color: #c23b3b; }
+.badge.cancelled { background: rgba(150,150,150,.18); color: #77756f; }
+h1, h2, h3, h4 { line-height: 1.25; letter-spacing: -0.012em; }
+h1 { font-size: 30px; margin: 0 0 18px; }
+h2 { font-size: 22px; margin: 36px 0 12px; }
+h3 { font-size: 18px; margin: 28px 0 10px; }
+a { color: #2563c4; text-decoration: none; }
+a:hover { text-decoration: underline; }
+@media (prefers-color-scheme: dark) { a { color: #7aa7e8; } }
+code {
+  font: 13.5px/1.5 ui-monospace, "SF Mono", Menlo, Consolas, monospace;
+  background: rgba(128,128,128,.13); padding: 1.5px 5px; border-radius: 4px;
+}
+pre {
+  background: rgba(128,128,128,.09); border: 1px solid rgba(128,128,128,.18);
+  border-radius: 8px; padding: 14px 16px; overflow-x: auto;
+}
+pre code { background: none; padding: 0; }
+blockquote {
+  margin: 16px 0; padding: 2px 18px; border-left: 3px solid rgba(128,128,128,.35);
+  color: #6e6e68;
+}
+table { border-collapse: collapse; margin: 18px 0; width: 100%; font-size: 14.5px; }
+th, td { border: 1px solid rgba(128,128,128,.25); padding: 7px 12px; text-align: left; vertical-align: top; }
+th { background: rgba(128,128,128,.08); }
+img { max-width: 100%; border-radius: 6px; }
+hr { border: none; border-top: 1px solid rgba(128,128,128,.25); margin: 32px 0; }
+ul, ol { padding-left: 26px; }
+li { margin: 3px 0; }
+`;
+/** Self-contained HTML document (inline CSS, no scripts, no external fetches). */
+function renderFinalHtml(o) {
+    const title = /^#\s+(.+)$/m.exec(o.markdown)?.[1] ?? o.mission;
+    const date = new Date(o.finishedAt).toISOString().replace("T", " ").slice(0, 16) + " UTC";
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${esc(title.slice(0, 120))}</title>
+<style>${CSS}</style>
+</head>
+<body>
+<header class="run-meta">
+  <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>
+</header>
+<main>
+${mdToHtml(o.markdown)}
+</main>
+</body>
+</html>
+`;
+}

package/dist/run.js

@@ -126,8 +126,13 @@ const summaryCache = new Map();
  */
 const liveCache = new Map();
 const TERMINAL_STATUSES = ["done", "failed", "cancelled"];
-/** Grace before a silent, pid-less run is presumed dead (engine startup, fs lag). */
-const STALE_AFTER_MS = 20_000;
+/**
+ * Grace before a silent, pid-less run is presumed dead. The pid file is the
+ * primary live signal; this window only covers engine startup (before
+ * writePid) and filesystem lag — generous enough that slow disks and slow
+ * provider preflights never flag a healthy run as interrupted.
+ */
+const STALE_AFTER_MS = 45_000;
 /**
  * A run whose engine process vanished without writing a terminal status
  * (kill -9, reboot) would otherwise show "running" forever. Presentation-level

package/dist/searchcore.js

@@ -0,0 +1,191 @@
+"use strict";
+/**
+ * Native search intelligence, ported from the author's SearchKit project
+ * (~/Code/searchkit): canonical-URL dedup, source classification, quality
+ * ranking, and quotable-passage extraction. Pure string/URL processing —
+ * no external services or processes; the engines that feed it live in
+ * webtools.ts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryTerms = queryTerms;
+exports.expandQueries = expandQueries;
+exports.canonicalizeUrl = canonicalizeUrl;
+exports.classifySource = classifySource;
+exports.detectDate = detectDate;
+exports.selectPassages = selectPassages;
+exports.scorePage = scorePage;
+exports.resultQualityScore = resultQualityScore;
+exports.mergeCandidates = mergeCandidates;
+exports.passageBonus = passageBonus;
+exports.rankBonus = rankBonus;
+/** Lowercased alphanumeric query tokens, stopword-ish short tokens dropped. */
+function queryTerms(query) {
+    const m = query.toLowerCase().match(/[a-z0-9]+/g) || [];
+    return [...new Set(m.filter((t) => t.length > 2))];
+}
+/**
+ * Generate a few complementary query phrasings to widen source coverage in
+ * one search: the original, a stopword-stripped keyword core (different
+ * recall on most engines), and a docs/guide angle for question-shaped
+ * queries. Deterministic and low-noise — capped at `max`.
+ */
+function expandQueries(query, max = 3) {
+    const base = query.trim();
+    const out = [base];
+    const terms = queryTerms(query);
+    const core = terms.join(" ");
+    if (core && core.length > 4 && core !== base.toLowerCase())
+        out.push(core);
+    if (/^(how|what|why|when|which|where|who|is|are|can|does|do)\b/i.test(base) && terms.length) {
+        out.push(`${core} guide`);
+    }
+    const seen = new Set();
+    return out.map((q) => q.trim()).filter((q) => q && !seen.has(q.toLowerCase()) && seen.add(q.toLowerCase())).slice(0, max);
+}
+const TRACKING_KEYS = new Set(["fbclid", "gclid", "mc_cid", "mc_eid"]);
+/** Stable canonical form for dedup: strip tracking params, www, trailing slash; sort the query. */
+function canonicalizeUrl(url) {
+    let u;
+    try {
+        u = new URL(url);
+    }
+    catch {
+        return url.toLowerCase();
+    }
+    const pairs = [...u.searchParams.entries()].filter(([k]) => !TRACKING_KEYS.has(k.toLowerCase()) && !k.toLowerCase().startsWith("utm_"));
+    pairs.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    const query = pairs.length ? "?" + pairs.map(([k, v]) => `${k}=${v}`).join("&") : "";
+    const host = u.hostname.toLowerCase().replace(/^www\./, "");
+    let path = u.pathname || "/";
+    if (path !== "/")
+        path = path.replace(/\/+$/, "");
+    return `${u.protocol.toLowerCase()}//${host}${path}${query}`;
+}
+function classifySource(domain) {
+    const d = domain.toLowerCase();
+    if (d.endsWith(".gov") || d.endsWith(".mil"))
+        return "government";
+    if (d.endsWith(".edu"))
+        return "academic";
+    if (["twitter.com", "x.com", "reddit.com", "facebook.com"].some((s) => d.includes(s)))
+        return "social";
+    if (d.includes("news") || d.includes("reuters.com") || d.includes("apnews.com") || d.includes("bbc."))
+        return "news";
+    return "secondary";
+}
+/** ISO date if present, else a bare year. */
+function detectDate(text) {
+    const iso = /\b(20\d{2}-\d{2}-\d{2})\b/.exec(text);
+    if (iso)
+        return iso[1];
+    const year = /\b(20\d{2})\b/.exec(text);
+    return year?.[1];
+}
+const WINDOW_WORDS = 60;
+const STRIDE = 30;
+/**
+ * Quotable passages: slide a 60-word window (stride 30) over the text and
+ * score each window by the fraction of query terms it contains. Deterministic
+ * lexical matching — no embeddings. Falls back to the lead window so a hit
+ * always carries something quotable.
+ */
+function selectPassages(text, query, maxPassages = 3) {
+    const body = text.trim();
+    if (!body)
+        return [];
+    const terms = queryTerms(query);
+    const tokens = [...body.matchAll(/\S+/g)];
+    if (!tokens.length)
+        return [];
+    const windows = [];
+    for (let i = 0; i < tokens.length; i += STRIDE) {
+        const slice = tokens.slice(i, i + WINDOW_WORDS);
+        const start = slice[0].index;
+        const last = slice[slice.length - 1];
+        const chunk = body.slice(start, last.index + last[0].length);
+        windows.push({ text: chunk, score: scoreChunk(chunk, terms) });
+        if (i + WINDOW_WORDS >= tokens.length)
+            break;
+    }
+    const scored = windows.filter((w) => w.score > 0).sort((a, b) => b.score - a.score);
+    const picked = (scored.length ? scored : windows).slice(0, maxPassages);
+    return picked.map((p) => ({ text: p.text, score: Math.round(p.score * 10_000) / 10_000 }));
+}
+function scoreChunk(chunk, terms) {
+    if (!terms.length)
+        return 0;
+    const lowered = chunk.toLowerCase();
+    let hits = 0;
+    for (const t of terms)
+        if (lowered.includes(t))
+            hits++;
+    return hits / terms.length;
+}
+/** Content-quality score for a fetched page (deep mode re-ranking). */
+function scorePage(page, terms) {
+    let score = 0;
+    const domain = page.domain.toLowerCase();
+    const url = page.url.toLowerCase();
+    const title = page.title.toLowerCase();
+    const type = classifySource(domain);
+    if (type === "primary" || type === "government" || type === "academic")
+        score += 5;
+    if (domain.includes("docs") || url.includes("docs") || title.includes("documentation"))
+        score += 5;
+    if (domain === "github.com" || domain === "gitlab.com")
+        score += 4;
+    if (["pypi.org", "npmjs.com", "rubygems.org"].includes(domain))
+        score -= 2;
+    if (page.date)
+        score += 1;
+    const lowered = page.text.toLowerCase();
+    for (const t of terms)
+        if (lowered.includes(t))
+            score += 1;
+    score += Math.min(page.text.length / 4000, 1);
+    return score;
+}
+const LOW_VALUE_SNIPPET = ["copy a direct link", "file metadata"];
+/** Pre-fetch quality score for one engine result (snippet-level signals only). */
+function resultQualityScore(c) {
+    const url = c.url.toLowerCase();
+    const title = c.title.toLowerCase();
+    const snippet = c.snippet.toLowerCase();
+    let score = Math.max(0, 20 - c.rank);
+    if (title.includes("official") || snippet.includes("official"))
+        score += 4;
+    if (title.includes("documentation") || snippet.includes("documentation") || url.includes("docs"))
+        score += 4;
+    if (url.includes("github.com") || url.includes("gitlab.com"))
+        score += 3;
+    if (LOW_VALUE_SNIPPET.some((t) => snippet.includes(t)))
+        score -= 10;
+    return score;
+}
+/**
+ * Merge results from several engines: quality-rank, dedupe by canonical URL
+ * (first/best occurrence wins), cap at maxResults.
+ */
+function mergeCandidates(candidates, maxResults) {
+    const ranked = [...candidates].sort((a, b) => resultQualityScore(b) - resultQualityScore(a));
+    const seen = new Set();
+    const out = [];
+    for (const c of ranked) {
+        const key = canonicalizeUrl(c.url);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(c);
+        if (out.length >= maxResults)
+            break;
+    }
+    return out;
+}
+/** Best-passage bonus used in deep-mode composite scoring. */
+function passageBonus(passages) {
+    return passages.length ? passages[0].score * 3 : 0;
+}
+/** Engine-rank decay bonus used in composite scoring. */
+function rankBonus(rank, ceiling) {
+    return Math.max(0, ceiling - rank) * 0.2;
+}

package/dist/state.js

@@ -14,6 +14,8 @@ class RunState {
     taskOrder = [];
     agents = new Map();
     notes = [];
+    phases = [];
+    planExcerpt = "";
     conductorLog = [];
     operatorNotes = [];
     usageByModel = new Map();
@@ -29,10 +31,33 @@ class RunState {
     constructor(pricing = {}) {
         this.pricing = pricing;
     }
+    /** Sub-states for hierarchical teams, keyed by the owning task id. */
+    teams = new Map();
     apply(ev) {
         this.lastSeq = ev.seq;
         this.lastT = ev.t;
         this.updatedAt = ev.t;
+        // Team-stamped events reduce into their team's sub-state so a sub-swarm's
+        // hundred tasks never pollute the root task list. Usage still rolls up
+        // here — the run's budget/cost is one number.
+        const teamId = typeof ev.teamId === "string" ? ev.teamId : undefined;
+        if (teamId) {
+            let team = this.teams.get(teamId);
+            if (!team) {
+                team = new RunState(this.pricing);
+                this.teams.set(teamId, team);
+            }
+            const { teamId: _omit, ...rest } = ev;
+            team.apply(rest);
+            if (ev.type === "usage") {
+                const u = ev.usage;
+                const model = ev.model ?? "unknown";
+                this.usageByModel.set(model, (0, types_1.addUsage)(this.usageByModel.get(model) ?? { ...types_1.ZERO_USAGE }, u));
+                this.totalUsage = (0, types_1.addUsage)(this.totalUsage, u);
+                this.cost += (0, types_1.usageCost)(u, this.pricing[model]);
+            }
+            return;
+        }
         switch (ev.type) {
             case "run.created": {
                 this.meta = ev.meta;
@@ -96,9 +121,21 @@ class RunState {
                     t.report = ev.report;
                     t.reportStatus = ev.status;
                     t.artifacts = ev.artifacts ?? t.artifacts;
+                    if (Array.isArray(ev.keyFacts))
+                        t.keyFacts = ev.keyFacts;
+                    if (Array.isArray(ev.openQuestions))
+                        t.openQuestions = ev.openQuestions;
+                    if (Array.isArray(ev.filesTouched))
+                        t.filesTouched = ev.filesTouched;
                 }
                 break;
             }
+            case "task.checkpoint": {
+                const t = this.tasks.get(ev.taskId);
+                if (t)
+                    t.lastCheckpoint = ev.summary;
+                break;
+            }
             case "verify.result": {
                 const t = this.tasks.get(ev.taskId);
                 if (t)
@@ -146,18 +183,35 @@ class RunState {
                 }
                 break;
             }
+            case "plan.updated":
+                this.planExcerpt = String(ev.excerpt ?? "");
+                break;
+            case "phase.set":
+                this.phases.push({
+                    t: ev.t,
+                    name: String(ev.name ?? ""),
+                    goal: ev.goal,
+                    exitCriteria: ev.exit_criteria,
+                });
+                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,
                 });
                 // Reduced state is held live by the hub and the resume seed — keep
-                // only the tail that digests/views actually use.
-                if (this.notes.length > 1000)
-                    this.notes.splice(0, this.notes.length - 1000);
+                // only the tail that digests/views actually use. Decisions are never
+                // dropped: they anchor the conductor's long-horizon coherence.
+                if (this.notes.length > 1000) {
+                    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, 1000 - decisions.length));
+                    this.notes = [...decisions, ...rest].sort((a, b) => a.t - b.t);
+                }
                 break;
             case "conductor.say":
                 this.conductorLog.push({ t: ev.t, text: ev.text });