@ra3orblade/swarm 0.7.0 → 0.9.0

package/dist/swarmd.js

@@ -2,9 +2,34 @@
 // @bun
 
 // packages/client/src/daemon.ts
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { randomBytes } from "crypto";
+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");
 }
@@ -18,9 +43,68 @@ function writeDaemonInfo(info) {
 `);
   return full;
 }
+var tokenFile = (home = swarmHome()) => join(home, "token");
+function readToken(home = swarmHome()) {
+  try {
+    const t = readFileSync(tokenFile(home), "utf8").trim();
+    return /^[a-f0-9]{64}$/.test(t) ? t : null;
+  } catch {
+    return null;
+  }
+}
+function ensureToken(home = swarmHome()) {
+  const cur = readToken(home);
+  if (cur)
+    return cur;
+  mkdirSync(home, { recursive: true });
+  const t = randomBytes(32).toString("hex");
+  writeFileSync(tokenFile(home), `${t}
+`, { mode: 384 });
+  return t;
+}
 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"]);
+function actorFrom(owner, sessionId, opts = {}) {
+  const o = (owner ?? "").trim();
+  const sid = sessionId?.trim() || undefined;
+  if (opts.runId)
+    return { kind: "run", id: opts.runId, session: sid };
+  if (o.startsWith("auto:"))
+    return { kind: "daemon", id: "daemon", session: sid };
+  if (DAEMON_ALIASES.has(o))
+    return { kind: "daemon", id: "daemon" };
+  if (o === "agent" || o.startsWith("agent:") || o.startsWith("session:"))
+    return {
+      kind: "agent",
+      id: sid ?? o.replace(/^(agent|session):/, "") ?? "agent",
+      session: sid
+    };
+  if (!o || HUMAN_ALIASES.has(o)) {
+    if (!o && sid)
+      return { kind: "agent", id: sid, session: sid };
+    return { kind: "human", id: opts.user?.trim() || "me" };
+  }
+  if (sid && o === sid)
+    return { kind: "agent", id: sid, session: sid };
+  return { kind: "human", id: o };
+}
+function actorFromColumns(kind, id, session) {
+  if (!kind || !id)
+    return null;
+  if (!["human", "agent", "run", "daemon"].includes(kind))
+    return null;
+  const a = { kind, id };
+  if (session && kind !== "human" && kind !== "daemon")
+    a.session = session;
+  return a;
+}
 // packages/core/src/adapters/claude-code/transcript.ts
 function parseTranscriptChunk(chunk) {
   const out = {
@@ -161,6 +245,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 };
@@ -229,6 +386,18 @@ function parseGrokUpdates(chunk) {
   return out;
 }
 // packages/core/src/adapters/claude-code/hooks.ts
+var HOOK_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "SubagentStart",
+  "SubagentStop",
+  "Stop",
+  "SessionEnd",
+  "Notification",
+  "PreCompact"
+];
 var MAP = {
   SessionStart: "session.started",
   UserPromptSubmit: "prompt.submitted",
@@ -322,6 +491,157 @@ function normalizeHook(event, raw, projectId, ts = new Date().toISOString()) {
     payload.prompt = raw.prompt;
   return { ts, type, projectId, sessionId: raw.session_id ?? null, payload, raw };
 }
+// packages/core/src/audit.ts
+var AUDIT_TYPES = new Set([
+  "session.started",
+  "session.ended",
+  "tool.denied",
+  "claim.acquired",
+  "claim.renewed",
+  "claim.released",
+  "claim.expired",
+  "claim.orphaned",
+  "worktree.created",
+  "worktree.removed",
+  "worktree.bootstrapped",
+  "pr.opened",
+  "question.asked",
+  "question.answered",
+  "dispatch.queued",
+  "dispatch.started",
+  "dispatch.finished",
+  "resource.acquired",
+  "resource.released",
+  "resource.reaped",
+  "process.started",
+  "process.exited",
+  "gate.recorded",
+  "handoff.recorded",
+  "permission.requested",
+  "permission.resolved",
+  "incident.opened",
+  "incident.acked",
+  "run.result",
+  "workflow.started",
+  "workflow.finished"
+]);
+var isAuditType = (t) => AUDIT_TYPES.has(t);
+var AUDIT_TYPES_SQL = [...AUDIT_TYPES].map((t) => `'${t}'`).join(", ");
+var DEFAULT_PRIVACY = {
+  store_prompts: true,
+  store_reasoning: true,
+  redact: []
+};
+var BUILTIN_REDACT = [
+  /\b(sk|pk|rk|ghp|gho|ghu|ghs|xoxb|xoxp|AKIA)[A-Za-z0-9_-]{16,}\b/g,
+  /\bBearer\s+[A-Za-z0-9._-]{20,}/g
+];
+function compileRedactions(patterns) {
+  const out = [...BUILTIN_REDACT];
+  for (const p of patterns) {
+    try {
+      out.push(new RegExp(p, "g"));
+    } catch {}
+  }
+  return out;
+}
+function redactValue(v, res) {
+  if (!res.length)
+    return v;
+  if (typeof v === "string")
+    return redactString(v, res);
+  if (Array.isArray(v)) {
+    let changed = false;
+    const out = v.map((x) => {
+      const r = redactValue(x, res);
+      if (r !== x)
+        changed = true;
+      return r;
+    });
+    return changed ? out : v;
+  }
+  if (v && typeof v === "object") {
+    let changed = false;
+    const out = {};
+    for (const [k, x] of Object.entries(v)) {
+      const r = redactValue(x, res);
+      if (r !== x)
+        changed = true;
+      out[k] = r;
+    }
+    return changed ? out : v;
+  }
+  return v;
+}
+function redactString(s, res) {
+  let out = s;
+  for (const re of res) {
+    re.lastIndex = 0;
+    if (re.test(out)) {
+      re.lastIndex = 0;
+      out = out.replace(re, "[redacted]");
+    }
+  }
+  return out;
+}
+var AUDIT_COLUMNS = [
+  "seq",
+  "ts",
+  "type",
+  "projectId",
+  "sessionId",
+  "actorKind",
+  "actorId",
+  "summary",
+  "payload"
+];
+function auditRow(e) {
+  const p = e.payload ?? {};
+  const summary = typeof p.summary === "string" ? p.summary : typeof p.reason === "string" ? p.reason : typeof p.command === "string" ? p.command : typeof p.task === "string" ? String(p.task) : "";
+  return {
+    seq: e.seq ?? 0,
+    ts: e.ts,
+    type: e.type,
+    projectId: e.projectId,
+    sessionId: e.sessionId,
+    actorKind: e.actor?.kind ?? null,
+    actorId: e.actor?.id ?? null,
+    summary: summary.slice(0, 400),
+    payload: e.payload ?? null
+  };
+}
+var csvCell = (v) => {
+  const s = v == null ? "" : typeof v === "string" ? v : JSON.stringify(v);
+  return /[",\n\r]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+};
+function formatAudit(rows, format) {
+  if (format === "json")
+    return JSON.stringify(rows);
+  if (format === "csv") {
+    const lines = [
+      AUDIT_COLUMNS.join(","),
+      ...rows.map((r) => AUDIT_COLUMNS.map((c) => csvCell(r[c])).join(","))
+    ];
+    return `${lines.join(`
+`)}
+`;
+  }
+  return `${rows.map((r) => JSON.stringify(r)).join(`
+`)}${rows.length ? `
+` : ""}`;
+}
+function sinceToIso(since, now = Date.now()) {
+  if (!since)
+    return null;
+  const m = /^(\d+)([dhm])$/.exec(since.trim());
+  if (m) {
+    const n = Number(m[1]);
+    const ms = m[2] === "d" ? 86400000 : m[2] === "h" ? 3600000 : 60000;
+    return new Date(now - n * ms).toISOString();
+  }
+  const t = Date.parse(since);
+  return Number.isNaN(t) ? null : new Date(t).toISOString();
+}
 // packages/core/src/budget.ts
 function budgetStatus(spent, cfg) {
   const part = (s, l) => ({
@@ -376,33 +696,109 @@ 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) || typeof v.cmd !== "string" || !v.cmd.trim())
+    if (!isRecord2(v))
+      continue;
+    const builtin = v.builtin === "review" ? "review" : null;
+    const cmd = typeof v.cmd === "string" ? v.cmd.trim() : "";
+    if (!cmd && !builtin)
       continue;
     if (!/^[a-z0-9][a-z0-9_.-]{0,39}$/i.test(name))
       continue;
     const t = Number(v.timeout);
     out[name] = {
-      cmd: v.cmd.trim(),
-      timeout: Number.isFinite(t) && t > 0 ? Math.min(t, 86400) : DEFAULT_GATE_TIMEOUT_S,
-      cwd: isRepoRelative(v.cwd) ? v.cwd.trim() : null
+      cmd: builtin ? "" : cmd,
+      timeout: Number.isFinite(t) && t > 0 ? Math.min(t, 86400) : builtin ? 600 : DEFAULT_GATE_TIMEOUT_S,
+      cwd: isRepoRelative(v.cwd) ? v.cwd.trim() : null,
+      builtin,
+      model: typeof v.model === "string" && v.model.trim() ? v.model.trim() : null
     };
   }
   return out;
 }
 var DEFAULT_CONFIG = {
-  daemon: { port: 7777 },
+  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" },
+  events: { retain_days: 30 },
+  audit: { retain_days: 0 },
+  privacy: DEFAULT_PRIVACY,
   dispatch: {
     max_parallel: 2,
     permission_mode: null,
@@ -423,11 +819,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))
@@ -450,6 +846,10 @@ function isRepoRelative(f) {
     return false;
   return !t.split(/[/\\]/).some((seg) => seg === "..");
 }
+var days = (v, fallback) => {
+  const n = Number(v);
+  return Number.isInteger(n) && n >= 0 ? Math.min(n, 3650) : fallback;
+};
 function validate(c) {
   const mode = (v, fallback) => MODES.includes(v) ? v : fallback;
   const port = Number(c.daemon?.port);
@@ -470,7 +870,10 @@ function validate(c) {
   const auto = rawGates?.auto;
   return {
     ...c,
-    daemon: { port: Number.isInteger(port) && port > 0 && port < 65536 ? port : 7777 },
+    daemon: {
+      port: Number.isInteger(port) && port > 0 && port < 65536 ? port : 7777,
+      auth: c.daemon?.auth === "required" ? "required" : "loopback-optional"
+    },
     tasks: {
       source: typeof source === "string" && source.trim() && !source.startsWith("/") ? source.trim() : null,
       labels: Array.isArray(c.tasks?.labels) ? c.tasks.labels.filter((l) => typeof l === "string" && l.trim() !== "") : [],
@@ -487,6 +890,18 @@ 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),
+    events: {
+      retain_days: days(c.events?.retain_days, 30)
+    },
+    audit: {
+      retain_days: days(c.audit?.retain_days, 0)
+    },
+    privacy: {
+      store_prompts: c.privacy?.store_prompts !== false,
+      store_reasoning: c.privacy?.store_reasoning !== false,
+      redact: Array.isArray(c.privacy?.redact) ? c.privacy.redact.filter((r) => typeof r === "string" && r.length > 0) : []
+    },
     dispatch: {
       max_parallel: Number.isInteger(mp) && mp > 0 ? Math.min(mp, 16) : 2,
       permission_mode: str(d.permission_mode),
@@ -514,18 +929,84 @@ function validate(c) {
     }
   };
 }
-function loadConfig(opts = {}) {
+function leafPaths(v, prefix = "") {
+  if (!isRecord2(v))
+    return prefix ? [prefix] : [];
+  const keys = Object.keys(v);
+  if (keys.length === 0)
+    return prefix ? [prefix] : [];
+  return keys.flatMap((k) => leafPaths(v[k], prefix ? `${prefix}.${k}` : k));
+}
+function getPath(v, path) {
+  let cur = v;
+  for (const seg of path.split(".")) {
+    if (!isRecord2(cur))
+      return;
+    cur = cur[seg];
+  }
+  return cur;
+}
+function setPath(obj, path, value) {
+  const segs = path.split(".");
+  let cur = obj;
+  for (const seg of segs.slice(0, -1)) {
+    if (!isRecord2(cur[seg]))
+      cur[seg] = {};
+    cur = cur[seg];
+  }
+  cur[segs[segs.length - 1]] = value;
+}
+var isLockedBy = (path, lock) => path === lock || path.startsWith(`${lock}.`);
+function readLayer(path) {
+  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");
+  const policyPath = opts.policy ?? process.env.SWARM_POLICY ?? join2(home, "policy.toml");
+  const policyRaw = readLayer(policyPath);
+  const locked = Array.isArray(policyRaw?.locked) ? policyRaw.locked.filter((k) => typeof k === "string" && /^[a-z0-9_.-]+$/i.test(k)) : [];
+  const policy = { ...policyRaw ?? {} };
+  delete policy.locked;
+  const layers = [
+    ["policy", policyRaw ? policy : null],
+    ["global", readLayer(join2(home, "config.toml"))],
+    ["repo", opts.repoRoot ? readLayer(join2(opts.repoRoot, ".swarm.toml")) : null]
+  ];
+  const provenance = {};
+  for (const p of leafPaths(DEFAULT_CONFIG))
+    provenance[p] = "default";
+  const overridden = [];
   let cfg = DEFAULT_CONFIG;
-  const globalPath = join2(home, "config.toml");
-  if (existsSync2(globalPath))
-    cfg = merge(cfg, parseToml(readFileSync2(globalPath, "utf8"), globalPath));
-  if (opts.repoRoot) {
-    const repoPath = join2(opts.repoRoot, ".swarm.toml");
-    if (existsSync2(repoPath))
-      cfg = merge(cfg, parseToml(readFileSync2(repoPath, "utf8"), repoPath));
+  for (const [layer, raw] of layers) {
+    if (!raw)
+      continue;
+    for (const p of leafPaths(raw)) {
+      const lock = layer !== "policy" && locked.find((l) => isLockedBy(p, l));
+      if (lock)
+        overridden.push({ key: p, layer, attempted: getPath(raw, p) });
+      else
+        provenance[p] = layer;
+    }
+    cfg = merge(cfg, raw);
+  }
+  if (overridden.length) {
+    const out = structuredClone(cfg);
+    for (const { key } of overridden) {
+      const fromPolicy = getPath(policy, key);
+      setPath(out, key, fromPolicy === undefined ? getPath(DEFAULT_CONFIG, key) : fromPolicy);
+      provenance[key] = fromPolicy === undefined ? "default" : "policy";
+    }
+    cfg = out;
   }
-  return validate(cfg);
+  return {
+    config: validate(cfg),
+    provenance,
+    overridden,
+    policy: { path: policyRaw ? policyPath : null, locked }
+  };
+}
+function loadConfig(opts = {}) {
+  return loadConfigDetailed(opts).config;
 }
 // packages/core/src/dispatch.ts
 function planDispatch(tasks, wanted, opts) {
@@ -963,11 +1444,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"' };
@@ -1328,6 +1809,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/policy.ts
+import { createHash } from "crypto";
+var HOOK_MARK = "swarm-hook";
+var hookIsOurs = (h) => typeof h.command === "string" && (h.command.includes(HOOK_MARK) || h.command.includes("/packages/hook/src/bin.ts"));
+var MIN_HOOK_TIMEOUT_S = 5;
+function hookCoverage(settings) {
+  const hooks = settings && typeof settings === "object" && !Array.isArray(settings) ? settings.hooks : undefined;
+  const missing = [];
+  const short = [];
+  for (const ev of HOOK_EVENTS) {
+    const groups = Array.isArray(hooks?.[ev]) ? hooks?.[ev] : [];
+    const ours = groups.flatMap((g) => {
+      const list = g?.hooks;
+      return Array.isArray(list) ? list.filter((h) => hookIsOurs(h)) : [];
+    });
+    if (!ours.length)
+      missing.push(ev);
+    else if (ours.every((h) => typeof h.timeout === "number" && h.timeout < MIN_HOOK_TIMEOUT_S))
+      short.push(ev);
+  }
+  return { missing, short, complete: !missing.length && !short.length };
+}
+var hasLockedRules = (loaded) => loaded.policy.locked.some((k) => k === "rules" || k.startsWith("rules."));
+function policyFindings(input) {
+  const out = [];
+  const repo = input.repoRoot ?? "";
+  for (const o of input.loaded.overridden)
+    out.push({
+      key: `override:${repo}:${o.layer}:${o.key}`,
+      subject: `${o.layer === "repo" ? ".swarm.toml" : "config.toml"} ${o.key}`,
+      reason: `locked by policy; ${o.layer} config tried to set ${JSON.stringify(o.attempted)}`
+    });
+  const cov = input.coverage;
+  if (cov && !cov.complete) {
+    if (cov.missing.length)
+      out.push({
+        key: `hooks:missing:${cov.missing.join(",")}`,
+        subject: `hooks ${cov.missing.join(", ")}`,
+        reason: "swarm hook entry removed from settings.json \u2014 run: swarm install"
+      });
+    if (cov.short.length)
+      out.push({
+        key: `hooks:short:${cov.short.join(",")}`,
+        subject: `hooks ${cov.short.join(", ")}`,
+        reason: `hook timeout below ${MIN_HOOK_TIMEOUT_S}s \u2014 run: swarm install`
+      });
+  }
+  if (input.guardOff && hasLockedRules(input.loaded))
+    out.push({
+      key: "guard:off",
+      subject: "SWARM_GUARD=off",
+      reason: "policy locks rules; SWARM_GUARD=off is ignored for locked rules"
+    });
+  return out;
+}
+var POLICY_CACHE_VERSION = 1;
+var POLICY_CACHE_FILE = "policy.cache.json";
+var RULE_KEYS = [
+  "shared_tree",
+  "destructive_git",
+  "pattern_kill",
+  "protected_ports",
+  "no_foreign_worktree",
+  "claim_required_to_write"
+];
+var lockedKey = (locked, key) => locked.some((l) => l === "rules" || key === l || key.startsWith(`${l}.`));
+function offlineModes(loaded) {
+  const locked = loaded.policy.locked;
+  const out = { ...DEFAULT_MODES, protected: { ports: [] } };
+  for (const k of RULE_KEYS)
+    out[k] = lockedKey(locked, `rules.${k}`) ? loaded.config.rules[k] : "off";
+  if (lockedKey(locked, "rules.protected.ports"))
+    out.protected = { ports: [...loaded.config.rules.protected.ports] };
+  return out;
+}
+var digest = (body) => createHash("sha256").update(JSON.stringify(body)).digest("hex");
+function buildPolicyCache(loaded, sessions, worktrees, now = new Date) {
+  const body = {
+    version: POLICY_CACHE_VERSION,
+    writtenAt: now.toISOString(),
+    modes: offlineModes(loaded),
+    sessions,
+    worktrees
+  };
+  return { ...body, sha256: digest(body) };
+}
 // packages/core/src/pricing.ts
 var PRICES = {
   "claude-opus-4": { input: 15, output: 75, cacheWrite: 18.75, cacheWrite1h: 30, cacheRead: 1.5 },
@@ -1474,6 +2070,114 @@ function acquireRefusalMessage(holder) {
   const via = isTrackedPid(holder.pid) ? `pid ${holder.pid}` : holder.expiresAt ? `lease until ${holder.expiresAt}` : "unbounded";
   return `Resource "${holder.name}" is held by ${holder.owner} (${via}).` + ` Pick another name, coordinate with the holder, or wait for release/reap.`;
 }
+// packages/core/src/review.ts
+var REVIEW_RUBRIC = "review: no blocker/major findings \u2014 correctness bugs, data loss, security, broken invariants (never kill by pattern, never touch a worktree you don't hold, repo-agnostic), missing tests for changed behaviour";
+var REVIEW_PATCH_MAX = 120000;
+function reviewPrompt(input) {
+  const patch = input.patch.length > REVIEW_PATCH_MAX ? `${input.patch.slice(0, REVIEW_PATCH_MAX)}
+
+[\u2026 patch truncated at ${REVIEW_PATCH_MAX} chars; read the files for the rest]` : input.patch;
+  return [
+    `You are the review gate for task ${input.task}${input.title ? ` \u2014 ${input.title}` : ""}${input.branch ? ` (branch ${input.branch})` : ""}.`,
+    "You are read-only: you may Read, Grep and Glob files in this worktree to understand context. Do not edit anything.",
+    "",
+    "Judge the diff below against this rubric and nothing else:",
+    `- ${REVIEW_RUBRIC}`,
+    "- A finding is a concrete defect with a file and, when possible, a line \u2014 not style, not preference.",
+    "- Severity: blocker (must not merge), major (should not merge), minor (worth fixing), nit.",
+    '- verdict is "fail" if and only if there is at least one blocker or major finding.',
+    "",
+    "Respond with ONLY a JSON object, no prose, no code fence:",
+    '{"verdict":"pass"|"fail","summary":"one sentence","findings":[{"file":"path","line":123,"severity":"blocker|major|minor|nit","summary":"what is wrong and why"}]}',
+    "",
+    "Files changed:",
+    input.stat.trim() || "(no stat)",
+    "",
+    "Diff:",
+    patch.trim() || "(empty diff)"
+  ].join(`
+`);
+}
+function reviewArgs(prompt, opts = {}) {
+  const args = [
+    "-p",
+    prompt,
+    "--output-format",
+    "json",
+    "--allowedTools",
+    "Read",
+    "Grep",
+    "Glob",
+    "LS",
+    "--disallowedTools",
+    "Edit",
+    "Write",
+    "MultiEdit",
+    "NotebookEdit",
+    "Bash",
+    "WebFetch",
+    "WebSearch",
+    "--permission-mode",
+    "dontAsk"
+  ];
+  if (opts.model)
+    args.push("--model", opts.model);
+  return args;
+}
+function parseReviewVerdict(stdout) {
+  let text = stdout.trim();
+  try {
+    const env = JSON.parse(text);
+    if (env && typeof env === "object" && typeof env.result === "string")
+      text = env.result.trim();
+  } catch {}
+  text = text.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start < 0 || end <= start)
+    return null;
+  let obj;
+  try {
+    obj = JSON.parse(text.slice(start, end + 1));
+  } catch {
+    return null;
+  }
+  if (!obj || typeof obj !== "object")
+    return null;
+  const o = obj;
+  const findings = Array.isArray(o.findings) ? o.findings.filter((f) => !!f && typeof f === "object").map((f) => ({
+    file: String(f.file ?? "").slice(0, 300),
+    line: Number.isInteger(f.line) ? f.line : null,
+    severity: ["blocker", "major", "minor", "nit"].includes(String(f.severity)) ? String(f.severity) : "minor",
+    summary: String(f.summary ?? "").slice(0, 600)
+  })).filter((f) => f.summary) : [];
+  const serious = findings.some((f) => f.severity === "blocker" || f.severity === "major");
+  const verdict = serious ? "fail" : o.verdict === "fail" ? "fail" : "pass";
+  return { verdict, summary: String(o.summary ?? "").slice(0, 400), findings };
+}
+function reviewGateInput(task, gate, outcome) {
+  if (outcome.kind === "error")
+    return {
+      task,
+      gate,
+      verdict: "fail",
+      rubric: REVIEW_RUBRIC,
+      evidence: `reviewer did not answer: ${outcome.reason}${outcome.output ? `
+${outcome.output.slice(-1500)}` : ""}`
+    };
+  const v = outcome.verdict;
+  const lines = v.findings.map((f) => `- [${f.severity}] ${f.file}${f.line ? `:${f.line}` : ""} \u2014 ${f.summary}`);
+  const secs = (outcome.durationMs / 1000).toFixed(0);
+  return {
+    task,
+    gate,
+    verdict: v.verdict,
+    rubric: REVIEW_RUBRIC,
+    evidence: `${v.summary || (v.verdict === "pass" ? "no blocking findings" : "blocking findings")} (${v.findings.length} finding${v.findings.length === 1 ? "" : "s"}, ${secs}s)${lines.length ? `
+${lines.join(`
+`)}` : ""}`
+  };
+}
 // 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;
@@ -1707,10 +2411,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 join9 } 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) => {
@@ -1918,7 +2622,7 @@ var tryDecode = (str, decoder) => {
   }
 };
 var tryDecodeURI = (str) => tryDecode(str, decodeURI);
-var getPath = (request) => {
+var getPath2 = (request) => {
   const url = request.url;
   const start = url.indexOf("/", url.indexOf(":") + 4);
   let i = start;
@@ -1937,7 +2641,7 @@ var getPath = (request) => {
   return url.slice(start, i);
 };
 var getPathNoStrict = (request) => {
-  const result = getPath(request);
+  const result = getPath2(request);
   return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
 };
 var mergePath = (base, sub, ...rest) => {
@@ -2459,7 +3163,7 @@ var Hono = class _Hono {
     };
     const { strict, ...optionsWithoutStrict } = options;
     Object.assign(this, optionsWithoutStrict);
-    this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
+    this.getPath = strict ?? true ? options.getPath ?? getPath2 : getPathNoStrict;
   }
   #clone() {
     const clone = new _Hono({
@@ -3583,7 +4287,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 = [
@@ -3601,7 +4305,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;
@@ -4300,7 +5004,7 @@ class Runner {
 import { Database } from "bun:sqlite";
 import {
   closeSync,
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync4,
   openSync as openSync3,
   readdirSync,
@@ -4309,14 +5013,15 @@ import {
   realpathSync as realpathSync2,
   renameSync,
   statSync,
+  unlinkSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { homedir as homedir3 } from "os";
-import { basename, dirname as dirname2, join as join8 } from "path";
+import { homedir as homedir3, 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 });
@@ -4324,12 +5029,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) {
@@ -4491,6 +5196,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,
@@ -4519,6 +5230,11 @@ class Store {
     this.db.exec(SCHEMA);
     this.ensureColumn("sessions", "agent", "TEXT DEFAULT 'claude-code'");
     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();
     this.slimExistingEvents();
@@ -4567,9 +5283,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);
@@ -4601,8 +5317,59 @@ class Store {
       this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${col} ${decl}`);
     }
   }
