@open-code-review/cli 1.5.1 → 1.7.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;
     `
       }
     ];
@@ -20187,21 +20211,30 @@ 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 regex2 = new RegExp(
+  const blockRegex = new RegExp(
     `${escapeRegex(START_MARKER)}[\\s\\S]*?${escapeRegex(END_MARKER)}\\n?`,
     "g"
   );
-  if (regex2.test(content)) {
+  if (blockRegex.test(content)) {
     content = content.replace(
       new RegExp(
         `${escapeRegex(START_MARKER)}[\\s\\S]*?${escapeRegex(END_MARKER)}\\n?`,
@@ -20210,7 +20243,7 @@ function ensureGitignore(ocrDir) {
       block + "\n"
     );
   } else {
-    content = content.trimEnd();
+    content = stripLegacyLines(content).trimEnd();
     if (content.length > 0) {
       content += "\n\n";
     }
@@ -20328,6 +20361,153 @@ function installCommandsForTool(tool, commandsSource, targetDir) {
     return false;
   }
 }
+var BUILTIN_ICON_MAP = {
+  architect: "blocks",
+  fullstack: "layers",
+  reliability: "activity",
+  "staff-engineer": "compass",
+  principal: "crown",
+  frontend: "layout",
+  backend: "server",
+  infrastructure: "cloud",
+  performance: "gauge",
+  accessibility: "accessibility",
+  data: "database",
+  devops: "rocket",
+  dx: "terminal",
+  mobile: "smartphone",
+  security: "shield-alert",
+  quality: "sparkles",
+  testing: "test-tubes",
+  ai: "bot",
+  "docs-writer": "file-text"
+};
+var HOLISTIC_IDS = /* @__PURE__ */ new Set(["architect", "fullstack", "reliability", "staff-engineer", "principal"]);
+var SPECIALIST_IDS = /* @__PURE__ */ new Set([
+  "frontend",
+  "backend",
+  "infrastructure",
+  "performance",
+  "accessibility",
+  "data",
+  "devops",
+  "dx",
+  "mobile",
+  "security",
+  "quality",
+  "testing",
+  "ai",
+  "docs-writer"
+]);
+var PERSONA_IDS = /* @__PURE__ */ new Set([
+  "martin-fowler",
+  "kent-beck",
+  "john-ousterhout",
+  "anders-hejlsberg",
+  "vladimir-khorikov",
+  "kent-dodds",
+  "tanner-linsley",
+  "kamil-mysliwiec",
+  "sandi-metz",
+  "rich-hickey"
+]);
+function classifyTier(id) {
+  if (PERSONA_IDS.has(id)) return "persona";
+  if (HOLISTIC_IDS.has(id)) return "holistic";
+  if (SPECIALIST_IDS.has(id)) return "specialist";
+  return "custom";
+}
+function extractReviewerName(content) {
+  const match = content.match(/^#\s+(.+?)(?:\s+—\s+Reviewer|\s+Reviewer)\s*$/m);
+  if (match?.[1]) return match[1];
+  const titleMatch = content.match(/^#\s+(.+)$/m);
+  return titleMatch?.[1]?.replace(/\s*Reviewer\s*$/, "").trim() ?? "Unknown";
+}
+function extractReviewerDescription(content) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith(">")) continue;
+    if (trimmed.startsWith("You are a **") || trimmed.startsWith("You are reviewing")) {
+      return trimmed.replace(/\*\*/g, "").replace(/^You are a /, "").replace(/^You are reviewing code through the lens of .*?\.\s*/, "").trim();
+    }
+  }
+  return "";
+}
+function extractFocusAreas(content) {
+  const areas = [];
+  const focusMatch = content.match(/## Your Focus Areas\n([\s\S]*?)(?=\n##|\n---|\z)/);
+  if (focusMatch?.[1]) {
+    const bullets = focusMatch[1].match(/- \*\*(.+?)\*\*/g);
+    if (bullets) {
+      for (const b of bullets) {
+        const m = b.match(/- \*\*(.+?)\*\*/);
+        if (m?.[1]) areas.push(m[1]);
+      }
+    }
+  }
+  return areas;
+}
+function extractPersonaFields(content) {
+  const knownMatch = content.match(/>\s*\*\*Known for\*\*:\s*(.+)/);
+  const philMatch = content.match(/>\s*\*\*Philosophy\*\*:\s*([\s\S]*?)(?=\n(?!>)|\n\n)/);
+  const result = {};
+  if (knownMatch?.[1]) result.known_for = knownMatch[1].trim();
+  if (philMatch?.[1]) {
+    result.philosophy = philMatch[1].split("\n").map((l) => l.replace(/^>\s*/, "").trim()).join(" ").trim();
+  }
+  return result;
+}
+function generateReviewersMeta(reviewersDir, configPath) {
+  if (!existsSync2(reviewersDir)) return null;
+  const files = readdirSync(reviewersDir).filter((f) => f.endsWith(".md"));
+  if (files.length === 0) return null;
+  const defaultTeamIds = /* @__PURE__ */ new Set();
+  if (existsSync2(configPath)) {
+    try {
+      const configContent = readFileSync3(configPath, "utf-8");
+      const teamMatch = configContent.match(/default_team:\s*\n((?:\s+\w[\w-]*:\s*\d+\s*(?:#[^\n]*)?\n?)*)/);
+      if (teamMatch?.[1]) {
+        const entries = teamMatch[1].matchAll(/\s+([\w-]+):\s*\d+/g);
+        for (const entry of entries) {
+          if (entry[1]) defaultTeamIds.add(entry[1]);
+        }
+      }
+    } catch {
+    }
+  }
+  const reviewers = [];
+  for (const file of files) {
+    const id = file.replace(/\.md$/, "");
+    try {
+      const content = readFileSync3(join2(reviewersDir, file), "utf-8");
+      const tier = classifyTier(id);
+      const isBuiltin = HOLISTIC_IDS.has(id) || SPECIALIST_IDS.has(id) || PERSONA_IDS.has(id);
+      const reviewer = {
+        id,
+        name: extractReviewerName(content),
+        tier,
+        icon: BUILTIN_ICON_MAP[id] ?? (tier === "persona" ? "brain" : "user"),
+        description: extractReviewerDescription(content),
+        focus_areas: extractFocusAreas(content),
+        is_default: defaultTeamIds.has(id),
+        is_builtin: isBuiltin
+      };
+      if (tier === "persona") {
+        const persona = extractPersonaFields(content);
+        if (persona.known_for) reviewer.known_for = persona.known_for;
+        if (persona.philosophy) reviewer.philosophy = persona.philosophy;
+      }
+      reviewers.push(reviewer);
+    } catch {
+    }
+  }
+  return {
+    schema_version: 1,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    reviewers
+  };
+}
 function installForTool(tool, targetDir) {
   const agentsPath = getAgentsPackagePath();
   const ocrSkillsSource = join2(agentsPath, "skills", "ocr");
@@ -20402,6 +20582,14 @@ function installForTool(tool, targetDir) {
       }
     }
   }
+  const metaPath = join2(ocrDir, "reviewers-meta.json");
+  try {
+    const meta = generateReviewersMeta(reviewersDir, configPath);
+    if (meta) {
+      writeFileSync3(metaPath, JSON.stringify(meta, null, 2) + "\n");
+    }
+  } catch {
+  }
   const commandsOk = installCommandsForTool(tool, commandsSource, targetDir);
   if (!commandsOk) {
     return {
@@ -24507,12 +24695,19 @@ function renderCombinedProgress(sessionPath, preservedStartTimes, ocrDir) {
 }
 
 // src/commands/state.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync4 } from "node:fs";
+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 existsSync11, readdirSync as readdirSync6, statSync as statSync2 } from "node:fs";
+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;
@@ -24669,6 +24864,253 @@ 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 = join13(ocrDir, "data", "ocr.db");
@@ -24718,6 +25160,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)",
@@ -24736,7 +25189,7 @@ var initSubcommand = new Command("init").description("Initialize a new OCR sessi
     const ocrDir = join14(targetDir, ".ocr");
     const sessionDir = options.sessionDir ?? join14(ocrDir, "sessions", options.sessionId);
     if (!existsSync12(sessionDir)) {
-      mkdirSync4(sessionDir, { recursive: true });
+      mkdirSync5(sessionDir, { recursive: true });
     }
     try {
       const sessionId = await stateInit({
@@ -24762,6 +25215,23 @@ var transitionSubcommand = new Command("transition").description("Transition ses
     const targetDir = process.cwd();
     requireOcrSetup(targetDir);
     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({
@@ -24890,7 +25360,105 @@ 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 existsSync13 } from "node:fs";
@@ -25203,8 +25771,225 @@ var doctorCommand = new Command("doctor").description("Check OCR installation an
   console.log();
 });
 
+// src/commands/reviewers.ts
+import { writeFileSync as writeFileSync8, renameSync as renameSync2 } from "node:fs";
+import { join as join18 } from "node:path";
+async function readStdin2() {
+  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 VALID_TIERS = /* @__PURE__ */ new Set(["holistic", "specialist", "persona", "custom"]);
+var SLUG_RE = /^[a-z][a-z0-9-]*$/;
+function validateReviewersMeta(data) {
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw new Error("Payload must be a JSON object");
+  }
+  const obj = data;
+  if (obj.schema_version !== 1) {
+    throw new Error(`schema_version must be 1, got ${JSON.stringify(obj.schema_version)}`);
+  }
+  if (typeof obj.generated_at !== "string" || obj.generated_at.length === 0) {
+    throw new Error("generated_at must be a non-empty ISO 8601 string");
+  }
+  if (!Array.isArray(obj.reviewers)) {
+    throw new Error("reviewers must be an array");
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  for (let i = 0; i < obj.reviewers.length; i++) {
+    const r = obj.reviewers[i];
+    const prefix = `reviewers[${i}]`;
+    if (typeof r.id !== "string" || !SLUG_RE.test(r.id)) {
+      throw new Error(`${prefix}.id must be a lowercase slug (got ${JSON.stringify(r.id)})`);
+    }
+    if (seenIds.has(r.id)) {
+      throw new Error(`Duplicate reviewer id: "${r.id}"`);
+    }
+    seenIds.add(r.id);
+    if (typeof r.name !== "string" || r.name.length === 0) {
+      throw new Error(`${prefix}.name must be a non-empty string`);
+    }
+    if (!VALID_TIERS.has(r.tier)) {
+      throw new Error(`${prefix}.tier must be one of: ${[...VALID_TIERS].join(", ")} (got ${JSON.stringify(r.tier)})`);
+    }
+    if (typeof r.description !== "string" || r.description.length === 0) {
+      throw new Error(`${prefix}.description must be a non-empty string`);
+    }
+    if (!Array.isArray(r.focus_areas)) {
+      throw new Error(`${prefix}.focus_areas must be an array`);
+    }
+    if (r.known_for !== void 0 && typeof r.known_for !== "string") {
+      throw new Error(`${prefix}.known_for must be a string if provided`);
+    }
+    if (r.philosophy !== void 0 && typeof r.philosophy !== "string") {
+      throw new Error(`${prefix}.philosophy must be a string if provided`);
+    }
+  }
+  return data;
+}
+var syncSubcommand2 = new Command("sync").description("Sync reviewers-meta.json from reviewer markdown files or structured JSON").option("--stdin", "Read reviewers JSON from stdin (for AI-invoked sync)").action(async (options) => {
+  const targetDir = process.cwd();
+  requireOcrSetup(targetDir);
+  const ocrDir = join18(targetDir, ".ocr");
+  if (!options.stdin) {
+    try {
+      const reviewersDir = join18(ocrDir, "skills", "references", "reviewers");
+      const configPath = join18(ocrDir, "config.yaml");
+      const meta = generateReviewersMeta(reviewersDir, configPath);
+      if (!meta || meta.reviewers.length === 0) {
+        console.error(source_default.yellow("No reviewer files found in .ocr/skills/references/reviewers/"));
+        process.exit(1);
+      }
+      const metaPath = join18(ocrDir, "reviewers-meta.json");
+      const tmpPath = metaPath + ".tmp";
+      writeFileSync8(tmpPath, JSON.stringify(meta, null, 2) + "\n");
+      renameSync2(tmpPath, metaPath);
+      const tierCounts = meta.reviewers.reduce(
+        (acc, r) => {
+          acc[r.tier] = (acc[r.tier] ?? 0) + 1;
+          return acc;
+        },
+        {}
+      );
+      const breakdown = Object.entries(tierCounts).map(([tier, count]) => `${count} ${tier}`).join(", ");
+      console.log(source_default.green(`Synced ${meta.reviewers.length} reviewer(s) (${breakdown}).`));
+    } catch (error) {
+      console.error(
+        source_default.red(`Error: ${error instanceof Error ? error.message : "Failed to sync reviewers"}`)
+      );
+      process.exit(1);
+    }
+    return;
+  }
+  try {
+    const raw = await readStdin2();
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      throw new Error("Invalid JSON on stdin");
+    }
+    const meta = validateReviewersMeta(parsed);
+    const metaPath = join18(ocrDir, "reviewers-meta.json");
+    const tmpPath = metaPath + ".tmp";
+    writeFileSync8(tmpPath, JSON.stringify(meta, null, 2) + "\n");
+    renameSync2(tmpPath, metaPath);
+    const tierCounts = meta.reviewers.reduce(
+      (acc, r) => {
+        acc[r.tier] = (acc[r.tier] ?? 0) + 1;
+        return acc;
+      },
+      {}
+    );
+    const breakdown = Object.entries(tierCounts).map(([tier, count]) => `${count} ${tier}`).join(", ");
+    console.log(
+      source_default.green(`Synced ${meta.reviewers.length} reviewer(s) (${breakdown}).`)
+    );
+  } catch (error) {
+    console.error(
+      source_default.red(
+        `Error: ${error instanceof Error ? error.message : "Failed to sync reviewers"}`
+      )
+    );
+    process.exit(1);
+  }
+});
+var reviewersCommand = new Command("reviewers").description("Manage OCR reviewer metadata").addCommand(syncSubcommand2);
+
+// src/lib/update-check.ts
+import { homedir } from "node:os";
+import { join as join19 } from "node:path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync9, 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 = join19(homedir(), ".ocr");
+var CACHE_FILE = join19(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(join19(cacheFile, ".."), { recursive: true });
+    writeFileSync9(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 = join19(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.7.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);
@@ -25213,7 +25998,17 @@ program2.addCommand(stateCommand);
 program2.addCommand(updateCommand);
 program2.addCommand(dashboardCommand);
 program2.addCommand(doctorCommand);
-program2.parse();
+program2.addCommand(reviewersCommand);
+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: