@ra3orblade/swarm 0.6.0 → 0.8.0

package/dist/swarmd.js

@@ -2,6 +2,7 @@
 // @bun
 
 // packages/client/src/daemon.ts
+import { randomBytes } from "crypto";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
@@ -18,9 +19,65 @@ 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 });
 }
+// 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 = {
@@ -229,6 +286,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,13 +391,254 @@ 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"
+]);
+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) => ({
+    spent: s,
+    limit: l,
+    pct: l && l > 0 ? s / l : 0
+  });
+  const daily = part(spent.today, cfg.daily);
+  const weekly = part(spent.week, cfg.weekly);
+  const candidates = [
+    ["daily", daily],
+    ["weekly", weekly]
+  ];
+  let kind = null;
+  let top = { spent: 0, limit: null, pct: 0 };
+  for (const [k, v] of candidates)
+    if (v.limit && v.pct >= top.pct)
+      ({ kind, top } = { kind: k, top: v });
+  const level = !kind ? "ok" : top.pct >= 1 ? "exceeded" : top.pct >= cfg.warn_at ? "warn" : "ok";
+  return { level, kind, spent: top.spent, limit: top.limit, pct: top.pct, daily, weekly };
+}
+var BUDGET_ASK_TOOLS = new Set(["Bash", "Edit", "Write", "MultiEdit", "NotebookEdit"]);
+function budgetMessage(s, project) {
+  const usd = (n) => `$${n.toFixed(2)}`;
+  if (s.level === "ok" || !s.limit)
+    return `${project}: within budget`;
+  return `${project} has spent ${usd(s.spent)} of its ${usd(s.limit)} ${s.kind} budget (${Math.round(s.pct * 100)}%)`;
+}
+var RUN_PROFILES = {
+  full: {
+    name: "full",
+    description: "every tool, rules still apply",
+    disallowedTools: [],
+    allowedTools: []
+  },
+  "no-edits": {
+    name: "no-edits",
+    description: "may run commands, may not edit files (review, triage, test runs)",
+    disallowedTools: ["Edit", "Write", "MultiEdit", "NotebookEdit"],
+    allowedTools: []
+  },
+  "read-only": {
+    name: "read-only",
+    description: "read and search only \u2014 no edits, no shell",
+    disallowedTools: ["Edit", "Write", "MultiEdit", "NotebookEdit", "Bash"],
+    allowedTools: ["Read", "Grep", "Glob", "LS", "WebFetch", "WebSearch"]
+  }
+};
+function runProfile(name) {
+  if (!name)
+    return null;
+  return RUN_PROFILES[name] ?? null;
+}
 // packages/core/src/config.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { join as join2 } from "path";
+var DEFAULT_GATE_TIMEOUT_S = 900;
+var AUTO_MODES = ["session-end", "stop", "off"];
+function parseGateDefs(gates) {
+  const out = {};
+  if (!isRecord(gates))
+    return out;
+  for (const [name, v] of Object.entries(gates)) {
+    if (!isRecord(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: 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: [] },
+  gates: { required: [], auto: "session-end", defs: {} },
+  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,
+    model: null,
+    max_turns: null,
+    require_pr: true,
+    profile: null
+  },
+  worktree: { setup: null, copy: [], open: null },
   rules: {
     shared_tree: "ask",
     destructive_git: "ask",
@@ -359,18 +669,82 @@ function parseToml(text, source) {
     return {};
   }
 }
+function isRepoRelative(f) {
+  if (typeof f !== "string")
+    return false;
+  const t = f.trim();
+  if (!t || t.startsWith("/") || t.startsWith("\\") || /^[a-zA-Z]:/.test(t))
+    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);
   const source = c.tasks?.source;
+  const setup = c.worktree?.setup;
+  const opener = c.worktree?.open;
+  const rawGates = c.gates;
+  const d = c.dispatch ?? {};
+  const mp = Number(d.max_parallel);
+  const mt = Number(d.max_turns);
+  const str = (v) => typeof v === "string" && v.trim() ? v.trim() : null;
+  const b = c.budget ?? {};
+  const usd = (v) => {
+    const n = Number(v);
+    return Number.isFinite(n) && n > 0 ? n : null;
+  };
+  const warnAt = Number(b.warn_at);
+  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() !== "") : [],
       team: typeof c.tasks?.team === "string" && c.tasks.team.trim() ? c.tasks.team.trim() : null
     },
+    gates: {
+      required: Array.isArray(rawGates?.required) ? rawGates.required.filter((g) => typeof g === "string" && g.trim() !== "") : [],
+      auto: AUTO_MODES.includes(auto) ? auto : "session-end",
+      defs: parseGateDefs(rawGates)
+    },
+    budget: {
+      daily: usd(b.daily),
+      weekly: usd(b.weekly),
+      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"
+    },
+    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),
+      model: str(d.model),
+      max_turns: Number.isInteger(mt) && mt > 0 ? mt : null,
+      require_pr: d.require_pr === undefined ? true : d.require_pr === true,
+      profile: ["full", "no-edits", "read-only"].includes(String(d.profile)) ? String(d.profile) : null
+    },
+    worktree: {
+      setup: typeof setup === "string" && setup.trim() ? setup.trim() : null,
+      copy: Array.isArray(c.worktree?.copy) ? c.worktree.copy.filter((f) => isRepoRelative(f)) : [],
+      open: typeof opener === "string" && opener.trim() ? opener.trim() : null
+    },
     rules: {
       ...c.rules,
       shared_tree: mode(c.rules?.shared_tree, "ask"),
@@ -385,18 +759,149 @@ function validate(c) {
     }
   };
 }
-function loadConfig(opts = {}) {
+function leafPaths(v, prefix = "") {
+  if (!isRecord(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 (!isRecord(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 (!isRecord(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 existsSync2(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 {
+    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) {
+  const byId = new Map(tasks.map((t) => [t.id, t]));
+  const queued = new Set(opts.alreadyQueued ?? []);
+  const rejected = [];
+  const picked = [];
+  const ids = wanted === "ready" ? tasks.filter((t) => t.ready).map((t) => t.id) : wanted;
+  for (const id of ids) {
+    const t = byId.get(id);
+    if (!t)
+      rejected.push({ id, reason: "not in the task source" });
+    else if (queued.has(id))
+      rejected.push({ id, reason: "already queued" });
+    else if (t.claimedBy)
+      rejected.push({ id, reason: `held by ${t.claimedBy}` });
+    else if (t.status === "done")
+      rejected.push({ id, reason: "already done" });
+    else if (!t.ready)
+      rejected.push({
+        id,
+        reason: t.status === "active" ? "in progress" : "blocked by dependencies"
+      });
+    else if (picked.some((p) => p.id === id))
+      rejected.push({ id, reason: "listed twice" });
+    else
+      picked.push(t);
   }
-  return validate(cfg);
+  const limit = opts.max && opts.max > 0 ? picked.slice(0, opts.max) : picked;
+  for (const t of picked.slice(limit.length))
+    rejected.push({ id: t.id, reason: `beyond --max ${opts.max}` });
+  const slots = Math.max(0, opts.maxParallel - opts.running);
+  return { start: limit.slice(0, slots), queued: limit.slice(slots), rejected };
+}
+function taskPrompt(task, ctx = {
+  requiredGates: [],
+  executableGates: [],
+  openPr: true
+}) {
+  const manual = ctx.requiredGates.filter((g) => !ctx.executableGates.includes(g));
+  const exec = ctx.requiredGates.filter((g) => ctx.executableGates.includes(g));
+  const steps = [
+    "Work only inside this worktree; never touch the main checkout or another worktree.",
+    "Commit as you go with clear messages. Do not edit the task list or flip the task's status \u2014 Swarm derives it.",
+    exec.length ? `Run the executable gates with swarm_gate_run (${exec.join(", ")}) and fix what fails.` : null,
+    manual.length ? `Record the remaining required gates with swarm_gate_record and an honest rubric (${manual.join(", ")}).` : null,
+    "Call swarm_handoff with what was done, what remains, the files touched and how to verify.",
+    ctx.openPr ? "Then push and open the pull request with swarm_pr_open." : "Push the branch.",
+    "If you are blocked on a decision only a human can make, say so in the handoff and stop."
+  ].filter(Boolean);
+  return `Task ${task.id}: ${task.title}
+
+${steps.map((s, i) => `${i + 1}. ${s}`).join(`
+`)}`;
+}
+function dispatchOutcome(facts) {
+  if (facts.stopped)
+    return "stopped";
+  if (facts.exitCode !== 0 || facts.isError)
+    return "crashed";
+  if (!facts.gatesSatisfied)
+    return "gates-failed";
+  if (facts.requirePr && !facts.prOpen)
+    return "no-pr";
+  return "done";
 }
 // packages/core/src/rules.ts
 var LIVE_WINDOW_MS = 10 * 60000;
@@ -706,6 +1211,68 @@ function normalizeGitlab(raw, repo) {
     };
   });
 }
+function parseNumstat(numstat, nameStatus = "") {
+  const status = new Map;
+  for (const line of nameStatus.split(`
+`)) {
+    const [st, ...rest] = line.split("\t");
+    if (!st || !rest.length)
+      continue;
+    status.set(rest[rest.length - 1], st[0]);
+  }
+  const out = [];
+  for (const line of numstat.split(`
+`)) {
+    const [a, d, ...rest] = line.split("\t");
+    if (a === undefined || d === undefined || !rest.length)
+      continue;
+    const raw = rest.join("\t");
+    const path = raw.includes(" => ") ? raw.replace(/\{?([^{}]*) => ([^{}]*)\}?/, "$2") : raw;
+    out.push({
+      path,
+      added: a === "-" ? -1 : Number(a),
+      deleted: d === "-" ? -1 : Number(d),
+      status: status.get(path) ?? "M"
+    });
+  }
+  return out;
+}
+function prDraft(i) {
+  const title = ((i.title?.trim()) ? `${i.task}: ${i.title.trim()}` : i.task).slice(0, 120);
+  const b = [];
+  b.push("## Summary");
+  if (i.handoff?.done.trim())
+    b.push(i.handoff.done.trim());
+  else if (i.commits?.length)
+    b.push(i.commits.map((c) => `- ${c}`).join(`
+`));
+  else
+    b.push(`Work on ${i.task}.`);
+  if (i.handoff?.remaining.trim() && !/^(nothing|none|\u2014|-)\.?$/i.test(i.handoff.remaining.trim()))
+    b.push(`
+## Remaining
+${i.handoff.remaining.trim()}`);
+  if (i.gates?.length) {
+    b.push(`
+## Gates`);
+    b.push(i.gates.map((g) => `- ${g.verdict === "pass" ? "[x]" : "[ ]"} ${g.gate}${g.verdict === "fail" ? " \u2014 failed" : g.verdict ? "" : " \u2014 not run"}`).join(`
+`));
+  }
+  if (i.handoff?.verify?.trim())
+    b.push(`
+## Verify
+${i.handoff.verify.trim()}`);
+  if (i.files?.length) {
+    const shown = i.files.slice(0, 30);
+    b.push(`
+## Files (${i.files.length})
+${shown.map((f) => `- \`${f.path}\`${f.added >= 0 ? ` +${f.added} \u2212${f.deleted}` : " (binary)"}`).join(`
+`)}${i.files.length > shown.length ? `
+- \u2026 ${i.files.length - shown.length} more` : ""}`);
+  }
+  return { title, body: b.join(`
+`) };
+}
 // packages/core/src/gates.ts
 var NAME_RE = /^[a-z0-9][a-z0-9_.-]{0,39}$/i;
 function validateGateRun(input) {
@@ -749,6 +1316,25 @@ function gatesSatisfied(runs, declared) {
   const st = gateStatus(runs, declared);
   return declared.every((g) => st.find((s) => s.gate === g)?.verdict === "pass");
 }
+function evidenceTail(output, max = 2000) {
+  const t = output.trimEnd();
+  if (t.length <= max)
+    return t;
+  const cut = t.slice(-max);
+  const nl = cut.indexOf(`
+`);
+  return `\u2026${nl >= 0 && nl < 200 ? cut.slice(nl + 1) : cut}`;
+}
+function executedGateInput(task, gate, cmd, outcome) {
+  const how = outcome.timedOut === true ? "timed out" : outcome.exitCode === null ? "could not start" : `exit ${outcome.exitCode}`;
+  return {
+    task,
+    gate,
+    verdict: outcome.exitCode === 0 && !outcome.timedOut ? "pass" : "fail",
+    rubric: `ran \`${cmd}\` \u2014 ${how} in ${(outcome.durationMs / 1000).toFixed(1)}s`,
+    evidence: evidenceTail(outcome.output) || null
+  };
+}
 // packages/core/src/ledger.ts
 var DEFAULT_LEASE_MINUTES = 45;
 function isExpired(claim, now) {
@@ -1053,6 +1639,92 @@ function parseMemoryQuery(q) {
   }
   return { match: terms.join(" "), kind, task };
 }
+// 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 },
@@ -1151,6 +1823,29 @@ function projectIdentity(opts) {
   const name = parts[parts.length - 1] ?? opts.root;
   return { id: `p_${fnv1a(key)}`, root: opts.root, commonDir: opts.commonDir, name };
 }
+// packages/core/src/questions.ts
+function validateQuestion(text, options) {
+  const t = typeof text === "string" ? text.trim() : "";
+  if (t.length < 5)
+    return { ok: false, reason: "a question needs at least a few words" };
+  if (t.length > 4000)
+    return { ok: false, reason: "keep the question under 4000 characters" };
+  const opts = Array.isArray(options) ? options.filter((o) => typeof o === "string" && o.trim() !== "").map((o) => o.trim()).slice(0, 8) : [];
+  return { ok: true, text: t, options: opts };
+}
+function formatAnswers(qs) {
+  const answered = qs.filter((q) => q.answer !== null);
+  if (!answered.length)
+    return null;
+  return answered.map((q) => `[swarm] answer from ${q.answeredBy ?? "a human"} to your question "${q.text.slice(0, 200)}": ${q.answer}`).join(`
+`);
+}
+function formatOpenQuestions(qs) {
+  const open = qs.filter((q) => q.answer === null);
+  if (!open.length)
+    return null;
+  return `[swarm] waiting on a human for: ${open.map((q) => `#${q.id} "${q.text.slice(0, 120)}"`).join("; ")} \u2014 the answer arrives as context on a later tool call, or via swarm_inbox`;
+}
 // packages/core/src/resources.ts
 var DEFAULT_RESOURCE_LEASE_MINUTES = 60;
 function isTrackedPid(pid) {
@@ -1176,6 +1871,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;
@@ -1335,18 +2138,91 @@ function linearIssuesQuery(teamKey, first = 200) {
     inverseRelations { nodes { type issue { identifier } } }
   } } }`;
 }
+// packages/core/src/worktree.ts
+import { join as join3 } from "path";
+function planBootstrap(cfg, repoRoot, worktree) {
+  const seen = new Set;
+  const copies = [];
+  for (const raw of cfg.worktree.copy) {
+    if (!isRepoRelative(raw))
+      continue;
+    const rel = raw.trim().replace(/^\.\//, "");
+    if (seen.has(rel))
+      continue;
+    seen.add(rel);
+    copies.push({ rel, from: join3(repoRoot, rel), to: join3(worktree, rel) });
+  }
+  return { copies, setup: cfg.worktree.setup };
+}
+var needsBootstrap = (plan) => plan.copies.length > 0 || plan.setup !== null;
+function summarizeBootstrap(o) {
+  const parts = [];
+  if (o.copied.length)
+    parts.push(`copied ${o.copied.join(", ")}`);
+  if (o.skipped.length)
+    parts.push(`skipped ${o.skipped.join(", ")} (missing)`);
+  if (o.setup)
+    parts.push(`${o.setup.command} \u2192 ${o.setup.exitCode === 0 ? "ok" : `exit ${o.setup.exitCode}`} in ${(o.setup.durationMs / 1000).toFixed(1)}s`);
+  return parts.join("; ") || "nothing to do";
+}
+function canRemoveWorktree(w, heldByClaim, force) {
+  if (w.main)
+    return { ok: false, reason: "main" };
+  if (heldByClaim)
+    return { ok: false, reason: "held" };
+  if (force)
+    return { ok: true };
+  if (w.dirty > 0)
+    return { ok: false, reason: "dirty" };
+  if (w.ahead > 0)
+    return { ok: false, reason: "unpushed" };
+  return { ok: true };
+}
+function removeRefusalMessage(reason, path, task) {
+  switch (reason) {
+    case "main":
+      return `${path} is the main checkout \u2014 it is never removed`;
+    case "held":
+      return `${path} is held by claim ${task ?? "?"} \u2014 release the claim instead`;
+    case "dirty":
+      return `${path} has uncommitted changes \u2014 commit or stash them, or --force to discard`;
+    case "unpushed":
+      return `${path} has unpushed commits \u2014 push them, or --force to discard`;
+  }
+}
+function planGc(worktrees, claims) {
+  const held = new Map(claims.filter((c) => c.state === "held").map((c) => [c.worktree, c.task]));
+  const stale = new Set(claims.filter((c) => c.state !== "held").map((c) => c.worktree));
+  const out = [];
+  for (const w of worktrees) {
+    if (w.main || held.has(w.path))
+      continue;
+    const why = w.merged ? "merged" : stale.has(w.path) ? "released-claim" : null;
+    if (!why)
+      continue;
+    const can = canRemoveWorktree(w, null, false);
+    out.push({
+      path: w.path,
+      branch: w.branch,
+      why,
+      removable: can.ok,
+      blocker: can.ok ? null : can.reason
+    });
+  }
+  return out;
+}
 // packages/daemon/src/app.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4, realpathSync as realpathSync3 } from "fs";
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync4, realpathSync as realpathSync3 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname2, join as join7 } from "path";
+import { dirname as dirname3, join as join9 } from "path";
 import { fileURLToPath } from "url";
 
 // node_modules/.bun/hono@4.13.3/node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
   return (context, next) => {
     let index = -1;
-    return dispatch(0);
-    async function dispatch(i) {
+    return dispatch2(0);
+    async function dispatch2(i) {
       if (i <= index) {
         throw new Error("next() called multiple times");
       }
@@ -1362,7 +2238,7 @@ var compose = (middleware, onError, onNotFound) => {
       }
       if (handler) {
         try {
-          res = await handler(context, () => dispatch(i + 1));
+          res = await handler(context, () => dispatch2(i + 1));
         } catch (err) {
           if (err instanceof Error && onError) {
             context.error = err;
@@ -1547,7 +2423,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;
@@ -1566,7 +2442,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) => {
@@ -2088,7 +2964,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({
@@ -2958,75 +3834,328 @@ var streamSSE = (c, cb, onError) => {
   return c.newResponse(stream.responseReadable);
 };
 
-// packages/daemon/src/forge.ts
-import { existsSync as existsSync3 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
-var EXTRA_BIN_DIRS = [
-  "/opt/homebrew/bin",
-  "/usr/local/bin",
-  "/home/linuxbrew/.linuxbrew/bin",
-  join3(homedir2(), ".local", "bin"),
-  join3(homedir2(), "bin")
-];
-function findBin(name) {
-  if (!name)
-    return null;
-  const onPath = Bun.which(name, { PATH: process.env.PATH ?? "" });
-  if (onPath)
-    return onPath;
-  for (const d of EXTRA_BIN_DIRS) {
-    const p = join3(d, name);
-    if (existsSync3(p))
-      return p;
-  }
-  return null;
-}
-var GH_FIELDS = "number,title,headRefName,url,author,isDraft,mergeable,reviewDecision,statusCheckRollup,createdAt";
-
-class ForgeService {
+// packages/daemon/src/dispatcher.ts
+class Dispatcher {
   store;
-  cache = new Map;
-  inflight = new Set;
-  constructor(store) {
+  runner;
+  forge;
+  entries = new Map;
+  opts = new Map;
+  constructor(store, runner, forge2) {
     this.store = store;
+    this.runner = runner;
+    this.forge = forge2;
+    runner.onEnd((run2) => void this.onRunEnd(run2));
   }
-  prs() {
-    this.refresh();
-    const all = [...this.cache.values()].flatMap((c) => c.prs);
-    return all.sort((a, b) => a.createdAt < b.createdAt ? 1 : -1);
-  }
-  async refresh(maxAgeMs = 120000) {
-    const projects = this.store.projects();
-    await Promise.all(projects.map(async (p) => {
-      const hit = this.cache.get(p.id);
-      if (hit && Date.now() - hit.at < maxAgeMs)
-        return;
-      if (this.inflight.has(p.id))
-        return;
-      this.inflight.add(p.id);
-      try {
-        const prs = await this.poll(p.id, p.root);
-        this.cache.set(p.id, { at: Date.now(), prs });
-      } catch {
-        this.cache.set(p.id, { at: Date.now(), prs: this.cache.get(p.id)?.prs ?? [] });
-      } finally {
-        this.inflight.delete(p.id);
-      }
-    }));
+  project(projectId) {
+    let m = this.entries.get(projectId);
+    if (!m) {
+      m = new Map;
+      this.entries.set(projectId, m);
+    }
+    return m;
   }
-  remote(root) {
-    const r = Bun.spawnSync(["git", "-C", root, "remote", "get-url", "origin"]);
-    if (r.exitCode !== 0)
-      return null;
-    return parseRemote(new TextDecoder().decode(r.stdout).trim());
+  status(projectId) {
+    return [...this.entries.get(projectId)?.values() ?? []];
   }
-  async run(cmd, cwd) {
-    const bin = findBin(cmd[0]);
-    if (!bin)
-      return null;
-    const proc = Bun.spawn([bin, ...cmd.slice(1)], { cwd, stdout: "pipe", stderr: "ignore" });
-    const out = await new Response(proc.stdout).text();
+  async dispatch(projectId, wanted, o = {}) {
+    const board = this.store.tasks(projectId);
+    if (!board)
+      return {
+        ok: false,
+        error: "this repo has no task source ([tasks] source in .swarm.toml)"
+      };
+    if (board.error)
+      return { ok: false, error: `task source: ${board.error}` };
+    const cfg = this.store.config(projectId).dispatch;
+    const opts = {
+      owner: o.owner ?? "dispatch",
+      ...o,
+      maxParallel: o.maxParallel ?? cfg.max_parallel
+    };
+    this.opts.set(projectId, opts);
+    const m = this.project(projectId);
+    const running = [...m.values()].filter((e) => e.state === "running").length;
+    const plan = planDispatch(board.tasks, wanted, {
+      maxParallel: opts.maxParallel,
+      running,
+      max: o.max,
+      alreadyQueued: [...m.values()].filter((e) => e.state !== "finished").map((e) => e.task)
+    });
+    const now = new Date().toISOString();
+    for (const t of [...plan.start, ...plan.queued]) {
+      m.set(t.id, {
+        task: t.id,
+        title: t.title,
+        state: "queued",
+        runId: null,
+        sessionId: null,
+        queuedAt: now,
+        startedAt: null,
+        endedAt: null,
+        outcome: null,
+        detail: null,
+        costUsd: null
+      });
+    }
+    if (plan.start.length || plan.queued.length)
+      this.store.append({
+        ts: now,
+        type: "dispatch.queued",
+        projectId,
+        sessionId: null,
+        payload: {
+          tasks: [...plan.start, ...plan.queued].map((t) => t.id),
+          maxParallel: opts.maxParallel,
+          summary: `dispatch ${[...plan.start, ...plan.queued].map((t) => t.id).join(", ")}`
+        }
+      });
+    const started = [];
+    const failed = [];
+    for (const t of plan.start) {
+      const r = await this.startOne(projectId, t);
+      if (r.ok)
+        started.push(t.id);
+      else
+        failed.push({ id: t.id, reason: r.reason });
+    }
+    await this.fill(projectId);
+    return {
+      ok: true,
+      started,
+      queued: plan.queued.map((t) => t.id).filter((id) => m.get(id)?.state === "queued"),
+      rejected: [...plan.rejected, ...failed]
+    };
+  }
+  async startOne(projectId, t) {
+    const m = this.project(projectId);
+    const e = m.get(t.id);
+    const opts = this.opts.get(projectId) ?? { owner: "dispatch" };
+    const cfg = this.store.config(projectId);
+    const gates2 = cfg.gates;
+    const prompt = taskPrompt(t, {
+      requiredGates: gates2.required,
+      executableGates: gates2.required.filter((g) => gates2.defs[g]),
+      openPr: cfg.dispatch.require_pr
+    });
+    const r = await this.runner.start({
+      projectId,
+      task: t.id,
+      prompt,
+      owner: opts.owner,
+      permissionMode: opts.permissionMode ?? cfg.dispatch.permission_mode ?? "acceptEdits",
+      model: opts.model ?? cfg.dispatch.model ?? undefined,
+      maxTurns: opts.maxTurns ?? cfg.dispatch.max_turns ?? undefined,
+      profile: opts.profile ?? cfg.dispatch.profile ?? undefined
+    });
+    if (!r.ok) {
+      if (e) {
+        e.state = "finished";
+        e.endedAt = new Date().toISOString();
+        e.outcome = "crashed";
+        e.detail = r.reason;
+      }
+      this.store.append({
+        ts: new Date().toISOString(),
+        type: "dispatch.finished",
+        projectId,
+        sessionId: null,
+        payload: {
+          task: t.id,
+          outcome: "crashed",
+          detail: r.reason,
+          summary: `dispatch ${t.id}: could not start \u2014 ${r.reason}`
+        }
+      });
+      return { ok: false, reason: r.reason };
+    }
+    if (e) {
+      e.state = "running";
+      e.runId = r.run.id;
+      e.sessionId = r.run.sessionId;
+      e.startedAt = r.run.startedAt;
+    }
+    this.store.append({
+      ts: r.run.startedAt,
+      type: "dispatch.started",
+      projectId,
+      sessionId: r.run.sessionId,
+      payload: {
+        task: t.id,
+        runId: r.run.id,
+        worktree: r.run.worktree,
+        summary: `dispatch ${t.id} \u2192 run ${r.run.id}`
+      }
+    });
+    return { ok: true };
+  }
+  async fill(projectId) {
+    const m = this.project(projectId);
+    const cap = this.opts.get(projectId)?.maxParallel ?? this.store.config(projectId).dispatch.max_parallel;
+    for (const e of m.values()) {
+      const running = [...m.values()].filter((x) => x.state === "running").length;
+      if (running >= cap)
+        return;
+      if (e.state !== "queued")
+        continue;
+      await this.startOne(projectId, { id: e.task, title: e.title });
+    }
+  }
+  async onRunEnd(run2) {
+    const m = this.entries.get(run2.projectId);
+    const e = m?.get(run2.task);
+    if (!e || e.runId !== run2.id)
+      return;
+    const cfg = this.store.config(run2.projectId);
+    const required = cfg.gates.required;
+    let runs = this.store.gateRuns(run2.projectId, run2.task);
+    const status = this.store.gateStatusFor(runs, required);
+    const missing = required.filter((g) => cfg.gates.defs[g] && status.find((s) => s.gate === g)?.verdict !== "pass");
+    if (missing.length && !run2.stopped) {
+      await this.store.runGates(run2.projectId, run2.task, missing, {
+        sessionId: run2.sessionId,
+        owner: "dispatch"
+      });
+      runs = this.store.gateRuns(run2.projectId, run2.task);
+    }
+    const satisfied = gatesSatisfied(runs, required);
+    await this.forge.refresh(0).catch(() => {});
+    const branch = `task/${run2.task}`;
+    const pr = this.forge.prs().find((p) => p.projectId === run2.projectId && p.branch === branch);
+    const outcome = dispatchOutcome({
+      exitCode: run2.exitCode,
+      isError: run2.result?.isError ?? false,
+      gatesSatisfied: satisfied,
+      prOpen: Boolean(pr),
+      requirePr: cfg.dispatch.require_pr,
+      stopped: run2.stopped ?? false
+    });
+    const verdicts = this.store.gateStatusFor(runs, required).map((s) => `${s.gate} ${s.verdict ?? "\u2014"}`).join(", ");
+    const detail = [
+      `exit ${run2.exitCode}${run2.result?.isError ? " (error)" : ""}`,
+      required.length ? `gates: ${verdicts}` : null,
+      pr ? `PR ${pr.url}` : cfg.dispatch.require_pr ? "no PR" : null
+    ].filter(Boolean).join(" \xB7 ");
+    e.state = "finished";
+    e.endedAt = run2.endedAt;
+    e.outcome = outcome;
+    e.detail = detail;
+    e.costUsd = run2.result?.costUsd ?? null;
+    const ts = run2.endedAt ?? new Date().toISOString();
+    this.store.append({
+      ts,
+      type: "dispatch.finished",
+      projectId: run2.projectId,
+      sessionId: run2.sessionId,
+      payload: {
+        task: run2.task,
+        runId: run2.id,
+        outcome,
+        detail,
+        costUsd: e.costUsd,
+        summary: `dispatch ${run2.task}: ${outcome} \u2014 ${detail}`
+      }
+    });
+    if (outcome !== "done" && outcome !== "stopped")
+      this.store.append({
+        ts,
+        type: "incident.opened",
+        projectId: run2.projectId,
+        sessionId: run2.sessionId,
+        payload: {
+          rule: "dispatch_failed",
+          action: outcome,
+          command: run2.task,
+          reason: `dispatched run on ${run2.task} ended ${outcome}: ${detail}. The worktree and claim are kept; resume it from the session page or release it.`
+        }
+      });
+    this.store.touch();
+    await this.fill(run2.projectId);
+  }
+  clear(projectId, task) {
+    const m = this.project(projectId);
+    let n = 0;
+    for (const [id, e] of m) {
+      if (task && id !== task)
+        continue;
+      if (e.state === "queued" || e.state === "finished" && !task) {
+        m.delete(id);
+        n++;
+      }
+    }
+    return n;
+  }
+}
+
+// packages/daemon/src/forge.ts
+import { existsSync as existsSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
+var EXTRA_BIN_DIRS = [
+  "/opt/homebrew/bin",
+  "/usr/local/bin",
+  "/home/linuxbrew/.linuxbrew/bin",
+  join4(homedir2(), ".local", "bin"),
+  join4(homedir2(), "bin")
+];
+function findBin(name) {
+  if (!name)
+    return null;
+  const onPath = Bun.which(name, { PATH: process.env.PATH ?? "" });
+  if (onPath)
+    return onPath;
+  for (const d of EXTRA_BIN_DIRS) {
+    const p = join4(d, name);
+    if (existsSync3(p))
+      return p;
+  }
+  return null;
+}
+var GH_FIELDS = "number,title,headRefName,url,author,isDraft,mergeable,reviewDecision,statusCheckRollup,createdAt";
+
+class ForgeService {
+  store;
+  cache = new Map;
+  inflight = new Set;
+  constructor(store) {
+    this.store = store;
+  }
+  prs() {
+    this.refresh();
+    const all = [...this.cache.values()].flatMap((c) => c.prs);
+    return all.sort((a, b) => a.createdAt < b.createdAt ? 1 : -1);
+  }
+  async refresh(maxAgeMs = 120000) {
+    const projects = this.store.projects();
+    await Promise.all(projects.map(async (p) => {
+      const hit = this.cache.get(p.id);
+      if (hit && Date.now() - hit.at < maxAgeMs)
+        return;
+      if (this.inflight.has(p.id))
+        return;
+      this.inflight.add(p.id);
+      try {
+        const prs = await this.poll(p.id, p.root);
+        this.cache.set(p.id, { at: Date.now(), prs });
+      } catch {
+        this.cache.set(p.id, { at: Date.now(), prs: this.cache.get(p.id)?.prs ?? [] });
+      } finally {
+        this.inflight.delete(p.id);
+      }
+    }));
+  }
+  remote(root) {
+    const r = Bun.spawnSync(["git", "-C", root, "remote", "get-url", "origin"]);
+    if (r.exitCode !== 0)
+      return null;
+    return parseRemote(new TextDecoder().decode(r.stdout).trim());
+  }
+  async run(cmd, cwd) {
+    const bin = findBin(cmd[0]);
+    if (!bin)
+      return null;
+    const proc = Bun.spawn([bin, ...cmd.slice(1)], { cwd, stdout: "pipe", stderr: "ignore" });
+    const out = await new Response(proc.stdout).text();
     return await proc.exited === 0 ? out : null;
   }
   async poll(projectId, root) {
@@ -3045,6 +4174,69 @@ class ForgeService {
     }
     return prs.map((pr) => ({ ...pr, projectId, projectRoot: root }));
   }
+  async openPR(projectId, worktree2, draft) {
+    const p = this.store.projects().find((x) => x.id === projectId);
+    if (!p)
+      return { ok: false, error: "unknown project" };
+    if (worktree2.main)
+      return { ok: false, error: "that is the main checkout \u2014 open the PR from a task worktree" };
+    if (!worktree2.branch)
+      return { ok: false, error: "detached HEAD \u2014 check out a branch first" };
+    if (worktree2.dirty > 0)
+      return {
+        ok: false,
+        error: `${worktree2.path} has uncommitted changes \u2014 commit them first (Swarm never commits for you)`
+      };
+    const remote = this.remote(p.root);
+    if (!remote)
+      return { ok: false, error: "no GitHub/GitLab remote on origin" };
+    const cli = remote.forge === "github" ? "gh" : "glab";
+    const bin = findBin(cli);
+    if (!bin)
+      return { ok: false, error: `${cli} is not installed` };
+    const sh = async (cmd2, cwd) => {
+      const proc = Bun.spawn(cmd2, { cwd, stdout: "pipe", stderr: "pipe" });
+      const out = await new Response(proc.stdout).text() + await new Response(proc.stderr).text();
+      return { ok: await proc.exited === 0, out: out.trim() };
+    };
+    const push = await sh(["git", "push", "-u", "origin", worktree2.branch], worktree2.path);
+    if (!push.ok)
+      return { ok: false, error: `git push failed: ${push.out.slice(0, 400)}` };
+    const existing = this.prs().find((x) => x.projectId === projectId && x.branch === worktree2.branch);
+    if (existing)
+      return { ok: true, url: existing.url, number: existing.number };
+    const cmd = remote.forge === "github" ? [
+      bin,
+      "pr",
+      "create",
+      "--head",
+      worktree2.branch,
+      "--title",
+      draft.title,
+      "--body",
+      draft.body,
+      ...draft.isDraft ? ["--draft"] : []
+    ] : [
+      bin,
+      "mr",
+      "create",
+      "--source-branch",
+      worktree2.branch,
+      "--title",
+      draft.title,
+      "--description",
+      draft.body,
+      "--yes",
+      ...draft.isDraft ? ["--draft"] : []
+    ];
+    const r = await sh(cmd, worktree2.path);
+    if (!r.ok)
+      return { ok: false, error: `${cli} failed: ${r.out.slice(0, 400)}` };
+    const url = r.out.match(/https?:\/\/\S+/)?.[0] ?? r.out;
+    const num = Number(url.match(/\/(\d+)\s*$/)?.[1]);
+    this.cache.delete(projectId);
+    return { ok: true, url, number: Number.isFinite(num) ? num : null };
+  }
   async merge(projectId, number) {
     const p = this.store.projects().find((x) => x.id === projectId);
     if (!p)
@@ -3065,9 +4257,216 @@ class ForgeService {
   }
 }
 
+// packages/daemon/src/git.ts
+import { realpathSync } from "fs";
+import { join as join5 } from "path";
+function git(cwd, args) {
+  try {
+    const r = Bun.spawnSync(["git", "-C", cwd, ...args], { stdout: "pipe", stderr: "ignore" });
+    return r.exitCode === 0 ? r.stdout.toString() : null;
+  } catch {
+    return null;
+  }
+}
+function gitCommonDir(cwd) {
+  const out = git(cwd, ["rev-parse", "--git-common-dir"])?.trim();
+  if (!out)
+    return null;
+  try {
+    return realpathSync(out.startsWith("/") ? out : join5(cwd, out));
+  } catch {
+    return null;
+  }
+}
+function gitToplevel(cwd) {
+  const out = git(cwd, ["rev-parse", "--show-toplevel"])?.trim();
+  if (!out)
+    return null;
+  try {
+    return realpathSync(out);
+  } catch {
+    return null;
+  }
+}
+function parseWorktreeList(out) {
+  const wts = [];
+  let cur = null;
+  const flush = () => {
+    if (cur?.path) {
+      wts.push({
+        path: cur.path,
+        branch: cur.branch ?? null,
+        head: (cur.head ?? "").slice(0, 7),
+        main: wts.length === 0,
+        dirty: -1,
+        ahead: -1,
+        behind: -1,
+        merged: false
+      });
+    }
+    cur = null;
+  };
+  for (const line of out.split(`
+`)) {
+    if (line.startsWith("worktree ")) {
+      flush();
+      cur = { path: line.slice(9) };
+    } else if (line.startsWith("HEAD ") && cur)
+      cur.head = line.slice(5);
+    else if (line.startsWith("branch ") && cur)
+      cur.branch = line.slice(7).replace(/^refs\/heads\//, "");
+    else if (line === "")
+      flush();
+  }
+  flush();
+  return wts;
+}
+function applyStatus(w, st, ah) {
+  w.dirty = st === null ? -1 : st.split(`
+`).filter(Boolean).length;
+  const a = ah?.trim();
+  w.ahead = a === undefined || a === "" ? -1 : Number(a);
+}
+function applyDrift(w, behind, ancestor, firstParents) {
+  const b = behind?.trim();
+  w.behind = b === undefined || b === "" ? -1 : Number(b);
+  const onLine = firstParents?.split(`
+`).some((sha) => sha.startsWith(w.head)) ?? true;
+  w.merged = ancestor && !onLine;
+}
+var FIRST_PARENT_DEPTH = "5000";
+var baseOf = (wts) => wts[0]?.main ? wts[0].branch : null;
+async function gitAsync(cwd, args) {
+  try {
+    const p = Bun.spawn(["git", "-C", cwd, ...args], { stdout: "pipe", stderr: "ignore" });
+    const [out, code] = await Promise.all([new Response(p.stdout).text(), p.exited]);
+    return code === 0 ? out : null;
+  } catch {
+    return null;
+  }
+}
+async function listWorktreesAsync(root) {
+  const out = await gitAsync(root, ["worktree", "list", "--porcelain"]);
+  if (!out)
+    return [];
+  const wts = parseWorktreeList(out);
+  const base = baseOf(wts);
+  const line = base ? await gitAsync(root, ["rev-list", "--first-parent", "-n", FIRST_PARENT_DEPTH, base]) : null;
+  await Promise.all(wts.map(async (w) => {
+    const drift = base && !w.main;
+    const [st, ah, be, mg] = await Promise.all([
+      gitAsync(w.path, ["status", "--porcelain", "--untracked-files=no"]),
+      gitAsync(w.path, ["rev-list", "--count", "@{upstream}..HEAD"]),
+      drift ? gitAsync(w.path, ["rev-list", "--count", `HEAD..${base}`]) : null,
+      drift ? gitAsync(w.path, ["merge-base", "--is-ancestor", "HEAD", base]) : null
+    ]);
+    applyStatus(w, st, ah);
+    if (drift)
+      applyDrift(w, be, mg !== null, line);
+  }));
+  return wts;
+}
+var branchCache = new Map;
+function currentBranch(cwd) {
+  const hit = branchCache.get(cwd);
+  const now = Date.now();
+  if (hit && now - hit.t < 5000)
+    return hit.v;
+  const v = git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"])?.trim() ?? null;
+  branchCache.set(cwd, { v: v === "HEAD" ? "(detached)" : v, t: now });
+  return branchCache.get(cwd)?.v ?? null;
+}
+function worktreeAdd(repoRoot, path, branch, baseRef = "HEAD") {
+  const branchExists = git(repoRoot, ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`]) !== null;
+  const args = branchExists ? ["worktree", "add", path, branch] : ["worktree", "add", "-b", branch, path, baseRef];
+  if (git(repoRoot, args) === null)
+    return null;
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+function worktreeRemove(repoRoot, path, force) {
+  const args = ["worktree", "remove", path];
+  if (force)
+    args.push("--force");
+  return git(repoRoot, args) !== null;
+}
+function heldWork(path) {
+  const status = git(path, ["status", "--porcelain"]);
+  const dirty = status !== null && status.trim().length > 0;
+  const count = (args) => {
+    const out = git(path, ["rev-list", "--count", ...args])?.trim();
+    return out !== undefined && out !== "" ? Number(out) : 0;
+  };
+  let unpushed;
+  if (git(path, ["rev-parse", "--verify", "--quiet", "@{upstream}"]) !== null) {
+    unpushed = count(["@{upstream}..HEAD"]) > 0;
+  } else {
+    const baselines = ["--remotes"];
+    for (const b of ["main", "master"]) {
+      if (git(path, ["rev-parse", "--verify", "--quiet", `refs/heads/${b}`]) !== null)
+        baselines.push(b);
+    }
+    unpushed = baselines.length > 1 ? count(["HEAD", "--not", ...baselines]) > 0 : false;
+  }
+  return { dirty, unpushed };
+}
+async function worktreeDiff(root, path) {
+  const wts = parseWorktreeList(await gitAsync(root, ["worktree", "list", "--porcelain"]) ?? "");
+  const baseRef = wts[0]?.path === realpathOr(root) || wts[0]?.main ? wts[0]?.branch ?? null : null;
+  const isMain = wts[0]?.path === path;
+  const mb = baseRef && !isMain ? (await gitAsync(path, ["merge-base", baseRef, "HEAD"]))?.trim() : null;
+  const from = mb || "HEAD";
+  const [numstat, names, log, status] = await Promise.all([
+    gitAsync(path, ["diff", "--numstat", from]),
+    gitAsync(path, ["diff", "--name-status", from]),
+    mb ? gitAsync(path, ["log", "--format=%s", `${mb}..HEAD`]) : Promise.resolve(""),
+    gitAsync(path, ["status", "--porcelain"])
+  ]);
+  const files = parseNumstat(numstat ?? "", names ?? "");
+  for (const line of (status ?? "").split(`
+`)) {
+    if (line.startsWith("?? "))
+      files.push({ path: line.slice(3), added: -1, deleted: -1, status: "?" });
+  }
+  return {
+    base: mb ?? null,
+    baseRef,
+    files,
+    commits: (log ?? "").split(`
+`).filter(Boolean),
+    dirty: (status ?? "").trim().length > 0
+  };
+}
+async function worktreePatch(path, base, file) {
+  const from = base ?? "HEAD";
+  if (file) {
+    const tracked = await gitAsync(path, ["ls-files", "--error-unmatch", "--", file]) !== null;
+    if (!tracked) {
+      const p = Bun.spawn(["git", "-C", path, "diff", "--no-index", "--", "/dev/null", file], {
+        stdout: "pipe",
+        stderr: "ignore"
+      });
+      const [out] = await Promise.all([new Response(p.stdout).text(), p.exited]);
+      return out;
+    }
+    return await gitAsync(path, ["diff", from, "--", file]) ?? "";
+  }
+  return await gitAsync(path, ["diff", from]) ?? "";
+}
+function realpathOr(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+
 // packages/daemon/src/runner.ts
 import { appendFileSync, mkdirSync as mkdirSync2, openSync } from "fs";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 var PERMISSION_MODES = [
   "acceptEdits",
   "auto",
@@ -3081,6 +4480,11 @@ class Runner {
   store;
   home;
   live = new Map;
+  endListeners = new Set;
+  onEnd(fn) {
+    this.endListeners.add(fn);
+    return () => this.endListeners.delete(fn);
+  }
   constructor(store, home) {
     this.store = store;
     this.home = home;
@@ -3111,18 +4515,19 @@ class Runner {
         reason: `a run on ${input.task} is already live \u2014 stop it or send it input`
       };
     const held = this.store.claims(input.projectId).find((c) => c.task === input.task && c.state === "held" && c.owner === input.owner);
-    let worktree = held?.worktree ?? "";
-    if (!worktree) {
+    let worktree2 = held?.worktree ?? "";
+    if (!worktree2) {
       const c = this.store.claim(input.projectId, input.task, input.owner);
       if (!c.ok)
         return { ok: false, reason: c.error };
-      worktree = c.worktree;
+      worktree2 = c.worktree;
     }
+    await this.store.awaitBootstrap(worktree2);
     const sessionId = crypto.randomUUID();
     const id = sessionId.slice(0, 8);
-    const logDir = join4(this.home, "logs", project.id);
+    const logDir = join6(this.home, "logs", project.id);
     mkdirSync2(logDir, { recursive: true });
-    const log = join4(logDir, `run-${input.task.replace(/[^a-zA-Z0-9_.-]+/g, "-")}-${id}.log`);
+    const log = join6(logDir, `run-${input.task.replace(/[^a-zA-Z0-9_.-]+/g, "-")}-${id}.log`);
     const logFd = openSync(log, "a");
     const args = [
       bin,
@@ -3141,13 +4546,22 @@ class Runner {
       args.push("--model", input.model);
     if (input.permissionMode)
       args.push("--permission-mode", input.permissionMode);
-    if (input.allowedTools?.length)
-      args.push("--allowedTools", ...input.allowedTools);
+    const profile = runProfile(input.profile);
+    if (input.profile && !profile)
+      return {
+        ok: false,
+        reason: `unknown profile ${input.profile} \u2014 one of ${Object.keys(RUN_PROFILES).join(", ")}`
+      };
+    const allowed = [...input.allowedTools ?? [], ...profile?.allowedTools ?? []];
+    if (allowed.length)
+      args.push("--allowedTools", ...allowed);
+    if (profile?.disallowedTools.length)
+      args.push("--disallowedTools", ...profile.disallowedTools);
     if (input.maxTurns)
       args.push("--max-turns", String(input.maxTurns));
-    this.store.preregisterSpawnedSession(sessionId, project.id, worktree, input.task);
+    this.store.preregisterSpawnedSession(sessionId, project.id, worktree2, input.task);
     const proc = Bun.spawn(args, {
-      cwd: worktree,
+      cwd: worktree2,
       env: { ...process.env, SWARM_RUN_ID: id, SWARM_OWNER: input.owner },
       stdin: "pipe",
       stdout: "pipe",
@@ -3158,11 +4572,12 @@ class Runner {
       sessionId,
       projectId: project.id,
       task: input.task,
-      worktree,
+      worktree: worktree2,
       pid: proc.pid,
       owner: input.owner,
       model: input.model ?? null,
       permissionMode: input.permissionMode ?? null,
+      profile: input.profile ?? null,
       prompt: input.prompt,
       log,
       startedAt: new Date().toISOString(),
@@ -3178,7 +4593,7 @@ class Runner {
       sessionId,
       kind: "proc",
       name: `run:${input.task}`,
-      cwd: worktree,
+      cwd: worktree2,
       cmd: `claude -p (run ${id})`,
       owner: input.owner,
       log
@@ -3243,6 +4658,13 @@ class Runner {
     });
     this.store.endSpawnedSession(entry.run.sessionId);
     this.live.delete(id);
+    for (const fn of this.endListeners) {
+      try {
+        fn(entry.run);
+      } catch (e) {
+        console.error("swarm run: onEnd listener failed:", e.message);
+      }
+    }
   }
   onLine(run2, line) {
     if (!line.startsWith("{"))
@@ -3366,6 +4788,7 @@ class Runner {
     if (!run2)
       return { ok: false, reason: "no live run" };
     const entry = this.live.get(run2.id);
+    run2.stopped = true;
     try {
       const stdin = entry?.proc.stdin;
       if (stdin && typeof stdin !== "number")
@@ -3382,157 +4805,67 @@ class Runner {
 import { Database } from "bun:sqlite";
 import {
   closeSync,
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync3,
-  openSync as openSync2,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync4,
+  openSync as openSync3,
   readdirSync,
   readFileSync as readFileSync3,
   readSync,
   realpathSync as realpathSync2,
   renameSync,
   statSync,
+  unlinkSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { homedir as homedir3 } from "os";
-import { basename, dirname, join as join6 } from "path";
+import { homedir as homedir3, tmpdir, userInfo } from "os";
+import { basename, dirname as dirname2, join as join8 } from "path";
 
-// packages/daemon/src/git.ts
-import { realpathSync } from "fs";
-import { join as join5 } from "path";
-function git(cwd, args) {
-  try {
-    const r = Bun.spawnSync(["git", "-C", cwd, ...args], { stdout: "pipe", stderr: "ignore" });
-    return r.exitCode === 0 ? r.stdout.toString() : null;
-  } catch {
-    return null;
-  }
-}
-function gitCommonDir(cwd) {
-  const out = git(cwd, ["rev-parse", "--git-common-dir"])?.trim();
-  if (!out)
-    return null;
-  try {
-    return realpathSync(out.startsWith("/") ? out : join5(cwd, out));
-  } catch {
-    return null;
-  }
-}
-function gitToplevel(cwd) {
-  const out = git(cwd, ["rev-parse", "--show-toplevel"])?.trim();
-  if (!out)
-    return null;
-  try {
-    return realpathSync(out);
-  } catch {
-    return null;
-  }
-}
-function parseWorktreeList(out) {
-  const wts = [];
-  let cur = null;
-  const flush = () => {
-    if (cur?.path) {
-      wts.push({
-        path: cur.path,
-        branch: cur.branch ?? null,
-        head: (cur.head ?? "").slice(0, 7),
-        main: wts.length === 0,
-        dirty: -1,
-        ahead: -1
-      });
+// 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";
+function runBootstrap(plan, opts) {
+  const logDir = join7(opts.home, "logs", opts.projectId);
+  mkdirSync3(logDir, { recursive: true });
+  const log = join7(logDir, `bootstrap-${opts.task.replace(/[^a-zA-Z0-9_.-]+/g, "-")}.log`);
+  const copied = [];
+  const skipped = [];
+  for (const c of plan.copies) {
+    if (!existsSync4(c.from)) {
+      skipped.push(c.rel);
+      continue;
     }
-    cur = null;
-  };
-  for (const line of out.split(`
-`)) {
-    if (line.startsWith("worktree ")) {
-      flush();
-      cur = { path: line.slice(9) };
-    } else if (line.startsWith("HEAD ") && cur)
-      cur.head = line.slice(5);
-    else if (line.startsWith("branch ") && cur)
-      cur.branch = line.slice(7).replace(/^refs\/heads\//, "");
-    else if (line === "")
-      flush();
-  }
-  flush();
-  return wts;
-}
-function applyStatus(w, st, ah) {
-  w.dirty = st === null ? -1 : st.split(`
-`).filter(Boolean).length;
-  const a = ah?.trim();
-  w.ahead = a === undefined || a === "" ? -1 : Number(a);
-}
-async function gitAsync(cwd, args) {
-  try {
-    const p = Bun.spawn(["git", "-C", cwd, ...args], { stdout: "pipe", stderr: "ignore" });
-    const [out, code] = await Promise.all([new Response(p.stdout).text(), p.exited]);
-    return code === 0 ? out : null;
-  } catch {
-    return null;
-  }
-}
-async function listWorktreesAsync(root) {
-  const out = await gitAsync(root, ["worktree", "list", "--porcelain"]);
-  if (!out)
-    return [];
-  const wts = parseWorktreeList(out);
-  await Promise.all(wts.map(async (w) => {
-    const [st, ah] = await Promise.all([
-      gitAsync(w.path, ["status", "--porcelain", "--untracked-files=no"]),
-      gitAsync(w.path, ["rev-list", "--count", "@{upstream}..HEAD"])
-    ]);
-    applyStatus(w, st, ah);
-  }));
-  return wts;
-}
-var branchCache = new Map;
-function currentBranch(cwd) {
-  const hit = branchCache.get(cwd);
-  const now = Date.now();
-  if (hit && now - hit.t < 5000)
-    return hit.v;
-  const v = git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"])?.trim() ?? null;
-  branchCache.set(cwd, { v: v === "HEAD" ? "(detached)" : v, t: now });
-  return branchCache.get(cwd)?.v ?? null;
-}
-function worktreeAdd(repoRoot, path, branch, baseRef = "HEAD") {
-  const branchExists = git(repoRoot, ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`]) !== null;
-  const args = branchExists ? ["worktree", "add", path, branch] : ["worktree", "add", "-b", branch, path, baseRef];
-  if (git(repoRoot, args) === null)
-    return null;
-  try {
-    return realpathSync(path);
-  } catch {
-    return path;
-  }
-}
-function worktreeRemove(repoRoot, path, force) {
-  const args = ["worktree", "remove", path];
-  if (force)
-    args.push("--force");
-  return git(repoRoot, args) !== null;
-}
-function heldWork(path) {
-  const status = git(path, ["status", "--porcelain"]);
-  const dirty = status !== null && status.trim().length > 0;
-  const count = (args) => {
-    const out = git(path, ["rev-list", "--count", ...args])?.trim();
-    return out !== undefined && out !== "" ? Number(out) : 0;
-  };
-  let unpushed;
-  if (git(path, ["rev-parse", "--verify", "--quiet", "@{upstream}"]) !== null) {
-    unpushed = count(["@{upstream}..HEAD"]) > 0;
-  } else {
-    const baselines = ["--remotes"];
-    for (const b of ["main", "master"]) {
-      if (git(path, ["rev-parse", "--verify", "--quiet", `refs/heads/${b}`]) !== null)
-        baselines.push(b);
+    try {
+      mkdirSync3(dirname(c.to), { recursive: true });
+      cpSync(c.from, c.to, { recursive: true, force: true });
+      copied.push(c.rel);
+    } catch (e) {
+      skipped.push(`${c.rel} (${e.message})`);
     }
-    unpushed = baselines.length > 1 ? count(["HEAD", "--not", ...baselines]) > 0 : false;
   }
-  return { dirty, unpushed };
+  const done = (async () => {
+    if (!plan.setup)
+      return { copied, skipped, setup: null };
+    const command = plan.setup;
+    const started = Date.now();
+    let exitCode = -1;
+    try {
+      const fd = openSync2(log, "a");
+      const proc = Bun.spawn(["sh", "-c", command], {
+        cwd: opts.worktree,
+        stdin: "ignore",
+        stdout: fd,
+        stderr: fd,
+        env: { ...process.env, SWARM_WORKTREE: opts.worktree, SWARM_TASK: opts.task }
+      });
+      exitCode = await proc.exited;
+    } catch (e) {
+      exitCode = -1;
+      await Bun.write(log, `swarm: could not start setup: ${e.message}
+`);
+    }
+    return { copied, skipped, setup: { command, exitCode, durationMs: Date.now() - started } };
+  })();
+  return { log, done };
 }
 
 // packages/daemon/src/task-sources.ts
@@ -3658,6 +4991,12 @@ CREATE TABLE IF NOT EXISTS handoffs (
   files TEXT, verify TEXT, by TEXT, session_id TEXT, created_at TEXT
 );
 CREATE INDEX IF NOT EXISTS handoffs_task ON handoffs(project_id, task, created_at);
+CREATE TABLE IF NOT EXISTS messages (
+  id INTEGER PRIMARY KEY AUTOINCREMENT, project_id TEXT, session_id TEXT, task TEXT, kind TEXT,
+  text TEXT, options TEXT, asked_by TEXT, created_at TEXT,
+  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 claims (
   project_id TEXT, task TEXT, owner TEXT, worktree TEXT, branch TEXT,
   acquired_at TEXT, expires_at TEXT, released_at TEXT, state TEXT,
@@ -3678,15 +5017,18 @@ class Store {
   gen = 0;
   memo = new Map;
   constructor(home = swarmHome()) {
-    mkdirSync3(home, { recursive: true });
+    mkdirSync4(home, { recursive: true });
     this.home = home;
-    this.db = new Database(join6(home, "swarm.db"));
+    this.db = new Database(join8(home, "swarm.db"));
     this.loadPricing();
     this.db.exec("PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL; PRAGMA mmap_size=268435456; PRAGMA cache_size=-32000;");
     this.db.exec(SCHEMA);
     this.ensureColumn("sessions", "agent", "TEXT DEFAULT 'claude-code'");
     this.ensureColumn("projects", "sort_order", "INTEGER");
-    this.migrateProjectsJson(join6(home, "projects.json"));
+    this.ensureColumn("projects", "icon", "TEXT");
+    this.ensureColumn("projects", "color", "TEXT");
+    this.migrate();
+    this.migrateProjectsJson(join8(home, "projects.json"));
     this.reconcileMovedProjects();
     this.slimExistingEvents();
     this.retypeNotificationIncidents();
@@ -3734,9 +5076,9 @@ class Store {
   reconcileMovedProjects() {
     const all = this.projects();
     for (const stale of all) {
-      if (existsSync4(stale.root))
+      if (existsSync5(stale.root))
         continue;
-      const live = all.filter((p) => p.id !== stale.id && p.name === stale.name && existsSync4(p.root));
+      const live = all.filter((p) => p.id !== stale.id && p.name === stale.name && existsSync5(p.root));
       if (live.length !== 1)
         continue;
       this.mergeProject(stale.id, live[0].id);
@@ -3768,8 +5110,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 (!existsSync4(file))
+    if (!existsSync5(file))
       return;
     try {
       const list = JSON.parse(readFileSync3(file, "utf8"));
@@ -3784,11 +5177,12 @@ class Store {
     const hit = this.topCache.get(cwd);
     if (hit && Date.now() - hit.t < 1e4)
       return hit.v;
-    const v = cwd && existsSync4(cwd) ? gitToplevel(cwd) : null;
+    const v = cwd && existsSync5(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)
@@ -3817,8 +5211,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,
@@ -3868,8 +5262,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;
@@ -3989,7 +5383,7 @@ class Store {
     }));
   }
   sessionContext(cwd) {
-    if (!cwd || !existsSync4(cwd))
+    if (!cwd || !existsSync5(cwd))
       return null;
     const toplevel = this.toplevel(cwd);
     const project = this.resolveProject(cwd);
@@ -4001,6 +5395,9 @@ class Store {
       const h = this.latestHandoff(held.projectId, held.task);
       if (h)
         lines.push(formatHandoff(h));
+      const qc = this.questionContext(held.task, held.projectId);
+      if (qc)
+        lines.push(qc);
       const required = this.requiredGates(held.projectId);
       if (required.length) {
         const st = gateStatus(this.gateRuns(held.projectId, held.task), required);
@@ -4027,6 +5424,131 @@ class Store {
       lines.push(`[swarm] rules: ${on.join(" ")}`);
     return lines.length ? lines.join(`
 `) : null;
+  }
+  rowToQuestion(r) {
+    return {
+      id: r.id,
+      projectId: r.project_id,
+      sessionId: r.session_id ?? null,
+      task: r.task ?? null,
+      text: r.text,
+      options: JSON.parse(r.options || "[]"),
+      askedBy: r.asked_by ?? null,
+      createdAt: r.created_at,
+      answer: r.answer ?? null,
+      answeredBy: r.answered_by ?? null,
+      answeredAt: r.answered_at ?? null,
+      deliveredAt: r.delivered_at ?? null
+    };
+  }
+  questions(opts = {}) {
+    const where = ["kind = 'question'"];
+    const args = [];
+    if (opts.projectId) {
+      where.push("project_id = ?");
+      args.push(opts.projectId);
+    }
+    if (opts.sessionId) {
+      where.push("session_id = ?");
+      args.push(opts.sessionId);
+    }
+    if (opts.open)
+      where.push("answered_at IS NULL");
+    args.push(opts.limit ?? 100);
+    return this.db.query(`SELECT * FROM messages WHERE ${where.join(" AND ")} ORDER BY id DESC LIMIT ?`).all(...args).map((r) => this.rowToQuestion(r));
+  }
+  question(id) {
+    const r = this.db.query("SELECT * FROM messages WHERE id = ? AND kind = 'question'").get(id);
+    return r ? this.rowToQuestion(r) : null;
+  }
+  ask(projectId, input) {
+    if (!this.project(projectId))
+      return { ok: false, error: "unknown project" };
+    const v = validateQuestion(input.text, input.options);
+    if (!v.ok)
+      return { ok: false, error: v.reason };
+    const sessionId = this.knownSession(input.sessionId ?? null);
+    const task = (input.cwd ? this.heldClaimsWithWorktree().find((c) => isInside(input.cwd, c.worktree))?.task : null) ?? null;
+    const createdAt = new Date().toISOString();
+    const r = this.db.query(`INSERT INTO messages (project_id, session_id, task, kind, text, options, asked_by, created_at)
+         VALUES (?, ?, ?, 'question', ?, ?, ?, ?)`).run(projectId, sessionId, task, v.text, JSON.stringify(v.options), input.askedBy ?? null, createdAt);
+    const q = this.question(Number(r.lastInsertRowid));
+    this.append({
+      ts: createdAt,
+      type: "question.asked",
+      projectId,
+      sessionId,
+      payload: {
+        id: q.id,
+        task,
+        text: v.text,
+        options: v.options,
+        summary: `question #${q.id}: ${v.text.slice(0, 120)}`
+      }
+    });
+    this.touch();
+    return { ok: true, question: q };
+  }
+  answer(id, text, by) {
+    const q = this.question(id);
+    if (!q)
+      return { ok: false, error: `no question #${id}` };
+    if (q.answer !== null)
+      return {
+        ok: false,
+        error: `#${id} was already answered by ${q.answeredBy ?? "someone"}`
+      };
+    const a = typeof text === "string" ? text.trim() : "";
+    if (!a)
+      return { ok: false, error: "an answer is required" };
+    const at = new Date().toISOString();
+    this.db.query("UPDATE messages SET answer = ?, answered_by = ?, answered_at = ? WHERE id = ?").run(a, by, at, id);
+    this.append({
+      ts: at,
+      type: "question.answered",
+      projectId: q.projectId,
+      sessionId: q.sessionId,
+      payload: { id, task: q.task, answer: a, by, summary: `answer to #${id}: ${a.slice(0, 120)}` }
+    });
+    this.touch();
+    return { ok: true, question: this.question(id) };
+  }
+  inbox(sessionId, opts = {}) {
+    if (!sessionId)
+      return [];
+    const rows = this.db.query("SELECT * FROM messages WHERE kind = 'question' AND session_id = ? AND answered_at IS NOT NULL AND delivered_at IS NULL ORDER BY id").all(sessionId);
+    const qs = rows.map((r) => this.rowToQuestion(r));
+    if (qs.length && !opts.peek)
+      this.db.query(`UPDATE messages SET delivered_at = ? WHERE id IN (${qs.map(() => "?").join(",")})`).run(new Date().toISOString(), ...qs.map((q) => q.id));
+    return qs;
+  }
+  answerContext(sessionId) {
+    return formatAnswers(this.inbox(sessionId));
+  }
+  questionContext(task, projectId) {
+    if (!task)
+      return null;
+    const qs = this.db.query("SELECT * FROM messages WHERE kind = 'question' AND project_id = ? AND task = ? AND (answered_at IS NULL OR delivered_at IS NULL) ORDER BY id").all(projectId, task);
+    const list = qs.map((r) => this.rowToQuestion(r));
+    const parts = [formatAnswers(list), formatOpenQuestions(list)].filter(Boolean);
+    if (list.some((q) => q.answer !== null))
+      this.db.query("UPDATE messages SET delivered_at = ? WHERE kind = 'question' AND project_id = ? AND task = ? AND answered_at IS NOT NULL AND delivered_at IS NULL").run(new Date().toISOString(), projectId, task);
+    return parts.length ? parts.join(`
+`) : null;
+  }
+  contextFor(cwd, sessionId) {
+    const parts = [];
+    const base = this.sessionContext(cwd);
+    if (base)
+      parts.push(base);
+    const answers = this.answerContext(sessionId);
+    if (answers)
+      parts.push(answers);
+    const open = formatOpenQuestions(this.questions({ sessionId: sessionId ?? undefined, open: true }));
+    if (open && !base?.includes(open))
+      parts.push(open);
+    return { text: parts.length ? parts.join(`
+`) : null, parts };
   }
   rowToGate(r) {
     return {
@@ -4045,8 +5567,319 @@ class Store {
     const rows = task ? this.db.query("SELECT * FROM gates WHERE project_id = ? AND task = ? ORDER BY created_at DESC, id DESC LIMIT ?").all(projectId, task, limit) : this.db.query("SELECT * FROM gates WHERE project_id = ? ORDER BY created_at DESC, id DESC LIMIT ?").all(projectId, limit);
     return rows.map((r) => this.rowToGate(r));
   }
-  gateStatusFor(runs, required) {
-    return gateStatus(runs, required);
+  gateStatusFor(runs, required) {
+    return gateStatus(runs, required);
+  }
+  config(projectId) {
+    const p = this.project(projectId);
+    return loadConfig({ repoRoot: p?.root ?? null, home: this.home });
+  }
+  gateDefs(projectId) {
+    const p = this.project(projectId);
+    return p ? loadConfig({ repoRoot: p.root, home: this.home }).gates : null;
+  }
+  gateJobs = new Map;
+  gateBatches = new Map;
+  async awaitGates(projectId, task) {
+    const prefix = `${projectId}:${task}:`;
+    await Promise.all([
+      ...[...this.gateJobs].filter(([k]) => k.startsWith(prefix)).map(([, v]) => v),
+      ...this.gateBatches.get(`${projectId}:${task}`) ?? []
+    ]);
+  }
+  runGate(projectId, task, gate, opts = {}) {
+    const p = this.project(projectId);
+    if (!p)
+      return { ok: false, reason: "unknown project" };
+    const cfg = this.gateDefs(projectId);
+    const def = cfg?.defs[gate];
+    if (!def)
+      return {
+        ok: false,
+        reason: `gate ${gate} has no command \u2014 add [gates.${gate}] cmd = "\u2026" to .swarm.toml, or record it with swarm gate record`
+      };
+    const claim = this.claims(projectId).find((c) => c.task === task && c.state === "held");
+    const worktree2 = claim?.worktree;
+    if (!worktree2 || !existsSync5(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))
+      return { ok: false, reason: `gate cwd ${cwd} does not exist` };
+    const key = `${projectId}:${task}:${gate}`;
+    if (this.gateJobs.has(key))
+      return { ok: false, reason: `${gate} is already running on ${task}` };
+    const slug = (x) => x.replace(/[^a-zA-Z0-9_.-]+/g, "-");
+    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()}
+`);
+    const fd = openSync3(log, "a");
+    let proc;
+    try {
+      proc = Bun.spawn(["sh", "-c", def.cmd], {
+        cwd,
+        stdin: "ignore",
+        stdout: fd,
+        stderr: fd,
+        env: {
+          ...process.env,
+          SWARM_WORKTREE: worktree2,
+          SWARM_TASK: task,
+          SWARM_GATE: gate,
+          CI: process.env.CI ?? "1"
+        }
+      });
+    } catch (e) {
+      closeSync(fd);
+      const run2 = this.recordGate(projectId, {
+        ...executedGateInput(task, gate, def.cmd, {
+          exitCode: null,
+          durationMs: 0,
+          output: e.message
+        }),
+        sessionId: opts.sessionId ?? null
+      });
+      return { ok: true, pid: 0, log, done: Promise.resolve(run2.ok ? run2.run : null) };
+    }
+    const started = Date.now();
+    const reg = this.registerProcess({
+      pid: proc.pid,
+      projectId,
+      sessionId: opts.sessionId ?? null,
+      kind: "gate",
+      name: `gate:${task}:${gate}`,
+      cwd,
+      cmd: def.cmd,
+      owner: opts.owner ?? "daemon",
+      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 done = proc.exited.then((code) => {
+      clearTimeout(timer);
+      closeSync(fd);
+      let output = "";
+      try {
+        output = readFileSync3(log, "utf8");
+      } catch {}
+      const input = executedGateInput(task, gate, def.cmd, {
+        exitCode: timedOut ? null : code,
+        timedOut,
+        durationMs: Date.now() - started,
+        output
+      });
+      const run2 = this.recordGate(projectId, { ...input, sessionId: opts.sessionId ?? null });
+      if (reg.ok)
+        this.processes(projectId);
+      return run2.ok ? run2.run : null;
+    }).finally(() => {
+      this.gateJobs.delete(key);
+      this.touch();
+    });
+    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]);
+    const key = `${projectId}:${task}`;
+    const batch = (async () => {
+      const started = [];
+      const skipped = [];
+      const runs = [];
+      for (const g of names) {
+        const r = this.runGate(projectId, task, g, opts);
+        if (!r.ok) {
+          skipped.push({ gate: g, reason: r.reason });
+          continue;
+        }
+        started.push(g);
+        const run2 = await r.done;
+        if (run2)
+          runs.push(run2);
+      }
+      return { started, skipped, runs };
+    })();
+    const set = this.gateBatches.get(key) ?? new Set;
+    set.add(batch);
+    this.gateBatches.set(key, set);
+    try {
+      return await batch;
+    } finally {
+      set.delete(batch);
+      if (!set.size)
+        this.gateBatches.delete(key);
+    }
+  }
+  autoGateAt = new Map;
+  autoGate(event, sessionId, cwd) {
+    const held = this.heldClaimsWithWorktree().find((c) => isInside(cwd, c.worktree));
+    if (!held)
+      return;
+    const cfg = this.gateDefs(held.projectId);
+    if (!cfg || cfg.auto === "off")
+      return;
+    if (cfg.auto === "session-end" && event !== "SessionEnd")
+      return;
+    if (!cfg.required.some((g) => cfg.defs[g]))
+      return;
+    const key = `${held.projectId}:${held.task}`;
+    const now = Date.now();
+    if (event === "Stop" && now - (this.autoGateAt.get(key) ?? 0) < 120000)
+      return;
+    this.autoGateAt.set(key, now);
+    this.runGates(held.projectId, held.task, undefined, { sessionId, owner: "auto" }).then((r) => {
+      if (!r.runs.length)
+        return;
+      const line = r.runs.map((x) => `${x.gate} ${x.verdict === "pass" ? "\u2713" : "\u2717"} (${x.rubric})`).join("; ");
+      this.db.query("UPDATE handoffs SET verify = ? WHERE project_id = ? AND task = ? AND session_id = ? AND by LIKE 'auto%'").run(`auto-gates: ${line}`, held.projectId, held.task, sessionId);
+      this.touch();
+    });
   }
   requiredGates(projectId) {
     const p = this.project(projectId);
@@ -4060,8 +5893,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({
@@ -4113,8 +5946,8 @@ class Store {
       hit = { tasks: e.tasks };
       error = e.error;
     } else {
-      const path = join6(p.root, source);
-      if (!existsSync4(path))
+      const path = join8(p.root, source);
+      if (!existsSync5(path))
         return { source, required: this.requiredGates(projectId), tasks: [] };
       const mtime = statSync(path).mtimeMs;
       let md = this.taskCache.get(projectId);
@@ -4147,15 +5980,81 @@ 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 (existsSync5(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 existsSync5(p) ? JSON.parse(readFileSync3(p, "utf8")) : null;
+    } catch {
+      return null;
+    }
+  }
+  checkPolicy(cwd, sessionId) {
+    const project = existsSync5(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)) {
+      const project = this.resolveProject(cwd);
+      const b = this.budgetFor(project.id);
+      if (b && b.status.level === "exceeded" && b.config.on_exceed === "ask") {
+        const d = {
+          action: "ask",
+          rule: "budget",
+          reason: `${budgetMessage(b.status, project.name)} \u2014 [budget] on_exceed = "ask": confirm each change, or raise the ceiling in .swarm.toml`
+        };
+        return { decision: d, display: input.command ?? input.file_path ?? tool };
+      }
+    }
     const isWrite = WRITE_TOOLS.has(tool) && typeof input.file_path === "string";
     const cmd = tool === "Bash" ? input.command : undefined;
     const current = { id: sessionId, cwd, toplevel: this.toplevel(cwd) };
@@ -4235,7 +6134,7 @@ class Store {
     return this.openIncident(d, cwd, id, cmd);
   }
   openIncident(d, cwd, sessionId, command) {
-    const project = cwd && existsSync4(cwd) ? this.resolveProject(cwd) : null;
+    const project = cwd && existsSync5(cwd) ? this.resolveProject(cwd) : null;
     this.append({
       ts: new Date().toISOString(),
       type: "incident.opened",
@@ -4286,7 +6185,7 @@ class Store {
       }
     }
     const report = dryRunRules(calls, modes, {
-      toplevel: (cwd) => cwd && existsSync4(cwd) ? this.toplevel(cwd) : null,
+      toplevel: (cwd) => cwd && existsSync5(cwd) ? this.toplevel(cwd) : null,
       claims: this.heldWorktrees()
     });
     return { ...report, modes };
@@ -4301,8 +6200,8 @@ class Store {
   loadPricing() {
     this.prices = { ...PRICES };
     for (const f of ["pricing.litellm.json", "pricing.json"]) {
-      const p = join6(this.home, f);
-      if (!existsSync4(p))
+      const p = join8(this.home, f);
+      if (!existsSync5(p))
         continue;
       try {
         const j = JSON.parse(readFileSync3(p, "utf8"));
@@ -4317,7 +6216,7 @@ class Store {
       throw new Error(`pricing fetch ${r.status}`);
     const j = await r.json();
     const slim = Object.fromEntries(Object.entries(j).filter(([k, v]) => typeof v.input_cost_per_token === "number" && !k.includes("/")));
-    writeFileSync2(join6(this.home, "pricing.litellm.json"), JSON.stringify(slim, null, 1));
+    writeFileSync2(join8(this.home, "pricing.litellm.json"), JSON.stringify(slim, null, 1));
     this.loadPricing();
     this.reprice();
   }
@@ -4344,6 +6243,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
     }));
   }
@@ -4358,6 +6259,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
     };
   }
@@ -4395,6 +6298,8 @@ class Store {
         ...ident,
         discovered: !explicit,
         order: null,
+        icon: null,
+        color: null,
         createdAt: new Date().toISOString()
       };
       if (name)
@@ -4415,8 +6320,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) {
@@ -4435,10 +6356,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);
@@ -4448,9 +6388,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)
@@ -4461,11 +6426,13 @@ 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 = existsSync4(cwd) ? this.resolveProject(cwd) : null;
+    const project = existsSync5(cwd) ? this.resolveProject(cwd) : null;
     const e = this.append(normalizeHook(event, raw2, project?.id ?? "p_unknown"));
     if ((event === "Stop" || event === "SessionEnd") && e.sessionId) {
-      if (existsSync4(cwd))
+      if (existsSync5(cwd)) {
         this.autoHandoff(e.sessionId, cwd);
+        this.autoGate(event, e.sessionId, cwd);
+      }
       this.rememberSession(e.sessionId);
     }
     if (e.sessionId && typeof raw2.transcript_path === "string") {
@@ -4488,6 +6455,15 @@ class Store {
     "claim.renewed",
     "claim.released",
     "claim.orphaned",
+    "worktree.bootstrapped",
+    "worktree.created",
+    "worktree.removed",
+    "pr.opened",
+    "question.asked",
+    "question.answered",
+    "dispatch.queued",
+    "dispatch.started",
+    "dispatch.finished",
     "gate.recorded",
     "handoff.recorded",
     "incident.opened",
@@ -4499,7 +6475,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 && existsSync4(p.cwd) ? currentBranch(p.cwd) : null;
+    const branch = p.cwd && existsSync5(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);
     }
@@ -4519,7 +6495,7 @@ class Store {
       const size = statSync(path).size;
       if (size <= offset)
         return null;
-      const fd = openSync2(path, "r");
+      const fd = openSync3(path, "r");
       const buf = Buffer.alloc(size - offset);
       readSync(fd, buf, 0, buf.length, offset);
       closeSync(fd);
@@ -4537,13 +6513,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)
@@ -4569,12 +6547,12 @@ class Store {
   }
   tailSession(sessionId) {
     const s = this.db.query("SELECT transcript_path FROM sessions WHERE id = ?").get(sessionId);
-    if (!s?.transcript_path || !existsSync4(s.transcript_path))
+    if (!s?.transcript_path || !existsSync5(s.transcript_path))
       return 0;
     let n = this.tailFile(s.transcript_path, sessionId, null);
-    const subDir = join6(dirname(s.transcript_path), basename(s.transcript_path, ".jsonl"), "subagents");
+    const subDir = join8(dirname2(s.transcript_path), basename(s.transcript_path, ".jsonl"), "subagents");
     for (const f of this.subagentFiles(subDir)) {
-      n += this.tailFile(join6(subDir, f), sessionId, f.replace(/^agent-|\.jsonl$/g, ""));
+      n += this.tailFile(join8(subDir, f), sessionId, f.replace(/^agent-|\.jsonl$/g, ""));
     }
     return n;
   }
@@ -4606,7 +6584,7 @@ class Store {
     return n;
   }
   codexRoot() {
-    return process.env.SWARM_CODEX_DIR ?? join6(homedir3(), ".codex", "sessions");
+    return process.env.SWARM_CODEX_DIR ?? join8(homedir3(), ".codex", "sessions");
   }
   codexRolloutFiles(sinceMs) {
     const root = this.codexRoot();
@@ -4621,18 +6599,18 @@ class Store {
     for (const y of ls(root)) {
       if (!/^\d{4}$/.test(y))
         continue;
-      for (const m of ls(join6(root, y))) {
+      for (const m of ls(join8(root, y))) {
         if (!/^\d\d$/.test(m))
           continue;
-        for (const day of ls(join6(root, y, m))) {
+        for (const day of ls(join8(root, y, m))) {
           if (!/^\d\d$/.test(day))
             continue;
           if (Date.parse(`${y}-${m}-${day}T23:59:59Z`) < sinceMs)
             continue;
-          const dir = join6(root, y, m, day);
+          const dir = join8(root, y, m, day);
           for (const f of ls(dir)) {
             if (f.startsWith("rollout-") && f.endsWith(".jsonl"))
-              out.push(join6(dir, f));
+              out.push(join8(dir, f));
           }
         }
       }
@@ -4640,7 +6618,7 @@ class Store {
     return out;
   }
   tailCodex(windowMs = 3 * 24 * 60 * 60000) {
-    if (!existsSync4(this.codexRoot()))
+    if (!existsSync5(this.codexRoot()))
       return 0;
     let n = 0;
     for (const path of this.codexRolloutFiles(Date.now() - windowMs)) {
@@ -4649,12 +6627,12 @@ class Store {
     return n;
   }
   grokRoot() {
-    return process.env.SWARM_GROK_DIR ?? join6(homedir3(), ".grok", "sessions");
+    return process.env.SWARM_GROK_DIR ?? join8(homedir3(), ".grok", "sessions");
   }
   grokSummary = new Map;
   tailGrok(windowMs = 3 * 24 * 60 * 60000) {
     const root = this.grokRoot();
-    if (!existsSync4(root))
+    if (!existsSync5(root))
       return 0;
     const since = Date.now() - windowMs;
     const ls = (p) => {
@@ -4674,10 +6652,10 @@ class Store {
       } catch {
         cwd = enc;
       }
-      const cwdDir = join6(root, enc);
+      const cwdDir = join8(root, enc);
       for (const sid of ls(cwdDir)) {
-        const path = join6(cwdDir, sid, "updates.jsonl");
-        if (!existsSync4(path))
+        const path = join8(cwdDir, sid, "updates.jsonl");
+        if (!existsSync5(path))
           continue;
         try {
           if (statSync(path).mtimeMs < since)
@@ -4685,7 +6663,7 @@ class Store {
         } catch {
           continue;
         }
-        const sumPath = join6(cwdDir, sid, "summary.json");
+        const sumPath = join8(cwdDir, sid, "summary.json");
         let title;
         let fresh = false;
         try {
@@ -4736,9 +6714,9 @@ class Store {
   ensureAgentSession(sid, agent, cwd, mtime) {
     if (this.db.query("SELECT 1 FROM sessions WHERE id = ?").get(sid))
       return;
-    const project = cwd && existsSync4(cwd) ? this.resolveProject(cwd) : null;
+    const project = cwd && existsSync5(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 && existsSync4(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 && existsSync5(cwd) ? currentBranch(cwd) : null, ts, ts);
   }
   claimRows(projectId) {
     return this.db.query("SELECT * FROM claims WHERE project_id = ?").all(projectId).map((r) => ({
@@ -4772,9 +6750,9 @@ class Store {
   worktreePath(projectId, task) {
     const slug = (x) => x.replace(/[^a-zA-Z0-9._-]+/g, "-").toLowerCase();
     const p = this.project(projectId);
-    return join6(this.home, "worktrees", slug(p?.name ?? projectId), slug(task));
+    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" };
@@ -4783,28 +6761,77 @@ class Store {
     if (!decision.ok)
       return { ok: false, error: claimRefusalMessage(decision, task) };
     const branch = `task/${task}`;
-    const worktree = this.worktreePath(projectId, task);
-    if (existsSync4(worktree))
-      return { ok: false, error: `${worktree} already exists; release ${task} first` };
-    mkdirSync3(dirname(worktree), { recursive: true });
-    const created = worktreeAdd(p.root, worktree, branch, baseRef);
+    const worktree2 = this.worktreePath(projectId, task);
+    if (existsSync5(worktree2))
+      return { ok: false, error: `${worktree2} already exists; release ${task} first` };
+    mkdirSync4(dirname2(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}` }
     });
-    return { ok: true, task, owner, worktree: created, branch, expiresAt };
+    const bootstrap = this.bootstrapWorktree(projectId, task, p.root, created);
+    return { ok: true, task, owner, worktree: created, branch, expiresAt, bootstrap };
+  }
+  bootstraps = new Map;
+  bootstrapWorktree(projectId, task, repoRoot, worktree2) {
+    const plan = planBootstrap(loadConfig({ repoRoot, home: this.home }), repoRoot, worktree2);
+    if (!needsBootstrap(plan))
+      return null;
+    const job = runBootstrap(plan, { worktree: worktree2, home: this.home, projectId, task });
+    const done = job.done.then((o) => {
+      this.bootstraps.delete(worktree2);
+      const ts = new Date().toISOString();
+      const ok = !o.setup || o.setup.exitCode === 0;
+      this.append({
+        ts,
+        type: "worktree.bootstrapped",
+        projectId,
+        sessionId: null,
+        payload: {
+          task,
+          worktree: worktree2,
+          ok,
+          log: job.log,
+          ...o,
+          summary: `bootstrap ${task}: ${summarizeBootstrap(o)}`
+        }
+      });
+      if (!ok)
+        this.append({
+          ts,
+          type: "incident.opened",
+          projectId,
+          sessionId: null,
+          payload: {
+            rule: "bootstrap_failed",
+            action: "failed",
+            command: o.setup?.command ?? "",
+            reason: `worktree setup for ${task} exited ${o.setup?.exitCode} \u2014 see ${job.log}`
+          }
+        });
+      this.touch();
+      return o;
+    });
+    this.bootstraps.set(worktree2, done);
+    return job.log;
+  }
+  awaitBootstrap(worktree2) {
+    return this.bootstraps.get(worktree2) ?? Promise.resolve();
   }
   autoRenewAt = new Map;
   autoRenewFor(sessionId, cwd) {
@@ -4847,7 +6874,7 @@ class Store {
       for (const c of this.claimRows(p.id)) {
         if (c.state !== "held" || isActive(c, now))
           continue;
-        const exists = c.worktree ? existsSync4(c.worktree) : false;
+        const exists = c.worktree ? existsSync5(c.worktree) : false;
         const work = exists ? heldWork(c.worktree) : null;
         if (reapAction(c, now, exists, work) !== "keep-orphaned")
           continue;
@@ -4902,18 +6929,18 @@ class Store {
     const row = this.db.query("SELECT * FROM claims WHERE project_id = ? AND task = ?").get(projectId, task);
     if (!row)
       return { ok: false, error: `no claim on ${task}` };
-    const worktree = row.worktree ?? "";
-    if (worktree && existsSync4(worktree)) {
-      const work = heldWork(worktree);
+    const worktree2 = row.worktree ?? "";
+    if (worktree2 && existsSync5(worktree2)) {
+      const work = heldWork(worktree2);
       const can = canRelease(work, force);
       if (!can.ok)
         return {
           ok: false,
-          error: releaseRefusalMessage(can, worktree),
+          error: releaseRefusalMessage(can, worktree2),
           refused: can.reason
         };
-      if (p && !worktreeRemove(p.root, worktree, force))
-        return { ok: false, error: `git worktree remove failed for ${worktree}` };
+      if (p && !worktreeRemove(p.root, worktree2, force))
+        return { ok: false, error: `git worktree remove failed for ${worktree2}` };
       this.invalidateWorktrees(projectId);
     }
     const releasedAt = new Date().toISOString();
@@ -4938,7 +6965,7 @@ class Store {
           continue;
         if (isActive({ ...c, state: "held" }, now))
           continue;
-        const exists = c.worktree ? existsSync4(c.worktree) : false;
+        const exists = c.worktree ? existsSync5(c.worktree) : false;
         const work = exists ? heldWork(c.worktree) : null;
         const action = reapAction({ ...c, state: "held" }, now, exists, work);
         if (action === "not-expired")
@@ -5029,6 +7056,141 @@ class Store {
     this.wtInflight.set(projectId, run2);
     return run2;
   }
+  createWorktree(projectId, name, baseRef = "HEAD", branch) {
+    const p = this.project(projectId);
+    if (!p)
+      return { ok: false, error: "unknown project" };
+    const slug = name.replace(/[^a-zA-Z0-9._-]+/g, "-").toLowerCase();
+    if (!slug || slug === "." || slug === "..")
+      return { ok: false, error: "bad worktree name" };
+    const path = this.worktreePath(projectId, slug);
+    if (existsSync5(path))
+      return { ok: false, error: `${path} already exists` };
+    mkdirSync4(dirname2(path), { recursive: true });
+    const br = branch?.trim() || `wt/${slug}`;
+    const created = worktreeAdd(p.root, path, br, baseRef);
+    if (!created)
+      return { ok: false, error: `git worktree add failed for ${name}` };
+    this.invalidateWorktrees(projectId);
+    this.append({
+      ts: new Date().toISOString(),
+      type: "worktree.created",
+      projectId,
+      sessionId: null,
+      payload: { name: slug, worktree: created, branch: br, summary: `worktree ${slug} created` }
+    });
+    const bootstrap = this.bootstrapWorktree(projectId, slug, p.root, created);
+    return { ok: true, name: slug, worktree: created, branch: br, bootstrap };
+  }
+  findWorktree(projectId, ref) {
+    const wts = this.wtCache.get(projectId)?.v ?? [];
+    const abs = ref.startsWith("/") ? ref.replace(/\/+$/, "") : null;
+    return wts.find((w) => w.path === abs) ?? wts.find((w) => !w.main && basename(w.path) === ref) ?? wts.find((w) => w.branch === ref) ?? null;
+  }
+  async removeWorktree(projectId, ref, force = false) {
+    const p = this.project(projectId);
+    if (!p)
+      return { ok: false, error: "unknown project" };
+    await this.refreshWorktrees(projectId);
+    const w = this.findWorktree(projectId, ref);
+    if (!w)
+      return { ok: false, error: `no worktree ${ref} in ${p.name}` };
+    const held = this.claims(projectId).find((c) => c.state === "held" && c.worktree === w.path);
+    const can = canRemoveWorktree(w, held?.task ?? null, force);
+    if (!can.ok)
+      return {
+        ok: false,
+        error: removeRefusalMessage(can.reason, w.path, held?.task),
+        refused: can.reason
+      };
+    if (!worktreeRemove(p.root, w.path, force))
+      return { ok: false, error: `git worktree remove failed for ${w.path}` };
+    this.invalidateWorktrees(projectId);
+    this.append({
+      ts: new Date().toISOString(),
+      type: "worktree.removed",
+      projectId,
+      sessionId: null,
+      payload: {
+        worktree: w.path,
+        branch: w.branch,
+        force,
+        summary: `worktree ${basename(w.path)} removed`
+      }
+    });
+    return { ok: true, worktree: w.path };
+  }
+  async gcWorktrees(projectId, apply = false) {
+    await this.refreshWorktrees(projectId);
+    const plan = planGc(this.wtCache.get(projectId)?.v ?? [], this.claims(projectId));
+    const removed = [];
+    if (apply)
+      for (const c of plan) {
+        if (!c.removable)
+          continue;
+        const r = await this.removeWorktree(projectId, c.path, false);
+        if (r.ok)
+          removed.push(c.path);
+      }
+    return { candidates: plan, removed };
+  }
+  openWorktree(projectId, ref) {
+    const p = this.project(projectId);
+    if (!p)
+      return { ok: false, error: "unknown project" };
+    const w = this.findWorktree(projectId, ref);
+    if (!w)
+      return { ok: false, error: `no worktree ${ref}` };
+    const cfg = loadConfig({ repoRoot: p.root, home: this.home }).worktree.open;
+    const cmd = cfg ? ["sh", "-c", cfg.replace(/\{path\}/g, `'${w.path.replace(/'/g, "'\\''")}'`)] : [
+      process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer" : "xdg-open",
+      w.path
+    ];
+    try {
+      Bun.spawn(cmd, { stdin: "ignore", stdout: "ignore", stderr: "ignore" }).unref();
+      return { ok: true, worktree: w.path, command: cmd.join(" ") };
+    } catch (e) {
+      return { ok: false, error: e.message };
+    }
+  }
+  async prDraftFor(projectId, ref) {
+    const p = this.project(projectId);
+    if (!p)
+      return { ok: false, error: "unknown project" };
+    await this.refreshWorktrees(projectId);
+    const claim = this.claims(projectId).find((c) => c.task === ref && c.state === "held");
+    const w = this.findWorktree(projectId, claim?.worktree ?? ref);
+    if (!w)
+      return { ok: false, error: `no worktree or held task ${ref}` };
+    const task = claim?.task ?? this.claims(projectId).find((c) => c.state === "held" && c.worktree === w.path)?.task ?? (w.branch?.startsWith("task/") ? w.branch.slice(5) : null) ?? basename(w.path);
+    const taskRow = this.tasks(projectId)?.tasks.find((t) => t.id === task) ?? null;
+    const handoff = this.latestHandoff(projectId, task);
+    const required = this.requiredGates(projectId);
+    const gates2 = required.length ? this.gateStatusFor(this.gateRuns(projectId, task), required).map((g) => ({
+      gate: g.gate,
+      verdict: g.verdict
+    })) : [];
+    const diff = await worktreeDiff(p.root, w.path);
+    const d = prDraft({
+      task,
+      title: taskRow?.title ?? null,
+      handoff,
+      gates: gates2,
+      files: diff.files,
+      commits: diff.commits
+    });
+    return { ok: true, task, worktree: w, ...d, diff };
+  }
+  recordPrOpened(projectId, task, worktree2, url) {
+    this.append({
+      ts: new Date().toISOString(),
+      type: "pr.opened",
+      projectId,
+      sessionId: null,
+      payload: { task, worktree: worktree2, url, summary: `PR opened for ${task}: ${url}` }
+    });
+    this.touch();
+  }
   invalidateWorktrees(projectId) {
     if (projectId)
       this.wtCache.delete(projectId);
@@ -5098,6 +7260,56 @@ class Store {
       };
     });
   }
+  projectSpend(projectId) {
+    const dayStart = new Date;
+    dayStart.setHours(0, 0, 0, 0);
+    const weekStart = new Date(Date.now() - 7 * 86400000).toISOString();
+    const q = (since) => this.db.query("SELECT COALESCE(SUM(t.cost_usd), 0) AS cost FROM turns t JOIN sessions s ON s.id = t.session_id WHERE s.project_id = ? AND t.ts >= ?").get(projectId, since).cost;
+    return { today: q(dayStart.toISOString()), week: q(weekStart) };
+  }
+  budgetFor(projectId) {
+    const cfg = this.config(projectId).budget;
+    if (!cfg.daily && !cfg.weekly)
+      return null;
+    return { status: budgetStatus(this.projectSpend(projectId), cfg), config: cfg };
+  }
+  budgetNotified = new Map;
+  budgetListeners = new Set;
+  onBudgetStop(fn) {
+    this.budgetListeners.add(fn);
+  }
+  checkBudgets() {
+    const day = new Date().toDateString();
+    const out = [];
+    for (const p of this.projects()) {
+      const b = this.budgetFor(p.id);
+      if (!b || b.status.level === "ok")
+        continue;
+      out.push({ projectId: p.id, status: b.status });
+      const key = `${day}:${b.status.level}`;
+      if (this.budgetNotified.get(p.id) === key)
+        continue;
+      this.budgetNotified.set(p.id, key);
+      const msg = budgetMessage(b.status, p.name);
+      this.append({
+        ts: new Date().toISOString(),
+        type: "incident.opened",
+        projectId: p.id,
+        sessionId: null,
+        payload: {
+          rule: "budget",
+          action: b.status.level === "exceeded" ? b.config.on_exceed : "warn",
+          command: `${b.status.kind} budget`,
+          reason: b.status.level === "exceeded" ? `${msg}. ${b.config.on_exceed === "stop" ? "Spawned runs were stopped and the dispatch queue cleared." : b.config.on_exceed === "ask" ? "Every Bash/Edit/Write now asks first." : "Raise [budget] in .swarm.toml or wait for the next day."}` : `${msg} \u2014 approaching the ceiling`
+        }
+      });
+      if (b.status.level === "exceeded" && b.config.on_exceed === "stop")
+        for (const fn of this.budgetListeners)
+          fn(p.id, b.status);
+      this.touch();
+    }
+    return out;
+  }
   spend() {
     const dayStart = new Date;
     dayStart.setHours(0, 0, 0, 0);
@@ -5245,19 +7457,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);
   }
@@ -5424,8 +7636,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",
@@ -5489,11 +7701,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",
@@ -5540,7 +7753,7 @@ class Store {
   }
   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 {
@@ -5552,12 +7765,13 @@ class Store {
       processes: this.memoised("processes", 5000, () => this.processes()),
       incidents: this.memoised("incidents", 30000, () => this.incidents(20, { open: true })),
       openIncidents: this.memoised("openIncidents", 30000, () => this.openIncidents()),
+      questions: this.questions({ open: true, limit: 50 }),
       resources: this.resources(),
       seq: this.seq()
     };
   }
 }
-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;
@@ -5603,7 +7817,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,
@@ -5611,6 +7825,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 = {
@@ -5623,17 +7841,32 @@ 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}/`));
+}
 
 // packages/daemon/src/app.ts
-var VERSION = "0.6.0";
+var VERSION = "0.8.0";
 var WEB_DIR = (() => {
   if (process.env.SWARM_WEB_DIR)
     return process.env.SWARM_WEB_DIR;
-  const here = dirname2(fileURLToPath(import.meta.url));
-  const dev = join7(here, "../../web/public");
-  return existsSync5(join7(dev, "index.html")) ? dev : join7(here, "../web");
+  const here = dirname3(fileURLToPath(import.meta.url));
+  const dev = join9(here, "../../web/public");
+  return existsSync6(join9(dev, "index.html")) ? dev : join9(here, "../web");
 })();
 var REPLAY_TAIL = 200;
 var wireCache = new WeakMap;
@@ -5645,11 +7878,41 @@ function wireJson(e) {
   }
   return s;
 }
+function hookRepoRoot(store, raw2) {
+  const cwd = typeof raw2.cwd === "string" ? raw2.cwd : "";
+  return cwd && existsSync6(cwd) ? store.resolveProject(cwd)?.root ?? null : null;
+}
 function createApp(store = new Store) {
   const app = new Hono2;
   const forge2 = new ForgeService(store);
   const runner = new Runner(store, store.home);
-  app.get("/v1/health", (c) => c.json({ ok: true, version: VERSION }));
+  const dispatcher = new Dispatcher(store, runner, forge2);
+  store.onBudgetStop((projectId) => {
+    dispatcher.clear(projectId);
+    for (const run2 of runner.list(projectId))
+      runner.stop(run2.id);
+  });
+  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({
+    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();
@@ -5668,22 +7931,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 && existsSync5(q) ? q : homedir4());
+      dir = realpathSync3(q && existsSync6(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: existsSync5(join7(dir, e.name, ".git")) })).sort((a, b) => a.name.localeCompare(b.name));
-      const parent = dirname2(dir);
+      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);
       return c.json({ path: dir, parent: parent === dir ? null : parent, entries });
     } catch (e) {
       return c.json({ error: e.message, path: dir }, 400);
@@ -5708,6 +7973,31 @@ 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.get("/v1/rules/dryrun", (c) => {
     const projectId = c.req.query("project");
     if (!projectId)
@@ -5721,11 +8011,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 });
   });
@@ -5793,10 +8083,84 @@ function createApp(store = new Store) {
       model: b.model,
       permissionMode: b.permissionMode,
       allowedTools: b.allowedTools,
-      maxTurns: b.maxTurns
+      maxTurns: b.maxTurns,
+      profile: b.profile
     });
     return r.ok ? c.json(r, 201) : c.json({ ok: false, error: r.reason }, 409);
   });
+  app.get("/v1/budget", (c) => {
+    const project = c.req.query("project");
+    if (!project)
+      return c.json({ error: "project required" }, 400);
+    return c.json(store.budgetFor(project) ?? { status: null, config: store.config(project).budget });
+  });
+  app.get("/v1/context", (c) => {
+    const cwd = c.req.query("cwd");
+    if (!cwd)
+      return c.json({ error: "cwd required" }, 400);
+    return c.json(store.contextFor(cwd, c.req.query("session") || null));
+  });
+  app.get("/v1/questions", (c) => c.json(store.questions({
+    projectId: c.req.query("project") || undefined,
+    sessionId: c.req.query("session") || undefined,
+    open: c.req.query("open") === "1"
+  })));
+  app.post("/v1/questions", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    if (!b.projectId)
+      return c.json({ ok: false, error: "projectId required" }, 400);
+    const r = store.ask(b.projectId, {
+      sessionId: b.sessionId ?? null,
+      text: b.text,
+      options: b.options,
+      askedBy: b.askedBy ?? null,
+      cwd: b.cwd ?? null
+    });
+    return c.json(r, r.ok ? 201 : 400);
+  });
+  app.post("/v1/questions/:id/answer", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    const r = store.answer(Number(c.req.param("id")), b.text, b.by ?? null);
+    if (r.ok && r.question.sessionId) {
+      const run2 = runner.get(r.question.sessionId);
+      if (run2 && run2.sessionId === r.question.sessionId) {
+        const sent = runner.send(run2.id, `[swarm] answer from ${b.by ?? "a human"} to your question "${r.question.text.slice(0, 200)}": ${r.question.answer}`);
+        if (sent.ok)
+          store.inbox(r.question.sessionId);
+      }
+    }
+    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/dispatch", (c) => {
+    const project = c.req.query("project");
+    if (!project)
+      return c.json({ error: "project required" }, 400);
+    return c.json({ entries: dispatcher.status(project), config: store.config(project).dispatch });
+  });
+  app.post("/v1/dispatch", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    if (!b.projectId)
+      return c.json({ ok: false, error: "projectId required" }, 400);
+    if (!b.ready && !b.tasks?.length)
+      return c.json({ ok: false, error: "tasks or ready:true required" }, 400);
+    const r = await dispatcher.dispatch(b.projectId, b.ready ? "ready" : b.tasks, {
+      owner: b.owner ?? "dispatch",
+      max: b.max,
+      maxParallel: b.maxParallel,
+      permissionMode: b.permissionMode,
+      model: b.model,
+      maxTurns: b.maxTurns,
+      profile: b.profile
+    });
+    return c.json(r, r.ok ? 202 : 409);
+  });
+  app.delete("/v1/dispatch", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    if (!b.projectId)
+      return c.json({ ok: false, error: "projectId required" }, 400);
+    return c.json({ ok: true, cleared: dispatcher.clear(b.projectId, b.task) });
+  });
   app.post("/v1/runs/:id/send", async (c) => {
     const b = await c.req.json().catch(() => ({}));
     if (!b.text?.trim())
@@ -5848,10 +8212,31 @@ function createApp(store = new Store) {
     const required = store.requiredGates(project);
     return c.json({
       required,
+      executable: Object.keys(store.gateDefs(project)?.defs ?? {}),
       runs,
       status: task ? store.gateStatusFor(runs, required) : undefined
     });
   });
+  app.post("/v1/gates/run", 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 opts = { sessionId: b.sessionId ?? null, owner: "cli" };
+    if (b.wait === false) {
+      const projectId = b.projectId;
+      const cfg = store.gateDefs(projectId);
+      const names = b.gates?.length ? b.gates : (cfg?.required ?? []).filter((g) => cfg?.defs[g]);
+      store.runGates(projectId, b.task, names, opts);
+      return c.json({ ok: true, started: names, runs: [] }, 202);
+    }
+    const r = await store.runGates(b.projectId, b.task, b.gates, opts);
+    const ok = r.started.length > 0 && r.runs.every((x) => x.verdict === "pass");
+    return c.json({
+      ok,
+      ...r,
+      error: r.started.length ? undefined : r.skipped[0]?.reason ?? "no executable gates"
+    }, r.started.length ? 200 : 409);
+  });
   app.post("/v1/gates", async (c) => {
     const b = await c.req.json().catch(() => ({}));
     if (!b.projectId)
@@ -5878,7 +8263,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) => {
@@ -5891,6 +8276,81 @@ function createApp(store = new Store) {
     const r = store.release(b.projectId ?? "", b.task ?? "", b.force ?? false);
     return c.json(r, r.ok ? 200 : 409);
   });
+  app.get("/v1/worktrees", async (c) => {
+    const project = c.req.query("project");
+    if (!project)
+      return c.json({ error: "project required" }, 400);
+    return c.json(await store.refreshWorktrees(project));
+  });
+  app.post("/v1/worktrees", async (c) => {
+    const b = await c.req.json();
+    if (!b.projectId || !b.name)
+      return c.json({ error: "projectId and name required" }, 400);
+    const r = store.createWorktree(b.projectId, b.name, b.baseRef, b.branch);
+    return c.json(r, r.ok ? 201 : 409);
+  });
+  app.post("/v1/worktrees/remove", async (c) => {
+    const b = await c.req.json();
+    if (!b.projectId || !b.worktree)
+      return c.json({ error: "projectId and worktree required" }, 400);
+    const r = await store.removeWorktree(b.projectId, b.worktree, b.force ?? false);
+    return c.json(r, r.ok ? 200 : 409);
+  });
+  app.post("/v1/worktrees/open", async (c) => {
+    const b = await c.req.json();
+    if (!b.projectId || !b.worktree)
+      return c.json({ error: "projectId and worktree required" }, 400);
+    await store.refreshWorktrees(b.projectId);
+    const r = store.openWorktree(b.projectId, b.worktree);
+    return c.json(r, r.ok ? 200 : 404);
+  });
+  app.get("/v1/worktrees/diff", async (c) => {
+    const project = c.req.query("project");
+    const ref = c.req.query("worktree");
+    if (!project || !ref)
+      return c.json({ error: "project and worktree required" }, 400);
+    await store.refreshWorktrees(project);
+    const w = store.findWorktree(project, ref);
+    const p = store.project(project);
+    if (!w || !p)
+      return c.json({ error: `no worktree ${ref}` }, 404);
+    const file = c.req.query("file") || undefined;
+    const d = await worktreeDiff(p.root, w.path);
+    if (file || c.req.query("patch") === "1")
+      return c.json({ ...d, worktree: w.path, patch: await worktreePatch(w.path, d.base, file) });
+    return c.json({ ...d, worktree: w.path });
+  });
+  app.get("/v1/prs/draft", async (c) => {
+    const project = c.req.query("project");
+    const ref = c.req.query("worktree") || c.req.query("task");
+    if (!project || !ref)
+      return c.json({ error: "project and worktree|task required" }, 400);
+    const r = await store.prDraftFor(project, ref);
+    return c.json(r, r.ok ? 200 : 404);
+  });
+  app.post("/v1/prs/open", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    const ref = b.worktree || b.task;
+    if (!b.projectId || !ref)
+      return c.json({ ok: false, error: "projectId and worktree|task required" }, 400);
+    const d = await store.prDraftFor(b.projectId, ref);
+    if (!d.ok)
+      return c.json(d, 404);
+    const r = await forge2.openPR(b.projectId, d.worktree, {
+      title: b.title?.trim() || d.title,
+      body: b.body ?? d.body,
+      isDraft: b.draft ?? false
+    });
+    if (r.ok)
+      store.recordPrOpened(b.projectId, d.task, d.worktree.path, r.url);
+    return c.json(r, r.ok ? 201 : 409);
+  });
+  app.post("/v1/worktrees/gc", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    if (!b.projectId)
+      return c.json({ error: "projectId required" }, 400);
+    return c.json(await store.gcWorktrees(b.projectId, b.apply ?? false));
+  });
   app.post("/v1/claims/reap", async (c) => {
     const b = await c.req.json().catch(() => ({}));
     return c.json({ reaped: store.reap(b.projectId) });
@@ -5950,6 +8410,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({
@@ -5957,18 +8418,26 @@ function createApp(store = new Store) {
           hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: ctx }
         });
     }
-    if (event === "PreToolUse" && process.env.SWARM_GUARD !== "off") {
+    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" && !store.guardDisabled(hookRepoRoot(store, raw2))) {
       const guard = store.guardHook(raw2);
       if (guard) {
         return c.json({
           hookSpecificOutput: {
             hookEventName: "PreToolUse",
             permissionDecision: guard.action,
-            permissionDecisionReason: `[swarm] ${guard.reason}`
+            permissionDecisionReason: `[swarm] ${guard.reason}`,
+            ...answers ? { additionalContext: answers } : {}
           }
         });
       }
     }
+    if (answers)
+      return c.json({
+        additionalContext: answers,
+        hookSpecificOutput: { hookEventName: event, additionalContext: answers }
+      });
     return c.json({});
   });
   app.post("/v1/events", async (c) => {
@@ -5997,18 +8466,18 @@ function createApp(store = new Store) {
       });
     });
   });
-  app.get("/", (c) => c.html(readFileSync4(join7(WEB_DIR, "index.html"), "utf8")));
+  app.get("/", (c) => c.html(readFileSync4(join9(WEB_DIR, "index.html"), "utf8")));
   const MIME = { js: "text/javascript", css: "text/css" };
   app.get("/:file{[a-z0-9-]+\\.(js|css)}", (c) => {
     const f = c.req.param("file");
-    const p = join7(WEB_DIR, f);
-    if (!existsSync5(p))
+    const p = join9(WEB_DIR, f);
+    if (!existsSync6(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 };
+  return { app, store, forge: forge2, runner, dispatcher };
 }
 
 // packages/daemon/src/bin.ts
@@ -6027,6 +8496,7 @@ function serve() {
 }
 var 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;
@@ -6044,6 +8514,8 @@ var tailer = setInterval(() => {
   store.reapProcesses();
   if (tick % 12 === 0)
     store.sweepOrphans();
+  if (tick % 6 === 0)
+    store.checkBudgets();
 }, 5000);
 store.refreshAllWorktrees();
 var wtRefresh = setInterval(() => void store.refreshAllWorktrees(), 15000);