@ra3orblade/swarm 0.4.1 → 0.6.0

package/dist/swarmd.js

@@ -327,7 +327,8 @@ import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { join as join2 } from "path";
 var DEFAULT_CONFIG = {
   daemon: { port: 7777 },
-  tasks: { source: null },
+  tasks: { source: null, labels: [], team: null },
+  gates: { required: [] },
   rules: {
     shared_tree: "ask",
     destructive_git: "ask",
@@ -366,7 +367,9 @@ function validate(c) {
     ...c,
     daemon: { port: Number.isInteger(port) && port > 0 && port < 65536 ? port : 7777 },
     tasks: {
-      source: typeof source === "string" && source.trim() && !source.startsWith("/") ? source.trim() : null
+      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
     },
     rules: {
       ...c.rules,
@@ -395,6 +398,250 @@ function loadConfig(opts = {}) {
   }
   return validate(cfg);
 }
+// packages/core/src/rules.ts
+var LIVE_WINDOW_MS = 10 * 60000;
+function otherLiveInSameTree(current, sessions, now, withinMs = LIVE_WINDOW_MS) {
+  if (!current.toplevel)
+    return null;
+  for (const s of sessions) {
+    if (s.id === current.id)
+      continue;
+    if (s.state === "ended")
+      continue;
+    if (s.toplevel !== current.toplevel)
+      continue;
+    if (now - new Date(s.lastSeenAt).getTime() > withinMs)
+      continue;
+    return s;
+  }
+  return null;
+}
+function isBroadStage(cmd) {
+  const c = cmd.trim();
+  if (/\bgit\s+add\s+(-A\b|--all\b|\.(\s|$))/.test(c))
+    return true;
+  if (/\bgit\s+commit\b[^|&;]*\s-[a-zA-Z]*a/.test(c))
+    return true;
+  if (/\bgit\s+add\s*$/.test(c))
+    return true;
+  return false;
+}
+function isDestructiveGit(cmd) {
+  const c = cmd.trim();
+  return /\bgit\s+reset\s+[^|&;]*--hard\b/.test(c) || /\bgit\s+checkout\s+(--\s+)?\.(\s|$)/.test(c) || /\bgit\s+checkout\s+-f\b/.test(c) || /\bgit\s+restore\s+(--\s+)?\.(\s|$)/.test(c) || /\bgit\s+clean\s+[^|&;]*-[a-zA-Z]*f/.test(c) || /\bgit\s+stash\s+(drop|clear)\b/.test(c) || /\bgit\s+branch\s+[^|&;]*-[a-zA-Z]*D/.test(c);
+}
+function isPatternKill(cmd) {
+  return /\bpkill\s+-f\b/.test(cmd) || /\bpgrep\s+-f\b[^|]*\|\s*[^|]*\bkill\b/.test(cmd);
+}
+function killedPorts(cmd) {
+  const ports = new Set;
+  const killy = /\b(kill|fuser\s+-[a-z]*k|kill-port)\b/.test(cmd);
+  if (!killy)
+    return [];
+  for (const m of cmd.matchAll(/(?:-i\s*:?|:)(\d{2,5})\b/g))
+    ports.add(Number(m[1]));
+  for (const m of cmd.matchAll(/\bkill-port\s+(\d{2,5})/g))
+    ports.add(Number(m[1]));
+  for (const m of cmd.matchAll(/\bfuser\s+-[a-z]*k\s+(\d{2,5})/g))
+    ports.add(Number(m[1]));
+  return [...ports];
+}
+var DEFAULT_MODES = {
+  shared_tree: "ask",
+  destructive_git: "ask",
+  pattern_kill: "ask",
+  protected_ports: "ask",
+  no_foreign_worktree: "ask",
+  claim_required_to_write: "off",
+  protected: { ports: [] }
+};
+function guardBash(cmd, current, sessions, now, modes = DEFAULT_MODES) {
+  const other = () => otherLiveInSameTree(current, sessions, now);
+  const hit = (rule, reason) => {
+    const mode = modes[rule];
+    return mode === "off" ? { action: "allow" } : { action: mode, rule, reason };
+  };
+  if (modes.protected_ports !== "off" && modes.protected.ports.length) {
+    const target = killedPorts(cmd).filter((p) => modes.protected.ports.includes(p));
+    if (target.length) {
+      const d = hit("protected_ports", `Port${target.length > 1 ? "s" : ""} ${target.join(", ")} ${target.length > 1 ? "are" : "is"} protected in the Swarm config \u2014 something the owner relies on is listening there. Don't kill it.`);
+      if (d.action !== "allow")
+        return d;
+    }
+  }
+  if (modes.pattern_kill !== "off" && isPatternKill(cmd)) {
+    const d = hit("pattern_kill", "This kills processes by command pattern \u2014 it will match every process on the machine that fits, including other agents' or the owner's. Kill by pid instead.");
+    if (d.action !== "allow")
+      return d;
+  }
+  if (modes.shared_tree !== "off" && isBroadStage(cmd)) {
+    const o = other();
+    if (o) {
+      const d = hit("shared_tree", `Another session (${o.id.slice(0, 8)}) is active in this same checkout. \`git add -A\` / \`git commit -a\` will sweep its uncommitted changes into your commit. Stage explicit paths (\`git add <path>\`), or give each session its own git worktree.`);
+      if (d.action !== "allow")
+        return d;
+    }
+  }
+  if (modes.destructive_git !== "off" && isDestructiveGit(cmd)) {
+    const o = other();
+    if (o) {
+      const d = hit("destructive_git", `Another session (${o.id.slice(0, 8)}) is active in this same checkout and may have uncommitted work. This command can discard it. Coordinate, or use a separate git worktree.`);
+      if (d.action !== "allow")
+        return d;
+    }
+  }
+  return { action: "allow" };
+}
+function norm(p) {
+  const parts = [];
+  for (const seg of p.split("/")) {
+    if (seg === "" || seg === ".")
+      continue;
+    if (seg === "..")
+      parts.pop();
+    else
+      parts.push(seg);
+  }
+  return `/${parts.join("/")}`;
+}
+function isInside(path, dir) {
+  if (!path || !dir)
+    return false;
+  const a = norm(path);
+  const d = norm(dir);
+  return a === d || a.startsWith(`${d}/`);
+}
+function absolutePath(path, cwd) {
+  if (path.startsWith("/"))
+    return path;
+  if (path.startsWith("~/"))
+    return path;
+  return `${cwd.replace(/\/+$/, "")}/${path}`;
+}
+var WRITE_TOOLS = new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
+function guardWrite(target, current, claims, modes = DEFAULT_MODES, kind = "file") {
+  const hit = (rule, reason) => {
+    const mode = modes[rule];
+    return mode === "off" ? { action: "allow" } : { action: mode, rule, reason };
+  };
+  const held = claims.filter((c) => c.worktree);
+  const mine = held.find((c) => isInside(current.cwd, c.worktree)) ?? null;
+  if (modes.no_foreign_worktree !== "off") {
+    const foreign = held.find((c) => isInside(target, c.worktree) && c !== mine);
+    if (foreign) {
+      const d = hit("no_foreign_worktree", kind === "bash" ? `This command runs inside the worktree for "${foreign.task}", held by ${foreign.owner}. Never touch a worktree you don't hold \u2014 work in your own checkout, or claim the task.` : `${target} is inside the worktree for "${foreign.task}", held by ${foreign.owner}. Never touch a worktree you don't hold \u2014 edit your own checkout, or claim the task.`);
+      if (d.action !== "allow")
+        return d;
+    }
+  }
+  if (modes.claim_required_to_write !== "off" && kind === "file" && current.toplevel && !mine) {
+    const inShared = isInside(target, current.toplevel) && !held.some((c) => isInside(target, c.worktree));
+    if (inShared) {
+      const d = hit("claim_required_to_write", `This repo requires a claim before writing to its shared checkout. Run \`swarm claim <task>\` (or the swarm_claim MCP tool) and work in the worktree it creates.`);
+      if (d.action !== "allow")
+        return d;
+    }
+  }
+  return { action: "allow" };
+}
+
+// packages/core/src/dryrun.ts
+var RULE_IDS = [
+  "pattern_kill",
+  "shared_tree",
+  "destructive_git",
+  "protected_ports",
+  "no_foreign_worktree",
+  "claim_required_to_write"
+];
+function normalizeDisplay(s) {
+  return s.replace(/\s+/g, " ").trim().slice(0, 160);
+}
+function dryRunRules(calls, modes, ctx) {
+  const claims = ctx.claims ?? [];
+  const minRepeat = ctx.minRepeat ?? 3;
+  const maxHits = ctx.maxHits ?? 200;
+  const live = new Map;
+  const byRule = Object.fromEntries(RULE_IDS.map((r) => [r, { ask: 0, deny: 0 }]));
+  const hits = [];
+  const groups = new Map;
+  let evaluated = 0;
+  const sorted = [...calls].sort((a, b) => a.ts < b.ts ? -1 : a.ts > b.ts ? 1 : 0);
+  const writeRules = modes.no_foreign_worktree !== "off" || modes.claim_required_to_write !== "off";
+  for (const c of sorted) {
+    const toplevel = ctx.toplevel(c.cwd);
+    live.set(c.sessionId, { id: c.sessionId, toplevel, lastSeenAt: c.ts, state: "active" });
+    const now = new Date(c.ts).getTime();
+    const current = { id: c.sessionId, cwd: c.cwd, toplevel };
+    let d = { action: "allow" };
+    let display = c.tool;
+    const isWrite = WRITE_TOOLS.has(c.tool) && typeof c.filePath === "string";
+    if (isWrite) {
+      const target = absolutePath(c.filePath, c.cwd);
+      display = `${c.tool} ${target}`;
+      evaluated++;
+      if (writeRules)
+        d = guardWrite(target, current, claims, modes, "file");
+    } else if (c.tool === "Bash" && c.command) {
+      display = c.command;
+      evaluated++;
+      if (writeRules)
+        d = guardWrite(c.cwd, current, claims, modes, "bash");
+      if (d.action === "allow") {
+        const sessions = [...live.values()].filter((s) => now - new Date(s.lastSeenAt).getTime() <= LIVE_WINDOW_MS);
+        d = guardBash(c.command, current, sessions, now, modes);
+      }
+    } else
+      continue;
+    if (d.action === "allow")
+      continue;
+    byRule[d.rule][d.action]++;
+    const norm2 = normalizeDisplay(display);
+    if (hits.length < maxHits)
+      hits.push({
+        ts: c.ts,
+        sessionId: c.sessionId,
+        rule: d.rule,
+        action: d.action,
+        display: norm2,
+        completed: c.completed
+      });
+    const key = `${d.rule} ${norm2}`;
+    const g = groups.get(key) ?? {
+      rule: d.rule,
+      display: norm2,
+      fires: 0,
+      completedRatio: 0,
+      sessions: 0,
+      suggestion: "",
+      done: 0,
+      sids: new Set
+    };
+    g.fires++;
+    if (c.completed)
+      g.done++;
+    g.sids.add(c.sessionId);
+    groups.set(key, g);
+  }
+  const flaky = [];
+  for (const g of groups.values()) {
+    if (g.fires < minRepeat)
+      continue;
+    const ratio = g.done / g.fires;
+    if (ratio < 0.8)
+      continue;
+    flaky.push({
+      rule: g.rule,
+      display: g.display,
+      fires: g.fires,
+      completedRatio: Math.round(ratio * 100) / 100,
+      sessions: g.sids.size,
+      suggestion: modes[g.rule] === "deny" ? `${g.rule} denies this but it ran ${g.done}/${g.fires} times anyway \u2014 the rule is being bypassed; check the hook is installed, or turn it off here.` : `${g.rule} asked ${g.fires} times on this and it was allowed ${g.done} times \u2014 pure friction here. Turn it off for this repo, or make it deny so it stops asking.`
+    });
+  }
+  flaky.sort((a, b) => b.fires - a.fires);
+  return { calls: calls.length, evaluated, hits, byRule, flaky };
+}
 // packages/core/src/forge.ts
 function parseRemote(url) {
   const m = url.match(/^(?:ssh:\/\/)?git@([^:/]+)[:/](.+?)(?:\.git)?$/) ?? url.match(/^https?:\/\/([^/]+)\/(.+?)(?:\.git)?\/?$/);
@@ -459,6 +706,49 @@ function normalizeGitlab(raw, repo) {
     };
   });
 }
+// packages/core/src/gates.ts
+var NAME_RE = /^[a-z0-9][a-z0-9_.-]{0,39}$/i;
+function validateGateRun(input) {
+  if (!input.task?.trim())
+    return { ok: false, reason: "task is required" };
+  if (!NAME_RE.test(input.gate ?? ""))
+    return { ok: false, reason: "gate must be a short name (letters, digits, _ . -)" };
+  if (input.verdict !== "pass" && input.verdict !== "fail")
+    return { ok: false, reason: 'verdict must be "pass" or "fail"' };
+  const rubric = input.rubric?.trim() ?? "";
+  if (rubric.length < 8)
+    return {
+      ok: false,
+      reason: 'rubric is required: say what was checked (e.g. "tests green, no TODOs, reviewed error paths"). A verdict without a rubric is rejected.'
+    };
+  return { ok: true };
+}
+function gateStatus(runs, declared = []) {
+  const byGate = new Map;
+  for (const r of runs) {
+    const list = byGate.get(r.gate) ?? [];
+    list.push(r);
+    byGate.set(r.gate, list);
+  }
+  const names = [...new Set([...declared, ...byGate.keys()])];
+  return names.map((gate) => {
+    const list = (byGate.get(gate) ?? []).sort((a, b) => a.createdAt === b.createdAt ? b.id - a.id : a.createdAt < b.createdAt ? 1 : -1);
+    const latest = list[0] ?? null;
+    return {
+      gate,
+      verdict: latest?.verdict ?? null,
+      latest,
+      runs: list.length,
+      fails: list.filter((r) => r.verdict === "fail").length
+    };
+  });
+}
+function gatesSatisfied(runs, declared) {
+  if (!declared.length)
+    return true;
+  const st = gateStatus(runs, declared);
+  return declared.every((g) => st.find((s) => s.gate === g)?.verdict === "pass");
+}
 // packages/core/src/ledger.ts
 var DEFAULT_LEASE_MINUTES = 45;
 function isExpired(claim, now) {
@@ -495,12 +785,274 @@ function reapAction(claim, now, worktreeExists, work) {
     return "keep-orphaned";
   return "reap";
 }
+function shouldAutoRenew(claim, now, leaseMinutes = DEFAULT_LEASE_MINUTES) {
+  if (claim.state !== "held")
+    return false;
+  const left = new Date(claim.expiresAt).getTime() - now;
+  if (left <= 0)
+    return false;
+  return left < leaseMinutes * 60000 / 2;
+}
 function claimRefusalMessage(d, task) {
   return `${task} is held by ${d.heldBy} until ${d.until}. ` + "Pick another task or coordinate with the holder \u2014 claims fail closed on purpose.";
 }
 function releaseRefusalMessage(d, worktree) {
   return d.reason === "dirty" ? `${worktree} has uncommitted changes. Commit and push them, or re-run with --force to discard.` : `${worktree} has unpushed commits. Push them, or re-run with --force to discard the worktree.`;
 }
+function validateHandoff(h) {
+  if (!h.task?.trim())
+    return { ok: false, reason: "task is required" };
+  if (!h.done?.trim() || !h.remaining?.trim())
+    return {
+      ok: false,
+      reason: "a handoff needs both `done` (what was finished) and `remaining` (what is left, in order)"
+    };
+  return { ok: true };
+}
+function formatHandoff(h) {
+  const lines = [
+    `[swarm] handoff on ${h.task}${h.by ? ` from ${h.by}` : ""} (${h.createdAt.slice(0, 16).replace("T", " ")}):`,
+    `  done: ${h.done.trim()}`,
+    `  remaining: ${h.remaining.trim()}`
+  ];
+  if (h.files.length)
+    lines.push(`  files: ${h.files.join(", ")}`);
+  if (h.verify)
+    lines.push(`  verify: ${h.verify.trim()}`);
+  return lines.join(`
+`);
+}
+var EDIT_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+var VERIFY_RE = /\b(test|tests|typecheck|tsc|lint|biome|eslint|check|build|smoke|pytest|cargo (test|check|build)|go (test|vet|build)|make)\b/;
+function deriveHandoff(task, ev, opts = {}) {
+  const files = [];
+  let verify = null;
+  let lastPrompt = null;
+  for (const e of ev) {
+    const p = e.payload ?? {};
+    if (e.type === "tool.requested" && p.tool) {
+      const arg = (p.summary ?? "").slice(p.tool.length).trim();
+      if (EDIT_TOOLS.has(p.tool) && arg && !files.includes(arg))
+        files.push(arg);
+      if (p.tool === "Bash") {
+        if (arg && VERIFY_RE.test(arg))
+          verify = arg;
+      }
+    } else if (p.hook === "UserPromptSubmit" && (p.prompt ?? p.summary)) {
+      lastPrompt = (p.prompt ?? p.summary ?? "").trim().split(`
+`)[0]?.slice(0, 200) ?? null;
+    }
+  }
+  const said = (opts.lastText ?? "").trim().replace(/\s+/g, " ").slice(0, 600);
+  if (!files.length && !said)
+    return null;
+  const done = said || `edited ${files.length} file${files.length === 1 ? "" : "s"} (no summary)`;
+  const remaining = lastPrompt ? `unverified \u2014 session stopped without a manual handoff; last request: "${lastPrompt}". Re-read the files below, run verify, then continue.` : "unverified \u2014 session stopped without a manual handoff. Re-read the files below, run verify, then continue.";
+  return {
+    task,
+    done,
+    remaining,
+    files: files.slice(-30),
+    verify,
+    by: `auto${opts.sessionId ? `:${opts.sessionId.slice(0, 8)}` : ""}`,
+    createdAt: opts.now ?? new Date().toISOString()
+  };
+}
+function isAutoHandoff(h) {
+  return h.by === "auto" || (h.by?.startsWith("auto:") ?? false);
+}
+function formatResumePrompt(h, tail) {
+  const out = [
+    `You are resuming ${h.task}; the previous session on it stopped without finishing.`,
+    "",
+    formatHandoff(h)
+  ];
+  if (tail.length)
+    out.push("", "Its last actions, oldest first:", ...tail.map((t) => `  - ${t}`));
+  out.push("", "Start by reading the files listed, run the verify step if there is one, then continue with `remaining`. Work only inside this worktree; when done commit, push, and call swarm_handoff.");
+  return out.join(`
+`);
+}
+// packages/core/src/lessons.ts
+function portsIn(cmd) {
+  const ports = new Set;
+  for (const m of cmd.matchAll(/(?::|-i\s*:?|kill-port\s+|fuser\s+-[a-z]*k\s+)(\d{2,5})\b/g))
+    ports.add(Number(m[1]));
+  return [...ports];
+}
+var RECURRING = 3;
+function suggestFromIncident(inc) {
+  const n = inc.count ?? 1;
+  switch (inc.rule) {
+    case "protected_ports": {
+      const ports = portsIn(inc.command);
+      return {
+        title: ports.length ? `Protect port${ports.length > 1 ? "s" : ""} ${ports.join(", ")} for good` : "Protect this port",
+        toml: ports.length ? `[rules]
+protected_ports = "deny"
+
+[rules.protected]
+ports = [${ports.join(", ")}]` : null,
+        lesson: `Never kill the process on port ${ports.join("/") || "the dev server's port"} \u2014 it's someone's running service. Ask them, or use \`swarm serve\` so the port is tracked.`
+      };
+    }
+    case "pattern_kill":
+      return {
+        title: n >= RECURRING ? "Deny pattern kills (recurring)" : "Discourage pattern kills",
+        toml: `[rules]
+pattern_kill = "${n >= RECURRING ? "deny" : "ask"}"`,
+        lesson: "Kill processes by pid, never by command pattern (`pkill -f`) \u2014 pattern kills hit every matching process, including other agents' and the owner's."
+      };
+    case "shared_tree":
+      return {
+        title: "Deny broad staging in a shared checkout",
+        toml: `[rules]
+shared_tree = "deny"`,
+        lesson: "Don't `git add -A` / `git commit -a` while another session shares the checkout \u2014 stage explicit paths, or work in your own worktree via `swarm claim`."
+      };
+    case "destructive_git":
+      return {
+        title: "Deny destructive git in a shared checkout",
+        toml: `[rules]
+destructive_git = "deny"`,
+        lesson: "Never run `git reset --hard` / `checkout .` / `clean -f` in a checkout another session shares \u2014 coordinate, or use a separate worktree."
+      };
+    case "no_foreign_worktree":
+      return {
+        title: "Deny writes into others' worktrees",
+        toml: `[rules]
+no_foreign_worktree = "deny"`,
+        lesson: "Never edit inside a worktree you don't hold \u2014 work in your own checkout, or claim the task first."
+      };
+    case "claim_required_to_write":
+      return {
+        title: "Require a claim before writing",
+        toml: `[rules]
+claim_required_to_write = "deny"`,
+        lesson: "Claim a task (`swarm claim`) and work in the worktree it creates before editing this repo."
+      };
+    case "orphaned_claim":
+      return {
+        title: "A claim expired with unfinished work",
+        toml: null,
+        lesson: "Finish and push, or `swarm handoff`, before a lease expires \u2014 an orphaned worktree still holds work nobody owns."
+      };
+    case "gate_failed":
+      return {
+        title: "A verification gate failed",
+        toml: null,
+        lesson: `A gate failed here \u2014 ${inc.reason.slice(0, 120)}. Fix it and re-record the gate before marking the task done.`
+      };
+    default:
+      return {
+        title: `Codify the ${inc.rule} intent`,
+        toml: null,
+        lesson: inc.reason.slice(0, 160)
+      };
+  }
+}
+function incidentKey(inc) {
+  if (inc.rule === "protected_ports")
+    return `protected_ports:${portsIn(inc.command).join(",")}`;
+  return inc.rule;
+}
+// packages/core/src/memory.ts
+var MEMORY_KINDS = ["handoff", "incident", "gate", "session"];
+function handoffDoc(projectId, id, h, sessionId) {
+  return {
+    kind: "handoff",
+    ref: String(id),
+    projectId,
+    task: h.task,
+    sessionId,
+    ts: h.createdAt,
+    title: `handoff on ${h.task}${h.by ? ` by ${h.by}` : ""}`,
+    text: [
+      `done: ${h.done}`,
+      `remaining: ${h.remaining}`,
+      h.files.length ? `files: ${h.files.join(" ")}` : "",
+      h.verify ? `verify: ${h.verify}` : ""
+    ].filter(Boolean).join(`
+`)
+  };
+}
+function incidentDoc(projectId, seq, p, ts, sessionId) {
+  return {
+    kind: "incident",
+    ref: String(seq),
+    projectId,
+    task: null,
+    sessionId,
+    ts,
+    title: `${p.action ?? "ask"} \xB7 ${p.rule ?? "rule"}`,
+    text: [p.command ? `command: ${p.command}` : "", p.reason ? `reason: ${p.reason}` : ""].filter(Boolean).join(`
+`)
+  };
+}
+function gateDoc(projectId, id, g, sessionId) {
+  return {
+    kind: "gate",
+    ref: String(id),
+    projectId,
+    task: g.task,
+    sessionId,
+    ts: g.createdAt,
+    title: `${g.gate} ${g.verdict} on ${g.task}`,
+    text: [`rubric: ${g.rubric}`, g.evidence ? `evidence: ${g.evidence}` : ""].filter(Boolean).join(`
+`)
+  };
+}
+function sessionDoc(projectId, s) {
+  const text = (s.lastText ?? "").trim();
+  if (!text)
+    return null;
+  return {
+    kind: "session",
+    ref: s.id,
+    projectId,
+    task: s.task ?? null,
+    sessionId: s.id,
+    ts: s.ts,
+    title: s.title?.trim() || `session ${s.id.slice(0, 8)}`,
+    text: text.slice(0, 4000)
+  };
+}
+function parseMemoryQuery(q) {
+  let kind = null;
+  let task = null;
+  const terms = [];
+  const re = /"([^"]+)"|(\S+)/g;
+  for (const m of q.matchAll(re)) {
+    if (m[1] !== undefined) {
+      const phrase = m[1].replace(/"/g, "").trim();
+      if (phrase)
+        terms.push(`"${phrase}"`);
+      continue;
+    }
+    const w = m[2] ?? "";
+    const k = /^kind:(\w+)$/i.exec(w);
+    if (k) {
+      const v = (k[1] ?? "").toLowerCase();
+      if (MEMORY_KINDS.includes(v))
+        kind = v;
+      continue;
+    }
+    const t = /^task:(\S+)$/i.exec(w);
+    if (t) {
+      task = t[1] ?? null;
+      continue;
+    }
+    const clean = w.replace(/"/g, "").replace(/^\*+|\*+$/g, "");
+    if (clean)
+      terms.push(`"${clean}"`);
+  }
+  if (terms.length) {
+    const last = terms[terms.length - 1];
+    if (!/\s/.test(last) && !q.trim().endsWith('"'))
+      terms[terms.length - 1] = `${last}*`;
+  }
+  return { match: terms.join(" "), kind, task };
+}
 // packages/core/src/pricing.ts
 var PRICES = {
   "claude-opus-4": { input: 15, output: 75, cacheWrite: 18.75, cacheWrite1h: 30, cacheRead: 1.5 },
@@ -624,152 +1176,6 @@ 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/rules.ts
-var LIVE_WINDOW_MS = 10 * 60000;
-function otherLiveInSameTree(current, sessions, now, withinMs = LIVE_WINDOW_MS) {
-  if (!current.toplevel)
-    return null;
-  for (const s of sessions) {
-    if (s.id === current.id)
-      continue;
-    if (s.state === "ended")
-      continue;
-    if (s.toplevel !== current.toplevel)
-      continue;
-    if (now - new Date(s.lastSeenAt).getTime() > withinMs)
-      continue;
-    return s;
-  }
-  return null;
-}
-function isBroadStage(cmd) {
-  const c = cmd.trim();
-  if (/\bgit\s+add\s+(-A\b|--all\b|\.(\s|$))/.test(c))
-    return true;
-  if (/\bgit\s+commit\b[^|&;]*\s-[a-zA-Z]*a/.test(c))
-    return true;
-  if (/\bgit\s+add\s*$/.test(c))
-    return true;
-  return false;
-}
-function isDestructiveGit(cmd) {
-  const c = cmd.trim();
-  return /\bgit\s+reset\s+[^|&;]*--hard\b/.test(c) || /\bgit\s+checkout\s+(--\s+)?\.(\s|$)/.test(c) || /\bgit\s+checkout\s+-f\b/.test(c) || /\bgit\s+restore\s+(--\s+)?\.(\s|$)/.test(c) || /\bgit\s+clean\s+[^|&;]*-[a-zA-Z]*f/.test(c) || /\bgit\s+stash\s+(drop|clear)\b/.test(c) || /\bgit\s+branch\s+[^|&;]*-[a-zA-Z]*D/.test(c);
-}
-function isPatternKill(cmd) {
-  return /\bpkill\s+-f\b/.test(cmd) || /\bpgrep\s+-f\b[^|]*\|\s*[^|]*\bkill\b/.test(cmd);
-}
-function killedPorts(cmd) {
-  const ports = new Set;
-  const killy = /\b(kill|fuser\s+-[a-z]*k|kill-port)\b/.test(cmd);
-  if (!killy)
-    return [];
-  for (const m of cmd.matchAll(/(?:-i\s*:?|:)(\d{2,5})\b/g))
-    ports.add(Number(m[1]));
-  for (const m of cmd.matchAll(/\bkill-port\s+(\d{2,5})/g))
-    ports.add(Number(m[1]));
-  for (const m of cmd.matchAll(/\bfuser\s+-[a-z]*k\s+(\d{2,5})/g))
-    ports.add(Number(m[1]));
-  return [...ports];
-}
-var DEFAULT_MODES = {
-  shared_tree: "ask",
-  destructive_git: "ask",
-  pattern_kill: "ask",
-  protected_ports: "ask",
-  no_foreign_worktree: "ask",
-  claim_required_to_write: "off",
-  protected: { ports: [] }
-};
-function guardBash(cmd, current, sessions, now, modes = DEFAULT_MODES) {
-  const other = () => otherLiveInSameTree(current, sessions, now);
-  const hit = (rule, reason) => {
-    const mode = modes[rule];
-    return mode === "off" ? { action: "allow" } : { action: mode, rule, reason };
-  };
-  if (modes.protected_ports !== "off" && modes.protected.ports.length) {
-    const target = killedPorts(cmd).filter((p) => modes.protected.ports.includes(p));
-    if (target.length) {
-      const d = hit("protected_ports", `Port${target.length > 1 ? "s" : ""} ${target.join(", ")} ${target.length > 1 ? "are" : "is"} protected in the Swarm config \u2014 something the owner relies on is listening there. Don't kill it.`);
-      if (d.action !== "allow")
-        return d;
-    }
-  }
-  if (modes.pattern_kill !== "off" && isPatternKill(cmd)) {
-    const d = hit("pattern_kill", "This kills processes by command pattern \u2014 it will match every process on the machine that fits, including other agents' or the owner's. Kill by pid instead.");
-    if (d.action !== "allow")
-      return d;
-  }
-  if (modes.shared_tree !== "off" && isBroadStage(cmd)) {
-    const o = other();
-    if (o) {
-      const d = hit("shared_tree", `Another session (${o.id.slice(0, 8)}) is active in this same checkout. \`git add -A\` / \`git commit -a\` will sweep its uncommitted changes into your commit. Stage explicit paths (\`git add <path>\`), or give each session its own git worktree.`);
-      if (d.action !== "allow")
-        return d;
-    }
-  }
-  if (modes.destructive_git !== "off" && isDestructiveGit(cmd)) {
-    const o = other();
-    if (o) {
-      const d = hit("destructive_git", `Another session (${o.id.slice(0, 8)}) is active in this same checkout and may have uncommitted work. This command can discard it. Coordinate, or use a separate git worktree.`);
-      if (d.action !== "allow")
-        return d;
-    }
-  }
-  return { action: "allow" };
-}
-function norm(p) {
-  const parts = [];
-  for (const seg of p.split("/")) {
-    if (seg === "" || seg === ".")
-      continue;
-    if (seg === "..")
-      parts.pop();
-    else
-      parts.push(seg);
-  }
-  return `/${parts.join("/")}`;
-}
-function isInside(path, dir) {
-  if (!path || !dir)
-    return false;
-  const a = norm(path);
-  const d = norm(dir);
-  return a === d || a.startsWith(`${d}/`);
-}
-function absolutePath(path, cwd) {
-  if (path.startsWith("/"))
-    return path;
-  if (path.startsWith("~/"))
-    return path;
-  return `${cwd.replace(/\/+$/, "")}/${path}`;
-}
-var WRITE_TOOLS = new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
-function guardWrite(target, current, claims, modes = DEFAULT_MODES, kind = "file") {
-  const hit = (rule, reason) => {
-    const mode = modes[rule];
-    return mode === "off" ? { action: "allow" } : { action: mode, rule, reason };
-  };
-  const held = claims.filter((c) => c.worktree);
-  const mine = held.find((c) => isInside(current.cwd, c.worktree)) ?? null;
-  if (modes.no_foreign_worktree !== "off") {
-    const foreign = held.find((c) => isInside(target, c.worktree) && c !== mine);
-    if (foreign) {
-      const d = hit("no_foreign_worktree", kind === "bash" ? `This command runs inside the worktree for "${foreign.task}", held by ${foreign.owner}. Never touch a worktree you don't hold \u2014 work in your own checkout, or claim the task.` : `${target} is inside the worktree for "${foreign.task}", held by ${foreign.owner}. Never touch a worktree you don't hold \u2014 edit your own checkout, or claim the task.`);
-      if (d.action !== "allow")
-        return d;
-    }
-  }
-  if (modes.claim_required_to_write !== "off" && kind === "file" && current.toplevel && !mine) {
-    const inShared = isInside(target, current.toplevel) && !held.some((c) => isInside(target, c.worktree));
-    if (inShared) {
-      const d = hit("claim_required_to_write", `This repo requires a claim before writing to its shared checkout. Run \`swarm claim <task>\` (or the swarm_claim MCP tool) and work in the worktree it creates.`);
-      if (d.action !== "allow")
-        return d;
-    }
-  }
-  return { action: "allow" };
-}
 // 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;
@@ -870,10 +1276,69 @@ function taskBoard(tasks, activeClaims) {
     };
   });
 }
+var TASK_SOURCE_KINDS = ["github", "linear"];
+function taskSourceKind(source) {
+  if (!source)
+    return null;
+  return TASK_SOURCE_KINDS.includes(source) ? source : "markdown";
+}
+var ACTIVE_LABEL_RE = /^(in[- ]progress|wip|doing|active|started)$/i;
+var GH_DEP_RE = /\b(?:depends on|blocked by|after|requires)\b[^\n.]*?((?:#\d+[,\s]*(?:and)?\s*)+)/gi;
+function normalizeGithubIssues(issues) {
+  return issues.filter((i) => Number.isInteger(i.number) && typeof i.title === "string").sort((a, b) => a.number - b.number).map((i) => {
+    const labels = (i.labels ?? []).map((l) => l.name);
+    const closed = (i.state ?? "").toUpperCase() === "CLOSED";
+    const active = !closed && labels.some((l) => ACTIVE_LABEL_RE.test(l));
+    const depends = [];
+    for (const m of (i.body ?? "").matchAll(GH_DEP_RE))
+      for (const n of (m[1] ?? "").matchAll(/#(\d+)/g)) {
+        const id = `GH-${n[1]}`;
+        if (!depends.includes(id))
+          depends.push(id);
+      }
+    const statusText = closed ? "closed" : active ? `in progress${i.assignees?.length ? ` (${i.assignees.map((a) => a.login).join(", ")})` : ""}` : labels.length ? labels.join(", ") : "open";
+    return {
+      id: `GH-${i.number}`,
+      title: i.title,
+      depends,
+      status: closed ? "done" : active ? "active" : "todo",
+      statusText,
+      milestone: i.milestone?.title ?? null
+    };
+  });
+}
+function normalizeLinearIssues(issues) {
+  return issues.filter((i) => typeof i.identifier === "string" && typeof i.title === "string").map((i) => {
+    const type = i.state?.type ?? "unstarted";
+    const done = type === "completed" || type === "canceled";
+    const active = type === "started";
+    const depends = (i.inverseRelations?.nodes ?? []).filter((r) => r.type === "blocks").map((r) => r.issue.identifier);
+    const statusText = `${i.state?.name ?? type}${active && i.assignee ? ` (${i.assignee.name})` : ""}`;
+    return {
+      id: i.identifier,
+      title: i.title,
+      depends: [...new Set(depends)],
+      status: done ? "done" : active ? "active" : "todo",
+      statusText,
+      milestone: i.cycle?.name ?? (i.cycle ? `Cycle ${i.cycle.number}` : i.project?.name ?? null)
+    };
+  });
+}
+function linearIssuesQuery(teamKey, first = 200) {
+  const filter = teamKey ? `, filter: { team: { key: { eq: "${teamKey.replace(/"/g, "")}" } } }` : "";
+  return `{ issues(first: ${first}, orderBy: createdAt${filter}) { nodes {
+    identifier title sortOrder
+    state { name type }
+    assignee { name }
+    project { name }
+    cycle { name number }
+    inverseRelations { nodes { type issue { identifier } } }
+  } } }`;
+}
 // packages/daemon/src/app.ts
 import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4, realpathSync as realpathSync3 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname2, join as join6 } from "path";
+import { dirname as dirname2, join as join7 } from "path";
 import { fileURLToPath } from "url";
 
 // node_modules/.bun/hono@4.13.3/node_modules/hono/dist/compose.js
@@ -2507,7 +2972,7 @@ var EXTRA_BIN_DIRS = [
 function findBin(name) {
   if (!name)
     return null;
-  const onPath = Bun.which(name);
+  const onPath = Bun.which(name, { PATH: process.env.PATH ?? "" });
   if (onPath)
     return onPath;
   for (const d of EXTRA_BIN_DIRS) {
@@ -2578,25 +3043,338 @@ class ForgeService {
       if (out)
         prs = normalizeGitlab(JSON.parse(out), remote.repo);
     }
-    return prs.map((pr) => ({ ...pr, projectId, projectRoot: root }));
+    return prs.map((pr) => ({ ...pr, projectId, projectRoot: root }));
+  }
+  async merge(projectId, number) {
+    const p = this.store.projects().find((x) => x.id === projectId);
+    if (!p)
+      return { ok: false, output: "unknown project" };
+    const remote = this.remote(p.root);
+    if (!remote)
+      return { ok: false, output: "no forge remote" };
+    const cmd = remote.forge === "github" ? ["gh", "pr", "merge", String(number), "--squash"] : ["glab", "mr", "merge", String(number), "--squash", "--yes"];
+    const bin = findBin(cmd[0]);
+    if (!bin)
+      return { ok: false, output: `${cmd[0] ?? "forge CLI"} is not installed` };
+    const proc = Bun.spawn([bin, ...cmd.slice(1)], { cwd: p.root, stdout: "pipe", stderr: "pipe" });
+    const out = await new Response(proc.stdout).text() + await new Response(proc.stderr).text();
+    const ok = await proc.exited === 0;
+    if (ok)
+      this.cache.delete(projectId);
+    return { ok, output: out.trim().slice(0, 800) };
+  }
+}
+
+// packages/daemon/src/runner.ts
+import { appendFileSync, mkdirSync as mkdirSync2, openSync } from "fs";
+import { join as join4 } from "path";
+var PERMISSION_MODES = [
+  "acceptEdits",
+  "auto",
+  "bypassPermissions",
+  "manual",
+  "dontAsk",
+  "plan"
+];
+
+class Runner {
+  store;
+  home;
+  live = new Map;
+  constructor(store, home) {
+    this.store = store;
+    this.home = home;
+  }
+  list(projectId) {
+    return [...this.live.values()].map((x) => x.run).filter((r) => !projectId || r.projectId === projectId);
+  }
+  get(idOrTask) {
+    for (const { run: run2 } of this.live.values())
+      if (run2.id === idOrTask || run2.sessionId === idOrTask || run2.task === idOrTask)
+        return run2;
+    return null;
+  }
+  async start(input) {
+    const bin = findBin("claude");
+    if (!bin)
+      return { ok: false, reason: "claude CLI not found \u2014 install Claude Code first" };
+    const project = this.store.project(input.projectId);
+    if (!project)
+      return { ok: false, reason: "unknown project" };
+    if (!input.prompt.trim())
+      return { ok: false, reason: "prompt is required" };
+    if (input.permissionMode && !PERMISSION_MODES.includes(input.permissionMode))
+      return { ok: false, reason: `permission mode must be one of ${PERMISSION_MODES.join(", ")}` };
+    if (this.get(input.task)?.projectId === input.projectId)
+      return {
+        ok: false,
+        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) {
+      const c = this.store.claim(input.projectId, input.task, input.owner);
+      if (!c.ok)
+        return { ok: false, reason: c.error };
+      worktree = c.worktree;
+    }
+    const sessionId = crypto.randomUUID();
+    const id = sessionId.slice(0, 8);
+    const logDir = join4(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 logFd = openSync(log, "a");
+    const args = [
+      bin,
+      "-p",
+      "--output-format",
+      "stream-json",
+      "--input-format",
+      "stream-json",
+      "--verbose",
+      "--session-id",
+      sessionId,
+      "--permission-prompt-tool",
+      "stdio"
+    ];
+    if (input.model)
+      args.push("--model", input.model);
+    if (input.permissionMode)
+      args.push("--permission-mode", input.permissionMode);
+    if (input.allowedTools?.length)
+      args.push("--allowedTools", ...input.allowedTools);
+    if (input.maxTurns)
+      args.push("--max-turns", String(input.maxTurns));
+    this.store.preregisterSpawnedSession(sessionId, project.id, worktree, input.task);
+    const proc = Bun.spawn(args, {
+      cwd: worktree,
+      env: { ...process.env, SWARM_RUN_ID: id, SWARM_OWNER: input.owner },
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: logFd
+    });
+    const run2 = {
+      id,
+      sessionId,
+      projectId: project.id,
+      task: input.task,
+      worktree,
+      pid: proc.pid,
+      owner: input.owner,
+      model: input.model ?? null,
+      permissionMode: input.permissionMode ?? null,
+      prompt: input.prompt,
+      log,
+      startedAt: new Date().toISOString(),
+      endedAt: null,
+      exitCode: null,
+      result: null,
+      pending: []
+    };
+    this.live.set(id, { run: run2, proc });
+    this.store.registerProcess({
+      pid: proc.pid,
+      projectId: project.id,
+      sessionId,
+      kind: "proc",
+      name: `run:${input.task}`,
+      cwd: worktree,
+      cmd: `claude -p (run ${id})`,
+      owner: input.owner,
+      log
+    });
+    this.store.append({
+      ts: run2.startedAt,
+      type: "session.started",
+      projectId: project.id,
+      sessionId,
+      payload: { kind: "spawned", task: input.task, runId: id, summary: `swarm run ${input.task}` }
+    });
+    this.pump(id, proc);
+    this.send(id, input.prompt);
+    return { ok: true, run: run2 };
+  }
+  async pump(id, proc) {
+    const entry = this.live.get(id);
+    if (!entry || !proc.stdout || typeof proc.stdout === "number")
+      return;
+    const reader = proc.stdout.getReader();
+    const dec = new TextDecoder;
+    let buf = "";
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+          break;
+        buf += dec.decode(value, { stream: true });
+        let nl = buf.indexOf(`
+`);
+        while (nl >= 0) {
+          const line = buf.slice(0, nl);
+          buf = buf.slice(nl + 1);
+          try {
+            appendFileSync(entry.run.log, `${line}
+`);
+          } catch {}
+          this.onLine(entry.run, line);
+          nl = buf.indexOf(`
+`);
+        }
+      }
+    } catch (e) {
+      console.error("swarm run: stdout pump failed:", e.message);
+    }
+    const code = await proc.exited;
+    entry.run.endedAt = new Date().toISOString();
+    entry.run.exitCode = code;
+    this.store.append({
+      ts: entry.run.endedAt,
+      type: "run.result",
+      projectId: entry.run.projectId,
+      sessionId: entry.run.sessionId,
+      payload: {
+        runId: id,
+        task: entry.run.task,
+        exitCode: code,
+        final: true,
+        ...entry.run.result ?? {},
+        summary: `run ${entry.run.task} exited ${code}`
+      }
+    });
+    this.store.endSpawnedSession(entry.run.sessionId);
+    this.live.delete(id);
+  }
+  onLine(run2, line) {
+    if (!line.startsWith("{"))
+      return;
+    let j;
+    try {
+      j = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (j.type === "control_request" && j.request?.subtype === "can_use_tool") {
+      this.onPermissionRequest(run2, j.request_id, j.request.tool_name ?? "", j.request.input ?? {});
+      return;
+    }
+    if (j.type !== "result")
+      return;
+    run2.result = {
+      costUsd: Number(j.total_cost_usd ?? 0),
+      turns: Number(j.num_turns ?? 0),
+      isError: Boolean(j.is_error),
+      at: new Date().toISOString()
+    };
+    this.store.append({
+      ts: run2.result.at,
+      type: "run.result",
+      projectId: run2.projectId,
+      sessionId: run2.sessionId,
+      payload: {
+        runId: run2.id,
+        task: run2.task,
+        ...run2.result,
+        summary: `turn done \xB7 $${run2.result.costUsd.toFixed(2)} \xB7 ${run2.result.turns} turns${run2.result.isError ? " \xB7 error" : ""}`
+      }
+    });
+  }
+  onPermissionRequest(run2, requestId, tool, input) {
+    const { decision, display } = this.store.evaluateTool(tool, input, run2.sessionId, run2.worktree, true);
+    if (decision.action === "deny") {
+      this.answerPermission(run2.id, requestId, false, `[swarm] ${decision.reason}`);
+      return;
+    }
+    if (decision.action === "allow") {
+      this.answerPermission(run2.id, requestId, true);
+      return;
+    }
+    run2.pending.push({
+      requestId,
+      tool,
+      input,
+      display,
+      reason: decision.reason,
+      askedAt: new Date().toISOString()
+    });
+    this.store.append({
+      ts: new Date().toISOString(),
+      type: "permission.requested",
+      projectId: run2.projectId,
+      sessionId: run2.sessionId,
+      payload: {
+        runId: run2.id,
+        requestId,
+        tool,
+        display: display.slice(0, 300),
+        reason: decision.reason,
+        summary: `permission: ${tool} \u2014 waiting`
+      }
+    });
+    this.store.touch();
+  }
+  answerPermission(runId, requestId, allow, message) {
+    const entry = this.live.get(runId);
+    if (!entry)
+      return { ok: false, reason: "no live run" };
+    const stdin = entry.proc.stdin;
+    if (!stdin || typeof stdin === "number")
+      return { ok: false, reason: "stdin not available" };
+    const pend = entry.run.pending.find((p) => p.requestId === requestId);
+    const response = allow ? { behavior: "allow", updatedInput: pend?.input ?? {} } : { behavior: "deny", message: message ?? "Denied from the Swarm dashboard" };
+    stdin.write(`${JSON.stringify({ type: "control_response", response: { subtype: "success", request_id: requestId, response } })}
+`);
+    stdin.flush();
+    entry.run.pending = entry.run.pending.filter((p) => p.requestId !== requestId);
+    if (pend)
+      this.store.append({
+        ts: new Date().toISOString(),
+        type: "permission.resolved",
+        projectId: entry.run.projectId,
+        sessionId: entry.run.sessionId,
+        payload: {
+          runId,
+          requestId,
+          tool: pend.tool,
+          allow,
+          summary: `permission: ${pend.tool} \u2014 ${allow ? "allowed" : "denied"}`
+        }
+      });
+    this.store.touch();
+    return { ok: true };
   }
-  async merge(projectId, number) {
-    const p = this.store.projects().find((x) => x.id === projectId);
-    if (!p)
-      return { ok: false, output: "unknown project" };
-    const remote = this.remote(p.root);
-    if (!remote)
-      return { ok: false, output: "no forge remote" };
-    const cmd = remote.forge === "github" ? ["gh", "pr", "merge", String(number), "--squash"] : ["glab", "mr", "merge", String(number), "--squash", "--yes"];
-    const bin = findBin(cmd[0]);
-    if (!bin)
-      return { ok: false, output: `${cmd[0] ?? "forge CLI"} is not installed` };
-    const proc = Bun.spawn([bin, ...cmd.slice(1)], { cwd: p.root, stdout: "pipe", stderr: "pipe" });
-    const out = await new Response(proc.stdout).text() + await new Response(proc.stderr).text();
-    const ok = await proc.exited === 0;
-    if (ok)
-      this.cache.delete(projectId);
-    return { ok, output: out.trim().slice(0, 800) };
+  send(id, text) {
+    const entry = this.live.get(id) ?? [...this.live.values()].find((x) => x.run.task === id || x.run.sessionId === id);
+    if (!entry)
+      return { ok: false, reason: "no live run" };
+    const stdin = entry.proc.stdin;
+    if (!stdin || typeof stdin === "number")
+      return { ok: false, reason: "stdin not available" };
+    stdin.write(`${JSON.stringify({ type: "user", message: { role: "user", content: text } })}
+`);
+    stdin.flush();
+    this.store.append({
+      ts: new Date().toISOString(),
+      type: "prompt.submitted",
+      projectId: entry.run.projectId,
+      sessionId: entry.run.sessionId,
+      payload: { prompt: text.slice(0, 400), via: "swarm run send", summary: text.slice(0, 120) }
+    });
+    return { ok: true };
+  }
+  async stop(id) {
+    const run2 = this.get(id);
+    if (!run2)
+      return { ok: false, reason: "no live run" };
+    const entry = this.live.get(run2.id);
+    try {
+      const stdin = entry?.proc.stdin;
+      if (stdin && typeof stdin !== "number")
+        stdin.end();
+    } catch {}
+    return this.store.stopProcess(run2.pid, run2.projectId, 5000);
+  }
+  async stopAll() {
+    await Promise.all([...this.live.keys()].map((id) => this.stop(id)));
   }
 }
 
@@ -2605,8 +3383,8 @@ import { Database } from "bun:sqlite";
 import {
   closeSync,
   existsSync as existsSync4,
-  mkdirSync as mkdirSync2,
-  openSync,
+  mkdirSync as mkdirSync3,
+  openSync as openSync2,
   readdirSync,
   readFileSync as readFileSync3,
   readSync,
@@ -2616,11 +3394,11 @@ import {
   writeFileSync as writeFileSync2
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename, dirname, join as join5 } from "path";
+import { basename, dirname, join as join6 } from "path";
 
 // packages/daemon/src/git.ts
 import { realpathSync } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 function git(cwd, args) {
   try {
     const r = Bun.spawnSync(["git", "-C", cwd, ...args], { stdout: "pipe", stderr: "ignore" });
@@ -2634,7 +3412,7 @@ function gitCommonDir(cwd) {
   if (!out)
     return null;
   try {
-    return realpathSync(out.startsWith("/") ? out : join4(cwd, out));
+    return realpathSync(out.startsWith("/") ? out : join5(cwd, out));
   } catch {
     return null;
   }
@@ -2757,6 +3535,83 @@ function heldWork(path) {
   return { dirty, unpushed };
 }
 
+// packages/daemon/src/task-sources.ts
+class TaskSources {
+  env;
+  cache = new Map;
+  inflight = new Set;
+  constructor(env = process.env) {
+    this.env = env;
+  }
+  get(projectId, kind, root, opts, ttlMs = 60000) {
+    const hit = this.cache.get(projectId);
+    if (!hit || Date.now() - hit.at >= ttlMs)
+      this.refresh(projectId, kind, root, opts);
+    return hit ?? { at: 0, tasks: [], error: null };
+  }
+  async refresh(projectId, kind, root, opts) {
+    if (this.inflight.has(projectId))
+      return this.cache.get(projectId) ?? { at: 0, tasks: [], error: null };
+    this.inflight.add(projectId);
+    const prev = this.cache.get(projectId);
+    let entry;
+    try {
+      const tasks2 = kind === "github" ? await this.github(root, opts.labels) : await this.linear(opts.team);
+      entry = { at: Date.now(), tasks: tasks2, error: null };
+    } catch (e) {
+      entry = { at: Date.now(), tasks: prev?.tasks ?? [], error: e.message };
+    } finally {
+      this.inflight.delete(projectId);
+    }
+    this.cache.set(projectId, entry);
+    return entry;
+  }
+  async github(root, labels) {
+    const bin = findBin("gh");
+    if (!bin)
+      throw new Error("gh not installed \u2014 GitHub Issues need the gh CLI (brew install gh)");
+    const args = [
+      bin,
+      "issue",
+      "list",
+      "--state",
+      "all",
+      "--limit",
+      "300",
+      "--json",
+      "number,title,state,labels,body,assignees,milestone"
+    ];
+    for (const l of labels)
+      args.push("--label", l);
+    const proc = Bun.spawn(args, { cwd: root, stdout: "pipe", stderr: "pipe" });
+    const [out, err, code] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited
+    ]);
+    if (code !== 0)
+      throw new Error(`gh issue list failed: ${err.trim().split(`
+`)[0] ?? code}`);
+    return normalizeGithubIssues(JSON.parse(out));
+  }
+  async linear(team) {
+    const key = this.env.LINEAR_API_KEY;
+    if (!key)
+      throw new Error("LINEAR_API_KEY not set \u2014 export it in the environment swarmd starts from (never stored)");
+    const r = await fetch("https://api.linear.app/graphql", {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: key },
+      body: JSON.stringify({ query: linearIssuesQuery(team) })
+    });
+    if (!r.ok)
+      throw new Error(`Linear API ${r.status}`);
+    const j = await r.json();
+    if (j.errors?.length)
+      throw new Error(`Linear: ${j.errors[0]?.message}`);
+    return normalizeLinearIssues(j.data?.issues?.nodes ?? []);
+  }
+}
+
 // packages/daemon/src/store.ts
 var SCHEMA = `
 CREATE TABLE IF NOT EXISTS projects (id TEXT PRIMARY KEY, root TEXT, common_dir TEXT, name TEXT, discovered INTEGER, created_at TEXT);
@@ -2783,12 +3638,26 @@ CREATE TABLE IF NOT EXISTS resources (
   PRIMARY KEY (name, project_id)
 );
 CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);
+CREATE VIRTUAL TABLE IF NOT EXISTS memory USING fts5(
+  kind UNINDEXED, ref UNINDEXED, project_id UNINDEXED, task, session_id UNINDEXED, ts UNINDEXED,
+  title, text, tokenize = 'unicode61 remove_diacritics 2'
+);
 CREATE TABLE IF NOT EXISTS incident_acks (seq INTEGER PRIMARY KEY, acked_at TEXT);
 CREATE TABLE IF NOT EXISTS processes (
   pid INTEGER, start_time TEXT, project_id TEXT, session_id TEXT, kind TEXT, name TEXT, port INTEGER,
   cwd TEXT, cmd TEXT, owner TEXT, log TEXT, started_at TEXT, ended_at TEXT
 );
 CREATE INDEX IF NOT EXISTS processes_live ON processes(ended_at, project_id);
+CREATE TABLE IF NOT EXISTS gates (
+  id INTEGER PRIMARY KEY AUTOINCREMENT, project_id TEXT, task TEXT, gate TEXT, verdict TEXT,
+  rubric TEXT, evidence TEXT, session_id TEXT, created_at TEXT
+);
+CREATE INDEX IF NOT EXISTS gates_task ON gates(project_id, task, created_at);
+CREATE TABLE IF NOT EXISTS handoffs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT, project_id TEXT, task TEXT, done TEXT, remaining TEXT,
+  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 claims (
   project_id TEXT, task TEXT, owner TEXT, worktree TEXT, branch TEXT,
   acquired_at TEXT, expires_at TEXT, released_at TEXT, state TEXT,
@@ -2809,18 +3678,19 @@ class Store {
   gen = 0;
   memo = new Map;
   constructor(home = swarmHome()) {
-    mkdirSync2(home, { recursive: true });
+    mkdirSync3(home, { recursive: true });
     this.home = home;
-    this.db = new Database(join5(home, "swarm.db"));
+    this.db = new Database(join6(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(join5(home, "projects.json"));
+    this.migrateProjectsJson(join6(home, "projects.json"));
     this.reconcileMovedProjects();
     this.slimExistingEvents();
     this.retypeNotificationIncidents();
+    this.backfillMemory();
   }
   retypeNotificationIncidents() {
     if (this.meta("notifications_retyped") === "1")
@@ -2919,36 +3789,417 @@ class Store {
     return v;
   }
   rulesCache = new Map;
+  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)
+         VALUES (?, ?, 'spawned', ?, ?, ?, ?, 'session.started', 'active', ?)
+         ON CONFLICT(id) DO UPDATE SET kind = 'spawned', project_id = excluded.project_id, cwd = excluded.cwd`).run(id, projectId, cwd, now, now, `swarm run ${task}`, `run: ${task}`);
+    this.touch();
+  }
+  endSpawnedSession(id) {
+    const now = new Date().toISOString();
+    this.db.query("UPDATE sessions SET state = 'ended', ended_at = COALESCE(ended_at, ?), last_seen_at = ? WHERE id = ?").run(now, now, id);
+    this.touch();
+  }
+  recordHandoff(projectId, h) {
+    if (!this.project(projectId))
+      return { ok: false, reason: "unknown project" };
+    const v = validateHandoff(h);
+    if (!v.ok)
+      return v;
+    const handoff = {
+      task: h.task.trim(),
+      done: h.done.trim(),
+      remaining: h.remaining.trim(),
+      files: (h.files ?? []).map((f) => f.trim()).filter(Boolean).slice(0, 50),
+      verify: h.verify?.trim() || null,
+      by: h.by?.trim() || null,
+      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);
+    this.remember(handoffDoc(projectId, Number(ins.lastInsertRowid), handoff, sessionId));
+    this.append({
+      ts: handoff.createdAt,
+      type: "handoff.recorded",
+      projectId,
+      sessionId,
+      payload: { task: handoff.task, by: handoff.by, summary: `handoff on ${handoff.task}` }
+    });
+    this.touch();
+    return { ok: true, handoff };
+  }
+  latestHandoff(projectId, task) {
+    const r = this.db.query("SELECT * FROM handoffs WHERE project_id = ? AND task = ? ORDER BY id DESC LIMIT 1").get(projectId, task);
+    if (!r)
+      return null;
+    return {
+      task: r.task,
+      done: r.done,
+      remaining: r.remaining,
+      files: JSON.parse(r.files || "[]"),
+      verify: r.verify ?? null,
+      by: r.by ?? null,
+      createdAt: r.created_at
+    };
+  }
+  handoffs(projectId, limit = 50) {
+    return this.db.query("SELECT * FROM handoffs WHERE project_id = ? ORDER BY id DESC LIMIT ?").all(projectId, limit).map((r) => ({
+      task: r.task,
+      done: r.done,
+      remaining: r.remaining,
+      files: JSON.parse(r.files || "[]"),
+      verify: r.verify ?? null,
+      by: r.by ?? null,
+      createdAt: r.created_at,
+      sessionId: r.session_id ?? null
+    }));
+  }
+  autoHandoff(sessionId, cwd) {
+    const held = this.heldClaimsWithWorktree().find((c) => isInside(cwd, c.worktree));
+    if (!held)
+      return null;
+    const manual = this.db.query("SELECT id, by FROM handoffs WHERE project_id = ? AND task = ? AND session_id = ?").all(held.projectId, held.task, sessionId);
+    if (manual.some((h2) => !isAutoHandoff(h2)))
+      return null;
+    const row = this.db.query("SELECT last_text FROM sessions WHERE id = ?").get(sessionId);
+    const h = deriveHandoff(held.task, this.sessionEvents(sessionId, 2000), { lastText: row?.last_text ?? null, sessionId });
+    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);
+    this.remember(handoffDoc(held.projectId, Number(ins.lastInsertRowid), h, sessionId));
+    this.touch();
+    return h;
+  }
+  resumePlan(sessionId) {
+    const s = this.db.query("SELECT project_id, cwd, last_text FROM sessions WHERE id = ?").get(sessionId);
+    if (!s)
+      return { ok: false, reason: "unknown session" };
+    const byHandoff = this.db.query("SELECT project_id, task FROM handoffs WHERE session_id = ? ORDER BY id DESC LIMIT 1").get(sessionId);
+    const claim = this.claimRows(s.project_id).find((c) => c.worktree && s.cwd && isInside(s.cwd, c.worktree));
+    const task = byHandoff?.task ?? claim?.task;
+    const projectId = byHandoff?.project_id ?? s.project_id;
+    if (!task)
+      return { ok: false, reason: "this session was not working on a claimed task" };
+    const ev = this.sessionEvents(sessionId, 2000);
+    let handoff = this.latestHandoff(projectId, task);
+    if (!handoff)
+      handoff = deriveHandoff(task, ev, {
+        lastText: s.last_text,
+        sessionId
+      });
+    if (!handoff)
+      return { ok: false, reason: "nothing to resume \u2014 the session left no trail" };
+    const tail = ev.filter((e) => e.type === "tool.requested" || e.type === "prompt.submitted").slice(-12).map((e) => (e.payload.summary ?? e.type).slice(0, 160));
+    const owner = claim && claim.state === "held" ? claim.owner : null;
+    return { ok: true, projectId, task, owner, prompt: formatResumePrompt(handoff, tail), handoff };
+  }
+  remember(doc) {
+    if (!doc)
+      return;
+    this.db.query("DELETE FROM memory WHERE kind = ? AND ref = ?").run(doc.kind, doc.ref);
+    this.db.query("INSERT INTO memory (kind, ref, project_id, task, session_id, ts, title, text) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(doc.kind, doc.ref, doc.projectId, doc.task, doc.sessionId, doc.ts, doc.title, doc.text);
+  }
+  rememberSession(sessionId) {
+    const r = this.db.query("SELECT id, project_id, title, last_text, last_seen_at, cwd FROM sessions WHERE id = ?").get(sessionId);
+    if (!r)
+      return;
+    const held = r.cwd ? this.heldClaimsWithWorktree().find((c) => isInside(r.cwd, c.worktree)) : null;
+    this.remember(sessionDoc(r.project_id, {
+      id: r.id,
+      title: r.title,
+      lastText: r.last_text,
+      ts: r.last_seen_at,
+      task: held?.task ?? null
+    }));
+  }
+  backfillMemory() {
+    if (this.db.query("SELECT value FROM meta WHERE key = 'memory_backfilled'").get())
+      return;
+    const tx = this.db.transaction(() => {
+      for (const r of this.db.query("SELECT * FROM handoffs").all())
+        this.remember(handoffDoc(r.project_id, r.id, {
+          task: r.task,
+          done: r.done,
+          remaining: r.remaining,
+          files: JSON.parse(r.files || "[]"),
+          verify: r.verify ?? null,
+          by: r.by ?? null,
+          createdAt: r.created_at
+        }, r.session_id ?? null));
+      for (const r of this.db.query("SELECT * FROM gates").all())
+        this.remember(gateDoc(r.project_id, r.id, this.rowToGate(r), r.session_id ?? null));
+      for (const r of this.db.query("SELECT seq, ts, project_id, session_id, payload FROM events WHERE type = 'incident.opened'").all()) {
+        let p = {};
+        try {
+          p = JSON.parse(r.payload || "{}");
+        } catch {}
+        this.remember(incidentDoc(r.project_id, r.seq, p, r.ts, r.session_id ?? null));
+      }
+      for (const r of this.db.query("SELECT id, project_id, title, last_text, last_seen_at FROM sessions WHERE last_text IS NOT NULL AND last_text != ''").all())
+        this.remember(sessionDoc(r.project_id, {
+          id: r.id,
+          title: r.title ?? null,
+          lastText: r.last_text,
+          ts: r.last_seen_at
+        }));
+      this.db.query("INSERT OR REPLACE INTO meta (key, value) VALUES ('memory_backfilled', ?)").run(new Date().toISOString());
+    });
+    tx();
+  }
+  memorySearch(q, opts = {}) {
+    const parsed = parseMemoryQuery(q);
+    if (!parsed.match)
+      return [];
+    const kind = opts.kind ?? parsed.kind;
+    const task = opts.task ?? parsed.task;
+    const where = ["memory MATCH ?"];
+    const args = [parsed.match];
+    if (opts.projectId) {
+      where.push("project_id = ?");
+      args.push(opts.projectId);
+    }
+    if (kind) {
+      where.push("kind = ?");
+      args.push(kind);
+    }
+    if (task) {
+      where.push("task = ?");
+      args.push(task);
+    }
+    args.push(Math.min(200, Math.max(1, opts.limit ?? 30)));
+    const rows = this.db.query(`SELECT kind, ref, project_id, task, session_id, ts, title, text,
+                bm25(memory, 0, 0, 0, 2.0, 0, 0, 4.0, 1.0) AS score,
+                snippet(memory, 7, '\x01', '\x02', ' \u2026 ', 24) AS snippet
+           FROM memory WHERE ${where.join(" AND ")} ORDER BY score LIMIT ?`).all(...args);
+    return rows.map((r) => ({
+      kind: r.kind,
+      ref: r.ref,
+      projectId: r.project_id,
+      task: r.task ?? null,
+      sessionId: r.session_id ?? null,
+      ts: r.ts,
+      title: r.title,
+      text: r.text,
+      score: -r.score,
+      snippet: r.snippet
+    }));
+  }
+  sessionContext(cwd) {
+    if (!cwd || !existsSync4(cwd))
+      return null;
+    const toplevel = this.toplevel(cwd);
+    const project = this.resolveProject(cwd);
+    const lines = [];
+    const held = this.heldClaimsWithWorktree().find((c) => isInside(cwd, c.worktree));
+    if (held) {
+      const left = Math.max(0, Math.round((new Date(held.expiresAt).getTime() - Date.now()) / 60000));
+      lines.push(`[swarm] you hold ${held.task} (${left}m left, renews while you work) in ${held.worktree}`);
+      const h = this.latestHandoff(held.projectId, held.task);
+      if (h)
+        lines.push(formatHandoff(h));
+      const required = this.requiredGates(held.projectId);
+      if (required.length) {
+        const st = gateStatus(this.gateRuns(held.projectId, held.task), required);
+        lines.push(`[swarm] gates on ${held.task}: ${st.map((g) => `${g.gate} ${g.verdict ?? "not run"}`).join(", ")} \u2014 record with swarm_gate_record (rubric required)`);
+      }
+    } else if (project) {
+      const active = this.claimRows(project.id).filter((c) => isActive(c, Date.now()));
+      if (active.length)
+        lines.push(`[swarm] ${project.name}: held by others \u2014 ${active.map((c) => `${c.task} (${c.owner})`).join(", ")}. Claim a task (swarm_claim) to get your own worktree.`);
+    }
+    const res = this.resources(project?.id).filter((r) => !r.released);
+    if (res.length)
+      lines.push(`[swarm] resources held: ${res.map((r) => `${r.name}${r.port ? `:${r.port}` : ""} (${r.owner})`).join(", ")} \u2014 their ports are protected; don't kill them`);
+    const modes = this.rulesFor(toplevel);
+    const on = [
+      "shared_tree",
+      "destructive_git",
+      "pattern_kill",
+      "protected_ports",
+      "no_foreign_worktree",
+      "claim_required_to_write"
+    ].filter((k) => modes[k] !== "off").map((k) => `${k}=${modes[k]}`);
+    if (on.length && (lines.length || on.some((x) => x.endsWith("=deny"))))
+      lines.push(`[swarm] rules: ${on.join(" ")}`);
+    return lines.length ? lines.join(`
+`) : null;
+  }
+  rowToGate(r) {
+    return {
+      id: r.id,
+      projectId: r.project_id,
+      task: r.task,
+      gate: r.gate,
+      verdict: r.verdict,
+      rubric: r.rubric,
+      evidence: r.evidence ?? null,
+      sessionId: r.session_id ?? null,
+      createdAt: r.created_at
+    };
+  }
+  gateRuns(projectId, task, limit = 200) {
+    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);
+  }
+  requiredGates(projectId) {
+    const p = this.project(projectId);
+    return p ? loadConfig({ repoRoot: p.root, home: this.home }).gates.required : [];
+  }
+  recordGate(projectId, input) {
+    if (!this.project(projectId))
+      return { ok: false, reason: "unknown project" };
+    const v = validateGateRun(input);
+    if (!v.ok)
+      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 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({
+      ts: createdAt,
+      type: "gate.recorded",
+      projectId,
+      sessionId,
+      payload: {
+        task: run2.task,
+        gate: run2.gate,
+        verdict: run2.verdict,
+        summary: `gate ${run2.gate} ${run2.verdict} on ${run2.task}`
+      }
+    });
+    if (run2.verdict === "fail")
+      this.append({
+        ts: createdAt,
+        type: "incident.opened",
+        projectId,
+        sessionId,
+        payload: {
+          rule: "gate_failed",
+          action: "failed",
+          command: `${run2.task} \xB7 ${run2.gate}`,
+          reason: `${run2.rubric}${run2.evidence ? ` \u2014 ${run2.evidence.slice(0, 200)}` : ""}`
+        }
+      });
+    this.touch();
+    return { ok: true, run: run2 };
+  }
   taskCache = new Map;
+  taskSources = new TaskSources;
   tasks(projectId) {
     const p = this.project(projectId);
     if (!p)
       return null;
-    const source = loadConfig({ repoRoot: p.root }).tasks.source;
+    const cfg = loadConfig({ repoRoot: p.root, home: this.home }).tasks;
+    const source = cfg.source;
     if (!source)
       return null;
-    const path = join5(p.root, source);
-    if (!existsSync4(path))
-      return { source, tasks: [] };
-    const mtime = statSync(path).mtimeMs;
-    let hit = this.taskCache.get(projectId);
-    if (!hit || hit.path !== path || hit.mtime !== mtime) {
-      hit = { path, mtime, tasks: parseMarkdownTasks(readFileSync3(path, "utf8")) };
-      this.taskCache.set(projectId, hit);
+    let hit;
+    let error = null;
+    const kind = taskSourceKind(source);
+    if (kind === "github" || kind === "linear") {
+      const e = this.taskSources.get(projectId, kind, p.root, {
+        labels: cfg.labels,
+        team: cfg.team
+      });
+      hit = { tasks: e.tasks };
+      error = e.error;
+    } else {
+      const path = join6(p.root, source);
+      if (!existsSync4(path))
+        return { source, required: this.requiredGates(projectId), tasks: [] };
+      const mtime = statSync(path).mtimeMs;
+      let md = this.taskCache.get(projectId);
+      if (!md || md.path !== path || md.mtime !== mtime) {
+        md = { path, mtime, tasks: parseMarkdownTasks(readFileSync3(path, "utf8")) };
+        this.taskCache.set(projectId, md);
+      }
+      hit = md;
     }
     const now = Date.now();
     const active = this.claimRows(projectId).filter((c) => isActive(c, now));
-    return { source, tasks: taskBoard(hit.tasks, active) };
+    const required = this.requiredGates(projectId);
+    const runs = this.gateRuns(projectId, undefined, 2000);
+    const byTask = new Map;
+    for (const r of runs)
+      byTask.set(r.task, [...byTask.get(r.task) ?? [], r]);
+    const board = taskBoard(hit.tasks, active).map((t) => {
+      const tr = byTask.get(t.id) ?? [];
+      return {
+        ...t,
+        gates: gateStatus(tr, required).map((g) => ({
+          gate: g.gate,
+          verdict: g.verdict,
+          fails: g.fails,
+          runs: g.runs
+        })),
+        gated: gatesSatisfied(tr, required)
+      };
+    });
+    return { source, required, tasks: board, error };
   }
   rulesFor(repoRoot) {
     const key = repoRoot ?? "";
     const hit = this.rulesCache.get(key);
     if (hit && Date.now() - hit.at < 30000)
       return hit.rules;
-    const rules2 = loadConfig({ repoRoot }).rules;
+    const rules2 = loadConfig({ repoRoot, home: this.home }).rules;
     this.rulesCache.set(key, { at: Date.now(), rules: rules2 });
     return rules2;
   }
+  evaluateTool(tool, input, sessionId, cwd, recordIncident = true) {
+    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) };
+    const modes = this.rulesFor(current.toplevel);
+    if (isWrite && (modes.no_foreign_worktree !== "off" || modes.claim_required_to_write !== "off")) {
+      const target = absolutePath(input.file_path, cwd);
+      const w = guardWrite(target, current, this.heldWorktrees(), modes, "file");
+      if (w.action !== "allow") {
+        if (recordIncident)
+          this.openIncident(w, cwd, sessionId, `${tool} ${target}`);
+        return { decision: w, display: `${tool} ${target}` };
+      }
+    }
+    if (cmd) {
+      if (modes.no_foreign_worktree !== "off" || modes.claim_required_to_write !== "off") {
+        const w = guardWrite(cwd, current, this.heldWorktrees(), modes, "bash");
+        if (w.action !== "allow") {
+          if (recordIncident)
+            this.openIncident(w, cwd, sessionId, cmd);
+          return { decision: w, display: cmd };
+        }
+      }
+      const d = guardBash(cmd, current, this.liveSessions(), Date.now(), {
+        ...modes,
+        protected: { ports: [...new Set([...modes.protected.ports, ...this.heldPorts()])] }
+      });
+      if (d.action !== "allow" && recordIncident)
+        this.openIncident(d, cwd, sessionId, cmd);
+      return { decision: d, display: cmd };
+    }
+    return {
+      decision: { action: "allow" },
+      display: isWrite ? `${tool} ${input.file_path}` : tool
+    };
+  }
+  liveSessions() {
+    const rows = this.db.query("SELECT id, cwd, last_seen_at, state FROM sessions WHERE state != 'ended' AND last_seen_at > ?").all(new Date(Date.now() - LIVE_WINDOW_MS - 1e4).toISOString());
+    return rows.map((r) => ({
+      id: r.id,
+      toplevel: this.toplevel(r.cwd),
+      lastSeenAt: r.last_seen_at,
+      state: r.state
+    }));
+  }
   guardHook(raw2) {
     const tool = typeof raw2.tool_name === "string" ? raw2.tool_name : "";
     const input = raw2.tool_input ?? {};
@@ -2995,6 +4246,51 @@ class Store {
     return d;
   }
   heldWorktreesCache = null;
+  dryRun(projectId, overrides = {}, limit = 5000) {
+    const project = this.project(projectId);
+    const modes = { ...this.rulesFor(project?.root ?? null), ...overrides };
+    const rows = this.db.query(`SELECT * FROM (SELECT seq, ts, type, session_id, payload FROM events
+           WHERE project_id = ? AND type IN ('tool.requested', 'tool.completed')
+           ORDER BY seq DESC LIMIT ?) ORDER BY seq`).all(projectId, limit);
+    const calls = [];
+    const pending = new Map;
+    for (const r of rows) {
+      let p;
+      try {
+        p = JSON.parse(r.payload);
+      } catch {
+        continue;
+      }
+      if (!p.tool || !r.session_id)
+        continue;
+      const key = `${r.session_id} ${p.summary ?? p.tool}`;
+      if (r.type === "tool.requested") {
+        const input = p.toolInput ?? {};
+        const call = {
+          ts: r.ts,
+          sessionId: r.session_id,
+          cwd: p.cwd ?? "",
+          tool: p.tool,
+          command: typeof input.command === "string" ? input.command : undefined,
+          filePath: typeof input.file_path === "string" ? input.file_path : undefined,
+          completed: false
+        };
+        calls.push(call);
+        pending.set(key, call);
+      } else {
+        const c = pending.get(key);
+        if (c) {
+          c.completed = true;
+          pending.delete(key);
+        }
+      }
+    }
+    const report = dryRunRules(calls, modes, {
+      toplevel: (cwd) => cwd && existsSync4(cwd) ? this.toplevel(cwd) : null,
+      claims: this.heldWorktrees()
+    });
+    return { ...report, modes };
+  }
   heldWorktrees() {
     if (this.heldWorktreesCache && Date.now() - this.heldWorktreesCache.at < 2000)
       return this.heldWorktreesCache.v;
@@ -3005,7 +4301,7 @@ class Store {
   loadPricing() {
     this.prices = { ...PRICES };
     for (const f of ["pricing.litellm.json", "pricing.json"]) {
-      const p = join5(this.home, f);
+      const p = join6(this.home, f);
       if (!existsSync4(p))
         continue;
       try {
@@ -3021,7 +4317,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(join5(this.home, "pricing.litellm.json"), JSON.stringify(slim, null, 1));
+    writeFileSync2(join6(this.home, "pricing.litellm.json"), JSON.stringify(slim, null, 1));
     this.loadPricing();
     this.reprice();
   }
@@ -3143,6 +4439,8 @@ class Store {
     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) };
+    if (stored.type === "incident.opened")
+      this.remember(incidentDoc(stored.projectId, stored.seq, stored.payload, stored.ts, stored.sessionId));
     this.projectSession(stored);
     this.touch();
     const wire = toWire(stored);
@@ -3160,9 +4458,16 @@ class Store {
     return n;
   }
   ingestHook(event, raw2) {
+    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 e = this.append(normalizeHook(event, raw2, project?.id ?? "p_unknown"));
+    if ((event === "Stop" || event === "SessionEnd") && e.sessionId) {
+      if (existsSync4(cwd))
+        this.autoHandoff(e.sessionId, cwd);
+      this.rememberSession(e.sessionId);
+    }
     if (e.sessionId && typeof raw2.transcript_path === "string") {
       this.db.query("UPDATE sessions SET transcript_path = ? WHERE id = ? AND transcript_path IS NULL").run(raw2.transcript_path, e.sessionId);
       const last = this.lastTail.get(e.sessionId) ?? 0;
@@ -3173,8 +4478,24 @@ class Store {
     }
     return e;
   }
+  static LEDGER_EVENTS = new Set([
+    "process.started",
+    "process.exited",
+    "resource.acquired",
+    "resource.released",
+    "resource.reaped",
+    "claim.acquired",
+    "claim.renewed",
+    "claim.released",
+    "claim.orphaned",
+    "gate.recorded",
+    "handoff.recorded",
+    "incident.opened",
+    "incident.acked",
+    "run.result"
+  ]);
   projectSession(e) {
-    if (!e.sessionId)
+    if (!e.sessionId || Store.LEDGER_EVENTS.has(e.type))
       return;
     const p = e.payload;
     const row = this.db.query("SELECT id, tool_counts FROM sessions WHERE id = ?").get(e.sessionId);
@@ -3198,7 +4519,7 @@ class Store {
       const size = statSync(path).size;
       if (size <= offset)
         return null;
-      const fd = openSync(path, "r");
+      const fd = openSync2(path, "r");
       const buf = Buffer.alloc(size - offset);
       readSync(fd, buf, 0, buf.length, offset);
       closeSync(fd);
@@ -3239,6 +4560,10 @@ class Store {
     const lastText = [...d.turns].reverse().find((t) => t.text && !t.sidechain)?.text ?? null;
     const lastModel = [...d.turns].reverse().find((t) => !t.sidechain)?.model ?? null;
     this.db.query("UPDATE sessions SET title = COALESCE(?, title), model = COALESCE(?, model), version = COALESCE(?, version), last_text = COALESCE(?, last_text), branch = COALESCE(branch, ?), last_seen_at = MAX(COALESCE(last_seen_at, ''), ?) WHERE id = ?").run(d.title, agentId ? null : lastModel, d.version, agentId ? null : lastText, d.branch, new Date().toISOString(), sessionId);
+    if (d.turns.length) {
+      const cwdRow = this.db.query("SELECT cwd FROM sessions WHERE id = ?").get(sessionId);
+      this.autoRenewFor(sessionId, cwdRow?.cwd);
+    }
     this.db.query("INSERT INTO tails (path, session_id, agent_id, offset) VALUES (?, ?, ?, ?) ON CONFLICT(path) DO UPDATE SET offset = excluded.offset").run(path, sessionId, agentId, r.next);
     return d.turns.length;
   }
@@ -3247,9 +4572,9 @@ class Store {
     if (!s?.transcript_path || !existsSync4(s.transcript_path))
       return 0;
     let n = this.tailFile(s.transcript_path, sessionId, null);
-    const subDir = join5(dirname(s.transcript_path), basename(s.transcript_path, ".jsonl"), "subagents");
+    const subDir = join6(dirname(s.transcript_path), basename(s.transcript_path, ".jsonl"), "subagents");
     for (const f of this.subagentFiles(subDir)) {
-      n += this.tailFile(join5(subDir, f), sessionId, f.replace(/^agent-|\.jsonl$/g, ""));
+      n += this.tailFile(join6(subDir, f), sessionId, f.replace(/^agent-|\.jsonl$/g, ""));
     }
     return n;
   }
@@ -3281,7 +4606,7 @@ class Store {
     return n;
   }
   codexRoot() {
-    return process.env.SWARM_CODEX_DIR ?? join5(homedir3(), ".codex", "sessions");
+    return process.env.SWARM_CODEX_DIR ?? join6(homedir3(), ".codex", "sessions");
   }
   codexRolloutFiles(sinceMs) {
     const root = this.codexRoot();
@@ -3296,18 +4621,18 @@ class Store {
     for (const y of ls(root)) {
       if (!/^\d{4}$/.test(y))
         continue;
-      for (const m of ls(join5(root, y))) {
+      for (const m of ls(join6(root, y))) {
         if (!/^\d\d$/.test(m))
           continue;
-        for (const day of ls(join5(root, y, m))) {
+        for (const day of ls(join6(root, y, m))) {
           if (!/^\d\d$/.test(day))
             continue;
           if (Date.parse(`${y}-${m}-${day}T23:59:59Z`) < sinceMs)
             continue;
-          const dir = join5(root, y, m, day);
+          const dir = join6(root, y, m, day);
           for (const f of ls(dir)) {
             if (f.startsWith("rollout-") && f.endsWith(".jsonl"))
-              out.push(join5(dir, f));
+              out.push(join6(dir, f));
           }
         }
       }
@@ -3324,7 +4649,7 @@ class Store {
     return n;
   }
   grokRoot() {
-    return process.env.SWARM_GROK_DIR ?? join5(homedir3(), ".grok", "sessions");
+    return process.env.SWARM_GROK_DIR ?? join6(homedir3(), ".grok", "sessions");
   }
   grokSummary = new Map;
   tailGrok(windowMs = 3 * 24 * 60 * 60000) {
@@ -3349,9 +4674,9 @@ class Store {
       } catch {
         cwd = enc;
       }
-      const cwdDir = join5(root, enc);
+      const cwdDir = join6(root, enc);
       for (const sid of ls(cwdDir)) {
-        const path = join5(cwdDir, sid, "updates.jsonl");
+        const path = join6(cwdDir, sid, "updates.jsonl");
         if (!existsSync4(path))
           continue;
         try {
@@ -3360,7 +4685,7 @@ class Store {
         } catch {
           continue;
         }
-        const sumPath = join5(cwdDir, sid, "summary.json");
+        const sumPath = join6(cwdDir, sid, "summary.json");
         let title;
         let fresh = false;
         try {
@@ -3447,7 +4772,7 @@ class Store {
   worktreePath(projectId, task) {
     const slug = (x) => x.replace(/[^a-zA-Z0-9._-]+/g, "-").toLowerCase();
     const p = this.project(projectId);
-    return join5(this.home, "worktrees", slug(p?.name ?? projectId), slug(task));
+    return join6(this.home, "worktrees", slug(p?.name ?? projectId), slug(task));
   }
   claim(projectId, task, owner, baseRef = "HEAD") {
     const p = this.project(projectId);
@@ -3461,7 +4786,7 @@ class Store {
     const worktree = this.worktreePath(projectId, task);
     if (existsSync4(worktree))
       return { ok: false, error: `${worktree} already exists; release ${task} first` };
-    mkdirSync2(dirname(worktree), { recursive: true });
+    mkdirSync3(dirname(worktree), { recursive: true });
     const created = worktreeAdd(p.root, worktree, branch, baseRef);
     if (!created)
       return { ok: false, error: `git worktree add failed for ${task}` };
@@ -3481,6 +4806,82 @@ class Store {
     });
     return { ok: true, task, owner, worktree: created, branch, expiresAt };
   }
+  autoRenewAt = new Map;
+  autoRenewFor(sessionId, cwd) {
+    if (!cwd)
+      return;
+    const key = sessionId ?? cwd;
+    const last = this.autoRenewAt.get(key) ?? 0;
+    const now = Date.now();
+    if (now - last < 60000)
+      return;
+    this.autoRenewAt.set(key, now);
+    for (const c of this.heldClaimsWithWorktree()) {
+      if (!isInside(cwd, c.worktree))
+        continue;
+      if (!shouldAutoRenew({ state: "held", expiresAt: c.expiresAt }, now))
+        continue;
+      const expiresAt = nextExpiry(now);
+      this.db.query("UPDATE claims SET expires_at = ? WHERE project_id = ? AND task = ? AND state = 'held'").run(expiresAt, c.projectId, c.task);
+      this.append({
+        ts: new Date(now).toISOString(),
+        type: "claim.renewed",
+        projectId: c.projectId,
+        sessionId: this.knownSession(sessionId),
+        payload: { task: c.task, expiresAt, auto: true, summary: `auto-renew ${c.task}` }
+      });
+    }
+  }
+  heldClaimsWithWorktree() {
+    return this.db.query("SELECT project_id, task, worktree, expires_at FROM claims WHERE state = 'held' AND worktree != ''").all().map((r) => ({
+      projectId: r.project_id,
+      task: r.task,
+      worktree: r.worktree,
+      expiresAt: r.expires_at
+    }));
+  }
+  sweepOrphans() {
+    const now = Date.now();
+    let n = 0;
+    for (const p of this.projects()) {
+      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 work = exists ? heldWork(c.worktree) : null;
+        if (reapAction(c, now, exists, work) !== "keep-orphaned")
+          continue;
+        this.db.query("UPDATE claims SET state = 'orphaned' WHERE project_id = ? AND task = ?").run(p.id, c.task);
+        const ts = new Date(now).toISOString();
+        this.append({
+          ts,
+          type: "claim.orphaned",
+          projectId: p.id,
+          sessionId: null,
+          payload: {
+            task: c.task,
+            worktree: c.worktree,
+            summary: `orphaned ${c.task} (holds work)`
+          }
+        });
+        this.append({
+          ts,
+          type: "incident.opened",
+          projectId: p.id,
+          sessionId: null,
+          payload: {
+            rule: "orphaned_claim",
+            action: "orphaned",
+            command: `${c.task} \u2192 ${c.worktree}`,
+            reason: `The lease on "${c.task}" (held by ${c.owner}) expired while its worktree still holds ${work?.dirty ? "uncommitted" : "unpushed"} work. Nothing was removed: renew it, finish and push, or force-release to discard.`
+          }
+        });
+        this.touch();
+        n++;
+      }
+    }
+    return n;
+  }
   renew(projectId, task) {
     const row = this.db.query("SELECT state FROM claims WHERE project_id = ? AND task = ?").get(projectId, task);
     if (!row)
@@ -3720,6 +5121,23 @@ class Store {
       daily
     };
   }
+  attribution(projectId) {
+    const claims = this.db.query("SELECT task, owner, worktree, state FROM claims WHERE project_id = ? AND worktree != ''").all(projectId);
+    const byTask = claims.map((c) => {
+      const r = this.db.query(`SELECT COALESCE(SUM(t.cost_usd),0) AS cost, COALESCE(SUM(t.output),0) AS output, COUNT(*) AS turns,
+                    COUNT(DISTINCT s.id) AS sessions
+             FROM sessions s JOIN turns t ON t.session_id = s.id
+             WHERE s.cwd = ? OR s.cwd LIKE ?`).get(c.worktree, `${c.worktree}/%`);
+      return { task: c.task, owner: c.owner, state: c.state, worktree: c.worktree, ...r };
+    }).filter((t) => t.turns > 0).sort((a, b) => b.cost - a.cost);
+    const contextBudget = this.db.query(`SELECT s.id, s.title, s.project_id AS projectId,
+                  COALESCE(SUM(t.cache_read),0) AS cacheRead,
+                  COALESCE(SUM(t.input + t.cache_write + t.cache_read),0) AS input,
+                  COALESCE(SUM(t.cost_usd),0) AS cost, COUNT(*) AS turns
+           FROM sessions s JOIN turns t ON t.session_id = s.id
+           WHERE s.project_id = ? GROUP BY s.id HAVING turns > 3 ORDER BY cacheRead DESC LIMIT 12`).all(projectId).map((r) => ({ ...r, reuse: r.input ? r.cacheRead / r.input : 0 }));
+    return { byTask, contextBudget };
+  }
   stats(projectId) {
     const scope = projectId ? "s.project_id = ?" : "? IS NULL";
     const arg = projectId ?? null;
@@ -3794,7 +5212,7 @@ class Store {
     args.push(limit);
     const rows = this.db.query(`SELECT e.seq, e.ts, e.project_id, e.session_id, e.payload, a.acked_at FROM events e
          LEFT JOIN incident_acks a ON a.seq = e.seq WHERE ${where.join(" AND ")} ORDER BY e.seq DESC LIMIT ?`).all(...args);
-    return rows.map((r) => ({
+    const list = rows.map((r) => ({
       seq: r.seq,
       ts: r.ts,
       projectId: r.project_id,
@@ -3802,6 +5220,25 @@ class Store {
       acked: r.acked_at,
       ...JSON.parse(r.payload || "{}")
     }));
+    const counts = new Map;
+    for (const i of list) {
+      const key = incidentKey(i);
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return list.map((i) => {
+      const incident = i;
+      if (!incident.rule)
+        return i;
+      const key = incidentKey(incident);
+      const suggestion = suggestFromIncident({
+        rule: incident.rule,
+        action: incident.action ?? "",
+        command: incident.command ?? "",
+        reason: incident.reason ?? "",
+        count: counts.get(key) ?? 1
+      });
+      return { ...i, count: counts.get(key) ?? 1, suggestion };
+    });
   }
   openIncidents(projectId) {
     const r = this.db.query(`SELECT COUNT(*) AS n FROM events e LEFT JOIN incident_acks a ON a.seq = e.seq
@@ -4190,13 +5627,13 @@ function rowToEvent(r) {
 }
 
 // packages/daemon/src/app.ts
-var VERSION = "0.4.1";
+var VERSION = "0.6.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 = join6(here, "../../web/public");
-  return existsSync5(join6(dev, "index.html")) ? dev : join6(here, "../web");
+  const dev = join7(here, "../../web/public");
+  return existsSync5(join7(dev, "index.html")) ? dev : join7(here, "../web");
 })();
 var REPLAY_TAIL = 200;
 var wireCache = new WeakMap;
@@ -4211,6 +5648,7 @@ function wireJson(e) {
 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 }));
   app.get("/v1/projects", (c) => c.json(store.snapshot().projects));
   app.post("/v1/projects", async (c) => {
@@ -4244,7 +5682,7 @@ function createApp(store = new Store) {
       dir = homedir4();
     }
     try {
-      const entries = readdirSync2(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({ name: e.name, repo: existsSync5(join6(dir, e.name, ".git")) })).sort((a, b) => a.name.localeCompare(b.name));
+      const entries = readdirSync2(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({ name: e.name, repo: existsSync5(join7(dir, e.name, ".git")) })).sort((a, b) => a.name.localeCompare(b.name));
       const parent = dirname2(dir);
       return c.json({ path: dir, parent: parent === dir ? null : parent, entries });
     } catch (e) {
@@ -4257,6 +5695,30 @@ function createApp(store = new Store) {
     open: c.req.query("open") === "1",
     projectId: c.req.query("project") || undefined
   })));
+  app.get("/v1/memory", (c) => {
+    const q = c.req.query("q") ?? "";
+    const kind = c.req.query("kind");
+    return c.json({
+      q,
+      hits: store.memorySearch(q, {
+        projectId: c.req.query("project") || null,
+        kind: MEMORY_KINDS.includes(kind) ? kind : null,
+        task: c.req.query("task") || null,
+        limit: Number(c.req.query("limit")) || 30
+      })
+    });
+  });
+  app.get("/v1/rules/dryrun", (c) => {
+    const projectId = c.req.query("project");
+    if (!projectId)
+      return c.json({ ok: false, error: "project required" }, 400);
+    const overrides = {};
+    for (const [k, v] of Object.entries(c.req.query()))
+      if (RULE_IDS.includes(k) && ["ask", "deny", "off"].includes(v))
+        overrides[k] = v;
+    const limit = Math.min(20000, Math.max(100, Number(c.req.query("limit")) || 5000));
+    return c.json(store.dryRun(projectId, overrides, limit));
+  });
   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) });
@@ -4318,6 +5780,92 @@ function createApp(store = new Store) {
     const r = await store.stopProcess(pid, c.req.query("project") || null);
     return r.ok ? c.json(r) : c.json({ ok: false, error: r.reason }, 404);
   });
+  app.get("/v1/runs", (c) => c.json(runner.list(c.req.query("project") || undefined)));
+  app.post("/v1/runs", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    if (!b.projectId || !b.task || !b.prompt)
+      return c.json({ ok: false, error: "projectId, task and prompt required" }, 400);
+    const r = await runner.start({
+      projectId: b.projectId,
+      task: b.task,
+      prompt: b.prompt,
+      owner: b.owner ?? "dashboard",
+      model: b.model,
+      permissionMode: b.permissionMode,
+      allowedTools: b.allowedTools,
+      maxTurns: b.maxTurns
+    });
+    return r.ok ? c.json(r, 201) : c.json({ ok: false, error: r.reason }, 409);
+  });
+  app.post("/v1/runs/:id/send", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    if (!b.text?.trim())
+      return c.json({ ok: false, error: "text required" }, 400);
+    const r = runner.send(c.req.param("id"), b.text);
+    return r.ok ? c.json(r) : c.json({ ok: false, error: r.reason }, 404);
+  });
+  app.post("/v1/runs/:id/permissions/:reqId", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    const r = runner.answerPermission(c.req.param("id"), c.req.param("reqId"), b.allow === true, b.message);
+    return r.ok ? c.json(r) : c.json({ ok: false, error: r.reason }, 404);
+  });
+  app.delete("/v1/runs/:id", async (c) => {
+    const r = await runner.stop(c.req.param("id"));
+    return r.ok ? c.json(r) : c.json({ ok: false, error: r.reason }, 404);
+  });
+  app.get("/v1/handoffs", (c) => {
+    const project = c.req.query("project");
+    if (!project)
+      return c.json({ error: "project required" }, 400);
+    const task = c.req.query("task");
+    if (task) {
+      const h = store.latestHandoff(project, task);
+      return h ? c.json({ handoff: h, text: formatHandoff(h) }) : c.json({ handoff: null, text: null }, 404);
+    }
+    return c.json(store.handoffs(project));
+  });
+  app.post("/v1/handoffs", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    if (!b.projectId || !b.task)
+      return c.json({ ok: false, error: "projectId and task required" }, 400);
+    const r = store.recordHandoff(b.projectId, {
+      task: b.task,
+      done: b.done ?? "",
+      remaining: b.remaining ?? "",
+      files: Array.isArray(b.files) ? b.files : [],
+      verify: b.verify ?? null,
+      by: b.by ?? null,
+      sessionId: b.sessionId ?? null
+    });
+    return r.ok ? c.json(r, 201) : c.json({ ok: false, error: r.reason }, 400);
+  });
+  app.get("/v1/gates", (c) => {
+    const project = c.req.query("project");
+    if (!project)
+      return c.json({ error: "project required" }, 400);
+    const task = c.req.query("task") || undefined;
+    const runs = store.gateRuns(project, task);
+    const required = store.requiredGates(project);
+    return c.json({
+      required,
+      runs,
+      status: task ? store.gateStatusFor(runs, required) : undefined
+    });
+  });
+  app.post("/v1/gates", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    if (!b.projectId)
+      return c.json({ ok: false, error: "projectId required" }, 400);
+    const r = store.recordGate(b.projectId, {
+      task: b.task ?? "",
+      gate: b.gate ?? "",
+      verdict: b.verdict,
+      rubric: b.rubric,
+      evidence: b.evidence,
+      sessionId: b.sessionId ?? null
+    });
+    return r.ok ? c.json(r, 201) : c.json({ ok: false, error: r.reason }, 400);
+  });
   app.get("/v1/tasks", (c) => {
     const project = c.req.query("project");
     if (!project)
@@ -4362,6 +5910,10 @@ function createApp(store = new Store) {
     return e ? c.json(e) : c.json({ error: "not found" }, 404);
   });
   app.get("/v1/spend", (c) => c.json(store.spend()));
+  app.get("/v1/attribution", (c) => {
+    const project = c.req.query("project");
+    return project ? c.json(store.attribution(project)) : c.json({ error: "project required" }, 400);
+  });
   app.post("/v1/pricing/refresh", async (c) => {
     try {
       await store.refreshPricing();
@@ -4371,11 +5923,40 @@ function createApp(store = new Store) {
     }
   });
   app.get("/v1/pricing", (c) => c.json(store.prices));
+  app.get("/v1/sessions/:id/resume", (c) => {
+    const r = store.resumePlan(c.req.param("id"));
+    return r.ok ? c.json(r) : c.json({ ok: false, error: r.reason }, 404);
+  });
+  app.post("/v1/sessions/:id/resume", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    const plan = store.resumePlan(c.req.param("id"));
+    if (!plan.ok)
+      return c.json({ ok: false, error: plan.reason }, 404);
+    const r = await runner.start({
+      projectId: plan.projectId,
+      task: plan.task,
+      prompt: plan.prompt,
+      owner: b.owner ?? plan.owner ?? "dashboard",
+      model: b.model,
+      permissionMode: b.permissionMode,
+      allowedTools: b.allowedTools,
+      maxTurns: b.maxTurns
+    });
+    return r.ok ? c.json({ ...r, resumedFrom: c.req.param("id") }, 201) : c.json({ ok: false, error: r.reason }, 409);
+  });
   app.post("/v1/sessions/:id/tail", (c) => c.json({ turns: store.tailSession(c.req.param("id")) }));
   app.post("/v1/hook/:event", async (c) => {
     const event = c.req.param("event");
     const raw2 = await c.req.json().catch(() => ({}));
     store.ingestHook(event, raw2);
+    if (event === "SessionStart" && typeof raw2.cwd === "string") {
+      const ctx = store.sessionContext(raw2.cwd);
+      if (ctx)
+        return c.json({
+          additionalContext: ctx,
+          hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: ctx }
+        });
+    }
     if (event === "PreToolUse" && process.env.SWARM_GUARD !== "off") {
       const guard = store.guardHook(raw2);
       if (guard) {
@@ -4416,23 +5997,23 @@ function createApp(store = new Store) {
       });
     });
   });
-  app.get("/", (c) => c.html(readFileSync4(join6(WEB_DIR, "index.html"), "utf8")));
+  app.get("/", (c) => c.html(readFileSync4(join7(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 = join6(WEB_DIR, f);
+    const p = join7(WEB_DIR, f);
     if (!existsSync5(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 };
+  return { app, store, forge: forge2, runner };
 }
 
 // packages/daemon/src/bin.ts
 var DEFAULT_PORT2 = process.env.SWARM_PORT ? DEFAULT_PORT : loadConfig().daemon.port;
-var { app, store } = createApp();
+var { app, store, runner } = createApp();
 function serve() {
   const bind = (p) => Bun.serve({ port: p, hostname: "127.0.0.1", idleTimeout: 0, fetch: app.fetch });
   try {
@@ -4461,6 +6042,8 @@ var tailer = setInterval(() => {
   }
   store.reapResources();
   store.reapProcesses();
+  if (tick % 12 === 0)
+    store.sweepOrphans();
 }, 5000);
 store.refreshAllWorktrees();
 var wtRefresh = setInterval(() => void store.refreshAllWorktrees(), 15000);
@@ -4469,11 +6052,16 @@ var pruner = setInterval(() => store.prune(), 24 * 60 * 60000);
 if (process.env.SWARM_OFFLINE !== "1")
   store.refreshPricing().catch(() => {});
 console.log(`swarmd ${VERSION} listening on http://127.0.0.1:${port}`);
-function shutdown() {
+var stopping = false;
+async function shutdown() {
+  if (stopping)
+    return;
+  stopping = true;
   clearInterval(tailer);
   clearInterval(wtRefresh);
   clearInterval(pruner);
   clearDaemonInfo();
+  await Promise.race([runner.stopAll(), Bun.sleep(6000)]);
   server.stop(true);
   process.exit(0);
 }