@dendelion/paper-camp 0.2.1 → 0.4.0

package/dist/cli/index.js

@@ -1,150 +1,95 @@
 #!/usr/bin/env node
-import { join as O, dirname as ct, extname as dt, basename as pt, resolve as Y } from "node:path";
-import { Command as ut } from "commander";
-import { t as nt, r as z, m as Q, s as k, q as M, j as Z, c as at, i as it, w as B, a as ot, n as V, b as lt, f as ft, P as gt, l as mt, A as yt } from "../chunks/serializer.D1Ts_p8h.js";
-import { DEFAULT_AGENTS as X, PLAN_KINDS as F, AGENT_IDS as U } from "../types/index.js";
-import { readFile as $, writeFile as I, mkdir as ht, stat as st } from "node:fs/promises";
-import { createServer as Ct } from "node:http";
-import { fileURLToPath as wt } from "node:url";
-import { watch as G, readFileSync as St } from "node:fs";
-import { spawn as K, spawnSync as L } from "node:child_process";
+import { spawn as it, spawnSync as It } from "node:child_process";
+import { stat as ht, readFile as at, mkdir as ut, writeFile as q, lstat as ce, unlink as Xt } from "node:fs/promises";
+import { join as $, dirname as de, sep as le, extname as ue, basename as pe, resolve as ft } from "node:path";
 import { createInterface as Tt } from "node:readline";
-const E = (n, c) => O(n, "papercamp", c), _ = (n) => $(n, "utf-8").catch(() => "");
-async function q(n) {
-  const [c, o, s, u] = await Promise.all([
-    _(E(n, "plans.md")),
-    _(E(n, "decisions.md")),
-    _(E(n, "open-questions.md")),
-    _(E(n, "progress.md"))
-  ]);
-  return {
-    plans: k(c).entries,
-    decisions: Q(o).entries,
-    openQuestions: z(s).entries,
-    progress: nt(u)
-  };
-}
-function Nt(n, c) {
-  const o = [], s = (/* @__PURE__ */ new Date()).toISOString(), u = new Map(n.plans.map((e) => [e.title, e])), y = new Map(c.plans.map((e) => [e.title, e]));
-  for (const [e, d] of y) {
-    const f = u.get(e);
-    if (!f)
-      o.push({ message: `New plan added: ${e}`, timestamp: s });
-    else if (f.status !== d.status)
-      o.push({ message: `Plan "${e}" marked ${d.status}`, timestamp: s });
-    else
-      for (let p = 0; p < d.phases.length; p++) {
-        const l = f.phases[p], m = d.phases[p];
-        l && l.done !== m.done && o.push({
-          message: m.done ? `Phase ${p + 1}/${d.phases.length} checked off in "${e}"` : `Phase ${p + 1}/${d.phases.length} unchecked in "${e}"`,
-          timestamp: s
-        });
-      }
-  }
-  for (const [e] of u)
-    y.has(e) || o.push({ message: `Plan removed: ${e}`, timestamp: s });
-  const r = new Map(n.decisions.map((e) => [e.title, e])), t = new Map(c.decisions.map((e) => [e.title, e]));
-  for (const [e] of t)
-    r.has(e) || o.push({ message: `New decision: ${e}`, timestamp: s });
-  const b = new Map(n.openQuestions.map((e) => [e.title, e])), C = new Map(c.openQuestions.map((e) => [e.title, e]));
-  for (const [e] of C)
-    b.has(e) || o.push({ message: `New open question: ${e}`, timestamp: s });
-  const S = new Map(n.progress.map((e) => [e.date, e])), i = new Map(c.progress.map((e) => [e.date, e]));
-  for (const [e] of i)
-    S.has(e) || o.push({ message: `Progress logged: ${e}`, timestamp: s });
-  return o;
-}
-function Ot(n) {
-  const c = /* @__PURE__ */ new Set();
-  let o = null, s = null;
-  const u = ["plans.md", "decisions.md", "open-questions.md", "progress.md"];
-  async function y() {
-    try {
-      const r = await q(n);
-      if (o) {
-        const t = Nt(o, r);
-        for (const b of t) {
-          const C = `data: ${JSON.stringify(b)}
+import { Command as fe } from "commander";
+import { AGENT_OPTIONS as qt, coerceAgentConfig as z, DEFAULT_AGENTS as _t, AGENT_IDS as Mt, PLAN_KINDS as Et } from "../types/index.js";
+import { K as lt, D as mt, L as Ct, M as gt, q as Lt, k as Zt, o as xt, O as ot, E as Vt, J as te, B as ee, C as jt, i as he, b as me, m as ge, x as Jt, c as we, j as ne, e as ae, d as ye, F as $e, w as Kt, h as ke, P as be, t as Se, A as ve } from "../chunks/serializer.B8u-L8BI.js";
+import { createServer as xe } from "node:http";
+import { fileURLToPath as Ie } from "node:url";
+import { watch as Ot, readFileSync as Pe } from "node:fs";
+function ie(t) {
+  const a = t.phases.map((s, e) => `${e + 1}. [${s.done ? "x" : " "}] ${s.text}`).join(`
+`), i = t.log && t.log.length > 0 ? t.log.map((s) => `- ${s.date}: ${s.text}`).join(`
+`) : "(none)", r = t.clarifications && t.clarifications.length > 0 ? t.clarifications.map((s) => `- ${s.date}: ${s.text}`).join(`
+`) : "(none)";
+  return `You are auditing the plan "${t.title}" (${t.id ?? "no id"}) for missing phases. The plan is a single file at papercamp/plans/${t.id ?? "<ID>"}.md — if it is not there, it is archived at papercamp/plans/archive/${t.id ?? "<ID>"}.md. Edit only that file.
 
-`;
-          for (const S of c)
-            try {
-              S.write(C);
-            } catch {
-              c.delete(S);
-            }
-        }
-      }
-      o = r;
-    } catch {
-    }
-  }
-  for (const r of u) {
-    const t = E(n, r);
-    try {
-      G(t, () => {
-        s && clearTimeout(s), s = setTimeout(y, 300);
-      });
-    } catch {
-    }
-  }
-  return q(n).then((r) => {
-    o = r;
-  }), {
-    subscribe(r) {
-      c.add(r);
-      const t = JSON.stringify({
-        message: "Watching for changes…",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      r.write(`data: ${t}
+Plan body: ${t.body}
 
-`), r.on("close", () => c.delete(r));
-    }
-  };
+Current phases:
+${a}
+
+Log entries (issues, bugs, and review notes recorded so far):
+${i}
+
+Clarifications (answered scope/design questions):
+${r}
+
+Task:
+1. Read the plan above, then inspect the relevant code in this repo.
+2. Identify work that is clearly required to fulfil this plan but is covered by no existing phase. The Log entries are the best source — they often record bugs or gaps that were never turned into phases.
+3. If you found missing work: append one \`- [ ] <short phase title>\` line per item at the end of the \`### Phases\` list. You may add detail below a checkbox line as continuation lines indented with 6 spaces. Then append exactly one line to the \`### Log\` section, formatted \`- YYYY-MM-DD: <what was found and appended>\`, creating that section after the Phases list if it does not exist.
+4. If nothing is missing: make no edits at all — no Log line, no empty heading, no "nothing found" note. This audit re-runs regularly and must leave no trace when there is nothing to add.
+
+Rules:
+- Never modify, reorder, check, uncheck, or delete any existing line, even if it looks stale, wrong, or redundant.
+- Never touch the YAML frontmatter.
+- Append only: new unchecked phases at the end of the list, plus the single Log line.`;
 }
-function jt(n) {
-  return ["-p", n, "--output-format", "stream-json", "--verbose", "--permission-mode", "auto"];
+function Ae(t, a) {
+  const i = [
+    "-p",
+    t,
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--permission-mode",
+    "auto"
+  ];
+  return a != null && a.model && i.push("--model", a.model), a != null && a.effort && i.push("--effort", a.effort), i;
 }
-function bt(n) {
-  let c;
+function Te(t) {
+  let a;
   try {
-    c = JSON.parse(n);
+    a = JSON.parse(t);
   } catch {
     return null;
   }
-  switch (c.type) {
+  switch (a.type) {
     case "system":
-      return c.subtype === "init" ? { text: "Agent session started" } : c.subtype === "post_turn_summary" && typeof c.status_detail == "string" ? { text: c.status_detail } : null;
+      return a.subtype === "init" ? { text: "Agent session started" } : a.subtype === "post_turn_summary" && typeof a.status_detail == "string" ? { text: a.status_detail } : null;
     case "rate_limit_event":
       return null;
     case "assistant": {
-      const o = c.message, s = (o == null ? void 0 : o.content) ?? [];
-      for (const u of s) {
-        const y = u;
-        if (y.type === "tool_use")
-          return { text: `Running ${y.name ?? "a tool"}…` };
-        if (y.type === "text" && typeof y.text == "string" && y.text.trim())
-          return { text: y.text.trim() };
+      const i = a.message, r = (i == null ? void 0 : i.content) ?? [];
+      for (const s of r) {
+        const e = s;
+        if (e.type === "tool_use")
+          return { text: `Running ${e.name ?? "a tool"}…` };
+        if (e.type === "text" && typeof e.text == "string" && e.text.trim())
+          return { text: e.text.trim() };
       }
       return null;
     }
     case "user": {
-      const o = c.message, s = o == null ? void 0 : o.content, u = Array.isArray(s) ? s[0] : void 0;
-      return u != null && u.is_error ? { text: `Error: ${typeof u.content == "string" ? u.content : "Tool call failed"}`, error: !0 } : { text: "Tool finished" };
+      const i = a.message, r = i == null ? void 0 : i.content, s = Array.isArray(r) ? r[0] : void 0;
+      return s != null && s.is_error ? { text: `Error: ${typeof s.content == "string" ? s.content : "Tool call failed"}`, error: !0 } : { text: "Tool finished" };
     }
     case "result": {
-      const o = !!c.is_error;
-      return { text: (typeof c.result == "string" ? c.result.trim() : "") || (o ? "Agent run failed" : "Agent run finished"), done: !0, error: o };
+      const i = !!a.is_error;
+      return { text: (typeof a.result == "string" ? a.result.trim() : "") || (i ? "Agent run failed" : "Agent run finished"), done: !0, error: i };
     }
     default:
       return { text: "Agent is working…" };
   }
 }
-function Jt(n) {
-  return ["run", n, "--format", "json"];
+function Ee(t, a) {
+  const i = ["run", t, "--format", "json"];
+  return a != null && a.model && i.push("-m", a.model), a != null && a.effort && i.push("--variant", a.effort), i;
 }
-const vt = {
+const De = {
   bash: "Running command",
   read: "Reading file",
   edit: "Editing file",
@@ -155,1009 +100,2059 @@ const vt = {
   webfetch: "Fetching URL",
   question: "Asking for input"
 };
-function Ht(n) {
-  let c;
+function Oe(t) {
+  let a;
   try {
-    c = JSON.parse(n);
+    a = JSON.parse(t);
   } catch {
     return null;
   }
-  const o = c.type, s = c.part;
-  if (!o || !s) return null;
-  switch (o) {
+  const i = a.type, r = a.part;
+  if (!i || !r) return null;
+  switch (i) {
     case "step_start":
       return null;
     case "text": {
-      const u = s.text;
-      return u != null && u.trim() ? { text: u.trim() } : null;
+      const s = r.text;
+      return s != null && s.trim() ? { text: s.trim() } : null;
     }
     case "tool_use": {
-      const u = s.tool, y = s.state ? s.state.input : void 0, r = y ? y.description : void 0, t = u ? vt[u] : "Running tool", b = typeof r == "string" && r.trim() ? `: ${r.trim()}` : "";
-      return u ? { text: `${t}${b}…` } : null;
+      const s = r.tool, e = r.state ? r.state.input : void 0, n = e ? e.description : void 0, l = s ? De[s] : "Running tool", c = typeof n == "string" && n.trim() ? `: ${n.trim()}` : "";
+      return s ? { text: `${l}${c}…` } : null;
     }
     case "step_finish": {
-      const u = s.reason, y = u === "tool-calls" ? null : u === "stop" ? "Done" : "Step finished";
-      return y ? { text: y } : null;
+      const s = r.reason, e = s === "tool-calls" ? null : s === "stop" ? "Done" : "Step finished";
+      return e ? { text: e } : null;
     }
     default:
       return null;
   }
 }
-const tt = "claude-code", P = {
+const Gt = "claude-code", bt = {
   "claude-code": {
     command: "claude",
-    buildArgs: jt,
-    parseLine: bt
+    buildArgs: Ae,
+    parseLine: Te,
+    options: qt["claude-code"]
   },
   opencode: {
     command: "opencode",
-    buildArgs: Jt,
-    parseLine: Ht
+    buildArgs: Ee,
+    parseLine: Oe,
+    options: qt.opencode
   }
-}, xt = {
+}, Ne = {
   phase: "phase",
   audit: "phase",
+  "batch-audit": "phase",
+  "run-all": "phase",
+  sync: "phase",
+  reconcile: "phase",
   draft: "planDraft",
-  extend: "ideaExtend"
+  extend: "ideaExtend",
+  "commit-suggest": "commitSuggest"
 };
-function kt(n) {
-  const { agentId: c, defaultAgents: o, taskKind: s } = n;
-  if (c && c in P) return { id: c, adapter: P[c] };
-  if (s && o) {
-    const u = xt[s], y = o[u];
-    if (y && y in P) return { id: y, adapter: P[y] };
-  }
-  return { id: tt, adapter: P[tt] };
+function St(t) {
+  const { agentId: a, defaultAgents: i, taskKind: r } = t;
+  if (a && a in bt) return { id: a, adapter: bt[a] };
+  if (r && i) {
+    const s = Ne[r], e = i[s];
+    if (e) {
+      const n = e.agent;
+      if (n in bt)
+        return { id: n, adapter: bt[n], model: e.model, effort: e.effort };
+    }
+  }
+  return { id: Gt, adapter: bt[Gt] };
+}
+function se(t, a) {
+  return t.map((i) => {
+    if (!i.id)
+      return { ...i, status: "planned" };
+    const r = a.filter((e) => e.idea === i.id);
+    if (r.length === 0)
+      return { ...i, status: "planned" };
+    const s = r.every((e) => e.status === "done" || e.status === "dropped");
+    return { ...i, status: s ? "done" : "planned" };
+  });
+}
+function Re(t) {
+  const a = /* @__PURE__ */ new Set();
+  let i = null;
+  function r() {
+    const s = `data: ${JSON.stringify({
+      message: "changed",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    })}
+
+`;
+    for (const e of a)
+      try {
+        e.write(s);
+      } catch {
+        a.delete(e);
+      }
+  }
+  try {
+    Ot($(t, "papercamp"), { recursive: !0 }, () => {
+      i && clearTimeout(i), i = setTimeout(r, 300);
+    });
+  } catch {
+  }
+  return {
+    subscribe(s) {
+      a.add(s);
+      const e = JSON.stringify({
+        message: "Watching for changes…",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      s.write(`data: ${e}
+
+`), s.on("close", () => a.delete(s));
+    }
+  };
 }
-const $t = 50;
-function It(n) {
+const Be = 50, Ht = 30 * 60 * 1e3;
+function Pt(t) {
   try {
-    const c = St(O(n, ".paper-camp", "config.json"), "utf-8"), o = JSON.parse(c);
-    return o.defaultAgents ? o.defaultAgents : o.defaultAgent ? {
-      phase: o.defaultAgent,
-      planDraft: o.defaultAgent,
-      ideaExtend: o.defaultAgent
-    } : X;
+    const a = Pe($(t, "papercamp", "config.json"), "utf-8"), i = JSON.parse(a), r = i.defaultAgents;
+    if (r)
+      return {
+        phase: z(r.phase),
+        planDraft: z(r.planDraft),
+        ideaExtend: z(r.ideaExtend),
+        commitSuggest: z(r.commitSuggest)
+      };
+    if (i.defaultAgent) {
+      const s = i.defaultAgent;
+      return {
+        phase: { agent: s },
+        planDraft: { agent: s },
+        ideaExtend: { agent: s },
+        commitSuggest: { agent: s }
+      };
+    }
+    return _t;
   } catch {
-    return X;
+    return _t;
   }
 }
-function Pt(n, c, o) {
-  return `You're working on phase ${o + 1} ("${c.text}") of the plan "${n.title}" (${n.id ?? "no id"}) in papercamp/plans.md.
+function Wt(t, a, i) {
+  const r = a.description ? `Phase details:
+${a.description}
+
+` : "";
+  return `You are executing exactly one phase of the plan "${t.title}" (${t.id ?? "no id"}): phase ${i + 1}, "${a.text}". The plan is a single file at papercamp/plans/${t.id ?? "<ID>"}.md.
 
-${c.description ?? ""}
+${r}Plan context: ${t.body}
 
-Plan context: ${n.body}
+Do only this phase — do not start any other phase, even if it looks quick.
 
-Do only this phase. When done, check it off in plans.md (- [ ] -> - [x]) and append what you did to progress.md. If this was the last unchecked phase, set the plan's Status to \`review\`, not \`done\`, per this repo's AGENTS.md.`;
+When the work is done:
+1. In the plan file's \`### Phases\` list, change this phase's checkbox from \`- [ ]\` to \`- [x]\`. Do not change any other line.
+2. Add one bullet describing what you did under today's \`## YYYY-MM-DD\` heading at the top of progress.md (create the heading at the top if today's is not there yet — newest day stays first).
+3. If every phase in the list is now checked, set the plan's \`status:\` frontmatter field to \`review\` — never \`done\`; per this repo's AGENTS.md a human promotes plans to done.`;
 }
-function At(n, c = () => {
-}) {
-  const o = /* @__PURE__ */ new Set();
-  let s = null;
-  function u(a) {
-    const g = `data: ${JSON.stringify({ message: a, timestamp: (/* @__PURE__ */ new Date()).toISOString(), type: "agent" })}
+function Ce(t, a = () => {
+}, i, r, s) {
+  const e = /* @__PURE__ */ new Set();
+  let n = null;
+  function l(o) {
+    const k = `data: ${JSON.stringify({ message: o, timestamp: (/* @__PURE__ */ new Date()).toISOString(), type: "agent" })}
 
 `;
-    for (const w of o)
+    for (const v of e)
       try {
-        w.write(g);
+        v.write(k);
       } catch {
-        o.delete(w);
+        e.delete(v);
       }
   }
-  function y(a, g) {
-    a.lines.push(g), a.lines.length > $t && a.lines.shift(), u(g);
+  function c(o, k) {
+    o.lines.push(k), o.lines.length > Be && o.lines.shift(), l(k);
   }
-  function r(a, g) {
-    a.status = g, u(`agent: ${g}`);
+  function d(o, k) {
+    o.status = k, l(`agent: ${k}`);
   }
-  async function t(a) {
-    var g, w;
+  async function u(o) {
+    var k, v;
     try {
-      if (a.taskKind === "extend") {
-        const x = await $(O(n, "papercamp", "ideas.md"), "utf-8"), W = M(x).find((rt) => rt.id === a.ideaId);
-        return !W || a.ideaBodyBaseline === void 0 ? null : W.body !== a.ideaBodyBaseline;
+      if (o.taskKind === "extend") {
+        const x = $(t, "papercamp", "ideas"), { entries: W } = await Ct(x, $(t, "papercamp", "ideas.md")), Q = W.find((b) => b.id === o.ideaId);
+        return !Q || o.ideaBodyBaseline === void 0 ? null : Q.body !== o.ideaBodyBaseline;
       }
-      const T = await $(O(n, "papercamp", "plans.md"), "utf-8"), { entries: j } = k(T);
-      if (a.ideaId !== void 0)
-        return j.some((x) => x.idea === a.ideaId);
-      const v = j.find((x) => x.id === a.planId) ?? j.find((x) => x.title === a.planTitle);
-      return v ? a.phaseIndex !== void 0 ? ((g = v.phases[a.phaseIndex]) == null ? void 0 : g.done) ?? null : a.planBaseline ? v.phases.length > a.planBaseline.phases || (((w = v.log) == null ? void 0 : w.length) ?? 0) > a.planBaseline.log : null : null;
+      if (o.taskKind === "reconcile") {
+        const { entries: x } = await gt(
+          $(t, "papercamp", "plans"),
+          $(t, "papercamp", "plans.md")
+        ), W = x.find((Q) => Q.id === o.planId);
+        return !W || o.reconcileBaseline === void 0 ? null : JSON.stringify({ body: W.body, phases: W.phases.map((Q) => Q.text) }) !== o.reconcileBaseline;
+      }
+      const N = $(t, "papercamp", "plans"), { entries: X } = await gt(N, $(t, "papercamp", "plans.md"));
+      if (o.ideaId !== void 0)
+        return X.some((x) => x.idea === o.ideaId);
+      const G = X.find((x) => x.id === o.planId) ?? X.find((x) => x.title === o.planTitle);
+      return G ? o.phaseIndex !== void 0 ? ((k = G.phases[o.phaseIndex]) == null ? void 0 : k.done) ?? null : o.planBaseline ? G.phases.length > o.planBaseline.phases || (((v = G.log) == null ? void 0 : v.length) ?? 0) > o.planBaseline.log : null : null;
     } catch {
       return null;
     }
   }
-  function b(a, g) {
-    r(a, g ? "error" : "done"), !g && t(a).then((w) => {
-      if (s === a && w === !1) {
-        const T = a.taskKind === "extend" ? `Warning: agent finished but the idea body for ${a.ideaId} did not change — verify manually` : a.ideaId !== void 0 ? `Warning: agent finished but no plan linking idea: ${a.ideaId} appeared in plans.md — verify manually` : a.phaseIndex !== void 0 ? "Warning: agent finished but did not check off this phase in plans.md — verify manually" : "Warning: agent finished but appended nothing to Phases or Log — verify manually";
-        y(a, T);
+  function f(o, k) {
+    d(o, k ? "error" : "done"), !k && u(o).then((v) => {
+      if (n === o && v === !1) {
+        const N = o.taskKind === "extend" ? `Warning: agent finished but the idea body for ${o.ideaId} did not change — verify manually` : o.taskKind === "reconcile" ? "Warning: agent finished but the plan body and phase text did not change — verify manually" : o.ideaId !== void 0 ? `Warning: agent finished but no plan linking idea: ${o.ideaId} appeared in papercamp/plans/ — verify manually` : o.phaseIndex !== void 0 ? "Warning: agent finished but did not check off this phase in the plan file — verify manually" : "Warning: agent finished but appended nothing to Phases or Log — verify manually";
+        c(o, N);
       }
+      n === o && o.taskKind === "audit" && o.planId && v === !0 && (i == null || i(o.planId, 0).catch(() => {
+      }));
     });
   }
-  function C(a) {
-    if (!a.proc.stdout) return;
-    Tt({ input: a.proc.stdout }).on("line", (w) => {
-      if (s !== a || !w.trim()) return;
-      const T = a.adapter.parseLine(w);
-      T && (y(a, T.text), T.done && b(a, !!T.error));
-    }), a.proc.on("close", (w) => {
-      s === a && (a.status === "starting" || a.status === "running" ? b(a, w !== 0) : a.status === "stopping" && r(a, "done"));
-    }), a.proc.on("error", (w) => {
-      s === a && (y(a, `Failed to spawn agent: ${w.message}`), r(a, "error"));
+  function h(o) {
+    if (!o.proc.stdout) return;
+    Tt({ input: o.proc.stdout }).on("line", (v) => {
+      if (n !== o || !v.trim()) return;
+      const N = o.adapter.parseLine(v);
+      N && (c(o, N.text), N.done && f(o, !!N.error));
+    }), o.proc.on("close", (v) => {
+      n === o && (o.status === "starting" || o.status === "running" ? f(o, v !== 0) : o.status === "stopping" && d(o, "done"));
+    }), o.proc.on("error", (v) => {
+      n === o && (c(o, `Failed to spawn agent: ${v.message}`), d(o, "error"));
     });
   }
-  function S(a, g) {
-    return K(a.command, g, {
-      cwd: n,
+  function y(o, k) {
+    return it(o.command, k, {
+      cwd: t,
       stdio: ["ignore", "pipe", "pipe"]
     });
   }
-  function i() {
-    return s !== null && s.status !== "done" && s.status !== "error";
+  function g() {
+    return n !== null && n.status !== "done" && n.status !== "error";
   }
-  function e(a, g, w) {
-    if (i())
+  function E(o, k, v) {
+    if (g())
       return { ok: !1, error: "An agent task is already running" };
-    const T = It(n), { id: j, adapter: v } = kt({
-      agentId: a.agentOverride,
-      defaultAgents: T,
-      taskKind: w.taskKind
-    }), x = S(v, v.buildArgs(g)), R = {
-      planTitle: a.planTitle,
-      planId: a.planId,
+    const N = Pt(t), {
+      id: X,
+      adapter: G,
+      model: x,
+      effort: W
+    } = St({
+      agentId: o.agentOverride,
+      defaultAgents: N,
+      taskKind: v.taskKind
+    }), Q = y(G, G.buildArgs(k, { model: x, effort: W })), b = {
+      planTitle: o.planTitle,
+      planId: o.planId,
       status: "starting",
-      agentId: j,
-      adapter: v,
-      proc: x,
+      agentId: X,
+      adapter: G,
+      proc: Q,
       lines: [],
-      ...w
+      ...v
     };
-    return s = R, C(R), r(R, "running"), { ok: !0 };
+    return n = b, h(b), d(b, "running"), { ok: !0 };
   }
-  function d(a, g) {
-    if (i())
+  function F(o, k) {
+    if (g())
       return { ok: !1, error: "An agent task is already running" };
-    const w = a.phases[g];
-    if (!w)
+    const v = o.phases[k];
+    if (!v)
       return { ok: !1, error: "Phase not found" };
-    c(a);
-    const T = Pt(a, w, g);
-    return e({ planTitle: a.title, planId: a.id, agentOverride: a.agent }, T, {
+    a(o);
+    const N = Wt(o, v, k);
+    return E({ planTitle: o.title, planId: o.id, agentOverride: o.agent }, N, {
       taskKind: "phase",
-      phaseIndex: g
+      phaseIndex: k
     });
   }
-  function f(a, g) {
-    var w;
-    return e({ planTitle: a.title, planId: a.id, agentOverride: a.agent }, g, {
-      taskKind: "audit",
-      planBaseline: { phases: a.phases.length, log: ((w = a.log) == null ? void 0 : w.length) ?? 0 }
+  function D(o, k, v = "audit") {
+    var N;
+    return E({ planTitle: o.title, planId: o.id, agentOverride: o.agent }, k, {
+      taskKind: v,
+      ...v === "reconcile" ? {
+        reconcileBaseline: JSON.stringify({
+          body: o.body,
+          phases: o.phases.map((X) => X.text)
+        })
+      } : { planBaseline: { phases: o.phases.length, log: ((N = o.log) == null ? void 0 : N.length) ?? 0 } }
     });
   }
-  function p(a, g) {
-    return a.id ? e({ planTitle: `Draft plan for ${a.id}` }, g, {
+  function S(o, k) {
+    return o.id ? E({ planTitle: `Draft plan for ${o.id}` }, k, {
       taskKind: "draft",
-      ideaId: a.id
+      ideaId: o.id
     }) : { ok: !1, error: "Idea has no id to link a drafted plan back to" };
   }
-  function l(a, g) {
-    return a.id ? e({ planTitle: `Extend ${a.id}` }, g, {
+  function m(o, k) {
+    return o.id ? E({ planTitle: `Extend ${o.id}` }, k, {
       taskKind: "extend",
-      ideaId: a.id,
-      ideaBodyBaseline: a.body
+      ideaId: o.id,
+      ideaBodyBaseline: o.body
     }) : { ok: !1, error: "Idea has no id to extend" };
   }
-  function m() {
-    if (!s)
+  function w(o) {
+    return E({ planTitle: "Sync to main" }, o, { taskKind: "sync" });
+  }
+  async function I(o, k) {
+    const v = $(o, `${k}.md`);
+    try {
+      return await ht(v), v;
+    } catch {
+    }
+    const N = $(o, "archive", `${k}.md`);
+    try {
+      return await ht(N), N;
+    } catch {
+    }
+    return null;
+  }
+  function T() {
+    if (g())
+      return { ok: !1, error: "An agent task is already running" };
+    const o = Pt(t), {
+      id: k,
+      adapter: v,
+      model: N,
+      effort: X
+    } = St({ defaultAgents: o, taskKind: "audit" }), G = it("sh", ["-c", "exit 0"], {
+      cwd: t,
+      stdio: "ignore"
+    }), x = {
+      taskKind: "batch-audit",
+      planTitle: "Batch audit",
+      status: "starting",
+      agentId: k,
+      adapter: v,
+      proc: G,
+      lines: []
+    };
+    return n = x, d(x, "running"), (async () => {
+      var W, Q;
+      try {
+        const b = $(t, "papercamp", "plans"), { entries: K } = await lt(b), C = K.filter((A) => A.status === "review" || A.status === "done");
+        if (C.length === 0) {
+          n === x && (c(x, 'No plans with status "review" or "done" to audit.'), d(x, "done"));
+          return;
+        }
+        c(x, `Auditing ${C.length} plan(s)…`);
+        let st = 0, Z = 0, tt = 0;
+        for (const A of C) {
+          if (n !== x || x.status === "stopping") break;
+          if (!A.id) {
+            Z++;
+            continue;
+          }
+          const ct = await I(b, A.id);
+          if (!ct) {
+            Z++;
+            continue;
+          }
+          if (A.audited) {
+            const H = await ht(ct).catch(() => null), V = H ? H.mtime.toISOString().slice(0, 10) : null;
+            if (V && A.audited >= V) {
+              c(x, `[skip] ${A.id} — up to date`), Z++;
+              continue;
+            }
+          }
+          c(x, `[audit] ${A.id} ${A.title}`);
+          const U = ie(A), et = it(v.command, v.buildArgs(U, { model: N, effort: X }), {
+            cwd: t,
+            stdio: ["ignore", "pipe", "pipe"]
+          });
+          x.proc = et, et.stdout && Tt({ input: et.stdout }).on("line", (V) => {
+            if (n !== x) return;
+            const L = v.parseLine(V);
+            L != null && L.text && L.text !== "Agent is working…" && c(x, `  ${L.text}`);
+          }), (W = et.stderr) == null || W.on("data", () => {
+          });
+          const $t = await new Promise((H) => {
+            et.on("close", (V) => H(V === 0)), et.on("error", () => H(!1));
+          });
+          if (n !== x) return;
+          if ($t) {
+            let H = 0;
+            try {
+              const V = await at(ct, "utf-8"), nt = ((Q = mt(V).entries[0]) == null ? void 0 : Q.phases.length) ?? A.phases.length;
+              H = Math.max(0, nt - A.phases.length);
+            } catch {
+            }
+            await (i == null ? void 0 : i(A.id, H)), st++, c(
+              x,
+              H > 0 ? `[done] ${A.id} — ${H} gap phase${H === 1 ? "" : "s"} added` : `[done] ${A.id}`
+            );
+          } else
+            tt++, c(x, `[fail] ${A.id} — agent error`);
+        }
+        if (n !== x) return;
+        if (x.status === "stopping") {
+          d(x, "done");
+          return;
+        }
+        c(x, `Audit complete — ${st} audited, ${Z} skipped, ${tt} failed`), d(x, tt > 0 ? "error" : "done");
+      } catch (b) {
+        n === x && (c(x, `Batch audit failed: ${b.message}`), d(x, "error"));
+      }
+    })(), { ok: !0 };
+  }
+  function O(o, k) {
+    if (g())
+      return { ok: !1, error: "An agent task is already running" };
+    const v = o.phases.map((K, C) => ({ phase: K, i: C })).filter(({ phase: K }) => !K.done);
+    if (v.length === 0)
+      return { ok: !1, error: "No unchecked phases to run" };
+    a(o);
+    const N = Pt(t), {
+      id: X,
+      adapter: G,
+      model: x,
+      effort: W
+    } = St({ agentId: o.agent, defaultAgents: N, taskKind: "run-all" }), Q = it("sh", ["-c", "exit 0"], { cwd: t, stdio: "ignore" }), b = {
+      taskKind: "run-all",
+      planTitle: o.title,
+      planId: o.id,
+      status: "starting",
+      agentId: X,
+      adapter: G,
+      proc: Q,
+      lines: []
+    };
+    return n = b, d(b, "running"), (async () => {
+      var K;
+      try {
+        const C = o.phases.length;
+        let st = 0, Z = 0;
+        for (const { phase: tt, i: A } of v) {
+          if (n !== b || b.status === "stopping") break;
+          b.phaseIndex = A, c(b, `[phase ${A + 1}/${C}] ${tt.text}`);
+          const ct = Wt(o, tt, A), U = it(G.command, G.buildArgs(ct, { model: x, effort: W }), {
+            cwd: t,
+            stdio: ["ignore", "pipe", "pipe"]
+          });
+          b.proc = U, U.stdout && Tt({ input: U.stdout }).on("line", (kt) => {
+            if (n !== b) return;
+            const dt = G.parseLine(kt);
+            dt != null && dt.text && dt.text !== "Agent is working…" && c(b, `  ${dt.text}`);
+          }), (K = U.stderr) == null || K.on("data", () => {
+          });
+          let et = !1;
+          const $t = new Promise((nt) => {
+            U.on("close", (kt) => nt(kt === 0)), U.on("error", () => nt(!1));
+          }), H = setTimeout(() => {
+            et = !0, U.killed || U.kill("SIGTERM"), setTimeout(() => {
+              U.exitCode === null && U.signalCode === null && U.kill("SIGKILL");
+            }, 5e3);
+          }, Ht), V = await $t;
+          if (clearTimeout(H), n !== b) return;
+          if (et) {
+            Z++, c(
+              b,
+              `[timeout] phase ${A + 1} — no progress for ${Ht / 6e4}min, stopping`
+            );
+            break;
+          }
+          if (!V) {
+            Z++, c(b, `[fail] phase ${A + 1} — agent error, stopping`);
+            break;
+          }
+          const L = await u(b);
+          if (!L) {
+            Z++, c(
+              b,
+              L === null ? `[fail] phase ${A + 1} — could not read plan after run, stopping` : `[fail] phase ${A + 1} — phase checkbox did not flip, stopping`
+            );
+            break;
+          }
+          if (k) {
+            c(b, `[verify] phase ${A + 1} — running lint/format/test`);
+            const nt = await k();
+            if (n !== b) return;
+            if (!nt) {
+              Z++, c(b, `[fail] phase ${A + 1} — project checks failed, stopping`);
+              break;
+            }
+          }
+          st++, r && (c(b, `[commit] phase ${A + 1} — ${tt.text}`), await r(o, tt, A));
+        }
+        if (n !== b) return;
+        if (b.status === "stopping") {
+          d(b, "done");
+          return;
+        }
+        if (Z > 0)
+          c(b, `Run stopped after ${st} phase(s) completed, 1 failed`), d(b, "error");
+        else {
+          if (c(b, `All ${st} phase(s) completed`), s)
+            try {
+              c(b, "[review] setting plan status to review"), await s(o);
+            } catch (tt) {
+              c(
+                b,
+                `Warning: could not set plan status to review: ${tt.message}`
+              );
+            }
+          d(b, "done");
+        }
+      } catch (C) {
+        n === b && (c(b, `Run all phases failed: ${C.message}`), d(b, "error"));
+      }
+    })(), { ok: !0 };
+  }
+  const M = 6e4, B = 10 * 1024 * 1024;
+  function J(o) {
+    if (g())
+      return Promise.reject(new Error("An agent task is already running"));
+    if (Buffer.byteLength(o, "utf-8") > B)
+      return Promise.reject(new Error("Commit suggestion prompt exceeds the 10MB stdin limit"));
+    const k = Pt(t), {
+      id: v,
+      adapter: N,
+      model: X,
+      effort: G
+    } = St({
+      defaultAgents: k,
+      taskKind: "commit-suggest"
+    }), x = v === "claude-code", W = x ? ["-p", "--output-format", "json"] : ["run", "--format", "json"];
+    return X && W.push(x ? "--model" : "-m", X), G && W.push(x ? "--effort" : "--variant", G), new Promise((Q, b) => {
+      var U, et, $t, H, V;
+      const K = it(N.command, W, {
+        cwd: t,
+        stdio: ["pipe", "pipe", "pipe"]
+      }), C = {
+        taskKind: "commit-suggest",
+        planTitle: "Suggest commit message",
+        status: "starting",
+        agentId: v,
+        adapter: N,
+        proc: K,
+        lines: []
+      };
+      n = C, d(C, "running");
+      let st = !1;
+      const Z = (L) => {
+        st || (st = !0, clearTimeout(tt), L());
+      }, tt = setTimeout(() => {
+        Z(() => {
+          n === C && (c(C, "Commit suggestion timed out"), d(C, "error"), K.killed || K.kill("SIGTERM")), b(new Error("Commit suggestion timed out"));
+        });
+      }, M);
+      (U = K.stdin) == null || U.on("error", () => {
+      }), (et = K.stdin) == null || et.write(o), ($t = K.stdin) == null || $t.end();
+      let A = "", ct = "";
+      (H = K.stdout) == null || H.on("data", (L) => {
+        A += L.toString();
+      }), (V = K.stderr) == null || V.on("data", (L) => {
+        ct += L.toString();
+      }), K.on("close", (L) => {
+        n === C && Z(() => {
+          if (C.status === "stopping") {
+            d(C, "done"), b(new Error("Stopped"));
+            return;
+          }
+          if (L === 0) {
+            d(C, "done");
+            const nt = x ? A : A.split(`
+`).map((kt) => {
+              var dt;
+              try {
+                const pt = JSON.parse(kt);
+                if ((pt == null ? void 0 : pt.type) === "text" && ((dt = pt == null ? void 0 : pt.part) != null && dt.text)) return pt.part.text;
+              } catch {
+              }
+              return null;
+            }).filter(Boolean).join(`
+`);
+            Q(nt);
+          } else {
+            const nt = ct || `${N.command} exited with code ${L}`;
+            c(C, nt), d(C, "error"), b(new Error(nt));
+          }
+        });
+      }), K.on("error", (L) => {
+        n === C && Z(() => {
+          c(C, `Failed to spawn agent: ${L.message}`), d(C, "error"), b(L);
+        });
+      });
+    });
+  }
+  function _() {
+    if (!n)
       return { ok: !1, error: "No agent task running" };
-    const a = s;
-    return r(a, "stopping"), a.proc.killed || a.proc.kill("SIGTERM"), setTimeout(() => {
-      s === a && a.status === "stopping" && a.proc.kill("SIGKILL");
+    const o = n;
+    return d(o, "stopping"), o.proc.killed || o.proc.kill("SIGTERM"), setTimeout(() => {
+      n === o && o.status === "stopping" && o.proc.kill("SIGKILL");
     }, 5e3), { ok: !0 };
   }
-  function h() {
-    return s ? {
-      status: s.status,
-      taskKind: s.taskKind,
-      planTitle: s.planTitle,
-      planId: s.planId,
-      phaseIndex: s.phaseIndex,
-      ideaId: s.ideaId,
-      agentId: s.agentId,
-      lines: [...s.lines]
+  function R() {
+    return n ? {
+      status: n.status,
+      taskKind: n.taskKind,
+      planTitle: n.planTitle,
+      planId: n.planId,
+      phaseIndex: n.phaseIndex,
+      ideaId: n.ideaId,
+      agentId: n.agentId,
+      lines: [...n.lines]
     } : null;
   }
   return {
-    start: d,
-    startForPlan: f,
-    startForIdea: p,
-    startForIdeaExtend: l,
-    stop: m,
-    getStatus: h,
-    subscribe(a) {
-      o.add(a), a.on("close", () => o.delete(a));
+    start: F,
+    startForPlan: D,
+    startForIdea: S,
+    startForIdeaExtend: m,
+    startBatchAudit: T,
+    startRunAllPhases: O,
+    startSync: w,
+    runCommitSuggest: J,
+    stop: _,
+    getStatus: R,
+    subscribe(o) {
+      e.add(o), o.on("close", () => e.delete(o));
     },
     killCurrent() {
-      s != null && s.proc && !s.proc.killed && s.proc.kill();
+      n != null && n.proc && !n.proc.killed && n.proc.kill();
     }
   };
 }
-function Et(n) {
-  const c = /* @__PURE__ */ new Set();
-  function o(p) {
-    const l = `data: ${JSON.stringify(p)}
+async function j(t) {
+  try {
+    return await at(t, "utf-8");
+  } catch (a) {
+    if (a.code === "ENOENT") return "";
+    throw a;
+  }
+}
+async function wt(t) {
+  try {
+    return await ht(t), !0;
+  } catch {
+    return !1;
+  }
+}
+const P = (t, a) => $(t, "papercamp", a);
+function Nt(t, a = {}) {
+  return {
+    id: t.id ?? "",
+    title: t.title,
+    kind: t.kind ?? "feat",
+    status: t.status,
+    idea: t.idea,
+    agent: t.agent,
+    created: t.created,
+    updated: t.updated,
+    audited: t.audited,
+    tags: t.tags,
+    body: t.body,
+    phases: t.phases,
+    log: t.log,
+    clarifications: t.clarifications,
+    ...a
+  };
+}
+async function Rt(t, a) {
+  await q(t, `${xt(a)}
+`, "utf-8");
+}
+async function Dt(t) {
+  const a = P(t, "plans"), i = P(t, "ideas"), [r, s] = await Promise.all([
+    gt(a, P(t, "plans.md")),
+    Ct(i, P(t, "ideas.md"))
+  ]), e = se(s.entries, r.entries);
+  await ut(a, { recursive: !0 }), await ut(i, { recursive: !0 }), await Promise.all([
+    q($(a, "index.md"), Lt(r.entries)),
+    q($(i, "index.md"), Zt(e))
+  ]);
+}
+async function rt(t, a, i) {
+  const r = a.getFeatureBranchPlanId();
+  if (i && r === i || !r) return null;
+  if (await a.getBranchHygieneStatus() === "stale-merged")
+    return "You're on a merged branch — switch to main before starting another plan";
+  const e = P(t, "plans"), { entries: n } = await gt(e, P(t, "plans.md")), l = n.find((c) => c.id === r);
+  return !l || l.status === "done" || l.status === "dropped" ? null : `Finish \`${r}\` — ${l.title} — before starting another plan`;
+}
+function Fe(t, a) {
+  async function i(n) {
+    const l = P(t, "progress.md"), d = `## ${ot()}`, u = await j(l);
+    if (u.startsWith(`${d}
+`))
+      await q(
+        l,
+        `${d}
+- ${n}
+${u.slice(d.length + 1)}`,
+        "utf-8"
+      );
+    else {
+      const f = u.trimEnd(), h = f ? `${d}
+- ${n}
+
+${f}
+` : `${d}
+- ${n}
+`;
+      await q(l, h, "utf-8");
+    }
+  }
+  async function r(n, l) {
+    const c = P(t, "plans"), d = $(c, `${n}.md`), u = $(c, "archive", `${n}.md`), f = await wt(d) ? d : await wt(u) ? u : null;
+    if (!f) return;
+    const h = await j(f);
+    if (!h) return;
+    const y = mt(h);
+    if (y.entries.length === 0) return;
+    const g = y.entries[0];
+    if (await Rt(f, Nt(g, { id: n, audited: ot() })), l > 0) {
+      const E = `gap phase${l === 1 ? "" : "s"}`;
+      await i(
+        `Batch audit of ${n} (${g.title}) — ${l} ${E} appended`
+      );
+    }
+  }
+  async function s(n, l) {
+    var f;
+    const c = ((f = n.tags) == null ? void 0 : f[0]) ?? "plans", d = `${n.kind ?? "feat"}(${c}): ${l.text}`, u = n.id ? `Refs: ${n.id}` : void 0;
+    await a.stageAll(), await a.commit([], d, u);
+  }
+  async function e(n) {
+    var g;
+    if (!n.id) return;
+    const l = P(t, "plans"), c = $(l, `${n.id}.md`), d = await j(c);
+    if (!d) return;
+    const u = mt(d);
+    if (u.entries.length === 0) return;
+    const f = u.entries[0];
+    if (f.status === "review" || f.status === "done" || f.status === "dropped") return;
+    await Rt(
+      c,
+      Nt(f, {
+        id: f.id ?? n.id,
+        status: "review",
+        updated: ot()
+      })
+    );
+    const h = ((g = n.tags) == null ? void 0 : g[0]) ?? "plans", y = n.id ? `Refs: ${n.id}` : void 0;
+    await a.stageAll(), await a.commit([], `${f.kind ?? "feat"}(${h}): mark ${n.id} review`, y);
+  }
+  return { stampAuditDate: r, commitPhase: s, setRunReview: e };
+}
+const Ut = [/(^|\/)\.env(\.|$)/i, /\.(pem|key|p12|crt)$/i], Ft = (t) => `:(literal)${t}`;
+function _e(t, a = {}) {
+  const i = /* @__PURE__ */ new Set();
+  function r(w) {
+    const I = `data: ${JSON.stringify(w)}
 
 `;
-    for (const m of c)
+    for (const T of i)
       try {
-        m.write(l);
+        T.write(I);
       } catch {
-        c.delete(m);
+        i.delete(T);
       }
   }
-  function s(p) {
-    const l = [];
-    for (const m of p.split(`
+  function s(w) {
+    const I = [];
+    for (const T of w.split(`
 `)) {
-      if (!m.trim()) continue;
-      const h = m[0] ?? " ", a = m[1] ?? " ", g = m.slice(3), w = g.split(" -> ").pop() ?? g;
-      l.push({
-        path: w,
-        status: `${h}${a}`,
-        staged: h !== " " && h !== "?"
+      if (!T.trim()) continue;
+      const O = T[0] ?? " ", M = T[1] ?? " ", B = T.slice(3), J = B.split(" -> "), _ = J.pop() ?? B;
+      I.push({
+        path: _,
+        status: `${O}${M}`,
+        staged: O !== " " && O !== "?",
+        renameSource: (O === "R" || O === "C") && J.length > 0 ? J[0] : void 0
       });
     }
-    return l;
+    return I;
   }
-  function u(p) {
-    return new Promise((l, m) => {
-      var w, T;
-      const h = K("git", p, {
-        cwd: n,
+  function e(w) {
+    return new Promise((I, T) => {
+      var J, _;
+      const O = it("git", ["-c", "core.quotepath=off", ...w], {
+        cwd: t,
         stdio: ["ignore", "pipe", "pipe"]
       });
-      let a = "", g = "";
-      (w = h.stdout) == null || w.on("data", (j) => {
-        a += j.toString();
-      }), (T = h.stderr) == null || T.on("data", (j) => {
-        g += j.toString();
-      }), h.on("close", (j) => {
-        j === 0 ? l(a) : m(new Error(g || `git ${p[0]} exited with code ${j}`));
-      }), h.on("error", m);
+      let M = "", B = "";
+      (J = O.stdout) == null || J.on("data", (R) => {
+        M += R.toString();
+      }), (_ = O.stderr) == null || _.on("data", (R) => {
+        B += R.toString();
+      }), O.on("close", (R) => {
+        R === 0 ? I(M) : T(new Error(B || `git ${w[0]} exited with code ${R}`));
+      }), O.on("error", T);
     });
   }
-  function y() {
-    return u(["status", "--porcelain=v1"]).then(s);
+  function n() {
+    return e(["status", "--porcelain=v1"]).then(s);
   }
-  async function r(p, l, m) {
-    p.length > 0 && await u(["add", "--", ...p]);
-    const h = ["commit", "-m", l];
-    m && h.push("-m", m), await u(h);
+  async function l(w, I, T) {
+    let O = /* @__PURE__ */ new Map();
+    if (w.length > 0) {
+      const B = await n(), J = new Map(B.map((R) => [R.path, R.status]));
+      O = new Map(
+        B.filter((R) => !!R.renameSource).map((R) => [R.path, R.renameSource])
+      );
+      const _ = w.filter((R) => {
+        const o = J.get(R);
+        return o === void 0 || o[1] !== " ";
+      });
+      _.length > 0 && await e(["add", "--", ..._.map(Ft)]);
+    }
+    const M = ["commit", "-m", I];
+    if (T && M.push("-m", T), w.length > 0) {
+      const B = w.flatMap((J) => {
+        const _ = O.get(J);
+        return _ ? [J, _] : [J];
+      });
+      M.push("--", ...B.map(Ft));
+    }
+    await e(M);
   }
-  function t(p) {
-    if (!p.kind || !p.id) return;
-    const l = p.kind.toLowerCase(), m = p.id.toLowerCase(), h = p.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, ""), a = `${l}/${m}-${h}`, g = L("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: n });
-    if (g.status !== 0)
+  function c(w) {
+    if (!w.kind || !w.id) return;
+    const I = w.kind.toLowerCase(), T = w.id.toLowerCase(), O = w.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, ""), M = `${I}/${T}-${O}`, B = It("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: t });
+    if (B.status !== 0)
       throw new Error(
-        g.stderr.toString().trim() || "Unable to read current git branch"
+        B.stderr.toString().trim() || "Unable to read current git branch"
       );
-    if (g.stdout.toString().trim() === a) return;
-    const T = L("git", ["checkout", "-b", a, "main"], { cwd: n });
-    if (T.status !== 0) {
-      const j = L("git", ["checkout", a], { cwd: n });
-      if (j.status !== 0)
+    if (B.stdout.toString().trim() === M) return;
+    const _ = It("git", ["checkout", "-b", M, "main"], { cwd: t });
+    if (_.status !== 0) {
+      const R = It("git", ["checkout", M], { cwd: t });
+      if (R.status !== 0)
         throw new Error(
-          j.stderr.toString().trim() || T.stderr.toString().trim() || `Unable to check out ${a}`
+          R.stderr.toString().trim() || _.stderr.toString().trim() || `Unable to check out ${M}`
         );
     }
   }
-  async function b() {
+  async function d() {
     try {
-      await y(), o({
+      await n(), r({
         message: "Working tree status updated",
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
     } catch {
     }
   }
-  const C = O(n, ".git");
-  let S = null;
-  try {
-    G(C, { recursive: !0 }, (p, l) => {
-      l === "index" && (S && clearTimeout(S), S = setTimeout(b, 500));
-    });
-  } catch {
+  if (a.watch !== !1) {
+    const w = $(t, ".git");
+    let I = null;
+    try {
+      Ot(w, { recursive: !0 }, (M, B) => {
+        B === "index" && (I && clearTimeout(I), I = setTimeout(d, 500));
+      });
+    } catch {
+    }
+    const T = $(t, "src");
+    let O = null;
+    try {
+      Ot(T, { recursive: !0 }, () => {
+        O && clearTimeout(O), O = setTimeout(d, 500);
+      });
+    } catch {
+    }
   }
-  const i = O(n, "src");
-  let e = null;
-  try {
-    G(i, { recursive: !0 }, () => {
-      e && clearTimeout(e), e = setTimeout(b, 500);
-    });
-  } catch {
+  async function u() {
+    try {
+      return await e(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]), !0;
+    } catch {
+      return !1;
+    }
   }
-  function d() {
-    return L("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: n }).stdout.toString().trim();
+  async function f() {
+    try {
+      const w = await u() ? ["rev-list", "--count", "@{u}..HEAD"] : ["rev-list", "--count", "HEAD", "--not", "--remotes"], I = await e(w);
+      return Number.parseInt(I.trim(), 10) || 0;
+    } catch {
+      return 0;
+    }
   }
-  function f() {
-    const l = d().match(/^[a-z]+\/([a-z]+-\d+)-/);
-    return l ? l[1].toUpperCase() : null;
+  async function h() {
+    await u() ? await e(["push"]) : await e(["push", "--set-upstream", "origin", y()]);
   }
-  return {
-    async getStatus() {
-      return y();
-    },
-    getCurrentBranch: d,
-    commit: r,
-    ensureBranch: t,
-    getFeatureBranchPlanId: f,
-    subscribe(p) {
-      c.add(p), p.on("close", () => c.delete(p));
+  function y() {
+    return It("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: t }).stdout.toString().trim();
+  }
+  async function g() {
+    const w = y();
+    if (w === "main" || w === "master") return !1;
+    try {
+      return (await e(["branch", "--merged", "main"])).split(`
+`).some((T) => T.trim().replace(/^\*\s+/, "") === w);
+    } catch {
+      return !1;
     }
-  };
-}
-const Dt = {
-  lint: "npx biome lint .",
-  format: "npx biome format .",
-  test: "npx vitest run"
-};
-function Rt(n) {
-  const c = /* @__PURE__ */ new Set(), o = {
-    lint: { status: "stale", lastRun: null, output: "" },
-    format: { status: "stale", lastRun: null, output: "" },
-    test: { status: "stale", lastRun: null, output: "" }
-  }, s = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Set();
-  function y(i) {
-    const e = `data: ${JSON.stringify(i)}
-
-`;
-    for (const d of c)
-      try {
-        d.write(e);
-      } catch {
-        c.delete(d);
-      }
   }
-  function r(i, e, d) {
-    o[i] = { status: e, lastRun: (/* @__PURE__ */ new Date()).toISOString(), output: d }, y({
-      message: `${i}: ${e}`,
-      timestamp: o[i].lastRun
-    }), e !== "running" && u.has(i) && (u.delete(i), t(i));
+  async function E() {
+    const w = y(), T = (await n()).length > 0;
+    return w === "main" || w === "master" ? T ? "dirty" : "clean-on-main" : await g() && await e(["rev-list", "--count", "HEAD..main"]).then((M) => Number.parseInt(M.trim(), 10) || 0).catch(() => 0) > 0 ? "stale-merged" : T ? "dirty" : "fine";
   }
-  function t(i) {
-    var l, m;
-    if (s.has(i)) {
-      u.add(i);
-      return;
+  function F() {
+    const I = y().match(/^[a-z]+\/([a-z]+-\d+)-/);
+    return I ? I[1].toUpperCase() : null;
+  }
+  async function D(w, I = 12e3) {
+    if (w.length === 0) return "";
+    const T = w.find((o) => Ut.some((k) => k.test(o)));
+    if (T)
+      throw new Error(`Refusing to send sensitive file "${T}" to commit suggestion`);
+    const O = await n(), M = new Set(O.filter((o) => o.status === "??").map((o) => o.path)), B = new Map(
+      O.filter((o) => !!o.renameSource).map((o) => [o.path, o.renameSource])
+    ), J = w.filter((o) => {
+      if (M.has(o)) return !1;
+      const k = B.get(o);
+      return !(k && Ut.some((v) => v.test(k)));
+    }), _ = [];
+    if (J.length > 0) {
+      const o = await e([
+        "diff",
+        "HEAD",
+        "--",
+        ...J.map(Ft)
+      ]).catch(() => "");
+      o && _.push(o);
     }
-    s.add(i), r(i, "running", "");
-    const e = Dt[i], d = K(e, {
-      cwd: n,
-      stdio: ["ignore", "pipe", "pipe"],
-      shell: !0
-    });
-    let f = "", p = "";
-    (l = d.stdout) == null || l.on("data", (h) => {
-      f += h.toString();
-    }), (m = d.stderr) == null || m.on("data", (h) => {
-      p += h.toString();
-    }), d.on("close", (h) => {
-      s.delete(i);
-      const a = f + p;
-      h === 0 ? r(i, "pass", a) : r(i, "fail", a);
-    }), d.on("error", (h) => {
-      s.delete(i), r(i, "fail", `Failed to spawn process: ${h.message}`);
-    });
+    for (const o of w.filter((k) => M.has(k))) {
+      const k = $(t, o), v = await ce(k).catch(() => null);
+      if (!v) continue;
+      if (v.isSymbolicLink()) {
+        _.push(`--- /dev/null
++++ b/${o}
+(new file omitted: symlink)`);
+        continue;
+      }
+      if (v.size > I) {
+        _.push(`--- /dev/null
++++ b/${o}
+(new file omitted: exceeds diff size cap)`);
+        continue;
+      }
+      const N = await at(k, "utf-8").catch(() => "");
+      N && _.push(`--- /dev/null
++++ b/${o}
+(new file)
+${N}`);
+    }
+    const R = _.join(`
+
+`);
+    return R.length > I ? `${R.slice(0, I)}
+... (truncated)` : R;
   }
-  function b() {
-    if (s.has("lint") || s.has("format")) return;
-    r("lint", "running", "Applying automatic fixes…"), r("format", "running", "Applying automatic fixes…");
-    const i = K("npx biome check . --write", {
-      cwd: n,
-      stdio: ["ignore", "pipe", "pipe"],
-      shell: !0
-    });
-    i.on("close", () => {
-      t("lint"), t("format");
-    }), i.on("error", (e) => {
-      const d = `Failed to spawn fix process: ${e.message}`;
-      r("lint", "fail", d), r("format", "fail", d);
-    });
+  async function S() {
+    await e(["add", "-A"]);
   }
-  const C = O(n, "src");
-  let S = null;
-  try {
-    G(C, { recursive: !0 }, () => {
-      S && clearTimeout(S), S = setTimeout(() => {
-        t("lint"), t("format");
-      }, 1e3);
-    });
-  } catch {
+  async function m() {
+    await e(["checkout", "main"]), await e(["fetch", "--prune"]), await e(["merge", "--ff-only", "origin/main"]);
   }
   return {
-    getStatus() {
-      return {
-        lint: { ...o.lint },
-        format: { ...o.format },
-        test: { ...o.test }
-      };
+    async getStatus() {
+      return n();
     },
-    runCheck: t,
-    runQualityFix: b,
-    subscribe(i) {
-      c.add(i);
-      for (const e of ["lint", "format", "test"]) {
-        const d = o[e];
-        d.status !== "stale" && i.write(
-          `data: ${JSON.stringify({ message: `${e}: ${d.status}`, timestamp: d.lastRun })}
-
-`
-        );
-      }
-      i.on("close", () => c.delete(i));
+    getCurrentBranch: y,
+    commit: l,
+    stageAll: S,
+    diff: D,
+    ensureBranch: c,
+    getFeatureBranchPlanId: F,
+    getAheadCount: f,
+    push: h,
+    isMergedIntoMain: g,
+    getBranchHygieneStatus: E,
+    runGitSync: m,
+    subscribe(w) {
+      i.add(w), w.on("close", () => i.delete(w));
     }
   };
 }
-async function N(n) {
-  try {
-    return await $(n, "utf-8");
-  } catch (c) {
-    if (c.code === "ENOENT") return "";
-    throw c;
-  }
-}
-async function et(n) {
-  try {
-    return await st(n), !0;
-  } catch {
-    return !1;
-  }
+function p(t, a, i) {
+  t.statusCode = a, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify(i));
 }
-async function H(n) {
-  return new Promise((c, o) => {
-    let s = "";
-    n.on("data", (u) => {
-      s += u;
-    }), n.on("end", () => c(s)), n.on("error", o);
+async function Y(t) {
+  return new Promise((a, i) => {
+    let r = "";
+    t.on("data", (s) => {
+      r += s;
+    }), t.on("end", () => a(r)), t.on("error", i);
   });
 }
-const J = (n, c) => O(n, "papercamp", c), Lt = [
-  "biome.json",
-  "tsconfig.json",
-  "tailwind.config.ts",
-  "vite.config.ts",
-  "vite.app.config.ts",
-  "postcss.config.js",
-  "package.json"
+function vt(t) {
+  return new URL(t.url ?? "", `http://${t.headers.host ?? "localhost"}`);
+}
+async function Me(t, a) {
+  const i = $(P(t, "plans"), `${a}.md`);
+  if (await wt(i)) return i;
+  const r = $(P(t, "plans"), "archive", `${a}.md`);
+  return await wt(r) ? r : null;
+}
+const je = [
+  ["`plans.md`", "`papercamp/plans/`"],
+  ["`ideas.md`", "`papercamp/ideas/`"],
+  [".paper-camp/", "papercamp/"],
+  ["FocusTaskItem", "FocusPhaseItem"],
+  ["TaskItem", "PhaseItem"],
+  ["taskProgress", "phaseProgress"],
+  ["taskPercentage", "phasePercentage"]
 ];
-async function A(n, c, o) {
-  const s = c.getFeatureBranchPlanId();
-  if (!s || o && s === o) return null;
-  const u = await N(J(n, "plans.md"));
-  if (!u) return null;
-  const { entries: y } = k(u), r = y.find((t) => t.id === s);
-  return !r || r.status === "done" || r.status === "dropped" ? null : `Finish \`${s}\` — ${r.title} — before starting another plan`;
+function Le(t) {
+  const a = t.startsWith(`---
+`) ? t.indexOf(`
+---`, 4) + 4 : -1, i = a >= 4 ? t.slice(0, a) : "", s = (a >= 4 ? t.slice(a) : t).split(`
+`);
+  let e = !1, n = !1;
+  for (let l = 0; l < s.length; l++) {
+    const c = s[l];
+    if (/^- \[x\]/.test(c)) {
+      n = !0;
+      continue;
+    }
+    if (n) {
+      if (c.trim() === "" || /^\s+\S/.test(c)) continue;
+      n = !1;
+    }
+    let d = c;
+    for (const [u, f] of je)
+      d.includes(u) && (d = d.split(u).join(f));
+    d !== c && (e = !0, s[l] = d);
+  }
+  return { content: i + s.join(`
+`), changed: e };
 }
-const _t = [
-  {
-    path: "/api/package-name",
-    handler: async (n) => {
-      const c = await N(O(n, "package.json"));
-      if (!c) return null;
-      try {
-        return JSON.parse(c).name ?? null;
-      } catch {
-        return null;
+async function At(t, a) {
+  const { entries: i } = await lt(P(t, "plans")), r = i.find((e) => e.id === a);
+  return r || Vt(await j(P(t, "plans.md"))).entries.find((e) => e.id === a);
+}
+async function Yt(t, a) {
+  const { entries: i } = await te(P(t, "ideas")), r = i.find((e) => e.id === a);
+  return r || ee(await j(P(t, "ideas.md"))).find((e) => e.id === a);
+}
+function qe({ root: t, git: a, status: i, agent: r }) {
+  return [
+    // GET /api/agent/status — current agent task state, if any
+    {
+      method: "GET",
+      path: "/api/agent/status",
+      handle: (s, e) => {
+        p(e, 200, r.getStatus());
       }
-    }
-  },
-  {
-    path: "/api/plans",
-    handler: async (n) => k(await N(J(n, "plans.md")))
-  },
-  {
-    path: "/api/progress",
-    handler: async (n) => ({
-      entries: nt(await N(J(n, "progress.md")))
-    })
-  },
-  {
-    path: "/api/decisions",
-    handler: async (n) => Q(await N(J(n, "decisions.md")))
-  },
-  {
-    path: "/api/open-questions",
-    handler: async (n) => z(await N(J(n, "open-questions.md")))
-  },
-  {
-    path: "/api/ideas",
-    handler: async (n) => ({
-      content: await N(J(n, "ideas.md"))
-    })
-  },
-  {
-    path: "/api/consistency",
-    handler: async (n) => {
-      const [c, o, s] = await Promise.all([
-        N(J(n, "decisions.md")),
-        N(J(n, "open-questions.md")),
-        N(J(n, "plans.md"))
-      ]), u = Q(c), y = z(o), r = k(s);
-      return ft(u.entries, y.entries, r.entries);
-    }
-  },
-  {
-    path: "/api/config",
-    handler: async (n) => {
-      const c = await N(O(n, ".paper-camp", "config.json"));
-      return c ? JSON.parse(c) : null;
-    }
-  },
-  {
-    path: "/api/docs",
-    handler: async (n) => {
-      const c = ["MAIN.md", "README.md", "CHANGELOG.md", "LICENSE"], o = [];
-      for (const s of c) {
-        const u = await N(O(n, s));
-        u && o.push({ name: s, content: u });
-      }
-      return { files: o };
-    }
-  },
-  {
-    path: "/api/configs",
-    handler: async (n) => {
-      const c = [
-        "biome.json",
-        "tsconfig.json",
-        "tailwind.config.ts",
-        "vite.config.ts",
-        "vite.app.config.ts",
-        "postcss.config.js",
-        "package.json"
-      ], o = [];
-      for (const s of c)
-        await N(O(n, s)) && o.push(s);
-      return { files: o };
-    }
-  }
-];
-function Mt(n) {
-  const c = Ot(n), o = Et(n), s = Rt(n), u = At(n, (r) => o.ensureBranch(r)), y = async (r, t, b) => {
-    const C = (r.url ?? "").split("?")[0];
-    if (r.method === "DELETE" && C === "/api/plans") {
-      try {
-        const e = new URL(r.url ?? "", `http://${r.headers.host ?? "localhost"}`).searchParams.get("title");
-        if (!(e != null && e.trim())) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "title is required" }));
+    },
+    // POST /api/agent/launch — start a headless agent on one plan phase
+    {
+      method: "POST",
+      path: "/api/agent/launch",
+      handle: async (s, e) => {
+        const n = await Y(s), { planId: l, phaseIndex: c } = JSON.parse(n);
+        if (!l || typeof c != "number") {
+          p(e, 400, { error: "planId and phaseIndex are required" });
           return;
         }
-        const d = J(n, "plans.md"), f = k(await N(d)), p = e.trim(), l = f.entries.filter((m) => m.title !== p);
-        if (l.length === f.entries.length) {
-          t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "plan not found" }));
+        const d = await At(t, l);
+        if (!d) {
+          p(e, 404, { error: "plan not found" });
           return;
         }
-        await I(d, Z(l)), t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (i) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: i.message }));
-      }
-      return;
-    }
-    if (r.method === "POST" && C === "/api/plans") {
-      try {
-        const i = await H(r), { title: e, content: d, kind: f } = JSON.parse(i);
-        if (!(e != null && e.trim())) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "title is required" }));
+        const u = await rt(t, a, d.id);
+        if (u) {
+          p(e, 409, { error: u });
           return;
         }
-        const p = f && F.includes(f) ? f : "feat", l = O(n, ".paper-camp", "config.json"), m = await at(l, p), h = it({
-          title: e.trim(),
-          status: "idea",
-          kind: p,
-          id: m,
-          created: B(),
-          body: d == null ? void 0 : d.trim()
-        });
-        await ot(J(n, "plans.md"), h), t.statusCode = 201, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0, id: m }));
-      } catch (i) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: i.message }));
-      }
-      return;
-    }
-    if (r.method === "PATCH" && C === "/api/plans") {
-      try {
-        const e = new URL(r.url ?? "", `http://${r.headers.host ?? "localhost"}`).searchParams.get("title");
-        if (!(e != null && e.trim())) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "title is required" }));
+        const f = r.start(d, c);
+        if (!f.ok) {
+          p(e, 409, { error: f.error });
           return;
         }
-        const d = await H(r), f = JSON.parse(d);
-        if (f.agent && !U.includes(f.agent)) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "agent must be a known agent id" }));
+        p(e, 202, { ok: !0 });
+      }
+    },
+    // POST /api/agent/launch-audit — start a headless agent on a plan-scoped convergence audit
+    {
+      method: "POST",
+      path: "/api/agent/launch-audit",
+      handle: async (s, e) => {
+        const n = await Y(s), { planId: l, prompt: c } = JSON.parse(n);
+        if (!l || !c) {
+          p(e, 400, { error: "planId and prompt are required" });
           return;
         }
-        const p = J(n, "plans.md"), l = k(await N(p)), m = e.trim();
-        let h = !1;
-        const a = l.entries.map((g) => g.title === m ? (h = !0, {
-          ...g,
-          ...f.status !== void 0 && { status: f.status },
-          ...f.phases !== void 0 && { phases: f.phases },
-          ...f.log !== void 0 && { log: f.log },
-          ...f.agent !== void 0 && { agent: f.agent ?? void 0 },
-          updated: B()
-        }) : f.status === "in-progress" && g.status === "in-progress" ? { ...g, status: "planned", updated: B() } : g);
-        if (!h) {
-          t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "plan not found" }));
+        const d = await At(t, l);
+        if (!d) {
+          p(e, 404, { error: "plan not found" });
           return;
         }
-        if (f.status === "done") {
-          const g = l.entries.find((T) => T.title === m), w = await A(n, o, g == null ? void 0 : g.id);
-          if (w) {
-            t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: w }));
-            return;
-          }
-        }
-        if (await I(p, Z(a)), f.status === "done") {
-          const g = a.find((w) => w.title === m);
-          if (g)
-            try {
-              o.ensureBranch(g);
-            } catch {
-            }
+        const u = await rt(t, a, d.id);
+        if (u) {
+          p(e, 409, { error: u });
+          return;
         }
-        t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (i) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: i.message }));
-      }
-      return;
-    }
-    if (r.method === "POST" && C === "/api/ideas") {
-      try {
-        const i = await H(r), { title: e, content: d } = JSON.parse(i);
-        if (!(e != null && e.trim())) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "title is required" }));
+        const f = r.startForPlan(d, c);
+        if (!f.ok) {
+          p(e, 409, { error: f.error });
           return;
         }
-        const f = J(n, "ideas.md"), p = await N(f), h = `IDEA-${M(p).reduce((T, j) => {
-          if (j.id) {
-            const v = Number.parseInt(j.id.replace("IDEA-", ""), 10);
-            return Number.isNaN(v) ? T : Math.max(T, v);
-          }
-          return T;
-        }, 0) + 1}`, a = `### ${h}: ${e.trim()}
-
-${(d == null ? void 0 : d.trim()) ?? ""}`, g = p.trimEnd(), w = g.length === 0 ? "" : `
-
----
-
-`;
-        await I(f, `${g}${w}${a}
-`), t.statusCode = 201, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0, id: h }));
-      } catch (i) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: i.message }));
+        p(e, 202, { ok: !0 });
       }
-      return;
-    }
-    if (r.method === "GET" && C === "/api/icon") {
-      const i = O(n, ".paper-camp", "assets"), e = {
-        svg: "image/svg+xml",
-        png: "image/png",
-        jpg: "image/jpeg",
-        jpeg: "image/jpeg",
-        gif: "image/gif",
-        webp: "image/webp"
-      };
-      for (const [d, f] of Object.entries(e))
-        try {
-          const p = await $(O(i, `icon.${d}`));
-          t.statusCode = 200, t.setHeader("Content-Type", f), t.setHeader("Cache-Control", "no-cache"), t.end(p);
+    },
+    // POST /api/agent/launch-reconcile — start a headless agent that reconciles stale prose in a plan
+    {
+      method: "POST",
+      path: "/api/agent/launch-reconcile",
+      handle: async (s, e) => {
+        const n = await Y(s), { planId: l, prompt: c } = JSON.parse(n);
+        if (!l || !c) {
+          p(e, 400, { error: "planId and prompt are required" });
           return;
-        } catch {
         }
-      t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "no icon uploaded" }));
-      return;
-    }
-    if (r.method === "POST" && C === "/api/icon") {
-      try {
-        const i = await H(r), { dataUri: e } = JSON.parse(i);
-        if (!e) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "dataUri is required" }));
+        const d = await At(t, l);
+        if (!d) {
+          p(e, 404, { error: "plan not found" });
           return;
         }
-        const d = e.match(/^data:(image\/[a-z0-9+.-]+);base64,(.+)$/);
-        if (!d) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "invalid data URI" }));
+        const u = await rt(t, a, d.id);
+        if (u) {
+          p(e, 409, { error: u });
           return;
         }
-        const f = d[1], p = f === "image/svg+xml" ? "svg" : f.split("/")[1], l = Buffer.from(d[2], "base64"), m = O(n, ".paper-camp", "assets");
-        await ht(m, { recursive: !0 }), await I(O(m, `icon.${p}`), l), t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (i) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: i.message }));
-      }
-      return;
-    }
-    if (r.method === "GET" && C === "/api/git/status") {
-      try {
-        const i = await o.getStatus(), e = o.getCurrentBranch();
-        t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ branch: e, entries: i }));
-      } catch (i) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: i.message }));
-      }
-      return;
-    }
-    if (r.method === "POST" && C === "/api/git/commit") {
-      try {
-        const i = await H(r), { files: e, title: d, message: f } = JSON.parse(i);
-        if (!(d != null && d.trim())) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "title is required" }));
+        const f = await Me(t, l);
+        if (f) {
+          const y = await at(f, "utf-8"), { content: g, changed: E } = Le(y);
+          E && await q(f, g, "utf-8");
+        }
+        const h = r.startForPlan(d, c, "reconcile");
+        if (!h.ok) {
+          p(e, 409, { error: h.error });
           return;
         }
