@remixhq/claude-plugin 0.1.17 → 0.1.18

package/dist/hook-stop-collab.cjs

@@ -37,8 +37,8 @@ var require_windows = __commonJS({
     "use strict";
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs9 = require("fs");
-    function checkPathExt(path13, options) {
+    var fs8 = require("fs");
+    function checkPathExt(path12, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
         return true;
@@ -49,25 +49,25 @@ var require_windows = __commonJS({
       }
       for (var i2 = 0; i2 < pathext.length; i2++) {
         var p = pathext[i2].toLowerCase();
-        if (p && path13.substr(-p.length).toLowerCase() === p) {
+        if (p && path12.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat, path13, options) {
+    function checkStat(stat, path12, options) {
       if (!stat.isSymbolicLink() && !stat.isFile()) {
         return false;
       }
-      return checkPathExt(path13, options);
+      return checkPathExt(path12, options);
     }
-    function isexe(path13, options, cb) {
-      fs9.stat(path13, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path13, options));
+    function isexe(path12, options, cb) {
+      fs8.stat(path12, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path12, options));
       });
     }
-    function sync(path13, options) {
-      return checkStat(fs9.statSync(path13), path13, options);
+    function sync(path12, options) {
+      return checkStat(fs8.statSync(path12), path12, options);
     }
   }
 });
@@ -78,14 +78,14 @@ var require_mode = __commonJS({
     "use strict";
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs9 = require("fs");
-    function isexe(path13, options, cb) {
-      fs9.stat(path13, function(er, stat) {
+    var fs8 = require("fs");
+    function isexe(path12, options, cb) {
+      fs8.stat(path12, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
-    function sync(path13, options) {
-      return checkStat(fs9.statSync(path13), options);
+    function sync(path12, options) {
+      return checkStat(fs8.statSync(path12), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -110,7 +110,7 @@ var require_mode = __commonJS({
 var require_isexe = __commonJS({
   "node_modules/isexe/index.js"(exports2, module2) {
     "use strict";
-    var fs9 = require("fs");
+    var fs8 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -119,7 +119,7 @@ var require_isexe = __commonJS({
     }
     module2.exports = isexe;
     isexe.sync = sync;
-    function isexe(path13, options, cb) {
+    function isexe(path12, options, cb) {
       if (typeof options === "function") {
         cb = options;
         options = {};
@@ -129,7 +129,7 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve, reject) {
-          isexe(path13, options || {}, function(er, is) {
+          isexe(path12, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -138,7 +138,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path13, options || {}, function(er, is) {
+      core(path12, options || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options && options.ignoreErrors) {
             er = null;
@@ -148,9 +148,9 @@ var require_isexe = __commonJS({
         cb(er, is);
       });
     }
-    function sync(path13, options) {
+    function sync(path12, options) {
       try {
-        return core.sync(path13, options || {});
+        return core.sync(path12, options || {});
       } catch (er) {
         if (options && options.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -167,7 +167,7 @@ var require_which = __commonJS({
   "node_modules/which/which.js"(exports2, module2) {
     "use strict";
     var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-    var path13 = require("path");
+    var path12 = require("path");
     var COLON = isWindows ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -205,7 +205,7 @@ var require_which = __commonJS({
           return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i2];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path13.join(pathPart, cmd);
+        const pCmd = path12.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         resolve(subStep(p, i2, 0));
       });
@@ -232,7 +232,7 @@ var require_which = __commonJS({
       for (let i2 = 0; i2 < pathEnv.length; i2++) {
         const ppRaw = pathEnv[i2];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path13.join(pathPart, cmd);
+        const pCmd = path12.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];
@@ -280,7 +280,7 @@ var require_path_key = __commonJS({
 var require_resolveCommand = __commonJS({
   "node_modules/cross-spawn/lib/util/resolveCommand.js"(exports2, module2) {
     "use strict";
-    var path13 = require("path");
+    var path12 = require("path");
     var which = require_which();
     var getPathKey = require_path_key();
     function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -298,7 +298,7 @@ var require_resolveCommand = __commonJS({
       try {
         resolved = which.sync(parsed.command, {
           path: env[getPathKey({ env })],
-          pathExt: withoutPathExt ? path13.delimiter : void 0
+          pathExt: withoutPathExt ? path12.delimiter : void 0
         });
       } catch (e) {
       } finally {
@@ -307,7 +307,7 @@ var require_resolveCommand = __commonJS({
         }
       }
       if (resolved) {
-        resolved = path13.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+        resolved = path12.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
       }
       return resolved;
     }
@@ -361,8 +361,8 @@ var require_shebang_command = __commonJS({
       if (!match) {
         return null;
       }
-      const [path13, argument] = match[0].replace(/#! ?/, "").split(" ");
-      const binary = path13.split("/").pop();
+      const [path12, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path12.split("/").pop();
       if (binary === "env") {
         return argument;
       }
@@ -375,16 +375,16 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "node_modules/cross-spawn/lib/util/readShebang.js"(exports2, module2) {
     "use strict";
-    var fs9 = require("fs");
+    var fs8 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
       const buffer = Buffer.alloc(size);
       let fd;
       try {
-        fd = fs9.openSync(command, "r");
-        fs9.readSync(fd, buffer, 0, size, 0);
-        fs9.closeSync(fd);
+        fd = fs8.openSync(command, "r");
+        fs8.readSync(fd, buffer, 0, size, 0);
+        fs8.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -397,7 +397,7 @@ var require_readShebang = __commonJS({
 var require_parse = __commonJS({
   "node_modules/cross-spawn/lib/parse.js"(exports2, module2) {
     "use strict";
-    var path13 = require("path");
+    var path12 = require("path");
     var resolveCommand = require_resolveCommand();
     var escape = require_escape();
     var readShebang = require_readShebang();
@@ -422,7 +422,7 @@ var require_parse = __commonJS({
       const needsShell = !isExecutableRegExp.test(commandFile);
       if (parsed.options.forceShell || needsShell) {
         const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-        parsed.command = path13.normalize(parsed.command);
+        parsed.command = path12.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(" ");
@@ -512,7 +512,7 @@ var require_cross_spawn = __commonJS({
     var cp = require("child_process");
     var parse = require_parse();
     var enoent = require_enoent();
-    function spawn2(command, args, options) {
+    function spawn3(command, args, options) {
       const parsed = parse(command, args, options);
       const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
@@ -524,8 +524,8 @@ var require_cross_spawn = __commonJS({
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module2.exports = spawn2;
-    module2.exports.spawn = spawn2;
+    module2.exports = spawn3;
+    module2.exports.spawn = spawn3;
     module2.exports.sync = spawnSync2;
     module2.exports._parse = parse;
     module2.exports._enoent = enoent;
@@ -538,15 +538,7 @@ __export(hook_stop_collab_exports, {
   runHookStopCollab: () => runHookStopCollab
 });
 module.exports = __toCommonJS(hook_stop_collab_exports);
-
-// node_modules/@remixhq/core/dist/chunk-GC2MOT3U.js
-var REMIX_ERROR_CODES = {
-  REPO_LOCK_HELD: "REPO_LOCK_HELD",
-  REPO_LOCK_TIMEOUT: "REPO_LOCK_TIMEOUT",
-  REPO_LOCK_STALE_RECOVERED: "REPO_LOCK_STALE_RECOVERED",
-  REPO_STATE_CHANGED_DURING_OPERATION: "REPO_STATE_CHANGED_DURING_OPERATION",
-  PREFERRED_BRANCH_MISMATCH: "PREFERRED_BRANCH_MISMATCH"
-};
+var import_node_child_process6 = require("child_process");
 
 // node_modules/@remixhq/core/dist/chunk-YZ34ICNN.js
 var RemixError = class extends Error {
@@ -562,12 +554,6 @@ var RemixError = class extends Error {
   }
 };
 
-// node_modules/@remixhq/core/dist/chunk-RREREIGW.js
-var import_promises12 = __toESM(require("fs/promises"), 1);
-var import_crypto = require("crypto");
-var import_os = __toESM(require("os"), 1);
-var import_path = __toESM(require("path"), 1);
-
 // node_modules/is-plain-obj/index.js
 function isPlainObject(value) {
   if (typeof value !== "object" || value === null) {
@@ -4949,13 +4935,13 @@ var logOutputSync = ({ serializedResult, fdNumber, state, verboseInfo, encoding,
   }
 };
 var writeToFiles = (serializedResult, stdioItems, outputFiles) => {
-  for (const { path: path13, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
-    const pathString = typeof path13 === "string" ? path13 : path13.toString();
+  for (const { path: path12, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
+    const pathString = typeof path12 === "string" ? path12 : path12.toString();
     if (append || outputFiles.has(pathString)) {
-      (0, import_node_fs4.appendFileSync)(path13, serializedResult);
+      (0, import_node_fs4.appendFileSync)(path12, serializedResult);
     } else {
       outputFiles.add(pathString);
-      (0, import_node_fs4.writeFileSync)(path13, serializedResult);
+      (0, import_node_fs4.writeFileSync)(path12, serializedResult);
     }
   }
 };
@@ -7343,131 +7329,11 @@ var {
   getCancelSignal: getCancelSignal2
 } = getIpcExport();
 
-// node_modules/@remixhq/core/dist/chunk-RREREIGW.js
+// node_modules/@remixhq/core/dist/chunk-WT6VRLXU.js
 async function runGit(args, cwd) {
   const res = await execa("git", args, { cwd, stderr: "ignore" });
   return String(res.stdout || "").trim();
 }
-async function runGitWithEnv(args, cwd, env) {
-  const res = await execa("git", args, { cwd, env, stderr: "ignore" });
-  return String(res.stdout || "").trim();
-}
-async function runGitRawWithEnv(args, cwd, env) {
-  const res = await execa("git", args, { cwd, env, stderr: "ignore", stripFinalNewline: false });
-  return String(res.stdout || "");
-}
-async function runGitDetailed(args, cwd) {
-  const res = await execa("git", args, { cwd, reject: false });
-  return {
-    exitCode: res.exitCode ?? 1,
-    stdout: String(res.stdout || ""),
-    stderr: String(res.stderr || "")
-  };
-}
-function normalizeRepoRelativePath(value) {
-  const normalized = import_path.default.posix.normalize(value.replace(/\\/g, "/").trim());
-  if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../") || import_path.default.posix.isAbsolute(normalized)) {
-    throw new RemixError("Git returned an invalid repository-relative path.", {
-      exitCode: 1,
-      hint: `Path: ${value}`
-    });
-  }
-  return normalized;
-}
-function resolveRepoRelativePath(repoRoot, relativePath) {
-  return import_path.default.resolve(repoRoot, ...relativePath.split("/"));
-}
-function isWithinRepoRoot(repoRoot, targetPath) {
-  const relative = import_path.default.relative(repoRoot, targetPath);
-  return relative === "" || !relative.startsWith("..") && !import_path.default.isAbsolute(relative);
-}
-function sha256Hex(value) {
-  return (0, import_crypto.createHash)("sha256").update(value).digest("hex");
-}
-function resolveGitReportedPath(cwd, reportedPath) {
-  const value = reportedPath.trim();
-  if (!value) {
-    throw new RemixError("Git returned an empty internal path.", { exitCode: 1 });
-  }
-  return import_path.default.isAbsolute(value) ? value : import_path.default.resolve(cwd, value);
-}
-function parseGitNameStatusZ(stdout) {
-  const tokens = stdout.split("\0");
-  const entries = [];
-  for (let i2 = 0; i2 < tokens.length; i2 += 1) {
-    const rawToken = tokens[i2];
-    if (!rawToken) continue;
-    let status = rawToken;
-    let inlinePath = null;
-    const tabIdx = rawToken.indexOf("	");
-    if (tabIdx >= 0) {
-      status = rawToken.slice(0, tabIdx);
-      inlinePath = rawToken.slice(tabIdx + 1) || null;
-    }
-    const kind = status[0]?.toUpperCase() ?? "";
-    if (kind === "R" || kind === "C") {
-      const oldPath = inlinePath ?? tokens[++i2] ?? "";
-      const newPath = tokens[++i2] ?? "";
-      if (!newPath) continue;
-      entries.push({
-        status,
-        path: normalizeRepoRelativePath(newPath),
-        oldPath: oldPath ? normalizeRepoRelativePath(oldPath) : null
-      });
-      continue;
-    }
-    const nextPath = inlinePath ?? tokens[++i2] ?? "";
-    if (!nextPath) continue;
-    entries.push({
-      status,
-      path: normalizeRepoRelativePath(nextPath),
-      oldPath: null
-    });
-  }
-  return entries;
-}
-function buildStagePlan(entries) {
-  const updatePaths = /* @__PURE__ */ new Set();
-  const addPaths = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
-    const kind = entry.status[0]?.toUpperCase() ?? "";
-    if (kind === "A" || kind === "C") {
-      addPaths.add(entry.path);
-      continue;
-    }
-    if (kind === "R") {
-      if (entry.oldPath) updatePaths.add(entry.oldPath);
-      addPaths.add(entry.path);
-      continue;
-    }
-    updatePaths.add(entry.path);
-  }
-  const expectedPaths = /* @__PURE__ */ new Set([...updatePaths, ...addPaths]);
-  return {
-    updatePaths: Array.from(updatePaths).sort(),
-    addPaths: Array.from(addPaths).sort(),
-    expectedPaths: Array.from(expectedPaths).sort()
-  };
-}
-function classifyGitApplyFailure(detail) {
-  const normalized = String(detail ?? "").toLowerCase();
-  if (normalized.includes("corrupt patch") || normalized.includes("patch with only garbage") || normalized.includes("unrecognized input") || normalized.includes("malformed patch") || normalized.includes("patch fragment without header")) {
-    return "malformed_patch";
-  }
-  if (normalized.includes("patch failed") || normalized.includes("does not apply") || normalized.includes("merge conflict") || normalized.includes("conflict")) {
-    return "apply_conflict";
-  }
-  return "unknown";
-}
-async function pruneEmptyParentDirectories(repoRoot, filePath) {
-  let current = import_path.default.dirname(filePath);
-  while (current !== repoRoot && isWithinRepoRoot(repoRoot, current)) {
-    const entries = await import_promises12.default.readdir(current).catch(() => null);
-    if (!entries || entries.length > 0) return;
-    await import_promises12.default.rmdir(current).catch(() => void 0);
-    current = import_path.default.dirname(current);
-  }
-}
 async function findGitRoot(startDir) {
   try {
     const root = await runGit(["rev-parse", "--show-toplevel"], startDir);
@@ -7480,17 +7346,6 @@ async function findGitRoot(startDir) {
     });
   }
 }
-async function getGitCommonDir(cwd) {
-  try {
-    const commonDir = await runGit(["rev-parse", "--git-common-dir"], cwd);
-    return resolveGitReportedPath(cwd, commonDir);
-  } catch {
-    throw new RemixError("Failed to resolve the git common directory.", {
-      exitCode: 1,
-      hint: "Ensure the current working directory is inside a valid git repository."
-    });
-  }
-}
 async function getCurrentBranch(cwd) {
   try {
     const branch = await runGit(["branch", "--show-current"], cwd);
@@ -7499,121 +7354,6 @@ async function getCurrentBranch(cwd) {
     return null;
   }
 }
-async function listUntrackedFiles(cwd) {
-  try {
-    const out = await runGit(["ls-files", "--others", "--exclude-standard"], cwd);
-    return out.split("\n").map((line) => line.trim()).filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-async function getWorkspaceDiff(cwd) {
-  const snapshot = await getWorkspaceSnapshot(cwd);
-  return {
-    diff: snapshot.diff,
-    includedUntrackedPaths: snapshot.includedUntrackedPaths
-  };
-}
-async function getWorkspaceSnapshot(cwd) {
-  const headCommitHash = await getHeadCommitHash(cwd);
-  if (!headCommitHash) {
-    throw new RemixError("Failed to resolve local HEAD commit.", { exitCode: 1 });
-  }
-  const includedUntrackedPaths = Array.from(new Set((await listUntrackedFiles(cwd)).map((entry) => normalizeRepoRelativePath(entry))));
-  const tempDir = await import_promises12.default.mkdtemp(import_path.default.join(import_os.default.tmpdir(), "remix-index-"));
-  const tempIndexPath = import_path.default.join(tempDir, "index");
-  const env = { ...process.env, GIT_INDEX_FILE: tempIndexPath };
-  try {
-    try {
-      await runGitWithEnv(["read-tree", "HEAD"], cwd, env);
-      await runGitWithEnv(["add", "-A", "--", "."], cwd, env);
-      const diff = await runGitRawWithEnv(["diff", "--binary", "--no-ext-diff", "--cached", "HEAD"], cwd, env);
-      const nameStatus = await runGitRawWithEnv(["diff", "--name-status", "--find-renames", "-z", "--cached", "HEAD"], cwd, env);
-      const pathEntries = parseGitNameStatusZ(nameStatus);
-      return {
-        diff,
-        diffSha256: sha256Hex(diff),
-        includedUntrackedPaths,
-        pathEntries,
-        stagePlan: buildStagePlan(pathEntries)
-      };
-    } catch {
-      throw new RemixError("Failed to generate workspace diff.", {
-        exitCode: 1,
-        hint: "Git could not snapshot the current workspace into an isolated index."
-      });
-    }
-  } finally {
-    await import_promises12.default.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
-  }
-}
-async function writeTempUnifiedDiffBackup(diff, prefix = "remix-add-backup") {
-  const safePrefix = prefix.replace(/[^a-zA-Z0-9._-]+/g, "-") || "remix-add-backup";
-  const tmpDir = await import_promises12.default.mkdtemp(import_path.default.join(import_os.default.tmpdir(), `${safePrefix}-`));
-  const backupPath = import_path.default.join(tmpDir, "submitted.diff");
-  await import_promises12.default.writeFile(backupPath, diff, "utf8");
-  return { backupPath, diffSha256: sha256Hex(diff) };
-}
-async function validateUnifiedDiff(cwd, diff) {
-  const { backupPath } = await writeTempUnifiedDiffBackup(diff, "remix-validate-diff");
-  try {
-    const applyRes = await runGitDetailed(["apply", "--check", "--index", "--3way", backupPath], cwd);
-    if (applyRes.exitCode === 0) {
-      return { ok: true };
-    }
-    const detail = [applyRes.stderr.trim(), applyRes.stdout.trim()].filter(Boolean).join("\n\n") || null;
-    return {
-      ok: false,
-      kind: classifyGitApplyFailure(detail),
-      detail
-    };
-  } finally {
-    await import_promises12.default.rm(import_path.default.dirname(backupPath), { recursive: true, force: true }).catch(() => void 0);
-  }
-}
-async function preserveWorkspaceChanges(cwd, prefix = "remix-add-preserve") {
-  const baseHeadCommitHash = await getHeadCommitHash(cwd);
-  if (!baseHeadCommitHash) {
-    throw new RemixError("Failed to resolve local HEAD before preserving workspace changes.", { exitCode: 1 });
-  }
-  const snapshot = await getWorkspaceSnapshot(cwd);
-  const { backupPath, diffSha256 } = await writeTempUnifiedDiffBackup(snapshot.diff, prefix);
-  return {
-    baseHeadCommitHash,
-    preservedDiffPath: backupPath,
-    preservedDiffSha256: diffSha256,
-    includedUntrackedPaths: snapshot.includedUntrackedPaths,
-    stagePlan: snapshot.stagePlan
-  };
-}
-async function reapplyPreservedWorkspaceChanges(cwd, preserved, operation = "`remix collab add`") {
-  const patchFilePath = preserved.preservedDiffPath;
-  const tempPatchHash = await import_promises12.default.readFile(patchFilePath, "utf8").then((content) => sha256Hex(content)).catch(() => null);
-  if (!tempPatchHash) {
-    return { status: "failed", detail: "Preserved diff artifact is missing." };
-  }
-  if (tempPatchHash !== preserved.preservedDiffSha256) {
-    return { status: "failed", detail: "Preserved diff artifact failed integrity verification." };
-  }
-  const applyRes = await runGitDetailed(["apply", "--index", "--3way", patchFilePath], cwd);
-  if (applyRes.exitCode !== 0) {
-    await runGitDetailed(["reset", "--hard", "HEAD"], cwd).catch(() => void 0);
-    await runGitDetailed(["clean", "-fd"], cwd).catch(() => void 0);
-    const detail = [applyRes.stderr.trim(), applyRes.stdout.trim()].filter(Boolean).join("\n\n") || null;
-    return { status: "conflict", detail };
-  }
-  const unstageRes = await runGitDetailed(["reset", "--mixed", "HEAD", "--", "."], cwd);
-  if (unstageRes.exitCode !== 0) {
-    await runGitDetailed(["reset", "--hard", "HEAD"], cwd).catch(() => void 0);
-    await runGitDetailed(["clean", "-fd"], cwd).catch(() => void 0);
-    const detail = [unstageRes.stderr.trim(), unstageRes.stdout.trim()].filter(Boolean).join("\n\n") || null;
-    return {
-      status: "failed",
-      detail: detail || `Git could not restore the working tree state while running ${operation}.`
-    };
-  }
-  return { status: "clean" };
-}
 async function getHeadCommitHash(cwd) {
   try {
     const hash = await runGit(["rev-parse", "HEAD"], cwd);
@@ -7631,157 +7371,6 @@ async function getWorktreeStatus(cwd) {
     return { isClean: false, entries: [] };
   }
 }
-async function captureRepoSnapshot(cwd, options) {
-  const [branch, headCommitHash, worktreeStatus] = await Promise.all([
-    getCurrentBranch(cwd),
-    getHeadCommitHash(cwd),
-    getWorktreeStatus(cwd)
-  ]);
-  const workspaceDiffSha256 = options?.includeWorkspaceDiffHash ? (await getWorkspaceSnapshot(cwd)).diffSha256 : null;
-  return {
-    branch,
-    headCommitHash,
-    statusEntries: worktreeStatus.entries,
-    statusSha256: sha256Hex(worktreeStatus.entries.join("\n")),
-    workspaceDiffSha256
-  };
-}
-async function assertRepoSnapshotUnchanged(cwd, snapshot, params) {
-  const current = await captureRepoSnapshot(cwd, {
-    includeWorkspaceDiffHash: snapshot.workspaceDiffSha256 !== null
-  });
-  const changes = [];
-  if (current.branch !== snapshot.branch) {
-    changes.push(`Branch changed: ${snapshot.branch ?? "(detached)"} -> ${current.branch ?? "(detached)"}`);
-  }
-  if (current.headCommitHash !== snapshot.headCommitHash) {
-    changes.push(`HEAD changed: ${snapshot.headCommitHash ?? "(missing)"} -> ${current.headCommitHash ?? "(missing)"}`);
-  }
-  if (current.statusSha256 !== snapshot.statusSha256) {
-    changes.push("Working tree status changed.");
-  }
-  if (snapshot.workspaceDiffSha256 !== null && current.workspaceDiffSha256 !== snapshot.workspaceDiffSha256) {
-    changes.push("Workspace diff changed.");
-  }
-  if (changes.length === 0) return;
-  const operation = params?.operation?.trim() || "this Remix operation";
-  const hint = [
-    `Operation: ${operation}`,
-    ...changes,
-    params?.recoveryHint?.trim() || "Review the local changes, then rerun the operation."
-  ].filter(Boolean).join("\n");
-  throw new RemixError("Repository state changed during the operation.", {
-    code: REMIX_ERROR_CODES.REPO_STATE_CHANGED_DURING_OPERATION,
-    exitCode: 2,
-    hint
-  });
-}
-async function ensureCleanWorktree(cwd, operation = "`remix collab sync`") {
-  const status = await getWorktreeStatus(cwd);
-  if (status.isClean) return;
-  const preview = status.entries.slice(0, 10).join("\n");
-  const suffix = status.entries.length > 10 ? `
-...and ${status.entries.length - 10} more` : "";
-  throw new RemixError(`Working tree must be clean before running ${operation}.`, {
-    exitCode: 2,
-    hint: `Commit, stash, or discard local changes first.
-
-${preview}${suffix}`
-  });
-}
-async function discardTrackedChanges(cwd, operation = "`remix collab add`") {
-  const res = await runGitDetailed(["reset", "--hard", "HEAD"], cwd);
-  if (res.exitCode !== 0) {
-    const detail = [res.stderr.trim(), res.stdout.trim()].filter(Boolean).join("\n\n");
-    throw new RemixError(`Failed to discard local tracked changes while running ${operation}.`, {
-      exitCode: 1,
-      hint: detail || "Git could not reset tracked changes back to HEAD."
-    });
-  }
-  const hash = await getHeadCommitHash(cwd);
-  if (!hash) {
-    throw new RemixError("Failed to resolve local HEAD after discarding tracked changes.", { exitCode: 1 });
-  }
-  return hash;
-}
-async function discardCapturedUntrackedChanges(repoRoot, capturedPaths) {
-  const normalizedCapturedPaths = Array.from(new Set(capturedPaths.map((entry) => normalizeRepoRelativePath(entry))));
-  if (normalizedCapturedPaths.length === 0) {
-    return { removedPaths: [] };
-  }
-  const currentUntracked = new Set((await listUntrackedFiles(repoRoot)).map((entry) => normalizeRepoRelativePath(entry)));
-  const removedPaths = [];
-  for (const relativePath of normalizedCapturedPaths) {
-    if (!currentUntracked.has(relativePath)) continue;
-    const absolutePath = resolveRepoRelativePath(repoRoot, relativePath);
-    if (!isWithinRepoRoot(repoRoot, absolutePath)) {
-      throw new RemixError("Refusing to delete a path outside the repository root.", {
-        exitCode: 1,
-        hint: `Path: ${relativePath}`
-      });
-    }
-    await import_promises12.default.rm(absolutePath, { recursive: true, force: true }).catch((err) => {
-      throw new RemixError("Failed to remove a captured untracked path before syncing.", {
-        exitCode: 1,
-        hint: err instanceof Error ? `${relativePath}
-
-${err.message}` : relativePath
-      });
-    });
-    removedPaths.push(relativePath);
-    await pruneEmptyParentDirectories(repoRoot, absolutePath);
-  }
-  return { removedPaths };
-}
-async function requireCurrentBranch(cwd) {
-  const branch = await getCurrentBranch(cwd);
-  if (!branch) {
-    throw new RemixError("`remix collab sync` requires a checked out local branch.", {
-      exitCode: 2,
-      hint: "Checkout a branch before syncing."
-    });
-  }
-  return branch;
-}
-async function importGitBundle(cwd, bundlePath, bundleRef) {
-  const verifyRes = await runGitDetailed(["bundle", "verify", bundlePath], cwd);
-  if (verifyRes.exitCode !== 0) {
-    const detail = [verifyRes.stderr.trim(), verifyRes.stdout.trim()].filter(Boolean).join("\n\n");
-    throw new RemixError("Failed to verify sync bundle.", {
-      exitCode: 1,
-      hint: detail || "Git bundle verification failed."
-    });
-  }
-  const fetchRes = await runGitDetailed(["fetch", "--quiet", bundlePath, bundleRef], cwd);
-  if (fetchRes.exitCode !== 0) {
-    const detail = [fetchRes.stderr.trim(), fetchRes.stdout.trim()].filter(Boolean).join("\n\n");
-    throw new RemixError("Failed to import sync bundle.", {
-      exitCode: 1,
-      hint: detail || "Git could not fetch objects from the sync bundle."
-    });
-  }
-}
-async function ensureCommitExists(cwd, commitHash) {
-  const res = await runGitDetailed(["cat-file", "-e", `${commitHash}^{commit}`], cwd);
-  if (res.exitCode === 0) return;
-  throw new RemixError("Expected target commit is missing after bundle import.", {
-    exitCode: 1,
-    hint: `Commit ${commitHash} is not available in the local repository.`
-  });
-}
-async function fastForwardToCommit(cwd, commitHash) {
-  const res = await runGitDetailed(["merge", "--ff-only", commitHash], cwd);
-  if (res.exitCode !== 0) {
-    const detail = [res.stderr.trim(), res.stdout.trim()].filter(Boolean).join("\n\n");
-    throw new RemixError("Failed to fast-forward local branch.", {
-      exitCode: 1,
-      hint: detail || "Git could not fast-forward to the target commit."
-    });
-  }
-  const hash = await getHeadCommitHash(cwd);
-  if (!hash) throw new RemixError("Failed to resolve local HEAD after fast-forward sync.", { exitCode: 1 });
-  return hash;
-}
 function summarizeUnifiedDiff(diff) {
   const lines = diff.split("\n");
   let changedFilesCount = 0;
@@ -7795,21 +7384,21 @@ function summarizeUnifiedDiff(diff) {
   return { changedFilesCount, insertions, deletions };
 }
 
-// node_modules/@remixhq/core/dist/chunk-IXWQWFYT.js
+// node_modules/@remixhq/core/dist/chunk-YCFLOHJV.js
+var import_promises12 = __toESM(require("fs/promises"), 1);
+var import_path = __toESM(require("path"), 1);
 var import_promises13 = __toESM(require("fs/promises"), 1);
 var import_path2 = __toESM(require("path"), 1);
-var import_promises14 = __toESM(require("fs/promises"), 1);
-var import_path3 = __toESM(require("path"), 1);
 async function writeJsonAtomic(filePath, value) {
-  const dir = import_path3.default.dirname(filePath);
-  await import_promises14.default.mkdir(dir, { recursive: true });
+  const dir = import_path2.default.dirname(filePath);
+  await import_promises13.default.mkdir(dir, { recursive: true });
   const tmp = `${filePath}.tmp-${Date.now()}`;
-  await import_promises14.default.writeFile(tmp, `${JSON.stringify(value, null, 2)}
+  await import_promises13.default.writeFile(tmp, `${JSON.stringify(value, null, 2)}
 `, "utf8");
-  await import_promises14.default.rename(tmp, filePath);
+  await import_promises13.default.rename(tmp, filePath);
 }
 function getCollabBindingPath(repoRoot) {
-  return import_path2.default.join(repoRoot, ".remix", "config.json");
+  return import_path.default.join(repoRoot, ".remix", "config.json");
 }
 function buildBindingFileV3(params) {
   return {
@@ -7872,7 +7461,7 @@ async function readCollabBindingState(repoRoot, options) {
   try {
     const persist = options?.persist === true;
     const filePath = getCollabBindingPath(repoRoot);
-    const raw = await import_promises13.default.readFile(filePath, "utf8");
+    const raw = await import_promises12.default.readFile(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") return null;
     const currentBranch = normalizeBranchName(await getCurrentBranch(repoRoot).catch(() => null));
@@ -8072,15 +7661,19 @@ async function writeCollabBinding(repoRoot, binding) {
 }
 
 // node_modules/@remixhq/core/dist/collab.js
-var import_promises15 = __toESM(require("fs/promises"), 1);
+var import_promises14 = __toESM(require("fs/promises"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var import_crypto = require("crypto");
+var import_os = __toESM(require("os"), 1);
 var import_path4 = __toESM(require("path"), 1);
 var import_crypto2 = require("crypto");
-var import_promises16 = __toESM(require("fs/promises"), 1);
+var import_promises15 = __toESM(require("fs/promises"), 1);
 var import_os2 = __toESM(require("os"), 1);
 var import_path5 = __toESM(require("path"), 1);
-var import_promises17 = __toESM(require("fs/promises"), 1);
-var import_os3 = __toESM(require("os"), 1);
+var import_crypto3 = require("crypto");
+var import_promises16 = __toESM(require("fs/promises"), 1);
 var import_path6 = __toESM(require("path"), 1);
+var import_crypto4 = require("crypto");
 function describeBranch(value) {
   const normalized = String(value ?? "").trim();
   return normalized || "(detached)";
@@ -8099,18 +7692,562 @@ function buildBranchMismatchHint(params) {
     `Switch to ${describeBranch(params.branchName)} or rerun with ${overrideFlag} if this is intentional.`
   ].join("\n");
 }
-function assertBoundBranchMatch(params) {
-  if (params.allowBranchMismatch) return;
-  if (isBoundBranchMatch(params.currentBranch, params.branchName)) return;
-  throw new RemixError(`Current branch does not match this checkout's bound Remix branch while running ${params.operation}.`, {
-    code: REMIX_ERROR_CODES.PREFERRED_BRANCH_MISMATCH,
-    exitCode: 2,
-    hint: buildBranchMismatchHint({
-      currentBranch: params.currentBranch,
-      branchName: params.branchName,
-      overrideFlag: params.overrideFlag
-    })
+function sha256Hex(value) {
+  return (0, import_crypto.createHash)("sha256").update(value).digest("hex");
+}
+function getCollabStateRoot() {
+  const configured = process.env.REMIX_COLLAB_STATE_ROOT?.trim();
+  return configured || import_path4.default.join(import_os.default.homedir(), ".remix", "collab-state");
+}
+function buildLaneStateKey(params) {
+  const fingerprint = params.repoFingerprint?.trim();
+  const laneId = params.laneId?.trim();
+  const repoRoot = params.repoRoot?.trim();
+  const stableSource = repoRoot || "unknown-repo-root";
+  const fingerprintSource = fingerprint || "unknown-repo-fingerprint";
+  const laneSource = laneId || "unknown-lane";
+  return sha256Hex(`${stableSource}::${fingerprintSource}::${laneSource}`);
+}
+function getSnapshotsRoot() {
+  return import_path4.default.join(getCollabStateRoot(), "snapshots");
+}
+function getSnapshotRecordsRoot() {
+  return import_path4.default.join(getSnapshotsRoot(), "records");
+}
+function getSnapshotBlobsRoot() {
+  return import_path4.default.join(getSnapshotsRoot(), "blobs");
+}
+function getBaselinesRoot() {
+  return import_path4.default.join(getCollabStateRoot(), "baselines");
+}
+function getFinalizeQueueRoot() {
+  return import_path4.default.join(getCollabStateRoot(), "finalize-queue");
+}
+function getBaselinePath(params) {
+  return import_path3.default.join(getBaselinesRoot(), `${buildLaneStateKey(params)}.json`);
+}
+async function readLocalBaseline(params) {
+  try {
+    const raw = await import_promises14.default.readFile(getBaselinePath(params), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    if (parsed.schemaVersion !== 1 || typeof parsed.key !== "string" || typeof parsed.repoRoot !== "string") {
+      return null;
+    }
+    return {
+      schemaVersion: 1,
+      key: parsed.key,
+      repoRoot: parsed.repoRoot,
+      repoFingerprint: parsed.repoFingerprint ?? null,
+      laneId: parsed.laneId ?? null,
+      currentAppId: String(parsed.currentAppId ?? ""),
+      branchName: parsed.branchName ?? null,
+      lastSnapshotId: parsed.lastSnapshotId ?? null,
+      lastSnapshotHash: parsed.lastSnapshotHash ?? null,
+      lastServerHeadHash: parsed.lastServerHeadHash ?? null,
+      lastSeenLocalCommitHash: parsed.lastSeenLocalCommitHash ?? null,
+      updatedAt: String(parsed.updatedAt ?? "")
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeLocalBaseline(baseline) {
+  const key = buildLaneStateKey(baseline);
+  const normalized = {
+    schemaVersion: 1,
+    key,
+    repoRoot: baseline.repoRoot,
+    repoFingerprint: baseline.repoFingerprint ?? null,
+    laneId: baseline.laneId ?? null,
+    currentAppId: baseline.currentAppId,
+    branchName: baseline.branchName ?? null,
+    lastSnapshotId: baseline.lastSnapshotId ?? null,
+    lastSnapshotHash: baseline.lastSnapshotHash ?? null,
+    lastServerHeadHash: baseline.lastServerHeadHash ?? null,
+    lastSeenLocalCommitHash: baseline.lastSeenLocalCommitHash ?? null,
+    updatedAt: baseline.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeJsonAtomic(getBaselinePath(baseline), normalized);
+  return normalized;
+}
+function sha256Hex2(value) {
+  return (0, import_crypto2.createHash)("sha256").update(value).digest("hex");
+}
+function getSnapshotRecordPath(snapshotId) {
+  return import_path5.default.join(getSnapshotRecordsRoot(), `${snapshotId}.json`);
+}
+function getBlobPath(blobHash) {
+  return import_path5.default.join(getSnapshotBlobsRoot(), blobHash.slice(0, 2), blobHash);
+}
+async function runGitZ(args, cwd) {
+  const res = await execa("git", args, {
+    cwd,
+    stderr: "ignore",
+    stripFinalNewline: false
   });
+  return String(res.stdout || "");
+}
+async function listWorkspaceFiles(repoRoot) {
+  const raw = await runGitZ(["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--deduplicate"], repoRoot);
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const entry of raw.split("\0")) {
+    const relativePath = entry.trim();
+    if (!relativePath || seen.has(relativePath)) continue;
+    const absolutePath = import_path5.default.join(repoRoot, relativePath);
+    try {
+      const stat = await import_promises15.default.lstat(absolutePath);
+      if (stat.isFile() || stat.isSymbolicLink()) {
+        seen.add(relativePath);
+        result.push(relativePath);
+      }
+    } catch {
+    }
+  }
+  return result.sort((a2, b) => a2.localeCompare(b));
+}
+async function persistBlob(blobHash, content) {
+  const blobPath = getBlobPath(blobHash);
+  try {
+    await import_promises15.default.access(blobPath);
+  } catch {
+    await import_promises15.default.mkdir(import_path5.default.dirname(blobPath), { recursive: true });
+    if (typeof content === "string") {
+      await import_promises15.default.writeFile(blobPath, content, "utf8");
+    } else {
+      await import_promises15.default.writeFile(blobPath, content);
+    }
+  }
+}
+function buildSnapshotHash(files) {
+  const manifest = files.map((file) => `${file.path}	${file.mode}	${file.blobHash}	${file.size}`).join("\n");
+  return sha256Hex2(manifest);
+}
+async function inspectLocalSnapshot(params) {
+  const repoRoot = params.repoRoot;
+  const files = await listWorkspaceFiles(repoRoot);
+  const manifest = [];
+  for (const relativePath of files) {
+    const absolutePath = import_path5.default.join(repoRoot, relativePath);
+    const stat = await import_promises15.default.lstat(absolutePath);
+    if (stat.isSymbolicLink()) {
+      const linkTarget = await import_promises15.default.readlink(absolutePath);
+      const blobHash2 = sha256Hex2(`symlink:${linkTarget}`);
+      if (params.persistBlobs !== false) {
+        await persistBlob(blobHash2, linkTarget);
+      }
+      manifest.push({
+        path: relativePath,
+        mode: "symlink",
+        blobHash: blobHash2,
+        size: Buffer.byteLength(linkTarget)
+      });
+      continue;
+    }
+    const content = await import_promises15.default.readFile(absolutePath);
+    const blobHash = sha256Hex2(content);
+    if (params.persistBlobs !== false) {
+      await persistBlob(blobHash, content);
+    }
+    manifest.push({
+      path: relativePath,
+      mode: stat.mode & 73 ? "executable" : "file",
+      blobHash,
+      size: stat.size
+    });
+  }
+  const normalizedManifest = manifest.sort((a2, b) => a2.path.localeCompare(b.path));
+  return {
+    repoRoot,
+    repoFingerprint: params.repoFingerprint ?? null,
+    laneId: params.laneId ?? null,
+    branchName: params.branchName ?? await getCurrentBranch(repoRoot).catch(() => null),
+    localCommitHash: await getHeadCommitHash(repoRoot).catch(() => null),
+    snapshotHash: buildSnapshotHash(normalizedManifest),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: normalizedManifest
+  };
+}
+async function captureLocalSnapshot(params) {
+  const inspection = await inspectLocalSnapshot({ ...params, persistBlobs: true });
+  const snapshot = {
+    schemaVersion: 1,
+    id: (0, import_crypto2.randomUUID)(),
+    ...inspection
+  };
+  await writeJsonAtomic(getSnapshotRecordPath(snapshot.id), snapshot);
+  return snapshot;
+}
+async function readLocalSnapshot(snapshotId) {
+  if (!snapshotId) return null;
+  try {
+    const raw = await import_promises15.default.readFile(getSnapshotRecordPath(snapshotId), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || parsed.schemaVersion !== 1) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function materializeLocalSnapshot(snapshotId, targetDir) {
+  const snapshot = await readLocalSnapshot(snapshotId);
+  await import_promises15.default.mkdir(targetDir, { recursive: true });
+  if (!snapshot) return;
+  for (const entry of snapshot.files) {
+    const destination = import_path5.default.join(targetDir, entry.path);
+    await import_promises15.default.mkdir(import_path5.default.dirname(destination), { recursive: true });
+    const blobPath = getBlobPath(entry.blobHash);
+    if (entry.mode === "symlink") {
+      const linkTarget = await import_promises15.default.readFile(blobPath, "utf8");
+      await import_promises15.default.symlink(linkTarget, destination);
+      continue;
+    }
+    await import_promises15.default.copyFile(blobPath, destination);
+    if (entry.mode === "executable") {
+      await import_promises15.default.chmod(destination, 493);
+    }
+  }
+}
+async function clearDirectoryExceptGit(targetDir) {
+  const entries = await import_promises15.default.readdir(targetDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === ".git") continue;
+    await import_promises15.default.rm(import_path5.default.join(targetDir, entry.name), { recursive: true, force: true });
+  }
+}
+async function diffLocalSnapshots(params) {
+  const tempRoot = await import_promises15.default.mkdtemp(import_path5.default.join(import_os2.default.tmpdir(), "remix-snapshot-diff-"));
+  const repoDir = import_path5.default.join(tempRoot, "repo");
+  await import_promises15.default.mkdir(repoDir, { recursive: true });
+  try {
+    await materializeLocalSnapshot(params.baseSnapshotId, repoDir);
+    await execa("git", ["init"], { cwd: repoDir, stderr: "ignore" });
+    await execa("git", ["add", "-A"], { cwd: repoDir, stderr: "ignore" });
+    await execa(
+      "git",
+      ["-c", "user.name=Remix", "-c", "user.email=remix@local", "commit", "--allow-empty", "-m", "baseline snapshot"],
+      { cwd: repoDir, stderr: "ignore" }
+    );
+    await clearDirectoryExceptGit(repoDir);
+    await materializeLocalSnapshot(params.targetSnapshotId, repoDir);
+    await execa("git", ["add", "-A"], { cwd: repoDir, stderr: "ignore" });
+    const diffRes = await execa("git", ["diff", "--binary", "--no-ext-diff", "--cached", "HEAD"], {
+      cwd: repoDir,
+      reject: false,
+      stderr: "ignore",
+      stripFinalNewline: false
+    });
+    const pathsRes = await execa("git", ["diff", "--name-only", "--cached", "HEAD", "-z"], {
+      cwd: repoDir,
+      reject: false,
+      stderr: "ignore",
+      stripFinalNewline: false
+    });
+    const diff = String(diffRes.stdout || "");
+    const changedPaths = String(pathsRes.stdout || "").split("\0").map((value) => value.trim()).filter(Boolean);
+    return {
+      baseSnapshotId: params.baseSnapshotId,
+      targetSnapshotId: params.targetSnapshotId,
+      diff,
+      diffSha256: diff ? sha256Hex2(diff) : null,
+      changedPaths,
+      stats: summarizeUnifiedDiff(diff)
+    };
+  } finally {
+    await import_promises15.default.rm(tempRoot, { recursive: true, force: true });
+  }
+}
+var FINALIZE_JOB_LOCK_STALE_MS = 10 * 60 * 1e3;
+var TERMINAL_FINALIZE_JOB_RETENTION_MS = 24 * 60 * 60 * 1e3;
+function getJobPath(id) {
+  return import_path6.default.join(getFinalizeQueueRoot(), `${id}.json`);
+}
+function getJobLockPath(id) {
+  return import_path6.default.join(getFinalizeQueueRoot(), `${id}.lock`);
+}
+function isPastDue(isoTimestamp) {
+  if (!isoTimestamp) return true;
+  const parsed = Date.parse(isoTimestamp);
+  return Number.isFinite(parsed) && parsed <= Date.now();
+}
+function isStaleAttempt(job) {
+  if (job.status !== "processing") return false;
+  if (!job.lastAttemptAt) return true;
+  const parsed = Date.parse(job.lastAttemptAt);
+  if (!Number.isFinite(parsed)) return true;
+  return Date.now() - parsed >= FINALIZE_JOB_LOCK_STALE_MS;
+}
+function readMetadataDisposition(job) {
+  const value = job.metadata.failureDisposition;
+  return value === "retryable" || value === "terminal" ? value : null;
+}
+function isTerminalFailure(job) {
+  return job.status === "failed" && readMetadataDisposition(job) === "terminal";
+}
+function isTerminalFailureExpired(job) {
+  if (!isTerminalFailure(job)) return false;
+  const updatedAtMs = Date.parse(job.updatedAt);
+  if (!Number.isFinite(updatedAtMs)) return false;
+  return Date.now() - updatedAtMs >= TERMINAL_FINALIZE_JOB_RETENTION_MS;
+}
+function matchesJobScope(job, scope) {
+  if (job.repoRoot !== scope.repoRoot) return false;
+  if (scope.currentAppId && job.currentAppId !== scope.currentAppId) return false;
+  if (scope.laneId && job.laneId !== scope.laneId) return false;
+  if (scope.repoFingerprint && job.repoFingerprint && job.repoFingerprint !== scope.repoFingerprint) return false;
+  return true;
+}
+function createEmptyPendingFinalizeQueueSummary() {
+  return {
+    state: "idle",
+    activeJobCount: 0,
+    queuedJobCount: 0,
+    processingJobCount: 0,
+    retryScheduledJobCount: 0,
+    failedJobCount: 0,
+    oldestCapturedAt: null,
+    newestCapturedAt: null,
+    nextRetryAt: null,
+    latestError: null
+  };
+}
+async function acquireJobLock(jobId) {
+  const lockPath = getJobLockPath(jobId);
+  try {
+    await import_promises16.default.mkdir(lockPath);
+    return true;
+  } catch (error) {
+    if (error?.code !== "EEXIST") {
+      throw error;
+    }
+  }
+  try {
+    const stat = await import_promises16.default.stat(lockPath);
+    if (Date.now() - stat.mtimeMs < FINALIZE_JOB_LOCK_STALE_MS) {
+      return false;
+    }
+    await import_promises16.default.rm(lockPath, { recursive: true, force: true });
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  try {
+    await import_promises16.default.mkdir(lockPath);
+    return true;
+  } catch (error) {
+    if (error?.code === "EEXIST") {
+      return false;
+    }
+    throw error;
+  }
+}
+function normalizeJob(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    schemaVersion: 1,
+    id: input.id ?? (0, import_crypto3.randomUUID)(),
+    status: input.status,
+    repoRoot: input.repoRoot,
+    repoFingerprint: input.repoFingerprint ?? null,
+    currentAppId: input.currentAppId,
+    laneId: input.laneId ?? null,
+    threadId: input.threadId ?? null,
+    branchName: input.branchName ?? null,
+    prompt: input.prompt,
+    assistantResponse: input.assistantResponse,
+    baselineSnapshotId: input.baselineSnapshotId ?? null,
+    baselineServerHeadHash: input.baselineServerHeadHash ?? null,
+    currentSnapshotId: input.currentSnapshotId,
+    capturedAt: input.capturedAt ?? now,
+    updatedAt: input.updatedAt ?? now,
+    idempotencyKey: input.idempotencyKey ?? null,
+    error: input.error ?? null,
+    retryCount: Number.isFinite(input.retryCount) ? Math.max(0, Number(input.retryCount)) : 0,
+    lastAttemptAt: input.lastAttemptAt ?? null,
+    nextRetryAt: input.nextRetryAt ?? null,
+    metadata: input.metadata ?? {}
+  };
+}
+async function enqueuePendingFinalizeJob(input) {
+  const job = normalizeJob(input);
+  await writeJsonAtomic(getJobPath(job.id), job);
+  return job;
+}
+async function readPendingFinalizeJob(jobId) {
+  try {
+    const raw = await import_promises16.default.readFile(getJobPath(jobId), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || parsed.schemaVersion !== 1 || typeof parsed.id !== "string") return null;
+    return normalizeJob({
+      id: parsed.id,
+      status: parsed.status ?? "queued",
+      repoRoot: String(parsed.repoRoot ?? ""),
+      repoFingerprint: parsed.repoFingerprint ?? null,
+      currentAppId: String(parsed.currentAppId ?? ""),
+      laneId: parsed.laneId ?? null,
+      threadId: parsed.threadId ?? null,
+      branchName: parsed.branchName ?? null,
+      prompt: String(parsed.prompt ?? ""),
+      assistantResponse: String(parsed.assistantResponse ?? ""),
+      baselineSnapshotId: parsed.baselineSnapshotId ?? null,
+      baselineServerHeadHash: parsed.baselineServerHeadHash ?? null,
+      currentSnapshotId: String(parsed.currentSnapshotId ?? ""),
+      capturedAt: parsed.capturedAt,
+      updatedAt: parsed.updatedAt,
+      idempotencyKey: parsed.idempotencyKey ?? null,
+      error: parsed.error ?? null,
+      retryCount: parsed.retryCount ?? 0,
+      lastAttemptAt: parsed.lastAttemptAt ?? null,
+      nextRetryAt: parsed.nextRetryAt ?? null,
+      metadata: parsed.metadata ?? {}
+    });
+  } catch {
+    return null;
+  }
+}
+async function listPendingFinalizeJobs() {
+  try {
+    const entries = await import_promises16.default.readdir(getFinalizeQueueRoot(), { withFileTypes: true });
+    const jobs = await Promise.all(
+      entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => readPendingFinalizeJob(entry.name.replace(/\.json$/, "")))
+    );
+    return jobs.filter((job) => Boolean(job)).sort((a2, b) => a2.capturedAt.localeCompare(b.capturedAt));
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function prunePendingFinalizeJobs() {
+  const jobs = await listPendingFinalizeJobs();
+  await Promise.all(
+    jobs.filter((job) => job.status === "completed" || isTerminalFailureExpired(job)).map((job) => removePendingFinalizeJob(job.id))
+  );
+}
+async function summarizePendingFinalizeJobs(scope) {
+  const jobs = (await listPendingFinalizeJobs()).filter((job) => matchesJobScope(job, scope));
+  const summary = createEmptyPendingFinalizeQueueSummary();
+  const relevantJobs = jobs.filter((job) => job.status !== "completed");
+  if (relevantJobs.length === 0) return summary;
+  summary.oldestCapturedAt = relevantJobs[0]?.capturedAt ?? null;
+  summary.newestCapturedAt = relevantJobs[relevantJobs.length - 1]?.capturedAt ?? null;
+  for (const job of relevantJobs) {
+    if (job.error) {
+      summary.latestError = job.error;
+    }
+    if (job.nextRetryAt && (!summary.nextRetryAt || job.nextRetryAt < summary.nextRetryAt)) {
+      summary.nextRetryAt = job.nextRetryAt;
+    }
+    if (job.status === "processing") {
+      summary.processingJobCount += 1;
+      continue;
+    }
+    if (job.status === "failed") {
+      summary.failedJobCount += 1;
+      continue;
+    }
+    if (!isPastDue(job.nextRetryAt)) {
+      summary.retryScheduledJobCount += 1;
+      continue;
+    }
+    summary.queuedJobCount += 1;
+  }
+  summary.activeJobCount = summary.queuedJobCount + summary.processingJobCount + summary.retryScheduledJobCount;
+  if (summary.processingJobCount > 0) {
+    summary.state = "processing";
+  } else if (summary.queuedJobCount > 0) {
+    summary.state = "queued";
+  } else if (summary.retryScheduledJobCount > 0) {
+    summary.state = "retry_scheduled";
+  } else if (summary.failedJobCount > 0) {
+    summary.state = "failed";
+  }
+  return summary;
+}
+async function updatePendingFinalizeJob(jobId, update) {
+  const existing = await readPendingFinalizeJob(jobId);
+  if (!existing) return null;
+  const next = {
+    ...existing,
+    ...update,
+    schemaVersion: 1,
+    id: existing.id,
+    capturedAt: existing.capturedAt,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    metadata: update.metadata ? { ...existing.metadata, ...update.metadata } : existing.metadata
+  };
+  await writeJsonAtomic(getJobPath(jobId), next);
+  return next;
+}
+async function claimPendingFinalizeJob(jobId) {
+  const lockPath = getJobLockPath(jobId);
+  const lockAcquired = await acquireJobLock(jobId);
+  if (!lockAcquired) return null;
+  let released = false;
+  const release = async () => {
+    if (released) return;
+    released = true;
+    await import_promises16.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+  };
+  try {
+    let existing = await readPendingFinalizeJob(jobId);
+    if (!existing) {
+      await release();
+      return null;
+    }
+    if (isStaleAttempt(existing)) {
+      const recovered = await updatePendingFinalizeJob(jobId, {
+        status: "queued",
+        error: existing.error ?? "Recovered a stale finalize processing lease.",
+        nextRetryAt: null
+      });
+      existing = recovered ?? existing;
+    }
+    if (existing.status === "failed") {
+      if (isTerminalFailure(existing)) {
+        await release();
+        return null;
+      }
+      const recovered = await updatePendingFinalizeJob(jobId, {
+        status: "queued",
+        nextRetryAt: existing.nextRetryAt ?? null
+      });
+      existing = recovered ?? existing;
+    }
+    if (existing.status !== "queued" || !isPastDue(existing.nextRetryAt)) {
+      await release();
+      return null;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const claimed = await updatePendingFinalizeJob(jobId, {
+      status: "processing",
+      error: null,
+      retryCount: existing.retryCount + 1,
+      lastAttemptAt: now,
+      nextRetryAt: null
+    });
+    if (!claimed) {
+      await release();
+      return null;
+    }
+    return { job: claimed, release };
+  } catch (error) {
+    await release();
+    throw error;
+  }
+}
+async function removePendingFinalizeJob(jobId) {
+  try {
+    await import_promises16.default.unlink(getJobPath(jobId));
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  await import_promises16.default.rm(getJobLockPath(jobId), { recursive: true, force: true }).catch(() => void 0);
 }
 function unwrapResponseObject(resp, label) {
   const obj = resp?.responseObject;
@@ -8124,7 +8261,7 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function buildDeterministicIdempotencyKey(parts) {
-  return (0, import_crypto2.createHash)("sha256").update(JSON.stringify(parts)).digest("hex");
+  return (0, import_crypto4.createHash)("sha256").update(JSON.stringify(parts)).digest("hex");
 }
 function formatCliErrorDetail(err) {
   if (err instanceof RemixError) {
@@ -8135,25 +8272,6 @@ function formatCliErrorDetail(err) {
   }
   return typeof err === "string" && err.trim() ? err.trim() : null;
 }
-async function pollAppReady(api, appId) {
-  const started = Date.now();
-  let delay = 2e3;
-  while (Date.now() - started < 20 * 60 * 1e3) {
-    const appResp = await api.getApp(appId);
-    const app = unwrapResponseObject(appResp, "app");
-    const status = typeof app.status === "string" ? app.status : "";
-    if (status === "ready") return app;
-    if (status === "error") {
-      throw new RemixError("App is in error state.", {
-        exitCode: 1,
-        hint: typeof app.statusError === "string" ? app.statusError : null
-      });
-    }
-    await sleep(delay);
-    delay = Math.min(1e4, Math.floor(delay * 1.4));
-  }
-  throw new RemixError("Timed out waiting for app to become ready.", { exitCode: 1 });
-}
 async function pollChangeStep(api, appId, changeStepId) {
   const started = Date.now();
   let delay = 1500;
@@ -8428,638 +8546,567 @@ async function ensureActiveLaneBinding(params) {
     hint: `Run \`remix collab init\` on branch ${resolved.currentBranch} before running ${params.operation ?? "this command"}.`
   });
 }
-async function collabRecordingPreflight(params) {
+function buildBaseState() {
+  return {
+    status: "ready",
+    repoState: null,
+    repoRoot: null,
+    binding: null,
+    currentBranch: null,
+    branchName: null,
+    localCommitHash: null,
+    currentSnapshotHash: null,
+    currentServerHeadHash: null,
+    currentServerHeadCommitId: null,
+    worktreeClean: false,
+    pendingFinalize: {
+      state: "idle",
+      activeJobCount: 0,
+      queuedJobCount: 0,
+      processingJobCount: 0,
+      retryScheduledJobCount: 0,
+      failedJobCount: 0,
+      oldestCapturedAt: null,
+      newestCapturedAt: null,
+      nextRetryAt: null,
+      latestError: null
+    },
+    warnings: [],
+    hint: null,
+    metadataWarnings: [],
+    baseline: {
+      lastSnapshotId: null,
+      lastSnapshotHash: null,
+      lastServerHeadHash: null,
+      lastSeenLocalCommitHash: null
+    }
+  };
+}
+async function collabDetectRepoState(params) {
+  const detected = buildBaseState();
   let repoRoot;
   try {
     repoRoot = await findGitRoot(params.cwd);
   } catch (error) {
-    const message = error instanceof Error ? error.message : "Not inside a git repository.";
-    return {
-      status: "not_git_repo",
-      repoRoot: null,
-      appId: null,
-      currentBranch: null,
-      branchName: null,
-      headCommitHash: null,
-      worktreeClean: false,
-      syncStatus: null,
-      syncTargetCommitHash: null,
-      syncTargetCommitId: null,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: [],
-      hint: message
-    };
+    detected.status = "not_git_repo";
+    detected.hint = formatCliErrorDetail(error) ?? "Not inside a git repository.";
+    return detected;
   }
-  const bindingResolution = await resolveActiveLaneBinding({ repoRoot, api: params.api });
+  detected.repoRoot = repoRoot;
+  const bindingResolution = await resolveActiveLaneBinding({ repoRoot, api: params.api ?? void 0 });
   if (bindingResolution.status === "not_bound") {
-    return {
-      status: "not_bound",
-      repoRoot,
-      appId: null,
-      currentBranch: null,
-      branchName: null,
-      headCommitHash: null,
-      worktreeClean: false,
-      syncStatus: null,
-      syncTargetCommitHash: null,
-      syncTargetCommitId: null,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: [],
-      hint: "Run `remix collab init` first."
-    };
+    detected.status = "not_bound";
+    detected.repoState = "binding_problem";
+    detected.hint = "Run `remix collab init` first.";
+    return detected;
   }
   if (bindingResolution.status === "missing_branch_binding") {
-    return {
-      status: "branch_binding_missing",
-      repoRoot,
-      appId: null,
-      currentBranch: bindingResolution.currentBranch,
-      branchName: bindingResolution.currentBranch,
-      headCommitHash: null,
-      worktreeClean: false,
-      syncStatus: null,
-      syncTargetCommitHash: null,
-      syncTargetCommitId: null,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: [],
-      hint: `Current branch ${bindingResolution.currentBranch ?? "(detached)"} is not yet bound to a Remix lane.`
-    };
+    detected.status = "branch_binding_missing";
+    detected.repoState = "binding_problem";
+    detected.currentBranch = bindingResolution.currentBranch;
+    detected.branchName = bindingResolution.currentBranch;
+    detected.hint = `Current branch ${bindingResolution.currentBranch ?? "(detached)"} is not yet bound to a Remix lane.`;
+    return detected;
   }
   if (bindingResolution.status === "ambiguous_family_selection") {
-    return {
-      status: "family_ambiguous",
-      repoRoot,
-      appId: null,
-      currentBranch: bindingResolution.currentBranch,
-      branchName: bindingResolution.currentBranch,
-      headCommitHash: null,
-      worktreeClean: false,
-      syncStatus: null,
-      syncTargetCommitHash: null,
-      syncTargetCommitId: null,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: [],
-      hint: "Multiple canonical Remix families match this repository. Continue from a checkout already bound to the intended family, or run `remix collab init --force-new` to create a new canonical family."
-    };
+    detected.status = "family_ambiguous";
+    detected.repoState = "binding_problem";
+    detected.currentBranch = bindingResolution.currentBranch;
+    detected.branchName = bindingResolution.currentBranch;
+    detected.hint = "Multiple canonical Remix families match this repository. Continue from a checkout already bound to the intended family, or run `remix collab init --force-new`.";
+    return detected;
   }
   if (bindingResolution.status === "binding_conflict") {
-    return {
-      status: "metadata_conflict",
-      repoRoot,
-      appId: bindingResolution.binding.currentAppId,
-      currentBranch: bindingResolution.currentBranch,
-      branchName: bindingResolution.binding.branchName,
-      headCommitHash: null,
-      worktreeClean: false,
-      syncStatus: null,
-      syncTargetCommitHash: null,
-      syncTargetCommitId: null,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: [],
-      hint: `Local binding for ${bindingResolution.currentBranch ?? "(detached)"} points to app ${bindingResolution.binding.currentAppId}, but the server resolved lane ${bindingResolution.resolvedLane.laneId ?? "(unknown)"} / app ${bindingResolution.resolvedLane.currentAppId ?? "(unknown)"}. Repair the branch binding before recording work.`
-    };
+    detected.status = "metadata_conflict";
+    detected.repoState = "metadata_conflict";
+    detected.binding = bindingResolution.binding;
+    detected.currentBranch = bindingResolution.currentBranch;
+    detected.branchName = bindingResolution.binding.branchName;
+    detected.hint = `Local binding for ${bindingResolution.currentBranch ?? "(detached)"} points to app ${bindingResolution.binding.currentAppId}, but the server resolved lane ${bindingResolution.resolvedLane.laneId ?? "(unknown)"} / app ${bindingResolution.resolvedLane.currentAppId ?? "(unknown)"}.`;
+    return detected;
   }
   const binding = bindingResolution.binding;
-  const [currentBranch, headCommitHash, worktreeStatus] = await Promise.all([
+  detected.binding = binding;
+  const [currentBranch, localCommitHash, worktreeStatus] = await Promise.all([
     getCurrentBranch(repoRoot),
     getHeadCommitHash(repoRoot),
     getWorktreeStatus(repoRoot)
   ]);
-  const branchName = binding.branchName ?? null;
-  if (!headCommitHash) {
-    return {
-      status: "missing_head",
-      repoRoot,
-      appId: binding.currentAppId,
-      currentBranch,
-      branchName,
-      headCommitHash: null,
-      worktreeClean: worktreeStatus.isClean,
-      syncStatus: null,
-      syncTargetCommitHash: null,
-      syncTargetCommitId: null,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: [],
-      hint: "Failed to resolve local HEAD commit."
-    };
-  }
-  if (!params.allowBranchMismatch && !isBoundBranchMatch(currentBranch, branchName)) {
-    return {
-      status: "branch_mismatch",
-      repoRoot,
-      appId: binding.currentAppId,
-      currentBranch,
-      branchName,
-      headCommitHash,
-      worktreeClean: worktreeStatus.isClean,
-      syncStatus: null,
-      syncTargetCommitHash: null,
-      syncTargetCommitId: null,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: [],
-      hint: buildBranchMismatchHint({
-        currentBranch,
-        branchName
+  detected.currentBranch = currentBranch;
+  detected.branchName = binding.branchName ?? null;
+  detected.localCommitHash = localCommitHash;
+  detected.worktreeClean = worktreeStatus.isClean;
+  if (!localCommitHash) {
+    detected.status = "missing_head";
+    detected.repoState = "binding_problem";
+    detected.hint = "Failed to resolve local HEAD commit.";
+    return detected;
+  }
+  if (!params.allowBranchMismatch && !isBoundBranchMatch(currentBranch, binding.branchName ?? null)) {
+    detected.status = "branch_mismatch";
+    detected.repoState = "binding_problem";
+    detected.hint = buildBranchMismatchHint({ currentBranch, branchName: binding.branchName ?? null });
+    return detected;
+  }
+  if (!params.api) {
+    const [inspection, pendingFinalize] = await Promise.all([
+      inspectLocalSnapshot({
+        repoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        laneId: binding.laneId,
+        branchName: binding.branchName,
+        persistBlobs: false
+      }),
+      summarizePendingFinalizeJobs({
+        repoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        currentAppId: binding.currentAppId,
+        laneId: binding.laneId
       })
-    };
-  }
-  const syncResp = await params.api.syncLocalApp(binding.currentAppId, {
-    baseCommitHash: headCommitHash,
-    repoFingerprint: binding.repoFingerprint ?? void 0,
-    remoteUrl: binding.remoteUrl ?? void 0,
-    defaultBranch: binding.defaultBranch ?? void 0,
-    dryRun: true
-  });
-  const sync = unwrapResponseObject(syncResp, "sync result");
-  if (sync.status === "conflict_risk") {
-    return {
-      status: "metadata_conflict",
-      repoRoot,
-      appId: binding.currentAppId,
-      currentBranch,
-      branchName,
-      headCommitHash,
-      worktreeClean: worktreeStatus.isClean,
-      syncStatus: sync.status,
-      syncTargetCommitHash: sync.targetCommitHash,
-      syncTargetCommitId: sync.targetCommitId,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: sync.warnings,
-      hint: sync.warnings.join("\n") || "Run the command from the correct bound repository."
-    };
-  }
-  if (sync.status === "up_to_date" || sync.status === "ready_to_fast_forward") {
-    return {
-      status: sync.status,
-      repoRoot,
-      appId: binding.currentAppId,
-      currentBranch,
-      branchName,
-      headCommitHash,
-      worktreeClean: worktreeStatus.isClean,
-      syncStatus: sync.status,
-      syncTargetCommitHash: sync.targetCommitHash,
-      syncTargetCommitId: sync.targetCommitId,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: sync.warnings,
-      hint: null
-    };
-  }
-  const reconcileResp = await params.api.preflightAppReconcile(binding.currentAppId, {
-    localHeadCommitHash: headCommitHash,
-    repoFingerprint: binding.repoFingerprint ?? void 0,
-    remoteUrl: binding.remoteUrl ?? void 0,
-    defaultBranch: binding.defaultBranch ?? void 0
-  });
-  const reconcile = unwrapResponseObject(reconcileResp, "reconcile preflight");
-  if (reconcile.status === "metadata_conflict") {
-    return {
-      status: "metadata_conflict",
-      repoRoot,
-      appId: binding.currentAppId,
-      currentBranch,
-      branchName,
-      headCommitHash,
-      worktreeClean: worktreeStatus.isClean,
-      syncStatus: sync.status,
-      syncTargetCommitHash: sync.targetCommitHash,
-      syncTargetCommitId: sync.targetCommitId,
-      reconcileTargetHeadCommitHash: reconcile.targetHeadCommitHash,
-      reconcileTargetHeadCommitId: reconcile.targetHeadCommitId,
-      warnings: reconcile.warnings,
-      hint: reconcile.warnings.join("\n") || "Run the command from the correct bound repository."
-    };
-  }
-  if (reconcile.status === "up_to_date") {
-    return {
-      status: "up_to_date",
-      repoRoot,
-      appId: binding.currentAppId,
-      currentBranch,
-      branchName,
-      headCommitHash,
-      worktreeClean: worktreeStatus.isClean,
-      syncStatus: sync.status,
-      syncTargetCommitHash: sync.targetCommitHash,
-      syncTargetCommitId: sync.targetCommitId,
-      reconcileTargetHeadCommitHash: reconcile.targetHeadCommitHash,
-      reconcileTargetHeadCommitId: reconcile.targetHeadCommitId,
-      warnings: reconcile.warnings,
-      hint: null
-    };
+    ]);
+    detected.currentSnapshotHash = inspection.snapshotHash;
+    detected.pendingFinalize = pendingFinalize;
+    return detected;
   }
-  return {
-    status: "reconcile_required",
-    repoRoot,
-    appId: binding.currentAppId,
-    currentBranch,
-    branchName,
-    headCommitHash,
-    worktreeClean: worktreeStatus.isClean,
-    syncStatus: sync.status,
-    syncTargetCommitHash: sync.targetCommitHash,
-    syncTargetCommitId: sync.targetCommitId,
-    reconcileTargetHeadCommitHash: reconcile.targetHeadCommitHash,
-    reconcileTargetHeadCommitId: reconcile.targetHeadCommitId,
-    warnings: reconcile.warnings,
-    hint: reconcile.warnings.join("\n") || "Run `remix collab reconcile` first because the local history is no longer fast-forward compatible with the app."
-  };
-}
-var DEFAULT_ACQUIRE_TIMEOUT_MS = 15e3;
-var DEFAULT_STALE_MS = 45e3;
-var DEFAULT_HEARTBEAT_MS = 5e3;
-var RETRY_DELAY_MS = 250;
-var heldLocks = /* @__PURE__ */ new Map();
-function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function createOwner(params) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  return {
-    operation: params.operation,
-    repoRoot: params.repoRoot,
-    pid: process.pid,
-    hostname: import_os2.default.hostname(),
-    startedAt: now,
-    heartbeatAt: now,
-    version: process.version,
-    requestId: params.requestId?.trim() || null
-  };
-}
-async function writeOwnerMetadata(ownerPath, owner) {
-  await import_promises16.default.writeFile(ownerPath, `${JSON.stringify(owner, null, 2)}
-`, "utf8");
-}
-async function readOwnerMetadata(ownerPath) {
   try {
-    const raw = await import_promises16.default.readFile(ownerPath, "utf8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object") return null;
-    if (!parsed.operation || !parsed.repoRoot || typeof parsed.pid !== "number" || !parsed.startedAt || !parsed.heartbeatAt) {
-      return null;
-    }
-    return {
-      operation: parsed.operation,
-      repoRoot: parsed.repoRoot,
-      pid: parsed.pid,
-      hostname: typeof parsed.hostname === "string" ? parsed.hostname : "unknown",
-      startedAt: parsed.startedAt,
-      heartbeatAt: parsed.heartbeatAt,
-      version: typeof parsed.version === "string" ? parsed.version : "unknown",
-      requestId: typeof parsed.requestId === "string" ? parsed.requestId : null
+    const [headResp, inspection, baseline, pendingFinalize] = await Promise.all([
+      params.api.getAppHead(binding.currentAppId),
+      inspectLocalSnapshot({
+        repoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        laneId: binding.laneId,
+        branchName: binding.branchName,
+        persistBlobs: false
+      }),
+      readLocalBaseline({
+        repoFingerprint: binding.repoFingerprint,
+        laneId: binding.laneId,
+        repoRoot
+      }),
+      summarizePendingFinalizeJobs({
+        repoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        currentAppId: binding.currentAppId,
+        laneId: binding.laneId
+      })
+    ]);
+    const appHead = unwrapResponseObject(headResp, "app head");
+    detected.currentServerHeadHash = appHead.headCommitHash;
+    detected.currentServerHeadCommitId = appHead.headCommitId;
+    detected.currentSnapshotHash = inspection.snapshotHash;
+    detected.pendingFinalize = pendingFinalize;
+    detected.baseline = {
+      lastSnapshotId: baseline?.lastSnapshotId ?? null,
+      lastSnapshotHash: baseline?.lastSnapshotHash ?? null,
+      lastServerHeadHash: baseline?.lastServerHeadHash ?? null,
+      lastSeenLocalCommitHash: baseline?.lastSeenLocalCommitHash ?? null
     };
-  } catch {
-    return null;
-  }
-}
-async function isProcessAlive(owner) {
-  if (!owner) return null;
-  if (owner.hostname !== import_os2.default.hostname()) return null;
-  try {
-    process.kill(owner.pid, 0);
-    return true;
+    if (!baseline?.lastSnapshotHash || !baseline.lastServerHeadHash) {
+      if (detected.worktreeClean && localCommitHash && localCommitHash !== appHead.headCommitHash) {
+        try {
+          const bootstrapResp = await params.api.getAppDelta(binding.currentAppId, {
+            baseHeadHash: localCommitHash,
+            targetHeadHash: appHead.headCommitHash,
+            repoFingerprint: binding.repoFingerprint ?? void 0,
+            remoteUrl: binding.remoteUrl ?? void 0,
+            defaultBranch: binding.defaultBranch ?? void 0
+          });
+          const bootstrapDelta = unwrapResponseObject(bootstrapResp, "app delta");
+          detected.metadataWarnings = Array.from(/* @__PURE__ */ new Set([...detected.metadataWarnings, ...bootstrapDelta.warnings]));
+          detected.warnings.push(...bootstrapDelta.warnings);
+          if (bootstrapDelta.status === "conflict_risk") {
+            detected.status = "metadata_conflict";
+            detected.repoState = "metadata_conflict";
+            detected.hint = bootstrapDelta.warnings.join("\n") || "Run the command from the correct bound repository.";
+            return detected;
+          }
+          if (bootstrapDelta.status === "delta_ready" || bootstrapDelta.status === "up_to_date") {
+            detected.repoState = "server_only_changed";
+            detected.hint = "This checkout has not stored a local Remix baseline yet, but its current Git HEAD is already known to Remix. Pull the server delta locally to create the first baseline for this checkout.";
+            return detected;
+          }
+        } catch {
+        }
+      }
+      detected.repoState = "external_local_base_changed";
+      detected.hint = "No local Remix baseline exists for this lane yet. Run `remix collab re-anchor` to anchor this checkout.";
+      return detected;
+    }
+    const localHeadMovedSinceBaseline = Boolean(baseline.lastSeenLocalCommitHash) && localCommitHash !== baseline.lastSeenLocalCommitHash;
+    if (localHeadMovedSinceBaseline) {
+      detected.warnings.push(
+        "Local Git HEAD changed since the last Remix baseline. Remix will use the current workspace snapshot to detect divergence."
+      );
+    }
+    const metadataBaseHeadHash = baseline.lastServerHeadHash || appHead.headCommitHash;
+    const metadataResp = await params.api.getAppDelta(binding.currentAppId, {
+      baseHeadHash: metadataBaseHeadHash,
+      targetHeadHash: metadataBaseHeadHash,
+      repoFingerprint: binding.repoFingerprint ?? void 0,
+      remoteUrl: binding.remoteUrl ?? void 0,
+      defaultBranch: binding.defaultBranch ?? void 0
+    });
+    const metadataCheck = unwrapResponseObject(metadataResp, "app delta metadata");
+    detected.metadataWarnings = metadataCheck.warnings;
+    detected.warnings.push(...metadataCheck.warnings);
+    if (metadataCheck.status === "conflict_risk") {
+      detected.status = "metadata_conflict";
+      detected.repoState = "metadata_conflict";
+      detected.hint = metadataCheck.warnings.join("\n") || "Run the command from the correct bound repository.";
+      return detected;
+    }
+    const localChanged = inspection.snapshotHash !== baseline.lastSnapshotHash;
+    const serverChanged = appHead.headCommitHash !== baseline.lastServerHeadHash;
+    if (!localChanged && !serverChanged) {
+      detected.repoState = "idle";
+      return detected;
+    }
+    if (localChanged && !serverChanged) {
+      detected.repoState = "local_only_changed";
+      return detected;
+    }
+    if (!localChanged && serverChanged) {
+      detected.repoState = "server_only_changed";
+      detected.hint = "The server lane advanced since the last agreed baseline. Pull the server delta locally before continuing.";
+      return detected;
+    }
+    detected.repoState = "both_changed";
+    detected.hint = "Both the local workspace and the server lane changed since the last agreed baseline. Replay or reconcile is required before normal recording continues.";
+    return detected;
   } catch (error) {
-    if (error?.code === "EPERM") return true;
-    if (error?.code === "ESRCH") return false;
-    return null;
+    detected.status = "remote_error";
+    detected.hint = formatCliErrorDetail(error) ?? "Failed to detect the current Remix repo state.";
+    return detected;
   }
 }
-async function getLastKnownUpdateMs(lockDir, ownerPath, owner) {
-  const heartbeatMs = owner ? Date.parse(owner.heartbeatAt) : Number.NaN;
-  if (Number.isFinite(heartbeatMs)) return heartbeatMs;
-  const startedMs = owner ? Date.parse(owner.startedAt) : Number.NaN;
-  if (Number.isFinite(startedMs)) return startedMs;
-  const stat = await import_promises16.default.stat(ownerPath).catch(() => null);
-  if (stat) return stat.mtimeMs;
-  const dirStat = await import_promises16.default.stat(lockDir).catch(() => null);
-  if (dirStat) return dirStat.mtimeMs;
-  return 0;
+var FINALIZE_RETRY_BASE_DELAY_MS = 15e3;
+var FINALIZE_RETRY_MAX_DELAY_MS = 5 * 60 * 1e3;
+function readMetadataString(job, key) {
+  const value = job.metadata[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-async function ensureLockDir(lockDir) {
-  await import_promises16.default.mkdir(import_path5.default.dirname(lockDir), { recursive: true });
+function readMetadataActor(job) {
+  const actor = job.metadata.actor;
+  return actor && typeof actor === "object" ? actor : void 0;
 }
-async function tryAcquireLock(lockDir, ownerPath, owner) {
-  try {
-    await ensureLockDir(lockDir);
-    await import_promises16.default.mkdir(lockDir);
-    try {
-      await writeOwnerMetadata(ownerPath, owner);
-    } catch (error) {
-      await import_promises16.default.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
-      throw error;
-    }
-    return true;
-  } catch (error) {
-    if (error?.code === "EEXIST") return false;
-    throw error;
-  }
+function buildNextRetryAt(retryCount) {
+  const exponent = Math.max(0, retryCount - 1);
+  const delayMs = Math.min(FINALIZE_RETRY_BASE_DELAY_MS * 2 ** exponent, FINALIZE_RETRY_MAX_DELAY_MS);
+  return new Date(Date.now() + delayMs).toISOString();
 }
-function formatLockHint(params) {
-  const lines = [
-    params.observedHeldLock ? `Observed lock state: ${REMIX_ERROR_CODES.REPO_LOCK_HELD}.` : null,
-    params.owner ? `Active operation: ${params.owner.operation}` : "Active operation: unknown",
-    params.owner ? `Repo root: ${params.owner.repoRoot}` : null,
-    params.owner ? `Owner: pid=${params.owner.pid} host=${params.owner.hostname}` : null,
-    params.owner ? `Started at: ${params.owner.startedAt}` : null,
-    params.owner ? `Heartbeat at: ${params.owner.heartbeatAt}` : null,
-    `Waited ${params.waitedMs}ms for the repo mutation lock.`,
-    `Stale lock threshold: ${params.staleMs}ms.`,
-    "Retry after the active operation finishes. If the process crashed, wait for stale lock recovery or remove the stale lock manually if necessary."
-  ];
-  return lines.filter(Boolean).join("\n");
+function buildFinalizeCliError(params) {
+  const error = new RemixError(params.message, {
+    exitCode: params.exitCode,
+    hint: params.hint
+  });
+  error.finalizeDisposition = params.disposition;
+  error.finalizeReason = params.reason;
+  return error;
 }
-function formatOwnerSummary(owner) {
-  if (!owner) {
-    return "unknown owner";
-  }
-  return `operation=${owner.operation} pid=${owner.pid} host=${owner.hostname} startedAt=${owner.startedAt} heartbeatAt=${owner.heartbeatAt}`;
+function classifyFinalizeError(error) {
+  const tagged = error;
+  return {
+    disposition: tagged.finalizeDisposition ?? "retryable",
+    reason: tagged.finalizeReason ?? "unknown",
+    message: error instanceof Error ? error.message : String(error)
+  };
 }
-function buildStaleRecoveryNotice(owner) {
+function buildWorkspaceMetadata(params) {
   return {
-    code: REMIX_ERROR_CODES.REPO_LOCK_STALE_RECOVERED,
-    owner,
-    message: `[${REMIX_ERROR_CODES.REPO_LOCK_STALE_RECOVERED}] Recovered a stale Remix repo mutation lock (${formatOwnerSummary(owner)}).`
+    branch: params.branchName,
+    repoRoot: params.repoRoot,
+    remoteUrl: params.remoteUrl,
+    defaultBranch: params.defaultBranch,
+    recordingMode: "boundary_delta",
+    baselineSnapshotId: params.baselineSnapshotId,
+    currentSnapshotId: params.currentSnapshotId,
+    baselineServerHeadHash: params.baselineServerHeadHash,
+    currentSnapshotHash: params.currentSnapshotHash,
+    localCommitHash: params.localCommitHash,
+    repoStateAtCapture: params.repoState,
+    replayedFromBaseHash: params.replayedFromBaseHash ?? null
   };
 }
-async function acquirePhysicalLock(lockDir, ownerPath, owner, options) {
-  const startedAt = Date.now();
-  const notices = [];
-  let observedHeldLock = false;
-  while (Date.now() - startedAt < options.acquireTimeoutMs) {
-    if (await tryAcquireLock(lockDir, ownerPath, owner)) return notices;
-    const currentOwner2 = await readOwnerMetadata(ownerPath);
-    observedHeldLock = true;
-    const lastUpdateMs = await getLastKnownUpdateMs(lockDir, ownerPath, currentOwner2);
-    const ageMs = Math.max(0, Date.now() - lastUpdateMs);
-    const alive = await isProcessAlive(currentOwner2);
-    if (ageMs >= options.staleMs && alive !== true) {
-      notices.push(buildStaleRecoveryNotice(currentOwner2));
-      await import_promises16.default.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
-      continue;
+async function processClaimedPendingFinalizeJob(params) {
+  const job = params.job;
+  try {
+    const [snapshot, baseline, appHeadResp] = await Promise.all([
+      readLocalSnapshot(job.currentSnapshotId),
+      readLocalBaseline({
+        repoFingerprint: job.repoFingerprint,
+        laneId: job.laneId,
+        repoRoot: job.repoRoot
+      }),
+      params.api.getAppHead(job.currentAppId)
+    ]);
+    if (!snapshot) {
+      throw buildFinalizeCliError({
+        message: "Captured snapshot is missing from the local snapshot store.",
+        exitCode: 1,
+        disposition: "terminal",
+        reason: "snapshot_missing"
+      });
     }
-    await sleep2(RETRY_DELAY_MS);
-  }
-  const currentOwner = await readOwnerMetadata(ownerPath);
-  throw new RemixError("Repository is busy with another Remix mutation.", {
-    code: REMIX_ERROR_CODES.REPO_LOCK_TIMEOUT,
-    exitCode: 2,
-    hint: formatLockHint({
-      owner: currentOwner,
-      waitedMs: Date.now() - startedAt,
-      staleMs: options.staleMs,
-      observedHeldLock
-    })
-  });
-}
-function startHeartbeat(lockDir, ownerPath, owner, heartbeatMs) {
-  return setInterval(() => {
-    const nextOwner = {
-      ...owner,
-      heartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    owner.heartbeatAt = nextOwner.heartbeatAt;
-    void writeOwnerMetadata(ownerPath, nextOwner).catch(() => void 0);
-    void import_promises16.default.utimes(lockDir, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date()).catch(() => void 0);
-  }, heartbeatMs);
-}
-async function releaseReentrantLock(lockDir) {
-  const held = heldLocks.get(lockDir);
-  if (!held) return;
-  held.count -= 1;
-  if (held.count > 0) return;
-  clearInterval(held.heartbeatTimer);
-  heldLocks.delete(lockDir);
-  await import_promises16.default.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
-}
-async function withRepoMutationLock(options, fn) {
-  const repoRoot = await findGitRoot(options.cwd);
-  const gitCommonDir = await getGitCommonDir(repoRoot);
-  const lockDir = import_path5.default.join(gitCommonDir, "remix", "locks", "repo-mutation.lock");
-  const owner = createOwner({
-    operation: options.operation,
-    repoRoot,
-    requestId: options.requestId
-  });
-  const heartbeatMs = options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
-  const acquireTimeoutMs = options.acquireTimeoutMs ?? DEFAULT_ACQUIRE_TIMEOUT_MS;
-  const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
-  const existing = heldLocks.get(lockDir);
-  let notices = [];
-  if (!existing) {
-    notices = await acquirePhysicalLock(lockDir, import_path5.default.join(lockDir, "owner.json"), owner, {
-      acquireTimeoutMs,
-      staleMs
-    });
-    const ownerPath = import_path5.default.join(lockDir, "owner.json");
-    heldLocks.set(lockDir, {
-      count: 1,
-      lockDir,
-      ownerPath,
-      owner,
-      heartbeatTimer: startHeartbeat(lockDir, ownerPath, owner, heartbeatMs)
+    if (!baseline) {
+      throw buildFinalizeCliError({
+        message: "Local baseline is missing for this queued finalize job.",
+        exitCode: 2,
+        hint: "Run `remix collab re-anchor` to anchor the repository again.",
+        disposition: "terminal",
+        reason: "baseline_missing"
+      });
+    }
+    if (baseline.lastSnapshotId !== job.baselineSnapshotId || baseline.lastServerHeadHash !== job.baselineServerHeadHash) {
+      throw buildFinalizeCliError({
+        message: "Finalize queue baseline drifted before this job was processed.",
+        exitCode: 1,
+        hint: "Process queued finalize jobs in capture order, or re-anchor the repository before retrying.",
+        disposition: "terminal",
+        reason: "baseline_drifted"
+      });
+    }
+    const appHead = unwrapResponseObject(appHeadResp, "app head");
+    const remoteUrl = readMetadataString(job, "remoteUrl");
+    const defaultBranch = readMetadataString(job, "defaultBranch");
+    const repoState = readMetadataString(job, "repoState");
+    const actor = readMetadataActor(job);
+    const diffResult = await diffLocalSnapshots({
+      baseSnapshotId: job.baselineSnapshotId,
+      targetSnapshotId: job.currentSnapshotId
+    });
+    if (!diffResult.diff.trim()) {
+      if (appHead.headCommitHash !== job.baselineServerHeadHash) {
+        throw buildFinalizeCliError({
+          message: "Server lane changed before a no-diff turn could be recorded.",
+          exitCode: 2,
+          hint: "Pull the server changes locally before recording another no-diff turn.",
+          disposition: "terminal",
+          reason: "server_lane_changed"
+        });
+      }
+      const collabTurnResp = await params.api.createCollabTurn(job.currentAppId, {
+        threadId: job.threadId ?? void 0,
+        collabLaneId: job.laneId ?? void 0,
+        prompt: job.prompt,
+        assistantResponse: job.assistantResponse,
+        actor,
+        workspaceMetadata: buildWorkspaceMetadata({
+          repoRoot: job.repoRoot,
+          branchName: job.branchName,
+          remoteUrl,
+          defaultBranch,
+          baselineSnapshotId: job.baselineSnapshotId,
+          currentSnapshotId: job.currentSnapshotId,
+          baselineServerHeadHash: job.baselineServerHeadHash,
+          currentSnapshotHash: snapshot.snapshotHash,
+          localCommitHash: snapshot.localCommitHash,
+          repoState
+        }),
+        idempotencyKey: job.idempotencyKey ?? void 0
+      });
+      const collabTurn = unwrapResponseObject(collabTurnResp, "collab turn");
+      await writeLocalBaseline({
+        repoRoot: job.repoRoot,
+        repoFingerprint: job.repoFingerprint,
+        laneId: job.laneId,
+        currentAppId: job.currentAppId,
+        branchName: job.branchName,
+        lastSnapshotId: snapshot.id,
+        lastSnapshotHash: snapshot.snapshotHash,
+        lastServerHeadHash: appHead.headCommitHash,
+        lastSeenLocalCommitHash: snapshot.localCommitHash
+      });
+      await updatePendingFinalizeJob(job.id, {
+        status: "completed",
+        metadata: { collabTurnId: collabTurn.id }
+      });
+      return {
+        mode: "no_diff_turn",
+        idempotencyKey: job.idempotencyKey ?? "",
+        queued: false,
+        jobId: job.id,
+        repoState,
+        changeStep: null,
+        collabTurn,
+        autoSync: null,
+        warnings: []
+      };
+    }
+    let submissionDiff = diffResult.diff;
+    let submissionBaseHeadHash = job.baselineServerHeadHash;
+    let replayedFromBaseHash = null;
+    if (!submissionBaseHeadHash) {
+      throw buildFinalizeCliError({
+        message: "Baseline server head is missing for this finalize job.",
+        exitCode: 1,
+        disposition: "terminal",
+        reason: "baseline_server_head_missing"
+      });
+    }
+    if (appHead.headCommitHash !== submissionBaseHeadHash) {
+      const replayResp = await params.api.startChangeStepReplay(job.currentAppId, {
+        prompt: job.prompt,
+        assistantResponse: job.assistantResponse,
+        diff: diffResult.diff,
+        baseCommitHash: submissionBaseHeadHash,
+        targetHeadCommitHash: appHead.headCommitHash,
+        expectedPaths: diffResult.changedPaths,
+        actor,
+        workspaceMetadata: buildWorkspaceMetadata({
+          repoRoot: job.repoRoot,
+          branchName: job.branchName,
+          remoteUrl,
+          defaultBranch,
+          baselineSnapshotId: job.baselineSnapshotId,
+          currentSnapshotId: job.currentSnapshotId,
+          baselineServerHeadHash: job.baselineServerHeadHash,
+          currentSnapshotHash: snapshot.snapshotHash,
+          localCommitHash: snapshot.localCommitHash,
+          repoState
+        }),
+        idempotencyKey: buildDeterministicIdempotencyKey({
+          kind: "collab_finalize_turn_replay_v1",
+          appId: job.currentAppId,
+          baseCommitHash: submissionBaseHeadHash,
+          targetHeadCommitHash: appHead.headCommitHash,
+          currentSnapshotId: job.currentSnapshotId,
+          diffSha256: diffResult.diffSha256
+        })
+      });
+      const replayStart = unwrapResponseObject(replayResp, "change step replay");
+      const replay = await pollChangeStepReplay(params.api, job.currentAppId, String(replayStart.id));
+      const replayDiffResp = await params.api.getChangeStepReplayDiff(job.currentAppId, replay.id);
+      const replayDiff = unwrapResponseObject(replayDiffResp, "change step replay diff");
+      submissionDiff = replayDiff.diff;
+      replayedFromBaseHash = submissionBaseHeadHash;
+      submissionBaseHeadHash = appHead.headCommitHash;
+    }
+    const changeStepResp = await params.api.createChangeStep(job.currentAppId, {
+      threadId: job.threadId ?? void 0,
+      collabLaneId: job.laneId ?? void 0,
+      prompt: job.prompt,
+      assistantResponse: job.assistantResponse,
+      diff: submissionDiff,
+      baseCommitHash: submissionBaseHeadHash,
+      headCommitHash: submissionBaseHeadHash,
+      changedFilesCount: diffResult.stats.changedFilesCount,
+      insertions: diffResult.stats.insertions,
+      deletions: diffResult.stats.deletions,
+      actor,
+      workspaceMetadata: buildWorkspaceMetadata({
+        repoRoot: job.repoRoot,
+        branchName: job.branchName,
+        remoteUrl,
+        defaultBranch,
+        baselineSnapshotId: job.baselineSnapshotId,
+        currentSnapshotId: job.currentSnapshotId,
+        baselineServerHeadHash: job.baselineServerHeadHash,
+        currentSnapshotHash: snapshot.snapshotHash,
+        localCommitHash: snapshot.localCommitHash,
+        repoState,
+        replayedFromBaseHash
+      }),
+      idempotencyKey: job.idempotencyKey ?? void 0
+    });
+    const createdStep = unwrapResponseObject(changeStepResp, "change step");
+    const changeStep = await pollChangeStep(params.api, job.currentAppId, String(createdStep.id));
+    const nextHeadResp = await params.api.getAppHead(job.currentAppId);
+    const nextHead = unwrapResponseObject(nextHeadResp, "app head");
+    await writeLocalBaseline({
+      repoRoot: job.repoRoot,
+      repoFingerprint: job.repoFingerprint,
+      laneId: job.laneId,
+      currentAppId: job.currentAppId,
+      branchName: job.branchName,
+      lastSnapshotId: snapshot.id,
+      lastSnapshotHash: snapshot.snapshotHash,
+      lastServerHeadHash: nextHead.headCommitHash,
+      lastSeenLocalCommitHash: snapshot.localCommitHash
+    });
+    await updatePendingFinalizeJob(job.id, {
+      status: "completed",
+      metadata: { changeStepId: String(changeStep.id ?? "") }
     });
-  } else {
-    existing.count += 1;
-  }
-  try {
-    return await fn({
-      repoRoot,
-      gitCommonDir,
-      lockDir,
-      notices,
-      warnings: notices.map((notice) => notice.message)
+    return {
+      mode: "changed_turn",
+      idempotencyKey: job.idempotencyKey ?? "",
+      queued: false,
+      jobId: job.id,
+      repoState,
+      changeStep,
+      collabTurn: null,
+      autoSync: null,
+      warnings: []
+    };
+  } catch (error) {
+    const classified = classifyFinalizeError(error);
+    await updatePendingFinalizeJob(job.id, {
+      status: classified.disposition === "terminal" ? "failed" : "queued",
+      error: classified.message,
+      nextRetryAt: classified.disposition === "terminal" ? null : buildNextRetryAt(job.retryCount),
+      metadata: {
+        failureDisposition: classified.disposition,
+        failureReason: classified.reason
+      }
     });
+    throw error;
   } finally {
-    await releaseReentrantLock(lockDir);
+    await params.release();
   }
 }
-async function collabSync(params) {
-  const repoRoot = await findGitRoot(params.cwd);
-  const binding = await ensureActiveLaneBinding({
-    repoRoot,
-    api: params.api,
-    operation: "`remix collab sync`"
-  });
-  if (!binding) {
-    throw new RemixError("Repository is not bound to Remix.", {
-      exitCode: 2,
-      hint: "Run `remix collab init` first."
-    });
-  }
-  await ensureCleanWorktree(repoRoot);
-  const branch = await requireCurrentBranch(repoRoot);
-  assertBoundBranchMatch({
-    currentBranch: branch,
-    branchName: binding.branchName,
-    allowBranchMismatch: params.allowBranchMismatch,
-    operation: "`remix collab sync`"
-  });
-  const headCommitHash = await getHeadCommitHash(repoRoot);
-  const repoSnapshot = await captureRepoSnapshot(repoRoot);
-  if (!headCommitHash) {
-    throw new RemixError("Failed to resolve local HEAD commit.", { exitCode: 1 });
-  }
-  const resp = await params.api.syncLocalApp(binding.currentAppId, {
-    baseCommitHash: headCommitHash,
-    repoFingerprint: binding.repoFingerprint ?? void 0,
-    remoteUrl: binding.remoteUrl ?? void 0,
-    defaultBranch: binding.defaultBranch ?? void 0,
-    dryRun: params.dryRun
+async function enqueueCapturedFinalizeTurn(params) {
+  return enqueuePendingFinalizeJob({
+    status: "queued",
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.repoFingerprint,
+    currentAppId: params.currentAppId,
+    laneId: params.laneId,
+    threadId: params.threadId,
+    branchName: params.branchName,
+    prompt: params.prompt,
+    assistantResponse: params.assistantResponse,
+    baselineSnapshotId: params.baselineSnapshotId,
+    baselineServerHeadHash: params.baselineServerHeadHash,
+    currentSnapshotId: params.currentSnapshotId,
+    idempotencyKey: params.idempotencyKey,
+    error: null,
+    retryCount: 0,
+    lastAttemptAt: null,
+    nextRetryAt: null,
+    metadata: params.metadata ?? {}
   });
-  const sync = unwrapResponseObject(resp, "sync result");
-  if (sync.status === "conflict_risk") {
-    throw new RemixError("Local repository metadata conflicts with the bound Remix app.", {
-      exitCode: 2,
-      hint: sync.warnings.join("\n") || "Run the command from the correct bound repository."
-    });
-  }
-  if (sync.status === "base_unknown") {
-    throw new RemixError("Local repository cannot be fast-forward synced.", {
-      exitCode: 2,
-      hint: "Your local HEAD is not on the app sandbox history. Reconcile the repository manually before syncing."
-    });
-  }
-  if (sync.status === "up_to_date") {
-    return {
-      status: sync.status,
-      branch,
-      repoRoot,
-      baseCommitHash: sync.baseCommitHash,
-      targetCommitHash: sync.targetCommitHash,
-      targetCommitId: sync.targetCommitId,
-      stats: sync.stats,
-      localCommitHash: headCommitHash,
-      applied: false,
-      dryRun: params.dryRun
-    };
-  }
-  const previewResult = {
-    status: sync.status,
-    branch,
-    repoRoot,
-    baseCommitHash: sync.baseCommitHash,
-    targetCommitHash: sync.targetCommitHash,
-    targetCommitId: sync.targetCommitId,
-    stats: sync.stats,
-    bundleRef: sync.bundleRef,
-    bundleSizeBytes: sync.bundleSizeBytes,
-    localCommitHash: headCommitHash,
-    applied: false,
-    dryRun: params.dryRun
-  };
-  if (params.dryRun) {
-    return previewResult;
-  }
-  if (!sync.bundleBase64 || !sync.bundleRef) {
-    throw new RemixError("Sync bundle payload is missing.", { exitCode: 1 });
-  }
-  const bundleBase64 = sync.bundleBase64;
-  const bundleRef = sync.bundleRef;
-  return withRepoMutationLock(
-    {
-      cwd: repoRoot,
-      operation: "collabSync"
-    },
-    async ({ repoRoot: lockedRepoRoot, warnings }) => {
-      await assertRepoSnapshotUnchanged(lockedRepoRoot, repoSnapshot, {
-        operation: "`remix collab sync`",
-        recoveryHint: "The repository changed after sync was prepared. Review the local changes and rerun `remix collab sync`."
-      });
-      await ensureCleanWorktree(lockedRepoRoot);
-      const lockedBranch = await requireCurrentBranch(lockedRepoRoot);
-      assertBoundBranchMatch({
-        currentBranch: lockedBranch,
-        branchName: binding.branchName,
-        allowBranchMismatch: params.allowBranchMismatch,
-        operation: "`remix collab sync`"
+}
+async function drainPendingFinalizeQueue(params) {
+  await prunePendingFinalizeJobs();
+  const jobs = await listPendingFinalizeJobs();
+  const results = [];
+  for (const job of jobs) {
+    const claimed = await claimPendingFinalizeJob(job.id);
+    if (!claimed) continue;
+    try {
+      const result = await processClaimedPendingFinalizeJob({
+        api: params.api,
+        job: claimed.job,
+        release: claimed.release
       });
-      const tempDir = await import_promises17.default.mkdtemp(import_path6.default.join(import_os3.default.tmpdir(), "remix-sync-"));
-      const bundlePath = import_path6.default.join(tempDir, "sync-local.bundle");
-      try {
-        await import_promises17.default.writeFile(bundlePath, Buffer.from(bundleBase64, "base64"));
-        await importGitBundle(lockedRepoRoot, bundlePath, bundleRef);
-        await ensureCommitExists(lockedRepoRoot, sync.targetCommitHash);
-        const localCommitHash = await fastForwardToCommit(lockedRepoRoot, sync.targetCommitHash);
-        return {
-          ...previewResult,
-          localCommitHash,
-          applied: true,
-          dryRun: false,
-          ...warnings.length > 0 ? { warnings } : {}
-        };
-      } finally {
-        await import_promises17.default.rm(tempDir, { recursive: true, force: true });
-      }
+      results.push(result);
+      await removePendingFinalizeJob(job.id);
+    } catch {
     }
-  );
-}
-function assertSupportedRecordingPreflight(preflight) {
-  if (preflight.status === "not_bound") {
-    throw new RemixError("Repository is not bound to Remix.", {
-      exitCode: 2,
-      hint: preflight.hint
-    });
-  }
-  if (preflight.status === "branch_binding_missing") {
-    throw new RemixError("Current branch is not yet bound to a Remix lane.", {
-      exitCode: 2,
-      hint: preflight.hint
-    });
-  }
-  if (preflight.status === "family_ambiguous") {
-    throw new RemixError("Multiple canonical Remix families match this repository.", {
-      exitCode: 2,
-      hint: preflight.hint
-    });
-  }
-  if (preflight.status === "not_git_repo") {
-    throw new RemixError(preflight.hint || "Not inside a git repository.", {
-      exitCode: 2,
-      hint: preflight.hint
-    });
-  }
-  if (preflight.status === "missing_head") {
-    throw new RemixError("Failed to resolve local HEAD commit.", {
-      exitCode: 1,
-      hint: preflight.hint
-    });
-  }
-  if (preflight.status === "branch_mismatch") {
-    assertBoundBranchMatch({
-      currentBranch: preflight.currentBranch,
-      branchName: preflight.branchName,
-      allowBranchMismatch: false,
-      operation: "`remix collab add`"
-    });
-  }
-  if (preflight.status === "metadata_conflict") {
-    throw new RemixError("Local repository metadata conflicts with the bound Remix app.", {
-      exitCode: 2,
-      hint: preflight.hint
-    });
-  }
-  if (preflight.status === "reconcile_required") {
-    throw new RemixError("Local repository cannot be fast-forward synced.", {
-      exitCode: 2,
-      hint: preflight.hint
-    });
   }
+  return results;
 }
-async function collabAdd(params) {
+function collectWarnings(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+}
+var FINALIZE_QUEUED_WARNING = "Queued only: the local Remix turn was captured, but no remote change step or collab turn exists yet. Drain or await finalize before merge-related flows.";
+async function collabFinalizeTurn(params) {
   const repoRoot = await findGitRoot(params.cwd);
   const binding = await ensureActiveLaneBinding({
     repoRoot,
     api: params.api,
-    operation: "`remix collab add`"
+    operation: "`remix collab finalize-turn`"
   });
   if (!binding) {
     throw new RemixError("Repository is not bound to Remix.", {
@@ -9068,385 +9115,114 @@ async function collabAdd(params) {
     });
   }
   const prompt = params.prompt.trim();
+  const assistantResponse = params.assistantResponse.trim();
   if (!prompt) throw new RemixError("Prompt is required.", { exitCode: 2 });
-  const assistantResponse = params.assistantResponse?.trim() || null;
-  const attachWarnings = (value, warnings) => warnings.length > 0 ? { ...value, warnings } : value;
-  const diffSource = params.diffSource ?? (params.diff ? "external" : "worktree");
-  const autoSyncEnabled = params.sync !== false;
-  const run = async (lockWarnings = []) => {
-    const preflight = await collabRecordingPreflight({
-      api: params.api,
-      cwd: repoRoot,
-      allowBranchMismatch: params.allowBranchMismatch
-    });
-    assertSupportedRecordingPreflight(preflight);
-    const branch = preflight.currentBranch;
-    assertBoundBranchMatch({
-      currentBranch: branch,
-      branchName: binding.branchName,
-      allowBranchMismatch: params.allowBranchMismatch,
-      operation: "`remix collab add`"
-    });
-    let headCommitHash = preflight.headCommitHash;
-    if (!headCommitHash) {
-      throw new RemixError("Failed to resolve local HEAD commit.", { exitCode: 1 });
-    }
-    const worktreeStatus = await getWorktreeStatus(repoRoot);
-    if (preflight.status === "ready_to_fast_forward") {
-      if (!autoSyncEnabled) {
-        throw new RemixError("Local repository is stale and `collab add` sync automation is disabled.", {
-          exitCode: 2,
-          hint: "Run `remix collab sync` first, or rerun without disabling sync automation."
-        });
-      }
-      if (!worktreeStatus.isClean && diffSource !== "worktree") {
-        throw new RemixError("Automatic stale-work replay requires the current worktree diff.", {
-          exitCode: 2,
-          hint: "Use `remix collab add` without an external diff while the local repo is dirty, or clean the repo before submitting an external diff."
-        });
-      }
-      if (worktreeStatus.isClean) {
-        await collabSync({
-          api: params.api,
-          cwd: repoRoot,
-          dryRun: false,
-          allowBranchMismatch: params.allowBranchMismatch
-        });
-        headCommitHash = await getHeadCommitHash(repoRoot);
-        if (!headCommitHash) {
-          throw new RemixError("Failed to resolve local HEAD after syncing.", { exitCode: 1 });
-        }
-      } else {
-        const staleWorkSnapshot = await captureRepoSnapshot(repoRoot, { includeWorkspaceDiffHash: true });
-        const preserved = await preserveWorkspaceChanges(repoRoot, "remix-add-preserve");
-        try {
-          await assertRepoSnapshotUnchanged(repoRoot, staleWorkSnapshot, {
-            operation: "`remix collab add` stale-work pre-sync",
-            recoveryHint: "The worktree changed while local changes were being preserved. Review the local changes and rerun `remix collab add`."
-          });
-          await discardTrackedChanges(repoRoot, "`remix collab add`");
-          await discardCapturedUntrackedChanges(repoRoot, preserved.includedUntrackedPaths);
-          await collabSync({
-            api: params.api,
-            cwd: repoRoot,
-            dryRun: false,
-            allowBranchMismatch: params.allowBranchMismatch
-          });
-        } catch (err) {
-          const detail = formatCliErrorDetail(err);
-          const hint = [
-            detail,
-            `The preserved local diff is available at: ${preserved.preservedDiffPath}`
-          ].filter(Boolean).join("\n\n");
-          throw new RemixError("Failed to sync the stale repository before submitting the change step.", {
-            exitCode: err instanceof RemixError ? err.exitCode : 1,
-            hint
-          });
-        }
-        headCommitHash = await getHeadCommitHash(repoRoot);
-        if (!headCommitHash) {
-          throw new RemixError("Failed to resolve local HEAD after syncing.", { exitCode: 1 });
-        }
-        const deterministicReapply = await reapplyPreservedWorkspaceChanges(repoRoot, preserved);
-        if (deterministicReapply.status === "failed") {
-          const hint = [
-            deterministicReapply.detail,
-            `The preserved local diff is available at: ${preserved.preservedDiffPath}`
-          ].filter(Boolean).join("\n\n");
-          throw new RemixError("Failed to restore preserved local changes after syncing.", {
-            exitCode: 1,
-            hint
-          });
-        }
-        if (deterministicReapply.status === "conflict") {
-          try {
-            const replayResp = await params.api.startChangeStepReplay(binding.currentAppId, {
-              prompt,
-              assistantResponse: assistantResponse ?? void 0,
-              diff: await import_promises15.default.readFile(preserved.preservedDiffPath, "utf8"),
-              baseCommitHash: preserved.baseHeadCommitHash,
-              targetHeadCommitHash: headCommitHash,
-              expectedPaths: preserved.stagePlan.expectedPaths,
-              actor: params.actor,
-              workspaceMetadata: {
-                branch,
-                repoRoot,
-                remoteUrl: binding.remoteUrl,
-                defaultBranch: binding.defaultBranch
-              },
-              idempotencyKey: buildDeterministicIdempotencyKey({
-                appId: binding.currentAppId,
-                baseCommitHash: preserved.baseHeadCommitHash,
-                targetHeadCommitHash: headCommitHash,
-                prompt,
-                assistantResponse,
-                preservedDiffSha256: preserved.preservedDiffSha256
-              })
-            });
-            const startedReplay = unwrapResponseObject(replayResp, "change step replay");
-            const replay = await pollChangeStepReplay(params.api, binding.currentAppId, String(startedReplay.id));
-            const replayDiffResp = await params.api.getChangeStepReplayDiff(binding.currentAppId, String(replay.id));
-            const replayDiff = unwrapResponseObject(replayDiffResp, "change step replay diff");
-            const { backupPath: backupPath2, diffSha256 } = await writeTempUnifiedDiffBackup(replayDiff.diff, "remix-add-ai-replay");
-            const replayApply = await reapplyPreservedWorkspaceChanges(repoRoot, {
-              baseHeadCommitHash: headCommitHash,
-              preservedDiffPath: backupPath2,
-              preservedDiffSha256: diffSha256,
-              includedUntrackedPaths: [],
-              stagePlan: preserved.stagePlan
-            });
-            if (replayApply.status !== "clean") {
-              const hint = [
-                replayApply.detail,
-                `The preserved local diff is available at: ${preserved.preservedDiffPath}`,
-                `The AI-replayed diff is available at: ${backupPath2}`
-              ].filter(Boolean).join("\n\n");
-              throw new RemixError("AI-assisted stale-work replay produced a diff that could not be applied locally.", {
-                exitCode: 1,
-                hint
-              });
-            }
-          } catch (err) {
-            const detail = formatCliErrorDetail(err);
-            const hint = [
-              detail,
-              `The preserved local diff is available at: ${preserved.preservedDiffPath}`,
-              "Resolve the local conflict manually if needed, then rerun `remix collab add`."
-            ].filter(Boolean).join("\n\n");
-            throw new RemixError("AI-assisted stale-work replay could not complete safely.", {
-              exitCode: err instanceof RemixError ? err.exitCode : 1,
-              hint
-            });
-          }
-        }
-      }
-    }
-    const workspaceSnapshot = diffSource === "external" ? null : await getWorkspaceSnapshot(repoRoot);
-    const submissionSnapshot = diffSource === "worktree" ? await captureRepoSnapshot(repoRoot, { includeWorkspaceDiffHash: true }) : null;
-    const diff = params.diff ?? workspaceSnapshot?.diff ?? "";
-    if (!diff.trim()) {
-      throw new RemixError("Diff is empty.", {
-        exitCode: 2,
-        hint: "Make changes first, or pass `--diff-file`/`--diff-stdin`."
-      });
-    }
-    if (diffSource === "external") {
-      const validation = await validateUnifiedDiff(repoRoot, diff);
-      if (!validation.ok) {
-        const actionHint = validation.kind === "malformed_patch" ? "The provided external diff is malformed. Recreate it with `git diff --binary --no-ext-diff`, avoid hand-editing patch hunks, and ensure the patch ends with a trailing newline." : validation.kind === "apply_conflict" ? "The external diff is valid patch syntax, but it does not apply cleanly to the current local HEAD. Sync or update the repo and regenerate the diff against the latest base." : "Git could not validate the provided external diff against the current repository state.";
-        const hint = [validation.detail, actionHint].filter(Boolean).join("\n\n");
-        throw new RemixError("External diff validation failed.", {
-          exitCode: validation.kind === "malformed_patch" ? 2 : 1,
-          hint
-        });
-      }
-    }
-    headCommitHash = await getHeadCommitHash(repoRoot);
-    if (!headCommitHash) {
-      throw new RemixError("Failed to resolve local HEAD before creating the change step.", { exitCode: 1 });
-    }
-    const stats = summarizeUnifiedDiff(diff);
-    const idempotencyKey = params.idempotencyKey?.trim() || buildDeterministicIdempotencyKey({
-      appId: binding.currentAppId,
-      upstreamAppId: binding.upstreamAppId,
-      headCommitHash,
-      prompt,
-      assistantResponse,
-      diff
-    });
-    const resp = await params.api.createChangeStep(binding.currentAppId, {
-      threadId: binding.threadId ?? void 0,
-      collabLaneId: binding.laneId ?? void 0,
-      prompt,
-      assistantResponse: assistantResponse ?? void 0,
-      diff,
-      baseCommitHash: headCommitHash,
-      headCommitHash,
-      changedFilesCount: stats.changedFilesCount,
-      insertions: stats.insertions,
-      deletions: stats.deletions,
-      actor: params.actor,
-      workspaceMetadata: {
-        branch,
-        repoRoot,
-        remoteUrl: binding.remoteUrl,
-        defaultBranch: binding.defaultBranch
-      },
-      idempotencyKey
-    });
-    const created = unwrapResponseObject(resp, "change step");
-    const step = await pollChangeStep(params.api, binding.currentAppId, String(created.id));
-    const canAutoSyncLocally = autoSyncEnabled && diffSource === "worktree";
-    if (!autoSyncEnabled || !canAutoSyncLocally) {
-      return attachWarnings(step, lockWarnings);
-    }
-    const { backupPath } = await writeTempUnifiedDiffBackup(diff, "remix-add");
-    try {
-      await pollAppReady(params.api, binding.currentAppId);
-      if (submissionSnapshot) {
-        await assertRepoSnapshotUnchanged(repoRoot, submissionSnapshot, {
-          operation: "`remix collab add` auto-sync",
-          recoveryHint: "The repository changed after the change step was submitted. Review the local changes, inspect the preserved diff if needed, and rerun `remix collab sync` manually."
-        });
-      }
-      await discardTrackedChanges(repoRoot, "`remix collab add`");
-      await discardCapturedUntrackedChanges(repoRoot, workspaceSnapshot?.includedUntrackedPaths ?? []);
-      await collabSync({
-        api: params.api,
-        cwd: repoRoot,
-        dryRun: false,
-        allowBranchMismatch: params.allowBranchMismatch
-      });
-      await import_promises15.default.rm(import_path4.default.dirname(backupPath), { recursive: true, force: true }).catch(() => void 0);
-    } catch (err) {
-      const detail = formatCliErrorDetail(err);
-      const hint = [
-        detail,
-        `The submitted diff backup was preserved at: ${backupPath}`,
-        "The change step already succeeded remotely. Inspect or reapply that diff manually if needed, then run `remix collab sync`."
-      ].filter(Boolean).join("\n\n");
-      throw new RemixError("Change step succeeded remotely, but automatic local sync failed.", {
-        exitCode: err instanceof RemixError ? err.exitCode : 1,
-        hint
-      });
-    }
-    return attachWarnings(step, lockWarnings);
-  };
-  if (diffSource === "worktree") {
-    return withRepoMutationLock(
-      {
-        cwd: repoRoot,
-        operation: "collabAdd"
-      },
-      async ({ warnings }) => run(warnings)
-    );
-  }
-  return run();
-}
-function assertSupportedRecordingPreflight2(preflight) {
-  if (preflight.status === "not_bound") {
-    throw new RemixError("Repository is not bound to Remix.", {
+  if (!assistantResponse) throw new RemixError("Assistant response is required.", { exitCode: 2 });
+  if (params.diff?.trim()) {
+    throw new RemixError("External diff submission is no longer supported for `finalize_turn`.", {
       exitCode: 2,
-      hint: preflight.hint
+      hint: "Finalize turns now capture the real workspace boundary from the local snapshot store."
     });
   }
-  if (preflight.status === "branch_binding_missing") {
-    throw new RemixError("Current branch is not yet bound to a Remix lane.", {
-      exitCode: 2,
-      hint: preflight.hint
-    });
+  const detected = await collabDetectRepoState({
+    api: params.api,
+    cwd: repoRoot,
+    allowBranchMismatch: params.allowBranchMismatch
+  });
+  if (detected.status === "not_bound") {
+    throw new RemixError("Repository is not bound to Remix.", { exitCode: 2, hint: detected.hint });
   }
-  if (preflight.status === "family_ambiguous") {
-    throw new RemixError("Multiple canonical Remix families match this repository.", {
-      exitCode: 2,
-      hint: preflight.hint
-    });
+  if (detected.status === "branch_binding_missing" || detected.status === "family_ambiguous") {
+    throw new RemixError(detected.hint || "Current branch is not ready for Remix recording.", { exitCode: 2, hint: detected.hint });
   }
-  if (preflight.status === "not_git_repo") {
-    throw new RemixError(preflight.hint || "Not inside a git repository.", {
+  if (detected.status === "metadata_conflict" || detected.status === "branch_mismatch") {
+    throw new RemixError("Repository must be realigned before finalizing the turn.", {
       exitCode: 2,
-      hint: preflight.hint
+      hint: detected.hint
     });
   }
-  if (preflight.status === "missing_head") {
-    throw new RemixError("Failed to resolve local HEAD commit.", {
+  if (detected.status === "missing_head" || detected.status === "remote_error") {
+    throw new RemixError(detected.hint || "Failed to determine the current repo state.", {
       exitCode: 1,
-      hint: preflight.hint
-    });
-  }
-  if (preflight.status === "branch_mismatch") {
-    assertBoundBranchMatch({
-      currentBranch: preflight.currentBranch,
-      branchName: preflight.branchName,
-      allowBranchMismatch: false,
-      operation: "`remix collab record-turn`"
+      hint: detected.hint
     });
   }
-  if (preflight.status === "metadata_conflict") {
-    throw new RemixError("Local repository metadata conflicts with the bound Remix app.", {
+  if (detected.repoState === "server_only_changed") {
+    throw new RemixError("Server changes must be pulled locally before finalizing this turn.", {
       exitCode: 2,
-      hint: preflight.hint
+      hint: detected.hint
     });
   }
-  if (preflight.status === "reconcile_required") {
-    throw new RemixError("Local repository cannot be fast-forward synced.", {
+  if (detected.repoState === "external_local_base_changed") {
+    throw new RemixError("The local checkout must be re-anchored before finalizing this turn.", {
       exitCode: 2,
-      hint: preflight.hint
+      hint: detected.hint
     });
   }
-}
-async function collabRecordTurn(params) {
-  const repoRoot = await findGitRoot(params.cwd);
-  const binding = await ensureActiveLaneBinding({
-    repoRoot,
-    api: params.api,
-    operation: "`remix collab record-turn`"
-  });
-  if (!binding) {
-    throw new RemixError("Repository is not bound to Remix.", {
-      exitCode: 2,
-      hint: "Run `remix collab init` first."
-    });
-  }
-  const prompt = params.prompt.trim();
-  const assistantResponse = params.assistantResponse.trim();
-  if (!prompt) throw new RemixError("Prompt is required.", { exitCode: 2 });
-  if (!assistantResponse) throw new RemixError("Assistant response is required.", { exitCode: 2 });
-  const preflight = await collabRecordingPreflight({
-    api: params.api,
-    cwd: repoRoot,
-    allowBranchMismatch: params.allowBranchMismatch
+  const baseline = await readLocalBaseline({
+    repoFingerprint: binding.repoFingerprint,
+    laneId: binding.laneId,
+    repoRoot
   });
-  assertSupportedRecordingPreflight2(preflight);
-  if (!preflight.worktreeClean) {
-    throw new RemixError("Cannot record a no-diff turn while the worktree has local changes.", {
+  if (!baseline) {
+    throw new RemixError("Local Remix baseline is missing for this lane.", {
       exitCode: 2,
-      hint: "Record the pending code changes as a Remix change step with `remix collab add`, or clean the worktree before retrying `remix collab record-turn`."
+      hint: "Run `remix collab re-anchor` to create a fresh baseline."
     });
   }
-  if (preflight.status === "ready_to_fast_forward") {
-    await collabSync({
-      api: params.api,
-      cwd: repoRoot,
-      dryRun: false,
-      allowBranchMismatch: params.allowBranchMismatch
-    });
-  }
-  const branch = await getCurrentBranch(repoRoot);
-  assertBoundBranchMatch({
-    currentBranch: branch,
-    branchName: binding.branchName,
-    allowBranchMismatch: params.allowBranchMismatch,
-    operation: "`remix collab record-turn`"
+  const snapshot = await captureLocalSnapshot({
+    repoRoot,
+    repoFingerprint: binding.repoFingerprint,
+    laneId: binding.laneId,
+    branchName: binding.branchName
   });
-  const headCommitHash = await getHeadCommitHash(repoRoot);
+  const mode = snapshot.snapshotHash === baseline.lastSnapshotHash ? "no_diff_turn" : "changed_turn";
   const idempotencyKey = params.idempotencyKey?.trim() || buildDeterministicIdempotencyKey({
+    kind: "collab_finalize_turn_boundary_v1",
     appId: binding.currentAppId,
-    upstreamAppId: binding.upstreamAppId,
-    headCommitHash,
+    laneId: binding.laneId,
+    baselineSnapshotId: baseline.lastSnapshotId,
+    baselineServerHeadHash: baseline.lastServerHeadHash,
+    currentSnapshotId: snapshot.id,
+    currentSnapshotHash: snapshot.snapshotHash,
+    repoState: detected.repoState,
     prompt,
     assistantResponse
   });
-  const resp = await params.api.createCollabTurn(binding.currentAppId, {
-    threadId: binding.threadId ?? void 0,
-    collabLaneId: binding.laneId ?? void 0,
+  const job = await enqueueCapturedFinalizeTurn({
+    repoRoot,
+    repoFingerprint: binding.repoFingerprint,
+    currentAppId: binding.currentAppId,
+    laneId: binding.laneId,
+    threadId: binding.threadId,
+    branchName: binding.branchName,
     prompt,
     assistantResponse,
-    actor: params.actor,
-    workspaceMetadata: {
-      branch,
-      repoRoot,
+    baselineSnapshotId: baseline.lastSnapshotId,
+    baselineServerHeadHash: baseline.lastServerHeadHash,
+    currentSnapshotId: snapshot.id,
+    idempotencyKey,
+    metadata: {
       remoteUrl: binding.remoteUrl,
       defaultBranch: binding.defaultBranch,
-      headCommitHash
-    },
-    idempotencyKey
+      actor: params.actor ?? null,
+      repoState: detected.repoState
+    }
   });
-  const turn = unwrapResponseObject(resp, "collab turn");
-  return turn;
+  return {
+    mode,
+    idempotencyKey,
+    queued: true,
+    jobId: job.id,
+    repoState: detected.repoState,
+    changeStep: null,
+    collabTurn: null,
+    autoSync: null,
+    warnings: [FINALIZE_QUEUED_WARNING, ...collectWarnings(detected.warnings)]
+  };
 }
 
-// node_modules/@remixhq/core/dist/chunk-BNKPTE2U.js
+// node_modules/@remixhq/core/dist/chunk-R7FVSCQW.js
 async function readJsonSafe(res) {
   const ct = res.headers.get("content-type") ?? "";
   if (!ct.toLowerCase().includes("application/json")) return null;
@@ -9460,7 +9236,7 @@ function createApiClient(config, opts) {
   const apiKey = (opts?.apiKey ?? "").trim();
   const tokenProvider = opts?.tokenProvider;
   const CLIENT_KEY_HEADER = "x-comerge-api-key";
-  async function request(path13, init) {
+  async function request(path12, init) {
     if (!tokenProvider) {
       throw new RemixError("API client is missing a token provider.", {
         exitCode: 1,
@@ -9468,7 +9244,7 @@ function createApiClient(config, opts) {
       });
     }
     const auth = await tokenProvider();
-    const url = new URL(path13, config.apiUrl).toString();
+    const url = new URL(path12, config.apiUrl).toString();
     const doFetch = async (bearer) => fetch(url, {
       ...init,
       headers: {
@@ -9492,7 +9268,7 @@ function createApiClient(config, opts) {
     const json = await readJsonSafe(res);
     return json ?? null;
   }
-  async function requestBinary(path13, init) {
+  async function requestBinary(path12, init) {
     if (!tokenProvider) {
       throw new RemixError("API client is missing a token provider.", {
         exitCode: 1,
@@ -9500,7 +9276,7 @@ function createApiClient(config, opts) {
       });
     }
     const auth = await tokenProvider();
-    const url = new URL(path13, config.apiUrl).toString();
+    const url = new URL(path12, config.apiUrl).toString();
     const doFetch = async (bearer) => fetch(url, {
       ...init,
       headers: {
@@ -9599,6 +9375,15 @@ function createApiClient(config, opts) {
       const suffix = qs.toString() ? `?${qs.toString()}` : "";
       return request(`/v1/apps/${encodeURIComponent(appId)}/edit-queue${suffix}`, { method: "GET" });
     },
+    listAppJobQueue: (appId, params) => {
+      const qs = new URLSearchParams();
+      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
+      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
+      for (const kind of params?.kind ?? []) qs.append("kind", kind);
+      for (const status of params?.status ?? []) qs.append("status", status);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/job-queue${suffix}`, { method: "GET" });
+    },
     getMergeRequest: (mrId) => request(`/v1/merge-requests/${encodeURIComponent(mrId)}`, { method: "GET" }),
     presignImportUpload: (payload) => request("/v1/apps/import/upload/presign", { method: "POST", body: JSON.stringify(payload) }),
     importFromUpload: (payload) => request("/v1/apps/import/upload", { method: "POST", body: JSON.stringify(payload) }),
@@ -9606,6 +9391,11 @@ function createApiClient(config, opts) {
     importFromUploadFirstParty: (payload) => request("/v1/apps/import/upload/first-party", { method: "POST", body: JSON.stringify(payload) }),
     importFromGithubFirstParty: (payload) => request("/v1/apps/import/github/first-party", { method: "POST", body: JSON.stringify(payload) }),
     forkApp: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/fork`, { method: "POST", body: JSON.stringify(payload ?? {}) }),
+    getAppHead: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/head`, { method: "GET" }),
+    getAppDelta: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/delta`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
     downloadAppBundle: (appId) => requestBinary(`/v1/apps/${encodeURIComponent(appId)}/download.bundle`, { method: "GET" }),
     createChangeStep: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps`, {
       method: "POST",
@@ -10318,8 +10108,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path13, errorMaps, issueData } = params;
-  const fullPath = [...path13, ...issueData.path || []];
+  const { data, path: path12, errorMaps, issueData } = params;
+  const fullPath = [...path12, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -10435,11 +10225,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path13, key) {
+  constructor(parent, value, path12, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path13;
+    this._path = path12;
     this._key = key;
   }
   get path() {
@@ -13882,8 +13672,8 @@ var coerce = {
 var NEVER = INVALID;
 
 // node_modules/@remixhq/core/dist/chunk-EVWDYCBL.js
-var import_promises18 = __toESM(require("fs/promises"), 1);
-var import_os4 = __toESM(require("os"), 1);
+var import_promises17 = __toESM(require("fs/promises"), 1);
+var import_os3 = __toESM(require("os"), 1);
 var import_path7 = __toESM(require("path"), 1);
 
 // node_modules/tslib/tslib.es6.mjs
@@ -22772,8 +22562,8 @@ var IcebergError = class extends Error {
     return this.status === 419;
   }
 };
-function buildUrl(baseUrl, path13, query) {
-  const url = new URL(path13, baseUrl);
+function buildUrl(baseUrl, path12, query) {
+  const url = new URL(path12, baseUrl);
   if (query) {
     for (const [key, value] of Object.entries(query)) {
       if (value !== void 0) {
@@ -22803,12 +22593,12 @@ function createFetchClient(options) {
   return {
     async request({
       method,
-      path: path13,
+      path: path12,
       query,
       body,
       headers
     }) {
-      const url = buildUrl(options.baseUrl, path13, query);
+      const url = buildUrl(options.baseUrl, path12, query);
       const authHeaders = await buildAuthHeaders(options.auth);
       const res = await fetchFn(url, {
         method,
@@ -23627,7 +23417,7 @@ var StorageFileApi = class extends BaseApiClient {
   * @param path The relative file path. Should be of the format `folder/subfolder/filename.png`. The bucket must already exist before attempting to upload.
   * @param fileBody The body of the file to be stored in the bucket.
   */
-  async uploadOrUpdate(method, path13, fileBody, fileOptions) {
+  async uploadOrUpdate(method, path12, fileBody, fileOptions) {
     var _this = this;
     return _this.handleOperation(async () => {
       let body;
@@ -23651,7 +23441,7 @@ var StorageFileApi = class extends BaseApiClient {
         if ((typeof ReadableStream !== "undefined" && body instanceof ReadableStream || body && typeof body === "object" && "pipe" in body && typeof body.pipe === "function") && !options.duplex) options.duplex = "half";
       }
       if (fileOptions === null || fileOptions === void 0 ? void 0 : fileOptions.headers) headers = _objectSpread22(_objectSpread22({}, headers), fileOptions.headers);
-      const cleanPath = _this._removeEmptyFolders(path13);
+      const cleanPath = _this._removeEmptyFolders(path12);
       const _path = _this._getFinalPath(cleanPath);
       const data = await (method == "PUT" ? put : post)(_this.fetch, `${_this.url}/object/${_path}`, body, _objectSpread22({ headers }, (options === null || options === void 0 ? void 0 : options.duplex) ? { duplex: options.duplex } : {}));
       return {
@@ -23712,8 +23502,8 @@ var StorageFileApi = class extends BaseApiClient {
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   * - For React Native, using either `Blob`, `File` or `FormData` does not work as intended. Upload file using `ArrayBuffer` from base64 file data instead, see example below.
   */
-  async upload(path13, fileBody, fileOptions) {
-    return this.uploadOrUpdate("POST", path13, fileBody, fileOptions);
+  async upload(path12, fileBody, fileOptions) {
+    return this.uploadOrUpdate("POST", path12, fileBody, fileOptions);
   }
   /**
   * Upload a file with a token generated from `createSignedUploadUrl`.
@@ -23752,9 +23542,9 @@ var StorageFileApi = class extends BaseApiClient {
   *   - `objects` table permissions: none
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   */
-  async uploadToSignedUrl(path13, token, fileBody, fileOptions) {
+  async uploadToSignedUrl(path12, token, fileBody, fileOptions) {
     var _this3 = this;
-    const cleanPath = _this3._removeEmptyFolders(path13);
+    const cleanPath = _this3._removeEmptyFolders(path12);
     const _path = _this3._getFinalPath(cleanPath);
     const url = new URL(_this3.url + `/object/upload/sign/${_path}`);
     url.searchParams.set("token", token);
@@ -23816,10 +23606,10 @@ var StorageFileApi = class extends BaseApiClient {
   *   - `objects` table permissions: `insert`
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   */
-  async createSignedUploadUrl(path13, options) {
+  async createSignedUploadUrl(path12, options) {
     var _this4 = this;
     return _this4.handleOperation(async () => {
-      let _path = _this4._getFinalPath(path13);
+      let _path = _this4._getFinalPath(path12);
       const headers = _objectSpread22({}, _this4.headers);
       if (options === null || options === void 0 ? void 0 : options.upsert) headers["x-upsert"] = "true";
       const data = await post(_this4.fetch, `${_this4.url}/object/upload/sign/${_path}`, {}, { headers });
@@ -23828,7 +23618,7 @@ var StorageFileApi = class extends BaseApiClient {
       if (!token) throw new StorageError("No token returned by API");
       return {
         signedUrl: url.toString(),
-        path: path13,
+        path: path12,
         token
       };
     });
@@ -23884,8 +23674,8 @@ var StorageFileApi = class extends BaseApiClient {
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   * - For React Native, using either `Blob`, `File` or `FormData` does not work as intended. Update file using `ArrayBuffer` from base64 file data instead, see example below.
   */
-  async update(path13, fileBody, fileOptions) {
-    return this.uploadOrUpdate("PUT", path13, fileBody, fileOptions);
+  async update(path12, fileBody, fileOptions) {
+    return this.uploadOrUpdate("PUT", path12, fileBody, fileOptions);
   }
   /**
   * Moves an existing file to a new path in the same bucket.
@@ -24032,10 +23822,10 @@ var StorageFileApi = class extends BaseApiClient {
   *   - `objects` table permissions: `select`
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   */
-  async createSignedUrl(path13, expiresIn, options) {
+  async createSignedUrl(path12, expiresIn, options) {
     var _this8 = this;
     return _this8.handleOperation(async () => {
-      let _path = _this8._getFinalPath(path13);
+      let _path = _this8._getFinalPath(path12);
       const hasTransform = typeof (options === null || options === void 0 ? void 0 : options.transform) === "object" && options.transform !== null && Object.keys(options.transform).length > 0;
       let data = await post(_this8.fetch, `${_this8.url}/object/sign/${_path}`, _objectSpread22({ expiresIn }, hasTransform ? { transform: options.transform } : {}), { headers: _this8.headers });
       const downloadQueryParam = (options === null || options === void 0 ? void 0 : options.download) ? `&download=${options.download === true ? "" : options.download}` : "";
@@ -24162,11 +23952,11 @@ var StorageFileApi = class extends BaseApiClient {
   *   - `objects` table permissions: `select`
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   */
-  download(path13, options, parameters) {
+  download(path12, options, parameters) {
     const renderPath = typeof (options === null || options === void 0 ? void 0 : options.transform) !== "undefined" ? "render/image/authenticated" : "object";
     const transformationQuery = this.transformOptsToQueryString((options === null || options === void 0 ? void 0 : options.transform) || {});
     const queryString = transformationQuery ? `?${transformationQuery}` : "";
-    const _path = this._getFinalPath(path13);
+    const _path = this._getFinalPath(path12);
     const downloadFn = () => get(this.fetch, `${this.url}/${renderPath}/${_path}${queryString}`, {
       headers: this.headers,
       noResolveJson: true
@@ -24196,9 +23986,9 @@ var StorageFileApi = class extends BaseApiClient {
   * }
   * ```
   */
-  async info(path13) {
+  async info(path12) {
     var _this10 = this;
-    const _path = _this10._getFinalPath(path13);
+    const _path = _this10._getFinalPath(path12);
     return _this10.handleOperation(async () => {
       return recursiveToCamel(await get(_this10.fetch, `${_this10.url}/object/info/${_path}`, { headers: _this10.headers }));
     });
@@ -24218,9 +24008,9 @@ var StorageFileApi = class extends BaseApiClient {
   *   .exists('folder/avatar1.png')
   * ```
   */
-  async exists(path13) {
+  async exists(path12) {
     var _this11 = this;
-    const _path = _this11._getFinalPath(path13);
+    const _path = _this11._getFinalPath(path12);
     try {
       await head(_this11.fetch, `${_this11.url}/object/${_path}`, { headers: _this11.headers });
       return {
@@ -24297,8 +24087,8 @@ var StorageFileApi = class extends BaseApiClient {
   *   - `objects` table permissions: none
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   */
-  getPublicUrl(path13, options) {
-    const _path = this._getFinalPath(path13);
+  getPublicUrl(path12, options) {
+    const _path = this._getFinalPath(path12);
     const _queryString = [];
     const downloadQueryParam = (options === null || options === void 0 ? void 0 : options.download) ? `download=${options.download === true ? "" : options.download}` : "";
     if (downloadQueryParam !== "") _queryString.push(downloadQueryParam);
@@ -24437,10 +24227,10 @@ var StorageFileApi = class extends BaseApiClient {
   *   - `objects` table permissions: `select`
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   */
-  async list(path13, options, parameters) {
+  async list(path12, options, parameters) {
     var _this13 = this;
     return _this13.handleOperation(async () => {
-      const body = _objectSpread22(_objectSpread22(_objectSpread22({}, DEFAULT_SEARCH_OPTIONS), options), {}, { prefix: path13 || "" });
+      const body = _objectSpread22(_objectSpread22(_objectSpread22({}, DEFAULT_SEARCH_OPTIONS), options), {}, { prefix: path12 || "" });
       return await post(_this13.fetch, `${_this13.url}/object/list/${_this13.bucketId}`, body, { headers: _this13.headers }, parameters);
     });
   }
@@ -24504,11 +24294,11 @@ var StorageFileApi = class extends BaseApiClient {
     if (typeof Buffer !== "undefined") return Buffer.from(data).toString("base64");
     return btoa(data);
   }
-  _getFinalPath(path13) {
-    return `${this.bucketId}/${path13.replace(/^\/+/, "")}`;
+  _getFinalPath(path12) {
+    return `${this.bucketId}/${path12.replace(/^\/+/, "")}`;
   }
-  _removeEmptyFolders(path13) {
-    return path13.replace(/^\/|\/$/g, "").replace(/\/+/g, "/");
+  _removeEmptyFolders(path12) {
+    return path12.replace(/^\/|\/$/g, "").replace(/\/+/g, "/");
   }
   transformOptsToQueryString(transform) {
     const params = [];
@@ -26222,7 +26012,7 @@ function decodeJWT(token) {
   };
   return data;
 }
-async function sleep3(time) {
+async function sleep2(time) {
   return await new Promise((accept) => {
     setTimeout(() => accept(null), time);
   });
@@ -31991,7 +31781,7 @@ var GoTrueClient = class _GoTrueClient {
       const startedAt = Date.now();
       return await retryable(async (attempt) => {
         if (attempt > 0) {
-          await sleep3(200 * Math.pow(2, attempt - 1));
+          await sleep2(200 * Math.pow(2, attempt - 1));
         }
         this._debug(debugName, "refreshing attempt", attempt);
         return await _request(this.fetch, "POST", `${this.url}/token?grant_type=refresh_token`, {
@@ -33543,7 +33333,7 @@ var storedSessionSchema = external_exports.object({
 function xdgConfigHome() {
   const value = process.env.XDG_CONFIG_HOME;
   if (typeof value === "string" && value.trim()) return value;
-  return import_path7.default.join(import_os4.default.homedir(), ".config");
+  return import_path7.default.join(import_os3.default.homedir(), ".config");
 }
 async function maybeLoadKeytar() {
   try {
@@ -33562,21 +33352,21 @@ async function maybeLoadKeytar() {
 }
 async function ensurePathPermissions(filePath) {
   const dir = import_path7.default.dirname(filePath);
-  await import_promises18.default.mkdir(dir, { recursive: true });
+  await import_promises17.default.mkdir(dir, { recursive: true });
   try {
-    await import_promises18.default.chmod(dir, 448);
+    await import_promises17.default.chmod(dir, 448);
   } catch {
   }
   try {
-    await import_promises18.default.chmod(filePath, 384);
+    await import_promises17.default.chmod(filePath, 384);
   } catch {
   }
 }
 async function writeJsonAtomic2(filePath, value) {
-  await import_promises18.default.mkdir(import_path7.default.dirname(filePath), { recursive: true });
+  await import_promises17.default.mkdir(import_path7.default.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  await import_promises18.default.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
-  await import_promises18.default.rename(tmpPath, filePath);
+  await import_promises17.default.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  await import_promises17.default.rename(tmpPath, filePath);
 }
 async function writeSessionFileFallback(filePath, session) {
   await writeJsonAtomic2(filePath, session);
@@ -33599,7 +33389,7 @@ function createLocalSessionStore(params) {
           return null;
         }
       }
-      const raw = await import_promises18.default.readFile(filePath, "utf8").catch(() => null);
+      const raw = await import_promises17.default.readFile(filePath, "utf8").catch(() => null);
       if (!raw) return null;
       try {
         const parsed = storedSessionSchema.safeParse(JSON.parse(raw));
@@ -33786,12 +33576,12 @@ async function createHookCollabApiClient() {
 
 // src/hook-diagnostics.ts
 var import_node_crypto2 = require("crypto");
-var import_promises20 = __toESM(require("fs/promises"), 1);
+var import_promises19 = __toESM(require("fs/promises"), 1);
 var import_node_os5 = __toESM(require("os"), 1);
 var import_node_path7 = __toESM(require("path"), 1);
 
 // src/hook-state.ts
-var import_promises19 = __toESM(require("fs/promises"), 1);
+var import_promises18 = __toESM(require("fs/promises"), 1);
 var import_node_os4 = __toESM(require("os"), 1);
 var import_node_path6 = __toESM(require("path"), 1);
 var import_node_crypto = require("crypto");
@@ -33809,20 +33599,20 @@ function stateLockMetaPath(sessionId) {
   return import_node_path6.default.join(stateLockPath(sessionId), "owner.json");
 }
 async function writeJsonAtomic3(filePath, value) {
-  await import_promises19.default.mkdir(import_node_path6.default.dirname(filePath), { recursive: true });
+  await import_promises18.default.mkdir(import_node_path6.default.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  await import_promises19.default.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
-  await import_promises19.default.rename(tmpPath, filePath);
+  await import_promises18.default.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  await import_promises18.default.rename(tmpPath, filePath);
 }
 var STATE_LOCK_WAIT_MS = 2e3;
 var STATE_LOCK_POLL_MS = 25;
 var STATE_LOCK_STALE_MS = 3e4;
 var STATE_LOCK_HEARTBEAT_MS = 5e3;
-async function sleep4(ms) {
+async function sleep3(ms) {
   await new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function readStateLockMetadata(sessionId) {
-  const raw = await import_promises19.default.readFile(stateLockMetaPath(sessionId), "utf8").catch(() => null);
+  const raw = await import_promises18.default.readFile(stateLockMetaPath(sessionId), "utf8").catch(() => null);
   if (!raw) return null;
   try {
     const parsed = JSON.parse(raw);
@@ -33847,13 +33637,13 @@ async function tryRemoveStaleStateLock(sessionId) {
   const metadata = await readStateLockMetadata(sessionId);
   const staleByHeartbeat = metadata && Date.now() - new Date(metadata.heartbeatAt).getTime() > STATE_LOCK_STALE_MS;
   if (staleByHeartbeat) {
-    await import_promises19.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+    await import_promises18.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
     return true;
   }
   if (!metadata) {
-    const lockStat = await import_promises19.default.stat(lockPath).catch(() => null);
+    const lockStat = await import_promises18.default.stat(lockPath).catch(() => null);
     if (lockStat && Date.now() - lockStat.mtimeMs > STATE_LOCK_STALE_MS) {
-      await import_promises19.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+      await import_promises18.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
       return true;
     }
   }
@@ -33862,10 +33652,10 @@ async function tryRemoveStaleStateLock(sessionId) {
 async function acquireStateLock(sessionId) {
   const lockPath = stateLockPath(sessionId);
   const deadline = Date.now() + STATE_LOCK_WAIT_MS;
-  await import_promises19.default.mkdir(stateRoot(), { recursive: true });
+  await import_promises18.default.mkdir(stateRoot(), { recursive: true });
   while (true) {
     try {
-      await import_promises19.default.mkdir(lockPath);
+      await import_promises18.default.mkdir(lockPath);
       const ownerId = (0, import_node_crypto.randomUUID)();
       const createdAt = (/* @__PURE__ */ new Date()).toISOString();
       const metadata = {
@@ -33890,7 +33680,7 @@ async function acquireStateLock(sessionId) {
         clearInterval(heartbeat);
         const currentMetadata = await readStateLockMetadata(sessionId);
         if (currentMetadata?.ownerId === ownerId) {
-          await import_promises19.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+          await import_promises18.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
         }
       };
     } catch (error) {
@@ -33904,7 +33694,7 @@ async function acquireStateLock(sessionId) {
       if (Date.now() >= deadline) {
         throw new Error(`Timed out acquiring hook state lock for session ${sessionId}.`);
       }
-      await sleep4(STATE_LOCK_POLL_MS);
+      await sleep3(STATE_LOCK_POLL_MS);
     }
   }
 }
@@ -33930,6 +33720,12 @@ function normalizeStringArray(value) {
     )
   );
 }
+function normalizeManualRecordingScope(value) {
+  if (value === "full_turn") {
+    return "full_turn";
+  }
+  return null;
+}
 function normalizeTouchedRepo(value, repoRoot) {
   if (!value || typeof value !== "object") return null;
   const parsed = value;
@@ -33948,7 +33744,7 @@ function normalizeTouchedRepo(value, repoRoot) {
     manuallyRecorded: Boolean(parsed.manuallyRecorded),
     manuallyRecordedAt: normalizeString(parsed.manuallyRecordedAt),
     manuallyRecordedByTool: normalizeString(parsed.manuallyRecordedByTool),
-    manualRecordingScope: parsed.manualRecordingScope === "change_step" || parsed.manualRecordingScope === "full_turn" ? parsed.manualRecordingScope : null,
+    manualRecordingScope: normalizeManualRecordingScope(parsed.manualRecordingScope),
     manualRemoteChangeRecordedAt: normalizeString(parsed.manualRemoteChangeRecordedAt),
     stopAttempted: Boolean(parsed.stopAttempted),
     stopRecorded: Boolean(parsed.stopRecorded),
@@ -34002,7 +33798,7 @@ async function updatePendingTurnState(sessionId, updater) {
   });
 }
 async function loadPendingTurnState(sessionId) {
-  const raw = await import_promises19.default.readFile(statePath(sessionId), "utf8").catch(() => null);
+  const raw = await import_promises18.default.readFile(statePath(sessionId), "utf8").catch(() => null);
   if (!raw) return null;
   try {
     const parsed = JSON.parse(raw);
@@ -34104,14 +33900,14 @@ async function listTouchedRepos(sessionId) {
 }
 async function clearPendingTurnState(sessionId) {
   await withStateLock(sessionId, async () => {
-    await import_promises19.default.rm(statePath(sessionId), { force: true }).catch(() => void 0);
+    await import_promises18.default.rm(statePath(sessionId), { force: true }).catch(() => void 0);
   });
 }
 
 // package.json
 var package_default = {
   name: "@remixhq/claude-plugin",
-  version: "0.1.17",
+  version: "0.1.18",
   description: "Claude Code plugin for Remix collaboration workflows",
   homepage: "https://github.com/RemixDotOne/remix-claude-plugin",
   license: "MIT",
@@ -34142,8 +33938,8 @@ var package_default = {
     prepack: "npm run build"
   },
   dependencies: {
-    "@remixhq/core": "^0.1.12",
-    "@remixhq/mcp": "^0.1.12"
+    "@remixhq/core": "^0.1.13",
+    "@remixhq/mcp": "^0.1.13"
   },
   devDependencies: {
     "@types/node": "^25.4.0",
@@ -34194,13 +33990,13 @@ function normalizeFields(fields) {
   return Object.fromEntries(normalizedEntries);
 }
 async function rotateLogIfNeeded(logPath) {
-  const stat = await import_promises20.default.stat(logPath).catch(() => null);
+  const stat = await import_promises19.default.stat(logPath).catch(() => null);
   if (!stat || stat.size < MAX_LOG_BYTES) {
     return;
   }
   const rotatedPath = `${logPath}.1`;
-  await import_promises20.default.rm(rotatedPath, { force: true }).catch(() => void 0);
-  await import_promises20.default.rename(logPath, rotatedPath).catch(() => void 0);
+  await import_promises19.default.rm(rotatedPath, { force: true }).catch(() => void 0);
+  await import_promises19.default.rename(logPath, rotatedPath).catch(() => void 0);
 }
 function summarizeText(value) {
   if (typeof value !== "string" || !value.trim()) {
@@ -34220,7 +34016,7 @@ function summarizeText(value) {
 async function appendHookDiagnosticsEvent(params) {
   try {
     const logPath = getHookDiagnosticsLogPath();
-    await import_promises20.default.mkdir(import_node_path7.default.dirname(logPath), { recursive: true });
+    await import_promises19.default.mkdir(import_node_path7.default.dirname(logPath), { recursive: true });
     await rotateLogIfNeeded(logPath);
     const event = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -34237,14 +34033,14 @@ async function appendHookDiagnosticsEvent(params) {
       message: params.message?.trim() || null,
       fields: normalizeFields(params.fields)
     };
-    await import_promises20.default.appendFile(logPath, `${JSON.stringify(event)}
+    await import_promises19.default.appendFile(logPath, `${JSON.stringify(event)}
 `, "utf8");
   } catch {
   }
 }
 
 // src/hook-utils.ts
-var import_promises21 = __toESM(require("fs/promises"), 1);
+var import_promises20 = __toESM(require("fs/promises"), 1);
 var import_node_path8 = __toESM(require("path"), 1);
 async function readJsonStdin() {
   const chunks = [];
@@ -34308,13 +34104,13 @@ function extractBoolean(input, keys) {
 async function findBoundRepo(startPath) {
   if (!startPath) return null;
   let current = import_node_path8.default.resolve(startPath);
-  let stats = await import_promises21.default.stat(current).catch(() => null);
+  let stats = await import_promises20.default.stat(current).catch(() => null);
   if (stats?.isFile()) {
     current = import_node_path8.default.dirname(current);
   }
   while (true) {
     const bindingPath = import_node_path8.default.join(current, ".remix", "config.json");
-    const bindingStats = await import_promises21.default.stat(bindingPath).catch(() => null);
+    const bindingStats = await import_promises20.default.stat(bindingPath).catch(() => null);
     if (bindingStats?.isFile()) return current;
     const parent = import_node_path8.default.dirname(current);
     if (parent === current) return null;
@@ -34341,6 +34137,7 @@ var HOOK_ACTOR = {
   version: pluginMetadata.version,
   provider: "anthropic"
 };
+var collabFinalizeTurn2 = collabFinalizeTurn;
 function getErrorDetails(error) {
   if (error instanceof Error) {
     const hint = typeof error.hint === "string" ? String(error.hint) : null;
@@ -34352,58 +34149,13 @@ function getErrorDetails(error) {
   const message = typeof error === "string" && error.trim() ? error.trim() : "Fallback Remix turn recording failed.";
   return { message, hint: null };
 }
-function getRecordingBlockedMessage(status, repoRoot) {
-  if (status.status === "branch_binding_missing") {
-    return {
-      message: "Fallback Remix turn recording was blocked because the current branch does not have a Remix lane binding yet.",
-      hint: status.hint || `Run \`remix_collab_status\` for ${repoRoot}, then initialize or provision the current branch lane before recording work.`
-    };
-  }
-  if (status.status === "family_ambiguous") {
-    return {
-      message: "Fallback Remix turn recording was blocked because multiple canonical Remix families match this repository and the current checkout does not identify which family to use.",
-      hint: status.hint || `Continue from a checkout already bound to the intended family, or run \`remix_collab_init\` with forceNew=true for ${repoRoot} to create a new canonical family.`
-    };
-  }
-  switch (status.status) {
-    case "not_git_repo":
-      return {
-        message: "Fallback Remix turn recording failed because the repository is no longer inside a git repository.",
-        hint: status.hint || `Repo root: ${repoRoot}`
-      };
-    case "not_bound":
-      return {
-        message: "Fallback Remix turn recording failed because the repository is no longer bound to Remix.",
-        hint: status.hint || `Repo root: ${repoRoot}`
-      };
-    case "missing_head":
-      return {
-        message: "Fallback Remix turn recording failed because the repository HEAD could not be resolved.",
-        hint: status.hint || `Repo root: ${repoRoot}`
-      };
-    case "branch_mismatch":
-      return {
-        message: "Fallback Remix turn recording was blocked because the current checkout branch does not match the branch expected by the bound Remix lane.",
-        hint: status.hint || `Run \`remix_collab_status\` for ${repoRoot}, then switch back to the expected branch or refresh this branch's binding before recording or syncing.`
-      };
-    case "metadata_conflict":
-      return {
-        message: "Fallback Remix turn recording was blocked because local repository metadata conflicts with the bound Remix app.",
-        hint: status.hint || `Repo root: ${repoRoot}`
-      };
-    case "reconcile_required":
-      return {
-        message: "Fallback Remix turn recording was blocked because the repository must be reconciled before recording can continue safely.",
-        hint: status.hint || `Repo root: ${repoRoot}`
-      };
-    default:
-      return null;
-  }
-}
 function buildRepoIdempotencyKey(turnId, repo) {
   const repoToken = repo.currentAppId?.trim() || repo.repoRoot;
   return `${turnId}:${repoToken}:finalize_turn`;
 }
+function isLegacyManualRecordingTool(toolName) {
+  return /remix_collab_(add|add_change_step|record_turn|record_no_diff_turn)$/i.test(toolName ?? "");
+}
 function shouldSkipStopRecording(repo) {
   if (repo.stopRecorded) {
     return true;
@@ -34411,7 +34163,8 @@ function shouldSkipStopRecording(repo) {
   if (!repo.manuallyRecorded) {
     return false;
   }
-  if (repo.manualRecordingScope !== "full_turn") {
+  const alreadyRecordedByCompatibleFlow = repo.manualRecordingScope === "full_turn" || isLegacyManualRecordingTool(repo.manuallyRecordedByTool);
+  if (!alreadyRecordedByCompatibleFlow) {
     return false;
   }
   if (!repo.manuallyRecordedAt) {
@@ -34422,12 +34175,6 @@ function shouldSkipStopRecording(repo) {
   }
   return new Date(repo.lastObservedWriteAt).getTime() <= new Date(repo.manuallyRecordedAt).getTime();
 }
-function hasNewObservedWriteSince(timestamp, repo) {
-  if (!repo.lastObservedWriteAt) {
-    return false;
-  }
-  return new Date(repo.lastObservedWriteAt).getTime() > new Date(timestamp).getTime();
-}
 function createFallbackTouchedRepo(params) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
@@ -34486,113 +34233,9 @@ async function recordTouchedRepo(params) {
         reason: "repo_not_bound",
         repoRoot: repo.repoRoot
       });
-      return false;
-    }
-    const workspaceDiff = await getWorkspaceDiff(repo.repoRoot);
-    if (workspaceDiff.diff.trim()) {
-      await appendHookDiagnosticsEvent({
-        hook,
-        sessionId,
-        turnId,
-        stage: "workspace_diff_checked",
-        result: "info",
-        repoRoot: repo.repoRoot,
-        fields: {
-          hasWorkspaceDiff: true,
-          diffLength: workspaceDiff.diff.length
-        }
-      });
-      if (repo.manualRemoteChangeRecordedAt && !hasNewObservedWriteSince(repo.manualRemoteChangeRecordedAt, repo)) {
-        await markTouchedRepoStopRecorded(sessionId, repo.repoRoot, { mode: "changed_turn" });
-        await appendHookDiagnosticsEvent({
-          hook,
-          sessionId,
-          turnId,
-          stage: "recording_skipped",
-          result: "success",
-          reason: "manual_recording_already_covers_diff",
-          repoRoot: repo.repoRoot
-        });
-        return true;
-      }
-      const recordingPreflight2 = await collabRecordingPreflight({
-        api,
-        cwd: repo.repoRoot
-      });
-      const blocked2 = getRecordingBlockedMessage(recordingPreflight2, repo.repoRoot);
-      if (blocked2) {
-        await markTouchedRepoRecordingFailure(sessionId, repo.repoRoot, blocked2);
-        await appendHookDiagnosticsEvent({
-          hook,
-          sessionId,
-          turnId,
-          stage: "recording_preflight",
-          result: "error",
-          reason: recordingPreflight2.status,
-          repoRoot: repo.repoRoot,
-          message: blocked2.message,
-          fields: {
-            hint: blocked2.hint
-          }
-        });
-        return false;
-      }
-      await collabAdd({
-        api,
-        cwd: repo.repoRoot,
-        prompt,
-        assistantResponse,
-        diffSource: "worktree",
-        idempotencyKey: buildRepoIdempotencyKey(turnId, repo),
-        actor: HOOK_ACTOR
-      });
-      await markTouchedRepoStopRecorded(sessionId, repo.repoRoot, { mode: "changed_turn" });
-      await appendHookDiagnosticsEvent({
-        hook,
-        sessionId,
-        turnId,
-        stage: "recording_completed",
-        result: "success",
-        reason: "changed_turn_recorded",
-        repoRoot: repo.repoRoot
-      });
-      return true;
-    }
-    await appendHookDiagnosticsEvent({
-      hook,
-      sessionId,
-      turnId,
-      stage: "workspace_diff_checked",
-      result: "info",
-      repoRoot: repo.repoRoot,
-      fields: {
-        hasWorkspaceDiff: false,
-        diffLength: 0
-      }
-    });
-    const recordingPreflight = await collabRecordingPreflight({
-      api,
-      cwd: repo.repoRoot
-    });
-    const blocked = getRecordingBlockedMessage(recordingPreflight, repo.repoRoot);
-    if (blocked) {
-      await markTouchedRepoRecordingFailure(sessionId, repo.repoRoot, blocked);
-      await appendHookDiagnosticsEvent({
-        hook,
-        sessionId,
-        turnId,
-        stage: "recording_preflight",
-        result: "error",
-        reason: recordingPreflight.status,
-        repoRoot: repo.repoRoot,
-        message: blocked.message,
-        fields: {
-          hint: blocked.hint
-        }
-      });
-      return false;
+      return { recorded: false, queued: false };
     }
-    await collabRecordTurn({
+    const result = await collabFinalizeTurn2({
       api,
       cwd: repo.repoRoot,
       prompt,
@@ -34600,17 +34243,17 @@ async function recordTouchedRepo(params) {
       idempotencyKey: buildRepoIdempotencyKey(turnId, repo),
       actor: HOOK_ACTOR
     });
-    await markTouchedRepoStopRecorded(sessionId, repo.repoRoot, { mode: "no_diff_turn" });
+    await markTouchedRepoStopRecorded(sessionId, repo.repoRoot, { mode: result.mode });
     await appendHookDiagnosticsEvent({
       hook,
       sessionId,
       turnId,
       stage: "recording_completed",
       result: "success",
-      reason: "no_diff_turn_recorded",
+      reason: result.mode,
       repoRoot: repo.repoRoot
     });
-    return true;
+    return { recorded: true, queued: result.queued === true };
   } catch (error) {
     const details = getErrorDetails(error);
     await markTouchedRepoRecordingFailure(sessionId, repo.repoRoot, details);
@@ -34627,9 +34270,19 @@ async function recordTouchedRepo(params) {
         hint: details.hint
       }
     });
-    return false;
+    return { recorded: false, queued: false };
   }
 }
+function spawnFinalizeQueueDrainer() {
+  const entrypoint = process.argv[1];
+  if (!entrypoint) return;
+  const child = (0, import_node_child_process6.spawn)(process.execPath, [...process.execArgv, entrypoint, "--drain-finalize-queue"], {
+    detached: true,
+    stdio: "ignore",
+    env: process.env
+  });
+  child.unref();
+}
 async function runHookStopCollab(payload) {
   const hook = "Stop";
   if (extractBoolean(payload, ["stop_hook_active"])) {
@@ -34776,8 +34429,11 @@ async function runHookStopCollab(payload) {
       }
     });
     let hadFailure = false;
+    let queuedFinalizeWork = false;
     for (const repo of touchedRepos) {
       if (shouldSkipStopRecording(repo)) {
+        const backupDrainQueued = repo.manuallyRecordedByTool === "remix_collab_finalize_turn" && repo.manualRecordingScope === "full_turn";
+        queuedFinalizeWork = queuedFinalizeWork || backupDrainQueued;
         await appendHookDiagnosticsEvent({
           hook,
           sessionId,
@@ -34788,12 +34444,13 @@ async function runHookStopCollab(payload) {
           repoRoot: repo.repoRoot,
           fields: {
             manuallyRecorded: repo.manuallyRecorded,
-            stopRecorded: repo.stopRecorded
+            stopRecorded: repo.stopRecorded,
+            backupDrainQueued
           }
         });
         continue;
       }
-      const recorded = await recordTouchedRepo({
+      const recording = await recordTouchedRepo({
         hook,
         sessionId,
         turnId: state.turnId,
@@ -34802,10 +34459,14 @@ async function runHookStopCollab(payload) {
         assistantResponse,
         api
       });
-      if (!recorded) {
+      queuedFinalizeWork = queuedFinalizeWork || recording.queued;
+      if (!recording.recorded) {
         hadFailure = true;
       }
     }
+    if (queuedFinalizeWork) {
+      spawnFinalizeQueueDrainer();
+    }
     if (!hadFailure) {
       await clearPendingTurnState(sessionId);
       await appendHookDiagnosticsEvent({
@@ -34844,6 +34505,14 @@ async function runHookStopCollab(payload) {
   }
 }
 async function main() {
+  if (process.argv.includes("--drain-finalize-queue")) {
+    const api = await createHookCollabApiClient();
+    const drainPendingFinalizeQueue2 = drainPendingFinalizeQueue;
+    if (typeof drainPendingFinalizeQueue2 === "function") {
+      await drainPendingFinalizeQueue2({ api });
+    }
+    return;
+  }
   const payload = await readJsonStdin();
   await runHookStopCollab(payload);
 }