@dendelion/paper-camp 0.3.0 → 0.4.0

package/dist/cli/index.js

@@ -1,90 +1,95 @@
 #!/usr/bin/env node
-import { spawn as V, spawnSync as ht } from "node:child_process";
-import { stat as it, readFile as U, lstat as Ut, unlink as Wt, mkdir as q, writeFile as E } from "node:fs/promises";
-import { join as N, dirname as zt, extname as Yt, basename as Qt, resolve as nt } from "node:path";
-import { createInterface as jt } from "node:readline";
-import { Command as Xt } from "commander";
-import { AGENT_OPTIONS as Pt, coerceAgentConfig as B, DEFAULT_AGENTS as kt, PLAN_KINDS as wt, AGENT_IDS as Ot } from "../types/index.js";
-import { K as Q, D as dt, L as Tt, M as ct, e as Bt, o as at, O as Z, d as Zt, j as Ft, E as vt, J as xt, B as Jt, x as Et, c as Vt, C as It, i as qt, b as te, m as ee, q as Ht, k as _t, F as ne, w as Dt, h as ae, P as ie, t as se, A as oe } from "../chunks/serializer.DL7H4ZTd.js";
-import { createServer as re } from "node:http";
-import { fileURLToPath as de } from "node:url";
-import { watch as Ct, readFileSync as ce } from "node:fs";
-function Mt(e) {
-  const i = e.phases.map((n, h) => `${h + 1}. [${n.done ? "x" : " "}] ${n.text}`).join(`
-`), a = e.log && e.log.length > 0 ? e.log.map((n) => `- ${n.date}: ${n.text}`).join(`
-`) : "(none)", p = e.clarifications && e.clarifications.length > 0 ? e.clarifications.map((n) => `- ${n.date}: ${n.text}`).join(`
+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";
+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're auditing the plan "${e.title}" (${e.id ?? "no id"}), stored as a single file at papercamp/plans/${e.id ?? "<ID>"}.md (or papercamp/plans/archive/${e.id ?? "<ID>"}.md if it's already done/dropped — check both). Edit only that file.
+  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.
 
-Plan body: ${e.body}
+Plan body: ${t.body}
 
 Current phases:
-${i}
-
-Log entries (issues, bugs, and review notes documented so far):
 ${a}
 
-Clarifications (answered questions about scope and design):
-${p}
+Log entries (issues, bugs, and review notes recorded so far):
+${i}
 
-Read this plan's phases, body, Log entries, and Clarifications, then inspect the current repo state. The Log entries often document bugs, UX issues, or missing functionality that should be turned into new phases. Append any phase that's clearly required but missing as a normal \`- [ ]\` line at the end of the \`### Phases\` list — optionally with the existing indented description format. Explicitly never touch existing lines: never reorder, check, uncheck, or rewrite anything already there, no matter how stale or redundant it looks.
+Clarifications (answered scope/design questions):
+${r}
 
-If you append anything, finish with exactly one new \`### Log\` line (date: summary) describing what was found and appended.
+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.
 
-If nothing is missing, write nothing at all — not even an empty heading or a Log line. The audit must be safe to re-run anytime without producing log spam.`;
+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 pe(e, i) {
-  const a = [
+function Ae(t, a) {
+  const i = [
     "-p",
-    e,
+    t,
     "--output-format",
     "stream-json",
     "--verbose",
     "--permission-mode",
     "auto"
   ];
-  return i != null && i.model && a.push("--model", i.model), i != null && i.effort && a.push("--effort", i.effort), a;
+  return a != null && a.model && i.push("--model", a.model), a != null && a.effort && i.push("--effort", a.effort), i;
 }
-function ue(e) {
-  let i;
+function Te(t) {
+  let a;
   try {
-    i = JSON.parse(e);
+    a = JSON.parse(t);
   } catch {
     return null;
   }
-  switch (i.type) {
+  switch (a.type) {
     case "system":
-      return i.subtype === "init" ? { text: "Agent session started" } : i.subtype === "post_turn_summary" && typeof i.status_detail == "string" ? { text: i.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 a = i.message, p = (a == null ? void 0 : a.content) ?? [];
-      for (const n of p) {
-        const h = n;
-        if (h.type === "tool_use")
-          return { text: `Running ${h.name ?? "a tool"}…` };
-        if (h.type === "text" && typeof h.text == "string" && h.text.trim())
-          return { text: h.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 a = i.message, p = a == null ? void 0 : a.content, n = Array.isArray(p) ? p[0] : void 0;
-      return n != null && n.is_error ? { text: `Error: ${typeof n.content == "string" ? n.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 a = !!i.is_error;
-      return { text: (typeof i.result == "string" ? i.result.trim() : "") || (a ? "Agent run failed" : "Agent run finished"), done: !0, error: a };
+      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 le(e, i) {
-  const a = ["run", e, "--format", "json"];
-  return i != null && i.model && a.push("-m", i.model), i != null && i.effort && a.push("--variant", i.effort), a;
+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 fe = {
+const De = {
   bash: "Running command",
   read: "Reading file",
   edit: "Editing file",
@@ -95,465 +100,589 @@ const fe = {
   webfetch: "Fetching URL",
   question: "Asking for input"
 };
-function ge(e) {
-  let i;
+function Oe(t) {
+  let a;
   try {
-    i = JSON.parse(e);
+    a = JSON.parse(t);
   } catch {
     return null;
   }
-  const a = i.type, p = i.part;
-  if (!a || !p) return null;
-  switch (a) {
+  const i = a.type, r = a.part;
+  if (!i || !r) return null;
+  switch (i) {
     case "step_start":
       return null;
     case "text": {
-      const n = p.text;
-      return n != null && n.trim() ? { text: n.trim() } : null;
+      const s = r.text;
+      return s != null && s.trim() ? { text: s.trim() } : null;
     }
     case "tool_use": {
-      const n = p.tool, h = p.state ? p.state.input : void 0, m = h ? h.description : void 0, $ = n ? fe[n] : "Running tool", u = typeof m == "string" && m.trim() ? `: ${m.trim()}` : "";
-      return n ? { text: `${$}${u}…` } : 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 n = p.reason, h = n === "tool-calls" ? null : n === "stop" ? "Done" : "Step finished";
-      return h ? { text: h } : null;
+      const s = r.reason, e = s === "tool-calls" ? null : s === "stop" ? "Done" : "Step finished";
+      return e ? { text: e } : null;
     }
     default:
       return null;
   }
 }
-const Rt = "claude-code", lt = {
+const Gt = "claude-code", bt = {
   "claude-code": {
     command: "claude",
-    buildArgs: pe,
-    parseLine: ue,
-    options: Pt["claude-code"]
+    buildArgs: Ae,
+    parseLine: Te,
+    options: qt["claude-code"]
   },
   opencode: {
     command: "opencode",
-    buildArgs: le,
-    parseLine: ge,
-    options: Pt.opencode
+    buildArgs: Ee,
+    parseLine: Oe,
+    options: qt.opencode
   }
-}, me = {
+}, Ne = {
   phase: "phase",
   audit: "phase",
   "batch-audit": "phase",
+  "run-all": "phase",
+  sync: "phase",
+  reconcile: "phase",
   draft: "planDraft",
   extend: "ideaExtend",
   "commit-suggest": "commitSuggest"
 };
-function St(e) {
-  const { agentId: i, defaultAgents: a, taskKind: p } = e;
-  if (i && i in lt) return { id: i, adapter: lt[i] };
-  if (p && a) {
-    const n = me[p], h = a[n];
-    if (h) {
-      const m = h.agent;
-      if (m in lt)
-        return { id: m, adapter: lt[m], model: h.model, effort: h.effort };
-    }
-  }
-  return { id: Rt, adapter: lt[Rt] };
+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 Kt(e, i) {
-  return e.map((a) => {
-    if (!a.id)
-      return { ...a, status: "planned" };
-    const p = i.filter((h) => h.idea === a.id);
-    if (p.length === 0)
-      return { ...a, status: "planned" };
-    const n = p.every((h) => h.status === "done" || h.status === "dropped");
-    return { ...a, status: n ? "done" : "planned" };
+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" };
   });
 }
-const he = (e, i) => {
-  if (e)
-    return e.find((a) => a.status === "in-progress" || a.status === "review");
-};
-function ye(e) {
-  const i = /* @__PURE__ */ new Set();
-  let a = null;
-  function p() {
-    const n = `data: ${JSON.stringify({
+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 h of i)
+    for (const e of a)
       try {
-        h.write(n);
+        e.write(s);
       } catch {
-        i.delete(h);
+        a.delete(e);
       }
   }
   try {
-    Ct(N(e, "papercamp"), { recursive: !0 }, () => {
-      a && clearTimeout(a), a = setTimeout(p, 300);
+    Ot($(t, "papercamp"), { recursive: !0 }, () => {
+      i && clearTimeout(i), i = setTimeout(r, 300);
     });
   } catch {
   }
   return {
-    subscribe(n) {
-      i.add(n);
-      const h = JSON.stringify({
+    subscribe(s) {
+      a.add(s);
+      const e = JSON.stringify({
         message: "Watching for changes…",
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
-      n.write(`data: ${h}
+      s.write(`data: ${e}
 
-`), n.on("close", () => i.delete(n));
+`), s.on("close", () => a.delete(s));
     }
   };
 }
-const we = 50;
-function Nt(e) {
+const Be = 50, Ht = 30 * 60 * 1e3;
+function Pt(t) {
   try {
-    const i = ce(N(e, "papercamp", "config.json"), "utf-8"), a = JSON.parse(i), p = a.defaultAgents;
-    if (p)
+    const a = Pe($(t, "papercamp", "config.json"), "utf-8"), i = JSON.parse(a), r = i.defaultAgents;
+    if (r)
       return {
-        phase: B(p.phase),
-        planDraft: B(p.planDraft),
-        ideaExtend: B(p.ideaExtend),
-        commitSuggest: B(p.commitSuggest)
+        phase: z(r.phase),
+        planDraft: z(r.planDraft),
+        ideaExtend: z(r.ideaExtend),
+        commitSuggest: z(r.commitSuggest)
       };
-    if (a.defaultAgent) {
-      const n = a.defaultAgent;
+    if (i.defaultAgent) {
+      const s = i.defaultAgent;
       return {
-        phase: { agent: n },
-        planDraft: { agent: n },
-        ideaExtend: { agent: n },
-        commitSuggest: { agent: n }
+        phase: { agent: s },
+        planDraft: { agent: s },
+        ideaExtend: { agent: s },
+        commitSuggest: { agent: s }
       };
     }
-    return kt;
+    return _t;
   } catch {
-    return kt;
+    return _t;
   }
 }
-function Se(e, i, a) {
-  return `You're working on phase ${a + 1} ("${i.text}") of the plan "${e.title}" (${e.id ?? "no id"}), stored as a single file at papercamp/plans/${e.id ?? "<ID>"}.md.
+function Wt(t, a, i) {
+  const r = a.description ? `Phase details:
+${a.description}
 
-${i.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.
 
-Plan context: ${e.body}
+${r}Plan context: ${t.body}
 
-Do only this phase. When done, check it off in that file's \`### Phases\` list (- [ ] -> - [x]) and append what you did to progress.md. If this was the last unchecked phase, set the plan's \`status:\` frontmatter field to \`review\`, not \`done\`, per this repo's AGENTS.md.`;
+Do only this phase — do not start any other phase, even if it looks quick.
+
+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 Ce(e, i = () => {
-}, a) {
-  const p = /* @__PURE__ */ new Set();
+function Ce(t, a = () => {
+}, i, r, s) {
+  const e = /* @__PURE__ */ new Set();
   let n = null;
-  function h(s) {
-    const w = `data: ${JSON.stringify({ message: s, timestamp: (/* @__PURE__ */ new Date()).toISOString(), type: "agent" })}
+  function l(o) {
+    const k = `data: ${JSON.stringify({ message: o, timestamp: (/* @__PURE__ */ new Date()).toISOString(), type: "agent" })}
 
 `;
-    for (const C of p)
+    for (const v of e)
       try {
-        C.write(w);
+        v.write(k);
       } catch {
-        p.delete(C);
+        e.delete(v);
       }
   }
-  function m(s, w) {
-    s.lines.push(w), s.lines.length > we && s.lines.shift(), h(w);
+  function c(o, k) {
+    o.lines.push(k), o.lines.length > Be && o.lines.shift(), l(k);
   }
-  function $(s, w) {
-    s.status = w, h(`agent: ${w}`);
+  function d(o, k) {
+    o.status = k, l(`agent: ${k}`);
   }
-  async function u(s) {
-    var w, C;
+  async function u(o) {
+    var k, v;
     try {
-      if (s.taskKind === "extend") {
-        const k = N(e, "papercamp", "ideas"), { entries: W } = await Tt(k, N(e, "papercamp", "ideas.md")), z = W.find((F) => F.id === s.ideaId);
-        return !z || s.ideaBodyBaseline === void 0 ? null : z.body !== s.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;
+      }
+      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 O = N(e, "papercamp", "plans"), { entries: A } = await ct(O, N(e, "papercamp", "plans.md"));
-      if (s.ideaId !== void 0)
-        return A.some((k) => k.idea === s.ideaId);
-      const H = A.find((k) => k.id === s.planId) ?? A.find((k) => k.title === s.planTitle);
-      return H ? s.phaseIndex !== void 0 ? ((w = H.phases[s.phaseIndex]) == null ? void 0 : w.done) ?? null : s.planBaseline ? H.phases.length > s.planBaseline.phases || (((C = H.log) == null ? void 0 : C.length) ?? 0) > s.planBaseline.log : null : null;
+      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 t(s, w) {
-    $(s, w ? "error" : "done"), !w && u(s).then((C) => {
-      if (n === s && C === !1) {
-        const O = s.taskKind === "extend" ? `Warning: agent finished but the idea body for ${s.ideaId} did not change — verify manually` : s.ideaId !== void 0 ? `Warning: agent finished but no plan linking idea: ${s.ideaId} appeared in papercamp/plans/ — verify manually` : s.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";
-        m(s, O);
+  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 === s && s.taskKind === "audit" && s.planId && C === !0 && (a == null || a(s.planId, 0).catch(() => {
+      n === o && o.taskKind === "audit" && o.planId && v === !0 && (i == null || i(o.planId, 0).catch(() => {
       }));
     });
   }
-  function J(s) {
-    if (!s.proc.stdout) return;
-    jt({ input: s.proc.stdout }).on("line", (C) => {
-      if (n !== s || !C.trim()) return;
-      const O = s.adapter.parseLine(C);
-      O && (m(s, O.text), O.done && t(s, !!O.error));
-    }), s.proc.on("close", (C) => {
-      n === s && (s.status === "starting" || s.status === "running" ? t(s, C !== 0) : s.status === "stopping" && $(s, "done"));
-    }), s.proc.on("error", (C) => {
-      n === s && (m(s, `Failed to spawn agent: ${C.message}`), $(s, "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 g(s, w) {
-    return V(s.command, w, {
-      cwd: e,
+  function y(o, k) {
+    return it(o.command, k, {
+      cwd: t,
       stdio: ["ignore", "pipe", "pipe"]
     });
   }
-  function j() {
+  function g() {
     return n !== null && n.status !== "done" && n.status !== "error";
   }
-  function r(s, w, C) {
-    if (j())
+  function E(o, k, v) {
+    if (g())
       return { ok: !1, error: "An agent task is already running" };
-    const O = Nt(e), {
-      id: A,
-      adapter: H,
-      model: k,
+    const N = Pt(t), {
+      id: X,
+      adapter: G,
+      model: x,
       effort: W
     } = St({
-      agentId: s.agentOverride,
-      defaultAgents: O,
-      taskKind: C.taskKind
-    }), z = g(H, H.buildArgs(w, { model: k, effort: W })), F = {
-      planTitle: s.planTitle,
-      planId: s.planId,
+      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: A,
-      adapter: H,
-      proc: z,
+      agentId: X,
+      adapter: G,
+      proc: Q,
       lines: [],
-      ...C
+      ...v
     };
-    return n = F, J(F), $(F, "running"), { ok: !0 };
+    return n = b, h(b), d(b, "running"), { ok: !0 };
   }
-  function d(s, w) {
-    if (j())
+  function F(o, k) {
+    if (g())
       return { ok: !1, error: "An agent task is already running" };
-    const C = s.phases[w];
-    if (!C)
+    const v = o.phases[k];
+    if (!v)
       return { ok: !1, error: "Phase not found" };
-    i(s);
-    const O = Se(s, C, w);
-    return r({ planTitle: s.title, planId: s.id, agentOverride: s.agent }, O, {
+    a(o);
+    const N = Wt(o, v, k);
+    return E({ planTitle: o.title, planId: o.id, agentOverride: o.agent }, N, {
       taskKind: "phase",
-      phaseIndex: w
+      phaseIndex: k
     });
   }
-  function y(s, w) {
-    var C;
-    return r({ planTitle: s.title, planId: s.id, agentOverride: s.agent }, w, {
-      taskKind: "audit",
-      planBaseline: { phases: s.phases.length, log: ((C = s.log) == null ? void 0 : C.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 l(s, w) {
-    return s.id ? r({ planTitle: `Draft plan for ${s.id}` }, w, {
+  function S(o, k) {
+    return o.id ? E({ planTitle: `Draft plan for ${o.id}` }, k, {
       taskKind: "draft",
-      ideaId: s.id
+      ideaId: o.id
     }) : { ok: !1, error: "Idea has no id to link a drafted plan back to" };
   }
-  function T(s, w) {
-    return s.id ? r({ planTitle: `Extend ${s.id}` }, w, {
+  function m(o, k) {
+    return o.id ? E({ planTitle: `Extend ${o.id}` }, k, {
       taskKind: "extend",
-      ideaId: s.id,
-      ideaBodyBaseline: s.body
+      ideaId: o.id,
+      ideaBodyBaseline: o.body
     }) : { ok: !1, error: "Idea has no id to extend" };
   }
-  async function c(s, w) {
-    const C = N(s, `${w}.md`);
+  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 it(C), C;
+      return await ht(v), v;
     } catch {
     }
-    const O = N(s, "archive", `${w}.md`);
+    const N = $(o, "archive", `${k}.md`);
     try {
-      return await it(O), O;
+      return await ht(N), N;
     } catch {
     }
     return null;
   }
-  function o() {
-    if (j())
+  function T() {
+    if (g())
       return { ok: !1, error: "An agent task is already running" };
-    const s = Nt(e), {
-      id: w,
-      adapter: C,
-      model: O,
-      effort: A
-    } = St({ defaultAgents: s, taskKind: "audit" }), H = V("sh", ["-c", "exit 0"], {
-      cwd: e,
+    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"
-    }), k = {
+    }), x = {
       taskKind: "batch-audit",
       planTitle: "Batch audit",
       status: "starting",
-      agentId: w,
-      adapter: C,
-      proc: H,
+      agentId: k,
+      adapter: v,
+      proc: G,
       lines: []
     };
-    return n = k, $(k, "running"), (async () => {
-      var W, z;
+    return n = x, d(x, "running"), (async () => {
+      var W, Q;
       try {
-        const F = N(e, "papercamp", "plans"), { entries: K } = await Q(F), R = K.filter((D) => D.status === "review" || D.status === "done");
-        if (R.length === 0) {
-          n === k && (m(k, 'No plans with status "review" or "done" to audit.'), $(k, "done"));
+        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;
         }
-        m(k, `Auditing ${R.length} plan(s)…`);
-        let pt = 0, X = 0, ut = 0;
-        for (const D of R) {
-          if (n !== k || k.status === "stopping") break;
-          if (!D.id) {
-            X++;
+        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 ot = await c(F, D.id);
-          if (!ot) {
-            X++;
+          const ct = await I(b, A.id);
+          if (!ct) {
+            Z++;
             continue;
           }
-          if (D.audited) {
-            const _ = await it(ot).catch(() => null), G = _ ? _.mtime.toISOString().slice(0, 10) : null;
-            if (G && D.audited >= G) {
-              m(k, `[skip] ${D.id} — up to date`), X++;
+          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;
             }
           }
-          m(k, `[audit] ${D.id} ${D.title}`);
-          const gt = Mt(D), Y = V(C.command, C.buildArgs(gt, { model: O, effort: A }), {
-            cwd: e,
+          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"]
           });
-          k.proc = Y, Y.stdout && jt({ input: Y.stdout }).on("line", (G) => {
-            if (n !== k) return;
-            const L = C.parseLine(G);
-            L != null && L.text && L.text !== "Agent is working…" && m(k, `  ${L.text}`);
-          }), (W = Y.stderr) == null || W.on("data", () => {
+          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 mt = await new Promise((_) => {
-            Y.on("close", (G) => _(G === 0)), Y.on("error", () => _(!1));
+          const $t = await new Promise((H) => {
+            et.on("close", (V) => H(V === 0)), et.on("error", () => H(!1));
           });
-          if (n !== k) return;
-          if (mt) {
-            let _ = 0;
+          if (n !== x) return;
+          if ($t) {
+            let H = 0;
             try {
-              const G = await U(ot, "utf-8"), rt = ((z = dt(G).entries[0]) == null ? void 0 : z.phases.length) ?? D.phases.length;
-              _ = Math.max(0, rt - D.phases.length);
+              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 (a == null ? void 0 : a(D.id, _)), pt++, m(
-              k,
-              _ > 0 ? `[done] ${D.id} — ${_} gap phase${_ === 1 ? "" : "s"} added` : `[done] ${D.id}`
+            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
-            ut++, m(k, `[fail] ${D.id} — agent error`);
+            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 !== k) return;
-        if (k.status === "stopping") {
-          $(k, "done");
+        if (n !== b) return;
+        if (b.status === "stopping") {
+          d(b, "done");
           return;
         }
-        m(k, `Audit complete — ${pt} audited, ${X} skipped, ${ut} failed`), $(k, ut > 0 ? "error" : "done");
-      } catch (F) {
-        n === k && (m(k, `Batch audit failed: ${F.message}`), $(k, "error"));
+        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 f = 6e4, S = 10 * 1024 * 1024;
-  function b(s) {
-    if (j())
+  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(s, "utf-8") > S)
+    if (Buffer.byteLength(o, "utf-8") > B)
       return Promise.reject(new Error("Commit suggestion prompt exceeds the 10MB stdin limit"));
-    const w = Nt(e), {
-      id: C,
-      adapter: O,
-      model: A,
-      effort: H
+    const k = Pt(t), {
+      id: v,
+      adapter: N,
+      model: X,
+      effort: G
     } = St({
-      defaultAgents: w,
+      defaultAgents: k,
       taskKind: "commit-suggest"
-    }), k = C === "claude-code", W = k ? ["-p", "--output-format", "json"] : ["run", "--format", "json"];
-    return A && W.push(k ? "--model" : "-m", A), H && W.push(k ? "--effort" : "--variant", H), new Promise((z, F) => {
-      var gt, Y, mt, _, G;
-      const K = V(O.command, W, {
-        cwd: e,
+    }), 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"]
-      }), R = {
+      }), C = {
         taskKind: "commit-suggest",
         planTitle: "Suggest commit message",
         status: "starting",
-        agentId: C,
-        adapter: O,
+        agentId: v,
+        adapter: N,
         proc: K,
         lines: []
       };
-      n = R, $(R, "running");
-      let pt = !1;
-      const X = (L) => {
-        pt || (pt = !0, clearTimeout(ut), L());
-      }, ut = setTimeout(() => {
-        X(() => {
-          n === R && (m(R, "Commit suggestion timed out"), $(R, "error"), K.killed || K.kill("SIGTERM")), F(new Error("Commit suggestion timed out"));
+      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"));
         });
-      }, f);
-      (gt = K.stdin) == null || gt.on("error", () => {
-      }), (Y = K.stdin) == null || Y.write(s), (mt = K.stdin) == null || mt.end();
-      let D = "", ot = "";
-      (_ = K.stdout) == null || _.on("data", (L) => {
-        D += L.toString();
-      }), (G = K.stderr) == null || G.on("data", (L) => {
-        ot += L.toString();
+      }, 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 === R && X(() => {
-          if (R.status === "stopping") {
-            $(R, "done"), F(new Error("Stopped"));
+        n === C && Z(() => {
+          if (C.status === "stopping") {
+            d(C, "done"), b(new Error("Stopped"));
             return;
           }
           if (L === 0) {
-            $(R, "done");
-            const rt = k ? D : D.split(`
-`).map((Gt) => {
-              var At;
+            d(C, "done");
+            const nt = x ? A : A.split(`
+`).map((kt) => {
+              var dt;
               try {
-                const tt = JSON.parse(Gt);
-                if ((tt == null ? void 0 : tt.type) === "text" && ((At = tt == null ? void 0 : tt.part) != null && At.text)) return tt.part.text;
+                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(`
 `);
-            z(rt);
+            Q(nt);
           } else {
-            const rt = ot || `${O.command} exited with code ${L}`;
-            m(R, rt), $(R, "error"), F(new Error(rt));
+            const nt = ct || `${N.command} exited with code ${L}`;
+            c(C, nt), d(C, "error"), b(new Error(nt));
           }
         });
       }), K.on("error", (L) => {
-        n === R && X(() => {
-          m(R, `Failed to spawn agent: ${L.message}`), $(R, "error"), F(L);
+        n === C && Z(() => {
+          c(C, `Failed to spawn agent: ${L.message}`), d(C, "error"), b(L);
         });
       });
     });
   }
-  function I() {
+  function _() {
     if (!n)
       return { ok: !1, error: "No agent task running" };
-    const s = n;
-    return $(s, "stopping"), s.proc.killed || s.proc.kill("SIGTERM"), setTimeout(() => {
-      n === s && s.status === "stopping" && s.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 v() {
+  function R() {
     return n ? {
       status: n.status,
       taskKind: n.taskKind,
@@ -566,1161 +695,1464 @@ function Ce(e, i = () => {
     } : null;
   }
   return {
-    start: d,
-    startForPlan: y,
-    startForIdea: l,
-    startForIdeaExtend: T,
-    startBatchAudit: o,
-    runCommitSuggest: b,
-    stop: I,
-    getStatus: v,
-    subscribe(s) {
-      p.add(s), s.on("close", () => p.delete(s));
+    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() {
       n != null && n.proc && !n.proc.killed && n.proc.kill();
     }
   };
 }
-function $e(e, i) {
-  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.${i ? `
-This work belongs to plan ${i}. Do NOT put the plan id in the scope — instead end the message body with a \`Refs: ${i}\` 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": "${i ? `longer body describing what changed and why, ending with a \`Refs: ${i}\` line` : "optional longer body describing what changed and why, or an empty string if the title alone is clear enough"}"}
-
-Diff:
-${e}`;
+async function j(t) {
+  try {
+    return await at(t, "utf-8");
+  } catch (a) {
+    if (a.code === "ENOENT") return "";
+    throw a;
+  }
 }
-async function Te(e, i, a) {
-  if (!e.trim())
-    throw new Error("No changes to summarize — select at least one file first");
-  const p = $e(e, i), n = await a(p);
-  let h = n;
+async function wt(t) {
   try {
-    const t = JSON.parse(n);
-    typeof t.result == "string" && (h = t.result);
+    return await ht(t), !0;
   } catch {
+    return !1;
   }
-  const m = h.match(/\{[\s\S]*\}/);
-  if (!m) throw new Error("Agent did not return a parseable commit message");
-  const $ = JSON.parse(m[0]);
-  if (!$.title) throw new Error("Agent response missing a title");
-  let u = $.message ?? "";
-  return i && !/Refs:\s*\S/.test(u) && (u = u ? `${u}
+}
+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}
 
-Refs: ${i}` : `Refs: ${i}`), { title: $.title, message: u };
+${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 Lt = [/(^|\/)\.env(\.|$)/i, /\.(pem|key|p12|crt)$/i], bt = (e) => `:(literal)${e}`;
-function Oe(e) {
+const Ut = [/(^|\/)\.env(\.|$)/i, /\.(pem|key|p12|crt)$/i], Ft = (t) => `:(literal)${t}`;
+function _e(t, a = {}) {
   const i = /* @__PURE__ */ new Set();
-  function a(o) {
-    const f = `data: ${JSON.stringify(o)}
+  function r(w) {
+    const I = `data: ${JSON.stringify(w)}
 
 `;
-    for (const S of i)
+    for (const T of i)
       try {
-        S.write(f);
+        T.write(I);
       } catch {
-        i.delete(S);
+        i.delete(T);
       }
   }
-  function p(o) {
-    const f = [];
-    for (const S of o.split(`
+  function s(w) {
+    const I = [];
+    for (const T of w.split(`
 `)) {
-      if (!S.trim()) continue;
-      const b = S[0] ?? " ", I = S[1] ?? " ", v = S.slice(3), s = v.split(" -> "), w = s.pop() ?? v;
-      f.push({
-        path: w,
-        status: `${b}${I}`,
-        staged: b !== " " && b !== "?",
-        renameSource: (b === "R" || b === "C") && s.length > 0 ? s[0] : void 0
+      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 f;
+    return I;
   }
-  function n(o) {
-    return new Promise((f, S) => {
-      var s, w;
-      const b = V("git", o, {
-        cwd: e,
+  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 I = "", v = "";
-      (s = b.stdout) == null || s.on("data", (C) => {
-        I += C.toString();
-      }), (w = b.stderr) == null || w.on("data", (C) => {
-        v += C.toString();
-      }), b.on("close", (C) => {
-        C === 0 ? f(I) : S(new Error(v || `git ${o[0]} exited with code ${C}`));
-      }), b.on("error", S);
+      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 h() {
-    return n(["status", "--porcelain=v1"]).then(p);
+  function n() {
+    return e(["status", "--porcelain=v1"]).then(s);
   }
-  async function m(o, f, S) {
-    if (o.length > 0) {
-      const I = await h(), v = new Map(I.map((w) => [w.path, w.status])), s = o.filter((w) => {
-        const C = v.get(w);
-        return C === void 0 || C[1] !== " ";
+  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] !== " ";
       });
-      s.length > 0 && await n(["add", "--", ...s.map(bt)]);
+      _.length > 0 && await e(["add", "--", ..._.map(Ft)]);
     }
-    const b = ["commit", "-m", f];
-    S && b.push("-m", S), o.length > 0 && b.push("--", ...o.map(bt)), await n(b);
+    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 $(o) {
-    if (!o.kind || !o.id) return;
-    const f = o.kind.toLowerCase(), S = o.id.toLowerCase(), b = o.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, ""), I = `${f}/${S}-${b}`, v = ht("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: e });
-    if (v.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(
-        v.stderr.toString().trim() || "Unable to read current git branch"
+        B.stderr.toString().trim() || "Unable to read current git branch"
       );
-    if (v.stdout.toString().trim() === I) return;
-    const w = ht("git", ["checkout", "-b", I, "main"], { cwd: e });
-    if (w.status !== 0) {
-      const C = ht("git", ["checkout", I], { cwd: e });
-      if (C.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(
-          C.stderr.toString().trim() || w.stderr.toString().trim() || `Unable to check out ${I}`
+          R.stderr.toString().trim() || _.stderr.toString().trim() || `Unable to check out ${M}`
         );
     }
   }
-  async function u() {
+  async function d() {
     try {
-      await h(), a({
+      await n(), r({
         message: "Working tree status updated",
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
     } catch {
     }
   }
-  const t = N(e, ".git");
-  let J = null;
-  try {
-    Ct(t, { recursive: !0 }, (o, f) => {
-      f === "index" && (J && clearTimeout(J), J = setTimeout(u, 500));
-    });
-  } catch {
-  }
-  const g = N(e, "src");
-  let j = null;
-  try {
-    Ct(g, { recursive: !0 }, () => {
-      j && clearTimeout(j), j = setTimeout(u, 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 {
+    }
   }
-  async function r() {
+  async function u() {
     try {
-      return await n(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]), !0;
+      return await e(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]), !0;
     } catch {
       return !1;
     }
   }
-  async function d() {
+  async function f() {
     try {
-      const o = await r() ? ["rev-list", "--count", "@{u}..HEAD"] : ["rev-list", "--count", "HEAD", "--not", "--remotes"], f = await n(o);
-      return Number.parseInt(f.trim(), 10) || 0;
+      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;
     }
   }
-  async function y() {
-    await r() ? await n(["push"]) : await n(["push", "--set-upstream", "origin", l()]);
+  async function h() {
+    await u() ? await e(["push"]) : await e(["push", "--set-upstream", "origin", y()]);
   }
-  function l() {
-    return ht("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: e }).stdout.toString().trim();
+  function y() {
+    return It("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: t }).stdout.toString().trim();
   }
-  function T() {
-    const f = l().match(/^[a-z]+\/([a-z]+-\d+)-/);
-    return f ? f[1].toUpperCase() : null;
-  }
-  async function c(o, f = 12e3) {
-    if (o.length === 0) return "";
-    const S = o.find((O) => Lt.some((A) => A.test(O)));
-    if (S)
-      throw new Error(`Refusing to send sensitive file "${S}" to commit suggestion`);
-    const b = await h(), I = new Set(b.filter((O) => O.status === "??").map((O) => O.path)), v = new Map(
-      b.filter((O) => !!O.renameSource).map((O) => [O.path, O.renameSource])
-    ), s = o.filter((O) => {
-      if (I.has(O)) return !1;
-      const A = v.get(O);
-      return !(A && Lt.some((H) => H.test(A)));
-    }), w = [];
-    if (s.length > 0) {
-      const O = await n([
+  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;
+    }
+  }
+  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 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",
         "--",
-        ...s.map(bt)
+        ...J.map(Ft)
       ]).catch(() => "");
-      O && w.push(O);
-    }
-    for (const O of o.filter((A) => I.has(A))) {
-      const A = N(e, O), H = await Ut(A).catch(() => null);
-      if (!H) continue;
-      if (H.isSymbolicLink()) {
-        w.push(`--- /dev/null
-+++ b/${O}
+      o && _.push(o);
+    }
+    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 (H.size > f) {
-        w.push(`--- /dev/null
-+++ b/${O}
+      if (v.size > I) {
+        _.push(`--- /dev/null
++++ b/${o}
 (new file omitted: exceeds diff size cap)`);
         continue;
       }
-      const k = await U(A, "utf-8").catch(() => "");
-      k && w.push(`--- /dev/null
-+++ b/${O}
+      const N = await at(k, "utf-8").catch(() => "");
+      N && _.push(`--- /dev/null
++++ b/${o}
 (new file)
-${k}`);
+${N}`);
     }
-    const C = w.join(`
+    const R = _.join(`
 
 `);
-    return C.length > f ? `${C.slice(0, f)}
-... (truncated)` : C;
-  }
-  return {
-    async getStatus() {
-      return h();
-    },
-    getCurrentBranch: l,
-    commit: m,
-    diff: c,
-    ensureBranch: $,
-    getFeatureBranchPlanId: T,
-    getAheadCount: d,
-    push: y,
-    subscribe(o) {
-      i.add(o), o.on("close", () => i.delete(o));
-    }
-  };
-}
-const Ne = {
-  lint: "npx biome lint .",
-  format: "npx biome format .",
-  test: "npx vitest run"
-};
-function be(e) {
-  const i = /* @__PURE__ */ new Set(), a = {
-    lint: { status: "stale", lastRun: null, output: "" },
-    format: { status: "stale", lastRun: null, output: "" },
-    test: { status: "stale", lastRun: null, output: "" }
-  }, p = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
-  function h(g) {
-    const j = `data: ${JSON.stringify(g)}
-
-`;
-    for (const r of i)
-      try {
-        r.write(j);
-      } catch {
-        i.delete(r);
-      }
-  }
-  function m(g, j, r) {
-    a[g] = { status: j, lastRun: (/* @__PURE__ */ new Date()).toISOString(), output: r }, h({
-      message: `${g}: ${j}`,
-      timestamp: a[g].lastRun
-    }), j !== "running" && n.has(g) && (n.delete(g), $(g));
-  }
-  function $(g) {
-    var l, T;
-    if (p.has(g)) {
-      n.add(g);
-      return;
-    }
-    p.add(g), m(g, "running", "");
-    const j = Ne[g], r = V(j, {
-      cwd: e,
-      stdio: ["ignore", "pipe", "pipe"],
-      shell: !0
-    });
-    let d = "", y = "";
-    (l = r.stdout) == null || l.on("data", (c) => {
-      d += c.toString();
-    }), (T = r.stderr) == null || T.on("data", (c) => {
-      y += c.toString();
-    }), r.on("close", (c) => {
-      p.delete(g);
-      const o = d + y;
-      c === 0 ? m(g, "pass", o) : m(g, "fail", o);
-    }), r.on("error", (c) => {
-      p.delete(g), m(g, "fail", `Failed to spawn process: ${c.message}`);
-    });
+    return R.length > I ? `${R.slice(0, I)}
+... (truncated)` : R;
   }
-  function u() {
-    if (p.has("lint") || p.has("format")) return;
-    m("lint", "running", "Applying automatic fixes…"), m("format", "running", "Applying automatic fixes…");
-    const g = V("npx biome check . --write", {
-      cwd: e,
-      stdio: ["ignore", "pipe", "pipe"],
-      shell: !0
-    });
-    g.on("close", () => {
-      $("lint"), $("format");
-    }), g.on("error", (j) => {
-      const r = `Failed to spawn fix process: ${j.message}`;
-      m("lint", "fail", r), m("format", "fail", r);
-    });
+  async function S() {
+    await e(["add", "-A"]);
   }
-  const t = N(e, "src");
-  let J = null;
-  try {
-    Ct(t, { recursive: !0 }, () => {
-      J && clearTimeout(J), J = setTimeout(() => {
-        $("lint"), $("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: { ...a.lint },
-        format: { ...a.format },
-        test: { ...a.test }
-      };
+    async getStatus() {
+      return n();
     },
-    runCheck: $,
-    runQualityFix: u,
-    subscribe(g) {
-      i.add(g);
-      for (const j of ["lint", "format", "test"]) {
-        const r = a[j];
-        r.status !== "stale" && g.write(
-          `data: ${JSON.stringify({ message: `${j}: ${r.status}`, timestamp: r.lastRun })}
-
-`
-        );
-      }
-      g.on("close", () => i.delete(g));
+    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 P(e) {
-  try {
-    return await U(e, "utf-8");
-  } catch (i) {
-    if (i.code === "ENOENT") return "";
-    throw i;
-  }
-}
-async function ft(e) {
-  try {
-    return await it(e), !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 M(e) {
-  return new Promise((i, a) => {
-    let p = "";
-    e.on("data", (n) => {
-      p += n;
-    }), e.on("end", () => i(p)), e.on("error", a);
+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 x = (e, i) => N(e, "papercamp", i), je = [
-  "biome.json",
-  "tsconfig.json",
-  "tailwind.config.ts",
-  "vite.config.ts",
-  "vite.app.config.ts",
-  "postcss.config.js",
-  "package.json"
-];
-async function et(e, i, a) {
-  const p = i.getFeatureBranchPlanId();
-  if (!p || a && p === a) return null;
-  const n = x(e, "plans"), { entries: h } = await ct(n, x(e, "plans.md")), m = h.find(($) => $.id === p);
-  return !m || m.status === "done" || m.status === "dropped" ? null : `Finish \`${p}\` — ${m.title} — before starting another plan`;
+function vt(t) {
+  return new URL(t.url ?? "", `http://${t.headers.host ?? "localhost"}`);
 }
-async function yt(e) {
-  const i = x(e, "plans"), a = x(e, "ideas"), [p, n] = await Promise.all([
-    ct(i, x(e, "plans.md")),
-    Tt(a, x(e, "ideas.md"))
-  ]), h = Kt(n.entries, p.entries);
-  await q(i, { recursive: !0 }), await q(a, { recursive: !0 }), await Promise.all([
-    E(N(i, "index.md"), Ht(p.entries)),
-    E(N(a, "index.md"), _t(h))
-  ]);
+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 ke = [
-  {
-    path: "/api/package-name",
-    handler: async (e) => {
-      const i = await P(N(e, "package.json"));
-      if (!i) return null;
-      try {
-        return JSON.parse(i).name ?? null;
-      } catch {
-        return null;
-      }
-    }
-  },
-  {
-    path: "/api/plans",
-    handler: async (e) => ct(x(e, "plans"), x(e, "plans.md"))
-  },
-  {
-    path: "/api/progress",
-    handler: async (e) => ({
-      entries: ne(await P(x(e, "progress.md")))
-    })
-  },
-  {
-    path: "/api/decisions",
-    handler: async (e) => Dt(await P(x(e, "decisions.md")))
-  },
-  {
-    path: "/api/open-questions",
-    handler: async (e) => It(await P(x(e, "open-questions.md")))
-  },
-  {
-    path: "/api/ideas",
-    handler: async (e) => Tt(x(e, "ideas"), x(e, "ideas.md"))
-  },
-  {
-    path: "/api/consistency",
-    handler: async (e) => {
-      const [i, a, p] = await Promise.all([
-        P(x(e, "decisions.md")),
-        P(x(e, "open-questions.md")),
-        ct(x(e, "plans"), x(e, "plans.md"))
-      ]), n = Dt(i), h = It(a);
-      return ae(n.entries, h.entries, p.entries);
-    }
-  },
-  {
-    path: "/api/config",
-    handler: async (e) => {
-      const i = await P(N(e, "papercamp", "config.json"));
-      if (!i) return null;
-      const a = JSON.parse(i);
-      return a != null && a.defaultAgents && (a.defaultAgents = {
-        phase: B(a.defaultAgents.phase),
-        planDraft: B(a.defaultAgents.planDraft),
-        ideaExtend: B(a.defaultAgents.ideaExtend),
-        commitSuggest: B(a.defaultAgents.commitSuggest)
-      }), a;
-    }
-  },
-  {
-    path: "/api/docs",
-    handler: async (e) => {
-      const i = ["MAIN.md", "README.md", "CHANGELOG.md", "LICENSE"], a = [];
-      for (const p of i) {
-        const n = await P(N(e, p));
-        n && a.push({ name: p, content: n });
-      }
-      return { files: a };
-    }
-  },
-  {
-    path: "/api/configs",
-    handler: async (e) => {
-      const i = [
-        "biome.json",
-        "tsconfig.json",
-        "tailwind.config.ts",
-        "vite.config.ts",
-        "vite.app.config.ts",
-        "postcss.config.js",
-        "package.json"
-      ], a = [];
-      for (const p of i)
-        await P(N(e, p)) && a.push(p);
-      return { files: a };
-    }
-  }
+const je = [
+  ["`plans.md`", "`papercamp/plans/`"],
+  ["`ideas.md`", "`papercamp/ideas/`"],
+  [".paper-camp/", "papercamp/"],
+  ["FocusTaskItem", "FocusPhaseItem"],
+  ["TaskItem", "PhaseItem"],
+  ["taskProgress", "phaseProgress"],
+  ["taskPercentage", "phasePercentage"]
 ];
-function ve(e) {
-  const i = ye(e), a = Oe(e), p = be(e);
-  async function n(u) {
-    const t = x(e, "progress.md"), g = `## ${Z()}`, j = await P(t);
-    if (j.startsWith(`${g}
-`))
-      await E(
-        t,
-        `${g}
-- ${u}
-${j.slice(g.length + 1)}`,
-        "utf-8"
-      );
-    else {
-      const r = j.trimEnd(), d = r ? `${g}
-- ${u}
-
-${r}
-` : `${g}
-- ${u}
-`;
-      await E(t, d, "utf-8");
+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;
     }
-  }
-  async function h(u, t) {
-    const J = x(e, "plans"), g = N(J, `${u}.md`), j = N(J, "archive", `${u}.md`), r = await ft(g) ? g : await ft(j) ? j : null;
-    if (!r) return;
-    const d = await P(r);
-    if (!d) return;
-    const y = dt(d);
-    if (y.entries.length === 0) return;
-    const l = y.entries[0], T = {
-      id: u,
-      title: l.title,
-      kind: l.kind ?? "feat",
-      status: l.status,
-      idea: l.idea,
-      agent: l.agent,
-      created: l.created,
-      updated: l.updated,
-      audited: Z(),
-      tags: l.tags,
-      body: l.body,
-      phases: l.phases,
-      log: l.log,
-      clarifications: l.clarifications
-    };
-    if (await E(r, `${at(T)}
-`, "utf-8"), t > 0) {
-      const c = `gap phase${t === 1 ? "" : "s"}`;
-      await n(
-        `Batch audit of ${u} (${l.title}) — ${t} ${c} appended`
-      );
+    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);
   }
-  const m = Ce(e, (u) => a.ensureBranch(u), h), $ = async (u, t, J) => {
-    const g = (u.url ?? "").split("?")[0];
-    if (u.method === "DELETE" && g === "/api/plans") {
-      try {
-        const d = new URL(u.url ?? "", `http://${u.headers.host ?? "localhost"}`).searchParams.get("title");
-        if (!(d != null && d.trim())) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "title is required" }));
+  return { content: i + s.join(`
+`), changed: e };
+}
+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());
+      }
+    },
+    // 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 y = x(e, "plans"), l = d.trim(), { entries: T } = await Q(y), c = T.find((f) => f.title === l || f.id === l);
-        if (!(c != null && c.id)) {
-          t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "plan not found in per-file storage" }));
+        const d = await At(t, l);
+        if (!d) {
+          p(e, 404, { error: "plan not found" });
+          return;
+        }
+        const u = await rt(t, a, d.id);
+        if (u) {
+          p(e, 409, { error: u });
           return;
         }
-        const o = N(y, `${c.id}.md`);
-        if (!await ft(o)) {
-          t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "plan file not found" }));
+        const f = r.start(d, c);
+        if (!f.ok) {
+          p(e, 409, { error: f.error });
           return;
         }
-        await Wt(o), await yt(e), t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (r) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.message }));
+        p(e, 202, { ok: !0 });
       }
-      return;
-    }
-    if (u.method === "POST" && g === "/api/plans") {
-      try {
-        const r = await M(u), { title: d, content: y, kind: l } = JSON.parse(r);
-        if (!(d != null && d.trim())) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "title is required" }));
+    },
+    // 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 T = l && wt.includes(l) ? l : "feat", c = N(e, "papercamp", "config.json"), o = await Bt(c, T);
-        if (!o) {
-          t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "could not assign plan ID" }));
+        const d = await At(t, l);
+        if (!d) {
+          p(e, 404, { error: "plan not found" });
           return;
         }
-        const f = x(e, "plans");
-        await q(f, { recursive: !0 });
-        const S = at({
-          id: o,
-          title: d.trim(),
-          kind: T,
-          status: "idea",
-          created: Z(),
-          body: y == null ? void 0 : y.trim()
-        });
-        await E(N(f, `${o}.md`), `${S}
-`, "utf-8"), await yt(e), t.statusCode = 201, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0, id: o }));
-      } catch (r) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.message }));
-      }
-      return;
-    }
-    if (u.method === "PATCH" && g === "/api/plans") {
-      try {
-        const d = new URL(u.url ?? "", `http://${u.headers.host ?? "localhost"}`).searchParams.get("title");
-        if (!(d != null && d.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 y = await M(u), l = JSON.parse(y);
-        if (l.agent && !Ot.includes(l.agent)) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "agent must be a known agent id" }));
+        const f = r.startForPlan(d, c);
+        if (!f.ok) {
+          p(e, 409, { error: f.error });
           return;
         }
-        const T = x(e, "plans"), { entries: c } = await Q(T), o = d.trim(), f = c.find((w) => w.title === o || w.id === o);
-        if (!(f != null && f.id)) {
-          t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "plan not found" }));
+        p(e, 202, { ok: !0 });
+      }
+    },
+    // 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;
         }
-        const S = N(T, `${f.id}.md`), b = await P(S);
-        if (!b) {
-          t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "plan file not found" }));
+        const d = await At(t, l);
+        if (!d) {
+          p(e, 404, { error: "plan not found" });
           return;
         }
-        const I = dt(b);
-        if (I.entries.length === 0) {
-          t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "failed to parse plan file" }));
+        const u = await rt(t, a, d.id);
+        if (u) {
+          p(e, 409, { error: u });
           return;
         }
-        const v = {
-          ...I.entries[0],
-          ...l.status !== void 0 && { status: l.status },
-          ...l.phases !== void 0 && { phases: l.phases },
-          ...l.log !== void 0 && { log: l.log },
-          ...l.agent !== void 0 && { agent: l.agent ?? void 0 },
-          updated: Z()
-        };
-        if (l.status === "done" || l.status === "dropped") {
-          const w = await et(e, a, f.id);
-          if (w) {
-            t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: w }));
-            return;
-          }
+        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");
         }
-        if (l.status === "in-progress") {
-          const w = await Q(T);
-          for (const C of w.entries)
-            if (C.id !== f.id && C.status === "in-progress") {
-              const O = N(T, `${C.id}.md`), A = await P(O);
-              if (A) {
-                const H = dt(A);
-                if (H.entries.length > 0) {
-                  const k = {
-                    id: H.entries[0].id ?? C.id,
-                    title: H.entries[0].title,
-                    kind: H.entries[0].kind ?? "feat",
-                    status: "planned",
-                    created: H.entries[0].created,
-                    updated: Z(),
-                    audited: H.entries[0].audited,
-                    body: H.entries[0].body,
-                    phases: H.entries[0].phases,
-                    log: H.entries[0].log,
-                    clarifications: H.entries[0].clarifications
-                  };
-                  await E(O, `${at(k)}
-`, "utf-8");
-                }
-              }
-            }
+        const h = r.startForPlan(d, c, "reconcile");
+        if (!h.ok) {
+          p(e, 409, { error: h.error });
+          return;
         }
-        const s = {
-          id: v.id ?? f.id,
-          title: v.title,
-          kind: v.kind ?? "feat",
-          status: v.status,
-          idea: v.idea,
-          agent: v.agent,
-          created: v.created,
-          updated: v.updated,
-          audited: v.audited,
-          tags: v.tags,
-          body: v.body,
-          phases: v.phases,
-          log: v.log,
-          clarifications: v.clarifications
-        };
-        if (await E(S, `${at(s)}
-`, "utf-8"), await yt(e), l.status === "done" || l.status === "dropped") {
-          await Zt(e, f.id);
-          try {
-            a.ensureBranch(v);
-          } catch {
-          }
-        }
-        t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (r) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.message }));
+        p(e, 202, { ok: !0 });
       }
-      return;
-    }
-    if (u.method === "POST" && g === "/api/ideas") {
-      try {
-        const r = await M(u), { title: d, content: y } = JSON.parse(r);
-        if (!(d != null && d.trim())) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "title is 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 l = x(e, "ideas"), o = `IDEA-${(await Tt(l, x(e, "ideas.md"))).entries.reduce((S, b) => {
-          if (b.id) {
-            const I = Number.parseInt(b.id.replace("IDEA-", ""), 10);
-            return Number.isNaN(I) ? S : Math.max(S, I);
-          }
-          return S;
-        }, 0) + 1}`;
-        await q(l, { recursive: !0 });
-        const f = Ft({
-          id: o,
-          title: d.trim(),
-          body: y == null ? void 0 : y.trim()
-        });
-        await E(N(l, `${o}.md`), `${f}
-`, "utf-8"), await yt(e), t.statusCode = 201, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0, id: o }));
-      } catch (r) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.message }));
+        const d = await Yt(t, l);
+        if (!d) {
+          p(e, 404, { error: "idea not found" });
+          return;
+        }
+        const u = await rt(t, a);
+        if (u) {
+          p(e, 409, { error: u });
+          return;
+        }
+        const f = r.startForIdea(d, c);
+        if (!f.ok) {
+          p(e, 409, { error: f.error });
+          return;
+        }
+        p(e, 202, { ok: !0 });
       }
-      return;
-    }
-    if (u.method === "GET" && g === "/api/icon") {
-      const r = N(e, "papercamp", "assets"), d = {
-        svg: "image/svg+xml",
-        png: "image/png",
-        jpg: "image/jpeg",
-        jpeg: "image/jpeg",
-        gif: "image/gif",
-        webp: "image/webp"
-      };
-      for (const [y, l] of Object.entries(d))
-        try {
-          const T = await U(N(r, `icon.${y}`));
-          t.statusCode = 200, t.setHeader("Content-Type", l), t.setHeader("Cache-Control", "no-cache"), t.end(T);
+    },
+    // 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;
-        } catch {
         }
-      t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "no icon uploaded" }));
-      return;
-    }
-    if (u.method === "POST" && g === "/api/icon") {
-      try {
-        const r = await M(u), { dataUri: d } = JSON.parse(r);
+        const d = await Yt(t, l);
         if (!d) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "dataUri is required" }));
+          p(e, 404, { error: "idea not found" });
           return;
         }
-        const y = d.match(/^data:(image\/[a-z0-9+.-]+);base64,(.+)$/);
-        if (!y) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "invalid data URI" }));
+        const u = await rt(t, a);
+        if (u) {
+          p(e, 409, { error: u });
           return;
         }
-        const l = y[1], T = l === "image/svg+xml" ? "svg" : l.split("/")[1], c = Buffer.from(y[2], "base64"), o = N(e, "papercamp", "assets");
-        await q(o, { recursive: !0 }), await E(N(o, `icon.${T}`), c), t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (r) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.message }));
-      }
-      return;
-    }
-    if (u.method === "GET" && g === "/api/git/status") {
-      try {
-        const r = await a.getStatus(), d = a.getCurrentBranch(), y = await a.getAheadCount();
-        t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ branch: d, entries: r, ahead: y }));
-      } catch (r) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.message }));
-      }
-      return;
-    }
-    if (u.method === "POST" && g === "/api/git/push") {
-      try {
-        await a.push(), t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (r) {
-        t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.message }));
-      }
-      return;
-    }
-    if (u.method === "POST" && g === "/api/git/commit") {
-      try {
-        const r = await M(u), { files: d, title: y, message: l } = JSON.parse(r);
-        if (!(y != null && y.trim())) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "title is required" }));
+        const f = r.startForIdeaExtend(d, c);
+        if (!f.ok) {
+          p(e, 409, { error: f.error });
           return;
         }
-        await a.commit(d ?? [], y.trim(), l == null ? void 0 : l.trim()), t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (r) {
-        t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.message }));
+        p(e, 202, { ok: !0 });
       }
-      return;
-    }
-    if (u.method === "POST" && g === "/api/git/suggest-commit-message") {
-      try {
-        const r = await M(u), { files: d } = JSON.parse(r);
-        if (!(d != null && d.length)) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "files is 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 y = await a.diff(d), { entries: l } = await ct(
-          x(e, "plans"),
-          x(e, "plans.md")
-        ), T = he(l), c = await Te(
-          y,
-          T == null ? void 0 : T.id,
-          m.runCommitSuggest
-        );
-        t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify(c));
-      } catch (r) {
-        t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.message }));
-      }
-      return;
-    }
-    if (u.method === "GET" && g === "/api/status") {
-      t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify(p.getStatus()));
-      return;
-    }
-    if (u.method === "POST" && g === "/api/status/check") {
-      const d = new URL(u.url ?? "", `http://${u.headers.host ?? "localhost"}`).searchParams.get("name");
-      if (d !== "lint" && d !== "format" && d !== "test") {
-        t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "name must be lint, format, or test" }));
-        return;
+        const l = r.startBatchAudit();
+        if (!l.ok) {
+          p(e, 409, { error: l.error });
+          return;
+        }
+        p(e, 202, { ok: !0 });
       }