-        await o.commit(e ?? [], d.trim(), f == null ? void 0 : f.trim()), t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (i) {
-        t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: i.message }));
+        p(e, 202, { ok: !0 });
       }
-      return;
-    }
-    if (r.method === "GET" && C === "/api/status") {
-      t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify(s.getStatus()));
-      return;
-    }
-    if (r.method === "POST" && C === "/api/status/check") {
-      const e = new URL(r.url ?? "", `http://${r.headers.host ?? "localhost"}`).searchParams.get("name");
-      if (e !== "lint" && e !== "format" && e !== "test") {
-        t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "name must be lint, format, or test" }));
-        return;
-      }
-      s.runCheck(e), t.statusCode = 202, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      return;
-    }
-    if (r.method === "POST" && C === "/api/status/fix") {
-      s.runQualityFix(), t.statusCode = 202, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      return;
-    }
-    if (r.method === "GET" && C === "/api/activity/stream") {
-      t.statusCode = 200, t.setHeader("Content-Type", "text/event-stream"), t.setHeader("Cache-Control", "no-cache"), t.setHeader("Connection", "keep-alive"), t.flushHeaders(), c.subscribe(t), o.subscribe(t), s.subscribe(t), u.subscribe(t);
-      return;
-    }
-    if (r.method === "GET" && C === "/api/agent/status") {
-      t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify(u.getStatus()));
-      return;
-    }
-    if (r.method === "POST" && C === "/api/agent/launch") {
-      try {
-        const i = await H(r), { planId: e, phaseIndex: d } = JSON.parse(i);
-        if (!e || typeof d != "number") {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "planId and phaseIndex are required" }));
+    },
+    // POST /api/agent/launch-draft — start a headless agent that drafts a new plan from an idea
+    {
+      method: "POST",
+      path: "/api/agent/launch-draft",
+      handle: async (s, e) => {
+        const n = await Y(s), { ideaId: l, prompt: c } = JSON.parse(n);
+        if (!l || !c) {
+          p(e, 400, { error: "ideaId and prompt are required" });
           return;
         }
-        const p = k(await N(J(n, "plans.md"))).entries.find((h) => h.id === e);
-        if (!p) {
-          t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "plan not found" }));
+        const d = await Yt(t, l);
+        if (!d) {
+          p(e, 404, { error: "idea not found" });
           return;
         }
-        const l = await A(n, o, p.id);
-        if (l) {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: l }));
+        const u = await rt(t, a);
+        if (u) {
+          p(e, 409, { error: u });
           return;
         }
-        const m = await u.start(p, d);
-        if (!m.ok) {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: m.error }));
+        const f = r.startForIdea(d, c);
+        if (!f.ok) {
+          p(e, 409, { error: f.error });
           return;
         }
-        t.statusCode = 202, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (i) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: i.message }));
+        p(e, 202, { ok: !0 });
       }
-      return;
-    }
-    if (r.method === "POST" && C === "/api/agent/launch-audit") {
-      try {
-        const i = await H(r), { planId: e, prompt: d } = JSON.parse(i);
-        if (!e || !d) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "planId and prompt are required" }));
+    },
+    // POST /api/agent/launch-extend — start a headless agent to extend an idea's body
+    {
+      method: "POST",
+      path: "/api/agent/launch-extend",
+      handle: async (s, e) => {
+        const n = await Y(s), { ideaId: l, prompt: c } = JSON.parse(n);
+        if (!l || !c) {
+          p(e, 400, { error: "ideaId and prompt are required" });
           return;
         }
-        const p = k(await N(J(n, "plans.md"))).entries.find((h) => h.id === e);
-        if (!p) {
-          t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "plan not found" }));
+        const d = await Yt(t, l);
+        if (!d) {
+          p(e, 404, { error: "idea not found" });
           return;
         }
-        const l = await A(n, o, p.id);
-        if (l) {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: l }));
+        const u = await rt(t, a);
+        if (u) {
+          p(e, 409, { error: u });
           return;
         }
-        const m = u.startForPlan(p, d);
-        if (!m.ok) {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: m.error }));
+        const f = r.startForIdeaExtend(d, c);
+        if (!f.ok) {
+          p(e, 409, { error: f.error });
           return;
         }
-        t.statusCode = 202, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (i) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: i.message }));
+        p(e, 202, { ok: !0 });
       }
-      return;
-    }
-    if (r.method === "POST" && C === "/api/agent/launch-draft") {
-      try {
-        const i = await H(r), { ideaId: e, prompt: d } = JSON.parse(i);
-        if (!e || !d) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "ideaId and prompt are required" }));
+    },
+    // POST /api/agent/launch-audit-all — start a batch convergence audit across all review/done plans
+    {
+      method: "POST",
+      path: "/api/agent/launch-audit-all",
+      handle: async (s, e) => {
+        const n = await rt(t, a);
+        if (n) {
+          p(e, 409, { error: n });
+          return;
+        }
+        const l = r.startBatchAudit();
+        if (!l.ok) {
+          p(e, 409, { error: l.error });
+          return;
+        }
+        p(e, 202, { ok: !0 });
+      }
+    },
+    // POST /api/agent/launch-run-all — run every unchecked phase sequentially with per-phase commits
+    {
+      method: "POST",
+      path: "/api/agent/launch-run-all",
+      handle: async (s, e) => {
+        const n = await Y(s), { planId: l } = JSON.parse(n);
+        if (!l) {
+          p(e, 400, { error: "planId is required" });
           return;
         }
-        const p = M(await N(J(n, "ideas.md"))).find((h) => h.id === e);
-        if (!p) {
-          t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "idea not found" }));
+        const c = await At(t, l);
+        if (!c) {
+          p(e, 404, { error: "plan not found" });
           return;
         }
-        const l = await A(n, o);
-        if (l) {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: l }));
+        const d = await rt(t, a, c.id);
+        if (d) {
+          p(e, 409, { error: d });
           return;
         }
-        const m = u.startForIdea(p, d);
-        if (!m.ok) {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: m.error }));
+        const u = r.startRunAllPhases(c, () => i.runChecksAndWait());
+        if (!u.ok) {
+          p(e, 409, { error: u.error });
           return;
         }
-        t.statusCode = 202, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (i) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: i.message }));
+        p(e, 202, { ok: !0 });
+      }
+    },
+    // POST /api/agent/stop — kill the running agent task
+    {
+      method: "POST",
+      path: "/api/agent/stop",
+      handle: (s, e) => {
+        const n = r.stop();
+        if (!n.ok) {
+          p(e, 409, { error: n.error });
+          return;
+        }
+        p(e, 202, { ok: !0 });
       }
-      return;
     }
