qualia-framework 3.4.0 → 4.0.0

package/bin/state.js

@@ -8,13 +8,98 @@ const path = require("path");
 const PLANNING = ".planning";
 const STATE_FILE = path.join(PLANNING, "STATE.md");
 const TRACKING_FILE = path.join(PLANNING, "tracking.json");
+const LOCK_FILE = path.join(PLANNING, ".state.lock");
+
+// ─── Atomic write (tmp + rename) ─────────────────────────
+// Prevents half-written files when SIGINT, OOM, or AV scanners
+// interrupt mid-write. Same-filesystem rename is atomic on POSIX
+// and best-effort atomic on Windows (NTFS replaces in one syscall).
+function atomicWrite(file, content) {
+  const tmp = `${file}.tmp.${process.pid}`;
+  fs.writeFileSync(tmp, content);
+  try {
+    fs.renameSync(tmp, file);
+  } catch (err) {
+    // Cleanup tmp on failure (Windows EBUSY, EPERM, etc.)
+    try { fs.unlinkSync(tmp); } catch {}
+    throw err;
+  }
+}
+
+// ─── Exclusive lock ──────────────────────────────────────
+// Prevents two concurrent state.js mutations from racing on the dual
+// STATE.md + tracking.json write. Read commands (check, validate-plan)
+// don't take the lock — only mutators do.
+function acquireLock(timeoutMs = 5000) {
+  if (!fs.existsSync(PLANNING)) return null; // nothing to lock yet
+  const start = Date.now();
+  const ours = `${process.pid}@${new Date().toISOString()}`;
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const fd = fs.openSync(LOCK_FILE, "wx");
+      fs.writeSync(fd, ours);
+      fs.closeSync(fd);
+      return LOCK_FILE;
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      // Stale lock? If older than 30s, steal it.
+      try {
+        const stat = fs.statSync(LOCK_FILE);
+        if (Date.now() - stat.mtimeMs > 30_000) {
+          fs.unlinkSync(LOCK_FILE);
+          continue;
+        }
+      } catch {}
+      // Spin-wait briefly. State ops are fast; conflicts rare.
+      const t = Date.now() + 50;
+      while (Date.now() < t) {}
+    }
+  }
+  // Couldn't acquire — proceed unlocked rather than block the user.
+  return null;
+}
+
+function releaseLock(lock) {
+  if (!lock) return;
+  try { fs.unlinkSync(lock); } catch {}
+}
 
 // ─── Trace ──────────────────────────────────────────────
