work-kit-cli 0.2.8 → 0.4.0

package/cli/src/observer/renderer.ts

@@ -1,8 +1,11 @@
+import * as path from "node:path";
 import {
   bold, dim, green, yellow, red, cyan, magenta,
-  bgYellow, bgCyan, bgRed, bgMagenta,
-  boldCyan, boldGreen,
+  bgYellow, bgCyan, bgRed, bgMagenta, bgGreen, bgBlue, bgDim,
+  boldCyan, boldGreen, boldMagenta, boldRed,
 } from "../utils/colors.js";
+import { formatDurationMs, formatDurationSince } from "../utils/time.js";
+import { MODE_FULL } from "../state/schema.js";
 import type { DashboardData, WorkItemView, CompletedItemView } from "./data.js";
 
 // ── Spinners & Animation Frames ─────────────────────────────────────
@@ -63,19 +66,7 @@ function formatTimeAgo(dateStr: string): string {
   return `${weeks}w ago`;
 }
 
-function formatDuration(startStr: string): string {
-  const now = Date.now();
-  const start = new Date(startStr).getTime();
-  if (isNaN(start)) return "";
-  const diffMs = now - start;
-  const sec = Math.floor(diffMs / 1000);
-  if (sec < 60) return `${sec}s`;
-  const min = Math.floor(sec / 60);
-  if (min < 60) return `${min}m`;
-  const hr = Math.floor(min / 60);
-  const remMin = min % 60;
-  return remMin > 0 ? `${hr}h${remMin}m` : `${hr}h`;
-}
+const formatDuration = formatDurationSince;
 
 // ── Box Drawing ─────────────────────────────────────────────────────
 
@@ -157,7 +148,7 @@ function phaseIndicator(status: string, tick: number = 0): string {
   }
 }
 
-function subStageIndicator(status: string, tick: number): string {
+function stepIndicator(status: string, tick: number): string {
   switch (status) {
     case "completed": return green("●");
     case "in-progress": return cyan(pulse(tick));
@@ -169,13 +160,20 @@ function subStageIndicator(status: string, tick: number): string {
   }
 }
 
+function phaseDisplayName(name: string): string {
+  // Uppercase with letter-spacing to visually distinguish phases from steps.
+  // e.g. "plan" → "P L A N", "wrap-up" → "W R A P - U P"
+  return name.toUpperCase().split("").join(" ");
+}
+
 function phaseName(name: string, status: string, tick: number): string {
+  const display = phaseDisplayName(name);
   switch (status) {
-    case "completed": return boldGreen(name);
-    case "in-progress": return tick % 2 === 0 ? boldCyan(name) : bold(cyan(name));
-    case "waiting": return bold(yellow(name));
-    case "failed": return bold(red(name));
-    default: return dim(name);
+    case "completed": return boldGreen(display);
+    case "in-progress": return tick % 2 === 0 ? boldCyan(display) : bold(cyan(display));
+    case "waiting": return bold(yellow(display));
+    case "failed": return bold(red(display));
+    default: return dim(display);
   }
 }
 
@@ -192,30 +190,33 @@ function statusDot(status: string): string {
 // ── Badges ──────────────────────────────────────────────────────────
 
 function renderModeBadge(mode: string): string {
-  return mode === "full-kit" ? bgCyan(" Full Kit ") : bgYellow(" Auto Kit ");
+  return mode === MODE_FULL ? bgCyan(" Full Kit ") : bgYellow(" Auto Kit ");
 }
 
 function renderGatedBadge(): string {
   return bgMagenta(" GATED ");
 }
 
+function renderClassificationBadge(classification: string): string {
+  const label = ` ${classification.toUpperCase()} `;
+  switch (classification) {
+    case "bug-fix": return bgRed(label);
+    case "small-change": return bgGreen(label);
+    case "refactor": return bgCyan(label);
+    case "feature": return bgBlue(label);
+    case "large-feature": return bgMagenta(label);
+    default: return bgYellow(label);
+  }
+}
+
 // ── Phase Pipeline ──────────────────────────────────────────────────
 
 function phaseDuration(p: { status: string; startedAt?: string; completedAt?: string }): string {
   if (p.status === "completed" && p.startedAt && p.completedAt) {
     const ms = new Date(p.completedAt).getTime() - new Date(p.startedAt).getTime();
-    const sec = Math.floor(ms / 1000);
-    if (sec < 60) return `${sec}s`;
-    const min = Math.floor(sec / 60);
-    if (min < 60) return `${min}m`;
-    const hr = Math.floor(min / 60);
-    const remMin = min % 60;
-    return remMin > 0 ? `${hr}h${remMin}m` : `${hr}h`;
-  }
-  if (p.status === "in-progress" && p.startedAt) {
-    return formatDuration(p.startedAt);
+    return formatDurationMs(ms);
   }
-  if (p.status === "waiting" && p.startedAt) {
+  if ((p.status === "in-progress" || p.status === "waiting") && p.startedAt) {
     return formatDuration(p.startedAt);
   }
   return "";
@@ -223,7 +224,9 @@ function phaseDuration(p: { status: string; startedAt?: string; completedAt?: st
 
 function renderPhasePipeline(
   phases: WorkItemView["phases"],
-  tick: number
+  tick: number,
+  awaitingInput: boolean = false,
+  currentPhase: string | null = null,
 ): string[] {
   const connector = dim(" ── ");
   const connectorLen = 4; // " ── "
@@ -234,8 +237,13 @@ function renderPhasePipeline(
 
   for (let i = 0; i < phases.length; i++) {
     const p = phases[i];
-    const icon = phaseIndicator(p.status, tick);
-    const name = phaseName(p.name, p.status, tick);
+    const isBlockedHere = awaitingInput && p.name === currentPhase && p.status === "in-progress";
+    const icon = isBlockedHere
+      ? magenta(tick % 2 === 0 ? "▶" : "▷")
+      : phaseIndicator(p.status, tick);
+    const name = isBlockedHere
+      ? boldMagenta(phaseDisplayName(p.name))
+      : phaseName(p.name, p.status, tick);
     const segment = `${icon} ${name}`;
     topParts.push(segment);
 
@@ -276,18 +284,18 @@ function renderPhasePipeline(
   return [topLine];
 }
 
-// ── Sub-Stage Detail Box ────────────────────────────────────────────
+// ── Step Detail Box ─────────────────────────────────────────────────
 
-function renderSubStageBox(
+function renderStepBox(
   item: WorkItemView,
   innerWidth: number,
   tick: number
 ): string[] {
-  const subs = item.phaseSubStages;
+  const subs = item.phaseSteps;
   if (!subs || subs.length === 0 || !item.currentPhase) return [];
 
   const lines: string[] = [];
-  const label = dim(item.currentPhase);
+  const label = bold(phaseDisplayName(item.currentPhase));
   const boxInner = innerWidth - 8; // indent + border padding
 
   // Top border with phase label
@@ -295,29 +303,42 @@ function renderSubStageBox(
   const topRule = dim("┌─ ") + label + dim(" " + "─".repeat(Math.max(0, boxInner - labelLen - 2)) + "┐");
   lines.push("  " + topRule);
 
-  // Render sub-stages in rows that fit the width
+  // Render steps in rows that fit the width
   const entries: string[] = [];
   for (const ss of subs) {
-    const icon = subStageIndicator(ss.status, tick);
+    // Highlight the current in-progress step in magenta if the agent is
+    // blocked waiting for human input (permission prompt / AskUserQuestion).
+    const isBlockedHere =
+      item.awaitingInput && ss.status === "in-progress" && ss.name === item.currentStep;
+
+    let icon: string;
     let nameStr: string;
-    switch (ss.status) {
-      case "completed": nameStr = green(ss.name); break;
-      case "in-progress": nameStr = boldCyan(ss.name); break;
-      case "waiting": nameStr = yellow(ss.name); break;
-      case "failed": nameStr = red(ss.name); break;
-      default: nameStr = dim(ss.name);
+    if (isBlockedHere) {
+      // Pulsing magenta pointer + bold magenta name
+      icon = magenta(tick % 2 === 0 ? "▶" : "▷");
+      nameStr = boldMagenta(ss.name);
+    } else {
+      icon = stepIndicator(ss.status, tick);
+      switch (ss.status) {
+        case "completed": nameStr = green(ss.name); break;
+        case "in-progress": nameStr = boldCyan(ss.name); break;
+        case "waiting": nameStr = yellow(ss.name); break;
+        case "failed": nameStr = red(ss.name); break;
+        default: nameStr = dim(ss.name);
+      }
     }
-    // Add duration for completed or in-progress
+
     let duration = "";
     if (ss.status === "completed" && ss.startedAt && ss.completedAt) {
       const ms = new Date(ss.completedAt).getTime() - new Date(ss.startedAt).getTime();
-      const sec = Math.floor(ms / 1000);
-      if (sec < 60) duration = dim(` ${sec}s`);
-      else duration = dim(` ${Math.floor(sec / 60)}m`);
+      duration = dim(` ${formatDurationMs(ms)}`);
     } else if (ss.status === "in-progress" && ss.startedAt) {
       duration = dim(` ${formatDuration(ss.startedAt)}`);
     }
-    entries.push(`${icon} ${nameStr}${duration}`);
+
+    // Append an inline "waiting you" hint next to the blocked step
+    const hint = isBlockedHere ? magenta(" ← waiting you") : "";
+    entries.push(`${icon} ${nameStr}${duration}${hint}`);
   }
 
   // Flow entries into rows
@@ -356,56 +377,51 @@ function renderSubStageBox(
 function renderWorkItem(item: WorkItemView, innerWidth: number, tick: number): string[] {
   const lines: string[] = [];
 
-  // Line 1: status dot + bold slug + elapsed time (right)
-  const slugText = `${statusDot(item.status)} ${bold(item.slug)}`;
-  const elapsed = formatTimeAgo(item.startedAt);
-  const elapsedText = dim(`⏱ ${elapsed}`);
-  const slugLen = stripAnsi(slugText).length;
-  const elapsedLen = stripAnsi(elapsedText).length;
-  const gap1 = Math.max(2, innerWidth - slugLen - elapsedLen);
-  lines.push(slugText + " ".repeat(gap1) + elapsedText);
+  const repoPrefix = item.repoName ? dim(`${item.repoName} › `) : "";
+  const titleText = `${statusDot(item.status)} ${repoPrefix}${bold(item.slug)}`;
 
-  // Line 2: branch + mode badge + gated badge + classification
-  const branchText = dim("⎇ " + item.branch);
-  let badges = "  " + renderModeBadge(item.mode);
+  let badges = renderModeBadge(item.mode);
+  if (item.classification) badges += " " + renderClassificationBadge(item.classification);
+  if (item.status === "paused") badges += " " + bgDim(" ⏸ PAUSED ");
+  if (item.status === "failed") badges += " " + boldRed("✗ FAILED");
   if (item.gated) badges += " " + renderGatedBadge();
-  if (item.status === "paused") badges += " " + bgYellow(" PAUSED ");
-  if (item.status === "failed") badges += " " + bgRed(" FAILED ");
-  if (item.classification) badges += "  " + dim(item.classification);
-  lines.push("  " + branchText + badges);
-
-  // Line 3: timing — phase elapsed + sub-stage elapsed
-  const timingParts: string[] = [];
-  if (item.currentPhase && item.currentPhaseStartedAt) {
-    timingParts.push(cyan("phase") + dim(`: ${formatDuration(item.currentPhaseStartedAt)}`));
-  }
-  if (item.currentSubStage && item.currentSubStageStartedAt) {
-    timingParts.push(cyan("step") + dim(`: ${formatDuration(item.currentSubStageStartedAt)}`));
-  }
-  if (timingParts.length > 0) {
-    lines.push("  " + timingParts.join(dim("  │  ")));
+  if (item.awaitingInput) {
+    // Loud: agent definitely blocked on a permission prompt or AskUserQuestion
+    const arrow = tick % 2 === 0 ? "▶" : "▷";
+    badges += " " + bgMagenta(` ${arrow} AWAITING INPUT `);
+  } else if (item.idle) {
+    // Soft: turn ended but step not complete — probably asking a question in prose
+    badges += " " + dim("⏸ idle");
   }
 
-  // Line 4: progress bar with animated head
-  const barMaxWidth = Math.max(20, Math.min(40, innerWidth - 20));
-  lines.push("  " + renderProgressBar(
-    item.progress.completed,
-    item.progress.total,
-    item.progress.percent,
-    barMaxWidth,
-    tick
-  ));
-
-  // Line 5-6: phase pipeline with connectors, spinner, and timing row
-  const pipelineLines = renderPhasePipeline(item.phases, tick);
+  const leftLine = `${titleText}  ${badges}`;
+  const elapsed = formatTimeAgo(item.startedAt);
+  const elapsedText = dim(`⏱ ${elapsed}`);
+  const leftLen = stripAnsi(leftLine).length;
+  const elapsedLen = stripAnsi(elapsedText).length;
+  const gap1 = Math.max(2, innerWidth - leftLen - elapsedLen);
+  lines.push(leftLine + " ".repeat(gap1) + elapsedText);
+  lines.push("");
+
+  // TODO(progress-bar): re-enable after redesign — hidden per user request
+  // const barMaxWidth = Math.max(20, Math.min(40, innerWidth - 20));
+  // lines.push("  " + renderProgressBar(
+  //   item.progress.completed,
+  //   item.progress.total,
+  //   item.progress.percent,
+  //   barMaxWidth,
+  //   tick
+  // ));
+
+  const pipelineLines = renderPhasePipeline(item.phases, tick, item.awaitingInput, item.currentPhase);
   for (const pl of pipelineLines) {
     lines.push("  " + pl);
   }
 
-  // Line 6: sub-stage detail box (all sub-stages of current phase)
-  const subStageBox = renderSubStageBox(item, innerWidth, tick);
-  if (subStageBox.length > 0) {
-    for (const line of subStageBox) {
+  // Step detail box (all steps of current phase)
+  const stepBox = renderStepBox(item, innerWidth, tick);
+  if (stepBox.length > 0) {
+    for (const line of stepBox) {
       lines.push(line);
     }
   }
@@ -423,15 +439,11 @@ function renderWorkItem(item: WorkItemView, innerWidth: number, tick: number): s
     lines.push(loopStr);
   }
 
-  // Worktree path
+  // Worktree (basename only) and branch
   if (item.worktreePath) {
-    let displayPath = item.worktreePath;
-    const maxPathLen = innerWidth - 8;
-    if (displayPath.length > maxPathLen) {
-      displayPath = "…" + displayPath.slice(displayPath.length - maxPathLen + 1);
-    }
-    lines.push("  " + dim("⌂ " + displayPath));
+    lines.push("  " + dim("worktree: " + path.basename(item.worktreePath)));
   }
+  lines.push("  " + dim("⎇ " + item.branch));
 
   return lines;
 }
@@ -439,28 +451,31 @@ function renderWorkItem(item: WorkItemView, innerWidth: number, tick: number): s
 // ── Render Completed Item ───────────────────────────────────────────
 
 interface CompletedColumnWidths {
+  repo: number;
   slug: number;
   pr: number;
   date: number;
 }
 
 function computeCompletedWidths(items: CompletedItemView[]): CompletedColumnWidths {
-  let slug = 4, pr = 2, date = 4;
+  let repo = 4, slug = 4, pr = 2, date = 4;
   for (const item of items) {
+    repo = Math.max(repo, (item.repoName || "").length);
     slug = Math.max(slug, item.slug.length);
     pr = Math.max(pr, (item.pr || "—").length);
     date = Math.max(date, (item.completedAt || "").length);
   }
-  return { slug, pr, date };
+  return { repo, slug, pr, date };
 }
 
 function renderCompletedItem(item: CompletedItemView, cols: CompletedColumnWidths): string {
   const check = green("✓");
+  const repo = padRight(dim(item.repoName || ""), cols.repo);
   const slug = padRight(item.slug, cols.slug);
   const pr = padRight(dim(item.pr || "—"), cols.pr);
   const date = padRight(dim(item.completedAt || ""), cols.date);
   const phases = item.phases ? dim(item.phases) : "";
-  return `${check} ${slug}  ${pr}  ${date}  ${phases}`;
+  return `${check} ${repo}  ${slug}  ${pr}  ${date}  ${phases}`;
 }
 
 // ── Main Render Function ────────────────────────────────────────────
@@ -482,11 +497,14 @@ export function renderDashboard(
 
   // Header counts
   let activeCount = 0, pausedCount = 0, failedCount = 0, waitingCount = 0;
+  let awaitingInputCount = 0, idleCount = 0;
   for (const item of data.activeItems) {
     if (item.status === "in-progress") activeCount++;
     else if (item.status === "paused") pausedCount++;
     else if (item.status === "failed") failedCount++;
-    if (item.currentSubStageStatus === "waiting") waitingCount++;
+    if (item.currentStepStatus === "waiting") waitingCount++;
+    if (item.awaitingInput) awaitingInputCount++;
+    else if (item.idle) idleCount++;
   }
   const completedCount = data.completedItems.length;
   const hasActive = activeCount > 0;
@@ -494,7 +512,9 @@ export function renderDashboard(
   // Header: mascot + title + counts
   let headerRight = "";
   if (activeCount > 0) headerRight += `${green("●")} ${activeCount} active`;
-  if (waitingCount > 0) headerRight += `  ${yellow("◉")} ${waitingCount} waiting`;
+  if (awaitingInputCount > 0) headerRight += `  ${magenta("▶")} ${awaitingInputCount} awaiting`;
+  if (idleCount > 0) headerRight += `  ${dim("⏸")} ${idleCount} idle`;
+  if (waitingCount > 0) headerRight += `  ${yellow("◉")} ${waitingCount} gated`;
   if (pausedCount > 0) headerRight += `  ${yellow("○")} ${pausedCount} paused`;
   if (failedCount > 0) headerRight += `  ${red("✗")} ${failedCount} failed`;
   if (completedCount > 0) headerRight += `  ${green("✓")} ${completedCount} done`;

package/cli/src/observer/watcher.ts

@@ -1,21 +1,21 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { discoverWorktrees } from "./data.js";
+import { discoverWorktrees, type WorktreeEntry } from "./data.js";
 
 export interface WatcherHandle {
   stop: () => void;
-  getWorktrees: () => string[];
+  getWorktrees: () => WorktreeEntry[];
 }
 
 export function startWatching(
-  mainRepoRoot: string,
+  mainRepoRoots: string[],
   onUpdate: () => void
 ): WatcherHandle {
   const watchers = new Map<string, fs.FSWatcher>();
   let debounceTimer: ReturnType<typeof setTimeout> | null = null;
   let pollTimer: ReturnType<typeof setInterval> | null = null;
   let stopped = false;
-  let cachedWorktrees: string[] = [];
+  let cachedEntries: WorktreeEntry[] = [];
 
   function debouncedUpdate(): void {
     if (stopped) return;
@@ -60,19 +60,29 @@ export function startWatching(
 
   function refreshWorktrees(): void {
     if (stopped) return;
-    const current = discoverWorktrees(mainRepoRoot);
-    const currentSet = new Set(current);
+    const seen = new Set<string>();
+    const current: WorktreeEntry[] = [];
+    for (const root of mainRepoRoots) {
+      for (const wt of discoverWorktrees(root)) {
+        if (seen.has(wt)) continue;
+        seen.add(wt);
+        current.push({ root, worktree: wt });
+      }
+    }
 
-    // Only trigger update if worktree list actually changed
-    const changed = current.length !== cachedWorktrees.length
-      || current.some((wt, i) => wt !== cachedWorktrees[i]);
+    // Only trigger update if the entry list actually changed. Compare
+    // both fields so a worktree path reused under a different root is
+    // detected as a real change.
+    const changed = current.length !== cachedEntries.length
+      || current.some((e, i) =>
+        e.worktree !== cachedEntries[i].worktree || e.root !== cachedEntries[i].root);
 
-    for (const wt of current) {
-      watchStateFile(wt);
+    for (const e of current) {
+      watchStateFile(e.worktree);
     }
-    unwatchRemoved(currentSet);
+    unwatchRemoved(seen);
 
-    cachedWorktrees = current;
+    cachedEntries = current;
 
     if (changed) {
       debouncedUpdate();
@@ -82,10 +92,12 @@ export function startWatching(
   // Initial setup
   refreshWorktrees();
 
-  // Poll for new/removed worktrees every 5 seconds
+  // Poll for new/removed worktrees. Each tick spawns one `git worktree
+  // list` per root, so back off when watching many repos under --all.
+  const pollIntervalMs = mainRepoRoots.length > 1 ? 30_000 : 5_000;
   pollTimer = setInterval(() => {
     if (!stopped) refreshWorktrees();
-  }, 5000);
+  }, pollIntervalMs);
 
   return {
     stop() {
@@ -98,7 +110,7 @@ export function startWatching(
       watchers.clear();
     },
     getWorktrees() {
-      return cachedWorktrees;
+      return cachedEntries;
     },
   };
 }

package/cli/src/state/helpers.test.ts

@@ -1,27 +1,27 @@
 import { describe, it } from "node:test";
 import * as assert from "node:assert/strict";
 import { parseLocation, resetToLocation } from "./helpers.js";
-import type { WorkKitState, PhaseName, PhaseState, SubStageState } from "./schema.js";
-import { PHASE_NAMES, SUBSTAGES_BY_PHASE } from "./schema.js";
+import type { WorkKitState, PhaseName, PhaseState, StepState } from "./schema.js";
+import { PHASE_NAMES, STEPS_BY_PHASE } from "./schema.js";
 
 function makeState(): WorkKitState {
   const phases = {} as Record<PhaseName, PhaseState>;
   for (const phase of PHASE_NAMES) {
-    const subStages: Record<string, SubStageState> = {};
-    for (const ss of SUBSTAGES_BY_PHASE[phase]) {
-      subStages[ss] = { status: "pending" };
+    const steps: Record<string, StepState> = {};
+    for (const s of STEPS_BY_PHASE[phase]) {
+      steps[s] = { status: "pending" };
     }
-    phases[phase] = { status: "pending", subStages };
+    phases[phase] = { status: "pending", steps };
   }
   return {
-    version: 1,
+    version: 2,
     slug: "test",
     branch: "feature/test",
     started: "2026-01-01",
     mode: "full-kit",
     status: "in-progress",
     currentPhase: "plan",
-    currentSubStage: "clarify",
+    currentStep: "clarify",
     phases,
     loopbacks: [],
     metadata: { worktreeRoot: "/tmp/test", mainRepoRoot: "/tmp/test" },
@@ -31,7 +31,7 @@ function makeState(): WorkKitState {
 describe("parseLocation", () => {
   it("parses plan/clarify correctly", () => {
     const loc = parseLocation("plan/clarify");
-    assert.deepStrictEqual(loc, { phase: "plan", subStage: "clarify" });
+    assert.deepStrictEqual(loc, { phase: "plan", step: "clarify" });
   });
 
   it("throws on invalid format (no slash)", () => {
@@ -42,8 +42,8 @@ describe("parseLocation", () => {
     assert.throws(() => parseLocation("foobar/baz"), /Unknown phase/);
   });
 
-  it("throws on unknown sub-stage", () => {
-    assert.throws(() => parseLocation("plan/nonexistent"), /Unknown sub-stage/);
+  it("throws on unknown step", () => {
+    assert.throws(() => parseLocation("plan/nonexistent"), /Unknown step/);
   });
 });
 
@@ -52,40 +52,40 @@ describe("resetToLocation", () => {
     const state = makeState();
 
     // Mark plan and build as completed
-    for (const ss of Object.values(state.phases.plan.subStages)) {
-      ss.status = "completed";
-      ss.completedAt = "2026-01-01";
+    for (const s of Object.values(state.phases.plan.steps)) {
+      s.status = "completed";
+      s.completedAt = "2026-01-01";
     }
     state.phases.plan.status = "completed";
     state.phases.plan.completedAt = "2026-01-01";
 
-    for (const ss of Object.values(state.phases.build.subStages)) {
-      ss.status = "completed";
-      ss.completedAt = "2026-01-02";
+    for (const s of Object.values(state.phases.build.steps)) {
+      s.status = "completed";
+      s.completedAt = "2026-01-02";
     }
     state.phases.build.status = "completed";
     state.phases.build.completedAt = "2026-01-02";
 
     // Reset to plan/blueprint
-    resetToLocation(state, { phase: "plan", subStage: "blueprint" });
+    resetToLocation(state, { phase: "plan", step: "blueprint" });
 
-    // Sub-stages before blueprint should stay completed
-    assert.equal(state.phases.plan.subStages.clarify.status, "completed");
-    assert.equal(state.phases.plan.subStages.investigate.status, "completed");
-    assert.equal(state.phases.plan.subStages.sketch.status, "completed");
-    assert.equal(state.phases.plan.subStages.scope.status, "completed");
-    assert.equal(state.phases.plan.subStages["ux-flow"].status, "completed");
-    assert.equal(state.phases.plan.subStages.architecture.status, "completed");
+    // Steps before blueprint should stay completed
+    assert.equal(state.phases.plan.steps.clarify.status, "completed");
+    assert.equal(state.phases.plan.steps.investigate.status, "completed");
+    assert.equal(state.phases.plan.steps.sketch.status, "completed");
+    assert.equal(state.phases.plan.steps.scope.status, "completed");
+    assert.equal(state.phases.plan.steps["ux-flow"].status, "completed");
+    assert.equal(state.phases.plan.steps.architecture.status, "completed");
 
     // Blueprint and audit should be reset
-    assert.equal(state.phases.plan.subStages.blueprint.status, "pending");
-    assert.equal(state.phases.plan.subStages.audit.status, "pending");
+    assert.equal(state.phases.plan.steps.blueprint.status, "pending");
+    assert.equal(state.phases.plan.steps.audit.status, "pending");
 
     // Plan phase should be in-progress
     assert.equal(state.phases.plan.status, "in-progress");
 
     // Build (later phase) should be reset
     assert.equal(state.phases.build.status, "pending");
-    assert.equal(state.phases.build.subStages.core.status, "pending");
+    assert.equal(state.phases.build.steps.core.status, "pending");
   });
 });