@ra3orblade/swarm 0.8.0 → 0.10.0

package/dist/swarmd.js

@@ -3,9 +3,33 @@
 
 // packages/client/src/daemon.ts
 import { randomBytes } from "crypto";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
+
+// packages/client/src/bins.ts
+import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+var SRC = {
+  swarm: "cli",
+  swarmd: "daemon",
+  "swarm-hook": "hook",
+  "swarm-mcp": "mcp"
+};
+function resolveBin(name, from = import.meta.url) {
+  const here = dirname(fileURLToPath(from));
+  const candidates = [
+    resolve(here, `../../${SRC[name]}/src/bin.ts`),
+    resolve(here, `${name}.js`)
+  ];
+  for (const c of candidates)
+    if (existsSync(c))
+      return ["bun", c];
+  return [name];
+}
+
+// packages/client/src/daemon.ts
 function swarmHome() {
   return process.env.SWARM_HOME ?? join(homedir(), ".swarm");
 }
@@ -41,6 +65,9 @@ function ensureToken(home = swarmHome()) {
 function clearDaemonInfo() {
   rmSync(infoFile(), { force: true });
 }
+function daemonCommand() {
+  return resolveBin("swarmd");
+}
 // packages/core/src/actor.ts
 var HUMAN_ALIASES = new Set(["cli", "dashboard", "me", "desktop", "human"]);
 var DAEMON_ALIASES = new Set(["daemon", "system", "swarm"]);
@@ -78,6 +105,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 = {
@@ -218,6 +389,79 @@ function parseCodexRollout(chunk) {
   return out;
 }
 
+// packages/core/src/adapters/gemini/chats.ts
+function partText(content) {
+  if (typeof content === "string")
+    return content.slice(0, 400);
+  const parts = Array.isArray(content) ? content : [content];
+  let out = "";
+  for (const p of parts) {
+    if (typeof p === "string")
+      out += p;
+    else if (p && typeof p === "object" && typeof p.text === "string")
+      out += p.text;
+    if (out.length >= 400)
+      break;
+  }
+  return out.slice(0, 400);
+}
+function parseGeminiChat(chunk) {
+  const out = { turns: [], sessionId: null, model: null, cwd: null, title: null };
+  let subagent = false;
+  for (const raw of chunk.split(`
+`)) {
+    if (!raw.trim())
+      continue;
+    let d = null;
+    try {
+      d = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    if (d.$set) {
+      const set = d.$set;
+      if (typeof set.summary === "string")
+        out.title = set.summary;
+      continue;
+    }
+    if (d.sessionId && d.projectHash !== undefined) {
+      out.sessionId = d.sessionId;
+      if (Array.isArray(d.directories) && typeof d.directories[0] === "string")
+        out.cwd = d.directories[0];
+      if (typeof d.summary === "string")
+        out.title = d.summary;
+      if (d.kind === "subagent")
+        subagent = true;
+      continue;
+    }
+    if (d.type !== "gemini" || !d.id)
+      continue;
+    const t = d.tokens ?? {};
+    const cacheRead = t.cached ?? 0;
+    const turn = {
+      id: `${out.sessionId ?? "gemini"}-${d.id}`,
+      ts: d.timestamp ?? new Date(0).toISOString(),
+      model: d.model ?? out.model ?? "gemini-2.5-pro",
+      usage: {
+        input: Math.max(0, (t.input ?? 0) - cacheRead),
+        output: (t.output ?? 0) + (t.tool ?? 0),
+        cacheWrite: 0,
+        cacheWrite1h: 0,
+        cacheRead,
+        thinking: t.thoughts ?? 0
+      },
+      text: partText(d.content),
+      tools: (d.toolCalls ?? []).map((c) => c.name ?? c.displayName ?? c.tool ?? "").filter(Boolean),
+      effort: null,
+      sidechain: subagent
+    };
+    if (d.model)
+      out.model = d.model;
+    out.turns.push(turn);
+  }
+  return out;
+}
+
 // packages/core/src/adapters/grok/updates.ts
 function parseGrokUpdates(chunk) {
   const out = { turns: [], sessionId: null, model: null, cwd: null, title: null };
@@ -285,6 +529,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",
@@ -421,7 +721,9 @@ var AUDIT_TYPES = new Set([
   "permission.resolved",
   "incident.opened",
   "incident.acked",
-  "run.result"
+  "run.result",
+  "workflow.started",
+  "workflow.finished"
 ]);
 var isAuditType = (t) => AUDIT_TYPES.has(t);
 var AUDIT_TYPES_SQL = [...AUDIT_TYPES].map((t) => `'${t}'`).join(", ");
@@ -594,16 +896,82 @@ function runProfile(name) {
   return RUN_PROFILES[name] ?? null;
 }
 // packages/core/src/config.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { join as join2 } from "path";
+
+// packages/core/src/workflows.ts
+var NAME_RE = /^[a-z0-9][a-z0-9_.-]{0,39}$/i;
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function parseWorkflows(raw) {
+  const out = {};
+  if (!Array.isArray(raw))
+    return out;
+  for (const w of raw) {
+    if (!isRecord(w) || typeof w.name !== "string" || !NAME_RE.test(w.name))
+      continue;
+    if (!Array.isArray(w.steps) || !w.steps.length)
+      continue;
+    const prompts = isRecord(w.prompts) ? w.prompts : {};
+    const steps = [];
+    for (const s of w.steps) {
+      if (typeof s !== "string" || !s.trim()) {
+        steps.length = 0;
+        break;
+      }
+      const t = s.trim();
+      if (t === "pr")
+        steps.push({ kind: "pr" });
+      else if (t.startsWith("gate:")) {
+        const gate = t.slice(5);
+        if (!NAME_RE.test(gate)) {
+          steps.length = 0;
+          break;
+        }
+        steps.push({ kind: "gate", gate });
+      } else if (NAME_RE.test(t)) {
+        const p = prompts[t];
+        steps.push({
+          kind: "run",
+          name: t,
+          prompt: typeof p === "string" && p.trim() ? p.trim() : null
+        });
+      } else {
+        steps.length = 0;
+        break;
+      }
+    }
+    if (steps.length)
+      out[w.name] = { name: w.name, steps };
+  }
+  return out;
+}
+function workflowStepPrompt(step, task, ctx) {
+  if (step.prompt)
+    return step.prompt.replaceAll("{task}", task.id).replaceAll("{title}", task.title ?? "");
+  return [
+    `Task ${task.id}: ${task.title}`,
+    "",
+    `You are the "${step.name}" step of the "${ctx.workflow}" workflow. Work only inside this worktree; commit and push as you go.`,
+    ctx.remaining.length ? `After you finish, the workflow itself runs: ${ctx.remaining.join(" \u2192 ")}. Do not do those yourself.` : "You are the last step.",
+    "When done, call swarm_handoff with what was done and what remains."
+  ].join(`
+`);
+}
+function stepLabel(s) {
+  return s.kind === "run" ? s.name : s.kind === "gate" ? `gate:${s.gate}` : "pr";
+}
+
+// packages/core/src/config.ts
 var DEFAULT_GATE_TIMEOUT_S = 900;
 var AUTO_MODES = ["session-end", "stop", "off"];
 function parseGateDefs(gates) {
   const out = {};
-  if (!isRecord(gates))
+  if (!isRecord2(gates))
     return out;
   for (const [name, v] of Object.entries(gates)) {
-    if (!isRecord(v))
+    if (!isRecord2(v))
       continue;
     const builtin = v.builtin === "review" ? "review" : null;
     const cmd = typeof v.cmd === "string" ? v.cmd.trim() : "";
@@ -626,7 +994,11 @@ var DEFAULT_CONFIG = {
   daemon: { port: 7777, auth: "loopback-optional" },
   tasks: { source: null, labels: [], team: null },
   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,
@@ -650,11 +1022,11 @@ var DEFAULT_CONFIG = {
   }
 };
 var MODES = ["ask", "deny", "off"];
-function isRecord(v) {
+function isRecord2(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function merge(a, b) {
-  if (!isRecord(a) || !isRecord(b))
+  if (!isRecord2(a) || !isRecord2(b))
     return b === undefined ? a : b;
   const out = { ...a };
   for (const [k, v] of Object.entries(b))
@@ -721,6 +1093,27 @@ function validate(c) {
       warn_at: Number.isFinite(warnAt) && warnAt > 0 && warnAt < 1 ? warnAt : 0.8,
       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)
     },
@@ -760,7 +1153,7 @@ function validate(c) {
   };
 }
 function leafPaths(v, prefix = "") {
-  if (!isRecord(v))
+  if (!isRecord2(v))
     return prefix ? [prefix] : [];
   const keys = Object.keys(v);
   if (keys.length === 0)
@@ -770,7 +1163,7 @@ function leafPaths(v, prefix = "") {
 function getPath(v, path) {
   let cur = v;
   for (const seg of path.split(".")) {
-    if (!isRecord(cur))
+    if (!isRecord2(cur))
       return;
     cur = cur[seg];
   }
@@ -780,7 +1173,7 @@ function setPath(obj, path, value) {
   const segs = path.split(".");
   let cur = obj;
   for (const seg of segs.slice(0, -1)) {
-    if (!isRecord(cur[seg]))
+    if (!isRecord2(cur[seg]))
       cur[seg] = {};
     cur = cur[seg];
   }
@@ -788,7 +1181,7 @@ function setPath(obj, path, value) {
 }
 var isLockedBy = (path, lock) => path === lock || path.startsWith(`${lock}.`);
 function readLayer(path) {
-  return existsSync2(path) ? parseToml(readFileSync2(path, "utf8"), path) : null;
+  return existsSync3(path) ? parseToml(readFileSync2(path, "utf8"), path) : null;
 }
 function loadConfigDetailed(opts = {}) {
   const home = opts.home ?? process.env.SWARM_HOME ?? join2(process.env.HOME ?? "", ".swarm");
@@ -1274,11 +1667,11 @@ ${shown.map((f) => `- \`${f.path}\`${f.added >= 0 ? ` +${f.added} \u2212${f.dele
 `) };
 }
 // packages/core/src/gates.ts
-var NAME_RE = /^[a-z0-9][a-z0-9_.-]{0,39}$/i;
+var NAME_RE2 = /^[a-z0-9][a-z0-9_.-]{0,39}$/i;
 function validateGateRun(input) {
   if (!input.task?.trim())
     return { ok: false, reason: "task is required" };
-  if (!NAME_RE.test(input.gate ?? ""))
+  if (!NAME_RE2.test(input.gate ?? ""))
     return { ok: false, reason: "gate must be a short name (letters, digits, _ . -)" };
   if (input.verdict !== "pass" && input.verdict !== "fail")
     return { ok: false, reason: 'verdict must be "pass" or "fail"' };
@@ -1335,6 +1728,41 @@ function executedGateInput(task, gate, cmd, outcome) {
     evidence: evidenceTail(outcome.output) || null
   };
 }
+// 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/ledger.ts
 var DEFAULT_LEASE_MINUTES = 45;
 function isExpired(claim, now) {
@@ -1639,6 +2067,121 @@ function parseMemoryQuery(q) {
   }
   return { match: terms.join(" "), kind, task };
 }
+// packages/core/src/messages.ts
+var MESSAGE_MAX = 4000;
+function validateMessage(text) {
+  if (typeof text !== "string" || !text.trim())
+    return { ok: false, reason: "message text is required" };
+  const t = text.trim();
+  if (t.length > MESSAGE_MAX)
+    return { ok: false, reason: `message is over ${MESSAGE_MAX} chars` };
+  return { ok: true, text: t };
+}
+function parseTo(to) {
+  if (typeof to !== "string" || !to.trim())
+    return null;
+  const t = to.trim();
+  if (t === "lead")
+    return { kind: "lead" };
+  if (/^[0-9a-f]{8}(-[0-9a-f-]{4,28})?$/i.test(t))
+    return { kind: "session", id: t };
+  return { kind: "task", task: t };
+}
+function formatMessages(ms) {
+  if (!ms.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:
+${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";
@@ -1979,6 +2522,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;
@@ -2138,6 +2724,35 @@ function linearIssuesQuery(teamKey, first = 200) {
     inverseRelations { nodes { type issue { identifier } } }
   } } }`;
 }
+// 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 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 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/worktree.ts
 import { join as join3 } from "path";
 function planBootstrap(cfg, repoRoot, worktree) {
@@ -2212,10 +2827,10 @@ function planGc(worktrees, claims) {
   return out;
 }
 // packages/daemon/src/app.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync4, realpathSync as realpathSync3 } from "fs";
+import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync4, realpathSync as realpathSync3 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname3, join as join9 } from "path";
-import { fileURLToPath } from "url";
+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) => {
@@ -4088,7 +4703,7 @@ class Dispatcher {
 }
 
 // packages/daemon/src/forge.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join4 } from "path";
 var EXTRA_BIN_DIRS = [
@@ -4106,7 +4721,7 @@ function findBin(name) {
     return onPath;
   for (const d of EXTRA_BIN_DIRS) {
     const p = join4(d, name);
-    if (existsSync3(p))
+    if (existsSync4(p))
       return p;
   }
   return null;
@@ -4144,6 +4759,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)
@@ -4376,6 +5049,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];
@@ -4507,6 +5190,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)
@@ -4805,7 +5496,8 @@ class Runner {
 import { Database } from "bun:sqlite";
 import {
   closeSync,
-  existsSync as existsSync5,
+  copyFileSync,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync4,
   openSync as openSync3,
   readdirSync,
@@ -4817,12 +5509,12 @@ import {
   unlinkSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { homedir as homedir3, tmpdir, userInfo } from "os";
-import { basename, dirname as dirname2, join as join8 } from "path";
+import { homedir as homedir3, hostname, tmpdir, userInfo } from "os";
+import { basename, dirname as dirname3, join as join8 } from "path";
 
 // packages/daemon/src/bootstrap.ts
-import { cpSync, existsSync as existsSync4, mkdirSync as mkdirSync3, openSync as openSync2 } from "fs";
-import { dirname, join as join7 } from "path";
+import { cpSync, existsSync as existsSync5, mkdirSync as mkdirSync3, openSync as openSync2 } from "fs";
+import { dirname as dirname2, join as join7 } from "path";
 function runBootstrap(plan, opts) {
   const logDir = join7(opts.home, "logs", opts.projectId);
   mkdirSync3(logDir, { recursive: true });
@@ -4830,12 +5522,12 @@ function runBootstrap(plan, opts) {
   const copied = [];
   const skipped = [];
   for (const c of plan.copies) {
-    if (!existsSync4(c.from)) {
+    if (!existsSync5(c.from)) {
       skipped.push(c.rel);
       continue;
     }
     try {
-      mkdirSync3(dirname(c.to), { recursive: true });
+      mkdirSync3(dirname2(c.to), { recursive: true });
       cpSync(c.from, c.to, { recursive: true, force: true });
       copied.push(c.rel);
     } catch (e) {
@@ -4927,14 +5619,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}`);
@@ -4960,11 +5652,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,
@@ -4997,6 +5690,12 @@ CREATE TABLE IF NOT EXISTS messages (
   answer TEXT, answered_by TEXT, answered_at TEXT, delivered_at TEXT
 );
 CREATE INDEX IF NOT EXISTS messages_open ON messages(project_id, answered_at, delivered_at);
+CREATE TABLE IF NOT EXISTS workflow_runs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT, project_id TEXT, task TEXT, workflow TEXT,
+  step INTEGER, step_label TEXT, steps TEXT, state TEXT, detail TEXT, run_id TEXT,
+  started_at TEXT, updated_at TEXT, ended_at TEXT, actor_kind TEXT, actor_id TEXT
+);
+CREATE INDEX IF NOT EXISTS workflow_runs_proj ON workflow_runs(project_id, id);
 CREATE TABLE IF NOT EXISTS claims (
   project_id TEXT, task TEXT, owner TEXT, worktree TEXT, branch TEXT,
   acquired_at TEXT, expires_at TEXT, released_at TEXT, state TEXT,
@@ -5024,9 +5723,13 @@ 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");
+    this.ensureColumn("messages", "to_kind", "TEXT");
+    this.ensureColumn("messages", "from_session", "TEXT");
     this.migrate();
     this.migrateProjectsJson(join8(home, "projects.json"));
     this.reconcileMovedProjects();
@@ -5047,6 +5750,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;
@@ -5076,9 +5785,9 @@ class Store {
   reconcileMovedProjects() {
     const all = this.projects();
     for (const stale of all) {
-      if (existsSync5(stale.root))
+      if (existsSync6(stale.root))
         continue;
-      const live = all.filter((p) => p.id !== stale.id && p.name === stale.name && existsSync5(p.root));
+      const live = all.filter((p) => p.id !== stale.id && p.name === stale.name && existsSync6(p.root));
       if (live.length !== 1)
         continue;
       this.mergeProject(stale.id, live[0].id);
@@ -5162,7 +5871,7 @@ class Store {
     return actorFrom(owner, sessionId, { user: osUser(), runId });
   }
   migrateProjectsJson(file) {
-    if (!existsSync5(file))
+    if (!existsSync6(file))
       return;
     try {
       const list = JSON.parse(readFileSync3(file, "utf8"));
@@ -5177,7 +5886,7 @@ class Store {
     const hit = this.topCache.get(cwd);
     if (hit && Date.now() - hit.t < 1e4)
       return hit.v;
-    const v = cwd && existsSync5(cwd) ? gitToplevel(cwd) : null;
+    const v = cwd && existsSync6(cwd) ? gitToplevel(cwd) : null;
     this.topCache.set(cwd, { v, t: Date.now() });
     return v;
   }
@@ -5383,7 +6092,7 @@ class Store {
     }));
   }
   sessionContext(cwd) {
-    if (!cwd || !existsSync5(cwd))
+    if (!cwd || !existsSync6(cwd))
       return null;
     const toplevel = this.toplevel(cwd);
     const project = this.resolveProject(cwd);
@@ -5523,7 +6232,160 @@ class Store {
     return qs;
   }
   answerContext(sessionId) {
-    return formatAnswers(this.inbox(sessionId));
+    const parts = [
+      formatAnswers(this.inbox(sessionId)),
+      formatMessages(this.messageInbox(sessionId))
+    ];
+    const out = parts.filter(Boolean);
+    return out.length ? out.join(`
+`) : null;
+  }
+  wfInsert(projectId, task, workflow, steps, actor2) {
+    const now = new Date().toISOString();
+    const r = this.db.query(`INSERT INTO workflow_runs (project_id, task, workflow, step, step_label, steps, state, started_at, updated_at, actor_kind, actor_id)
+         VALUES (?, ?, ?, 0, ?, ?, 'running', ?, ?, ?, ?)`).run(projectId, task, workflow, steps[0] ?? "", JSON.stringify(steps), now, now, actor2.kind, actor2.id);
+    this.touch();
+    return Number(r.lastInsertRowid);
+  }
+  wfUpdate(id, patch) {
+    const sets = ["updated_at = ?"];
+    const args = [new Date().toISOString()];
+    if (patch.step !== undefined) {
+      sets.push("step = ?");
+      args.push(patch.step);
+    }
+    if (patch.stepLabel !== undefined) {
+      sets.push("step_label = ?");
+      args.push(patch.stepLabel);
+    }
+    if (patch.state !== undefined) {
+      sets.push("state = ?");
+      args.push(patch.state);
+    }
+    if (patch.detail !== undefined) {
+      sets.push("detail = ?");
+      args.push(patch.detail);
+    }
+    if (patch.runId !== undefined) {
+      sets.push("run_id = ?");
+      args.push(patch.runId);
+    }
+    if (patch.ended) {
+      sets.push("ended_at = ?");
+      args.push(new Date().toISOString());
+    }
+    this.db.query(`UPDATE workflow_runs SET ${sets.join(", ")} WHERE id = ?`).run(...args, id);
+    this.touch();
+  }
+  wfRuns(projectId, limit = 50) {
+    return this.db.query("SELECT * FROM workflow_runs WHERE project_id = ? ORDER BY id DESC LIMIT ?").all(projectId, limit).map(rowToWorkflowRun);
+  }
+  wfActive(projectId, task) {
+    const r = this.db.query("SELECT * FROM workflow_runs WHERE project_id = ? AND task = ? AND state = 'running' ORDER BY id DESC LIMIT 1").get(projectId, task);
+    return r ? rowToWorkflowRun(r) : null;
+  }
+  wfSweepOrphans() {
+    this.db.query("UPDATE workflow_runs SET state = 'stopped', detail = COALESCE(detail, 'daemon restarted mid-workflow'), ended_at = ? WHERE state = 'running'").run(new Date().toISOString());
+  }
+  send(projectId, input) {
+    if (!this.project(projectId))
+      return { ok: false, error: "unknown project" };
+    const v = validateMessage(input.text);
+    if (!v.ok)
+      return { ok: false, error: v.reason };
+    const to = parseTo(input.to);
+    if (!to)
+      return { ok: false, error: 'to must be a session id, a task, or "lead"' };
+    let sessionId = null;
+    let task = null;
+    if (to.kind === "session") {
+      sessionId = this.knownSession(to.id) ?? this.sessionByPrefix(to.id);
+      if (!sessionId)
+        return { ok: false, error: `unknown session ${to.id}` };
+    } else if (to.kind === "task") {
+      task = to.task;
+      sessionId = this.sessionForTask(projectId, to.task);
+    } else {
+      sessionId = this.leadSession(projectId);
+    }
+    const createdAt = new Date().toISOString();
+    const from = input.from ?? (input.fromSession ? `agent ${input.fromSession.slice(0, 8)}` : null);
+    const r = this.db.query(`INSERT INTO messages (project_id, session_id, task, kind, text, asked_by, created_at, to_kind, from_session)
+         VALUES (?, ?, ?, 'message', ?, ?, ?, ?, ?)`).run(projectId, sessionId, task, v.text, from, createdAt, to.kind, input.fromSession ?? null);
+    const message = this.message(Number(r.lastInsertRowid));
+    this.append({
+      ts: createdAt,
+      type: "message.sent",
+      projectId,
+      sessionId: input.fromSession ?? null,
+      actor: this.actorFor(input.from ?? null, input.fromSession ?? null),
+      payload: {
+        id: message.id,
+        to: input.to,
+        task,
+        recipient: sessionId,
+        text: v.text.slice(0, 400),
+        summary: `message to ${String(input.to)}: ${v.text.slice(0, 120)}`
+      }
+    });
+    return { ok: true, message };
+  }
+  message(id) {
+    const r = this.db.query("SELECT * FROM messages WHERE id = ? AND kind = 'message'").get(id);
+    return r ? rowToMessage(r) : null;
+  }
+  messages(opts = {}) {
+    const where = ["kind = 'message'"];
+    const args = [];
+    if (opts.projectId) {
+      where.push("project_id = ?");
+      args.push(opts.projectId);
+    }
+    if (opts.sessionId) {
+      where.push("(session_id = ? OR from_session = ?)");
+      args.push(opts.sessionId, opts.sessionId);
+    }
+    if (opts.task) {
+      where.push("task = ?");
+      args.push(opts.task);
+    }
+    args.push(opts.limit ?? 100);
+    return this.db.query(`SELECT * FROM messages WHERE ${where.join(" AND ")} ORDER BY id DESC LIMIT ?`).all(...args).map(rowToMessage);
+  }
+  messageInbox(sessionId, opts = {}) {
+    if (!sessionId)
+      return [];
+    const s = this.db.query("SELECT project_id, kind, cwd FROM sessions WHERE id = ?").get(sessionId);
+    if (!s)
+      return [];
+    const task = this.heldClaimsWithWorktree().find((c) => isInside(s.cwd, c.worktree))?.task ?? null;
+    const rows = this.db.query(`SELECT * FROM messages WHERE kind = 'message' AND delivered_at IS NULL AND from_session IS NOT ?
+           AND (session_id = ?
+             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;
+  }
+  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);
+  }
+  leadSession(projectId) {
+    const r = this.db.query("SELECT id FROM sessions WHERE project_id = ? AND kind = 'interactive' AND state != 'ended' ORDER BY last_seen_at DESC LIMIT 1").get(projectId);
+    return r?.id ?? null;
+  }
+  sessionByPrefix(prefix) {
+    const rows = this.db.query("SELECT id FROM sessions WHERE id LIKE ? ORDER BY last_seen_at DESC LIMIT 2").all(`${prefix}%`);
+    return rows.length === 1 ? rows[0]?.id ?? null : null;
+  }
+  sessionForTask(projectId, task) {
+    const claim = this.claims(projectId).find((c) => c.task === task && c.state === "held");
+    if (!claim?.worktree)
+      return null;
+    const rows = this.db.query("SELECT id, cwd FROM sessions WHERE project_id = ? AND state != 'ended' ORDER BY last_seen_at DESC").all(projectId);
+    return rows.find((r) => isInside(r.cwd, claim.worktree))?.id ?? null;
   }
   questionContext(task, projectId) {
     if (!task)
@@ -5600,13 +6462,13 @@ class Store {
       };
     const claim = this.claims(projectId).find((c) => c.task === task && c.state === "held");
     const worktree2 = claim?.worktree;
-    if (!worktree2 || !existsSync5(worktree2))
+    if (!worktree2 || !existsSync6(worktree2))
       return {
         ok: false,
         reason: `${task} has no held worktree to run ${gate} in \u2014 claim it first`
       };
     const cwd = def.cwd ? join8(worktree2, def.cwd) : worktree2;
-    if (!existsSync5(cwd))
+    if (!existsSync6(cwd))
       return { ok: false, reason: `gate cwd ${cwd} does not exist` };
     const key = `${projectId}:${task}:${gate}`;
     if (this.gateJobs.has(key))
@@ -5947,7 +6809,7 @@ ${err}
       error = e.error;
     } else {
       const path = join8(p.root, source);
-      if (!existsSync5(path))
+      if (!existsSync6(path))
         return { source, required: this.requiredGates(projectId), tasks: [] };
       const mtime = statSync(path).mtimeMs;
       let md = this.taskCache.get(projectId);
@@ -5996,7 +6858,7 @@ ${err}
     const file = join8(this.home, POLICY_CACHE_FILE);
     try {
       if (!hasLockedRules(loaded)) {
-        if (existsSync5(file))
+        if (existsSync6(file))
           unlinkSync(file);
         return;
       }
@@ -6012,13 +6874,13 @@ ${err}
   claudeSettings() {
     const p = process.env.CLAUDE_SETTINGS ?? join8(homedir3(), ".claude", "settings.json");
     try {
-      return existsSync5(p) ? JSON.parse(readFileSync3(p, "utf8")) : null;
+      return existsSync6(p) ? JSON.parse(readFileSync3(p, "utf8")) : null;
     } catch {
       return null;
     }
   }
   checkPolicy(cwd, sessionId) {
-    const project = existsSync5(cwd) ? this.resolveProject(cwd) : null;
+    const project = existsSync6(cwd) ? this.resolveProject(cwd) : null;
     const repoRoot = project?.root ?? null;
     const loaded = this.policyFor(repoRoot);
     const settings = this.claudeSettings();
@@ -6043,7 +6905,7 @@ ${err}
     return findings;
   }
   evaluateTool(tool, input, sessionId, cwd, recordIncident = true) {
-    if (BUDGET_ASK_TOOLS.has(tool) && cwd && existsSync5(cwd)) {
+    if (BUDGET_ASK_TOOLS.has(tool) && cwd && existsSync6(cwd)) {
       const project = this.resolveProject(cwd);
       const b = this.budgetFor(project.id);
       if (b && b.status.level === "exceeded" && b.config.on_exceed === "ask") {
@@ -6054,6 +6916,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;
@@ -6134,7 +7008,7 @@ ${err}
     return this.openIncident(d, cwd, id, cmd);
   }
   openIncident(d, cwd, sessionId, command) {
-    const project = cwd && existsSync5(cwd) ? this.resolveProject(cwd) : null;
+    const project = cwd && existsSync6(cwd) ? this.resolveProject(cwd) : null;
     this.append({
       ts: new Date().toISOString(),
       type: "incident.opened",
@@ -6185,7 +7059,7 @@ ${err}
       }
     }
     const report = dryRunRules(calls, modes, {
-      toplevel: (cwd) => cwd && existsSync5(cwd) ? this.toplevel(cwd) : null,
+      toplevel: (cwd) => cwd && existsSync6(cwd) ? this.toplevel(cwd) : null,
       claims: this.heldWorktrees()
     });
     return { ...report, modes };
@@ -6201,7 +7075,7 @@ ${err}
     this.prices = { ...PRICES };
     for (const f of ["pricing.litellm.json", "pricing.json"]) {
       const p = join8(this.home, f);
-      if (!existsSync5(p))
+      if (!existsSync6(p))
         continue;
       try {
         const j = JSON.parse(readFileSync3(p, "utf8"));
@@ -6221,7 +7095,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)
@@ -6382,13 +7256,70 @@ ${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;
   }
-  audit(opts = {}) {
+  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 = [];
     if (opts.since) {
@@ -6426,10 +7357,10 @@ ${err}
     if (typeof raw2.cwd === "string")
       this.autoRenewFor(typeof raw2.session_id === "string" ? raw2.session_id : null, raw2.cwd);
     const cwd = typeof raw2.cwd === "string" ? raw2.cwd : process.cwd();
-    const project = existsSync5(cwd) ? this.resolveProject(cwd) : null;
+    const project = existsSync6(cwd) ? this.resolveProject(cwd) : null;
     const e = this.append(normalizeHook(event, raw2, project?.id ?? "p_unknown"));
     if ((event === "Stop" || event === "SessionEnd") && e.sessionId) {
-      if (existsSync5(cwd)) {
+      if (existsSync6(cwd)) {
         this.autoHandoff(e.sessionId, cwd);
         this.autoGate(event, e.sessionId, cwd);
       }
@@ -6475,7 +7406,7 @@ ${err}
       return;
     const p = e.payload;
     const row = this.db.query("SELECT id, tool_counts FROM sessions WHERE id = ?").get(e.sessionId);
-    const branch = p.cwd && existsSync5(p.cwd) ? currentBranch(p.cwd) : null;
+    const branch = p.cwd && existsSync6(p.cwd) ? currentBranch(p.cwd) : null;
     if (!row) {
       this.db.query("INSERT INTO sessions (id, project_id, kind, cwd, branch, started_at, last_seen_at, last, last_type, state) VALUES (?, ?, 'interactive', ?, ?, ?, ?, ?, ?, 'active')").run(e.sessionId, e.projectId, p.cwd ?? "", branch, e.ts, e.ts, p.summary ?? e.type, e.type);
     }
@@ -6515,13 +7446,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)
@@ -6547,10 +7478,10 @@ ${err}
   }
   tailSession(sessionId) {
     const s = this.db.query("SELECT transcript_path FROM sessions WHERE id = ?").get(sessionId);
-    if (!s?.transcript_path || !existsSync5(s.transcript_path))
+    if (!s?.transcript_path || !existsSync6(s.transcript_path))
       return 0;
     let n = this.tailFile(s.transcript_path, sessionId, null);
-    const subDir = join8(dirname2(s.transcript_path), basename(s.transcript_path, ".jsonl"), "subagents");
+    const subDir = join8(dirname3(s.transcript_path), basename(s.transcript_path, ".jsonl"), "subagents");
     for (const f of this.subagentFiles(subDir)) {
       n += this.tailFile(join8(subDir, f), sessionId, f.replace(/^agent-|\.jsonl$/g, ""));
     }
@@ -6618,7 +7549,7 @@ ${err}
     return out;
   }
   tailCodex(windowMs = 3 * 24 * 60 * 60000) {
-    if (!existsSync5(this.codexRoot()))
+    if (!existsSync6(this.codexRoot()))
       return 0;
     let n = 0;
     for (const path of this.codexRolloutFiles(Date.now() - windowMs)) {
@@ -6630,9 +7561,54 @@ ${err}
     return process.env.SWARM_GROK_DIR ?? join8(homedir3(), ".grok", "sessions");
   }
   grokSummary = new Map;
+  tailGemini(windowMs = 3 * 24 * 60 * 60000) {
+    const root = process.env.SWARM_GEMINI_ROOT ?? join8(homedir3(), ".gemini", "tmp");
+    if (!existsSync6(root))
+      return 0;
+    const since = Date.now() - windowMs;
+    const ls = (p) => {
+      try {
+        return readdirSync(p);
+      } catch {
+        return [];
+      }
+    };
+    let n = 0;
+    const ingestDir = (dir) => {
+      for (const f of ls(dir)) {
+        const path = join8(dir, f);
+        if (!f.endsWith(".jsonl")) {
+          try {
+            if (statSync(path).isDirectory()) {
+              for (const g of ls(path))
+                if (g.endsWith(".jsonl"))
+                  ingestFile(join8(path, g));
+            }
+          } catch {}
+          continue;
+        }
+        ingestFile(path);
+      }
+    };
+    const ingestFile = (path) => {
+      try {
+        if (statSync(path).mtimeMs < since)
+          return;
+      } catch {
+        return;
+      }
+      n += this.ingestLog(path, "gemini", parseGeminiChat);
+    };
+    for (const hash of ls(root)) {
+      const chats = join8(root, hash, "chats");
+      if (existsSync6(chats))
+        ingestDir(chats);
+    }
+    return n;
+  }
   tailGrok(windowMs = 3 * 24 * 60 * 60000) {
     const root = this.grokRoot();
-    if (!existsSync5(root))
+    if (!existsSync6(root))
       return 0;
     const since = Date.now() - windowMs;
     const ls = (p) => {
@@ -6655,7 +7631,7 @@ ${err}
       const cwdDir = join8(root, enc);
       for (const sid of ls(cwdDir)) {
         const path = join8(cwdDir, sid, "updates.jsonl");
-        if (!existsSync5(path))
+        if (!existsSync6(path))
           continue;
         try {
           if (statSync(path).mtimeMs < since)
@@ -6686,6 +7662,160 @@ ${err}
     }
     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;
+  }
   ingestLog(path, agent, parse, cwdHint, titleHint) {
     const off = this.db.query("SELECT offset FROM tails WHERE path = ?").get(path) ?? { offset: 0 };
     const r = this.readFrom(path, off.offset);
@@ -6714,9 +7844,9 @@ ${err}
   ensureAgentSession(sid, agent, cwd, mtime) {
     if (this.db.query("SELECT 1 FROM sessions WHERE id = ?").get(sid))
       return;
-    const project = cwd && existsSync5(cwd) ? this.resolveProject(cwd) : null;
+    const project = cwd && existsSync6(cwd) ? this.resolveProject(cwd) : null;
     const ts = new Date(mtime).toISOString();
-    this.db.query("INSERT INTO sessions (id, project_id, kind, agent, cwd, branch, started_at, last_seen_at, last, last_type, state) VALUES (?, ?, 'interactive', ?, ?, ?, ?, ?, '', '', 'active')").run(sid, project?.id ?? "p_unknown", agent, cwd, cwd && existsSync5(cwd) ? currentBranch(cwd) : null, ts, ts);
+    this.db.query("INSERT INTO sessions (id, project_id, kind, agent, cwd, branch, started_at, last_seen_at, last, last_type, state) VALUES (?, ?, 'interactive', ?, ?, ?, ?, ?, '', '', 'active')").run(sid, project?.id ?? "p_unknown", agent, cwd, cwd && existsSync6(cwd) ? currentBranch(cwd) : null, ts, ts);
   }
   claimRows(projectId) {
     return this.db.query("SELECT * FROM claims WHERE project_id = ?").all(projectId).map((r) => ({
@@ -6762,9 +7892,9 @@ ${err}
       return { ok: false, error: claimRefusalMessage(decision, task) };
     const branch = `task/${task}`;
     const worktree2 = this.worktreePath(projectId, task);
-    if (existsSync5(worktree2))
+    if (existsSync6(worktree2))
       return { ok: false, error: `${worktree2} already exists; release ${task} first` };
-    mkdirSync4(dirname2(worktree2), { recursive: true });
+    mkdirSync4(dirname3(worktree2), { recursive: true });
     const created = worktreeAdd(p.root, worktree2, branch, baseRef);
     if (!created)
       return { ok: false, error: `git worktree add failed for ${task}` };
@@ -6867,6 +7997,77 @@ ${err}
       expiresAt: r.expires_at
     }));
   }
+  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;
@@ -6874,7 +8075,7 @@ ${err}
       for (const c of this.claimRows(p.id)) {
         if (c.state !== "held" || isActive(c, now))
           continue;
-        const exists = c.worktree ? existsSync5(c.worktree) : false;
+        const exists = c.worktree ? existsSync6(c.worktree) : false;
         const work = exists ? heldWork(c.worktree) : null;
         if (reapAction(c, now, exists, work) !== "keep-orphaned")
           continue;
@@ -6930,7 +8131,7 @@ ${err}
     if (!row)
       return { ok: false, error: `no claim on ${task}` };
     const worktree2 = row.worktree ?? "";
-    if (worktree2 && existsSync5(worktree2)) {
+    if (worktree2 && existsSync6(worktree2)) {
       const work = heldWork(worktree2);
       const can = canRelease(work, force);
       if (!can.ok)
@@ -6965,7 +8166,7 @@ ${err}
           continue;
         if (isActive({ ...c, state: "held" }, now))
           continue;
-        const exists = c.worktree ? existsSync5(c.worktree) : false;
+        const exists = c.worktree ? existsSync6(c.worktree) : false;
         const work = exists ? heldWork(c.worktree) : null;
         const action = reapAction({ ...c, state: "held" }, now, exists, work);
         if (action === "not-expired")
@@ -7064,9 +8265,9 @@ ${err}
     if (!slug || slug === "." || slug === "..")
       return { ok: false, error: "bad worktree name" };
     const path = this.worktreePath(projectId, slug);
-    if (existsSync5(path))
+    if (existsSync6(path))
       return { ok: false, error: `${path} already exists` };
-    mkdirSync4(dirname2(path), { recursive: true });
+    mkdirSync4(dirname3(path), { recursive: true });
     const br = branch?.trim() || `wt/${slug}`;
     const created = worktreeAdd(p.root, path, br, baseRef);
     if (!created)
@@ -7244,6 +8445,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,
@@ -7308,8 +8510,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);
@@ -7751,6 +9065,48 @@ ${err}
   seq() {
     return this.db.query("SELECT COALESCE(MAX(seq),0) AS seq FROM events").get().seq;
   }
+  timelineDetail(hours, projectId) {
+    const from = new Date(Date.now() - Math.min(Math.max(hours, 1), 168) * 3600000).toISOString();
+    const args = [from];
+    let filter = "";
+    if (projectId) {
+      filter = " AND s.project_id = ?";
+      args.push(projectId);
+    }
+    const rows = this.db.query(`SELECT t.session_id AS sid, t.ts FROM turns t JOIN sessions s ON s.id = t.session_id
+         WHERE t.ts >= ? AND t.sidechain = 0${filter} ORDER BY t.ts LIMIT 20000`).all(...args);
+    const turns = {};
+    for (const r of rows) {
+      turns[r.sid] ??= [];
+      turns[r.sid]?.push(new Date(r.ts).getTime());
+    }
+    const claims = this.claims().filter((c) => (!projectId || c.projectId === projectId) && c.state !== "released").map((c) => ({
+      projectId: c.projectId,
+      task: c.task,
+      owner: c.owner,
+      state: c.state,
+      acquiredAt: c.acquiredAt,
+      expiresAt: c.expiresAt
+    }));
+    return { turns, claims };
+  }
+  spendSparks() {
+    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 = [];
+    for (let i = 13;i >= 0; i--)
+      days2.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);
+      if (i >= 0)
+        arr[i] = (arr[i] ?? 0) + (r.usd ?? 0);
+    }
+    return out;
+  }
   snapshot() {
     const worktrees = {};
     const projects = this.projects().filter((p) => !(p.discovered && isScratchRoot(p.root)));
@@ -7761,6 +9117,7 @@ ${err}
       worktrees,
       sessions: this.memoised("sessions", 2000, () => this.sessions()),
       spend: this.memoised("spend", 30000, () => this.spend()),
+      spendSparks: this.memoised("spendSparks", 60000, () => this.spendSparks()),
       claims: this.claims(),
       processes: this.memoised("processes", 5000, () => this.processes()),
       incidents: this.memoised("incidents", 30000, () => this.incidents(20, { open: true })),
@@ -7858,15 +9215,428 @@ function isScratchRoot(root) {
   const tmp = [tmpdir(), "/tmp", "/private/tmp", "/private/var/folders", "/var/folders"];
   return tmp.some((t) => root === t || root.startsWith(`${t}/`));
 }
+function rowToMessage(r) {
+  return {
+    id: r.id,
+    projectId: r.project_id,
+    task: r.task ?? null,
+    sessionId: r.session_id ?? null,
+    toKind: r.to_kind ?? "session",
+    from: r.asked_by ?? null,
+    fromSession: r.from_session ?? null,
+    text: r.text,
+    createdAt: r.created_at,
+    deliveredAt: r.delivered_at ?? null
+  };
+}
+function rowToWorkflowRun(r) {
+  return {
+    id: r.id,
+    projectId: r.project_id,
+    task: r.task,
+    workflow: r.workflow,
+    step: r.step,
+    stepLabel: r.step_label ?? "",
+    steps: JSON.parse(r.steps ?? "[]"),
+    state: r.state,
+    detail: r.detail ?? null,
+    runId: r.run_id ?? null,
+    startedAt: r.started_at,
+    updatedAt: r.updated_at,
+    endedAt: r.ended_at ?? null
+  };
+}
+function localDayIso(offsetDays) {
+  const d = new Date;
+  d.setHours(0, 0, 0, 0);
+  d.setDate(d.getDate() + 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;
+  runner;
+  forge;
+  active = new Map;
+  constructor(store, runner, forge2) {
+    this.store = store;
+    this.runner = runner;
+    this.forge = forge2;
+    store.wfSweepOrphans();
+    runner.onEnd((run2) => void this.onRunEnd(run2));
+  }
+  start(projectId, task, workflow, opts = {}) {
+    const def = this.store.config(projectId).workflows[workflow];
+    if (!def) {
+      const known = Object.keys(this.store.config(projectId).workflows);
+      return {
+        ok: false,
+        error: `unknown workflow ${workflow}${known.length ? ` \u2014 this repo declares: ${known.join(", ")}` : " \u2014 declare [[workflows]] in .swarm.toml"}`
+      };
+    }
+    const key = `${projectId}:${task}`;
+    if (this.active.has(key) || this.store.wfActive(projectId, task))
+      return { ok: false, error: `a workflow is already running on ${task}` };
+    const title = this.store.tasks(projectId)?.tasks.find((t) => t.id === task)?.title ?? task;
+    const owner = opts.owner ?? "workflow";
+    const id = this.store.wfInsert(projectId, task, workflow, def.steps.map(stepLabel), this.store.actorFor(owner, opts.sessionId ?? null));
+    const w = { id, projectId, task, title, def, step: 0, runId: null, owner };
+    this.active.set(key, w);
+    this.store.append({
+      ts: new Date().toISOString(),
+      type: "workflow.started",
+      projectId,
+      sessionId: opts.sessionId ?? null,
+      payload: {
+        id,
+        task,
+        workflow,
+        steps: def.steps.map(stepLabel),
+        summary: `workflow ${workflow} on ${task}: ${def.steps.map(stepLabel).join(" \u2192 ")}`
+      }
+    });
+    this.advance(w);
+    return { ok: true, id };
+  }
+  status(projectId) {
+    return this.store.wfRuns(projectId);
+  }
+  stop(projectId, task) {
+    const key = `${projectId}:${task}`;
+    const w = this.active.get(key);
+    if (!w)
+      return { ok: false, error: `no running workflow on ${task}` };
+    if (w.runId)
+      this.runner.stop(w.runId);
+    this.finish(w, "stopped", `stopped at ${this.label(w)}`);
+    return { ok: true };
+  }
+  label(w) {
+    const s = w.def.steps[w.step];
+    return s ? stepLabel(s) : "done";
+  }
+  async advance(w) {
+    while (w.step < w.def.steps.length) {
+      const s = w.def.steps[w.step];
+      this.store.wfUpdate(w.id, { step: w.step, stepLabel: stepLabel(s), runId: null });
+      this.step(w, `step ${w.step + 1}/${w.def.steps.length}: ${stepLabel(s)}`);
+      if (s.kind === "run") {
+        const cfg = this.store.config(w.projectId).dispatch;
+        const remaining = w.def.steps.slice(w.step + 1).map(stepLabel);
+        const r = await this.runner.start({
+          projectId: w.projectId,
+          task: w.task,
+          prompt: workflowStepPrompt(s, { id: w.task, title: w.title }, { workflow: w.def.name, remaining }),
+          owner: w.owner,
+          permissionMode: cfg.permission_mode ?? "acceptEdits",
+          model: cfg.model ?? undefined,
+          maxTurns: cfg.max_turns ?? undefined,
+          profile: cfg.profile ?? undefined
+        });
+        if (!r.ok)
+          return this.fail(w, `could not start ${stepLabel(s)}: ${r.reason}`);
+        w.runId = r.run.id;
+        this.store.wfUpdate(w.id, { runId: r.run.id });
+        return;
+      }
+      if (s.kind === "gate") {
+        const r = await this.store.runGates(w.projectId, w.task, [s.gate], { owner: w.owner });
+        const run2 = r.runs.find((x) => x.gate === s.gate);
+        if (!run2)
+          return this.fail(w, `gate ${s.gate} did not run: ${r.skipped[0]?.reason ?? "unknown"}`);
+        if (run2.verdict !== "pass")
+          return this.fail(w, `gate ${s.gate} failed \u2014 ${run2.rubric}`);
+        w.step++;
+        continue;
+      }
+      const d = await this.store.prDraftFor(w.projectId, w.task);
+      if (!d.ok)
+        return this.fail(w, `pr: ${d.error}`);
+      const pr = await this.forge.openPR(w.projectId, d.worktree, {
+        title: d.title,
+        body: d.body,
+        isDraft: false
+      });
+      if (!pr.ok)
+        return this.fail(w, `pr: ${pr.error}`);
+      this.store.recordPrOpened(w.projectId, d.task, d.worktree.path, pr.url);
+      this.store.wfUpdate(w.id, { detail: `PR ${pr.url}` });
+      w.step++;
+    }
+    this.finish(w, "done", null);
+  }
+  async onRunEnd(run2) {
+    const w = this.active.get(`${run2.projectId}:${run2.task}`);
+    if (!w || w.runId !== run2.id)
+      return;
+    w.runId = null;
+    if (run2.stopped)
+      return this.finish(w, "stopped", `stopped during ${this.label(w)}`);
+    if (run2.exitCode !== 0 || run2.result?.isError)
+      return this.fail(w, `${this.label(w)} exited ${run2.exitCode}${run2.result?.isError ? " (error)" : ""} \u2014 log: ${run2.log}`);
+    w.step++;
+    this.advance(w);
+  }
+  step(w, summary) {
+    this.store.append({
+      ts: new Date().toISOString(),
+      type: "workflow.step",
+      projectId: w.projectId,
+      sessionId: null,
+      payload: {
+        id: w.id,
+        task: w.task,
+        workflow: w.def.name,
+        step: w.step,
+        label: this.label(w),
+        summary: `workflow ${w.def.name} on ${w.task} \u2014 ${summary}`
+      }
+    });
+  }
+  fail(w, detail) {
+    this.store.wfUpdate(w.id, { state: "failed", detail, ended: true });
+    this.active.delete(`${w.projectId}:${w.task}`);
+    this.store.append({
+      ts: new Date().toISOString(),
+      type: "workflow.finished",
+      projectId: w.projectId,
+      sessionId: null,
+      payload: {
+        id: w.id,
+        task: w.task,
+        workflow: w.def.name,
+        outcome: "failed",
+        detail,
+        summary: `workflow ${w.def.name} on ${w.task} failed at ${this.label(w)}: ${detail.slice(0, 160)}`
+      }
+    });
+    this.store.append({
+      ts: new Date().toISOString(),
+      type: "incident.opened",
+      projectId: w.projectId,
+      sessionId: null,
+      payload: {
+        rule: "workflow_failed",
+        action: "failed",
+        command: `${w.task} \xB7 ${w.def.name} \xB7 ${this.label(w)}`,
+        reason: detail.slice(0, 400)
+      }
+    });
+  }
+  finish(w, state, detail) {
+    this.store.wfUpdate(w.id, { state, ...detail !== null ? { detail } : {}, ended: true });
+    this.active.delete(`${w.projectId}:${w.task}`);
+    this.store.append({
+      ts: new Date().toISOString(),
+      type: "workflow.finished",
+      projectId: w.projectId,
+      sessionId: null,
+      payload: {
+        id: w.id,
+        task: w.task,
+        workflow: w.def.name,
+        outcome: state,
+        summary: `workflow ${w.def.name} on ${w.task}: ${state}${detail ? ` \u2014 ${detail}` : ""}`
+      }
+    });
+  }
+}
 
 // packages/daemon/src/app.ts
-var VERSION = "0.8.0";
+var VERSION = "0.10.0";
 var WEB_DIR = (() => {
   if (process.env.SWARM_WEB_DIR)
     return process.env.SWARM_WEB_DIR;
-  const here = dirname3(fileURLToPath(import.meta.url));
-  const dev = join9(here, "../../web/public");
-  return existsSync6(join9(dev, "index.html")) ? dev : join9(here, "../web");
+  const here = dirname4(fileURLToPath2(import.meta.url));
+  const dev = join10(here, "../../web/public");
+  return existsSync7(join10(dev, "index.html")) ? dev : join10(here, "../web");
 })();
 var REPLAY_TAIL = 200;
 var wireCache = new WeakMap;
@@ -7880,13 +9650,40 @@ function wireJson(e) {
 }
 function hookRepoRoot(store, raw2) {
   const cwd = typeof raw2.cwd === "string" ? raw2.cwd : "";
-  return cwd && existsSync6(cwd) ? store.resolveProject(cwd)?.root ?? null : null;
+  return cwd && existsSync7(cwd) ? store.resolveProject(cwd)?.root ?? null : null;
+}
+function claudeSettings() {
+  try {
+    const p = process.env.CLAUDE_SETTINGS ?? join10(homedir4(), ".claude", "settings.json");
+    return existsSync7(p) ? JSON.parse(readFileSync4(p, "utf8")) : null;
+  } catch {
+    return null;
+  }
+}
+function diskVersion() {
+  try {
+    const entry = daemonCommand().at(-1);
+    if (!entry || !existsSync7(entry))
+      return null;
+    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"));
+      if (m?.[1])
+        return m[1];
+    }
+    return null;
+  } catch {
+    return null;
+  }
 }
-function createApp(store = new Store) {
+function createApp(store = new Store, hooks2 = {}) {
   const app = new Hono2;
   const forge2 = new ForgeService(store);
   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))
@@ -7908,6 +9705,8 @@ function createApp(store = new Store) {
     return c.json({ error: "unauthorized: send the daemon token (~/.swarm/token) as Authorization: Bearer" }, 401);
   });
   app.get("/v1/health", (c) => c.json({
+    disk: diskVersion(),
+    hooksInstalled: hookCoverage(claudeSettings()).complete,
     ok: true,
     version: VERSION,
     schema: store.schemaVersion(),
@@ -7942,13 +9741,13 @@ function createApp(store = new Store) {
     const q = c.req.query("path");
     let dir;
     try {
-      dir = realpathSync3(q && existsSync6(q) ? q : homedir4());
+      dir = realpathSync3(q && existsSync7(q) ? q : homedir4());
     } catch {
       dir = homedir4();
     }
     try {
-      const entries = readdirSync2(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({ name: e.name, repo: existsSync6(join9(dir, e.name, ".git")) })).sort((a, b) => a.name.localeCompare(b.name));
-      const parent = dirname3(dir);
+      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) {
       return c.json({ error: e.message, path: dir }, 400);
@@ -7956,10 +9755,44 @@ function createApp(store = new Store) {
   });
   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/incidents", (c) => c.json(store.incidents(Number(c.req.query("limit") ?? 50), {
     open: c.req.query("open") === "1",
     projectId: c.req.query("project") || undefined
   })));
+  app.get("/v1/outcomes", async (c) => {
+    const project = c.req.query("project") || undefined;
+    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 c.json(outcomeReport(sessions, prs, reverted));
+  });
   app.get("/v1/memory", (c) => {
     const q = c.req.query("q") ?? "";
     const kind = c.req.query("kind");
@@ -7973,6 +9806,26 @@ function createApp(store = new Store) {
       })
     });
   });
+  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;
@@ -7998,6 +9851,12 @@ function createApp(store = new Store) {
     const ct = format === "csv" ? "text/csv; charset=utf-8" : format === "jsonl" ? "application/x-ndjson" : "application/json";
     return c.body(formatAudit(rows, format), 200, { "content-type": ct });
   });
+  app.post("/v1/daemon/restart", (c) => {
+    if (!hooks2.restart)
+      return c.json({ error: "not restartable in this environment" }, 501);
+    setTimeout(() => hooks2.restart?.(), 50);
+    return c.json({ ok: true, restarting: true });
+  });
   app.get("/v1/rules/dryrun", (c) => {
     const projectId = c.req.query("project");
     if (!projectId)
@@ -8132,6 +9991,58 @@ function createApp(store = new Store) {
     return c.json(r, r.ok ? 200 : 409);
   });
   app.get("/v1/inbox", (c) => c.json(store.inbox(c.req.query("session") || null, { peek: c.req.query("peek") === "1" })));
+  app.get("/v1/workflows", (c) => {
+    const project = c.req.query("project");
+    if (!project)
+      return c.json({ error: "project required" }, 400);
+    return c.json({ defs: store.config(project).workflows, runs: workflows2.status(project) });
+  });
+  app.post("/v1/workflows", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    if (!b.projectId || !b.task || !b.workflow)
+      return c.json({ ok: false, error: "projectId, task, workflow required" }, 400);
+    const r = workflows2.start(b.projectId, b.task, b.workflow, {
+      ...b.owner ? { owner: b.owner } : {},
+      sessionId: b.sessionId ?? null
+    });
+    return c.json(r, r.ok ? 201 : 409);
+  });
+  app.post("/v1/workflows/stop", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    if (!b.projectId || !b.task)
+      return c.json({ ok: false, error: "projectId and task required" }, 400);
+    const r = workflows2.stop(b.projectId, b.task);
+    return c.json(r, r.ok ? 200 : 404);
+  });
+  app.get("/v1/timeline", (c) => c.json(store.timelineDetail(Number(c.req.query("hours")) || 12, c.req.query("project") || null)));
+  app.get("/v1/messages", (c) => c.json(store.messages({
+    ...c.req.query("project") ? { projectId: c.req.query("project") } : {},
+    ...c.req.query("session") ? { sessionId: c.req.query("session") } : {},
+    ...c.req.query("task") ? { task: c.req.query("task") } : {},
+    limit: Number(c.req.query("limit")) || 100
+  })));
+  app.get("/v1/messages/inbox", (c) => c.json(store.messageInbox(c.req.query("session") || null, { peek: c.req.query("peek") === "1" })));
+  app.post("/v1/messages", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    if (!b.projectId)
+      return c.json({ ok: false, error: "projectId required" }, 400);
+    const r = store.send(b.projectId, {
+      to: b.to,
+      text: b.text,
+      from: b.from ?? null,
+      fromSession: b.sessionId ?? null
+    });
+    if (!r.ok)
+      return c.json(r, 400);
+    const m = r.message;
+    const run2 = m.task ? runner.get(m.task) : m.sessionId ? runner.get(m.sessionId) : null;
+    if (run2 && !run2.endedAt) {
+      const sent = runner.send(run2.id, `[swarm] message from ${m.from ?? "unknown"}: ${m.text}`);
+      if (sent.ok)
+        store.markMessageDelivered(m.id, run2.sessionId);
+    }
+    return c.json({ ok: true, message: store.message(m.id) }, 201);
+  });
   app.get("/v1/dispatch", (c) => {
     const project = c.req.query("project");
     if (!project)
@@ -8453,7 +10364,7 @@ function createApp(store = new Store) {
         await stream2.writeSSE({ id: String(e.seq), event: e.type, data: JSON.stringify(e) });
       }
       await stream2.writeSSE({ event: "ping", data: "" });
-      await new Promise((resolve) => {
+      await new Promise((resolve2) => {
         const off = store.subscribe((e) => {
           stream2.writeSSE({ id: String(e.seq), event: e.type, data: wireJson(e) });
         });
@@ -8461,28 +10372,117 @@ function createApp(store = new Store) {
         stream2.onAbort(() => {
           clearInterval(beat);
           off();
-          resolve();
+          resolve2();
         });
       });
     });
   });
-  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);
-    if (!existsSync6(p))
+    const p = join10(WEB_DIR, f);
+    if (!existsSync7(p))
       return c.text(`${f} not built \u2014 run: bun run build:web`, 404);
     return c.body(readFileSync4(p, "utf8"), 200, {
       "content-type": MIME[f.split(".").pop() ?? ""] ?? "text/plain"
     });
   });
-  return { app, store, forge: forge2, runner, dispatcher };
+  return { app, store, forge: forge2, runner, dispatcher, workflows: workflows2, team: team2 };
+}
+
+// packages/daemon/src/demo.ts
+var H = 3600000;
+var iso = (msAgo) => new Date(Date.now() - msAgo).toISOString();
+function isEmpty(store) {
+  return !store.db.query("SELECT 1 FROM sessions LIMIT 1").get();
+}
+function seedDemo(store) {
+  const db = store.db;
+  const project = (id, name, root, icon, color) => db.query("INSERT OR IGNORE INTO projects (id, root, common_dir, name, discovered, created_at, icon, color) VALUES (?, ?, ?, ?, 0, ?, ?, ?)").run(id, root, `${root}/.git`, name, iso(90 * 24 * H), icon, color);
+  project("p_demo1", "acme-app", "/work/acme-app", "\uD83D\uDED2", "c3");
+  project("p_demo2", "acme-site", "/work/acme-site", "\uD83C\uDF10", "c5");
+  const session = (id, pid, agent, title, cwd, branch, startedAgo, lastAgo, state, model) => {
+    db.query(`INSERT OR IGNORE INTO sessions (id, project_id, kind, agent, cwd, branch, title, model, started_at, last_seen_at, last, last_type, last_text, state, tool_calls)
+       VALUES (?, ?, 'interactive', ?, ?, ?, ?, ?, ?, ?, ?, 'tool.completed', ?, ?, ?)`).run(id, pid, agent, cwd, branch, title, model, iso(startedAgo), iso(lastAgo), state === "active" ? "Bash bun test" : "session ended", state === "active" ? "Running the suite before handing off." : "Done \u2014 PR opened, gates green.", state, 40 + Math.floor(Math.random() * 200));
+    let t = startedAgo;
+    let i = 0;
+    while (t > lastAgo) {
+      const out = 300 + Math.floor(Math.random() * 4000);
+      const read = 50000 + Math.floor(Math.random() * 900000);
+      db.query(`INSERT OR IGNORE 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 (?, ?, NULL, ?, ?, NULL, 0, ?, ?, ?, 0, ?, ?, ?, ?, '["Bash","Edit"]')`).run(`${id}-t${i}`, id, iso(t), model, 800 + i * 97 % 2000, out, 12000, read, i % 3 === 0 ? 900 : 0, 0.02 + out / 1e6 * 15 + read / 1e6 * 0.3, i % 4 === 0 ? "Tests are green; tightening the error path next." : "");
+      t -= (8 + i * 13 % 30) * 60000;
+      i++;
+    }
+  };
+  session("demo-s1", "p_demo1", "claude-code", "Checkout flow refactor", "/work/acme-app-wt/checkout", "task/checkout", 5 * H, 2 * 60000, "active", "claude-fable-5");
+  session("demo-s2", "p_demo1", "codex", "Fix flaky cart tests", "/work/acme-app", "main", 7 * H, 3 * H, "ended", "gpt-5.2-codex");
+  session("demo-s3", "p_demo1", "gemini", "Payment webhook audit", "/work/acme-app", "main", 26 * H, 22 * H, "ended", "gemini-2.5-pro");
+  session("demo-s4", "p_demo2", "grok", "Landing page rewrite", "/work/acme-site", "task/landing", 30 * H, 25 * H, "ended", "grok-4");
+  session("demo-s5", "p_demo2", "claude-code", "SEO metadata sweep", "/work/acme-site", "main", 50 * H, 47 * H, "ended", "claude-sonnet-5");
+  db.query(`INSERT OR IGNORE INTO claims (project_id, task, owner, worktree, branch, acquired_at, expires_at, released_at, state, actor_kind, actor_id)
+     VALUES ('p_demo1', 'checkout', 'demo-s1', '/work/acme-app-wt/checkout', 'task/checkout', ?, ?, NULL, 'held', 'agent', 'demo-s1')`).run(iso(5 * H), iso(-30 * 60000));
+  db.query(`INSERT OR IGNORE INTO claims (project_id, task, owner, worktree, branch, acquired_at, expires_at, released_at, state, actor_kind, actor_id)
+     VALUES ('p_demo1', 'webhooks', 'alice', '/work/acme-app-wt/webhooks', 'task/webhooks', ?, ?, NULL, 'orphaned', 'human', 'alice')`).run(iso(26 * H), iso(20 * H));
+  const gate = (task, gate2, verdict, rubric, ago, sid) => db.query(`INSERT OR IGNORE INTO gates (project_id, task, gate, verdict, rubric, evidence, session_id, created_at, actor_kind, actor_id)
+       VALUES ('p_demo1', ?, ?, ?, ?, NULL, ?, ?, 'daemon', 'daemon')`).run(task, gate2, verdict, rubric, sid, iso(ago));
+  gate("checkout", "tests", "fail", "ran `bun test` \u2014 exit 1 in 41s", 3 * H, "demo-s1");
+  gate("checkout", "tests", "pass", "ran `bun test` \u2014 exit 0 in 39s", 1 * H, "demo-s1");
+  gate("checkout", "review", "pass", "review: no blocker/major findings", 40 * 60000, null);
+  gate("webhooks", "tests", "pass", "ran `bun test` \u2014 exit 0 in 22s", 22 * H, "demo-s3");
+  const ev = (type, ago, sid, payload) => store.append({
+    ts: iso(ago),
+    type,
+    projectId: "p_demo1",
+    sessionId: sid,
+    payload
+  });
+  ev("incident.opened", 4 * H, "demo-s1", {
+    rule: "pattern_kill",
+    action: "ask",
+    command: "pkill -f vite",
+    reason: "This kills processes by command pattern \u2014 other agents' dev servers match too."
+  });
+  ev("incident.opened", 26 * H, "demo-s3", {
+    rule: "shared_tree",
+    action: "deny",
+    command: "git reset --hard",
+    reason: "Another session (demo-s2) is active in this same checkout."
+  });
+  ev("claim.acquired", 5 * H, "demo-s1", {
+    task: "checkout",
+    owner: "demo-s1",
+    summary: "claim checkout"
+  });
+  ev("pr.opened", 30 * 60000, "demo-s1", {
+    task: "checkout",
+    url: "https://github.com/acme/app/pull/128",
+    summary: "PR #128 opened for checkout"
+  });
+  ev("question.asked", 20 * 60000, "demo-s1", {
+    id: 1,
+    task: "checkout",
+    text: "Coupon codes: keep the legacy endpoint alive for one release, or cut over now?",
+    options: ["Keep one release", "Cut over"],
+    summary: "question #1"
+  });
+  db.query(`INSERT OR IGNORE INTO messages (project_id, session_id, task, kind, text, options, asked_by, created_at)
+     VALUES ('p_demo1', 'demo-s1', 'checkout', 'question', 'Coupon codes: keep the legacy endpoint alive for one release, or cut over now?', '["Keep one release","Cut over"]', 'demo-s1', ?)`).run(iso(20 * 60000));
+  db.query(`INSERT OR IGNORE INTO messages (project_id, session_id, task, kind, text, asked_by, created_at, to_kind, from_session)
+     VALUES ('p_demo1', 'demo-s1', 'checkout', 'message', 'Cart tests are green again \u2014 rebasing on main is safe now.', 'agent demo-s2', ?, 'task', 'demo-s2')`).run(iso(50 * 60000));
+  db.query(`INSERT OR IGNORE INTO handoffs (project_id, task, done, remaining, files, verify, by, session_id, created_at, actor_kind, actor_id)
+     VALUES ('p_demo1', 'webhooks', 'Signature validation + retries done', 'Dead-letter queue wiring', '["src/webhooks.ts","src/queue.ts"]', 'bun test \u2014 118 pass', 'auto:demo-s3', 'demo-s3', ?, 'daemon', 'daemon')`).run(iso(22 * H));
+  db.query(`INSERT OR IGNORE INTO workflow_runs (project_id, task, workflow, step, step_label, steps, state, detail, started_at, updated_at, ended_at, actor_kind, actor_id)
+     VALUES ('p_demo1', 'checkout', 'ship', 2, 'gate:review', '["implement","gate:tests","gate:review","pr"]', 'running', NULL, ?, ?, NULL, 'human', 'demo')`).run(iso(2 * H), iso(10 * 60000));
 }
 
 // packages/daemon/src/bin.ts
 var DEFAULT_PORT2 = process.env.SWARM_PORT ? DEFAULT_PORT : loadConfig().daemon.port;
-var { app, store, runner } = createApp();
+var appHooks = {};
+var { app, store, runner, team: team2 } = createApp(new Store, appHooks);
+if (process.env.SWARM_DEMO === "1" && isEmpty(store))
+  seedDemo(store);
 function serve() {
   const bind = (p) => Bun.serve({ port: p, hostname: "127.0.0.1", idleTimeout: 0, fetch: app.fetch });
   try {
@@ -8494,21 +10494,54 @@ function serve() {
     return bind(0);
   }
 }
-var server = serve();
+var server;
+var restart = () => {
+  console.error("swarmd: restarting into the version on disk\u2026");
+  try {
+    clearInterval(tailer);
+    clearInterval(wtRefresh);
+    clearInterval(pruner);
+  } catch {}
+  try {
+    server.stop(true);
+  } catch {}
+  clearDaemonInfo();
+  const [cmd, ...args] = daemonCommand();
+  if (cmd)
+    Bun.spawn([cmd, ...args], {
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: "ignore",
+      env: { ...process.env }
+    }).unref();
+  setTimeout(() => process.exit(0), 100);
+};
+appHooks.restart = restart;
+server = serve();
 var port = server.port ?? DEFAULT_PORT2;
 ensureToken();
 writeDaemonInfo({ port, pid: process.pid, version: VERSION, startedAt: new Date().toISOString() });
 var backfillDays = Number(process.env.SWARM_CODEX_BACKFILL_DAYS ?? 30);
 var backfillMs = backfillDays * 24 * 60 * 60000;
-store.tailCodex(backfillMs);
-store.tailGrok(backfillMs);
+var DEMO = process.env.SWARM_DEMO === "1";
+if (!DEMO) {
+  store.tailCodex(backfillMs);
+  store.tailGrok(backfillMs);
+  store.tailGemini(backfillMs);
+  store.tailAider(backfillMs);
+  store.tailOpencode(backfillMs);
+}
 var tick = 0;
 var tailer = setInterval(() => {
   tick++;
-  store.tailActive();
-  if (tick % 3 === 0 || store.hasActiveSessions()) {
+  if (!DEMO)
+    store.tailActive();
+  if (!DEMO && (tick % 3 === 0 || store.hasActiveSessions())) {
     store.tailCodex();
     store.tailGrok();
+    store.tailGemini();
+    store.tailAider();
+    store.tailOpencode();
   }
   store.reapResources();
   store.reapProcesses();
@@ -8516,6 +10549,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);