-function _trace(event, data) {
+// Signature normalized: _trace(event, result, data?). Old callers passed
+// (event, data) with `result` as a string in `data` — that produced
+// nonsense JSONL ({0:"a",1:"l",2:"l",...}). Always use the 3-arg form.
+//
+// Log rotation: trace files older than TRACE_RETENTION_DAYS are pruned
+// on every write. Heavy users used to accumulate unbounded MB/day in
+// ~/.claude/.qualia-traces/. The prune is best-effort and never throws.
+const TRACE_RETENTION_DAYS = 30;
+
+function _pruneTraces(traceDir) {
+  try {
+    const cutoff = Date.now() - TRACE_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+    for (const name of fs.readdirSync(traceDir)) {
+      if (!name.endsWith(".jsonl")) continue;
+      const p = path.join(traceDir, name);
+      try {
+        const stat = fs.statSync(p);
+        if (stat.mtimeMs < cutoff) fs.unlinkSync(p);
+      } catch {}
+    }
+  } catch {}
+}
+
+function _trace(event, result, data) {
   try {
     const traceDir = path.join(require("os").homedir(), ".claude", ".qualia-traces");
     if (!fs.existsSync(traceDir)) fs.mkdirSync(traceDir, { recursive: true });
-    const entry = { hook: event, timestamp: new Date().toISOString(), ...data };
+    // Prune ~1% of the time (cheap on most invocations, bounded over time).
+    if (Math.random() < 0.01) _pruneTraces(traceDir);
+    const entry = {
+      hook: event,
+      result: result || "allow",
+      timestamp: new Date().toISOString(),
+      ...(data && typeof data === "object" ? data : {}),
+    };
     const file = path.join(traceDir, `${new Date().toISOString().split("T")[0]}.jsonl`);
     fs.appendFileSync(file, JSON.stringify(entry) + "\n");
   } catch { /* trace failures must not disrupt state machine */ }
@@ -48,13 +133,15 @@ function readTracking() {
 }
 
 function writeTracking(t) {
-  fs.writeFileSync(TRACKING_FILE, JSON.stringify(t, null, 2) + "\n");
+  atomicWrite(TRACKING_FILE, JSON.stringify(t, null, 2) + "\n");
 }
 
 // Ensure lifetime + milestone fields exist (backward compat for old tracking files)
 function ensureLifetime(t) {
   if (!t) return t;
   if (typeof t.milestone !== "number") t.milestone = 1;
+  if (typeof t.milestone_name !== "string") t.milestone_name = "";
+  if (!Array.isArray(t.milestones)) t.milestones = [];
   if (!t.lifetime || typeof t.lifetime !== "object") {
     t.lifetime = {
       tasks_completed: 0,
@@ -79,14 +166,17 @@ function parseStateMd(content) {
   if (!content) return null;
   const schema_errors = [];
   const get = (prefix) => {
-    const m = content.match(new RegExp(`^${prefix}:\\s*(.+)$`, "m"));
+    // CRLF tolerance: Windows editors save with `\r\n`. Use `(.+?)\r?$` so
+    // the `\r` is consumed, not captured. `.trim()` is still applied as
+    // belt-and-suspenders for any other trailing whitespace.
+    const m = content.match(new RegExp(`^${prefix}:\\s*(.+?)\\r?$`, "m"));
     return m ? m[1].trim() : "";
   };
   const hasField = (prefix) =>
     new RegExp(`^${prefix}:\\s*`, "m").test(content);
 
   const phaseMatch = content.match(
-    /^Phase:\s*(\d+)\s+of\s+(\d+)\s*[—-]\s*(.+)$/m
+    /^Phase:\s*(\d+)\s+of\s+(\d+)\s*[—-]\s*(.+?)\r?$/m
   );
   if (!phaseMatch) {
     schema_errors.push({
@@ -198,7 +288,7 @@ Last session: ${now}
 Last worked by: ${s.assigned_to}
 Resume: ${s.resume || "—"}
 `;
-  fs.writeFileSync(STATE_FILE, md);
+  atomicWrite(STATE_FILE, md);
 }
 
 // ─── Precondition Checks ─────────────────────────────────
@@ -257,9 +347,13 @@ function checkPreconditions(current, target, opts) {
     const taskHeaders = planContent.match(/^## Task \d+/gm);
     if (!taskHeaders || taskHeaders.length === 0)
       return fail("INVALID_PLAN", "Plan file has no task headers (expected '## Task N')");
+    // Accept either legacy "**Done when:**" or story-file "**Acceptance Criteria:**"
+    // so old in-flight plans don't break on upgrade.
     const doneWhenCount = (planContent.match(/\*\*Done when:\*\*/g) || []).length;
-    if (doneWhenCount < taskHeaders.length)
-      return fail("INVALID_PLAN", `${taskHeaders.length} tasks but only ${doneWhenCount} 'Done when:' entries`);
+    const acCount = (planContent.match(/\*\*Acceptance Criteria:\*\*/g) || []).length;
+    const anchors = doneWhenCount + acCount;
+    if (anchors < taskHeaders.length)
+      return fail("INVALID_PLAN", `${taskHeaders.length} tasks but only ${anchors} 'Done when:' or 'Acceptance Criteria:' anchors`);
   }
 
   if (target === "verified") {
@@ -348,6 +442,8 @@ function cmdCheck(opts) {
     status: s.status,
     assigned_to: s.assigned_to,
     milestone: t.milestone || 1,
+    milestone_name: t.milestone_name || "",
+    milestones: t.milestones || [],
     lifetime: t.lifetime,
     verification: t.verification || "pending",
     gap_cycles: (t.gap_cycles || {})[String(s.phase)] || 0,
@@ -462,6 +558,7 @@ function cmdTransition(opts) {
     t.tasks_done = parseInt(opts.tasks_done) || 0;
     t.tasks_total = parseInt(opts.tasks_total) || 0;
     t.wave = parseInt(opts.wave) || 0;
+    t.build_count = (parseInt(t.build_count) || 0) + 1;
     s.last_activity = `Phase ${phase} built (${t.tasks_done}/${t.tasks_total} tasks)`;
     if (s.phases[phase - 1]) s.phases[phase - 1].status = "built";
   }
@@ -498,12 +595,22 @@ function cmdTransition(opts) {
   }
 
   if (target === "polished") {
-    if (s.phases[s.phases.length - 1])
-      s.phases[s.phases.length - 1].status = "verified";
+    // Mark every passed phase as polished (polish is a whole-project pass).
+    // Previously only the last roadmap row was touched, and was set to
+    // "verified" — which both lost current-phase context and used the wrong
+    // status string. Now we use "polished" on every row that's already at
+    // verified or polished or completed.
+    for (const p of s.phases) {
+      const st = (p.status || "").toLowerCase();
+      if (st === "verified" || st === "polished" || st === "completed" || st === "complete") {
+        p.status = "polished";
+      }
+    }
   }
 
   if (target === "shipped") {
     t.deployed_url = opts.deployed_url || "";
+    t.deploy_count = (parseInt(t.deploy_count) || 0) + 1;
   }
 
   // Write both files
@@ -512,21 +619,18 @@ function cmdTransition(opts) {
     writeStateMd(s);
     writeTracking(t);
   } catch (e) {
-    // Revert STATE.md on failure
-    if (backupState) fs.writeFileSync(STATE_FILE, backupState);
+    // Revert STATE.md on failure (atomic so the revert itself is safe)
+    if (backupState) atomicWrite(STATE_FILE, backupState);
     return output(fail("WRITE_ERROR", e.message));
   }
 
   // Skill outcome scoring — log transition for analytics
-  _trace("state-transition", {
-    result: "allow",
+  _trace("state-transition", "allow", {
     phase: s.phase,
     status: s.status,
     previous_status: prevStatus,
     verification: t.verification,
     gap_closure: prevStatus === "verified" && target === "planned",
-    duration_ms: 0,
-    extra: { verification: t.verification, gap_closure: prevStatus === "verified" && target === "planned" }
   });
 
   output({
@@ -544,6 +648,19 @@ function cmdTransition(opts) {
 function cmdInit(opts) {
   if (!opts.project) return output(fail("MISSING_ARG", "--project required"));
 
+  // Refuse to clobber an active project unless --force.
+  // Lifetime preservation runs lower in this fn — but current-phase fields
+  // (phase, status, wave, tasks_done, tasks_total, gap_cycles) ARE wiped
+  // on init, which is a footgun for an in-progress project.
+  if (!opts.force && fs.existsSync(STATE_FILE)) {
+    return output(
+      fail(
+        "ALREADY_INITIALIZED",
+        "Project already initialized at .planning/STATE.md. Use --force to re-initialize (preserves lifetime, resets current phase)."
+      )
+    );
+  }
+
   // Parse phases
   let phases = [];
   if (opts.phases) {
@@ -591,13 +708,35 @@ function cmdInit(opts) {
     resume: "—",
   };
 
-  // Build tracking — current-phase fields reset, lifetime fields preserved
+  // Defensive lifetime hydrate: even if `prevLife.lifetime` is partial (an
+  // older tracking.json missing some keys), the spread would leave gaps that
+  // later `+=` would NaN. Build with safe defaults, then overlay.
+  const defaultLifetime = {
+    tasks_completed: 0,
+    phases_completed: 0,
+    milestones_completed: 0,
+    total_phases: 0,
+    last_closed_milestone: 0,
+  };
+  const lifetime = prevLife
+    ? { ...defaultLifetime, ...(prevLife.lifetime || {}) }
+    : { ...defaultLifetime };
+
+  // Preserve milestones array across re-init (v4: milestone summaries for ERP tree).
+  const prevMilestones = (prevLife && Array.isArray(prevLife.milestones)) ? prevLife.milestones : [];
+
+  // Build tracking — current-phase fields reset, lifetime + identity preserved
   const t = {
     project: opts.project,
     client: opts.client || (prevLife ? prevLife.client : ""),
     type: opts.type || (prevLife ? prevLife.type : ""),
     assigned_to: opts.assigned_to || (prevLife ? prevLife.assigned_to : ""),
+    team_id: opts.team_id || (prevLife ? prevLife.team_id || "" : ""),
+    project_id: opts.project_id || (prevLife ? prevLife.project_id || "" : ""),
+    git_remote: opts.git_remote || (prevLife ? prevLife.git_remote || "" : ""),
     milestone: prevLife ? prevLife.milestone : 1,
+    milestone_name: opts.milestone_name || (prevLife ? prevLife.milestone_name || "" : ""),
+    milestones: prevMilestones,
     phase: 1,
     phase_name: phases[0].name,
     total_phases: totalPhases,
@@ -608,16 +747,16 @@ function cmdInit(opts) {
     verification: "pending",
     gap_cycles: {},
     blockers: [],
+    session_started_at: now,
     last_updated: now,
+    last_pushed_at: prevLife ? prevLife.last_pushed_at || "" : "",
     last_commit: prevLife ? prevLife.last_commit : "",
+    build_count: prevLife ? (prevLife.build_count || 0) : 0,
+    deploy_count: prevLife ? (prevLife.deploy_count || 0) : 0,
     deployed_url: prevLife ? prevLife.deployed_url : "",
     notes: "",
-    lifetime: prevLife ? { ...prevLife.lifetime } : {
-      tasks_completed: 0,
-      phases_completed: 0,
-      milestones_completed: 0,
-      total_phases: 0,
-    },
+    submitted_by: opts.assigned_to || (prevLife ? prevLife.submitted_by || "" : ""),
+    lifetime,
   };
   // lifetime.total_phases starts at 0 for new projects. It accumulates only via
   // close-milestone (which adds current total_phases before the next init).
@@ -730,12 +869,15 @@ function cmdValidatePlan(opts) {
     errors.push("No task headers found (expected '## Task N — title')");
   }
 
-  // Check "Done when" exists for each task
+  // Check "Done when" OR "Acceptance Criteria" anchor exists for each task
+  // (story-file format uses Acceptance Criteria; legacy format uses Done when)
   const taskCount = taskHeaders ? taskHeaders.length : 0;
   const doneWhenCount = (content.match(/\*\*Done when:\*\*/g) || []).length;
-  if (doneWhenCount < taskCount) {
+  const acCount = (content.match(/\*\*Acceptance Criteria:\*\*/g) || []).length;
+  const anchors = doneWhenCount + acCount;
+  if (anchors < taskCount) {
     errors.push(
-      `${taskCount} tasks but only ${doneWhenCount} 'Done when:' entries`
+      `${taskCount} tasks but only ${anchors} 'Done when:' or 'Acceptance Criteria:' anchors`
     );
   }
 
@@ -834,12 +976,17 @@ function cmdValidatePlan(opts) {
     phase,
     task_count: taskCount,
     done_when_count: doneWhenCount,
+    ac_count: acCount,
     contract_count: contractCount,
     warnings: warnings.length > 0 ? warnings : undefined,
   });
 }
 
 // ─── Close Milestone ─────────────────────────────────────
+// Idempotent: a sentinel `lifetime.last_closed_milestone` records the most
+// recently closed milestone so re-running close-milestone (e.g., after a
+// hiccup) does NOT double-count. To re-close a milestone deliberately, pass
+// --force.
 function cmdCloseMilestone(opts) {
   const t = readTracking();
   const s = parseStateMd(readState());
@@ -849,9 +996,89 @@ function cmdCloseMilestone(opts) {
   ensureLifetime(t);
 
   const closedMilestone = t.milestone || 1;
+  if (
+    !opts.force &&
+    typeof t.lifetime.last_closed_milestone === "number" &&
+    t.lifetime.last_closed_milestone >= closedMilestone
+  ) {
+    return output(
+      fail(
+        "ALREADY_CLOSED",
+        `Milestone ${closedMilestone} was already closed (last_closed_milestone=${t.lifetime.last_closed_milestone}). Use --force to close again.`
+      )
+    );
+  }
+
+  // ─── v4 guard rails ─────────────────────────────────────
+  // A milestone is only closable if it actually acted like one:
+  //   (a) all its phases are verified/polished/completed, AND
+  //   (b) it had ≥ 2 phases (so a 1-phase "milestone" is forced back to being a phase).
+  // Both guards are bypassable with --force for retroactive bookkeeping.
+  if (!opts.force) {
+    const totalPhases = parseInt(t.total_phases) || s.phases.length || 0;
+    if (totalPhases < 2) {
+      return output(
+        fail(
+          "MILESTONE_TOO_SMALL",
+          `Milestone ${closedMilestone} has only ${totalPhases} phase(s). A milestone needs ≥ 2 phases OR must be a shipped release gate. Use --force if this is intentional (e.g. a preview/demo milestone).`
+        )
+      );
+    }
+    const unfinished = s.phases.filter((p) => {
+      const st = (p.status || "").toLowerCase();
+      return !(st === "verified" || st === "polished" || st === "completed" || st === "complete");
+    });
+    if (unfinished.length > 0) {
+      return output(
+        fail(
+          "MILESTONE_NOT_READY",
+          `Milestone ${closedMilestone} has ${unfinished.length} unfinished phase(s): ${unfinished.map((p) => `${p.num}:${p.name}`).join(", ")}. Verify them first, or use --force.`
+        )
+      );
+    }
+  }
+
+  // ─── Append a summary to milestones[] so the ERP can render the tree ──
+  // This is the minimal metadata needed to reconstruct "milestone N of the
+  // project contained these phases" without replaying git history.
+  const phasesCompleted = s.phases.filter((p) => {
+    const st = (p.status || "").toLowerCase();
+    return st === "verified" || st === "polished" || st === "completed" || st === "complete";
+  }).length;
+  // tasks_completed for THIS milestone = lifetime.tasks_completed minus the
+  // sum of tasks already counted in prior milestones[] entries. This gives
+  // the correct per-milestone count even though `t.tasks_done` only reflects
+  // the current phase, not the cumulative milestone total.
+  const priorMilestoneTasks = Array.isArray(t.milestones)
+    ? t.milestones.reduce((sum, m) => sum + (parseInt(m && m.tasks_completed) || 0), 0)
+    : 0;
+  const tasksCompletedThisMilestone = Math.max(
+    0,
+    (parseInt(t.lifetime && t.lifetime.tasks_completed) || 0) - priorMilestoneTasks
+  );
+  const summary = {
+    num: closedMilestone,
+    name: t.milestone_name || `Milestone ${closedMilestone}`,
+    total_phases: parseInt(t.total_phases) || s.phases.length || 0,
+    phases_completed: phasesCompleted,
+    tasks_completed: tasksCompletedThisMilestone,
+    shipped_url: t.deployed_url || "",
+    closed_at: new Date().toISOString(),
+  };
+  t.milestones = Array.isArray(t.milestones) ? t.milestones : [];
+  // Idempotency: don't duplicate if the same milestone number is already logged.
+  const existing = t.milestones.findIndex((m) => m && m.num === closedMilestone);
+  if (existing >= 0) {
+    t.milestones[existing] = summary;
+  } else {
+    t.milestones.push(summary);
+  }
+
   t.lifetime.milestones_completed += 1;
   t.lifetime.total_phases += (parseInt(t.total_phases) || 0);
+  t.lifetime.last_closed_milestone = closedMilestone;
   t.milestone = closedMilestone + 1;
+  t.milestone_name = ""; // cleared; /qualia-milestone reads next one from JOURNEY.md
   t.last_updated = new Date().toISOString();
 
   writeTracking(t);
@@ -871,6 +1098,83 @@ function cmdCloseMilestone(opts) {
   });
 }
 
+// ─── Backfill Lifetime ───────────────────────────────────
+// Reconstructs lifetime counters from STATE.md roadmap + plan files.
+// Safe to run multiple times (idempotent — recalculates from source).
+function cmdBackfillLifetime(opts) {
+  const t = readTracking();
+  const s = parseStateMd(readState());
+  if (!t || !s) {
+    return output(fail("NO_PROJECT", "No .planning/ found."));
+  }
+  ensureLifetime(t);
+
+  let phasesCompleted = 0;
+  let tasksCompleted = 0;
+
+  // Count completed phases from roadmap table
+  for (const p of s.phases) {
+    const st = (p.status || "").toLowerCase();
+    if (st === "verified" || st === "completed" || st === "complete") {
+      phasesCompleted++;
+
+      // Count tasks from that phase's plan file
+      const planFile = path.join(PLANNING, `phase-${p.num}-plan.md`);
+      const gapsPlanFile = path.join(PLANNING, `phase-${p.num}-gaps-plan.md`);
+      for (const f of [planFile, gapsPlanFile]) {
+        try {
+          if (fs.existsSync(f)) {
+            const content = fs.readFileSync(f, "utf8");
+            const taskHeaders = content.match(/^## Task \d+/gm);
+            if (taskHeaders) tasksCompleted += taskHeaders.length;
+          }
+        } catch {}
+      }
+    }
+  }
+
+  // Also count the current phase if it's past built (tasks exist but phase not yet verified)
+  const currentStatus = (t.status || "").toLowerCase();
+  if (currentStatus === "built" || currentStatus === "verified") {
+    // Current phase tasks are already in t.tasks_done — add if not already counted
+    const currentPhaseAlreadyCounted = s.phases.some(
+      (p) => p.num === t.phase && ["verified", "completed", "complete"].includes((p.status || "").toLowerCase())
+    );
+    if (!currentPhaseAlreadyCounted && t.tasks_done > 0) {
+      tasksCompleted += t.tasks_done;
+    }
+  }
+
+  const previous = { ...t.lifetime };
+
+  // Use Math.max — backfill must NEVER reduce lifetime counters. If the user
+  // ran close-milestone previously (rolling phases into lifetime) and then
+  // calls backfill, the recomputed value reflects only the current milestone
+  // and would otherwise destroy the historical accumulation.
+  t.lifetime.phases_completed = Math.max(t.lifetime.phases_completed || 0, phasesCompleted);
+  t.lifetime.tasks_completed = Math.max(t.lifetime.tasks_completed || 0, tasksCompleted);
+  // total_phases is accumulated by close-milestone only — backfill leaves it.
+  t.last_updated = new Date().toISOString();
+
+  writeTracking(t);
+
+  _trace("backfill-lifetime", "allow", {
+    previous,
+    computed: t.lifetime,
+    phases_scanned: s.phases.length,
+  });
+
+  output({
+    ok: true,
+    action: "backfill-lifetime",
+    previous,
+    computed: t.lifetime,
+    phases_scanned: s.phases.length,
+    phases_completed: phasesCompleted,
+    tasks_completed: tasksCompleted,
+  });
+}
+
 // ─── Output ──────────────────────────────────────────────
 function output(obj) {
   console.log(JSON.stringify(obj, null, 2));
@@ -881,30 +1185,51 @@ function output(obj) {
 const [cmd, ...rest] = process.argv.slice(2);
 const opts = parseArgs(rest);
 
-switch (cmd) {
-  case "check":
-    cmdCheck(opts);
-    break;
-  case "transition":
-    cmdTransition(opts);
-    break;
-  case "init":
-    cmdInit(opts);
-    break;
-  case "fix":
-    cmdFix(opts);
-    break;
-  case "validate-plan":
-    cmdValidatePlan(opts);
-    break;
-  case "close-milestone":
-    cmdCloseMilestone(opts);
-    break;
-  default:
-    output(
-      fail(
-        "UNKNOWN_COMMAND",
-        `Usage: state.js <check|transition|init|fix|validate-plan> [--options]`
-      )
-    );
+// Mutators must hold the .planning/.state.lock for the duration of their
+// dual STATE.md + tracking.json writes. Read commands (check, validate-plan)
+// don't need the lock. The lock is best-effort: if it can't be acquired
+// inside acquireLock's timeout, the command proceeds anyway — we'd rather
+// risk a rare race than hard-block the user.
+const READ_ONLY = new Set(["check", "validate-plan"]);
+let __lock = null;
+if (!READ_ONLY.has(cmd)) {
+  __lock = acquireLock();
+  process.on("exit", () => releaseLock(__lock));
+  process.on("SIGINT", () => { releaseLock(__lock); process.exit(130); });
+  process.on("SIGTERM", () => { releaseLock(__lock); process.exit(143); });
+}
+
+try {
+  switch (cmd) {
+    case "check":
+      cmdCheck(opts);
+      break;
+    case "transition":
+      cmdTransition(opts);
+      break;
+    case "init":
+      cmdInit(opts);
+      break;
+    case "fix":
+      cmdFix(opts);
+      break;
+    case "validate-plan":
+      cmdValidatePlan(opts);
+      break;
+    case "close-milestone":
+      cmdCloseMilestone(opts);
+      break;
+    case "backfill-lifetime":
+      cmdBackfillLifetime(opts);
+      break;
+    default:
+      output(
+        fail(
+          "UNKNOWN_COMMAND",
+          `Usage: state.js <check|transition|init|fix|validate-plan|close-milestone|backfill-lifetime> [--options]`
+        )
+      );
+  }
+} finally {
+  releaseLock(__lock);
 }

package/bin/statusline.js

@@ -93,35 +93,55 @@ try {
     let branch = "";
     let changes = 0;
     try {
-      const dirCheck = spawnSync("git", ["rev-parse", "--git-dir"], {
+      // Single git spawn: `status -b --porcelain=v1` returns branch on the
+      // first line (`## branch.name...`) and one change per subsequent line.
+      // Three separate git spawns cost ~450ms on Windows; this collapses to one.
+      const st = spawnSync("git", ["status", "-b", "--porcelain=v1"], {
         cwd: DIR,
         encoding: "utf8",
         timeout: 1000,
         stdio: ["ignore", "pipe", "ignore"],
+        shell: process.platform === "win32",
       });
-      if (dirCheck.status === 0) {
-        const br = spawnSync("git", ["branch", "--show-current"], {
-          cwd: DIR,
-          encoding: "utf8",
-          timeout: 1000,
-          stdio: ["ignore", "pipe", "ignore"],
-        });
-        if (br.status === 0) branch = (br.stdout || "").trim();
-
-        const st = spawnSync("git", ["status", "--porcelain"], {
-          cwd: DIR,
-          encoding: "utf8",
-          timeout: 1000,
-          stdio: ["ignore", "pipe", "ignore"],
-        });
-        if (st.status === 0) {
-          const out = (st.stdout || "").trim();
-          changes = out ? out.split("\n").length : 0;
+      if (st.status === 0) {
+        const lines = (st.stdout || "").split("\n");
+        const header = lines[0] || "";
+        if (header.startsWith("## ")) {
+          // Possible forms:
+          //   "## main"
+          //   "## main...origin/main"
+          //   "## main...origin/main [ahead 1, behind 2]"
+          //   "## HEAD (no branch)"  ← detached
+          //   "## No commits yet on main"
+          let raw = header.slice(3);
+          const ellipsisIdx = raw.indexOf("...");
+          if (ellipsisIdx !== -1) raw = raw.slice(0, ellipsisIdx);
+          // Strip any trailing "[ahead/behind]" annotation that survived
+          raw = raw.replace(/\s*\[.*\]\s*$/, "").trim();
+          if (raw === "HEAD (no branch)") {
+            branch = "HEAD";
+          } else if (raw.startsWith("No commits yet on ")) {
+            branch = raw.slice("No commits yet on ".length).trim();
+          } else {
+            branch = raw;
+          }
+        }
+        // Count change lines: every non-empty line after the header
+        for (let i = 1; i < lines.length; i++) {
+          if (lines[i].length > 0) changes++;
         }
       }
     } catch {}
     try {
-      fs.writeFileSync(cacheFile, `${branch}|${changes}`);
+      // Atomic write: tmp + rename so concurrent prompts can't observe
+      // a half-written cache file. Same pattern as state.js atomicWrite.
+      const tmp = `${cacheFile}.tmp.${process.pid}`;
+      fs.writeFileSync(tmp, `${branch}|${changes}`);
+      try {
+        fs.renameSync(tmp, cacheFile);
+      } catch {
+        try { fs.unlinkSync(tmp); } catch {}
+      }
     } catch {}
   }