@open-code-review/cli 1.5.0 → 1.6.0

package/dist/index.js

@@ -2157,7 +2157,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        *
        * @private
        */
-      _executeSubCommand(subcommand, args) {
+      _executeSubCommand(subcommand2, args) {
         args = args.slice();
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
@@ -2173,7 +2173,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         }
         this._checkForMissingMandatoryOptions();
         this._checkForConflictingOptions();
-        let executableFile = subcommand._executableFile || `${this._name}-${subcommand._name}`;
+        let executableFile = subcommand2._executableFile || `${this._name}-${subcommand2._name}`;
         let executableDir = this._executableDir || "";
         if (this._scriptPath) {
           let resolvedScriptPath;
@@ -2189,7 +2189,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
-          if (!localFile && !subcommand._executableFile && this._scriptPath) {
+          if (!localFile && !subcommand2._executableFile && this._scriptPath) {
             const legacyName = path2.basename(
               this._scriptPath,
               path2.extname(this._scriptPath)
@@ -2197,7 +2197,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             if (legacyName !== this._name) {
               localFile = findFile(
                 executableDir,
-                `${legacyName}-${subcommand._name}`
+                `${legacyName}-${subcommand2._name}`
               );
             }
           }
@@ -2217,7 +2217,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           this._checkForMissingExecutable(
             executableFile,
             executableDir,
-            subcommand._name
+            subcommand2._name
           );
           args.unshift(executableFile);
           args = incrementNodeInspectorPort(process13.execArgv).concat(args);
@@ -2253,7 +2253,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             this._checkForMissingExecutable(
               executableFile,
               executableDir,
-              subcommand._name
+              subcommand2._name
             );
           } else if (err.code === "EACCES") {
             throw new Error(`'${executableFile}' not executable`);
@@ -16283,6 +16283,30 @@ var init_migrations = __esm({
       ALTER TABLE orchestration_events_new RENAME TO orchestration_events;
       CREATE INDEX idx_events_session ON orchestration_events(session_id);
       CREATE INDEX idx_events_type ON orchestration_events(event_type);
+    `
+      },
+      {
+        version: 6,
+        description: "Add orchestrator-first columns to review_rounds for round-meta.json support",
+        sql: `
+      ALTER TABLE review_rounds ADD COLUMN source TEXT DEFAULT NULL;
+      ALTER TABLE review_rounds ADD COLUMN reviewer_count INTEGER DEFAULT 0;
+      ALTER TABLE review_rounds ADD COLUMN total_finding_count INTEGER DEFAULT 0;
+    `
+      },
+      {
+        version: 7,
+        description: "Add category column to review_findings for blocker/should_fix/suggestion classification",
+        sql: `
+      ALTER TABLE review_findings ADD COLUMN category TEXT DEFAULT NULL;
+    `
+      },
+      {
+        version: 8,
+        description: "Add orchestrator-first columns to map_runs for map-meta.json support",
+        sql: `
+      ALTER TABLE map_runs ADD COLUMN source TEXT DEFAULT NULL;
+      ALTER TABLE map_runs ADD COLUMN section_count INTEGER DEFAULT 0;
     `
       }
     ];
@@ -16428,14 +16452,14 @@ __export(db_exports, {
   saveDatabase: () => saveDatabase,
   updateSession: () => updateSession
 });
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync7, renameSync, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname4, join as join10 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync8, renameSync, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname4, join as join11 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 import initSqlJs from "sql.js";
 function locateWasm() {
   const require3 = createRequire2(import.meta.url);
   const sqlJsPath = require3.resolve("sql.js");
-  return join10(dirname4(sqlJsPath), "sql-wasm.wasm");
+  return join11(dirname4(sqlJsPath), "sql-wasm.wasm");
 }
 function applyPragmas(db) {
   db.run("PRAGMA foreign_keys = ON;");
@@ -16447,7 +16471,7 @@ async function openDatabase(dbPath) {
   if (cached) {
     return cached;
   }
-  const wasmBuffer = readFileSync7(locateWasm());
+  const wasmBuffer = readFileSync8(locateWasm());
   const wasmBinary = wasmBuffer.buffer.slice(
     wasmBuffer.byteOffset,
     wasmBuffer.byteOffset + wasmBuffer.byteLength
@@ -16456,8 +16480,8 @@ async function openDatabase(dbPath) {
     wasmBinary
   });
   let db;
-  if (existsSync8(dbPath)) {
-    const fileBuffer = readFileSync7(dbPath);
+  if (existsSync9(dbPath)) {
+    const fileBuffer = readFileSync8(dbPath);
     db = new SQL.Database(fileBuffer);
   } else {
     db = new SQL.Database();
@@ -16469,23 +16493,23 @@ async function openDatabase(dbPath) {
 function saveDatabase(db, dbPath) {
   const data = db.export();
   const dir = dirname4(dbPath);
-  if (!existsSync8(dir)) {
+  if (!existsSync9(dir)) {
     mkdirSync3(dir, { recursive: true });
   }
   const tmpPath = dbPath + ".tmp";
-  writeFileSync5(tmpPath, Buffer.from(data));
+  writeFileSync6(tmpPath, Buffer.from(data));
   renameSync(tmpPath, dbPath);
 }
 async function getDb(ocrDir) {
-  const dbPath = join10(ocrDir, "data", "ocr.db");
+  const dbPath = join11(ocrDir, "data", "ocr.db");
   return openDatabase(dbPath);
 }
 async function ensureDatabase(ocrDir) {
-  const dataDir = join10(ocrDir, "data");
-  if (!existsSync8(dataDir)) {
+  const dataDir = join11(ocrDir, "data");
+  if (!existsSync9(dataDir)) {
     mkdirSync3(dataDir, { recursive: true });
   }
-  const dbPath = join10(dataDir, "ocr.db");
+  const dbPath = join11(dataDir, "ocr.db");
   const db = await openDatabase(dbPath);
   runMigrations(db);
   saveDatabase(db, dbPath);
@@ -20170,19 +20194,68 @@ function parseToolsArg(toolsArg) {
 
 // src/lib/installer.ts
 import {
-  existsSync,
+  existsSync as existsSync2,
   mkdirSync,
   cpSync,
-  writeFileSync as writeFileSync2,
+  writeFileSync as writeFileSync3,
   readdirSync,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   unlinkSync as unlinkSync2
 } from "node:fs";
-import { join, dirname } from "node:path";
+import { join as join2, dirname } from "node:path";
 import { createRequire } from "node:module";
+
+// src/lib/gitignore.ts
+import { existsSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join } from "node:path";
+var START_MARKER = "# OCR:START \u2014 managed by open-code-review (do not edit this block)";
+var END_MARKER = "# OCR:END";
+var MANAGED_ENTRIES = ["sessions/", "data/", "*.db-shm", "*.db-wal"];
+var LEGACY_LINES = /* @__PURE__ */ new Set([
+  "# OCR session files",
+  "sessions/",
+  "data",
+  "data/"
+]);
+function buildManagedBlock() {
+  return [START_MARKER, ...MANAGED_ENTRIES, END_MARKER].join("\n");
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function stripLegacyLines(content) {
+  return content.split("\n").filter((line) => !LEGACY_LINES.has(line.trim())).join("\n");
+}
+function ensureGitignore(ocrDir) {
+  const gitignorePath = join(ocrDir, ".gitignore");
+  const block = buildManagedBlock();
+  let content = existsSync(gitignorePath) ? readFileSync2(gitignorePath, "utf-8") : "";
+  const blockRegex = new RegExp(
+    `${escapeRegex(START_MARKER)}[\\s\\S]*?${escapeRegex(END_MARKER)}\\n?`,
+    "g"
+  );
+  if (blockRegex.test(content)) {
+    content = content.replace(
+      new RegExp(
+        `${escapeRegex(START_MARKER)}[\\s\\S]*?${escapeRegex(END_MARKER)}\\n?`,
+        "g"
+      ),
+      block + "\n"
+    );
+  } else {
+    content = stripLegacyLines(content).trimEnd();
+    if (content.length > 0) {
+      content += "\n\n";
+    }
+    content += block + "\n";
+  }
+  writeFileSync2(gitignorePath, content);
+}
+
+// src/lib/installer.ts
 var require2 = createRequire(import.meta.url);
 function ensureDir(dir) {
-  if (!existsSync(dir)) {
+  if (!existsSync2(dir)) {
     mkdirSync(dir, { recursive: true });
   }
 }
@@ -20191,8 +20264,8 @@ function getAgentsPackagePath() {
     const agentsPath = require2.resolve("@open-code-review/agents/package.json");
     return dirname(agentsPath);
   } catch {
-    const localPath = join(process.cwd(), "packages", "agents");
-    if (existsSync(localPath)) {
+    const localPath = join2(process.cwd(), "packages", "agents");
+    if (existsSync2(localPath)) {
       return localPath;
     }
     throw new Error(
@@ -20212,8 +20285,8 @@ function copyDirSafe(src, dest) {
 function copyFileSafe(src, dest) {
   try {
     ensureDir(dirname(dest));
-    const content = readFileSync2(src);
-    writeFileSync2(dest, content);
+    const content = readFileSync3(src);
+    writeFileSync3(dest, content);
     return true;
   } catch {
     return false;
@@ -20237,8 +20310,8 @@ function extractDescription(content) {
   return match?.[1]?.trim() ?? "OCR command";
 }
 function installCommandsForTool(tool, commandsSource, targetDir) {
-  const toolCommandsDir = join(targetDir, tool.commandsDir);
-  const centralCommandsDir = join(targetDir, ".ocr", "commands");
+  const toolCommandsDir = join2(targetDir, tool.commandsDir);
+  const centralCommandsDir = join2(targetDir, ".ocr", "commands");
   ensureDir(toolCommandsDir);
   ensureDir(centralCommandsDir);
   try {
@@ -20246,32 +20319,32 @@ function installCommandsForTool(tool, commandsSource, targetDir) {
       (f) => f.endsWith(".md")
     );
     for (const file of commandFiles) {
-      const srcPath = join(commandsSource, file);
+      const srcPath = join2(commandsSource, file);
       const normalizedName = file.replace(/^ocr-/, "");
-      const centralPath = join(centralCommandsDir, normalizedName);
+      const centralPath = join2(centralCommandsDir, normalizedName);
       if (!copyFileSafe(srcPath, centralPath)) {
         return false;
       }
     }
     if (tool.commandStrategy === "subdirectory") {
-      const ocrSubdir = join(toolCommandsDir, "ocr");
+      const ocrSubdir = join2(toolCommandsDir, "ocr");
       ensureDir(ocrSubdir);
       for (const file of commandFiles) {
-        const srcPath = join(commandsSource, file);
-        const content = readFileSync2(srcPath, "utf-8");
+        const srcPath = join2(commandsSource, file);
+        const content = readFileSync3(srcPath, "utf-8");
         const description = extractDescription(content);
         const normalizedName = file.replace(/^ocr-/, "");
         const refContent = generateCommandReference(
           normalizedName,
           description
         );
-        const destPath = join(ocrSubdir, normalizedName);
-        writeFileSync2(destPath, refContent);
+        const destPath = join2(ocrSubdir, normalizedName);
+        writeFileSync3(destPath, refContent);
       }
     } else {
       for (const file of commandFiles) {
-        const srcPath = join(commandsSource, file);
-        const content = readFileSync2(srcPath, "utf-8");
+        const srcPath = join2(commandsSource, file);
+        const content = readFileSync3(srcPath, "utf-8");
         const description = extractDescription(content);
         const normalizedName = file.replace(/^ocr-/, "");
         const destName = `ocr-${normalizedName}`;
@@ -20279,8 +20352,8 @@ function installCommandsForTool(tool, commandsSource, targetDir) {
           normalizedName,
           description
         );
-        const destPath = join(toolCommandsDir, destName);
-        writeFileSync2(destPath, refContent);
+        const destPath = join2(toolCommandsDir, destName);
+        writeFileSync3(destPath, refContent);
       }
     }
     return true;
@@ -20290,39 +20363,33 @@ function installCommandsForTool(tool, commandsSource, targetDir) {
 }
 function installForTool(tool, targetDir) {
   const agentsPath = getAgentsPackagePath();
-  const ocrSkillsSource = join(agentsPath, "skills", "ocr");
-  const commandsSource = join(agentsPath, "commands");
-  const ocrDir = join(targetDir, ".ocr");
-  const ocrSkillsDest = join(ocrDir, "skills");
+  const ocrSkillsSource = join2(agentsPath, "skills", "ocr");
+  const commandsSource = join2(agentsPath, "commands");
+  const ocrDir = join2(targetDir, ".ocr");
+  const ocrSkillsDest = join2(ocrDir, "skills");
   ensureDir(ocrDir);
-  ensureDir(join(ocrDir, "sessions"));
-  const gitignoreContent = `# OCR session files
-sessions/
-`;
-  const gitignorePath = join(ocrDir, ".gitignore");
-  if (!existsSync(gitignorePath)) {
-    writeFileSync2(gitignorePath, gitignoreContent);
-  }
-  const configPath = join(ocrDir, "config.yaml");
+  ensureDir(join2(ocrDir, "sessions"));
+  ensureGitignore(ocrDir);
+  const configPath = join2(ocrDir, "config.yaml");
   let existingConfig = null;
-  if (existsSync(configPath)) {
+  if (existsSync2(configPath)) {
     try {
-      existingConfig = readFileSync2(configPath);
+      existingConfig = readFileSync3(configPath);
     } catch {
     }
   }
-  const reviewersDir = join(ocrSkillsDest, "references", "reviewers");
+  const reviewersDir = join2(ocrSkillsDest, "references", "reviewers");
   const existingReviewers = /* @__PURE__ */ new Map();
   const warnings = [];
-  if (existsSync(reviewersDir)) {
+  if (existsSync2(reviewersDir)) {
     try {
       const reviewerFiles = readdirSync(reviewersDir).filter(
         (f) => f.endsWith(".md")
       );
       for (const file of reviewerFiles) {
-        const filePath = join(reviewersDir, file);
+        const filePath = join2(reviewersDir, file);
         try {
-          existingReviewers.set(file, readFileSync2(filePath));
+          existingReviewers.set(file, readFileSync3(filePath));
         } catch (err) {
           const msg = err instanceof Error ? err.message : "unknown error";
           warnings.push(`Could not read reviewer ${file}: ${msg}`);
@@ -20341,17 +20408,17 @@ sessions/
       error: "Failed to install OCR skills to .ocr/"
     };
   }
-  const configSource = join(ocrSkillsSource, "assets", "config.yaml");
+  const configSource = join2(ocrSkillsSource, "assets", "config.yaml");
   if (existingConfig) {
     try {
-      writeFileSync2(configPath, existingConfig);
+      writeFileSync3(configPath, existingConfig);
     } catch {
     }
-  } else if (existsSync(configSource)) {
+  } else if (existsSync2(configSource)) {
     copyFileSafe(configSource, configPath);
   }
-  const duplicateConfig = join(ocrSkillsDest, "assets", "config.yaml");
-  if (existsSync(duplicateConfig)) {
+  const duplicateConfig = join2(ocrSkillsDest, "assets", "config.yaml");
+  if (existsSync2(duplicateConfig)) {
     try {
       unlinkSync2(duplicateConfig);
     } catch {
@@ -20361,7 +20428,7 @@ sessions/
     ensureDir(reviewersDir);
     for (const [file, content] of existingReviewers) {
       try {
-        writeFileSync2(join(reviewersDir, file), content);
+        writeFileSync3(join2(reviewersDir, file), content);
       } catch (err) {
         const msg = err instanceof Error ? err.message : "unknown error";
         warnings.push(`Could not restore reviewer ${file}: ${msg}`);
@@ -20384,27 +20451,27 @@ sessions/
 }
 function detectInstalledTools(targetDir, tools) {
   return tools.filter((tool) => {
-    const configPath = join(targetDir, tool.configDir);
+    const configPath = join2(targetDir, tool.configDir);
     if (tool.id === "github-copilot") {
-      const copilotInstructions = join(
+      const copilotInstructions = join2(
         targetDir,
         ".github",
         "copilot-instructions.md"
       );
-      const copilotDir = join(targetDir, ".github", "copilot");
-      const copilotCommands = join(targetDir, ".github", "commands");
-      return existsSync(copilotInstructions) || existsSync(copilotDir) || existsSync(copilotCommands);
+      const copilotDir = join2(targetDir, ".github", "copilot");
+      const copilotCommands = join2(targetDir, ".github", "commands");
+      return existsSync2(copilotInstructions) || existsSync2(copilotDir) || existsSync2(copilotCommands);
     }
-    return existsSync(configPath);
+    return existsSync2(configPath);
   });
 }
 
 // src/lib/injector.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join2 } from "node:path";
-var START_MARKER = "<!-- OCR:START -->";
-var END_MARKER = "<!-- OCR:END -->";
-var OCR_INSTRUCTION_BLOCK = `${START_MARKER}
+import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join3 } from "node:path";
+var START_MARKER2 = "<!-- OCR:START -->";
+var END_MARKER2 = "<!-- OCR:END -->";
+var OCR_INSTRUCTION_BLOCK = `${START_MARKER2}
 # Open Code Review Instructions
 
 These instructions are for AI assistants handling code review in this project.
@@ -20423,12 +20490,12 @@ Use \`.ocr/skills/SKILL.md\` to learn:
 
 Keep this managed block so 'ocr init' can refresh the instructions.
 
-${END_MARKER}`;
+${END_MARKER2}`;
 function injectOcrInstructions(filePath) {
   try {
-    let content = existsSync2(filePath) ? readFileSync3(filePath, "utf-8") : "";
+    let content = existsSync3(filePath) ? readFileSync4(filePath, "utf-8") : "";
     const regex2 = new RegExp(
-      `${escapeRegex(START_MARKER)}[\\s\\S]*?${escapeRegex(END_MARKER)}\\n?`,
+      `${escapeRegex2(START_MARKER2)}[\\s\\S]*?${escapeRegex2(END_MARKER2)}\\n?`,
       "g"
     );
     content = content.replace(regex2, "");
@@ -20437,18 +20504,18 @@ function injectOcrInstructions(filePath) {
       content += "\n\n";
     }
     content += OCR_INSTRUCTION_BLOCK + "\n";
-    writeFileSync3(filePath, content);
+    writeFileSync4(filePath, content);
     return true;
   } catch {
     return false;
   }
 }
-function escapeRegex(str) {
+function escapeRegex2(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function injectIntoProjectFiles(targetDir) {
-  const agentsMdPath = join2(targetDir, "AGENTS.md");
-  const claudeMdPath = join2(targetDir, "CLAUDE.md");
+  const agentsMdPath = join3(targetDir, "AGENTS.md");
+  const claudeMdPath = join3(targetDir, "CLAUDE.md");
   const agentsMd = injectOcrInstructions(agentsMdPath);
   const claudeMd = injectOcrInstructions(claudeMdPath);
   return { agentsMd, claudeMd };
@@ -20491,19 +20558,19 @@ function printHeader() {
 }
 
 // src/lib/cli-config.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join4 } from "node:path";
 var CLI_CONFIG_FILE = "cli-config.json";
 function getCliConfigPath(targetDir) {
-  return join3(targetDir, ".ocr", CLI_CONFIG_FILE);
+  return join4(targetDir, ".ocr", CLI_CONFIG_FILE);
 }
 function loadCliConfig(targetDir) {
   const configPath = getCliConfigPath(targetDir);
-  if (!existsSync3(configPath)) {
+  if (!existsSync4(configPath)) {
     return null;
   }
   try {
-    const content = readFileSync4(configPath, "utf-8");
+    const content = readFileSync5(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -20516,7 +20583,7 @@ function saveCliConfig(targetDir, config) {
       ...config,
       lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
     };
-    writeFileSync4(configPath, JSON.stringify(configWithMeta, null, 2) + "\n");
+    writeFileSync5(configPath, JSON.stringify(configWithMeta, null, 2) + "\n");
     return true;
   } catch {
     return false;
@@ -22533,8 +22600,8 @@ function watch(paths, options = {}) {
 }
 
 // src/commands/progress.ts
-import { existsSync as existsSync9, readdirSync as readdirSync5, statSync } from "node:fs";
-import { join as join11, basename as basename7 } from "node:path";
+import { existsSync as existsSync10, readdirSync as readdirSync5, statSync } from "node:fs";
+import { join as join12, basename as basename7 } from "node:path";
 
 // ../../node_modules/.pnpm/log-update@7.0.2/node_modules/log-update/index.js
 import process12 from "node:process";
@@ -23402,15 +23469,15 @@ var log_update_default = logUpdate;
 var logUpdateStderr = createLogUpdate(process12.stderr);
 
 // src/lib/guards.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2 } from "node:fs";
-import { join as join6 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join7 } from "node:path";
 function checkOcrSetup(targetDir) {
-  const ocrDir = join6(targetDir, ".ocr");
-  const skillsDir = join6(ocrDir, "skills");
-  const sessionsDir = join6(ocrDir, "sessions");
-  const hasOcrDir = existsSync4(ocrDir);
-  const hasSkills = existsSync4(skillsDir);
-  const hasSessions = existsSync4(sessionsDir);
+  const ocrDir = join7(targetDir, ".ocr");
+  const skillsDir = join7(ocrDir, "skills");
+  const sessionsDir = join7(ocrDir, "sessions");
+  const hasOcrDir = existsSync5(ocrDir);
+  const hasSkills = existsSync5(skillsDir);
+  const hasSessions = existsSync5(sessionsDir);
   return {
     valid: hasOcrDir && hasSkills,
     ocrDir,
@@ -23426,7 +23493,7 @@ function requireOcrSetup(targetDir) {
     console.error();
     console.error(source_default.red.bold("  \u2717 OCR is not set up in this directory"));
     console.error();
-    if (!existsSync4(status.ocrDir)) {
+    if (!existsSync5(status.ocrDir)) {
       console.error(source_default.dim("  The .ocr directory was not found."));
     } else if (!status.hasSkills) {
       console.error(source_default.dim("  The .ocr/skills directory is missing."));
@@ -23446,8 +23513,8 @@ function requireOcrSetup(targetDir) {
   return status;
 }
 function ensureSessionsDir(targetDir) {
-  const sessionsDir = join6(targetDir, ".ocr", "sessions");
-  if (!existsSync4(sessionsDir)) {
+  const sessionsDir = join7(targetDir, ".ocr", "sessions");
+  if (!existsSync5(sessionsDir)) {
     mkdirSync2(sessionsDir, { recursive: true });
   }
   return sessionsDir;
@@ -23463,8 +23530,8 @@ function getStrategy(workflowType) {
 }
 
 // src/lib/progress/detector.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2 } from "node:fs";
-import { join as join7, basename as basename4 } from "node:path";
+import { existsSync as existsSync6, readdirSync as readdirSync2 } from "node:fs";
+import { join as join8, basename as basename4 } from "node:path";
 
 // src/lib/progress/session-reader.ts
 init_result_mapper();
@@ -23535,8 +23602,8 @@ function detectWorkflowType(sessionPath, explicitType) {
     } catch {
     }
   }
-  const hasMapDir = existsSync5(join7(sessionPath, "map"));
-  const hasRoundsDir = existsSync5(join7(sessionPath, "rounds"));
+  const hasMapDir = existsSync6(join8(sessionPath, "map"));
+  const hasRoundsDir = existsSync6(join8(sessionPath, "rounds"));
   if (hasMapDir && !hasRoundsDir) {
     return "map";
   }
@@ -23592,28 +23659,28 @@ function isSessionActive(sessionPath) {
 }
 function detectActiveWorkflows(sessionPath) {
   const activeWorkflows = [];
-  const hasRoundsDir = existsSync5(join7(sessionPath, "rounds"));
+  const hasRoundsDir = existsSync6(join8(sessionPath, "rounds"));
   if (hasRoundsDir) {
-    const roundsDir = join7(sessionPath, "rounds");
-    const rounds = existsSync5(roundsDir) ? readdirSync2(roundsDir).filter((d) => d.match(/^round-\d+$/)).sort() : [];
+    const roundsDir = join8(sessionPath, "rounds");
+    const rounds = existsSync6(roundsDir) ? readdirSync2(roundsDir).filter((d) => d.match(/^round-\d+$/)).sort() : [];
     if (rounds.length > 0) {
       const latestRound = rounds[rounds.length - 1];
-      const finalPath = join7(roundsDir, latestRound, "final.md");
-      if (!existsSync5(finalPath)) {
+      const finalPath = join8(roundsDir, latestRound, "final.md");
+      if (!existsSync6(finalPath)) {
         activeWorkflows.push("review");
       }
     } else {
       activeWorkflows.push("review");
     }
   }
-  const hasMapDir = existsSync5(join7(sessionPath, "map"));
+  const hasMapDir = existsSync6(join8(sessionPath, "map"));
   if (hasMapDir) {
-    const runsDir = join7(sessionPath, "map", "runs");
-    const runs = existsSync5(runsDir) ? readdirSync2(runsDir).filter((d) => d.match(/^run-\d+$/)).sort() : [];
+    const runsDir = join8(sessionPath, "map", "runs");
+    const runs = existsSync6(runsDir) ? readdirSync2(runsDir).filter((d) => d.match(/^run-\d+$/)).sort() : [];
     if (runs.length > 0) {
       const latestRun = runs[runs.length - 1];
-      const mapPath = join7(runsDir, latestRun, "map.md");
-      if (!existsSync5(mapPath)) {
+      const mapPath = join8(runsDir, latestRun, "map.md");
+      if (!existsSync6(mapPath)) {
         activeWorkflows.push("map");
       }
     } else {
@@ -23692,8 +23759,8 @@ function padLines(lines) {
 }
 
 // src/lib/progress/review-strategy.ts
-import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync5 } from "node:fs";
-import { join as join8, basename as basename5 } from "node:path";
+import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "node:fs";
+import { join as join9, basename as basename5 } from "node:path";
 var REVIEW_PHASES = [
   { key: "context", label: "Context Discovery" },
   { key: "change-context", label: "Change Context" },
@@ -23705,10 +23772,10 @@ var REVIEW_PHASES = [
   { key: "complete", label: "Complete" }
 ];
 function countFindings(filePath) {
-  if (!existsSync6(filePath)) {
+  if (!existsSync7(filePath)) {
     return 0;
   }
-  const content = readFileSync5(filePath, "utf-8");
+  const content = readFileSync6(filePath, "utf-8");
   const findingMatches = content.match(/^##\s+(Finding|Issue|Suggestion)/gm);
   return findingMatches?.length ?? 0;
 }
@@ -23722,7 +23789,7 @@ function formatReviewerName(filename) {
   return base.charAt(0).toUpperCase() + base.slice(1);
 }
 function deriveRoundsFromFilesystem(roundsDir) {
-  if (!existsSync6(roundsDir)) {
+  if (!existsSync7(roundsDir)) {
     return [];
   }
   const roundDirs = readdirSync3(roundsDir).filter((d) => d.match(/^round-\d+$/)).sort((a, b) => {
@@ -23732,17 +23799,17 @@ function deriveRoundsFromFilesystem(roundsDir) {
   });
   return roundDirs.map((dir) => {
     const roundNum = parseInt(dir.replace("round-", ""));
-    const roundPath = join8(roundsDir, dir);
-    const reviewsPath = join8(roundPath, "reviews");
-    const finalPath = join8(roundPath, "final.md");
+    const roundPath = join9(roundsDir, dir);
+    const reviewsPath = join9(roundPath, "reviews");
+    const finalPath = join9(roundPath, "final.md");
     const reviewers = [];
-    if (existsSync6(reviewsPath)) {
+    if (existsSync7(reviewsPath)) {
       const files = readdirSync3(reviewsPath).filter((f) => f.endsWith(".md"));
       reviewers.push(...files.map((f) => f.replace(".md", "")));
     }
     return {
       round: roundNum,
-      isComplete: existsSync6(finalPath),
+      isComplete: existsSync7(finalPath),
       reviewers
     };
   });
@@ -23771,19 +23838,19 @@ var ReviewProgressStrategy = class {
   parseFromState(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 = join8(sessionPath, "rounds");
+    const roundsDir = join9(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 = join8(roundsDir, `round-${currentRound}`);
-    const reviewsDir = join8(currentRoundDir, "reviews");
+    const currentRoundDir = join9(roundsDir, `round-${currentRound}`);
+    const reviewsDir = join9(currentRoundDir, "reviews");
     const reviewers = [];
-    if (existsSync6(reviewsDir)) {
+    if (existsSync7(reviewsDir)) {
       const entries = readdirSync3(reviewsDir);
       const reviewFiles = entries.filter((f) => f.endsWith(".md"));
       for (const file of reviewFiles) {
-        const reviewPath = join8(reviewsDir, file);
+        const reviewPath = join9(reviewsDir, file);
         const findings = countFindings(reviewPath);
         reviewers.push({
           name: file.replace(".md", ""),
@@ -23793,14 +23860,14 @@ var ReviewProgressStrategy = class {
         });
       }
     }
-    const contextComplete = existsSync6(
-      join8(sessionPath, "discovered-standards.md")
+    const contextComplete = existsSync7(
+      join9(sessionPath, "discovered-standards.md")
     );
-    const changeContextComplete = existsSync6(join8(sessionPath, "context.md"));
+    const changeContextComplete = existsSync7(join9(sessionPath, "context.md"));
     const analysisComplete = changeContextComplete;
     const reviewsComplete = state.phase_number > 4;
-    const discourseComplete = existsSync6(join8(currentRoundDir, "discourse.md"));
-    const synthesisComplete = existsSync6(join8(currentRoundDir, "final.md"));
+    const discourseComplete = existsSync7(join9(currentRoundDir, "discourse.md"));
+    const synthesisComplete = existsSync7(join9(currentRoundDir, "final.md"));
     return {
       workflowType: "review",
       session,
@@ -23932,8 +23999,8 @@ var ReviewProgressStrategy = class {
 var reviewStrategy = new ReviewProgressStrategy();
 
 // src/lib/progress/map-strategy.ts
-import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync6 } from "node:fs";
-import { join as join9, basename as basename6 } from "node:path";
+import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync7 } from "node:fs";
+import { join as join10, basename as basename6 } from "node:path";
 var MAP_PHASES = [
   { key: "map-context", label: "Context Discovery" },
   { key: "topology", label: "Topology Analysis" },
@@ -23943,8 +24010,8 @@ var MAP_PHASES = [
   { key: "complete", label: "Complete" }
 ];
 function deriveRunsFromFilesystem(mapDir) {
-  const runsDir = join9(mapDir, "runs");
-  if (!existsSync7(runsDir)) {
+  const runsDir = join10(mapDir, "runs");
+  if (!existsSync8(runsDir)) {
     return [];
   }
   const runDirs = readdirSync4(runsDir).filter((d) => d.match(/^run-\d+$/)).sort((a, b) => {
@@ -23954,12 +24021,12 @@ function deriveRunsFromFilesystem(mapDir) {
   });
   return runDirs.map((dir) => {
     const runNum = parseInt(dir.replace("run-", ""));
-    const runPath = join9(runsDir, dir);
-    const mapPath = join9(runPath, "map.md");
+    const runPath = join10(runsDir, dir);
+    const mapPath = join10(runPath, "map.md");
     let fileCount = 0;
-    const topologyPath = join9(runPath, "topology.md");
-    if (existsSync7(topologyPath)) {
-      const content = readFileSync6(topologyPath, "utf-8");
+    const topologyPath = join10(runPath, "topology.md");
+    if (existsSync8(topologyPath)) {
+      const content = readFileSync7(topologyPath, "utf-8");
       const fileListMatch = content.match(
         /## Canonical File List[\s\S]*?```([\s\S]*?)```/
       );
@@ -23969,7 +24036,7 @@ function deriveRunsFromFilesystem(mapDir) {
     }
     return {
       run: runNum,
-      isComplete: existsSync7(mapPath),
+      isComplete: existsSync8(mapPath),
       fileCount
     };
   });
@@ -24001,24 +24068,24 @@ var MapProgressStrategy = class {
   parseFromState(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 = join9(sessionPath, "map");
+    const mapDir = join10(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 = join9(mapDir, "runs", `run-${currentRun}`);
-    const contextComplete = existsSync7(
-      join9(sessionPath, "discovered-standards.md")
+    const currentRunDir = join10(mapDir, "runs", `run-${currentRun}`);
+    const contextComplete = existsSync8(
+      join10(sessionPath, "discovered-standards.md")
     );
-    const topologyComplete = existsSync7(join9(currentRunDir, "topology.md"));
-    const flowAnalysisComplete = existsSync7(
-      join9(currentRunDir, "flow-analysis.md")
+    const topologyComplete = existsSync8(join10(currentRunDir, "topology.md"));
+    const flowAnalysisComplete = existsSync8(
+      join10(currentRunDir, "flow-analysis.md")
     );
-    const requirementsMappingComplete = existsSync7(
-      join9(currentRunDir, "requirements-mapping.md")
+    const requirementsMappingComplete = existsSync8(
+      join10(currentRunDir, "requirements-mapping.md")
     );
-    const synthesisComplete = existsSync7(join9(currentRunDir, "map.md"));
-    const hasRequirements = existsSync7(join9(sessionPath, "requirements.md"));
+    const synthesisComplete = existsSync8(join10(currentRunDir, "map.md"));
+    const hasRequirements = existsSync8(join10(sessionPath, "requirements.md"));
     const flowAnalysts = flowAnalysisComplete ? [
       {
         name: "flow-analyst",
@@ -24170,15 +24237,15 @@ function debounce(fn, delay) {
   };
 }
 function findLatestActiveSession(sessionsDir) {
-  if (!existsSync9(sessionsDir)) {
+  if (!existsSync10(sessionsDir)) {
     return null;
   }
   const sessions = readdirSync5(sessionsDir).filter((name) => {
-    const sessionPath = join11(sessionsDir, name);
+    const sessionPath = join12(sessionsDir, name);
     return statSync(sessionPath).isDirectory();
   }).sort().reverse();
   for (const session of sessions) {
-    const sessionPath = join11(sessionsDir, session);
+    const sessionPath = join12(sessionsDir, session);
     if (isSessionActive(sessionPath)) {
       return session;
     }
@@ -24193,8 +24260,8 @@ function getStrategyForSession(sessionPath, explicitWorkflow) {
   return getStrategy(workflowType) ?? null;
 }
 async function initProgressDb(ocrDir) {
-  const dbPath = join11(ocrDir, "data", "ocr.db");
-  if (!existsSync9(dbPath)) {
+  const dbPath = join12(ocrDir, "data", "ocr.db");
+  if (!existsSync10(dbPath)) {
     return;
   }
   try {
@@ -24219,11 +24286,11 @@ var progressCommand = new Command("progress").description("Watch real-time progr
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
   const sessionsDir = ensureSessionsDir(targetDir);
-  const ocrDir = join11(targetDir, ".ocr");
+  const ocrDir = join12(targetDir, ".ocr");
   await initProgressDb(ocrDir);
   if (options.session) {
-    const sessionPath = join11(sessionsDir, options.session);
-    if (!existsSync9(sessionPath)) {
+    const sessionPath = join12(sessionsDir, options.session);
+    if (!existsSync10(sessionPath)) {
       console.error(source_default.red(`Session not found: ${options.session}`));
       process.exit(1);
     }
@@ -24284,7 +24351,7 @@ var progressCommand = new Command("progress").description("Watch real-time progr
     return;
   }
   let currentSession = findLatestActiveSession(sessionsDir);
-  let currentSessionPath = currentSession ? join11(sessionsDir, currentSession) : null;
+  let currentSessionPath = currentSession ? join12(sessionsDir, currentSession) : null;
   let sessionWatcher = null;
   const preservedStartTimes = {
     review: void 0,
@@ -24292,11 +24359,11 @@ var progressCommand = new Command("progress").description("Watch real-time progr
   };
   let currentStrategy = null;
   const updateDisplayImpl = () => {
-    if (!currentSessionPath || !existsSync9(currentSessionPath) || !isSessionActive(currentSessionPath)) {
+    if (!currentSessionPath || !existsSync10(currentSessionPath) || !isSessionActive(currentSessionPath)) {
       const latestActive = findLatestActiveSession(sessionsDir);
       if (latestActive && latestActive !== currentSession) {
         currentSession = latestActive;
-        currentSessionPath = join11(sessionsDir, latestActive);
+        currentSessionPath = join12(sessionsDir, latestActive);
         preservedStartTimes.review = void 0;
         preservedStartTimes.map = void 0;
         currentStrategy = null;
@@ -24309,7 +24376,7 @@ var progressCommand = new Command("progress").description("Watch real-time progr
         currentStrategy = null;
       }
     }
-    if (currentSessionPath && existsSync9(currentSessionPath)) {
+    if (currentSessionPath && existsSync10(currentSessionPath)) {
       if (!options.workflow) {
         const activeWorkflows = detectActiveWorkflows(currentSessionPath);
         if (activeWorkflows.length > 1) {
@@ -24363,15 +24430,15 @@ var progressCommand = new Command("progress").description("Watch real-time progr
     watchSession(currentSessionPath);
   }
   const timerInterval = setInterval(updateDisplay, 1e3);
-  const watchDir = existsSync9(ocrDir) ? ocrDir : targetDir;
+  const watchDir = existsSync10(ocrDir) ? ocrDir : targetDir;
   const dirWatcher = watch(watchDir, {
     persistent: true,
     ignoreInitial: true,
     depth: 3
   });
   dirWatcher.on("addDir", (dirPath) => {
-    const parentDir = join11(dirPath, "..");
-    const isDirectChild = parentDir.endsWith("sessions") || parentDir.endsWith(join11(".ocr", "sessions"));
+    const parentDir = join12(dirPath, "..");
+    const isDirectChild = parentDir.endsWith("sessions") || parentDir.endsWith(join12(".ocr", "sessions"));
     if (isDirectChild && !dirPath.endsWith("sessions")) {
       const newSession = basename7(dirPath);
       currentSession = newSession;
@@ -24473,27 +24540,34 @@ function renderCombinedProgress(sessionPath, preservedStartTimes, ocrDir) {
 }
 
 // src/commands/state.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync4 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5 } from "node:fs";
+import { join as join14 } from "node:path";
 
 // src/lib/state/index.ts
 init_db();
-import { existsSync as existsSync10, readdirSync as readdirSync6, statSync as statSync2 } from "node:fs";
-import { join as join12 } from "node:path";
+import {
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync6,
+  readFileSync as readFileSync9,
+  statSync as statSync2,
+  writeFileSync as writeFileSync7
+} from "node:fs";
+import { join as join13 } from "node:path";
 async function stateInit(params) {
   const { sessionId, branch, workflowType, sessionDir, ocrDir } = params;
   const db = await ensureDatabase(ocrDir);
-  const dbPath = join12(ocrDir, "data", "ocr.db");
+  const dbPath = join13(ocrDir, "data", "ocr.db");
   const existing = getSession(db, sessionId);
   if (existing) {
-    const roundsDir = join12(sessionDir, "rounds");
+    const roundsDir = join13(sessionDir, "rounds");
     let nextRound = 1;
-    if (existsSync10(roundsDir)) {
+    if (existsSync11(roundsDir)) {
       const roundDirs = readdirSync6(roundsDir).filter((d) => /^round-\d+$/.test(d)).map((d) => parseInt(d.replace("round-", ""), 10)).sort((a, b) => a - b);
       if (roundDirs.length > 0) {
         const highest = roundDirs[roundDirs.length - 1];
-        const hasFinal = existsSync10(
-          join12(roundsDir, `round-${highest}`, "final.md")
+        const hasFinal = existsSync11(
+          join13(roundsDir, `round-${highest}`, "final.md")
         );
         nextRound = hasFinal ? highest + 1 : highest;
       }
@@ -24537,7 +24611,7 @@ async function stateInit(params) {
 async function stateTransition(params) {
   const { sessionId, phase, phaseNumber, round, mapRun, ocrDir } = params;
   const db = await ensureDatabase(ocrDir);
-  const dbPath = join12(ocrDir, "data", "ocr.db");
+  const dbPath = join13(ocrDir, "data", "ocr.db");
   const existing = getSession(db, sessionId);
   if (!existing) {
     throw new Error(`Session not found: ${sessionId}`);
@@ -24570,7 +24644,7 @@ async function stateTransition(params) {
 async function stateClose(params) {
   const { sessionId, ocrDir } = params;
   const db = await ensureDatabase(ocrDir);
-  const dbPath = join12(ocrDir, "data", "ocr.db");
+  const dbPath = join13(ocrDir, "data", "ocr.db");
   const existing = getSession(db, sessionId);
   if (!existing) {
     throw new Error(`Session not found: ${sessionId}`);
@@ -24635,26 +24709,273 @@ async function resolveActiveSession(ocrDir) {
     sessionDir: session.session_dir
   };
 }
+function readJsonFromSource(params) {
+  if (params.source === "file") {
+    if (!existsSync11(params.filePath)) {
+      throw new Error(`File not found: ${params.filePath}`);
+    }
+    return readFileSync9(params.filePath, "utf-8");
+  }
+  return params.data;
+}
+function parseRawJson(raw, label) {
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `Failed to parse ${label}: ${err instanceof Error ? err.message : "invalid JSON"}`
+    );
+  }
+}
+function resolveSessionForCompletion(db, explicitId) {
+  if (explicitId) {
+    const existing = getSession(db, explicitId);
+    if (!existing) throw new Error(`Session not found: ${explicitId}`);
+    return {
+      id: existing.id,
+      session_dir: existing.session_dir,
+      current_round: existing.current_round,
+      current_map_run: existing.current_map_run
+    };
+  }
+  const active = getLatestActiveSession(db);
+  if (!active) throw new Error("No active session found");
+  return {
+    id: active.id,
+    session_dir: active.session_dir,
+    current_round: active.current_round,
+    current_map_run: active.current_map_run
+  };
+}
+var VALID_CATEGORIES = /* @__PURE__ */ new Set(["blocker", "should_fix", "suggestion", "style"]);
+var VALID_SEVERITIES = /* @__PURE__ */ new Set(["critical", "high", "medium", "low", "info"]);
+function validateRoundMeta(meta) {
+  if (!meta || typeof meta !== "object") {
+    throw new Error("round-meta.json must be a JSON object");
+  }
+  const obj = meta;
+  if (obj.schema_version !== 1) {
+    throw new Error(
+      `Unsupported schema_version: ${String(obj.schema_version)}. Expected 1.`
+    );
+  }
+  if (typeof obj.verdict !== "string" || obj.verdict.trim().length === 0) {
+    throw new Error("round-meta.json must contain a non-empty verdict string");
+  }
+  if (!Array.isArray(obj.reviewers)) {
+    throw new Error("round-meta.json must contain a reviewers array");
+  }
+  for (const reviewer of obj.reviewers) {
+    if (!reviewer || typeof reviewer !== "object") {
+      throw new Error("Each reviewer must be an object");
+    }
+    const r = reviewer;
+    if (typeof r.type !== "string") {
+      throw new Error("Each reviewer must have a type string");
+    }
+    if (typeof r.instance !== "number") {
+      throw new Error("Each reviewer must have an instance number");
+    }
+    if (!Array.isArray(r.findings)) {
+      throw new Error(`Reviewer ${r.type}-${r.instance} must have a findings array`);
+    }
+    for (const finding of r.findings) {
+      if (!finding || typeof finding !== "object") {
+        throw new Error("Each finding must be an object");
+      }
+      const f = finding;
+      if (typeof f.title !== "string" || f.title.trim().length === 0) {
+        throw new Error("Each finding must have a non-empty title");
+      }
+      if (typeof f.category !== "string" || !VALID_CATEGORIES.has(f.category)) {
+        throw new Error(
+          `Finding "${f.title}" has invalid category: "${String(f.category)}". Must be one of: ${[...VALID_CATEGORIES].join(", ")}`
+        );
+      }
+      if (typeof f.severity !== "string" || !VALID_SEVERITIES.has(f.severity)) {
+        throw new Error(
+          `Finding "${f.title}" has invalid severity: "${String(f.severity)}". Must be one of: ${[...VALID_SEVERITIES].join(", ")}`
+        );
+      }
+      if (typeof f.summary !== "string") {
+        throw new Error(`Finding "${f.title}" must have a summary string`);
+      }
+      if (f.file_path !== void 0 && typeof f.file_path !== "string") {
+        throw new Error(`Finding "${f.title}" has invalid file_path: expected string`);
+      }
+      if (f.line_start !== void 0 && typeof f.line_start !== "number") {
+        throw new Error(`Finding "${f.title}" has invalid line_start: expected number`);
+      }
+      if (f.line_end !== void 0 && typeof f.line_end !== "number") {
+        throw new Error(`Finding "${f.title}" has invalid line_end: expected number`);
+      }
+      if (f.flagged_by !== void 0 && !Array.isArray(f.flagged_by)) {
+        throw new Error(`Finding "${f.title}" has invalid flagged_by: expected array`);
+      }
+    }
+  }
+  return meta;
+}
+function computeRoundCounts(meta) {
+  const allFindings = [];
+  for (const reviewer of meta.reviewers) {
+    allFindings.push(...reviewer.findings);
+  }
+  return {
+    blockerCount: allFindings.filter((f) => f.category === "blocker").length,
+    shouldFixCount: allFindings.filter((f) => f.category === "should_fix").length,
+    suggestionCount: allFindings.filter((f) => f.category === "suggestion").length,
+    reviewerCount: meta.reviewers.length,
+    totalFindingCount: allFindings.length
+  };
+}
+async function stateRoundComplete(params) {
+  const { ocrDir } = params;
+  const db = await ensureDatabase(ocrDir);
+  const dbPath = join13(ocrDir, "data", "ocr.db");
+  const rawJsonString = readJsonFromSource(params);
+  const label = params.source === "file" ? params.filePath : "stdin";
+  const raw = parseRawJson(rawJsonString, label);
+  const meta = validateRoundMeta(raw);
+  const counts = computeRoundCounts(meta);
+  const session = resolveSessionForCompletion(db, params.sessionId);
+  const roundNumber = params.round ?? session.current_round;
+  let metaPath;
+  if (params.source === "stdin") {
+    const roundDir = join13(session.session_dir, "rounds", `round-${roundNumber}`);
+    mkdirSync4(roundDir, { recursive: true });
+    metaPath = join13(roundDir, "round-meta.json");
+    writeFileSync7(metaPath, JSON.stringify(meta, null, 2));
+  }
+  insertEvent(db, {
+    session_id: session.id,
+    event_type: "round_completed",
+    phase: "synthesis",
+    phase_number: 7,
+    round: roundNumber,
+    metadata: JSON.stringify({
+      verdict: meta.verdict,
+      blocker_count: counts.blockerCount,
+      should_fix_count: counts.shouldFixCount,
+      suggestion_count: counts.suggestionCount,
+      reviewer_count: counts.reviewerCount,
+      total_finding_count: counts.totalFindingCount,
+      source: "orchestrator"
+    })
+  });
+  saveDatabase(db, dbPath);
+  return { sessionId: session.id, round: roundNumber, metaPath };
+}
+function validateMapMeta(meta) {
+  if (!meta || typeof meta !== "object") {
+    throw new Error("map-meta.json must be a JSON object");
+  }
+  const obj = meta;
+  if (obj.schema_version !== 1) {
+    throw new Error(
+      `Unsupported schema_version: ${String(obj.schema_version)}. Expected 1.`
+    );
+  }
+  if (!Array.isArray(obj.sections)) {
+    throw new Error("map-meta.json must contain a sections array");
+  }
+  for (const section of obj.sections) {
+    if (!section || typeof section !== "object") {
+      throw new Error("Each section must be an object");
+    }
+    const s = section;
+    if (typeof s.section_number !== "number") {
+      throw new Error("Each section must have a section_number");
+    }
+    if (typeof s.title !== "string" || s.title.trim().length === 0) {
+      throw new Error("Each section must have a non-empty title");
+    }
+    if (!Array.isArray(s.files)) {
+      throw new Error(`Section "${s.title}" must have a files array`);
+    }
+    for (const file of s.files) {
+      if (!file || typeof file !== "object") {
+        throw new Error("Each file must be an object");
+      }
+      const f = file;
+      if (typeof f.file_path !== "string" || f.file_path.trim().length === 0) {
+        throw new Error("Each file must have a non-empty file_path");
+      }
+      if (typeof f.role !== "string") {
+        throw new Error(`File "${f.file_path}" must have a role string`);
+      }
+      if (typeof f.lines_added !== "number") {
+        throw new Error(`File "${f.file_path}" must have a lines_added number`);
+      }
+      if (typeof f.lines_deleted !== "number") {
+        throw new Error(`File "${f.file_path}" must have a lines_deleted number`);
+      }
+    }
+  }
+  if (obj.dependencies !== void 0 && !Array.isArray(obj.dependencies)) {
+    throw new Error("map-meta.json dependencies must be an array if provided");
+  }
+  return meta;
+}
+function computeMapCounts(meta) {
+  return {
+    sectionCount: meta.sections.length,
+    fileCount: meta.sections.reduce((sum, s) => sum + s.files.length, 0)
+  };
+}
+async function stateMapComplete(params) {
+  const { ocrDir } = params;
+  const db = await ensureDatabase(ocrDir);
+  const dbPath = join13(ocrDir, "data", "ocr.db");
+  const rawJsonString = readJsonFromSource(params);
+  const label = params.source === "file" ? params.filePath : "stdin";
+  const raw = parseRawJson(rawJsonString, label);
+  const meta = validateMapMeta(raw);
+  const counts = computeMapCounts(meta);
+  const session = resolveSessionForCompletion(db, params.sessionId);
+  const mapRunNumber = params.mapRun ?? session.current_map_run;
+  let metaPath;
+  if (params.source === "stdin") {
+    const runDir = join13(session.session_dir, "map", "runs", `run-${mapRunNumber}`);
+    mkdirSync4(runDir, { recursive: true });
+    metaPath = join13(runDir, "map-meta.json");
+    writeFileSync7(metaPath, JSON.stringify(meta, null, 2));
+  }
+  insertEvent(db, {
+    session_id: session.id,
+    event_type: "map_completed",
+    phase: "synthesis",
+    phase_number: 5,
+    round: mapRunNumber,
+    metadata: JSON.stringify({
+      section_count: counts.sectionCount,
+      file_count: counts.fileCount,
+      source: "orchestrator"
+    })
+  });
+  saveDatabase(db, dbPath);
+  return { sessionId: session.id, mapRun: mapRunNumber, metaPath };
+}
 async function stateSync(ocrDir) {
   const db = await ensureDatabase(ocrDir);
-  const dbPath = join12(ocrDir, "data", "ocr.db");
-  const sessionsRoot = join12(ocrDir, "sessions");
-  if (!existsSync10(sessionsRoot)) {
+  const dbPath = join13(ocrDir, "data", "ocr.db");
+  const sessionsRoot = join13(ocrDir, "sessions");
+  if (!existsSync11(sessionsRoot)) {
     return 0;
   }
   const entries = readdirSync6(sessionsRoot).filter((name) => {
-    const fullPath = join12(sessionsRoot, name);
+    const fullPath = join13(sessionsRoot, name);
     return statSync2(fullPath).isDirectory();
   });
   let synced = 0;
   for (const dirName of entries) {
-    const dirPath = join12(sessionsRoot, dirName);
+    const dirPath = join13(sessionsRoot, dirName);
     const existing = getSession(db, dirName);
     if (existing) {
       continue;
     }
-    const hasRoundsDir = existsSync10(join12(dirPath, "rounds"));
-    const hasMapDir = existsSync10(join12(dirPath, "map"));
+    const hasRoundsDir = existsSync11(join13(dirPath, "rounds"));
+    const hasMapDir = existsSync11(join13(dirPath, "map"));
     const workflowType = hasMapDir && !hasRoundsDir ? "map" : "review";
     const branchMatch = dirName.match(/^\d{4}-\d{2}-\d{2}-(.+)$/);
     const branch = branchMatch?.[1] ?? dirName;
@@ -24684,6 +25005,17 @@ async function stateSync(ocrDir) {
 }
 
 // src/commands/state.ts
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  const data = Buffer.concat(chunks).toString("utf-8").trim();
+  if (data.length === 0) {
+    throw new Error("No data received on stdin");
+  }
+  return data;
+}
 var initSubcommand = new Command("init").description("Initialize a new OCR session").requiredOption("--session-id <id>", "Session ID").requiredOption("--branch <branch>", "Branch name").requiredOption(
   "--workflow-type <type>",
   "Workflow type (review or map)",
@@ -24699,10 +25031,10 @@ var initSubcommand = new Command("init").description("Initialize a new OCR sessi
   async (options) => {
     const targetDir = process.cwd();
     requireOcrSetup(targetDir);
-    const ocrDir = join13(targetDir, ".ocr");
-    const sessionDir = options.sessionDir ?? join13(ocrDir, "sessions", options.sessionId);
-    if (!existsSync11(sessionDir)) {
-      mkdirSync4(sessionDir, { recursive: true });
+    const ocrDir = join14(targetDir, ".ocr");
+    const sessionDir = options.sessionDir ?? join14(ocrDir, "sessions", options.sessionId);
+    if (!existsSync12(sessionDir)) {
+      mkdirSync5(sessionDir, { recursive: true });
     }
     try {
       const sessionId = await stateInit({
@@ -24727,7 +25059,24 @@ var transitionSubcommand = new Command("transition").description("Transition ses
   async (options) => {
     const targetDir = process.cwd();
     requireOcrSetup(targetDir);
-    const ocrDir = join13(targetDir, ".ocr");
+    const ocrDir = join14(targetDir, ".ocr");
+    const VALID_PHASES = /* @__PURE__ */ new Set([
+      "context",
+      "change-context",
+      "analysis",
+      "reviews",
+      "aggregation",
+      "discourse",
+      "synthesis",
+      "complete",
+      "map-context",
+      "topology",
+      "flow-analysis",
+      "requirements-mapping"
+    ]);
+    if (!VALID_PHASES.has(options.phase)) {
+      throw new Error(`Invalid phase: "${options.phase}". Must be one of: ${[...VALID_PHASES].join(", ")}`);
+    }
     try {
       const sessionId = options.sessionId ?? (await resolveActiveSession(ocrDir)).id;
       await stateTransition({
@@ -24754,7 +25103,7 @@ var transitionSubcommand = new Command("transition").description("Transition ses
 var closeSubcommand = new Command("close").description("Close a session").option("--session-id <id>", "Session ID (auto-detects latest active if omitted)").action(async (options) => {
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
-  const ocrDir = join13(targetDir, ".ocr");
+  const ocrDir = join14(targetDir, ".ocr");
   try {
     const sessionId = options.sessionId ?? (await resolveActiveSession(ocrDir)).id;
     await stateClose({
@@ -24774,7 +25123,7 @@ var closeSubcommand = new Command("close").description("Close a session").option
 var showSubcommand = new Command("show").description("Show current session state").option("--session-id <id>", "Session ID (defaults to latest active)").option("--json", "Output as JSON").action(async (options) => {
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
-  const ocrDir = join13(targetDir, ".ocr");
+  const ocrDir = join14(targetDir, ".ocr");
   try {
     const result = await stateShow(ocrDir, options.sessionId);
     if (!result) {
@@ -24843,7 +25192,7 @@ var showSubcommand = new Command("show").description("Show current session state
 var syncSubcommand = new Command("sync").description("Rebuild session state from filesystem artifacts").action(async () => {
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
-  const ocrDir = join13(targetDir, ".ocr");
+  const ocrDir = join14(targetDir, ".ocr");
   try {
     const synced = await stateSync(ocrDir);
     console.log(`Synced ${synced} session${synced !== 1 ? "s" : ""} from filesystem.`);
@@ -24856,19 +25205,117 @@ var syncSubcommand = new Command("sync").description("Rebuild session state from
     process.exit(1);
   }
 });
-var stateCommand = new Command("state").description("Manage OCR session state").addCommand(initSubcommand).addCommand(transitionSubcommand).addCommand(closeSubcommand).addCommand(showSubcommand).addCommand(syncSubcommand);
+var roundCompleteSubcommand = new Command("round-complete").description("Import structured round data into SQLite").option("--file <path>", "Path to round-meta.json").option("--stdin", "Read round-meta JSON from stdin (recommended)").option("--session-id <id>", "Session ID (auto-detects latest active if omitted)").option("--round <number>", "Round number (auto-detects current if omitted)", parseInt).action(
+  async (options) => {
+    const targetDir = process.cwd();
+    requireOcrSetup(targetDir);
+    const ocrDir = join14(targetDir, ".ocr");
+    if (!options.file && !options.stdin) {
+      console.error(source_default.red("Error: Provide either --file <path> or --stdin"));
+      process.exit(1);
+    }
+    if (options.file && options.stdin) {
+      console.error(source_default.red("Error: --file and --stdin are mutually exclusive"));
+      process.exit(1);
+    }
+    try {
+      let result;
+      if (options.stdin) {
+        const data = await readStdin();
+        result = await stateRoundComplete({
+          source: "stdin",
+          ocrDir,
+          data,
+          sessionId: options.sessionId,
+          round: options.round
+        });
+      } else if (options.file) {
+        result = await stateRoundComplete({
+          source: "file",
+          ocrDir,
+          filePath: options.file,
+          sessionId: options.sessionId,
+          round: options.round
+        });
+      } else {
+        process.exit(1);
+      }
+      console.log(source_default.green("Round data imported successfully."));
+      if (result.metaPath) {
+        console.log(source_default.dim(`Wrote ${result.metaPath}`));
+      }
+    } catch (error) {
+      console.error(
+        source_default.red(
+          `Error: ${error instanceof Error ? error.message : "Failed to import round data"}`
+        )
+      );
+      process.exit(1);
+    }
+  }
+);
+var mapCompleteSubcommand = new Command("map-complete").description("Import structured map run data into SQLite").option("--file <path>", "Path to map-meta.json").option("--stdin", "Read map-meta JSON from stdin (recommended)").option("--session-id <id>", "Session ID (auto-detects latest active if omitted)").option("--map-run <number>", "Map run number (auto-detects current if omitted)", parseInt).action(
+  async (options) => {
+    const targetDir = process.cwd();
+    requireOcrSetup(targetDir);
+    const ocrDir = join14(targetDir, ".ocr");
+    if (!options.file && !options.stdin) {
+      console.error(source_default.red("Error: Provide either --file <path> or --stdin"));
+      process.exit(1);
+    }
+    if (options.file && options.stdin) {
+      console.error(source_default.red("Error: --file and --stdin are mutually exclusive"));
+      process.exit(1);
+    }
+    try {
+      let result;
+      if (options.stdin) {
+        const data = await readStdin();
+        result = await stateMapComplete({
+          source: "stdin",
+          ocrDir,
+          data,
+          sessionId: options.sessionId,
+          mapRun: options.mapRun
+        });
+      } else if (options.file) {
+        result = await stateMapComplete({
+          source: "file",
+          ocrDir,
+          filePath: options.file,
+          sessionId: options.sessionId,
+          mapRun: options.mapRun
+        });
+      } else {
+        process.exit(1);
+      }
+      console.log(source_default.green("Map data imported successfully."));
+      if (result.metaPath) {
+        console.log(source_default.dim(`Wrote ${result.metaPath}`));
+      }
+    } catch (error) {
+      console.error(
+        source_default.red(
+          `Error: ${error instanceof Error ? error.message : "Failed to import map data"}`
+        )
+      );
+      process.exit(1);
+    }
+  }
+);
+var stateCommand = new Command("state").description("Manage OCR session state").addCommand(initSubcommand).addCommand(transitionSubcommand).addCommand(closeSubcommand).addCommand(showSubcommand).addCommand(syncSubcommand).addCommand(roundCompleteSubcommand).addCommand(mapCompleteSubcommand);
 
 // src/commands/update.ts
-import { existsSync as existsSync12 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync13 } from "node:fs";
+import { join as join15 } from "node:path";
 function detectConfiguredTools(targetDir) {
   return AI_TOOLS.filter((tool) => {
     if (tool.commandStrategy === "subdirectory") {
-      const ocrDir = join14(targetDir, tool.commandsDir, "ocr");
-      return existsSync12(ocrDir);
+      const ocrDir = join15(targetDir, tool.commandsDir, "ocr");
+      return existsSync13(ocrDir);
     } else {
-      const reviewCmd = join14(targetDir, tool.commandsDir, "ocr-review.md");
-      return existsSync12(reviewCmd);
+      const reviewCmd = join15(targetDir, tool.commandsDir, "ocr-review.md");
+      return existsSync13(reviewCmd);
     }
   });
 }
@@ -24942,6 +25389,7 @@ var updateCommand = new Command("update").description("Update OCR assets after p
         const result = installForTool(tool, targetDir);
         results.push(result);
       }
+      ensureGitignore(join15(targetDir, ".ocr"));
       spinner.stop();
       const successful = results.filter((r) => r.success);
       const failed = results.filter((r) => !r.success);
@@ -24977,10 +25425,10 @@ var updateCommand = new Command("update").description("Update OCR assets after p
   if (updateInject) {
     if (options.dryRun) {
       console.log(source_default.dim("  Would update:"));
-      if (existsSync12(join14(targetDir, "AGENTS.md"))) {
+      if (existsSync13(join15(targetDir, "AGENTS.md"))) {
         console.log(source_default.dim("    \u2022 AGENTS.md (OCR managed block)"));
       }
-      if (existsSync12(join14(targetDir, "CLAUDE.md"))) {
+      if (existsSync13(join15(targetDir, "CLAUDE.md"))) {
         console.log(source_default.dim("    \u2022 CLAUDE.md (OCR managed block)"));
       }
       console.log();
@@ -25011,14 +25459,14 @@ var updateCommand = new Command("update").description("Update OCR assets after p
 });
 
 // src/commands/dashboard.ts
-import { existsSync as existsSync13 } from "node:fs";
-import { join as join15, dirname as dirname5 } from "node:path";
+import { existsSync as existsSync14 } from "node:fs";
+import { join as join16, dirname as dirname5 } from "node:path";
 import { fileURLToPath } from "node:url";
 init_db();
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname5(__filename);
 function resolveServerPath() {
-  return join15(__dirname, "dashboard", "server.js");
+  return join16(__dirname, "dashboard", "server.js");
 }
 var dashboardCommand = new Command("dashboard").description("Start the OCR dashboard web interface").option("-p, --port <port>", "Port to run the server on", "4173").option("--no-open", "Don't open the browser automatically").action(
   async (options) => {
@@ -25029,7 +25477,7 @@ var dashboardCommand = new Command("dashboard").description("Start the OCR dashb
       console.error(source_default.red(`Error: Invalid port "${options.port}". Must be 1-65535.`));
       process.exit(1);
     }
-    const ocrDir = join15(targetDir, ".ocr");
+    const ocrDir = join16(targetDir, ".ocr");
     try {
       await ensureDatabase(ocrDir);
       closeAllDatabases();
@@ -25043,7 +25491,7 @@ var dashboardCommand = new Command("dashboard").description("Start the OCR dashb
       process.exit(1);
     }
     const serverPath = resolveServerPath();
-    if (!existsSync13(serverPath)) {
+    if (!existsSync14(serverPath)) {
       console.error(source_default.red("Error: Dashboard server bundle not found."));
       console.error(
         source_default.dim(`  Expected at: ${serverPath}`)
@@ -25077,8 +25525,8 @@ var dashboardCommand = new Command("dashboard").description("Start the OCR dashb
 );
 
 // src/commands/doctor.ts
-import { existsSync as existsSync14 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync15 } from "node:fs";
+import { join as join17 } from "node:path";
 var doctorCommand = new Command("doctor").description("Check OCR installation and verify all dependencies").action(() => {
   printHeader();
   const targetDir = process.cwd();
@@ -25092,10 +25540,10 @@ var doctorCommand = new Command("doctor").description("Check OCR installation an
   console.log(source_default.bold("  OCR Installation"));
   console.log();
   const ocrStatus = checkOcrSetup(targetDir);
-  const configPath = join16(targetDir, ".ocr", "config.yaml");
-  const dbPath = join16(targetDir, ".ocr", "data", "ocr.db");
-  const hasConfig = existsSync14(configPath);
-  const hasDb = existsSync14(dbPath);
+  const configPath = join17(targetDir, ".ocr", "config.yaml");
+  const dbPath = join17(targetDir, ".ocr", "data", "ocr.db");
+  const hasConfig = existsSync15(configPath);
+  const hasDb = existsSync15(dbPath);
   const ocrChecks = [
     { label: ".ocr/skills/", ok: ocrStatus.hasSkills },
     { label: ".ocr/sessions/", ok: ocrStatus.hasSessions },
@@ -25168,8 +25616,94 @@ var doctorCommand = new Command("doctor").description("Check OCR installation an
   console.log();
 });
 
+// src/lib/update-check.ts
+import { homedir } from "node:os";
+import { join as join18 } from "node:path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync8, mkdirSync as mkdirSync6 } from "node:fs";
+var PACKAGE_NAME = "@open-code-review/cli";
+var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+var CACHE_DIR = join18(homedir(), ".ocr");
+var CACHE_FILE = join18(CACHE_DIR, "update-check.json");
+var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 3e3;
+function readCache(cacheFile) {
+  try {
+    return JSON.parse(readFileSync10(cacheFile, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeCache(cacheFile, cache) {
+  try {
+    mkdirSync6(join18(cacheFile, ".."), { recursive: true });
+    writeFileSync8(cacheFile, JSON.stringify(cache));
+  } catch {
+  }
+}
+function isNewer(latest, current) {
+  const l = latest.split(".").map(Number);
+  const c = current.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((l[i] ?? 0) > (c[i] ?? 0)) return true;
+    if ((l[i] ?? 0) < (c[i] ?? 0)) return false;
+  }
+  return false;
+}
+function detectUpdateCommand() {
+  return `npm i -g ${PACKAGE_NAME}@latest && ocr update`;
+}
+async function checkForUpdate(currentVersion, options) {
+  if (process.env.CI || process.env.OCR_NO_UPDATE_CHECK) {
+    return null;
+  }
+  const cacheFile = join18(options?.cacheDir ?? CACHE_DIR, "update-check.json");
+  try {
+    const cache = readCache(cacheFile);
+    if (cache && Date.now() - cache.lastCheck < CHECK_INTERVAL_MS) {
+      if (!cache.latestVersion) return null;
+      if (!isNewer(cache.latestVersion, currentVersion)) return null;
+      return {
+        updateAvailable: true,
+        currentVersion,
+        latestVersion: cache.latestVersion,
+        updateCommand: detectUpdateCommand()
+      };
+    }
+    const response = await fetch(REGISTRY_URL, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+    const data = await response.json();
+    const latestVersion = data.version ?? null;
+    writeCache(cacheFile, { lastCheck: Date.now(), latestVersion });
+    if (!latestVersion || !isNewer(latestVersion, currentVersion)) {
+      return null;
+    }
+    return {
+      updateAvailable: true,
+      currentVersion,
+      latestVersion,
+      updateCommand: detectUpdateCommand()
+    };
+  } catch {
+    writeCache(cacheFile, { lastCheck: Date.now(), latestVersion: null });
+    return null;
+  }
+}
+function printUpdateNotification(result) {
+  const line1 = source_default.yellow("  Update available: ") + source_default.dim(result.currentVersion) + source_default.yellow(" \u2192 ") + source_default.green(result.latestVersion);
+  const line2 = source_default.dim("  Run: ") + source_default.bold(result.updateCommand);
+  process.stderr.write(`
+${line1}
+${line2}
+
+`);
+}
+
 // src/index.ts
-var cliVersion = true ? "1.5.0" : createRequire(import.meta.url)("../package.json").version;
+var cliVersion = true ? "1.6.0" : createRequire(import.meta.url)("../package.json").version;
+var HUMAN_COMMANDS = /* @__PURE__ */ new Set(["init", "update", "doctor", "dashboard", "progress"]);
+var subcommand = process.argv[2];
+var updateCheck = subcommand && HUMAN_COMMANDS.has(subcommand) ? checkForUpdate(cliVersion) : null;
 var program2 = new Command();
 program2.name("ocr").description("Open Code Review - AI-powered multi-agent code review").version(cliVersion);
 program2.addCommand(initCommand);
@@ -25178,7 +25712,16 @@ program2.addCommand(stateCommand);
 program2.addCommand(updateCommand);
 program2.addCommand(dashboardCommand);
 program2.addCommand(doctorCommand);
-program2.parse();
+await program2.parseAsync();
+if (updateCheck) {
+  const updateResult = await Promise.race([
+    updateCheck,
+    new Promise((r) => setTimeout(() => r(null), 500))
+  ]);
+  if (updateResult?.updateAvailable) {
+    printUpdateNotification(updateResult);
+  }
+}
 /*! Bundled license information:
 
 chokidar/esm/index.js: