@ra3orblade/swarm 0.13.0 → 0.13.2

package/dist/swarmd.js

@@ -968,8 +968,8 @@ function sinceToIso(since, now = Date.now()) {
   const m = /^(\d+)([dhm])$/.exec(since.trim());
   if (m) {
     const n = Number(m[1]);
-    const ms2 = m[2] === "d" ? 86400000 : m[2] === "h" ? 3600000 : 60000;
-    return new Date(now - n * ms2).toISOString();
+    const ms = m[2] === "d" ? 86400000 : m[2] === "h" ? 3600000 : 60000;
+    return new Date(now - n * ms).toISOString();
   }
   const t = Date.parse(since);
   return Number.isNaN(t) ? null : new Date(t).toISOString();
@@ -1421,22 +1421,22 @@ function contextReport(results, reads, turns, opts = {}) {
   const sessions = [];
   for (const sessionId of ids) {
     const worstAll = rereadWaste(readsBySession.get(sessionId) ?? []);
-    const wastedChars2 = worstAll.reduce((a, w) => a + w.wastedChars, 0);
-    const toolChars2 = charsBySession.get(sessionId) ?? 0;
+    const wastedChars = worstAll.reduce((a, w) => a + w.wastedChars, 0);
+    const toolChars = charsBySession.get(sessionId) ?? 0;
     const tk = tokensBySession.get(sessionId);
     const cacheable = (tk?.cacheRead ?? 0) + (tk?.input ?? 0);
     sessions.push({
       sessionId,
-      toolChars: toolChars2,
-      toolTokens: estTokens(toolChars2),
+      toolChars,
+      toolTokens: estTokens(toolChars),
       thinking: tk?.thinking ?? 0,
       cacheRead: tk?.cacheRead ?? 0,
       input: tk?.input ?? 0,
       cacheHit: cacheable ? (tk?.cacheRead ?? 0) / cacheable : 0,
       reads: (readsBySession.get(sessionId) ?? []).length,
       rereadFiles: worstAll.length,
-      wastedChars: wastedChars2,
-      wasteShare: toolChars2 ? wastedChars2 / toolChars2 : 0,
+      wastedChars,
+      wasteShare: toolChars ? wastedChars / toolChars : 0,
       worst: worstAll.slice(0, o.worstLimit)
     });
   }
@@ -1678,22 +1678,26 @@ function otherLiveInSameTree(current, sessions, now, withinMs = LIVE_WINDOW_MS)
   }
   return null;
 }
