@open-code-review/cli 2.2.0 → 2.3.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,29 +16017,688 @@ var require_emoji_regex2 = __commonJS({
   }
 });
 
+// ../../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) {
+  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 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,
+    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";
-import {
-  execFile,
-  execFileSync,
-  spawn as spawn2
-} from "node:child_process";
-import { promisify } from "node:util";
 async function importModule(absolutePath) {
   return import(pathToFileURL(absolutePath).href);
 }
-function execBinary(binary, args, opts) {
-  return execFileSync(binary, args, {
-    ...opts,
-    shell: isWindows
-  });
+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) {
@@ -16048,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",
@@ -23393,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;
@@ -23471,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;
@@ -23598,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];
@@ -23653,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 = [
       {
@@ -24152,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,
@@ -24267,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;
@@ -24316,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;
@@ -24328,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,
@@ -24405,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) {
@@ -24427,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,
@@ -24463,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
@@ -24634,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
@@ -24829,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();
@@ -24839,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 {
@@ -24877,7 +25543,7 @@ function foreignKeyViolationGroups(db) {
 function scanOrphanTempFiles(dataDir) {
   let entries;
   try {
-    entries = readdirSync5(dataDir);
+    entries = readdirSync2(dataDir);
   } catch {
     return [];
   }
@@ -24888,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;
     }
@@ -24907,7 +25573,7 @@ function scanOrphanTempFiles(dataDir) {
 function scanBackupFiles(dataDir, dbBase) {
   let entries;
   try {
-    entries = readdirSync5(dataDir);
+    entries = readdirSync2(dataDir);
   } catch {
     return [];
   }
@@ -24915,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 {
     }
   }
@@ -24923,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");
@@ -24935,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,
@@ -24963,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}`;
@@ -24978,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 {
     }
@@ -24988,7 +25654,7 @@ function reapOrphanDbFiles(dataDir) {
 function reapStaleExecLogs(execLogsDir, maxAgeMs = SEVEN_DAYS_MS) {
   let entries;
   try {
-    entries = readdirSync5(execLogsDir);
+    entries = readdirSync2(execLogsDir);
   } catch {
     return [];
   }
@@ -24996,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);
@@ -25014,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 {
     }
   }
@@ -25029,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 {
       }
@@ -25045,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, () => {
@@ -25089,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,
@@ -25174,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([
@@ -25249,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++;
@@ -25276,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;
@@ -25328,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;
@@ -25342,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";
@@ -25352,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,
@@ -25360,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,
@@ -25392,6 +26059,7 @@ __export(db_exports, {
   insertEvent: () => insertEvent,
   insertSession: () => insertSession,
   isBusyError: () => isBusyError,
+  isSafeVendorSessionId: () => isSafeVendorSessionId,
   linkDashboardInvocationToWorkflow: () => linkDashboardInvocationToWorkflow,
   listAgentSessionsForWorkflow: () => listAgentSessionsForWorkflow,
   openDatabase: () => openDatabase,
@@ -25422,7 +26090,7 @@ __export(db_exports, {
   withForeignKeysDisabled: () => withForeignKeysDisabled
 });
 import {
-  existsSync as existsSync13,
+  existsSync as existsSync10,
   mkdirSync as mkdirSync5,
   copyFileSync as copyFileSync2,
   statSync as statSync2,
@@ -25430,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;
@@ -25472,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);
@@ -25480,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 {
@@ -25516,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);
@@ -25558,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(() => {
@@ -25592,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();
@@ -26361,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 = {
@@ -26375,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,
@@ -29352,7 +30020,7 @@ 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";
@@ -29397,6 +30065,9 @@ function parseTeamConfigYaml(content) {
         aliases,
         defaultModel
       );
+      if (resolvedModel !== null) {
+        assertSafeModelId(resolvedModel, `default_team.${persona}[${i}]`);
+      }
       team.push({
         persona,
         instance_index: i + 1,
@@ -29477,6 +30148,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 {};
@@ -29518,6 +30199,9 @@ 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;
@@ -30086,7 +30770,7 @@ ${hint}
 }
 
 // src/lib/version.ts
-var CLI_VERSION = true ? "2.2.0" : createRequire(import.meta.url)("../../package.json").version;
+var CLI_VERSION = true ? "2.3.0" : createRequire(import.meta.url)("../../package.json").version;
 
 // src/lib/deps.ts
 init_src();
@@ -33020,12 +33704,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;
@@ -33044,7 +33728,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])
   );
@@ -33079,7 +33763,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]
@@ -33092,8 +33776,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";
   }
@@ -33103,7 +33787,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]
@@ -33127,7 +33811,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]
@@ -33149,28 +33833,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 {
@@ -33181,7 +33865,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]
@@ -33249,8 +33933,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" },
@@ -33262,10 +33946,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;
 }
@@ -33279,27 +33963,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
     };
   });
@@ -33309,7 +33993,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;
@@ -33328,19 +34012,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", ""),
@@ -33350,14 +34034,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,
@@ -33489,8 +34173,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" },
@@ -33500,23 +34184,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]*?)```/
       );
@@ -33526,7 +34210,7 @@ function deriveRunsFromFilesystem(mapDir) {
     }
     return {
       run: runNum,
-      isComplete: existsSync9(mapPath),
+      isComplete: existsSync13(mapPath),
       fileCount
     };
   });
@@ -33536,7 +34220,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;
@@ -33558,24 +34242,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",
@@ -34030,10 +34714,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 {
@@ -34046,7 +34730,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,
@@ -34128,7 +34812,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;
@@ -34138,9 +34822,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");
@@ -34151,10 +34837,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");
+  }
+  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 = sanitizeMetadataString(obj.verdict);
+  obj.verdict = verdict;
   if (!Array.isArray(obj.reviewers)) {
     throw new Error("round-meta.json must contain a reviewers array");
   }
@@ -34177,8 +34869,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)) {
@@ -34223,25 +34917,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");
@@ -34308,7 +35121,7 @@ function computeMapCounts(meta) {
   };
 }
 
