@ra3orblade/swarm 0.4.0

package/dist/swarmd.js

@@ -0,0 +1,4554 @@
+#!/usr/bin/env bun
+// @bun
+
+// packages/client/src/daemon.ts
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function swarmHome() {
+  return process.env.SWARM_HOME ?? join(homedir(), ".swarm");
+}
+var DEFAULT_PORT = Number(process.env.SWARM_PORT ?? 7777);
+var infoFile = () => join(swarmHome(), "daemon.json");
+function writeDaemonInfo(info) {
+  const home = swarmHome();
+  mkdirSync(home, { recursive: true });
+  const full = { ...info, url: `http://127.0.0.1:${info.port}` };
+  writeFileSync(join(home, "daemon.json"), `${JSON.stringify(full, null, 2)}
+`);
+  return full;
+}
+function clearDaemonInfo() {
+  rmSync(infoFile(), { force: true });
+}
+// packages/core/src/adapters/claude-code/transcript.ts
+function parseTranscriptChunk(chunk) {
+  const out = {
+    turns: [],
+    title: null,
+    branch: null,
+    version: null,
+    turnDurationsMs: []
+  };
+  const byId = new Map;
+  for (const line of chunk.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    let d;
+    try {
+      d = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (d.type === "ai-title" && d.aiTitle)
+      out.title = d.aiTitle;
+    if (d.gitBranch && d.gitBranch !== "HEAD")
+      out.branch = d.gitBranch;
+    if (d.version)
+      out.version = d.version;
+    if (d.type === "system" && d.subtype === "turn_duration" && typeof d.durationMs === "number")
+      out.turnDurationsMs.push(d.durationMs);
+    if (d.type !== "assistant" || !d.message)
+      continue;
+    const m = d.message;
+    const u = m.usage;
+    const id = m.id ?? d.uuid ?? "";
+    if (!id)
+      continue;
+    const content = Array.isArray(m.content) ? m.content : [];
+    const prev = byId.get(id);
+    const turn = prev ?? {
+      id,
+      ts: d.timestamp ?? new Date().toISOString(),
+      model: m.model ?? "unknown",
+      usage: { input: 0, output: 0, cacheWrite: 0, cacheWrite1h: 0, cacheRead: 0, thinking: 0 },
+      text: "",
+      tools: [],
+      effort: d.effort ?? null,
+      sidechain: Boolean(d.isSidechain)
+    };
+    if (u) {
+      turn.usage = {
+        input: u.input_tokens ?? 0,
+        output: u.output_tokens ?? 0,
+        cacheWrite: u.cache_creation_input_tokens ?? 0,
+        cacheWrite1h: u.cache_creation?.ephemeral_1h_input_tokens ?? 0,
+        cacheRead: u.cache_read_input_tokens ?? 0,
+        thinking: u.output_tokens_details?.thinking_tokens ?? 0
+      };
+    }
+    for (const c of content) {
+      if (c.type === "text" && c.text && turn.text.length < 400)
+        turn.text = `${turn.text}${turn.text ? `
+` : ""}${c.text}`.slice(0, 400);
+      if (c.type === "tool_use" && c.name)
+        turn.tools.push(c.name);
+    }
+    if (!prev) {
+      byId.set(id, turn);
+      out.turns.push(turn);
+    }
+  }
+  return out;
+}
+
+// packages/core/src/adapters/codex/rollout.ts
+function parseCodexRollout(chunk) {
+  const out = { turns: [], sessionId: null, cwd: null, model: null, title: null };
+  let n = 0;
+  let text = "";
+  let tools = [];
+  let lastTs = "";
+  for (const raw of chunk.split(`
+`)) {
+    if (!raw.trim())
+      continue;
+    let d;
+    try {
+      d = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    const p = d.payload ?? {};
+    if (d.type === "session_meta") {
+      out.sessionId = p.session_id ?? out.sessionId ?? null;
+      out.cwd = p.cwd ?? out.cwd ?? null;
+    } else if (d.type === "turn_context") {
+      if (p.model)
+        out.model = p.model;
+    } else if (d.type === "response_item") {
+      if (p.type === "function_call" && p.name)
+        tools.push(p.name);
+      else if (p.type === "custom_tool_call" && p.name)
+        tools.push(p.name);
+    } else if (d.type === "event_msg") {
+      if (p.type === "agent_message") {
+        const t = p.message ?? p.text ?? "";
+        if (t && text.length < 400)
+          text = `${text}${text ? `
+` : ""}${t}`.slice(0, 400);
+        lastTs = d.timestamp ?? lastTs;
+      } else if (p.type === "token_count") {
+        const u = p.info?.last_token_usage;
+        if (!u)
+          continue;
+        const cacheRead = u.cached_input_tokens ?? 0;
+        const turn = {
+          id: `${out.sessionId ?? "codex"}-t${n}`,
+          ts: d.timestamp ?? (lastTs || new Date(0).toISOString()),
+          model: out.model ?? "gpt-5",
+          usage: {
+            input: Math.max(0, (u.input_tokens ?? 0) - cacheRead),
+            output: u.output_tokens ?? 0,
+            cacheWrite: 0,
+            cacheWrite1h: 0,
+            cacheRead,
+            thinking: u.reasoning_output_tokens ?? 0
+          },
+          text,
+          tools,
+          effort: null,
+          sidechain: false
+        };
+        out.turns.push(turn);
+        n++;
+        text = "";
+        tools = [];
+      }
+    }
+  }
+  return out;
+}
+
+// packages/core/src/adapters/grok/updates.ts
+function parseGrokUpdates(chunk) {
+  const out = { turns: [], sessionId: null, model: null, cwd: null, title: null };
+  let n = 0;
+  let text = "";
+  let tools = [];
+  let ts = "";
+  for (const raw of chunk.split(`
+`)) {
+    if (!raw.trim())
+      continue;
+    let d = null;
+    try {
+      d = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    if (typeof d.timestamp === "number")
+      ts = new Date(d.timestamp * 1000).toISOString();
+    const p = d.params ?? {};
+    if (p.sessionId)
+      out.sessionId = p.sessionId;
+    const u = p.update;
+    if (!u)
+      continue;
+    const model = u._meta?.modelId;
+    if (model)
+      out.model = model;
+    switch (u.sessionUpdate) {
+      case "agent_message_chunk":
+        if (u.content?.text && text.length < 400)
+          text = `${text}${u.content.text}`.slice(0, 400);
+        break;
+      case "tool_call":
+        if (u.title)
+          tools.push(u.title);
+        break;
+      case "turn_completed": {
+        const usage = u.usage;
+        const cacheRead = usage?.cachedReadTokens ?? 0;
+        const turn = {
+          id: `${out.sessionId ?? "grok"}-t${n}`,
+          ts: ts || new Date(0).toISOString(),
+          model: out.model ?? "grok-4",
+          usage: {
+            input: Math.max(0, (usage?.inputTokens ?? 0) - cacheRead),
+            output: usage?.outputTokens ?? 0,
+            cacheWrite: 0,
+            cacheWrite1h: 0,
+            cacheRead,
+            thinking: usage?.reasoningTokens ?? 0
+          },
+          text,
+          tools,
+          effort: null,
+          sidechain: false
+        };
+        out.turns.push(turn);
+        n++;
+        text = "";
+        tools = [];
+        break;
+      }
+    }
+  }
+  return out;
+}
+// packages/core/src/adapters/claude-code/hooks.ts
+var MAP = {
+  SessionStart: "session.started",
+  UserPromptSubmit: "prompt.submitted",
+  PreToolUse: "tool.requested",
+  PostToolUse: "tool.completed",
+  SubagentStart: "subagent.started",
+  SubagentStop: "subagent.stopped",
+  Stop: "agent.text",
+  SessionEnd: "session.ended",
+  Notification: "session.notification",
+  PreCompact: "agent.text"
+};
+function summarizeToolInput(tool, input) {
+  const i = input ?? {};
+  const s = (v) => typeof v === "string" ? v : JSON.stringify(v ?? "");
+  switch (tool) {
+    case "Bash":
+      return s(i.command).split(`
+`)[0] ?? "";
+    case "Read":
+    case "Edit":
+    case "Write":
+    case "MultiEdit":
+    case "NotebookEdit":
+      return s(i.file_path);
+    case "Glob":
+    case "Grep":
+      return s(i.pattern) + (i.path ? ` in ${s(i.path)}` : "");
+    case "Agent":
+    case "Task":
+      return s(i.description ?? i.prompt).slice(0, 80);
+    case "WebFetch":
+      return s(i.url);
+    case "WebSearch":
+      return s(i.query);
+    default: {
+      const first = Object.entries(i)[0];
+      return first ? `${first[0]}=${s(first[1]).slice(0, 80)}` : "";
+    }
+  }
+}
+function normalizeHook(event, raw, projectId, ts = new Date().toISOString()) {
+  const type = MAP[event] ?? "agent.text";
+  const tool = raw.tool_name;
+  let summary;
+  switch (event) {
+    case "SessionStart":
+      summary = `session started (${raw.source ?? "startup"})`;
+      break;
+    case "UserPromptSubmit":
+      summary = (raw.prompt ?? "").split(`
+`)[0]?.slice(0, 120) ?? "";
+      break;
+    case "PreToolUse":
+    case "PostToolUse":
+      summary = `${tool ?? "?"} ${summarizeToolInput(tool, raw.tool_input)}`.trim();
+      break;
+    case "SubagentStart":
+      summary = `subagent ${raw.agent_type ?? ""} started`.trim();
+      break;
+    case "SubagentStop":
+      summary = `subagent ${raw.agent_type ?? ""} stopped`.trim();
+      break;
+    case "Stop":
+      summary = "turn finished \xB7 waiting for input";
+      break;
+    case "SessionEnd":
+      summary = `session ended (${raw.reason ?? ""})`.trim();
+      break;
+    case "Notification":
+      summary = raw.message ?? "notification";
+      break;
+    case "PreCompact":
+      summary = "context compaction";
+      break;
+    default:
+      summary = event;
+  }
+  const payload = { hook: event, cwd: raw.cwd ?? null, summary };
+  if (tool)
+    payload.tool = tool;
+  if (raw.tool_input !== undefined)
+    payload.toolInput = raw.tool_input;
+  if (raw.tool_response !== undefined)
+    payload.toolResponse = raw.tool_response;
+  if (raw.agent_id)
+    payload.agentId = raw.agent_id;
+  if (raw.agent_type)
+    payload.agentType = raw.agent_type;
+  if (raw.prompt)
+    payload.prompt = raw.prompt;
+  return { ts, type, projectId, sessionId: raw.session_id ?? null, payload, raw };
+}
+// packages/core/src/config.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+var DEFAULT_CONFIG = {
+  daemon: { port: 7777 },
+  tasks: { source: null },
+  rules: {
+    shared_tree: "ask",
+    destructive_git: "ask",
+    pattern_kill: "ask",
+    protected_ports: "ask",
+    no_foreign_worktree: "ask",
+    claim_required_to_write: "off",
+    protected: { ports: [] }
+  }
+};
+var MODES = ["ask", "deny", "off"];
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function merge(a, b) {
+  if (!isRecord(a) || !isRecord(b))
+    return b === undefined ? a : b;
+  const out = { ...a };
+  for (const [k, v] of Object.entries(b))
+    out[k] = merge(a[k], v);
+  return out;
+}
+function parseToml(text, source) {
+  try {
+    return Bun.TOML.parse(text) ?? {};
+  } catch (e) {
+    console.error(`swarm: ignoring invalid TOML in ${source}: ${e.message}`);
+    return {};
+  }
+}
+function validate(c) {
+  const mode = (v, fallback) => MODES.includes(v) ? v : fallback;
+  const port = Number(c.daemon?.port);
+  const source = c.tasks?.source;
+  return {
+    ...c,
+    daemon: { port: Number.isInteger(port) && port > 0 && port < 65536 ? port : 7777 },
+    tasks: {
+      source: typeof source === "string" && source.trim() && !source.startsWith("/") ? source.trim() : null
+    },
+    rules: {
+      ...c.rules,
+      shared_tree: mode(c.rules?.shared_tree, "ask"),
+      destructive_git: mode(c.rules?.destructive_git, "ask"),
+      pattern_kill: mode(c.rules?.pattern_kill, "ask"),
+      protected_ports: mode(c.rules?.protected_ports, "ask"),
+      no_foreign_worktree: mode(c.rules?.no_foreign_worktree, "ask"),
+      claim_required_to_write: mode(c.rules?.claim_required_to_write, "off"),
+      protected: {
+        ports: Array.isArray(c.rules?.protected?.ports) ? c.rules.protected.ports.filter((p) => Number.isInteger(p) && p > 0 && p < 65536) : []
+      }
+    }
+  };
+}
+function loadConfig(opts = {}) {
+  const home = opts.home ?? process.env.SWARM_HOME ?? join2(process.env.HOME ?? "", ".swarm");
+  let cfg = DEFAULT_CONFIG;
+  const globalPath = join2(home, "config.toml");
+  if (existsSync2(globalPath))
+    cfg = merge(cfg, parseToml(readFileSync2(globalPath, "utf8"), globalPath));
+  if (opts.repoRoot) {
+    const repoPath = join2(opts.repoRoot, ".swarm.toml");
+    if (existsSync2(repoPath))
+      cfg = merge(cfg, parseToml(readFileSync2(repoPath, "utf8"), repoPath));
+  }
+  return validate(cfg);
+}
+// packages/core/src/forge.ts
+function parseRemote(url) {
+  const m = url.match(/^(?:ssh:\/\/)?git@([^:/]+)[:/](.+?)(?:\.git)?$/) ?? url.match(/^https?:\/\/([^/]+)\/(.+?)(?:\.git)?\/?$/);
+  if (!m)
+    return null;
+  const host = m[1]?.toLowerCase();
+  const repo = m[2];
+  if (!host || !repo)
+    return null;
+  if (host === "github.com" || host.startsWith("github."))
+    return { forge: "github", host, repo };
+  if (host.includes("gitlab"))
+    return { forge: "gitlab", host, repo };
+  return null;
+}
+function normalizeGithub(raw, repo) {
+  if (!Array.isArray(raw))
+    return [];
+  return raw.map((p) => {
+    const r = p;
+    const rollup = Array.isArray(r.statusCheckRollup) ? r.statusCheckRollup : [];
+    const states = rollup.map((c) => String(c.conclusion ?? c.state ?? "").toUpperCase());
+    const checks = !states.length ? "none" : states.some((s) => ["FAILURE", "ERROR", "TIMED_OUT", "CANCELLED"].includes(s)) ? "fail" : states.some((s) => ["", "PENDING", "IN_PROGRESS", "QUEUED", "EXPECTED"].includes(s)) ? "pending" : "pass";
+    const decision = String(r.reviewDecision ?? "");
+    return {
+      forge: "github",
+      repo,
+      number: Number(r.number),
+      title: String(r.title ?? ""),
+      branch: String(r.headRefName ?? ""),
+      author: String(r.author?.login ?? ""),
+      url: String(r.url ?? ""),
+      draft: !!r.isDraft,
+      checks,
+      review: decision === "APPROVED" ? "approved" : decision === "CHANGES_REQUESTED" ? "changes" : "none",
+      mergeable: String(r.mergeable ?? "").toUpperCase() !== "CONFLICTING",
+      createdAt: String(r.createdAt ?? "")
+    };
+  });
+}
+function normalizeGitlab(raw, repo) {
+  if (!Array.isArray(raw))
+    return [];
+  return raw.map((p) => {
+    const r = p;
+    const pipeline = r.head_pipeline ?? r.pipeline;
+    const status = String(pipeline?.status ?? "");
+    const checks = !status ? "none" : ["failed", "canceled"].includes(status) ? "fail" : ["success"].includes(status) ? "pass" : "pending";
+    return {
+      forge: "gitlab",
+      repo,
+      number: Number(r.iid),
+      title: String(r.title ?? ""),
+      branch: String(r.source_branch ?? ""),
+      author: String(r.author?.username ?? ""),
+      url: String(r.web_url ?? ""),
+      draft: !!(r.draft ?? r.work_in_progress),
+      checks,
+      review: Number(r.approvals_before_merge ?? 0) > 0 || Array.isArray(r.approved_by) && r.approved_by.length > 0 ? "approved" : "none",
+      mergeable: String(r.detailed_merge_status ?? r.merge_status ?? "") !== "cannot_be_merged",
+      createdAt: String(r.created_at ?? "")
+    };
+  });
+}
+// packages/core/src/ledger.ts
+var DEFAULT_LEASE_MINUTES = 45;
+function isExpired(claim, now) {
+  return new Date(claim.expiresAt).getTime() < now;
+}
+function isActive(claim, now) {
+  return claim.state === "held" && !isExpired(claim, now);
+}
+function nextExpiry(now, leaseMinutes = DEFAULT_LEASE_MINUTES) {
+  return new Date(now + leaseMinutes * 60000).toISOString();
+}
+function canClaim(existing, task, owner, now) {
+  const active = existing.find((c) => c.task === task && isActive(c, now));
+  if (active && active.owner !== owner) {
+    return { ok: false, reason: "held", heldBy: active.owner, until: active.expiresAt };
+  }
+  return { ok: true };
+}
+function canRelease(work, force) {
+  if (force)
+    return { ok: true };
+  if (work.dirty)
+    return { ok: false, reason: "dirty" };
+  if (work.unpushed)
+    return { ok: false, reason: "unpushed" };
+  return { ok: true };
+}
+function reapAction(claim, now, worktreeExists, work) {
+  if (isActive(claim, now))
+    return "not-expired";
+  if (!worktreeExists)
+    return "reap";
+  if (work && (work.dirty || work.unpushed))
+    return "keep-orphaned";
+  return "reap";
+}
+function claimRefusalMessage(d, task) {
+  return `${task} is held by ${d.heldBy} until ${d.until}. ` + "Pick another task or coordinate with the holder \u2014 claims fail closed on purpose.";
+}
+function releaseRefusalMessage(d, worktree) {
+  return d.reason === "dirty" ? `${worktree} has uncommitted changes. Commit and push them, or re-run with --force to discard.` : `${worktree} has unpushed commits. Push them, or re-run with --force to discard the worktree.`;
+}
+// packages/core/src/pricing.ts
+var PRICES = {
+  "claude-opus-4": { input: 15, output: 75, cacheWrite: 18.75, cacheWrite1h: 30, cacheRead: 1.5 },
+  "claude-opus-4-5": { input: 5, output: 25, cacheWrite: 6.25, cacheWrite1h: 10, cacheRead: 0.5 },
+  "claude-opus-4-6": { input: 5, output: 25, cacheWrite: 6.25, cacheWrite1h: 10, cacheRead: 0.5 },
+  "claude-sonnet-4": { input: 3, output: 15, cacheWrite: 3.75, cacheWrite1h: 6, cacheRead: 0.3 },
+  "claude-haiku-4-5": { input: 1, output: 5, cacheWrite: 1.25, cacheWrite1h: 2, cacheRead: 0.1 },
+  "claude-3-5-haiku": { input: 0.8, output: 4, cacheWrite: 1, cacheWrite1h: 1.6, cacheRead: 0.08 },
+  "claude-opus-5": { input: 5, output: 25, cacheWrite: 6.25, cacheWrite1h: 10, cacheRead: 0.5 },
+  "claude-sonnet-5": { input: 2, output: 10, cacheWrite: 2.5, cacheWrite1h: 4, cacheRead: 0.2 },
+  "claude-fable-5": { input: 10, output: 50, cacheWrite: 12.5, cacheWrite1h: 20, cacheRead: 1 },
+  "gpt-4o": { input: 2.5, output: 10, cacheWrite: 2.5, cacheRead: 1.25 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6, cacheWrite: 0.15, cacheRead: 0.075 },
+  "gpt-4.1": { input: 2, output: 8, cacheWrite: 2, cacheRead: 0.5 },
+  "gpt-4.1-mini": { input: 0.4, output: 1.6, cacheWrite: 0.4, cacheRead: 0.1 },
+  "gpt-5": { input: 1.25, output: 10, cacheWrite: 1.25, cacheRead: 0.125 },
+  o3: { input: 2, output: 8, cacheWrite: 2, cacheRead: 0.5 },
+  "o4-mini": { input: 1.1, output: 4.4, cacheWrite: 1.1, cacheRead: 0.275 },
+  "gemini-2.5-pro": { input: 1.25, output: 10, cacheWrite: 1.25, cacheRead: 0.31 },
+  "gemini-2.5-flash": { input: 0.3, output: 2.5, cacheWrite: 0.3, cacheRead: 0.075 },
+  "deepseek-chat": { input: 0.27, output: 1.1, cacheWrite: 0.27, cacheRead: 0.07 },
+  "deepseek-reasoner": { input: 0.55, output: 2.19, cacheWrite: 0.55, cacheRead: 0.14 },
+  "grok-4": { input: 3, output: 15, cacheWrite: 3, cacheRead: 0.75 },
+  "grok-3": { input: 3, output: 15, cacheWrite: 3, cacheRead: 0.75 },
+  "grok-code-fast": { input: 0.2, output: 1.5, cacheWrite: 0.2, cacheRead: 0.02 },
+  "grok-composer": { input: 0.2, output: 1.5, cacheWrite: 0.2, cacheRead: 0.02 }
+};
+function priceFor(model, table = PRICES) {
+  if (!model)
+    return null;
+  const m = model.toLowerCase();
+  let best = null;
+  for (const k of Object.keys(table)) {
+    if (m.startsWith(k) && (!best || k.length > best.length))
+      best = k;
+  }
+  return best ? table[best] ?? null : null;
+}
+function costUsd(model, u, table = PRICES) {
+  const p = priceFor(model, table);
+  if (!p)
+    return null;
+  const w5 = u.cacheWrite - (u.cacheWrite1h ?? 0);
+  return (u.input * p.input + u.output * p.output + w5 * p.cacheWrite + (u.cacheWrite1h ?? 0) * (p.cacheWrite1h ?? p.cacheWrite) + u.cacheRead * p.cacheRead) / 1e6;
+}
+function fromLiteLLM(json) {
+  const out = {};
+  for (const [k, v] of Object.entries(json)) {
+    if (typeof v.input_cost_per_token !== "number")
+      continue;
+    if (k.includes("/") || k.includes("ft:"))
+      continue;
+    const n = (x, fb) => typeof x === "number" ? x * 1e6 : fb;
+    const input = n(v.input_cost_per_token, 0);
+    out[k] = {
+      input,
+      output: n(v.output_cost_per_token, 0),
+      cacheWrite: n(v.cache_creation_input_token_cost, input * 1.25),
+      cacheWrite1h: n(v.cache_creation_input_token_cost_above_1hr, input * 2),
+      cacheRead: n(v.cache_read_input_token_cost, input * 0.1)
+    };
+  }
+  return out;
+}
+// packages/core/src/processes.ts
+function pickPort(from, taken, isFree, span = 200) {
+  const t = new Set(taken);
+  for (let p = from;p < Math.min(from + span, 65536); p++) {
+    if (t.has(p))
+      continue;
+    if (isFree(p))
+      return p;
+  }
+  return null;
+}
+function isOurs(row, alive, currentStartTime) {
+  if (!alive)
+    return false;
+  if (row.startTime == null || currentStartTime == null)
+    return true;
+  return row.startTime === currentStartTime;
+}
+var DEFAULT_FROM_PORT = 3400;
+// packages/core/src/project-id.ts
+function fnv1a(input) {
+  let h = 2166136261;
+  for (let i = 0;i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
+function projectIdentity(opts) {
+  const key = opts.commonDir ?? opts.root;
+  const parts = opts.root.split("/").filter(Boolean);
+  const name = parts[parts.length - 1] ?? opts.root;
+  return { id: `p_${fnv1a(key)}`, root: opts.root, commonDir: opts.commonDir, name };
+}
+// packages/core/src/resources.ts
+var DEFAULT_RESOURCE_LEASE_MINUTES = 60;
+function isTrackedPid(pid) {
+  return pid != null && pid > 0;
+}
+function isAliveHolding(r, now, pidAlive) {
+  if (r.released)
+    return false;
+  if (isTrackedPid(r.pid))
+    return pidAlive(r.pid);
+  if (r.expiresAt != null)
+    return new Date(r.expiresAt).getTime() > now;
+  return true;
+}
+function canAcquire(existing, requester, now, pidAlive) {
+  if (!existing || !isAliveHolding(existing, now, pidAlive))
+    return { ok: true };
+  if (existing.owner === requester.owner)
+    return { ok: true };
+  return { ok: false, reason: "held", holder: existing };
+}
+function acquireRefusalMessage(holder) {
+  const via = isTrackedPid(holder.pid) ? `pid ${holder.pid}` : holder.expiresAt ? `lease until ${holder.expiresAt}` : "unbounded";
+  return `Resource "${holder.name}" is held by ${holder.owner} (${via}).` + ` Pick another name, coordinate with the holder, or wait for release/reap.`;
+}
+// packages/core/src/rules.ts
+var LIVE_WINDOW_MS = 10 * 60000;
+function otherLiveInSameTree(current, sessions, now, withinMs = LIVE_WINDOW_MS) {
+  if (!current.toplevel)
+    return null;
+  for (const s of sessions) {
+    if (s.id === current.id)
+      continue;
+    if (s.state === "ended")
+      continue;
+    if (s.toplevel !== current.toplevel)
+      continue;
+    if (now - new Date(s.lastSeenAt).getTime() > withinMs)
+      continue;
+    return s;
+  }
+  return null;
+}
+function isBroadStage(cmd) {
+  const c = cmd.trim();
+  if (/\bgit\s+add\s+(-A\b|--all\b|\.(\s|$))/.test(c))
+    return true;
+  if (/\bgit\s+commit\b[^|&;]*\s-[a-zA-Z]*a/.test(c))
+    return true;
+  if (/\bgit\s+add\s*$/.test(c))
+    return true;
+  return false;
+}
+function isDestructiveGit(cmd) {
+  const c = cmd.trim();
+  return /\bgit\s+reset\s+[^|&;]*--hard\b/.test(c) || /\bgit\s+checkout\s+(--\s+)?\.(\s|$)/.test(c) || /\bgit\s+checkout\s+-f\b/.test(c) || /\bgit\s+restore\s+(--\s+)?\.(\s|$)/.test(c) || /\bgit\s+clean\s+[^|&;]*-[a-zA-Z]*f/.test(c) || /\bgit\s+stash\s+(drop|clear)\b/.test(c) || /\bgit\s+branch\s+[^|&;]*-[a-zA-Z]*D/.test(c);
+}
+function isPatternKill(cmd) {
+  return /\bpkill\s+-f\b/.test(cmd) || /\bpgrep\s+-f\b[^|]*\|\s*[^|]*\bkill\b/.test(cmd);
+}
+function killedPorts(cmd) {
+  const ports = new Set;
+  const killy = /\b(kill|fuser\s+-[a-z]*k|kill-port)\b/.test(cmd);
+  if (!killy)
+    return [];
+  for (const m of cmd.matchAll(/(?:-i\s*:?|:)(\d{2,5})\b/g))
+    ports.add(Number(m[1]));
+  for (const m of cmd.matchAll(/\bkill-port\s+(\d{2,5})/g))
+    ports.add(Number(m[1]));
+  for (const m of cmd.matchAll(/\bfuser\s+-[a-z]*k\s+(\d{2,5})/g))
+    ports.add(Number(m[1]));
+  return [...ports];
+}
+var DEFAULT_MODES = {
+  shared_tree: "ask",
+  destructive_git: "ask",
+  pattern_kill: "ask",
+  protected_ports: "ask",
+  no_foreign_worktree: "ask",
+  claim_required_to_write: "off",
+  protected: { ports: [] }
+};
+function guardBash(cmd, current, sessions, now, modes = DEFAULT_MODES) {
+  const other = () => otherLiveInSameTree(current, sessions, now);
+  const hit = (rule, reason) => {
+    const mode = modes[rule];
+    return mode === "off" ? { action: "allow" } : { action: mode, rule, reason };
+  };
+  if (modes.protected_ports !== "off" && modes.protected.ports.length) {
+    const target = killedPorts(cmd).filter((p) => modes.protected.ports.includes(p));
+    if (target.length) {
+      const d = hit("protected_ports", `Port${target.length > 1 ? "s" : ""} ${target.join(", ")} ${target.length > 1 ? "are" : "is"} protected in the Swarm config \u2014 something the owner relies on is listening there. Don't kill it.`);
+      if (d.action !== "allow")
+        return d;
+    }
+  }
+  if (modes.pattern_kill !== "off" && isPatternKill(cmd)) {
+    const d = hit("pattern_kill", "This kills processes by command pattern \u2014 it will match every process on the machine that fits, including other agents' or the owner's. Kill by pid instead.");
+    if (d.action !== "allow")
+      return d;
+  }
+  if (modes.shared_tree !== "off" && isBroadStage(cmd)) {
+    const o = other();
+    if (o) {
+      const d = hit("shared_tree", `Another session (${o.id.slice(0, 8)}) is active in this same checkout. \`git add -A\` / \`git commit -a\` will sweep its uncommitted changes into your commit. Stage explicit paths (\`git add <path>\`), or give each session its own git worktree.`);
+      if (d.action !== "allow")
+        return d;
+    }
+  }
+  if (modes.destructive_git !== "off" && isDestructiveGit(cmd)) {
+    const o = other();
+    if (o) {
+      const d = hit("destructive_git", `Another session (${o.id.slice(0, 8)}) is active in this same checkout and may have uncommitted work. This command can discard it. Coordinate, or use a separate git worktree.`);
+      if (d.action !== "allow")
+        return d;
+    }
+  }
+  return { action: "allow" };
+}
+function norm(p) {
+  const parts = [];
+  for (const seg of p.split("/")) {
+    if (seg === "" || seg === ".")
+      continue;
+    if (seg === "..")
+      parts.pop();
+    else
+      parts.push(seg);
+  }
+  return `/${parts.join("/")}`;
+}
+function isInside(path, dir) {
+  if (!path || !dir)
+    return false;
+  const a = norm(path);
+  const d = norm(dir);
+  return a === d || a.startsWith(`${d}/`);
+}
+function absolutePath(path, cwd) {
+  if (path.startsWith("/"))
+    return path;
+  if (path.startsWith("~/"))
+    return path;
+  return `${cwd.replace(/\/+$/, "")}/${path}`;
+}
+var WRITE_TOOLS = new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
+function guardWrite(target, current, claims, modes = DEFAULT_MODES, kind = "file") {
+  const hit = (rule, reason) => {
+    const mode = modes[rule];
+    return mode === "off" ? { action: "allow" } : { action: mode, rule, reason };
+  };
+  const held = claims.filter((c) => c.worktree);
+  const mine = held.find((c) => isInside(current.cwd, c.worktree)) ?? null;
+  if (modes.no_foreign_worktree !== "off") {
+    const foreign = held.find((c) => isInside(target, c.worktree) && c !== mine);
+    if (foreign) {
+      const d = hit("no_foreign_worktree", kind === "bash" ? `This command runs inside the worktree for "${foreign.task}", held by ${foreign.owner}. Never touch a worktree you don't hold \u2014 work in your own checkout, or claim the task.` : `${target} is inside the worktree for "${foreign.task}", held by ${foreign.owner}. Never touch a worktree you don't hold \u2014 edit your own checkout, or claim the task.`);
+      if (d.action !== "allow")
+        return d;
+    }
+  }
+  if (modes.claim_required_to_write !== "off" && kind === "file" && current.toplevel && !mine) {
+    const inShared = isInside(target, current.toplevel) && !held.some((c) => isInside(target, c.worktree));
+    if (inShared) {
+      const d = hit("claim_required_to_write", `This repo requires a claim before writing to its shared checkout. Run \`swarm claim <task>\` (or the swarm_claim MCP tool) and work in the worktree it creates.`);
+      if (d.action !== "allow")
+        return d;
+    }
+  }
+  return { action: "allow" };
+}
+// packages/core/src/tasks.ts
+var ID_RE = /^[A-Za-z][A-Za-z0-9_-]*\d[\w.-]*$/;
+var DEP_RE = /[A-Za-z][A-Za-z0-9_-]*\d[\w.]*/g;
+function splitRow(line) {
+  const t = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+  const cells = [];
+  let cur = "";
+  let code = false;
+  for (const ch of t) {
+    if (ch === "`")
+      code = !code;
+    if (ch === "|" && !code) {
+      cells.push(cur.trim());
+      cur = "";
+    } else
+      cur += ch;
+  }
+  cells.push(cur.trim());
+  return cells;
+}
+function isSeparator(line) {
+  return /^\|?\s*:?-{2,}/.test(line.trim()) && !/[A-Za-z]/.test(line);
+}
+function statusOf(cell) {
+  const c = cell.trim();
+  if (/^(\u2705|\u2611|\u2714|\[x\]|done|shipped|complete)/i.test(c))
+    return "done";
+  if (/^(\uD83D\uDFE1|\uD83D\uDFE0|\uD83D\uDD35|\[~\]|wip|active|doing|in[- ]progress|held)/i.test(c))
+    return "active";
+  return "todo";
+}
+function parseMarkdownTasks(text) {
+  const out = [];
+  const lines = text.split(/\r?\n/);
+  let milestone = null;
+  let cols = null;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const h = /^#{1,6}\s+(.+)/.exec(line);
+    if (h) {
+      milestone = (h[1] ?? "").trim();
+      cols = null;
+      continue;
+    }
+    if (!line.trim().startsWith("|")) {
+      cols = null;
+      continue;
+    }
+    const cells = splitRow(line);
+    if (!cols) {
+      const lc = cells.map((c) => c.toLowerCase());
+      const id2 = lc.indexOf("id");
+      const task = lc.findIndex((c) => c === "task" || c === "title");
+      if (id2 < 0 || task < 0 || !isSeparator(lines[i + 1] ?? ""))
+        continue;
+      cols = {
+        id: id2,
+        task,
+        depends: lc.findIndex((c) => c.startsWith("depend")),
+        status: lc.indexOf("status")
+      };
+      i++;
+      continue;
+    }
+    const id = cells[cols.id] ?? "";
+    if (!ID_RE.test(id))
+      continue;
+    const depCell = cols.depends >= 0 ? cells[cols.depends] ?? "" : "";
+    const depends = /^(\u2014|-|\u2013|none)?$/.test(depCell.trim()) ? [] : depCell.match(DEP_RE) ?? [];
+    const statusText = cols.status >= 0 ? cells[cols.status] ?? "" : "";
+    out.push({
+      id,
+      title: (cells[cols.task] ?? "").replace(/\*\*/g, ""),
+      depends,
+      status: statusOf(statusText),
+      statusText,
+      milestone
+    });
+  }
+  return out;
+}
+function depsDone(task, all) {
+  return task.depends.every((d) => {
+    const exact = all.find((t) => t.id === d);
+    if (exact)
+      return exact.status === "done";
+    const under = all.filter((t) => t.id.startsWith(`${d}.`));
+    return under.length === 0 || under.every((t) => t.status === "done");
+  });
+}
+function taskBoard(tasks, activeClaims) {
+  return tasks.map((t) => {
+    const claim = activeClaims.find((c) => c.task === t.id) ?? null;
+    return {
+      ...t,
+      claimedBy: claim?.owner ?? null,
+      ready: t.status === "todo" && !claim && depsDone(t, tasks)
+    };
+  });
+}
+// packages/daemon/src/app.ts
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4, realpathSync as realpathSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname2, join as join6 } from "path";
+import { fileURLToPath } from "url";
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/compose.js
+var compose = (middleware, onError, onNotFound) => {
+  return (context, next) => {
+    let index = -1;
+    return dispatch(0);
+    async function dispatch(i) {
+      if (i <= index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i;
+      let res;
+      let isError = false;
+      let handler;
+      if (middleware[i]) {
+        handler = middleware[i][0][0];
+        context.req.routeIndex = i;
+      } else {
+        handler = i === middleware.length && next || undefined;
+      }
+      if (handler) {
+        try {
+          res = await handler(context, () => dispatch(i + 1));
+        } catch (err) {
+          if (err instanceof Error && onError) {
+            context.error = err;
+            res = await onError(err, context);
+            isError = true;
+          } else {
+            throw err;
+          }
+        }
+      } else {
+        if (context.finalized === false && onNotFound) {
+          res = await onNotFound(context);
+        }
+      }
+      if (res && (context.finalized === false || isError)) {
+        context.res = res;
+      }
+      return context;
+    }
+  };
+};
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/request/constants.js
+var GET_MATCH_RESULT = /* @__PURE__ */ Symbol();
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/utils/buffer.js
+var bufferToFormData = (arrayBuffer, contentType) => {
+  const response = new Response(arrayBuffer, {
+    headers: {
+      "Content-Type": contentType.replace(/^[^;]+/, (mediaType) => mediaType.toLowerCase())
+    }
+  });
+  return response.formData();
+};
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/utils/body.js
+var isRawRequest = (request) => ("headers" in request);
+var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
+  const { all = false, dot = false } = options;
+  const headers = isRawRequest(request) ? request.headers : request.raw.headers;
+  const contentType = headers.get("Content-Type");
+  const mediaType = contentType?.split(";")[0].trim().toLowerCase();
+  if (mediaType === "multipart/form-data" || mediaType === "application/x-www-form-urlencoded") {
+    return parseFormData(request, { all, dot });
+  }
+  return {};
+};
+async function parseFormData(request, options) {
+  if (!isRawRequest(request) && request.bodyCache.formData) {
+    return convertFormDataToBodyData(await request.bodyCache.formData, options);
+  }
+  const headers = isRawRequest(request) ? request.headers : request.raw.headers;
+  const arrayBuffer = await request.arrayBuffer();
+  const formDataPromise = bufferToFormData(arrayBuffer, headers.get("Content-Type") || "");
+  if (!isRawRequest(request)) {
+    request.bodyCache.formData = formDataPromise;
+  }
+  const formData = await formDataPromise;
+  if (formData) {
+    return convertFormDataToBodyData(formData, options);
+  }
+  return {};
+}
+function convertFormDataToBodyData(formData, options) {
+  const form = /* @__PURE__ */ Object.create(null);
+  formData.forEach((value, key) => {
+    const shouldParseAllValues = options.all || key.endsWith("[]");
+    if (!shouldParseAllValues) {
+      form[key] = value;
+    } else {
+      handleParsingAllValues(form, key, value);
+    }
+  });
+  if (options.dot) {
+    Object.entries(form).forEach(([key, value]) => {
+      const shouldParseDotValues = key.includes(".");
+      if (shouldParseDotValues) {
+        handleParsingNestedValues(form, key, value);
+        delete form[key];
+      }
+    });
+  }
+  return form;
+}
+var handleParsingAllValues = (form, key, value) => {
+  if (form[key] !== undefined) {
+    if (Array.isArray(form[key])) {
+      form[key].push(value);
+    } else {
+      form[key] = [form[key], value];
+    }
+  } else {
+    if (!key.endsWith("[]")) {
+      form[key] = value;
+    } else {
+      form[key] = [value];
+    }
+  }
+};
+var handleParsingNestedValues = (form, key, value) => {
+  if (/(?:^|\.)__proto__\./.test(key)) {
+    return;
+  }
+  let nestedForm = form;
+  const keys = key.split(".");
+  keys.forEach((key2, index) => {
+    if (index === keys.length - 1) {
+      nestedForm[key2] = value;
+    } else {
+      if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
+        nestedForm[key2] = /* @__PURE__ */ Object.create(null);
+      }
+      nestedForm = nestedForm[key2];
+    }
+  });
+};
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/utils/url.js
+var splitPath = (path) => {
+  const paths = path.split("/");
+  if (paths[0] === "") {
+    paths.shift();
+  }
+  return paths;
+};
+var splitRoutingPath = (routePath) => {
+  const { groups, path } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path);
+  return replaceGroupMarks(paths, groups);
+};
+var extractGroupsFromPath = (path) => {
+  const groups = [];
+  path = path.replace(/\{[^}]+\}/g, (match, index) => {
+    const mark = `@${index}`;
+    groups.push([mark, match]);
+    return mark;
+  });
+  return { groups, path };
+};
+var replaceGroupMarks = (paths, groups) => {
+  for (let i = groups.length - 1;i >= 0; i--) {
+    const [mark] = groups[i];
+    for (let j = paths.length - 1;j >= 0; j--) {
+      if (paths[j].includes(mark)) {
+        paths[j] = paths[j].replace(mark, groups[i][1]);
+        break;
+      }
+    }
+  }
+  return paths;
+};
+var patternCache = {};
+var getPattern = (label, next) => {
+  if (label === "*") {
+    return "*";
+  }
+  const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+  if (match) {
+    const cacheKey = `${label}#${next}`;
+    if (!patternCache[cacheKey]) {
+      if (match[2]) {
+        patternCache[cacheKey] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey, match[1], new RegExp(`^${match[2]}(?=/${next})`)] : [label, match[1], new RegExp(`^${match[2]}$`)];
+      } else {
+        patternCache[cacheKey] = [label, match[1], true];
+      }
+    }
+    return patternCache[cacheKey];
+  }
+  return null;
+};
+var tryDecode = (str, decoder) => {
+  try {
+    return decoder(str);
+  } catch {
+    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+      try {
+        return decoder(match);
+      } catch {
+        return match;
+      }
+    });
+  }
+};
+var tryDecodeURI = (str) => tryDecode(str, decodeURI);
+var getPath = (request) => {
+  const url = request.url;
+  const start = url.indexOf("/", url.indexOf(":") + 4);
+  let i = start;
+  for (;i < url.length; i++) {
+    const charCode = url.charCodeAt(i);
+    if (charCode === 37) {
+      const queryIndex = url.indexOf("?", i);
+      const hashIndex = url.indexOf("#", i);
+      const end = queryIndex === -1 ? hashIndex === -1 ? undefined : hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
+      const path = url.slice(start, end);
+      return tryDecodeURI(path.includes("%25") ? path.replace(/%25/g, "%2525") : path);
+    } else if (charCode === 63 || charCode === 35) {
+      break;
+    }
+  }
+  return url.slice(start, i);
+};
+var getPathNoStrict = (request) => {
+  const result = getPath(request);
+  return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
+};
+var mergePath = (base, sub, ...rest) => {
+  if (rest.length) {
+    sub = mergePath(sub, ...rest);
+  }
+  return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
+};
+var checkOptionalParameter = (path) => {
+  if (path.charCodeAt(path.length - 1) !== 63 || !path.includes(":")) {
+    return null;
+  }
+  const segments = path.split("/");
+  const results = [];
+  let basePath = "";
+  segments.forEach((segment) => {
+    if (segment !== "" && !/\:/.test(segment)) {
+      basePath += "/" + segment;
+    } else if (/\:/.test(segment)) {
+      if (segment.charCodeAt(segment.length - 1) === 63) {
+        if (results.length === 0 && basePath === "") {
+          results.push("/");
+        } else {
+          results.push(basePath);
+        }
+        const optionalSegment = segment.slice(0, -1);
+        basePath += "/" + optionalSegment;
+        results.push(basePath);
+      } else {
+        basePath += "/" + segment;
+      }
+    }
+  });
+  return results.filter((v, i, a) => a.indexOf(v) === i);
+};
+var tryDecodeURIComponent = (str) => str.indexOf("%") !== -1 ? tryDecode(str, decodeURIComponent_) : str;
+var _decodeURI = (value) => {
+  if (value.indexOf("+") !== -1) {
+    value = value.replace(/\+/g, " ");
+  }
+  return tryDecodeURIComponent(value);
+};
+var _getQueryParam = (url, key, multiple) => {
+  let encoded;
+  if (!multiple && key && key.indexOf("%") === -1 && key.indexOf("+") === -1) {
+    let keyIndex2 = url.indexOf("?", 8);
+    if (keyIndex2 === -1) {
+      return;
+    }
+    if (!url.startsWith(key, keyIndex2 + 1)) {
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+    }
+    while (keyIndex2 !== -1) {
+      const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
+      if (trailingKeyCode === 61) {
+        const valueIndex = keyIndex2 + key.length + 2;
+        const endIndex = url.indexOf("&", valueIndex);
+        return _decodeURI(url.slice(valueIndex, endIndex === -1 ? undefined : endIndex));
+      } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) {
+        return "";
+      }
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+    }
+    encoded = /[%+]/.test(url);
+    if (!encoded) {
+      return;
+    }
+  }
+  const results = /* @__PURE__ */ Object.create(null);
+  encoded ??= /[%+]/.test(url);
+  let keyIndex = url.indexOf("?", 8);
+  while (keyIndex !== -1) {
+    const nextKeyIndex = url.indexOf("&", keyIndex + 1);
+    let valueIndex = url.indexOf("=", keyIndex);
+    if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) {
+      valueIndex = -1;
+    }
+    let name = url.slice(keyIndex + 1, valueIndex === -1 ? nextKeyIndex === -1 ? undefined : nextKeyIndex : valueIndex);
+    if (encoded) {
+      name = _decodeURI(name);
+    }
+    keyIndex = nextKeyIndex;
+    if (name === "") {
+      continue;
+    }
+    let value;
+    if (valueIndex === -1) {
+      value = "";
+    } else {
+      value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? undefined : nextKeyIndex);
+      if (encoded) {
+        value = _decodeURI(value);
+      }
+    }
+    if (multiple) {
+      if (!(results[name] && Array.isArray(results[name]))) {
+        results[name] = [];
+      }
+      results[name].push(value);
+    } else {
+      results[name] ??= value;
+    }
+  }
+  return key ? results[key] : results;
+};
+var getQueryParam = _getQueryParam;
+var getQueryParams = (url, key) => {
+  return _getQueryParam(url, key, true);
+};
+var decodeURIComponent_ = decodeURIComponent;
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/request.js
+var HonoRequest = class {
+  raw;
+  #validatedData;
+  #matchResult;
+  routeIndex = 0;
+  path;
+  bodyCache = {};
+  constructor(request, path = "/", matchResult = [[]]) {
+    this.raw = request;
+    this.path = path;
+    this.#matchResult = matchResult;
+  }
+  param(key) {
+    return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
+  }
+  #getDecodedParam(key) {
+    const paramKey = this.#matchResult[0][this.routeIndex][1][key];
+    const param = this.#getParamValue(paramKey);
+    return param && tryDecodeURIComponent(param);
+  }
+  #getAllDecodedParams() {
+    const decoded = {};
+    const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
+    for (const key of keys) {
+      const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
+      if (value !== undefined) {
+        decoded[key] = tryDecodeURIComponent(value);
+      }
+    }
+    return decoded;
+  }
+  #getParamValue(paramKey) {
+    return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
+  }
+  query(key) {
+    return getQueryParam(this.url, key);
+  }
+  queries(key) {
+    return getQueryParams(this.url, key);
+  }
+  header(name) {
+    if (name) {
+      return this.raw.headers.get(name) ?? undefined;
+    }
+    const headerData = /* @__PURE__ */ Object.create(null);
+    this.raw.headers.forEach((value, key) => {
+      headerData[key] = value;
+    });
+    return headerData;
+  }
+  async parseBody(options) {
+    return parseBody(this, options);
+  }
+  #cachedBody = (key) => {
+    const { bodyCache, raw } = this;
+    const cachedBody = bodyCache[key];
+    if (cachedBody) {
+      return cachedBody;
+    }
+    for (const anyCachedKey in bodyCache) {
+      return bodyCache[anyCachedKey].then((body) => {
+        if (anyCachedKey === "json") {
+          body = JSON.stringify(body);
+        }
+        return new Response(body)[key]();
+      });
+    }
+    return bodyCache[key] = raw[key]();
+  };
+  json() {
+    return this.#cachedBody("text").then((text) => JSON.parse(text));
+  }
+  text() {
+    return this.#cachedBody("text");
+  }
+  arrayBuffer() {
+    return this.#cachedBody("arrayBuffer");
+  }
+  bytes() {
+    return this.#cachedBody("arrayBuffer").then((buffer) => new Uint8Array(buffer));
+  }
+  blob() {
+    return this.#cachedBody("blob");
+  }
+  formData() {
+    return this.#cachedBody("formData");
+  }
+  addValidatedData(target, data) {
+    (this.#validatedData ??= {})[target] = data;
+  }
+  valid(target) {
+    return this.#validatedData?.[target];
+  }
+  get url() {
+    return this.raw.url;
+  }
+  get method() {
+    return this.raw.method;
+  }
+  get [GET_MATCH_RESULT]() {
+    return this.#matchResult;
+  }
+  get matchedRoutes() {
+    return this.#matchResult[0].map(([[, route]]) => route);
+  }
+  get routePath() {
+    return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
+  }
+};
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/utils/html.js
+var HtmlEscapedCallbackPhase = {
+  Stringify: 1,
+  BeforeStream: 2,
+  Stream: 3
+};
+var raw = (value, callbacks) => {
+  const escapedString = new String(value);
+  escapedString.isEscaped = true;
+  escapedString.callbacks = callbacks;
+  return escapedString;
+};
+var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+  if (typeof str === "object" && !(str instanceof String)) {
+    if (!(str instanceof Promise)) {
+      str = str.toString();
+    }
+    if (str instanceof Promise) {
+      str = await str;
+    }
+  }
+  const callbacks = str.callbacks;
+  if (!callbacks?.length) {
+    return Promise.resolve(str);
+  }
+  if (buffer) {
+    buffer[0] += str;
+  } else {
+    buffer = [str];
+  }
+  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 {
+    return resStr;
+  }
+};
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/context.js
+var TEXT_PLAIN = "text/plain; charset=UTF-8";
+var setDefaultContentType = (contentType, headers) => {
+  return {
+    "Content-Type": contentType,
+    ...headers
+  };
+};
+var createResponseInstance = (body, init) => new Response(body, init);
+var Context = class {
+  #rawRequest;
+  #req;
+  env = {};
+  #var;
+  finalized = false;
+  error;
+  #status;
+  #executionCtx;
+  #res;
+  #layout;
+  #renderer;
+  #notFoundHandler;
+  #preparedHeaders;
+  #matchResult;
+  #path;
+  constructor(req, options) {
+    this.#rawRequest = req;
+    if (options) {
+      this.#executionCtx = options.executionCtx;
+      this.env = options.env;
+      this.#notFoundHandler = options.notFoundHandler;
+      this.#path = options.path;
+      this.#matchResult = options.matchResult;
+    }
+  }
+  get req() {
+    this.#req ??= new HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
+    return this.#req;
+  }
+  get event() {
+    if (this.#executionCtx && "respondWith" in this.#executionCtx) {
+      return this.#executionCtx;
+    } else {
+      throw Error("This context has no FetchEvent");
+    }
+  }
+  get executionCtx() {
+    if (this.#executionCtx) {
+      return this.#executionCtx;
+    } else {
+      throw Error("This context has no ExecutionContext");
+    }
+  }
+  get res() {
+    return this.#res ||= createResponseInstance(null, {
+      headers: this.#preparedHeaders ??= new Headers
+    });
+  }
+  set res(_res) {
+    if (this.#res && _res) {
+      _res = createResponseInstance(_res.body, _res);
+      for (const [k, v] of this.#res.headers.entries()) {
+        if (k === "content-type") {
+          continue;
+        }
+        if (k === "set-cookie") {
+          const cookies = this.#res.headers.getSetCookie();
+          _res.headers.delete("set-cookie");
+          for (const cookie of cookies) {
+            _res.headers.append("set-cookie", cookie);
+          }
+        } else {
+          _res.headers.set(k, v);
+        }
+      }
+    }
+    this.#res = _res;
+    this.finalized = true;
+  }
+  render = (...args) => {
+    this.#renderer ??= (content) => this.html(content);
+    return this.#renderer(...args);
+  };
+  setLayout = (layout) => this.#layout = layout;
+  getLayout = () => this.#layout;
+  setRenderer = (renderer) => {
+    this.#renderer = renderer;
+  };
+  header = (name, value, options) => {
+    if (this.finalized) {
+      this.#res = createResponseInstance(this.#res.body, this.#res);
+    }
+    const headers = this.#res ? this.#res.headers : this.#preparedHeaders ??= new Headers;
+    if (value === undefined) {
+      headers.delete(name);
+    } else if (options?.append) {
+      headers.append(name, value);
+    } else {
+      headers.set(name, value);
+    }
+  };
+  status = (status) => {
+    this.#status = status;
+  };
+  set = (key, value) => {
+    this.#var ??= /* @__PURE__ */ new Map;
+    this.#var.set(key, value);
+  };
+  get = (key) => {
+    return this.#var ? this.#var.get(key) : undefined;
+  };
+  get var() {
+    if (!this.#var) {
+      return {};
+    }
+    return Object.fromEntries(this.#var);
+  }
+  #newResponse(data, arg, headers) {
+    let responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders;
+    if (typeof arg === "object" && arg.headers) {
+      responseHeaders ??= new Headers;
+      for (const [key, value] of new Headers(arg.headers)) {
+        if (key === "set-cookie") {
+          responseHeaders.append(key, value);
+        } else {
+          responseHeaders.set(key, value);
+        }
+      }
+    }
+    if (headers) {
+      if (!responseHeaders) {
+        let count = 0;
+        for (const k in headers) {
+          if (++count > 1 || typeof headers[k] !== "string") {
+            responseHeaders = new Headers;
+            break;
+          }
+        }
+      }
+      if (responseHeaders) {
+        for (const k in headers) {
+          const v = headers[k];
+          if (typeof v === "string") {
+            responseHeaders.set(k, v);
+          } else {
+            responseHeaders.delete(k);
+            for (const v2 of v) {
+              responseHeaders.append(k, v2);
+            }
+          }
+        }
+      }
+    }
+    const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
+    return createResponseInstance(data, {
+      status,
+      headers: responseHeaders ?? headers
+    });
+  }
+  newResponse = (...args) => this.#newResponse(...args);
+  body = (data, arg, headers) => this.#newResponse(data, arg, headers);
+  text = (text, arg, headers) => {
+    return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(text, arg, setDefaultContentType(TEXT_PLAIN, headers));
+  };
+  json = (object, arg, headers) => {
+    return this.#newResponse(JSON.stringify(object), arg, setDefaultContentType("application/json", headers));
+  };
+  html = (html, arg, headers) => {
+    const res = (html2) => this.#newResponse(html2, arg, setDefaultContentType("text/html; charset=UTF-8", headers));
+    return typeof html === "object" ? resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html);
+  };
+  redirect = (location, status) => {
+    const locationString = String(location);
+    this.header("Location", !/[^\x00-\xFF]/.test(locationString) ? locationString : encodeURI(locationString));
+    return this.newResponse(null, status ?? 302);
+  };
+  notFound = () => {
+    this.#notFoundHandler ??= () => createResponseInstance();
+    return this.#notFoundHandler(this);
+  };
+};
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/router.js
+var METHOD_NAME_ALL = "ALL";
+var METHOD_NAME_ALL_LOWERCASE = "all";
+var METHODS = ["get", "post", "put", "delete", "options", "patch", "query"];
+var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+var UnsupportedPathError = class extends Error {
+};
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/utils/constants.js
+var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/hono-base.js
+var notFoundHandler = (c) => {
+  return c.text("404 Not Found", 404);
+};
+var errorHandler = (err, c) => {
+  if ("getResponse" in err) {
+    const res = err.getResponse();
+    return c.newResponse(res.body, res);
+  }
+  console.error(err);
+  return c.text("Internal Server Error", 500);
+};
+var Hono = class _Hono {
+  get;
+  post;
+  put;
+  delete;
+  options;
+  patch;
+  query;
+  all;
+  on;
+  use;
+  router;
+  getPath;
+  _basePath = "/";
+  #path = "/";
+  routes = [];
+  constructor(options = {}) {
+    const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
+    allMethods.forEach((method) => {
+      this[method] = (args1, ...args) => {
+        if (typeof args1 === "string") {
+          this.#path = args1;
+        } else {
+          this.#addRoute(method, this.#path, args1);
+        }
+        args.forEach((handler) => {
+          this.#addRoute(method, this.#path, handler);
+        });
+        return this;
+      };
+    });
+    this.on = (method, path, ...handlers) => {
+      for (const p of [path].flat()) {
+        this.#path = p;
+        for (const m of [method].flat()) {
+          handlers.map((handler) => {
+            this.#addRoute(m.toUpperCase(), this.#path, handler);
+          });
+        }
+      }
+      return this;
+    };
+    this.use = (arg1, ...handlers) => {
+      if (typeof arg1 === "string") {
+        this.#path = arg1;
+      } else {
+        this.#path = "*";
+        handlers.unshift(arg1);
+      }
+      handlers.forEach((handler) => {
+        this.#addRoute(METHOD_NAME_ALL, this.#path, handler);
+      });
+      return this;
+    };
+    const { strict, ...optionsWithoutStrict } = options;
+    Object.assign(this, optionsWithoutStrict);
+    this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
+  }
+  #clone() {
+    const clone = new _Hono({
+      router: this.router,
+      getPath: this.getPath
+    });
+    clone.errorHandler = this.errorHandler;
+    clone.#notFoundHandler = this.#notFoundHandler;
+    clone.routes = this.routes;
+    return clone;
+  }
+  #notFoundHandler = notFoundHandler;
+  errorHandler = errorHandler;
+  route(path, app) {
+    const subApp = this.basePath(path);
+    app.routes.map((r) => {
+      let handler;
+      if (app.errorHandler === errorHandler) {
+        handler = r.handler;
+      } else {
+        handler = async (c, next) => (await compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
+        handler[COMPOSED_HANDLER] = r.handler;
+      }
+      subApp.#addRoute(r.method, r.path, handler, r.basePath);
+    });
+    return this;
+  }
+  basePath(path) {
+    const subApp = this.#clone();
+    subApp._basePath = mergePath(this._basePath, path);
+    return subApp;
+  }
+  onError = (handler) => {
+    this.errorHandler = handler;
+    return this;
+  };
+  notFound = (handler) => {
+    this.#notFoundHandler = handler;
+    return this;
+  };
+  mount(path, applicationHandler, options) {
+    let replaceRequest;
+    let optionHandler;
+    if (options) {
+      if (typeof options === "function") {
+        optionHandler = options;
+      } else {
+        optionHandler = options.optionHandler;
+        if (options.replaceRequest === false) {
+          replaceRequest = (request) => request;
+        } else {
+          replaceRequest = options.replaceRequest;
+        }
+      }
+    }
+    const getOptions = optionHandler ? (c) => {
+      const options2 = optionHandler(c);
+      return Array.isArray(options2) ? options2 : [options2];
+    } : (c) => {
+      let executionContext = undefined;
+      try {
+        executionContext = c.executionCtx;
+      } catch {}
+      return [c.env, executionContext];
+    };
+    replaceRequest ||= (() => {
+      const mergedPath = mergePath(this._basePath, path);
+      const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
+      return (request) => {
+        const url = new URL(request.url);
+        url.pathname = this.getPath(request).slice(pathPrefixLength) || "/";
+        return new Request(url, request);
+      };
+    })();
+    const handler = async (c, next) => {
+      const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
+      if (res) {
+        return res;
+      }
+      await next();
+    };
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path, "*"), handler);
+    return this;
+  }
+  #addRoute(method, path, handler, baseRoutePath) {
+    method = method.toUpperCase();
+    path = mergePath(this._basePath, path);
+    const r = {
+      basePath: baseRoutePath !== undefined ? mergePath(this._basePath, baseRoutePath) : this._basePath,
+      path,
+      method,
+      handler
+    };
+    this.router.add(method, path, [handler, r]);
+    this.routes.push(r);
+  }
+  #handleError(err, c) {
+    if (err instanceof Error) {
+      return this.errorHandler(err, c);
+    }
+    throw err;
+  }
+  #dispatch(request, executionCtx, env, method) {
+    if (method === "HEAD") {
+      return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
+    }
+    const path = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path);
+    const c = new Context(request, {
+      path,
+      matchResult,
+      env,
+      executionCtx,
+      notFoundHandler: this.#notFoundHandler
+    });
+    if (matchResult[0].length === 1) {
+      let res;
+      try {
+        res = matchResult[0][0][0][0](c, async () => {
+          c.res = await this.#notFoundHandler(c);
+        });
+      } catch (err) {
+        return this.#handleError(err, c);
+      }
+      return res instanceof Promise ? res.then((resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
+    }
+    const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
+    return (async () => {
+      try {
+        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 context.res;
+      } catch (err) {
+        return this.#handleError(err, c);
+      }
+    })();
+  }
+  fetch = (request, ...rest) => {
+    return this.#dispatch(request, rest[1], rest[0], request.method);
+  };
+  request = (input, requestInit, Env, executionCtx) => {
+    if (input instanceof Request) {
+      return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
+    }
+    input = input.toString();
+    return this.fetch(new Request(/^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`, requestInit), Env, executionCtx);
+  };
+  fire = () => {
+    addEventListener("fetch", (event) => {
+      event.respondWith(this.#dispatch(event.request, event, undefined, event.request.method));
+    });
+  };
+};
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/router/reg-exp-router/matcher.js
+var emptyParam = [];
+function match(method, path) {
+  const matchers = this.buildAllMatchers();
+  const match2 = (method2, path2) => {
+    const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
+    const staticMatch = matcher[2][path2];
+    if (staticMatch) {
+      return staticMatch;
+    }
+    const match3 = path2.match(matcher[0]);
+    if (!match3) {
+      return [[], emptyParam];
+    }
+    const index = match3.indexOf("", 1);
+    return [matcher[1][index], match3];
+  };
+  this.match = match2;
+  return match2(method, path);
+}
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/router/reg-exp-router/node.js
+var LABEL_REG_EXP_STR = "[^/]+";
+var ONLY_WILDCARD_REG_EXP_STR = ".*";
+var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
+var PATH_ERROR = /* @__PURE__ */ Symbol();
+var regExpMetaChars = new Set(".\\+*[^]$()");
+function compareKey(a, b) {
+  if (a.length === 1) {
+    return b.length === 1 ? a < b ? -1 : 1 : -1;
+  }
+  if (b.length === 1) {
+    return 1;
+  }
+  if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
+    return b === TAIL_WILDCARD_REG_EXP_STR ? -1 : 1;
+  } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
+    return -1;
+  }
+  if (a === LABEL_REG_EXP_STR) {
+    return 1;
+  } else if (b === LABEL_REG_EXP_STR) {
+    return -1;
+  }
+  return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
+}
+var Node = class _Node {
+  #index;
+  #varIndex;
+  #children = /* @__PURE__ */ Object.create(null);
+  insert(tokens, index, paramMap, context, isStatic) {
+    let node = this;
+    for (let i = 0, len = tokens.length;i < len; i++) {
+      const token = tokens[i];
+      const pattern = token.length === 1 ? token === "*" ? i === len - 1 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : null : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+      let nextNode;
+      if (pattern) {
+        const name = pattern[1];
+        let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
+        if (name && pattern[2]) {
+          if (regexpStr === ".*") {
+            throw PATH_ERROR;
+          }
+          regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
+          if (/\((?!\?:)/.test(regexpStr)) {
+            throw PATH_ERROR;
+          }
+          if (regexpStr.length === 1 && regExpMetaChars.has(regexpStr)) {
+            throw PATH_ERROR;
+          }
+        }
+        nextNode = node.#children[regexpStr];
+        if (!nextNode) {
+          if (regexpStr !== ONLY_WILDCARD_REG_EXP_STR && regexpStr !== TAIL_WILDCARD_REG_EXP_STR) {
+            for (const k in node.#children) {
+              if ((regexpStr.length > 1 || k.length > 1) && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR) {
+                throw PATH_ERROR;
+              }
+            }
+          }
+          nextNode = node.#children[regexpStr] = new _Node;
+        }
+        if (name !== "") {
+          nextNode.#varIndex ??= context.varIndex++;
+          paramMap.push([name, nextNode.#varIndex]);
+        }
+      } else {
+        nextNode = node.#children[token];
+        if (!nextNode) {
+          for (const k in node.#children) {
+            if (k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR) {
+              throw PATH_ERROR;
+            }
+          }
+          nextNode = node.#children[token] = new _Node;
+        }
+      }
+      node = nextNode;
+    }
+    if (node.#index !== undefined) {
+      throw PATH_ERROR;
+    }
+    node.#index = isStatic ? -1 : index;
+  }
+  buildRegExpStr() {
+    const childKeys = Object.keys(this.#children).sort(compareKey);
+    const strList = childKeys.map((k) => {
+      const c = this.#children[k];
+      const childStr = c.buildRegExpStr();
+      return childStr === "" ? "" : (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + childStr;
+    }).filter(Boolean);
+    if (typeof this.#index === "number" && this.#index !== -1) {
+      strList.unshift(`#${this.#index}`);
+    }
+    if (strList.length === 0) {
+      return "";
+    }
+    if (strList.length === 1) {
+      return strList[0];
+    }
+    return "(?:" + strList.join("|") + ")";
+  }
+};
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/router/reg-exp-router/trie.js
+var Trie = class {
+  #context = { varIndex: 0 };
+  #root = new Node;
+  #index = 0;
+  paths = /* @__PURE__ */ Object.create(null);
+  insert(path, isStatic) {
+    if (isStatic) {
+      this.#root.insert(path.split(""), 0, [], this.#context, true);
+      return;
+    }
+    const paramAssoc = [];
+    const groups = [];
+    let markedPath = path;
+    for (let i = 0;; ) {
+      let replaced = false;
+      markedPath = markedPath.replace(/\{[^}]+\}/g, (m) => {
+        const mark = `@\\${i}`;
+        groups[i] = [mark, m];
+        i++;
+        replaced = true;
+        return mark;
+      });
+      if (!replaced) {
+        break;
+      }
+    }
+    const tokens = markedPath.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    for (let i = groups.length - 1;i >= 0; i--) {
+      const [mark] = groups[i];
+      for (let j = tokens.length - 1;j >= 0; j--) {
+        if (tokens[j].indexOf(mark) !== -1) {
+          tokens[j] = tokens[j].replace(mark, groups[i][1]);
+          break;
+        }
+      }
+    }
+    this.#root.insert(tokens, this.#index, paramAssoc, this.#context, false);
+    this.paths[path] = [this.#index++, paramAssoc];
+  }
+  buildRegExp() {
+    let regexp = this.#root.buildRegExpStr();
+    if (regexp === "") {
+      return [/^$/, [], []];
+    }
+    let captureIndex = 0;
+    const indexReplacementMap = [];
+    const paramReplacementMap = [];
+    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+      if (handlerIndex !== undefined) {
+        indexReplacementMap[++captureIndex] = Number(handlerIndex);
+        return "$()";
+      }
+      if (paramIndex !== undefined) {
+        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+        return "";
+      }
+      return "";
+    });
+    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
+  }
+};
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/router/reg-exp-router/router.js
+var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+function buildWildcardRegExp(path) {
+  return wildcardRegExpCache[path] ??= new RegExp(path === "*" ? "" : `^${path.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)")}$`);
+}
+function clearWildcardRegExpCache() {
+  wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+}
+function findMiddleware(middleware, path) {
+  if (!middleware) {
+    return;
+  }
+  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
+    if (buildWildcardRegExp(k).test(path)) {
+      return [...middleware[k]];
+    }
+  }
+  return;
+}
+var RegExpRouter = class {
+  name = "RegExpRouter";
+  #middleware;
+  #routes;
+  #tries;
+  constructor() {
+    this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#tries = { [METHOD_NAME_ALL]: new Trie };
+  }
+  #insertPath(method, path) {
+    try {
+      this.#tries[method].insert(path, !/\*|\/:/.test(path));
+    } catch (e) {
+      throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
+    }
+  }
+  add(method, path, handler) {
+    const middleware = this.#middleware;
+    const routes = this.#routes;
+    if (!middleware || !routes) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+    }
+    if (!middleware[method]) {
+      this.#tries[method] = new Trie;
+      [middleware, routes].forEach((handlerMap) => {
+        handlerMap[method] = /* @__PURE__ */ Object.create(null);
+        Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p) => {
+          handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]];
+          this.#insertPath(method, p);
+        });
+      });
+    }
+    if (path === "/*") {
+      path = "*";
+    }
+    const paramCount = (path.match(/\/:/g) || []).length;
+    if (/\*$/.test(path)) {
+      const re = buildWildcardRegExp(path);
+      Object.keys(middleware).forEach((m) => {
+        if ((method === METHOD_NAME_ALL || method === m) && !middleware[m][path]) {
+          this.#insertPath(m, path);
+          middleware[m][path] = findMiddleware(middleware[m], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
+        }
+      });
+      Object.keys(middleware).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          Object.keys(middleware[m]).forEach((p) => {
+            re.test(p) && middleware[m][p].push([handler, paramCount]);
+          });
+        }
+      });
+      Object.keys(routes).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          Object.keys(routes[m]).forEach((p) => re.test(p) && routes[m][p].push([handler, paramCount]));
+        }
+      });
+      return;
+    }
+    const paths = checkOptionalParameter(path) || [path];
+    for (let i = 0, len = paths.length;i < len; i++) {
+      const path2 = paths[i];
+      Object.keys(routes).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          if (!routes[m][path2]) {
+            this.#insertPath(m, path2);
+            routes[m][path2] = [
+              ...findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []
+            ];
+          }
+          routes[m][path2].push([handler, paramCount - len + i + 1]);
+        }
+      });
+    }
+  }
+  match = match;
+  buildAllMatchers() {
+    const matchers = /* @__PURE__ */ Object.create(null);
+    Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
+      matchers[method] ||= this.#buildMatcher(method);
+    });
+    this.#middleware = this.#routes = this.#tries = undefined;
+    clearWildcardRegExpCache();
+    return matchers;
+  }
+  #buildMatcher(method) {
+    const middleware = this.#middleware[method];
+    const routes = this.#routes[method];
+    const trie = this.#tries[method];
+    const staticMap = /* @__PURE__ */ Object.create(null);
+    const handlerData = [];
+    [middleware, routes].forEach((r) => {
+      for (const path in r) {
+        const handlers = r[path];
+        const pathData = trie.paths[path];
+        if (!pathData) {
+          staticMap[path] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+          continue;
+        }
+        const paramAssoc = pathData[1];
+        handlerData[pathData[0]] = handlers.map(([h, paramCount]) => {
+          const paramIndexMap = /* @__PURE__ */ Object.create(null);
+          paramCount -= 1;
+          for (;paramCount >= 0; paramCount--) {
+            const [key, value] = paramAssoc[paramCount];
+            paramIndexMap[key] = value;
+          }
+          return [h, paramIndexMap];
+        });
+      }
+    });
+    const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+    for (let i = 0, len = handlerData.length;i < len; i++) {
+      for (let j = 0, len2 = handlerData[i].length;j < len2; j++) {
+        const map = handlerData[i][j]?.[1];
+        if (!map) {
+          continue;
+        }
+        const keys = Object.keys(map);
+        for (let k = 0, len3 = keys.length;k < len3; k++) {
+          map[keys[k]] = paramReplacementMap[map[keys[k]]];
+        }
+      }
+    }
+    const handlerMap = [];
+    for (const i in indexReplacementMap) {
+      handlerMap[i] = handlerData[indexReplacementMap[i]];
+    }
+    return [regexp, handlerMap, staticMap];
+  }
+};
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/router/reg-exp-router/prepared-router.js
+var PreparedRegExpRouter = class {
+  name = "PreparedRegExpRouter";
+  #matchers;
+  #relocateMap;
+  constructor(matchers, relocateMap) {
+    this.#matchers = matchers;
+    this.#relocateMap = relocateMap;
+  }
+  #addWildcard(method, handlerData) {
+    const matcher = this.#matchers[method];
+    matcher[1].forEach((list) => list && list.push(handlerData));
+    Object.values(matcher[2]).forEach((list) => list[0].push(handlerData));
+  }
+  #addPath(method, path, handler, indexes, map) {
+    const matcher = this.#matchers[method];
+    if (!map) {
+      matcher[2][path][0].push([handler, {}]);
+    } else {
+      indexes.forEach((index) => {
+        if (typeof index === "number") {
+          matcher[1][index].push([handler, map]);
+        } else {
+          matcher[2][index || path][0].push([handler, map]);
+        }
+      });
+    }
+  }
+  add(method, path, handler) {
+    if (!this.#matchers[method]) {
+      const all = this.#matchers[METHOD_NAME_ALL];
+      const staticMap = {};
+      for (const key in all[2]) {
+        staticMap[key] = [all[2][key][0].slice(), emptyParam];
+      }
+      this.#matchers[method] = [
+        all[0],
+        all[1].map((list) => Array.isArray(list) ? list.slice() : 0),
+        staticMap
+      ];
+    }
+    if (path === "/*" || path === "*") {
+      const handlerData = [handler, {}];
+      if (method === METHOD_NAME_ALL) {
+        for (const m in this.#matchers) {
+          this.#addWildcard(m, handlerData);
+        }
+      } else {
+        this.#addWildcard(method, handlerData);
+      }
+      return;
+    }
+    const data = this.#relocateMap[path];
+    if (!data) {
+      throw new Error(`Path ${path} is not registered`);
+    }
+    for (const [indexes, map] of data) {
+      if (method === METHOD_NAME_ALL) {
+        for (const m in this.#matchers) {
+          this.#addPath(m, path, handler, indexes, map);
+        }
+      } else {
+        this.#addPath(method, path, handler, indexes, map);
+      }
+    }
+  }
+  buildAllMatchers() {
+    return this.#matchers;
+  }
+  match = match;
+};
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/router/smart-router/router.js
+var SmartRouter = class {
+  name = "SmartRouter";
+  #routers = [];
+  #routes = [];
+  constructor(init) {
+    this.#routers = init.routers;
+  }
+  add(method, path, handler) {
+    if (!this.#routes) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+    }
+    this.#routes.push([method, path, handler]);
+  }
+  match(method, path) {
+    if (!this.#routes) {
+      throw new Error("Fatal error");
+    }
+    const routers = this.#routers;
+    const routes = this.#routes;
+    const len = routers.length;
+    let i = 0;
+    let res;
+    for (;i < len; i++) {
+      const router = routers[i];
+      try {
+        for (let i2 = 0, len2 = routes.length;i2 < len2; i2++) {
+          router.add(...routes[i2]);
+        }
+        res = router.match(method, path);
+      } catch (e) {
+        if (e instanceof UnsupportedPathError) {
+          continue;
+        }
+        throw e;
+      }
+      this.match = router.match.bind(router);
+      this.#routers = [router];
+      this.#routes = undefined;
+      break;
+    }
+    if (i === len) {
+      throw new Error("Fatal error");
+    }
+    this.name = `SmartRouter + ${this.activeRouter.name}`;
+    return res;
+  }
+  get activeRouter() {
+    if (this.#routes || this.#routers.length !== 1) {
+      throw new Error("No active router has been determined yet.");
+    }
+    return this.#routers[0];
+  }
+};
+
+// 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 {
+  #methods = [];
+  #children = /* @__PURE__ */ Object.create(null);
+  #patterns = [];
+  #pattern;
+  #params = emptyParams;
+  insert(method, path, handler) {
+    let curNode = this;
+    const parts = splitRoutingPath(path);
+    const possibleKeys = /* @__PURE__ */ new Set;
+    let i = 0;
+    for (const p of parts) {
+      const nextP = parts[++i];
+      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;
+      if (pattern && !child.#pattern) {
+        child.#pattern = pattern;
+        curNode.#patterns.push(child);
+      }
+      curNode = child;
+      if (isParam) {
+        possibleKeys.add(pattern[1]);
+      }
+    }
+    curNode.#methods.push({
+      [method]: {
+        handler,
+        possibleKeys: [...possibleKeys],
+        score: ++order
+      }
+    });
+  }
+  #pushHandlerSets(handlerSets, node, method, nodeParams, params) {
+    for (let i = 0, len = node.#methods.length;i < len; i++) {
+      const m = node.#methods[i];
+      const handlerSet = m[method] || m[METHOD_NAME_ALL];
+      if (handlerSet) {
+        handlerSet.params = /* @__PURE__ */ Object.create(null);
+        handlerSets.push(handlerSet);
+        for (let i2 = 0, len2 = handlerSet.possibleKeys.length;i2 < len2; i2++) {
+          const key = handlerSet.possibleKeys[i2];
+          handlerSet.params[key] = params?.[key] && !i2 ? params[key] : nodeParams[key] ?? params?.[key];
+        }
+      }
+    }
+  }
+  search(method, path) {
+    const handlerSets = [];
+    this.#params = emptyParams;
+    const curNode = this;
+    let curNodes = [curNode];
+    const parts = splitPath(path);
+    const curNodesQueue = [];
+    const len = parts.length;
+    let partOffsets = null;
+    for (let i = 0;i < len; i++) {
+      const part = parts[i];
+      const isLast = i === len - 1;
+      const tempNodes = [];
+      for (let j = 0, len2 = curNodes.length;j < len2; j++) {
+        const node = curNodes[j];
+        const nextNode = node.#children[part];
+        if (nextNode) {
+          nextNode.#params = node.#params;
+          if (isLast) {
+            if (nextNode.#children["*"]) {
+              this.#pushHandlerSets(handlerSets, nextNode.#children["*"], method, node.#params);
+            }
+            this.#pushHandlerSets(handlerSets, nextNode, method, node.#params);
+          } else {
+            tempNodes.push(nextNode);
+          }
+        }
+        for (const child of node.#patterns) {
+          const pattern = child.#pattern;
+          const params = node.#params === emptyParams ? {} : { ...node.#params };
+          if (typeof pattern === "string") {
+            if (pattern === "*" || part.startsWith(pattern.slice(0, -1))) {
+              this.#pushHandlerSets(handlerSets, child, method, node.#params);
+              if (pattern === "*") {
+                child.#params = params;
+                tempNodes.push(child);
+              }
+            }
+            continue;
+          }
+          const [, name, matcher] = pattern;
+          if (!part && matcher === true) {
+            continue;
+          }
+          if (matcher !== true) {
+            if (!partOffsets) {
+              partOffsets = [];
+              let offset = path[0] === "/" ? 1 : 0;
+              for (let p = 0;p < len; p++) {
+                partOffsets[p] = offset;
+                offset += parts[p].length + 1;
+              }
+            }
+            const restPathString = path.slice(partOffsets[i]);
+            const m = matcher.exec(restPathString);
+            if (m) {
+              params[name] = m[0];
+              this.#pushHandlerSets(handlerSets, child, method, node.#params, params);
+              if (m[0].length === restPathString.length && child.#children["*"]) {
+                this.#pushHandlerSets(handlerSets, child.#children["*"], method, node.#params, params);
+              }
+              for (const _ in child.#children) {
+                child.#params = params;
+                const componentCount = m[0].match(/\//g)?.length ?? 0;
+                const targetCurNodes = curNodesQueue[componentCount] ||= [];
+                targetCurNodes.push(child);
+                break;
+              }
+              continue;
+            }
+          }
+          if (matcher === true || matcher.test(part)) {
+            params[name] = part;
+            if (isLast) {
+              this.#pushHandlerSets(handlerSets, child, method, params, node.#params);
+              if (child.#children["*"]) {
+                this.#pushHandlerSets(handlerSets, child.#children["*"], method, params, node.#params);
+              }
+            } else {
+              child.#params = params;
+              tempNodes.push(child);
+            }
+          }
+        }
+      }
+      const shifted = curNodesQueue.shift();
+      curNodes = shifted ? tempNodes.concat(shifted) : tempNodes;
+    }
+    if (handlerSets[1]) {
+      handlerSets.sort((a, b) => {
+        return a.score - b.score;
+      });
+    }
+    return [handlerSets.map(({ handler, params }) => [handler, params])];
+  }
+};
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/router/trie-router/router.js
+var TrieRouter = class {
+  name = "TrieRouter";
+  #node = new Node2;
+  add(method, path, handler) {
+    for (const result of checkOptionalParameter(path) || [path]) {
+      this.#node.insert(method, result, handler);
+    }
+  }
+  match(method, path) {
+    return this.#node.search(method, path);
+  }
+};
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/hono.js
+var Hono2 = class extends Hono {
+  constructor(options = {}) {
+    super(options);
+    this.router = options.router ?? new SmartRouter({
+      routers: [new RegExpRouter, new TrieRouter]
+    });
+  }
+};
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/utils/stream.js
+var StreamingApi = class {
+  writer;
+  encoder;
+  writable;
+  abortSubscribers = [];
+  responseReadable;
+  aborted = false;
+  closed = false;
+  constructor(writable, _readable) {
+    this.writable = writable;
+    this.writer = writable.getWriter();
+    this.encoder = new TextEncoder;
+    const reader = _readable.getReader();
+    this.abortSubscribers.push(async () => {
+      await reader.cancel();
+    });
+    this.responseReadable = new ReadableStream({
+      async pull(controller) {
+        const { done, value } = await reader.read();
+        done ? controller.close() : controller.enqueue(value);
+      },
+      cancel: () => {
+        if (!this.closed) {
+          this.abort();
+        }
+      }
+    });
+  }
+  async write(input) {
+    try {
+      if (typeof input === "string") {
+        input = this.encoder.encode(input);
+      }
+      await this.writer.write(input);
+    } catch {}
+    return this;
+  }
+  async writeln(input) {
+    await this.write(input + `
+`);
+    return this;
+  }
+  sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+  }
+  async close() {
+    this.closed = true;
+    try {
+      await this.writer.close();
+    } catch {}
+  }
+  async pipe(body) {
+    this.writer.releaseLock();
+    try {
+      await body.pipeTo(this.writable, { preventClose: true, preventAbort: true });
+    } finally {
+      this.writer = this.writable.getWriter();
+    }
+  }
+  onAbort(listener) {
+    this.abortSubscribers.push(listener);
+  }
+  abort() {
+    if (!this.aborted) {
+      this.aborted = true;
+      this.abortSubscribers.forEach((subscriber) => subscriber());
+    }
+  }
+};
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/helper/streaming/utils.js
+var isOldBunVersion = () => {
+  const version = typeof Bun !== "undefined" ? Bun.version : undefined;
+  if (version === undefined) {
+    return false;
+  }
+  const result = version.startsWith("1.1") || version.startsWith("1.0") || version.startsWith("0.");
+  isOldBunVersion = () => result;
+  return result;
+};
+
+// node_modules/.bun/hono@4.13.3/node_modules/hono/dist/helper/streaming/sse.js
+var SSEStreamingApi = class extends StreamingApi {
+  constructor(writable, readable) {
+    super(writable, readable);
+  }
+  async writeSSE(message) {
+    const data = await resolveCallback(message.data, HtmlEscapedCallbackPhase.Stringify, false, {});
+    const dataLines = data.split(/\r\n|\r|\n/).map((line) => {
+      return `data: ${line}`;
+    }).join(`
+`);
+    for (const key of ["event", "id"]) {
+      const value = message[key];
+      if (value && /[\r\n]/.test(value)) {
+        throw new Error(`${key} must not contain "\\r" or "\\n"`);
+      }
+    }
+    const sseData = [
+      message.event && `event: ${message.event}`,
+      dataLines,
+      message.id !== undefined && `id: ${message.id}`,
+      message.retry !== undefined && `retry: ${message.retry}`
+    ].filter(Boolean).join(`
+`) + `
+
+`;
+    await this.write(sseData);
+  }
+};
+var run = async (stream, cb, onError) => {
+  try {
+    await cb(stream);
+  } catch (e) {
+    if (e instanceof Error && onError) {
+      await onError(e, stream);
+      await stream.writeSSE({
+        event: "error",
+        data: e.message
+      });
+    } else {
+      console.error(e);
+    }
+  } finally {
+    stream.close();
+  }
+};
+var contextStash = /* @__PURE__ */ new WeakMap;
+var streamSSE = (c, cb, onError) => {
+  const { readable, writable } = new TransformStream;
+  const stream = new SSEStreamingApi(writable, readable);
+  if (isOldBunVersion()) {
+    c.req.raw.signal.addEventListener("abort", () => {
+      if (!stream.closed) {
+        stream.abort();
+      }
+    });
+  }
+  contextStash.set(stream.responseReadable, c);
+  c.header("Transfer-Encoding", "chunked");
+  c.header("Content-Type", "text/event-stream");
+  c.header("Cache-Control", "no-cache");
+  c.header("Connection", "keep-alive");
+  run(stream, cb, onError);
+  return c.newResponse(stream.responseReadable);
+};
+
+// packages/daemon/src/forge.ts
+import { existsSync as existsSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+var EXTRA_BIN_DIRS = [
+  "/opt/homebrew/bin",
+  "/usr/local/bin",
+  "/home/linuxbrew/.linuxbrew/bin",
+  join3(homedir2(), ".local", "bin"),
+  join3(homedir2(), "bin")
+];
+function findBin(name) {
+  if (!name)
+    return null;
+  const onPath = Bun.which(name);
+  if (onPath)
+    return onPath;
+  for (const d of EXTRA_BIN_DIRS) {
+    const p = join3(d, name);
+    if (existsSync3(p))
+      return p;
+  }
+  return null;
+}
+var GH_FIELDS = "number,title,headRefName,url,author,isDraft,mergeable,reviewDecision,statusCheckRollup,createdAt";
+
+class ForgeService {
+  store;
+  cache = new Map;
+  inflight = new Set;
+  constructor(store) {
+    this.store = store;
+  }
+  prs() {
+    this.refresh();
+    const all = [...this.cache.values()].flatMap((c) => c.prs);
+    return all.sort((a, b) => a.createdAt < b.createdAt ? 1 : -1);
+  }
+  async refresh(maxAgeMs = 120000) {
+    const projects = this.store.projects();
+    await Promise.all(projects.map(async (p) => {
+      const hit = this.cache.get(p.id);
+      if (hit && Date.now() - hit.at < maxAgeMs)
+        return;
+      if (this.inflight.has(p.id))
+        return;
+      this.inflight.add(p.id);
+      try {
+        const prs = await this.poll(p.id, p.root);
+        this.cache.set(p.id, { at: Date.now(), prs });
+      } catch {
+        this.cache.set(p.id, { at: Date.now(), prs: this.cache.get(p.id)?.prs ?? [] });
+      } finally {
+        this.inflight.delete(p.id);
+      }
+    }));
+  }
+  remote(root) {
+    const r = Bun.spawnSync(["git", "-C", root, "remote", "get-url", "origin"]);
+    if (r.exitCode !== 0)
+      return null;
+    return parseRemote(new TextDecoder().decode(r.stdout).trim());
+  }
+  async run(cmd, cwd) {
+    const bin = findBin(cmd[0]);
+    if (!bin)
+      return null;
+    const proc = Bun.spawn([bin, ...cmd.slice(1)], { cwd, stdout: "pipe", stderr: "ignore" });
+    const out = await new Response(proc.stdout).text();
+    return await proc.exited === 0 ? out : null;
+  }
+  async poll(projectId, root) {
+    const remote = this.remote(root);
+    if (!remote)
+      return [];
+    let prs = [];
+    if (remote.forge === "github") {
+      const out = await this.run(["gh", "pr", "list", "--json", GH_FIELDS], root);
+      if (out)
+        prs = normalizeGithub(JSON.parse(out), remote.repo);
+    } else {
+      const out = await this.run(["glab", "mr", "list", "--output", "json"], root);
+      if (out)
+        prs = normalizeGitlab(JSON.parse(out), remote.repo);
+    }
+    return prs.map((pr) => ({ ...pr, projectId, projectRoot: root }));
+  }
+  async merge(projectId, number) {
+    const p = this.store.projects().find((x) => x.id === projectId);
+    if (!p)
+      return { ok: false, output: "unknown project" };
+    const remote = this.remote(p.root);
+    if (!remote)
+      return { ok: false, output: "no forge remote" };
+    const cmd = remote.forge === "github" ? ["gh", "pr", "merge", String(number), "--squash"] : ["glab", "mr", "merge", String(number), "--squash", "--yes"];
+    const bin = findBin(cmd[0]);
+    if (!bin)
+      return { ok: false, output: `${cmd[0] ?? "forge CLI"} is not installed` };
+    const proc = Bun.spawn([bin, ...cmd.slice(1)], { cwd: p.root, stdout: "pipe", stderr: "pipe" });
+    const out = await new Response(proc.stdout).text() + await new Response(proc.stderr).text();
+    const ok = await proc.exited === 0;
+    if (ok)
+      this.cache.delete(projectId);
+    return { ok, output: out.trim().slice(0, 800) };
+  }
+}
+
+// packages/daemon/src/store.ts
+import { Database } from "bun:sqlite";
+import {
+  closeSync,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readdirSync,
+  readFileSync as readFileSync3,
+  readSync,
+  realpathSync as realpathSync2,
+  renameSync,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { basename, dirname, join as join5 } from "path";
+
+// packages/daemon/src/git.ts
+import { realpathSync } from "fs";
+import { join as join4 } from "path";
+function git(cwd, args) {
+  try {
+    const r = Bun.spawnSync(["git", "-C", cwd, ...args], { stdout: "pipe", stderr: "ignore" });
+    return r.exitCode === 0 ? r.stdout.toString() : null;
+  } catch {
+    return null;
+  }
+}
+function gitCommonDir(cwd) {
+  const out = git(cwd, ["rev-parse", "--git-common-dir"])?.trim();
+  if (!out)
+    return null;
+  try {
+    return realpathSync(out.startsWith("/") ? out : join4(cwd, out));
+  } catch {
+    return null;
+  }
+}
+function gitToplevel(cwd) {
+  const out = git(cwd, ["rev-parse", "--show-toplevel"])?.trim();
+  if (!out)
+    return null;
+  try {
+    return realpathSync(out);
+  } catch {
+    return null;
+  }
+}
+function parseWorktreeList(out) {
+  const wts = [];
+  let cur = null;
+  const flush = () => {
+    if (cur?.path) {
+      wts.push({
+        path: cur.path,
+        branch: cur.branch ?? null,
+        head: (cur.head ?? "").slice(0, 7),
+        main: wts.length === 0,
+        dirty: -1,
+        ahead: -1
+      });
+    }
+    cur = null;
+  };
+  for (const line of out.split(`
+`)) {
+    if (line.startsWith("worktree ")) {
+      flush();
+      cur = { path: line.slice(9) };
+    } else if (line.startsWith("HEAD ") && cur)
+      cur.head = line.slice(5);
+    else if (line.startsWith("branch ") && cur)
+      cur.branch = line.slice(7).replace(/^refs\/heads\//, "");
+    else if (line === "")
+      flush();
+  }
+  flush();
+  return wts;
+}
+function applyStatus(w, st, ah) {
+  w.dirty = st === null ? -1 : st.split(`
+`).filter(Boolean).length;
+  const a = ah?.trim();
+  w.ahead = a === undefined || a === "" ? -1 : Number(a);
+}
+async function gitAsync(cwd, args) {
+  try {
+    const p = Bun.spawn(["git", "-C", cwd, ...args], { stdout: "pipe", stderr: "ignore" });
+    const [out, code] = await Promise.all([new Response(p.stdout).text(), p.exited]);
+    return code === 0 ? out : null;
+  } catch {
+    return null;
+  }
+}
+async function listWorktreesAsync(root) {
+  const out = await gitAsync(root, ["worktree", "list", "--porcelain"]);
+  if (!out)
+    return [];
+  const wts = parseWorktreeList(out);
+  await Promise.all(wts.map(async (w) => {
+    const [st, ah] = await Promise.all([
+      gitAsync(w.path, ["status", "--porcelain", "--untracked-files=no"]),
+      gitAsync(w.path, ["rev-list", "--count", "@{upstream}..HEAD"])
+    ]);
+    applyStatus(w, st, ah);
+  }));
+  return wts;
+}
+var branchCache = new Map;
+function currentBranch(cwd) {
+  const hit = branchCache.get(cwd);
+  const now = Date.now();
+  if (hit && now - hit.t < 5000)
+    return hit.v;
+  const v = git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"])?.trim() ?? null;
+  branchCache.set(cwd, { v: v === "HEAD" ? "(detached)" : v, t: now });
+  return branchCache.get(cwd)?.v ?? null;
+}
+function worktreeAdd(repoRoot, path, branch, baseRef = "HEAD") {
+  const branchExists = git(repoRoot, ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`]) !== null;
+  const args = branchExists ? ["worktree", "add", path, branch] : ["worktree", "add", "-b", branch, path, baseRef];
+  if (git(repoRoot, args) === null)
+    return null;
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+function worktreeRemove(repoRoot, path, force) {
+  const args = ["worktree", "remove", path];
+  if (force)
+    args.push("--force");
+  return git(repoRoot, args) !== null;
+}
+function heldWork(path) {
+  const status = git(path, ["status", "--porcelain"]);
+  const dirty = status !== null && status.trim().length > 0;
+  const count = (args) => {
+    const out = git(path, ["rev-list", "--count", ...args])?.trim();
+    return out !== undefined && out !== "" ? Number(out) : 0;
+  };
+  let unpushed;
+  if (git(path, ["rev-parse", "--verify", "--quiet", "@{upstream}"]) !== null) {
+    unpushed = count(["@{upstream}..HEAD"]) > 0;
+  } else {
+    const baselines = ["--remotes"];
+    for (const b of ["main", "master"]) {
+      if (git(path, ["rev-parse", "--verify", "--quiet", `refs/heads/${b}`]) !== null)
+        baselines.push(b);
+    }
+    unpushed = baselines.length > 1 ? count(["HEAD", "--not", ...baselines]) > 0 : false;
+  }
+  return { dirty, unpushed };
+}
+
+// packages/daemon/src/store.ts
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS projects (id TEXT PRIMARY KEY, root TEXT, common_dir TEXT, name TEXT, discovered INTEGER, created_at TEXT);
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY, project_id TEXT, kind TEXT, parent_id TEXT, cwd TEXT, branch TEXT, transcript_path TEXT,
+  title TEXT, model TEXT, version TEXT, started_at TEXT, ended_at TEXT, last_seen_at TEXT,
+  last TEXT, last_type TEXT, last_text TEXT, state TEXT, tool_calls INTEGER DEFAULT 0, subagents INTEGER DEFAULT 0,
+  tool_counts TEXT DEFAULT '{}'
+);
+CREATE TABLE IF NOT EXISTS events (seq INTEGER PRIMARY KEY AUTOINCREMENT, ts TEXT, type TEXT, project_id TEXT, session_id TEXT, payload TEXT, raw TEXT);
+CREATE INDEX IF NOT EXISTS events_session ON events(session_id, seq);
+CREATE INDEX IF NOT EXISTS events_type_seq ON events(type, seq);
+CREATE TABLE IF NOT EXISTS turns (
+  id TEXT PRIMARY KEY, session_id TEXT, agent_id TEXT, ts TEXT, model TEXT, effort TEXT, sidechain INTEGER,
+  input INTEGER, output INTEGER, cache_write INTEGER, cache_write_1h INTEGER, cache_read INTEGER, thinking INTEGER,
+  cost_usd REAL, text TEXT, tools TEXT
+);
+CREATE INDEX IF NOT EXISTS turns_session ON turns(session_id, ts);
+CREATE INDEX IF NOT EXISTS turns_ts ON turns(ts);
+CREATE TABLE IF NOT EXISTS tails (path TEXT PRIMARY KEY, session_id TEXT, agent_id TEXT, offset INTEGER);
+CREATE TABLE IF NOT EXISTS resources (
+  name TEXT, project_id TEXT, kind TEXT, owner TEXT, session_id TEXT,
+  pid INTEGER, port INTEGER, acquired_at TEXT, expires_at TEXT, released INTEGER DEFAULT 0,
+  PRIMARY KEY (name, project_id)
+);
+CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);
+CREATE TABLE IF NOT EXISTS incident_acks (seq INTEGER PRIMARY KEY, acked_at TEXT);
+CREATE TABLE IF NOT EXISTS processes (
+  pid INTEGER, start_time TEXT, project_id TEXT, session_id TEXT, kind TEXT, name TEXT, port INTEGER,
+  cwd TEXT, cmd TEXT, owner TEXT, log TEXT, started_at TEXT, ended_at TEXT
+);
+CREATE INDEX IF NOT EXISTS processes_live ON processes(ended_at, project_id);
+CREATE TABLE IF NOT EXISTS claims (
+  project_id TEXT, task TEXT, owner TEXT, worktree TEXT, branch TEXT,
+  acquired_at TEXT, expires_at TEXT, released_at TEXT, state TEXT,
+  PRIMARY KEY (project_id, task)
+);
+`;
+var IDLE_MS = 10 * 60000;
+
+class Store {
+  db;
+  prices = { ...PRICES };
+  home;
+  listeners = new Set;
+  wtCache = new Map;
+  wtInflight = new Map;
+  cwdProject = new Map;
+  lastTail = new Map;
+  gen = 0;
+  memo = new Map;
+  constructor(home = swarmHome()) {
+    mkdirSync2(home, { recursive: true });
+    this.home = home;
+    this.db = new Database(join5(home, "swarm.db"));
+    this.loadPricing();
+    this.db.exec("PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL; PRAGMA mmap_size=268435456; PRAGMA cache_size=-32000;");
+    this.db.exec(SCHEMA);
+    this.ensureColumn("sessions", "agent", "TEXT DEFAULT 'claude-code'");
+    this.ensureColumn("projects", "sort_order", "INTEGER");
+    this.migrateProjectsJson(join5(home, "projects.json"));
+    this.reconcileMovedProjects();
+    this.slimExistingEvents();
+    this.retypeNotificationIncidents();
+  }
+  retypeNotificationIncidents() {
+    if (this.meta("notifications_retyped") === "1")
+      return;
+    this.db.exec(`UPDATE events SET type = 'session.notification' WHERE type = 'incident.opened' AND payload NOT LIKE '%"rule"%'`);
+    this.setMeta("notifications_retyped", "1");
+  }
+  meta(key) {
+    const r = this.db.query("SELECT value FROM meta WHERE key = ?").get(key);
+    return r?.value ?? null;
+  }
+  setMeta(key, value) {
+    this.db.query("INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
+  }
+  slimExistingEvents() {
+    if (this.meta("events_slim") === "1")
+      return;
+    const rows = this.db.query("SELECT seq, payload, raw FROM events WHERE length(payload) > ? OR length(raw) > ?").all(TOOL_RESPONSE_MAX + TOOL_INPUT_MAX, TOOL_INPUT_MAX);
+    const upd = this.db.query("UPDATE events SET payload = ?, raw = ? WHERE seq = ?");
+    this.db.transaction(() => {
+      for (const r of rows) {
+        let payload;
+        let raw2;
+        try {
+          payload = JSON.parse(r.payload);
+          raw2 = r.raw ? JSON.parse(r.raw) : undefined;
+        } catch {
+          continue;
+        }
+        const slim = slimForStorage({ payload, raw: raw2 });
+        upd.run(JSON.stringify(slim.payload ?? null), slim.raw === undefined ? null : JSON.stringify(slim.raw), r.seq);
+      }
+      this.setMeta("events_slim", "1");
+    })();
+    if (rows.length) {
+      try {
+        this.db.exec("VACUUM");
+      } catch {}
+    }
+  }
+  reconcileMovedProjects() {
+    const all = this.projects();
+    for (const stale of all) {
+      if (existsSync4(stale.root))
+        continue;
+      const live = all.filter((p) => p.id !== stale.id && p.name === stale.name && existsSync4(p.root));
+      if (live.length !== 1)
+        continue;
+      this.mergeProject(stale.id, live[0].id);
+    }
+  }
+  mergeProject(from, into) {
+    const src = this.project(from);
+    const dst = this.project(into);
+    if (!src || !dst || from === into)
+      return false;
+    this.db.transaction(() => {
+      for (const t of ["sessions", "events"])
+        this.db.query(`UPDATE ${t} SET project_id = ? WHERE project_id = ?`).run(into, from);
+      this.db.query("UPDATE OR IGNORE resources SET project_id = ? WHERE project_id = ?").run(into, from);
+      this.db.query("UPDATE OR IGNORE claims SET project_id = ? WHERE project_id = ?").run(into, from);
+      this.db.query("DELETE FROM resources WHERE project_id = ?").run(from);
+      this.db.query("DELETE FROM claims WHERE project_id = ?").run(from);
+      if (!src.discovered)
+        this.db.query("UPDATE projects SET discovered = 0, name = ? WHERE id = ?").run(src.name, into);
+      this.db.query("DELETE FROM projects WHERE id = ?").run(from);
+    })();
+    this.cwdProject.clear();
+    this.touch();
+    return true;
+  }
+  ensureColumn(table, col, decl) {
+    const cols = this.db.query(`PRAGMA table_info(${table})`).all();
+    if (!cols.some((c) => c.name === col)) {
+      this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${col} ${decl}`);
+    }
+  }
+  migrateProjectsJson(file) {
+    if (!existsSync4(file))
+      return;
+    try {
+      const list = JSON.parse(readFileSync3(file, "utf8"));
+      const ins = this.db.query("INSERT OR IGNORE INTO projects (id, root, common_dir, name, discovered, created_at) VALUES (?, ?, ?, ?, ?, ?)");
+      for (const p of list)
+        ins.run(p.id, p.root, p.commonDir, p.name, p.discovered ? 1 : 0, p.createdAt);
+      renameSync(file, `${file}.migrated`);
+    } catch {}
+  }
+  topCache = new Map;
+  toplevel(cwd) {
+    const hit = this.topCache.get(cwd);
+    if (hit && Date.now() - hit.t < 1e4)
+      return hit.v;
+    const v = cwd && existsSync4(cwd) ? gitToplevel(cwd) : null;
+    this.topCache.set(cwd, { v, t: Date.now() });
+    return v;
+  }
+  rulesCache = new Map;
+  taskCache = new Map;
+  tasks(projectId) {
+    const p = this.project(projectId);
+    if (!p)
+      return null;
+    const source = loadConfig({ repoRoot: p.root }).tasks.source;
+    if (!source)
+      return null;
+    const path = join5(p.root, source);
+    if (!existsSync4(path))
+      return { source, tasks: [] };
+    const mtime = statSync(path).mtimeMs;
+    let hit = this.taskCache.get(projectId);
+    if (!hit || hit.path !== path || hit.mtime !== mtime) {
+      hit = { path, mtime, tasks: parseMarkdownTasks(readFileSync3(path, "utf8")) };
+      this.taskCache.set(projectId, hit);
+    }
+    const now = Date.now();
+    const active = this.claimRows(projectId).filter((c) => isActive(c, now));
+    return { source, tasks: taskBoard(hit.tasks, active) };
+  }
+  rulesFor(repoRoot) {
+    const key = repoRoot ?? "";
+    const hit = this.rulesCache.get(key);
+    if (hit && Date.now() - hit.at < 30000)
+      return hit.rules;
+    const rules2 = loadConfig({ repoRoot }).rules;
+    this.rulesCache.set(key, { at: Date.now(), rules: rules2 });
+    return rules2;
+  }
+  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 : "";
+    const isWrite = WRITE_TOOLS.has(tool) && typeof input.file_path === "string";
+    const cmd = tool === "Bash" ? input.command : undefined;
+    if (!isWrite && !cmd)
+      return null;
+    const current = { id, cwd, toplevel: this.toplevel(cwd) };
+    const modes = this.rulesFor(current.toplevel);
+    if (modes.no_foreign_worktree !== "off" || modes.claim_required_to_write !== "off") {
+      const target = isWrite ? absolutePath(input.file_path, cwd) : cwd;
+      const w = guardWrite(target, current, this.heldWorktrees(), modes, isWrite ? "file" : "bash");
+      if (w.action !== "allow")
+        return this.openIncident(w, cwd, id, isWrite ? `${tool} ${target}` : cmd);
+    }
+    if (!cmd)
+      return null;
+    const rows = this.db.query("SELECT id, cwd, last_seen_at, state FROM sessions WHERE state != 'ended' AND last_seen_at > ?").all(new Date(Date.now() - LIVE_WINDOW_MS - 1e4).toISOString());
+    const sessions = rows.map((r) => ({
+      id: r.id,
+      toplevel: this.toplevel(r.cwd),
+      lastSeenAt: r.last_seen_at,
+      state: r.state
+    }));
+    const d = guardBash(cmd, current, sessions, Date.now(), {
+      ...modes,
+      protected: { ports: [...new Set([...modes.protected.ports, ...this.heldPorts()])] }
+    });
+    if (d.action === "allow")
+      return null;
+    return this.openIncident(d, cwd, id, cmd);
+  }
+  openIncident(d, cwd, sessionId, command) {
+    const project = cwd && existsSync4(cwd) ? this.resolveProject(cwd) : null;
+    this.append({
+      ts: new Date().toISOString(),
+      type: "incident.opened",
+      projectId: project?.id ?? "p_unknown",
+      sessionId: sessionId || null,
+      payload: { rule: d.rule, action: d.action, command: command.slice(0, 400), reason: d.reason }
+    });
+    return d;
+  }
+  heldWorktreesCache = null;
+  heldWorktrees() {
+    if (this.heldWorktreesCache && Date.now() - this.heldWorktreesCache.at < 2000)
+      return this.heldWorktreesCache.v;
+    const v = this.db.query("SELECT task, owner, worktree FROM claims WHERE state = 'held' AND expires_at > ?").all(new Date().toISOString()).filter((c) => c.worktree);
+    this.heldWorktreesCache = { at: Date.now(), v };
+    return v;
+  }
+  loadPricing() {
+    this.prices = { ...PRICES };
+    for (const f of ["pricing.litellm.json", "pricing.json"]) {
+      const p = join5(this.home, f);
+      if (!existsSync4(p))
+        continue;
+      try {
+        const j = JSON.parse(readFileSync3(p, "utf8"));
+        const table = f === "pricing.json" ? j : fromLiteLLM(j);
+        Object.assign(this.prices, table);
+      } catch {}
+    }
+  }
+  async refreshPricing(url = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json") {
+    const r = await fetch(url, { signal: AbortSignal.timeout(1e4) });
+    if (!r.ok)
+      throw new Error(`pricing fetch ${r.status}`);
+    const j = await r.json();
+    const slim = Object.fromEntries(Object.entries(j).filter(([k, v]) => typeof v.input_cost_per_token === "number" && !k.includes("/")));
+    writeFileSync2(join5(this.home, "pricing.litellm.json"), JSON.stringify(slim, null, 1));
+    this.loadPricing();
+    this.reprice();
+  }
+  reprice() {
+    const rows = this.db.query("SELECT id, model, input, output, cache_write, cache_write_1h, cache_read FROM turns").all();
+    const up = this.db.query("UPDATE turns SET cost_usd = ? WHERE id = ?");
+    const tx = this.db.transaction(() => {
+      for (const r of rows)
+        up.run(costUsd(r.model, {
+          input: r.input,
+          output: r.output,
+          cacheWrite: r.cache_write,
+          cacheWrite1h: r.cache_write_1h,
+          cacheRead: r.cache_read
+        }, this.prices), r.id);
+    });
+    tx();
+  }
+  projects() {
+    return this.db.query("SELECT * FROM projects ORDER BY discovered, sort_order IS NULL, sort_order, name COLLATE NOCASE").all().map((r) => ({
+      id: r.id,
+      root: r.root,
+      commonDir: r.common_dir ?? null,
+      name: r.name,
+      discovered: Boolean(r.discovered),
+      order: typeof r.sort_order === "number" ? r.sort_order : null,
+      createdAt: r.created_at
+    }));
+  }
+  project(id) {
+    const r = this.db.query("SELECT * FROM projects WHERE id = ?").get(id);
+    if (!r)
+      return;
+    return {
+      id: r.id,
+      root: r.root,
+      commonDir: r.common_dir ?? null,
+      name: r.name,
+      discovered: Boolean(r.discovered),
+      order: typeof r.sort_order === "number" ? r.sort_order : null,
+      createdAt: r.created_at
+    };
+  }
+  memoised(key, ttlMs, compute) {
+    const hit = this.memo.get(key);
+    const now = Date.now();
+    if (hit && hit.gen === this.gen && now - hit.t < ttlMs)
+      return hit.v;
+    const v = compute();
+    this.memo.set(key, { gen: this.gen, t: now, v });
+    return v;
+  }
+  touch() {
+    this.gen++;
+  }
+  resolveProject(path, explicit = false, name) {
+    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.resolveProjectUncached(path, explicit, name);
+    this.cwdProject.set(path, { id: p.id, t: Date.now() });
+    return p;
+  }
+  resolveProjectUncached(path, explicit, name) {
+    const root = gitToplevel(path) ?? realpathSync2(path);
+    const ident = projectIdentity({ root, commonDir: gitCommonDir(root) });
+    const existing = this.project(ident.id);
+    if (!existing) {
+      const p = {
+        ...ident,
+        discovered: !explicit,
+        order: null,
+        createdAt: new Date().toISOString()
+      };
+      if (name)
+        p.name = name;
+      this.db.query("INSERT INTO projects (id, root, common_dir, name, discovered, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(p.id, p.root, p.commonDir, p.name, p.discovered ? 1 : 0, p.createdAt);
+      this.reconcileMovedProjects();
+      return this.project(p.id) ?? p;
+    }
+    if (explicit) {
+      this.db.query("UPDATE projects SET discovered = 0, name = ? WHERE id = ?").run(name ?? existing.name, existing.id);
+      return { ...existing, discovered: false, name: name ?? existing.name };
+    }
+    return existing;
+  }
+  updateProject(id, patch) {
+    const cur = this.project(id);
+    if (!cur)
+      return;
+    if (patch.pinned !== undefined)
+      this.db.query("UPDATE projects SET discovered = ? WHERE id = ?").run(patch.pinned ? 0 : 1, id);
+    if (patch.name)
+      this.db.query("UPDATE projects SET name = ? WHERE id = ?").run(patch.name, id);
+    return this.project(id);
+  }
+  reorderProjects(ids) {
+    const upd = this.db.query("UPDATE projects SET sort_order = ? WHERE id = ?");
+    this.db.transaction(() => {
+      ids.forEach((id, i) => {
+        upd.run(i, id);
+      });
+    })();
+    this.touch();
+    return this.projects();
+  }
+  removeProject(id) {
+    this.cwdProject.clear();
+    this.wtCache.delete(id);
+    this.touch();
+    return this.db.query("DELETE FROM projects WHERE id = ?").run(id).changes > 0;
+  }
+  append(e) {
+    const slim = slimForStorage(e);
+    const r = this.db.query("INSERT INTO events (ts, type, project_id, session_id, payload, raw) VALUES (?, ?, ?, ?, ?, ?)").run(e.ts, e.type, e.projectId, e.sessionId, JSON.stringify(slim.payload ?? null), slim.raw === undefined ? null : JSON.stringify(slim.raw));
+    const stored = { ...e, seq: Number(r.lastInsertRowid) };
+    this.projectSession(stored);
+    this.touch();
+    const wire = toWire(stored);
+    for (const l of this.listeners)
+      l(wire);
+    return stored;
+  }
+  prune(days = 30) {
+    const cutoff = new Date(Date.now() - days * 86400000).toISOString();
+    const n = this.db.query("DELETE FROM events WHERE ts < ? AND type != 'incident.opened'").run(cutoff).changes;
+    const old = new Date(Date.now() - 7 * 86400000).toISOString();
+    this.db.query("UPDATE events SET raw = NULL WHERE ts < ? AND raw IS NOT NULL").run(old);
+    if (n > 0)
+      this.touch();
+    return n;
+  }
+  ingestHook(event, raw2) {
+    const cwd = typeof raw2.cwd === "string" ? raw2.cwd : process.cwd();
+    const project = existsSync4(cwd) ? this.resolveProject(cwd) : null;
+    const e = this.append(normalizeHook(event, raw2, project?.id ?? "p_unknown"));
+    if (e.sessionId && typeof raw2.transcript_path === "string") {
+      this.db.query("UPDATE sessions SET transcript_path = ? WHERE id = ? AND transcript_path IS NULL").run(raw2.transcript_path, e.sessionId);
+      const last = this.lastTail.get(e.sessionId) ?? 0;
+      if (Date.now() - last > 2000) {
+        this.lastTail.set(e.sessionId, Date.now());
+        this.tailSession(e.sessionId);
+      }
+    }
+    return e;
+  }
+  projectSession(e) {
+    if (!e.sessionId)
+      return;
+    const p = e.payload;
+    const row = this.db.query("SELECT id, tool_counts FROM sessions WHERE id = ?").get(e.sessionId);
+    const branch = p.cwd && existsSync4(p.cwd) ? currentBranch(p.cwd) : null;
+    if (!row) {
+      this.db.query("INSERT INTO sessions (id, project_id, kind, cwd, branch, started_at, last_seen_at, last, last_type, state) VALUES (?, ?, 'interactive', ?, ?, ?, ?, ?, ?, 'active')").run(e.sessionId, e.projectId, p.cwd ?? "", branch, e.ts, e.ts, p.summary ?? e.type, e.type);
+    }
+    const counts = JSON.parse(row?.tool_counts ?? "{}");
+    if (e.type === "tool.requested" && p.tool)
+      counts[p.tool] = (counts[p.tool] ?? 0) + 1;
+    const state = e.type === "session.ended" ? "ended" : p.hook === "Stop" || e.type === "session.notification" ? "waiting" : "active";
+    this.db.query(`UPDATE sessions SET last_seen_at = ?, last = ?, last_type = ?, state = ?, tool_counts = ?,
+           tool_calls = tool_calls + ?, subagents = MAX(0, subagents + ?),
+           project_id = CASE WHEN ? != 'p_unknown' THEN ? ELSE project_id END,
+           cwd = COALESCE(?, cwd), branch = COALESCE(?, branch),
+           ended_at = CASE WHEN ? = 'session.ended' THEN ? ELSE ended_at END
+         WHERE id = ?`).run(e.ts, p.summary ?? e.type, e.type, state, JSON.stringify(counts), e.type === "tool.requested" ? 1 : 0, e.type === "subagent.started" ? 1 : e.type === "subagent.stopped" ? -1 : 0, e.projectId, e.projectId, p.cwd ?? null, branch, e.type, e.ts, e.sessionId);
+  }
+  readFrom(path, offset) {
+    try {
+      const size = statSync(path).size;
+      if (size <= offset)
+        return null;
+      const fd = openSync(path, "r");
+      const buf = Buffer.alloc(size - offset);
+      readSync(fd, buf, 0, buf.length, offset);
+      closeSync(fd);
+      const text = buf.toString("utf8");
+      const cut = text.lastIndexOf(`
+`);
+      if (cut < 0)
+        return null;
+      return {
+        chunk: text.slice(0, cut + 1),
+        next: offset + Buffer.byteLength(text.slice(0, cut + 1))
+      };
+    } catch {
+      return null;
+    }
+  }
+  persistTurns(sessionId, agentId, turns) {
+    const up = this.db.query(`INSERT INTO turns (id, session_id, agent_id, ts, model, effort, sidechain, input, output, cache_write, cache_write_1h, cache_read, thinking, cost_usd, text, tools)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET input=excluded.input, output=excluded.output, cache_write=excluded.cache_write, cache_write_1h=excluded.cache_write_1h,
+         cache_read=excluded.cache_read, thinking=excluded.thinking, cost_usd=excluded.cost_usd, text=CASE WHEN excluded.text != '' THEN excluded.text ELSE turns.text END, tools=excluded.tools`);
+    const tx = this.db.transaction((ts) => {
+      for (const t of ts) {
+        up.run(t.id, sessionId, agentId, t.ts, t.model, t.effort, t.sidechain ? 1 : 0, t.usage.input, t.usage.output, t.usage.cacheWrite, t.usage.cacheWrite1h ?? 0, t.usage.cacheRead, t.usage.thinking, costUsd(t.model, t.usage, this.prices), t.text, JSON.stringify(t.tools));
+      }
+    });
+    if (turns.length)
+      this.touch();
+    tx(turns);
+  }
+  tailFile(path, sessionId, agentId) {
+    const row = this.db.query("SELECT offset FROM tails WHERE path = ?").get(path);
+    const r = this.readFrom(path, row?.offset ?? 0);
+    if (!r)
+      return 0;
+    const d = parseTranscriptChunk(r.chunk);
+    this.persistTurns(sessionId, agentId, d.turns);
+    const lastText = [...d.turns].reverse().find((t) => t.text && !t.sidechain)?.text ?? null;
+    const lastModel = [...d.turns].reverse().find((t) => !t.sidechain)?.model ?? null;
+    this.db.query("UPDATE sessions SET title = COALESCE(?, title), model = COALESCE(?, model), version = COALESCE(?, version), last_text = COALESCE(?, last_text), branch = COALESCE(branch, ?), last_seen_at = MAX(COALESCE(last_seen_at, ''), ?) WHERE id = ?").run(d.title, agentId ? null : lastModel, d.version, agentId ? null : lastText, d.branch, new Date().toISOString(), sessionId);
+    this.db.query("INSERT INTO tails (path, session_id, agent_id, offset) VALUES (?, ?, ?, ?) ON CONFLICT(path) DO UPDATE SET offset = excluded.offset").run(path, sessionId, agentId, r.next);
+    return d.turns.length;
+  }
+  tailSession(sessionId) {
+    const s = this.db.query("SELECT transcript_path FROM sessions WHERE id = ?").get(sessionId);
+    if (!s?.transcript_path || !existsSync4(s.transcript_path))
+      return 0;
+    let n = this.tailFile(s.transcript_path, sessionId, null);
+    const subDir = join5(dirname(s.transcript_path), basename(s.transcript_path, ".jsonl"), "subagents");
+    for (const f of this.subagentFiles(subDir)) {
+      n += this.tailFile(join5(subDir, f), sessionId, f.replace(/^agent-|\.jsonl$/g, ""));
+    }
+    return n;
+  }
+  subDirCache = new Map;
+  subagentFiles(dir) {
+    let mtime;
+    try {
+      mtime = statSync(dir).mtimeMs;
+    } catch {
+      return [];
+    }
+    const hit = this.subDirCache.get(dir);
+    if (hit && hit.mtime === mtime)
+      return hit.files;
+    const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+    this.subDirCache.set(dir, { mtime, files });
+    return files;
+  }
+  hasActiveSessions() {
+    const since = new Date(Date.now() - IDLE_MS).toISOString();
+    return this.db.query("SELECT 1 AS x FROM sessions WHERE state != 'ended' AND last_seen_at > ? LIMIT 1").get(since) !== null;
+  }
+  tailActive() {
+    const since = new Date(Date.now() - IDLE_MS).toISOString();
+    const ids = this.db.query("SELECT id FROM sessions WHERE state != 'ended' AND last_seen_at > ? AND transcript_path IS NOT NULL").all(since);
+    let n = 0;
+    for (const { id } of ids)
+      n += this.tailSession(id);
+    return n;
+  }
+  codexRoot() {
+    return process.env.SWARM_CODEX_DIR ?? join5(homedir3(), ".codex", "sessions");
+  }
+  codexRolloutFiles(sinceMs) {
+    const root = this.codexRoot();
+    const out = [];
+    const ls = (p) => {
+      try {
+        return readdirSync(p);
+      } catch {
+        return [];
+      }
+    };
+    for (const y of ls(root)) {
+      if (!/^\d{4}$/.test(y))
+        continue;
+      for (const m of ls(join5(root, y))) {
+        if (!/^\d\d$/.test(m))
+          continue;
+        for (const day of ls(join5(root, y, m))) {
+          if (!/^\d\d$/.test(day))
+            continue;
+          if (Date.parse(`${y}-${m}-${day}T23:59:59Z`) < sinceMs)
+            continue;
+          const dir = join5(root, y, m, day);
+          for (const f of ls(dir)) {
+            if (f.startsWith("rollout-") && f.endsWith(".jsonl"))
+              out.push(join5(dir, f));
+          }
+        }
+      }
+    }
+    return out;
+  }
+  tailCodex(windowMs = 3 * 24 * 60 * 60000) {
+    if (!existsSync4(this.codexRoot()))
+      return 0;
+    let n = 0;
+    for (const path of this.codexRolloutFiles(Date.now() - windowMs)) {
+      n += this.ingestLog(path, "codex", parseCodexRollout);
+    }
+    return n;
+  }
+  grokRoot() {
+    return process.env.SWARM_GROK_DIR ?? join5(homedir3(), ".grok", "sessions");
+  }
+  grokSummary = new Map;
+  tailGrok(windowMs = 3 * 24 * 60 * 60000) {
+    const root = this.grokRoot();
+    if (!existsSync4(root))
+      return 0;
+    const since = Date.now() - windowMs;
+    const ls = (p) => {
+      try {
+        return readdirSync(p);
+      } catch {
+        return [];
+      }
+    };
+    let n = 0;
+    for (const enc of ls(root)) {
+      if (!enc.includes("%2F") && !enc.startsWith("/"))
+        continue;
+      let cwd = "";
+      try {
+        cwd = decodeURIComponent(enc);
+      } catch {
+        cwd = enc;
+      }
+      const cwdDir = join5(root, enc);
+      for (const sid of ls(cwdDir)) {
+        const path = join5(cwdDir, sid, "updates.jsonl");
+        if (!existsSync4(path))
+          continue;
+        try {
+          if (statSync(path).mtimeMs < since)
+            continue;
+        } catch {
+          continue;
+        }
+        const sumPath = join5(cwdDir, sid, "summary.json");
+        let title;
+        let fresh = false;
+        try {
+          const m = statSync(sumPath).mtimeMs;
+          const hit = this.grokSummary.get(sumPath);
+          if (hit && hit.mtime === m)
+            title = hit.title;
+          else {
+            const sum = JSON.parse(readFileSync3(sumPath, "utf8"));
+            title = sum.session_summary;
+            this.grokSummary.set(sumPath, { mtime: m, title });
+            fresh = true;
+          }
+        } catch {}
+        n += this.ingestLog(path, "grok", parseGrokUpdates, cwd, title);
+        if (title && fresh) {
+          this.db.query("UPDATE sessions SET title = ? WHERE id = ? AND (title IS NULL OR title = '')").run(title, sid);
+        }
+      }
+    }
+    return n;
+  }
+  ingestLog(path, agent, parse, cwdHint, titleHint) {
+    const off = this.db.query("SELECT offset FROM tails WHERE path = ?").get(path) ?? { offset: 0 };
+    const r = this.readFrom(path, off.offset);
+    if (!r)
+      return 0;
+    const d = parse(r.chunk);
+    const sid = d.sessionId;
+    if (!sid)
+      return 0;
+    const mtime = (() => {
+      try {
+        return statSync(path).mtimeMs;
+      } catch {
+        return Date.now();
+      }
+    })();
+    this.ensureAgentSession(sid, agent, d.cwd ?? cwdHint ?? "", mtime);
+    this.persistTurns(sid, null, d.turns);
+    const lastText = [...d.turns].reverse().find((t) => t.text)?.text ?? null;
+    const state = Date.now() - mtime < 90000 ? "active" : "ended";
+    const lastSeen = new Date(mtime).toISOString();
+    this.db.query("UPDATE sessions SET title = COALESCE(title, ?), model = COALESCE(?, model), last_text = COALESCE(?, last_text), last_seen_at = ?, state = ?, ended_at = CASE WHEN ? = 'ended' AND ended_at IS NULL THEN ? ELSE ended_at END WHERE id = ?").run(d.title ?? titleHint ?? null, d.model ?? null, lastText, lastSeen, state, state, lastSeen, sid);
+    this.db.query("INSERT INTO tails (path, session_id, agent_id, offset) VALUES (?, ?, NULL, ?) ON CONFLICT(path) DO UPDATE SET offset = excluded.offset").run(path, sid, r.next);
+    return d.turns.length;
+  }
+  ensureAgentSession(sid, agent, cwd, mtime) {
+    if (this.db.query("SELECT 1 FROM sessions WHERE id = ?").get(sid))
+      return;
+    const project = cwd && existsSync4(cwd) ? this.resolveProject(cwd) : null;
+    const ts = new Date(mtime).toISOString();
+    this.db.query("INSERT INTO sessions (id, project_id, kind, agent, cwd, branch, started_at, last_seen_at, last, last_type, state) VALUES (?, ?, 'interactive', ?, ?, ?, ?, ?, '', '', 'active')").run(sid, project?.id ?? "p_unknown", agent, cwd, cwd && existsSync4(cwd) ? currentBranch(cwd) : null, ts, ts);
+  }
+  claimRows(projectId) {
+    return this.db.query("SELECT * FROM claims WHERE project_id = ?").all(projectId).map((r) => ({
+      task: r.task,
+      owner: r.owner ?? "",
+      worktree: r.worktree ?? "",
+      branch: r.branch ?? "",
+      acquiredAt: r.acquired_at,
+      expiresAt: r.expires_at,
+      state: r.state
+    }));
+  }
+  claims(projectId) {
+    const rows = this.db.query(projectId ? "SELECT * FROM claims WHERE project_id = ? ORDER BY acquired_at DESC" : "SELECT * FROM claims ORDER BY acquired_at DESC").all(...projectId ? [projectId] : []).map((r) => ({
+      projectId: r.project_id,
+      task: r.task,
+      owner: r.owner ?? "",
+      worktree: r.worktree ?? "",
+      branch: r.branch ?? "",
+      acquiredAt: r.acquired_at,
+      expiresAt: r.expires_at,
+      releasedAt: r.released_at ?? null,
+      state: r.state
+    }));
+    const now = Date.now();
+    for (const c of rows)
+      if (c.state === "held" && new Date(c.expiresAt).getTime() < now)
+        c.state = "expired";
+    return rows;
+  }
+  worktreePath(projectId, task) {
+    const slug = (x) => x.replace(/[^a-zA-Z0-9._-]+/g, "-").toLowerCase();
+    const p = this.project(projectId);
+    return join5(this.home, "worktrees", slug(p?.name ?? projectId), slug(task));
+  }
+  claim(projectId, task, owner, baseRef = "HEAD") {
+    const p = this.project(projectId);
+    if (!p)
+      return { ok: false, error: "unknown project" };
+    const now = Date.now();
+    const decision = canClaim(this.claimRows(projectId), task, owner, now);
+    if (!decision.ok)
+      return { ok: false, error: claimRefusalMessage(decision, task) };
+    const branch = `task/${task}`;
+    const worktree = this.worktreePath(projectId, task);
+    if (existsSync4(worktree))
+      return { ok: false, error: `${worktree} already exists; release ${task} first` };
+    mkdirSync2(dirname(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);
+    const expiresAt = nextExpiry(now);
+    const acquiredAt = new Date(now).toISOString();
+    this.db.query(`INSERT INTO claims (project_id, task, owner, worktree, branch, acquired_at, expires_at, released_at, state)
+         VALUES (?, ?, ?, ?, ?, ?, ?, NULL, 'held')
+         ON CONFLICT(project_id, task) DO UPDATE SET owner=excluded.owner, worktree=excluded.worktree, branch=excluded.branch,
+           acquired_at=excluded.acquired_at, expires_at=excluded.expires_at, released_at=NULL, state='held'`).run(projectId, task, owner, created, branch, acquiredAt, expiresAt);
+    this.append({
+      ts: acquiredAt,
+      type: "claim.acquired",
+      projectId,
+      sessionId: null,
+      payload: { task, owner, worktree: created, branch, summary: `claim ${task} by ${owner}` }
+    });
+    return { ok: true, task, owner, worktree: created, branch, expiresAt };
+  }
+  renew(projectId, task) {
+    const row = this.db.query("SELECT state FROM claims WHERE project_id = ? AND task = ?").get(projectId, task);
+    if (!row)
+      return { ok: false, error: `no claim on ${task}` };
+    const expiresAt = nextExpiry(Date.now());
+    this.db.query("UPDATE claims SET expires_at = ?, state = 'held' WHERE project_id = ? AND task = ?").run(expiresAt, projectId, task);
+    this.append({
+      ts: new Date().toISOString(),
+      type: "claim.renewed",
+      projectId,
+      sessionId: null,
+      payload: { task, expiresAt, summary: `renew ${task}` }
+    });
+    return { ok: true, task, expiresAt };
+  }
+  release(projectId, task, force = false) {
+    const p = this.project(projectId);
+    const row = this.db.query("SELECT * FROM claims WHERE project_id = ? AND task = ?").get(projectId, task);
+    if (!row)
+      return { ok: false, error: `no claim on ${task}` };
+    const worktree = row.worktree ?? "";
+    if (worktree && existsSync4(worktree)) {
+      const work = heldWork(worktree);
+      const can = canRelease(work, force);
+      if (!can.ok)
+        return {
+          ok: false,
+          error: releaseRefusalMessage(can, worktree),
+          refused: can.reason
+        };
+      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();
+    this.db.query("UPDATE claims SET state = 'released', released_at = ? WHERE project_id = ? AND task = ?").run(releasedAt, projectId, task);
+    this.append({
+      ts: releasedAt,
+      type: "claim.released",
+      projectId,
+      sessionId: null,
+      payload: { task, summary: `release ${task}` }
+    });
+    return { ok: true, task };
+  }
+  reap(projectId) {
+    const scope = projectId ? [projectId] : this.projects().map((p) => p.id);
+    const now = Date.now();
+    const result = [];
+    for (const pid of scope) {
+      const p = this.project(pid);
+      for (const c of this.claimRows(pid)) {
+        if (c.state !== "held" && c.state !== "expired")
+          continue;
+        if (isActive({ ...c, state: "held" }, now))
+          continue;
+        const exists = c.worktree ? existsSync4(c.worktree) : false;
+        const work = exists ? heldWork(c.worktree) : null;
+        const action = reapAction({ ...c, state: "held" }, now, exists, work);
+        if (action === "not-expired")
+          continue;
+        if (action === "reap") {
+          if (exists && p) {
+            worktreeRemove(p.root, c.worktree, false);
+            this.invalidateWorktrees(pid);
+          }
+          this.db.query("UPDATE claims SET state = 'reaped', released_at = ? WHERE project_id = ? AND task = ?").run(new Date(now).toISOString(), pid, c.task);
+          this.append({
+            ts: new Date(now).toISOString(),
+            type: "claim.released",
+            projectId: pid,
+            sessionId: null,
+            payload: { task: c.task, summary: `reaped ${c.task}` }
+          });
+        } else {
+          this.db.query("UPDATE claims SET state = 'orphaned' WHERE project_id = ? AND task = ?").run(pid, c.task);
+          this.append({
+            ts: new Date(now).toISOString(),
+            type: "claim.orphaned",
+            projectId: pid,
+            sessionId: null,
+            payload: {
+              task: c.task,
+              worktree: c.worktree,
+              summary: `orphaned ${c.task} (holds work)`
+            }
+          });
+        }
+        result.push({ task: c.task, projectId: pid, action });
+      }
+    }
+    return result;
+  }
+  since(seq, limit = 5000, full = false) {
+    const rows = this.db.query(`SELECT ${full ? "*" : WIRE_COLS} FROM events WHERE seq > ? ORDER BY seq LIMIT ?`).all(seq, limit);
+    return rows.map(full ? rowToEvent : wireRowToEvent);
+  }
+  sessionEvents(id, limit = 500, after = 0) {
+    const rows = this.db.query(`SELECT * FROM (SELECT ${WIRE_COLS} FROM events WHERE session_id = ? AND seq > ? ORDER BY seq DESC LIMIT ?) ORDER BY seq`).all(id, after, limit);
+    return rows.map(wireRowToEvent);
+  }
+  event(seq) {
+    const r = this.db.query("SELECT * FROM events WHERE seq = ?").get(seq);
+    return r ? rowToEvent(r) : null;
+  }
+  sessionTurns(id, limit = 500, afterTs) {
+    return this.db.query("SELECT * FROM turns WHERE session_id = ? AND ts > ? ORDER BY ts DESC LIMIT ?").all(id, afterTs ?? "", limit).reverse().map((r) => ({
+      id: r.id,
+      agentId: r.agent_id,
+      ts: r.ts,
+      model: r.model,
+      effort: r.effort,
+      sidechain: Boolean(r.sidechain),
+      input: r.input,
+      output: r.output,
+      cacheWrite: r.cache_write,
+      cacheRead: r.cache_read,
+      thinking: r.thinking,
+      costUsd: r.cost_usd,
+      text: r.text,
+      tools: JSON.parse(r.tools || "[]")
+    }));
+  }
+  subscribe(l) {
+    this.listeners.add(l);
+    return () => this.listeners.delete(l);
+  }
+  worktrees(projectId, ttlMs = 15000) {
+    const hit = this.wtCache.get(projectId);
+    if (!hit || Date.now() - hit.t >= ttlMs)
+      this.refreshWorktrees(projectId);
+    return hit?.v ?? [];
+  }
+  refreshWorktrees(projectId) {
+    const inflight = this.wtInflight.get(projectId);
+    if (inflight)
+      return inflight;
+    const p = this.project(projectId);
+    if (!p)
+      return Promise.resolve([]);
+    const run2 = 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;
+  }
+  invalidateWorktrees(projectId) {
+    if (projectId)
+      this.wtCache.delete(projectId);
+    else
+      this.wtCache.clear();
+  }
+  async refreshAllWorktrees() {
+    await Promise.all(this.projects().map((p) => this.refreshWorktrees(p.id)));
+  }
+  sessions() {
+    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();
+    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();
+    const sparks = new Map;
+    for (const x of sparkRows) {
+      const a = sparks.get(x.session_id) ?? [];
+      a.push([x.output, x.cost_usd]);
+      sparks.set(x.session_id, a);
+    }
+    return rows.map((r) => {
+      let state = r.state;
+      if (state !== "ended" && new Date(r.last_seen_at).getTime() < idleBefore)
+        state = "idle";
+      return {
+        id: r.id,
+        projectId: r.project_id,
+        kind: r.kind,
+        agent: r.agent ?? "claude-code",
+        parentId: r.parent_id ?? null,
+        cwd: r.cwd,
+        branch: r.branch ?? null,
+        transcriptPath: r.transcript_path ?? null,
+        title: r.title ?? null,
+        model: r.live_model ?? r.model ?? null,
+        models: r.model_count ?? 0,
+        version: r.version ?? null,
+        startedAt: r.started_at,
+        endedAt: r.ended_at ?? null,
+        lastSeenAt: r.last_seen_at,
+        last: r.last,
+        lastType: r.last_type,
+        lastText: r.last_text ?? null,
+        state,
+        toolCalls: r.tool_calls,
+        subagents: r.subagents,
+        turns: r.turns,
+        tokens: {
+          input: r.input,
+          output: r.output,
+          cacheWrite: r.cache_write,
+          cacheRead: r.cache_read,
+          thinking: r.thinking
+        },
+        costUsd: r.unpriced ? null : r.cost_usd ?? 0,
+        toolCounts: JSON.parse(r.tool_counts || "{}"),
+        spark: sparks.get(r.id) ?? []
+      };
+    });
+  }
+  spend() {
+    const dayStart = new Date;
+    dayStart.setHours(0, 0, 0, 0);
+    const today = dayStart.toISOString();
+    const q = (where, by) => this.db.query(`SELECT ${by} AS key, SUM(t.cost_usd) AS cost, SUM(t.input + t.cache_write + t.cache_read) AS input, SUM(t.output) AS output, COUNT(*) AS turns
+           FROM turns t JOIN sessions s ON s.id = t.session_id ${where} GROUP BY key`).all(today);
+    const daily = this.db.query(`SELECT date(t.ts, 'localtime') AS day, s.project_id AS projectId, COALESCE(s.agent, 'claude-code') AS agent,
+                SUM(t.cost_usd) AS cost, SUM(t.output) AS output, COUNT(*) AS turns
+         FROM turns t JOIN sessions s ON s.id = t.session_id WHERE t.ts > date('now', '-90 days') GROUP BY day, projectId, agent ORDER BY day`).all();
+    const hourly = this.db.query(`SELECT CAST(strftime('%w', t.ts, 'localtime') AS INTEGER) AS dow, CAST(strftime('%H', t.ts, 'localtime') AS INTEGER) AS hour,
+                s.project_id AS projectId, SUM(t.cost_usd) AS cost, COUNT(*) AS turns
+         FROM turns t JOIN sessions s ON s.id = t.session_id WHERE t.ts > date('now', '-28 days') GROUP BY dow, hour, projectId`).all();
+    return {
+      hourly,
+      byProjectToday: q("WHERE t.ts >= ?", "s.project_id"),
+      byProjectAll: q("WHERE ? IS NOT NULL", "s.project_id"),
+      byModelToday: q("WHERE t.ts >= ?", "t.model"),
+      byModelAll: q("WHERE ? IS NOT NULL", "t.model"),
+      byAgentToday: q("WHERE t.ts >= ?", "COALESCE(s.agent, 'claude-code')"),
+      byAgentAll: q("WHERE ? IS NOT NULL", "COALESCE(s.agent, 'claude-code')"),
+      daily
+    };
+  }
+  stats(projectId) {
+    const scope = projectId ? "s.project_id = ?" : "? IS NULL";
+    const arg = projectId ?? null;
+    const totals = this.db.query(`SELECT COUNT(t.id) AS turns, COUNT(DISTINCT t.session_id) AS sessions,
+                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,
+                COALESCE(SUM(t.sidechain),0) AS sidechain, MIN(t.ts) AS first_ts, MAX(t.ts) AS last_ts
+         FROM turns t JOIN sessions s ON s.id = t.session_id WHERE ${scope}`).get(arg);
+    const sess = this.db.query(`SELECT COUNT(*) AS sessions, COALESCE(SUM(s.tool_calls),0) AS tool_calls, COALESCE(SUM(s.subagents),0) AS subagents,
+                SUM(s.kind = 'subagent') AS subagent_sessions
+         FROM sessions s WHERE ${scope}`).get(arg);
+    const daily = this.db.query(`SELECT date(t.ts, 'localtime') AS day, SUM(t.input) AS input, SUM(t.output) AS output, SUM(t.cache_write) AS cacheWrite,
+                SUM(t.cache_read) AS cacheRead, SUM(t.thinking) AS thinking, SUM(t.cost_usd) AS cost, COUNT(*) AS turns
+         FROM turns t JOIN sessions s ON s.id = t.session_id WHERE ${scope} AND t.ts > datetime('now', '-366 days') GROUP BY day ORDER BY day`).all(arg);
+    const byHour = this.db.query(`SELECT CAST(strftime('%H', t.ts, 'localtime') AS INTEGER) AS hour, COUNT(*) AS turns, SUM(t.output) AS output, SUM(t.cost_usd) AS cost
+         FROM turns t JOIN sessions s ON s.id = t.session_id WHERE ${scope} GROUP BY hour ORDER BY hour`).all(arg);
+    const byModel = this.db.query(`SELECT t.model AS model, COUNT(*) AS turns, SUM(t.output) AS output, SUM(t.cost_usd) AS cost
+         FROM turns t JOIN sessions s ON s.id = t.session_id WHERE ${scope} GROUP BY t.model ORDER BY output DESC`).all(arg);
+    const tools = {};
+    for (const r of this.db.query(`SELECT s.tool_counts AS tc FROM sessions s WHERE ${scope}`).all(arg)) {
+      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,
+                  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);
+    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;
+    return {
+      totals: {
+        turns: Number(totals.turns ?? 0),
+        sessions: Number(sess.sessions ?? 0),
+        sessionsWithTurns: Number(totals.sessions ?? 0),
+        subagentSessions: Number(sess.subagent_sessions ?? 0),
+        toolCalls: Number(sess.tool_calls ?? 0),
+        subagents: Number(sess.subagents ?? 0),
+        sidechainTurns: Number(totals.sidechain ?? 0),
+        input: Number(totals.input ?? 0),
+        output: Number(totals.output ?? 0),
+        cacheWrite: Number(totals.cache_write ?? 0),
+        cacheRead: Number(totals.cache_read ?? 0),
+        thinking: Number(totals.thinking ?? 0),
+        cost: totals.cost == null ? null : Number(totals.cost),
+        firstTs: totals.first_ts ?? null,
+        lastTs: totals.last_ts ?? null
+      },
+      daily,
+      byHour,
+      byModel,
+      tools: Object.entries(tools).sort((a, b) => b[1] - a[1]).slice(0, 15),
+      records: {
+        costliestSession: sessionRow("cost"),
+        longestSession: sessionRow("turns"),
+        longestWallSession: sessionRow("(julianday(s.last_seen_at) - julianday(s.started_at))"),
+        biggestTurn,
+        busiestDay
+      }
+    };
+  }
+  incidents(limit = 50, opts = {}) {
+    const where = ["e.type = 'incident.opened'"];
+    const args = [];
+    if (opts.open)
+      where.push("a.seq IS NULL");
+    if (opts.projectId) {
+      where.push("e.project_id = ?");
+      args.push(opts.projectId);
+    }
+    args.push(limit);
+    const rows = this.db.query(`SELECT e.seq, e.ts, e.project_id, e.session_id, e.payload, a.acked_at FROM events e
+         LEFT JOIN incident_acks a ON a.seq = e.seq WHERE ${where.join(" AND ")} ORDER BY e.seq DESC LIMIT ?`).all(...args);
+    return rows.map((r) => ({
+      seq: r.seq,
+      ts: r.ts,
+      projectId: r.project_id,
+      sessionId: r.session_id,
+      acked: r.acked_at,
+      ...JSON.parse(r.payload || "{}")
+    }));
+  }
+  openIncidents(projectId) {
+    const r = this.db.query(`SELECT COUNT(*) AS n FROM events e LEFT JOIN incident_acks a ON a.seq = e.seq
+         WHERE e.type = 'incident.opened' AND a.seq IS NULL${projectId ? " AND e.project_id = ?" : ""}`).get(...projectId ? [projectId] : []);
+    return r.n;
+  }
+  ackIncident(seq) {
+    const row = this.db.query("SELECT seq FROM events WHERE seq = ? AND type = 'incident.opened'").get(seq);
+    if (!row)
+      return false;
+    this.db.query("INSERT OR IGNORE INTO incident_acks (seq, acked_at) VALUES (?, ?)").run(seq, new Date().toISOString());
+    this.touch();
+    return true;
+  }
+  ackAllIncidents(projectId) {
+    const at = new Date().toISOString();
+    const r = this.db.query(`INSERT OR IGNORE INTO incident_acks (seq, acked_at)
+         SELECT e.seq, ? FROM events e LEFT JOIN incident_acks a ON a.seq = e.seq
+         WHERE e.type = 'incident.opened' AND a.seq IS NULL${projectId ? " AND e.project_id = ?" : ""}`).run(at, ...projectId ? [projectId] : []);
+    this.touch();
+    return Number(r.changes);
+  }
+  static pidAlive(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  rowToResource(r) {
+    return {
+      name: r.name,
+      kind: r.kind ?? "custom",
+      projectId: r.project_id || null,
+      owner: r.owner,
+      sessionId: r.session_id || null,
+      pid: isTrackedPid(r.pid) ? r.pid : null,
+      port: r.port ?? null,
+      acquiredAt: r.acquired_at,
+      expiresAt: r.expires_at || null,
+      released: !!r.released
+    };
+  }
+  resources(projectId) {
+    this.reapResources();
+    const rows = projectId ? this.db.query("SELECT * FROM resources WHERE released = 0 AND (project_id = ? OR project_id = '')").all(projectId) : this.db.query("SELECT * FROM resources WHERE released = 0").all();
+    return rows.map((r) => this.rowToResource(r));
+  }
+  heldPorts() {
+    return this.db.query("SELECT port FROM resources WHERE released = 0 AND port IS NOT NULL").all().map((r) => r.port);
+  }
+  reapResources() {
+    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))
+        n++;
+    return n;
+  }
+  reapIfDead(r, now = Date.now()) {
+    if (r.released || isAliveHolding(r, now, Store.pidAlive))
+      return false;
+    this.db.query("UPDATE resources SET released = 1 WHERE name = ? AND project_id = ?").run(r.name, r.projectId ?? "");
+    this.append({
+      ts: new Date().toISOString(),
+      type: "resource.reaped",
+      projectId: r.projectId ?? "p_unknown",
+      sessionId: r.sessionId,
+      payload: { name: r.name, owner: r.owner, pid: r.pid, port: r.port }
+    });
+    return true;
+  }
+  static processStartTime(pid) {
+    try {
+      const r = Bun.spawnSync(["ps", "-o", "lstart=", "-p", String(pid)], {
+        stdout: "pipe",
+        stderr: "ignore"
+      });
+      const out = r.stdout.toString().trim();
+      return out || null;
+    } catch {
+      return null;
+    }
+  }
+  rowToProcess(r) {
+    return {
+      pid: r.pid,
+      startTime: r.start_time ?? null,
+      projectId: r.project_id,
+      sessionId: r.session_id ?? null,
+      kind: r.kind,
+      name: r.name,
+      port: r.port ?? null,
+      cwd: r.cwd ?? "",
+      cmd: r.cmd ?? "",
+      owner: r.owner ?? "",
+      log: r.log ?? null,
+      startedAt: r.started_at,
+      endedAt: r.ended_at ?? null
+    };
+  }
+  processes(projectId) {
+    const rows = this.db.query(projectId ? "SELECT rowid, * FROM processes WHERE ended_at IS NULL AND project_id = ? ORDER BY started_at DESC" : "SELECT rowid, * FROM processes WHERE ended_at IS NULL ORDER BY started_at DESC").all(...projectId ? [projectId] : []).map((r) => ({ rowid: r.rowid, p: this.rowToProcess(r) }));
+    const live = [];
+    for (const { rowid, p } of rows) {
+      if (this.processIsOurs(p))
+        live.push(p);
+      else
+        this.endProcess(rowid, p, "exited");
+    }
+    return live;
+  }
+  processIsOurs(p) {
+    const alive = Store.pidAlive(p.pid);
+    return isOurs(p, alive, alive ? Store.processStartTime(p.pid) : null);
+  }
+  endProcess(rowid, p, how) {
+    const at = new Date().toISOString();
+    this.db.query("UPDATE processes SET ended_at = ? WHERE rowid = ?").run(at, rowid);
+    this.db.query("UPDATE resources SET released = 1 WHERE name = ? AND project_id = ? AND pid = ?").run(p.name, p.projectId, p.pid);
+    this.append({
+      ts: at,
+      type: "process.exited",
+      projectId: p.projectId,
+      sessionId: p.sessionId,
+      payload: { pid: p.pid, name: p.name, kind: p.kind, port: p.port, how }
+    });
+  }
+  reapProcesses() {
+    const before = this.db.query("SELECT COUNT(*) AS n FROM processes WHERE ended_at IS NULL").get().n;
+    return before - this.processes().length;
+  }
+  takenPorts() {
+    const held = this.heldPorts();
+    const procs = this.db.query("SELECT port FROM processes WHERE ended_at IS NULL AND port IS NOT NULL").all().map((r) => r.port);
+    return [...held, ...procs];
+  }
+  static portFree(port) {
+    try {
+      const l = Bun.listen({ hostname: "127.0.0.1", port, socket: { data() {} } });
+      l.stop(true);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  allocatePort(from = DEFAULT_FROM_PORT) {
+    return pickPort(from, this.takenPorts(), Store.portFree);
+  }
+  registerProcess(input) {
+    if (!isTrackedPid(input.pid))
+      return { ok: false, reason: "a real pid is required" };
+    if (!this.project(input.projectId))
+      return { ok: false, reason: "unknown project" };
+    if (!Store.pidAlive(input.pid))
+      return { ok: false, reason: `pid ${input.pid} is not running` };
+    const res = this.acquireResource({
+      name: input.name,
+      projectId: input.projectId,
+      kind: "process",
+      owner: input.owner,
+      sessionId: input.sessionId ?? null,
+      pid: input.pid,
+      port: input.port ?? null
+    });
+    if (!res.ok)
+      return res;
+    const p = {
+      pid: input.pid,
+      startTime: Store.processStartTime(input.pid),
+      projectId: input.projectId,
+      sessionId: this.knownSession(input.sessionId),
+      kind: input.kind,
+      name: input.name,
+      port: input.port ?? null,
+      cwd: input.cwd,
+      cmd: input.cmd,
+      owner: input.owner,
+      log: input.log ?? null,
+      startedAt: new Date().toISOString(),
+      endedAt: null
+    };
+    this.db.query("UPDATE processes SET ended_at = ? WHERE ended_at IS NULL AND project_id = ? AND name = ?").run(p.startedAt, p.projectId, p.name);
+    this.db.query(`INSERT INTO processes (pid, start_time, project_id, session_id, kind, name, port, cwd, cmd, owner, log, started_at, ended_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)`).run(p.pid, p.startTime, p.projectId, p.sessionId, p.kind, p.name, p.port, p.cwd, p.cmd, p.owner, p.log, p.startedAt);
+    this.append({
+      ts: p.startedAt,
+      type: "process.started",
+      projectId: p.projectId,
+      sessionId: p.sessionId,
+      payload: { pid: p.pid, name: p.name, kind: p.kind, port: p.port, cmd: p.cmd.slice(0, 200) }
+    });
+    this.touch();
+    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)
+      return { ok: false, reason: "not a registered process" };
+    const p = this.rowToProcess(raw2);
+    const rowid = raw2.rowid;
+    if (!this.processIsOurs(p)) {
+      this.endProcess(rowid, p, "exited");
+      return { ok: true, reason: "already gone" };
+    }
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {}
+    const deadline = Date.now() + graceMs;
+    while (Date.now() < deadline && Store.pidAlive(pid))
+      await Bun.sleep(100);
+    if (Store.pidAlive(pid) && this.processIsOurs(p)) {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {}
+    }
+    this.endProcess(rowid, p, "stopped");
+    this.touch();
+    return { ok: true };
+  }
+  knownSession(id) {
+    if (!id)
+      return null;
+    return this.db.query("SELECT 1 FROM sessions WHERE id = ?").get(id) ? id : null;
+  }
+  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;
+    if (existing && this.reapIfDead(existing))
+      existing = null;
+    const d = canAcquire(existing, { owner: input.owner }, Date.now(), Store.pidAlive);
+    if (!d.ok)
+      return { ok: false, reason: acquireRefusalMessage(d.holder) };
+    const pid = isTrackedPid(input.pid) ? input.pid : null;
+    const expiresAt = pid != null ? null : new Date(Date.now() + (input.leaseMinutes ?? DEFAULT_RESOURCE_LEASE_MINUTES) * 60000).toISOString();
+    const resource = {
+      name: input.name,
+      kind: input.kind ?? (input.port != null ? "port" : pid != null ? "process" : "custom"),
+      projectId: input.projectId ?? null,
+      owner: input.owner,
+      sessionId: this.knownSession(input.sessionId),
+      pid,
+      port: input.port ?? null,
+      acquiredAt: new Date().toISOString(),
+      expiresAt,
+      released: false
+    };
+    this.db.query(`INSERT INTO resources (name, project_id, kind, owner, session_id, pid, port, acquired_at, expires_at, released)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
+         ON CONFLICT(name, project_id) DO UPDATE SET
+           kind=excluded.kind, owner=excluded.owner, session_id=excluded.session_id, pid=excluded.pid,
+           port=excluded.port, acquired_at=excluded.acquired_at, expires_at=excluded.expires_at, released=0`).run(resource.name, key, resource.kind, resource.owner, resource.sessionId, resource.pid, resource.port, resource.acquiredAt, resource.expiresAt);
+    this.append({
+      ts: resource.acquiredAt,
+      type: "resource.acquired",
+      projectId: resource.projectId ?? "p_unknown",
+      sessionId: resource.sessionId,
+      payload: {
+        name: resource.name,
+        kind: resource.kind,
+        owner: resource.owner,
+        pid: resource.pid,
+        port: resource.port
+      }
+    });
+    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)
+      return { ok: false, reason: "not held" };
+    const r = this.rowToResource(raw2);
+    if (!force) {
+      if (!owner)
+        return { ok: false, reason: `held by ${r.owner}; pass owner or force` };
+      if (r.owner !== owner)
+        return { ok: false, reason: `held by ${r.owner}, not ${owner}` };
+    }
+    this.db.query("UPDATE resources SET released = 1 WHERE name = ? AND project_id = ?").run(name, projectId ?? "");
+    this.append({
+      ts: new Date().toISOString(),
+      type: "resource.released",
+      projectId: r.projectId ?? "p_unknown",
+      sessionId: r.sessionId,
+      payload: {
+        name: r.name,
+        owner: r.owner,
+        by: owner ?? null,
+        forced: force && owner !== r.owner
+      }
+    });
+    return { ok: true };
+  }
+  seq() {
+    return this.db.query("SELECT COALESCE(MAX(seq),0) AS seq FROM events").get().seq;
+  }
+  snapshot() {
+    const worktrees = {};
+    const projects = this.projects();
+    for (const p of projects)
+      worktrees[p.id] = this.worktrees(p.id);
+    return {
+      projects,
+      worktrees,
+      sessions: this.memoised("sessions", 2000, () => this.sessions()),
+      spend: this.memoised("spend", 30000, () => this.spend()),
+      claims: this.claims(),
+      processes: this.memoised("processes", 5000, () => this.processes()),
+      incidents: this.memoised("incidents", 30000, () => this.incidents(20, { open: true })),
+      openIncidents: this.memoised("openIncidents", 30000, () => this.openIncidents()),
+      resources: this.resources(),
+      seq: this.seq()
+    };
+  }
+}
+var WIRE_COLS = "seq, ts, type, project_id, session_id, json_remove(payload, '$.toolInput', '$.toolResponse', '$.prompt') AS payload";
+var RAW_TOOL_KEYS = ["tool_input", "tool_response", "toolInput", "toolResponse", "toolResult"];
+var TOOL_INPUT_MAX = 2048;
+var TOOL_RESPONSE_MAX = 4096;
+function clip(v, max) {
+  if (v === undefined)
+    return;
+  const s = JSON.stringify(v);
+  if (s.length <= max)
+    return v;
+  return { truncated: true, bytes: s.length, preview: s.slice(0, max) };
+}
+function slimForStorage(e) {
+  const p = e.payload;
+  let payload = p;
+  if (p && typeof p === "object" && (("toolInput" in p) || ("toolResponse" in p))) {
+    payload = {
+      ...p,
+      toolInput: clip(p.toolInput, TOOL_INPUT_MAX),
+      toolResponse: clip(p.toolResponse, TOOL_RESPONSE_MAX)
+    };
+  }
+  let raw2 = e.raw;
+  if (raw2 && typeof raw2 === "object") {
+    const r = raw2;
+    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;
+    }
+  }
+  return { payload, raw: raw2 };
+}
+function toWire(e) {
+  const { raw: _raw, ...rest } = e;
+  const p = rest.payload;
+  if (p && typeof p === "object" && (("toolInput" in p) || ("toolResponse" in p) || ("prompt" in p))) {
+    const { toolInput: _a, toolResponse: _b, prompt: _c, ...small } = p;
+    return { ...rest, payload: small };
+  }
+  return rest;
+}
+function wireRowToEvent(r) {
+  const p = JSON.parse(r.payload ?? "null");
+  return {
+    seq: r.seq,
+    ts: r.ts,
+    type: r.type,
+    projectId: r.project_id,
+    sessionId: r.session_id ?? null,
+    payload: p
+  };
+}
+function rowToEvent(r) {
+  const e = {
+    seq: r.seq,
+    ts: r.ts,
+    type: r.type,
+    projectId: r.project_id,
+    sessionId: r.session_id ?? null,
+    payload: JSON.parse(r.payload ?? "null")
+  };
+  if (r.raw)
+    e.raw = JSON.parse(r.raw);
+  return e;
+}
+
+// packages/daemon/src/app.ts
+var VERSION = "0.4.0";
+var WEB_DIR = (() => {
+  if (process.env.SWARM_WEB_DIR)
+    return process.env.SWARM_WEB_DIR;
+  const here = dirname2(fileURLToPath(import.meta.url));
+  const dev = join6(here, "../../web/public");
+  return existsSync5(join6(dev, "index.html")) ? dev : join6(here, "../web");
+})();
+var REPLAY_TAIL = 200;
+var wireCache = new WeakMap;
+function wireJson(e) {
+  let s = wireCache.get(e);
+  if (!s) {
+    s = JSON.stringify(e);
+    wireCache.set(e, s);
+  }
+  return s;
+}
+function createApp(store = new Store) {
+  const app = new Hono2;
+  const forge2 = new ForgeService(store);
+  app.get("/v1/health", (c) => c.json({ ok: true, version: VERSION }));
+  app.get("/v1/projects", (c) => c.json(store.snapshot().projects));
+  app.post("/v1/projects", async (c) => {
+    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);
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+  });
+  app.put("/v1/projects/order", async (c) => {
+    const { ids } = await c.req.json().catch(() => ({}));
+    if (!Array.isArray(ids) || !ids.every((x) => typeof x === "string"))
+      return c.json({ error: "ids: string[] required" }, 400);
+    return c.json(store.reorderProjects(ids));
+  });
+  app.patch("/v1/projects/:id", async (c) => {
+    const { pinned, name } = await c.req.json().catch(() => ({}));
+    const p = store.updateProject(c.req.param("id"), { pinned, name });
+    return p ? c.json(p) : c.json({ error: "not found" }, 404);
+  });
+  app.delete("/v1/projects/:id", (c) => store.removeProject(c.req.param("id")) ? c.body(null, 204) : c.json({ error: "not found" }, 404));
+  app.get("/v1/fs/ls", (c) => {
+    const q = c.req.query("path");
+    let dir;
+    try {
+      dir = realpathSync3(q && existsSync5(q) ? q : homedir4());
+    } catch {
+      dir = homedir4();
+    }
+    try {
+      const entries = readdirSync2(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({ name: e.name, repo: existsSync5(join6(dir, e.name, ".git")) })).sort((a, b) => a.name.localeCompare(b.name));
+      const parent = dirname2(dir);
+      return c.json({ path: dir, parent: parent === dir ? null : parent, entries });
+    } catch (e) {
+      return c.json({ error: e.message, path: dir }, 400);
+    }
+  });
+  app.get("/v1/state", (c) => c.json(store.snapshot()));
+  app.get("/v1/stats", (c) => c.json(store.stats(c.req.query("project") || undefined)));
+  app.get("/v1/incidents", (c) => c.json(store.incidents(Number(c.req.query("limit") ?? 50), {
+    open: c.req.query("open") === "1",
+    projectId: c.req.query("project") || undefined
+  })));
+  app.post("/v1/incidents/ack", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    return c.json({ ok: true, acked: store.ackAllIncidents(body.project || undefined) });
+  });
+  app.post("/v1/incidents/:seq/ack", (c) => {
+    const seq = Number(c.req.param("seq"));
+    if (!Number.isInteger(seq) || !store.ackIncident(seq))
+      return c.json({ ok: false, error: "no such incident" }, 404);
+    return c.json({ ok: true });
+  });
+  app.get("/v1/resources", (c) => c.json(store.resources(c.req.query("project"))));
+  app.post("/v1/resources", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    if (!b.name || !b.owner)
+      return c.json({ ok: false, error: "name and owner are required" }, 400);
+    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.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);
+    return r.ok ? c.json(r) : c.json({ error: r.output || "merge failed" }, 409);
+  });
+  app.delete("/v1/resources/:name", (c) => {
+    const r = store.releaseResource(c.req.param("name"), c.req.query("project") ?? null, c.req.query("owner"), c.req.query("force") === "1" || c.req.query("force") === "true");
+    return r.ok ? c.json(r) : c.json({ ok: false, error: r.reason }, r.reason === "not held" ? 404 : 409);
+  });
+  app.get("/v1/processes", (c) => c.json(store.processes(c.req.query("project") || undefined)));
+  app.post("/v1/ports/allocate", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    const port = store.allocatePort(Number.isInteger(b.from) && b.from > 0 ? b.from : undefined);
+    return port ? c.json({ ok: true, port }) : c.json({ ok: false, error: "no free port" }, 503);
+  });
+  app.post("/v1/processes", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    if (!b.pid || !b.projectId || !b.name || !b.cwd)
+      return c.json({ ok: false, error: "pid, projectId, name and cwd required" }, 400);
+    const r = store.registerProcess({
+      pid: Number(b.pid),
+      projectId: b.projectId,
+      sessionId: b.sessionId ?? null,
+      kind: b.kind === "serve" ? "serve" : "proc",
+      name: b.name,
+      port: b.port ?? null,
+      cwd: b.cwd,
+      cmd: b.cmd ?? "",
+      owner: b.owner ?? "cli",
+      log: b.log ?? null
+    });
+    return r.ok ? c.json(r, 201) : c.json({ ok: false, error: r.reason }, 409);
+  });
+  app.delete("/v1/processes/:pid", async (c) => {
+    const pid = Number(c.req.param("pid"));
+    if (!Number.isInteger(pid) || pid <= 0)
+      return c.json({ ok: false, error: "bad pid" }, 400);
+    const r = await store.stopProcess(pid, c.req.query("project") || null);
+    return r.ok ? c.json(r) : c.json({ ok: false, error: r.reason }, 404);
+  });
+  app.get("/v1/tasks", (c) => {
+    const project = c.req.query("project");
+    if (!project)
+      return c.json({ error: "project required" }, 400);
+    const t = store.tasks(project);
+    return c.json(t ?? { source: null, tasks: [] });
+  });
+  app.get("/v1/claims", (c) => c.json(store.claims(c.req.query("project"))));
+  app.post("/v1/claims", async (c) => {
+    const b = await c.req.json();
+    if (!b.projectId || !b.task)
+      return c.json({ error: "projectId and task required" }, 400);
+    const r = store.claim(b.projectId, b.task, b.owner ?? "cli", b.baseRef);
+    return c.json(r, r.ok ? 201 : 409);
+  });
+  app.post("/v1/claims/renew", async (c) => {
+    const b = await c.req.json();
+    const r = store.renew(b.projectId ?? "", b.task ?? "");
+    return c.json(r, r.ok ? 200 : 404);
+  });
+  app.post("/v1/claims/release", async (c) => {
+    const b = await c.req.json();
+    const r = store.release(b.projectId ?? "", b.task ?? "", b.force ?? false);
+    return c.json(r, r.ok ? 200 : 409);
+  });
+  app.post("/v1/claims/reap", async (c) => {
+    const b = await c.req.json().catch(() => ({}));
+    return c.json({ reaped: store.reap(b.projectId) });
+  });
+  app.get("/v1/sessions/:id/events", (c) => {
+    const id = c.req.param("id");
+    const after = Number(c.req.query("after") ?? 0);
+    const afterTs = c.req.query("afterTs") || undefined;
+    return c.json({
+      events: store.sessionEvents(id, 500, after),
+      turns: store.sessionTurns(id, 500, afterTs),
+      seq: store.seq()
+    });
+  });
+  app.get("/v1/events/:seq", (c) => {
+    const e = store.event(Number(c.req.param("seq")));
+    return e ? c.json(e) : c.json({ error: "not found" }, 404);
+  });
+  app.get("/v1/spend", (c) => c.json(store.spend()));
+  app.post("/v1/pricing/refresh", async (c) => {
+    try {
+      await store.refreshPricing();
+      return c.json({ ok: true, models: Object.keys(store.prices).length });
+    } catch (e) {
+      return c.json({ error: e.message }, 502);
+    }
+  });
+  app.get("/v1/pricing", (c) => c.json(store.prices));
+  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 === "PreToolUse" && process.env.SWARM_GUARD !== "off") {
+      const guard = store.guardHook(raw2);
+      if (guard) {
+        return c.json({
+          hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: guard.action,
+            permissionDecisionReason: `[swarm] ${guard.reason}`
+          }
+        });
+      }
+    }
+    return c.json({});
+  });
+  app.post("/v1/events", async (c) => {
+    const e = await c.req.json();
+    return c.json(store.append(e), 201);
+  });
+  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) => {
+      for (const e of store.since(since, 5000, full)) {
+        await stream2.writeSSE({ id: String(e.seq), event: e.type, data: JSON.stringify(e) });
+      }
+      await stream2.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) });
+        });
+        const beat = setInterval(() => void stream2.writeSSE({ event: "ping", data: "" }), 15000);
+        stream2.onAbort(() => {
+          clearInterval(beat);
+          off();
+          resolve();
+        });
+      });
+    });
+  });
+  app.get("/", (c) => c.html(readFileSync4(join6(WEB_DIR, "index.html"), "utf8")));
+  const MIME = { js: "text/javascript", css: "text/css" };
+  app.get("/:file{[a-z0-9-]+\\.(js|css)}", (c) => {
+    const f = c.req.param("file");
+    const p = join6(WEB_DIR, f);
+    if (!existsSync5(p))
+      return c.text(`${f} not built \u2014 run: bun run build:web`, 404);
+    return c.body(readFileSync4(p, "utf8"), 200, {
+      "content-type": MIME[f.split(".").pop() ?? ""] ?? "text/plain"
+    });
+  });
+  return { app, store, forge: forge2 };
+}
+
+// packages/daemon/src/bin.ts
+var DEFAULT_PORT2 = process.env.SWARM_PORT ? DEFAULT_PORT : loadConfig().daemon.port;
+var { app, store } = createApp();
+function serve() {
+  const bind = (p) => Bun.serve({ port: p, hostname: "127.0.0.1", idleTimeout: 0, fetch: app.fetch });
+  try {
+    return bind(DEFAULT_PORT2);
+  } catch (e) {
+    if (process.env.SWARM_STRICT_PORT === "1" || !/EADDRINUSE|in use/i.test(e.message))
+      throw e;
+    console.error(`swarmd: port ${DEFAULT_PORT2} in use \u2014 picking a free port instead.`);
+    return bind(0);
+  }
+}
+var server = serve();
+var port = server.port ?? DEFAULT_PORT2;
+writeDaemonInfo({ port, pid: process.pid, version: VERSION, startedAt: new Date().toISOString() });
+var backfillDays = Number(process.env.SWARM_CODEX_BACKFILL_DAYS ?? 30);
+var backfillMs = backfillDays * 24 * 60 * 60000;
+store.tailCodex(backfillMs);
+store.tailGrok(backfillMs);
+var tick = 0;
+var tailer = setInterval(() => {
+  tick++;
+  store.tailActive();
+  if (tick % 3 === 0 || store.hasActiveSessions()) {
+    store.tailCodex();
+    store.tailGrok();
+  }
+  store.reapResources();
+  store.reapProcesses();
+}, 5000);
+store.refreshAllWorktrees();
+var wtRefresh = setInterval(() => void store.refreshAllWorktrees(), 15000);
+store.prune();
+var pruner = setInterval(() => store.prune(), 24 * 60 * 60000);
+if (process.env.SWARM_OFFLINE !== "1")
+  store.refreshPricing().catch(() => {});
+console.log(`swarmd ${VERSION} listening on http://127.0.0.1:${port}`);
+function shutdown() {
+  clearInterval(tailer);
+  clearInterval(wtRefresh);
+  clearInterval(pruner);
+  clearDaemonInfo();
+  server.stop(true);
+  process.exit(0);
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+process.on("exit", () => clearDaemonInfo());