-      p.runCheck(d), t.statusCode = 202, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      return;
-    }
-    if (u.method === "POST" && g === "/api/status/fix") {
-      p.runQualityFix(), t.statusCode = 202, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      return;
-    }
-    if (u.method === "GET" && g === "/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(), i.subscribe(t), a.subscribe(t), p.subscribe(t), m.subscribe(t);
-      return;
-    }
-    if (u.method === "GET" && g === "/api/agent/status") {
-      t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify(m.getStatus()));
-      return;
-    }
-    if (u.method === "POST" && g === "/api/agent/launch") {
-      try {
-        const r = await M(u), { planId: d, phaseIndex: y } = JSON.parse(r);
-        if (!d || typeof y != "number") {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "planId and phaseIndex are required" }));
+    },
+    // 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 l = x(e, "plans"), c = (await Q(l)).entries.find((S) => S.id === d);
+        const c = await At(t, l);
         if (!c) {
-          const b = vt(await P(x(e, "plans.md"))).entries.find((s) => s.id === d);
-          if (!b) {
-            t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "plan not found" }));
-            return;
-          }
-          const I = await et(e, a, b.id);
-          if (I) {
-            t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: I }));
-            return;
-          }
-          const v = await m.start(b, y);
-          if (!v.ok) {
-            t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: v.error }));
-            return;
-          }
-          t.statusCode = 202, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
+          p(e, 404, { error: "plan not found" });
           return;
         }