-// src/lib/state/projection.ts
+// ../shared/persistence/src/state/projection.ts
 init_db();
 var REASON_EVENT_TYPES = [
   "session_aborted",
@@ -34338,7 +35151,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(
@@ -34393,6 +35206,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(() => {
@@ -34692,18 +35511,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") {
@@ -34713,7 +35533,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,
@@ -34721,13 +35541,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,
@@ -34778,19 +35593,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") {
@@ -34799,13 +35614,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,
@@ -34831,7 +35641,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(
@@ -34844,6 +35654,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";
@@ -34861,12 +35673,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 {
@@ -34882,7 +35707,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) {
@@ -34970,14 +35797,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;
   }
@@ -34998,6 +35884,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) {
@@ -35039,7 +35949,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) {
@@ -35108,7 +36018,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.`);
@@ -35135,7 +36045,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 });
@@ -35194,9 +36104,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,
@@ -35218,7 +36128,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({
@@ -35238,7 +36148,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");
@@ -35262,7 +36172,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");
@@ -35284,7 +36194,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 });
@@ -35296,14 +36206,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");
@@ -35327,50 +36243,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",
@@ -35421,6 +36293,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 {
@@ -35518,25 +36395,64 @@ 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();
-var BUNDLED_CLAUDE_MODELS = [
-  { id: "claude-opus-4-7", displayName: "Claude Opus 4.7" },
-  { id: "claude-sonnet-4-6", displayName: "Claude Sonnet 4.6" },
-  { id: "claude-haiku-4-5-20251001", displayName: "Claude Haiku 4.5" }
-];
-var BUNDLED_OPENCODE_MODELS = [
-  { id: "anthropic/claude-opus-4-7", provider: "anthropic" },
-  { id: "anthropic/claude-sonnet-4-6", provider: "anthropic" },
-  { id: "anthropic/claude-haiku-4-5-20251001", provider: "anthropic" }
-];
-function detectActiveVendor() {
-  for (const vendor of ["claude", "opencode"]) {
+function parseOpenCodeModelList(stdout) {
+  const models = [];
+  for (const rawLine of stdout.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!/^[^\s:]+\/\S+$/.test(line)) continue;
+    const provider = line.slice(0, line.indexOf("/"));
+    models.push({ id: line, provider });
+  }
+  return models.length > 0 ? models : null;
+}
+var VENDOR_MODEL_STRATEGIES = {
+  claude: {
+    displayName: "Claude Code",
+    native: {
+      // Verified against Claude Code 2.1.x: the CLI has no model-listing
+      // subcommand (`claude models --json` → "unknown option"). Revisit if
+      // a future release adds one.
+      unavailableReason: "Claude Code does not provide a model-listing command; showing its documented model aliases instead"
+    },
+    // Vendor-documented aliases that always track the latest generation —
+    // dated ids here would go stale by construction (the exact bug class of
+    // issue #39). Pinned dated ids remain available via free-text entry.
+    bundled: [
+      { id: "opus", displayName: "Claude Opus (latest)" },
+      { id: "sonnet", displayName: "Claude Sonnet (latest)" },
+      { id: "haiku", displayName: "Claude Haiku (latest)" }
+    ]
+  },
+  opencode: {
+    displayName: "OpenCode",
+    native: {
+      // Plain `opencode models` — newline-delimited ids. (`--json` is not a
+      // real flag, and `--verbose` interleaves JSON metadata blocks that
+      // defeat line parsing.)
+      args: ["models"],
+      parse: parseOpenCodeModelList
+    },
+    bundled: [
+      { id: "anthropic/claude-opus-4-8", provider: "anthropic" },
+      { id: "anthropic/claude-sonnet-4-6", provider: "anthropic" },
+      { id: "anthropic/claude-haiku-4-5", provider: "anthropic" }
+    ]
+  }
+};
+var SUPPORTED_VENDORS = Object.keys(
+  VENDOR_MODEL_STRATEGIES
+);
+function isModelVendor(value) {
+  return Object.hasOwn(VENDOR_MODEL_STRATEGIES, value);
+}
+async function detectActiveVendor() {
+  for (const vendor of SUPPORTED_VENDORS) {
     try {
-      execBinary(vendor, ["--version"], {
+      await execBinaryAsync(vendor, ["--version"], {
         encoding: "utf-8",
-        timeout: 3e3,
-        stdio: ["ignore", "pipe", "ignore"]
+        timeout: 3e3
       });
       return vendor;
     } catch {
@@ -35544,68 +36460,97 @@ function detectActiveVendor() {
   }
   return null;
 }
-function tryNativeEnumeration(vendor) {
+function describeProbeFailure(vendor, args, err) {
+  const command = `${vendor} ${args.join(" ")}`;
+  const e = err;
+  if (e.code === "ENOENT") {
+    return `\`${vendor}\` is not installed or not on PATH`;
+  }
+  if (e.killed) {
+    return `\`${command}\` timed out or exceeded output limits`;
+  }
+  const stderr = typeof e.stderr === "string" ? e.stderr.trim() : "";
+  const firstLine = (stderr.split(/\r?\n/)[0] ?? "").replace(/\u001b\[[0-9;]*[A-Za-z]/g, "").replace(/[\u0000-\u001f\u007f]/g, "").slice(0, 200);
+  const detail = firstLine ? `: ${firstLine}` : "";
+  const exit = typeof e.code === "number" ? ` with exit code ${e.code}` : "";
+  return `\`${command}\` failed${exit}${detail}`;
+}
+async function tryNativeEnumeration(vendor, probe) {
+  let stdout;
   try {
-    const output = execBinary(vendor, ["models", "--json"], {
+    const result = await execBinaryAsync(vendor, probe.args, {
       encoding: "utf-8",
-      timeout: 5e3,
-      stdio: ["ignore", "pipe", "ignore"]
+      timeout: 5e3
     });
-    const parsed = JSON.parse(output);
-    if (!Array.isArray(parsed)) return null;
-    const models = [];
-    for (const item of parsed) {
-      if (typeof item === "string") {
-        models.push({ id: item });
-      } else if (typeof item === "object" && item !== null && "id" in item && typeof item.id === "string") {
-        const obj = item;
-        const desc = { id: obj.id };
-        if (typeof obj.displayName === "string") desc.displayName = obj.displayName;
-        if (typeof obj.provider === "string") desc.provider = obj.provider;
-        if (Array.isArray(obj.tags)) {
-          desc.tags = obj.tags.filter((t) => typeof t === "string");
-        }
-        models.push(desc);
-      }
-    }
-    return models.length > 0 ? models : null;
-  } catch {
-    return null;
+    stdout = result.stdout;
+  } catch (err) {
+    return { models: null, reason: describeProbeFailure(vendor, probe.args, err) };
   }
+  const models = probe.parse(stdout);
+  if (!models) {
+    return {
+      models: null,
+      reason: `\`${vendor} ${probe.args.join(" ")}\` output did not contain any model identifiers`
+    };
+  }
+  return { models };
 }
-function bundledForVendor(vendor) {
-  if (vendor === "claude") return BUNDLED_CLAUDE_MODELS;
-  return BUNDLED_OPENCODE_MODELS;
-}
-function listModelsForVendor(vendor) {
-  const native = tryNativeEnumeration(vendor);
-  if (native) {
-    return { vendor, source: "native", models: native };
+var SUCCESS_TTL_MS = 6e4;
+var FAILURE_TTL_MS = 1e4;
+var cache = /* @__PURE__ */ new Map();
+async function listModelsForVendor(vendor) {
+  const cached = cache.get(vendor);
+  if (cached && cached.expiresAt > Date.now()) {
+    return cached.result;
+  }
+  const strategy = VENDOR_MODEL_STRATEGIES[vendor];
+  if (!strategy) {
+    throw new Error(`Unknown vendor: ${vendor}`);
   }
-  return { vendor, source: "bundled", models: bundledForVendor(vendor) };
+  let result;
+  if ("unavailableReason" in strategy.native) {
+    result = {
+      vendor,
+      source: "bundled",
+      models: strategy.bundled,
+      nativeUnavailableReason: strategy.native.unavailableReason
+    };
+  } else {
+    const native = await tryNativeEnumeration(vendor, strategy.native);
+    result = native.models ? { vendor, source: "native", models: native.models } : {
+      vendor,
+      source: "bundled",
+      models: strategy.bundled,
+      nativeUnavailableReason: native.reason
+    };
+  }
+  const ttl = result.source === "native" ? SUCCESS_TTL_MS : FAILURE_TTL_MS;
+  cache.set(vendor, { result, expiresAt: Date.now() + ttl });
+  return result;
 }
 
 // src/commands/models.ts
-var listSubcommand2 = new Command("list").description("List models the active AI CLI is willing to accept").option(
-  "--vendor <vendor>",
-  "Override autodetection (claude | opencode)"
-).option("--json", "Emit JSON for programmatic consumption").action(async (options) => {
+var vendorList = SUPPORTED_VENDORS.join(" | ");
+var listSubcommand2 = new Command("list").description("List models the active AI CLI is willing to accept").option("--vendor <vendor>", `Override autodetection (${vendorList})`).option("--json", "Emit JSON for programmatic consumption").action(async (options) => {
   let vendor;
   if (options.vendor) {
-    if (options.vendor !== "claude" && options.vendor !== "opencode") {
+    const requested = options.vendor.toLowerCase();
+    if (!isModelVendor(requested)) {
       console.error(
         source_default.red(
-          `Invalid --vendor: "${options.vendor}". Must be "claude" or "opencode".`
+          `Invalid --vendor: "${options.vendor}". Must be one of: ${vendorList}.`
         )
       );
       process.exit(1);
     }
-    vendor = options.vendor;
+    vendor = requested;
   } else {
-    vendor = detectActiveVendor();
+    vendor = await detectActiveVendor();
     if (!vendor) {
       if (options.json) {
-        console.log("[]");
+        console.log(
+          JSON.stringify({ vendor: null, source: null, models: [] }, null, 2)
+        );
         return;
       }
       console.error(
@@ -35616,16 +36561,18 @@ var listSubcommand2 = new Command("list").description("List models the active AI
       process.exit(1);
     }
   }
-  const { source, models } = listModelsForVendor(vendor);
+  const result = await listModelsForVendor(vendor);
   if (options.json) {
-    console.log(JSON.stringify(models, null, 2));
+    console.log(JSON.stringify(result, null, 2));
     return;
   }
+  const { source, models, nativeUnavailableReason } = result;
   console.log(source_default.bold(`Models for ${vendor} (${source})`));
   if (source === "bundled") {
+    const reason = nativeUnavailableReason ? ` \u2014 ${nativeUnavailableReason}` : "";
     console.log(
       source_default.dim(
-        "  Note: bundled fallback list \u2014 may be stale. Free-text input is always accepted."
+        `  Note: bundled fallback list${reason}. Free-text input is always accepted.`
       )
     );
   }
@@ -35850,11 +36797,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"
@@ -35876,6 +36823,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(
@@ -35892,21 +36840,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 {
@@ -35914,12 +36930,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
   });
@@ -36844,10 +37856,10 @@ function readCache(cacheFile) {
     return null;
   }
 }
-function writeCache(cacheFile, cache) {
+function writeCache(cacheFile, cache2) {
   try {
     mkdirSync8(join28(cacheFile, ".."), { recursive: true });
-    writeFileSync10(cacheFile, JSON.stringify(cache));
+    writeFileSync10(cacheFile, JSON.stringify(cache2));
   } catch {
   }
 }
@@ -36869,14 +37881,14 @@ async function checkForUpdate(currentVersion, options) {
   }
   const cacheFile = join28(options?.cacheDir ?? CACHE_DIR2, "update-check.json");
   try {
-    const cache = readCache(cacheFile);
-    if (cache && Date.now() - cache.lastCheck < CHECK_INTERVAL_MS) {
-      if (!cache.latestVersion) return null;
-      if (!isNewer(cache.latestVersion, currentVersion)) return null;
+    const cache2 = readCache(cacheFile);
+    if (cache2 && Date.now() - cache2.lastCheck < CHECK_INTERVAL_MS) {
+      if (!cache2.latestVersion) return null;
+      if (!isNewer(cache2.latestVersion, currentVersion)) return null;
       return {
         updateAvailable: true,
         currentVersion,
-        latestVersion: cache.latestVersion,
+        latestVersion: cache2.latestVersion,
         updateCommand: detectUpdateCommand()
       };
     }