+  static SCHEMA_VERSION = 1;
+  schemaVersion() {
+    return Number(this.meta("schema_version") ?? 0);
+  }
+  migrate() {
+    const steps = [
+      (db) => {
+        for (const t of [
+          "events",
+          "claims",
+          "resources",
+          "processes",
+          "handoffs",
+          "gates",
+          "incident_acks",
+          "sessions"
+        ]) {
+          this.ensureColumn(t, "actor_kind", "TEXT");
+          this.ensureColumn(t, "actor_id", "TEXT");
+        }
+        const user = osUser();
+        const fill = (table, ownerCol, sessionCol, key) => {
+          const rows = db.query(`SELECT rowid AS rid, ${ownerCol ?? "NULL"} AS owner, ${sessionCol ?? "NULL"} AS sid FROM ${table} WHERE actor_kind IS NULL`).all();
+          const upd = db.query(`UPDATE ${table} SET actor_kind = ?, actor_id = ? WHERE rowid = ?`);
+          for (const r of rows) {
+            const a = actorFrom(r.owner, r.sid, { user });
+            upd.run(a.kind, a.id, r.rid);
+          }
+          return `${key}:${rows.length}`;
+        };
+        fill("claims", "owner", null, "claims");
+        fill("resources", "owner", "session_id", "resources");
+        fill("processes", "owner", "session_id", "processes");
+        fill("handoffs", "by", "session_id", "handoffs");
+        fill("gates", "NULL", "session_id", "gates");
+        fill("incident_acks", "'dashboard'", null, "acks");
+        fill("sessions", "NULL", "id", "sessions");
+        fill("events", "COALESCE(json_extract(payload, '$.owner'), json_extract(payload, '$.by'))", "session_id", "events");
+      }
+    ];
+    for (let v = this.schemaVersion();v < steps.length; v++) {
+      const step = steps[v];
+      this.db.transaction(() => {
+        step(this.db);
+        this.setMeta("schema_version", String(v + 1));
+      })();
+    }
+  }
+  actorFor(owner, sessionId, runId) {
+    return actorFrom(owner, sessionId, { user: osUser(), runId });
+  }
   migrateProjectsJson(file) {
-    if (!existsSync5(file))
+    if (!existsSync6(file))
       return;
     try {
       const list = JSON.parse(readFileSync3(file, "utf8"));
@@ -4617,11 +5384,12 @@ 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;
   }
-  rulesCache = new Map;
+  policyCache = new Map;
+  policySeen = new Set;
   preregisterSpawnedSession(id, projectId, cwd, task) {
     const now = new Date().toISOString();
     this.db.query(`INSERT INTO sessions (id, project_id, kind, cwd, started_at, last_seen_at, last, last_type, state, title)
@@ -4650,8 +5418,8 @@ class Store {
       createdAt: new Date().toISOString()
     };
     const sessionId = this.knownSession(h.sessionId);
-    const ins = this.db.query(`INSERT INTO handoffs (project_id, task, done, remaining, files, verify, by, session_id, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(projectId, handoff.task, handoff.done, handoff.remaining, JSON.stringify(handoff.files), handoff.verify, handoff.by, sessionId, handoff.createdAt);
+    const ins = this.db.query(`INSERT INTO handoffs (project_id, task, done, remaining, files, verify, by, session_id, created_at, actor_kind, actor_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(projectId, handoff.task, handoff.done, handoff.remaining, JSON.stringify(handoff.files), handoff.verify, handoff.by, sessionId, handoff.createdAt, ...actorCols(this.actorFor(handoff.by, sessionId)));
     this.remember(handoffDoc(projectId, Number(ins.lastInsertRowid), handoff, sessionId));
     this.append({
       ts: handoff.createdAt,
@@ -4701,8 +5469,8 @@ class Store {
     if (!h)
       return null;
     this.db.query("DELETE FROM handoffs WHERE project_id = ? AND task = ? AND session_id = ? AND by LIKE 'auto%'").run(held.projectId, held.task, sessionId);
-    const ins = this.db.query(`INSERT INTO handoffs (project_id, task, done, remaining, files, verify, by, session_id, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(held.projectId, held.task, h.done, h.remaining, JSON.stringify(h.files), h.verify, h.by, sessionId, h.createdAt);
+    const ins = this.db.query(`INSERT INTO handoffs (project_id, task, done, remaining, files, verify, by, session_id, created_at, actor_kind, actor_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(held.projectId, held.task, h.done, h.remaining, JSON.stringify(h.files), h.verify, h.by, sessionId, h.createdAt, ...actorCols(this.actorFor(h.by, sessionId)));
     this.remember(handoffDoc(held.projectId, Number(ins.lastInsertRowid), h, sessionId));
     this.touch();
     return h;
@@ -4822,7 +5590,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);
@@ -4962,7 +5730,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)
@@ -5039,13 +5960,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))
@@ -5054,6 +5975,8 @@ class Store {
     const logDir = join8(this.home, "logs", projectId);
     mkdirSync4(logDir, { recursive: true });
     const log = join8(logDir, `gate-${slug(task)}-${slug(gate)}.log`);
+    if (def.builtin === "review")
+      return this.runReviewGate(projectId, task, gate, def, { worktree: worktree2, cwd, key, log }, opts);
     writeFileSync2(log, `$ ${def.cmd}
 # cwd ${cwd} \xB7 ${new Date().toISOString()}
 `);
@@ -5133,6 +6056,134 @@ class Store {
     this.gateJobs.set(key, done);
     return { ok: true, pid: proc.pid, log, done };
   }
+  runReviewGate(projectId, task, gate, def, where, opts) {
+    const bin = findBin("claude");
+    if (!bin)
+      return { ok: false, reason: "claude CLI not found \u2014 the review gate needs Claude Code" };
+    const p = this.project(projectId);
+    if (!p)
+      return { ok: false, reason: "unknown project" };
+    const started = Date.now();
+    const record = (input) => {
+      const run2 = this.recordGate(projectId, { ...input, sessionId: opts.sessionId ?? null });
+      return run2.ok ? run2.run : null;
+    };
+    const done = (async () => {
+      let diffText = "";
+      let stat = "";
+      try {
+        const diff = await worktreeDiff(p.root, where.worktree);
+        stat = diff.files.map((f) => `${f.status ?? "M"} ${f.path} (+${f.added} -${f.deleted})`).join(`
+`);
+        diffText = await worktreePatch(where.worktree, diff.base);
+      } catch (e) {
+        return record(reviewGateInput(task, gate, {
+          kind: "error",
+          reason: `diff failed: ${e.message}`,
+          durationMs: Date.now() - started
+        }));
+      }
+      if (!diffText.trim())
+        return record(reviewGateInput(task, gate, {
+          kind: "verdict",
+          durationMs: Date.now() - started,
+          verdict: { verdict: "pass", summary: "nothing to review \u2014 empty diff", findings: [] }
+        }));
+      const taskRow = this.tasks(projectId)?.tasks.find((t) => t.id === task) ?? null;
+      const w = this.findWorktree(projectId, where.worktree);
+      const prompt = reviewPrompt({
+        task,
+        title: taskRow?.title ?? null,
+        branch: w?.branch ?? null,
+        stat,
+        patch: diffText
+      });
+      writeFileSync2(where.log, `$ claude -p <review prompt, ${prompt.length} chars> --output-format json (read-only)
+# cwd ${where.cwd} \xB7 ${new Date().toISOString()}
+`);
+      let proc;
+      try {
+        proc = Bun.spawn([bin, ...reviewArgs(prompt, { model: def.model })], {
+          cwd: where.cwd,
+          stdin: "ignore",
+          stdout: "pipe",
+          stderr: "pipe",
+          env: {
+            ...process.env,
+            SWARM_WORKTREE: where.worktree,
+            SWARM_TASK: task,
+            SWARM_GATE: gate,
+            CLAUDE_CODE_DISABLE_AUTOUPDATE: "1"
+          }
+        });
+      } catch (e) {
+        return record(reviewGateInput(task, gate, {
+          kind: "error",
+          reason: e.message,
+          durationMs: Date.now() - started
+        }));
+      }
+      const reg = this.registerProcess({
+        pid: proc.pid,
+        projectId,
+        sessionId: opts.sessionId ?? null,
+        kind: "gate",
+        name: `gate:${task}:${gate}`,
+        cwd: where.cwd,
+        cmd: "claude -p (review)",
+        owner: opts.owner ?? "daemon",
+        log: where.log
+      });
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        try {
+          proc.kill("SIGTERM");
+          setTimeout(() => {
+            try {
+              proc.kill("SIGKILL");
+            } catch {}
+          }, 5000).unref();
+        } catch {}
+      }, def.timeout * 1000);
+      const [out, err] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text()
+      ]);
+      const code = await proc.exited;
+      clearTimeout(timer);
+      try {
+        writeFileSync2(where.log, `${readFileSync3(where.log, "utf8")}${out}
+${err}
+# exit ${timedOut ? "timeout" : code} \xB7 ${((Date.now() - started) / 1000).toFixed(0)}s
+`);
+      } catch {}
+      if (reg.ok)
+        this.processes(projectId);
+      const durationMs = Date.now() - started;
+      if (timedOut)
+        return record(reviewGateInput(task, gate, {
+          kind: "error",
+          reason: `timed out after ${def.timeout}s`,
+          durationMs,
+          output: err
+        }));
+      const verdict = parseReviewVerdict(out);
+      if (!verdict)
+        return record(reviewGateInput(task, gate, {
+          kind: "error",
+          reason: code === 0 ? "no JSON verdict in the reply" : `claude exited ${code}`,
+          durationMs,
+          output: err || out
+        }));
+      return record(reviewGateInput(task, gate, { kind: "verdict", verdict, durationMs }));
+    })().finally(() => {
+      this.gateJobs.delete(where.key);
+      this.touch();
+    });
+    this.gateJobs.set(where.key, done);
+    return { ok: true, pid: 0, log: where.log, done };
+  }
   async runGates(projectId, task, gates2, opts = {}) {
     const cfg = this.gateDefs(projectId);
     const names = gates2?.length ? gates2 : (cfg?.required ?? []).filter((g) => cfg?.defs[g]);
@@ -5202,8 +6253,8 @@ class Store {
       return v;
     const createdAt = new Date().toISOString();
     const sessionId = this.knownSession(input.sessionId);
-    const r = this.db.query(`INSERT INTO gates (project_id, task, gate, verdict, rubric, evidence, session_id, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(projectId, input.task.trim(), input.gate, input.verdict, input.rubric.trim(), input.evidence?.trim() || null, sessionId, createdAt);
+    const r = this.db.query(`INSERT INTO gates (project_id, task, gate, verdict, rubric, evidence, session_id, created_at, actor_kind, actor_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(projectId, input.task.trim(), input.gate, input.verdict, input.rubric.trim(), input.evidence?.trim() || null, sessionId, createdAt, ...actorCols(this.actorFor(input.sessionId ? null : "daemon", sessionId)));
     const run2 = this.rowToGate(this.db.query("SELECT * FROM gates WHERE id = ?").get(Number(r.lastInsertRowid)));
     this.remember(gateDoc(projectId, run2.id, run2, sessionId));
     this.append({
@@ -5256,7 +6307,7 @@ class Store {
       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);
@@ -5289,16 +6340,70 @@ class Store {
     return { source, required, tasks: board, error };
   }
   rulesFor(repoRoot) {
+    return this.policyFor(repoRoot).config.rules;
+  }
+  policyFor(repoRoot) {
     const key = repoRoot ?? "";
-    const hit = this.rulesCache.get(key);
+    const hit = this.policyCache.get(key);
     if (hit && Date.now() - hit.at < 30000)
-      return hit.rules;
-    const rules2 = loadConfig({ repoRoot, home: this.home }).rules;
-    this.rulesCache.set(key, { at: Date.now(), rules: rules2 });
-    return rules2;
+      return hit.loaded;
+    const loaded = loadConfigDetailed({ repoRoot, home: this.home });
+    this.policyCache.set(key, { at: Date.now(), loaded });
+    this.writePolicyCache(loaded);
+    return loaded;
+  }
+  writePolicyCache(loaded) {
+    const file = join8(this.home, POLICY_CACHE_FILE);
+    try {
+      if (!hasLockedRules(loaded)) {
+        if (existsSync6(file))
+          unlinkSync(file);
+        return;
+      }
+      const cache = buildPolicyCache(loaded, this.liveSessions(), this.heldWorktrees());
+      writeFileSync2(file, JSON.stringify(cache), { mode: 384 });
+    } catch (e) {
+      console.error(`swarm: policy cache: ${e.message}`);
+    }
+  }
+  guardDisabled(repoRoot) {
+    return process.env.SWARM_GUARD === "off" && !hasLockedRules(this.policyFor(repoRoot));
+  }
+  claudeSettings() {
+    const p = process.env.CLAUDE_SETTINGS ?? join8(homedir3(), ".claude", "settings.json");
+    try {
+      return existsSync6(p) ? JSON.parse(readFileSync3(p, "utf8")) : null;
+    } catch {
+      return null;
+    }
+  }
+  checkPolicy(cwd, sessionId) {
+    const project = existsSync6(cwd) ? this.resolveProject(cwd) : null;
+    const repoRoot = project?.root ?? null;
+    const loaded = this.policyFor(repoRoot);
+    const settings = this.claudeSettings();
+    const findings = policyFindings({
+      loaded,
+      coverage: settings === null ? null : hookCoverage(settings),
+      guardOff: process.env.SWARM_GUARD === "off",
+      repoRoot
+    });
+    for (const f of findings) {
+      if (this.policySeen.has(f.key))
+        continue;
+      this.policySeen.add(f.key);
+      this.append({
+        ts: new Date().toISOString(),
+        type: "incident.opened",
+        projectId: project?.id ?? "p_unknown",
+        sessionId,
+        payload: { rule: "policy", action: "tampered", command: f.subject, reason: f.reason }
+      });
+    }
+    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") {
@@ -5389,7 +6494,7 @@ class Store {
     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",
@@ -5440,7 +6545,7 @@ class Store {
       }
     }
     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 };
@@ -5456,7 +6561,7 @@ class Store {
     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"));
@@ -5498,6 +6603,8 @@ class Store {
       name: r.name,
       discovered: Boolean(r.discovered),
       order: typeof r.sort_order === "number" ? r.sort_order : null,
+      icon: r.icon ?? null,
+      color: r.color ?? null,
       createdAt: r.created_at
     }));
   }
@@ -5512,6 +6619,8 @@ class Store {
       name: r.name,
       discovered: Boolean(r.discovered),
       order: typeof r.sort_order === "number" ? r.sort_order : null,
+      icon: r.icon ?? null,
+      color: r.color ?? null,
       createdAt: r.created_at
     };
   }
@@ -5549,6 +6658,8 @@ class Store {
         ...ident,
         discovered: !explicit,
         order: null,
+        icon: null,
+        color: null,
         createdAt: new Date().toISOString()
       };
       if (name)
@@ -5569,8 +6680,24 @@ class Store {
       return;
     if (patch.pinned !== undefined)
       this.db.query("UPDATE projects SET discovered = ? WHERE id = ?").run(patch.pinned ? 0 : 1, id);
-    if (patch.name)
-      this.db.query("UPDATE projects SET name = ? WHERE id = ?").run(patch.name, id);
+    if (patch.name?.trim())
+      this.db.query("UPDATE projects SET name = ? WHERE id = ?").run(patch.name.trim(), id);
+    if (patch.icon !== undefined) {
+      const icon = (patch.icon ?? "").trim();
+      const isImage = /^data:image\/(png|jpeg|webp);base64,[A-Za-z0-9+/=]+$/.test(icon);
+      if (!isImage && [...icon].length > 4)
+        return;
+      if (isImage && icon.length > 24000)
+        return;
+      this.db.query("UPDATE projects SET icon = ? WHERE id = ?").run(icon || null, id);
+    }
+    if (patch.color !== undefined) {
+      const color = (patch.color ?? "").trim();
+      if (color && !/^c[1-7]$/.test(color))
+        return;
+      this.db.query("UPDATE projects SET color = ? WHERE id = ?").run(color || null, id);
+    }
+    this.touch();
     return this.project(id);
   }
   reorderProjects(ids) {
@@ -5589,10 +6716,29 @@ class Store {
     this.touch();
     return this.db.query("DELETE FROM projects WHERE id = ?").run(id).changes > 0;
   }
-  append(e) {
+  redactions() {
+    const cfg = this.policyFor(null).config.privacy;
+    const key = cfg.redact.join("\x00");
+    if (this.redactCache?.key !== key)
+      this.redactCache = { key, res: compileRedactions(cfg.redact) };
+    return this.redactCache.res;
+  }
+  redactCache = null;
+  append(e0) {
+    const privacy = this.policyFor(null).config.privacy;
+    let e = e0;
+    if (!privacy.store_prompts && e.type === "prompt.submitted" && e.payload && typeof e.payload === "object") {
+      const { prompt: _p, ...rest } = e.payload;
+      e = { ...e, payload: { ...rest, prompt: "[not stored]" } };
+    }
+    const res = this.redactions();
+    if (res.length)
+      e = { ...e, payload: redactValue(e.payload, res), raw: redactValue(e.raw, res) };
     const slim = slimForStorage(e);
-    const r = this.db.query("INSERT INTO events (ts, type, project_id, session_id, payload, raw) VALUES (?, ?, ?, ?, ?, ?)").run(e.ts, e.type, e.projectId, e.sessionId, JSON.stringify(slim.payload ?? null), slim.raw === undefined ? null : JSON.stringify(slim.raw));
-    const stored = { ...e, seq: Number(r.lastInsertRowid) };
+    const p = e.payload ?? {};
+    const actor2 = e.actor ?? this.actorFor(typeof p.owner === "string" ? p.owner : typeof p.by === "string" ? p.by : null, e.sessionId);
+    const r = this.db.query("INSERT INTO events (ts, type, project_id, session_id, payload, raw, actor_kind, actor_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(e.ts, e.type, e.projectId, e.sessionId, JSON.stringify(slim.payload ?? null), slim.raw === undefined ? null : JSON.stringify(slim.raw), actor2.kind, actor2.id);
+    const stored = { ...e, actor: actor2, seq: Number(r.lastInsertRowid) };
     if (stored.type === "incident.opened")
       this.remember(incidentDoc(stored.projectId, stored.seq, stored.payload, stored.ts, stored.sessionId));
     this.projectSession(stored);
@@ -5602,9 +6748,34 @@ class Store {
       l(wire);
     return stored;
   }
-  prune(days = 30) {
-    const cutoff = new Date(Date.now() - days * 86400000).toISOString();
-    const n = this.db.query("DELETE FROM events WHERE ts < ? AND type != 'incident.opened'").run(cutoff).changes;
+  audit(opts = {}) {
+    const where = [`type IN (${AUDIT_TYPES_SQL})`];
+    const args = [];
+    if (opts.since) {
+      where.push("ts >= ?");
+      args.push(opts.since);
+    }
+    if (opts.projectId) {
+      where.push("project_id = ?");
+      args.push(opts.projectId);
+    }
+    if (opts.type && isAuditType(opts.type)) {
+      where.push("type = ?");
+      args.push(opts.type);
+    }
+    const limit = Math.min(Math.max(opts.limit ?? 1e4, 1), 1e5);
+    const rows = this.db.query(`SELECT * FROM (SELECT ${WIRE_COLS} FROM events WHERE ${where.join(" AND ")} ORDER BY seq DESC LIMIT ?) ORDER BY seq`).all(...args, limit);
+    return rows.map((r) => auditRow(wireRowToEvent(r)));
+  }
+  prune(days2) {
+    const cfg = this.policyFor(null).config;
+    const chatter = days2 ?? cfg.events.retain_days;
+    const cutoff = new Date(Date.now() - chatter * 86400000).toISOString();
+    let n = this.db.query(`DELETE FROM events WHERE ts < ? AND type NOT IN (${AUDIT_TYPES_SQL})`).run(cutoff).changes;
+    if (cfg.audit.retain_days > 0) {
+      const acut = new Date(Date.now() - cfg.audit.retain_days * 86400000).toISOString();
+      n += this.db.query(`DELETE FROM events WHERE ts < ? AND type IN (${AUDIT_TYPES_SQL}) AND type != 'incident.opened'`).run(acut).changes;
+    }
     const old = new Date(Date.now() - 7 * 86400000).toISOString();
     this.db.query("UPDATE events SET raw = NULL WHERE ts < ? AND raw IS NOT NULL").run(old);
     if (n > 0)
@@ -5615,10 +6786,10 @@ class Store {
     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);
       }
@@ -5664,7 +6835,7 @@ class Store {
       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);
     }
@@ -5702,13 +6873,15 @@ class Store {
     }
   }
   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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        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`);
     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), t.text, 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, costUsd(t.model, t.usage, this.prices), privacy.store_reasoning ? redactValue(t.text, res) : "", JSON.stringify(t.tools));
       }
     });
     if (turns.length)
@@ -5734,10 +6907,10 @@ class Store {
   }
   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, ""));
     }
@@ -5805,7 +6978,7 @@ class Store {
     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)) {
@@ -5817,9 +6990,54 @@ class Store {
     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) => {
@@ -5842,7 +7060,7 @@ class Store {
       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)
@@ -5901,9 +7119,9 @@ class Store {
   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) => ({
@@ -5939,7 +7157,7 @@ class Store {
     const p = this.project(projectId);
     return join8(this.home, "worktrees", slug(p?.name ?? projectId), slug(task));
   }
-  claim(projectId, task, owner, baseRef = "HEAD") {
+  claim(projectId, task, owner, baseRef = "HEAD", sessionId = null) {
     const p = this.project(projectId);
     if (!p)
       return { ok: false, error: "unknown project" };
@@ -5949,24 +7167,26 @@ class Store {
       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}` };
     this.invalidateWorktrees(projectId);
     const expiresAt = nextExpiry(now);
     const acquiredAt = new Date(now).toISOString();
-    this.db.query(`INSERT INTO claims (project_id, task, owner, worktree, branch, acquired_at, expires_at, released_at, state)
-         VALUES (?, ?, ?, ?, ?, ?, ?, NULL, 'held')
+    this.db.query(`INSERT INTO claims (project_id, task, owner, worktree, branch, acquired_at, expires_at, released_at, state, actor_kind, actor_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?, NULL, 'held', ?, ?)
          ON CONFLICT(project_id, task) DO UPDATE SET owner=excluded.owner, worktree=excluded.worktree, branch=excluded.branch,
-           acquired_at=excluded.acquired_at, expires_at=excluded.expires_at, released_at=NULL, state='held'`).run(projectId, task, owner, created, branch, acquiredAt, expiresAt);
+           acquired_at=excluded.acquired_at, expires_at=excluded.expires_at, released_at=NULL, state='held',
+           actor_kind=excluded.actor_kind, actor_id=excluded.actor_id`).run(projectId, task, owner, created, branch, acquiredAt, expiresAt, ...actorCols(this.actorFor(owner, sessionId)));
     this.append({
       ts: acquiredAt,
       type: "claim.acquired",
       projectId,
-      sessionId: null,
+      sessionId,
+      actor: this.actorFor(owner, sessionId),
       payload: { task, owner, worktree: created, branch, summary: `claim ${task} by ${owner}` }
     });
     const bootstrap = this.bootstrapWorktree(projectId, task, p.root, created);
@@ -6059,7 +7279,7 @@ class Store {
       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;
@@ -6115,7 +7335,7 @@ class Store {
     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)
@@ -6150,7 +7370,7 @@ class Store {
           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")
@@ -6249,9 +7469,9 @@ class Store {
     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)
@@ -6642,19 +7862,19 @@ class Store {
          WHERE e.type = 'incident.opened' AND a.seq IS NULL${projectId ? " AND e.project_id = ?" : ""}`).get(...projectId ? [projectId] : []);
     return r.n;
   }
-  ackIncident(seq) {
+  ackIncident(seq, by) {
     const row = this.db.query("SELECT seq FROM events WHERE seq = ? AND type = 'incident.opened'").get(seq);
     if (!row)
       return false;
-    this.db.query("INSERT OR IGNORE INTO incident_acks (seq, acked_at) VALUES (?, ?)").run(seq, new Date().toISOString());
+    this.db.query("INSERT OR IGNORE INTO incident_acks (seq, acked_at, actor_kind, actor_id) VALUES (?, ?, ?, ?)").run(seq, new Date().toISOString(), ...actorCols(this.actorFor(by ?? "dashboard")));
     this.touch();
     return true;
   }
-  ackAllIncidents(projectId) {
+  ackAllIncidents(projectId, by) {
     const at = new Date().toISOString();
-    const r = this.db.query(`INSERT OR IGNORE INTO incident_acks (seq, acked_at)
-         SELECT e.seq, ? FROM events e LEFT JOIN incident_acks a ON a.seq = e.seq
-         WHERE e.type = 'incident.opened' AND a.seq IS NULL${projectId ? " AND e.project_id = ?" : ""}`).run(at, ...projectId ? [projectId] : []);
+    const r = this.db.query(`INSERT OR IGNORE INTO incident_acks (seq, acked_at, actor_kind, actor_id)
+         SELECT e.seq, ?, ?, ? FROM events e LEFT JOIN incident_acks a ON a.seq = e.seq
+         WHERE e.type = 'incident.opened' AND a.seq IS NULL${projectId ? " AND e.project_id = ?" : ""}`).run(at, ...actorCols(this.actorFor(by ?? "dashboard")), ...projectId ? [projectId] : []);
     this.touch();
     return Number(r.changes);
   }
@@ -6821,8 +8041,8 @@ class Store {
       endedAt: null
     };
     this.db.query("UPDATE processes SET ended_at = ? WHERE ended_at IS NULL AND project_id = ? AND name = ?").run(p.startedAt, p.projectId, p.name);
-    this.db.query(`INSERT INTO processes (pid, start_time, project_id, session_id, kind, name, port, cwd, cmd, owner, log, started_at, ended_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)`).run(p.pid, p.startTime, p.projectId, p.sessionId, p.kind, p.name, p.port, p.cwd, p.cmd, p.owner, p.log, p.startedAt);
+    this.db.query(`INSERT INTO processes (pid, start_time, project_id, session_id, kind, name, port, cwd, cmd, owner, log, started_at, ended_at, actor_kind, actor_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`).run(p.pid, p.startTime, p.projectId, p.sessionId, p.kind, p.name, p.port, p.cwd, p.cmd, p.owner, p.log, p.startedAt, ...actorCols(this.actorFor(p.owner, p.sessionId)));
     this.append({
       ts: p.startedAt,
       type: "process.started",
@@ -6886,11 +8106,12 @@ class Store {
       expiresAt,
       released: false
     };
-    this.db.query(`INSERT INTO resources (name, project_id, kind, owner, session_id, pid, port, acquired_at, expires_at, released)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
+    this.db.query(`INSERT INTO resources (name, project_id, kind, owner, session_id, pid, port, acquired_at, expires_at, released, actor_kind, actor_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
          ON CONFLICT(name, project_id) DO UPDATE SET
            kind=excluded.kind, owner=excluded.owner, session_id=excluded.session_id, pid=excluded.pid,
-           port=excluded.port, acquired_at=excluded.acquired_at, expires_at=excluded.expires_at, released=0`).run(resource.name, key, resource.kind, resource.owner, resource.sessionId, resource.pid, resource.port, resource.acquiredAt, resource.expiresAt);
+           port=excluded.port, acquired_at=excluded.acquired_at, expires_at=excluded.expires_at, released=0,
+           actor_kind=excluded.actor_kind, actor_id=excluded.actor_id`).run(resource.name, key, resource.kind, resource.owner, resource.sessionId, resource.pid, resource.port, resource.acquiredAt, resource.expiresAt, ...actorCols(this.actorFor(resource.owner, resource.sessionId)));
     this.append({
       ts: resource.acquiredAt,
       type: "resource.acquired",
@@ -6935,9 +8156,51 @@ class Store {
   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();
+    const projects = this.projects().filter((p) => !(p.discovered && isScratchRoot(p.root)));
     for (const p of projects)
       worktrees[p.id] = this.worktrees(p.id);
     return {
@@ -6945,6 +8208,7 @@ class Store {
       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 })),
@@ -6955,7 +8219,7 @@ class Store {
     };
   }
 }
-var WIRE_COLS = "seq, ts, type, project_id, session_id, json_remove(payload, '$.toolInput', '$.toolResponse', '$.prompt') AS payload";
+var WIRE_COLS = "seq, ts, type, project_id, session_id, actor_kind, actor_id, json_remove(payload, '$.toolInput', '$.toolResponse', '$.prompt') AS payload";
 var RAW_TOOL_KEYS = ["tool_input", "tool_response", "toolInput", "toolResponse", "toolResult"];
 var TOOL_INPUT_MAX = 2048;
 var TOOL_RESPONSE_MAX = 4096;
@@ -7001,7 +8265,7 @@ function toWire(e) {
 }
 function wireRowToEvent(r) {
   const p = JSON.parse(r.payload ?? "null");
-  return {
+  const e = {
     seq: r.seq,
     ts: r.ts,
     type: r.type,
@@ -7009,6 +8273,10 @@ function wireRowToEvent(r) {
     sessionId: r.session_id ?? null,
     payload: p
   };
+  const a = actorFromColumns(r.actor_kind, r.actor_id, r.session_id);
+  if (a)
+    e.actor = a;
+  return e;
 }
 function rowToEvent(r) {
   const e = {
@@ -7021,17 +8289,259 @@ function rowToEvent(r) {
   };
   if (r.raw)
     e.raw = JSON.parse(r.raw);
+  const a = actorFromColumns(r.actor_kind, r.actor_id, r.session_id);
+  if (a)
+    e.actor = a;
   return e;
 }
+function osUser() {
+  try {
+    return userInfo().username || process.env.USER || "me";
+  } catch {
+    return process.env.USER || "me";
+  }
+}
+var actorCols = (a) => [a.kind, a.id];
+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/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.7.0";
+var VERSION = "0.9.0";
 var WEB_DIR = (() => {
   if (process.env.SWARM_WEB_DIR)
     return process.env.SWARM_WEB_DIR;
-  const here = dirname3(fileURLToPath(import.meta.url));
+  const here = dirname4(fileURLToPath2(import.meta.url));
   const dev = join9(here, "../../web/public");
-  return existsSync6(join9(dev, "index.html")) ? dev : join9(here, "../web");
+  return existsSync7(join9(dev, "index.html")) ? dev : join9(here, "../web");
 })();
 var REPLAY_TAIL = 200;
 var wireCache = new WeakMap;
@@ -7043,17 +8553,69 @@ function wireJson(e) {
   }
   return s;
 }
-function createApp(store = new Store) {
+function hookRepoRoot(store, raw2) {
+  const cwd = typeof raw2.cwd === "string" ? raw2.cwd : "";
+  return cwd && existsSync7(cwd) ? store.resolveProject(cwd)?.root ?? null : null;
+}
+function claudeSettings() {
+  try {
+    const p = process.env.CLAUDE_SETTINGS ?? join9(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, join9(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, 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);
   store.onBudgetStop((projectId) => {
     dispatcher.clear(projectId);
     for (const run2 of runner.list(projectId))
       runner.stop(run2.id);
   });
-  app.get("/v1/health", (c) => c.json({ ok: true, version: VERSION }));
+  app.use("/v1/*", async (c, next) => {
+    if (c.req.path === "/v1/health")
+      return next();
+    const token = readToken(store.home);
+    const given = c.req.header("authorization")?.replace(/^Bearer\s+/i, "") ?? c.req.query("token");
+    if (token && given && given === token)
+      return next();
+    if (given)
+      return c.json({ error: "unauthorized: wrong daemon token" }, 401);
+    const ip = c.env?.requestIP?.(c.req.raw)?.address;
+    const loopback = !ip || ip === "127.0.0.1" || ip === "::1" || ip === "::ffff:127.0.0.1";
+    if (loopback && store.policyFor(null).config.daemon.auth !== "required")
+      return next();
+    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(),
+    auth: store.policyFor(null).config.daemon.auth
+  }));
   app.get("/v1/projects", (c) => c.json(store.snapshot().projects));
   app.post("/v1/projects", async (c) => {
     const { path, name } = await c.req.json();
@@ -7072,22 +8634,24 @@ function createApp(store = new Store) {
     return c.json(store.reorderProjects(ids));
   });
   app.patch("/v1/projects/:id", async (c) => {
-    const { pinned, name } = await c.req.json().catch(() => ({}));
-    const p = store.updateProject(c.req.param("id"), { pinned, name });
-    return p ? c.json(p) : c.json({ error: "not found" }, 404);
+    const { pinned, name, icon, color } = await c.req.json().catch(() => ({}));
+    if (!store.project(c.req.param("id")))
+      return c.json({ error: "not found" }, 404);
+    const p = store.updateProject(c.req.param("id"), { pinned, name, icon, color });
+    return p ? c.json(p) : c.json({ error: "icon is at most 4 characters; color is c1\u2026c7" }, 400);
   });
   app.delete("/v1/projects/:id", (c) => store.removeProject(c.req.param("id")) ? c.body(null, 204) : c.json({ error: "not found" }, 404));
   app.get("/v1/fs/ls", (c) => {
     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(join9(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);
@@ -7112,6 +8676,37 @@ function createApp(store = new Store) {
       })
     });
   });
+  app.get("/v1/policy", (c) => {
+    const id = c.req.query("project");
+    const p = id ? store.project(id) : null;
+    if (id && !p)
+      return c.json({ error: "unknown project" }, 404);
+    const { provenance, overridden, policy: policy2 } = store.policyFor(p?.root ?? null);
+    return c.json({ ...policy2, provenance, overridden });
+  });
+  app.get("/v1/audit", (c) => {
+    const since = sinceToIso(c.req.query("since"));
+    if (c.req.query("since") && !since)
+      return c.json({ error: "since: use 30d / 12h / 90m or an ISO date" }, 400);
+    const pid = c.req.query("project") || null;
+    if (pid && !store.project(pid))
+      return c.json({ error: "unknown project" }, 404);
+    const rows = store.audit({
+      since,
+      projectId: pid,
+      type: c.req.query("type") || null,
+      limit: Number(c.req.query("limit")) || undefined
+    });
+    const format = c.req.query("format") === "csv" ? "csv" : c.req.query("format") === "jsonl" ? "jsonl" : "json";
+    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)
@@ -7125,11 +8720,11 @@ function createApp(store = new Store) {
   });
   app.post("/v1/incidents/ack", async (c) => {
     const body = await c.req.json().catch(() => ({}));
-    return c.json({ ok: true, acked: store.ackAllIncidents(body.project || undefined) });
+    return c.json({ ok: true, acked: store.ackAllIncidents(body.project || undefined, body.by) });
   });
   app.post("/v1/incidents/:seq/ack", (c) => {
     const seq = Number(c.req.param("seq"));
-    if (!Number.isInteger(seq) || !store.ackIncident(seq))
+    if (!Number.isInteger(seq) || !store.ackIncident(seq, c.req.query("by")))
       return c.json({ ok: false, error: "no such incident" }, 404);
     return c.json({ ok: true });
   });
@@ -7246,6 +8841,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)
@@ -7377,7 +9024,7 @@ function createApp(store = new Store) {
     const b = await c.req.json();
     if (!b.projectId || !b.task)
       return c.json({ error: "projectId and task required" }, 400);
-    const r = store.claim(b.projectId, b.task, b.owner ?? "cli", b.baseRef);
+    const r = store.claim(b.projectId, b.task, b.owner ?? "cli", b.baseRef, b.sessionId ?? null);
     return c.json(r, r.ok ? 201 : 409);
   });
   app.post("/v1/claims/renew", async (c) => {
@@ -7524,6 +9171,7 @@ function createApp(store = new Store) {
     const raw2 = await c.req.json().catch(() => ({}));
     store.ingestHook(event, raw2);
     if (event === "SessionStart" && typeof raw2.cwd === "string") {
+      store.checkPolicy(raw2.cwd, typeof raw2.session_id === "string" ? raw2.session_id : null);
       const ctx = store.sessionContext(raw2.cwd);
       if (ctx)
         return c.json({
@@ -7533,7 +9181,7 @@ function createApp(store = new Store) {
     }
     const sid = typeof raw2.session_id === "string" ? raw2.session_id : null;
     const answers = event === "UserPromptSubmit" || event === "PreToolUse" || event === "PostToolUse" ? store.answerContext(sid) : null;
-    if (event === "PreToolUse" && process.env.SWARM_GUARD !== "off") {
+    if (event === "PreToolUse" && !store.guardDisabled(hookRepoRoot(store, raw2))) {
       const guard = store.guardHook(raw2);
       if (guard) {
         return c.json({
@@ -7566,7 +9214,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) });
         });
@@ -7574,7 +9222,7 @@ function createApp(store = new Store) {
         stream2.onAbort(() => {
           clearInterval(beat);
           off();
-          resolve();
+          resolve2();
         });
       });
     });
@@ -7584,18 +9232,107 @@ function createApp(store = new Store) {
   app.get("/:file{[a-z0-9-]+\\.(js|css)}", (c) => {
     const f = c.req.param("file");
     const p = join9(WEB_DIR, f);
-    if (!existsSync6(p))
+    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 };
+}
+
+// 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 } = 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 {
@@ -7607,20 +9344,50 @@ 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);
+}
 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.reapResources();
   store.reapProcesses();