-        const o = await et(e, a, c.id);
-        if (o) {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: o }));
+        const d = await rt(t, a, c.id);
+        if (d) {
+          p(e, 409, { error: d });
           return;
         }
-        const f = await m.start(c, y);
-        if (!f.ok) {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: f.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 (r) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.message }));
+        p(e, 202, { ok: !0 });
       }
-      return;
-    }
-    if (u.method === "POST" && g === "/api/agent/launch-audit") {
-      try {
-        const r = await M(u), { planId: d, prompt: y } = JSON.parse(r);
-        if (!d || !y) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "planId and prompt are required" }));
+    },
+    // 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;
         }
-        const l = x(e, "plans");
-        let c = (await Q(l)).entries.find((S) => S.id === d);
-        if (c || (c = vt(await P(x(e, "plans.md"))).entries.find((b) => b.id === d)), !c) {
-          t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "plan not found" }));
+        p(e, 202, { ok: !0 });
+      }
+    }
+  ];
+}
+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 o = await et(e, a, c.id);
-        if (o) {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: o }));
+        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 f = m.startForPlan(c, y);
-        if (!f.ok) {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: f.error }));
+        if (c !== void 0 && c.trim().length === 0) {
+          p(i, 400, { error: "projectName must not be empty" });
           return;
         }
-        t.statusCode = 202, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (r) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.message }));
-      }
-      return;
-    }
-    if (u.method === "POST" && g === "/api/agent/launch-draft") {
-      try {
-        const r = await M(u), { ideaId: d, prompt: y } = JSON.parse(r);
-        if (!d || !y) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "ideaId and prompt are required" }));
+        if (d !== void 0 && !Mt.includes(d)) {
+          p(i, 400, { error: "defaultAgent must be a known agent id" });
           return;
         }
-        const l = x(e, "ideas");
-        let c = (await xt(l)).entries.find((S) => S.id === d);
-        if (c || (c = Jt(await P(x(e, "ideas.md"))).find((b) => b.id === d)), !c) {
-          t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "idea not found" }));
+        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 });
+      }
+    },
+    // 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;
         }
-        const o = await et(e, a);
-        if (o) {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: o }));
+        if (!re.includes(r)) {
+          p(i, 400, { error: "invalid config file name" });
           return;
         }
-        const f = m.startForIdea(c, y);
-        if (!f.ok) {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: f.error }));
+        const s = await j($(t, r));
+        if (!s) {
+          p(i, 404, { error: "config file not found" });
           return;
         }
-        t.statusCode = 202, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (r) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.message }));
+        p(i, 200, { name: r, content: s });
       }
-      return;
     }
-    if (u.method === "POST" && g === "/api/agent/launch-extend") {
-      try {
-        const r = await M(u), { ideaId: d, prompt: y } = JSON.parse(r);
-        if (!d || !y) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "ideaId and prompt are required" }));
+  ];
+}
+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 l = x(e, "ideas");
-        let c = (await xt(l)).entries.find((S) => S.id === d);
-        if (c || (c = Jt(await P(x(e, "ideas.md"))).find((b) => b.id === d)), !c) {
-          t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "idea not found" }));
+        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;
         }
-        const o = await et(e, a);
-        if (o) {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: o }));
+        const l = P(t, "open-questions.md"), c = await j(l);
+        if (!c) {
+          p(i, 404, { error: "open-questions.md not found" });
           return;
         }
-        const f = m.startForIdeaExtend(c, y);
-        if (!f.ok) {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: f.error }));
+        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;
         }
-        t.statusCode = 202, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (r) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.message }));
+        const u = r.trim(), f = d.entries.find((g) => g.title === u);
+        if (!f) {
+          p(i, 404, { error: `open question "${u}" not found` });
+          return;
+        }
+        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 (u.method === "POST" && g === "/api/agent/launch-audit-all") {
-      const r = await et(e, a);
-      if (r) {
-        t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r }));
-        return;
+  ];
+}
+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 });
       }
-      const d = m.startBatchAudit();
-      if (!d.ok) {
-        t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: d.error }));
-        return;
+    },
+    // 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 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 (e.has(c.key)) {
+            p(i, 400, { error: `duplicate key: ${c.key}` });
+            return;
+          }
+          e.add(c.key);
+        }
+        const n = $(t, ".env"), l = await j(n);
+        await q(n, we(l, s)), p(i, 200, { ok: !0 });
       }
-      t.statusCode = 202, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      return;
     }
-    if (u.method === "POST" && g === "/api/agent/stop") {
-      const r = m.stop();
-      if (!r.ok) {
-        t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.error }));
-        return;
+  ];
+}
+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 });
       }
-      t.statusCode = 202, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      return;
-    }
-    if (u.method === "POST" && g === "/api/config") {
-      try {
-        const r = N(e, "papercamp", "config.json"), d = await P(r);
-        if (!d) {
-          t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "config not found" }));
-          return;
+    },
+    // POST /api/git/push — push the current branch to its upstream
+    {
+      method: "POST",
+      path: "/api/git/push",
+      handle: async (r, s) => {
+        try {
+          await a.push(), p(s, 200, { ok: !0 });
+        } catch (e) {
+          p(s, 400, { error: e.message });
         }
-        const y = await M(u), l = JSON.parse(y), { port: T, projectName: c, defaultAgent: o } = l, f = l.defaultAgents;
-        if (T !== void 0 && (!Number.isInteger(T) || T <= 0)) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "port must be a positive integer" }));
+      }
+    },
+    // 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;
+          }
+          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 (c !== void 0 && c.trim().length === 0) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "projectName must not be empty" }));
+        if (n === "clean") {
+          if ((await a.getStatus()).length > 0) {
+            p(s, 409, { error: "Working tree is no longer clean — refresh and retry" });
+            return;
+          }
+          await a.runGitSync(), p(s, 200, { ok: !0 });
           return;
         }
-        if (o !== void 0 && !Ot.includes(o)) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "defaultAgent must be a known agent id" }));
+        const l = i.startSync(Ye);
+        if (!l.ok) {
+          p(s, 409, { error: l.error });
           return;
         }
-        if (f !== void 0)
-          for (const O of ["phase", "planDraft", "ideaExtend", "commitSuggest"]) {
-            const A = f[O], H = typeof A == "string" ? A : A == null ? void 0 : A.agent;
-            if (!H || !Ot.includes(H)) {
-              t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: `defaultAgents.${O} must be a known agent id` }));
-              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 S = JSON.parse(d), I = (f ? {
-          phase: B(f.phase),
-          planDraft: B(f.planDraft),
-          ideaExtend: B(f.ideaExtend),
-          commitSuggest: B(f.commitSuggest)
-        } : void 0) ?? (o !== void 0 ? {
-          phase: { agent: o },
-          planDraft: { agent: o },
-          ideaExtend: { agent: o },
-          commitSuggest: { agent: o }
-        } : void 0), v = S, { defaultAgent: s, ...w } = v, C = {
-          ...w,
-          ...T !== void 0 && { port: T },
-          ...c !== void 0 && { projectName: c.trim() },
-          ...I && { defaultAgents: I }
-        };
-        await E(r, JSON.stringify(C, null, 2)), t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (r) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.message }));
+          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 });
+        }
       }
-      return;
     }
-    if (u.method === "GET" && g === "/api/env") {
-      try {
-        const r = N(e, ".env"), d = N(e, ".env.example"), [y, l] = await Promise.all([
-          ft(r),
-          ft(d)
-        ]), T = y ? Et(await P(r)) : [], c = l ? Et(await P(d)).map((S) => S.key) : [], o = new Set(T.map((S) => S.key)), f = c.filter((S) => !o.has(S));
-        t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ exists: y, exampleExists: l, entries: T, missingKeys: f }));
-      } catch (r) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.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 });
       }
-      return;
     }
-    if (u.method === "POST" && g === "/api/env") {
-      try {
-        const r = await M(u), { entries: d } = JSON.parse(r);
-        if (!Array.isArray(d)) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "entries is required" }));
+  ];
+}
+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 y = /* @__PURE__ */ new Set();
-        for (const c of d) {
-          if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(c.key)) {
-            t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: `invalid key: ${c.key}` }));
-            return;
-          }
-          if (y.has(c.key)) {
-            t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: `duplicate key: ${c.key}` }));
-            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);
           }
-          y.add(c.key);
-        }
-        const l = N(e, ".env"), T = await P(l);
-        await E(l, Vt(T, d)), t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (r) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.message }));
+          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 });
       }
-      return;
     }
-    if (u.method === "POST" && g === "/api/open-questions/resolve") {
-      try {
-        const d = new URL(u.url ?? "", `http://${u.headers.host ?? "localhost"}`).searchParams.get("title");
-        if (!(d != null && d.trim())) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "title is required" }));
+  ];
+}
+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 y = await M(u), { decision: l, rationale: T } = JSON.parse(y);
-        if (!(l != null && l.trim())) {
-          t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "decision is required" }));
+        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 c = x(e, "open-questions.md"), o = await P(c);
-        if (!o) {
-          t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "open-questions.md not found" }));
+        const d = $(e, `${c.id}.md`);
+        if (!await wt(d)) {
+          p(r, 404, { error: "plan file not found" });
           return;
         }
-        const f = It(o);
-        if (f.warnings.length > 0) {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(
-            JSON.stringify({
-              error: "open-questions.md has parse warnings — resolve them before updating to avoid data loss",
-              warnings: f.warnings.map((s) => `${s.title}: ${s.message}`)
-            })
-          );
+        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 S = d.trim(), b = f.entries.find((s) => s.title === S);
-        if (!b) {
-          t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: `open question "${S}" not found` }));
+        const c = await rt(t, a);
+        if (c) {
+          p(r, 409, { error: c });
           return;
         }
-        if (b.status !== "open") {
-          t.statusCode = 409, t.setHeader("Content-Type", "application/json"), t.end(
-            JSON.stringify({ error: `open question "${S}" is already ${b.status}` })
-          );
+        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 I = qt({
-          title: l.trim(),
-          date: Z(),
-          status: "decided",
-          body: T == null ? void 0 : T.trim()
+        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 te(x(e, "decisions.md"), I), b.status = "resolved", b.resolvedBy = l.trim();
-        const v = ee(f.entries);
-        await E(c, `${v}
-`, "utf-8"), t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0 }));
-      } catch (r) {
-        t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.message }));
+        await q($(h, `${f}.md`), `${y}
+`, "utf-8"), await Dt(t), p(r, 201, { ok: !0, id: f });
       }
-      return;
-    }
-    if (u.method === "GET" && g === "/api/configs") {
-      const d = new URL(u.url ?? "", `http://${u.headers.host ?? "localhost"}`).searchParams.get("name");
-      if (d)
-        try {
-          if (!je.includes(d)) {
-            t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "invalid config file name" }));
+    },
+    // 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;
+        }
+        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;
           }
-          const y = await P(N(e, d));
-          if (!y) {
-            t.statusCode = 404, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "config file not found" }));
-            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 {
           }
-          t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ name: d, content: y }));
-          return;
-        } catch (y) {
-          t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: y.message }));
+        }
+        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;
     }
-    const j = ke.find((r) => r.path === g);
-    if (!j) {
-      J();
+    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));
+    }
+  };
+}
+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 r = await j.handler(e);
-      t.statusCode = 200, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify(r));
-    } catch (r) {
-      t.statusCode = 500, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: r.message }));
+      p(d, 200, await y.handler(t));
+    } catch (g) {
+      p(d, 500, { error: g.message });
     }
   };
-  return $.agent = m, $;
+  return l.agent = e, l;
 }