-    if (r.method === "POST" && C === "/api/agent/launch-extend") {
-      try {
-        const i = await H(r), { ideaId: e, prompt: d } = JSON.parse(i);
-        if (!e || !d) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "ideaId and prompt are required" }));
+  ];
+}
+const re = [
+  "biome.json",
+  "tsconfig.json",
+  "tailwind.config.ts",
+  "vite.config.ts",
+  "vite.app.config.ts",
+  "postcss.config.js",
+  "package.json"
+];
+async function oe(t) {
+  const a = [];
+  for (const i of re)
+    await j($(t, i)) && a.push(i);
+  return { files: a };
+}
+function Je({ root: t }) {
+  return [
+    // POST /api/config — update editable fields in papercamp/config.json (port, projectName)
+    {
+      method: "POST",
+      path: "/api/config",
+      handle: async (a, i) => {
+        const r = $(t, "papercamp", "config.json"), s = await j(r);
+        if (!s) {
+          p(i, 404, { error: "config not found" });
           return;
         }
-        const p = M(await N(J(n, "ideas.md"))).find((h) => h.id === e);
-        if (!p) {
-          t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "idea not found" }));
+        const e = await Y(a), n = JSON.parse(e), { port: l, projectName: c, defaultAgent: d } = n, u = n.defaultAgents;
+        if (l !== void 0 && (!Number.isInteger(l) || l <= 0)) {
+          p(i, 400, { error: "port must be a positive integer" });
           return;
         }
-        const l = await A(n, o);
-        if (l) {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: l }));
+        if (c !== void 0 && c.trim().length === 0) {
+          p(i, 400, { error: "projectName must not be empty" });
           return;
         }
-        const m = u.startForIdeaExtend(p, d);
-        if (!m.ok) {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: m.error }));
+        if (d !== void 0 && !Mt.includes(d)) {
+          p(i, 400, { error: "defaultAgent must be a known agent id" });
           return;
         }
-        t.statusCode = 202, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (i) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: i.message }));
+        if (u !== void 0)
+          for (const S of ["phase", "planDraft", "ideaExtend", "commitSuggest"]) {
+            const m = u[S], w = typeof m == "string" ? m : m == null ? void 0 : m.agent;
+            if (!w || !Mt.includes(w)) {
+              p(i, 400, { error: `defaultAgents.${S} must be a known agent id` });
+              return;
+            }
+          }
+        const f = JSON.parse(s), y = (u ? {
+          phase: z(u.phase),
+          planDraft: z(u.planDraft),
+          ideaExtend: z(u.ideaExtend),
+          commitSuggest: z(u.commitSuggest)
+        } : void 0) ?? (d !== void 0 ? {
+          phase: { agent: d },
+          planDraft: { agent: d },
+          ideaExtend: { agent: d },
+          commitSuggest: { agent: d }
+        } : void 0), g = f, { defaultAgent: E, ...F } = g, D = {
+          ...F,
+          ...l !== void 0 && { port: l },
+          ...c !== void 0 && { projectName: c.trim() },
+          ...y && { defaultAgents: y }
+        };
+        await q(r, `${JSON.stringify(D, null, 2)}
+`), p(i, 200, { ok: !0 });
       }
-      return;
-    }
-    if (r.method === "POST" && C === "/api/agent/stop") {
-      const i = u.stop();
-      if (!i.ok) {
-        t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: i.error }));
-        return;
+    },
+    // GET /api/configs — list readable config files, or ?name=... for one file's content
+    {
+      method: "GET",
+      path: "/api/configs",
+      handle: async (a, i) => {
+        const r = vt(a).searchParams.get("name");
+        if (!r) {
+          p(i, 200, await oe(t));
+          return;
+        }
+        if (!re.includes(r)) {
+          p(i, 400, { error: "invalid config file name" });
+          return;
+        }
+        const s = await j($(t, r));
+        if (!s) {
+          p(i, 404, { error: "config file not found" });
+          return;
+        }
+        p(i, 200, { name: r, content: s });
       }
-      t.statusCode = 202, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      return;
     }
-    if (r.method === "POST" && C === "/api/config") {
-      try {
-        const i = O(n, ".paper-camp", "config.json"), e = await N(i);
-        if (!e) {
-          t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "config not found" }));
+  ];
+}
+function Ke({ root: t }) {
+  return [
+    // POST /api/open-questions/resolve?title=... — resolve an open question with a new decision
+    {
+      method: "POST",
+      path: "/api/open-questions/resolve",
+      handle: async (a, i) => {
+        const r = vt(a).searchParams.get("title");
+        if (!(r != null && r.trim())) {
+          p(i, 400, { error: "title is required" });
           return;
         }
-        const d = await H(r), { port: f, projectName: p, defaultAgent: l, defaultAgents: m } = JSON.parse(d);
-        if (f !== void 0 && (!Number.isInteger(f) || f <= 0)) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "port must be a positive integer" }));
+        const s = await Y(a), { decision: e, rationale: n } = JSON.parse(s);
+        if (!(e != null && e.trim())) {
+          p(i, 400, { error: "decision is required" });
           return;
         }
-        if (p !== void 0 && p.trim().length === 0) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "projectName must not be empty" }));
+        const l = P(t, "open-questions.md"), c = await j(l);
+        if (!c) {
+          p(i, 404, { error: "open-questions.md not found" });
           return;
         }
-        if (l !== void 0 && !U.includes(l)) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "defaultAgent must be a known agent id" }));
+        const d = jt(c);
+        if (d.warnings.length > 0) {
+          p(i, 409, {
+            error: "open-questions.md has parse warnings — resolve them before updating to avoid data loss",
+            warnings: d.warnings.map((g) => `${g.title}: ${g.message}`)
+          });
           return;
         }
-        if (m !== void 0) {
-          for (const v of ["phase", "planDraft", "ideaExtend"])
-            if (!U.includes(m[v])) {
-              t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: `defaultAgents.${v} must be a known agent id` }));
-              return;
-            }
+        const u = r.trim(), f = d.entries.find((g) => g.title === u);
+        if (!f) {
+          p(i, 404, { error: `open question "${u}" not found` });
+          return;
         }
-        const h = JSON.parse(e), a = m ?? (l !== void 0 ? { phase: l, planDraft: l, ideaExtend: l } : void 0), g = h, { defaultAgent: w, ...T } = g, j = {
-          ...T,
-          ...f !== void 0 && { port: f },
-          ...p !== void 0 && { projectName: p.trim() },
-          ...a && { defaultAgents: a }
-        };
-        await I(i, JSON.stringify(j, null, 2)), t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (i) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: i.message }));
+        if (f.status !== "open") {
+          p(i, 409, { error: `open question "${u}" is already ${f.status}` });
+          return;
+        }
+        const h = he({
+          title: e.trim(),
+          date: ot(),
+          status: "decided",
+          body: n == null ? void 0 : n.trim()
+        });
+        await me(P(t, "decisions.md"), h), f.status = "resolved", f.resolvedBy = e.trim();
+        const y = ge(d.entries);
+        await q(l, `${y}
+`, "utf-8"), p(i, 200, { ok: !0 });
       }
-      return;
     }
-    if (r.method === "GET" && C === "/api/env") {
-      try {
-        const i = O(n, ".env"), e = O(n, ".env.example"), [d, f] = await Promise.all([
-          et(i),
-          et(e)
-        ]), p = d ? V(await N(i)) : [], l = f ? V(await N(e)).map((a) => a.key) : [], m = new Set(p.map((a) => a.key)), h = l.filter((a) => !m.has(a));
-        t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ exists: d, exampleExists: f, entries: p, missingKeys: h }));
-      } catch (i) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: i.message }));
+  ];
+}
+function Ge({ root: t }) {
+  return [
+    // GET /api/env — read the project root's .env, masked client-side only
+    {
+      method: "GET",
+      path: "/api/env",
+      handle: async (a, i) => {
+        const r = $(t, ".env"), s = $(t, ".env.example"), [e, n] = await Promise.all([
+          wt(r),
+          wt(s)
+        ]), l = e ? Jt(await j(r)) : [], c = n ? Jt(await j(s)).map((f) => f.key) : [], d = new Set(l.map((f) => f.key)), u = c.filter((f) => !d.has(f));
+        p(i, 200, { exists: e, exampleExists: n, entries: l, missingKeys: u });
       }
-      return;
-    }
-    if (r.method === "POST" && C === "/api/env") {
-      try {
-        const i = await H(r), { entries: e } = JSON.parse(i);
-        if (!Array.isArray(e)) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "entries is required" }));
+    },
+    // POST /api/env — write the full desired entry set back to .env
+    {
+      method: "POST",
+      path: "/api/env",
+      handle: async (a, i) => {
+        const r = await Y(a), { entries: s } = JSON.parse(r);
+        if (!Array.isArray(s)) {
+          p(i, 400, { error: "entries is required" });
           return;
         }
-        const d = /* @__PURE__ */ new Set();
-        for (const l of e) {
-          if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(l.key)) {
-            t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: `invalid key: ${l.key}` }));
+        const e = /* @__PURE__ */ new Set();
+        for (const c of s) {
+          if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(c.key)) {
+            p(i, 400, { error: `invalid key: ${c.key}` });
             return;
           }
-          if (d.has(l.key)) {
-            t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: `duplicate key: ${l.key}` }));
+          if (e.has(c.key)) {
+            p(i, 400, { error: `duplicate key: ${c.key}` });
             return;
           }
-          d.add(l.key);
+          e.add(c.key);
         }
-        const f = O(n, ".env"), p = await N(f);
-        await I(f, lt(p, e)), t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (i) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: i.message }));
+        const n = $(t, ".env"), l = await j(n);
+        await q(n, we(l, s)), p(i, 200, { ok: !0 });
       }
-      return;
     }
