@ra3orblade/swarm 0.9.0 → 0.11.0

package/dist/swarmd.js

@@ -68,6 +68,44 @@ function clearDaemonInfo() {
 function daemonCommand() {
   return resolveBin("swarmd");
 }
+// packages/core/src/abtrial.ts
+var ms = (a, b) => b ? Math.max(0, new Date(b).getTime() - new Date(a).getTime()) : null;
+function splitArmTask(id) {
+  const i = id.lastIndexOf("#");
+  return i < 0 ? { task: id, arm: null } : { task: id.slice(0, i), arm: id.slice(i + 1) };
+}
+var armTask = (task, label) => `${task}#${label}`;
+function scoreTrial(task, arms) {
+  const scored = arms.map((a) => {
+    const ineligibleFor = a.state === "running" ? "still running" : a.state === "failed" ? "crashed" : a.gatesFailed > 0 ? "failed a gate" : null;
+    return {
+      ...a,
+      wallMs: ms(a.startedAt, a.endedAt),
+      churn: a.insertions === null && a.deletions === null ? null : (a.insertions ?? 0) + (a.deletions ?? 0),
+      eligible: ineligibleFor === null,
+      ineligibleFor,
+      winner: false
+    };
+  });
+  const eligible = scored.filter((a) => a.eligible).sort((a, b) => a.costUsd - b.costUsd || (a.wallMs ?? Number.POSITIVE_INFINITY) - (b.wallMs ?? Number.POSITIVE_INFINITY) || a.label.localeCompare(b.label));
+  const best = eligible[0] ?? null;
+  if (best)
+    best.winner = true;
+  const finished = scored.filter((a) => a.state !== "running").length;
+  const dearest = eligible.at(-1);
+  return {
+    task,
+    arms: scored.sort((a, b) => Number(b.eligible) - Number(a.eligible) || a.costUsd - b.costUsd || a.label.localeCompare(b.label)),
+    winner: best?.label ?? null,
+    verdict: best ? "winner" : scored.some((a) => a.state === "running") ? "undecided" : "all-failed",
+    totals: {
+      arms: scored.length,
+      finished,
+      costUsd: scored.reduce((a, x) => a + x.costUsd, 0),
+      savedUsd: best && dearest ? Math.max(0, dearest.costUsd - best.costUsd) : 0
+    }
+  };
+}
 // packages/core/src/actor.ts
 var HUMAN_ALIASES = new Set(["cli", "dashboard", "me", "desktop", "human"]);
 var DAEMON_ALIASES = new Set(["daemon", "system", "swarm"]);
@@ -105,6 +143,150 @@ function actorFromColumns(kind, id, session) {
     a.session = session;
   return a;
 }
+// packages/core/src/adapters/aider/history.ts
+var djb2 = (s) => {
+  let h = 5381;
+  for (let i = 0;i < s.length; i++)
+    h = (h * 33 ^ s.charCodeAt(i)) >>> 0;
+  return h.toString(36);
+};
+var toks = (s) => {
+  if (!s)
+    return 0;
+  const n = Number.parseFloat(s.replaceAll(",", ""));
+  return Math.round(s.trim().endsWith("k") ? n * 1000 : n);
+};
+var HEADER = /^# aider chat started at (\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})/;
+var MODEL = /^> Model: (\S+) with /;
+var TOKENS = /^(?:> )?Tokens: ([\d.,]+k?) sent(?:, ([\d.,]+k?) cache write)?(?:, ([\d.,]+k?) cache hit)?, ([\d.,]+k?) received\./;
+var COST = /Cost: \$([\d.]+(?:e-?\d+)?) message/;
+var EDIT = /^> Applied edit to (.+)/;
+var COMMIT = /^> Commit [0-9a-f]{6,}/;
+function parseAiderHistory(chunk, seed, carry) {
+  const segments = [];
+  let cur = carry ? {
+    sessionId: carry.sessionId,
+    startMs: carry.startMs,
+    model: carry.model,
+    title: carry.title,
+    turns: [],
+    c: { ...carry }
+  } : null;
+  const closeTurn = (t, cost) => {
+    if (!cur)
+      return;
+    t.cost = cost;
+    cur.turns.push(t);
+    cur.c.turns++;
+    cur.c.text = "";
+    cur.c.tools = [];
+    cur.c.pending = null;
+  };
+  const flushPending = () => {
+    if (cur?.c.pending)
+      closeTurn(cur.c.pending, null);
+  };
+  for (const line of chunk.split(`
+`)) {
+    const h = line.match(HEADER);
+    if (h) {
+      flushPending();
+      if (cur)
+        segments.push(cur);
+      const stamp = h[1] ?? "";
+      const startMs = Date.parse(stamp.replace(" ", "T"));
+      const sessionId = `aider-${djb2(`${seed}|${stamp}`)}`;
+      cur = {
+        sessionId,
+        startMs,
+        model: null,
+        title: null,
+        turns: [],
+        c: {
+          sessionId,
+          startMs,
+          model: null,
+          title: null,
+          turns: 0,
+          text: "",
+          tools: [],
+          pending: null
+        }
+      };
+      continue;
+    }
+    if (!cur)
+      continue;
+    const c = cur.c;
+    if (c.pending) {
+      const cost = line.match(COST);
+      if (cost) {
+        closeTurn(c.pending, Number.parseFloat(cost[1] ?? "0"));
+        continue;
+      }
+      flushPending();
+    }
+    const m = line.match(MODEL);
+    if (m) {
+      cur.model = (m[1] ?? "").split("/").pop() || null;
+      c.model = cur.model;
+      continue;
+    }
+    const tk = line.match(TOKENS);
+    if (tk) {
+      const cacheRead = toks(tk[3]);
+      const turn = {
+        id: `${c.sessionId}-t${c.turns}`,
+        ts: new Date(c.startMs + c.turns * 1000).toISOString(),
+        model: c.model ?? "aider",
+        usage: {
+          input: Math.max(0, toks(tk[1]) - cacheRead),
+          output: toks(tk[4]),
+          cacheWrite: toks(tk[2]),
+          cacheWrite1h: 0,
+          cacheRead,
+          thinking: 0
+        },
+        text: c.text,
+        tools: c.tools,
+        effort: null,
+        sidechain: false
+      };
+      const cost = line.match(COST);
+      if (cost)
+        closeTurn(turn, Number.parseFloat(cost[1] ?? "0"));
+      else
+        c.pending = turn;
+      continue;
+    }
+    if (line.startsWith("#### ")) {
+      const t = line.slice(5).trim();
+      if (t && !cur.title) {
+        cur.title = t.slice(0, 80);
+        c.title = cur.title;
+      }
+      continue;
+    }
+    if (EDIT.test(line)) {
+      c.tools.push("edit");
+      continue;
+    }
+    if (COMMIT.test(line)) {
+      c.tools.push("commit");
+      continue;
+    }
+    if (line.startsWith(">"))
+      continue;
+    if (line.trim() && c.text.length < 400)
+      c.text = `${c.text}${c.text ? `
+` : ""}${line}`.slice(0, 400);
+  }
+  if (cur)
+    segments.push(cur);
+  const last = cur ? { ...cur.c } : null;
+  return { segments, carry: last };
+}
+
 // packages/core/src/adapters/claude-code/transcript.ts
 function parseTranscriptChunk(chunk) {
   const out = {
@@ -385,6 +567,62 @@ function parseGrokUpdates(chunk) {
   }
   return out;
 }
+
+// packages/core/src/adapters/opencode/db.ts
+var ocModel = (d) => {
+  if (typeof d.model === "string")
+    return d.model;
+  if (d.model && typeof d.model === "object" && typeof d.model.id === "string")
+    return d.model.id;
+  return typeof d.modelID === "string" ? d.modelID : null;
+};
+var ocTs = (t, fallbackMs) => {
+  if (typeof t === "number")
+    return new Date(t).toISOString();
+  if (typeof t === "string" && !Number.isNaN(Date.parse(t)))
+    return new Date(t).toISOString();
+  return new Date(fallbackMs).toISOString();
+};
+function opencodeTurn(sessionId, msgId, data, fallbackMs = 0, sidechain = false) {
+  let d;
+  try {
+    d = JSON.parse(data);
+  } catch {
+    return null;
+  }
+  if ((d.type ?? d.role) !== "assistant")
+    return null;
+  const t = d.tokens ?? {};
+  let text = "";
+  const tools = [];
+  for (const p of Array.isArray(d.content) ? d.content : []) {
+    if (p?.type === "text" && typeof p.text === "string" && text.length < 400)
+      text = `${text}${p.text}`.slice(0, 400);
+    else if (p?.type === "tool") {
+      const name = p.tool ?? p.name;
+      if (name)
+        tools.push(name);
+    }
+  }
+  return {
+    id: `${sessionId}-${msgId}`,
+    ts: ocTs(d.time?.created, fallbackMs),
+    model: ocModel(d) ?? "opencode",
+    usage: {
+      input: t.input ?? 0,
+      output: t.output ?? 0,
+      cacheWrite: t.cache?.write ?? 0,
+      cacheWrite1h: 0,
+      cacheRead: t.cache?.read ?? 0,
+      thinking: t.reasoning ?? 0
+    },
+    text,
+    tools,
+    effort: null,
+    sidechain,
+    cost: typeof d.cost === "number" && d.cost > 0 ? d.cost : null
+  };
+}
 // packages/core/src/adapters/claude-code/hooks.ts
 var HOOK_EVENTS = [
   "SessionStart",
@@ -491,6 +729,38 @@ function normalizeHook(event, raw, projectId, ts = new Date().toISOString()) {
     payload.prompt = raw.prompt;
   return { ts, type, projectId, sessionId: raw.session_id ?? null, payload, raw };
 }
+// packages/core/src/art.ts
+var ROBOT = [
+  "       g       g       ",
+  "       X       X       ",
+  "       X       X       ",
+  "     ddddddddddddd     ",
+  "     dXXXXXXXXXXXd     ",
+  "     dggXXXXXXXXXd     ",
+  "   dddXXddXXXddXXddd   ",
+  "   dddXXddXXXddXXddd   ",
+  "   dddXXXXXXXXXXXddd   ",
+  "   dddXXdddddddXXddd   ",
+  "     dXXXXXXXXXXXd     ",
+  "     dXXXXXXXXXXXd     ",
+  "     ddddddddddddd     ",
+  "          XXX          ",
+  "         ddddd         ",
+  "      ddddddddddd      ",
+  "   dXXdggXXXXXXXdXXd   ",
+  "   dXXdXggggXddddXXd   ",
+  "   dXXdXggggXXXXdXXd   ",
+  "   dXXdXXXXXXddddXXd   ",
+  "   dXXdXXXXXXXXXdXXd   ",
+  "   dXXdXdddXXXXXdXXd   ",
+  "   ddddXXXXXXXXXdddd   ",
+  "      ddddddddddd      ",
+  "        XX   XX        ",
+  "        XX   XX        ",
+  "       XXXX XXXX       ",
+  "       dddd dddd       "
+];
+var ROBOT_HEAD = ROBOT.slice(0, 13);
 // packages/core/src/audit.ts
 var AUDIT_TYPES = new Set([
   "session.started",
@@ -636,8 +906,8 @@ function sinceToIso(since, now = Date.now()) {
   const m = /^(\d+)([dhm])$/.exec(since.trim());
   if (m) {
     const n = Number(m[1]);
-    const ms = m[2] === "d" ? 86400000 : m[2] === "h" ? 3600000 : 60000;
-    return new Date(now - n * ms).toISOString();
+    const ms2 = m[2] === "d" ? 86400000 : m[2] === "h" ? 3600000 : 60000;
+    return new Date(now - n * ms2).toISOString();
   }
   const t = Date.parse(since);
   return Number.isNaN(t) ? null : new Date(t).toISOString();
@@ -796,6 +1066,9 @@ var DEFAULT_CONFIG = {
   gates: { required: [], auto: "session-end", defs: {} },
   workflows: {},
   budget: { daily: null, weekly: null, warn_at: 0.8, on_exceed: "warn" },
+  models: { allow: [] },
+  notify: { webhook: null },
+  team: { url: null, forward: ["ledger", "cost"], interval: 5 },
   events: { retain_days: 30 },
   audit: { retain_days: 0 },
   privacy: DEFAULT_PRIVACY,
@@ -891,6 +1164,26 @@ function validate(c) {
       on_exceed: b.on_exceed === "ask" || b.on_exceed === "stop" ? b.on_exceed : "warn"
     },
     workflows: parseWorkflows(c.workflows),
+    notify: {
+      webhook: (() => {
+        const w = c.notify?.webhook;
+        return typeof w === "string" && /^https?:\/\//.test(w.trim()) ? w.trim() : null;
+      })()
+    },
+    models: {
+      allow: Array.isArray(c.models?.allow) ? c.models.allow.filter((m) => typeof m === "string" && m.trim() !== "") : []
+    },
+    team: (() => {
+      const t = c.team ?? {};
+      const url = typeof t.url === "string" && /^https?:\/\//.test(t.url.trim()) ? t.url.trim().replace(/\/+$/, "") : null;
+      const iv = Number(t.interval);
+      const KINDS = ["ledger", "cost", "transcripts"];
+      return {
+        url,
+        forward: Array.isArray(t.forward) ? t.forward.filter((k) => typeof k === "string" && KINDS.includes(k)) : ["ledger", "cost"],
+        interval: Number.isFinite(iv) && iv >= 1 && iv <= 300 ? Math.round(iv) : 5
+      };
+    })(),
     events: {
       retain_days: days(c.events?.retain_days, 30)
     },
@@ -1008,6 +1301,238 @@ function loadConfigDetailed(opts = {}) {
 function loadConfig(opts = {}) {
   return loadConfigDetailed(opts).config;
 }
+// packages/core/src/context.ts
+var CHARS_PER_TOKEN = 4;
+var estTokens = (chars) => Math.round(chars / CHARS_PER_TOKEN);
+var CONTEXT_DEFAULTS = { worstLimit: 5, toolLimit: 12 };
+function rereadWaste(reads) {
+  const byPath = new Map;
+  for (const r of reads) {
+    const hit = byPath.get(r.path);
+    if (hit) {
+      hit.reads++;
+      hit.chars += r.chars;
+    } else {
+      byPath.set(r.path, { reads: 1, chars: r.chars, first: r.chars });
+    }
+  }
+  const out = [];
+  for (const [path, v] of byPath) {
+    if (v.reads < 2)
+      continue;
+    out.push({ path, reads: v.reads, chars: v.chars, wastedChars: v.chars - v.first });
+  }
+  return out.sort((a, b) => b.wastedChars - a.wastedChars || a.path.localeCompare(b.path));
+}
+function contextReport(results, reads, turns, opts = {}) {
+  const o = { ...CONTEXT_DEFAULTS, ...opts };
+  const ids = new Set;
+  for (const r of results)
+    ids.add(r.sessionId);
+  for (const r of reads)
+    ids.add(r.sessionId);
+  for (const t of turns)
+    ids.add(t.sessionId);
+  const readsBySession = new Map;
+  for (const r of reads) {
+    const list = readsBySession.get(r.sessionId);
+    if (list)
+      list.push(r);
+    else
+      readsBySession.set(r.sessionId, [r]);
+  }
+  const charsBySession = new Map;
+  for (const r of results)
+    charsBySession.set(r.sessionId, (charsBySession.get(r.sessionId) ?? 0) + r.chars);
+  const tokensBySession = new Map;
+  for (const t of turns) {
+    const hit = tokensBySession.get(t.sessionId);
+    if (hit) {
+      hit.input += t.input;
+      hit.cacheRead += t.cacheRead;
+      hit.cacheWrite += t.cacheWrite;
+      hit.thinking += t.thinking;
+      hit.output += t.output;
+    } else
+      tokensBySession.set(t.sessionId, { ...t });
+  }
+  const sessions = [];
+  for (const sessionId of ids) {
+    const worstAll = rereadWaste(readsBySession.get(sessionId) ?? []);
+    const wastedChars2 = worstAll.reduce((a, w) => a + w.wastedChars, 0);
+    const toolChars2 = charsBySession.get(sessionId) ?? 0;
+    const tk = tokensBySession.get(sessionId);
+    const cacheable = (tk?.cacheRead ?? 0) + (tk?.input ?? 0);
+    sessions.push({
+      sessionId,
+      toolChars: toolChars2,
+      toolTokens: estTokens(toolChars2),
+      thinking: tk?.thinking ?? 0,
+      cacheRead: tk?.cacheRead ?? 0,
+      input: tk?.input ?? 0,
+      cacheHit: cacheable ? (tk?.cacheRead ?? 0) / cacheable : 0,
+      reads: (readsBySession.get(sessionId) ?? []).length,
+      rereadFiles: worstAll.length,
+      wastedChars: wastedChars2,
+      wasteShare: toolChars2 ? wastedChars2 / toolChars2 : 0,
+      worst: worstAll.slice(0, o.worstLimit)
+    });
+  }
+  sessions.sort((a, b) => b.wastedChars - a.wastedChars || b.toolChars - a.toolChars);
+  const byToolMap = new Map;
+  for (const r of results) {
+    const hit = byToolMap.get(r.tool);
+    if (hit) {
+      hit.calls++;
+      hit.chars += r.chars;
+    } else
+      byToolMap.set(r.tool, { tool: r.tool, calls: 1, chars: r.chars, tokens: 0 });
+  }
+  const byTool = [...byToolMap.values()].map((t) => ({ ...t, tokens: estTokens(t.chars) })).sort((a, b) => b.chars - a.chars || a.tool.localeCompare(b.tool)).slice(0, o.toolLimit);
+  const toolChars = sessions.reduce((a, s) => a + s.toolChars, 0);
+  const wastedChars = sessions.reduce((a, s) => a + s.wastedChars, 0);
+  const cacheRead = sessions.reduce((a, s) => a + s.cacheRead, 0);
+  const input = sessions.reduce((a, s) => a + s.input, 0);
+  return {
+    sessions,
+    byTool,
+    totals: {
+      sessions: sessions.length,
+      toolChars,
+      toolTokens: estTokens(toolChars),
+      wastedChars,
+      wastedTokens: estTokens(wastedChars),
+      wasteShare: toolChars ? wastedChars / toolChars : 0,
+      rereadFiles: sessions.reduce((a, s) => a + s.rereadFiles, 0),
+      cacheHit: cacheRead + input ? cacheRead / (cacheRead + input) : 0
+    }
+  };
+}
+// packages/core/src/dag.ts
+var DAG_DEFAULTS = { dx: 190, dy: 34, passes: 2 };
+var edgeKey = (from, to) => JSON.stringify([from, to]);
+function findBackEdges(nodes, edges) {
+  const ids = nodes.map((n) => n.id);
+  const known = new Set(ids);
+  const out = new Map;
+  for (const id of ids)
+    out.set(id, []);
+  for (const e of edges)
+    if (known.has(e.from) && known.has(e.to) && e.from !== e.to)
+      out.get(e.from)?.push(e.to);
+  for (const [, list] of out)
+    list.sort();
+  const back = new Set;
+  const state = new Map;
+  const visit = (start) => {
+    const stack = [{ id: start, i: 0 }];
+    state.set(start, 1);
+    while (stack.length) {
+      const top = stack[stack.length - 1];
+      const next = out.get(top.id) ?? [];
+      if (top.i >= next.length) {
+        state.set(top.id, 2);
+        stack.pop();
+        continue;
+      }
+      const to = next[top.i++];
+      const st = state.get(to) ?? 0;
+      if (st === 1)
+        back.add(edgeKey(top.id, to));
+      else if (st === 0) {
+        state.set(to, 1);
+        stack.push({ id: to, i: 0 });
+      }
+    }
+  };
+  for (const id of [...ids].sort())
+    if ((state.get(id) ?? 0) === 0)
+      visit(id);
+  return back;
+}
+function assignLayers(nodes, forward) {
+  const layer = new Map;
+  const parents = new Map;
+  for (const n of nodes)
+    parents.set(n.id, []);
+  for (const e of forward)
+    parents.get(e.to)?.push(e.from);
+  const resolving = new Set;
+  const depth = (id) => {
+    const fixed = nodes.find((n) => n.id === id)?.layer;
+    if (typeof fixed === "number") {
+      layer.set(id, fixed);
+      return fixed;
+    }
+    const hit = layer.get(id);
+    if (hit !== undefined)
+      return hit;
+    if (resolving.has(id))
+      return 0;
+    resolving.add(id);
+    const ps = parents.get(id) ?? [];
+    const d = ps.length ? Math.max(...ps.map((p) => depth(p) + 1)) : 0;
+    resolving.delete(id);
+    layer.set(id, d);
+    return d;
+  };
+  for (const n of [...nodes].sort((a, b) => a.id.localeCompare(b.id)))
+    depth(n.id);
+  return layer;
+}
+function layoutDag(nodes, edges, opts = {}) {
+  const o = { ...DAG_DEFAULTS, ...opts };
+  if (!nodes.length)
+    return { nodes: [], edges: [], width: 0, height: 0, layers: 0 };
+  const known = new Set(nodes.map((n) => n.id));
+  const clean = edges.filter((e) => known.has(e.from) && known.has(e.to) && e.from !== e.to);
+  const back = findBackEdges(nodes, clean);
+  const isBack = (e) => back.has(edgeKey(e.from, e.to));
+  const forward = clean.filter((e) => !isBack(e));
+  const layerOf = assignLayers(nodes, forward);
+  const maxLayer = Math.max(0, ...nodes.map((n) => layerOf.get(n.id) ?? 0));
+  const groups = Array.from({ length: maxLayer + 1 }, () => []);
+  for (const n of [...nodes].sort((a, b) => {
+    const sa = o.seed?.[a.id] ?? Number.POSITIVE_INFINITY;
+    const sb = o.seed?.[b.id] ?? Number.POSITIVE_INFINITY;
+    return sa - sb || a.id.localeCompare(b.id);
+  }))
+    groups[layerOf.get(n.id) ?? 0].push(n.id);
+  const parentsOf = new Map;
+  for (const n of nodes)
+    parentsOf.set(n.id, []);
+  for (const e of forward)
+    parentsOf.get(e.to)?.push(e.from);
+  for (let pass = 0;pass < o.passes; pass++) {
+    for (let l = 1;l <= maxLayer; l++) {
+      const prev = groups[l - 1];
+      const idx = new Map(prev.map((id, i) => [id, i]));
+      const group = groups[l];
+      const bary = new Map;
+      for (const id of group) {
+        const ps = (parentsOf.get(id) ?? []).map((p) => idx.get(p)).filter((v) => v !== undefined);
+        bary.set(id, ps.length ? ps.reduce((a, b) => a + b, 0) / ps.length : group.indexOf(id));
+      }
+      group.sort((a, b) => bary.get(a) - bary.get(b) || a.localeCompare(b));
+    }
+  }
+  const widest = Math.max(1, ...groups.map((g) => g.length));
+  const placed = [];
+  groups.forEach((group, l) => {
+    const offset = (widest - group.length) * o.dy / 2;
+    group.forEach((id, i) => {
+      placed.push({ id, layer: l, order: i, x: l * o.dx, y: offset + i * o.dy });
+    });
+  });
+  placed.sort((a, b) => a.layer - b.layer || a.order - b.order);
+  return {
+    nodes: placed,
+    edges: clean.map((e) => ({ ...e, back: isBack(e) })),
+    width: maxLayer * o.dx,
+    height: Math.max(0, (widest - 1) * o.dy),
+    layers: maxLayer + 1
+  };
+}
 // packages/core/src/dispatch.ts
 function planDispatch(tasks, wanted, opts) {
   const byId = new Map(tasks.map((t) => [t.id, t]));
@@ -1443,6 +1968,83 @@ ${shown.map((f) => `- \`${f.path}\`${f.added >= 0 ? ` +${f.added} \u2212${f.dele
   return { title, body: b.join(`
 `) };
 }
+// packages/core/src/gatehealth.ts
+var ms2 = (iso) => new Date(iso).getTime();
+function percentile(xs, p) {
+  if (!xs.length)
+    return null;
+  const s = [...xs].sort((a, b) => a - b);
+  const rank = Math.max(1, Math.ceil(p / 100 * s.length));
+  return s[Math.min(s.length, rank) - 1];
+}
+var GATE_HEALTH_DEFAULTS = { historyLimit: 20 };
+function gateHealth(samples, opts = {}) {
+  const o = { ...GATE_HEALTH_DEFAULTS, ...opts };
+  const byGate = new Map;
+  for (const r of samples) {
+    const list = byGate.get(r.gate);
+    if (list)
+      list.push(r);
+    else
+      byGate.set(r.gate, [r]);
+  }
+  const gates = [];
+  for (const [gate, runsUnsorted] of byGate) {
+    const runs = [...runsUnsorted].sort((a, b) => ms2(a.at) - ms2(b.at));
+    const passes = runs.filter((r) => r.verdict === "pass").length;
+    const byTask = new Map;
+    for (const r of runs) {
+      const key = `${r.projectId ?? ""}\x00${r.task}`;
+      const list = byTask.get(key);
+      if (list)
+        list.push(r);
+      else
+        byTask.set(key, [r]);
+    }
+    let flips = 0;
+    let flakyTasks = 0;
+    for (const list of byTask.values()) {
+      let changed = 0;
+      for (let i = 1;i < list.length; i++)
+        if (list[i].verdict !== list[i - 1].verdict)
+          changed++;
+      flips += changed;
+      if (list.some((r) => r.verdict === "pass") && list.some((r) => r.verdict === "fail"))
+        flakyTasks++;
+    }
+    const timed = runs.map((r) => r.durationMs).filter((d) => typeof d === "number");
+    const last = runs.at(-1);
+    gates.push({
+      gate,
+      runs: runs.length,
+      passes,
+      fails: runs.length - passes,
+      passRate: passes / runs.length,
+      flips,
+      flakyTasks,
+      flaky: flakyTasks > 0,
+      p50Ms: percentile(timed, 50),
+      p95Ms: percentile(timed, 95),
+      maxMs: timed.length ? Math.max(...timed) : null,
+      totalMs: timed.reduce((a, b) => a + b, 0),
+      timedRuns: timed.length,
+      lastVerdict: last?.verdict ?? null,
+      lastAt: last?.at ?? null,
+      history: runs.slice(-o.historyLimit).reverse().map((r) => ({ verdict: r.verdict, at: r.at, task: r.task, durationMs: r.durationMs }))
+    });
+  }
+  gates.sort((a, b) => Number(b.flaky) - Number(a.flaky) || b.flakyTasks - a.flakyTasks || b.totalMs - a.totalMs);
+  return {
+    gates,
+    totals: {
+      gates: gates.length,
+      runs: samples.length,
+      fails: gates.reduce((a, g) => a + g.fails, 0),
+      flakyGates: gates.filter((g) => g.flaky).length,
+      totalMs: gates.reduce((a, g) => a + g.totalMs, 0)
+    }
+  };
+}
 // packages/core/src/gates.ts
 var NAME_RE2 = /^[a-z0-9][a-z0-9_.-]{0,39}$/i;
 function validateGateRun(input) {
@@ -1502,7 +2104,196 @@ function executedGateInput(task, gate, cmd, outcome) {
     gate,
     verdict: outcome.exitCode === 0 && !outcome.timedOut ? "pass" : "fail",
     rubric: `ran \`${cmd}\` \u2014 ${how} in ${(outcome.durationMs / 1000).toFixed(1)}s`,
-    evidence: evidenceTail(outcome.output) || null
+    evidence: evidenceTail(outcome.output) || null,
+    durationMs: outcome.durationMs
+  };
+}
+// packages/core/src/graphs.ts
+function collisionGraph(rows, writeTools = WRITE_TOOLS) {
+  const files = new Map;
+  const sessions = new Map;
+  for (const r of rows) {
+    if (!r.path || !r.sessionId)
+      continue;
+    const f = files.get(r.path) ?? { readers: new Set, writers: new Set };
+    const s = sessions.get(r.sessionId) ?? { files: new Set, writes: 0 };
+    if (writeTools.has(r.tool)) {
+      f.writers.add(r.sessionId);
+      s.writes++;
+    } else
+      f.readers.add(r.sessionId);
+    s.files.add(r.path);
+    files.set(r.path, f);
+    sessions.set(r.sessionId, s);
+  }
+  const out = [...files.entries()].map(([path, f]) => {
+    const writers = [...f.writers].sort();
+    const readers = [...f.readers].filter((id) => !f.writers.has(id)).sort();
+    const touchers = writers.length + readers.length;
+    return { path, readers, writers, contested: touchers >= 2 && writers.length >= 1 };
+  });
+  out.sort((a, b) => Number(b.contested) - Number(a.contested) || b.readers.length + b.writers.length - (a.readers.length + a.writers.length) || a.path.localeCompare(b.path));
+  return {
+    sessions: [...sessions.entries()].map(([id, s]) => ({
+      id,
+      files: s.files.size,
+      writes: s.writes
+    })),
+    files: out,
+    contested: out.filter((f) => f.contested).length
+  };
+}
+// packages/core/src/worktree.ts
+import { join as join3 } from "path";
+function planBootstrap(cfg, repoRoot, worktree) {
+  const seen = new Set;
+  const copies = [];
+  for (const raw of cfg.worktree.copy) {
+    if (!isRepoRelative(raw))
+      continue;
+    const rel = raw.trim().replace(/^\.\//, "");
+    if (seen.has(rel))
+      continue;
+    seen.add(rel);
+    copies.push({ rel, from: join3(repoRoot, rel), to: join3(worktree, rel) });
+  }
+  return { copies, setup: cfg.worktree.setup };
+}
+var needsBootstrap = (plan) => plan.copies.length > 0 || plan.setup !== null;
+function summarizeBootstrap(o) {
+  const parts = [];
+  if (o.copied.length)
+    parts.push(`copied ${o.copied.join(", ")}`);
+  if (o.skipped.length)
+    parts.push(`skipped ${o.skipped.join(", ")} (missing)`);
+  if (o.setup)
+    parts.push(`${o.setup.command} \u2192 ${o.setup.exitCode === 0 ? "ok" : `exit ${o.setup.exitCode}`} in ${(o.setup.durationMs / 1000).toFixed(1)}s`);
+  return parts.join("; ") || "nothing to do";
+}
+function canRemoveWorktree(w, heldByClaim, force) {
+  if (w.main)
+    return { ok: false, reason: "main" };
+  if (heldByClaim)
+    return { ok: false, reason: "held" };
+  if (force)
+    return { ok: true };
+  if (w.dirty > 0)
+    return { ok: false, reason: "dirty" };
+  if (w.ahead > 0)
+    return { ok: false, reason: "unpushed" };
+  return { ok: true };
+}
+function removeRefusalMessage(reason, path, task) {
+  switch (reason) {
+    case "main":
+      return `${path} is the main checkout \u2014 it is never removed`;
+    case "held":
+      return `${path} is held by claim ${task ?? "?"} \u2014 release the claim instead`;
+    case "dirty":
+      return `${path} has uncommitted changes \u2014 commit or stash them, or --force to discard`;
+    case "unpushed":
+      return `${path} has unpushed commits \u2014 push them, or --force to discard`;
+  }
+}
+function planGc(worktrees, claims) {
+  const held = new Map(claims.filter((c) => c.state === "held").map((c) => [c.worktree, c.task]));
+  const stale = new Set(claims.filter((c) => c.state !== "held").map((c) => c.worktree));
+  const out = [];
+  for (const w of worktrees) {
+    if (w.main || held.has(w.path))
+      continue;
+    const why = w.merged ? "merged" : stale.has(w.path) ? "released-claim" : null;
+    if (!why)
+      continue;
+    const can = canRemoveWorktree(w, null, false);
+    out.push({
+      path: w.path,
+      branch: w.branch,
+      why,
+      removable: can.ok,
+      blocker: can.ok ? null : can.reason
+    });
+  }
+  return out;
+}
+
+// packages/core/src/hygiene.ts
+var HYGIENE_DEFAULTS = {
+  staleDays: 7,
+  abandonedDays: 30,
+  hungryRssKb: 1024 * 1024,
+  heavyKb: 2 * 1024 * 1024
+};
+var days2 = (ms3) => ms3 / 86400000;
+function classifyProcess(p, opts = {}) {
+  const o = { ...HYGIENE_DEFAULTS, ...opts };
+  if (!p.alive)
+    return {
+      ...p,
+      issue: "dead",
+      note: `pid ${p.pid} is gone but the registry still lists it${p.port ? ` holding port ${p.port}` : ""}`,
+      reclaimable: true
+    };
+  if (p.sessionId && !p.sessionLive)
+    return {
+      ...p,
+      issue: "orphaned",
+      note: `still running after its session ended${p.port ? ` \u2014 port ${p.port} stays taken` : ""}`,
+      reclaimable: true
+    };
+  if (p.rssKb !== null && p.rssKb >= o.hungryRssKb)
+    return {
+      ...p,
+      issue: "hungry",
+      note: `holding ${Math.round(p.rssKb / 1024)} MB of RSS`,
+      reclaimable: false
+    };
+  return { ...p, issue: null, note: null, reclaimable: false };
+}
+function classifyWorktree(w, opts = {}) {
+  const o = { ...HYGIENE_DEFAULTS, ...opts };
+  const kb = w.diskKb ?? 0;
+  const done = (issue, note, reclaimable) => ({
+    ...w,
+    issue,
+    note,
+    reclaimable,
+    reclaimableKb: reclaimable ? kb : 0
+  });
+  if (w.main)
+    return done(null, null, false);
+  const removable = canRemoveWorktree(w, w.heldByClaim, false).ok;
+  const inUse = w.liveSessions > 0 || w.heldByClaim !== null;
+  const unsafe = w.dirty > 0 || w.ahead > 0;
+  const idleDays = w.idleMs === null ? null : days2(w.idleMs);
+  if (w.merged && !inUse && removable && idleDays !== null && idleDays >= o.staleDays)
+    return done("stale", `merged and untouched for ${Math.floor(idleDays)} days${kb ? ` \u2014 ${Math.round(kb / 1024)} MB to reclaim` : ""}`, true);
+  if (!w.merged && !inUse && idleDays !== null && idleDays >= o.abandonedDays)
+    return done("abandoned", unsafe ? `untouched for ${Math.floor(idleDays)} days with ${w.dirty > 0 ? "uncommitted" : "unpushed"} work \u2014 review before removing` : `untouched for ${Math.floor(idleDays)} days and never merged`, false);
+  if (kb >= o.heavyKb)
+    return done("heavy", `${Math.round(kb / 1024)} MB on disk`, false);
+  return done(null, null, false);
+}
+function hygieneReport(procs, worktrees, opts = {}) {
+  const processes = procs.map((p) => classifyProcess(p, opts));
+  const trees = worktrees.map((w) => classifyWorktree(w, opts));
+  const issues = processes.filter((p) => p.issue).length + trees.filter((w) => w.issue).length;
+  const rank = (i) => i ? 0 : 1;
+  processes.sort((a, b) => rank(a.issue) - rank(b.issue) || (b.rssKb ?? 0) - (a.rssKb ?? 0));
+  trees.sort((a, b) => rank(a.issue) - rank(b.issue) || (b.diskKb ?? 0) - (a.diskKb ?? 0));
+  return {
+    processes,
+    worktrees: trees,
+    totals: {
+      processes: processes.length,
+      deadProcesses: processes.filter((p) => p.issue === "dead").length,
+      orphanedProcesses: processes.filter((p) => p.issue === "orphaned").length,
+      worktrees: trees.length,
+      staleWorktrees: trees.filter((w) => w.issue === "stale").length,
+      diskKb: trees.reduce((a, w) => a + (w.diskKb ?? 0), 0),
+      reclaimableKb: trees.reduce((a, w) => a + w.reclaimableKb, 0),
+      issues
+    }
   };
 }
 // packages/core/src/ledger.ts
@@ -1712,6 +2503,250 @@ function incidentKey(inc) {
     return `protected_ports:${portsIn(inc.command).join(",")}`;
   return inc.rule;
 }
+// packages/core/src/lineage.ts
+var LINEAGE_MAX_NODES = 40;
+var LINEAGE_FANOUT = 4;
+var groupId = (parent, kind) => `group:${parent}:${kind}`;
+function collapseFanout(sessions, edges, fanout, expanded) {
+  const fans = new Map;
+  for (const e of edges) {
+    const k = groupId(e.from, e.kind);
+    const list = fans.get(k) ?? [];
+    list.push(e);
+    fans.set(k, list);
+  }
+  const collapse = [...fans.entries()].filter(([id, list]) => list.length > fanout && !expanded.has(id));
+  if (!collapse.length)
+    return { sessions, edges, sizes: new Map };
+  const hidden = new Set;
+  const dropped = new Set;
+  const extraSessions = [];
+  const extraEdges = [];
+  const sizes = new Map;
+  for (const [id, list] of collapse) {
+    const first = list[0];
+    const parent = sessions.find((x) => x.id === first.from);
+    sizes.set(id, list.length);
+    for (const e of list) {
+      dropped.add(e);
+      hidden.add(e.to);
+    }
+    extraSessions.push({
+      id,
+      projectId: parent?.projectId ?? null,
+      title: `${list.length} ${first.kind}${list.length === 1 ? "" : "s"}`,
+      agent: parent?.agent ?? null,
+      kind: "group",
+      state: "ended",
+      startedAt: first.at,
+      endedAt: null,
+      costUsd: null,
+      outcome: null
+    });
+    extraEdges.push({ from: first.from, to: id, kind: first.kind, at: first.at });
+  }
+  const stillLinked = new Set;
+  for (const e of edges) {
+    if (dropped.has(e))
+      continue;
+    stillLinked.add(e.from);
+    stillLinked.add(e.to);
+  }
+  const keptSessions = sessions.filter((x) => !hidden.has(x.id) || stillLinked.has(x.id));
+  const keptEdges = edges.filter((e) => !dropped.has(e));
+  return {
+    sessions: [...keptSessions, ...extraSessions],
+    edges: [...keptEdges, ...extraEdges],
+    sizes
+  };
+}
+function handoffEdges(holds) {
+  const byTask = new Map;
+  for (const h of holds) {
+    if (!h.sessionId)
+      continue;
+    const key = `${h.projectId ?? ""}\x00${h.task}`;
+    const list = byTask.get(key) ?? [];
+    list.push({ sessionId: h.sessionId, at: h.at, task: h.task });
+    byTask.set(key, list);
+  }
+  const out = [];
+  for (const list of byTask.values()) {
+    list.sort((a, b) => new Date(a.at).getTime() - new Date(b.at).getTime());
+    for (let i = 1;i < list.length; i++) {
+      const prev = list[i - 1];
+      const cur = list[i];
+      if (prev.sessionId === cur.sessionId)
+        continue;
+      out.push({
+        from: prev.sessionId,
+        to: cur.sessionId,
+        kind: "handoff",
+        at: cur.at,
+        label: cur.task
+      });
+    }
+  }
+  return out;
+}
+function lineageGraph(sessions, edges, opts = {}) {
+  const maxNodes = opts.maxNodes ?? LINEAGE_MAX_NODES;
+  const known = new Map(sessions.map((s) => [s.id, s]));
+  const seen = new Set;
+  const usable = [];
+  for (const e of edges) {
+    if (!known.has(e.from) || !known.has(e.to) || e.from === e.to)
+      continue;
+    const key = JSON.stringify([e.from, e.to, e.kind]);
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    usable.push(e);
+  }
+  const collapsed = collapseFanout(sessions, usable, opts.fanout ?? LINEAGE_FANOUT, new Set(opts.expanded ?? []));
+  const shownSessions = collapsed.sessions;
+  const shownEdges = collapsed.edges;
+  const groupSizes = collapsed.sizes;
+  const byId = new Map(shownSessions.map((x) => [x.id, x]));
+  const involved = new Set;
+  for (const e of shownEdges) {
+    involved.add(e.from);
+    involved.add(e.to);
+  }
+  const all = shownSessions.filter((s) => involved.has(s.id));
+  const deg0 = new Map;
+  for (const e of shownEdges) {
+    deg0.set(e.from, (deg0.get(e.from) ?? 0) + 1);
+    deg0.set(e.to, (deg0.get(e.to) ?? 0) + 1);
+  }
+  const nodes = all.length <= maxNodes ? all : [...all].sort((a, b) => (deg0.get(b.id) ?? 0) - (deg0.get(a.id) ?? 0) || a.id.localeCompare(b.id)).slice(0, maxNodes);
+  const truncated = all.length - nodes.length;
+  if (!nodes.length)
+    return {
+      nodes: [],
+      edges: [],
+      width: 0,
+      height: 0,
+      roots: 0,
+      byKind: { subagent: 0, dispatch: 0, message: 0, handoff: 0 },
+      truncated: 0
+    };
+  const kept = new Set(nodes.map((s) => s.id));
+  const shown = shownEdges.filter((e) => kept.has(e.from) && kept.has(e.to));
+  const layout = layoutDag(nodes.map((s) => ({ id: s.id })), shown.map((e) => ({ from: e.from, to: e.to })), opts);
+  const degree = new Map;
+  for (const e of shown) {
+    degree.set(e.from, (degree.get(e.from) ?? 0) + 1);
+    degree.set(e.to, (degree.get(e.to) ?? 0) + 1);
+  }
+  const backSet = new Set(layout.edges.filter((e) => e.back).map((e) => JSON.stringify([e.from, e.to])));
+  const byKind = {
+    subagent: 0,
+    dispatch: 0,
+    message: 0,
+    handoff: 0
+  };
+  for (const e of shown)
+    byKind[e.kind]++;
+  return {
+    nodes: layout.nodes.map((p) => {
+      const s = byId.get(p.id);
+      const size = groupSizes.get(p.id) ?? null;
+      const parts = size ? p.id.split(":") : null;
+      return {
+        ...s,
+        layer: p.layer,
+        order: p.order,
+        x: p.x,
+        y: p.y,
+        degree: degree.get(p.id) ?? 0,
+        groupSize: size,
+        groupOf: parts ? parts.slice(1, -1).join(":") ?? null : null,
+        groupKind: parts ? parts.at(-1) ?? null : null
+      };
+    }),
+    edges: shown.map((e) => ({ ...e, back: backSet.has(JSON.stringify([e.from, e.to])) })),
+    width: layout.width,
+    height: layout.height,
+    roots: layout.nodes.filter((p) => p.layer === 0).length,
+    byKind,
+    truncated
+  };
+}
+// packages/core/src/mcphealth.ts
+var BUILTIN = "builtin";
+var MCP_HEALTH_DEFAULTS = { toolLimit: 6 };
+function serverOf(tool) {
+  const m = /^mcp__([^_]+(?:_[^_]+)*?)__/.exec(tool);
+  return m?.[1] ?? BUILTIN;
+}
+function toolOf(tool) {
+  return tool.replace(/^mcp__[^_]+(?:_[^_]+)*?__/, "");
+}
+var stat = (tool, calls) => {
+  const timed = calls.map((c) => c.ms).filter((m) => typeof m === "number");
+  return {
+    tool,
+    calls: calls.length,
+    errors: calls.filter((c) => c.errored).length,
+    p50Ms: percentile(timed, 50),
+    p95Ms: percentile(timed, 95),
+    maxMs: timed.length ? Math.max(...timed) : null,
+    totalMs: timed.reduce((a, b) => a + b, 0)
+  };
+};
+function mcpHealth(calls, opts = {}) {
+  const o = { ...MCP_HEALTH_DEFAULTS, ...opts };
+  const byServer = new Map;
+  for (const c of calls) {
+    const s = serverOf(c.tool);
+    const list = byServer.get(s);
+    if (list)
+      list.push(c);
+    else
+      byServer.set(s, [c]);
+  }
+  const servers = [];
+  for (const [server, list] of byServer) {
+    const byTool = new Map;
+    for (const c of list) {
+      const t = toolOf(c.tool);
+      const tl = byTool.get(t);
+      if (tl)
+        tl.push(c);
+      else
+        byTool.set(t, [c]);
+    }
+    const tools = [...byTool.entries()].map(([t, cs]) => stat(t, cs)).sort((a, b) => b.calls - a.calls || a.tool.localeCompare(b.tool)).slice(0, o.toolLimit);
+    const all = stat(server, list);
+    servers.push({
+      server,
+      mcp: server !== BUILTIN,
+      calls: all.calls,
+      errors: all.errors,
+      errorRate: all.calls ? all.errors / all.calls : 0,
+      unanswered: list.filter((c) => c.ms === null).length,
+      sessions: new Set(list.map((c) => c.sessionId)).size,
+      p50Ms: all.p50Ms,
+      p95Ms: all.p95Ms,
+      maxMs: all.maxMs,
+      totalMs: all.totalMs,
+      tools,
+      lastAt: list.map((c) => c.at).sort().at(-1) ?? null
+    });
+  }
+  servers.sort((a, b) => Number(b.mcp) - Number(a.mcp) || b.totalMs - a.totalMs || b.calls - a.calls);
+  return {
+    servers,
+    totals: {
+      servers: servers.filter((s) => s.mcp).length,
+      calls: calls.length,
+      errors: servers.reduce((a, s) => a + s.errors, 0),
+      totalMs: servers.reduce((a, s) => a + s.totalMs, 0),
+      mcpMs: servers.filter((s) => s.mcp).reduce((a, s) => a + s.totalMs, 0)
+    }
+  };
+}
 // packages/core/src/memory.ts
 var MEMORY_KINDS = ["handoff", "incident", "gate", "session"];
 function handoffDoc(projectId, id, h, sessionId) {
@@ -1829,15 +2864,101 @@ function parseTo(to) {
     return { kind: "session", id: t };
   return { kind: "task", task: t };
 }
-function formatMessages(ms) {
-  if (!ms.length)
+function formatMessages(ms3) {
+  if (!ms3.length)
     return null;
-  const lines = ms.map((m) => `- from ${m.from ?? "unknown"}${m.task ? ` (re ${m.task})` : ""}: ${m.text}`);
-  return `[swarm] While you were working, message${ms.length === 1 ? "" : "s"} arrived:
+  const lines = ms3.map((m) => `- from ${m.from ?? "unknown"}${m.task ? ` (re ${m.task})` : ""}: ${m.text}`);
+  return `[swarm] While you were working, message${ms3.length === 1 ? "" : "s"} arrived:
 ${lines.join(`
 `)}
 Reply with swarm_send if a reply is expected.`;
 }
+// packages/core/src/outcomes.ts
+var DEFAULT_BRANCHES = new Set(["main", "master", "develop", "trunk"]);
+var median = (xs) => {
+  if (!xs.length)
+    return null;
+  const s = [...xs].sort((a, b) => a - b);
+  const mid = Math.floor(s.length / 2);
+  return s.length % 2 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
+};
+function scorecard(key, rows) {
+  const merged = rows.filter((r) => r.outcome === "merged");
+  const reverted = rows.filter((r) => r.outcome === "reverted");
+  const open = rows.filter((r) => r.outcome === "open");
+  const noPr = rows.filter((r) => r.outcome === "no-pr");
+  const finished = merged.length + reverted.length + noPr.length;
+  const mergedCost = merged.reduce((a, r) => a + r.costUsd, 0);
+  return {
+    key,
+    branches: rows.length,
+    merged: merged.length,
+    reverted: reverted.length,
+    open: open.length,
+    noPr: noPr.length,
+    mergeRate: finished ? merged.length / finished : null,
+    medianLeadHours: median(merged.map((r) => r.leadHours).filter((x) => x != null)),
+    costPerMerge: merged.length ? mergedCost / merged.length : null
+  };
+}
+function outcomeReport(sessions, prs, revertedShas) {
+  const byBranch = new Map;
+  for (const s of sessions) {
+    if (!s.branch || DEFAULT_BRANCHES.has(s.branch))
+      continue;
+    const a = byBranch.get(s.branch) ?? [];
+    a.push(s);
+    byBranch.set(s.branch, a);
+  }
+  const prByBranch = new Map;
+  for (const pr of prs) {
+    const prev = prByBranch.get(pr.branch);
+    if (!prev || pr.state === "merged" && prev.state !== "merged" || pr.state === prev.state && pr.number > prev.number)
+      prByBranch.set(pr.branch, pr);
+  }
+  const rows = [...byBranch.entries()].map(([branch, ss]) => {
+    const dominant = [...ss].sort((a, b) => (b.costUsd ?? 0) - (a.costUsd ?? 0) || a.startedAt.localeCompare(b.startedAt))[0];
+    const pr = prByBranch.get(branch) ?? null;
+    const wasReverted = (sha) => {
+      if (!sha)
+        return false;
+      const s = sha.toLowerCase();
+      for (const r of revertedShas)
+        if (s.startsWith(r) || r.startsWith(s))
+          return true;
+      return false;
+    };
+    const outcome = !pr ? "no-pr" : pr.state === "open" ? "open" : wasReverted(pr.mergeSha) ? "reverted" : "merged";
+    const firstStart = ss.map((s) => s.startedAt).sort()[0];
+    const leadHours = outcome === "merged" && pr?.mergedAt ? Math.max(0, (new Date(pr.mergedAt).getTime() - new Date(firstStart).getTime()) / 3600000) : null;
+    return {
+      branch,
+      outcome,
+      prNumber: pr?.number ?? null,
+      title: pr?.title ?? null,
+      url: pr?.url ?? null,
+      mergedAt: pr?.mergedAt ?? null,
+      leadHours,
+      sessions: ss.map((s) => s.id),
+      model: dominant.model,
+      agent: dominant.agent,
+      costUsd: ss.reduce((a, s) => a + (s.costUsd ?? 0), 0)
+    };
+  });
+  rows.sort((a, b) => (b.mergedAt ?? "").localeCompare(a.mergedAt ?? "") || a.branch.localeCompare(b.branch));
+  const group = (key) => {
+    const m = new Map;
+    for (const r of rows) {
+      const k = key(r) ?? "unknown";
+      m.set(k, [...m.get(k) ?? [], r]);
+    }
+    return [...m.entries()].map(([k, rs]) => scorecard(k, rs)).sort((a, b) => b.branches - a.branches);
+  };
+  return { branches: rows, byModel: group((r) => r.model), byAgent: group((r) => r.agent) };
+}
+function parseReverts(gitLog) {
+  return new Set([...gitLog.matchAll(/This reverts commit ([0-9a-f]{7,40})/gi)].map((m) => m[1].toLowerCase()));
+}
 // packages/core/src/policy.ts
 import { createHash } from "crypto";
 var HOOK_MARK = "swarm-hook";
@@ -2022,6 +3143,147 @@ function projectIdentity(opts) {
   const name = parts[parts.length - 1] ?? opts.root;
   return { id: `p_${fnv1a(key)}`, root: opts.root, commonDir: opts.commonDir, name };
 }
+// packages/core/src/provenance.ts
+var SEVERITY = {
+  "no-task": 0,
+  "open-pr": 1,
+  "no-pr": 2,
+  "no-branch": 3,
+  "no-session": 4,
+  unclaimed: 5,
+  complete: 6
+};
+var severity = (b) => SEVERITY[b ?? "complete"];
+function breakOf(l) {
+  if (!l.task)
+    return "no-task";
+  if (!l.claim)
+    return "unclaimed";
+  if (!l.session)
+    return "no-session";
+  if (!l.branch)
+    return "no-branch";
+  if (!l.pr)
+    return "no-pr";
+  if (!l.merged)
+    return "open-pr";
+  return null;
+}
+function provenance(tasks, claims, sessions, branches) {
+  const claimsByTask = new Map;
+  for (const c of claims) {
+    const list = claimsByTask.get(c.task);
+    if (list)
+      list.push(c);
+    else
+      claimsByTask.set(c.task, [c]);
+  }
+  const branchRow = new Map(branches.map((b) => [b.branch, b]));
+  const sessionsByBranch = new Map;
+  for (const s of sessions) {
+    if (!s.branch)
+      continue;
+    const list = sessionsByBranch.get(s.branch);
+    if (list)
+      list.push(s);
+    else
+      sessionsByBranch.set(s.branch, [s]);
+  }
+  const chains = [];
+  for (const t of tasks) {
+    const cs = (claimsByTask.get(t.id) ?? []).sort((a, b) => new Date(a.acquiredAt).getTime() - new Date(b.acquiredAt).getTime());
+    const branch = cs.map((c) => c.branch).find((b) => !!b) ?? null;
+    const worktree = cs.map((c) => c.worktree).find((w) => !!w) ?? null;
+    const row = branch ? branchRow.get(branch) : undefined;
+    const byId = new Map;
+    for (const s of branch ? sessionsByBranch.get(branch) ?? [] : [])
+      byId.set(s.id, s);
+    for (const c of cs) {
+      if (!c.sessionId || byId.has(c.sessionId))
+        continue;
+      const hit = sessions.find((s) => s.id === c.sessionId);
+      if (hit)
+        byId.set(hit.id, hit);
+    }
+    const sess = [...byId.values()];
+    const links = {
+      task: true,
+      claim: cs.length > 0,
+      session: sess.length > 0,
+      branch: !!branch,
+      pr: !!row?.prNumber,
+      merged: row?.outcome === "merged"
+    };
+    chains.push({
+      task: t.id,
+      fromTask: true,
+      title: t.title,
+      status: t.status,
+      url: t.url ?? null,
+      holders: [...new Set(cs.map((c) => c.owner).filter((o) => !!o))],
+      claimedAt: cs[0]?.acquiredAt ?? null,
+      worktree,
+      branch,
+      sessions: sess,
+      costUsd: row?.costUsd ?? sess.reduce((a, s) => a + (s.costUsd ?? 0), 0),
+      prNumber: row?.prNumber ?? null,
+      prUrl: row?.url ?? null,
+      outcome: row?.outcome ?? null,
+      mergedAt: row?.mergedAt ?? null,
+      leadHours: row?.leadHours ?? null,
+      links,
+      depth: Object.values(links).filter(Boolean).length,
+      brokenAt: breakOf(links)
+    });
+  }
+  const explained = new Set(chains.map((c) => c.branch).filter((b) => !!b));
+  for (const b of branches) {
+    if (explained.has(b.branch))
+      continue;
+    const links = {
+      task: false,
+      claim: false,
+      session: b.sessions.length > 0,
+      branch: true,
+      pr: !!b.prNumber,
+      merged: b.outcome === "merged"
+    };
+    chains.push({
+      task: b.branch,
+      fromTask: false,
+      title: b.title ?? b.branch,
+      status: b.outcome,
+      url: null,
+      holders: [],
+      claimedAt: null,
+      worktree: null,
+      branch: b.branch,
+      sessions: b.sessions.map((id) => sessions.find((s) => s.id === id)).filter((s) => !!s),
+      costUsd: b.costUsd,
+      prNumber: b.prNumber,
+      prUrl: b.url,
+      outcome: b.outcome,
+      mergedAt: b.mergedAt,
+      leadHours: b.leadHours,
+      links,
+      depth: Object.values(links).filter(Boolean).length,
+      brokenAt: "no-task"
+    });
+  }
+  chains.sort((a, b) => severity(a.brokenAt) - severity(b.brokenAt) || b.costUsd - a.costUsd || a.task.localeCompare(b.task));
+  return {
+    chains,
+    totals: {
+      tasks: chains.length,
+      complete: chains.filter((c) => c.brokenAt === null).length,
+      broken: chains.filter((c) => c.brokenAt !== null).length,
+      unclaimed: chains.filter((c) => c.brokenAt === "unclaimed").length,
+      noPr: chains.filter((c) => c.brokenAt === "no-pr").length,
+      untracked: chains.filter((c) => c.brokenAt === "no-task").length,
+      costUsd: chains.reduce((a, c) => a + c.costUsd, 0)
+    }
+  };
+}
 // packages/core/src/questions.ts
 function validateQuestion(text, options) {
   const t = typeof text === "string" ? text.trim() : "";
@@ -2178,6 +3440,49 @@ ${lines.join(`
 `)}` : ""}`
   };
 }
+// packages/core/src/stall.ts
+var STALL_DEFAULTS = { window: 12, repeat: 3, repeatErrors: 2, errors: 4 };
+function toolResponseErrored(resp) {
+  if (typeof resp === "string")
+    return /^\s*error[:\s]/i.test(resp);
+  if (!resp || typeof resp !== "object")
+    return false;
+  const r = resp;
+  if (r.is_error === true || r.isError === true)
+    return true;
+  if (r.success === false)
+    return true;
+  if (r.interrupted === true)
+    return true;
+  if (typeof r.error === "string" && r.error.length > 0)
+    return true;
+  return false;
+}
+function detectStall(calls, opts = {}) {
+  const o = { ...STALL_DEFAULTS, ...opts };
+  const tail = calls.slice(-o.window);
+  const last = tail.at(-1);
+  if (!last)
+    return null;
+  let run = 0;
+  let runErrors = 0;
+  for (let i = tail.length - 1;i >= 0; i--) {
+    const c = tail[i];
+    if (!c || c.tool !== last.tool || c.input !== last.input)
+      break;
+    run++;
+    if (c.errored)
+      runErrors++;
+  }
+  if (run >= o.repeat && runErrors >= o.repeatErrors)
+    return { kind: "repeat", reason: `repeating a failing ${last.tool} call \xD7${run}` };
+  let streak = 0;
+  for (let i = tail.length - 1;i >= 0 && tail[i]?.errored; i--)
+    streak++;
+  if (streak >= o.errors)
+    return { kind: "errors", reason: `${streak} tool calls failing in a row` };
+  return null;
+}
 // packages/core/src/tasks.ts
 var ID_RE = /^[A-Za-z][A-Za-z0-9_-]*\d[\w.-]*$/;
 var DEP_RE = /[A-Za-z][A-Za-z0-9_-]*\d[\w.]*/g;
@@ -2337,88 +3642,157 @@ function linearIssuesQuery(teamKey, first = 200) {
     inverseRelations { nodes { type issue { identifier } } }
   } } }`;
 }
-// packages/core/src/worktree.ts
-import { join as join3 } from "path";
-function planBootstrap(cfg, repoRoot, worktree) {
-  const seen = new Set;
-  const copies = [];
-  for (const raw of cfg.worktree.copy) {
-    if (!isRepoRelative(raw))
-      continue;
-    const rel = raw.trim().replace(/^\.\//, "");
-    if (seen.has(rel))
-      continue;
-    seen.add(rel);
-    copies.push({ rel, from: join3(repoRoot, rel), to: join3(worktree, rel) });
-  }
-  return { copies, setup: cfg.worktree.setup };
-}
-var needsBootstrap = (plan) => plan.copies.length > 0 || plan.setup !== null;
-function summarizeBootstrap(o) {
-  const parts = [];
-  if (o.copied.length)
-    parts.push(`copied ${o.copied.join(", ")}`);
-  if (o.skipped.length)
-    parts.push(`skipped ${o.skipped.join(", ")} (missing)`);
-  if (o.setup)
-    parts.push(`${o.setup.command} \u2192 ${o.setup.exitCode === 0 ? "ok" : `exit ${o.setup.exitCode}`} in ${(o.setup.durationMs / 1000).toFixed(1)}s`);
-  return parts.join("; ") || "nothing to do";
-}
-function canRemoveWorktree(w, heldByClaim, force) {
-  if (w.main)
-    return { ok: false, reason: "main" };
-  if (heldByClaim)
-    return { ok: false, reason: "held" };
-  if (force)
-    return { ok: true };
-  if (w.dirty > 0)
-    return { ok: false, reason: "dirty" };
-  if (w.ahead > 0)
-    return { ok: false, reason: "unpushed" };
-  return { ok: true };
+// packages/core/src/team.ts
+import { createPublicKey, verify as nodeVerify } from "crypto";
+function modelAllowed(model, allow) {
+  if (!allow.length)
+    return true;
+  return allow.some((g) => {
+    const re = new RegExp(`^${g.trim().split("*").map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`, "i");
+    return re.test(model);
+  });
 }
-function removeRefusalMessage(reason, path, task) {
-  switch (reason) {
-    case "main":
-      return `${path} is the main checkout \u2014 it is never removed`;
-    case "held":
-      return `${path} is held by claim ${task ?? "?"} \u2014 release the claim instead`;
-    case "dirty":
-      return `${path} has uncommitted changes \u2014 commit or stash them, or --force to discard`;
-    case "unpushed":
-      return `${path} has unpushed commits \u2014 push them, or --force to discard`;
+function verifyPolicySignature(toml, signatureB64, publicKeyB64) {
+  try {
+    return nodeVerify(null, Buffer.from(toml), createPublicKey({ key: Buffer.from(publicKeyB64, "base64"), format: "der", type: "spki" }), Buffer.from(signatureB64, "base64"));
+  } catch {
+    return false;
   }
 }
-function planGc(worktrees, claims) {
-  const held = new Map(claims.filter((c) => c.state === "held").map((c) => [c.worktree, c.task]));
-  const stale = new Set(claims.filter((c) => c.state !== "held").map((c) => c.worktree));
+function clusterProjectKey(remoteUrl) {
+  if (!remoteUrl)
+    return null;
+  const url = remoteUrl.trim();
+  const m = url.match(/^https?:\/\/(?:[^@/]+@)?([^/:]+)(?::\d+)?\/(.+?)(?:\.git)?\/?$/) ?? url.match(/^(?:ssh:\/\/)?(?:[^@/]+@)?([^:/]+)[:/](.+?)(?:\.git)?\/?$/);
+  if (!m?.[1] || !m[2])
+    return null;
+  const host = m[1].toLowerCase();
+  if (host.includes(" ") || !host.includes("."))
+    return null;
+  return `${host}/${m[2]}`;
+}
+// packages/core/src/waiting.ts
+var emptyByKind = () => ({
+  permission: { episodes: 0, blockedMs: 0 },
+  question: { episodes: 0, blockedMs: 0 },
+  notification: { episodes: 0, blockedMs: 0 }
+});
+var ms3 = (iso) => new Date(iso).getTime();
+function median2(xs) {
+  if (!xs.length)
+    return 0;
+  const s = [...xs].sort((a, b) => a - b);
+  const mid = s.length >> 1;
+  return s.length % 2 ? s[mid] : Math.round((s[mid - 1] + s[mid]) / 2);
+}
+function pairWaits(samples, now, sessionEnds = {}) {
+  const nowMs = ms3(now);
+  const open = new Map;
   const out = [];
-  for (const w of worktrees) {
-    if (w.main || held.has(w.path))
+  const id = (s) => `${s.sessionId}\x00${s.kind}\x00${s.key}`;
+  const rank = (p) => p === "start" ? 0 : 1;
+  const ordered = [...samples].sort((a, b) => ms3(a.ts) - ms3(b.ts) || rank(a.phase) - rank(b.phase));
+  for (const s of ordered) {
+    const k = id(s);
+    if (s.phase === "start") {
+      if (!open.has(k))
+        open.set(k, s);
       continue;
-    const why = w.merged ? "merged" : stale.has(w.path) ? "released-claim" : null;
-    if (!why)
+    }
+    const start = open.get(k);
+    if (!start)
       continue;
-    const can = canRemoveWorktree(w, null, false);
+    open.delete(k);
     out.push({
-      path: w.path,
-      branch: w.branch,
-      why,
-      removable: can.ok,
-      blocker: can.ok ? null : can.reason
+      sessionId: start.sessionId,
+      projectId: start.projectId ?? null,
+      kind: start.kind,
+      key: start.key,
+      startedAt: start.ts,
+      endedAt: s.ts,
+      ms: Math.max(0, ms3(s.ts) - ms3(start.ts)),
+      open: false,
+      label: start.label ?? s.label ?? null
     });
   }
-  return out;
+  for (const start of open.values()) {
+    const ended = sessionEnds[start.sessionId];
+    const until = ended ? Math.min(ms3(ended), nowMs) : nowMs;
+    out.push({
+      sessionId: start.sessionId,
+      projectId: start.projectId ?? null,
+      kind: start.kind,
+      key: start.key,
+      startedAt: start.ts,
+      endedAt: ended ?? null,
+      ms: Math.max(0, until - ms3(start.ts)),
+      open: !ended,
+      label: start.label ?? null
+    });
+  }
+  return out.sort((a, b) => ms3(a.startedAt) - ms3(b.startedAt));
+}
+function waitingReport(episodes) {
+  const bySession = new Map;
+  for (const e of episodes) {
+    const list = bySession.get(e.sessionId);
+    if (list)
+      list.push(e);
+    else
+      bySession.set(e.sessionId, [e]);
+  }
+  const sessions = [];
+  for (const [sessionId, list] of bySession) {
+    const byKind = emptyByKind();
+    for (const e of list) {
+      const k = byKind[e.kind];
+      k.episodes++;
+      k.blockedMs += e.ms;
+    }
+    const openEp = list.filter((e) => e.open).sort((a, b) => ms3(a.startedAt) - ms3(b.startedAt))[0];
+    const durations = list.map((e) => e.ms);
+    sessions.push({
+      sessionId,
+      projectId: list[0]?.projectId ?? null,
+      episodes: list.length,
+      blockedMs: durations.reduce((a, b) => a + b, 0),
+      longestMs: durations.length ? Math.max(...durations) : 0,
+      medianMs: median2(durations),
+      openSince: openEp?.startedAt ?? null,
+      openKind: openEp?.kind ?? null,
+      openLabel: openEp?.label ?? null,
+      byKind
+    });
+  }
+  sessions.sort((a, b) => b.blockedMs - a.blockedMs);
+  const all = episodes.map((e) => e.ms);
+  const totalsByKind = emptyByKind();
+  for (const e of episodes) {
+    const k = totalsByKind[e.kind];
+    k.episodes++;
+    k.blockedMs += e.ms;
+  }
+  return {
+    sessions,
+    totals: {
+      episodes: episodes.length,
+      blockedMs: all.reduce((a, b) => a + b, 0),
+      medianMs: median2(all),
+      longestMs: all.length ? Math.max(...all) : 0,
+      waitingNow: sessions.filter((s) => s.openSince).length,
+      byKind: totalsByKind
+    }
+  };
 }
 // packages/daemon/src/app.ts
-import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync4, realpathSync as realpathSync3 } from "fs";
+import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync4, realpathSync as realpathSync3, statSync as statSync2 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname4, join as join9 } from "path";
+import { dirname as dirname4, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // node_modules/.bun/hono@4.13.3/node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
-  return (context, next) => {
+  return (context2, next) => {
     let index = -1;
     return dispatch2(0);
     async function dispatch2(i) {
@@ -2431,31 +3805,31 @@ var compose = (middleware, onError, onNotFound) => {
       let handler;
       if (middleware[i]) {
         handler = middleware[i][0][0];
-        context.req.routeIndex = i;
+        context2.req.routeIndex = i;
       } else {
         handler = i === middleware.length && next || undefined;
       }
       if (handler) {
         try {
-          res = await handler(context, () => dispatch2(i + 1));
+          res = await handler(context2, () => dispatch2(i + 1));
         } catch (err) {
           if (err instanceof Error && onError) {
-            context.error = err;
-            res = await onError(err, context);
+            context2.error = err;
+            res = await onError(err, context2);
             isError = true;
           } else {
             throw err;
           }
         }
       } else {
-        if (context.finalized === false && onNotFound) {
-          res = await onNotFound(context);
+        if (context2.finalized === false && onNotFound) {
+          res = await onNotFound(context2);
         }
       }
-      if (res && (context.finalized === false || isError)) {
-        context.res = res;
+      if (res && (context2.finalized === false || isError)) {
+        context2.res = res;
       }
-      return context;
+      return context2;
     }
   };
 };
@@ -2876,7 +4250,7 @@ var raw = (value, callbacks) => {
   escapedString.callbacks = callbacks;
   return escapedString;
 };
-var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+var resolveCallback = async (str, phase, preserveCallbacks, context2, buffer) => {
   if (typeof str === "object" && !(str instanceof String)) {
     if (!(str instanceof Promise)) {
       str = str.toString();
@@ -2894,7 +4268,7 @@ var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) =>
   } else {
     buffer = [str];
   }
-  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then((res) => Promise.all(res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))).then(() => buffer[0]));
+  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context: context2 }))).then((res) => Promise.all(res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context2, buffer))).then(() => buffer[0]));
   if (preserveCallbacks) {
     return raw(await resStr, callbacks);
   } else {
@@ -3293,11 +4667,11 @@ var Hono = class _Hono {
     const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
     return (async () => {
       try {
-        const context = await composed(c);
-        if (!context.finalized) {
+        const context2 = await composed(c);
+        if (!context2.finalized) {
           throw new Error("Context is not finalized. Did you forget to return a Response object or `await next()`?");
         }
-        return context.res;
+        return context2.res;
       } catch (err) {
         return this.#handleError(err, c);
       }
@@ -3370,7 +4744,7 @@ var Node = class _Node {
   #index;
   #varIndex;
   #children = /* @__PURE__ */ Object.create(null);
-  insert(tokens, index, paramMap, context, isStatic) {
+  insert(tokens, index, paramMap, context2, isStatic) {
     let node = this;
     for (let i = 0, len = tokens.length;i < len; i++) {
       const token = tokens[i];
@@ -3403,7 +4777,7 @@ var Node = class _Node {
           nextNode = node.#children[regexpStr] = new _Node;
         }
         if (name !== "") {
-          nextNode.#varIndex ??= context.varIndex++;
+          nextNode.#varIndex ??= context2.varIndex++;
           paramMap.push([name, nextNode.#varIndex]);
         }
       } else {
@@ -3928,8 +5302,8 @@ var StreamingApi = class {
 `);
     return this;
   }
-  sleep(ms) {
-    return new Promise((res) => setTimeout(res, ms));
+  sleep(ms4) {
+    return new Promise((res) => setTimeout(res, ms4));
   }
   async close() {
     this.closed = true;
@@ -4183,6 +5557,7 @@ class Dispatcher {
         task: t.id,
         runId: r.run.id,
         worktree: r.run.worktree,
+        by: this.opts.get(projectId)?.owner ?? null,
         summary: `dispatch ${t.id} \u2192 run ${r.run.id}`
       }
     });
@@ -4343,6 +5718,64 @@ class ForgeService {
       }
     }));
   }
+  outcomeCache = new Map;
+  async merged(projectId, root) {
+    const hit = this.outcomeCache.get(projectId);
+    if (hit && Date.now() - hit.at < 600000)
+      return hit;
+    let merged = [];
+    const remote = this.remote(root);
+    if (remote?.forge === "github") {
+      const out = await this.run([
+        "gh",
+        "pr",
+        "list",
+        "--state",
+        "merged",
+        "--limit",
+        "200",
+        "--json",
+        "number,title,headRefName,url,createdAt,mergedAt,mergeCommit"
+      ], root);
+      if (out)
+        merged = JSON.parse(out).map((r) => ({
+          branch: String(r.headRefName ?? ""),
+          number: Number(r.number ?? 0),
+          title: String(r.title ?? ""),
+          url: String(r.url ?? ""),
+          createdAt: r.createdAt ?? null,
+          mergedAt: r.mergedAt ?? null,
+          mergeSha: (r.mergeCommit?.oid ?? null)?.toLowerCase() ?? null
+        }));
+    } else if (remote?.forge === "gitlab") {
+      const out = await this.run(["glab", "mr", "list", "--merged", "--output", "json"], root);
+      if (out)
+        merged = JSON.parse(out).map((r) => ({
+          branch: String(r.source_branch ?? ""),
+          number: Number(r.iid ?? 0),
+          title: String(r.title ?? ""),
+          url: String(r.web_url ?? ""),
+          createdAt: r.created_at ?? null,
+          mergedAt: r.merged_at ?? null,
+          mergeSha: (r.merge_commit_sha ?? null)?.toLowerCase() ?? null
+        }));
+    }
+    const log = Bun.spawnSync([
+      "git",
+      "-C",
+      root,
+      "log",
+      "--grep",
+      "This reverts commit",
+      "--format=%B",
+      "-n",
+      "300"
+    ]);
+    const reverted = log.exitCode === 0 ? [...parseReverts(new TextDecoder().decode(log.stdout))] : [];
+    const entry = { at: Date.now(), merged, reverted };
+    this.outcomeCache.set(projectId, entry);
+    return entry;
+  }
   remote(root) {
     const r = Bun.spawnSync(["git", "-C", root, "remote", "get-url", "origin"]);
     if (r.exitCode !== 0)
@@ -4575,6 +6008,16 @@ function currentBranch(cwd) {
   branchCache.set(cwd, { v: v === "HEAD" ? "(detached)" : v, t: now });
   return branchCache.get(cwd)?.v ?? null;
 }
+var originCache = new Map;
+function originUrl(root) {
+  const hit = originCache.get(root);
+  const now = Date.now();
+  if (hit && now - hit.t < 300000)
+    return hit.v;
+  const v = git(root, ["config", "--get", "remote.origin.url"])?.trim() || null;
+  originCache.set(root, { v, t: now });
+  return v;
+}
 function worktreeAdd(repoRoot, path, branch, baseRef = "HEAD") {
   const branchExists = git(repoRoot, ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`]) !== null;
   const args = branchExists ? ["worktree", "add", path, branch] : ["worktree", "add", "-b", branch, path, baseRef];
@@ -4706,6 +6149,14 @@ class Runner {
       return { ok: false, reason: "unknown project" };
     if (!input.prompt.trim())
       return { ok: false, reason: "prompt is required" };
+    if (input.model) {
+      const allow = this.store.config(input.projectId).models.allow;
+      if (!modelAllowed(input.model, allow))
+        return {
+          ok: false,
+          reason: `model "${input.model}" is not in [models] allow (${allow.join(", ")})`
+        };
+    }
     if (input.permissionMode && !PERMISSION_MODES.includes(input.permissionMode))
       return { ok: false, reason: `permission mode must be one of ${PERMISSION_MODES.join(", ")}` };
     if (this.get(input.task)?.projectId === input.projectId)
@@ -5004,6 +6455,7 @@ class Runner {
 import { Database } from "bun:sqlite";
 import {
   closeSync,
+  copyFileSync,
   existsSync as existsSync6,
   mkdirSync as mkdirSync4,
   openSync as openSync3,
@@ -5016,7 +6468,7 @@ import {
   unlinkSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { homedir as homedir3, tmpdir, userInfo } from "os";
+import { homedir as homedir3, hostname, tmpdir, userInfo } from "os";
 import { basename, dirname as dirname3, join as join8 } from "path";
 
 // packages/daemon/src/bootstrap.ts
@@ -5126,14 +6578,14 @@ class TaskSources {
 `)[0] ?? code}`);
     return normalizeGithubIssues(JSON.parse(out));
   }
-  async linear(team) {
+  async linear(team2) {
     const key = this.env.LINEAR_API_KEY;
     if (!key)
       throw new Error("LINEAR_API_KEY not set \u2014 export it in the environment swarmd starts from (never stored)");
     const r = await fetch("https://api.linear.app/graphql", {
       method: "POST",
       headers: { "content-type": "application/json", authorization: key },
-      body: JSON.stringify({ query: linearIssuesQuery(team) })
+      body: JSON.stringify({ query: linearIssuesQuery(team2) })
     });
     if (!r.ok)
       throw new Error(`Linear API ${r.status}`);
@@ -5159,11 +6611,12 @@ CREATE INDEX IF NOT EXISTS events_type_seq ON events(type, seq);
 CREATE TABLE IF NOT EXISTS turns (
   id TEXT PRIMARY KEY, session_id TEXT, agent_id TEXT, ts TEXT, model TEXT, effort TEXT, sidechain INTEGER,
   input INTEGER, output INTEGER, cache_write INTEGER, cache_write_1h INTEGER, cache_read INTEGER, thinking INTEGER,
-  cost_usd REAL, text TEXT, tools TEXT
+  cost_usd REAL, cost_fixed INTEGER DEFAULT 0, text TEXT, tools TEXT
 );
 CREATE INDEX IF NOT EXISTS turns_session ON turns(session_id, ts);
 CREATE INDEX IF NOT EXISTS turns_ts ON turns(ts);
 CREATE TABLE IF NOT EXISTS tails (path TEXT PRIMARY KEY, session_id TEXT, agent_id TEXT, offset INTEGER);
+CREATE TABLE IF NOT EXISTS outbox (seq INTEGER PRIMARY KEY AUTOINCREMENT, kind TEXT, payload TEXT, created_at TEXT);
 CREATE TABLE IF NOT EXISTS resources (
   name TEXT, project_id TEXT, kind TEXT, owner TEXT, session_id TEXT,
   pid INTEGER, port INTEGER, acquired_at TEXT, expires_at TEXT, released INTEGER DEFAULT 0,
@@ -5182,7 +6635,7 @@ CREATE TABLE IF NOT EXISTS processes (
 CREATE INDEX IF NOT EXISTS processes_live ON processes(ended_at, project_id);
 CREATE TABLE IF NOT EXISTS gates (
   id INTEGER PRIMARY KEY AUTOINCREMENT, project_id TEXT, task TEXT, gate TEXT, verdict TEXT,
-  rubric TEXT, evidence TEXT, session_id TEXT, created_at TEXT
+  rubric TEXT, evidence TEXT, session_id TEXT, duration_ms INTEGER, created_at TEXT
 );
 CREATE INDEX IF NOT EXISTS gates_task ON gates(project_id, task, created_at);
 CREATE TABLE IF NOT EXISTS handoffs (
@@ -5229,6 +6682,8 @@ class Store {
     this.db.exec("PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL; PRAGMA mmap_size=268435456; PRAGMA cache_size=-32000;");
     this.db.exec(SCHEMA);
     this.ensureColumn("sessions", "agent", "TEXT DEFAULT 'claude-code'");
+    this.ensureColumn("claims", "team_state", "TEXT");
+    this.ensureColumn("turns", "cost_fixed", "INTEGER DEFAULT 0");
     this.ensureColumn("projects", "sort_order", "INTEGER");
     this.ensureColumn("projects", "icon", "TEXT");
     this.ensureColumn("projects", "color", "TEXT");
@@ -5254,6 +6709,12 @@ class Store {
   setMeta(key, value) {
     this.db.query("INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
   }
+  metaValue(key) {
+    return this.meta(key) || null;
+  }
+  setMetaValue(key, value) {
+    this.setMeta(key, value);
+  }
   slimExistingEvents() {
     if (this.meta("events_slim") === "1")
       return;
@@ -5317,7 +6778,7 @@ class Store {
       this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${col} ${decl}`);
     }
   }
-  static SCHEMA_VERSION = 1;
+  static SCHEMA_VERSION = 2;
   schemaVersion() {
     return Number(this.meta("schema_version") ?? 0);
   }
@@ -5355,6 +6816,16 @@ class Store {
         fill("incident_acks", "'dashboard'", null, "acks");
         fill("sessions", "NULL", "id", "sessions");
         fill("events", "COALESCE(json_extract(payload, '$.owner'), json_extract(payload, '$.by'))", "session_id", "events");
+      },
+      (db) => {
+        this.ensureColumn("gates", "duration_ms", "INTEGER");
+        const rows = db.query("SELECT id, rubric FROM gates WHERE duration_ms IS NULL AND rubric LIKE '%s'").all();
+        const upd = db.query("UPDATE gates SET duration_ms = ? WHERE id = ?");
+        for (const r of rows) {
+          const m = /\bin ([0-9]+(?:\.[0-9]+)?)s$/.exec(r.rubric ?? "");
+          if (m)
+            upd.run(Math.round(Number(m[1]) * 1000), r.id);
+        }
       }
     ];
     for (let v = this.schemaVersion();v < steps.length; v++) {
@@ -5862,10 +7333,10 @@ class Store {
              OR (to_kind = 'task' AND project_id = ? AND task IS ?)
              OR (to_kind = 'lead' AND project_id = ? AND ? = 'interactive'))
          ORDER BY id`).all(sessionId, sessionId, s.project_id, task, s.project_id, s.kind);
-    const ms = rows.map(rowToMessage);
-    if (ms.length && !opts.peek)
-      this.db.query(`UPDATE messages SET delivered_at = ?, session_id = ? WHERE id IN (${ms.map(() => "?").join(",")})`).run(new Date().toISOString(), sessionId, ...ms.map((m) => m.id));
-    return ms;
+    const ms4 = rows.map(rowToMessage);
+    if (ms4.length && !opts.peek)
+      this.db.query(`UPDATE messages SET delivered_at = ?, session_id = ? WHERE id IN (${ms4.map(() => "?").join(",")})`).run(new Date().toISOString(), sessionId, ...ms4.map((m) => m.id));
+    return ms4;
   }
   markMessageDelivered(id, sessionId) {
     this.db.query("UPDATE messages SET delivered_at = ?, session_id = COALESCE(?, session_id) WHERE id = ? AND delivered_at IS NULL").run(new Date().toISOString(), sessionId, id);
@@ -5920,6 +7391,7 @@ class Store {
       rubric: r.rubric,
       evidence: r.evidence ?? null,
       sessionId: r.session_id ?? null,
+      durationMs: r.duration_ms ?? null,
       createdAt: r.created_at
     };
   }
@@ -6070,10 +7542,10 @@ class Store {
     };
     const done = (async () => {
       let diffText = "";
-      let stat = "";
+      let stat2 = "";
       try {
         const diff = await worktreeDiff(p.root, where.worktree);
-        stat = diff.files.map((f) => `${f.status ?? "M"} ${f.path} (+${f.added} -${f.deleted})`).join(`
+        stat2 = diff.files.map((f) => `${f.status ?? "M"} ${f.path} (+${f.added} -${f.deleted})`).join(`
 `);
         diffText = await worktreePatch(where.worktree, diff.base);
       } catch (e) {
@@ -6095,7 +7567,7 @@ class Store {
         task,
         title: taskRow?.title ?? null,
         branch: w?.branch ?? null,
-        stat,
+        stat: stat2,
         patch: diffText
       });
       writeFileSync2(where.log, `$ claude -p <review prompt, ${prompt.length} chars> --output-format json (read-only)
@@ -6253,8 +7725,8 @@ ${err}
       return v;
     const createdAt = new Date().toISOString();
     const sessionId = this.knownSession(input.sessionId);
-    const r = this.db.query(`INSERT INTO gates (project_id, task, gate, verdict, rubric, evidence, session_id, created_at, actor_kind, actor_id)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(projectId, input.task.trim(), input.gate, input.verdict, input.rubric.trim(), input.evidence?.trim() || null, sessionId, createdAt, ...actorCols(this.actorFor(input.sessionId ? null : "daemon", sessionId)));
+    const r = this.db.query(`INSERT INTO gates (project_id, task, gate, verdict, rubric, evidence, session_id, duration_ms, created_at, actor_kind, actor_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(projectId, input.task.trim(), input.gate, input.verdict, input.rubric.trim(), input.evidence?.trim() || null, sessionId, typeof input.durationMs === "number" ? Math.max(0, Math.round(input.durationMs)) : null, createdAt, ...actorCols(this.actorFor(input.sessionId ? null : "daemon", sessionId)));
     const run2 = this.rowToGate(this.db.query("SELECT * FROM gates WHERE id = ?").get(Number(r.lastInsertRowid)));
     this.remember(gateDoc(projectId, run2.id, run2, sessionId));
     this.append({
@@ -6414,6 +7886,18 @@ ${err}
         };
         return { decision: d, display: input.command ?? input.file_path ?? tool };
       }
+      const tb = this.teamBudgets().find((x) => x.level === "exceeded" && x.on_exceed === "ask" && (x.scope !== "project" || x.key === this.clusterKeyFor(project.id)));
+      if (tb) {
+        const label = tb.scope === "org" ? "the org" : `${tb.scope} ${tb.key}`;
+        return {
+          decision: {
+            action: "ask",
+            rule: "budget",
+            reason: `team ${tb.kind} budget for ${label} is exceeded ($${tb.spent.toFixed(2)} of $${tb.limit}) \u2014 the team's on_exceed = "ask": confirm each change, or have an admin raise it (POST /t1/budgets)`
+          },
+          display: input.command ?? input.file_path ?? tool
+        };
+      }
     }
     const isWrite = WRITE_TOOLS.has(tool) && typeof input.file_path === "string";
     const cmd = tool === "Bash" ? input.command : undefined;
@@ -6581,7 +8065,7 @@ ${err}
     this.reprice();
   }
   reprice() {
-    const rows = this.db.query("SELECT id, model, input, output, cache_write, cache_write_1h, cache_read FROM turns").all();
+    const rows = this.db.query("SELECT id, model, input, output, cache_write, cache_write_1h, cache_read FROM turns WHERE cost_fixed IS NOT 1").all();
     const up = this.db.query("UPDATE turns SET cost_usd = ? WHERE id = ?");
     const tx = this.db.transaction(() => {
       for (const r of rows)
@@ -6742,12 +8226,69 @@ ${err}
     if (stored.type === "incident.opened")
       this.remember(incidentDoc(stored.projectId, stored.seq, stored.payload, stored.ts, stored.sessionId));
     this.projectSession(stored);
+    if (stored.type === "incident.opened") {
+      const webhook = this.policyFor(null).config.notify.webhook;
+      if (webhook) {
+        const p2 = stored.payload ?? {};
+        const project = this.project(stored.projectId)?.name ?? stored.projectId;
+        fetch(webhook, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            text: `Swarm incident \xB7 ${p2.rule ?? "?"} \xB7 ${project}
+${p2.command ?? ""}
+${p2.reason ?? ""}`.trim(),
+            rule: p2.rule,
+            project,
+            sessionId: stored.sessionId,
+            ts: stored.ts
+          }),
+          signal: AbortSignal.timeout(5000)
+        }).catch(() => {});
+      }
+    }
+    const team2 = this.policyFor(null).config.team;
+    if (team2.url && team2.forward.includes("ledger") && isAuditType(stored.type)) {
+      this.db.query("INSERT INTO outbox (kind, payload, created_at) VALUES ('event', ?, ?)").run(JSON.stringify({
+        seq: stored.seq,
+        ts: stored.ts,
+        type: stored.type,
+        projectId: stored.projectId,
+        sessionId: stored.sessionId,
+        actor: actor2,
+        payload: slim.payload ?? null
+      }), stored.ts);
+    }
     this.touch();
     const wire = toWire(stored);
     for (const l of this.listeners)
       l(wire);
     return stored;
   }
+  outboxPending(limit = 200) {
+    return this.db.query("SELECT seq, kind, payload FROM outbox ORDER BY seq LIMIT ?").all(limit);
+  }
+  outboxAck(upTo) {
+    this.db.query("DELETE FROM outbox WHERE seq <= ?").run(upTo);
+  }
+  outboxStatus() {
+    const r = this.db.query("SELECT COUNT(*) AS n, MIN(created_at) AS oldest FROM outbox").get();
+    return { pending: r.n, oldest: r.oldest };
+  }
+  machineIdentity() {
+    let id = this.meta("machine_id");
+    if (!id) {
+      id = crypto.randomUUID();
+      this.setMeta("machine_id", id);
+    }
+    return { id, name: hostname() };
+  }
+  spendRollup(day = new Date().toISOString().slice(0, 10)) {
+    return this.db.query(`SELECT s.project_id AS projectId, COALESCE(s.agent, 'claude-code') AS agent, t.model AS model,
+                SUM(t.cost_usd) AS cost, SUM(t.input + t.cache_write + t.cache_read) AS tokensIn, SUM(t.output) AS tokensOut
+         FROM turns t JOIN sessions s ON s.id = t.session_id
+         WHERE t.ts >= ? AND t.ts < ? GROUP BY s.project_id, agent, t.model`).all(`${day}T00:00:00.000Z`, `${day}T23:59:59.999Z`);
+  }
   audit(opts = {}) {
     const where = [`type IN (${AUDIT_TYPES_SQL})`];
     const args = [];
@@ -6767,9 +8308,9 @@ ${err}
     const rows = this.db.query(`SELECT * FROM (SELECT ${WIRE_COLS} FROM events WHERE ${where.join(" AND ")} ORDER BY seq DESC LIMIT ?) ORDER BY seq`).all(...args, limit);
     return rows.map((r) => auditRow(wireRowToEvent(r)));
   }
-  prune(days2) {
+  prune(days3) {
     const cfg = this.policyFor(null).config;
-    const chatter = days2 ?? cfg.events.retain_days;
+    const chatter = days3 ?? cfg.events.retain_days;
     const cutoff = new Date(Date.now() - chatter * 86400000).toISOString();
     let n = this.db.query(`DELETE FROM events WHERE ts < ? AND type NOT IN (${AUDIT_TYPES_SQL})`).run(cutoff).changes;
     if (cfg.audit.retain_days > 0) {
@@ -6875,13 +8416,13 @@ ${err}
   persistTurns(sessionId, agentId, turns) {
     const privacy = this.policyFor(null).config.privacy;
     const res = this.redactions();
-    const up = this.db.query(`INSERT INTO turns (id, session_id, agent_id, ts, model, effort, sidechain, input, output, cache_write, cache_write_1h, cache_read, thinking, cost_usd, text, tools)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    const up = this.db.query(`INSERT INTO turns (id, session_id, agent_id, ts, model, effort, sidechain, input, output, cache_write, cache_write_1h, cache_read, thinking, cost_usd, cost_fixed, text, tools)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(id) DO UPDATE SET input=excluded.input, output=excluded.output, cache_write=excluded.cache_write, cache_write_1h=excluded.cache_write_1h,
-         cache_read=excluded.cache_read, thinking=excluded.thinking, cost_usd=excluded.cost_usd, text=CASE WHEN excluded.text != '' THEN excluded.text ELSE turns.text END, tools=excluded.tools`);
+         cache_read=excluded.cache_read, thinking=excluded.thinking, cost_usd=excluded.cost_usd, cost_fixed=excluded.cost_fixed, text=CASE WHEN excluded.text != '' THEN excluded.text ELSE turns.text END, tools=excluded.tools`);
     const tx = this.db.transaction((ts) => {
       for (const t of ts) {
-        up.run(t.id, sessionId, agentId, t.ts, t.model, t.effort, t.sidechain ? 1 : 0, t.usage.input, t.usage.output, t.usage.cacheWrite, t.usage.cacheWrite1h ?? 0, t.usage.cacheRead, t.usage.thinking, costUsd(t.model, t.usage, this.prices), privacy.store_reasoning ? redactValue(t.text, res) : "", JSON.stringify(t.tools));
+        up.run(t.id, sessionId, agentId, t.ts, t.model, t.effort, t.sidechain ? 1 : 0, t.usage.input, t.usage.output, t.usage.cacheWrite, t.usage.cacheWrite1h ?? 0, t.usage.cacheRead, t.usage.thinking, t.cost ?? costUsd(t.model, t.usage, this.prices), t.cost != null ? 1 : 0, privacy.store_reasoning ? redactValue(t.text, res) : "", JSON.stringify(t.tools));
       }
     });
     if (turns.length)
@@ -7072,22 +8613,176 @@ ${err}
         let title;
         let fresh = false;
         try {
-          const m = statSync(sumPath).mtimeMs;
-          const hit = this.grokSummary.get(sumPath);
-          if (hit && hit.mtime === m)
-            title = hit.title;
-          else {
-            const sum = JSON.parse(readFileSync3(sumPath, "utf8"));
-            title = sum.session_summary;
-            this.grokSummary.set(sumPath, { mtime: m, title });
-            fresh = true;
-          }
-        } catch {}
-        n += this.ingestLog(path, "grok", parseGrokUpdates, cwd, title);
-        if (title && fresh) {
-          this.db.query("UPDATE sessions SET title = ? WHERE id = ? AND (title IS NULL OR title = '')").run(title, sid);
+          const m = statSync(sumPath).mtimeMs;
+          const hit = this.grokSummary.get(sumPath);
+          if (hit && hit.mtime === m)
+            title = hit.title;
+          else {
+            const sum = JSON.parse(readFileSync3(sumPath, "utf8"));
+            title = sum.session_summary;
+            this.grokSummary.set(sumPath, { mtime: m, title });
+            fresh = true;
+          }
+        } catch {}
+        n += this.ingestLog(path, "grok", parseGrokUpdates, cwd, title);
+        if (title && fresh) {
+          this.db.query("UPDATE sessions SET title = ? WHERE id = ? AND (title IS NULL OR title = '')").run(title, sid);
+        }
+      }
+    }
+    return n;
+  }
+  heldClaimsForSync() {
+    return this.db.query("SELECT project_id, task, acquired_at, expires_at, actor_kind, actor_id, team_state FROM claims WHERE state = 'held'").all().map((r) => ({
+      projectId: r.project_id,
+      task: r.task,
+      acquiredAt: r.acquired_at,
+      expiresAt: r.expires_at,
+      actorKind: r.actor_kind ?? null,
+      actorId: r.actor_id ?? null,
+      teamState: r.team_state ?? null
+    }));
+  }
+  markClaimTeamState(projectId, task, state) {
+    this.db.query("UPDATE claims SET team_state = ? WHERE project_id = ? AND task = ?").run(state, projectId, task);
+  }
+  revokeClaimConflict(projectId, task, holder) {
+    const row = this.db.query("SELECT state FROM claims WHERE project_id = ? AND task = ?").get(projectId, task);
+    if (row?.state !== "held")
+      return;
+    const now = new Date().toISOString();
+    this.db.query("UPDATE claims SET state = 'released', released_at = ?, team_state = 'conflict' WHERE project_id = ? AND task = ?").run(now, projectId, task);
+    this.append({
+      ts: now,
+      type: "claim.released",
+      projectId,
+      sessionId: null,
+      payload: { task, summary: `revoked \u2014 the team ledger holds ${task} on ${holder}` }
+    });
+    this.append({
+      ts: now,
+      type: "incident.opened",
+      projectId,
+      sessionId: null,
+      payload: {
+        rule: "claim_conflict",
+        action: "revoked",
+        command: task,
+        reason: `the team daemon holds ${task} for ${holder}; the local claim was revoked \u2014 the worktree is untouched`
+      }
+    });
+  }
+  aiderCarries = new Map;
+  recoverAiderCarry(sessionId) {
+    const s = this.db.query("SELECT started_at, model, title FROM sessions WHERE id = ?").get(sessionId);
+    if (!s)
+      return null;
+    const t = this.db.query("SELECT COUNT(*) AS n FROM turns WHERE session_id = ?").get(sessionId);
+    return {
+      sessionId,
+      startMs: Date.parse(s.started_at) || 0,
+      model: s.model,
+      title: s.title,
+      turns: t.n,
+      text: "",
+      tools: [],
+      pending: null
+    };
+  }
+  tailAider(windowMs = 3 * 24 * 60 * 60000) {
+    const roots = this.db.query("SELECT DISTINCT root FROM projects WHERE root IS NOT NULL AND root != ''").all();
+    let n = 0;
+    for (const { root } of roots) {
+      const path = join8(root, ".aider.chat.history.md");
+      let mtime;
+      try {
+        mtime = statSync(path).mtimeMs;
+      } catch {
+        continue;
+      }
+      if (mtime < Date.now() - windowMs)
+        continue;
+      const row = this.db.query("SELECT offset, session_id FROM tails WHERE path = ?").get(path);
+      const r = this.readFrom(path, row?.offset ?? 0);
+      if (!r)
+        continue;
+      let carry = this.aiderCarries.get(path) ?? null;
+      if (!carry && row?.session_id)
+        carry = this.recoverAiderCarry(row.session_id);
+      const { segments, carry: next } = parseAiderHistory(r.chunk, path, carry);
+      this.aiderCarries.set(path, next);
+      const lastSeg = segments.at(-1);
+      for (const seg of segments) {
+        this.ensureAgentSession(seg.sessionId, "aider", root, seg.startMs || mtime);
+        this.persistTurns(seg.sessionId, null, seg.turns);
+        const live = seg === lastSeg && Date.now() - mtime < 90000;
+        const lastSeen = new Date(seg === lastSeg ? mtime : seg.startMs + seg.turns.length * 1000).toISOString();
+        const lastText = [...seg.turns].reverse().find((t) => t.text)?.text ?? null;
+        this.db.query("UPDATE sessions SET title = COALESCE(title, ?), model = COALESCE(?, model), last_text = COALESCE(?, last_text), last_seen_at = ?, state = ?, ended_at = CASE WHEN ? = 'ended' AND ended_at IS NULL THEN ? ELSE ended_at END WHERE id = ?").run(seg.title, seg.model, lastText, lastSeen, live ? "active" : "ended", live ? "active" : "ended", lastSeen, seg.sessionId);
+        n += seg.turns.length;
+      }
+      this.db.query("INSERT INTO tails (path, session_id, agent_id, offset) VALUES (?, ?, NULL, ?) ON CONFLICT(path) DO UPDATE SET offset = excluded.offset, session_id = excluded.session_id").run(path, lastSeg?.sessionId ?? row?.session_id ?? null, r.next);
+    }
+    return n;
+  }
+  ocDbs = new Map;
+  tailOpencode(windowMs = 3 * 24 * 60 * 60000) {
+    const dir = process.env.SWARM_OPENCODE_DIR ?? join8(process.env.XDG_DATA_HOME ?? join8(homedir3(), ".local", "share"), "opencode");
+    let files;
+    try {
+      files = readdirSync(dir).filter((f) => /^opencode[^/]*\.db$/.test(f));
+    } catch {
+      return 0;
+    }
+    let n = 0;
+    for (const f of files) {
+      const path = join8(dir, f);
+      let db = this.ocDbs.get(path);
+      if (!db) {
+        try {
+          db = new Database(path, { readonly: true });
+        } catch {
+          continue;
         }
+        this.ocDbs.set(path, db);
+      }
+      const row = this.db.query("SELECT offset FROM tails WHERE path = ?").get(path);
+      const lower = Math.max(row?.offset ?? 0, Date.now() - windowMs);
+      let rows;
+      try {
+        rows = db.query(`SELECT m.id, m.session_id, m.time_created, m.time_updated, m.data,
+                    s.directory, s.title, s.parent_id
+             FROM message m JOIN session s ON s.id = m.session_id
+             WHERE m.time_updated > ? ORDER BY m.time_updated ASC LIMIT 2000`).all(lower);
+      } catch {
+        continue;
+      }
+      if (!rows.length)
+        continue;
+      let cursor = lower;
+      const bySession = new Map;
+      for (const m of rows) {
+        cursor = Math.max(cursor, m.time_updated ?? 0);
+        const g = bySession.get(m.session_id) ?? { rows: [], last: 0 };
+        g.rows.push(m);
+        g.last = Math.max(g.last, m.time_updated ?? m.time_created ?? 0);
+        bySession.set(m.session_id, g);
       }
+      for (const [sid, g] of bySession) {
+        const first = g.rows[0];
+        if (!first)
+          continue;
+        this.ensureAgentSession(sid, "opencode", first.directory ?? "", first.time_created ?? g.last);
+        const turns = g.rows.map((m) => opencodeTurn(sid, m.id, m.data, m.time_created ?? 0, first.parent_id != null)).filter((t) => t != null);
+        this.persistTurns(sid, null, turns);
+        const live = Date.now() - g.last < 90000;
+        const lastSeen = new Date(g.last).toISOString();
+        const lastText = [...turns].reverse().find((t) => t.text)?.text ?? null;
+        const model = [...turns].reverse().find((t) => t.model !== "opencode")?.model ?? null;
+        this.db.query("UPDATE sessions SET title = COALESCE(?, title), model = COALESCE(?, model), last_text = COALESCE(?, last_text), last_seen_at = ?, state = ?, ended_at = CASE WHEN ? = 'ended' AND ended_at IS NULL THEN ? ELSE ended_at END WHERE id = ?").run(first.title, model, lastText, lastSeen, live ? "active" : "ended", live ? "active" : "ended", lastSeen, sid);
+        n += turns.length;
+      }
+      this.db.query("INSERT INTO tails (path, session_id, agent_id, offset) VALUES (?, NULL, NULL, ?) ON CONFLICT(path) DO UPDATE SET offset = excluded.offset").run(path, cursor);
     }
     return n;
   }
@@ -7144,7 +8839,8 @@ ${err}
       acquiredAt: r.acquired_at,
       expiresAt: r.expires_at,
       releasedAt: r.released_at ?? null,
-      state: r.state
+      state: r.state,
+      sessionId: r.actor_kind === "agent" ? r.actor_id ?? null : null
     }));
     const now = Date.now();
     for (const c of rows)
@@ -7272,6 +8968,507 @@ ${err}
       expiresAt: r.expires_at
     }));
   }
+  waiting(projectId, days3 = 7) {
+    const since = new Date(Date.now() - days3 * 86400000).toISOString();
+    const pArgs = projectId ? [projectId] : [];
+    const paired = this.db.query(`SELECT type, session_id, project_id, ts,
+                COALESCE(json_extract(payload,'$.requestId'), json_extract(payload,'$.id')) AS key,
+                COALESCE(json_extract(payload,'$.tool'), json_extract(payload,'$.text')) AS label
+         FROM events
+         WHERE type IN ('permission.requested','permission.resolved','question.asked','question.answered')
+           AND ts >= ?${projectId ? " AND project_id = ?" : ""}`).all(since, ...pArgs);
+    const notes = this.db.query(`SELECT n.seq, n.session_id, n.project_id, n.ts,
+                json_extract(n.payload,'$.summary') AS label,
+                (SELECT MIN(a.ts) FROM events a
+                  WHERE a.session_id = n.session_id AND a.seq > n.seq
+                    AND a.type IN ('prompt.submitted','tool.requested')) AS resumed
+         FROM events n
+         WHERE n.type = 'session.notification' AND n.ts >= ?${projectId ? " AND n.project_id = ?" : ""}`).all(since, ...pArgs);
+    const samples = [];
+    for (const r of paired) {
+      if (!r.session_id || r.key === null)
+        continue;
+      const kind = r.type.startsWith("permission") ? "permission" : "question";
+      samples.push({
+        sessionId: r.session_id,
+        projectId: r.project_id,
+        kind,
+        key: String(r.key),
+        phase: r.type.endsWith(".requested") || r.type.endsWith(".asked") ? "start" : "end",
+        ts: r.ts,
+        ...r.label ? { label: r.label.slice(0, 120) } : {}
+      });
+    }
+    for (const n of notes) {
+      if (!n.session_id)
+        continue;
+      const key = String(n.seq);
+      samples.push({
+        sessionId: n.session_id,
+        projectId: n.project_id,
+        kind: "notification",
+        key,
+        phase: "start",
+        ts: n.ts,
+        ...n.label ? { label: n.label.slice(0, 120) } : {}
+      });
+      if (n.resumed)
+        samples.push({
+          sessionId: n.session_id,
+          projectId: n.project_id,
+          kind: "notification",
+          key,
+          phase: "end",
+          ts: n.resumed
+        });
+    }
+    const ends = {};
+    for (const r of this.db.query("SELECT id, ended_at FROM sessions WHERE ended_at IS NOT NULL").all())
+      ends[r.id] = r.ended_at;
+    const report = waitingReport(pairWaits(samples, new Date().toISOString(), ends));
+    const meta = new Map(this.db.query("SELECT id, title, agent, project_id FROM sessions").all().map((r) => [r.id, r]));
+    return {
+      ...report,
+      sessions: report.sessions.map((s) => ({
+        ...s,
+        title: meta.get(s.sessionId)?.title ?? null,
+        agent: meta.get(s.sessionId)?.agent ?? "claude-code",
+        projectId: s.projectId ?? meta.get(s.sessionId)?.project_id ?? null
+      }))
+    };
+  }
+  gateHealth(projectId, days3 = 30) {
+    const since = new Date(Date.now() - days3 * 86400000).toISOString();
+    const rows = this.db.query(`SELECT project_id, task, gate, verdict, duration_ms, created_at FROM gates
+         WHERE created_at >= ?${projectId ? " AND project_id = ?" : ""}`).all(...projectId ? [since, projectId] : [since]);
+    return gateHealth(rows.filter((r) => r.verdict === "pass" || r.verdict === "fail").map((r) => ({
+      projectId: r.project_id,
+      task: r.task,
+      gate: r.gate,
+      verdict: r.verdict,
+      durationMs: r.duration_ms,
+      at: r.created_at
+    })));
+  }
+  static worktreeIdleMs(path) {
+    let newest = 0;
+    for (const f of [path, join8(path, ".git")]) {
+      try {
+        newest = Math.max(newest, statSync(f).mtimeMs);
+      } catch {}
+    }
+    return newest ? Math.max(0, Date.now() - newest) : null;
+  }
+  duCache = new Map;
+  duInflight = null;
+  refreshDisk(paths, ttlMs) {
+    if (this.duInflight)
+      return;
+    const stale = paths.filter((p) => {
+      const hit = this.duCache.get(p);
+      return !hit || Date.now() - hit.t >= ttlMs;
+    });
+    if (!stale.length)
+      return;
+    this.duInflight = (async () => {
+      for (const path of stale) {
+        let v = null;
+        try {
+          const proc = Bun.spawn(["du", "-sk", "-x", path], { stdout: "pipe", stderr: "ignore" });
+          const out = await new Response(proc.stdout).text();
+          if (await proc.exited === 0) {
+            const n = Number.parseInt(out.trim().split(/\s+/)[0] ?? "", 10);
+            if (Number.isFinite(n))
+              v = n;
+          }
+        } catch {}
+        this.duCache.set(path, { v, t: Date.now() });
+      }
+    })().finally(() => {
+      this.duInflight = null;
+    });
+  }
+  hygiene(projectId, diskTtlMs = 600000) {
+    const rows = this.db.query(`SELECT * FROM processes WHERE ended_at IS NULL${projectId ? " AND project_id = ?" : ""}
+           ORDER BY started_at DESC`).all(...projectId ? [projectId] : []).map((r) => this.rowToProcess(r));
+    const usage = new Map;
+    if (rows.length) {
+      try {
+        const out = Bun.spawnSync([
+          "ps",
+          "-o",
+          "pid=,pcpu=,rss=",
+          "-p",
+          rows.map((r) => r.pid).join(",")
+        ]);
+        for (const line of new TextDecoder().decode(out.stdout).split(`
+`)) {
+          const [pid, cpu, rss] = line.trim().split(/\s+/);
+          if (pid)
+            usage.set(Number(pid), { cpu: Number(cpu) || 0, rss: Number(rss) || 0 });
+        }
+      } catch {}
+    }
+    const liveSessionIds = new Set(this.db.query("SELECT id FROM sessions WHERE ended_at IS NULL AND state IN ('active','waiting')").all().map((r) => r.id));
+    const procs = rows.map((p) => {
+      const u = usage.get(p.pid);
+      return {
+        pid: p.pid,
+        name: p.name,
+        kind: p.kind,
+        projectId: p.projectId,
+        sessionId: p.sessionId,
+        port: p.port,
+        startedAt: p.startedAt,
+        alive: this.processIsOurs(p),
+        sessionLive: !p.sessionId || liveSessionIds.has(p.sessionId),
+        cpuPct: u ? u.cpu : null,
+        rssKb: u ? u.rss : null
+      };
+    });
+    const projects = projectId ? [projectId] : this.projects().map((p) => p.id);
+    const claims = this.claims().filter((c) => c.state !== "released");
+    const trees = [];
+    for (const pid of projects)
+      for (const w of this.worktrees(pid)) {
+        const held = claims.find((c) => c.worktree === w.path);
+        trees.push({
+          projectId: pid,
+          path: w.path,
+          branch: w.branch,
+          main: w.main,
+          dirty: w.dirty,
+          ahead: w.ahead,
+          merged: w.merged,
+          idleMs: Store.worktreeIdleMs(w.path),
+          diskKb: this.duCache.get(w.path)?.v ?? null,
+          heldByClaim: held?.task ?? null,
+          liveSessions: this.sessions().filter((s) => s.cwd?.startsWith(w.path) && !s.endedAt && s.state !== "ended").length
+        });
+      }
+    this.refreshDisk(trees.map((t) => t.path), diskTtlMs);
+    return hygieneReport(procs, trees);
+  }
+  lineage(projectId, days3 = 14, expanded = []) {
+    const since = new Date(Date.now() - days3 * 86400000).toISOString();
+    const pArgs = projectId ? [projectId] : [];
+    const rows = this.db.query(`SELECT id, project_id, title, agent, kind, state, parent_id, started_at, ended_at
+         FROM sessions WHERE last_seen_at >= ?${projectId ? " AND project_id = ?" : ""}`).all(since, ...pArgs);
+    const cost = new Map(this.db.query("SELECT session_id, SUM(cost_usd) AS c FROM turns WHERE ts >= ? GROUP BY session_id").all(since).map((r) => [r.session_id, r.c]));
+    const sessions = rows.map((r) => ({
+      id: r.id,
+      projectId: r.project_id,
+      title: r.title,
+      agent: r.agent ?? "claude-code",
+      kind: r.kind,
+      state: r.state,
+      startedAt: r.started_at,
+      endedAt: r.ended_at,
+      costUsd: cost.get(r.id) ?? null,
+      outcome: null
+    }));
+    const known = new Set(sessions.map((s) => s.id));
+    const edges = [];
+    for (const a of this.db.query(`SELECT t.session_id, t.agent_id, MIN(t.ts) AS first_ts, MAX(t.ts) AS last_ts,
+                SUM(t.cost_usd) AS cost, COUNT(*) AS turns
+         FROM turns t WHERE t.agent_id IS NOT NULL AND t.ts >= ?
+         GROUP BY t.session_id, t.agent_id`).all(since)) {
+      const parent = sessions.find((x) => x.id === a.session_id);
+      if (!parent)
+        continue;
+      const id = `sub:${a.session_id}:${a.agent_id}`;
+      sessions.push({
+        id,
+        projectId: parent.projectId,
+        title: `subagent ${a.agent_id.slice(0, 8)} \xB7 ${a.turns} turn${a.turns === 1 ? "" : "s"}`,
+        agent: parent.agent,
+        kind: "subagent",
+        state: "ended",
+        startedAt: a.first_ts,
+        endedAt: a.last_ts,
+        costUsd: a.cost,
+        outcome: null
+      });
+      known.add(id);
+      edges.push({ from: a.session_id, to: id, kind: "subagent", at: a.first_ts });
+    }
+    for (const d of this.db.query(`SELECT session_id, ts, json_extract(payload,'$.by') AS by, json_extract(payload,'$.task') AS task
+         FROM events WHERE type = 'dispatch.started' AND ts >= ?${projectId ? " AND project_id = ?" : ""}`).all(since, ...pArgs)) {
+      if (!d.session_id || !d.by)
+        continue;
+      const a = actorFrom(d.by, null);
+      if (a.kind === "agent" && known.has(a.id) && a.id !== d.session_id)
+        edges.push({ from: a.id, to: d.session_id, kind: "dispatch", at: d.ts, label: d.task });
+    }
+    for (const m of this.db.query(`SELECT session_id, ts, json_extract(payload,'$.recipient') AS to_session,
+                json_extract(payload,'$.text') AS text
+         FROM events WHERE type = 'message.sent' AND ts >= ?${projectId ? " AND project_id = ?" : ""}`).all(since, ...pArgs))
+      if (m.session_id && m.to_session)
+        edges.push({
+          from: m.session_id,
+          to: m.to_session,
+          kind: "message",
+          at: m.ts,
+          label: m.text?.slice(0, 80) ?? null
+        });
+    const holds = this.db.query(`SELECT task, project_id, actor_kind, actor_id, acquired_at FROM claims
+           WHERE acquired_at >= ?${projectId ? " AND project_id = ?" : ""}`).all(since, ...pArgs).map((c) => ({
+      task: c.task,
+      projectId: c.project_id,
+      sessionId: c.actor_kind === "agent" ? c.actor_id : null,
+      at: c.acquired_at
+    }));
+    edges.push(...handoffEdges(holds));
+    return lineageGraph(sessions, edges, { expanded });
+  }
+  mcpHealth(projectId, days3 = 7) {
+    const since = new Date(Date.now() - days3 * 86400000).toISOString();
+    const rows = this.db.query(`SELECT session_id, seq, ts, type,
+                json_extract(payload,'$.tool') AS tool,
+                json_extract(payload,'$.toolResponse') AS response
+         FROM events
+         WHERE type IN ('tool.requested','tool.completed') AND ts >= ?
+           AND json_extract(payload,'$.tool') IS NOT NULL${projectId ? " AND project_id = ?" : ""}
+         ORDER BY session_id, seq`).all(...projectId ? [since, projectId] : [since]);
+    const calls = [];
+    const pending = new Map;
+    const abandon = (sessionId, tool, at) => {
+      calls.push({ sessionId, tool, ms: null, errored: false, at });
+    };
+    for (const r of rows) {
+      if (!r.session_id)
+        continue;
+      const perSession = pending.get(r.session_id) ?? new Map;
+      pending.set(r.session_id, perSession);
+      if (r.type === "tool.requested") {
+        const open = perSession.get(r.tool);
+        if (open)
+          abandon(r.session_id, r.tool, open);
+        perSession.set(r.tool, r.ts);
+        continue;
+      }
+      const startedAt = perSession.get(r.tool);
+      perSession.delete(r.tool);
+      calls.push({
+        sessionId: r.session_id,
+        tool: r.tool,
+        ms: startedAt ? Math.max(0, new Date(r.ts).getTime() - new Date(startedAt).getTime()) : null,
+        errored: toolResponseErrored(safeJson(r.response)),
+        at: r.ts
+      });
+    }
+    for (const [sessionId, perSession] of pending)
+      for (const [tool, at] of perSession)
+        abandon(sessionId, tool, at);
+    return mcpHealth(calls);
+  }
+  context(projectId, days3 = 7) {
+    const since = new Date(Date.now() - days3 * 86400000).toISOString();
+    const pArgs = projectId ? [projectId] : [];
+    const where = projectId ? " AND project_id = ?" : "";
+    const results = this.db.query(`SELECT session_id, json_extract(payload,'$.tool') AS tool,
+                  LENGTH(json_extract(payload,'$.toolResponse')) AS chars
+           FROM events
+           WHERE type = 'tool.completed' AND ts >= ?${where}
+             AND json_extract(payload,'$.tool') IS NOT NULL
+             AND json_extract(payload,'$.toolResponse') IS NOT NULL`).all(since, ...pArgs).filter((r) => r.session_id).map((r) => ({ sessionId: r.session_id, tool: r.tool, chars: r.chars ?? 0 }));
+    const reads = this.db.query(`SELECT req.session_id,
+                  json_extract(req.payload,'$.toolInput.file_path') AS path,
+                  (SELECT LENGTH(json_extract(done.payload,'$.toolResponse')) FROM events done
+                    WHERE done.session_id = req.session_id AND done.seq > req.seq
+                      AND done.type = 'tool.completed'
+                      AND json_extract(done.payload,'$.tool') = 'Read'
+                    ORDER BY done.seq LIMIT 1) AS chars
+           FROM events req
+           WHERE req.type = 'tool.requested' AND json_extract(req.payload,'$.tool') = 'Read'
+             AND req.ts >= ?${where.replace("project_id", "req.project_id")}
+             AND json_extract(req.payload,'$.toolInput.file_path') IS NOT NULL`).all(since, ...pArgs).filter((r) => r.session_id).map((r) => ({ sessionId: r.session_id, path: r.path, chars: r.chars ?? 0 }));
+    const turns = this.db.query(`SELECT t.session_id, SUM(t.input) AS input, SUM(t.cache_read) AS cache_read,
+                  SUM(t.cache_write) AS cache_write, SUM(t.thinking) AS thinking, SUM(t.output) AS output
+           FROM turns t${projectId ? " JOIN sessions s ON s.id = t.session_id" : ""}
+           WHERE t.ts >= ?${projectId ? " AND s.project_id = ?" : ""}
+           GROUP BY t.session_id`).all(since, ...pArgs).map((r) => ({
+      sessionId: r.session_id,
+      input: r.input ?? 0,
+      cacheRead: r.cache_read ?? 0,
+      cacheWrite: r.cache_write ?? 0,
+      thinking: r.thinking ?? 0,
+      output: r.output ?? 0
+    }));
+    const report = contextReport(results, reads, turns);
+    const meta = new Map(this.db.query("SELECT id, title, agent FROM sessions").all().map((r) => [r.id, r]));
+    return {
+      ...report,
+      sessions: report.sessions.map((s) => ({
+        ...s,
+        title: meta.get(s.sessionId)?.title ?? null,
+        agent: meta.get(s.sessionId)?.agent ?? "claude-code"
+      }))
+    };
+  }
+  abTrials(projectId) {
+    const projects = projectId ? [projectId] : this.projects().map((p) => p.id);
+    const out = [];
+    for (const pid of projects) {
+      const tasks2 = [
+        ...new Set(this.claims(pid).map((c) => splitArmTask(c.task)).filter((x) => x.arm).map((x) => x.task))
+      ];
+      for (const t of tasks2.sort())
+        out.push({ ...this.abTrial(pid, t), projectId: pid });
+    }
+    const rank = { undecided: 0, "all-failed": 1, winner: 2 };
+    return out.sort((a, b) => rank[a.verdict] - rank[b.verdict] || b.totals.costUsd - a.totals.costUsd);
+  }
+  diffCache = new Map;
+  diffInflight = null;
+  refreshDiffs(worktrees, base, ttlMs = 30000) {
+    if (this.diffInflight)
+      return;
+    const stale = worktrees.filter((w) => {
+      const hit = this.diffCache.get(w);
+      return !hit || Date.now() - hit.t >= ttlMs;
+    });
+    if (!stale.length)
+      return;
+    this.diffInflight = (async () => {
+      for (const wt of stale) {
+        let v = null;
+        try {
+          const proc = Bun.spawn(["git", "diff", "--shortstat", `${base}...HEAD`], {
+            cwd: wt,
+            stdout: "pipe",
+            stderr: "ignore"
+          });
+          const out = await new Response(proc.stdout).text();
+          if (await proc.exited === 0) {
+            const f = /(\d+) files? changed/.exec(out)?.[1];
+            const i = /(\d+) insertions?/.exec(out)?.[1];
+            const d = /(\d+) deletions?/.exec(out)?.[1];
+            v = [Number(f ?? 0), Number(i ?? 0), Number(d ?? 0)];
+          }
+        } catch {}
+        this.diffCache.set(wt, { v, t: Date.now() });
+      }
+    })().finally(() => {
+      this.diffInflight = null;
+    });
+  }
+  abTrial(projectId, task) {
+    const claims = this.claims(projectId).filter((c) => splitArmTask(c.task).task === task);
+    const all = this.sessions();
+    const sessions = new Map(all.map((s) => [s.id, s]));
+    const byCwd = new Map;
+    for (const s of all)
+      if (s.cwd && !byCwd.has(s.cwd))
+        byCwd.set(s.cwd, s);
+    const gateRuns = this.gateRuns(projectId, undefined, 2000);
+    const arms = [];
+    for (const c of claims) {
+      const label = splitArmTask(c.task).arm;
+      if (!label)
+        continue;
+      const sess = (c.worktree ? byCwd.get(c.worktree) : undefined) ?? (c.sessionId ? sessions.get(c.sessionId) : undefined);
+      const sid = sess?.id ?? c.sessionId;
+      const g = gateRuns.filter((x) => x.task === c.task);
+      const latest = new Map;
+      for (const run2 of [...g].sort((a, b) => a.createdAt < b.createdAt ? -1 : 1))
+        latest.set(run2.gate, run2);
+      const verdicts = [...latest.values()];
+      const diff = c.worktree ? this.diffCache.get(c.worktree)?.v : null;
+      arms.push({
+        label,
+        task: c.task,
+        model: sess?.model ?? null,
+        agent: sess?.agent ?? "claude-code",
+        sessionId: sid,
+        worktree: c.worktree || null,
+        startedAt: c.acquiredAt,
+        endedAt: sess?.endedAt ?? null,
+        state: sess && sess.state !== "ended" ? "running" : sess ? "done" : c.state === "held" ? "running" : "failed",
+        costUsd: sess?.costUsd ?? 0,
+        turns: sess?.turns ?? 0,
+        gatesPassed: verdicts.filter((v) => v.verdict === "pass").length,
+        gatesFailed: verdicts.filter((v) => v.verdict === "fail").length,
+        filesChanged: diff ? diff[0] : null,
+        insertions: diff ? diff[1] : null,
+        deletions: diff ? diff[2] : null
+      });
+    }
+    const base = this.worktrees(projectId).find((w) => w.main)?.branch ?? "main";
+    this.refreshDiffs(arms.map((a) => a.worktree).filter((w) => !!w), base);
+    return scoreTrial(task, arms);
+  }
+  collisions(projectId) {
+    const cutoff = new Date(Date.now() - IDLE_MS).toISOString();
+    const live = this.db.query(`SELECT id, project_id, title, agent, kind FROM sessions
+         WHERE state IN ('active','waiting') AND ended_at IS NULL AND last_seen_at >= ?${projectId ? " AND project_id = ?" : ""}`).all(...projectId ? [cutoff, projectId] : [cutoff]);
+    if (!live.length)
+      return { sessions: [], files: [], contested: 0 };
+    const rows = this.db.query(`SELECT session_id, json_extract(payload,'$.tool') AS tool, json_extract(payload,'$.toolInput.file_path') AS path
+         FROM events WHERE type = 'tool.requested' AND session_id IN (${live.map(() => "?").join(",")})
+           AND json_extract(payload,'$.toolInput.file_path') IS NOT NULL`).all(...live.map((s) => s.id));
+    const g = collisionGraph(rows.map((r) => ({ sessionId: r.session_id, tool: r.tool ?? "", path: r.path ?? "" })));
+    const meta = new Map(live.map((s) => [s.id, s]));
+    return {
+      ...g,
+      sessions: g.sessions.map((s) => {
+        const m = meta.get(s.id);
+        return {
+          ...s,
+          title: m?.title ?? null,
+          agent: m?.agent ?? "claude-code",
+          projectId: m?.project_id ?? null
+        };
+      })
+    };
+  }
+  stalls = new Map;
+  checkStalls() {
+    const live = this.db.query("SELECT id, project_id FROM sessions WHERE state IN ('active','waiting') AND ended_at IS NULL AND last_seen_at >= ?").all(new Date(Date.now() - IDLE_MS).toISOString());
+    const liveIds = new Set(live.map((s) => s.id));
+    for (const id of [...this.stalls.keys()])
+      if (!liveIds.has(id))
+        this.stalls.delete(id);
+    let flagged = 0;
+    for (const s of live) {
+      const rows = this.db.query("SELECT payload FROM events WHERE session_id = ? AND type = 'tool.completed' ORDER BY seq DESC LIMIT 12").all(s.id);
+      const calls = rows.reverse().map((r) => {
+        let p = {};
+        try {
+          p = JSON.parse(r.payload || "{}");
+        } catch {}
+        return {
+          tool: typeof p.tool === "string" ? p.tool : "?",
+          input: JSON.stringify(p.toolInput ?? null),
+          errored: toolResponseErrored(p.toolResponse),
+          ts: ""
+        };
+      });
+      const stall2 = detectStall(calls);
+      if (!stall2) {
+        this.stalls.delete(s.id);
+        continue;
+      }
+      flagged++;
+      const prev = this.stalls.get(s.id);
+      this.stalls.set(s.id, stall2);
+      if (prev?.kind === stall2.kind)
+        continue;
+      this.append({
+        ts: new Date().toISOString(),
+        type: "session.stuck",
+        projectId: s.project_id,
+        sessionId: s.id,
+        payload: {
+          kind: stall2.kind,
+          reason: stall2.reason,
+          summary: `session looks stuck \u2014 ${stall2.reason}`
+        }
+      });
+      this.touch();
+    }
+    return flagged;
+  }
   sweepOrphans() {
     const now = Date.now();
     let n = 0;
@@ -7649,6 +9846,7 @@ ${err}
         lastType: r.last_type,
         lastText: r.last_text ?? null,
         state,
+        stuck: state === "active" || state === "waiting" ? this.stalls.get(r.id)?.reason ?? null : null,
         toolCalls: r.tool_calls,
         subagents: r.subagents,
         turns: r.turns,
@@ -7713,8 +9911,120 @@ ${err}
           fn(p.id, b.status);
       this.touch();
     }
+    for (const b of this.teamBudgets()) {
+      if (b.level === "ok")
+        continue;
+      const mapKey = `team:${b.scope}:${b.key}`;
+      const seen = `${day}:${b.level}`;
+      const affected = b.scope === "project" ? this.projects().filter((p) => this.clusterKeyFor(p.id) === b.key) : this.projects();
+      if (this.budgetNotified.get(mapKey) !== seen) {
+        this.budgetNotified.set(mapKey, seen);
+        const label = b.scope === "org" ? "the org" : `${b.scope} ${b.key}`;
+        this.append({
+          ts: new Date().toISOString(),
+          type: "incident.opened",
+          projectId: affected[0]?.id ?? "p_unknown",
+          sessionId: null,
+          payload: {
+            rule: "budget",
+            action: b.level === "exceeded" ? b.on_exceed : "warn",
+            command: `team ${b.kind ?? ""} budget \xB7 ${label}`,
+            reason: b.level === "exceeded" ? `${label} spent $${b.spent.toFixed(2)} of the $${b.limit} ${b.kind} ceiling set on the team daemon. ${b.on_exceed === "stop" ? "Spawned runs were stopped." : b.on_exceed === "ask" ? "Every Bash/Edit/Write now asks first." : "An admin can raise it via POST /t1/budgets."}` : `${label} is at $${b.spent.toFixed(2)} of the $${b.limit} ${b.kind} ceiling \u2014 approaching the team's limit`
+          }
+        });
+        this.touch();
+      }
+      if (b.level === "exceeded" && b.on_exceed === "stop")
+        for (const p of affected)
+          for (const fn of this.budgetListeners)
+            fn(p.id, {
+              level: "exceeded",
+              kind: b.kind === "daily" ? "daily" : "weekly",
+              spent: b.spent,
+              limit: b.limit,
+              pct: b.limit ? b.spent / b.limit : 1,
+              daily: { spent: b.spent, limit: b.limit, pct: 1 },
+              weekly: { spent: 0, limit: null, pct: 0 }
+            });
+    }
     return out;
   }
+  teamBudgets() {
+    try {
+      return JSON.parse(this.metaValue("team_budget") ?? "[]");
+    } catch {
+      return [];
+    }
+  }
+  backupTo(destDir) {
+    mkdirSync4(destDir, { recursive: true });
+    const files = [];
+    const dbDest = join8(destDir, "swarm.db");
+    if (existsSync6(dbDest))
+      unlinkSync(dbDest);
+    this.db.exec(`VACUUM INTO '${dbDest.replaceAll("'", "''")}'`);
+    files.push("swarm.db");
+    for (const f of [
+      "config.toml",
+      "policy.toml",
+      "policy.sig.json",
+      "token",
+      "pricing.json",
+      "pricing.litellm.json",
+      "team-token"
+    ]) {
+      const src = join8(this.home, f);
+      if (!existsSync6(src))
+        continue;
+      copyFileSync(src, join8(destDir, f));
+      files.push(f);
+    }
+    return { dest: destDir, files };
+  }
+  clusterKeyCache = new Map;
+  clusterKeyFor(projectId) {
+    const hit = this.clusterKeyCache.get(projectId);
+    if (hit)
+      return hit;
+    const root = this.db.query("SELECT root FROM projects WHERE id = ?").get(projectId)?.root;
+    const key = root && clusterProjectKey(originUrl(root)) || `local:${projectId}`;
+    this.clusterKeyCache.set(projectId, key);
+    return key;
+  }
+  taskSpendRollup(day = new Date().toISOString().slice(0, 10)) {
+    return this.db.query(`SELECT s.project_id AS projectId, c.task AS task, SUM(t.cost_usd) AS cost
+         FROM turns t JOIN sessions s ON s.id = t.session_id
+         JOIN claims c ON c.project_id = s.project_id AND c.worktree != '' AND (s.cwd = c.worktree OR s.cwd LIKE c.worktree || '/%')
+         WHERE t.ts >= ? AND t.ts < ? GROUP BY s.project_id, c.task`).all(`${day}T00:00:00.000Z`, `${day}T23:59:59.999Z`);
+  }
+  modelFlagged = new Set;
+  checkModels() {
+    const since = new Date(Date.now() - IDLE_MS).toISOString();
+    const rows = this.db.query("SELECT id, project_id, model FROM sessions WHERE model IS NOT NULL AND model != '' AND state != 'ended' AND last_seen_at > ?").all(since);
+    let n = 0;
+    for (const s of rows) {
+      if (this.modelFlagged.has(s.id))
+        continue;
+      const allow = this.config(s.project_id).models.allow;
+      if (!allow.length || modelAllowed(s.model, allow))
+        continue;
+      this.modelFlagged.add(s.id);
+      n++;
+      this.append({
+        ts: new Date().toISOString(),
+        type: "incident.opened",
+        projectId: s.project_id,
+        sessionId: s.id,
+        payload: {
+          rule: "model_allowlist",
+          action: "observed",
+          command: s.model,
+          reason: `session runs on "${s.model}", outside [models] allow (${allow.join(", ")}) \u2014 nothing was interrupted; spawned runs on this model are refused`
+        }
+      });
+    }
+    return n;
+  }
   spend() {
     const dayStart = new Date;
     dayStart.setHours(0, 0, 0, 0);
@@ -7862,6 +10172,16 @@ ${err}
          WHERE e.type = 'incident.opened' AND a.seq IS NULL${projectId ? " AND e.project_id = ?" : ""}`).get(...projectId ? [projectId] : []);
     return r.n;
   }
+  openIncidentsByProject() {
+    const rows = this.db.query(`SELECT e.project_id AS pid, COUNT(*) AS n FROM events e
+         LEFT JOIN incident_acks a ON a.seq = e.seq
+         WHERE e.type = 'incident.opened' AND a.seq IS NULL AND e.project_id IS NOT NULL
+         GROUP BY e.project_id`).all();
+    const out = {};
+    for (const r of rows)
+      out[r.pid] = r.n;
+    return out;
+  }
   ackIncident(seq, by) {
     const row = this.db.query("SELECT seq FROM events WHERE seq = ? AND type = 'incident.opened'").get(seq);
     if (!row)
@@ -8185,14 +10505,14 @@ ${err}
     const from = localDayIso(-13);
     const rows = this.db.query(`SELECT s.project_id AS pid, substr(t.ts, 1, 10) AS day, SUM(t.cost_usd) AS usd
          FROM turns t JOIN sessions s ON s.id = t.session_id WHERE t.ts >= ? GROUP BY pid, day`).all(from);
-    const days2 = [];
+    const days3 = [];
     for (let i = 13;i >= 0; i--)
-      days2.push(localDayIso(-i).slice(0, 10));
+      days3.push(localDayIso(-i).slice(0, 10));
     const out = {};
     for (const r of rows) {
       out[r.pid] ??= new Array(14).fill(0);
       const arr = out[r.pid];
-      const i = days2.indexOf(r.day);
+      const i = days3.indexOf(r.day);
       if (i >= 0)
         arr[i] = (arr[i] ?? 0) + (r.usd ?? 0);
     }
@@ -8213,12 +10533,22 @@ ${err}
       processes: this.memoised("processes", 5000, () => this.processes()),
       incidents: this.memoised("incidents", 30000, () => this.incidents(20, { open: true })),
       openIncidents: this.memoised("openIncidents", 30000, () => this.openIncidents()),
+      openIncidentsByProject: this.memoised("openIncidentsByProject", 30000, () => this.openIncidentsByProject()),
       questions: this.questions({ open: true, limit: 50 }),
       resources: this.resources(),
       seq: this.seq()
     };
   }
 }
+function safeJson(v) {
+  if (v === null)
+    return null;
+  try {
+    return JSON.parse(v);
+  } catch {
+    return v;
+  }
+}
 var WIRE_COLS = "seq, ts, type, project_id, session_id, actor_kind, actor_id, json_remove(payload, '$.toolInput', '$.toolResponse', '$.prompt') AS payload";
 var RAW_TOOL_KEYS = ["tool_input", "tool_response", "toolInput", "toolResponse", "toolResult"];
 var TOOL_INPUT_MAX = 2048;
@@ -8344,6 +10674,192 @@ function localDayIso(offsetDays) {
   return d.toISOString();
 }
 
+// packages/daemon/src/team.ts
+import { writeFileSync as writeFileSync3 } from "fs";
+import { join as join9 } from "path";
+var SPEND_EVERY_MS = 60000;
+var MAX_BACKOFF_MS = 300000;
+var POLICY_EVERY_MS = 300000;
+
+class TeamForwarder {
+  store;
+  version;
+  lastTry = 0;
+  backoffMs = 0;
+  lastSpend = 0;
+  constructor(store, version) {
+    this.store = store;
+    this.version = version;
+  }
+  projectKey(projectId) {
+    return this.store.clusterKeyFor(projectId);
+  }
+  status() {
+    const team2 = this.store.policyFor(null).config.team;
+    const box = this.store.outboxStatus();
+    return {
+      configured: team2.url != null,
+      url: team2.url,
+      forward: team2.forward,
+      pending: box.pending,
+      oldest: box.oldest,
+      lastAckAt: this.store.metaValue("team_last_ack") ?? null,
+      lastError: this.store.metaValue("team_last_error") ?? null,
+      machine: this.store.machineIdentity(),
+      authed: this.store.metaValue("team_machine_token") != null
+    };
+  }
+  async tick(now = Date.now()) {
+    const team2 = this.store.policyFor(null).config.team;
+    if (!team2.url)
+      return 0;
+    if (now - this.lastTry < team2.interval * 1000 + this.backoffMs)
+      return 0;
+    this.lastTry = now;
+    const records = [];
+    const events = team2.forward.includes("ledger") ? this.store.outboxPending() : [];
+    for (const e of events) {
+      const body = JSON.parse(e.payload);
+      if (typeof body.projectId === "string")
+        body.projectKey = this.projectKey(body.projectId);
+      records.push({ seq: e.seq, kind: e.kind, body });
+    }
+    let spendRows = 0;
+    if (team2.forward.includes("cost") && now - this.lastSpend > SPEND_EVERY_MS) {
+      const day = new Date(now).toISOString().slice(0, 10);
+      for (const r of this.store.spendRollup(day)) {
+        records.push({
+          seq: 0,
+          kind: "spend",
+          body: { day, ...r, projectKey: this.projectKey(r.projectId) }
+        });
+        spendRows++;
+      }
+      for (const r of this.store.taskSpendRollup(day)) {
+        records.push({
+          seq: 0,
+          kind: "spend_task",
+          body: { day, ...r, projectKey: this.projectKey(r.projectId) }
+        });
+        spendRows++;
+      }
+    }
+    const held = this.store.heldClaimsForSync();
+    if (!records.length && !held.length)
+      return 0;
+    const machine = { ...this.store.machineIdentity(), version: this.version };
+    const token = this.store.metaValue("team_machine_token");
+    const headers = {
+      "content-type": "application/json",
+      ...token ? { authorization: `Bearer ${token}` } : {}
+    };
+    const base = this.store.policyFor(null).config.team.url;
+    try {
+      if (records.length) {
+        const req = { machine, records };
+        const res = await fetch(`${base}/t1/ingest`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(req),
+          signal: AbortSignal.timeout(1e4)
+        });
+        if (!res.ok)
+          throw new Error(`ingest ${res.status}`);
+        const reply = await res.json();
+        if (reply.ack > 0)
+          this.store.outboxAck(reply.ack);
+        if (spendRows)
+          this.lastSpend = now;
+      }
+      if (held.length) {
+        const claims = held.map((c) => ({
+          projectKey: this.projectKey(c.projectId),
+          task: c.task,
+          acquiredAt: c.acquiredAt,
+          expiresAt: c.expiresAt,
+          actor: c.actorKind && c.actorId ? { kind: c.actorKind, id: c.actorId } : undefined
+        }));
+        const res = await fetch(`${base}/t1/claims`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ machine, claims }),
+          signal: AbortSignal.timeout(1e4)
+        });
+        if (!res.ok)
+          throw new Error(`claims ${res.status}`);
+        const reply = await res.json();
+        for (const r of reply.results) {
+          const local = held.find((c) => c.task === r.task && this.projectKey(c.projectId) === r.projectKey);
+          if (!local)
+            continue;
+          if (r.status === "ok") {
+            if (local.teamState !== "registered")
+              this.store.markClaimTeamState(local.projectId, local.task, "registered");
+          } else
+            this.store.revokeClaimConflict(local.projectId, local.task, r.holder);
+        }
+      }
+      try {
+        const res = await fetch(`${base}/t1/budget`, {
+          headers,
+          signal: AbortSignal.timeout(1e4)
+        });
+        if (res.ok) {
+          const { budgets } = await res.json();
+          this.store.setMetaValue("team_budget", JSON.stringify(budgets ?? []));
+        }
+      } catch {}
+      this.backoffMs = 0;
+      this.store.setMetaValue("team_last_ack", new Date(now).toISOString());
+      this.store.setMetaValue("team_last_error", "");
+      await this.syncPolicy(base, headers, now);
+      return records.length + held.length;
+    } catch (e) {
+      this.backoffMs = Math.min(this.backoffMs ? this.backoffMs * 2 : 5000, MAX_BACKOFF_MS);
+      this.store.setMetaValue("team_last_error", e.message);
+      return 0;
+    }
+  }
+  lastPolicy = 0;
+  async syncPolicy(base, headers, now) {
+    if (now - this.lastPolicy < POLICY_EVERY_MS)
+      return;
+    this.lastPolicy = now;
+    try {
+      const res = await fetch(`${base}/t1/policy`, {
+        headers,
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!res.ok)
+        return;
+      const { policy: policy2 } = await res.json();
+      if (!policy2)
+        return;
+      let pinned = this.store.metaValue("team_policy_pubkey");
+      if (!pinned) {
+        pinned = policy2.publicKey;
+        this.store.setMetaValue("team_policy_pubkey", pinned);
+      }
+      if (!verifyPolicySignature(policy2.toml, policy2.signature, pinned)) {
+        this.store.setMetaValue("team_last_error", "org policy signature invalid \u2014 not installed");
+        return;
+      }
+      const file = join9(this.store.home, "policy.toml");
+      const prev = this.store.metaValue("team_policy_sig");
+      if (prev === policy2.signature)
+        return;
+      writeFileSync3(file, policy2.toml, { mode: 384 });
+      writeFileSync3(join9(this.store.home, "policy.sig.json"), JSON.stringify({
+        signature: policy2.signature,
+        publicKey: pinned,
+        fetchedAt: new Date(now).toISOString(),
+        url: base
+      }), { mode: 384 });
+      this.store.setMetaValue("team_policy_sig", policy2.signature);
+    } catch {}
+  }
+}
+
 // packages/daemon/src/workflow.ts
 class WorkflowEngine {
   store;
@@ -8535,13 +11051,13 @@ class WorkflowEngine {
 }
 
 // packages/daemon/src/app.ts
-var VERSION = "0.9.0";
+var VERSION = "0.11.0";
 var WEB_DIR = (() => {
   if (process.env.SWARM_WEB_DIR)
     return process.env.SWARM_WEB_DIR;
   const here = dirname4(fileURLToPath2(import.meta.url));
-  const dev = join9(here, "../../web/public");
-  return existsSync7(join9(dev, "index.html")) ? dev : join9(here, "../web");
+  const dev = join10(here, "../../web/public");
+  return existsSync7(join10(dev, "index.html")) ? dev : join10(here, "../web");
 })();
 var REPLAY_TAIL = 200;
 var wireCache = new WeakMap;
@@ -8559,7 +11075,7 @@ function hookRepoRoot(store, raw2) {
 }
 function claudeSettings() {
   try {
-    const p = process.env.CLAUDE_SETTINGS ?? join9(homedir4(), ".claude", "settings.json");
+    const p = process.env.CLAUDE_SETTINGS ?? join10(homedir4(), ".claude", "settings.json");
     return existsSync7(p) ? JSON.parse(readFileSync4(p, "utf8")) : null;
   } catch {
     return null;
@@ -8570,7 +11086,7 @@ function diskVersion() {
     const entry = daemonCommand().at(-1);
     if (!entry || !existsSync7(entry))
       return null;
-    for (const f of [entry, join9(dirname4(entry), "app.ts")]) {
+    for (const f of [entry, join10(dirname4(entry), "app.ts")]) {
       if (!existsSync7(f))
         continue;
       const m = /SWARM_VERSION\s*\?\?\s*"(\d+\.\d+\.\d+)"/.exec(readFileSync4(f, "utf8"));
@@ -8588,6 +11104,7 @@ function createApp(store = new Store, hooks2 = {}) {
   const runner = new Runner(store, store.home);
   const dispatcher = new Dispatcher(store, runner, forge2);
   const workflows2 = new WorkflowEngine(store, runner, forge2);
+  const team2 = new TeamForwarder(store, VERSION);
   store.onBudgetStop((projectId) => {
     dispatcher.clear(projectId);
     for (const run2 of runner.list(projectId))
@@ -8650,7 +11167,7 @@ function createApp(store = new Store, hooks2 = {}) {
       dir = homedir4();
     }
     try {
-      const entries = readdirSync2(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({ name: e.name, repo: existsSync7(join9(dir, e.name, ".git")) })).sort((a, b) => a.name.localeCompare(b.name));
+      const entries = readdirSync2(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({ name: e.name, repo: existsSync7(join10(dir, e.name, ".git")) })).sort((a, b) => a.name.localeCompare(b.name));
       const parent = dirname4(dir);
       return c.json({ path: dir, parent: parent === dir ? null : parent, entries });
     } catch (e) {
@@ -8659,10 +11176,130 @@ function createApp(store = new Store, hooks2 = {}) {
   });
   app.get("/v1/state", (c) => c.json(store.snapshot()));
   app.get("/v1/stats", (c) => c.json(store.stats(c.req.query("project") || undefined)));
+  app.get("/v1/graphs/collisions", (c) => c.json(store.collisions(c.req.query("project") || undefined)));
+  app.get("/v1/graphs/lineage", (c) => c.json(store.lineage(c.req.query("project") || undefined, Math.max(1, Math.min(90, Number(c.req.query("days") ?? 14) || 14)), c.req.queries("expand") ?? [])));
+  app.get("/v1/context", (c) => c.json(store.context(c.req.query("project") || undefined, Math.max(1, Math.min(90, Number(c.req.query("days") ?? 7) || 7)))));
+  app.get("/v1/mcp/health", (c) => c.json(store.mcpHealth(c.req.query("project") || undefined, Math.max(1, Math.min(90, Number(c.req.query("days") ?? 7) || 7)))));
+  app.get("/v1/hygiene", (c) => c.json(store.hygiene(c.req.query("project") || undefined)));
+  app.get("/v1/gates/health", (c) => c.json(store.gateHealth(c.req.query("project") || undefined, Math.max(1, Math.min(365, Number(c.req.query("days") ?? 30) || 30)))));
+  app.get("/v1/waiting", (c) => c.json(store.waiting(c.req.query("project") || undefined, Math.max(1, Math.min(90, Number(c.req.query("days") ?? 7) || 7)))));
   app.get("/v1/incidents", (c) => c.json(store.incidents(Number(c.req.query("limit") ?? 50), {
     open: c.req.query("open") === "1",
     projectId: c.req.query("project") || undefined
   })));
+  const outcomesFor = async (project) => {
+    const sessions = store.snapshot().sessions.filter((s) => !project || s.projectId === project).map((s) => ({
+      id: s.id,
+      branch: s.branch,
+      model: s.model,
+      agent: s.agent,
+      costUsd: s.costUsd,
+      startedAt: s.startedAt
+    }));
+    const prs = [];
+    const reverted = new Set;
+    for (const p of store.projects().filter((x) => !project || x.id === project)) {
+      const o = await forge2.merged(p.id, p.root);
+      for (const m of o.merged)
+        prs.push({ ...m, state: "merged" });
+      for (const sha of o.reverted)
+        reverted.add(sha);
+    }
+    for (const pr of forge2.prs())
+      if (!project || pr.projectId === project)
+        prs.push({
+          branch: pr.branch,
+          number: pr.number,
+          state: "open",
+          title: pr.title,
+          url: pr.url,
+          createdAt: pr.createdAt,
+          mergedAt: null,
+          mergeSha: null
+        });
+    return outcomeReport(sessions, prs, reverted);
+  };
+  app.get("/v1/outcomes", async (c) => c.json(await outcomesFor(c.req.query("project") || undefined)));
+  app.get("/v1/ab", (c) => {
+    const project = c.req.query("project") || undefined;
+    const task = c.req.query("task");
+    if (task) {
+      if (!project)
+        return c.json({ error: "project is required with task" }, 400);
+      return c.json(store.abTrial(project, task));
+    }
+    return c.json({ trials: store.abTrials(project) });
+  });
+  app.post("/v1/ab", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    if (!b.projectId || !b.task)
+      return c.json({ error: "projectId and task are required" }, 400);
+    const arms = (b.arms ?? []).filter((a) => a.model || a.label);
+    if (arms.length < 2)
+      return c.json({ error: "a trial needs at least two arms" }, 400);
+    const cfg = store.config(b.projectId);
+    const started = [];
+    const failed = [];
+    for (const a of arms) {
+      const label = (a.label ?? a.model ?? "").replace(/[^a-zA-Z0-9._-]+/g, "-");
+      const id = armTask(b.task, label);
+      const r = await runner.start({
+        projectId: b.projectId,
+        task: id,
+        prompt: taskPrompt({ id: b.task, title: b.title ?? b.task }, {
+          requiredGates: cfg.gates.required,
+          executableGates: cfg.gates.required.filter((g) => cfg.gates.defs[g]),
+          openPr: false
+        }),
+        owner: `ab:${label}`,
+        permissionMode: cfg.dispatch.permission_mode ?? "acceptEdits",
+        ...a.model ? { model: a.model } : {},
+        ...cfg.dispatch.max_turns ? { maxTurns: cfg.dispatch.max_turns } : {}
+      });
+      if (r.ok)
+        started.push(label);
+      else
+        failed.push({ arm: label, reason: r.reason });
+    }
+    store.append({
+      ts: new Date().toISOString(),
+      type: "dispatch.queued",
+      projectId: b.projectId,
+      sessionId: null,
+      payload: {
+        task: b.task,
+        arms: arms.map((a) => a.label ?? a.model),
+        summary: `A/B ${b.task}: ${started.length} arm${started.length === 1 ? "" : "s"} started`
+      }
+    });
+    return c.json({ ok: failed.length === 0, started, failed }, failed.length ? 207 : 200);
+  });
+  app.get("/v1/provenance", async (c) => {
+    const project = c.req.query("project") || undefined;
+    const { branches } = await outcomesFor(project);
+    const projects = store.projects().filter((p) => !project || p.id === project);
+    const tasks2 = [];
+    for (const p of projects)
+      for (const t of store.tasks(p.id)?.tasks ?? [])
+        tasks2.push({ id: t.id, title: t.title, status: t.statusText, url: null });
+    const claims = store.claims(project).map((cl) => ({
+      task: cl.task,
+      sessionId: cl.sessionId,
+      owner: cl.owner || null,
+      worktree: cl.worktree || null,
+      branch: cl.branch || null,
+      acquiredAt: cl.acquiredAt,
+      state: cl.state
+    }));
+    const sessions = store.snapshot().sessions.filter((s) => !project || s.projectId === project).map((s) => ({
+      id: s.id,
+      title: s.title,
+      agent: s.agent,
+      branch: s.branch,
+      costUsd: s.costUsd
+    }));
+    return c.json(provenance(tasks2, claims, sessions, branches));
+  });
   app.get("/v1/memory", (c) => {
     const q = c.req.query("q") ?? "";
     const kind = c.req.query("kind");
@@ -8676,13 +11313,33 @@ function createApp(store = new Store, hooks2 = {}) {
       })
     });
   });
+  app.post("/v1/backup", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    if (typeof b.dest !== "string" || !b.dest.startsWith("/"))
+      return c.json({ error: "dest must be an absolute path" }, 400);
+    try {
+      return c.json(store.backupTo(b.dest));
+    } catch (e) {
+      return c.json({ error: e.message }, 500);
+    }
+  });
+  app.get("/v1/team", (c) => c.json(team2.status()));
+  app.post("/v1/team/credentials", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    if (typeof b.token !== "string" || !b.token)
+      return c.json({ error: "token required" }, 400);
+    store.setMetaValue("team_machine_token", b.token);
+    if (typeof b.policyPublicKey === "string" && b.policyPublicKey)
+      store.setMetaValue("team_policy_pubkey", b.policyPublicKey);
+    return c.json({ ok: true, machine: store.machineIdentity() });
+  });
   app.get("/v1/policy", (c) => {
     const id = c.req.query("project");
     const p = id ? store.project(id) : null;
     if (id && !p)
       return c.json({ error: "unknown project" }, 404);
-    const { provenance, overridden, policy: policy2 } = store.policyFor(p?.root ?? null);
-    return c.json({ ...policy2, provenance, overridden });
+    const { provenance: provenance3, overridden, policy: policy2 } = store.policyFor(p?.root ?? null);
+    return c.json({ ...policy2, provenance: provenance3, overridden });
   });
   app.get("/v1/audit", (c) => {
     const since = sinceToIso(c.req.query("since"));
@@ -9227,18 +11884,24 @@ function createApp(store = new Store, hooks2 = {}) {
       });
     });
   });
-  app.get("/", (c) => c.html(readFileSync4(join9(WEB_DIR, "index.html"), "utf8")));
+  app.get("/", (c) => c.html(readFileSync4(join10(WEB_DIR, "index.html"), "utf8")));
   const MIME = { js: "text/javascript", css: "text/css" };
   app.get("/:file{[a-z0-9-]+\\.(js|css)}", (c) => {
     const f = c.req.param("file");
-    const p = join9(WEB_DIR, f);
+    const p = join10(WEB_DIR, f);
     if (!existsSync7(p))
       return c.text(`${f} not built \u2014 run: bun run build:web`, 404);
+    const st = statSync2(p);
+    const etag = `W/"${st.size.toString(16)}-${st.mtimeMs.toString(16)}"`;
+    if (c.req.header("if-none-match") === etag)
+      return c.body(null, 304, { etag });
     return c.body(readFileSync4(p, "utf8"), 200, {
-      "content-type": MIME[f.split(".").pop() ?? ""] ?? "text/plain"
+      "content-type": MIME[f.split(".").pop() ?? ""] ?? "text/plain",
+      "cache-control": "no-cache",
+      etag
     });
   });
-  return { app, store, forge: forge2, runner, dispatcher, workflows: workflows2 };
+  return { app, store, forge: forge2, runner, dispatcher, workflows: workflows2, team: team2 };
 }
 
 // packages/daemon/src/demo.ts
@@ -9330,7 +11993,7 @@ function seedDemo(store) {
 // packages/daemon/src/bin.ts
 var DEFAULT_PORT2 = process.env.SWARM_PORT ? DEFAULT_PORT : loadConfig().daemon.port;
 var appHooks = {};
-var { app, store, runner } = createApp(new Store, appHooks);
+var { app, store, runner, team: team2 } = createApp(new Store, appHooks);
 if (process.env.SWARM_DEMO === "1" && isEmpty(store))
   seedDemo(store);
 function serve() {
@@ -9378,6 +12041,8 @@ if (!DEMO) {
   store.tailCodex(backfillMs);
   store.tailGrok(backfillMs);
   store.tailGemini(backfillMs);
+  store.tailAider(backfillMs);
+  store.tailOpencode(backfillMs);
 }
 var tick = 0;
 var tailer = setInterval(() => {
@@ -9388,6 +12053,8 @@ var tailer = setInterval(() => {
     store.tailCodex();
     store.tailGrok();
     store.tailGemini();
+    store.tailAider();
+    store.tailOpencode();
   }
   store.reapResources();
   store.reapProcesses();
@@ -9395,6 +12062,11 @@ var tailer = setInterval(() => {
     store.sweepOrphans();
   if (tick % 6 === 0)
     store.checkBudgets();
+  if (tick % 12 === 0)
+    store.checkModels();
+  if (tick % 2 === 0)
+    store.checkStalls();
+  team2.tick();
 }, 5000);
 store.refreshAllWorktrees();
 var wtRefresh = setInterval(() => void store.refreshAllWorktrees(), 15000);