@open-code-review/cli 1.3.1 → 1.4.0

package/dist/index.js

@@ -289,6 +289,28 @@ sessions/
     } catch {
     }
   }
+  const reviewersDir = join(ocrSkillsDest, "references", "reviewers");
+  const existingReviewers = /* @__PURE__ */ new Map();
+  const warnings = [];
+  if (existsSync(reviewersDir)) {
+    try {
+      const reviewerFiles = readdirSync(reviewersDir).filter(
+        (f) => f.endsWith(".md")
+      );
+      for (const file of reviewerFiles) {
+        const filePath = join(reviewersDir, file);
+        try {
+          existingReviewers.set(file, readFileSync(filePath));
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : "unknown error";
+          warnings.push(`Could not read reviewer ${file}: ${msg}`);
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "unknown error";
+      warnings.push(`Could not read reviewers directory: ${msg}`);
+    }
+  }
   const skillsOk = copyDirSafe(ocrSkillsSource, ocrSkillsDest);
   if (!skillsOk) {
     return {
@@ -313,6 +335,17 @@ sessions/
     } catch {
     }
   }
+  if (existingReviewers.size > 0) {
+    ensureDir(reviewersDir);
+    for (const [file, content] of existingReviewers) {
+      try {
+        writeFileSync(join(reviewersDir, file), content);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "unknown error";
+        warnings.push(`Could not restore reviewer ${file}: ${msg}`);
+      }
+    }
+  }
   const commandsOk = installCommandsForTool(tool, commandsSource, targetDir);
   if (!commandsOk) {
     return {
@@ -323,7 +356,8 @@ sessions/
   }
   return {
     tool,
-    success: true
+    success: true,
+    warnings: warnings.length > 0 ? warnings : void 0
   };
 }
 function detectInstalledTools(targetDir, tools) {
@@ -357,9 +391,11 @@ Always open \`.ocr/skills/SKILL.md\` when the request:
 - Asks for code review, PR review, or feedback on changes
 - Mentions "review my code" or similar phrases
 - Wants multi-perspective analysis of code quality
+- Asks to map, organize, or navigate a large changeset
 
 Use \`.ocr/skills/SKILL.md\` to learn:
 - How to run the 8-phase review workflow
+- How to generate a Code Review Map for large changesets
 - Available reviewer personas and their focus areas
 - Session management and output format
 
@@ -545,6 +581,14 @@ var initCommand = new Command("init").description("Set up OCR for AI coding envi
       console.log(`  ${chalk2.red("\u2717")} ${result.tool.name}: ${result.error}`);
     }
   }
+  const allWarnings = results.flatMap((r) => r.warnings ?? []);
+  if (allWarnings.length > 0) {
+    console.log();
+    console.log(chalk2.yellow("\u26A0 Warnings:"));
+    for (const warning of allWarnings) {
+      console.log(`  ${chalk2.yellow("\u26A0")} ${warning}`);
+    }
+  }
   if (options.inject && successful.length > 0) {
     console.log();
     const injectSpinner = ora(
@@ -582,11 +626,11 @@ var initCommand = new Command("init").description("Set up OCR for AI coding envi
 
 // packages/cli/src/commands/progress.ts
 import { Command as Command2 } from "commander";
-import chalk4 from "chalk";
+import chalk7 from "chalk";
 import { watch } from "chokidar";
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync } from "node:fs";
-import { join as join5, basename } from "node:path";
-import logUpdate from "log-update";
+import { existsSync as existsSync8, readdirSync as readdirSync5, statSync } from "node:fs";
+import { join as join8, basename as basename3 } from "node:path";
+import logUpdate4 from "log-update";
 
 // packages/cli/src/lib/guards.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync2 } from "node:fs";
@@ -641,30 +685,66 @@ function ensureSessionsDir(targetDir) {
   return sessionsDir;
 }
 
-// packages/cli/src/commands/progress.ts
-function debounce(fn, delay) {
-  let timeoutId = null;
-  return (...args) => {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
+// packages/cli/src/lib/progress/strategy.ts
+var strategies = /* @__PURE__ */ new Map();
+function registerStrategy(strategy) {
+  strategies.set(strategy.workflowType, strategy);
+}
+function getStrategy(workflowType) {
+  return strategies.get(workflowType);
+}
+
+// packages/cli/src/lib/progress/detector.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync2 } from "node:fs";
+import { join as join5 } from "node:path";
+function detectWorkflowType(sessionPath, explicitType) {
+  if (explicitType) {
+    return explicitType;
+  }
+  const statePath = join5(sessionPath, "state.json");
+  if (existsSync5(statePath)) {
+    try {
+      const content = readFileSync4(statePath, "utf-8");
+      const state = JSON.parse(content);
+      if (state.workflow_type) {
+        return state.workflow_type;
+      }
+    } catch {
     }
-    timeoutId = setTimeout(() => {
-      fn(...args);
-      timeoutId = null;
-    }, delay);
-  };
+  }
+  const hasMapDir = existsSync5(join5(sessionPath, "map"));
+  const hasRoundsDir = existsSync5(join5(sessionPath, "rounds"));
+  if (hasMapDir && !hasRoundsDir) {
+    return "map";
+  }
+  if (hasRoundsDir && !hasMapDir) {
+    return "review";
+  }
+  if (hasMapDir && hasRoundsDir) {
+    if (existsSync5(statePath)) {
+      try {
+        const content = readFileSync4(statePath, "utf-8");
+        const state = JSON.parse(content);
+        const phase = state.current_phase;
+        if (phase.startsWith("map-") || phase === "topology" || phase === "flow-analysis" || phase === "requirements-mapping") {
+          return "map";
+        }
+        return "review";
+      } catch {
+        return "review";
+      }
+    }
+  }
+  return "review";
 }
-var lastRenderType = null;
-var lastLineCount = 0;
-var TOTAL_PHASES = 8;
 function isSessionActive(sessionPath) {
   const statePath = join5(sessionPath, "state.json");
   if (!existsSync5(statePath)) {
     return true;
   }
   try {
-    const stateContent = readFileSync4(statePath, "utf-8");
-    const state = JSON.parse(stateContent);
+    const content = readFileSync4(statePath, "utf-8");
+    const state = JSON.parse(content);
     if (state.status === "closed" || state.current_phase === "complete") {
       return false;
     }
@@ -673,27 +753,119 @@ function isSessionActive(sessionPath) {
     return true;
   }
 }
-function findLatestActiveSession(sessionsDir) {
-  if (!existsSync5(sessionsDir)) {
-    return null;
+function detectActiveWorkflows(sessionPath) {
+  const activeWorkflows = [];
+  const hasRoundsDir = existsSync5(join5(sessionPath, "rounds"));
+  if (hasRoundsDir) {
+    const roundsDir = join5(sessionPath, "rounds");
+    const rounds = existsSync5(roundsDir) ? readdirSync2(roundsDir).filter((d) => d.match(/^round-\d+$/)).sort() : [];
+    if (rounds.length > 0) {
+      const latestRound = rounds[rounds.length - 1];
+      const finalPath = join5(roundsDir, latestRound, "final.md");
+      if (!existsSync5(finalPath)) {
+        activeWorkflows.push("review");
+      }
+    } else {
+      activeWorkflows.push("review");
+    }
   }
-  const sessions = readdirSync2(sessionsDir).filter((name) => {
-    const sessionPath = join5(sessionsDir, name);
-    return statSync(sessionPath).isDirectory();
-  }).sort().reverse();
-  for (const session of sessions) {
-    const sessionPath = join5(sessionsDir, session);
-    if (isSessionActive(sessionPath)) {
-      return session;
+  const hasMapDir = existsSync5(join5(sessionPath, "map"));
+  if (hasMapDir) {
+    const runsDir = join5(sessionPath, "map", "runs");
+    const runs = existsSync5(runsDir) ? readdirSync2(runsDir).filter((d) => d.match(/^run-\d+$/)).sort() : [];
+    if (runs.length > 0) {
+      const latestRun = runs[runs.length - 1];
+      const mapPath = join5(runsDir, latestRun, "map.md");
+      if (!existsSync5(mapPath)) {
+        activeWorkflows.push("map");
+      }
+    } else {
+      activeWorkflows.push("map");
     }
   }
-  return null;
+  if (activeWorkflows.length === 0) {
+    const statePath = join5(sessionPath, "state.json");
+    if (existsSync5(statePath)) {
+      try {
+        const content = readFileSync4(statePath, "utf-8");
+        const state = JSON.parse(content);
+        if (state.workflow_type && state.current_phase !== "complete") {
+          activeWorkflows.push(state.workflow_type);
+        }
+      } catch {
+      }
+    }
+  }
+  return activeWorkflows;
+}
+
+// packages/cli/src/lib/progress/render-utils.ts
+import chalk4 from "chalk";
+import logUpdate from "log-update";
+var lastRenderType = null;
+var lastLineCount = 0;
+function formatDuration(ms) {
+  const clampedMs = Math.max(0, ms);
+  const totalSeconds = Math.floor(clampedMs / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) {
+    return `${hours}h ${minutes}m ${seconds}s`;
+  } else if (minutes > 0) {
+    return `${minutes}m ${seconds}s`;
+  } else {
+    return `${seconds}s`;
+  }
+}
+function renderProgressBar(current, total, label) {
+  const width = 24;
+  const filled = Math.round(current / total * width);
+  const empty = width - filled;
+  const bar = chalk4.green("\u2501".repeat(filled)) + chalk4.dim("\u2500".repeat(empty));
+  const percent = Math.round(current / total * 100);
+  const percentStr = chalk4.bold.white(`${percent}%`);
+  return label ? `${bar}  ${percentStr} ${chalk4.dim("\xB7")} ${chalk4.cyan(label)}` : `${bar}  ${percentStr}`;
+}
+function getPhaseStatus(isComplete, isCurrent) {
+  if (isComplete) return chalk4.green("\u2713");
+  if (isCurrent) return chalk4.cyan("\u25B8");
+  return chalk4.dim("\xB7");
+}
+function clearForRenderType(renderType) {
+  if (lastRenderType !== renderType) {
+    logUpdate.clear();
+  }
+  lastRenderType = renderType;
+}
+function padLines(lines) {
+  while (lines.length < lastLineCount) {
+    lines.push("");
+  }
+  lastLineCount = lines.length;
+  return lines;
 }
+
+// packages/cli/src/lib/progress/review-strategy.ts
+import chalk5 from "chalk";
+import logUpdate2 from "log-update";
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync5 } from "node:fs";
+import { join as join6, basename } from "node:path";
+var REVIEW_PHASES = [
+  { key: "context", label: "Context Discovery" },
+  { key: "change-context", label: "Change Context" },
+  { key: "analysis", label: "Tech Lead Analysis" },
+  { key: "reviews", label: "Parallel Reviews" },
+  { key: "aggregation", label: "Aggregate Findings" },
+  { key: "discourse", label: "Reviewer Discourse" },
+  { key: "synthesis", label: "Final Synthesis" },
+  { key: "complete", label: "Complete" }
+];
 function countFindings(filePath) {
-  if (!existsSync5(filePath)) {
+  if (!existsSync6(filePath)) {
     return 0;
   }
-  const content = readFileSync4(filePath, "utf-8");
+  const content = readFileSync5(filePath, "utf-8");
   const findingMatches = content.match(/^##\s+(Finding|Issue|Suggestion)/gm);
   return findingMatches?.length ?? 0;
 }
@@ -706,346 +878,622 @@ function formatReviewerName(filename) {
   }
   return base.charAt(0).toUpperCase() + base.slice(1);
 }
-function parseSessionState(sessionPath, preservedStartTime) {
-  const session = basename(sessionPath);
-  const statePath = join5(sessionPath, "state.json");
-  if (!existsSync5(statePath)) {
-    return null;
-  }
-  try {
-    const stateContent = readFileSync4(statePath, "utf-8");
-    const state = JSON.parse(stateContent);
-    return parseFromStateJson(session, state, sessionPath, preservedStartTime);
-  } catch {
-    return null;
-  }
-}
-function parseFromStateJson(session, state, sessionPath, preservedStartTime) {
-  const effectiveStartTime = state.round_started_at ?? state.started_at;
-  const startTime = preservedStartTime ?? (effectiveStartTime ? new Date(effectiveStartTime).getTime() : Date.now());
-  const roundsDir = join5(sessionPath, "rounds");
-  const rounds = deriveRoundsFromFilesystem(roundsDir);
-  const highestExistingRound = rounds.length > 0 ? Math.max(...rounds.map((r) => r.round)) : 1;
-  const stateRound = state.current_round ?? 1;
-  const currentRound = Math.min(stateRound, highestExistingRound);
-  const currentRoundDir = join5(roundsDir, `round-${currentRound}`);
-  const reviewsDir = join5(currentRoundDir, "reviews");
-  const reviewers = [];
-  if (existsSync5(reviewsDir)) {
-    const entries = readdirSync2(reviewsDir);
-    const reviewFiles = entries.filter((f) => f.endsWith(".md"));
-    for (const file of reviewFiles) {
-      const reviewPath = join5(reviewsDir, file);
-      const findings = countFindings(reviewPath);
-      reviewers.push({
-        name: file.replace(".md", ""),
-        displayName: formatReviewerName(file),
-        status: "complete",
-        findings
-      });
-    }
-  }
-  const contextComplete = existsSync5(
-    join5(sessionPath, "discovered-standards.md")
-  );
-  const changeContextComplete = existsSync5(join5(sessionPath, "context.md"));
-  const analysisComplete = changeContextComplete;
-  const reviewsComplete = state.phase_number > 4;
-  const discourseComplete = existsSync5(join5(currentRoundDir, "discourse.md"));
-  const synthesisComplete = existsSync5(join5(currentRoundDir, "final.md"));
-  return {
-    session,
-    phase: state.current_phase,
-    phaseNumber: state.phase_number,
-    totalPhases: TOTAL_PHASES,
-    contextComplete,
-    changeContextComplete,
-    analysisComplete,
-    reviewsComplete,
-    aggregationComplete: reviewsComplete,
-    // Aggregation is inline
-    discourseComplete,
-    synthesisComplete,
-    currentRound,
-    rounds,
-    reviewers,
-    startTime,
-    complete: state.current_phase === "complete"
-  };
-}
 function deriveRoundsFromFilesystem(roundsDir) {
-  if (!existsSync5(roundsDir)) {
+  if (!existsSync6(roundsDir)) {
     return [];
   }
-  const roundDirs = readdirSync2(roundsDir).filter((d) => d.match(/^round-\d+$/)).sort((a, b) => {
+  const roundDirs = readdirSync3(roundsDir).filter((d) => d.match(/^round-\d+$/)).sort((a, b) => {
     const numA = parseInt(a.replace("round-", ""));
     const numB = parseInt(b.replace("round-", ""));
     return numA - numB;
   });
   return roundDirs.map((dir) => {
     const roundNum = parseInt(dir.replace("round-", ""));
-    const roundPath = join5(roundsDir, dir);
-    const reviewsPath = join5(roundPath, "reviews");
-    const finalPath = join5(roundPath, "final.md");
+    const roundPath = join6(roundsDir, dir);
+    const reviewsPath = join6(roundPath, "reviews");
+    const finalPath = join6(roundPath, "final.md");
     const reviewers = [];
-    if (existsSync5(reviewsPath)) {
-      const files = readdirSync2(reviewsPath).filter((f) => f.endsWith(".md"));
+    if (existsSync6(reviewsPath)) {
+      const files = readdirSync3(reviewsPath).filter((f) => f.endsWith(".md"));
       reviewers.push(...files.map((f) => f.replace(".md", "")));
     }
     return {
       round: roundNum,
-      isComplete: existsSync5(finalPath),
+      isComplete: existsSync6(finalPath),
       reviewers
     };
   });
 }
-function formatDuration(ms) {
-  const absMs = Math.abs(ms);
-  const totalSeconds = Math.floor(absMs / 1e3);
-  const hours = Math.floor(totalSeconds / 3600);
-  const minutes = Math.floor(totalSeconds % 3600 / 60);
-  const seconds = totalSeconds % 60;
-  let duration;
-  if (hours > 0) {
-    duration = `${hours}h ${minutes}m ${seconds}s`;
-  } else if (minutes > 0) {
-    duration = `${minutes}m ${seconds}s`;
-  } else {
-    duration = `${seconds}s`;
+var ReviewProgressStrategy = class {
+  workflowType = "review";
+  phases = REVIEW_PHASES;
+  totalPhases = 8;
+  parseState(sessionPath, preservedStartTime) {
+    const session = basename(sessionPath);
+    const statePath = join6(sessionPath, "state.json");
+    if (!existsSync6(statePath)) {
+      return null;
+    }
+    try {
+      const stateContent = readFileSync5(statePath, "utf-8");
+      const state = JSON.parse(stateContent);
+      return this.parseFromStateJson(
+        session,
+        state,
+        sessionPath,
+        preservedStartTime
+      );
+    } catch {
+      return null;
+    }
   }
-  return duration;
-}
-var PHASE_INFO = [
-  { key: "context", label: "Context Discovery" },
-  { key: "change-context", label: "Change Context" },
-  { key: "analysis", label: "Tech Lead Analysis" },
-  { key: "reviews", label: "Parallel Reviews" },
-  { key: "aggregation", label: "Aggregate Findings" },
-  { key: "discourse", label: "Reviewer Discourse" },
-  { key: "synthesis", label: "Final Synthesis" },
+  parseFromStateJson(session, state, sessionPath, preservedStartTime) {
+    const effectiveStartTime = state.round_started_at ?? state.started_at;
+    const startTime = preservedStartTime ?? (effectiveStartTime ? new Date(effectiveStartTime).getTime() : Date.now());
+    const roundsDir = join6(sessionPath, "rounds");
+    const rounds = deriveRoundsFromFilesystem(roundsDir);
+    const highestExistingRound = rounds.length > 0 ? Math.max(...rounds.map((r) => r.round)) : 1;
+    const stateRound = state.current_round ?? 1;
+    const currentRound = Math.min(stateRound, highestExistingRound);
+    const currentRoundDir = join6(roundsDir, `round-${currentRound}`);
+    const reviewsDir = join6(currentRoundDir, "reviews");
+    const reviewers = [];
+    if (existsSync6(reviewsDir)) {
+      const entries = readdirSync3(reviewsDir);
+      const reviewFiles = entries.filter((f) => f.endsWith(".md"));
+      for (const file of reviewFiles) {
+        const reviewPath = join6(reviewsDir, file);
+        const findings = countFindings(reviewPath);
+        reviewers.push({
+          name: file.replace(".md", ""),
+          displayName: formatReviewerName(file),
+          status: "complete",
+          findings
+        });
+      }
+    }
+    const contextComplete = existsSync6(
+      join6(sessionPath, "discovered-standards.md")
+    );
+    const changeContextComplete = existsSync6(join6(sessionPath, "context.md"));
+    const analysisComplete = changeContextComplete;
+    const reviewsComplete = state.phase_number > 4;
+    const discourseComplete = existsSync6(join6(currentRoundDir, "discourse.md"));
+    const synthesisComplete = existsSync6(join6(currentRoundDir, "final.md"));
+    return {
+      workflowType: "review",
+      session,
+      phase: state.current_phase,
+      phaseNumber: state.phase_number,
+      totalPhases: this.totalPhases,
+      contextComplete,
+      changeContextComplete,
+      analysisComplete,
+      reviewsComplete,
+      aggregationComplete: reviewsComplete,
+      discourseComplete,
+      synthesisComplete,
+      currentRound,
+      rounds,
+      reviewers,
+      startTime,
+      complete: state.current_phase === "complete"
+    };
+  }
+  render(state) {
+    const lines = [];
+    const log = (line = "") => lines.push(line);
+    log();
+    log(chalk5.bold.white("  Open Code Review"));
+    log();
+    const elapsed = Math.max(0, Date.now() - state.startTime);
+    const roundInfo = state.currentRound > 1 ? chalk5.cyan(` Round ${state.currentRound}`) + chalk5.dim("  \xB7  ") : "";
+    log(
+      chalk5.dim("  ") + chalk5.white(state.session) + chalk5.dim("  \xB7  ") + roundInfo + chalk5.white(formatDuration(elapsed))
+    );
+    log();
+    const progressPhases = state.complete ? 8 : state.phaseNumber;
+    const currentPhase = this.phases.find((p) => p.key === state.phase);
+    const phaseLabel = state.complete ? "Done" : currentPhase?.label;
+    log(`  ${renderProgressBar(progressPhases, 8, phaseLabel)}`);
+    log();
+    const phaseCompletion = {
+      context: state.contextComplete,
+      "change-context": state.changeContextComplete,
+      analysis: state.analysisComplete,
+      reviews: state.reviewsComplete,
+      aggregation: state.aggregationComplete,
+      discourse: state.discourseComplete,
+      synthesis: state.synthesisComplete,
+      complete: state.complete
+    };
+    for (const phase of this.phases) {
+      const isComplete = phaseCompletion[phase.key] ?? false;
+      const isCurrent = state.phase === phase.key && !state.complete;
+      const status = getPhaseStatus(isComplete, isCurrent);
+      let label;
+      if (isCurrent) {
+        label = chalk5.cyan.bold(phase.label);
+      } else if (isComplete) {
+        label = chalk5.white(phase.label);
+      } else {
+        label = chalk5.dim(phase.label);
+      }
+      log(`  ${status} ${label}`);
+      if (phase.key === "reviews" && state.reviewers.length > 0) {
+        if (state.currentRound > 1) {
+          log(chalk5.dim("    ") + chalk5.cyan(`Round ${state.currentRound}`));
+        }
+        const reviewerLine = state.reviewers.map((r) => {
+          const icon = r.status === "complete" ? chalk5.green("\u2713") : chalk5.dim("\u25CB");
+          const name = chalk5.dim(r.displayName);
+          const count = r.findings > 0 ? chalk5.cyan(` ${r.findings}`) : chalk5.dim(" 0");
+          return `${icon} ${name}${count}`;
+        }).join(chalk5.dim("  \u2502  "));
+        log(chalk5.dim("    ") + reviewerLine);
+        if (state.rounds.length > 1) {
+          const prevRounds = state.rounds.slice(0, -1);
+          for (const round of prevRounds) {
+            const roundLabel = chalk5.dim(`    Round ${round.round}`);
+            const reviewerCount = round.reviewers.length;
+            const rstatus = round.isComplete ? chalk5.green("\u2713") : chalk5.dim("\u25CB");
+            log(
+              `${roundLabel} ${rstatus} ${chalk5.dim(`${reviewerCount} reviewers`)}`
+            );
+          }
+        }
+      }
+    }
+    log();
+    if (state.complete) {
+      const totalFindings = state.reviewers.reduce(
+        (sum, r) => sum + r.findings,
+        0
+      );
+      log(
+        chalk5.green.bold("  \u2713 Complete") + chalk5.dim(" \xB7 ") + chalk5.white(
+          `${totalFindings} finding${totalFindings !== 1 ? "s" : ""}`
+        )
+      );
+      log(
+        chalk5.dim("    ") + chalk5.dim("\u2192 ") + chalk5.white(
+          `.ocr/sessions/${state.session}/rounds/round-${state.currentRound}/final.md`
+        )
+      );
+    } else {
+      log(chalk5.dim("  Ctrl+C to exit"));
+    }
+    log();
+    clearForRenderType("review-progress");
+    logUpdate2(padLines(lines).join("\n"));
+  }
+  renderWaiting() {
+    const lines = [];
+    const log = (line = "") => lines.push(line);
+    log();
+    log(chalk5.bold.white("  Open Code Review"));
+    log();
+    log(chalk5.dim("  Waiting for session..."));
+    log();
+    const bar = chalk5.dim("\u2500".repeat(24));
+    log(`  ${bar}  ${chalk5.dim("0%")}`);
+    log();
+    log(
+      chalk5.dim("  Run ") + chalk5.white("/ocr-review") + chalk5.dim(" to start")
+    );
+    log();
+    log(chalk5.dim("  Ctrl+C to exit"));
+    log();
+    clearForRenderType("review-waiting");
+    logUpdate2(padLines(lines).join("\n"));
+  }
+};
+var reviewStrategy = new ReviewProgressStrategy();
+
+// packages/cli/src/lib/progress/map-strategy.ts
+import chalk6 from "chalk";
+import logUpdate3 from "log-update";
+import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync6 } from "node:fs";
+import { join as join7, basename as basename2 } from "node:path";
+var MAP_PHASES = [
+  { key: "map-context", label: "Context Discovery" },
+  { key: "topology", label: "Topology Analysis" },
+  { key: "flow-analysis", label: "Flow Tracing" },
+  { key: "requirements-mapping", label: "Requirements Mapping" },
+  { key: "synthesis", label: "Map Synthesis" },
   { key: "complete", label: "Complete" }
 ];
-function getPhaseStatus(isComplete, isCurrent) {
-  if (isComplete) return chalk4.green("\u2713");
-  if (isCurrent) return chalk4.cyan("\u25B8");
-  return chalk4.dim("\xB7");
-}
-function renderProgressBar(current, total, label) {
-  const width = 24;
-  const filled = Math.round(current / total * width);
-  const empty = width - filled;
-  const bar = chalk4.green("\u2501".repeat(filled)) + chalk4.dim("\u2500".repeat(empty));
-  const percent = Math.round(current / total * 100);
-  const percentStr = chalk4.bold.white(`${percent}%`);
-  return label ? `${bar}  ${percentStr} ${chalk4.dim("\xB7")} ${chalk4.cyan(label)}` : `${bar}  ${percentStr}`;
+function deriveRunsFromFilesystem(mapDir) {
+  const runsDir = join7(mapDir, "runs");
+  if (!existsSync7(runsDir)) {
+    return [];
+  }
+  const runDirs = readdirSync4(runsDir).filter((d) => d.match(/^run-\d+$/)).sort((a, b) => {
+    const numA = parseInt(a.replace("run-", ""));
+    const numB = parseInt(b.replace("run-", ""));
+    return numA - numB;
+  });
+  return runDirs.map((dir) => {
+    const runNum = parseInt(dir.replace("run-", ""));
+    const runPath = join7(runsDir, dir);
+    const mapPath = join7(runPath, "map.md");
+    let fileCount = 0;
+    const topologyPath = join7(runPath, "topology.md");
+    if (existsSync7(topologyPath)) {
+      const content = readFileSync6(topologyPath, "utf-8");
+      const fileListMatch = content.match(
+        /## Canonical File List[\s\S]*?```([\s\S]*?)```/
+      );
+      if (fileListMatch && fileListMatch[1]) {
+        fileCount = fileListMatch[1].trim().split("\n").filter(Boolean).length;
+      }
+    }
+    return {
+      run: runNum,
+      isComplete: existsSync7(mapPath),
+      fileCount
+    };
+  });
 }
-function renderProgress(state) {
-  const lines = [];
-  const log = (line = "") => lines.push(line);
-  log();
-  log(chalk4.bold.white("  Open Code Review"));
-  log();
-  const elapsed = Date.now() - state.startTime;
-  const roundInfo = state.currentRound > 1 ? chalk4.cyan(` Round ${state.currentRound}`) + chalk4.dim("  \xB7  ") : "";
-  log(
-    chalk4.dim("  ") + chalk4.white(state.session) + chalk4.dim("  \xB7  ") + roundInfo + chalk4.white(formatDuration(elapsed))
-  );
-  log();
-  const progressPhases = state.complete ? 8 : state.phaseNumber;
-  const currentPhase = PHASE_INFO.find((p) => p.key === state.phase);
-  const phaseLabel = state.complete ? "Done" : currentPhase?.label;
-  log(`  ${renderProgressBar(progressPhases, 8, phaseLabel)}`);
-  log();
-  const phaseCompletion = {
-    waiting: false,
-    context: state.contextComplete,
-    "change-context": state.changeContextComplete,
-    analysis: state.analysisComplete,
-    reviews: state.reviewsComplete,
-    aggregation: state.aggregationComplete,
-    discourse: state.discourseComplete,
-    synthesis: state.synthesisComplete,
-    complete: state.complete
-  };
-  for (const phase of PHASE_INFO) {
-    const isComplete = phaseCompletion[phase.key];
-    const isCurrent = state.phase === phase.key && !state.complete;
-    const status = getPhaseStatus(isComplete, isCurrent);
-    let label;
-    if (isCurrent) {
-      label = chalk4.cyan.bold(phase.label);
-    } else if (isComplete) {
-      label = chalk4.white(phase.label);
-    } else {
-      label = chalk4.dim(phase.label);
+var MapProgressStrategy = class {
+  workflowType = "map";
+  phases = MAP_PHASES;
+  totalPhases = 6;
+  parseState(sessionPath, preservedStartTime) {
+    const session = basename2(sessionPath);
+    const statePath = join7(sessionPath, "state.json");
+    if (!existsSync7(statePath)) {
+      return null;
     }
-    log(`  ${status} ${label}`);
-    if (phase.key === "reviews" && state.reviewers.length > 0) {
-      if (state.currentRound > 1) {
-        log(chalk4.dim("    ") + chalk4.cyan(`Round ${state.currentRound}`));
-      }
-      const reviewerLine = state.reviewers.map((r) => {
-        const icon = r.status === "complete" ? chalk4.green("\u2713") : chalk4.dim("\u25CB");
-        const name = chalk4.dim(r.displayName);
-        const count = r.findings > 0 ? chalk4.cyan(` ${r.findings}`) : chalk4.dim(" 0");
-        return `${icon} ${name}${count}`;
-      }).join(chalk4.dim("  \u2502  "));
-      log(chalk4.dim("    ") + reviewerLine);
-      if (state.rounds.length > 1) {
-        const prevRounds = state.rounds.slice(0, -1);
-        for (const round of prevRounds) {
-          const roundLabel = chalk4.dim(`    Round ${round.round}`);
-          const reviewerCount = round.reviewers.length;
-          const status2 = round.isComplete ? chalk4.green("\u2713") : chalk4.dim("\u25CB");
-          log(
-            `${roundLabel} ${status2} ${chalk4.dim(`${reviewerCount} reviewers`)}`
-          );
-        }
+    try {
+      const stateContent = readFileSync6(statePath, "utf-8");
+      const state = JSON.parse(stateContent);
+      if (state.workflow_type !== "map") {
+        return null;
       }
+      return this.parseFromStateJson(
+        session,
+        state,
+        sessionPath,
+        preservedStartTime
+      );
+    } catch {
+      return null;
     }
   }
-  log();
-  if (state.complete) {
-    const totalFindings = state.reviewers.reduce(
-      (sum, r) => sum + r.findings,
-      0
+  parseFromStateJson(session, state, sessionPath, preservedStartTime) {
+    const effectiveStartTime = state.map_started_at ?? state.started_at;
+    const startTime = preservedStartTime ?? (effectiveStartTime ? new Date(effectiveStartTime).getTime() : Date.now());
+    const mapDir = join7(sessionPath, "map");
+    const runs = deriveRunsFromFilesystem(mapDir);
+    const highestExistingRun = runs.length > 0 ? Math.max(...runs.map((r) => r.run)) : 1;
+    const stateRun = state.current_map_run ?? 1;
+    const currentRun = Math.min(stateRun, highestExistingRun);
+    const currentRunDir = join7(mapDir, "runs", `run-${currentRun}`);
+    const contextComplete = existsSync7(
+      join7(sessionPath, "discovered-standards.md")
     );
-    log(
-      chalk4.green.bold("  \u2713 Complete") + chalk4.dim(" \xB7 ") + chalk4.white(
-        `${totalFindings} finding${totalFindings !== 1 ? "s" : ""}`
-      )
+    const topologyComplete = existsSync7(join7(currentRunDir, "topology.md"));
+    const flowAnalysisComplete = existsSync7(
+      join7(currentRunDir, "flow-analysis.md")
     );
-    log(
-      chalk4.dim("    ") + chalk4.dim("\u2192 ") + chalk4.white(
-        `.ocr/sessions/${state.session}/rounds/round-${state.currentRound}/final.md`
-      )
+    const requirementsMappingComplete = existsSync7(
+      join7(currentRunDir, "requirements-mapping.md")
     );
-  } else {
-    log(chalk4.dim("  Ctrl+C to exit"));
+    const synthesisComplete = existsSync7(join7(currentRunDir, "map.md"));
+    const hasRequirements = existsSync7(join7(sessionPath, "requirements.md"));
+    const flowAnalysts = flowAnalysisComplete ? [
+      {
+        name: "flow-analyst",
+        displayName: "Flow Analysts",
+        status: "complete"
+      }
+    ] : [];
+    const requirementsMappers = requirementsMappingComplete && hasRequirements ? [
+      {
+        name: "req-mapper",
+        displayName: "Requirements Mappers",
+        status: "complete"
+      }
+    ] : [];
+    return {
+      workflowType: "map",
+      session,
+      phase: state.current_phase,
+      phaseNumber: state.phase_number,
+      totalPhases: this.totalPhases,
+      contextComplete,
+      topologyComplete,
+      flowAnalysisComplete,
+      requirementsMappingComplete,
+      synthesisComplete,
+      currentRun,
+      runs,
+      flowAnalysts,
+      requirementsMappers,
+      hasRequirements,
+      startTime,
+      complete: state.current_phase === "complete"
+    };
   }
-  log();
-  if (lastRenderType !== "progress") {
-    logUpdate.clear();
+  render(state) {
+    const lines = [];
+    const log = (line = "") => lines.push(line);
+    log();
+    log(chalk6.bold.white("  Open Code Review") + chalk6.cyan(" \xB7 Map"));
+    log();
+    const elapsed = Math.max(0, Date.now() - state.startTime);
+    const runInfo = state.currentRun > 1 ? chalk6.cyan(` Run ${state.currentRun}`) + chalk6.dim("  \xB7  ") : "";
+    log(
+      chalk6.dim("  ") + chalk6.white(state.session) + chalk6.dim("  \xB7  ") + runInfo + chalk6.white(formatDuration(elapsed))
+    );
+    log();
+    const currentRunInfo = state.runs.find((r) => r.run === state.currentRun);
+    if (currentRunInfo && currentRunInfo.fileCount > 0) {
+      log(
+        chalk6.dim("  ") + chalk6.white(`${currentRunInfo.fileCount} files`) + chalk6.dim(" in changeset")
+      );
+      log();
+    }
+    const progressPhases = state.complete ? 6 : state.phaseNumber;
+    const currentPhase = this.phases.find((p) => p.key === state.phase);
+    const phaseLabel = state.complete ? "Done" : currentPhase?.label;
+    log(`  ${renderProgressBar(progressPhases, 6, phaseLabel)}`);
+    log();
+    const phaseCompletion = {
+      "map-context": state.contextComplete,
+      topology: state.topologyComplete,
+      "flow-analysis": state.flowAnalysisComplete,
+      "requirements-mapping": state.requirementsMappingComplete,
+      synthesis: state.synthesisComplete,
+      complete: state.complete
+    };
+    for (const phase of this.phases) {
+      if (phase.key === "requirements-mapping" && !state.hasRequirements) {
+        continue;
+      }
+      const isComplete = phaseCompletion[phase.key] ?? false;
+      const isCurrent = state.phase === phase.key && !state.complete;
+      const status = getPhaseStatus(isComplete, isCurrent);
+      let label;
+      if (isCurrent) {
+        label = chalk6.cyan.bold(phase.label);
+      } else if (isComplete) {
+        label = chalk6.white(phase.label);
+      } else {
+        label = chalk6.dim(phase.label);
+      }
+      log(`  ${status} ${label}`);
+      if (phase.key === "flow-analysis" && state.flowAnalysts.length > 0) {
+        const agentLine = state.flowAnalysts.map((a) => {
+          const icon = a.status === "complete" ? chalk6.green("\u2713") : chalk6.dim("\u25CB");
+          return `${icon} ${chalk6.dim(a.displayName)}`;
+        }).join(chalk6.dim("  \u2502  "));
+        log(chalk6.dim("    ") + agentLine);
+      }
+      if (phase.key === "requirements-mapping" && state.requirementsMappers.length > 0) {
+        const agentLine = state.requirementsMappers.map((a) => {
+          const icon = a.status === "complete" ? chalk6.green("\u2713") : chalk6.dim("\u25CB");
+          return `${icon} ${chalk6.dim(a.displayName)}`;
+        }).join(chalk6.dim("  \u2502  "));
+        log(chalk6.dim("    ") + agentLine);
+      }
+    }
+    log();
+    if (state.complete) {
+      log(chalk6.green.bold("  \u2713 Map Complete"));
+      log(
+        chalk6.dim("    ") + chalk6.dim("\u2192 ") + chalk6.white(
+          `.ocr/sessions/${state.session}/map/runs/run-${state.currentRun}/map.md`
+        )
+      );
+    } else {
+      log(chalk6.dim("  Ctrl+C to exit"));
+    }
+    log();
+    clearForRenderType("map-progress");
+    logUpdate3(padLines(lines).join("\n"));
   }
-  lastRenderType = "progress";
-  while (lines.length < lastLineCount) {
-    lines.push("");
+  renderWaiting() {
+    const lines = [];
+    const log = (line = "") => lines.push(line);
+    log();
+    log(chalk6.bold.white("  Open Code Review") + chalk6.cyan(" \xB7 Map"));
+    log();
+    log(chalk6.dim("  Waiting for session..."));
+    log();
+    const bar = chalk6.dim("\u2500".repeat(24));
+    log(`  ${bar}  ${chalk6.dim("0%")}`);
+    log();
+    log(chalk6.dim("  Run ") + chalk6.white("/ocr-map") + chalk6.dim(" to start"));
+    log();
+    log(chalk6.dim("  Ctrl+C to exit"));
+    log();
+    clearForRenderType("map-waiting");
+    logUpdate3(padLines(lines).join("\n"));
   }
-  lastLineCount = lines.length;
-  logUpdate(lines.join("\n"));
+};
+var mapStrategy = new MapProgressStrategy();
+
+// packages/cli/src/lib/progress/index.ts
+registerStrategy(reviewStrategy);
+registerStrategy(mapStrategy);
+
+// packages/cli/src/commands/progress.ts
+function debounce(fn, delay) {
+  let timeoutId = null;
+  return (...args) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn(...args);
+      timeoutId = null;
+    }, delay);
+  };
 }
-function renderWaiting() {
-  const lines = [];
-  const log = (line = "") => lines.push(line);
-  log();
-  log(chalk4.bold.white("  Open Code Review"));
-  log();
-  log(chalk4.dim("  Waiting for session..."));
-  log();
-  const bar = chalk4.dim("\u2500".repeat(24));
-  log(`  ${bar}  ${chalk4.dim("0%")}`);
-  log();
-  log(
-    chalk4.dim("  Run ") + chalk4.white("/ocr-review") + chalk4.dim(" to start")
-  );
-  log();
-  log(chalk4.dim("  Ctrl+C to exit"));
-  log();
-  if (lastRenderType !== "waiting") {
-    logUpdate.clear();
+function findLatestActiveSession(sessionsDir) {
+  if (!existsSync8(sessionsDir)) {
+    return null;
   }
-  lastRenderType = "waiting";
-  while (lines.length < lastLineCount) {
-    lines.push("");
+  const sessions = readdirSync5(sessionsDir).filter((name) => {
+    const sessionPath = join8(sessionsDir, name);
+    return statSync(sessionPath).isDirectory();
+  }).sort().reverse();
+  for (const session of sessions) {
+    const sessionPath = join8(sessionsDir, session);
+    if (isSessionActive(sessionPath)) {
+      return session;
+    }
   }
-  lastLineCount = lines.length;
-  logUpdate(lines.join("\n"));
+  return null;
 }
-var progressCommand = new Command2("progress").description("Watch real-time progress of a code review session").option("-s, --session <name>", "Specify session name").action(async (options) => {
+function getStrategyForSession(sessionPath, explicitWorkflow) {
+  const workflowType = detectWorkflowType(sessionPath, explicitWorkflow);
+  if (!workflowType) {
+    return null;
+  }
+  return getStrategy(workflowType) ?? null;
+}
+var progressCommand = new Command2("progress").description("Watch real-time progress of a code review or map session").option("-s, --session <name>", "Specify session name").option(
+  "-w, --workflow <type>",
+  "Specify workflow type (review or map)",
+  (value) => {
+    if (value !== "review" && value !== "map") {
+      throw new Error(
+        `Invalid workflow type: ${value}. Use 'review' or 'map'.`
+      );
+    }
+    return value;
+  }
+).action(async (options) => {
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
   const sessionsDir = ensureSessionsDir(targetDir);
-  const ocrDir = join5(targetDir, ".ocr");
+  const ocrDir = join8(targetDir, ".ocr");
   if (options.session) {
-    const sessionPath = join5(sessionsDir, options.session);
-    if (!existsSync5(sessionPath)) {
-      console.log(chalk4.red(`Session not found: ${options.session}`));
+    const sessionPath = join8(sessionsDir, options.session);
+    if (!existsSync8(sessionPath)) {
+      console.log(chalk7.red(`Session not found: ${options.session}`));
+      process.exit(1);
+    }
+    const strategy = getStrategyForSession(sessionPath, options.workflow);
+    if (!strategy) {
+      console.log(
+        chalk7.red(
+          `Cannot determine workflow type for session ${options.session}`
+        )
+      );
+      console.log(
+        chalk7.dim(`Try specifying --workflow review or --workflow map`)
+      );
       process.exit(1);
     }
-    let state = parseSessionState(sessionPath);
+    let state = strategy.parseState(sessionPath);
     if (!state) {
       console.log(
-        chalk4.red(
+        chalk7.red(
           `Session ${options.session} has no state.json - cannot track progress`
         )
       );
       console.log(
-        chalk4.dim(
+        chalk7.dim(
           `The orchestrating agent must create state.json for progress tracking.`
         )
       );
       process.exit(1);
     }
-    let preservedStartTime2 = state.startTime;
-    renderProgress(state);
+    let preservedStartTime = state.startTime;
+    strategy.render(state);
     const timerInterval2 = setInterval(() => {
-      const newState = parseSessionState(sessionPath, preservedStartTime2);
+      const newState = strategy.parseState(sessionPath, preservedStartTime);
       if (newState) {
         state = newState;
-        renderProgress(state);
+        strategy.render(state);
       }
     }, 1e3);
     const watcher = watch(sessionPath, {
       persistent: true,
       ignoreInitial: true,
-      depth: 3
+      depth: 4
+      // map/runs/run-{n}/*.md
     });
     watcher.on("all", () => {
-      const newState = parseSessionState(sessionPath, preservedStartTime2);
+      const newState = strategy.parseState(sessionPath, preservedStartTime);
       if (newState) {
         state = newState;
-        renderProgress(state);
+        strategy.render(state);
       }
     });
     process.on("SIGINT", () => {
       clearInterval(timerInterval2);
       watcher.close();
-      logUpdate.done();
+      logUpdate4.done();
       process.exit(0);
     });
     return;
   }
   let currentSession = findLatestActiveSession(sessionsDir);
-  let currentSessionPath = currentSession ? join5(sessionsDir, currentSession) : null;
+  let currentSessionPath = currentSession ? join8(sessionsDir, currentSession) : null;
   let sessionWatcher = null;
-  let preservedStartTime;
+  const preservedStartTimes = {
+    review: void 0,
+    map: void 0
+  };
+  let currentStrategy = null;
   const updateDisplayImpl = () => {
-    if (!currentSessionPath || !existsSync5(currentSessionPath) || !isSessionActive(currentSessionPath)) {
+    if (!currentSessionPath || !existsSync8(currentSessionPath) || !isSessionActive(currentSessionPath)) {
       const latestActive = findLatestActiveSession(sessionsDir);
       if (latestActive && latestActive !== currentSession) {
         currentSession = latestActive;
-        currentSessionPath = join5(sessionsDir, latestActive);
-        preservedStartTime = void 0;
+        currentSessionPath = join8(sessionsDir, latestActive);
+        preservedStartTimes.review = void 0;
+        preservedStartTimes.map = void 0;
+        currentStrategy = null;
         watchSession(currentSessionPath);
       } else if (!latestActive) {
         currentSession = null;
         currentSessionPath = null;
-        preservedStartTime = void 0;
+        preservedStartTimes.review = void 0;
+        preservedStartTimes.map = void 0;
+        currentStrategy = null;
       }
     }
-    if (currentSessionPath && existsSync5(currentSessionPath)) {
-      const state = parseSessionState(currentSessionPath, preservedStartTime);
-      if (state) {
-        if (!preservedStartTime) {
-          preservedStartTime = state.startTime;
+    if (currentSessionPath && existsSync8(currentSessionPath)) {
+      if (!options.workflow) {
+        const activeWorkflows = detectActiveWorkflows(currentSessionPath);
+        if (activeWorkflows.length > 1) {
+          renderCombinedProgress(currentSessionPath, preservedStartTimes);
+          return;
+        }
+      }
+      if (!currentStrategy) {
+        currentStrategy = getStrategyForSession(
+          currentSessionPath,
+          options.workflow
+        );
+      }
+      if (currentStrategy) {
+        const workflowType = currentStrategy.workflowType;
+        const state = currentStrategy.parseState(
+          currentSessionPath,
+          preservedStartTimes[workflowType]
+        );
+        if (state) {
+          if (!preservedStartTimes[workflowType]) {
+            preservedStartTimes[workflowType] = state.startTime;
+          }
+          currentStrategy.render(state);
+        } else {
+          currentStrategy.renderWaiting();
         }
-        renderProgress(state);
       } else {
-        renderWaiting();
+        renderGenericWaiting();
       }
     } else {
-      preservedStartTime = void 0;
-      renderWaiting();
+      preservedStartTimes.review = void 0;
+      preservedStartTimes.map = void 0;
+      renderGenericWaiting();
     }
   };
   const updateDisplay = debounce(updateDisplayImpl, 50);
@@ -1056,7 +1504,7 @@ var progressCommand = new Command2("progress").description("Watch real-time prog
     sessionWatcher = watch(sessionPath, {
       persistent: true,
       ignoreInitial: true,
-      depth: 3
+      depth: 4
     });
     sessionWatcher.on("all", updateDisplay);
   };
@@ -1065,20 +1513,22 @@ var progressCommand = new Command2("progress").description("Watch real-time prog
     watchSession(currentSessionPath);
   }
   const timerInterval = setInterval(updateDisplay, 1e3);
-  const watchDir = existsSync5(ocrDir) ? ocrDir : targetDir;
+  const watchDir = existsSync8(ocrDir) ? ocrDir : targetDir;
   const dirWatcher = watch(watchDir, {
     persistent: true,
     ignoreInitial: true,
     depth: 3
   });
   dirWatcher.on("addDir", (dirPath) => {
-    const parentDir = join5(dirPath, "..");
-    const isDirectChild = parentDir.endsWith("sessions") || parentDir.endsWith(join5(".ocr", "sessions"));
+    const parentDir = join8(dirPath, "..");
+    const isDirectChild = parentDir.endsWith("sessions") || parentDir.endsWith(join8(".ocr", "sessions"));
     if (isDirectChild && !dirPath.endsWith("sessions")) {
-      const newSession = basename(dirPath);
+      const newSession = basename3(dirPath);
       currentSession = newSession;
       currentSessionPath = dirPath;
-      preservedStartTime = void 0;
+      preservedStartTimes.review = void 0;
+      preservedStartTimes.map = void 0;
+      currentStrategy = null;
       watchSession(dirPath);
       updateDisplay();
     }
@@ -1089,25 +1539,103 @@ var progressCommand = new Command2("progress").description("Watch real-time prog
     clearInterval(timerInterval);
     dirWatcher.close();
     if (sessionWatcher) sessionWatcher.close();
-    logUpdate.done();
+    logUpdate4.done();
     process.exit(0);
   });
 });
+function renderGenericWaiting() {
+  const lines = [];
+  lines.push("");
+  lines.push(chalk7.bold.white("  Open Code Review"));
+  lines.push("");
+  lines.push(chalk7.dim("  Waiting for session..."));
+  lines.push("");
+  lines.push(`  ${chalk7.dim("\u2500".repeat(24))}  ${chalk7.dim("0%")}`);
+  lines.push("");
+  lines.push(
+    chalk7.dim("  Run ") + chalk7.white("/ocr-review") + chalk7.dim(" or ") + chalk7.white("/ocr-map") + chalk7.dim(" to start")
+  );
+  lines.push("");
+  lines.push(chalk7.dim("  Ctrl+C to exit"));
+  lines.push("");
+  logUpdate4(lines.join("\n"));
+}
+function renderCombinedProgress(sessionPath, preservedStartTimes) {
+  const lines = [];
+  const session = basename3(sessionPath);
+  lines.push("");
+  lines.push(
+    chalk7.bold.white("  Open Code Review") + chalk7.yellow(" \xB7 Parallel Workflows")
+  );
+  lines.push("");
+  lines.push(chalk7.dim("  ") + chalk7.white(session));
+  lines.push("");
+  const reviewStrategy2 = getStrategy("review");
+  const mapStrategy2 = getStrategy("map");
+  if (reviewStrategy2) {
+    const reviewState = reviewStrategy2.parseState(
+      sessionPath,
+      preservedStartTimes.review
+    );
+    if (reviewState) {
+      const reviewPercent = Math.round(
+        reviewState.phaseNumber / reviewStrategy2.totalPhases * 100
+      );
+      const reviewBar = chalk7.blue("\u2501".repeat(Math.round(reviewPercent / 10))) + chalk7.dim("\u2500".repeat(10 - Math.round(reviewPercent / 10)));
+      const currentPhase = reviewStrategy2.phases.find(
+        (p) => p.key === reviewState.phase
+      );
+      lines.push(
+        chalk7.blue("  \u25C9 Review") + chalk7.dim("  ") + reviewBar + chalk7.dim("  ") + chalk7.white(`${reviewPercent}%`) + chalk7.dim(" \xB7 ") + chalk7.cyan(currentPhase?.label ?? reviewState.phase)
+      );
+    } else {
+      lines.push(chalk7.blue("  \u25C9 Review") + chalk7.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  0%"));
+    }
+  }
+  if (mapStrategy2) {
+    const mapState = mapStrategy2.parseState(
+      sessionPath,
+      preservedStartTimes.map
+    );
+    if (mapState) {
+      const mapPercent = Math.round(
+        mapState.phaseNumber / mapStrategy2.totalPhases * 100
+      );
+      const mapBar = chalk7.green("\u2501".repeat(Math.round(mapPercent / 10))) + chalk7.dim("\u2500".repeat(10 - Math.round(mapPercent / 10)));
+      const currentPhase = mapStrategy2.phases.find(
+        (p) => p.key === mapState.phase
+      );
+      lines.push(
+        chalk7.green("  \u25C9 Map") + chalk7.dim("     ") + mapBar + chalk7.dim("  ") + chalk7.white(`${mapPercent}%`) + chalk7.dim(" \xB7 ") + chalk7.cyan(currentPhase?.label ?? mapState.phase)
+      );
+    } else {
+      lines.push(chalk7.green("  \u25C9 Map") + chalk7.dim("     \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  0%"));
+    }
+  }
+  lines.push("");
+  lines.push(
+    chalk7.dim("  Use ") + chalk7.white("--workflow review") + chalk7.dim(" or ") + chalk7.white("--workflow map") + chalk7.dim(" for details")
+  );
+  lines.push("");
+  lines.push(chalk7.dim("  Ctrl+C to exit"));
+  lines.push("");
+  logUpdate4(lines.join("\n"));
+}
 
 // packages/cli/src/commands/update.ts
 import { Command as Command3 } from "commander";
-import chalk5 from "chalk";
+import chalk8 from "chalk";
 import ora2 from "ora";
-import { existsSync as existsSync6 } from "node:fs";
-import { join as join6 } from "node:path";
+import { existsSync as existsSync9 } from "node:fs";
+import { join as join9 } from "node:path";
 function detectConfiguredTools(targetDir) {
   return AI_TOOLS.filter((tool) => {
     if (tool.commandStrategy === "subdirectory") {
-      const ocrDir = join6(targetDir, tool.commandsDir, "ocr");
-      return existsSync6(ocrDir);
+      const ocrDir = join9(targetDir, tool.commandsDir, "ocr");
+      return existsSync9(ocrDir);
     } else {
-      const reviewCmd = join6(targetDir, tool.commandsDir, "ocr-review.md");
-      return existsSync6(reviewCmd);
+      const reviewCmd = join9(targetDir, tool.commandsDir, "ocr-review.md");
+      return existsSync9(reviewCmd);
     }
   });
 }
@@ -1118,7 +1646,7 @@ var updateCommand = new Command3("update").description("Update OCR assets after
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
   console.log();
-  console.log(chalk5.bold.cyan("  Open Code Review - Update"));
+  console.log(chalk8.bold.cyan("  Open Code Review - Update"));
   console.log();
   const savedToolIds = getConfiguredToolIds(targetDir);
   const configuredTools = detectConfiguredTools(targetDir);
@@ -1132,8 +1660,8 @@ var updateCommand = new Command3("update").description("Update OCR assets after
     );
   }
   if (toolsToUpdate.length === 0) {
-    console.log(chalk5.yellow("  No configured AI tools found."));
-    console.log(chalk5.dim("  Run `ocr init` to set up OCR first."));
+    console.log(chalk8.yellow("  No configured AI tools found."));
+    console.log(chalk8.dim("  Run `ocr init` to set up OCR first."));
     console.log();
     process.exit(1);
   }
@@ -1142,31 +1670,33 @@ var updateCommand = new Command3("update").description("Update OCR assets after
   const updateSkills = options.skills || !hasSpecificFlag;
   const updateInject = options.inject || !hasSpecificFlag;
   if (options.dryRun) {
-    console.log(chalk5.yellow("  Dry run mode - no files will be modified"));
+    console.log(chalk8.yellow("  Dry run mode - no files will be modified"));
     console.log();
   }
-  console.log(chalk5.dim("  Detected tools:"));
+  console.log(chalk8.dim("  Detected tools:"));
   for (const tool of toolsToUpdate) {
     console.log(`    \u2022 ${tool.name}`);
   }
   console.log();
   if (updateCommands || updateSkills) {
     if (options.dryRun) {
-      console.log(chalk5.dim("  Would update:"));
-      console.log(chalk5.dim("    \u2022 .ocr/skills/SKILL.md (main skill)"));
+      console.log(chalk8.dim("  Would update:"));
+      console.log(chalk8.dim("    \u2022 .ocr/skills/SKILL.md (main skill)"));
       console.log(
-        chalk5.dim("    \u2022 .ocr/skills/references/ (workflow, reviewers)")
+        chalk8.dim("    \u2022 .ocr/skills/references/ (except reviewers/)")
       );
-      console.log(chalk5.dim("    \u2022 .ocr/skills/assets/reviewer-template.md"));
+      console.log(chalk8.dim("    \u2022 .ocr/skills/assets/reviewer-template.md"));
+      console.log(chalk8.dim("  Preserved (not modified):"));
+      console.log(chalk8.dim("    \u2022 .ocr/config.yaml"));
       console.log(
-        chalk5.dim("    \u2022 .ocr/config.yaml (preserved if customized)")
+        chalk8.dim("    \u2022 .ocr/skills/references/reviewers/ (all reviewers)")
       );
       for (const tool of toolsToUpdate) {
         if (tool.commandStrategy === "subdirectory") {
-          console.log(chalk5.dim(`    \u2022 ${tool.commandsDir}/ocr/ (commands)`));
+          console.log(chalk8.dim(`    \u2022 ${tool.commandsDir}/ocr/ (commands)`));
         } else {
           console.log(
-            chalk5.dim(`    \u2022 ${tool.commandsDir}/ocr-*.md (commands)`)
+            chalk8.dim(`    \u2022 ${tool.commandsDir}/ocr-*.md (commands)`)
           );
         }
       }
@@ -1183,34 +1713,42 @@ var updateCommand = new Command3("update").description("Update OCR assets after
       const successful = results.filter((r) => r.success);
       const failed = results.filter((r) => !r.success);
       if (successful.length > 0) {
-        console.log(chalk5.green("  \u2713 Commands and skills updated"));
+        console.log(chalk8.green("  \u2713 Commands and skills updated"));
         console.log(
-          chalk5.dim("    Including: SKILL.md, references/, assets/")
+          chalk8.dim("    Including: SKILL.md, references/, assets/")
         );
         for (const result of successful) {
-          console.log(`    ${chalk5.green("\u2713")} ${result.tool.name}`);
+          console.log(`    ${chalk8.green("\u2713")} ${result.tool.name}`);
         }
       }
       if (failed.length > 0) {
         console.log();
-        console.log(chalk5.red("  \u2717 Some updates failed:"));
+        console.log(chalk8.red("  \u2717 Some updates failed:"));
         for (const result of failed) {
           console.log(
-            `    ${chalk5.red("\u2717")} ${result.tool.name}: ${result.error}`
+            `    ${chalk8.red("\u2717")} ${result.tool.name}: ${result.error}`
           );
         }
       }
+      const allWarnings = results.flatMap((r) => r.warnings ?? []);
+      if (allWarnings.length > 0) {
+        console.log();
+        console.log(chalk8.yellow("  \u26A0 Warnings:"));
+        for (const warning of allWarnings) {
+          console.log(`    ${chalk8.yellow("\u26A0")} ${warning}`);
+        }
+      }
       console.log();
     }
   }
   if (updateInject) {
     if (options.dryRun) {
-      console.log(chalk5.dim("  Would update:"));
-      if (existsSync6(join6(targetDir, "AGENTS.md"))) {
-        console.log(chalk5.dim("    \u2022 AGENTS.md (OCR managed block)"));
+      console.log(chalk8.dim("  Would update:"));
+      if (existsSync9(join9(targetDir, "AGENTS.md"))) {
+        console.log(chalk8.dim("    \u2022 AGENTS.md (OCR managed block)"));
       }
-      if (existsSync6(join6(targetDir, "CLAUDE.md"))) {
-        console.log(chalk5.dim("    \u2022 CLAUDE.md (OCR managed block)"));
+      if (existsSync9(join9(targetDir, "CLAUDE.md"))) {
+        console.log(chalk8.dim("    \u2022 CLAUDE.md (OCR managed block)"));
       }
       console.log();
     } else {
@@ -1218,23 +1756,23 @@ var updateCommand = new Command3("update").description("Update OCR assets after
       const injectResults = injectIntoProjectFiles(targetDir);
       spinner.stop();
       if (injectResults.agentsMd || injectResults.claudeMd) {
-        console.log(chalk5.green("  \u2713 Instructions updated"));
+        console.log(chalk8.green("  \u2713 Instructions updated"));
         if (injectResults.agentsMd) {
-          console.log(`    ${chalk5.green("\u2713")} AGENTS.md`);
+          console.log(`    ${chalk8.green("\u2713")} AGENTS.md`);
         }
         if (injectResults.claudeMd) {
-          console.log(`    ${chalk5.green("\u2713")} CLAUDE.md`);
+          console.log(`    ${chalk8.green("\u2713")} CLAUDE.md`);
         }
       } else {
-        console.log(chalk5.dim("  No instruction files to update"));
+        console.log(chalk8.dim("  No instruction files to update"));
       }
       console.log();
     }
   }
   if (options.dryRun) {
-    console.log(chalk5.dim("  Run without --dry-run to apply changes."));
+    console.log(chalk8.dim("  Run without --dry-run to apply changes."));
   } else {
-    console.log(chalk5.green("  \u2713 Update complete"));
+    console.log(chalk8.green("  \u2713 Update complete"));
   }
   console.log();
 });