-    if (r.method === "GET" && C === "/api/configs") {
-      const e = new URL(r.url ?? "", `http://${r.headers.host ?? "localhost"}`).searchParams.get("name");
-      if (e)
+  ];
+}
+const He = (t, a) => {
+  if (t)
+    return t.find((i) => i.status === "in-progress" || i.status === "review");
+};
+function We(t, a) {
+  return `You are writing a single git commit message for the diff below. Do not use any tools, do not read or edit any files — base your answer only on the diff text given.
+
+Follow this repo's commit convention: \`type(scope): Description\`, where type is one of feat|fix|chore|docs|refactor and scope is a subsystem area from this fixed list: core, cli, app, server, agent, plans, ideas, docs, settings, stack, ui, ci, config, deps, repo. Pick the area the diff most affects. Keep the whole title under 100 characters and do not end it with a period.${a ? `
+This work belongs to plan ${a}. Do NOT put the plan id in the scope — instead end the message body with a \`Refs: ${a}\` line as its final line.` : ""}
+
+Respond with ONLY a single JSON object, no prose, no code fences, no markdown — exactly this shape:
+{"title": "type(scope): Description", "message": "${a ? `longer body describing what changed and why, ending with a \`Refs: ${a}\` line` : "optional longer body describing what changed and why, or an empty string if the title alone is clear enough"}"}
+
+Diff:
+${t}`;
+}
+async function Ue(t, a, i) {
+  if (!t.trim())
+    throw new Error("No changes to summarize — select at least one file first");
+  const r = We(t, a), s = await i(r);
+  let e = s;
+  try {
+    const d = JSON.parse(s);
+    typeof d.result == "string" && (e = d.result);
+  } catch {
+  }
+  const n = e.match(/\{[\s\S]*\}/);
+  if (!n) throw new Error("Agent did not return a parseable commit message");
+  const l = JSON.parse(n[0]);
+  if (!l.title) throw new Error("Agent response missing a title");
+  let c = l.message ?? "";
+  return a && !/Refs:\s*\S/.test(c) && (c = c ? `${c}
+
+Refs: ${a}` : `Refs: ${a}`), { title: l.title, message: c };
+}
+const Ye = "Sync the current branch to main by:\n1. Stashing or committing any uncommitted changes (do not use `git reset --hard` or `git clean -fd` without an explicit confirmation step)\n2. Relocating any mis-filed content (e.g., any new plans written to the legacy `papercamp/plans.md` instead of per-file `papercamp/plans/*.md`)\n3. Checking out main: `git checkout main`\n4. Fetching from origin: `git fetch --prune`\n5. Fast-forwarding the merge: `git merge --ff-only origin/main`\n6. Confirming success\n\nReport the final branch and status to verify the sync completed.";
+function ze({ root: t, git: a, agent: i }) {
+  return [
+    // GET /api/git/status — return working tree status
+    {
+      method: "GET",
+      path: "/api/git/status",
+      handle: async (r, s) => {
+        const e = await a.getStatus(), n = a.getCurrentBranch(), l = await a.getAheadCount(), c = await a.getBranchHygieneStatus();
+        p(s, 200, { branch: n, entries: e, ahead: l, branchHygiene: c });
+      }
+    },
+    // POST /api/git/push — push the current branch to its upstream
+    {
+      method: "POST",
+      path: "/api/git/push",
+      handle: async (r, s) => {
         try {
-          if (!Lt.includes(e)) {
-            t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "invalid config file name" }));
+          await a.push(), p(s, 200, { ok: !0 });
+        } catch (e) {
+          p(s, 400, { error: e.message });
+        }
+      }
+    },
+    // POST /api/git/commit — stage files and create a commit
+    {
+      method: "POST",
+      path: "/api/git/commit",
+      handle: async (r, s) => {
+        try {
+          const e = await Y(r), { files: n, title: l, message: c } = JSON.parse(e);
+          if (!(l != null && l.trim())) {
+            p(s, 400, { error: "title is required" });
             return;
           }
-          const d = await N(O(n, e));
-          if (!d) {
-            t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "config file not found" }));
+          await a.commit(n ?? [], l.trim(), c == null ? void 0 : c.trim()), p(s, 200, { ok: !0 });
+        } catch (e) {
+          p(s, 400, { error: e.message });
+        }
+      }
+    },
+    // POST /api/git/sync — sync to main (clean: inline, dirty: agent task)
+    {
+      method: "POST",
+      path: "/api/git/sync",
+      handle: async (r, s) => {
+        const e = await Y(r), { mode: n } = JSON.parse(e);
+        if (n !== "clean" && n !== "dirty") {
+          p(s, 400, { error: "mode must be 'clean' or 'dirty'" });
+          return;
+        }
+        if (n === "clean") {
+          if ((await a.getStatus()).length > 0) {
+            p(s, 409, { error: "Working tree is no longer clean — refresh and retry" });
             return;
           }
-          t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ name: e, content: d }));
+          await a.runGitSync(), p(s, 200, { ok: !0 });
+          return;
+        }
+        const l = i.startSync(Ye);
+        if (!l.ok) {
+          p(s, 409, { error: l.error });
+          return;
+        }
+        p(s, 202, { ok: !0 });
+      }
+    },
+    // POST /api/git/suggest-commit-message — agent-written title/body from the actual diff
+    {
+      method: "POST",
+      path: "/api/git/suggest-commit-message",
+      handle: async (r, s) => {
+        try {
+          const e = await Y(r), { files: n } = JSON.parse(e);
+          if (!(n != null && n.length)) {
+            p(s, 400, { error: "files is required" });
+            return;
+          }
+          const l = await a.diff(n), { entries: c } = await gt(
+            P(t, "plans"),
+            P(t, "plans.md")
+          ), d = He(c), u = await Ue(
+            l,
+            d == null ? void 0 : d.id,
+            i.runCommitSuggest
+          );
+          p(s, 200, u);
+        } catch (e) {
+          p(s, 400, { error: e.message });
+        }
+      }
+    }
+  ];
+}
+const zt = {
+  svg: "image/svg+xml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp"
+};
+function Qe({ root: t }) {
+  return [
+    // GET /api/icon — serve project icon
+    {
+      method: "GET",
+      path: "/api/icon",
+      handle: async (a, i) => {
+        const r = $(t, "papercamp", "assets");
+        for (const [s, e] of Object.entries(zt))
+          try {
+            const n = await at($(r, `icon.${s}`));
+            i.statusCode = 200, i.setHeader("Content-Type", e), i.setHeader("Cache-Control", "no-cache"), i.end(n);
+            return;
+          } catch {
+          }
+        p(i, 404, { error: "no icon uploaded" });
+      }
+    },
+    // POST /api/icon — upload project icon
+    {
+      method: "POST",
+      path: "/api/icon",
+      handle: async (a, i) => {
+        const r = await Y(a), { dataUri: s } = JSON.parse(r);
+        if (!s) {
+          p(i, 400, { error: "dataUri is required" });
+          return;
+        }
+        const e = s.match(/^data:(image\/[a-z0-9+.-]+);base64,(.+)$/);
+        if (!e) {
+          p(i, 400, { error: "invalid data URI" });
+          return;
+        }
+        const n = e[1], l = n === "image/svg+xml" ? "svg" : n.split("/")[1], c = Buffer.from(e[2], "base64"), d = $(t, "papercamp", "assets");
+        await ut(d, { recursive: !0 }), await Promise.all(
+          Object.keys(zt).filter((u) => u !== l).map((u) => Xt($(d, `icon.${u}`)).catch(() => {
+          }))
+        ), await q($(d, `icon.${l}`), c), p(i, 200, { ok: !0 });
+      }
+    }
+  ];
+}
+function Xe({ root: t }) {
+  return [
+    // POST /api/ideas — create a new per-file idea entry
+    {
+      method: "POST",
+      path: "/api/ideas",
+      handle: async (a, i) => {
+        const r = await Y(a), { title: s, content: e } = JSON.parse(r);
+        if (!(s != null && s.trim())) {
+          p(i, 400, { error: "title is required" });
+          return;
+        }
+        const n = P(t, "ideas"), d = `IDEA-${(await Ct(n, P(t, "ideas.md"))).entries.reduce((f, h) => {
+          if (h.id) {
+            const y = Number.parseInt(h.id.replace("IDEA-", ""), 10);
+            return Number.isNaN(y) ? f : Math.max(f, y);
+          }
+          return f;
+        }, 0) + 1}`;
+        await ut(n, { recursive: !0 });
+        const u = ne({
+          id: d,
+          title: s.trim(),
+          body: e == null ? void 0 : e.trim()
+        });
+        await q($(n, `${d}.md`), `${u}
+`, "utf-8"), await Dt(t), p(i, 201, { ok: !0, id: d });
+      }
+    }
+  ];
+}
+function Ze({ root: t, git: a }) {
+  return [
+    // DELETE /api/plans?title=... — remove a plan entry from per-file storage
+    {
+      method: "DELETE",
+      path: "/api/plans",
+      handle: async (i, r) => {
+        const s = vt(i).searchParams.get("title");
+        if (!(s != null && s.trim())) {
+          p(r, 400, { error: "title is required" });
+          return;
+        }
+        const e = P(t, "plans"), n = s.trim(), { entries: l } = await lt(e), c = l.find((u) => u.title === n || u.id === n);
+        if (!(c != null && c.id)) {
+          p(r, 404, { error: "plan not found in per-file storage" });
+          return;
+        }
+        const d = $(e, `${c.id}.md`);
+        if (!await wt(d)) {
+          p(r, 404, { error: "plan file not found" });
+          return;
+        }
+        await Xt(d), await Dt(t), p(r, 200, { ok: !0 });
+      }
+    },
+    // POST /api/plans — create a new per-file plan entry
+    {
+      method: "POST",
+      path: "/api/plans",
+      handle: async (i, r) => {
+        const s = await Y(i), { title: e, content: n, kind: l } = JSON.parse(s);
+        if (!(e != null && e.trim())) {
+          p(r, 400, { error: "title is required" });
+          return;
+        }
+        const c = await rt(t, a);
+        if (c) {
+          p(r, 409, { error: c });
+          return;
+        }
+        const d = l && Et.includes(l) ? l : "feat", u = $(t, "papercamp", "config.json"), f = await ae(u, d);
+        if (!f) {
+          p(r, 500, { error: "could not assign plan ID" });
+          return;
+        }
+        const h = P(t, "plans");
+        await ut(h, { recursive: !0 });
+        const y = xt({
+          id: f,
+          title: e.trim(),
+          kind: d,
+          status: "idea",
+          created: ot(),
+          body: n == null ? void 0 : n.trim()
+        });
+        await q($(h, `${f}.md`), `${y}
+`, "utf-8"), await Dt(t), p(r, 201, { ok: !0, id: f });
+      }
+    },
+    // PATCH /api/plans?title=... — update an existing plan entry
+    {
+      method: "PATCH",
+      path: "/api/plans",
+      handle: async (i, r) => {
+        const s = vt(i).searchParams.get("title");
+        if (!(s != null && s.trim())) {
+          p(r, 400, { error: "title is required" });
+          return;
+        }
+        const e = await Y(i), n = JSON.parse(e);
+        if (n.agent && !Mt.includes(n.agent)) {
+          p(r, 400, { error: "agent must be a known agent id" });
+          return;
+        }
+        const l = P(t, "plans"), { entries: c } = await lt(l), d = s.trim(), u = c.find((E) => E.title === d || E.id === d);
+        if (!(u != null && u.id)) {
+          p(r, 404, { error: "plan not found" });
           return;
-        } catch (d) {
-          t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: d.message }));
+        }
+        const f = $(l, `${u.id}.md`), h = await j(f);
+        if (!h) {
+          p(r, 404, { error: "plan file not found" });
           return;
         }
+        const y = mt(h);
+        if (y.entries.length === 0) {
+          p(r, 500, { error: "failed to parse plan file" });
+          return;
+        }
+        const g = {
+          ...y.entries[0],
+          ...n.body !== void 0 && { body: n.body },
+          ...n.status !== void 0 && { status: n.status },
+          ...n.phases !== void 0 && { phases: n.phases },
+          ...n.log !== void 0 && { log: n.log },
+          ...n.agent !== void 0 && { agent: n.agent ?? void 0 },
+          updated: ot()
+        };
+        if (n.status === "done" || n.status === "dropped") {
+          const E = await rt(t, a, u.id);
+          if (E) {
+            p(r, 409, { error: E });
+            return;
+          }
+        }
+        if (n.status === "in-progress") {
+          const E = await lt(l);
+          for (const F of E.entries)
+            if (F.id !== u.id && F.status === "in-progress") {
+              const D = $(l, `${F.id}.md`), S = await j(D);
+              if (S) {
+                const m = mt(S);
+                m.entries.length > 0 && await Rt(
+                  D,
+                  Nt(m.entries[0], {
+                    id: m.entries[0].id ?? F.id,
+                    status: "planned",
+                    updated: ot()
+                  })
+                );
+              }
+            }
+        }
+        if (await Rt(
+          f,
+          Nt(g, { id: g.id ?? u.id })
+        ), await Dt(t), n.status === "done" || n.status === "dropped") {
+          await ye(t, u.id);
+          try {
+            a.ensureBranch(g);
+          } catch {
+          }
+        }
+        p(r, 200, { ok: !0 });
+      }
+    }
+  ];
+}
+function Ve({ activity: t, agent: a, git: i, status: r }) {
+  return [
+    // GET /api/status — return current lint/format/test check results
+    {
+      method: "GET",
+      path: "/api/status",
+      handle: (s, e) => {
+        p(e, 200, r.getStatus());
+      }
+    },
+    // POST /api/status/check?name=lint|format|test — trigger a one-off check run
+    {
+      method: "POST",
+      path: "/api/status/check",
+      handle: (s, e) => {
+        const n = vt(s).searchParams.get("name");
+        if (n !== "lint" && n !== "format" && n !== "test") {
+          p(e, 400, { error: "name must be lint, format, or test" });
+          return;
+        }
+        r.runCheck(n), p(e, 202, { ok: !0 });
+      }
+    },
+    // POST /api/status/fix — run `biome check . --write` to auto-fix lint/format issues
+    {
+      method: "POST",
+      path: "/api/status/fix",
+      handle: (s, e) => {
+        r.runQualityFix(), p(e, 202, { ok: !0 });
+      }
+    },
+    // GET /api/activity/stream — SSE endpoint for live activity events
+    {
+      method: "GET",
+      path: "/api/activity/stream",
+      handle: (s, e) => {
+        e.statusCode = 200, e.setHeader("Content-Type", "text/event-stream"), e.setHeader("Cache-Control", "no-cache"), e.setHeader("Connection", "keep-alive"), e.flushHeaders(), t.subscribe(e), i.subscribe(e), r.subscribe(e), a.subscribe(e);
+      }
+    }
+  ];
+}
+const tn = [
+  {
+    path: "/api/package-name",
+    handler: async (t) => {
+      const a = await j($(t, "package.json"));
+      if (!a) return null;
+      try {
+        return JSON.parse(a).name ?? null;
+      } catch {
+        return null;
+      }
+    }
+  },
+  {
+    path: "/api/plans",
+    handler: async (t) => gt(P(t, "plans"), P(t, "plans.md"))
+  },
+  {
+    path: "/api/progress",
+    handler: async (t) => ({
+      entries: $e(await j(P(t, "progress.md")))
+    })
+  },
+  {
+    path: "/api/decisions",
+    handler: async (t) => Kt(await j(P(t, "decisions.md")))
+  },
+  {
+    path: "/api/open-questions",
+    handler: async (t) => jt(await j(P(t, "open-questions.md")))
+  },
+  {
+    path: "/api/ideas",
+    handler: async (t) => Ct(P(t, "ideas"), P(t, "ideas.md"))
+  },
+  {
+    path: "/api/consistency",
+    handler: async (t) => {
+      const [a, i, r] = await Promise.all([
+        j(P(t, "decisions.md")),
+        j(P(t, "open-questions.md")),
+        gt(P(t, "plans"), P(t, "plans.md"))
+      ]), s = Kt(a), e = jt(i);
+      return ke(s.entries, e.entries, r.entries);
+    }
+  },
+  {
+    path: "/api/config",
+    handler: async (t) => {
+      const a = await j($(t, "papercamp", "config.json"));
+      if (!a) return null;
+      const i = JSON.parse(a);
+      return i != null && i.defaultAgents && (i.defaultAgents = {
+        phase: z(i.defaultAgents.phase),
+        planDraft: z(i.defaultAgents.planDraft),
+        ideaExtend: z(i.defaultAgents.ideaExtend),
+        commitSuggest: z(i.defaultAgents.commitSuggest)
+      }), i;
+    }
+  },
+  {
+    path: "/api/docs",
+    handler: async (t) => {
+      const a = ["MAIN.md", "README.md", "CHANGELOG.md", "LICENSE"], i = [];
+      for (const r of a) {
+        const s = await j($(t, r));
+        s && i.push({ name: r, content: s });
+      }
+      return { files: i };
+    }
+  },
+  {
+    path: "/api/configs",
+    handler: async (t) => oe(t)
+  }
+];
+function en(t) {
+  return [
+    ...Ze(t),
+    ...Xe(t),
+    ...Qe(t),
+    ...ze(t),
+    ...Ve(t),
+    ...qe(t),
+    ...Je(t),
+    ...Ge(t),
+    ...Ke(t)
+  ];
+}
+const Qt = {
+  lint: "npx biome lint .",
+  format: "npx biome format .",
+  test: "npx vitest run"
+};
+function nn(t) {
+  const a = /* @__PURE__ */ new Set(), i = {
+    lint: { status: "stale", lastRun: null, output: "" },
+    format: { status: "stale", lastRun: null, output: "" },
+    test: { status: "stale", lastRun: null, output: "" }
+  }, r = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set();
+  function e(h) {
+    const y = `data: ${JSON.stringify(h)}
+
+`;
+    for (const g of a)
+      try {
+        g.write(y);
+      } catch {
+        a.delete(g);
+      }
+  }
+  function n(h, y, g) {
+    i[h] = { status: y, lastRun: (/* @__PURE__ */ new Date()).toISOString(), output: g }, e({
+      message: `${h}: ${y}`,
+      timestamp: i[h].lastRun
+    }), y !== "running" && s.has(h) && (s.delete(h), l(h));
+  }
+  function l(h) {
+    var D, S;
+    if (r.has(h)) {
+      s.add(h);
+      return;
+    }
+    r.add(h), n(h, "running", "");
+    const y = Qt[h], g = it(y, {
+      cwd: t,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: !0
+    });
+    let E = "", F = "";
+    (D = g.stdout) == null || D.on("data", (m) => {
+      E += m.toString();
+    }), (S = g.stderr) == null || S.on("data", (m) => {
+      F += m.toString();
+    }), g.on("close", (m) => {
+      r.delete(h);
+      const w = E + F;
+      m === 0 ? n(h, "pass", w) : n(h, "fail", w);
+    }), g.on("error", (m) => {
+      r.delete(h), n(h, "fail", `Failed to spawn process: ${m.message}`);
+    });
+  }
+  function c() {
+    if (r.has("lint") || r.has("format")) return;
+    n("lint", "running", "Applying automatic fixes…"), n("format", "running", "Applying automatic fixes…");
+    const h = it("npx biome check . --write", {
+      cwd: t,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: !0
+    });
+    h.on("close", () => {
+      l("lint"), l("format");
+    }), h.on("error", (y) => {
+      const g = `Failed to spawn fix process: ${y.message}`;
+      n("lint", "fail", g), n("format", "fail", g);
+    });
+  }
+  const d = $(t, "src");
+  let u = null;
+  try {
+    Ot(d, { recursive: !0 }, () => {
+      u && clearTimeout(u), u = setTimeout(() => {
+        l("lint"), l("format");
+      }, 1e3);
+    });
+  } catch {
+  }
+  function f() {
+    return new Promise((h) => {
+      const y = ["lint", "format", "test"], g = { lint: null, format: null, test: null };
+      let E = y.length;
+      function F(D, S) {
+        g[D] = S, E--, E === 0 && h(y.every((m) => g[m] === !0));
+      }
+      for (const D of y) {
+        const S = it(Qt[D], { cwd: t, stdio: "ignore", shell: !0 });
+        S.on("close", (m) => F(D, m === 0)), S.on("error", () => F(D, !1));
+      }
+    });
+  }
+  return {
+    getStatus() {
+      return {
+        lint: { ...i.lint },
+        format: { ...i.format },
+        test: { ...i.test }
+      };
+    },
+    runCheck: l,
+    runChecksAndWait: f,
+    runQualityFix: c,
+    subscribe(h) {
+      a.add(h);
+      for (const y of ["lint", "format", "test"]) {
+        const g = i[y];
+        g.status !== "stale" && h.write(
+          `data: ${JSON.stringify({ message: `${y}: ${g.status}`, timestamp: g.lastRun })}
+
+`
+        );
+      }
+      h.on("close", () => a.delete(h));
     }
-    const S = _t.find((i) => i.path === C);
-    if (!S) {
-      b();
+  };
+}
+function an(t) {
+  const a = Re(t), i = _e(t), r = nn(t), s = Fe(t, i), e = Ce(
+    t,
+    (c) => i.ensureBranch(c),
+    s.stampAuditDate,
+    s.commitPhase,
+    s.setRunReview
+  ), n = en({ root: t, activity: a, agent: e, git: i, status: r }), l = async (c, d, u) => {
+    const f = (c.url ?? "").split("?")[0], h = n.find((g) => g.method === c.method && g.path === f);
+    if (h) {
+      try {
+        await h.handle(c, d);
+      } catch (g) {
+        p(d, 500, { error: g.message });
+      }
+      return;
+    }
+    const y = tn.find((g) => g.path === f);
+    if (!y) {
+      u();
       return;
     }
     try {
-      const i = await S.handler(n);
-      t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify(i));
-    } catch (i) {
-      t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: i.message }));
+      p(d, 200, await y.handler(t));
+    } catch (g) {
+      p(d, 500, { error: g.message });
     }
   };
-  return y.agent = u, y;
+  return l.agent = e, l;
 }
