@open-code-review/cli 1.5.1 → 1.7.0

package/dist/dashboard/server.js

@@ -18410,10 +18410,10 @@ var require_view = __commonJS({
     var debug = require_src()("express:view");
     var path2 = __require("path");
     var fs6 = __require("fs");
-    var dirname10 = path2.dirname;
+    var dirname11 = path2.dirname;
     var basename3 = path2.basename;
     var extname = path2.extname;
-    var join13 = path2.join;
+    var join14 = path2.join;
     var resolve3 = path2.resolve;
     module.exports = View;
     function View(name, options) {
@@ -18449,7 +18449,7 @@ var require_view = __commonJS({
       for (var i = 0; i < roots.length && !path3; i++) {
         var root = roots[i];
         var loc = resolve3(root, name);
-        var dir = dirname10(loc);
+        var dir = dirname11(loc);
         var file = basename3(loc);
         path3 = this.resolve(dir, file);
       }
@@ -18461,12 +18461,12 @@ var require_view = __commonJS({
     };
     View.prototype.resolve = function resolve4(dir, file) {
       var ext = this.ext;
-      var path3 = join13(dir, file);
+      var path3 = join14(dir, file);
       var stat = tryStat(path3);
       if (stat && stat.isFile()) {
         return path3;
       }
-      path3 = join13(dir, basename3(file, ext), "index" + ext);
+      path3 = join14(dir, basename3(file, ext), "index" + ext);
       stat = tryStat(path3);
       if (stat && stat.isFile()) {
         return path3;
@@ -19099,7 +19099,7 @@ var require_send = __commonJS({
     var Stream = __require("stream");
     var util = __require("util");
     var extname = path2.extname;
-    var join13 = path2.join;
+    var join14 = path2.join;
     var normalize = path2.normalize;
     var resolve3 = path2.resolve;
     var sep = path2.sep;
@@ -19318,7 +19318,7 @@ var require_send = __commonJS({
           return res;
         }
         parts = path3.split(sep);
-        path3 = normalize(join13(root, path3));
+        path3 = normalize(join14(root, path3));
       } else {
         if (UP_PATH_REGEXP.test(path3)) {
           debug('malicious path "%s"', path3);
@@ -19453,7 +19453,7 @@ var require_send = __commonJS({
           if (err) return self.onStatError(err);
           return self.error(404);
         }
-        var p = join13(path3, self._index[i]);
+        var p = join14(path3, self._index[i]);
         debug('stat "%s"', p);
         fs6.stat(p, function(err2, stat) {
           if (err2) return next(err2);
@@ -20592,7 +20592,7 @@ var require_application = __commonJS({
   "../../node_modules/.pnpm/express@4.22.1/node_modules/express/lib/application.js"(exports, module) {
     "use strict";
     var finalhandler = require_finalhandler();
-    var Router11 = require_router();
+    var Router12 = require_router();
     var methods = require_methods();
     var middleware = require_init();
     var query = require_query();
@@ -20657,7 +20657,7 @@ var require_application = __commonJS({
     };
     app2.lazyrouter = function lazyrouter() {
       if (!this._router) {
-        this._router = new Router11({
+        this._router = new Router12({
           caseSensitive: this.enabled("case sensitive routing"),
           strict: this.enabled("strict routing")
         });
@@ -22521,7 +22521,7 @@ var require_express = __commonJS({
     var mixin = require_merge_descriptors();
     var proto = require_application();
     var Route = require_route();
-    var Router11 = require_router();
+    var Router12 = require_router();
     var req = require_request();
     var res = require_response();
     exports = module.exports = createApplication;
@@ -22544,7 +22544,7 @@ var require_express = __commonJS({
     exports.request = req;
     exports.response = res;
     exports.Route = Route;
-    exports.Router = Router11;
+    exports.Router = Router12;
     exports.json = bodyParser.json;
     exports.query = require_query();
     exports.raw = bodyParser.raw;
@@ -23179,10 +23179,10 @@ var init_open = __esm({
 });
 
 // src/server/index.ts
-var import_express11 = __toESM(require_express2(), 1);
+var import_express12 = __toESM(require_express2(), 1);
 import { createServer } from "node:http";
-import { existsSync as existsSync8, readFileSync as readFileSync9, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3 } from "node:fs";
-import { join as join12, dirname as dirname9, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync10, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3 } from "node:fs";
+import { join as join13, dirname as dirname10, resolve as resolve2 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { randomBytes } from "node:crypto";
 import { Server as SocketIOServer } from "socket.io";
@@ -23440,6 +23440,30 @@ var MIGRATIONS = [
       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;
+    `
   }
 ];
 function ensureSchemaVersionTable(db) {
@@ -23984,24 +24008,24 @@ function enrichSession(db, session) {
   let reviewPhaseNumber = 0;
   let reviewPhase = "";
   if (hasReview) {
+    const derived = deriveReviewPhase(db, session.id);
     if (session.workflow_type === "review") {
-      reviewPhaseNumber = session.phase_number;
-      reviewPhase = session.current_phase;
+      reviewPhaseNumber = Math.max(session.phase_number, derived);
     } else {
-      reviewPhaseNumber = deriveReviewPhase(db, session.id);
-      reviewPhase = REVIEW_PHASE_NAMES[reviewPhaseNumber - 1] ?? "context";
+      reviewPhaseNumber = derived;
     }
+    reviewPhase = REVIEW_PHASE_NAMES[reviewPhaseNumber - 1] ?? "context";
   }
   let mapPhaseNumber = 0;
   let mapPhase = "";
   if (hasMap) {
+    const derived = deriveMapPhase(db, session.id);
     if (session.workflow_type === "map") {
-      mapPhaseNumber = session.phase_number;
-      mapPhase = session.current_phase;
+      mapPhaseNumber = Math.max(session.phase_number, derived);
     } else {
-      mapPhaseNumber = deriveMapPhase(db, session.id);
-      mapPhase = MAP_PHASE_NAMES[mapPhaseNumber - 1] ?? "map-context";
+      mapPhaseNumber = derived;
     }
+    mapPhase = MAP_PHASE_NAMES[mapPhaseNumber - 1] ?? "map-context";
   }
   const latestRound = rounds.length > 0 ? rounds[rounds.length - 1] : null;
   const latestVerdict = latestRound?.verdict ?? null;
@@ -25166,11 +25190,37 @@ function resolveLocalCli() {
 }
 
 // src/server/socket/command-runner.ts
+function shellSplit(str) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str[i];
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else {
+        current += ch;
+      }
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (/\s/.test(ch)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += ch;
+    }
+  }
+  if (current) tokens.push(current);
+  return tokens;
+}
 var ALLOWED_COMMANDS = /* @__PURE__ */ new Set([
   "progress",
   "state"
 ]);
-var AI_COMMANDS = /* @__PURE__ */ new Set(["map", "review", "translate-review-to-single-human", "address"]);
+var AI_COMMANDS = /* @__PURE__ */ new Set(["map", "review", "translate-review-to-single-human", "address", "create-reviewer", "sync-reviewers"]);
 var MAX_CONCURRENT = 3;
 var activeCommands = /* @__PURE__ */ new Map();
 function getActiveCommands() {
@@ -25192,7 +25242,7 @@ function registerCommandHandlers(io2, socket, db, ocrDir, aiCliService) {
       }
       const { command } = payload;
       const normalized = command.replace(/^ocr\s+/, "");
-      const parts = normalized.split(/\s+/);
+      const parts = shellSplit(normalized);
       const baseCommand = parts[0] ?? "";
       const subArgs = parts.slice(1);
       if (!ALLOWED_COMMANDS.has(baseCommand) && !AI_COMMANDS.has(baseCommand)) {
@@ -25349,34 +25399,68 @@ function spawnAiCommand(io2, _socket, db, ocrDir, executionId, baseCommand, subA
     finishExecution(io2, db, ocrDir, executionId, 1, content);
     return;
   }
-  let target = "staged changes";
-  let requirements = "";
-  const options = [];
-  let i = 0;
-  while (i < subArgs.length) {
-    const arg = subArgs[i] ?? "";
-    if (arg === "--fresh") {
-      options.push("--fresh");
-      i++;
-    } else if (arg === "--requirements" && i + 1 < subArgs.length) {
-      requirements = subArgs.slice(i + 1).join(" ");
-      break;
-    } else if (!arg.startsWith("--")) {
-      target = arg;
-      i++;
-    } else {
-      i++;
+  const promptLines = [];
+  if (baseCommand === "create-reviewer" || baseCommand === "sync-reviewers") {
+    const argsStr = subArgs.length > 0 ? subArgs.join(" ") : "";
+    promptLines.push(
+      `Follow the instructions below to run the OCR ${baseCommand} workflow.`,
+      "",
+      `Arguments: ${argsStr || "none"}`
+    );
+  } else {
+    let target = "staged changes";
+    let requirements = "";
+    let team = "";
+    const reviewerDescriptions = [];
+    const options = [];
+    let i = 0;
+    while (i < subArgs.length) {
+      const arg = subArgs[i] ?? "";
+      if (arg === "--fresh") {
+        options.push("--fresh");
+        i++;
+      } else if (arg === "--requirements" && i + 1 < subArgs.length) {
+        requirements = subArgs.slice(i + 1).join(" ");
+        break;
+      } else if (arg === "--team" && i + 1 < subArgs.length) {
+        team = subArgs[i + 1] ?? "";
+        i += 2;
+      } else if (arg === "--reviewer" && i + 1 < subArgs.length) {
+        const raw = subArgs[i + 1] ?? "";
+        const countMatch = raw.match(/^(\d+):(.+)$/);
+        if (countMatch) {
+          reviewerDescriptions.push({ description: countMatch[2], count: parseInt(countMatch[1], 10) });
+        } else {
+          reviewerDescriptions.push({ description: raw, count: 1 });
+        }
+        i += 2;
+      } else if (!arg.startsWith("--")) {
+        target = arg;
+        i++;
+      } else {
+        i++;
+      }
+    }
+    const optionsStr = options.length > 0 ? options.join(" ") : "none";
+    promptLines.push(
+      `Follow the instructions below to run the OCR ${baseCommand} workflow.`,
+      "",
+      `Target: ${target}`,
+      `Options: ${optionsStr}`
+    );
+    if (team) {
+      promptLines.push(`Team: ${team}`);
+    }
+    for (const { description, count } of reviewerDescriptions) {
+      if (count > 1) {
+        promptLines.push(`Reviewer (x${count}): ${description}`);
+      } else {
+        promptLines.push(`Reviewer: ${description}`);
+      }
+    }
+    if (requirements) {
+      promptLines.push(`Requirements: ${requirements}`);
     }
-  }
-  const optionsStr = options.length > 0 ? options.join(" ") : "none";
-  const promptLines = [
-    `Follow the instructions below to run the OCR ${baseCommand} workflow.`,
-    "",
-    `Target: ${target}`,
-    `Options: ${optionsStr}`
-  ];
-  if (requirements) {
-    promptLines.push(`Requirements: ${requirements}`);
   }
   const localCli = resolveLocalCli();
   if (localCli) {
@@ -25744,10 +25828,77 @@ function createChatRouter(db, ocrDir) {
   return router;
 }
 
+// src/server/routes/reviewers.ts
+var import_express11 = __toESM(require_express2(), 1);
+import { readFileSync as readFileSync5, existsSync as existsSync4, watch } from "node:fs";
+import { join as join9 } from "node:path";
+function readReviewersMeta(ocrDir) {
+  const metaPath = join9(ocrDir, "reviewers-meta.json");
+  if (!existsSync4(metaPath)) {
+    return { reviewers: [], defaults: [] };
+  }
+  try {
+    const raw = readFileSync5(metaPath, "utf-8");
+    const meta = JSON.parse(raw);
+    const reviewers = meta.reviewers ?? [];
+    const defaults = reviewers.filter((r) => r.is_default).map((r) => r.id);
+    return { reviewers, defaults };
+  } catch {
+    return { reviewers: [], defaults: [] };
+  }
+}
+var VALID_ID_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function createReviewersRouter(ocrDir) {
+  const router = (0, import_express11.Router)();
+  router.get("/", (_req, res) => {
+    res.json(readReviewersMeta(ocrDir));
+  });
+  router.get("/:id/prompt", (req, res) => {
+    const { id } = req.params;
+    if (!id || !VALID_ID_RE.test(id)) {
+      res.status(400).json({ error: "Invalid reviewer ID" });
+      return;
+    }
+    const filePath = join9(ocrDir, "skills", "references", "reviewers", `${id}.md`);
+    if (!existsSync4(filePath)) {
+      res.status(404).json({ error: "Reviewer not found", id });
+      return;
+    }
+    try {
+      const content = readFileSync5(filePath, "utf-8");
+      res.json({ id, content });
+    } catch {
+      res.status(500).json({ error: "Failed to read reviewer file", id });
+    }
+  });
+  return router;
+}
+function watchReviewersMeta(ocrDir, io2) {
+  const metaPath = join9(ocrDir, "reviewers-meta.json");
+  let watcher = null;
+  let debounce;
+  try {
+    watcher = watch(metaPath, () => {
+      clearTimeout(debounce);
+      debounce = setTimeout(() => {
+        const data = readReviewersMeta(ocrDir);
+        io2.emit("reviewers:updated", data);
+      }, 200);
+    });
+    watcher.on("error", () => {
+    });
+  } catch {
+  }
+  return () => {
+    clearTimeout(debounce);
+    watcher?.close();
+  };
+}
+
 // src/server/services/filesystem-sync.ts
-import { readdirSync, readFileSync as readFileSync5, statSync, existsSync as existsSync4 } from "node:fs";
-import { join as join9, basename as basename2, relative } from "node:path";
-import { watch } from "chokidar";
+import { readdirSync, readFileSync as readFileSync6, statSync, existsSync as existsSync5 } from "node:fs";
+import { join as join10, basename as basename2, dirname as dirname7, relative } from "node:path";
+import { watch as watch2 } from "chokidar";
 
 // src/server/services/parsers/reviewer-parser.ts
 var FINDING_HEADING_RE = /^#{2,3}\s+(?:Finding|Issue|Suggestion)\s*(?:\d+)?\s*[:\s]*\s*(.*)/i;
@@ -25838,9 +25989,9 @@ function finalizeFinding(partial, summaryLines) {
 
 // src/server/services/parsers/final-parser.ts
 var VERDICT_RE = /^\*?\*?\s*(?:##\s*)?Verdict\s*\*?\*?\s*:?\s*\*?\*?\s*(.*)/im;
-var BLOCKERS_RE = /\*?\*?Blockers?\*?\*?\s*:?\s*(\d+)/i;
-var SHOULD_FIX_RE = /\*?\*?Should\s*Fix\*?\*?\s*:?\s*(\d+)/i;
-var SUGGESTIONS_RE = /\*?\*?Suggestions?\*?\*?\s*:?\s*(\d+)/i;
+var BLOCKERS_RE = /^\*\*Blockers?\*\*\s*:?\s*(\d+)/im;
+var SHOULD_FIX_RE = /^\*\*Should\s*Fix\*\*\s*:?\s*(\d+)/im;
+var SUGGESTIONS_RE = /^\*\*Suggestions?\*\*\s*:?\s*(\d+)/im;
 function parseFinalMd(content) {
   let verdict = null;
   const verdictMatch = content.match(VERDICT_RE);
@@ -25854,25 +26005,39 @@ function parseFinalMd(content) {
   let shouldFixCount = shouldFixMatch ? parseInt(shouldFixMatch[1] ?? "0", 10) : 0;
   let suggestionCount = suggestionsMatch ? parseInt(suggestionsMatch[1] ?? "0", 10) : 0;
   if (!blockerMatch) {
-    blockerCount = countSectionHeaders(content, /^##\s+Blockers?\b/im);
+    blockerCount = countSectionItems(content, /^##\s+Blockers?\b/im);
   }
   if (!shouldFixMatch) {
-    shouldFixCount = countSectionHeaders(content, /^##\s+Should\s*Fix\b/im);
+    shouldFixCount = countSectionItems(content, /^##\s+Should\s*Fix\b/im);
   }
   if (!suggestionsMatch) {
-    suggestionCount = countSectionHeaders(content, /^##\s+Suggestions?\b/im);
+    suggestionCount = countSectionItems(content, /^##\s+Suggestions?\b/im);
   }
   return { verdict, blockerCount, shouldFixCount, suggestionCount };
 }
-function countSectionHeaders(content, sectionRe) {
+function countSectionItems(content, sectionRe) {
   const match = content.match(sectionRe);
-  if (!match?.index) return 0;
+  if (!match?.index && match?.index !== 0) return 0;
   const afterSection = content.slice(match.index + (match[0]?.length ?? 0));
   const lines = afterSection.split("\n");
   let count = 0;
   for (const line of lines) {
-    if (line.match(/^##\s+[^#]/) && !line.match(/^###/)) break;
-    if (line.match(/^###\s+\d+\./)) count++;
+    const trimmed = line.trim();
+    if (/^##\s+[^#]/.test(trimmed)) break;
+    if (/^---+\s*$/.test(trimmed)) break;
+    if (/^###\s+\d+\./.test(trimmed)) {
+      count++;
+      continue;
+    }
+    if (/^###\s+[^\w\s#]/.test(trimmed)) {
+      count++;
+      continue;
+    }
+    if (/^-\s+\S/.test(trimmed)) {
+      if (/^-\s+(?:none\b|no\s|n\/a\b)/i.test(trimmed)) continue;
+      count++;
+      continue;
+    }
   }
   return count;
 }
@@ -25913,60 +26078,68 @@ var FilesystemSync = class {
   debounceTimers = /* @__PURE__ */ new Map();
   onSync;
   // ── 6.1: Full Scan ──
-  fullScan() {
-    if (!existsSync4(this.sessionsDir)) return;
+  async fullScan() {
+    if (!existsSync5(this.sessionsDir)) return;
     const entries = readdirSync(this.sessionsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const sessionId = entry.name;
-      const sessionDir = join9(this.sessionsDir, sessionId);
+      const sessionDir = join10(this.sessionsDir, sessionId);
       this.syncSession(sessionId, sessionDir);
     }
   }
   syncSession(sessionId, sessionDir) {
     this.ensureSessionRow(sessionId, sessionDir);
-    const roundsDir = join9(sessionDir, "rounds");
-    if (existsSync4(roundsDir)) {
+    const roundsDir = join10(sessionDir, "rounds");
+    if (existsSync5(roundsDir)) {
       const rounds = readdirSync(roundsDir, { withFileTypes: true });
       for (const roundEntry of rounds) {
         if (!roundEntry.isDirectory()) continue;
         const roundMatch = roundEntry.name.match(/^round-(\d+)$/);
         if (!roundMatch) continue;
         const roundNumber = parseInt(roundMatch[1] ?? "0", 10);
-        const roundDir = join9(roundsDir, roundEntry.name);
-        const reviewsDir = join9(roundDir, "reviews");
-        if (existsSync4(reviewsDir)) {
+        const roundDir = join10(roundsDir, roundEntry.name);
+        const reviewsDir = join10(roundDir, "reviews");
+        if (existsSync5(reviewsDir)) {
           const reviewFiles = readdirSync(reviewsDir).filter((f) => f.endsWith(".md"));
           for (const reviewFile of reviewFiles) {
-            const filePath = join9(reviewsDir, reviewFile);
+            const filePath = join10(reviewsDir, reviewFile);
             this.processReviewerOutput(sessionId, roundNumber, filePath, reviewFile);
           }
         }
-        const finalPath = join9(roundDir, "final.md");
-        if (existsSync4(finalPath)) {
+        const roundMetaPath = join10(roundDir, "round-meta.json");
+        if (existsSync5(roundMetaPath)) {
+          this.processRoundMeta(sessionId, roundNumber, roundMetaPath);
+        }
+        const finalPath = join10(roundDir, "final.md");
+        if (existsSync5(finalPath)) {
           this.processFinalMd(sessionId, roundNumber, finalPath);
         }
-        const finalHumanPath = join9(roundDir, "final-human.md");
-        if (existsSync4(finalHumanPath)) {
+        const finalHumanPath = join10(roundDir, "final-human.md");
+        if (existsSync5(finalHumanPath)) {
           this.processGenericArtifact(sessionId, "final-human", finalHumanPath, roundNumber);
         }
-        const discoursePath = join9(roundDir, "discourse.md");
-        if (existsSync4(discoursePath)) {
+        const discoursePath = join10(roundDir, "discourse.md");
+        if (existsSync5(discoursePath)) {
           this.processGenericArtifact(sessionId, "discourse", discoursePath, roundNumber);
         }
       }
     }
-    const mapDir = join9(sessionDir, "map", "runs");
-    if (existsSync4(mapDir)) {
+    const mapDir = join10(sessionDir, "map", "runs");
+    if (existsSync5(mapDir)) {
       const runs = readdirSync(mapDir, { withFileTypes: true });
       for (const runEntry of runs) {
         if (!runEntry.isDirectory()) continue;
         const runMatch = runEntry.name.match(/^run-(\d+)$/);
         if (!runMatch) continue;
         const runNumber = parseInt(runMatch[1] ?? "0", 10);
-        const runDir = join9(mapDir, runEntry.name);
-        const mapPath = join9(runDir, "map.md");
-        if (existsSync4(mapPath)) {
+        const runDir = join10(mapDir, runEntry.name);
+        const mapMetaPath = join10(runDir, "map-meta.json");
+        if (existsSync5(mapMetaPath)) {
+          this.processMapMeta(sessionId, runNumber, mapMetaPath);
+        }
+        const mapPath = join10(runDir, "map.md");
+        if (existsSync5(mapPath)) {
           this.processMapMd(sessionId, runNumber, mapPath);
         }
         const mapArtifacts = [
@@ -25975,8 +26148,8 @@ var FilesystemSync = class {
           ["requirements-mapping.md", "requirements-mapping"]
         ];
         for (const [fileName, artifactType] of mapArtifacts) {
-          const filePath = join9(runDir, fileName);
-          if (existsSync4(filePath)) {
+          const filePath = join10(runDir, fileName);
+          if (existsSync5(filePath)) {
             this.processGenericArtifact(sessionId, artifactType, filePath, void 0, runNumber);
           }
         }
@@ -25987,8 +26160,8 @@ var FilesystemSync = class {
       ["discovered-standards.md", "discovered-standards"]
     ];
     for (const [fileName, artifactType] of sessionArtifacts) {
-      const filePath = join9(sessionDir, fileName);
-      if (existsSync4(filePath)) {
+      const filePath = join10(sessionDir, fileName);
+      if (existsSync5(filePath)) {
         this.processGenericArtifact(sessionId, artifactType, filePath);
       }
     }
@@ -25997,17 +26170,17 @@ var FilesystemSync = class {
   ensureSessionRow(sessionId, sessionDir) {
     const branchMatch = sessionId.match(/^\d{4}-\d{2}-\d{2}-(.+)$/);
     const branch = branchMatch?.[1] ?? "unknown";
-    const hasRoundsDir = existsSync4(join9(sessionDir, "rounds"));
-    const hasMapDir = existsSync4(join9(sessionDir, "map"));
+    const hasRoundsDir = existsSync5(join10(sessionDir, "rounds"));
+    const hasMapDir = existsSync5(join10(sessionDir, "map"));
     const workflowType = hasMapDir && !hasRoundsDir ? "map" : "review";
     let currentRound = 1;
     if (hasRoundsDir) {
-      const roundDirs = readdirSync(join9(sessionDir, "rounds")).filter((d) => d.match(/^round-\d+$/));
+      const roundDirs = readdirSync(join10(sessionDir, "rounds")).filter((d) => d.match(/^round-\d+$/));
       currentRound = Math.max(1, roundDirs.length);
     }
     let currentMapRun = 1;
-    const mapRunsDir = join9(sessionDir, "map", "runs");
-    if (existsSync4(mapRunsDir)) {
+    const mapRunsDir = join10(sessionDir, "map", "runs");
+    if (existsSync5(mapRunsDir)) {
       const runDirs = readdirSync(mapRunsDir).filter((d) => d.match(/^run-\d+$/));
       currentMapRun = Math.max(1, runDirs.length);
     }
@@ -26015,40 +26188,40 @@ var FilesystemSync = class {
     let phaseNumber = 1;
     let status = "active";
     if (workflowType === "review" && hasRoundsDir) {
-      const roundDir = join9(sessionDir, "rounds", `round-${currentRound}`);
-      if (existsSync4(join9(roundDir, "final.md"))) {
+      const roundDir = join10(sessionDir, "rounds", `round-${currentRound}`);
+      if (existsSync5(join10(roundDir, "final.md"))) {
         phase = "complete";
         phaseNumber = 8;
         status = "closed";
-      } else if (existsSync4(join9(roundDir, "discourse.md"))) {
+      } else if (existsSync5(join10(roundDir, "discourse.md"))) {
         phase = "synthesis";
         phaseNumber = 7;
-      } else if (existsSync4(join9(roundDir, "reviews")) && readdirSync(join9(roundDir, "reviews")).filter((f) => f.endsWith(".md")).length > 0) {
+      } else if (existsSync5(join10(roundDir, "reviews")) && readdirSync(join10(roundDir, "reviews")).filter((f) => f.endsWith(".md")).length > 0) {
         phase = "reviews";
         phaseNumber = 4;
-      } else if (existsSync4(join9(sessionDir, "context.md"))) {
+      } else if (existsSync5(join10(sessionDir, "context.md"))) {
         phase = "analysis";
         phaseNumber = 3;
-      } else if (existsSync4(join9(sessionDir, "discovered-standards.md"))) {
+      } else if (existsSync5(join10(sessionDir, "discovered-standards.md"))) {
         phase = "change-context";
         phaseNumber = 2;
       }
     } else if (workflowType === "map" && hasMapDir) {
-      const runDir = join9(mapRunsDir, `run-${currentMapRun}`);
-      if (existsSync4(join9(runDir, "map.md"))) {
+      const runDir = join10(mapRunsDir, `run-${currentMapRun}`);
+      if (existsSync5(join10(runDir, "map.md"))) {
         phase = "complete";
         phaseNumber = 6;
         status = "closed";
-      } else if (existsSync4(join9(runDir, "requirements-mapping.md"))) {
+      } else if (existsSync5(join10(runDir, "requirements-mapping.md"))) {
         phase = "synthesis";
         phaseNumber = 5;
-      } else if (existsSync4(join9(runDir, "flow-analysis.md"))) {
+      } else if (existsSync5(join10(runDir, "flow-analysis.md"))) {
         phase = "requirements-mapping";
         phaseNumber = 4;
-      } else if (existsSync4(join9(runDir, "topology.md"))) {
+      } else if (existsSync5(join10(runDir, "topology.md"))) {
         phase = "flow-analysis";
         phaseNumber = 3;
-      } else if (existsSync4(join9(sessionDir, "discovered-standards.md"))) {
+      } else if (existsSync5(join10(sessionDir, "discovered-standards.md"))) {
         phase = "topology";
         phaseNumber = 2;
       }
@@ -26106,15 +26279,21 @@ var FilesystemSync = class {
   processMapMd(sessionId, runNumber, filePath) {
     const existingRun = queryFirst(
       this.db,
-      "SELECT id, parsed_at FROM map_runs WHERE session_id = ? AND run_number = ?",
+      "SELECT id, parsed_at, source FROM map_runs WHERE session_id = ? AND run_number = ?",
       [sessionId, runNumber]
     );
     if (existingRun && this.shouldSkip(filePath, existingRun["parsed_at"] ?? null)) return;
-    const content = readFileSync5(filePath, "utf-8");
+    if (existingRun?.["source"] === "orchestrator") {
+      const content2 = readFileSync6(filePath, "utf-8");
+      const action2 = this.upsertMarkdownArtifact(sessionId, "map", filePath, content2, void 0);
+      this.emitArtifactEvent(action2, { sessionId, artifactType: "map", filePath });
+      return;
+    }
+    const content = readFileSync6(filePath, "utf-8");
     const parsed = parseMapMd(content);
     this.db.run(
-      `INSERT OR REPLACE INTO map_runs (session_id, run_number, file_count, map_md_path, parsed_at)
-       VALUES (?, ?, ?, ?, ?)`,
+      `INSERT OR REPLACE INTO map_runs (session_id, run_number, file_count, map_md_path, parsed_at, source)
+       VALUES (?, ?, ?, ?, ?, 'parser')`,
       [sessionId, runNumber, parsed.sections.reduce((sum, s) => sum + s.files.length, 0), filePath, sqlNow()]
     );
     const runRow = queryFirst(
@@ -26192,10 +26371,10 @@ var FilesystemSync = class {
     }
     const session = queryFirst(
       this.db,
-      "SELECT current_phase, workflow_type FROM sessions WHERE id = ?",
+      "SELECT current_phase, phase_number, workflow_type FROM sessions WHERE id = ?",
       [sessionId]
     );
-    if (session && session["workflow_type"] === "map" && session["current_phase"] !== "complete") {
+    if (session && session["workflow_type"] === "map" && (session["current_phase"] !== "complete" || session["phase_number"] < 6)) {
       this.db.run(
         `UPDATE sessions SET current_phase = 'complete', phase_number = 6, status = 'closed', updated_at = datetime('now')
          WHERE id = ?`,
@@ -26224,11 +26403,22 @@ var FilesystemSync = class {
     );
     const roundRow = queryFirst(
       this.db,
-      "SELECT id FROM review_rounds WHERE session_id = ? AND round_number = ?",
+      "SELECT id, source FROM review_rounds WHERE session_id = ? AND round_number = ?",
       [sessionId, roundNumber]
     );
     const roundId = roundRow?.["id"];
     if (!roundId) return;
+    if (roundRow?.["source"] === "orchestrator") {
+      const content2 = readFileSync6(filePath, "utf-8");
+      const action2 = this.upsertMarkdownArtifact(sessionId, "reviewer-output", filePath, content2, roundNumber);
+      this.emitArtifactEvent(action2, {
+        sessionId,
+        artifactType: "reviewer-output",
+        roundNumber,
+        filePath
+      });
+      return;
+    }
     const nameMatch = fileName.replace(/\.md$/, "").match(/^(.+?)-(\d+)$/);
     const reviewerType = nameMatch?.[1] ?? fileName.replace(/\.md$/, "");
     const instanceNumber = nameMatch?.[2] ? parseInt(nameMatch[2], 10) : 1;
@@ -26238,7 +26428,7 @@ var FilesystemSync = class {
       [roundId, reviewerType, instanceNumber]
     );
     if (existingOutput && this.shouldSkip(filePath, existingOutput["parsed_at"] ?? null)) return;
-    const content = readFileSync5(filePath, "utf-8");
+    const content = readFileSync6(filePath, "utf-8");
     const parsed = parseReviewerOutput(content);
     this.db.run(
       `INSERT OR REPLACE INTO reviewer_outputs (round_id, reviewer_type, instance_number, file_path, finding_count, parsed_at)
@@ -26311,8 +26501,8 @@ var FilesystemSync = class {
       filePath
     });
   }
-  // ── 6.4: Final.md Integration ──
-  processFinalMd(sessionId, roundNumber, filePath) {
+  // ── 6.3b: Round Meta (Orchestrator-First) ──
+  processRoundMeta(sessionId, roundNumber, filePath) {
     this.db.run(
       `INSERT OR IGNORE INTO review_rounds (session_id, round_number)
        VALUES (?, ?)`,
@@ -26320,46 +26510,332 @@ var FilesystemSync = class {
     );
     const existingRound = queryFirst(
       this.db,
-      "SELECT parsed_at FROM review_rounds WHERE session_id = ? AND round_number = ?",
+      "SELECT parsed_at, source FROM review_rounds WHERE session_id = ? AND round_number = ?",
       [sessionId, roundNumber]
     );
-    if (existingRound && this.shouldSkip(filePath, existingRound["parsed_at"] ?? null)) return;
-    const content = readFileSync5(filePath, "utf-8");
-    const parsed = parseFinalMd(content);
+    if (existingRound?.["source"] === "orchestrator" && this.shouldSkip(filePath, existingRound["parsed_at"] ?? null)) return;
+    let raw;
+    try {
+      raw = JSON.parse(readFileSync6(filePath, "utf-8"));
+    } catch {
+      console.error(`[FilesystemSync] Failed to parse ${filePath}`);
+      return;
+    }
+    const meta = raw;
+    if (meta.schema_version !== 1 || !meta.verdict || !Array.isArray(meta.reviewers)) {
+      console.error(`[FilesystemSync] Invalid round-meta.json at ${filePath}`);
+      return;
+    }
+    const allFindings = meta.reviewers.flatMap((r) => r.findings ?? []);
+    const blockerCount = allFindings.filter((f) => f.category === "blocker").length;
+    const shouldFixCount = allFindings.filter((f) => f.category === "should_fix").length;
+    const suggestionCount = allFindings.filter((f) => f.category === "suggestion").length;
+    const reviewerCount = meta.reviewers.length;
+    const totalFindingCount = allFindings.length;
+    this.db.run("BEGIN TRANSACTION");
+    try {
+      this.db.run(
+        `UPDATE review_rounds
+         SET verdict = ?, blocker_count = ?, suggestion_count = ?, should_fix_count = ?,
+             reviewer_count = ?, total_finding_count = ?, source = 'orchestrator', parsed_at = ?
+         WHERE session_id = ? AND round_number = ?`,
+        [
+          meta.verdict,
+          blockerCount,
+          suggestionCount,
+          shouldFixCount,
+          reviewerCount,
+          totalFindingCount,
+          sqlNow(),
+          sessionId,
+          roundNumber
+        ]
+      );
+      const roundRow = queryFirst(
+        this.db,
+        "SELECT id FROM review_rounds WHERE session_id = ? AND round_number = ?",
+        [sessionId, roundNumber]
+      );
+      const roundId = roundRow?.["id"];
+      if (!roundId) {
+        this.db.run("COMMIT");
+        return;
+      }
+      const roundDir = dirname7(filePath);
+      for (const reviewer of meta.reviewers) {
+        const reviewerType = reviewer.type ?? "unknown";
+        const instanceNumber = reviewer.instance ?? 1;
+        const findings = reviewer.findings ?? [];
+        const reviewerMdPath = join10(roundDir, "reviews", `${reviewerType}-${instanceNumber}.md`);
+        this.db.run(
+          `INSERT OR REPLACE INTO reviewer_outputs (round_id, reviewer_type, instance_number, file_path, finding_count, parsed_at)
+           VALUES (?, ?, ?, ?, ?, ?)`,
+          [roundId, reviewerType, instanceNumber, reviewerMdPath, findings.length, sqlNow()]
+        );
+        const outputRow = queryFirst(
+          this.db,
+          "SELECT id FROM reviewer_outputs WHERE round_id = ? AND reviewer_type = ? AND instance_number = ?",
+          [roundId, reviewerType, instanceNumber]
+        );
+        const outputId = outputRow?.["id"];
+        if (!outputId) continue;
+        const stashedFindingProgress = /* @__PURE__ */ new Map();
+        const findingProgressResult = this.db.exec(
+          `SELECT rf.title, rf.severity, rf.file_path, ufp.status, ufp.updated_at
+           FROM user_finding_progress ufp
+           JOIN review_findings rf ON rf.id = ufp.finding_id
+           WHERE rf.reviewer_output_id = ?`,
+          [outputId]
+        );
+        if (findingProgressResult[0]) {
+          for (const row of findingProgressResult[0].values) {
+            const key = `${row[0]}|${row[1]}|${row[2]}`;
+            stashedFindingProgress.set(key, {
+              status: row[3],
+              updatedAt: row[4]
+            });
+          }
+        }
+        this.db.run("DELETE FROM review_findings WHERE reviewer_output_id = ?", [outputId]);
+        for (const finding of findings) {
+          this.db.run(
+            `INSERT INTO review_findings (reviewer_output_id, title, severity, file_path, line_start, line_end, summary, is_blocker, parsed_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            [
+              outputId,
+              finding.title ?? "",
+              finding.severity ?? "info",
+              finding.file_path ?? null,
+              finding.line_start ?? null,
+              finding.line_end ?? null,
+              finding.summary ?? null,
+              finding.category === "blocker" ? 1 : 0,
+              sqlNow()
+            ]
+          );
+          const key = `${finding.title ?? ""}|${finding.severity ?? "info"}|${finding.file_path ?? ""}`;
+          const stashed = stashedFindingProgress.get(key);
+          if (stashed) {
+            const newFindingRow = queryFirst(
+              this.db,
+              "SELECT id FROM review_findings WHERE reviewer_output_id = ? AND title = ? AND severity = ? AND file_path IS ?",
+              [outputId, finding.title ?? "", finding.severity ?? "info", finding.file_path ?? null]
+            );
+            if (newFindingRow) {
+              this.db.run(
+                `INSERT OR REPLACE INTO user_finding_progress (finding_id, status, updated_at)
+                 VALUES (?, ?, ?)`,
+                [newFindingRow["id"], stashed.status, stashed.updatedAt]
+              );
+            }
+          }
+        }
+      }
+      this.db.run("COMMIT");
+    } catch (err) {
+      this.db.run("ROLLBACK");
+      console.error(`[FilesystemSync] Error in processRoundMeta for ${filePath}:`, err);
+      return;
+    }
+    this.io?.to(`session:${sessionId}`).emit("round:updated", {
+      sessionId,
+      roundNumber,
+      verdict: meta.verdict,
+      blockerCount,
+      shouldFixCount,
+      suggestionCount,
+      reviewerCount,
+      totalFindingCount,
+      source: "orchestrator"
+    });
+  }
+  // ── 6.2b: Map-meta.json Integration ──
+  processMapMeta(sessionId, runNumber, filePath) {
     this.db.run(
-      `UPDATE review_rounds SET verdict = ?, blocker_count = ?, suggestion_count = ?, should_fix_count = ?, final_md_path = ?, parsed_at = ?
-       WHERE session_id = ? AND round_number = ?`,
-      [
-        parsed.verdict,
-        parsed.blockerCount,
-        parsed.suggestionCount,
-        parsed.shouldFixCount,
-        filePath,
-        sqlNow(),
-        sessionId,
-        roundNumber
-      ]
+      `INSERT OR IGNORE INTO map_runs (session_id, run_number)
+       VALUES (?, ?)`,
+      [sessionId, runNumber]
     );
-    const actualBlockers = queryScalar(
+    const existingRun = queryFirst(
       this.db,
-      `SELECT COUNT(*) FROM review_findings rf
-       JOIN reviewer_outputs ro ON rf.reviewer_output_id = ro.id
-       WHERE ro.round_id = (SELECT id FROM review_rounds WHERE session_id = ? AND round_number = ?)
-         AND rf.is_blocker = 1`,
+      "SELECT id, parsed_at, source FROM map_runs WHERE session_id = ? AND run_number = ?",
+      [sessionId, runNumber]
+    );
+    if (existingRun?.["source"] === "orchestrator" && this.shouldSkip(filePath, existingRun["parsed_at"] ?? null)) return;
+    let raw;
+    try {
+      raw = JSON.parse(readFileSync6(filePath, "utf-8"));
+    } catch {
+      console.error(`[FilesystemSync] Failed to parse ${filePath}`);
+      return;
+    }
+    const meta = raw;
+    if (meta.schema_version !== 1 || !Array.isArray(meta.sections)) {
+      console.error(`[FilesystemSync] Invalid map-meta.json at ${filePath}`);
+      return;
+    }
+    const sectionCount = meta.sections.length;
+    const fileCount = meta.sections.reduce((sum, s) => sum + (s.files?.length ?? 0), 0);
+    this.db.run("BEGIN TRANSACTION");
+    try {
+      this.db.run(
+        `UPDATE map_runs
+         SET file_count = ?, section_count = ?, source = 'orchestrator', parsed_at = ?
+         WHERE session_id = ? AND run_number = ?`,
+        [fileCount, sectionCount, sqlNow(), sessionId, runNumber]
+      );
+      const runRow = queryFirst(
+        this.db,
+        "SELECT id FROM map_runs WHERE session_id = ? AND run_number = ?",
+        [sessionId, runNumber]
+      );
+      const mapRunId = runRow?.["id"];
+      if (!mapRunId) {
+        this.db.run("COMMIT");
+        return;
+      }
+      const stashedFileProgress = /* @__PURE__ */ new Map();
+      const progressResult = this.db.exec(
+        `SELECT mf.file_path, ufp.is_reviewed, ufp.reviewed_at
+         FROM user_file_progress ufp
+         JOIN map_files mf ON mf.id = ufp.map_file_id
+         JOIN map_sections ms ON ms.id = mf.section_id
+         WHERE ms.map_run_id = ?`,
+        [mapRunId]
+      );
+      if (progressResult[0]) {
+        for (const row of progressResult[0].values) {
+          const fp = row[0];
+          stashedFileProgress.set(fp, {
+            isReviewed: row[1],
+            reviewedAt: row[2]
+          });
+        }
+      }
+      const oldSections = this.db.exec(
+        "SELECT id FROM map_sections WHERE map_run_id = ?",
+        [mapRunId]
+      );
+      if (oldSections[0]) {
+        for (const row of oldSections[0].values) {
+          this.db.run("DELETE FROM map_files WHERE section_id = ?", [row[0]]);
+        }
+      }
+      this.db.run("DELETE FROM map_sections WHERE map_run_id = ?", [mapRunId]);
+      for (const section of meta.sections) {
+        const sectionNumber = section.section_number ?? 0;
+        const title = section.title ?? "Untitled";
+        const description = section.description ?? null;
+        const files = section.files ?? [];
+        this.db.run(
+          `INSERT OR REPLACE INTO map_sections (map_run_id, section_number, title, description, file_count, display_order)
+           VALUES (?, ?, ?, ?, ?, ?)`,
+          [mapRunId, sectionNumber, title, description, files.length, sectionNumber]
+        );
+        const sectionRow = queryFirst(
+          this.db,
+          "SELECT id FROM map_sections WHERE map_run_id = ? AND section_number = ?",
+          [mapRunId, sectionNumber]
+        );
+        const sectionId = sectionRow?.["id"];
+        if (!sectionId) continue;
+        for (let fi = 0; fi < files.length; fi++) {
+          const file = files[fi];
+          if (!file) continue;
+          this.db.run(
+            `INSERT OR REPLACE INTO map_files (section_id, file_path, role, lines_added, lines_deleted, display_order)
+             VALUES (?, ?, ?, ?, ?, ?)`,
+            [sectionId, file.file_path ?? "", file.role ?? null, file.lines_added ?? 0, file.lines_deleted ?? 0, fi]
+          );
+          const stashed = stashedFileProgress.get(file.file_path ?? "");
+          if (stashed) {
+            const newFileRow = queryFirst(
+              this.db,
+              "SELECT id FROM map_files WHERE section_id = ? AND file_path = ?",
+              [sectionId, file.file_path ?? ""]
+            );
+            if (newFileRow) {
+              this.db.run(
+                `INSERT OR REPLACE INTO user_file_progress (map_file_id, is_reviewed, reviewed_at)
+                 VALUES (?, ?, ?)`,
+                [newFileRow["id"], stashed.isReviewed, stashed.reviewedAt]
+              );
+            }
+          }
+        }
+      }
+      this.db.run("COMMIT");
+    } catch (err) {
+      this.db.run("ROLLBACK");
+      console.error(`[FilesystemSync] Error in processMapMeta for ${filePath}:`, err);
+      return;
+    }
+    this.io?.to(`session:${sessionId}`).emit("map:updated", {
+      sessionId,
+      runNumber,
+      fileCount,
+      sectionCount,
+      source: "orchestrator"
+    });
+  }
+  // ── 6.4: Final.md Integration ──
+  processFinalMd(sessionId, roundNumber, filePath) {
+    this.db.run(
+      `INSERT OR IGNORE INTO review_rounds (session_id, round_number)
+       VALUES (?, ?)`,
+      [sessionId, roundNumber]
+    );
+    const existingRound = queryFirst(
+      this.db,
+      "SELECT parsed_at, source FROM review_rounds WHERE session_id = ? AND round_number = ?",
       [sessionId, roundNumber]
     );
-    if (actualBlockers !== null && actualBlockers !== parsed.blockerCount) {
+    const isOrchestratorSource = existingRound?.["source"] === "orchestrator";
+    if (!isOrchestratorSource && existingRound && this.shouldSkip(filePath, existingRound["parsed_at"] ?? null)) return;
+    const content = readFileSync6(filePath, "utf-8");
+    if (isOrchestratorSource) {
       this.db.run(
-        "UPDATE review_rounds SET blocker_count = ? WHERE session_id = ? AND round_number = ?",
-        [actualBlockers, sessionId, roundNumber]
+        `UPDATE review_rounds SET final_md_path = ?, parsed_at = ?
+         WHERE session_id = ? AND round_number = ?`,
+        [filePath, sqlNow(), sessionId, roundNumber]
+      );
+    } else {
+      const parsed = parseFinalMd(content);
+      this.db.run(
+        `UPDATE review_rounds SET verdict = ?, blocker_count = ?, suggestion_count = ?, should_fix_count = ?, final_md_path = ?, parsed_at = ?, source = 'parser'
+         WHERE session_id = ? AND round_number = ?`,
+        [
+          parsed.verdict,
+          parsed.blockerCount,
+          parsed.suggestionCount,
+          parsed.shouldFixCount,
+          filePath,
+          sqlNow(),
+          sessionId,
+          roundNumber
+        ]
+      );
+      const actualBlockers = queryScalar(
+        this.db,
+        `SELECT COUNT(*) FROM review_findings rf
+         JOIN reviewer_outputs ro ON rf.reviewer_output_id = ro.id
+         WHERE ro.round_id = (SELECT id FROM review_rounds WHERE session_id = ? AND round_number = ?)
+           AND rf.is_blocker = 1`,
+        [sessionId, roundNumber]
       );
+      if (actualBlockers !== null && actualBlockers !== parsed.blockerCount) {
+        this.db.run(
+          "UPDATE review_rounds SET blocker_count = ? WHERE session_id = ? AND round_number = ?",
+          [actualBlockers, sessionId, roundNumber]
+        );
+      }
     }
     const session = queryFirst(
       this.db,
       "SELECT current_phase, phase_number, status FROM sessions WHERE id = ?",
       [sessionId]
     );
-    if (session && session["current_phase"] !== "complete") {
+    if (session && (session["current_phase"] !== "complete" || session["phase_number"] < 8)) {
       this.db.run(
         `UPDATE sessions SET current_phase = 'complete', phase_number = 8, status = 'closed', updated_at = datetime('now')
          WHERE id = ?`,
@@ -26389,7 +26865,7 @@ var FilesystemSync = class {
       [sessionId, artifactType, relPath]
     );
     if (existing && this.shouldSkip(filePath, existing["parsed_at"] ?? null)) return;
-    const content = readFileSync5(filePath, "utf-8");
+    const content = readFileSync6(filePath, "utf-8");
     const action = this.upsertMarkdownArtifact(sessionId, artifactType, filePath, content, roundNumber);
     this.emitArtifactEvent(action, {
       sessionId,
@@ -26401,7 +26877,7 @@ var FilesystemSync = class {
   // ── 6.6: Chokidar Watcher ──
   startWatching() {
     if (this.watcher) return;
-    this.watcher = watch(this.sessionsDir, {
+    this.watcher = watch2(this.sessionsDir, {
       persistent: true,
       ignoreInitial: true,
       depth: 10,
@@ -26427,7 +26903,7 @@ var FilesystemSync = class {
     this.debounceTimers.clear();
   }
   handleFileChange(filePath) {
-    if (!filePath.endsWith(".md")) return;
+    if (!filePath.endsWith(".md") && !filePath.endsWith(".json")) return;
     const existing = this.debounceTimers.get(filePath);
     if (existing) clearTimeout(existing);
     this.debounceTimers.set(
@@ -26448,7 +26924,7 @@ var FilesystemSync = class {
     const parts = relFromSessions.split("/");
     const sessionId = parts[0];
     if (!sessionId) return;
-    const sessionDir = join9(this.sessionsDir, sessionId);
+    const sessionDir = join10(this.sessionsDir, sessionId);
     this.ensureSessionRow(sessionId, sessionDir);
     const fileName = basename2(filePath);
     const reviewerMatch = relFromSessions.match(/rounds\/round-(\d+)\/reviews\/(.+\.md)$/);
@@ -26457,6 +26933,12 @@ var FilesystemSync = class {
       this.processReviewerOutput(sessionId, roundNumber, filePath, reviewerMatch[2] ?? "");
       return;
     }
+    const roundMetaMatch = relFromSessions.match(/rounds\/round-(\d+)\/round-meta\.json$/);
+    if (roundMetaMatch) {
+      const roundNumber = parseInt(roundMetaMatch[1] ?? "0", 10);
+      this.processRoundMeta(sessionId, roundNumber, filePath);
+      return;
+    }
     const finalMatch = relFromSessions.match(/rounds\/round-(\d+)\/final\.md$/);
     if (finalMatch) {
       const roundNumber = parseInt(finalMatch[1] ?? "0", 10);
@@ -26475,6 +26957,12 @@ var FilesystemSync = class {
       this.processGenericArtifact(sessionId, "discourse", filePath, roundNumber);
       return;
     }
+    const mapMetaMatch = relFromSessions.match(/map\/runs\/run-(\d+)\/map-meta\.json$/);
+    if (mapMetaMatch) {
+      const runNumber = parseInt(mapMetaMatch[1] ?? "0", 10);
+      this.processMapMeta(sessionId, runNumber, filePath);
+      return;
+    }
     const mapMatch = relFromSessions.match(/map\/runs\/run-(\d+)\/map\.md$/);
     if (mapMatch) {
       const runNumber = parseInt(mapMatch[1] ?? "0", 10);
@@ -26508,8 +26996,8 @@ var FilesystemSync = class {
 };
 
 // src/server/services/db-sync-watcher.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6, statSync as statSync2 } from "node:fs";
-import { watch as watch2 } from "chokidar";
+import { existsSync as existsSync6, readFileSync as readFileSync7, statSync as statSync2 } from "node:fs";
+import { watch as watch3 } from "chokidar";
 import initSqlJs3 from "sql.js";
 function col(row, key) {
   return row[key] ?? null;
@@ -26530,7 +27018,7 @@ var DbSyncWatcher = class {
    * Initialize the WASM runtime (called once at startup).
    */
   async init() {
-    const wasmBuffer = readFileSync6(locateWasm());
+    const wasmBuffer = readFileSync7(locateWasm());
     this.wasmBinary = wasmBuffer.buffer.slice(
       wasmBuffer.byteOffset,
       wasmBuffer.byteOffset + wasmBuffer.byteLength
@@ -26541,12 +27029,12 @@ var DbSyncWatcher = class {
    * Start watching the DB file for external changes.
    */
   startWatching() {
-    if (!existsSync5(this.dbFilePath)) return;
+    if (!existsSync6(this.dbFilePath)) return;
     try {
       this.lastMtime = statSync2(this.dbFilePath).mtimeMs;
     } catch {
     }
-    this.watcher = watch2(this.dbFilePath, {
+    this.watcher = watch3(this.dbFilePath, {
       // Also watch WAL/SHM files that SQLite may create
       persistent: true,
       ignoreInitial: true,
@@ -26592,7 +27080,7 @@ var DbSyncWatcher = class {
    * to avoid overwriting CLI changes.
    */
   syncFromDisk() {
-    if (!this.SQL || !existsSync5(this.dbFilePath)) return;
+    if (!this.SQL || !existsSync6(this.dbFilePath)) return;
     let currentMtime;
     try {
       currentMtime = statSync2(this.dbFilePath).mtimeMs;
@@ -26603,7 +27091,7 @@ var DbSyncWatcher = class {
     this.lastMtime = currentMtime;
     let diskDb = null;
     try {
-      const fileBuffer = readFileSync6(this.dbFilePath);
+      const fileBuffer = readFileSync7(this.dbFilePath);
       diskDb = new this.SQL.Database(fileBuffer);
       this.syncSessions(diskDb);
       this.syncEvents(diskDb);
@@ -26698,7 +27186,7 @@ var DbSyncWatcher = class {
     const diskEvents = resultToRows(
       diskDb.exec("SELECT * FROM orchestration_events ORDER BY id ASC")
     );
-    let insertedCount = 0;
+    const newEvents = [];
     const affectedSessions = /* @__PURE__ */ new Set();
     for (const row of diskEvents) {
       const eventId = col(row, "id");
@@ -26722,15 +27210,128 @@ var DbSyncWatcher = class {
           col(row, "created_at")
         ]
       );
-      insertedCount++;
+      newEvents.push(row);
       affectedSessions.add(sessionId);
     }
-    if (insertedCount > 0) {
+    for (const row of newEvents) {
+      const eventType = col(row, "event_type");
+      const sessionId = col(row, "session_id");
+      const metadataStr = col(row, "metadata");
+      if (eventType === "round_completed") {
+        const roundNumber = col(row, "round");
+        if (sessionId && roundNumber && metadataStr) {
+          this.processRoundCompletedEvent(sessionId, roundNumber, metadataStr);
+        }
+      } else if (eventType === "map_completed") {
+        const runNumber = col(row, "round");
+        if (sessionId && runNumber && metadataStr) {
+          this.processMapCompletedEvent(sessionId, runNumber, metadataStr);
+        }
+      }
+    }
+    if (newEvents.length > 0) {
       for (const sessionId of affectedSessions) {
-        this.io.emit("session:events", { session_id: sessionId });
+        this.io.to(`session:${sessionId}`).emit("session:events", { session_id: sessionId });
       }
     }
   }
+  /**
+   * Process a `round_completed` orchestration event.
+   * Upserts review_rounds with orchestrator data for real-time dashboard updates.
+   * Idempotent — skips if round already has source='orchestrator'.
+   */
+  processRoundCompletedEvent(sessionId, roundNumber, metadataStr) {
+    let metadata;
+    try {
+      metadata = JSON.parse(metadataStr);
+    } catch {
+      return;
+    }
+    const existing = this.db.exec(
+      "SELECT source FROM review_rounds WHERE session_id = ? AND round_number = ?",
+      [sessionId, roundNumber]
+    );
+    const rows = resultToRows(existing);
+    if (rows.length > 0 && col(rows[0], "source") === "orchestrator") {
+      return;
+    }
+    this.db.run(
+      `INSERT OR IGNORE INTO review_rounds (session_id, round_number)
+       VALUES (?, ?)`,
+      [sessionId, roundNumber]
+    );
+    this.db.run(
+      `UPDATE review_rounds
+       SET verdict = ?, blocker_count = ?, suggestion_count = ?, should_fix_count = ?,
+           reviewer_count = ?, total_finding_count = ?, source = 'orchestrator',
+           parsed_at = datetime('now')
+       WHERE session_id = ? AND round_number = ?`,
+      [
+        metadata.verdict ?? null,
+        metadata.blocker_count ?? 0,
+        metadata.suggestion_count ?? 0,
+        metadata.should_fix_count ?? 0,
+        metadata.reviewer_count ?? 0,
+        metadata.total_finding_count ?? 0,
+        sessionId,
+        roundNumber
+      ]
+    );
+    this.io.to(`session:${sessionId}`).emit("round:updated", {
+      sessionId,
+      roundNumber,
+      verdict: metadata.verdict,
+      blockerCount: metadata.blocker_count,
+      shouldFixCount: metadata.should_fix_count,
+      suggestionCount: metadata.suggestion_count,
+      source: "orchestrator"
+    });
+  }
+  /**
+   * Process a `map_completed` orchestration event.
+   * Upserts map_runs with orchestrator data for real-time dashboard updates.
+   * Idempotent — skips if run already has source='orchestrator'.
+   */
+  processMapCompletedEvent(sessionId, runNumber, metadataStr) {
+    let metadata;
+    try {
+      metadata = JSON.parse(metadataStr);
+    } catch {
+      return;
+    }
+    const existing = this.db.exec(
+      "SELECT source FROM map_runs WHERE session_id = ? AND run_number = ?",
+      [sessionId, runNumber]
+    );
+    const rows = resultToRows(existing);
+    if (rows.length > 0 && col(rows[0], "source") === "orchestrator") {
+      return;
+    }
+    this.db.run(
+      `INSERT OR IGNORE INTO map_runs (session_id, run_number)
+       VALUES (?, ?)`,
+      [sessionId, runNumber]
+    );
+    this.db.run(
+      `UPDATE map_runs
+       SET file_count = ?, section_count = ?, source = 'orchestrator',
+           parsed_at = datetime('now')
+       WHERE session_id = ? AND run_number = ?`,
+      [
+        metadata.file_count ?? 0,
+        metadata.section_count ?? 0,
+        sessionId,
+        runNumber
+      ]
+    );
+    this.io.to(`session:${sessionId}`).emit("map:updated", {
+      sessionId,
+      runNumber,
+      fileCount: metadata.file_count,
+      sectionCount: metadata.section_count,
+      source: "orchestrator"
+    });
+  }
   /**
    * Record current mtime after the dashboard writes to disk.
    * Called automatically via registered save hooks after saveDb().
@@ -26744,20 +27345,20 @@ var DbSyncWatcher = class {
 };
 
 // src/server/socket/chat-handler.ts
-import { dirname as dirname7 } from "node:path";
+import { dirname as dirname8 } from "node:path";
 
 // src/server/services/chat-context.ts
-import { readFileSync as readFileSync7, readdirSync as readdirSync2, existsSync as existsSync6 } from "node:fs";
-import { join as join10 } from "node:path";
+import { readFileSync as readFileSync8, readdirSync as readdirSync2, existsSync as existsSync7 } from "node:fs";
+import { join as join11 } from "node:path";
 function buildChatContext(ocrDir, target) {
-  const sessionsDir = join10(ocrDir, "sessions");
+  const sessionsDir = join11(ocrDir, "sessions");
   if (target.type === "map_run") {
     return buildMapRunContext(sessionsDir, target.sessionId, target.runNumber);
   }
   return buildReviewRoundContext(sessionsDir, target.sessionId, target.roundNumber);
 }
 function buildMapRunContext(sessionsDir, sessionId, runNumber) {
-  const mapPath = join10(
+  const mapPath = join11(
     sessionsDir,
     sessionId,
     "map",
@@ -26771,8 +27372,8 @@ function buildMapRunContext(sessionsDir, sessionId, runNumber) {
     "",
     `Below is the Code Review Map that organizes the changeset into reviewable sections:`
   ];
-  if (existsSync6(mapPath)) {
-    const content = readFileSync7(mapPath, "utf-8");
+  if (existsSync7(mapPath)) {
+    const content = readFileSync8(mapPath, "utf-8");
     parts.push("");
     parts.push("<map>");
     parts.push(content);
@@ -26784,26 +27385,26 @@ function buildMapRunContext(sessionsDir, sessionId, runNumber) {
   return parts.join("\n");
 }
 function buildReviewRoundContext(sessionsDir, sessionId, roundNumber) {
-  const roundDir = join10(sessionsDir, sessionId, "rounds", `round-${roundNumber}`);
-  const finalPath = join10(roundDir, "final.md");
-  const reviewersDir = join10(roundDir, "reviews");
+  const roundDir = join11(sessionsDir, sessionId, "rounds", `round-${roundNumber}`);
+  const finalPath = join11(roundDir, "final.md");
+  const reviewersDir = join11(roundDir, "reviews");
   const parts = [
     `You are an expert code reviewer assisting with a code review session.`,
     `You are looking at review round #${roundNumber} for session "${sessionId}".`,
     "",
     `Below are the review artifacts for this round:`
   ];
-  if (existsSync6(finalPath)) {
-    const content = readFileSync7(finalPath, "utf-8");
+  if (existsSync7(finalPath)) {
+    const content = readFileSync8(finalPath, "utf-8");
     parts.push("");
     parts.push("<final-synthesis>");
     parts.push(content);
     parts.push("</final-synthesis>");
   }
-  if (existsSync6(reviewersDir)) {
+  if (existsSync7(reviewersDir)) {
     const files = readdirSync2(reviewersDir).filter((f) => f.endsWith(".md")).sort();
     for (const file of files) {
-      const content = readFileSync7(join10(reviewersDir, file), "utf-8");
+      const content = readFileSync8(join11(reviewersDir, file), "utf-8");
       const reviewerName = file.replace(/\.md$/, "");
       parts.push("");
       parts.push(`<reviewer name="${reviewerName}">`);
@@ -26811,7 +27412,7 @@ function buildReviewRoundContext(sessionsDir, sessionId, roundNumber) {
       parts.push("</reviewer>");
     }
   }
-  if (!existsSync6(finalPath) && !existsSync6(reviewersDir)) {
+  if (!existsSync7(finalPath) && !existsSync7(reviewersDir)) {
     parts.push("");
     parts.push("(No review artifacts found on disk for this round.)");
   }
@@ -26939,7 +27540,7 @@ User: ${message}`;
         });
         return;
       }
-      const repoRoot = dirname7(ocrDir);
+      const repoRoot = dirname8(ocrDir);
       const spawnResult = adapter.spawn({
         prompt,
         cwd: repoRoot,
@@ -27116,15 +27717,15 @@ function cleanupAllChats() {
 
 // src/server/socket/post-handler.ts
 import { execFile } from "node:child_process";
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync8, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync9, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join11, dirname as dirname8, isAbsolute } from "node:path";
+import { join as join12, dirname as dirname9, isAbsolute } from "node:path";
 import { randomUUID } from "node:crypto";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
 function resolveSessionDir(sessionDir, ocrDir) {
   if (isAbsolute(sessionDir)) return sessionDir;
-  return join11(dirname8(ocrDir), sessionDir);
+  return join12(dirname9(ocrDir), sessionDir);
 }
 var BRANCH_PREFIXES = [
   "feat",
@@ -27193,7 +27794,7 @@ function registerPostHandlers(io2, socket, db, ocrDir, aiCliService) {
         return;
       }
       const branch = session.branch;
-      const repoRoot = dirname8(ocrDir);
+      const repoRoot = dirname9(ocrDir);
       try {
         await execFileAsync("gh", ["auth", "status"], { env: cleanEnv(), cwd: repoRoot });
       } catch {
@@ -27294,19 +27895,19 @@ function registerPostHandlers(io2, socket, db, ocrDir, aiCliService) {
         socket.emit("post:error", { error: "Session not found" });
         return;
       }
-      const sessionDir = session.session_dir ? resolveSessionDir(session.session_dir, ocrDir) : join11(ocrDir, "sessions", sessionId);
-      const roundDir = join11(sessionDir, "rounds", `round-${roundNumber}`);
-      const finalPath = join11(roundDir, "final.md");
-      if (!existsSync7(finalPath)) {
+      const sessionDir = session.session_dir ? resolveSessionDir(session.session_dir, ocrDir) : join12(ocrDir, "sessions", sessionId);
+      const roundDir = join12(sessionDir, "rounds", `round-${roundNumber}`);
+      const finalPath = join12(roundDir, "final.md");
+      if (!existsSync8(finalPath)) {
         socket.emit("post:error", { error: "final.md not found for this round" });
         return;
       }
-      const humanReviewPath = join11(roundDir, "final-human.md");
-      const repoRoot = dirname8(ocrDir);
-      const commandMdPath = join11(ocrDir, "commands", "translate-review-to-single-human.md");
+      const humanReviewPath = join12(roundDir, "final-human.md");
+      const repoRoot = dirname9(ocrDir);
+      const commandMdPath = join12(ocrDir, "commands", "translate-review-to-single-human.md");
       let commandContent;
       try {
-        commandContent = readFileSync8(commandMdPath, "utf-8");
+        commandContent = readFileSync9(commandMdPath, "utf-8");
       } catch {
         socket.emit("post:error", {
           error: `Command file not found: ${commandMdPath}. Run \`ocr init\` to set up.`
@@ -27382,9 +27983,9 @@ function registerPostHandlers(io2, socket, db, ocrDir, aiCliService) {
           }
         }
         let generatedContent = "";
-        if (existsSync7(humanReviewPath)) {
+        if (existsSync8(humanReviewPath)) {
           try {
-            generatedContent = readFileSync8(humanReviewPath, "utf-8").trim();
+            generatedContent = readFileSync9(humanReviewPath, "utf-8").trim();
           } catch {
           }
         }
@@ -27459,10 +28060,10 @@ function registerPostHandlers(io2, socket, db, ocrDir, aiCliService) {
           socket.emit("post:save-result", { success: false, error: "Session not found" });
           return;
         }
-        const sessionDir = session.session_dir ? resolveSessionDir(session.session_dir, ocrDir) : join11(ocrDir, "sessions", sessionId);
-        const roundDir = join11(sessionDir, "rounds", `round-${roundNumber}`);
+        const sessionDir = session.session_dir ? resolveSessionDir(session.session_dir, ocrDir) : join12(ocrDir, "sessions", sessionId);
+        const roundDir = join12(sessionDir, "rounds", `round-${roundNumber}`);
         mkdirSync2(roundDir, { recursive: true });
-        const filePath = join11(roundDir, "final-human.md");
+        const filePath = join12(roundDir, "final-human.md");
         writeFileSync3(filePath, content, { mode: 420 });
         saveDb(db, ocrDir);
         socket.emit("post:save-result", { success: true });
@@ -27490,14 +28091,14 @@ function registerPostHandlers(io2, socket, db, ocrDir, aiCliService) {
         );
         tracker.appendOutput(`\u25B8 Posting review to PR #${prNumber}...
 `);
-        const tmpDir = join11(tmpdir2(), "ocr-post-comments");
+        const tmpDir = join12(tmpdir2(), "ocr-post-comments");
         try {
           mkdirSync2(tmpDir, { recursive: true, mode: 448 });
         } catch {
         }
-        const tmpFile = join11(tmpDir, `${randomUUID()}.md`);
+        const tmpFile = join12(tmpDir, `${randomUUID()}.md`);
         writeFileSync3(tmpFile, content, { mode: 384 });
-        const repoRoot = dirname8(ocrDir);
+        const repoRoot = dirname9(ocrDir);
         try {
           const { stdout } = await execFileAsync(
             "gh",
@@ -27541,9 +28142,9 @@ function cleanupAllPostGenerations() {
 }
 
 // src/server/index.ts
-var __dirname3 = dirname9(fileURLToPath3(import.meta.url));
+var __dirname3 = dirname10(fileURLToPath3(import.meta.url));
 var AUTH_TOKEN = randomBytes(32).toString("hex");
-var app = (0, import_express11.default)();
+var app = (0, import_express12.default)();
 var httpServer = createServer(app);
 var io = new SocketIOServer(httpServer, {
   cors: {
@@ -27552,7 +28153,7 @@ var io = new SocketIOServer(httpServer, {
   maxHttpBufferSize: 1e6
   // 1 MB — explicit default; review if large payloads are needed
 });
-app.use(import_express11.default.json());
+app.use(import_express12.default.json());
 if (process.env.NODE_ENV !== "production") {
   app.use((_req, res, next) => {
     const origin = _req.headers.origin;
@@ -27604,12 +28205,12 @@ async function startServer(options = {}) {
   const ocrDir = resolveOcrDir();
   const aiCliService = new AiCliService(ocrDir);
   const db = await openDb(ocrDir);
-  const dataDir = join12(ocrDir, "data");
-  const pidFilePath = join12(dataDir, "dashboard.pid");
+  const dataDir = join13(ocrDir, "data");
+  const pidFilePath = join13(dataDir, "dashboard.pid");
   mkdirSync3(dataDir, { recursive: true });
-  if (existsSync8(pidFilePath)) {
+  if (existsSync9(pidFilePath)) {
     try {
-      const oldPid = parseInt(readFileSync9(pidFilePath, "utf-8").trim(), 10);
+      const oldPid = parseInt(readFileSync10(pidFilePath, "utf-8").trim(), 10);
       if (!isNaN(oldPid)) {
         try {
           process.kill(oldPid, 0);
@@ -27709,11 +28310,12 @@ async function startServer(options = {}) {
   app.use("/api/commands", createCommandsRouter(db));
   app.use("/api/config", createConfigRouter(ocrDir, aiCliService));
   app.use("/api/sessions", createChatRouter(db, ocrDir));
-  const clientDir = join12(__dirname3, "client");
-  if (process.env.NODE_ENV === "production" && existsSync8(clientDir)) {
-    app.use(import_express11.default.static(clientDir, { index: false }));
-    const indexHtmlPath = join12(clientDir, "index.html");
-    const rawIndexHtml = existsSync8(indexHtmlPath) ? readFileSync9(indexHtmlPath, "utf-8") : "";
+  app.use("/api/reviewers", createReviewersRouter(ocrDir));
+  const clientDir = join13(__dirname3, "client");
+  if (process.env.NODE_ENV === "production" && existsSync9(clientDir)) {
+    app.use(import_express12.default.static(clientDir, { index: false }));
+    const indexHtmlPath = join13(clientDir, "index.html");
+    const rawIndexHtml = existsSync9(indexHtmlPath) ? readFileSync10(indexHtmlPath, "utf-8") : "";
     const tokenScript = `<script>window.__OCR_TOKEN__=${JSON.stringify(AUTH_TOKEN)};</script>`;
     const injectedIndexHtml = rawIndexHtml.replace(
       "</head>",
@@ -27736,7 +28338,7 @@ async function startServer(options = {}) {
       console.log("Client disconnected:", socket.id);
     });
   });
-  const dbFilePath = join12(ocrDir, "data", "ocr.db");
+  const dbFilePath = join13(ocrDir, "data", "ocr.db");
   const dbSyncWatcher = new DbSyncWatcher(db, dbFilePath, io, () => {
     saveDb(db, ocrDir);
   });
@@ -27747,12 +28349,13 @@ async function startServer(options = {}) {
     () => dbSyncWatcher.syncFromDisk(),
     () => dbSyncWatcher.markOwnWrite()
   );
-  const sessionsDir = join12(ocrDir, "sessions");
+  const sessionsDir = join13(ocrDir, "sessions");
   const fsSync = new FilesystemSync(db, sessionsDir, io, () => saveDb(db, ocrDir));
   await fsSync.fullScan();
   saveDb(db, ocrDir);
   fsSync.startWatching();
   console.log(`Watching sessions: ${sessionsDir}`);
+  const stopReviewersWatch = watchReviewersMeta(ocrDir, io);
   await new Promise((resolve3, reject) => {
     httpServer.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
@@ -27836,6 +28439,7 @@ async function startServer(options = {}) {
     }
     dbSyncWatcher.stopWatching();
     fsSync.stopWatching();
+    stopReviewersWatch();
     io.close();
     httpServer.close(() => {
       try {