-const xe = {
+const sn = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
   ".mjs": "text/javascript; charset=utf-8",
@@ -1733,301 +2165,304 @@ const xe = {
   ".woff": "font/woff",
   ".woff2": "font/woff2"
 };
-function Je() {
-  return N(zt(de(import.meta.url)), "..", "app");
+function rn() {
+  return $(de(Ie(import.meta.url)), "..", "app");
 }
-async function Ie({ root: e, port: i }) {
-  const a = Je(), p = N(a, "index.html"), n = await U(p, "utf-8").catch(() => null);
-  if (n === 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 ${a}. 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 h = ve(e);
-  async function m(t, J) {
-    const g = decodeURIComponent((t.url ?? "/").split("?")[0]), j = N(a, g === "/" ? "index.html" : g);
+  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 it(j)).isFile()) {
-        J.statusCode = 200, J.setHeader("Content-Type", xe[Yt(j)] ?? "application/octet-stream"), J.end(await U(j));
+      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 {
     }
-    J.statusCode = 200, J.setHeader("Content-Type", "text/html; charset=utf-8"), J.end(n);
+    u.statusCode = 200, u.setHeader("Content-Type", "text/html; charset=utf-8"), u.end(s);
   }
-  const $ = re((t, J) => {
-    h(t, J, () => {
-      m(t, J).catch((g) => {
-        J.statusCode = 500, J.end(String(g));
+  const l = xe((d, u) => {
+    e(d, u, () => {
+      n(d, u).catch((f) => {
+        u.statusCode = 500, u.end(String(f));
       });
     });
-  }), u = () => {
-    h.agent.killCurrent(), process.exit(0);
+  }), c = () => {
+    e.agent.killCurrent(), process.exit(0);
   };
-  process.on("SIGINT", u), process.on("SIGTERM", u), await new Promise((t) => $.listen(i, t));
+  process.on("SIGINT", c), process.on("SIGTERM", c), await new Promise((d, u) => {
+    l.once("error", u), l.listen(a, d);
+  });
 }
-async function $t(e) {
+async function Bt(t) {
   try {
-    return await it(e), !0;
+    return await ht(t), !0;
   } catch {
     return !1;
   }
 }
-async function He(e, i) {
-  const a = N(e, `${i}.md`);
-  if (await $t(a)) return a;
-  const p = N(e, "archive", `${i}.md`);
-  return await $t(p) ? p : null;
+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 Ae(e) {
+async function dn(t) {
   try {
-    return (await it(e)).mtime.toISOString().slice(0, 10);
+    return (await ht(t)).mtime.toISOString().slice(0, 10);
   } catch {
     return null;
   }
 }
-async function Pe(e, i) {
-  const a = await U(e, "utf-8"), n = dt(a).entries[0];
-  if (!n)
-    throw new Error(`Could not parse plan file after audit: ${e}`);
-  const h = {
-    id: i,
-    title: n.title,
-    kind: n.kind ?? "feat",
-    status: n.status,
-    idea: n.idea,
-    agent: n.agent,
-    created: n.created,
-    updated: n.updated,
-    audited: Z(),
-    tags: n.tags,
-    body: n.body,
-    phases: n.phases,
-    log: n.log,
-    clarifications: n.clarifications
+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
   };
-  await E(e, `${at(h)}
+  await q(t, `${xt(e)}
 `, "utf-8");
 }
-async function Ee(e, i, a, p) {
-  var m;
-  const n = Mt(i), h = V(a.command, a.buildArgs(n, p), {
-    cwd: e,
+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 h.stdout && jt({ input: h.stdout }).on("line", (u) => {
-    const t = a.parseLine(u);
-    t != null && t.text && t.text !== "Agent is working…" && process.stdout.write(`    ${t.text}
+  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}
 `);
-  }), (m = h.stderr) == null || m.on("data", ($) => process.stderr.write($)), new Promise(($) => {
-    h.on("close", (u) => $(u === 0)), h.on("error", () => $(!1));
+  }), (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 st = new Xt();
-st.name("paper-camp").description("Local-first, AI-native project companion.").version(ie);
-st.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 (e, i) => {
-  const a = process.cwd(), p = e ?? Qt(a);
+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 se(a, { projectName: p, intent: i.intent }), console.log(`Initialized Paper Camp in ${a}`), 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 (n) {
-    if (n instanceof oe) {
-      console.error(n.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 n;
+    throw s;
   }
 });
-st.command("dev").description("Start the local dashboard").option("-p, --port <number>", "port to listen on", "3333").action(async (e) => {
-  const i = Number(e.port), a = 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 Ie({ root: a, port: i }), console.log(`Paper Camp dashboard running at http://localhost:${i}`);
-  } catch (p) {
-    console.error(p.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);
   }
 });
-st.command("add <type> [name]").description("Add a new entry (currently supports: plan)").option("-k, --kind <kind>", `plan kind (${wt.join("|")})`, "feat").action(async (e, i, a) => {
-  if (e !== "plan") {
-    console.error(`Unknown type "${e}". 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 (!i) {
+  if (!a) {
     console.error("Usage: paper-camp add plan <name> [--kind feat|fix|chore|docs|refactor]"), process.exitCode = 1;
     return;
   }
-  if (!wt.includes(a.kind)) {
-    console.error(`Unknown kind "${a.kind}". Supported kinds: ${wt.join(", ")}`), process.exitCode = 1;
+  if (!Et.includes(i.kind)) {
+    console.error(`Unknown kind "${i.kind}". Supported kinds: ${Et.join(", ")}`), process.exitCode = 1;
     return;
   }
-  const p = a.kind, n = process.cwd(), h = nt(n, "papercamp", "config.json"), m = await Bt(h, p);
-  if (!m) {
+  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 $ = nt(n, "papercamp", "plans");
-  await q($, { recursive: !0 });
-  const u = at({
-    id: m,
-    title: i,
-    kind: p,
+  const l = ft(s, "papercamp", "plans");
+  await ut(l, { recursive: !0 });
+  const c = xt({
+    id: n,
+    title: a,
+    kind: r,
     status: "idea",
-    created: Z()
+    created: ot()
   });
-  await E(N($, `${m}.md`), `${u}
+  await q($(l, `${n}.md`), `${c}
 `, "utf-8");
-  const { entries: t } = await Q($);
-  await E(N($, "index.md"), Ht(t), "utf-8"), console.log(`Added plan "${i}" (${m}) to papercamp/plans/${m}.md`);
+  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`);
 });
-st.command("migrate").description(
+yt.command("migrate").description(
   "One-time migration: split monolithic plans.md/ideas.md into per-file YAML frontmatter entries"
 ).action(async () => {
-  const e = process.cwd(), i = nt(e, "papercamp", "plans"), a = N(i, "archive"), p = nt(e, "papercamp", "ideas");
-  await q(a, { recursive: !0 }), await q(p, { recursive: !0 });
-  const n = nt(e, "papercamp", "plans.md"), h = nt(e, "papercamp", "ideas.md");
-  let m = 0, $ = 0, u = 0;
-  const t = await U(n, "utf-8").catch(() => "");
-  if (t.trim()) {
-    const { entries: l, warnings: T } = vt(t);
-    u = T.length;
-    for (const c of T)
-      console.warn(`  warning: ${c.title}: ${c.message}`);
-    for (const c of l) {
-      if (!c.id) {
-        console.warn(`  skipping plan "${c.title}" — no Id assigned, cannot migrate`), $++;
+  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 o = c.status === "done" || c.status === "dropped" ? a : i, f = N(o, `${c.id}.md`);
-      if (await $t(f)) {
-        $++;
+      const m = S.status === "done" || S.status === "dropped" ? i : a, w = $(m, `${S.id}.md`);
+      if (await Bt(w)) {
+        l++;
         continue;
       }
-      const S = at({
-        id: c.id,
-        title: c.title,
-        kind: c.kind ?? "feat",
-        status: c.status,
-        idea: c.idea,
-        agent: c.agent,
-        created: c.created,
-        updated: c.updated,
-        tags: c.tags,
-        body: c.body,
-        phases: c.phases,
-        log: c.log,
-        clarifications: c.clarifications
+      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 E(f, `${S}
-`, "utf-8"), m++;
+      await q(w, `${I}
+`, "utf-8"), n++;
     }
   }
-  let J = 0, g = 0;
-  const j = await U(h, "utf-8").catch(() => "");
-  if (j.trim()) {
-    const l = Jt(j);
-    for (const T of l) {
-      if (!T.id) {
-        console.warn(`  skipping idea "${T.title}" — no Id assigned, cannot migrate`), g++;
+  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 c = N(p, `${T.id}.md`);
-      if (await $t(c)) {
-        g++;
+      const S = $(r, `${D.id}.md`);
+      if (await Bt(S)) {
+        f++;
         continue;
       }
-      const o = T.body.replace(/^#{1,3}\s+.+(?:\r?\n)?/, "").trim(), f = Ft({ id: T.id, title: T.title, body: o });
-      await E(c, `${f}
-`, "utf-8"), J++;
+      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: r } = await Q(i);
-  await E(N(i, "index.md"), Ht(r), "utf-8");
-  const { entries: d } = await xt(p), y = Kt(d, r);
-  await E(N(p, "index.md"), _t(y), "utf-8"), m > 0 && $ === 0 && u === 0 && await E(n, "", "utf-8"), J > 0 && g === 0 && await E(h, "", "utf-8"), console.log(
-    `Migrated ${m} plans (${$} skipped), ${J} ideas (${g} skipped).`
+  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).`
   );
 });
-st.command("audit").description("Audit all review/done plans for missing phases").action(async () => {
-  var c;
-  const e = process.cwd(), i = nt(e, "papercamp", "plans"), { entries: a, warnings: p } = await Q(i);
-  for (const o of p)
-    console.warn(`  warning: ${o.title}: ${o.message}`);
-  const n = a.filter((o) => o.status === "review" || o.status === "done");
-  if (n.length === 0) {
+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 h = await U(N(e, "papercamp", "config.json"), "utf-8").catch(
+  const e = await at($(t, "papercamp", "config.json"), "utf-8").catch(
     () => "{}"
   );
-  let m;
+  let n;
   try {
-    m = JSON.parse(h);
+    n = JSON.parse(e);
   } catch {
     console.error("Invalid papercamp/config.json"), process.exitCode = 1;
     return;
   }
-  const $ = m.defaultAgents, u = $ ? {
-    phase: B($.phase),
-    planDraft: B($.planDraft),
-    ideaExtend: B($.ideaExtend),
-    commitSuggest: B($.commitSuggest)
-  } : kt, { adapter: t, model: J, effort: g } = St({ defaultAgents: u, taskKind: "audit" });
-  console.log(`Auditing ${n.length} plan(s):
+  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 j = [];
-  for (const o of n) {
-    const f = o.id ?? "(no id)", S = f.padEnd(14);
-    if (!o.id) {
-      console.log(`  [skip]  ${S} ${o.title} — no id`), j.push({ id: f, title: o.title, status: "skipped", skipReason: "no id" });
+  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 b = await He(i, o.id);
-    if (!b) {
-      console.log(`  [skip]  ${S} ${o.title} — file not found`), j.push({ id: f, title: o.title, status: "skipped", skipReason: "file not found" });
+    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 (o.audited) {
-      const s = await Ae(b);
-      if (s && o.audited >= s) {
+    if (m.audited) {
+      const B = await dn(T);
+      if (B && m.audited >= B) {
         console.log(
-          `  [skip]  ${S} ${o.title} — audited ${o.audited}, unchanged since`
-        ), j.push({
-          id: f,
-          title: o.title,
+          `  [skip]  ${I} ${m.title} — audited ${m.audited}, unchanged since`
+        ), h.push({
+          id: w,
+          title: m.title,
           status: "skipped",
-          skipReason: `audited ${o.audited}, unchanged`
+          skipReason: `audited ${m.audited}, unchanged`
         });
         continue;
       }
     }
-    const I = o.phases.length;
-    if (console.log(`  [audit] ${S} ${o.title}`), await Ee(e, o, t, { model: J, effort: g })) {
+    const O = m.phases.length;
+    if (console.log(`  [audit] ${I} ${m.title}`), await un(t, m, d, { model: u, effort: f })) {
       try {
-        await Pe(b, o.id);
-      } catch (A) {
-        console.log(`  [fail]  ${S} ${o.title} — ${A.message}`), process.exitCode = 1, j.push({ id: f, title: o.title, status: "failed" });
+        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 s = await U(b, "utf-8").catch(() => ""), C = ((c = dt(s).entries[0]) == null ? void 0 : c.phases.length) ?? I, O = Math.max(0, C - I);
-      console.log(`  [done]  ${S} ${o.title}`), j.push({ id: f, title: o.title, status: "audited", gapPhases: O });
+      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]  ${S} ${o.title} — agent exited with error`), process.exitCode = 1, j.push({ id: f, title: o.title, status: "failed" });
+      console.log(`  [fail]  ${I} ${m.title} — agent exited with error`), process.exitCode = 1, h.push({ id: w, title: m.title, status: "failed" });
   }
-  const r = j.filter((o) => o.status === "audited"), d = j.filter((o) => o.status === "skipped"), y = j.filter((o) => o.status === "failed"), l = r.reduce((o, f) => o + (f.gapPhases ?? 0), 0), T = "─".repeat(43);
+  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(`
-${T}`), console.log("Audit summary"), console.log(
-    `  Audited : ${r.length}   Skipped : ${d.length}   Failed : ${y.length}`
-  ), r.length > 0)
-    if (l > 0) {
-      console.log(`  Gap phases appended: ${l} total`);
-      for (const o of r.filter((f) => (f.gapPhases ?? 0) > 0))
-        console.log(`    ${o.id.padEnd(14)} +${o.gapPhases} phase(s)`);
+${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 (d.length > 0) {
+  if (g.length > 0) {
     console.log("  Skipped:");
-    for (const o of d)
-      console.log(`    ${o.id.padEnd(14)} ${o.skipReason}`);
+    for (const m of g)
+      console.log(`    ${m.id.padEnd(14)} ${m.skipReason}`);
   }
-  console.log(T);
+  console.log(D);
 });
-st.parseAsync(process.argv);
+yt.parseAsync(process.argv);
 //# sourceMappingURL=index.js.map