@open-code-review/cli 2.2.1 → 2.4.0

package/dist/index.js

@@ -39,7 +39,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/lib/runtime-checks.ts
+// ../shared/persistence/src/runtime-checks.ts
 function isSupportedNode(version) {
   const [major = 0, minor = 0] = version.split(".").map((n) => Number.parseInt(n, 10) || 0);
   return major > NODE_FLOOR.major || major === NODE_FLOOR.major && minor >= NODE_FLOOR.minor;
@@ -57,7 +57,7 @@ function isSuppressibleSqliteWarning(warning) {
 }
 var NODE_FLOOR;
 var init_runtime_checks = __esm({
-  "src/lib/runtime-checks.ts"() {
+  "../shared/persistence/src/runtime-checks.ts"() {
     "use strict";
     NODE_FLOOR = { major: 22, minor: 5 };
   }
@@ -16017,35 +16017,688 @@ var require_emoji_regex2 = __commonJS({
   }
 });
 
-// ../shared/platform/src/index.ts
-import { pathToFileURL } from "node:url";
-import {
-  execFile,
-  execFileSync,
-  spawn as spawn2
-} from "node:child_process";
-import { promisify } from "node:util";
-async function importModule(absolutePath) {
-  return import(pathToFileURL(absolutePath).href);
-}
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
+var require_windows = __commonJS({
+  "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports, module) {
+    "use strict";
+    module.exports = isexe;
+    isexe.sync = sync;
+    var fs = __require("fs");
+    function checkPathExt(path2, options) {
+      var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+      if (!pathext) {
+        return true;
+      }
+      pathext = pathext.split(";");
+      if (pathext.indexOf("") !== -1) {
+        return true;
+      }
+      for (var i = 0; i < pathext.length; i++) {
+        var p = pathext[i].toLowerCase();
+        if (p && path2.substr(-p.length).toLowerCase() === p) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function checkStat(stat4, path2, options) {
+      if (!stat4.isSymbolicLink() && !stat4.isFile()) {
+        return false;
+      }
+      return checkPathExt(path2, options);
+    }
+    function isexe(path2, options, cb) {
+      fs.stat(path2, function(er, stat4) {
+        cb(er, er ? false : checkStat(stat4, path2, options));
+      });
+    }
+    function sync(path2, options) {
+      return checkStat(fs.statSync(path2), path2, options);
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js
+var require_mode = __commonJS({
+  "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports, module) {
+    "use strict";
+    module.exports = isexe;
+    isexe.sync = sync;
+    var fs = __require("fs");
+    function isexe(path2, options, cb) {
+      fs.stat(path2, function(er, stat4) {
+        cb(er, er ? false : checkStat(stat4, options));
+      });
+    }
+    function sync(path2, options) {
+      return checkStat(fs.statSync(path2), options);
+    }
+    function checkStat(stat4, options) {
+      return stat4.isFile() && checkMode(stat4, options);
+    }
+    function checkMode(stat4, options) {
+      var mod = stat4.mode;
+      var uid = stat4.uid;
+      var gid = stat4.gid;
+      var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
+      var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+      var u = parseInt("100", 8);
+      var g = parseInt("010", 8);
+      var o = parseInt("001", 8);
+      var ug = u | g;
+      var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+      return ret;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
+var require_isexe = __commonJS({
+  "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var core;
+    if (process.platform === "win32" || global.TESTING_WINDOWS) {
+      core = require_windows();
+    } else {
+      core = require_mode();
+    }
+    module.exports = isexe;
+    isexe.sync = sync;
+    function isexe(path2, options, cb) {
+      if (typeof options === "function") {
+        cb = options;
+        options = {};
+      }
+      if (!cb) {
+        if (typeof Promise !== "function") {
+          throw new TypeError("callback not provided");
+        }
+        return new Promise(function(resolve3, reject) {
+          isexe(path2, options || {}, function(er, is) {
+            if (er) {
+              reject(er);
+            } else {
+              resolve3(is);
+            }
+          });
+        });
+      }
+      core(path2, options || {}, function(er, is) {
+        if (er) {
+          if (er.code === "EACCES" || options && options.ignoreErrors) {
+            er = null;
+            is = false;
+          }
+        }
+        cb(er, is);
+      });
+    }
+    function sync(path2, options) {
+      try {
+        return core.sync(path2, options || {});
+      } catch (er) {
+        if (options && options.ignoreErrors || er.code === "EACCES") {
+          return false;
+        } else {
+          throw er;
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
+var require_which = __commonJS({
+  "../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js"(exports, module) {
+    "use strict";
+    var isWindows5 = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+    var path2 = __require("path");
+    var COLON = isWindows5 ? ";" : ":";
+    var isexe = require_isexe();
+    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+    var getPathInfo = (cmd, opt) => {
+      const colon = opt.colon || COLON;
+      const pathEnv = cmd.match(/\//) || isWindows5 && cmd.match(/\\/) ? [""] : [
+        // windows always checks the cwd first
+        ...isWindows5 ? [process.cwd()] : [],
+        ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
+        "").split(colon)
+      ];
+      const pathExtExe = isWindows5 ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+      const pathExt = isWindows5 ? pathExtExe.split(colon) : [""];
+      if (isWindows5) {
+        if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+          pathExt.unshift("");
+      }
+      return {
+        pathEnv,
+        pathExt,
+        pathExtExe
+      };
+    };
+    var which = (cmd, opt, cb) => {
+      if (typeof opt === "function") {
+        cb = opt;
+        opt = {};
+      }
+      if (!opt)
+        opt = {};
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      const step = (i) => new Promise((resolve3, reject) => {
+        if (i === pathEnv.length)
+          return opt.all && found.length ? resolve3(found) : reject(getNotFoundError(cmd));
+        const ppRaw = pathEnv[i];
+        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+        const pCmd = path2.join(pathPart, cmd);
+        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        resolve3(subStep(p, i, 0));
+      });
+      const subStep = (p, i, ii) => new Promise((resolve3, reject) => {
+        if (ii === pathExt.length)
+          return resolve3(step(i + 1));
+        const ext = pathExt[ii];
+        isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+          if (!er && is) {
+            if (opt.all)
+              found.push(p + ext);
+            else
+              return resolve3(p + ext);
+          }
+          return resolve3(subStep(p, i, ii + 1));
+        });
+      });
+      return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+    };
+    var whichSync = (cmd, opt) => {
+      opt = opt || {};
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (let i = 0; i < pathEnv.length; i++) {
+        const ppRaw = pathEnv[i];
+        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+        const pCmd = path2.join(pathPart, cmd);
+        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        for (let j = 0; j < pathExt.length; j++) {
+          const cur = p + pathExt[j];
+          try {
+            const is = isexe.sync(cur, { pathExt: pathExtExe });
+            if (is) {
+              if (opt.all)
+                found.push(cur);
+              else
+                return cur;
+            }
+          } catch (ex) {
+          }
+        }
+      }
+      if (opt.all && found.length)
+        return found;
+      if (opt.nothrow)
+        return null;
+      throw getNotFoundError(cmd);
+    };
+    module.exports = which;
+    which.sync = whichSync;
+  }
+});
+
+// ../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js
+var require_path_key = __commonJS({
+  "../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js"(exports, module) {
+    "use strict";
+    var pathKey = (options = {}) => {
+      const environment = options.env || process.env;
+      const platform2 = options.platform || process.platform;
+      if (platform2 !== "win32") {
+        return "PATH";
+      }
+      return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+    };
+    module.exports = pathKey;
+    module.exports.default = pathKey;
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module) {
+    "use strict";
+    var path2 = __require("path");
+    var which = require_which();
+    var getPathKey = require_path_key();
+    function resolveCommandAttempt(parsed, withoutPathExt) {
+      const env2 = parsed.options.env || process.env;
+      const cwd = process.cwd();
+      const hasCustomCwd = parsed.options.cwd != null;
+      const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+      if (shouldSwitchCwd) {
+        try {
+          process.chdir(parsed.options.cwd);
+        } catch (err) {
+        }
+      }
+      let resolved;
+      try {
+        resolved = which.sync(parsed.command, {
+          path: env2[getPathKey({ env: env2 })],
+          pathExt: withoutPathExt ? path2.delimiter : void 0
+        });
+      } catch (e) {
+      } finally {
+        if (shouldSwitchCwd) {
+          process.chdir(cwd);
+        }
+      }
+      if (resolved) {
+        resolved = path2.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+      }
+      return resolved;
+    }
+    function resolveCommand(parsed) {
+      return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+    }
+    module.exports = resolveCommand;
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js"(exports, module) {
+    "use strict";
+    var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+    function escapeCommand(arg) {
+      arg = arg.replace(metaCharsRegExp, "^$1");
+      return arg;
+    }
+    function escapeArgument(arg, doubleEscapeMetaChars) {
+      arg = `${arg}`;
+      arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+      arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+      arg = `"${arg}"`;
+      arg = arg.replace(metaCharsRegExp, "^$1");
+      if (doubleEscapeMetaChars) {
+        arg = arg.replace(metaCharsRegExp, "^$1");
+      }
+      return arg;
+    }
+    module.exports.command = escapeCommand;
+    module.exports.argument = escapeArgument;
+  }
+});
+
+// ../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS({
+  "../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js"(exports, module) {
+    "use strict";
+    module.exports = /^#!(.*)/;
+  }
+});
+
+// ../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS({
+  "../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js"(exports, module) {
+    "use strict";
+    var shebangRegex = require_shebang_regex();
+    module.exports = (string = "") => {
+      const match = string.match(shebangRegex);
+      if (!match) {
+        return null;
+      }
+      const [path2, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path2.split("/").pop();
+      if (binary === "env") {
+        return argument;
+      }
+      return argument ? `${binary} ${argument}` : binary;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var shebangCommand = require_shebang_command();
+    function readShebang(command) {
+      const size = 150;
+      const buffer = Buffer.alloc(size);
+      let fd;
+      try {
+        fd = fs.openSync(command, "r");
+        fs.readSync(fd, buffer, 0, size, 0);
+        fs.closeSync(fd);
+      } catch (e) {
+      }
+      return shebangCommand(buffer.toString());
+    }
+    module.exports = readShebang;
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
+var require_parse = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js"(exports, module) {
+    "use strict";
+    var path2 = __require("path");
+    var resolveCommand = require_resolveCommand();
+    var escape = require_escape();
+    var readShebang = require_readShebang();
+    var isWin = process.platform === "win32";
+    var isExecutableRegExp = /\.(?:com|exe)$/i;
+    var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+    function detectShebang(parsed) {
+      parsed.file = resolveCommand(parsed);
+      const shebang = parsed.file && readShebang(parsed.file);
+      if (shebang) {
+        parsed.args.unshift(parsed.file);
+        parsed.command = shebang;
+        return resolveCommand(parsed);
+      }
+      return parsed.file;
+    }
+    function parseNonShell(parsed) {
+      if (!isWin) {
+        return parsed;
+      }
+      const commandFile = detectShebang(parsed);
+      const needsShell = !isExecutableRegExp.test(commandFile);
+      if (parsed.options.forceShell || needsShell) {
+        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+        parsed.command = path2.normalize(parsed.command);
+        parsed.command = escape.command(parsed.command);
+        parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+        const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+        parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+        parsed.command = process.env.comspec || "cmd.exe";
+        parsed.options.windowsVerbatimArguments = true;
+      }
+      return parsed;
+    }
+    function parse(command, args, options) {
+      if (args && !Array.isArray(args)) {
+        options = args;
+        args = null;
+      }
+      args = args ? args.slice(0) : [];
+      options = Object.assign({}, options);
+      const parsed = {
+        command,
+        args,
+        options,
+        file: void 0,
+        original: {
+          command,
+          args
+        }
+      };
+      return options.shell ? parsed : parseNonShell(parsed);
+    }
+    module.exports = parse;
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js"(exports, module) {
+    "use strict";
+    var isWin = process.platform === "win32";
+    function notFoundError(original, syscall) {
+      return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+        code: "ENOENT",
+        errno: "ENOENT",
+        syscall: `${syscall} ${original.command}`,
+        path: original.command,
+        spawnargs: original.args
+      });
+    }
+    function hookChildProcess(cp, parsed) {
+      if (!isWin) {
+        return;
+      }
+      const originalEmit = cp.emit;
+      cp.emit = function(name, arg1) {
+        if (name === "exit") {
+          const err = verifyENOENT(arg1, parsed);
+          if (err) {
+            return originalEmit.call(cp, "error", err);
+          }
+        }
+        return originalEmit.apply(cp, arguments);
+      };
+    }
+    function verifyENOENT(status, parsed) {
+      if (isWin && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, "spawn");
+      }
+      return null;
+    }
+    function verifyENOENTSync(status, parsed) {
+      if (isWin && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, "spawnSync");
+      }
+      return null;
+    }
+    module.exports = {
+      hookChildProcess,
+      verifyENOENT,
+      verifyENOENTSync,
+      notFoundError
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js"(exports, module) {
+    "use strict";
+    var cp = __require("child_process");
+    var parse = require_parse();
+    var enoent = require_enoent();
+    function spawn2(command, args, options) {
+      const parsed = parse(command, args, options);
+      const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+      enoent.hookChildProcess(spawned, parsed);
+      return spawned;
+    }
+    function spawnSync2(command, args, options) {
+      const parsed = parse(command, args, options);
+      const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+      result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+      return result;
+    }
+    module.exports = spawn2;
+    module.exports.spawn = spawn2;
+    module.exports.sync = spawnSync2;
+    module.exports._parse = parse;
+    module.exports._enoent = enoent;
+  }
+});
+
+// ../shared/platform/src/spawn.ts
 function execBinary(binary, args, opts) {
-  return execFileSync(binary, args, {
-    ...opts,
-    shell: isWindows
+  const result = import_cross_spawn.default.sync(binary, args, {
+    maxBuffer: DEFAULT_MAX_BUFFER,
+    ...opts
   });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw Object.assign(
+      new Error(
+        `Command failed: ${binary} ${args.join(" ")}
+${String(result.stderr ?? "")}`
+      ),
+      {
+        status: result.status,
+        code: result.status,
+        signal: result.signal,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        pid: result.pid
+      }
+    );
+  }
+  return result.stdout;
 }
 async function execBinaryAsync(binary, args, opts) {
-  return execFilePromise(binary, args, {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = (0, import_cross_spawn.default)(binary, args, {
+      cwd: opts.cwd,
+      env: opts.env,
+      windowsHide: true
+    });
+    const maxBuffer = opts.maxBuffer ?? DEFAULT_MAX_BUFFER;
+    let stdout = "";
+    let stderr = "";
+    let killed = false;
+    let settled = false;
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      fn();
+    };
+    const overflow = () => {
+      killed = true;
+      child.kill();
+    };
+    child.stdout?.setEncoding(opts.encoding);
+    child.stderr?.setEncoding(opts.encoding);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+      if (stdout.length > maxBuffer) overflow();
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+      if (stderr.length > maxBuffer) overflow();
+    });
+    const timer = opts.timeout ? setTimeout(() => {
+      killed = true;
+      child.kill();
+    }, opts.timeout) : void 0;
+    child.on("error", (err) => {
+      settle(
+        () => rejectPromise(Object.assign(err, { stdout, stderr, killed }))
+      );
+    });
+    child.on("close", (code, signal) => {
+      settle(() => {
+        if (code === 0 && !killed) {
+          resolvePromise({ stdout, stderr });
+          return;
+        }
+        rejectPromise(
+          Object.assign(
+            new Error(
+              `Command failed: ${binary} ${args.join(" ")}
+${stderr}`
+            ),
+            {
+              code: code ?? void 0,
+              signal,
+              stdout,
+              stderr,
+              killed
+            }
+          )
+        );
+      });
+    });
+  });
+}
+function spawnBinary(binary, args, opts) {
+  return (0, import_cross_spawn.default)(binary, args, {
     ...opts,
-    shell: isWindows
+    windowsHide: true
   });
 }
+var import_cross_spawn, DEFAULT_MAX_BUFFER;
+var init_spawn = __esm({
+  "../shared/platform/src/spawn.ts"() {
+    "use strict";
+    import_cross_spawn = __toESM(require_cross_spawn(), 1);
+    DEFAULT_MAX_BUFFER = 1024 * 1024;
+  }
+});
+
+// ../shared/platform/src/verdict.ts
+function isCanonicalVerdict(v) {
+  return VERDICT_SET.has(v);
+}
+var CANONICAL_VERDICTS, VERDICT_SET;
+var init_verdict = __esm({
+  "../shared/platform/src/verdict.ts"() {
+    "use strict";
+    CANONICAL_VERDICTS = [
+      "APPROVE",
+      "REQUEST CHANGES",
+      "NEEDS DISCUSSION"
+    ];
+    VERDICT_SET = new Set(CANONICAL_VERDICTS);
+  }
+});
+
+// ../shared/platform/src/counts.ts
+function deriveCounts(findings) {
+  const counts = {
+    blocker: 0,
+    should_fix: 0,
+    suggestion: 0,
+    style: 0
+  };
+  for (const finding of findings) {
+    const category = finding?.category;
+    if (category === "blocker" || category === "should_fix" || category === "suggestion" || category === "style") {
+      counts[category]++;
+    }
+  }
+  return counts;
+}
+function collectFindings(meta) {
+  const all = [];
+  for (const reviewer of meta.reviewers ?? []) {
+    for (const finding of reviewer?.findings ?? []) all.push(finding);
+  }
+  return all;
+}
+function preferred(scValue, derivedValue) {
+  return typeof scValue === "number" && Number.isFinite(scValue) ? scValue : derivedValue;
+}
+function resolveRoundCounts(meta) {
+  const allFindings = collectFindings(meta);
+  const derived = deriveCounts(allFindings);
+  const sc = meta.synthesis_counts ?? void 0;
+  return {
+    blockerCount: sc ? preferred(sc.blockers, derived.blocker) : derived.blocker,
+    shouldFixCount: sc ? preferred(sc.should_fix, derived.should_fix) : derived.should_fix,
+    suggestionCount: sc ? preferred(sc.suggestions, derived.suggestion) : derived.suggestion,
+    reviewerCount: (meta.reviewers ?? []).length,
+    totalFindingCount: allFindings.length
+  };
+}
+var init_counts = __esm({
+  "../shared/platform/src/counts.ts"() {
+    "use strict";
+  }
+});
+
+// ../shared/platform/src/index.ts
+import { pathToFileURL } from "node:url";
+async function importModule(absolutePath) {
+  return import(pathToFileURL(absolutePath).href);
+}
+function killErrorMeansDead(err) {
+  return err instanceof Error && "code" in err && err.code === "ESRCH";
+}
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
     return true;
   } catch (err) {
-    return !(err instanceof Error && "code" in err && err.code === "ESRCH");
+    return !killErrorMeansDead(err);
   }
 }
 function defaultIconFor(id, tier) {
@@ -16054,11 +16707,13 @@ function defaultIconFor(id, tier) {
 function hostCapabilitiesFor(vendor) {
   return vendor && HOST_CAPABILITIES[vendor] || DEFAULT_HOST_CAPABILITIES;
 }
-var execFilePromise, isWindows, BUILTIN_ICON_MAP, DEFAULT_HOST_CAPABILITIES, HOST_CAPABILITIES;
+var isWindows, BUILTIN_ICON_MAP, DEFAULT_HOST_CAPABILITIES, HOST_CAPABILITIES;
 var init_src = __esm({
   "../shared/platform/src/index.ts"() {
     "use strict";
-    execFilePromise = promisify(execFile);
+    init_spawn();
+    init_verdict();
+    init_counts();
     isWindows = process.platform === "win32";
     BUILTIN_ICON_MAP = {
       architect: "blocks",
@@ -23399,31 +24054,7 @@ var require_dist = __commonJS({
   }
 });
 
-// src/lib/db/result-mapper.ts
-function resultToRows(result) {
-  if (result.length === 0 || !result[0]) {
-    return [];
-  }
-  const { columns, values } = result[0];
-  return values.map((row) => {
-    const obj = {};
-    for (let i = 0; i < columns.length; i++) {
-      obj[columns[i]] = row[i];
-    }
-    return obj;
-  });
-}
-function resultToRow(result) {
-  const rows = resultToRows(result);
-  return rows[0];
-}
-var init_result_mapper = __esm({
-  "src/lib/db/result-mapper.ts"() {
-    "use strict";
-  }
-});
-
-// src/lib/db/engine.ts
+// ../shared/persistence/src/db/engine.ts
 import { createRequire as createRequire2 } from "node:module";
 function applyEnginePreconditions() {
   if (_preconditionsApplied) return;
@@ -23477,7 +24108,7 @@ function openEngine(dbPath) {
 }
 var SQLITE_BUSY, SQLITE_BUSY_SNAPSHOT, BUSY_RETRY_ATTEMPTS, BUSY_RETRY_BACKOFF_MS, savepointName, nodeRequire, _preconditionsApplied, _DatabaseSyncCtor, SLEEP_BUF, NodeSqliteAdapter;
 var init_engine = __esm({
-  "src/lib/db/engine.ts"() {
+  "../shared/persistence/src/db/engine.ts"() {
     "use strict";
     init_runtime_checks();
     SQLITE_BUSY = 5;
@@ -23604,7 +24235,7 @@ var init_engine = __esm({
   }
 });
 
-// src/lib/db/migrations.ts
+// ../shared/persistence/src/db/migrations.ts
 function columnExists(db, table, column) {
   const result = db.exec(`PRAGMA table_info(${table})`);
   const first = result[0];
@@ -23659,7 +24290,7 @@ function runMigrations(db) {
 }
 var MIGRATIONS;
 var init_migrations = __esm({
-  "src/lib/db/migrations.ts"() {
+  "../shared/persistence/src/db/migrations.ts"() {
     "use strict";
     MIGRATIONS = [
       {
@@ -24158,7 +24789,31 @@ var init_migrations = __esm({
   }
 });
 
-// src/lib/db/queries.ts
+// ../shared/persistence/src/db/result-mapper.ts
+function resultToRows(result) {
+  if (result.length === 0 || !result[0]) {
+    return [];
+  }
+  const { columns, values } = result[0];
+  return values.map((row) => {
+    const obj = {};
+    for (let i = 0; i < columns.length; i++) {
+      obj[columns[i]] = row[i];
+    }
+    return obj;
+  });
+}
+function resultToRow(result) {
+  const rows = resultToRows(result);
+  return rows[0];
+}
+var init_result_mapper = __esm({
+  "../shared/persistence/src/db/result-mapper.ts"() {
+    "use strict";
+  }
+});
+
+// ../shared/persistence/src/db/queries.ts
 function insertSession(db, params) {
   const {
     id,
@@ -24273,15 +24928,15 @@ function commitReasonClose(db, sessionId, reasonEvent, projectionUpdates) {
   });
 }
 var init_queries = __esm({
-  "src/lib/db/queries.ts"() {
+  "../shared/persistence/src/db/queries.ts"() {
     "use strict";
     init_result_mapper();
   }
 });
 
-// src/lib/db/reconcile.ts
-import { existsSync as existsSync10 } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join12, dirname as dirname5 } from "node:path";
+// ../shared/persistence/src/db/reconcile.ts
+import { existsSync as existsSync7 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join9, dirname as dirname5 } from "node:path";
 function hasTerminalArtifactEvent(db, sessionId, workflowType, currentRound, currentMapRun) {
   const eventType = workflowType === "map" ? "map_completed" : "round_completed";
   const round = workflowType === "map" ? currentMapRun : currentRound;
@@ -24322,7 +24977,7 @@ function hasInFlightDependents(db, sessionId) {
 function resolveSessionDir(ocrDir, sessionDir) {
   if (!sessionDir) return null;
   if (isAbsolute2(sessionDir)) return sessionDir;
-  return join12(dirname5(ocrDir), sessionDir);
+  return join9(dirname5(ocrDir), sessionDir);
 }
 function reconcileLegacyState(db, ocrDir, opts = {}) {
   const dryRun = opts.dryRun ?? false;
@@ -24334,8 +24989,8 @@ function reconcileLegacyState(db, ocrDir, opts = {}) {
       if (hasTerminalArtifactEvent(db, s.id, s.workflow_type, s.current_round, s.current_map_run) || hasReasonEvent(db, s.id)) {
         continue;
       }
-      const reviewFinal = s.workflow_type === "review" && dir ? existsSync10(join12(dir, "rounds", `round-${s.current_round}`, "final.md")) : false;
-      const mapFinal = s.workflow_type === "map" && dir ? existsSync10(join12(dir, "map", "runs", `run-${s.current_map_run}`, "map.md")) : false;
+      const reviewFinal = s.workflow_type === "review" && dir ? existsSync7(join9(dir, "rounds", `round-${s.current_round}`, "final.md")) : false;
+      const mapFinal = s.workflow_type === "map" && dir ? existsSync7(join9(dir, "map", "runs", `run-${s.current_map_run}`, "map.md")) : false;
       if (reviewFinal) {
         actions.push({
           sessionId: s.id,
@@ -24411,20 +25066,20 @@ function reconcileLegacyState(db, ocrDir, opts = {}) {
 }
 var DEFAULT_STALE_THRESHOLD_SECONDS;
 var init_reconcile = __esm({
-  "src/lib/db/reconcile.ts"() {
+  "../shared/persistence/src/db/reconcile.ts"() {
     "use strict";
     init_queries();
     DEFAULT_STALE_THRESHOLD_SECONDS = 7 * 24 * 60 * 60;
   }
 });
 
-// src/lib/db/liveness.ts
+// ../shared/persistence/src/db/liveness.ts
 function defaultIsAlive(pid) {
   try {
     process.kill(pid, 0);
     return true;
   } catch (err) {
-    return !(err instanceof Error && "code" in err && err.code === "ESRCH");
+    return !killErrorMeansDead(err);
   }
 }
 function sqliteUtcMs(ts) {
@@ -24433,16 +25088,17 @@ function sqliteUtcMs(ts) {
 }
 var PID_REUSE_GUARD_MS;
 var init_liveness = __esm({
-  "src/lib/db/liveness.ts"() {
+  "../shared/persistence/src/db/liveness.ts"() {
     "use strict";
+    init_src();
     PID_REUSE_GUARD_MS = 24 * 60 * 60 * 1e3;
   }
 });
 
-// src/lib/state/exit-codes.ts
+// ../shared/persistence/src/state/exit-codes.ts
 var STATE_EXIT, StateError, CANCELLED_EXIT_CODE, ORPHAN_EXIT_CODE, CASCADE_CLOSE_EXIT_CODE, WATCHDOG_DEADLINE_EXIT_CODE;
 var init_exit_codes = __esm({
-  "src/lib/state/exit-codes.ts"() {
+  "../shared/persistence/src/state/exit-codes.ts"() {
     "use strict";
     STATE_EXIT = {
       OK: 0,
@@ -24469,7 +25125,7 @@ var init_exit_codes = __esm({
   }
 });
 
-// src/lib/db/agent-sessions.ts
+// ../shared/persistence/src/db/agent-sessions.ts
 function cascadeTerminateExecutions(db, workflowId, exitCode, note) {
   db.run(
     `UPDATE command_executions
@@ -24640,6 +25296,9 @@ function bindVendorSessionIdOpportunistically(db, vendorSessionId) {
   );
   return candidate.uid ?? String(candidate.id);
 }
+function isSafeVendorSessionId(id) {
+  return SAFE_VENDOR_SESSION_ID.test(id);
+}
 function recordVendorSessionIdForExecution(db, executionId, vendorSessionId) {
   db.run(
     `UPDATE command_executions
@@ -24835,9 +25494,9 @@ function sweepStaleSessions(db, thresholdSeconds) {
   }
   return { closedSessionIds: rows.map((r) => r.id) };
 }
-var NOTE_ORPHAN_PREFIX, INSTANCE_COMMAND;
+var NOTE_ORPHAN_PREFIX, INSTANCE_COMMAND, SAFE_VENDOR_SESSION_ID;
 var init_agent_sessions = __esm({
-  "src/lib/db/agent-sessions.ts"() {
+  "../shared/persistence/src/db/agent-sessions.ts"() {
     "use strict";
     init_result_mapper();
     init_queries();
@@ -24845,18 +25504,19 @@ var init_agent_sessions = __esm({
     init_exit_codes();
     NOTE_ORPHAN_PREFIX = "orphaned by liveness sweep";
     INSTANCE_COMMAND = "session-instance";
+    SAFE_VENDOR_SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/;
   }
 });
 
-// src/lib/db/maintenance.ts
+// ../shared/persistence/src/db/maintenance.ts
 import {
-  existsSync as existsSync11,
-  readdirSync as readdirSync5,
+  existsSync as existsSync8,
+  readdirSync as readdirSync2,
   statSync,
   unlinkSync as unlinkSync3,
   copyFileSync
 } from "node:fs";
-import { dirname as dirname6, join as join13, basename as basename7 } from "node:path";
+import { dirname as dirname6, join as join10, basename as basename3 } from "node:path";
 function withForeignKeysDisabled(db, fn) {
   db.pragma("foreign_keys = OFF");
   try {
@@ -24883,7 +25543,7 @@ function foreignKeyViolationGroups(db) {
 function scanOrphanTempFiles(dataDir) {
   let entries;
   try {
-    entries = readdirSync5(dataDir);
+    entries = readdirSync2(dataDir);
   } catch {
     return [];
   }
@@ -24894,7 +25554,7 @@ function scanOrphanTempFiles(dataDir) {
     const pid = Number(m[1]);
     let ageMs = 0;
     try {
-      ageMs = Date.now() - statSync(join13(dataDir, name)).mtimeMs;
+      ageMs = Date.now() - statSync(join10(dataDir, name)).mtimeMs;
     } catch {
       continue;
     }
@@ -24913,7 +25573,7 @@ function scanOrphanTempFiles(dataDir) {
 function scanBackupFiles(dataDir, dbBase) {
   let entries;
   try {
-    entries = readdirSync5(dataDir);
+    entries = readdirSync2(dataDir);
   } catch {
     return [];
   }
@@ -24921,7 +25581,7 @@ function scanBackupFiles(dataDir, dbBase) {
   for (const name of entries) {
     if (!name.startsWith(`${dbBase}.bak`)) continue;
     try {
-      out.push({ name, sizeBytes: statSync(join13(dataDir, name)).size });
+      out.push({ name, sizeBytes: statSync(join10(dataDir, name)).size });
     } catch {
     }
   }
@@ -24929,7 +25589,7 @@ function scanBackupFiles(dataDir, dbBase) {
 }
 function collectDbHealth(db, dbPath) {
   const dataDir = dirname6(dbPath);
-  const dbBase = basename7(dbPath);
+  const dbBase = basename3(dbPath);
   const pageSize = scalarInt(db, "PRAGMA page_size");
   const pageCount = scalarInt(db, "PRAGMA page_count");
   const freelistCount = scalarInt(db, "PRAGMA freelist_count");
@@ -24941,7 +25601,7 @@ function collectDbHealth(db, dbPath) {
   const protectedFkViolations = allGroups.filter(
     (g) => PROTECTED_TABLES.has(g.table)
   );
-  const fileSizeBytes = existsSync11(dbPath) ? statSync(dbPath).size : 0;
+  const fileSizeBytes = existsSync8(dbPath) ? statSync(dbPath).size : 0;
   return {
     dbPath,
     fileSizeBytes,
@@ -24969,7 +25629,7 @@ function collectDbHealth(db, dbPath) {
 }
 function snapshotDb(db, dbPath, label = "doctor") {
   try {
-    if (!existsSync11(dbPath) || statSync(dbPath).size === 0) return null;
+    if (!existsSync8(dbPath) || statSync(dbPath).size === 0) return null;
     db.pragma("wal_checkpoint(TRUNCATE)");
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const bakPath = `${dbPath}.bak.${label}.${ts}`;
@@ -24984,7 +25644,7 @@ function reapOrphanDbFiles(dataDir) {
   for (const f of scanOrphanTempFiles(dataDir)) {
     if (!f.reapable) continue;
     try {
-      unlinkSync3(join13(dataDir, f.name));
+      unlinkSync3(join10(dataDir, f.name));
       reaped.push(f.name);
     } catch {
     }
@@ -24994,7 +25654,7 @@ function reapOrphanDbFiles(dataDir) {
 function reapStaleExecLogs(execLogsDir, maxAgeMs = SEVEN_DAYS_MS) {
   let entries;
   try {
-    entries = readdirSync5(execLogsDir);
+    entries = readdirSync2(execLogsDir);
   } catch {
     return [];
   }
@@ -25002,7 +25662,7 @@ function reapStaleExecLogs(execLogsDir, maxAgeMs = SEVEN_DAYS_MS) {
   const reaped = [];
   for (const name of entries) {
     if (!name.endsWith(".log")) continue;
-    const full = join13(execLogsDir, name);
+    const full = join10(execLogsDir, name);
     try {
       if (statSync(full).mtimeMs > cutoff) continue;
       unlinkSync3(full);
@@ -25020,11 +25680,11 @@ function pruneBackups(dataDir, dbPath, opts = {}) {
     );
   }
   const dryRun = opts.dryRun ?? false;
-  const dbBase = basename7(dbPath);
+  const dbBase = basename3(dbPath);
   const withMtime = [];
   for (const file of scanBackupFiles(dataDir, dbBase)) {
     try {
-      withMtime.push({ file, mtimeMs: statSync(join13(dataDir, file.name)).mtimeMs });
+      withMtime.push({ file, mtimeMs: statSync(join10(dataDir, file.name)).mtimeMs });
     } catch {
     }
   }
@@ -25035,7 +25695,7 @@ function pruneBackups(dataDir, dbPath, opts = {}) {
   if (!dryRun) {
     for (const b of toDelete) {
       try {
-        unlinkSync3(join13(dataDir, b.name));
+        unlinkSync3(join10(dataDir, b.name));
         deleted.push(b);
       } catch {
       }
@@ -25051,7 +25711,7 @@ function pruneBackups(dataDir, dbPath, opts = {}) {
 }
 function fixDb(db, dbPath, opts = {}) {
   const dataDir = dirname6(dbPath);
-  const sizeBeforeBytes = existsSync11(dbPath) ? statSync(dbPath).size : 0;
+  const sizeBeforeBytes = existsSync8(dbPath) ? statSync(dbPath).size : 0;
   const snapshotPath = opts.snapshot === false ? null : snapshotDb(db, dbPath, "doctor");
   const fkOrphansDeleted = [];
   withForeignKeysDisabled(db, () => {
@@ -25095,12 +25755,12 @@ function fixDb(db, dbPath, opts = {}) {
   };
 }
 function vacuumDb(db, dbPath, opts = {}) {
-  const sizeBeforeBytes = existsSync11(dbPath) ? statSync(dbPath).size : 0;
+  const sizeBeforeBytes = existsSync8(dbPath) ? statSync(dbPath).size : 0;
   const snapshotPath = opts.snapshot === false ? null : snapshotDb(db, dbPath, "vacuum");
   db.pragma("wal_checkpoint(TRUNCATE)");
   db.run("VACUUM");
   db.pragma("wal_checkpoint(TRUNCATE)");
-  const sizeAfterBytes = existsSync11(dbPath) ? statSync(dbPath).size : 0;
+  const sizeAfterBytes = existsSync8(dbPath) ? statSync(dbPath).size : 0;
   return {
     snapshotPath,
     sizeBeforeBytes,
@@ -25180,7 +25840,7 @@ function pruneDb(db, dbPath, opts = {}) {
 }
 var PROTECTED_TABLES, ORPHAN_SWEEPS, MARKDOWN_DEDUP_SQL, ONE_HOUR_MS, SEVEN_DAYS_MS;
 var init_maintenance = __esm({
-  "src/lib/db/maintenance.ts"() {
+  "../shared/persistence/src/db/maintenance.ts"() {
     "use strict";
     init_src();
     PROTECTED_TABLES = /* @__PURE__ */ new Set([
@@ -25255,24 +25915,24 @@ var init_maintenance = __esm({
   }
 });
 
-// src/lib/db/command-log.ts
-import { appendFileSync, existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync9, renameSync, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname7, join as join14 } from "node:path";
+// ../shared/persistence/src/db/command-log.ts
+import { appendFileSync, existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync7, renameSync, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname7, join as join11 } from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 function generateCommandUid() {
   return randomUUID2();
 }
 function cacheDir(ocrDir) {
-  return join14(ocrDir, "data", CACHE_DIR);
+  return join11(ocrDir, "data", CACHE_DIR);
 }
 function commandLogPath(ocrDir) {
-  return join14(cacheDir(ocrDir), FILENAME);
+  return join11(cacheDir(ocrDir), FILENAME);
 }
 function appendCommandLog(ocrDir, entry) {
   try {
     const filePath = commandLogPath(ocrDir);
     const dir = dirname7(filePath);
-    if (!existsSync12(dir)) mkdirSync4(dir, { recursive: true });
+    if (!existsSync9(dir)) mkdirSync4(dir, { recursive: true });
     const line = JSON.stringify(entry) + "\n";
     appendFileSync(filePath, line, { encoding: "utf-8" });
     if (approxLineCount >= 0) approxLineCount++;
@@ -25282,8 +25942,8 @@ function appendCommandLog(ocrDir, entry) {
 }
 function readCommandLog(ocrDir) {
   const filePath = commandLogPath(ocrDir);
-  if (!existsSync12(filePath)) return [];
-  const content = readFileSync9(filePath, "utf-8");
+  if (!existsSync9(filePath)) return [];
+  const content = readFileSync7(filePath, "utf-8");
   const entries = [];
   for (const line of content.split("\n")) {
     if (!line.trim()) continue;
@@ -25334,7 +25994,7 @@ function replayCommandLog(db, ocrDir) {
 function rotateIfNeeded(filePath) {
   try {
     if (approxLineCount >= 0 && approxLineCount <= MAX_LINES) return;
-    const content = readFileSync9(filePath, "utf-8");
+    const content = readFileSync7(filePath, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     approxLineCount = lines.length;
     if (approxLineCount <= MAX_LINES) return;
@@ -25348,7 +26008,7 @@ function rotateIfNeeded(filePath) {
 }
 var CACHE_DIR, FILENAME, MAX_LINES, KEEP_LINES, approxLineCount;
 var init_command_log = __esm({
-  "src/lib/db/command-log.ts"() {
+  "../shared/persistence/src/db/command-log.ts"() {
     "use strict";
     CACHE_DIR = ".cache";
     FILENAME = "command-history.jsonl";
@@ -25358,7 +26018,7 @@ var init_command_log = __esm({
   }
 });
 
-// src/lib/db/index.ts
+// ../shared/persistence/src/db/index.ts
 var db_exports = {};
 __export(db_exports, {
   CANCELLED_EXIT_CODE: () => CANCELLED_EXIT_CODE,
@@ -25366,6 +26026,7 @@ __export(db_exports, {
   MIGRATIONS: () => MIGRATIONS,
   ORPHAN_EXIT_CODE: () => ORPHAN_EXIT_CODE,
   PID_REUSE_GUARD_MS: () => PID_REUSE_GUARD_MS,
+  SAFE_VENDOR_SESSION_ID: () => SAFE_VENDOR_SESSION_ID,
   STATE_EXIT: () => STATE_EXIT,
   StateError: () => StateError,
   WATCHDOG_DEADLINE_EXIT_CODE: () => WATCHDOG_DEADLINE_EXIT_CODE,
@@ -25398,6 +26059,7 @@ __export(db_exports, {
   insertEvent: () => insertEvent,
   insertSession: () => insertSession,
   isBusyError: () => isBusyError,
+  isSafeVendorSessionId: () => isSafeVendorSessionId,
   linkDashboardInvocationToWorkflow: () => linkDashboardInvocationToWorkflow,
   listAgentSessionsForWorkflow: () => listAgentSessionsForWorkflow,
   openDatabase: () => openDatabase,
@@ -25428,7 +26090,7 @@ __export(db_exports, {
   withForeignKeysDisabled: () => withForeignKeysDisabled
 });
 import {
-  existsSync as existsSync13,
+  existsSync as existsSync10,
   mkdirSync as mkdirSync5,
   copyFileSync as copyFileSync2,
   statSync as statSync2,
@@ -25436,13 +26098,13 @@ import {
   rmSync
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname as dirname8, join as join15 } from "node:path";
+import { dirname as dirname8, join as join12 } from "node:path";
 function maybeSnapshotBeforeUpgrade(db, dbPath, fromVersion) {
   if (fromVersion < 1 || fromVersion >= V2_SCHEMA_VERSION) return null;
   const bakPath = `${dbPath}.bak.v${fromVersion}`;
-  if (existsSync13(bakPath)) return bakPath;
+  if (existsSync10(bakPath)) return bakPath;
   try {
-    if (!existsSync13(dbPath) || statSync2(dbPath).size === 0) return null;
+    if (!existsSync10(dbPath) || statSync2(dbPath).size === 0) return null;
     db.pragma("wal_checkpoint(TRUNCATE)");
     copyFileSync2(dbPath, bakPath);
     return bakPath;
@@ -25478,7 +26140,7 @@ async function openDatabase(dbPath) {
     return cached;
   }
   const dir = dirname8(dbPath);
-  if (!existsSync13(dir)) {
+  if (!existsSync10(dir)) {
     mkdirSync5(dir, { recursive: true });
   }
   const db = openEngine(dbPath);
@@ -25486,15 +26148,15 @@ async function openDatabase(dbPath) {
   return db;
 }
 async function getDb(ocrDir) {
-  const dbPath = join15(ocrDir, "data", "ocr.db");
+  const dbPath = join12(ocrDir, "data", "ocr.db");
   return openDatabase(dbPath);
 }
 async function ensureDatabase(ocrDir) {
-  const dataDir = join15(ocrDir, "data");
-  if (!existsSync13(dataDir)) {
+  const dataDir = join12(ocrDir, "data");
+  if (!existsSync10(dataDir)) {
     mkdirSync5(dataDir, { recursive: true });
   }
-  const dbPath = join15(dataDir, "ocr.db");
+  const dbPath = join12(dataDir, "ocr.db");
   const db = await openDatabase(dbPath);
   let before = 0;
   try {
@@ -25522,7 +26184,7 @@ async function ensureDatabase(ocrDir) {
   return db;
 }
 function walCheckpointTruncate(dbPath) {
-  if (!existsSync13(dbPath)) {
+  if (!existsSync10(dbPath)) {
     return "skipped";
   }
   const cached = connections.get(dbPath);
@@ -25564,8 +26226,8 @@ function closeAllDatabases() {
 function probeWrite() {
   let dir;
   try {
-    dir = mkdtempSync(join15(tmpdir(), "ocr-probe-"));
-    const db = openEngine(join15(dir, "probe.db"));
+    dir = mkdtempSync(join12(tmpdir(), "ocr-probe-"));
+    const db = openEngine(join12(dir, "probe.db"));
     try {
       db.run("CREATE TABLE _probe_write (id INTEGER PRIMARY KEY, v TEXT)");
       db.transaction(() => {
@@ -25598,7 +26260,7 @@ function rmDirBestEffort(dir) {
 }
 var V2_SCHEMA_VERSION, connections;
 var init_db = __esm({
-  "src/lib/db/index.ts"() {
+  "../shared/persistence/src/db/index.ts"() {
     "use strict";
     init_engine();
     init_migrations();
@@ -26367,7 +27029,7 @@ if (process.platform === "linux") {
 // ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
 var processOk = (process13) => !!process13 && typeof process13 === "object" && typeof process13.removeListener === "function" && typeof process13.emit === "function" && typeof process13.reallyExit === "function" && typeof process13.listeners === "function" && typeof process13.kill === "function" && typeof process13.pid === "number" && typeof process13.on === "function";
 var kExitEmitter = Symbol.for("signal-exit emitter");
-var global = globalThis;
+var global2 = globalThis;
 var ObjectDefineProperty = Object.defineProperty.bind(Object);
 var Emitter = class {
   emitted = {
@@ -26381,10 +27043,10 @@ var Emitter = class {
   count = 0;
   id = Math.random();
   constructor() {
-    if (global[kExitEmitter]) {
-      return global[kExitEmitter];
+    if (global2[kExitEmitter]) {
+      return global2[kExitEmitter];
     }
-    ObjectDefineProperty(global, kExitEmitter, {
+    ObjectDefineProperty(global2, kExitEmitter, {
       value: this,
       writable: false,
       enumerable: false,
@@ -29358,10 +30020,11 @@ function ensureGitignore(ocrDir) {
   writeFileSync2(gitignorePath, content);
 }
 
-// src/lib/team-config.ts
+// ../shared/config/src/team-config.ts
 var import_yaml = __toESM(require_dist(), 1);
 import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
 import { join as join2 } from "node:path";
+var MAX_INSTANCES_PER_PERSONA = 50;
 function loadTeamConfig(ocrDir) {
   const configPath = join2(ocrDir, "config.yaml");
   if (!existsSync2(configPath)) {
@@ -29403,6 +30066,9 @@ function parseTeamConfigYaml(content) {
         aliases,
         defaultModel
       );
+      if (resolvedModel !== null) {
+        assertSafeModelId(resolvedModel, `default_team.${persona}[${i}]`);
+      }
       team.push({
         persona,
         instance_index: i + 1,
@@ -29420,6 +30086,11 @@ function parseEntry(persona, entry) {
         `default_team.${persona}: count must be a positive integer (got ${entry})`
       );
     }
+    if (entry > MAX_INSTANCES_PER_PERSONA) {
+      throw new Error(
+        `default_team.${persona}: count must be <= ${MAX_INSTANCES_PER_PERSONA} (got ${entry})`
+      );
+    }
     return Array.from({ length: entry }, () => ({}));
   }
   if (Array.isArray(entry)) {
@@ -29428,6 +30099,11 @@ function parseEntry(persona, entry) {
         `default_team.${persona}: list form must contain at least one instance`
       );
     }
+    if (entry.length > MAX_INSTANCES_PER_PERSONA) {
+      throw new Error(
+        `default_team.${persona}: list form must contain <= ${MAX_INSTANCES_PER_PERSONA} instances (got ${entry.length})`
+      );
+    }
     return entry.map((item, idx) => parseListItem(persona, idx, item));
   }
   if (entry && typeof entry === "object") {
@@ -29449,6 +30125,11 @@ function parseEntry(persona, entry) {
         `default_team.${persona}: count must be a positive integer (got ${String(count)})`
       );
     }
+    if (count > MAX_INSTANCES_PER_PERSONA) {
+      throw new Error(
+        `default_team.${persona}: count must be <= ${MAX_INSTANCES_PER_PERSONA} (got ${count})`
+      );
+    }
     const teamModel = readOptionalString(obj, "model", `default_team.${persona}.model`);
     return Array.from({ length: count }, () => ({ teamModel }));
   }
@@ -29483,6 +30164,16 @@ function readOptionalString(obj, key, pathLabel) {
   }
   return value;
 }
+var SAFE_MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._/:@[\]+-]{0,255}$/;
+function assertSafeModelId(value, pathLabel) {
+  if (SAFE_MODEL_ID.test(value)) return;
+  const allowed = /[A-Za-z0-9._/:@[\]+-]/;
+  const offending = [...value].find((ch) => !allowed.test(ch));
+  const detail = value.length === 0 ? "empty string" : value.length > 256 ? "longer than 256 characters" : offending !== void 0 ? `contains ${JSON.stringify(offending)}` : `starts with ${JSON.stringify(value[0])}`;
+  throw new Error(
+    `${pathLabel}: model id ${detail} \u2014 no vendor model id uses that. Allowed: letters and digits plus . _ / : @ [ ] + - (max 256 chars).`
+  );
+}
 function readAliases(root) {
   const models = root["models"];
   if (!models || typeof models !== "object" || Array.isArray(models)) return {};
@@ -29524,10 +30215,78 @@ function resolveTeamComposition(team, override) {
     result.push(inst);
   }
   for (const inst of override) {
+    if (inst.model !== null) {
+      assertSafeModelId(inst.model, `override ${inst.persona}#${inst.instance_index}`);
+    }
     result.push(inst);
   }
   return result;
 }
+var REVIEWER_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function parseTeamSpec(spec, aliases = {}, defaultModel = null) {
+  const trimmed = spec.trim();
+  if (trimmed.length === 0) {
+    throw new Error(
+      "--team spec is empty; expected reviewer-id:count[,reviewer-id:count...]"
+    );
+  }
+  const model = resolveModel(null, null, aliases, defaultModel);
+  if (model !== null) assertSafeModelId(model, "--team");
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const rawEntry of trimmed.split(",")) {
+    const entry = rawEntry.trim();
+    if (entry.length === 0) {
+      throw new Error(
+        `--team has an empty entry (stray or trailing comma) in "${spec}"`
+      );
+    }
+    const colon = entry.indexOf(":");
+    if (colon === -1) {
+      throw new Error(
+        `--team entry "${entry}" must be "reviewer-id:count" \u2014 the :count is required`
+      );
+    }
+    const persona = entry.slice(0, colon).trim();
+    const countRaw = entry.slice(colon + 1).trim();
+    if (!REVIEWER_ID_PATTERN.test(persona)) {
+      throw new Error(
+        `--team reviewer id "${persona}" is invalid; expected lowercase letters, digits, and single hyphens (e.g. principal, martin-fowler)`
+      );
+    }
+    if (seen.has(persona)) {
+      throw new Error(
+        `--team lists "${persona}" more than once; combine its instances into a single entry (e.g. ${persona}:2)`
+      );
+    }
+    if (!/^[0-9]+$/.test(countRaw)) {
+      throw new Error(
+        `--team count for "${persona}" must be a positive integer (got "${countRaw}")`
+      );
+    }
+    const count = Number(countRaw);
+    if (count < 1) {
+      throw new Error(
+        `--team count for "${persona}" must be a positive integer (got ${count})`
+      );
+    }
+    if (count > MAX_INSTANCES_PER_PERSONA) {
+      throw new Error(
+        `--team count for "${persona}" must be <= ${MAX_INSTANCES_PER_PERSONA} (got ${count})`
+      );
+    }
+    seen.add(persona);
+    for (let i = 0; i < count; i++) {
+      result.push({
+        persona,
+        instance_index: i + 1,
+        name: `${persona}-${i + 1}`,
+        model
+      });
+    }
+  }
+  return result;
+}
 
 // src/lib/installer.ts
 init_src();
@@ -30092,7 +30851,7 @@ ${hint}
 }
 
 // src/lib/version.ts
-var CLI_VERSION = true ? "2.2.1" : createRequire(import.meta.url)("../../package.json").version;
+var CLI_VERSION = true ? "2.4.0" : createRequire(import.meta.url)("../../package.json").version;
 
 // src/lib/deps.ts
 init_src();
@@ -33026,12 +33785,12 @@ function getStrategy(workflowType) {
 }
 
 // src/lib/progress/detector.ts
-import { existsSync as existsSync7, readdirSync as readdirSync2 } from "node:fs";
-import { join as join9, basename as basename4 } from "node:path";
+import { existsSync as existsSync11, readdirSync as readdirSync3 } from "node:fs";
+import { join as join13, basename as basename5 } from "node:path";
 
 // src/lib/progress/session-reader.ts
-init_result_mapper();
-import { basename as basename3 } from "node:path";
+init_db();
+import { basename as basename4 } from "node:path";
 var cachedDb = null;
 function setProgressDb(db) {
   cachedDb = db;
@@ -33050,7 +33809,7 @@ function readSessionState(sessionPath) {
   }
 }
 function readFromSqlite(sessionPath, db) {
-  const sessionId = basename3(sessionPath);
+  const sessionId = basename4(sessionPath);
   let row = resultToRow(
     db.exec("SELECT * FROM sessions WHERE id = ?", [sessionId])
   );
@@ -33085,7 +33844,7 @@ function detectWorkflowType(sessionPath, explicitType) {
   const db = getProgressDb();
   if (db) {
     try {
-      const sessionId = basename4(sessionPath);
+      const sessionId = basename5(sessionPath);
       const result = db.exec(
         "SELECT workflow_type FROM sessions WHERE id = ?",
         [sessionId]
@@ -33098,8 +33857,8 @@ function detectWorkflowType(sessionPath, explicitType) {
     } catch {
     }
   }
-  const hasMapDir = existsSync7(join9(sessionPath, "map"));
-  const hasRoundsDir = existsSync7(join9(sessionPath, "rounds"));
+  const hasMapDir = existsSync11(join13(sessionPath, "map"));
+  const hasRoundsDir = existsSync11(join13(sessionPath, "rounds"));
   if (hasMapDir && !hasRoundsDir) {
     return "map";
   }
@@ -33109,7 +33868,7 @@ function detectWorkflowType(sessionPath, explicitType) {
   if (hasMapDir && hasRoundsDir) {
     if (db) {
       try {
-        const sessionId = basename4(sessionPath);
+        const sessionId = basename5(sessionPath);
         const result = db.exec(
           "SELECT current_phase FROM sessions WHERE id = ?",
           [sessionId]
@@ -33133,7 +33892,7 @@ function isSessionActive(sessionPath) {
   const db = getProgressDb();
   if (db) {
     try {
-      const sessionId = basename4(sessionPath);
+      const sessionId = basename5(sessionPath);
       const result = db.exec(
         "SELECT status, current_phase FROM sessions WHERE id = ?",
         [sessionId]
@@ -33155,28 +33914,28 @@ function isSessionActive(sessionPath) {
 }
 function detectActiveWorkflows(sessionPath) {
   const activeWorkflows = [];
-  const hasRoundsDir = existsSync7(join9(sessionPath, "rounds"));
+  const hasRoundsDir = existsSync11(join13(sessionPath, "rounds"));
   if (hasRoundsDir) {
-    const roundsDir = join9(sessionPath, "rounds");
-    const rounds = existsSync7(roundsDir) ? readdirSync2(roundsDir).filter((d) => d.match(/^round-\d+$/)).sort() : [];
+    const roundsDir = join13(sessionPath, "rounds");
+    const rounds = existsSync11(roundsDir) ? readdirSync3(roundsDir).filter((d) => d.match(/^round-\d+$/)).sort() : [];
     if (rounds.length > 0) {
       const latestRound = rounds[rounds.length - 1];
-      const finalPath = join9(roundsDir, latestRound, "final.md");
-      if (!existsSync7(finalPath)) {
+      const finalPath = join13(roundsDir, latestRound, "final.md");
+      if (!existsSync11(finalPath)) {
         activeWorkflows.push("review");
       }
     } else {
       activeWorkflows.push("review");
     }
   }
-  const hasMapDir = existsSync7(join9(sessionPath, "map"));
+  const hasMapDir = existsSync11(join13(sessionPath, "map"));
   if (hasMapDir) {
-    const runsDir = join9(sessionPath, "map", "runs");
-    const runs = existsSync7(runsDir) ? readdirSync2(runsDir).filter((d) => d.match(/^run-\d+$/)).sort() : [];
+    const runsDir = join13(sessionPath, "map", "runs");
+    const runs = existsSync11(runsDir) ? readdirSync3(runsDir).filter((d) => d.match(/^run-\d+$/)).sort() : [];
     if (runs.length > 0) {
       const latestRun = runs[runs.length - 1];
-      const mapPath = join9(runsDir, latestRun, "map.md");
-      if (!existsSync7(mapPath)) {
+      const mapPath = join13(runsDir, latestRun, "map.md");
+      if (!existsSync11(mapPath)) {
         activeWorkflows.push("map");
       }
     } else {
@@ -33187,7 +33946,7 @@ function detectActiveWorkflows(sessionPath) {
     const db = getProgressDb();
     if (db) {
       try {
-        const sessionId = basename4(sessionPath);
+        const sessionId = basename5(sessionPath);
         const result = db.exec(
           "SELECT workflow_type, current_phase FROM sessions WHERE id = ?",
           [sessionId]
@@ -33255,8 +34014,8 @@ function padLines(lines) {
 }
 
 // src/lib/progress/review-strategy.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync7 } from "node:fs";
-import { join as join10, basename as basename5 } from "node:path";
+import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync8 } from "node:fs";
+import { join as join14, basename as basename6 } from "node:path";
 var REVIEW_PHASES = [
   { key: "context", label: "Context Discovery" },
   { key: "change-context", label: "Change Context" },
@@ -33268,10 +34027,10 @@ var REVIEW_PHASES = [
   { key: "complete", label: "Complete" }
 ];
 function countFindings(filePath) {
-  if (!existsSync8(filePath)) {
+  if (!existsSync12(filePath)) {
     return 0;
   }
-  const content = readFileSync7(filePath, "utf-8");
+  const content = readFileSync8(filePath, "utf-8");
   const findingMatches = content.match(/^##\s+(Finding|Issue|Suggestion)/gm);
   return findingMatches?.length ?? 0;
 }
@@ -33285,27 +34044,27 @@ function formatReviewerName(filename) {
   return base.charAt(0).toUpperCase() + base.slice(1);
 }
 function deriveRoundsFromFilesystem(roundsDir) {
-  if (!existsSync8(roundsDir)) {
+  if (!existsSync12(roundsDir)) {
     return [];
   }
-  const roundDirs = readdirSync3(roundsDir).filter((d) => d.match(/^round-\d+$/)).sort((a, b) => {
+  const roundDirs = readdirSync4(roundsDir).filter((d) => d.match(/^round-\d+$/)).sort((a, b) => {
     const numA = parseInt(a.replace("round-", ""));
     const numB = parseInt(b.replace("round-", ""));
     return numA - numB;
   });
   return roundDirs.map((dir) => {
     const roundNum = parseInt(dir.replace("round-", ""));
-    const roundPath = join10(roundsDir, dir);
-    const reviewsPath = join10(roundPath, "reviews");
-    const finalPath = join10(roundPath, "final.md");
+    const roundPath = join14(roundsDir, dir);
+    const reviewsPath = join14(roundPath, "reviews");
+    const finalPath = join14(roundPath, "final.md");
     const reviewers = [];
-    if (existsSync8(reviewsPath)) {
-      const files = readdirSync3(reviewsPath).filter((f) => f.endsWith(".md"));
+    if (existsSync12(reviewsPath)) {
+      const files = readdirSync4(reviewsPath).filter((f) => f.endsWith(".md"));
       reviewers.push(...files.map((f) => f.replace(".md", "")));
     }
     return {
       round: roundNum,
-      isComplete: existsSync8(finalPath),
+      isComplete: existsSync12(finalPath),
       reviewers
     };
   });
@@ -33315,7 +34074,7 @@ var ReviewProgressStrategy = class {
   phases = REVIEW_PHASES;
   totalPhases = 8;
   parseState(sessionPath, preservedStartTime) {
-    const session = basename5(sessionPath);
+    const session = basename6(sessionPath);
     const state = readSessionState(sessionPath);
     if (!state) {
       return null;
@@ -33334,19 +34093,19 @@ var ReviewProgressStrategy = class {
   parseFromState(session, state, sessionPath, preservedStartTime) {
     const effectiveStartTime = state.round_started_at ?? state.started_at;
     const startTime = preservedStartTime ?? (effectiveStartTime ? new Date(effectiveStartTime).getTime() : Date.now());
-    const roundsDir = join10(sessionPath, "rounds");
+    const roundsDir = join14(sessionPath, "rounds");
     const rounds = deriveRoundsFromFilesystem(roundsDir);
     const highestExistingRound = rounds.length > 0 ? Math.max(...rounds.map((r) => r.round)) : 1;
     const stateRound = state.current_round ?? 1;
     const currentRound = Math.min(stateRound, highestExistingRound);
-    const currentRoundDir = join10(roundsDir, `round-${currentRound}`);
-    const reviewsDir = join10(currentRoundDir, "reviews");
+    const currentRoundDir = join14(roundsDir, `round-${currentRound}`);
+    const reviewsDir = join14(currentRoundDir, "reviews");
     const reviewers = [];
-    if (existsSync8(reviewsDir)) {
-      const entries = readdirSync3(reviewsDir);
+    if (existsSync12(reviewsDir)) {
+      const entries = readdirSync4(reviewsDir);
       const reviewFiles = entries.filter((f) => f.endsWith(".md"));
       for (const file of reviewFiles) {
-        const reviewPath = join10(reviewsDir, file);
+        const reviewPath = join14(reviewsDir, file);
         const findings = countFindings(reviewPath);
         reviewers.push({
           name: file.replace(".md", ""),
@@ -33356,14 +34115,14 @@ var ReviewProgressStrategy = class {
         });
       }
     }
-    const contextComplete = existsSync8(
-      join10(sessionPath, "discovered-standards.md")
+    const contextComplete = existsSync12(
+      join14(sessionPath, "discovered-standards.md")
     );
-    const changeContextComplete = existsSync8(join10(sessionPath, "context.md"));
+    const changeContextComplete = existsSync12(join14(sessionPath, "context.md"));
     const analysisComplete = changeContextComplete;
     const reviewsComplete = state.phase_number > 4;
-    const discourseComplete = existsSync8(join10(currentRoundDir, "discourse.md"));
-    const synthesisComplete = existsSync8(join10(currentRoundDir, "final.md"));
+    const discourseComplete = existsSync12(join14(currentRoundDir, "discourse.md"));
+    const synthesisComplete = existsSync12(join14(currentRoundDir, "final.md"));
     return {
       workflowType: "review",
       session,
@@ -33495,8 +34254,8 @@ var ReviewProgressStrategy = class {
 var reviewStrategy = new ReviewProgressStrategy();
 
 // src/lib/progress/map-strategy.ts
-import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync8 } from "node:fs";
-import { join as join11, basename as basename6 } from "node:path";
+import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync9 } from "node:fs";
+import { join as join15, basename as basename7 } from "node:path";
 var MAP_PHASES = [
   { key: "map-context", label: "Context Discovery" },
   { key: "topology", label: "Topology Analysis" },
@@ -33506,23 +34265,23 @@ var MAP_PHASES = [
   { key: "complete", label: "Complete" }
 ];
 function deriveRunsFromFilesystem(mapDir) {
-  const runsDir = join11(mapDir, "runs");
-  if (!existsSync9(runsDir)) {
+  const runsDir = join15(mapDir, "runs");
+  if (!existsSync13(runsDir)) {
     return [];
   }
-  const runDirs = readdirSync4(runsDir).filter((d) => d.match(/^run-\d+$/)).sort((a, b) => {
+  const runDirs = readdirSync5(runsDir).filter((d) => d.match(/^run-\d+$/)).sort((a, b) => {
     const numA = parseInt(a.replace("run-", ""));
     const numB = parseInt(b.replace("run-", ""));
     return numA - numB;
   });
   return runDirs.map((dir) => {
     const runNum = parseInt(dir.replace("run-", ""));
-    const runPath = join11(runsDir, dir);
-    const mapPath = join11(runPath, "map.md");
+    const runPath = join15(runsDir, dir);
+    const mapPath = join15(runPath, "map.md");
     let fileCount = 0;
-    const topologyPath = join11(runPath, "topology.md");
-    if (existsSync9(topologyPath)) {
-      const content = readFileSync8(topologyPath, "utf-8");
+    const topologyPath = join15(runPath, "topology.md");
+    if (existsSync13(topologyPath)) {
+      const content = readFileSync9(topologyPath, "utf-8");
       const fileListMatch = content.match(
         /## Canonical File List[\s\S]*?```([\s\S]*?)```/
       );
@@ -33532,7 +34291,7 @@ function deriveRunsFromFilesystem(mapDir) {
     }
     return {
       run: runNum,
-      isComplete: existsSync9(mapPath),
+      isComplete: existsSync13(mapPath),
       fileCount
     };
   });
@@ -33542,7 +34301,7 @@ var MapProgressStrategy = class {
   phases = MAP_PHASES;
   totalPhases = 6;
   parseState(sessionPath, preservedStartTime) {
-    const session = basename6(sessionPath);
+    const session = basename7(sessionPath);
     const state = readSessionState(sessionPath);
     if (!state) {
       return null;
@@ -33564,24 +34323,24 @@ var MapProgressStrategy = class {
   parseFromState(session, state, sessionPath, preservedStartTime) {
     const effectiveStartTime = state.map_started_at ?? state.started_at;
     const startTime = preservedStartTime ?? (effectiveStartTime ? new Date(effectiveStartTime).getTime() : Date.now());
-    const mapDir = join11(sessionPath, "map");
+    const mapDir = join15(sessionPath, "map");
     const runs = deriveRunsFromFilesystem(mapDir);
     const highestExistingRun = runs.length > 0 ? Math.max(...runs.map((r) => r.run)) : 1;
     const stateRun = state.current_map_run ?? 1;
     const currentRun = Math.min(stateRun, highestExistingRun);
-    const currentRunDir = join11(mapDir, "runs", `run-${currentRun}`);
-    const contextComplete = existsSync9(
-      join11(sessionPath, "discovered-standards.md")
+    const currentRunDir = join15(mapDir, "runs", `run-${currentRun}`);
+    const contextComplete = existsSync13(
+      join15(sessionPath, "discovered-standards.md")
     );
-    const topologyComplete = existsSync9(join11(currentRunDir, "topology.md"));
-    const flowAnalysisComplete = existsSync9(
-      join11(currentRunDir, "flow-analysis.md")
+    const topologyComplete = existsSync13(join15(currentRunDir, "topology.md"));
+    const flowAnalysisComplete = existsSync13(
+      join15(currentRunDir, "flow-analysis.md")
     );
-    const requirementsMappingComplete = existsSync9(
-      join11(currentRunDir, "requirements-mapping.md")
+    const requirementsMappingComplete = existsSync13(
+      join15(currentRunDir, "requirements-mapping.md")
     );
-    const synthesisComplete = existsSync9(join11(currentRunDir, "map.md"));
-    const hasRequirements = existsSync9(join11(sessionPath, "requirements.md"));
+    const synthesisComplete = existsSync13(join15(currentRunDir, "map.md"));
+    const hasRequirements = existsSync13(join15(sessionPath, "requirements.md"));
     const flowAnalysts = flowAnalysisComplete ? [
       {
         name: "flow-analyst",
@@ -34036,10 +34795,10 @@ function renderCombinedProgress(sessionPath, preservedStartTimes, ocrDir) {
 }
 
 // src/commands/state.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync11 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync7, readFileSync as readFileSync12, readdirSync as readdirSync8 } from "node:fs";
+import { join as join19 } from "node:path";
 
-// src/lib/state/index.ts
+// ../shared/persistence/src/state/index.ts
 init_db();
 init_exit_codes();
 import {
@@ -34052,7 +34811,7 @@ import {
 } from "node:fs";
 import { join as join17 } from "node:path";
 
-// src/lib/state/phase-graph.ts
+// ../shared/persistence/src/state/phase-graph.ts
 init_exit_codes();
 var REVIEW_PHASE_NUMBERS = {
   context: 1,
@@ -34134,7 +34893,7 @@ function validatePhaseTransition(workflowType, source, target, isRoundBoundary)
   }
 }
 
-// src/lib/state/meta-util.ts
+// ../shared/persistence/src/state/meta-util.ts
 var DEFAULT_METADATA_MAX_LEN = 4096;
 function sanitizeMetadataString(s, opts = {}) {
   const maxLen = opts.maxLen ?? DEFAULT_METADATA_MAX_LEN;
@@ -34144,9 +34903,11 @@ function sanitizeMetadataString(s, opts = {}) {
   return out;
 }
 
-// src/lib/state/round-meta.ts
+// ../shared/persistence/src/state/round-meta.ts
+init_src();
 var VALID_CATEGORIES = /* @__PURE__ */ new Set(["blocker", "should_fix", "suggestion", "style"]);
 var VALID_SEVERITIES = /* @__PURE__ */ new Set(["critical", "high", "medium", "low", "info"]);
+var MIN_TITLE_LEN = 8;
 function validateRoundMeta(meta) {
   if (!meta || typeof meta !== "object") {
     throw new Error("round-meta.json must be a JSON object");
@@ -34157,10 +34918,16 @@ function validateRoundMeta(meta) {
       `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 (typeof obj.verdict !== "string") {
+    throw new Error("round-meta.json must contain a verdict string");
   }
-  obj.verdict = sanitizeMetadataString(obj.verdict);
+  const verdict = sanitizeMetadataString(obj.verdict).trim();
+  if (!isCanonicalVerdict(verdict)) {
+    throw new Error(
+      `round-meta.json verdict "${String(obj.verdict)}" is not one of: ${CANONICAL_VERDICTS.join(", ")}`
+    );
+  }
+  obj.verdict = verdict;
   if (!Array.isArray(obj.reviewers)) {
     throw new Error("round-meta.json must contain a reviewers array");
   }
@@ -34183,8 +34950,10 @@ function validateRoundMeta(meta) {
         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.title !== "string" || f.title.trim().length < MIN_TITLE_LEN) {
+        throw new Error(
+          `Each finding title must be at least ${MIN_TITLE_LEN} characters; got "${String(f.title)}"`
+        );
       }
       f.title = sanitizeMetadataString(f.title);
       if (typeof f.category !== "string" || !VALID_CATEGORIES.has(f.category)) {
@@ -34229,25 +34998,144 @@ function validateRoundMeta(meta) {
     if (typeof sc.suggestions !== "number" || sc.suggestions < 0) {
       throw new Error("synthesis_counts.suggestions must be a non-negative number");
     }
+    const allFindings = obj.reviewers.flatMap((reviewer) => reviewer.findings);
+    const derived = deriveCounts(allFindings);
+    if (sc.blockers > derived.blocker) {
+      throw new Error(
+        `synthesis_counts.blockers (${sc.blockers}) exceeds the ${derived.blocker} blocker finding(s) present`
+      );
+    }
+    if (sc.should_fix > derived.should_fix) {
+      throw new Error(
+        `synthesis_counts.should_fix (${sc.should_fix}) exceeds the ${derived.should_fix} should_fix finding(s) present`
+      );
+    }
+    if (sc.suggestions > derived.suggestion) {
+      throw new Error(
+        `synthesis_counts.suggestions (${sc.suggestions}) exceeds the ${derived.suggestion} suggestion finding(s) present`
+      );
+    }
+  }
+  const { blockerCount } = resolveRoundCounts(obj);
+  if (verdict === "APPROVE" && blockerCount > 0) {
+    throw new Error(
+      `round-meta.json verdict "APPROVE" is inconsistent with ${blockerCount} blocker finding(s); APPROVE requires zero blockers (use "REQUEST CHANGES", or carry residual work as should_fix/suggestion/style)`
+    );
+  }
+  if (verdict === "REQUEST CHANGES" && blockerCount === 0) {
+    throw new Error(
+      `round-meta.json verdict "REQUEST CHANGES" requires at least one blocker finding; found ${blockerCount} (use "APPROVE" if there is nothing to block on, or "NEEDS DISCUSSION")`
+    );
   }
   return meta;
 }
 function computeRoundCounts(meta) {
-  const allFindings = [];
-  for (const reviewer of meta.reviewers) {
-    allFindings.push(...reviewer.findings);
+  return resolveRoundCounts(meta);
+}
+
+// ../shared/persistence/src/state/forward-resume.ts
+init_db();
+init_liveness();
+var FORWARD_RESUME_KIND = "forward_resume";
+var FORWARD_RESUME_EXHAUSTED_REASON = "forward_resume_exhausted";
+function parseLeaseMetadata(e) {
+  if (e.event_type !== "session_resumed" || !e.metadata) return null;
+  try {
+    return JSON.parse(e.metadata);
+  } catch {
+    return null;
+  }
+}
+function remainingPhasesAfter(workflowType, currentPhase) {
+  const numbers = workflowType === "map" ? MAP_PHASE_NUMBERS : REVIEW_PHASE_NUMBERS;
+  const cur = numbers[currentPhase];
+  if (cur === void 0) return [];
+  return Object.entries(numbers).filter(([, n]) => n > cur).sort((a, b) => a[1] - b[1]).map(([phase]) => phase);
+}
+function countForwardResumeLeases(events, round) {
+  return events.filter((e) => parseLeaseMetadata(e)?.kind === FORWARD_RESUME_KIND && parseLeaseMetadata(e)?.round === round).length;
+}
+function forwardResumeLeaseState(events, round, leaseMs, nowMs) {
+  const leases = events.filter(
+    (e) => parseLeaseMetadata(e)?.kind === FORWARD_RESUME_KIND && parseLeaseMetadata(e)?.round === round
+  );
+  if (leases.length === 0) return { leaseCount: 0, activeLeaseHeld: false };
+  const latestLease = leases[leases.length - 1];
+  const latestLeaseMs = sqliteUtcMs(latestLease.created_at);
+  let effectiveMs = latestLeaseMs;
+  for (const e of events) {
+    if (e.event_type === "phase_transition" && (e.round == null || e.round === round)) {
+      const t = sqliteUtcMs(e.created_at);
+      if (t >= latestLeaseMs && t > effectiveMs) effectiveMs = t;
+    }
   }
-  const sc = meta.synthesis_counts;
   return {
-    blockerCount: sc ? sc.blockers : allFindings.filter((f) => f.category === "blocker").length,
-    shouldFixCount: sc ? sc.should_fix : allFindings.filter((f) => f.category === "should_fix").length,
-    suggestionCount: sc ? sc.suggestions : allFindings.filter((f) => f.category === "suggestion").length,
-    reviewerCount: meta.reviewers.length,
-    totalFindingCount: allFindings.length
+    leaseCount: leases.length,
+    activeLeaseHeld: nowMs - effectiveMs < leaseMs
+  };
+}
+function tryAcquireForwardResumeLease(db, sessionId, round, opts) {
+  const nowMs = opts.nowMs ?? Date.now();
+  return db.transaction(() => {
+    const events = getEventsForSession(db, sessionId);
+    const { leaseCount, activeLeaseHeld } = forwardResumeLeaseState(
+      events,
+      round,
+      opts.leaseMs,
+      nowMs
+    );
+    if (leaseCount >= opts.maxAttempts) {
+      return { acquired: false, reason: "cap_exhausted", attemptsUsed: leaseCount };
+    }
+    if (activeLeaseHeld) {
+      return { acquired: false, reason: "lease_held", attemptsUsed: leaseCount };
+    }
+    insertEvent(db, {
+      session_id: sessionId,
+      event_type: "session_resumed",
+      metadata: JSON.stringify({ kind: FORWARD_RESUME_KIND, round })
+    });
+    return { acquired: true, attemptsUsed: leaseCount + 1 };
+  });
+}
+function hasLiveOwningTurn(db, sessionId, heartbeatMs, nowMs) {
+  const instances = listAgentSessionsForWorkflow(db, sessionId);
+  return instances.some(
+    (s) => s.ended_at == null && nowMs - sqliteUtcMs(s.last_heartbeat_at) <= heartbeatMs
+  );
+}
+function deriveStrandedStatus(db, session, cfg) {
+  const nowMs = cfg.nowMs ?? Date.now();
+  if (hasLiveOwningTurn(db, session.id, cfg.heartbeatMs, nowMs)) return null;
+  return strandedActionByCap(db, session, cfg.maxAttempts);
+}
+function strandedActionByCap(db, session, maxAttempts) {
+  const events = getEventsForSession(db, session.id);
+  const leaseCount = countForwardResumeLeases(events, session.current_round);
+  const workflowType = session.workflow_type === "map" ? "map" : "review";
+  return {
+    action: leaseCount >= maxAttempts ? "abort_or_fresh" : "forward_resume",
+    remainingPhases: remainingPhasesAfter(workflowType, session.current_phase),
+    attemptsRemaining: Math.max(0, maxAttempts - leaseCount)
   };
 }
+function closeForwardResumeExhausted(db, sessionId, attempts) {
+  commitReasonClose(
+    db,
+    sessionId,
+    {
+      event_type: "session_auto_closed_stale",
+      phase: "complete",
+      metadata: JSON.stringify({
+        reason: FORWARD_RESUME_EXHAUSTED_REASON,
+        attempts
+      })
+    },
+    { status: "closed", current_phase: "complete" }
+  );
+}
 
-// src/lib/state/map-meta.ts
+// ../shared/persistence/src/state/map-meta.ts
 function validateMapMeta(meta) {
   if (!meta || typeof meta !== "object") {
     throw new Error("map-meta.json must be a JSON object");
@@ -34314,7 +35202,7 @@ function computeMapCounts(meta) {
   };
 }
 
-// src/lib/state/projection.ts
+// ../shared/persistence/src/state/projection.ts
 init_db();
 var REASON_EVENT_TYPES = [
   "session_aborted",
@@ -34344,7 +35232,7 @@ function getCompletenessState(db, sessionId) {
   return r[0]?.values[0]?.[0] ?? null;
 }
 
-// src/lib/state/index.ts
+// ../shared/persistence/src/state/index.ts
 init_exit_codes();
 function deriveNextRound(db, sessionId, fallbackRound) {
   const result = db.exec(
@@ -34399,6 +35287,12 @@ async function stateInit(params) {
         `Cannot re-open session ${sessionId} as workflow_type "${workflowType}": existing workflow_type is "${existing.workflow_type}". Maps and reviews have disjoint phase graphs.`
       );
     }
+    if (existing.status === "active" && !hasCompletionInvariant(db, existing)) {
+      throw new StateError(
+        STATE_EXIT.INVARIANT_UNMET,
+        `Session ${sessionId} is active and its current round is not complete \u2014 'begin' would reset it to "${initialPhaseFor(workflowType)}" and lose progress. Forward-resume instead: re-run the review (it continues from current_phase via 'ocr state status --json'), or 'ocr review --resume ${sessionId}'.`
+      );
+    }
     const nextRound = deriveNextRound(db, sessionId, existing.current_round);
     const initialPhase2 = workflowType === "map" ? "map-context" : "context";
     db.transaction(() => {
@@ -34698,18 +35592,19 @@ async function stateCompleteRound(params) {
   }
   const resolved = resolveSession(db, params.sessionId);
   const roundNumber = params.round ?? resolved.current_round;
-  const roundMetaPath = join17(
-    resolved.session_dir,
-    "rounds",
-    `round-${roundNumber}`,
-    "round-meta.json"
-  );
+  const roundDir = join17(resolved.session_dir, "rounds", `round-${roundNumber}`);
+  const roundMetaPath = join17(roundDir, "round-meta.json");
+  const materializeArtifact = () => {
+    mkdirSync6(roundDir, { recursive: true });
+    writeFileSync7(roundMetaPath, JSON.stringify(meta, null, 2));
+  };
   const already = db.exec(
     `SELECT 1 FROM orchestration_events
        WHERE session_id = ? AND event_type = 'round_completed' AND round = ? LIMIT 1`,
     [resolved.id, roundNumber]
   );
   if ((already[0]?.values.length ?? 0) > 0) {
+    if (!existsSync15(roundMetaPath)) materializeArtifact();
     return { sessionId: resolved.id, round: roundNumber, metaPath: roundMetaPath, schema_version: 1 };
   }
   if (resolved.current_phase !== "synthesis") {
@@ -34719,7 +35614,7 @@ async function stateCompleteRound(params) {
     );
   }
   if (params.requireFinal) {
-    const finalPath = join17(resolved.session_dir, "rounds", `round-${roundNumber}`, "final.md");
+    const finalPath = join17(roundDir, "final.md");
     if (!existsSync15(finalPath)) {
       throw new StateError(
         STATE_EXIT.INVARIANT_UNMET,
@@ -34727,13 +35622,8 @@ async function stateCompleteRound(params) {
       );
     }
   }
-  let metaPath;
-  if (params.source === "stdin") {
-    const roundDir = join17(resolved.session_dir, "rounds", `round-${roundNumber}`);
-    mkdirSync6(roundDir, { recursive: true });
-    metaPath = roundMetaPath;
-    writeFileSync7(metaPath, JSON.stringify(meta, null, 2));
-  }
+  materializeArtifact();
+  const metaPath = roundMetaPath;
   db.transaction(() => {
     insertEvent(db, {
       session_id: resolved.id,
@@ -34784,19 +35674,19 @@ async function stateCompleteMap(params) {
   }
   const resolved = resolveSession(db, params.sessionId);
   const mapRunNumber = params.mapRun ?? resolved.current_map_run;
-  const mapMetaPath = join17(
-    resolved.session_dir,
-    "map",
-    "runs",
-    `run-${mapRunNumber}`,
-    "map-meta.json"
-  );
+  const runDir = join17(resolved.session_dir, "map", "runs", `run-${mapRunNumber}`);
+  const mapMetaPath = join17(runDir, "map-meta.json");
+  const materializeArtifact = () => {
+    mkdirSync6(runDir, { recursive: true });
+    writeFileSync7(mapMetaPath, JSON.stringify(meta, null, 2));
+  };
   const already = db.exec(
     `SELECT 1 FROM orchestration_events
        WHERE session_id = ? AND event_type = 'map_completed' AND round = ? LIMIT 1`,
     [resolved.id, mapRunNumber]
   );
   if ((already[0]?.values.length ?? 0) > 0) {
+    if (!existsSync15(mapMetaPath)) materializeArtifact();
     return { sessionId: resolved.id, mapRun: mapRunNumber, metaPath: mapMetaPath, schema_version: 1 };
   }
   if (resolved.current_phase !== "synthesis") {
@@ -34805,13 +35695,8 @@ async function stateCompleteMap(params) {
       `Cannot complete map: workflow is at "${resolved.current_phase}", not "synthesis". Advance first.`
     );
   }
-  let metaPath;
-  if (params.source === "stdin") {
-    const runDir = join17(resolved.session_dir, "map", "runs", `run-${mapRunNumber}`);
-    mkdirSync6(runDir, { recursive: true });
-    metaPath = mapMetaPath;
-    writeFileSync7(metaPath, JSON.stringify(meta, null, 2));
-  }
+  materializeArtifact();
+  const metaPath = mapMetaPath;
   db.transaction(() => {
     insertEvent(db, {
       session_id: resolved.id,
@@ -34837,7 +35722,7 @@ async function stateCompleteMap(params) {
   });
   return { sessionId: resolved.id, mapRun: mapRunNumber, metaPath, schema_version: 1 };
 }
-async function stateStatus(ocrDir, sessionId) {
+async function stateStatus(ocrDir, sessionId, forwardResume) {
   const db = await ensureDatabase(ocrDir);
   const resolved = resolveSession(db, sessionId);
   const view = db.exec(
@@ -34850,6 +35735,8 @@ async function stateStatus(ocrDir, sessionId) {
   const hasTerminalArtifact = row?.[1] === 1;
   let nextAction;
   let nextActionKind;
+  let remainingPhases;
+  let attemptsRemaining;
   switch (completenessState) {
     case "complete":
       nextAction = "none \u2014 session is complete";
@@ -34867,12 +35754,25 @@ async function stateStatus(ocrDir, sessionId) {
       if (hasTerminalArtifact) {
         nextAction = "run 'ocr state finish' to close the workflow";
         nextActionKind = "finish";
-      } else if (resolved.current_phase === "synthesis") {
-        nextAction = "pipe round metadata to 'ocr state complete-round --stdin'";
-        nextActionKind = "complete_round";
       } else {
-        nextAction = "advance through the phases, then 'ocr state complete-round'";
-        nextActionKind = "advance";
+        const stranded = forwardResume && resolved.status === "active" ? deriveStrandedStatus(db, resolved, forwardResume) : null;
+        if (stranded) {
+          remainingPhases = stranded.remainingPhases;
+          attemptsRemaining = stranded.attemptsRemaining;
+          if (stranded.action === "forward_resume") {
+            nextAction = `forward-resume from '${resolved.current_phase}': re-run the review (it continues via 'ocr state status --json'), or 'ocr review --resume ${resolved.id}'`;
+            nextActionKind = "forward_resume";
+          } else {
+            nextAction = "forward-resume attempts exhausted \u2014 abort with 'ocr state finish --abort' or start a fresh review";
+            nextActionKind = "abort_or_fresh";
+          }
+        } else if (resolved.current_phase === "synthesis") {
+          nextAction = "pipe round metadata to 'ocr state complete-round --stdin'";
+          nextActionKind = "complete_round";
+        } else {
+          nextAction = "advance through the phases, then 'ocr state complete-round'";
+          nextActionKind = "advance";
+        }
       }
   }
   return {
@@ -34888,7 +35788,9 @@ async function stateStatus(ocrDir, sessionId) {
     marked_closed: row?.[2] === 1,
     dependents_settled: row?.[3] === 1,
     next_action: nextAction,
-    next_action_kind: nextActionKind
+    next_action_kind: nextActionKind,
+    ...remainingPhases ? { remaining_phases: remainingPhases } : {},
+    ...attemptsRemaining !== void 0 ? { forward_resume_attempts_remaining: attemptsRemaining } : {}
   };
 }
 async function stateSync(ocrDir) {
@@ -34976,14 +35878,73 @@ async function stateSync(ocrDir) {
 }
 
 // src/commands/state.ts
-init_command_log();
 init_db();
 init_db();
-function readDashboardSpawnMarker(ocrDir) {
-  const path2 = join18(ocrDir, "data", "dashboard-active-spawn.json");
+
+// ../shared/config/src/runtime-config.ts
+import { existsSync as existsSync16, readFileSync as readFileSync11 } from "node:fs";
+import { join as join18 } from "node:path";
+var DEFAULT_AGENT_HEARTBEAT_SECONDS = 60;
+var DEFAULT_FORWARD_RESUME_MAX_ATTEMPTS = 2;
+var DEFAULT_FORWARD_RESUME_LEASE_SECONDS = 1800;
+function readRuntimePositiveInt(ocrDir, key, defaultValue) {
+  const configPath = join18(ocrDir, "config.yaml");
+  if (!existsSync16(configPath)) return defaultValue;
+  let content;
+  try {
+    content = readFileSync11(configPath, "utf-8");
+  } catch {
+    return defaultValue;
+  }
+  const blockMatch = content.match(
+    new RegExp(
+      String.raw`^runtime:\s*\n(?:\s+[^\n]*\n)*?\s+${key}:\s*([^\s#\n]+)`,
+      "m"
+    )
+  );
+  const inlineMatch = content.match(
+    new RegExp(String.raw`^runtime:\s*\{[^}]*\b${key}:\s*([^\s,}]+)`, "m")
+  );
+  const raw = blockMatch?.[1] ?? inlineMatch?.[1];
+  if (!raw) return defaultValue;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0 || !Number.isInteger(parsed)) {
+    process.stderr.write(
+      `[ocr] runtime.${key} is not a positive integer (got "${raw}"); falling back to ${defaultValue}.
+`
+    );
+    return defaultValue;
+  }
+  return parsed;
+}
+function getAgentHeartbeatSeconds(ocrDir) {
+  return readRuntimePositiveInt(
+    ocrDir,
+    "agent_heartbeat_seconds",
+    DEFAULT_AGENT_HEARTBEAT_SECONDS
+  );
+}
+function getForwardResumeMaxAttempts(ocrDir) {
+  return readRuntimePositiveInt(
+    ocrDir,
+    "forward_resume_max_attempts",
+    DEFAULT_FORWARD_RESUME_MAX_ATTEMPTS
+  );
+}
+function getForwardResumeLeaseMs(ocrDir) {
+  return readRuntimePositiveInt(
+    ocrDir,
+    "forward_resume_lease_seconds",
+    DEFAULT_FORWARD_RESUME_LEASE_SECONDS
+  ) * 1e3;
+}
+
+// src/commands/state.ts
+init_db();
+function readMarkerFile(path2) {
   let raw;
   try {
-    raw = readFileSync11(path2, "utf-8");
+    raw = readFileSync12(path2, "utf-8");
   } catch {
     return null;
   }
@@ -35004,6 +35965,30 @@ function readDashboardSpawnMarker(ocrDir) {
   }
   return marker;
 }
+function readDashboardSpawnMarker(ocrDir) {
+  const dir = join19(ocrDir, "data", "dashboard-active-spawn");
+  let entries = [];
+  try {
+    entries = readdirSync8(dir).filter((f) => f.endsWith(".json"));
+  } catch {
+    entries = [];
+  }
+  const live = [];
+  for (const entry of entries) {
+    const marker = readMarkerFile(join19(dir, entry));
+    if (marker) live.push(marker);
+  }
+  if (live.length === 1) return live[0] ?? null;
+  if (live.length > 1) {
+    console.error(
+      source_default.gray(
+        `[state] ${live.length} concurrent dashboard spawns live; marker fallback is ambiguous \u2014 pass --dashboard-uid for linkage`
+      )
+    );
+    return null;
+  }
+  return readMarkerFile(join19(ocrDir, "data", "dashboard-active-spawn.json"));
+}
 async function readStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -35045,7 +36030,7 @@ async function linkDashboardInvocation(ocrDir, sessionId, explicitUid, label) {
 var showSubcommand = new Command("show").description("Show current session state").option("--session-id <id>", "Session ID (defaults to latest active)").option("--json", "Output as JSON").action(async (options) => {
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
-  const ocrDir = join18(targetDir, ".ocr");
+  const ocrDir = join19(targetDir, ".ocr");
   try {
     const result = await stateShow(ocrDir, options.sessionId);
     if (!result) {
@@ -35114,7 +36099,7 @@ var showSubcommand = new Command("show").description("Show current session state
 var syncSubcommand = new Command("sync").description("Rebuild session state from filesystem artifacts").action(async () => {
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
-  const ocrDir = join18(targetDir, ".ocr");
+  const ocrDir = join19(targetDir, ".ocr");
   try {
     const synced = await stateSync(ocrDir);
     console.log(`Synced ${synced} session${synced !== 1 ? "s" : ""} from filesystem.`);
@@ -35141,7 +36126,7 @@ var reconcileSubcommand = new Command("reconcile").description(
 ).option("--dry-run", "Print the repair plan without writing anything").option("--json", "Output the result as JSON").action(async (options) => {
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
-  const ocrDir = join18(targetDir, ".ocr");
+  const ocrDir = join19(targetDir, ".ocr");
   try {
     const db = await ensureDatabase(ocrDir);
     const result = reconcileLegacyState(db, ocrDir, { dryRun: options.dryRun });
@@ -35200,9 +36185,9 @@ var beginSubcommand = new Command("begin").description("Start or resume a workfl
   async (options) => {
     const targetDir = process.cwd();
     requireOcrSetup(targetDir);
-    const ocrDir = join18(targetDir, ".ocr");
-    const sessionDir = options.sessionDir ?? join18(ocrDir, "sessions", options.sessionId);
-    if (!existsSync16(sessionDir)) mkdirSync7(sessionDir, { recursive: true });
+    const ocrDir = join19(targetDir, ".ocr");
+    const sessionDir = options.sessionDir ?? join19(ocrDir, "sessions", options.sessionId);
+    if (!existsSync17(sessionDir)) mkdirSync7(sessionDir, { recursive: true });
     try {
       const result = await stateBegin({
         sessionId: options.sessionId,
@@ -35224,7 +36209,7 @@ var advanceSubcommand = new Command("advance").description("Advance the workflow
   async (options) => {
     const targetDir = process.cwd();
     requireOcrSetup(targetDir);
-    const ocrDir = join18(targetDir, ".ocr");
+    const ocrDir = join19(targetDir, ".ocr");
     try {
       const { id: sessionId } = await resolveActiveSession(ocrDir, options.sessionId);
       await stateAdvance({
@@ -35244,7 +36229,7 @@ var completeRoundSubcommand = new Command("complete-round").description("Atomica
   async (options) => {
     const targetDir = process.cwd();
     requireOcrSetup(targetDir);
-    const ocrDir = join18(targetDir, ".ocr");
+    const ocrDir = join19(targetDir, ".ocr");
     try {
       const base = options.stdin ? { source: "stdin", data: await readStdin() } : options.file ? { source: "file", filePath: options.file } : (() => {
         throw new StateError(STATE_EXIT.USAGE, "Provide --stdin or --file with round metadata");
@@ -35268,7 +36253,7 @@ var completeMapSubcommand = new Command("complete-map").description("Atomically
   async (options) => {
     const targetDir = process.cwd();
     requireOcrSetup(targetDir);
-    const ocrDir = join18(targetDir, ".ocr");
+    const ocrDir = join19(targetDir, ".ocr");
     try {
       const base = options.stdin ? { source: "stdin", data: await readStdin() } : options.file ? { source: "file", filePath: options.file } : (() => {
         throw new StateError(STATE_EXIT.USAGE, "Provide --stdin or --file with map metadata");
@@ -35290,7 +36275,7 @@ var completeMapSubcommand = new Command("complete-map").description("Atomically
 var finishSubcommand = new Command("finish").description("Close a workflow (refuses unless the current round/run is complete)").option("--session-id <id>", "Session ID (auto-detects active if omitted)").option("--abort", "Abandon the session \u2014 records a distinct, non-success terminal").action(async (options) => {
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
-  const ocrDir = join18(targetDir, ".ocr");
+  const ocrDir = join19(targetDir, ".ocr");
   try {
     const { id: sessionId } = await resolveActiveSession(ocrDir, options.sessionId);
     await stateClose({ sessionId, ocrDir, abort: options.abort });
@@ -35302,14 +36287,20 @@ var finishSubcommand = new Command("finish").description("Close a workflow (refu
 var statusSubcommand = new Command("status").description("Report whether a session is complete and, if not, what's missing").option("--session-id <id>", "Session ID (auto-detects active if omitted)").option("--json", "Output the result as JSON").action(async (options) => {
   const targetDir = process.cwd();
   requireOcrSetup(targetDir);
-  const ocrDir = join18(targetDir, ".ocr");
+  const ocrDir = join19(targetDir, ".ocr");
   try {
-    const result = await stateStatus(ocrDir, options.sessionId);
+    const result = await stateStatus(ocrDir, options.sessionId, {
+      maxAttempts: getForwardResumeMaxAttempts(ocrDir),
+      heartbeatMs: getAgentHeartbeatSeconds(ocrDir) * 1e3
+    });
     if (options.json) {
       console.log(JSON.stringify(result, null, 2));
     } else {
       console.log(`${result.session_id}: ${result.completeness_state}`);
       console.log(source_default.dim(`  next: ${result.next_action}`));
+      if (result.remaining_phases?.length) {
+        console.log(source_default.dim(`  remaining: ${result.remaining_phases.join(" \u2192 ")}`));
+      }
     }
   } catch (error) {
     exitFromStateError(error, "Failed to read status");
@@ -35333,50 +36324,6 @@ var stateCommand = new Command("state").description("Manage OCR session state").
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { join as join20 } from "node:path";
 init_db();
-
-// src/lib/runtime-config.ts
-import { existsSync as existsSync17, readFileSync as readFileSync12 } from "node:fs";
-import { join as join19 } from "node:path";
-var DEFAULT_AGENT_HEARTBEAT_SECONDS = 60;
-function readRuntimePositiveInt(ocrDir, key, defaultValue) {
-  const configPath = join19(ocrDir, "config.yaml");
-  if (!existsSync17(configPath)) return defaultValue;
-  let content;
-  try {
-    content = readFileSync12(configPath, "utf-8");
-  } catch {
-    return defaultValue;
-  }
-  const blockMatch = content.match(
-    new RegExp(
-      String.raw`^runtime:\s*\n(?:\s+[^\n]*\n)*?\s+${key}:\s*([^\s#\n]+)`,
-      "m"
-    )
-  );
-  const inlineMatch = content.match(
-    new RegExp(String.raw`^runtime:\s*\{[^}]*\b${key}:\s*([^\s,}]+)`, "m")
-  );
-  const raw = blockMatch?.[1] ?? inlineMatch?.[1];
-  if (!raw) return defaultValue;
-  const parsed = Number(raw);
-  if (!Number.isFinite(parsed) || parsed <= 0 || !Number.isInteger(parsed)) {
-    process.stderr.write(
-      `[ocr] runtime.${key} is not a positive integer (got "${raw}"); falling back to ${defaultValue}.
-`
-    );
-    return defaultValue;
-  }
-  return parsed;
-}
-function getAgentHeartbeatSeconds(ocrDir) {
-  return readRuntimePositiveInt(
-    ocrDir,
-    "agent_heartbeat_seconds",
-    DEFAULT_AGENT_HEARTBEAT_SECONDS
-  );
-}
-
-// src/commands/session.ts
 var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
   "done",
   "crashed",
@@ -35427,6 +36374,11 @@ var startInstanceSubcommand = new Command("start-instance").description("Journal
   }
 );
 var bindVendorIdSubcommand = new Command("bind-vendor-id").description("Bind the underlying CLI's session id to an OCR agent session").argument("<agent-session-id>", "OCR agent session id").argument("<vendor-session-id>", "Underlying CLI's session id").action(async (agentId, vendorId) => {
+  if (!SAFE_VENDOR_SESSION_ID.test(vendorId)) {
+    fail(
+      `vendor-session-id ${JSON.stringify(vendorId)} is not a plausible vendor session id (allowed: letters and digits plus . _ : - , max 256 chars). Nothing was bound \u2014 retry with the id the vendor CLI actually emitted.`
+    );
+  }
   const { ocrDir } = await setup();
   const db = await ensureDatabase(ocrDir);
   try {
@@ -35524,7 +36476,7 @@ var listSubcommand = new Command("list").description("List agent sessions for a
 });
 var sessionCommand = new Command("session").description("Manage agent-CLI session lifecycle journal").addCommand(startInstanceSubcommand).addCommand(bindVendorIdSubcommand).addCommand(beatSubcommand).addCommand(endInstanceSubcommand).addCommand(listSubcommand);
 
-// src/lib/models.ts
+// ../shared/config/src/models.ts
 init_src();
 function parseOpenCodeModelList(stdout) {
   const models = [];
@@ -35770,6 +36722,9 @@ function parseSessionOverride(raw) {
   return result;
 }
 var resolveSubcommand = new Command("resolve").description("Resolve and print the team composition for the active workspace").option(
+  "--team <spec>",
+  "Session team override replacing default_team. Format: reviewer-id:count[,reviewer-id:count...] (e.g. principal:2,architect:1)"
+).option(
   "--session-override <json>",
   "JSON array of ReviewerInstance overrides applied on top of disk config"
 ).option("--session-override-stdin", "Read --session-override JSON from stdin").option("--json", "Emit JSON for programmatic consumption (the AI workflow uses this)").action(
@@ -35778,7 +36733,8 @@ var resolveSubcommand = new Command("resolve").description("Resolve and print th
     requireOcrSetup(targetDir);
     const ocrDir = join21(targetDir, ".ocr");
     try {
-      const { team } = loadTeamConfig(ocrDir);
+      const { team, aliases, defaultModel } = loadTeamConfig(ocrDir);
+      const baseTeam = options.team ? parseTeamSpec(options.team, aliases, defaultModel) : team;
       let override;
       if (options.sessionOverride) {
         override = parseSessionOverride(options.sessionOverride);
@@ -35788,7 +36744,7 @@ var resolveSubcommand = new Command("resolve").description("Resolve and print th
           override = parseSessionOverride(raw);
         }
       }
-      const resolved = resolveTeamComposition(team, override);
+      const resolved = resolveTeamComposition(baseTeam, override);
       if (options.json) {
         console.log(JSON.stringify(resolved, null, 2));
         return;
@@ -35926,11 +36882,11 @@ function pairKey(pair) {
 var teamCommand = new Command("team").description("Resolve and persist team composition").addCommand(resolveSubcommand).addCommand(setSubcommand);
 
 // src/commands/review.ts
-import { spawn as spawn3 } from "node:child_process";
+init_src();
 import { join as join22 } from "node:path";
 init_db();
 
-// src/lib/vendor-resume.ts
+// ../shared/persistence/src/vendor-resume.ts
 var VENDOR_BINARIES = {
   claude: "claude",
   opencode: "opencode"
@@ -35952,6 +36908,7 @@ function fail3(message) {
   console.error(source_default.red(`Error: ${message}`));
   process.exit(1);
 }
+var CONTROL_PROMPT = "Resume this OCR review: run `ocr state status --json` and act on `next_action`, continuing forward from `current_phase` without redoing completed phases.";
 var reviewCommand = new Command("review").description("Run or resume an OCR review").option("--resume <workflow-id>", "Resume a prior review by its workflow session id").action(async (options) => {
   if (!options.resume) {
     console.error(
@@ -35968,21 +36925,89 @@ var reviewCommand = new Command("review").description("Run or resume an OCR revi
   requireOcrSetup(targetDir);
   const ocrDir = join22(targetDir, ".ocr");
   const db = await ensureDatabase(ocrDir);
-  const session = getSession(db, options.resume);
+  const workflowId = options.resume;
+  const session = getSession(db, workflowId);
   if (!session) {
-    fail3(`Workflow session not found: ${options.resume}`);
+    fail3(`Workflow session not found: ${workflowId}`);
+  }
+  const maxAttempts = getForwardResumeMaxAttempts(ocrDir);
+  const leaseMs = getForwardResumeLeaseMs(ocrDir);
+  const heartbeatMs = getAgentHeartbeatSeconds(ocrDir) * 1e3;
+  const status = await stateStatus(ocrDir, workflowId, {
+    maxAttempts,
+    heartbeatMs
+  });
+  switch (status.next_action_kind) {
+    case "none":
+      console.error(source_default.green(`Workflow ${workflowId} is already complete \u2014 nothing to resume.`));
+      process.exit(0);
+      break;
+    case "finish":
+      console.error(
+        source_default.yellow(`Workflow ${workflowId}'s round is complete but the session is still open.`)
+      );
+      console.error(source_default.dim("Run `ocr state finish` to close it."));
+      process.exit(0);
+      break;
+    case "abort_or_fresh": {
+      closeForwardResumeExhausted(db, workflowId, maxAttempts);
+      fail3(
+        `Forward-resume attempts exhausted for workflow ${workflowId} (cap ${maxAttempts}). Closed non-success (artifacts preserved). Start a fresh review, or run \`ocr state finish --abort\` if it was already closed.`
+      );
+      break;
+    }
+    case "advance":
+    case "complete_round":
+    case "wait":
+      console.error(
+        source_default.yellow(
+          `Workflow ${workflowId} appears to still be running (phase "${status.current_phase}"). Nothing to resume yet.`
+        )
+      );
+      process.exit(0);
+      break;
+    case "reopen":
+      console.error(
+        source_default.yellow(`Workflow ${workflowId} was closed without a completed round.`)
+      );
+      console.error(source_default.dim("Re-invoke the review skill to finalize it."));
+      process.exit(0);
+      break;
   }
-  const latest = getLatestAgentSessionWithVendorId(db, options.resume);
-  if (!latest || !latest.vendor_session_id) {
+  const lease = tryAcquireForwardResumeLease(db, workflowId, session.current_round, {
+    leaseMs,
+    maxAttempts
+  });
+  if (!lease.acquired) {
+    if (lease.reason === "cap_exhausted") {
+      closeForwardResumeExhausted(db, workflowId, lease.attemptsUsed);
+      fail3(
+        `Forward-resume attempts exhausted for workflow ${workflowId} (cap ${maxAttempts}). Closed non-success (artifacts preserved). Start a fresh review.`
+      );
+    }
     fail3(
-      `No vendor session id has been captured for workflow ${options.resume}. Resume requires at least one journaled agent session with a bound vendor id. Start a fresh review with \`ocr review\` (no --resume).`
+      `A forward-resume is already in progress for workflow ${workflowId} (lease held). Wait for it to finish or retry after the lease expires.`
     );
   }
-  const binary = VENDOR_BINARIES[latest.vendor];
-  if (!binary) {
-    fail3(
-      `Unknown vendor "${latest.vendor}" recorded for workflow ${options.resume}. OCR knows how to resume Claude Code and OpenCode; this workflow used something else.`
+  console.error(
+    source_default.dim(
+      `Forward-resuming workflow ${session.id} on branch ${session.branch} from phase "${status.current_phase}" (${status.forward_resume_attempts_remaining ?? "?"} attempt(s) left).`
+    )
+  );
+  const latest = getLatestAgentSessionWithVendorId(db, workflowId);
+  const binary = latest?.vendor ? VENDOR_BINARIES[latest.vendor] : void 0;
+  if (!latest || !latest.vendor_session_id || !binary) {
+    console.error(
+      source_default.yellow(
+        `No resumable vendor session is captured for workflow ${workflowId}.`
+      )
     );
+    console.error(
+      source_default.dim(
+        `Continue it by re-invoking the review skill (\`/ocr-review\`) in your AI CLI \u2014 its Phase 0 reads \`ocr state status --json\` and continues forward from "${status.current_phase}". (${CONTROL_PROMPT})`
+      )
+    );
+    process.exit(0);
   }
   let args;
   try {
@@ -35990,12 +37015,8 @@ var reviewCommand = new Command("review").description("Run or resume an OCR revi
   } catch (err) {
     fail3(err instanceof Error ? err.message : String(err));
   }
-  console.error(
-    source_default.dim(
-      `Resuming workflow ${session.id} on branch ${session.branch} via ${binary}\u2026`
-    )
-  );
-  const child = spawn3(binary, args, {
+  console.error(source_default.dim(`Resuming via ${binary} (continue forward from "${status.current_phase}")\u2026`));
+  const child = spawnBinary(binary, args, {
     stdio: "inherit",
     cwd: targetDir
   });