@open-code-review/cli 1.5.1 → 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;
     `
       }
     ];
@@ -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";
     }
@@ -24507,12 +24540,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 +24709,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 +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)",
@@ -24736,7 +25034,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 +25060,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 +25205,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 +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);
@@ -25213,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: