@ra3orblade/swarm 0.5.0 → 0.6.0

package/dist/swarmd.js

@@ -327,7 +327,7 @@ 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",
@@ -367,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,
@@ -396,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)?\/?$/);
@@ -576,6 +822,237 @@ function formatHandoff(h) {
   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 },
@@ -699,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;
@@ -945,6 +1276,65 @@ 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";
@@ -3145,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);
@@ -3171,6 +3638,10 @@ 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,
@@ -3219,6 +3690,7 @@ class Store {
     this.reconcileMovedProjects();
     this.slimExistingEvents();
     this.retypeNotificationIncidents();
+    this.backfillMemory();
   }
   retypeNotificationIncidents() {
     if (this.meta("notifications_retyped") === "1")
@@ -3345,8 +3817,9 @@ class Store {
       createdAt: new Date().toISOString()
     };
     const sessionId = this.knownSession(h.sessionId);
-    this.db.query(`INSERT INTO handoffs (project_id, task, done, remaining, files, verify, by, session_id, created_at)
+    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",
@@ -3383,6 +3856,138 @@ class Store {
       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;
@@ -3458,6 +4063,7 @@ class Store {
     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",
@@ -3487,21 +4093,36 @@ class Store {
     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, home: this.home }).tasks.source;
+    const cfg = loadConfig({ repoRoot: p.root, home: this.home }).tasks;
+    const source = cfg.source;
     if (!source)
       return null;
-    const path = join6(p.root, source);
-    if (!existsSync4(path))
-      return { source, required: this.requiredGates(projectId), 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));
@@ -3523,7 +4144,7 @@ class Store {
         gated: gatesSatisfied(tr, required)
       };
     });
-    return { source, required, tasks: board };
+    return { source, required, tasks: board, error };
   }
   rulesFor(repoRoot) {
     const key = repoRoot ?? "";
@@ -3625,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;
@@ -3773,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);
@@ -3795,6 +4463,11 @@ class Store {
     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;
@@ -4448,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;
@@ -4522,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,
@@ -4530,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
@@ -4918,7 +5627,7 @@ function rowToEvent(r) {
 }
 
 // packages/daemon/src/app.ts
-var VERSION = "0.5.0";
+var VERSION = "0.6.0";
 var WEB_DIR = (() => {
   if (process.env.SWARM_WEB_DIR)
     return process.env.SWARM_WEB_DIR;
@@ -4986,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) });
@@ -5177,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();
@@ -5186,6 +5923,27 @@ 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");