-const Bt = {
+const sn = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
   ".mjs": "text/javascript; charset=utf-8",
@@ -1170,81 +2165,304 @@ const Bt = {
   ".woff": "font/woff",
   ".woff2": "font/woff2"
 };
-function Ft() {
-  return O(ct(wt(import.meta.url)), "..", "app");
+function rn() {
+  return $(de(Ie(import.meta.url)), "..", "app");
 }
-async function Gt({ root: n, port: c }) {
-  const o = Ft(), s = O(o, "index.html"), u = await $(s, "utf-8").catch(() => null);
-  if (u === null)
+async function on({ root: t, port: a }) {
+  const i = rn(), r = $(i, "index.html"), s = await at(r, "utf-8").catch(() => null);
+  if (s === null)
     throw new Error(
-      `Dashboard assets not found at ${o}. Run \`pnpm build\` (or reinstall the package) so dist/app exists.`
+      `Dashboard assets not found at ${i}. Run \`pnpm build\` (or reinstall the package) so dist/app exists.`
     );
-  const y = Mt(n);
-  async function r(C, S) {
-    const i = decodeURIComponent((C.url ?? "/").split("?")[0]), e = O(o, i === "/" ? "index.html" : i);
+  const e = an(t);
+  async function n(d, u) {
+    const f = decodeURIComponent((d.url ?? "/").split("?")[0]), h = $(i, f === "/" ? "index.html" : f), y = h !== i && !h.startsWith(i + le);
     try {
-      if ((await st(e)).isFile()) {
-        S.statusCode = 200, S.setHeader("Content-Type", Bt[dt(e)] ?? "application/octet-stream"), S.end(await $(e));
+      const g = y ? null : await ht(h);
+      if (g != null && g.isFile()) {
+        u.statusCode = 200, u.setHeader("Content-Type", sn[ue(h)] ?? "application/octet-stream"), u.end(await at(h));
         return;
       }
     } catch {
     }
-    S.statusCode = 200, S.setHeader("Content-Type", "text/html; charset=utf-8"), S.end(u);
+    u.statusCode = 200, u.setHeader("Content-Type", "text/html; charset=utf-8"), u.end(s);
   }
-  const t = Ct((C, S) => {
-    y(C, S, () => {
-      r(C, S).catch((i) => {
-        S.statusCode = 500, S.end(String(i));
+  const l = xe((d, u) => {
+    e(d, u, () => {
+      n(d, u).catch((f) => {
+        u.statusCode = 500, u.end(String(f));
       });
     });
-  }), b = () => {
-    y.agent.killCurrent(), process.exit(0);
+  }), c = () => {
+    e.agent.killCurrent(), process.exit(0);
+  };
+  process.on("SIGINT", c), process.on("SIGTERM", c), await new Promise((d, u) => {
+    l.once("error", u), l.listen(a, d);
+  });
+}
+async function Bt(t) {
+  try {
+    return await ht(t), !0;
+  } catch {
+    return !1;
+  }
+}
+async function cn(t, a) {
+  const i = $(t, `${a}.md`);
+  if (await Bt(i)) return i;
+  const r = $(t, "archive", `${a}.md`);
+  return await Bt(r) ? r : null;
+}
+async function dn(t) {
+  try {
+    return (await ht(t)).mtime.toISOString().slice(0, 10);
+  } catch {
+    return null;
+  }
+}
+async function ln(t, a) {
+  const i = await at(t, "utf-8"), s = mt(i).entries[0];
+  if (!s)
+    throw new Error(`Could not parse plan file after audit: ${t}`);
+  const e = {
+    id: a,
+    title: s.title,
+    kind: s.kind ?? "feat",
+    status: s.status,
+    idea: s.idea,
+    agent: s.agent,
+    created: s.created,
+    updated: s.updated,
+    audited: ot(),
+    tags: s.tags,
+    body: s.body,
+    phases: s.phases,
+    log: s.log,
+    clarifications: s.clarifications
   };
-  process.on("SIGINT", b), process.on("SIGTERM", b), await new Promise((C) => t.listen(c, C));
+  await q(t, `${xt(e)}
+`, "utf-8");
 }
-const D = new ut();
-D.name("paper-camp").description("Local-first, AI-native project companion.").version(gt);
-D.command("init [project-name]").description("Initialize Paper Camp in the current directory").option("-i, --intent <text>", "one-line description of what you are building").action(async (n, c) => {
-  const o = process.cwd(), s = n ?? pt(o);
+async function un(t, a, i, r) {
+  var n;
+  const s = ie(a), e = it(i.command, i.buildArgs(s, r), {
+    cwd: t,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return e.stdout && Tt({ input: e.stdout }).on("line", (c) => {
+    const d = i.parseLine(c);
+    d != null && d.text && d.text !== "Agent is working…" && process.stdout.write(`    ${d.text}
+`);
+  }), (n = e.stderr) == null || n.on("data", (l) => process.stderr.write(l)), new Promise((l) => {
+    e.on("close", (c) => l(c === 0)), e.on("error", () => l(!1));
+  });
+}
+const yt = new fe();
+yt.name("paper-camp").description("Local-first, AI-native project companion.").version(be);
+yt.command("init [project-name]").description("Initialize Paper Camp in the current directory").option("-i, --intent <text>", "one-line description of what you are building").action(async (t, a) => {
+  const i = process.cwd(), r = t ?? pe(i);
   try {
-    await mt(o, { projectName: s, intent: c.intent }), console.log(`Initialized Paper Camp in ${o}`), console.log("  .paper-camp/config.json"), console.log("  papercamp/ideas.md, plans.md, progress.md, decisions.md, open-questions.md");
-  } catch (u) {
-    if (u instanceof yt) {
-      console.error(u.message), process.exitCode = 1;
+    await Se(i, { projectName: r, intent: a.intent }), console.log(`Initialized Paper Camp in ${i}`), console.log("  papercamp/config.json"), console.log("  papercamp/plans/          (per-file plan entries)"), console.log("  papercamp/plans/index.md"), console.log("  papercamp/plans/archive/"), console.log("  papercamp/ideas/          (per-file idea entries)"), console.log("  papercamp/ideas/index.md"), console.log("  papercamp/progress.md, decisions.md, open-questions.md");
+  } catch (s) {
+    if (s instanceof ve) {
+      console.error(s.message), process.exitCode = 1;
       return;
     }
-    throw u;
+    throw s;
   }
 });
-D.command("dev").description("Start the local dashboard").option("-p, --port <number>", "port to listen on", "3333").action(async (n) => {
-  const c = Number(n.port), o = process.cwd();
+yt.command("dev").description("Start the local dashboard").option("-p, --port <number>", "port to listen on", "3333").action(async (t) => {
+  const a = Number(t.port), i = process.cwd();
   try {
-    await Gt({ root: o, port: c }), console.log(`Paper Camp dashboard running at http://localhost:${c}`);
-  } catch (s) {
-    console.error(s.message), process.exitCode = 1;
+    await on({ root: i, port: a }), console.log(`Paper Camp dashboard running at http://localhost:${a}`);
+  } catch (r) {
+    console.error(r.message), process.exit(1);
   }
 });
-D.command("add <type> [name]").description("Add a new entry (currently supports: plan)").option("-k, --kind <kind>", `plan kind (${F.join("|")})`, "feat").action(async (n, c, o) => {
-  if (n !== "plan") {
-    console.error(`Unknown type "${n}". Supported types: plan`), process.exitCode = 1;
+yt.command("add <type> [name]").description("Add a new entry (currently supports: plan)").option("-k, --kind <kind>", `plan kind (${Et.join("|")})`, "feat").action(async (t, a, i) => {
+  if (t !== "plan") {
+    console.error(`Unknown type "${t}". Supported types: plan`), process.exitCode = 1;
     return;
   }
-  if (!c) {
+  if (!a) {
     console.error("Usage: paper-camp add plan <name> [--kind feat|fix|chore|docs|refactor]"), process.exitCode = 1;
     return;
   }
-  if (!F.includes(o.kind)) {
-    console.error(`Unknown kind "${o.kind}". Supported kinds: ${F.join(", ")}`), process.exitCode = 1;
+  if (!Et.includes(i.kind)) {
+    console.error(`Unknown kind "${i.kind}". Supported kinds: ${Et.join(", ")}`), process.exitCode = 1;
     return;
   }
-  const s = o.kind, u = Y(process.cwd(), ".paper-camp", "config.json"), y = await at(u, s), r = Y(process.cwd(), "papercamp", "plans.md"), t = it({
-    title: c,
+  const r = i.kind, s = process.cwd(), e = ft(s, "papercamp", "config.json"), n = await ae(e, r);
+  if (!n) {
+    console.error("Could not assign plan ID — is the project initialized?"), process.exitCode = 1;
+    return;
+  }
+  const l = ft(s, "papercamp", "plans");
+  await ut(l, { recursive: !0 });
+  const c = xt({
+    id: n,
+    title: a,
+    kind: r,
     status: "idea",
-    kind: s,
-    id: y,
-    created: B()
+    created: ot()
   });
-  await ot(r, t), console.log(`Added plan "${c}"${y ? ` (${y})` : ""} to papercamp/plans.md`);
+  await q($(l, `${n}.md`), `${c}
+`, "utf-8");
+  const { entries: d } = await lt(l);
+  await q($(l, "index.md"), Lt(d), "utf-8"), console.log(`Added plan "${a}" (${n}) to papercamp/plans/${n}.md`);
+});
+yt.command("migrate").description(
+  "One-time migration: split monolithic plans.md/ideas.md into per-file YAML frontmatter entries"
+).action(async () => {
+  const t = process.cwd(), a = ft(t, "papercamp", "plans"), i = $(a, "archive"), r = ft(t, "papercamp", "ideas");
+  await ut(i, { recursive: !0 }), await ut(r, { recursive: !0 });
+  const s = ft(t, "papercamp", "plans.md"), e = ft(t, "papercamp", "ideas.md");
+  let n = 0, l = 0, c = 0;
+  const d = await at(s, "utf-8").catch(() => "");
+  if (d.trim()) {
+    const { entries: F, warnings: D } = Vt(d);
+    c = D.length;
+    for (const S of D)
+      console.warn(`  warning: ${S.title}: ${S.message}`);
+    for (const S of F) {
+      if (!S.id) {
+        console.warn(`  skipping plan "${S.title}" — no Id assigned, cannot migrate`), l++;
+        continue;
+      }
+      const m = S.status === "done" || S.status === "dropped" ? i : a, w = $(m, `${S.id}.md`);
+      if (await Bt(w)) {
+        l++;
+        continue;
+      }
+      const I = xt({
+        id: S.id,
+        title: S.title,
+        kind: S.kind ?? "feat",
+        status: S.status,
+        idea: S.idea,
+        agent: S.agent,
+        created: S.created,
+        updated: S.updated,
+        tags: S.tags,
+        body: S.body,
+        phases: S.phases,
+        log: S.log,
+        clarifications: S.clarifications
+      });
+      await q(w, `${I}
+`, "utf-8"), n++;
+    }
+  }
+  let u = 0, f = 0;
+  const h = await at(e, "utf-8").catch(() => "");
+  if (h.trim()) {
+    const F = ee(h);
+    for (const D of F) {
+      if (!D.id) {
+        console.warn(`  skipping idea "${D.title}" — no Id assigned, cannot migrate`), f++;
+        continue;
+      }
+      const S = $(r, `${D.id}.md`);
+      if (await Bt(S)) {
+        f++;
+        continue;
+      }
+      const m = D.body.replace(/^#{1,3}\s+.+(?:\r?\n)?/, "").trim(), w = ne({ id: D.id, title: D.title, body: m });
+      await q(S, `${w}
+`, "utf-8"), u++;
+    }
+  }
+  const { entries: y } = await lt(a);
+  await q($(a, "index.md"), Lt(y), "utf-8");
+  const { entries: g } = await te(r), E = se(g, y);
+  await q($(r, "index.md"), Zt(E), "utf-8"), n > 0 && l === 0 && c === 0 && await q(s, "", "utf-8"), u > 0 && f === 0 && await q(e, "", "utf-8"), console.log(
+    `Migrated ${n} plans (${l} skipped), ${u} ideas (${f} skipped).`
+  );
+});
+yt.command("audit").description("Audit all review/done plans for missing phases").action(async () => {
+  var S;
+  const t = process.cwd(), a = ft(t, "papercamp", "plans"), { entries: i, warnings: r } = await lt(a);
+  for (const m of r)
+    console.warn(`  warning: ${m.title}: ${m.message}`);
+  const s = i.filter((m) => m.status === "review" || m.status === "done");
+  if (s.length === 0) {
+    console.log('No plans with status "review" or "done" found.');
+    return;
+  }
+  const e = await at($(t, "papercamp", "config.json"), "utf-8").catch(
+    () => "{}"
+  );
+  let n;
+  try {
+    n = JSON.parse(e);
+  } catch {
+    console.error("Invalid papercamp/config.json"), process.exitCode = 1;
+    return;
+  }
+  const l = n.defaultAgents, c = l ? {
+    phase: z(l.phase),
+    planDraft: z(l.planDraft),
+    ideaExtend: z(l.ideaExtend),
+    commitSuggest: z(l.commitSuggest)
+  } : _t, { adapter: d, model: u, effort: f } = St({ defaultAgents: c, taskKind: "audit" });
+  console.log(`Auditing ${s.length} plan(s):
+`);
+  const h = [];
+  for (const m of s) {
+    const w = m.id ?? "(no id)", I = w.padEnd(14);
+    if (!m.id) {
+      console.log(`  [skip]  ${I} ${m.title} — no id`), h.push({ id: w, title: m.title, status: "skipped", skipReason: "no id" });
+      continue;
+    }
+    const T = await cn(a, m.id);
+    if (!T) {
+      console.log(`  [skip]  ${I} ${m.title} — file not found`), h.push({ id: w, title: m.title, status: "skipped", skipReason: "file not found" });
+      continue;
+    }
+    if (m.audited) {
+      const B = await dn(T);
+      if (B && m.audited >= B) {
+        console.log(
+          `  [skip]  ${I} ${m.title} — audited ${m.audited}, unchanged since`
+        ), h.push({
+          id: w,
+          title: m.title,
+          status: "skipped",
+          skipReason: `audited ${m.audited}, unchanged`
+        });
+        continue;
+      }
+    }
+    const O = m.phases.length;
+    if (console.log(`  [audit] ${I} ${m.title}`), await un(t, m, d, { model: u, effort: f })) {
+      try {
+        await ln(T, m.id);
+      } catch (o) {
+        console.log(`  [fail]  ${I} ${m.title} — ${o.message}`), process.exitCode = 1, h.push({ id: w, title: m.title, status: "failed" });
+        continue;
+      }
+      const B = await at(T, "utf-8").catch(() => ""), _ = ((S = mt(B).entries[0]) == null ? void 0 : S.phases.length) ?? O, R = Math.max(0, _ - O);
+      console.log(`  [done]  ${I} ${m.title}`), h.push({ id: w, title: m.title, status: "audited", gapPhases: R });
+    } else
+      console.log(`  [fail]  ${I} ${m.title} — agent exited with error`), process.exitCode = 1, h.push({ id: w, title: m.title, status: "failed" });
+  }
+  const y = h.filter((m) => m.status === "audited"), g = h.filter((m) => m.status === "skipped"), E = h.filter((m) => m.status === "failed"), F = y.reduce((m, w) => m + (w.gapPhases ?? 0), 0), D = "─".repeat(43);
+  if (console.log(`
+${D}`), console.log("Audit summary"), console.log(
+    `  Audited : ${y.length}   Skipped : ${g.length}   Failed : ${E.length}`
+  ), y.length > 0)
+    if (F > 0) {
+      console.log(`  Gap phases appended: ${F} total`);
+      for (const m of y.filter((w) => (w.gapPhases ?? 0) > 0))
+        console.log(`    ${m.id.padEnd(14)} +${m.gapPhases} phase(s)`);
+    } else
+      console.log("  No gap phases appended — all audited plans are complete.");
+  if (g.length > 0) {
+    console.log("  Skipped:");
+    for (const m of g)
+      console.log(`    ${m.id.padEnd(14)} ${m.skipReason}`);
+  }
+  console.log(D);
 });
-D.parseAsync(process.argv);
+yt.parseAsync(process.argv);
 //# sourceMappingURL=index.js.map