+var GIT_GLOBAL_OPTS = "(?:\\s+(?:-C\\s+\\S+|-c\\s+\\S+|--git-dir(?:=|\\s+)\\S+|--work-tree(?:=|\\s+)\\S+|--namespace(?:=|\\s+)\\S+|--no-pager|--paginate|--bare|--literal-pathspecs|--exec-path(?:=\\S+)?))*";
+function gitVerb(verb, tail) {
+  return new RegExp(`\\bgit${GIT_GLOBAL_OPTS}\\s+${verb}${tail}`);
+}
 function isBroadStage(cmd) {
   const c = cmd.trim();
-  if (/\bgit\s+add\s+(-A\b|--all\b|\.(\s|$))/.test(c))
+  if (gitVerb("add", "\\s+(-A\\b|--all\\b|\\.(\\s|$))").test(c))
     return true;
-  if (/\bgit\s+commit\b[^|&;]*\s-[a-zA-Z]*a/.test(c))
+  if (gitVerb("commit", "\\b[^|&;]*\\s-[a-zA-Z]*a").test(c))
     return true;
-  if (/\bgit\s+add\s*$/.test(c))
+  if (gitVerb("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);
+  return gitVerb("reset", "\\s+[^|&;]*--hard\\b").test(c) || gitVerb("checkout", "\\s+(--\\s+)?\\.(\\s|$)").test(c) || gitVerb("checkout", "\\s+-f\\b").test(c) || gitVerb("restore", "\\s+(--\\s+)?\\.(\\s|$)").test(c) || gitVerb("clean", "\\s+[^|&;]*-[a-zA-Z]*f").test(c) || gitVerb("stash", "\\s+(drop|clear)\\b").test(c) || gitVerb("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);
+  return /\bpkill\s+(-[a-zA-Z]*f\b|--full\b)/.test(cmd) || /\bkillall\b/.test(cmd) || /\bpgrep\s+(-[a-zA-Z]*f\b|--full\b)[^|]*\|\s*[^|]*\bkill\b/.test(cmd);
 }
 function killedPorts(cmd) {
   const ports = new Set;
@@ -1858,20 +1862,20 @@ function dryRunRules(calls, modes, ctx) {
     if (d.action === "allow")
       continue;
     byRule[d.rule][d.action]++;
-    const norm2 = normalizeDisplay(display);
+    const norm = normalizeDisplay(display);
     if (hits.length < maxHits)
       hits.push({
         ts: c.ts,
         sessionId: c.sessionId,
         rule: d.rule,
         action: d.action,
-        display: norm2,
+        display: norm,
         completed: c.completed
       });
-    const key = `${d.rule} ${norm2}`;
+    const key = `${d.rule} ${norm}`;
     const g = groups.get(key) ?? {
       rule: d.rule,
-      display: norm2,
+      display: norm,
       fires: 0,
       completedRatio: 0,
       sessions: 0,
@@ -2362,7 +2366,7 @@ var HYGIENE_DEFAULTS = {
   hungryRssKb: 1024 * 1024,
   heavyKb: 2 * 1024 * 1024
 };
-var days2 = (ms3) => ms3 / 86400000;
+var days2 = (ms) => ms / 86400000;
 function classifyProcess(p, opts = {}) {
   const o = { ...HYGIENE_DEFAULTS, ...opts };
   if (!p.alive)
@@ -3026,11 +3030,11 @@ function parseTo(to) {
     return { kind: "session", id: t };
   return { kind: "task", task: t };
 }
-function formatMessages(ms3) {
-  if (!ms3.length)
+function formatMessages(ms) {
+  if (!ms.length)
     return null;
-  const lines = ms3.map((m) => `- from ${m.from ?? "unknown"}${m.task ? ` (re ${m.task})` : ""}: ${m.text}`);
-  return `[swarm] While you were working, message${ms3.length === 1 ? "" : "s"} arrived:
+  const lines = ms.map((m) => `- from ${m.from ?? "unknown"}${m.task ? ` (re ${m.task})` : ""}: ${m.text}`);
+  return `[swarm] While you were working, message${ms.length === 1 ? "" : "s"} arrived:
 ${lines.join(`
 `)}
 Reply with swarm_send if a reply is expected.`;
@@ -3718,8 +3722,8 @@ function commandSignature(command) {
   const more = tokens.length > 2;
   return `${name}${second ? ` ${second}` : ""}${more ? " \u2026" : ""}`;
 }
-function ruleEffect(incidents, changes = [], now = Date.now(), days3 = 30) {
-  const since = now - days3 * DAY;
+function ruleEffect(incidents, changes = [], now = Date.now(), days = 30) {
+  const since = now - days * DAY;
   const rows = incidents.filter((i) => i.rule && Date.parse(i.at) >= since);
   const byRule = new Map;
   for (const i of rows)
@@ -3993,12 +3997,12 @@ function parseMarkdownTasks(text) {
     const cells = splitRow(line);
     if (!cols) {
       const lc = cells.map((c) => c.toLowerCase());
-      const id2 = lc.indexOf("id");
+      const id = lc.indexOf("id");
       const task = lc.findIndex((c) => c === "task" || c === "title");
-      if (id2 < 0 || task < 0 || !isSeparator(lines[i + 1] ?? ""))
+      if (id < 0 || task < 0 || !isSeparator(lines[i + 1] ?? ""))
         continue;
       cols = {
-        id: id2,
+        id,
         task,
         depends: lc.findIndex((c) => c.startsWith("depend")),
         status: lc.indexOf("status")
@@ -4315,10 +4319,10 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 
 // node_modules/.bun/hono@4.13.3/node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
-  return (context2, next) => {
+  return (context, next) => {
     let index = -1;
-    return dispatch2(0);
-    async function dispatch2(i) {
+    return dispatch(0);
+    async function dispatch(i) {
       if (i <= index) {
         throw new Error("next() called multiple times");
       }
@@ -4328,31 +4332,31 @@ var compose = (middleware, onError, onNotFound) => {
       let handler;
       if (middleware[i]) {
         handler = middleware[i][0][0];
-        context2.req.routeIndex = i;
+        context.req.routeIndex = i;
       } else {
         handler = i === middleware.length && next || undefined;
       }
       if (handler) {
         try {
-          res = await handler(context2, () => dispatch2(i + 1));
+          res = await handler(context, () => dispatch(i + 1));
         } catch (err) {
           if (err instanceof Error && onError) {
-            context2.error = err;
-            res = await onError(err, context2);
+            context.error = err;
+            res = await onError(err, context);
             isError = true;
           } else {
             throw err;
           }
         }
       } else {
-        if (context2.finalized === false && onNotFound) {
-          res = await onNotFound(context2);
+        if (context.finalized === false && onNotFound) {
+          res = await onNotFound(context);
         }
       }
-      if (res && (context2.finalized === false || isError)) {
-        context2.res = res;
+      if (res && (context.finalized === false || isError)) {
+        context.res = res;
       }
-      return context2;
+      return context;
     }
   };
 };
@@ -4773,7 +4777,7 @@ var raw = (value, callbacks) => {
   escapedString.callbacks = callbacks;
   return escapedString;
 };
-var resolveCallback = async (str, phase, preserveCallbacks, context2, buffer) => {
+var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
   if (typeof str === "object" && !(str instanceof String)) {
     if (!(str instanceof Promise)) {
       str = str.toString();
@@ -4791,7 +4795,7 @@ var resolveCallback = async (str, phase, preserveCallbacks, context2, buffer) =>
   } else {
     buffer = [str];
   }
-  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context: context2 }))).then((res) => Promise.all(res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context2, buffer))).then(() => buffer[0]));
+  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then((res) => Promise.all(res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))).then(() => buffer[0]));
   if (preserveCallbacks) {
     return raw(await resStr, callbacks);
   } else {
@@ -5190,11 +5194,11 @@ var Hono = class _Hono {
     const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
     return (async () => {
       try {
-        const context2 = await composed(c);
-        if (!context2.finalized) {
+        const context = await composed(c);
+        if (!context.finalized) {
           throw new Error("Context is not finalized. Did you forget to return a Response object or `await next()`?");
         }
-        return context2.res;
+        return context.res;
       } catch (err) {
         return this.#handleError(err, c);
       }
@@ -5267,7 +5271,7 @@ var Node = class _Node {
   #index;
   #varIndex;
   #children = /* @__PURE__ */ Object.create(null);
-  insert(tokens, index, paramMap, context2, isStatic) {
+  insert(tokens, index, paramMap, context, isStatic) {
     let node = this;
     for (let i = 0, len = tokens.length;i < len; i++) {
       const token = tokens[i];
@@ -5300,7 +5304,7 @@ var Node = class _Node {
           nextNode = node.#children[regexpStr] = new _Node;
         }
         if (name !== "") {
-          nextNode.#varIndex ??= context2.varIndex++;
+          nextNode.#varIndex ??= context.varIndex++;
           paramMap.push([name, nextNode.#varIndex]);
         }
       } else {
@@ -5613,7 +5617,7 @@ var SmartRouter = class {
 // node_modules/.bun/hono@4.13.3/node_modules/hono/dist/router/trie-router/node.js
 var emptyParams = /* @__PURE__ */ Object.create(null);
 var order = 0;
-var Node2 = class _Node2 {
+var Node2 = class _Node {
   #methods = [];
   #children = /* @__PURE__ */ Object.create(null);
   #patterns = [];
@@ -5629,7 +5633,7 @@ var Node2 = class _Node2 {
       const pattern = getPattern(p, nextP) || (nextP === undefined && p && p.indexOf("*") === p.length - 1 ? p : null);
       const isParam = Array.isArray(pattern);
       const key = isParam ? pattern[0] : pattern || p;
-      const child = curNode.#children[key] ||= new _Node2;
+      const child = curNode.#children[key] ||= new _Node;
       if (pattern && !child.#pattern) {
         child.#pattern = pattern;
         curNode.#patterns.push(child);
@@ -5825,8 +5829,8 @@ var StreamingApi = class {
 `);
     return this;
   }
-  sleep(ms4) {
-    return new Promise((res) => setTimeout(res, ms4));
+  sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
   }
   async close() {
     this.closed = true;
@@ -5937,11 +5941,11 @@ class Dispatcher {
   forge;
   entries = new Map;
   opts = new Map;
-  constructor(store, runner, forge2) {
+  constructor(store, runner, forge) {
     this.store = store;
     this.runner = runner;
-    this.forge = forge2;
-    runner.onEnd((run2) => void this.onRunEnd(run2));
+    this.forge = forge;
+    runner.onEnd((run) => void this.onRunEnd(run));
   }
   project(projectId) {
     let m = this.entries.get(projectId);
@@ -6028,10 +6032,10 @@ class Dispatcher {
     const e = m.get(t.id);
     const opts = this.opts.get(projectId) ?? { owner: "dispatch" };
     const cfg = this.store.config(projectId);
-    const gates2 = cfg.gates;
+    const gates = cfg.gates;
     const prompt = taskPrompt(t, {
-      requiredGates: gates2.required,
-      executableGates: gates2.required.filter((g) => gates2.defs[g]),
+      requiredGates: gates.required,
+      executableGates: gates.required.filter((g) => gates.defs[g]),
       openPr: cfg.dispatch.require_pr
     });
     const r = await this.runner.start({
@@ -6098,76 +6102,76 @@ class Dispatcher {
       await this.startOne(projectId, { id: e.task, title: e.title });
     }
   }
-  async onRunEnd(run2) {
-    const m = this.entries.get(run2.projectId);
-    const e = m?.get(run2.task);
-    if (!e || e.runId !== run2.id)
+  async onRunEnd(run) {
+    const m = this.entries.get(run.projectId);
+    const e = m?.get(run.task);
+    if (!e || e.runId !== run.id)
       return;
-    const cfg = this.store.config(run2.projectId);
+    const cfg = this.store.config(run.projectId);
     const required = cfg.gates.required;
-    let runs = this.store.gateRuns(run2.projectId, run2.task);
+    let runs = this.store.gateRuns(run.projectId, run.task);
     const status = this.store.gateStatusFor(runs, required);
     const missing = required.filter((g) => cfg.gates.defs[g] && status.find((s) => s.gate === g)?.verdict !== "pass");
-    if (missing.length && !run2.stopped) {
-      await this.store.runGates(run2.projectId, run2.task, missing, {
-        sessionId: run2.sessionId,
+    if (missing.length && !run.stopped) {
+      await this.store.runGates(run.projectId, run.task, missing, {
+        sessionId: run.sessionId,
         owner: "dispatch"
       });
-      runs = this.store.gateRuns(run2.projectId, run2.task);
+      runs = this.store.gateRuns(run.projectId, run.task);
     }
     const satisfied = gatesSatisfied(runs, required);
     await this.forge.refresh(0).catch(() => {});
-    const branch = `task/${run2.task}`;
-    const pr = this.forge.prs().find((p) => p.projectId === run2.projectId && p.branch === branch);
+    const branch = `task/${run.task}`;
+    const pr = this.forge.prs().find((p) => p.projectId === run.projectId && p.branch === branch);
     const outcome = dispatchOutcome({
-      exitCode: run2.exitCode,
-      isError: run2.result?.isError ?? false,
+      exitCode: run.exitCode,
+      isError: run.result?.isError ?? false,
       gatesSatisfied: satisfied,
       prOpen: Boolean(pr),
       requirePr: cfg.dispatch.require_pr,
-      stopped: run2.stopped ?? false
+      stopped: run.stopped ?? false
     });
     const verdicts = this.store.gateStatusFor(runs, required).map((s) => `${s.gate} ${s.verdict ?? "\u2014"}`).join(", ");
     const detail = [
-      `exit ${run2.exitCode}${run2.result?.isError ? " (error)" : ""}`,
+      `exit ${run.exitCode}${run.result?.isError ? " (error)" : ""}`,
       required.length ? `gates: ${verdicts}` : null,
       pr ? `PR ${pr.url}` : cfg.dispatch.require_pr ? "no PR" : null
     ].filter(Boolean).join(" \xB7 ");
     e.state = "finished";
-    e.endedAt = run2.endedAt;
+    e.endedAt = run.endedAt;
     e.outcome = outcome;
     e.detail = detail;
-    e.costUsd = run2.result?.costUsd ?? null;
-    const ts = run2.endedAt ?? new Date().toISOString();
+    e.costUsd = run.result?.costUsd ?? null;
+    const ts = run.endedAt ?? new Date().toISOString();
     this.store.append({
       ts,
       type: "dispatch.finished",
-      projectId: run2.projectId,
-      sessionId: run2.sessionId,
+      projectId: run.projectId,
+      sessionId: run.sessionId,
       payload: {
-        task: run2.task,
-        runId: run2.id,
+        task: run.task,
+        runId: run.id,
         outcome,
         detail,
         costUsd: e.costUsd,
-        summary: `dispatch ${run2.task}: ${outcome} \u2014 ${detail}`
+        summary: `dispatch ${run.task}: ${outcome} \u2014 ${detail}`
       }
     });
     if (outcome !== "done" && outcome !== "stopped")
       this.store.append({
         ts,
         type: "incident.opened",
-        projectId: run2.projectId,
-        sessionId: run2.sessionId,
+        projectId: run.projectId,
+        sessionId: run.sessionId,
         payload: {
           rule: "dispatch_failed",
           action: outcome,
-          command: run2.task,
-          reason: `dispatched run on ${run2.task} ended ${outcome}: ${detail}. The worktree and claim are kept; resume it from the session page or release it.`
+          command: run.task,
+          reason: `dispatched run on ${run.task} ended ${outcome}: ${detail}. The worktree and claim are kept; resume it from the session page or release it.`
         }
       });
     this.store.touch();
-    await this.fill(run2.projectId);
+    await this.fill(run.projectId);
   }
   clear(projectId, task) {
     const m = this.project(projectId);
@@ -6223,7 +6227,7 @@ class ForgeService {
     return all.sort((a, b) => a.createdAt < b.createdAt ? 1 : -1);
   }
   async refresh(maxAgeMs = 120000) {
-    const projects = this.store.projects();
+    const projects = this.store.liveProjects();
     await Promise.all(projects.map(async (p) => {
       const hit = this.cache.get(p.id);
       if (hit && Date.now() - hit.at < maxAgeMs)
@@ -6246,18 +6250,24 @@ class ForgeService {
   mergedCached(projectId, root) {
     const hit = this.outcomeCache.get(projectId);
     const fresh = !!hit && Date.now() - hit.at < 600000;
-    if (!fresh && !this.outcomeInflight.has(projectId)) {
-      const run2 = this.merged(projectId, root).finally(() => this.outcomeInflight.delete(projectId));
-      this.outcomeInflight.set(projectId, run2);
-    }
+    if (!fresh)
+      this.merged(projectId, root).catch(() => {});
     return { merged: hit?.merged ?? [], reverted: hit?.reverted ?? [], fresh };
   }
   async merged(projectId, root) {
     const hit = this.outcomeCache.get(projectId);
     if (hit && Date.now() - hit.at < 600000)
       return hit;
+    const inflight = this.outcomeInflight.get(projectId);
+    if (inflight)
+      return inflight;
+    const run = this.fetchMerged(projectId, root).finally(() => this.outcomeInflight.delete(projectId));
+    this.outcomeInflight.set(projectId, run);
+    return run;
+  }
+  async fetchMerged(projectId, root) {
     let merged = [];
-    const remote = this.remote(root);
+    const remote = await this.remote(root);
     if (remote?.forge === "github") {
       const out = await this.run([
         "gh",
@@ -6293,38 +6303,44 @@ class ForgeService {
           mergeSha: (r.merge_commit_sha ?? null)?.toLowerCase() ?? null
         }));
     }
-    const log = Bun.spawnSync([
-      "git",
-      "-C",
-      root,
-      "log",
-      "--grep",
-      "This reverts commit",
-      "--format=%B",
-      "-n",
-      "300"
-    ]);
-    const reverted = log.exitCode === 0 ? [...parseReverts(new TextDecoder().decode(log.stdout))] : [];
+    const log = await this.run(["git", "log", "--grep", "This reverts commit", "--format=%B", "-n", "300"], root);
+    const reverted = log ? [...parseReverts(log)] : [];
     const entry = { at: Date.now(), merged, reverted };
     this.outcomeCache.set(projectId, entry);
     return entry;
   }
-  remote(root) {
-    const r = Bun.spawnSync(["git", "-C", root, "remote", "get-url", "origin"]);
-    if (r.exitCode !== 0)
-      return null;
-    return parseRemote(new TextDecoder().decode(r.stdout).trim());
+  remoteCache = new Map;
+  async remote(root) {
+    const hit = this.remoteCache.get(root);
+    if (hit && Date.now() - hit.at < (hit.v ? 600000 : 60000))
+      return hit.v;
+    const out = await this.run(["git", "remote", "get-url", "origin"], root);
+    const v = out ? parseRemote(out.trim()) : null;
+    this.remoteCache.set(root, { at: Date.now(), v });
+    return v;
   }
-  async run(cmd, cwd) {
+  async run(cmd, cwd, timeoutMs = 20000) {
     const bin = findBin(cmd[0]);
     if (!bin)
       return null;
-    const proc = Bun.spawn([bin, ...cmd.slice(1)], { cwd, stdout: "pipe", stderr: "ignore" });
-    const out = await new Response(proc.stdout).text();
-    return await proc.exited === 0 ? out : null;
+    let proc;
+    try {
+      proc = Bun.spawn([bin, ...cmd.slice(1)], { cwd, stdout: "pipe", stderr: "ignore" });
+    } catch {
+      return null;
+    }
+    const killer = setTimeout(() => proc.kill(), timeoutMs);
+    try {
+      const out = await new Response(proc.stdout).text();
+      return await proc.exited === 0 ? out : null;
+    } catch {
+      return null;
+    } finally {
+      clearTimeout(killer);
+    }
   }
   async poll(projectId, root) {
-    const remote = this.remote(root);
+    const remote = await this.remote(root);
     if (!remote)
       return [];
     let prs = [];
@@ -6339,35 +6355,35 @@ class ForgeService {
     }
     return prs.map((pr) => ({ ...pr, projectId, projectRoot: root }));
   }
-  async openPR(projectId, worktree2, draft) {
+  async openPR(projectId, worktree, draft) {
     const p = this.store.projects().find((x) => x.id === projectId);
     if (!p)
       return { ok: false, error: "unknown project" };
-    if (worktree2.main)
+    if (worktree.main)
       return { ok: false, error: "that is the main checkout \u2014 open the PR from a task worktree" };
-    if (!worktree2.branch)
+    if (!worktree.branch)
       return { ok: false, error: "detached HEAD \u2014 check out a branch first" };
-    if (worktree2.dirty > 0)
+    if (worktree.dirty > 0)
       return {
         ok: false,
-        error: `${worktree2.path} has uncommitted changes \u2014 commit them first (Swarm never commits for you)`
+        error: `${worktree.path} has uncommitted changes \u2014 commit them first (Swarm never commits for you)`
       };
-    const remote = this.remote(p.root);
+    const remote = await this.remote(p.root);
     if (!remote)
       return { ok: false, error: "no GitHub/GitLab remote on origin" };
     const cli = remote.forge === "github" ? "gh" : "glab";
     const bin = findBin(cli);
     if (!bin)
       return { ok: false, error: `${cli} is not installed` };
-    const sh = async (cmd2, cwd) => {
-      const proc = Bun.spawn(cmd2, { cwd, stdout: "pipe", stderr: "pipe" });
+    const sh = async (cmd, cwd) => {
+      const proc = Bun.spawn(cmd, { cwd, stdout: "pipe", stderr: "pipe" });
       const out = await new Response(proc.stdout).text() + await new Response(proc.stderr).text();
       return { ok: await proc.exited === 0, out: out.trim() };
     };
-    const push = await sh(["git", "push", "-u", "origin", worktree2.branch], worktree2.path);
+    const push = await sh(["git", "push", "-u", "origin", worktree.branch], worktree.path);
     if (!push.ok)
       return { ok: false, error: `git push failed: ${push.out.slice(0, 400)}` };
-    const existing = this.prs().find((x) => x.projectId === projectId && x.branch === worktree2.branch);
+    const existing = this.prs().find((x) => x.projectId === projectId && x.branch === worktree.branch);
     if (existing)
       return { ok: true, url: existing.url, number: existing.number };
     const cmd = remote.forge === "github" ? [
@@ -6375,7 +6391,7 @@ class ForgeService {
       "pr",
       "create",
       "--head",
-      worktree2.branch,
+      worktree.branch,
       "--title",
       draft.title,
       "--body",
@@ -6386,7 +6402,7 @@ class ForgeService {
       "mr",
       "create",
       "--source-branch",
-      worktree2.branch,
+      worktree.branch,
       "--title",
       draft.title,
       "--description",
@@ -6394,7 +6410,7 @@ class ForgeService {
       "--yes",
       ...draft.isDraft ? ["--draft"] : []
     ];
-    const r = await sh(cmd, worktree2.path);
+    const r = await sh(cmd, worktree.path);
     if (!r.ok)
       return { ok: false, error: `${cli} failed: ${r.out.slice(0, 400)}` };
     const url = r.out.match(/https?:\/\/\S+/)?.[0] ?? r.out;
@@ -6406,7 +6422,7 @@ class ForgeService {
     const p = this.store.projects().find((x) => x.id === projectId);
     if (!p)
       return { ok: false, output: "unknown project" };
-    const remote = this.remote(p.root);
+    const remote = await 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"];
@@ -6676,9 +6692,9 @@ class Runner {
     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;
+    for (const { run } of this.live.values())
+      if (run.id === idOrTask || run.sessionId === idOrTask || run.task === idOrTask)
+        return run;
     return null;
   }
   async start(input) {
@@ -6706,14 +6722,14 @@ class Runner {
         reason: `a run on ${input.task} is already live \u2014 stop it or send it input`
       };
     const held = this.store.claims(input.projectId).find((c) => c.task === input.task && c.state === "held" && c.owner === input.owner);
-    let worktree2 = held?.worktree ?? "";
-    if (!worktree2) {
+    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 };
-      worktree2 = c.worktree;
+      worktree = c.worktree;
     }
-    await this.store.awaitBootstrap(worktree2);
+    await this.store.awaitBootstrap(worktree);
     const sessionId = crypto.randomUUID();
     const id = sessionId.slice(0, 8);
     const logDir = join6(this.home, "logs", project.id);
@@ -6750,20 +6766,20 @@ class Runner {
       args.push("--disallowedTools", ...profile.disallowedTools);
     if (input.maxTurns)
       args.push("--max-turns", String(input.maxTurns));
-    this.store.preregisterSpawnedSession(sessionId, project.id, worktree2, input.task);
+    this.store.preregisterSpawnedSession(sessionId, project.id, worktree, input.task);
     const proc = Bun.spawn(args, {
-      cwd: worktree2,
+      cwd: worktree,
       env: { ...process.env, SWARM_RUN_ID: id, SWARM_OWNER: input.owner },
       stdin: "pipe",
       stdout: "pipe",
       stderr: logFd
     });
-    const run2 = {
+    const run = {
       id,
       sessionId,
       projectId: project.id,
       task: input.task,
-      worktree: worktree2,
+      worktree,
       pid: proc.pid,
       owner: input.owner,
       model: input.model ?? null,
@@ -6777,20 +6793,20 @@ class Runner {
       result: null,
       pending: []
     };
-    this.live.set(id, { run: run2, proc });
+    this.live.set(id, { run, proc });
     this.store.registerProcess({
       pid: proc.pid,
       projectId: project.id,
       sessionId,
       kind: "proc",
       name: `run:${input.task}`,
-      cwd: worktree2,
+      cwd: worktree,
       cmd: `claude -p (run ${id})`,
       owner: input.owner,
       log
     });
     this.store.append({
-      ts: run2.startedAt,
+      ts: run.startedAt,
       type: "session.started",
       projectId: project.id,
       sessionId,
@@ -6798,7 +6814,7 @@ class Runner {
     });
     this.pump(id, proc);
     this.send(id, input.prompt);
-    return { ok: true, run: run2 };
+    return { ok: true, run };
   }
   async pump(id, proc) {
     const entry = this.live.get(id);
@@ -6857,7 +6873,7 @@ class Runner {
       }
     }
   }
-  onLine(run2, line) {
+  onLine(run, line) {
     if (!line.startsWith("{"))
       return;
     let j;
@@ -6867,41 +6883,41 @@ class Runner {
       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 ?? {});
+      this.onPermissionRequest(run, j.request_id, j.request.tool_name ?? "", j.request.input ?? {});
       return;
     }
     if (j.type !== "result")
       return;
-    run2.result = {
+    run.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,
+      ts: run.result.at,
       type: "run.result",
-      projectId: run2.projectId,
-      sessionId: run2.sessionId,
+      projectId: run.projectId,
+      sessionId: run.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" : ""}`
+        runId: run.id,
+        task: run.task,
+        ...run.result,
+        summary: `turn done \xB7 $${run.result.costUsd.toFixed(2)} \xB7 ${run.result.turns} turns${run.result.isError ? " \xB7 error" : ""}`
       }
     });
   }
-  onPermissionRequest(run2, requestId, tool, input) {
-    const { decision, display } = this.store.evaluateTool(tool, input, run2.sessionId, run2.worktree, true);
+  onPermissionRequest(run, requestId, tool, input) {
+    const { decision, display } = this.store.evaluateTool(tool, input, run.sessionId, run.worktree, true);
     if (decision.action === "deny") {
-      this.answerPermission(run2.id, requestId, false, `[swarm] ${decision.reason}`);
+      this.answerPermission(run.id, requestId, false, `[swarm] ${decision.reason}`);
       return;
     }
     if (decision.action === "allow") {
-      this.answerPermission(run2.id, requestId, true);
+      this.answerPermission(run.id, requestId, true);
       return;
     }
-    run2.pending.push({
+    run.pending.push({
       requestId,
       tool,
       input,
@@ -6912,10 +6928,10 @@ class Runner {
     this.store.append({
       ts: new Date().toISOString(),
       type: "permission.requested",
-      projectId: run2.projectId,
-      sessionId: run2.sessionId,
+      projectId: run.projectId,
+      sessionId: run.sessionId,
       payload: {
-        runId: run2.id,
+        runId: run.id,
         requestId,
         tool,
         display: display.slice(0, 300),
@@ -6975,17 +6991,17 @@ class Runner {
     return { ok: true };
   }
   async stop(id) {
-    const run2 = this.get(id);
-    if (!run2)
+    const run = this.get(id);
+    if (!run)
       return { ok: false, reason: "no live run" };
-    const entry = this.live.get(run2.id);
-    run2.stopped = true;
+    const entry = this.live.get(run.id);
+    run.stopped = true;
     try {
       const stdin = entry?.proc.stdin;
       if (stdin && typeof stdin !== "number")
         stdin.end();
     } catch {}
-    return this.store.stopProcess(run2.pid, run2.projectId, 5000);
+    return this.store.stopProcess(run.pid, run.projectId, 5000);
   }
   async stopAll() {
     await Promise.all([...this.live.keys()].map((id) => this.stop(id)));
@@ -7084,8 +7100,8 @@ class TaskSources {
     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 };
+      const tasks = kind === "github" ? await this.github(root, opts.labels) : await this.linear(opts.team);
+      entry = { at: Date.now(), tasks, error: null };
     } catch (e) {
       entry = { at: Date.now(), tasks: prev?.tasks ?? [], error: e.message };
     } finally {
@@ -7122,14 +7138,14 @@ class TaskSources {
 `)[0] ?? code}`);
     return normalizeGithubIssues(JSON.parse(out));
   }
-  async linear(team2) {
+  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(team2) })
+      body: JSON.stringify({ query: linearIssuesQuery(team) })
     });
     if (!r.ok)
       throw new Error(`Linear API ${r.status}`);
@@ -7267,14 +7283,14 @@ class Store {
     this.db.transaction(() => {
       for (const r of rows) {
         let payload;
-        let raw2;
+        let raw;
         try {
           payload = JSON.parse(r.payload);
-          raw2 = r.raw ? JSON.parse(r.raw) : undefined;
+          raw = r.raw ? JSON.parse(r.raw) : undefined;
         } catch {
           continue;
         }
-        const slim = slimForStorage({ payload, raw: raw2 });
+        const slim = slimForStorage({ payload, raw });
         upd.run(JSON.stringify(slim.payload ?? null), slim.raw === undefined ? null : JSON.stringify(slim.raw), r.seq);
       }
       this.setMeta("events_slim", "1");
@@ -7477,7 +7493,7 @@ class Store {
     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)))
+    if (manual.some((h) => !isAutoHandoff(h)))
       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 });
@@ -7753,10 +7769,10 @@ class Store {
     return out.length ? out.join(`
 `) : null;
   }
-  wfInsert(projectId, task, workflow, steps, actor2) {
+  wfInsert(projectId, task, workflow, steps, actor) {
     const now = new Date().toISOString();
     const r = this.db.query(`INSERT INTO workflow_runs (project_id, task, workflow, step, step_label, steps, state, started_at, updated_at, actor_kind, actor_id)
-         VALUES (?, ?, ?, 0, ?, ?, 'running', ?, ?, ?, ?)`).run(projectId, task, workflow, steps[0] ?? "", JSON.stringify(steps), now, now, actor2.kind, actor2.id);
+         VALUES (?, ?, ?, 0, ?, ?, 'running', ?, ?, ?, ?)`).run(projectId, task, workflow, steps[0] ?? "", JSON.stringify(steps), now, now, actor.kind, actor.id);
     this.touch();
     return Number(r.lastInsertRowid);
   }
@@ -7877,10 +7893,10 @@ class Store {
              OR (to_kind = 'task' AND project_id = ? AND task IS ?)
              OR (to_kind = 'lead' AND project_id = ? AND ? = 'interactive'))
          ORDER BY id`).all(sessionId, sessionId, s.project_id, task, s.project_id, s.kind);
-    const ms4 = rows.map(rowToMessage);
-    if (ms4.length && !opts.peek)
-      this.db.query(`UPDATE messages SET delivered_at = ?, session_id = ? WHERE id IN (${ms4.map(() => "?").join(",")})`).run(new Date().toISOString(), sessionId, ...ms4.map((m) => m.id));
-    return ms4;
+    const ms = rows.map(rowToMessage);
+    if (ms.length && !opts.peek)
+      this.db.query(`UPDATE messages SET delivered_at = ?, session_id = ? WHERE id IN (${ms.map(() => "?").join(",")})`).run(new Date().toISOString(), sessionId, ...ms.map((m) => m.id));
+    return ms;
   }
   markMessageDelivered(id, sessionId) {
     this.db.query("UPDATE messages SET delivered_at = ?, session_id = COALESCE(?, session_id) WHERE id = ? AND delivered_at IS NULL").run(new Date().toISOString(), sessionId, id);
@@ -7975,13 +7991,13 @@ class Store {
         reason: `gate ${gate} has no command \u2014 add [gates.${gate}] cmd = "\u2026" to .swarm.toml, or record it with swarm gate record`
       };
     const claim = this.claims(projectId).find((c) => c.task === task && c.state === "held");
-    const worktree2 = claim?.worktree;
-    if (!worktree2 || !existsSync6(worktree2))
+    const worktree = claim?.worktree;
+    if (!worktree || !existsSync6(worktree))
       return {
         ok: false,
         reason: `${task} has no held worktree to run ${gate} in \u2014 claim it first`
       };
-    const cwd = def.cwd ? join8(worktree2, def.cwd) : worktree2;
+    const cwd = def.cwd ? join8(worktree, def.cwd) : worktree;
     if (!existsSync6(cwd))
       return { ok: false, reason: `gate cwd ${cwd} does not exist` };
     const key = `${projectId}:${task}:${gate}`;
@@ -7992,7 +8008,7 @@ class Store {
     mkdirSync4(logDir, { recursive: true });
     const log = join8(logDir, `gate-${slug(task)}-${slug(gate)}.log`);
     if (def.builtin === "review")
-      return this.runReviewGate(projectId, task, gate, def, { worktree: worktree2, cwd, key, log }, opts);
+      return this.runReviewGate(projectId, task, gate, def, { worktree, cwd, key, log }, opts);
     writeFileSync2(log, `$ ${def.cmd}
 # cwd ${cwd} \xB7 ${new Date().toISOString()}
 `);
@@ -8006,7 +8022,7 @@ class Store {
         stderr: fd,
         env: {
           ...process.env,
-          SWARM_WORKTREE: worktree2,
+          SWARM_WORKTREE: worktree,
           SWARM_TASK: task,
           SWARM_GATE: gate,
           CI: process.env.CI ?? "1"
@@ -8014,7 +8030,7 @@ class Store {
       });
     } catch (e) {
       closeSync(fd);
-      const run2 = this.recordGate(projectId, {
+      const run = this.recordGate(projectId, {
         ...executedGateInput(task, gate, def.cmd, {
           exitCode: null,
           durationMs: 0,
@@ -8022,7 +8038,7 @@ class Store {
         }),
         sessionId: opts.sessionId ?? null
       });
-      return { ok: true, pid: 0, log, done: Promise.resolve(run2.ok ? run2.run : null) };
+      return { ok: true, pid: 0, log, done: Promise.resolve(run.ok ? run.run : null) };
     }
     const started = Date.now();
     const reg = this.registerProcess({
@@ -8061,10 +8077,10 @@ class Store {
         durationMs: Date.now() - started,
         output
       });
-      const run2 = this.recordGate(projectId, { ...input, sessionId: opts.sessionId ?? null });
+      const run = this.recordGate(projectId, { ...input, sessionId: opts.sessionId ?? null });
       if (reg.ok)
         this.processes(projectId);
-      return run2.ok ? run2.run : null;
+      return run.ok ? run.run : null;
     }).finally(() => {
       this.gateJobs.delete(key);
       this.touch();
@@ -8081,15 +8097,15 @@ class Store {
       return { ok: false, reason: "unknown project" };
     const started = Date.now();
     const record = (input) => {
-      const run2 = this.recordGate(projectId, { ...input, sessionId: opts.sessionId ?? null });
-      return run2.ok ? run2.run : null;
+      const run = this.recordGate(projectId, { ...input, sessionId: opts.sessionId ?? null });
+      return run.ok ? run.run : null;
     };
     const done = (async () => {
       let diffText = "";
-      let stat2 = "";
+      let stat = "";
       try {
         const diff = await worktreeDiff(p.root, where.worktree);
-        stat2 = diff.files.map((f) => `${f.status ?? "M"} ${f.path} (+${f.added} -${f.deleted})`).join(`
+        stat = diff.files.map((f) => `${f.status ?? "M"} ${f.path} (+${f.added} -${f.deleted})`).join(`
 `);
         diffText = await worktreePatch(where.worktree, diff.base);
       } catch (e) {
@@ -8111,7 +8127,7 @@ class Store {
         task,
         title: taskRow?.title ?? null,
         branch: w?.branch ?? null,
-        stat: stat2,
+        stat,
         patch: diffText
       });
       writeFileSync2(where.log, `$ claude -p <review prompt, ${prompt.length} chars> --output-format json (read-only)
@@ -8200,9 +8216,9 @@ ${err}
     this.gateJobs.set(where.key, done);
     return { ok: true, pid: 0, log: where.log, done };
   }
-  async runGates(projectId, task, gates2, opts = {}) {
+  async runGates(projectId, task, gates, opts = {}) {
     const cfg = this.gateDefs(projectId);
-    const names = gates2?.length ? gates2 : (cfg?.required ?? []).filter((g) => cfg?.defs[g]);
+    const names = gates?.length ? gates : (cfg?.required ?? []).filter((g) => cfg?.defs[g]);
     const key = `${projectId}:${task}`;
     const batch = (async () => {
       const started = [];
@@ -8215,9 +8231,9 @@ ${err}
           continue;
         }
         started.push(g);
-        const run2 = await r.done;
-        if (run2)
-          runs.push(run2);
+        const run = await r.done;
+        if (run)
+          runs.push(run);
       }
       return { started, skipped, runs };
     })();
@@ -8271,21 +8287,21 @@ ${err}
     const sessionId = this.knownSession(input.sessionId);
     const r = this.db.query(`INSERT INTO gates (project_id, task, gate, verdict, rubric, evidence, session_id, duration_ms, created_at, actor_kind, actor_id)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(projectId, input.task.trim(), input.gate, input.verdict, input.rubric.trim(), input.evidence?.trim() || null, sessionId, typeof input.durationMs === "number" ? Math.max(0, Math.round(input.durationMs)) : null, createdAt, ...actorCols(this.actorFor(input.sessionId ? null : "daemon", sessionId)));
-    const run2 = this.rowToGate(this.db.query("SELECT * FROM gates WHERE id = ?").get(Number(r.lastInsertRowid)));
-    this.remember(gateDoc(projectId, run2.id, run2, sessionId));
+    const run = this.rowToGate(this.db.query("SELECT * FROM gates WHERE id = ?").get(Number(r.lastInsertRowid)));
+    this.remember(gateDoc(projectId, run.id, run, 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}`
+        task: run.task,
+        gate: run.gate,
+        verdict: run.verdict,
+        summary: `gate ${run.gate} ${run.verdict} on ${run.task}`
       }
     });
-    if (run2.verdict === "fail")
+    if (run.verdict === "fail")
       this.append({
         ts: createdAt,
         type: "incident.opened",
@@ -8294,12 +8310,12 @@ ${err}
         payload: {
           rule: "gate_failed",
           action: "failed",
-          command: `${run2.task} \xB7 ${run2.gate}`,
-          reason: `${run2.rubric}${run2.evidence ? ` \u2014 ${run2.evidence.slice(0, 200)}` : ""}`
+          command: `${run.task} \xB7 ${run.gate}`,
+          reason: `${run.rubric}${run.evidence ? ` \u2014 ${run.evidence.slice(0, 200)}` : ""}`
         }
       });
     this.touch();
-    return { ok: true, run: run2 };
+    return { ok: true, run };
   }
   taskCache = new Map;
   taskSources = new TaskSources;
@@ -8383,8 +8399,8 @@ ${err}
     const row = this.db.query("SELECT id FROM projects WHERE root = ?").get(root);
     return row?.id ?? null;
   }
-  noteRuleChange(key, rules2) {
-    const sig = JSON.stringify(Object.entries(rules2).sort());
+  noteRuleChange(key, rules) {
+    const sig = JSON.stringify(Object.entries(rules).sort());
     const metaKey = `rules.sig:${key}`;
     const prev = this.db.query("SELECT value FROM meta WHERE key = ?").get(metaKey)?.value;
     if (prev === sig)
@@ -8393,7 +8409,7 @@ ${err}
     if (prev === undefined)
       return;
     const before = new Map(JSON.parse(prev));
-    const after = new Map(Object.entries(rules2));
+    const after = new Map(Object.entries(rules));
     const added = [...after.keys()].filter((r) => !before.has(r)).sort();
     const removed = [...before.keys()].filter((r) => !after.has(r)).sort();
     const retuned = [...after.entries()].filter(([r, mode]) => before.has(r) && before.get(r) !== mode).map(([r, mode]) => `${r}=${mode}`).sort();
@@ -8533,11 +8549,11 @@ ${err}
       state: r.state
     }));
   }
-  guardHook(raw2) {
-    const tool = typeof raw2.tool_name === "string" ? raw2.tool_name : "";
-    const input = raw2.tool_input ?? {};
-    const id = typeof raw2.session_id === "string" ? raw2.session_id : "";
-    const cwd = typeof raw2.cwd === "string" ? raw2.cwd : "";
+  guardHook(raw) {
+    const tool = typeof raw.tool_name === "string" ? raw.tool_name : "";
+    const input = raw.tool_input ?? {};
+    const id = typeof raw.session_id === "string" ? raw.session_id : "";
+    const cwd = typeof raw.cwd === "string" ? raw.cwd : "";
     const isWrite = WRITE_TOOLS.has(tool) && typeof input.file_path === "string";
     const cmd = tool === "Bash" ? input.command : undefined;
     if (!isWrite && !cmd)
@@ -8682,6 +8698,9 @@ ${err}
       createdAt: r.created_at
     }));
   }
+  liveProjects() {
+    return this.projects().filter((p) => !(p.discovered && isScratchRoot(p.root)));
+  }
   project(id) {
     const r = this.db.query("SELECT * FROM projects WHERE id = ?").get(id);
     if (!r)
@@ -8714,9 +8733,9 @@ ${err}
     if (!explicit) {
       const hit = this.cwdProject.get(path);
       if (hit && Date.now() - hit.t < 60000) {
-        const p2 = this.project(hit.id);
-        if (p2)
-          return p2;
+        const p = this.project(hit.id);
+        if (p)
+          return p;
       }
     }
     const p = this.resolveProjectUncached(path, explicit, name);
@@ -8810,25 +8829,25 @@ ${err}
       e = { ...e, payload: redactValue(e.payload, res), raw: redactValue(e.raw, res) };
     const slim = slimForStorage(e);
     const p = e.payload ?? {};
-    const actor2 = e.actor ?? this.actorFor(typeof p.owner === "string" ? p.owner : typeof p.by === "string" ? p.by : null, e.sessionId);
-    const r = this.db.query("INSERT INTO events (ts, type, project_id, session_id, payload, raw, actor_kind, actor_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(e.ts, e.type, e.projectId, e.sessionId, JSON.stringify(slim.payload ?? null), slim.raw === undefined ? null : JSON.stringify(slim.raw), actor2.kind, actor2.id);
-    const stored = { ...e, actor: actor2, seq: Number(r.lastInsertRowid) };
+    const actor = e.actor ?? this.actorFor(typeof p.owner === "string" ? p.owner : typeof p.by === "string" ? p.by : null, e.sessionId);
+    const r = this.db.query("INSERT INTO events (ts, type, project_id, session_id, payload, raw, actor_kind, actor_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(e.ts, e.type, e.projectId, e.sessionId, JSON.stringify(slim.payload ?? null), slim.raw === undefined ? null : JSON.stringify(slim.raw), actor.kind, actor.id);
+    const stored = { ...e, actor, 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);
     if (stored.type === "incident.opened") {
       const webhook = this.policyFor(null).config.notify.webhook;
       if (webhook) {
-        const p2 = stored.payload ?? {};
+        const p = stored.payload ?? {};
         const project = this.project(stored.projectId)?.name ?? stored.projectId;
         fetch(webhook, {
           method: "POST",
           headers: { "content-type": "application/json" },
           body: JSON.stringify({
-            text: `Swarm incident \xB7 ${p2.rule ?? "?"} \xB7 ${project}
-${p2.command ?? ""}
-${p2.reason ?? ""}`.trim(),
-            rule: p2.rule,
+            text: `Swarm incident \xB7 ${p.rule ?? "?"} \xB7 ${project}
+${p.command ?? ""}
+${p.reason ?? ""}`.trim(),
+            rule: p.rule,
             project,
             sessionId: stored.sessionId,
             ts: stored.ts
@@ -8837,15 +8856,15 @@ ${p2.reason ?? ""}`.trim(),
         }).catch(() => {});
       }
     }
-    const team2 = this.policyFor(null).config.team;
-    if (team2.url && team2.forward.includes("ledger") && isAuditType(stored.type)) {
+    const team = this.policyFor(null).config.team;
+    if (team.url && team.forward.includes("ledger") && isAuditType(stored.type)) {
       this.db.query("INSERT INTO outbox (kind, payload, created_at) VALUES ('event', ?, ?)").run(JSON.stringify({
         seq: stored.seq,
         ts: stored.ts,
         type: stored.type,
         projectId: stored.projectId,
         sessionId: stored.sessionId,
-        actor: actor2,
+        actor,
         payload: slim.payload ?? null
       }), stored.ts);
     }
@@ -8898,9 +8917,9 @@ ${p2.reason ?? ""}`.trim(),
     const rows = this.db.query(`SELECT * FROM (SELECT ${WIRE_COLS} FROM events WHERE ${where.join(" AND ")} ORDER BY seq DESC LIMIT ?) ORDER BY seq`).all(...args, limit);
     return rows.map((r) => auditRow(wireRowToEvent(r)));
   }
-  prune(days3) {
+  prune(days) {
     const cfg = this.policyFor(null).config;
-    const chatter = days3 ?? cfg.events.retain_days;
+    const chatter = days ?? cfg.events.retain_days;
     const cutoff = new Date(Date.now() - chatter * 86400000).toISOString();
     let n = this.db.query(`DELETE FROM events WHERE ts < ? AND type NOT IN (${AUDIT_TYPES_SQL})`).run(cutoff).changes;
     if (cfg.audit.retain_days > 0) {
@@ -8913,12 +8932,12 @@ ${p2.reason ?? ""}`.trim(),
       this.touch();
     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();
+  ingestHook(event, raw) {
+    if (typeof raw.cwd === "string")
+      this.autoRenewFor(typeof raw.session_id === "string" ? raw.session_id : null, raw.cwd);
+    const cwd = typeof raw.cwd === "string" ? raw.cwd : process.cwd();
     const project = existsSync6(cwd) ? this.resolveProject(cwd) : null;
-    const e = this.append(normalizeHook(event, raw2, project?.id ?? "p_unknown"));
+    const e = this.append(normalizeHook(event, raw, project?.id ?? "p_unknown"));
     if ((event === "Stop" || event === "SessionEnd") && e.sessionId) {
       if (existsSync6(cwd)) {
         this.autoHandoff(e.sessionId, cwd);
@@ -8926,8 +8945,8 @@ ${p2.reason ?? ""}`.trim(),
       }
       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);
+    if (e.sessionId && typeof raw.transcript_path === "string") {
+      this.db.query("UPDATE sessions SET transcript_path = ? WHERE id = ? AND transcript_path IS NULL").run(raw.transcript_path, e.sessionId);
       const last = this.lastTail.get(e.sessionId) ?? 0;
       if (Date.now() - last > 2000) {
         this.lastTail.set(e.sessionId, Date.now());
@@ -9468,11 +9487,11 @@ ${p2.reason ?? ""}`.trim(),
       return { ok: false, error: claimRefusalMessage(decision, task) };
     }
     const branch = `task/${task}`;
-    const worktree2 = this.worktreePath(projectId, task);
-    if (existsSync6(worktree2))
-      return { ok: false, error: `${worktree2} already exists; release ${task} first` };
-    mkdirSync4(dirname3(worktree2), { recursive: true });
-    const created = worktreeAdd(p.root, worktree2, branch, baseRef);
+    const worktree = this.worktreePath(projectId, task);
+    if (existsSync6(worktree))
+      return { ok: false, error: `${worktree} already exists; release ${task} first` };
+    mkdirSync4(dirname3(worktree), { recursive: true });
+    const created = worktreeAdd(p.root, worktree, branch, baseRef);
     if (!created)
       return { ok: false, error: `git worktree add failed for ${task}` };
     this.invalidateWorktrees(projectId);
@@ -9495,13 +9514,13 @@ ${p2.reason ?? ""}`.trim(),
     return { ok: true, task, owner, worktree: created, branch, expiresAt, bootstrap };
   }
   bootstraps = new Map;
-  bootstrapWorktree(projectId, task, repoRoot, worktree2) {
-    const plan = planBootstrap(loadConfig({ repoRoot, home: this.home }), repoRoot, worktree2);
+  bootstrapWorktree(projectId, task, repoRoot, worktree) {
+    const plan = planBootstrap(loadConfig({ repoRoot, home: this.home }), repoRoot, worktree);
     if (!needsBootstrap(plan))
       return null;
-    const job = runBootstrap(plan, { worktree: worktree2, home: this.home, projectId, task });
+    const job = runBootstrap(plan, { worktree, home: this.home, projectId, task });
     const done = job.done.then((o) => {
-      this.bootstraps.delete(worktree2);
+      this.bootstraps.delete(worktree);
       const ts = new Date().toISOString();
       const ok = !o.setup || o.setup.exitCode === 0;
       this.append({
@@ -9511,7 +9530,7 @@ ${p2.reason ?? ""}`.trim(),
         sessionId: null,
         payload: {
           task,
-          worktree: worktree2,
+          worktree,
           ok,
           log: job.log,
           ...o,
@@ -9534,11 +9553,11 @@ ${p2.reason ?? ""}`.trim(),
       this.touch();
       return o;
     });
-    this.bootstraps.set(worktree2, done);
+    this.bootstraps.set(worktree, done);
     return job.log;
   }
-  awaitBootstrap(worktree2) {
-    return this.bootstraps.get(worktree2) ?? Promise.resolve();
+  awaitBootstrap(worktree) {
+    return this.bootstraps.get(worktree) ?? Promise.resolve();
   }
   autoRenewAt = new Map;
   autoRenewFor(sessionId, cwd) {
@@ -9574,8 +9593,8 @@ ${p2.reason ?? ""}`.trim(),
       expiresAt: r.expires_at
     }));
   }
-  waiting(projectId, days3 = 7) {
-    const since = new Date(Date.now() - days3 * 86400000).toISOString();
+  waiting(projectId, days = 7) {
+    const since = new Date(Date.now() - days * 86400000).toISOString();
     const pArgs = projectId ? [projectId] : [];
     const paired = this.db.query(`SELECT type, session_id, project_id, ts,
                 COALESCE(json_extract(payload,'$.requestId'), json_extract(payload,'$.id')) AS key,
@@ -9643,8 +9662,8 @@ ${p2.reason ?? ""}`.trim(),
       }))
     };
   }
-  gateHealth(projectId, days3 = 30) {
-    const since = new Date(Date.now() - days3 * 86400000).toISOString();
+  gateHealth(projectId, days = 30) {
+    const since = new Date(Date.now() - days * 86400000).toISOString();
     const rows = this.db.query(`SELECT project_id, task, gate, verdict, duration_ms, created_at FROM gates
          WHERE created_at >= ?${projectId ? " AND project_id = ?" : ""}`).all(...projectId ? [since, projectId] : [since]);
     return gateHealth(rows.filter((r) => r.verdict === "pass" || r.verdict === "fail").map((r) => ({
@@ -9784,8 +9803,8 @@ ${p2.reason ?? ""}`.trim(),
     this.refreshDisk(trees.map((t) => t.path), diskTtlMs);
     return hygieneReport(procs, trees);
   }
-  lineage(projectId, days3 = 14, expanded = []) {
-    const since = new Date(Date.now() - days3 * 86400000).toISOString();
+  lineage(projectId, days = 14, expanded = []) {
+    const since = new Date(Date.now() - days * 86400000).toISOString();
     const pArgs = projectId ? [projectId] : [];
     const rows = this.db.query(`SELECT id, project_id, title, agent, kind, state, parent_id, started_at, ended_at
          FROM sessions WHERE last_seen_at >= ?${projectId ? " AND project_id = ?" : ""}`).all(since, ...pArgs);
@@ -9856,8 +9875,8 @@ ${p2.reason ?? ""}`.trim(),
     edges.push(...handoffEdges(holds));
     return lineageGraph(sessions, edges, { expanded });
   }
-  mcpHealth(projectId, days3 = 7) {
-    const since = new Date(Date.now() - days3 * 86400000).toISOString();
+  mcpHealth(projectId, days = 7) {
+    const since = new Date(Date.now() - days * 86400000).toISOString();
     const rows = this.db.query(`SELECT session_id, seq, ts, type,
                 json_extract(payload,'$.tool') AS tool,
                 json_extract(payload,'$.toolResponse') AS response
@@ -9897,8 +9916,8 @@ ${p2.reason ?? ""}`.trim(),
         abandon(sessionId, tool, at);
     return mcpHealth(calls);
   }
-  context(projectId, days3 = 7) {
-    const since = new Date(Date.now() - days3 * 86400000).toISOString();
+  context(projectId, days = 7) {
+    const since = new Date(Date.now() - days * 86400000).toISOString();
     const pArgs = projectId ? [projectId] : [];
     const where = projectId ? " AND project_id = ?" : "";
     const results = this.db.query(`SELECT session_id, json_extract(payload,'$.tool') AS tool,
@@ -9945,10 +9964,10 @@ ${p2.reason ?? ""}`.trim(),
     const projects = projectId ? [projectId] : this.projects().map((p) => p.id);
     const out = [];
     for (const pid of projects) {
-      const tasks2 = [
+      const tasks = [
         ...new Set(this.claims(pid).map((c) => splitArmTask(c.task)).filter((x) => x.arm).map((x) => x.task))
       ];
-      for (const t of tasks2.sort())
+      for (const t of tasks.sort())
         out.push({ ...this.abTrial(pid, t), projectId: pid });
     }
     const rank = { undecided: 0, "all-failed": 1, winner: 2 };
@@ -10006,8 +10025,8 @@ ${p2.reason ?? ""}`.trim(),
       const sid = sess?.id ?? c.sessionId;
       const g = gateRuns.filter((x) => x.task === c.task);
       const latest = new Map;
-      for (const run2 of [...g].sort((a, b) => a.createdAt < b.createdAt ? -1 : 1))
-        latest.set(run2.gate, run2);
+      for (const run of [...g].sort((a, b) => a.createdAt < b.createdAt ? -1 : 1))
+        latest.set(run.gate, run);
       const verdicts = [...latest.values()];
       const diff = c.worktree ? this.diffCache.get(c.worktree)?.v : null;
       arms.push({
@@ -10057,8 +10076,8 @@ ${p2.reason ?? ""}`.trim(),
       })
     };
   }
-  transitions(projectId, days3 = 7, minWeight = 1) {
-    const since = new Date(Date.now() - days3 * 86400000).toISOString();
+  transitions(projectId, days = 7, minWeight = 1) {
+    const since = new Date(Date.now() - days * 86400000).toISOString();
     const rows = this.db.query(`SELECT session_id, json_extract(payload,'$.tool') AS tool
          FROM events
          WHERE type = 'tool.requested' AND ts >= ?
@@ -10066,14 +10085,14 @@ ${p2.reason ?? ""}`.trim(),
          ORDER BY session_id, seq`).all(...projectId ? [since, projectId] : [since]);
     return transitionGraph(rows.map((r) => ({ sessionId: r.session_id ?? "", tool: r.tool ?? "" })), { minWeight });
   }
-  resourceHolding(projectId, days3 = 3) {
-    const since = new Date(Date.now() - days3 * 86400000).toISOString();
+  resourceHolding(projectId, days = 3) {
+    const since = new Date(Date.now() - days * 86400000).toISOString();
     const p = projectId ? " AND c.project_id = ?" : "";
     const args = projectId ? [projectId] : [];
     const ended = new Map(this.db.query("SELECT id, ended_at FROM sessions WHERE ended_at IS NOT NULL").all().map((r) => [r.id, r.ended_at]));
     const claims = this.db.query(`SELECT c.task AS name, c.owner, c.project_id, c.expires_at, c.actor_id AS session_id
          FROM claims c WHERE c.state = 'held' AND c.released_at IS NULL${p}`).all(...args);
-    const resources2 = this.db.query(`SELECT c.name, c.owner, c.project_id, c.expires_at, c.session_id, c.port
+    const resources = this.db.query(`SELECT c.name, c.owner, c.project_id, c.expires_at, c.session_id, c.port
          FROM resources c WHERE c.released = 0${p}`).all(...args);
     const procs = this.db.query(`SELECT c.name, c.owner, c.project_id, c.session_id, c.port
          FROM processes c WHERE c.ended_at IS NULL${p}`).all(...args);
@@ -10090,7 +10109,7 @@ ${p2.reason ?? ""}`.trim(),
         expiresAt: r.expires_at,
         projectId: r.project_id
       })),
-      ...resources2.map((r) => ({
+      ...resources.map((r) => ({
         kind: r.port ? "port" : "lease",
         name: r.port ? String(r.port) : r.name,
         owner: r.owner ?? "unknown",
@@ -10119,8 +10138,8 @@ ${p2.reason ?? ""}`.trim(),
     }));
     return resourceGraph(held, wanted);
   }
-  fileHeat(projectId, days3 = 14) {
-    const since = new Date(Date.now() - days3 * 86400000).toISOString();
+  fileHeat(projectId, days = 14) {
+    const since = new Date(Date.now() - days * 86400000).toISOString();
     const rows = this.db.query(`SELECT session_id, json_extract(payload,'$.tool') AS tool,
                 json_extract(payload,'$.toolInput.file_path') AS path
          FROM events
@@ -10128,8 +10147,8 @@ ${p2.reason ?? ""}`.trim(),
            AND json_extract(payload,'$.toolInput.file_path') IS NOT NULL${projectId ? " AND project_id = ?" : ""}`).all(...projectId ? [since, projectId] : [since]);
     return fileHeat(rows.map((r) => ({ sessionId: r.session_id ?? "", tool: r.tool ?? "", path: r.path ?? "" })));
   }
-  security(projectId, days3 = 14) {
-    const since = new Date(Date.now() - days3 * 86400000).toISOString();
+  security(projectId, days = 14) {
+    const since = new Date(Date.now() - days * 86400000).toISOString();
     const rows = this.db.query(`SELECT session_id, ts, json_extract(payload,'$.tool') AS tool,
                 COALESCE(json_extract(payload,'$.toolInput.command'),
                          json_extract(payload,'$.toolInput.url'), '') AS command,
@@ -10144,8 +10163,8 @@ ${p2.reason ?? ""}`.trim(),
       at: r.ts
     })));
   }
-  ruleEffect(projectId, days3 = 30) {
-    const since = new Date(Date.now() - days3 * 86400000).toISOString();
+  ruleEffect(projectId, days = 30) {
+    const since = new Date(Date.now() - days * 86400000).toISOString();
     const rows = this.db.query(`SELECT e.seq, e.ts,
                 json_extract(e.payload,'$.rule') AS rule,
                 COALESCE(json_extract(e.payload,'$.command'), '') AS command,
@@ -10159,7 +10178,7 @@ ${p2.reason ?? ""}`.trim(),
       command: r.command ?? "",
       at: r.ts,
       acked: Boolean(r.acked)
-    })), changes.map((c) => ({ at: c.ts, added: JSON.parse(c.added) })), Date.now(), days3);
+    })), changes.map((c) => ({ at: c.ts, added: JSON.parse(c.added) })), Date.now(), days);
   }
   reclaimBuild(path, { dryRun = false } = {}) {
     const report = this.hygiene();
@@ -10206,6 +10225,7 @@ ${p2.reason ?? ""}`.trim(),
   checkStalls() {
     const live = this.db.query("SELECT id, project_id FROM sessions WHERE state IN ('active','waiting') AND ended_at IS NULL AND last_seen_at >= ?").all(new Date(Date.now() - IDLE_MS).toISOString());
     const liveIds = new Set(live.map((s) => s.id));
+    const before = JSON.stringify([...this.stalls].map(([id, v]) => [id, v.kind, v.reason]));
     for (const id of [...this.stalls.keys()])
       if (!liveIds.has(id))
         this.stalls.delete(id);
@@ -10224,15 +10244,15 @@ ${p2.reason ?? ""}`.trim(),
           ts: ""
         };
       });
-      const stall2 = detectStall(calls);
-      if (!stall2) {
+      const stall = detectStall(calls);
+      if (!stall) {
         this.stalls.delete(s.id);
         continue;
       }
       flagged++;
       const prev = this.stalls.get(s.id);
-      this.stalls.set(s.id, stall2);
-      if (prev?.kind === stall2.kind)
+      this.stalls.set(s.id, stall);
+      if (prev?.kind === stall.kind)
         continue;
       this.append({
         ts: new Date().toISOString(),
@@ -10240,13 +10260,16 @@ ${p2.reason ?? ""}`.trim(),
         projectId: s.project_id,
         sessionId: s.id,
         payload: {
-          kind: stall2.kind,
-          reason: stall2.reason,
-          summary: `session looks stuck \u2014 ${stall2.reason}`
+          kind: stall.kind,
+          reason: stall.reason,
+          summary: `session looks stuck \u2014 ${stall.reason}`
         }
       });
       this.touch();
     }
+    const after = JSON.stringify([...this.stalls].map(([id, v]) => [id, v.kind, v.reason]));
+    if (after !== before)
+      this.touch();
     return flagged;
   }
   sweepOrphans() {
@@ -10311,18 +10334,18 @@ ${p2.reason ?? ""}`.trim(),
     const row = this.db.query("SELECT * FROM claims WHERE project_id = ? AND task = ?").get(projectId, task);
     if (!row)
       return { ok: false, error: `no claim on ${task}` };
-    const worktree2 = row.worktree ?? "";
-    if (worktree2 && existsSync6(worktree2)) {
-      const work = heldWork(worktree2);
+    const worktree = row.worktree ?? "";
+    if (worktree && existsSync6(worktree)) {
+      const work = heldWork(worktree);
       const can = canRelease(work, force);
       if (!can.ok)
         return {
           ok: false,
-          error: releaseRefusalMessage(can, worktree2),
+          error: releaseRefusalMessage(can, worktree),
           refused: can.reason
         };
-      if (p && !worktreeRemove(p.root, worktree2, force))
-        return { ok: false, error: `git worktree remove failed for ${worktree2}` };
+      if (p && !worktreeRemove(p.root, worktree, force))
+        return { ok: false, error: `git worktree remove failed for ${worktree}` };
       this.invalidateWorktrees(projectId);
     }
     const releasedAt = new Date().toISOString();
@@ -10431,12 +10454,12 @@ ${p2.reason ?? ""}`.trim(),
     const p = this.project(projectId);
     if (!p)
       return Promise.resolve([]);
-    const run2 = listWorktreesAsync(p.root).then((v) => {
+    const run = listWorktreesAsync(p.root).then((v) => {
       this.wtCache.set(projectId, { v, t: Date.now() });
       return v;
     }).finally(() => this.wtInflight.delete(projectId));
-    this.wtInflight.set(projectId, run2);
-    return run2;
+    this.wtInflight.set(projectId, run);
+    return run;
   }
   createWorktree(projectId, name, baseRef = "HEAD", branch) {
     const p = this.project(projectId);
@@ -10548,7 +10571,7 @@ ${p2.reason ?? ""}`.trim(),
     const taskRow = this.tasks(projectId)?.tasks.find((t) => t.id === task) ?? null;
     const handoff = this.latestHandoff(projectId, task);
     const required = this.requiredGates(projectId);
-    const gates2 = required.length ? this.gateStatusFor(this.gateRuns(projectId, task), required).map((g) => ({
+    const gates = required.length ? this.gateStatusFor(this.gateRuns(projectId, task), required).map((g) => ({
       gate: g.gate,
       verdict: g.verdict
     })) : [];
@@ -10557,19 +10580,19 @@ ${p2.reason ?? ""}`.trim(),
       task,
       title: taskRow?.title ?? null,
       handoff,
-      gates: gates2,
+      gates,
       files: diff.files,
       commits: diff.commits
     });
     return { ok: true, task, worktree: w, ...d, diff };
   }
-  recordPrOpened(projectId, task, worktree2, url) {
+  recordPrOpened(projectId, task, worktree, url) {
     this.append({
       ts: new Date().toISOString(),
       type: "pr.opened",
       projectId,
       sessionId: null,
-      payload: { task, worktree: worktree2, url, summary: `PR opened for ${task}: ${url}` }
+      payload: { task, worktree, url, summary: `PR opened for ${task}: ${url}` }
     });
     this.touch();
   }
@@ -10580,22 +10603,31 @@ ${p2.reason ?? ""}`.trim(),
       this.wtCache.clear();
   }
   async refreshAllWorktrees() {
-    await Promise.all(this.projects().map((p) => this.refreshWorktrees(p.id)));
+    await Promise.all(this.liveProjects().map((p) => this.refreshWorktrees(p.id)));
   }
   sessions() {
+    return this.memoised("sessions", 2000, () => this.computeSessions());
+  }
+  computeSessions() {
+    const page = this.db.query("SELECT id FROM sessions ORDER BY last_seen_at DESC LIMIT 200").all();
+    if (!page.length)
+      return [];
+    const ids = page.map((r) => r.id);
+    const holes = ids.map(() => "?").join(",");
     const rows = this.db.query(`SELECT s.*, COUNT(t.id) AS turns, COALESCE(SUM(t.input),0) AS input, COALESCE(SUM(t.output),0) AS output,
                 COALESCE(SUM(t.cache_write),0) AS cache_write, COALESCE(SUM(t.cache_read),0) AS cache_read, COALESCE(SUM(t.thinking),0) AS thinking,
                 SUM(t.cost_usd) AS cost_usd, MAX(t.cost_usd IS NULL AND t.id IS NOT NULL) AS unpriced,
                 (SELECT model FROM turns lt WHERE lt.session_id = s.id AND lt.agent_id IS NULL AND lt.sidechain = 0 ORDER BY lt.ts DESC LIMIT 1) AS live_model,
                 (SELECT COUNT(DISTINCT model) FROM turns lm WHERE lm.session_id = s.id AND lm.agent_id IS NULL AND lm.sidechain = 0) AS model_count
          FROM sessions s LEFT JOIN turns t ON t.session_id = s.id
-         GROUP BY s.id ORDER BY s.last_seen_at DESC LIMIT 200`).all();
+         WHERE s.id IN (${holes})
+         GROUP BY s.id ORDER BY s.last_seen_at DESC`).all(...ids);
     const idleBefore = Date.now() - IDLE_MS;
     const sparkRows = this.db.query(`SELECT session_id, output, cost_usd FROM (
            SELECT t.session_id, t.output, t.cost_usd, t.ts,
                   ROW_NUMBER() OVER (PARTITION BY t.session_id ORDER BY t.ts DESC) AS rn
-           FROM turns t WHERE t.agent_id IS NULL AND t.sidechain = 0
-         ) WHERE rn <= 24 ORDER BY ts`).all();
+           FROM turns t WHERE t.agent_id IS NULL AND t.sidechain = 0 AND t.session_id IN (${holes})
+         ) WHERE rn <= 24 ORDER BY ts`).all(...ids);
     const sparks = new Map;
     for (const x of sparkRows) {
       const a = sparks.get(x.session_id) ?? [];
@@ -10869,10 +10901,10 @@ ${p2.reason ?? ""}`.trim(),
       for (const [k, v] of Object.entries(JSON.parse(r.tc || "{}")))
         tools[k] = (tools[k] ?? 0) + v;
     }
-    const sessionRow = (order2) => this.db.query(`SELECT s.id, s.title, s.project_id AS projectId, s.started_at AS startedAt, s.last_seen_at AS lastSeenAt,
+    const sessionRow = (order) => this.db.query(`SELECT s.id, s.title, s.project_id AS projectId, s.started_at AS startedAt, s.last_seen_at AS lastSeenAt,
                   COUNT(t.id) AS turns, SUM(t.cost_usd) AS cost, SUM(t.output) AS output, s.tool_calls AS toolCalls
            FROM sessions s JOIN turns t ON t.session_id = s.id WHERE ${scope} AND s.kind != 'subagent'
-           GROUP BY s.id ORDER BY ${order2} DESC LIMIT 1`).get(arg);
+           GROUP BY s.id ORDER BY ${order} DESC LIMIT 1`).get(arg);
     const biggestTurn = this.db.query(`SELECT t.session_id AS sessionId, s.title, t.ts, t.output, t.thinking, t.cost_usd AS cost, t.model
          FROM turns t JOIN sessions s ON s.id = t.session_id WHERE ${scope} ORDER BY t.output DESC LIMIT 1`).get(arg);
     const busiestDay = daily.slice().sort((a, b) => (b.cost ?? 0) - (a.cost ?? 0) || b.turns - a.turns)[0] ?? null;
@@ -11012,8 +11044,8 @@ ${p2.reason ?? ""}`.trim(),
     const rows = this.db.query("SELECT * FROM resources WHERE released = 0").all();
     const now = Date.now();
     let n = 0;
-    for (const raw2 of rows)
-      if (this.reapIfDead(this.rowToResource(raw2), now))
+    for (const raw of rows)
+      if (this.reapIfDead(this.rowToResource(raw), now))
         n++;
     return n;
   }
@@ -11154,11 +11186,11 @@ ${p2.reason ?? ""}`.trim(),
     return { ok: true, process: p };
   }
   async stopProcess(pid, projectId, graceMs = 3000) {
-    const raw2 = this.db.query(`SELECT rowid, * FROM processes WHERE pid = ? AND ended_at IS NULL${projectId ? " AND project_id = ?" : ""}`).get(...projectId ? [pid, projectId] : [pid]);
-    if (!raw2)
+    const raw = this.db.query(`SELECT rowid, * FROM processes WHERE pid = ? AND ended_at IS NULL${projectId ? " AND project_id = ?" : ""}`).get(...projectId ? [pid, projectId] : [pid]);
+    if (!raw)
       return { ok: false, reason: "not a registered process" };
-    const p = this.rowToProcess(raw2);
-    const rowid = raw2.rowid;
+    const p = this.rowToProcess(raw);
+    const rowid = raw.rowid;
     if (!this.processIsOurs(p)) {
       this.endProcess(rowid, p, "exited");
       return { ok: true, reason: "already gone" };
@@ -11185,8 +11217,8 @@ ${p2.reason ?? ""}`.trim(),
   }
   acquireResource(input) {
     const key = input.projectId ?? "";
-    const raw2 = this.db.query("SELECT * FROM resources WHERE name = ? AND project_id = ?").get(input.name, key);
-    let existing = raw2 ? this.rowToResource(raw2) : null;
+    const raw = this.db.query("SELECT * FROM resources WHERE name = ? AND project_id = ?").get(input.name, key);
+    let existing = raw ? this.rowToResource(raw) : null;
     if (existing && this.reapIfDead(existing))
       existing = null;
     const d = canAcquire(existing, { owner: input.owner }, Date.now(), Store.pidAlive);
@@ -11228,10 +11260,10 @@ ${p2.reason ?? ""}`.trim(),
     return { ok: true, resource };
   }
   releaseResource(name, projectId, owner, force = false) {
-    const raw2 = this.db.query("SELECT * FROM resources WHERE name = ? AND project_id = ? AND released = 0").get(name, projectId ?? "");
-    if (!raw2)
+    const raw = this.db.query("SELECT * FROM resources WHERE name = ? AND project_id = ? AND released = 0").get(name, projectId ?? "");
+    if (!raw)
       return { ok: false, reason: "not held" };
-    const r = this.rowToResource(raw2);
+    const r = this.rowToResource(raw);
     if (!force) {
       if (!owner)
         return { ok: false, reason: `held by ${r.owner}; pass owner or force` };
@@ -11285,14 +11317,14 @@ ${p2.reason ?? ""}`.trim(),
     const from = localDayIso(-13);
     const rows = this.db.query(`SELECT s.project_id AS pid, substr(t.ts, 1, 10) AS day, SUM(t.cost_usd) AS usd
          FROM turns t JOIN sessions s ON s.id = t.session_id WHERE t.ts >= ? GROUP BY pid, day`).all(from);
-    const days3 = [];
+    const days = [];
     for (let i = 13;i >= 0; i--)
-      days3.push(localDayIso(-i).slice(0, 10));
+      days.push(localDayIso(-i).slice(0, 10));
     const out = {};
     for (const r of rows) {
       out[r.pid] ??= new Array(14).fill(0);
       const arr = out[r.pid];
-      const i = days3.indexOf(r.day);
+      const i = days.indexOf(r.day);
       if (i >= 0)
         arr[i] = (arr[i] ?? 0) + (r.usd ?? 0);
     }
@@ -11300,13 +11332,13 @@ ${p2.reason ?? ""}`.trim(),
   }
   snapshot() {
     const worktrees = {};
-    const projects = this.projects().filter((p) => !(p.discovered && isScratchRoot(p.root)));
+    const projects = this.liveProjects();
     for (const p of projects)
       worktrees[p.id] = this.worktrees(p.id);
     return {
       projects,
       worktrees,
-      sessions: this.memoised("sessions", 2000, () => this.sessions()),
+      sessions: this.sessions(),
       spend: this.memoised("spend", 30000, () => this.spend()),
       spendSparks: this.memoised("spendSparks", 60000, () => this.spendSparks()),
       claims: this.claims(),
@@ -11351,18 +11383,18 @@ function slimForStorage(e) {
       toolResponse: clip(p.toolResponse, TOOL_RESPONSE_MAX)
     };
   }
-  let raw2 = e.raw;
-  if (raw2 && typeof raw2 === "object") {
-    const r = raw2;
+  let raw = e.raw;
+  if (raw && typeof raw === "object") {
+    const r = raw;
     if (RAW_TOOL_KEYS.some((k) => (k in r))) {
       const rest = {};
       for (const k of Object.keys(r))
         if (!RAW_TOOL_KEYS.includes(k))
           rest[k] = r[k];
-      raw2 = rest;
+      raw = rest;
     }
   }
-  return { payload, raw: raw2 };
+  return { payload, raw };
 }
 function toWire(e) {
   const { raw: _raw, ...rest } = e;
@@ -11475,12 +11507,12 @@ class TeamForwarder {
     return this.store.clusterKeyFor(projectId);
   }
   status() {
-    const team2 = this.store.policyFor(null).config.team;
+    const team = this.store.policyFor(null).config.team;
     const box = this.store.outboxStatus();
     return {
-      configured: team2.url != null,
-      url: team2.url,
-      forward: team2.forward,
+      configured: team.url != null,
+      url: team.url,
+      forward: team.forward,
       pending: box.pending,
       oldest: box.oldest,
       lastAckAt: this.store.metaValue("team_last_ack") ?? null,
@@ -11490,14 +11522,14 @@ class TeamForwarder {
     };
   }
   async tick(now = Date.now()) {
-    const team2 = this.store.policyFor(null).config.team;
-    if (!team2.url)
+    const team = this.store.policyFor(null).config.team;
+    if (!team.url)
       return 0;
-    if (now - this.lastTry < team2.interval * 1000 + this.backoffMs)
+    if (now - this.lastTry < team.interval * 1000 + this.backoffMs)
       return 0;
     this.lastTry = now;
     const records = [];
-    const events = team2.forward.includes("ledger") ? this.store.outboxPending() : [];
+    const events = team.forward.includes("ledger") ? this.store.outboxPending() : [];
     for (const e of events) {
       const body = JSON.parse(e.payload);
       if (typeof body.projectId === "string")
@@ -11505,7 +11537,7 @@ class TeamForwarder {
       records.push({ seq: e.seq, kind: e.kind, body });
     }
     let spendRows = 0;
-    if (team2.forward.includes("cost") && now - this.lastSpend > SPEND_EVERY_MS) {
+    if (team.forward.includes("cost") && now - this.lastSpend > SPEND_EVERY_MS) {
       const day = new Date(now).toISOString().slice(0, 10);
       for (const r of this.store.spendRollup(day)) {
         records.push({
@@ -11612,30 +11644,30 @@ class TeamForwarder {
       });
       if (!res.ok)
         return;
-      const { policy: policy2 } = await res.json();
-      if (!policy2)
+      const { policy } = await res.json();
+      if (!policy)
         return;
       let pinned = this.store.metaValue("team_policy_pubkey");
       if (!pinned) {
-        pinned = policy2.publicKey;
+        pinned = policy.publicKey;
         this.store.setMetaValue("team_policy_pubkey", pinned);
       }
-      if (!verifyPolicySignature(policy2.toml, policy2.signature, pinned)) {
+      if (!verifyPolicySignature(policy.toml, policy.signature, pinned)) {
         this.store.setMetaValue("team_last_error", "org policy signature invalid \u2014 not installed");
         return;
       }
       const file = join9(this.store.home, "policy.toml");
       const prev = this.store.metaValue("team_policy_sig");
-      if (prev === policy2.signature)
+      if (prev === policy.signature)
         return;
-      writeFileSync3(file, policy2.toml, { mode: 384 });
+      writeFileSync3(file, policy.toml, { mode: 384 });
       writeFileSync3(join9(this.store.home, "policy.sig.json"), JSON.stringify({
-        signature: policy2.signature,
+        signature: policy.signature,
         publicKey: pinned,
         fetchedAt: new Date(now).toISOString(),
         url: base
       }), { mode: 384 });
-      this.store.setMetaValue("team_policy_sig", policy2.signature);
+      this.store.setMetaValue("team_policy_sig", policy.signature);
     } catch {}
   }
 }
@@ -11646,12 +11678,12 @@ class WorkflowEngine {
   runner;
   forge;
   active = new Map;
-  constructor(store, runner, forge2) {
+  constructor(store, runner, forge) {
     this.store = store;
     this.runner = runner;
-    this.forge = forge2;
+    this.forge = forge;
     store.wfSweepOrphans();
-    runner.onEnd((run2) => void this.onRunEnd(run2));
+    runner.onEnd((run) => void this.onRunEnd(run));
   }
   start(projectId, task, workflow, opts = {}) {
     const def = this.store.config(projectId).workflows[workflow];
@@ -11729,11 +11761,11 @@ class WorkflowEngine {
       }
       if (s.kind === "gate") {
         const r = await this.store.runGates(w.projectId, w.task, [s.gate], { owner: w.owner });
-        const run2 = r.runs.find((x) => x.gate === s.gate);
-        if (!run2)
+        const run = r.runs.find((x) => x.gate === s.gate);
+        if (!run)
           return this.fail(w, `gate ${s.gate} did not run: ${r.skipped[0]?.reason ?? "unknown"}`);
-        if (run2.verdict !== "pass")
-          return this.fail(w, `gate ${s.gate} failed \u2014 ${run2.rubric}`);
+        if (run.verdict !== "pass")
+          return this.fail(w, `gate ${s.gate} failed \u2014 ${run.rubric}`);
         w.step++;
         continue;
       }
@@ -11753,15 +11785,15 @@ class WorkflowEngine {
     }
     this.finish(w, "done", null);
   }
-  async onRunEnd(run2) {
-    const w = this.active.get(`${run2.projectId}:${run2.task}`);
-    if (!w || w.runId !== run2.id)
+  async onRunEnd(run) {
+    const w = this.active.get(`${run.projectId}:${run.task}`);
+    if (!w || w.runId !== run.id)
       return;
     w.runId = null;
-    if (run2.stopped)
+    if (run.stopped)
       return this.finish(w, "stopped", `stopped during ${this.label(w)}`);
-    if (run2.exitCode !== 0 || run2.result?.isError)
-      return this.fail(w, `${this.label(w)} exited ${run2.exitCode}${run2.result?.isError ? " (error)" : ""} \u2014 log: ${run2.log}`);
+    if (run.exitCode !== 0 || run.result?.isError)
+      return this.fail(w, `${this.label(w)} exited ${run.exitCode}${run.result?.isError ? " (error)" : ""} \u2014 log: ${run.log}`);
     w.step++;
     this.advance(w);
   }
@@ -11831,7 +11863,7 @@ class WorkflowEngine {
 }
 
 // packages/daemon/src/app.ts
-var VERSION = "0.13.0";
+var VERSION = "0.13.2";
 var WEB_DIR = (() => {
   if (process.env.SWARM_WEB_DIR)
     return process.env.SWARM_WEB_DIR;
@@ -11849,8 +11881,8 @@ function wireJson(e) {
   }
   return s;
 }
-function hookRepoRoot(store, raw2) {
-  const cwd = typeof raw2.cwd === "string" ? raw2.cwd : "";
+function hookRepoRoot(store, raw) {
+  const cwd = typeof raw.cwd === "string" ? raw.cwd : "";
   return cwd && existsSync7(cwd) ? store.resolveProject(cwd)?.root ?? null : null;
 }
 function claudeSettings() {
@@ -11878,17 +11910,24 @@ function diskVersion() {
     return null;
   }
 }
-function createApp(store = new Store, hooks2 = {}) {
+function expandHome(p, home = homedir4()) {
+  if (p === "~")
+    return home;
+  if (p.startsWith("~/"))
+    return join10(home, p.slice(2));
+  return p;
+}
+function createApp(store = new Store, hooks = {}) {
   const app = new Hono2;
-  const forge2 = new ForgeService(store);
+  const forge = new ForgeService(store);
   const runner = new Runner(store, store.home);
-  const dispatcher = new Dispatcher(store, runner, forge2);
-  const workflows2 = new WorkflowEngine(store, runner, forge2);
-  const team2 = new TeamForwarder(store, VERSION);
+  const dispatcher = new Dispatcher(store, runner, forge);
+  const workflows = new WorkflowEngine(store, runner, forge);
+  const team = new TeamForwarder(store, VERSION);
   store.onBudgetStop((projectId) => {
     dispatcher.clear(projectId);
-    for (const run2 of runner.list(projectId))
-      runner.stop(run2.id);
+    for (const run of runner.list(projectId))
+      runner.stop(run.id);
   });
   app.use("/v1/*", async (c, next) => {
     if (c.req.path === "/v1/health")
@@ -11913,13 +11952,13 @@ function createApp(store = new Store, hooks2 = {}) {
     schema: store.schemaVersion(),
     auth: store.policyFor(null).config.daemon.auth
   }));
-  app.get("/v1/projects", (c) => c.json(store.snapshot().projects));
+  app.get("/v1/projects", (c) => c.json(store.liveProjects()));
   app.post("/v1/projects", async (c) => {
     const { path, name } = await c.req.json();
     if (!path)
       return c.json({ error: "path required" }, 400);
     try {
-      return c.json(store.resolveProject(path, true, name), 201);
+      return c.json(store.resolveProject(expandHome(path), true, name), 201);
     } catch (e) {
       return c.json({ error: e.message }, 400);
     }
@@ -11939,10 +11978,12 @@ function createApp(store = new Store, hooks2 = {}) {
   });
   app.delete("/v1/projects/:id", (c) => store.removeProject(c.req.param("id")) ? c.body(null, 204) : c.json({ error: "not found" }, 404));
   app.get("/v1/fs/ls", (c) => {
-    const q = c.req.query("path");
+    const q = expandHome(c.req.query("path") ?? "");
+    if (q && !existsSync7(q))
+      return c.json({ error: "no such folder", path: q }, 404);
     let dir;
     try {
-      dir = realpathSync3(q && existsSync7(q) ? q : homedir4());
+      dir = realpathSync3(q || homedir4());
     } catch {
       dir = homedir4();
     }
@@ -11954,7 +11995,14 @@ function createApp(store = new Store, hooks2 = {}) {
       return c.json({ error: e.message, path: dir }, 400);
     }
   });
-  app.get("/v1/state", (c) => c.json(store.snapshot()));
+  app.get("/v1/state", (c) => {
+    const body = JSON.stringify(store.snapshot());
+    const etag = `W/"${Bun.hash(body).toString(36)}"`;
+    const head = { etag, "cache-control": "no-cache" };
+    if (c.req.header("if-none-match") === etag)
+      return c.body(null, 304, head);
+    return c.body(body, 200, { ...head, "content-type": "application/json" });
+  });
   app.get("/v1/stats", (c) => c.json(store.stats(c.req.query("project") || undefined)));
   app.get("/v1/graphs/collisions", (c) => c.json(store.collisions(c.req.query("project") || undefined)));
   app.get("/v1/graphs/lineage", (c) => c.json(store.lineage(c.req.query("project") || undefined, Math.max(1, Math.min(90, Number(c.req.query("days") ?? 14) || 14)), c.req.queries("expand") ?? [])));
@@ -11981,7 +12029,7 @@ function createApp(store = new Store, hooks2 = {}) {
   })));
   const outcomesFor = async (project, opts = {}) => {
     const blocking = opts.blocking !== false;
-    const sessions = store.snapshot().sessions.filter((s) => !project || s.projectId === project).map((s) => ({
+    const sessions = store.sessions().filter((s) => !project || s.projectId === project).map((s) => ({
       id: s.id,
       branch: s.branch,
       model: s.model,
@@ -11992,8 +12040,9 @@ function createApp(store = new Store, hooks2 = {}) {
     const prs = [];
     const reverted = new Set;
     let stale = false;
-    for (const p of store.projects().filter((x) => !project || x.id === project)) {
-      const o = blocking ? { ...await forge2.merged(p.id, p.root), fresh: true } : forge2.mergedCached(p.id, p.root);
+    const scope = store.liveProjects().filter((x) => !project || x.id === project);
+    const outcomes = await Promise.all(scope.map(async (p) => blocking ? { ...await forge.merged(p.id, p.root), fresh: true } : forge.mergedCached(p.id, p.root)));
+    for (const o of outcomes) {
       if (!o.fresh)
         stale = true;
       for (const m of o.merged)
@@ -12001,7 +12050,7 @@ function createApp(store = new Store, hooks2 = {}) {
       for (const sha of o.reverted)
         reverted.add(sha);
     }
-    for (const pr of forge2.prs())
+    for (const pr of forge.prs())
       if (!project || pr.projectId === project)
         prs.push({
           branch: pr.branch,
@@ -12076,10 +12125,10 @@ function createApp(store = new Store, hooks2 = {}) {
     const offset = Math.max(0, Number(c.req.query("offset") ?? 0) || 0);
     const { branches, stale } = await outcomesFor(project, { blocking: false });
     const projects = store.projects().filter((p) => !project || p.id === project);
-    const tasks2 = [];
+    const tasks = [];
     for (const p of projects)
       for (const t of store.tasks(p.id)?.tasks ?? [])
-        tasks2.push({ id: t.id, title: t.title, status: t.statusText, url: null });
+        tasks.push({ id: t.id, title: t.title, status: t.statusText, url: null });
     const claims = store.claims(project).map((cl) => ({
       task: cl.task,
       sessionId: cl.sessionId,
@@ -12089,14 +12138,14 @@ function createApp(store = new Store, hooks2 = {}) {
       acquiredAt: cl.acquiredAt,
       state: cl.state
     }));
-    const sessions = store.snapshot().sessions.filter((s) => !project || s.projectId === project).map((s) => ({
+    const sessions = store.sessions().filter((s) => !project || s.projectId === project).map((s) => ({
       id: s.id,
       title: s.title,
       agent: s.agent,
       branch: s.branch,
       costUsd: s.costUsd
     }));
-    const full = provenance(tasks2, claims, sessions, branches);
+    const full = provenance(tasks, claims, sessions, branches);
     return c.json({
       ...full,
       chains: full.chains.slice(offset, offset + limit),
@@ -12127,7 +12176,7 @@ function createApp(store = new Store, hooks2 = {}) {
       return c.json({ error: e.message }, 500);
     }
   });
-  app.get("/v1/team", (c) => c.json(team2.status()));
+  app.get("/v1/team", (c) => c.json(team.status()));
   app.post("/v1/team/credentials", async (c) => {
     const b = await c.req.json().catch(() => ({}));
     if (typeof b.token !== "string" || !b.token)
@@ -12142,8 +12191,8 @@ function createApp(store = new Store, hooks2 = {}) {
     const p = id ? store.project(id) : null;
     if (id && !p)
       return c.json({ error: "unknown project" }, 404);
-    const { provenance: provenance3, overridden, policy: policy2 } = store.policyFor(p?.root ?? null);
-    return c.json({ ...policy2, provenance: provenance3, overridden });
+    const { provenance, overridden, policy } = store.policyFor(p?.root ?? null);
+    return c.json({ ...policy, provenance, overridden });
   });
   app.get("/v1/audit", (c) => {
     const since = sinceToIso(c.req.query("since"));
@@ -12163,9 +12212,9 @@ function createApp(store = new Store, hooks2 = {}) {
     return c.body(formatAudit(rows, format), 200, { "content-type": ct });
   });
   app.post("/v1/daemon/restart", (c) => {
-    if (!hooks2.restart)
+    if (!hooks.restart)
       return c.json({ error: "not restartable in this environment" }, 501);
-    setTimeout(() => hooks2.restart?.(), 50);
+    setTimeout(() => hooks.restart?.(), 50);
     return c.json({ ok: true, restarting: true });
   });
   app.get("/v1/rules/dryrun", (c) => {
@@ -12197,12 +12246,12 @@ function createApp(store = new Store, hooks2 = {}) {
     const r = store.acquireResource({ ...b, name: b.name, owner: b.owner });
     return r.ok ? c.json(r, 201) : c.json({ ok: false, error: r.reason }, 409);
   });
-  app.get("/v1/prs", (c) => c.json(forge2.prs()));
+  app.get("/v1/prs", (c) => c.json(forge.prs()));
   app.post("/v1/prs/merge", async (c) => {
     const b = await c.req.json().catch(() => ({}));
     if (!b.projectId || !b.number)
       return c.json({ error: "projectId and number are required" }, 400);
-    const r = await forge2.merge(b.projectId, b.number);
+    const r = await forge.merge(b.projectId, b.number);
     return r.ok ? c.json(r) : c.json({ error: r.output || "merge failed" }, 409);
   });
   app.delete("/v1/resources/:name", (c) => {
@@ -12292,9 +12341,9 @@ function createApp(store = new Store, hooks2 = {}) {
     const b = await c.req.json().catch(() => ({}));
     const r = store.answer(Number(c.req.param("id")), b.text, b.by ?? null);
     if (r.ok && r.question.sessionId) {
-      const run2 = runner.get(r.question.sessionId);
-      if (run2 && run2.sessionId === r.question.sessionId) {
-        const sent = runner.send(run2.id, `[swarm] answer from ${b.by ?? "a human"} to your question "${r.question.text.slice(0, 200)}": ${r.question.answer}`);
+      const run = runner.get(r.question.sessionId);
+      if (run && run.sessionId === r.question.sessionId) {
+        const sent = runner.send(run.id, `[swarm] answer from ${b.by ?? "a human"} to your question "${r.question.text.slice(0, 200)}": ${r.question.answer}`);
         if (sent.ok)
           store.inbox(r.question.sessionId);
       }
@@ -12306,13 +12355,13 @@ function createApp(store = new Store, hooks2 = {}) {
     const project = c.req.query("project");
     if (!project)
       return c.json({ error: "project required" }, 400);
-    return c.json({ defs: store.config(project).workflows, runs: workflows2.status(project) });
+    return c.json({ defs: store.config(project).workflows, runs: workflows.status(project) });
   });
   app.post("/v1/workflows", async (c) => {
     const b = await c.req.json().catch(() => ({}));
     if (!b.projectId || !b.task || !b.workflow)
       return c.json({ ok: false, error: "projectId, task, workflow required" }, 400);
-    const r = workflows2.start(b.projectId, b.task, b.workflow, {
+    const r = workflows.start(b.projectId, b.task, b.workflow, {
       ...b.owner ? { owner: b.owner } : {},
       sessionId: b.sessionId ?? null
     });
@@ -12322,7 +12371,7 @@ function createApp(store = new Store, hooks2 = {}) {
     const b = await c.req.json().catch(() => ({}));
     if (!b.projectId || !b.task)
       return c.json({ ok: false, error: "projectId and task required" }, 400);
-    const r = workflows2.stop(b.projectId, b.task);
+    const r = workflows.stop(b.projectId, b.task);
     return c.json(r, r.ok ? 200 : 404);
   });
   app.get("/v1/timeline", (c) => c.json(store.timelineDetail(Number(c.req.query("hours")) || 12, c.req.query("project") || null)));
@@ -12346,11 +12395,11 @@ function createApp(store = new Store, hooks2 = {}) {
     if (!r.ok)
       return c.json(r, 400);
     const m = r.message;
-    const run2 = m.task ? runner.get(m.task) : m.sessionId ? runner.get(m.sessionId) : null;
-    if (run2 && !run2.endedAt) {
-      const sent = runner.send(run2.id, `[swarm] message from ${m.from ?? "unknown"}: ${m.text}`);
+    const run = m.task ? runner.get(m.task) : m.sessionId ? runner.get(m.sessionId) : null;
+    if (run && !run.endedAt) {
+      const sent = runner.send(run.id, `[swarm] message from ${m.from ?? "unknown"}: ${m.text}`);
       if (sent.ok)
-        store.markMessageDelivered(m.id, run2.sessionId);
+        store.markMessageDelivered(m.id, run.sessionId);
     }
     return c.json({ ok: true, message: store.message(m.id) }, 201);
   });
@@ -12558,7 +12607,7 @@ function createApp(store = new Store, hooks2 = {}) {
     const d = await store.prDraftFor(b.projectId, ref);
     if (!d.ok)
       return c.json(d, 404);
-    const r = await forge2.openPR(b.projectId, d.worktree, {
+    const r = await forge.openPR(b.projectId, d.worktree, {
       title: b.title?.trim() || d.title,
       body: b.body ?? d.body,
       isDraft: b.draft ?? false
@@ -12629,21 +12678,21 @@ function createApp(store = new Store, hooks2 = {}) {
   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") {
-      store.checkPolicy(raw2.cwd, typeof raw2.session_id === "string" ? raw2.session_id : null);
-      const ctx = store.sessionContext(raw2.cwd);
+    const raw = await c.req.json().catch(() => ({}));
+    store.ingestHook(event, raw);
+    if (event === "SessionStart" && typeof raw.cwd === "string") {
+      store.checkPolicy(raw.cwd, typeof raw.session_id === "string" ? raw.session_id : null);
+      const ctx = store.sessionContext(raw.cwd);
       if (ctx)
         return c.json({
           additionalContext: ctx,
           hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: ctx }
         });
     }
-    const sid = typeof raw2.session_id === "string" ? raw2.session_id : null;
+    const sid = typeof raw.session_id === "string" ? raw.session_id : null;
     const answers = event === "UserPromptSubmit" || event === "PreToolUse" || event === "PostToolUse" ? store.answerContext(sid) : null;
-    if (event === "PreToolUse" && !store.guardDisabled(hookRepoRoot(store, raw2))) {
-      const guard = store.guardHook(raw2);
+    if (event === "PreToolUse" && !store.guardDisabled(hookRepoRoot(store, raw))) {
+      const guard = store.guardHook(raw);
       if (guard) {
         return c.json({
           hookSpecificOutput: {
@@ -12668,22 +12717,22 @@ function createApp(store = new Store, hooks2 = {}) {
   });
   app.get("/v1/events", (c) => {
     const full = c.req.query("full") === "1";
-    const raw2 = Number(c.req.query("since") ?? 0);
-    const since = raw2 > 0 ? raw2 : Math.max(0, store.seq() - REPLAY_TAIL);
-    return streamSSE(c, async (stream2) => {
+    const raw = Number(c.req.query("since") ?? 0);
+    const since = raw > 0 ? raw : Math.max(0, store.seq() - REPLAY_TAIL);
+    return streamSSE(c, async (stream) => {
       for (const e of store.since(since, 5000, full)) {
-        await stream2.writeSSE({ id: String(e.seq), event: e.type, data: JSON.stringify(e) });
+        await stream.writeSSE({ id: String(e.seq), event: e.type, data: JSON.stringify(e) });
       }
-      await stream2.writeSSE({ event: "ping", data: "" });
-      await new Promise((resolve2) => {
+      await stream.writeSSE({ event: "ping", data: "" });
+      await new Promise((resolve) => {
         const off = store.subscribe((e) => {
-          stream2.writeSSE({ id: String(e.seq), event: e.type, data: wireJson(e) });
+          stream.writeSSE({ id: String(e.seq), event: e.type, data: wireJson(e) });
         });
-        const beat = setInterval(() => void stream2.writeSSE({ event: "ping", data: "" }), 15000);
-        stream2.onAbort(() => {
+        const beat = setInterval(() => void stream.writeSSE({ event: "ping", data: "" }), 15000);
+        stream.onAbort(() => {
           clearInterval(beat);
           off();
-          resolve2();
+          resolve();
         });
       });
     });
@@ -12714,7 +12763,7 @@ function createApp(store = new Store, hooks2 = {}) {
       etag
     });
   });
-  return { app, store, forge: forge2, runner, dispatcher, workflows: workflows2, team: team2 };
+  return { app, store, forge, runner, dispatcher, workflows, team };
 }
 
 // packages/daemon/src/demo.ts
@@ -12751,8 +12800,8 @@ function seedDemo(store) {
      VALUES ('p_demo1', 'checkout', 'demo-s1', '/work/acme-app-wt/checkout', 'task/checkout', ?, ?, NULL, 'held', 'agent', 'demo-s1')`).run(iso(5 * H), iso(-30 * 60000));
   db.query(`INSERT OR IGNORE INTO claims (project_id, task, owner, worktree, branch, acquired_at, expires_at, released_at, state, actor_kind, actor_id)
      VALUES ('p_demo1', 'webhooks', 'alice', '/work/acme-app-wt/webhooks', 'task/webhooks', ?, ?, NULL, 'orphaned', 'human', 'alice')`).run(iso(26 * H), iso(20 * H));
-  const gate = (task, gate2, verdict, rubric, ago, sid) => db.query(`INSERT OR IGNORE INTO gates (project_id, task, gate, verdict, rubric, evidence, session_id, created_at, actor_kind, actor_id)
-       VALUES ('p_demo1', ?, ?, ?, ?, NULL, ?, ?, 'daemon', 'daemon')`).run(task, gate2, verdict, rubric, sid, iso(ago));
+  const gate = (task, gate, verdict, rubric, ago, sid) => db.query(`INSERT OR IGNORE INTO gates (project_id, task, gate, verdict, rubric, evidence, session_id, created_at, actor_kind, actor_id)
+       VALUES ('p_demo1', ?, ?, ?, ?, NULL, ?, ?, 'daemon', 'daemon')`).run(task, gate, verdict, rubric, sid, iso(ago));
   gate("checkout", "tests", "fail", "ran `bun test` \u2014 exit 1 in 41s", 3 * H, "demo-s1");
   gate("checkout", "tests", "pass", "ran `bun test` \u2014 exit 0 in 39s", 1 * H, "demo-s1");
   gate("checkout", "review", "pass", "review: no blocker/major findings", 40 * 60000, null);