@hanzlaa/rcode 3.6.0 → 3.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanzlaa/rcode",
-  "version": "3.6.0",
+  "version": "3.6.2",
   "description": "rcode — the AI team that never forgets. Persistent memory, specialist agents, and slash commands for AI IDEs. Works in Claude Code, Cursor, Gemini, VS Code, and Antigravity.",
   "main": "cli/index.js",
   "bin": {

package/rihal/bin/rihal-tools.cjs

@@ -3324,6 +3324,137 @@ function cmdPhase(subArgs) {
     };
   }
 
+  // =====================================================================
+  // phase complete <phase_number> — mark a phase complete and report the
+  // next phase. Closes the workflow/CLI drift (#766): execute.md calls
+  // `phase complete` but only set-status existed.
+  // =====================================================================
+  if (sub === 'complete') {
+    const phaseRef = subArgs[1];
+    if (!phaseRef) throw new Error('phase complete requires <phase_number>');
+    const statePath = path.join(RIHAL_DIR, 'state.json');
+    if (!fs.existsSync(statePath)) {
+      throw new Error(`state.json not found at ${statePath} — run 'rihal-tools state init' first`);
+    }
+    let state;
+    try { state = JSON.parse(fs.readFileSync(statePath, 'utf8')); }
+    catch (e) { throw new Error(`Invalid JSON in state.json: ${e.message}`); }
+    if (!state.phases) state.phases = [];
+    const idx = state.phases.findIndex(p =>
+      String(p.number) === String(phaseRef) ||
+      String(p.id) === String(phaseRef) ||
+      p.name === phaseRef
+    );
+    if (idx === -1) {
+      throw new Error(`Phase "${phaseRef}" not found in state.phases (looked up by number, id, and name)`);
+    }
+    const previous = state.phases[idx].status || null;
+    state.phases[idx].status = 'complete';
+    state.phases[idx].status_updated = new Date().toISOString();
+    state.phases[idx].completed_at = state.phases[idx].completed_at || new Date().toISOString().slice(0, 10);
+
+    const num = parseInt(String(state.phases[idx].number || phaseRef), 10);
+    const next = state.phases
+      .filter(p => parseInt(String(p.number), 10) > num)
+      .sort((a, b) => parseInt(String(a.number), 10) - parseInt(String(b.number), 10))[0] || null;
+
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n');
+    return {
+      ok: true,
+      phase: phaseRef,
+      previous_status: previous,
+      new_status: 'complete',
+      next_phase: next ? next.number : null,
+      next_phase_name: next ? (next.name || null) : null,
+      is_last_phase: !next,
+      warnings: [],
+      has_warnings: false,
+    };
+  }
+
+  // =====================================================================
+  // phase sync-sprints <phase_number> — register sprint records into
+  // state.json by deriving them from the .planning/phases/<dir>/*-SPRINT.md
+  // files (the source of truth). Closes #765: planner agents write SPRINT.md
+  // files but do not always register sprint entries, leaving state.json an
+  // incomplete mirror. This makes registration a deterministic CLI step.
+  // =====================================================================
+  if (sub === 'sync-sprints') {
+    const phaseRef = subArgs[1];
+    if (!phaseRef) throw new Error('phase sync-sprints requires <phase_number>');
+    const statePath = path.join(RIHAL_DIR, 'state.json');
+    if (!fs.existsSync(statePath)) {
+      throw new Error(`state.json not found at ${statePath} — run 'rihal-tools state init' first`);
+    }
+    let state;
+    try { state = JSON.parse(fs.readFileSync(statePath, 'utf8')); }
+    catch (e) { throw new Error(`Invalid JSON in state.json: ${e.message}`); }
+    if (!state.phases) state.phases = [];
+    const idx = state.phases.findIndex(p =>
+      String(p.number) === String(phaseRef) ||
+      String(p.id) === String(phaseRef) ||
+      p.name === phaseRef
+    );
+    if (idx === -1) {
+      throw new Error(`Phase "${phaseRef}" not found in state.phases`);
+    }
+
+    const phasesDir = path.join(PLANNING_DIR, 'phases');
+    const intId = String(phaseRef).split('.')[0];
+    let dirs;
+    try { dirs = fs.readdirSync(phasesDir, { withFileTypes: true }).filter(d => d.isDirectory()); }
+    catch { throw new Error(`No .planning/phases directory found`); }
+    const dir = dirs.find(d => d.name.startsWith(intId + '-') ||
+                               d.name.startsWith(intId.padStart(2, '0') + '-'));
+    if (!dir) throw new Error(`No phase directory on disk for phase ${phaseRef}`);
+
+    const files = fs.readdirSync(path.join(phasesDir, dir.name));
+    const sprintFiles = files.filter(f => /-SPRINT\.md$/i.test(f)).sort();
+    const sprints = sprintFiles.map(f => {
+      const m   = f.match(/^(\d+)-(\d+)-SPRINT\.md$/i);
+      const num = m ? parseInt(m[2], 10) : 0;
+      const sid = m ? `${parseInt(m[1], 10)}.${num}` : f.replace(/-SPRINT\.md$/i, '');
+      const text = fs.readFileSync(path.join(phasesDir, dir.name, f), 'utf8');
+      const fmGoal = (text.match(/^goal:\s*(.+)$/m) || [])[1];
+      let goal = fmGoal ? fmGoal.trim() : '';
+      if (!goal) {
+        const obj = (text.match(/<objective>\s*([\s\S]*?)<\/objective>/) || [])[1] || '';
+        goal = (obj.trim().split('\n').map(s => s.trim()).filter(Boolean)[0] || '').slice(0, 160);
+      }
+      const stories = [];
+      const taskRe = /<task\b([^>]*)>([\s\S]*?)<\/task>/g;
+      let tm;
+      while ((tm = taskRe.exec(text))) {
+        const idM = tm[1].match(/id="([^"]+)"/);
+        const tM  = tm[2].match(/<title>([\s\S]*?)<\/title>/);
+        stories.push({ id: idM ? idM[1] : `${sid}.${stories.length + 1}`,
+                       title: tM ? tM[1].trim() : `Task ${stories.length + 1}`,
+                       status: 'planned' });
+      }
+      if (!stories.length) {
+        // Legacy SPRINT.md: "### Story|Task <id> — <title>" headings.
+        const headRe = /^#{2,4}\s+(?:Story|Task)\s+([^\s—–-]+)\s*[—–-]\s*(.+?)\s*$/gm;
+        let hm;
+        while ((hm = headRe.exec(text))) {
+          stories.push({ id: hm[1].trim(), title: hm[2].trim(), status: 'planned' });
+        }
+      }
+      const hasSummary = files.includes(f.replace(/-SPRINT\.md$/i, '-SUMMARY.md'));
+      return { id: sid, number: num, goal: goal || `Sprint ${num}`,
+               status: hasSummary ? 'complete' : 'planned', stories };
+    });
+
+    state.phases[idx].sprints = sprints;
+    state.phases[idx].plan_count = sprints.length;
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n');
+    return {
+      ok: true,
+      phase: phaseRef,
+      sprints_registered: sprints.length,
+      stories_registered: sprints.reduce((a, s) => a + s.stories.length, 0),
+    };
+  }
+
   if (sub === 'set-status') {
     const phaseRef = subArgs[1];
     const newStatus = subArgs[2];
@@ -3435,33 +3566,35 @@ function cmdPhase(subArgs) {
     const roadmapPath = path.join(PLANNING_DIR, 'ROADMAP.md');
     const statePath = path.join(RIHAL_DIR, 'state.json');
 
+    // #769 — the next free number is derived from phase DIRECTORIES only.
+    // A directory is the physical "slot taken" signal. ROADMAP.md headings and
+    // directory-less state.json entries represent phases that are *planned but
+    // not yet scaffolded* — which is exactly what this command materialises —
+    // so they must NOT push the start number forward. (The old code also read
+    // the roadmap + state into maxNum, which made scaffold-milestone skip past
+    // an already-written roadmap range, e.g. scaffolding 38-41 for a 34-37
+    // milestone.)
+    const dirNumbers = new Set();
     let maxNum = 0;
     if (fs.existsSync(phasesDir)) {
       for (const entry of fs.readdirSync(phasesDir)) {
         const m = entry.match(/^(\d+)/);
-        if (m) maxNum = Math.max(maxNum, parseInt(m[1], 10));
+        if (m) {
+          const n = parseInt(m[1], 10);
+          dirNumbers.add(n);
+          maxNum = Math.max(maxNum, n);
+        }
       }
     }
-    if (fs.existsSync(roadmapPath)) {
-      const text = fs.readFileSync(roadmapPath, 'utf8');
-      const pipeRe = /^\|\s*(\d+)\s*\|/gm;
-      let m;
-      while ((m = pipeRe.exec(text)) !== null) maxNum = Math.max(maxNum, parseInt(m[1], 10));
-      const headRe = /^#{2,4}\s*Phase\s+(\d+)\b/gm;
-      while ((m = headRe.exec(text)) !== null) maxNum = Math.max(maxNum, parseInt(m[1], 10));
-    }
     let state = { phases: [] };
     if (fs.existsSync(statePath)) {
       try { state = JSON.parse(fs.readFileSync(statePath, 'utf8')); } catch {}
     }
     if (!Array.isArray(state.phases)) state.phases = [];
-    for (const p of state.phases) {
-      const n = parseInt(String(p.number || ''), 10);
-      if (!Number.isNaN(n)) maxNum = Math.max(maxNum, n);
-    }
 
     const firstNum = startOverride !== null ? startOverride : maxNum + 1;
     const created  = [];
+    const roadmapSkipped = [];
 
     for (let i = 0; i < names.length; i++) {
       const phaseName = names[i];
@@ -3475,8 +3608,17 @@ function cmdPhase(subArgs) {
       if (!slug) {
         throw new Error(`Name at index ${i} ("${phaseName}") produces an empty slug`);
       }
-      if (state.phases.some(p => String(p.number) === number)) {
-        throw new Error(`Phase ${number} already exists in state.json (would collide at index ${i})`);
+      // #769 — a real collision is a state entry that ALSO has a directory on
+      // disk (the phase is genuinely already scaffolded). A directory-less
+      // state entry is a phantom — e.g. rihal-roadmapper synced the phase into
+      // state.json but never created the folder — so reconcile it in place
+      // instead of aborting.
+      const existingIdx = state.phases.findIndex(p => String(p.number) === number);
+      if (existingIdx !== -1) {
+        if (dirNumbers.has(firstNum + i)) {
+          throw new Error(`Phase ${number} already scaffolded (directory + state entry exist) — collision at index ${i}`);
+        }
+        state.phases.splice(existingIdx, 1);
       }
 
       const dirName  = `${number}-${slug}`;
@@ -3486,22 +3628,29 @@ function cmdPhase(subArgs) {
       }
       fs.mkdirSync(directory, { recursive: true });
 
-      // Append ROADMAP entry
+      // Append ROADMAP entry — but skip if the roadmap already declares this
+      // phase (#769: rihal-roadmapper writes `## Phase N` sections directly, so
+      // appending a stub here produced a duplicate heading).
       if (fs.existsSync(roadmapPath)) {
-        const entry = `## Phase ${number} — ${phaseName}\n\n` +
-          `**Goal:** _TBD — fill in via /rihal-discuss-phase ${number} or edit directly._\n\n` +
-          `**Status:** Planned\n\n` +
-          `**Plans:**\n- _TBD_\n\n` +
-          `**Acceptance:** _TBD_\n\n---\n`;
         let text = fs.readFileSync(roadmapPath, 'utf8');
-        const backlogMatch = text.match(/^##\s+Backlog\b/m);
-        if (backlogMatch) {
-          text = text.slice(0, backlogMatch.index) + entry + '\n' + text.slice(backlogMatch.index);
+        const headingRe = new RegExp(`^#{2,4}\\s*Phase\\s+${number}\\b`, 'm');
+        if (headingRe.test(text)) {
+          roadmapSkipped.push(number);
         } else {
-          if (!text.endsWith('\n')) text += '\n';
-          text += '\n' + entry;
+          const entry = `## Phase ${number} — ${phaseName}\n\n` +
+            `**Goal:** _TBD — fill in via /rihal-discuss-phase ${number} or edit directly._\n\n` +
+            `**Status:** Planned\n\n` +
+            `**Plans:**\n- _TBD_\n\n` +
+            `**Acceptance:** _TBD_\n\n---\n`;
+          const backlogMatch = text.match(/^##\s+Backlog\b/m);
+          if (backlogMatch) {
+            text = text.slice(0, backlogMatch.index) + entry + '\n' + text.slice(backlogMatch.index);
+          } else {
+            if (!text.endsWith('\n')) text += '\n';
+            text += '\n' + entry;
+          }
+          fs.writeFileSync(roadmapPath, text);
         }
-        fs.writeFileSync(roadmapPath, text);
       }
 
       state.phases.push({
@@ -3519,10 +3668,10 @@ function cmdPhase(subArgs) {
     if (!fs.existsSync(stateDir)) fs.mkdirSync(stateDir, { recursive: true });
     fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n');
 
-    return { ok: true, count: created.length, phases: created };
+    return { ok: true, count: created.length, phases: created, roadmap_skipped: roadmapSkipped };
   }
 
-  throw new Error(`Unknown phase subcommand: ${sub || '(none)'}. Valid: add, set-status, next-range, scaffold-milestone`);
+  throw new Error(`Unknown phase subcommand: ${sub || '(none)'}. Valid: add, complete, sync-sprints, set-status, next-range, scaffold-milestone`);
 }
 
 /**
@@ -4434,6 +4583,96 @@ function cmdPhasePlanIndex(rawArgs) {
   };
 }
 
+/**
+ * Extract a frontmatter list field that may be written inline (`key: [a, b]`),
+ * as a single scalar (`key: a`), or as a block list (`key:` then `  - a`).
+ * Returns a string array (empty if the key is absent).
+ */
+function fmListField(block, key) {
+  const lines = block.split('\n');
+  const strip = (s) => s.trim().replace(/^["']|["']$/g, '');
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(new RegExp(`^${key}\\s*:\\s*(.*)$`));
+    if (!m) continue;
+    const inline = m[1].trim();
+    if (inline.startsWith('[')) {
+      return inline.replace(/^\[|\]$/g, '').split(',').map(strip).filter(Boolean);
+    }
+    if (inline) return [strip(inline)];
+    const out = [];
+    for (let j = i + 1; j < lines.length; j++) {
+      const lm = lines[j].match(/^\s+-\s+(.*)$/);
+      if (!lm) break;
+      out.push(strip(lm[1]));
+    }
+    return out;
+  }
+  return [];
+}
+
+/**
+ * plan check-wave-overlaps <phase> — enforce the wave-parallelism rule
+ * (plan.md Step 12.5, issue #768): two plans in the SAME wave that both list
+ * the same path in `files_modified` cannot run in parallel — the later plan
+ * (by plan number) must declare `sequential: true`. Returns a JSON report of
+ * unresolved conflicts so /rihal-plan can auto-correct the frontmatter.
+ */
+function cmdPlanCheckWaveOverlaps(rawArgs) {
+  const phaseArg = String(rawArgs || '').trim().split(/\s+/)[0] || '';
+  if (!phaseArg) {
+    console.error('Usage: plan check-wave-overlaps <phase-number>');
+    process.exit(1);
+  }
+  const phasesDir = path.join(PLANNING_DIR, 'phases');
+  const norm = phaseArg.replace(/^0+/, '') || '0';
+  let phaseDir = null;
+  if (fs.existsSync(phasesDir)) {
+    for (const d of fs.readdirSync(phasesDir)) {
+      const m = d.match(/^(\d+)(?:[-.])/);
+      if (m && (m[1].replace(/^0+/, '') || '0') === norm) { phaseDir = path.join(phasesDir, d); break; }
+    }
+  }
+  if (!phaseDir) return { phase: phaseArg, conflicts: [], plans_checked: 0, phase_dir: null };
+
+  const plans = [];
+  for (const file of fs.readdirSync(phaseDir).filter((f) => /-SPRINT\.md$/i.test(f)).sort()) {
+    const text = fs.readFileSync(path.join(phaseDir, file), 'utf8');
+    let block = '';
+    if (text.startsWith('---\n')) {
+      const end = text.indexOf('\n---\n', 4);
+      if (end !== -1) block = text.slice(4, end);
+    }
+    const stem = file.replace(/-SPRINT\.md$/i, '');
+    const numMatch = (block.match(/^plan_number\s*:\s*(\d+)/m) || stem.match(/-(\d+)$/));
+    plans.push({
+      id: stem,
+      order: numMatch ? parseInt(numMatch[1], 10) : 0,
+      wave: parseInt((block.match(/^wave\s*:\s*(\d+)/m) || [])[1] || '1', 10) || 1,
+      sequential: /^sequential\s*:\s*true\s*$/m.test(block),
+      files: fmListField(block, 'files_modified'),
+    });
+  }
+
+  const conflicts = [];
+  for (let a = 0; a < plans.length; a++) {
+    for (let b = a + 1; b < plans.length; b++) {
+      const [earlier, later] = plans[a].order <= plans[b].order ? [plans[a], plans[b]] : [plans[b], plans[a]];
+      if (earlier.wave !== later.wave) continue;
+      const shared = earlier.files.filter((f) => later.files.includes(f));
+      if (shared.length === 0) continue;
+      if (later.sequential) continue;
+      conflicts.push({
+        wave: earlier.wave,
+        plan_a: earlier.id,
+        plan_b: later.id,
+        shared_files: shared,
+        plan_b_sequential: false,
+      });
+    }
+  }
+  return { phase: phaseArg, phase_dir: path.relative(PROJECT_ROOT, phaseDir), plans_checked: plans.length, conflicts };
+}
+
 /** phases list — directory inventory under .planning/phases with optional --type filter and --pick path. */
 function cmdPhasesList(args) {
   const argv = Array.isArray(args) ? args : String(args || '').trim().split(/\s+/).filter(Boolean);
@@ -6501,7 +6740,10 @@ async function main() {
           console.log(JSON.stringify(result, null, 2));
           process.exit(result.ok ? 0 : 1);
         }
-        else { console.error('Unknown plan subcommand. Valid: list, validate-evidence'); process.exit(1); }
+        else if (args[0] === 'check-wave-overlaps') {
+          result = cmdPlanCheckWaveOverlaps(args.slice(1).join(' '));
+        }
+        else { console.error('Unknown plan subcommand. Valid: list, validate-evidence, check-wave-overlaps'); process.exit(1); }
         break;
       case 'phase-plan-index':
         result = cmdPhasePlanIndex(args.join(' '));
@@ -6761,8 +7003,9 @@ async function main() {
         console.log('  classify-tech --keywords "<keywords>"        → classify tech stack from keywords (frontend/backend/mobile/styling)');
         console.log('  context refresh                              → refresh .rihal/context/ cache from .rihal/sources.yaml');
         console.log('  module <subcommand> [args]                   → module system helpers');
-        console.log('  plan <list|validate-evidence>                → phase/plan operations');
+        console.log('  plan <list|validate-evidence|check-wave-overlaps>  → phase/plan operations');
         console.log('  plan validate-evidence <N> [--spot-check]    → enforce <evidence> blocks in SPRINT.md (#649); exit 1 on violation');
+        console.log('  plan check-wave-overlaps <N>                 → detect same-wave plans sharing files_modified (#768)');
         console.log('  phase-plan-index <N>                         → JSON inventory of plans under phase N (waves, summary status, task counts)');
         console.log('  phases list [--type X] [--pick path]         → directory inventory of .planning/phases (--type: summaries|sprints|directories|all; --pick: e.g. directories[-1])');
         console.log('  find-phase <N> [--raw]                       → resolve phase number to dir/slug + decimal children');

package/server/lib/html/client/components/App.js

@@ -157,7 +157,7 @@ export function App() {
         const r = await fetch('/api/state');
         if (!r.ok) return;
         const s = await r.json();
-        if (s.lastScanned !== lastScannedRef.current) await fetchAndRerender();
+        if (s && s.lastScanned !== lastScannedRef.current) await fetchAndRerender();
       } catch { /* ignore */ }
     }, 30000);
     return () => clearInterval(id);

package/server/lib/html/client/components/OrchPanel.js

@@ -191,7 +191,7 @@ export function OrchPanel() {
   }
 
   function handleClean() {
-    cleanSessions(7).then(d => {
+    cleanSessions().then(d => {
       showToast('Cleaned ' + (d.removed || 0) + ' sessions');
     });
   }

package/server/lib/html/client/components/XtermPanel.js

@@ -82,6 +82,7 @@ function connectWs(storyId) {
   ws.onmessage = e => {
     let m;
     try { m = JSON.parse(e.data); } catch { return; }
+    if (!m) return;
     if (m.t === 'o' || m.t === 'hist') {
       if (_term) _term.write(m.d);
     } else if (m.t === 's') {

package/server/lib/html/client/orchestrator.js

@@ -78,9 +78,10 @@ export function fetchSessions() {
 }
 
 /**
- * POST /api/clean-sessions — remove sessions older than N days.
+ * POST /api/clean-sessions — remove ended sessions.
+ * olderThanDays = 0 removes all ended sessions; > 0 keeps recent ones.
  */
-export function cleanSessions(olderThanDays = 7) {
+export function cleanSessions(olderThanDays = 0) {
   const tok = orchToken();
   return fetch(ORCH_HTTP + '/api/clean-sessions', {
     method: 'POST',

package/server/lib/html/client/util.js

@@ -110,6 +110,7 @@ export function orchElapsed(iso) {
  * @returns {Array<[string, string]>}
  */
 export function sprintHints(s) {
+  if (!s) return [];
   const stories = Array.isArray(s.stories) ? s.stories : [];
   const st = s.status || 'planned';
   const sid = s.id || '';
@@ -155,6 +156,7 @@ export function sprintHints(s) {
  * @returns {Array<[string, string]>}
  */
 export function phaseHints(p) {
+  if (!p) return [];
   const sps = Array.isArray(p.sprints) ? p.sprints : [];
   const st = p.status || 'planned';
   const pid = p.id || '';

package/server/lib/html/client/views/PhasesView.js

@@ -53,7 +53,7 @@ function VelocityBars({ sprints }) {
 
 function PhaseDetail({ phase: p, S }) {
   const sps = Array.isArray(p.sprints) ? p.sprints : [];
-  const stories = sps.flatMap(s => (Array.isArray(s.stories) ? s.stories : []));
+  const stories = sps.flatMap(s => (s && Array.isArray(s.stories) ? s.stories : []));
   const done = stories.filter(t => t.status === 'done' || t.status === 'completed').length;
   const running = runningInPhase(p);
   const hints = phaseHints(p);
@@ -158,7 +158,7 @@ export function PhasesView({ subId }) {
 
   const q = filter.toLowerCase();
   const filtered = q
-    ? phases.filter(p => p.name.toLowerCase().includes(q) || String(p.id).includes(q))
+    ? phases.filter(p => (p.name || '').toLowerCase().includes(q) || String(p.id).includes(q))
     : phases;
 
   return html`

package/server/lib/html/client/views/RoadmapView.js

@@ -70,13 +70,13 @@ function PhaseNode({ phase: p, filterQuery, expandSignal }) {
     if (expandSignal && expandSignal.key > 0) setOpen(expandSignal.open);
   }, [expandSignal && expandSignal.key]);
   const sps = p.sprints || [];
-  const pStories = sps.flatMap(s => s.stories || []);
+  const pStories = sps.flatMap(s => (s ? s.stories || [] : []));
   const pDone = pStories.filter(t => t.status === 'done' || t.status === 'completed').length;
   const pp = pctNum(pDone, pStories.length);
   const running = runningInPhase(p);
 
   // Filter: hide this node if query doesn't match phase name
-  if (filterQuery && !p.name.toLowerCase().includes(filterQuery)) return null;
+  if (filterQuery && !(p.name || '').toLowerCase().includes(filterQuery)) return null;
 
   function handleDblClick(e) {
     e.stopPropagation();

package/server/lib/html/css.js

@@ -28,7 +28,6 @@ function renderCss() {
   --text-secondary: #b4bcd0;
   --text-tertiary:  #8a8f98;
   --text-muted:     #62666d;
-  --text-on-accent: #ffffff;
 
   /* Brand — Rihal keeps Aether Blue */
   --accent-primary: #5e6ad2;
@@ -43,7 +42,6 @@ function renderCss() {
   --red:     #eb5757;
   --blue:    #26b5ce;
   --violet:  #bf7af0;
-  --orange:  #f2994a;
 
   /* Status */
   --status-todo:     #e2e2e2;
@@ -56,7 +54,6 @@ function renderCss() {
   --font-mono: "JetBrains Mono", "SF Mono", Menlo, Consolas, monospace;
 
   /* Size scale */
-  --text-2xl: 24px;
   --text-xl:  20px;
   --text-lg:  17px;
   --text-md:  15px;
@@ -78,7 +75,6 @@ function renderCss() {
   --space-6: 20px;
   --space-7: 24px;
   --space-8: 32px;
-  --space-9: 48px;
   --space-10: 64px;
 
   /* Radius */
@@ -90,19 +86,13 @@ function renderCss() {
   --radius-full: 9999px;
 
   /* Shadows */
-  --shadow-sm:    0 1px 2px rgba(0,0,0,0.4);
-  --shadow-md:    0 4px 12px rgba(0,0,0,0.5);
   --shadow-lg:    0 16px 32px rgba(0,0,0,0.6);
-  --shadow-modal: 0 32px 64px rgba(0,0,0,0.7), 0 0 0 1px rgba(255,255,255,0.06);
-  --shadow-focus: 0 0 0 2px var(--bg-page), 0 0 0 4px var(--accent-primary);
 
   /* Motion */
   --ease: cubic-bezier(0.4,0,0.2,1);
-  --ease-in: cubic-bezier(0.4,0,1,1);
   --t-fast: 120ms;
   --t-base: 200ms;
   --t-menu: 240ms;
-  --t-view: 320ms;
 
   /* Legacy compat aliases */
   --bg: var(--bg-page);
@@ -110,7 +100,6 @@ function renderCss() {
   --border: var(--border-default);
   --radius-sm: var(--radius-2);
   --radius-md: var(--radius-4);
-  --radius-lg: var(--radius-5);
   --accent-green: var(--green);
   --accent-amber: var(--amber);
   --accent-red: var(--red);
@@ -1005,7 +994,7 @@ section .body {
 .agent-card .role {
   font-size: var(--text-2xs);
   color: var(--text-tertiary);
-  letter---spacing: -0.006em;
+  letter-spacing: -0.006em;
 }
 .real-badge {
   font-size: var(--text-2xs);

package/server/lib/scanner.js

@@ -91,6 +91,19 @@ function buildPhaseTree(projectDir, rawPhases) {
           status: phaseComplete ? 'done' : 'todo',
         });
       }
+      // Fallback for pre-<task> SPRINT.md format (phases 20-30 era):
+      // "### Story 20.01.01 — title" / "### Task X — title" headings.
+      if (!stories.length) {
+        const headRe = /^#{2,4}\s+(?:Story|Task)\s+([^\s—–-]+)\s*[—–-]\s*(.+?)\s*$/gm;
+        let hm;
+        while ((hm = headRe.exec(text))) {
+          stories.push({
+            id:     hm[1].trim(),
+            title:  hm[2].trim(),
+            status: phaseComplete ? 'done' : 'todo',
+          });
+        }
+      }
 
       // Status: a *-SUMMARY.md sibling means the sprint shipped.
       const hasSummary = files.includes(f.replace(/-SPRINT\.md$/i, '-SUMMARY.md'));

package/server/orchestrator.js

@@ -279,6 +279,23 @@ async function handleStop(req, res) {
   json(res, 200, { storyId, status: 'stopped' });
 }
 
+// Remove ended sessions (done/exited/stopped/error). Running sessions are never
+// touched. Optional body.olderThanDays gates removal by session start age.
+async function handleCleanSessions(req, res) {
+  const body = await parseBody(req);
+  const olderThanDays = Number(body.olderThanDays) || 0;
+  const cutoff = olderThanDays > 0 ? Date.now() - olderThanDays * 86400000 : null;
+  let removed = 0;
+  for (const [id, s] of sessions) {
+    if (s.status === 'running') continue;
+    if (cutoff !== null && (Date.parse(s.startTime || '') || 0) > cutoff) continue;
+    s.wsClients.forEach(ws => { try { ws.close(); } catch {} });
+    sessions.delete(id);
+    removed++;
+  }
+  json(res, 200, { removed });
+}
+
 // ── WebSocket data plane ───────────────────────────────────────────────────────
 
 function attachWebSocket(ws, storyId) {
@@ -333,6 +350,7 @@ const server = http.createServer(async (req, res) => {
   if (method === 'GET'  && pathOnly === '/api/sessions') { await handleSessions(res); return; }
   if (method === 'POST' && pathOnly === '/api/run')      { await handleRun(req, res);  return; }
   if (method === 'POST' && pathOnly === '/api/stop')     { await handleStop(req, res); return; }
+  if (method === 'POST' && pathOnly === '/api/clean-sessions') { await handleCleanSessions(req, res); return; }
 
   res.writeHead(404); res.end('Not found');
 });