@remixhq/claude-plugin 0.1.22 → 0.1.24

package/dist/hook-user-prompt.cjs

@@ -38,7 +38,7 @@ var require_windows = __commonJS({
     module2.exports = isexe;
     isexe.sync = sync;
     var fs11 = require("fs");
-    function checkPathExt(path16, options) {
+    function checkPathExt(path17, 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 && path16.substr(-p.length).toLowerCase() === p) {
+        if (p && path17.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat, path16, options) {
+    function checkStat(stat, path17, options) {
       if (!stat.isSymbolicLink() && !stat.isFile()) {
         return false;
       }
-      return checkPathExt(path16, options);
+      return checkPathExt(path17, options);
     }
-    function isexe(path16, options, cb) {
-      fs11.stat(path16, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path16, options));
+    function isexe(path17, options, cb) {
+      fs11.stat(path17, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path17, options));
       });
     }
-    function sync(path16, options) {
-      return checkStat(fs11.statSync(path16), path16, options);
+    function sync(path17, options) {
+      return checkStat(fs11.statSync(path17), path17, options);
     }
   }
 });
@@ -79,13 +79,13 @@ var require_mode = __commonJS({
     module2.exports = isexe;
     isexe.sync = sync;
     var fs11 = require("fs");
-    function isexe(path16, options, cb) {
-      fs11.stat(path16, function(er, stat) {
+    function isexe(path17, options, cb) {
+      fs11.stat(path17, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
-    function sync(path16, options) {
-      return checkStat(fs11.statSync(path16), options);
+    function sync(path17, options) {
+      return checkStat(fs11.statSync(path17), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -119,7 +119,7 @@ var require_isexe = __commonJS({
     }
     module2.exports = isexe;
     isexe.sync = sync;
-    function isexe(path16, options, cb) {
+    function isexe(path17, 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(path16, options || {}, function(er, is) {
+          isexe(path17, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -138,7 +138,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path16, options || {}, function(er, is) {
+      core(path17, 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(path16, options) {
+    function sync(path17, options) {
       try {
-        return core.sync(path16, options || {});
+        return core.sync(path17, 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 path16 = require("path");
+    var path17 = 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 = path16.join(pathPart, cmd);
+        const pCmd = path17.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 = path16.join(pathPart, cmd);
+        const pCmd = path17.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 path16 = require("path");
+    var path17 = 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 ? path16.delimiter : void 0
+          pathExt: withoutPathExt ? path17.delimiter : void 0
         });
       } catch (e) {
       } finally {
@@ -307,7 +307,7 @@ var require_resolveCommand = __commonJS({
         }
       }
       if (resolved) {
-        resolved = path16.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+        resolved = path17.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
       }
       return resolved;
     }
@@ -361,8 +361,8 @@ var require_shebang_command = __commonJS({
       if (!match) {
         return null;
       }
-      const [path16, argument] = match[0].replace(/#! ?/, "").split(" ");
-      const binary = path16.split("/").pop();
+      const [path17, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path17.split("/").pop();
       if (binary === "env") {
         return argument;
       }
@@ -397,7 +397,7 @@ var require_readShebang = __commonJS({
 var require_parse = __commonJS({
   "node_modules/cross-spawn/lib/parse.js"(exports2, module2) {
     "use strict";
-    var path16 = require("path");
+    var path17 = 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 = path16.normalize(parsed.command);
+        parsed.command = path17.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 spawn4(command, args, options) {
+    function spawn5(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 = spawn4;
-    module2.exports.spawn = spawn4;
+    module2.exports = spawn5;
+    module2.exports.spawn = spawn5;
     module2.exports.sync = spawnSync2;
     module2.exports._parse = parse;
     module2.exports._enoent = enoent;
@@ -538,21 +538,27 @@ __export(hook_user_prompt_exports, {
   runHookUserPrompt: () => runHookUserPrompt
 });
 module.exports = __toCommonJS(hook_user_prompt_exports);
-var import_node_child_process7 = require("child_process");
-var import_node_fs6 = require("fs");
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_child_process8 = require("child_process");
+var import_node_fs7 = require("fs");
+var import_node_path13 = __toESM(require("path"), 1);
 
-// node_modules/@remixhq/core/dist/chunk-YZ34ICNN.js
+// node_modules/@remixhq/core/dist/chunk-7XJGOKEO.js
 var RemixError = class extends Error {
   code;
   exitCode;
   hint;
+  // HTTP status code when this error originates from an API response.
+  // null for non-HTTP errors (validation, local IO, programming bugs).
+  // Callers use this to distinguish transient (5xx) from permanent (4xx)
+  // API failures without resorting to error-message string matching.
+  statusCode;
   constructor(message, opts) {
     super(message);
     this.name = "RemixError";
     this.code = opts?.code ?? null;
     this.exitCode = opts?.exitCode ?? 1;
     this.hint = opts?.hint ?? null;
+    this.statusCode = opts?.statusCode ?? null;
   }
 };
 
@@ -4937,13 +4943,13 @@ var logOutputSync = ({ serializedResult, fdNumber, state, verboseInfo, encoding,
   }
 };
 var writeToFiles = (serializedResult, stdioItems, outputFiles) => {
-  for (const { path: path16, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
-    const pathString = typeof path16 === "string" ? path16 : path16.toString();
+  for (const { path: path17, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
+    const pathString = typeof path17 === "string" ? path17 : path17.toString();
     if (append || outputFiles.has(pathString)) {
-      (0, import_node_fs4.appendFileSync)(path16, serializedResult);
+      (0, import_node_fs4.appendFileSync)(path17, serializedResult);
     } else {
       outputFiles.add(pathString);
-      (0, import_node_fs4.writeFileSync)(path16, serializedResult);
+      (0, import_node_fs4.writeFileSync)(path17, serializedResult);
     }
   }
 };
@@ -7331,7 +7337,7 @@ var {
   getCancelSignal: getCancelSignal2
 } = getIpcExport();
 
-// node_modules/@remixhq/core/dist/chunk-WT6VRLXU.js
+// node_modules/@remixhq/core/dist/chunk-S4ECO35X.js
 async function runGit(args, cwd) {
   const res = await execa("git", args, { cwd, stderr: "ignore" });
   return String(res.stdout || "").trim();
@@ -7386,7 +7392,7 @@ function summarizeUnifiedDiff(diff) {
   return { changedFilesCount, insertions, deletions };
 }
 
-// node_modules/@remixhq/core/dist/chunk-YCFLOHJV.js
+// node_modules/@remixhq/core/dist/chunk-DBVN42RF.js
 var import_promises12 = __toESM(require("fs/promises"), 1);
 var import_path = __toESM(require("path"), 1);
 var import_promises13 = __toESM(require("fs/promises"), 1);
@@ -7770,6 +7776,7 @@ var import_promises14 = __toESM(require("fs/promises"), 1);
 var import_node_os4 = __toESM(require("os"), 1);
 var import_node_path6 = __toESM(require("path"), 1);
 var DEFERRED_TURN_SCHEMA_VERSION = 1;
+var DEFERRED_TURN_MAX_ATTEMPTS = 10;
 var DEFERRED_TURN_TTL_MS = 24 * 60 * 60 * 1e3;
 var DEFERRED_TURN_DIR = "deferred-turns";
 function stateRoot() {
@@ -7779,6 +7786,28 @@ function stateRoot() {
 function getDeferredTurnDirPath() {
   return import_node_path6.default.join(stateRoot(), DEFERRED_TURN_DIR);
 }
+function deferredTurnFileName(sessionId, turnId) {
+  const safe = (s) => s.replace(/[^A-Za-z0-9_-]/g, "_");
+  return `${safe(sessionId)}-${safe(turnId)}.json`;
+}
+function getDeferredTurnFilePath(sessionId, turnId) {
+  return import_node_path6.default.join(getDeferredTurnDirPath(), deferredTurnFileName(sessionId, turnId));
+}
+async function writeDeferredTurn(record) {
+  if (record.schemaVersion !== DEFERRED_TURN_SCHEMA_VERSION) {
+    throw new Error(`writeDeferredTurn: unsupported schemaVersion ${record.schemaVersion}`);
+  }
+  if (!record.prompt.trim() || !record.assistantResponse.trim()) {
+    throw new Error("writeDeferredTurn: prompt and assistantResponse must be non-empty");
+  }
+  const dir = getDeferredTurnDirPath();
+  await import_promises14.default.mkdir(dir, { recursive: true });
+  const filePath = getDeferredTurnFilePath(record.sessionId, record.turnId);
+  const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  await import_promises14.default.writeFile(tmpPath, JSON.stringify(record), "utf8");
+  await import_promises14.default.rename(tmpPath, filePath);
+  return filePath;
+}
 async function readDeferredTurnFile(filePath) {
   const raw = await import_promises14.default.readFile(filePath, "utf8").catch(() => null);
   if (!raw) return null;
@@ -7791,7 +7820,7 @@ async function readDeferredTurnFile(filePath) {
   if (!parsed || typeof parsed !== "object") return null;
   const record = parsed;
   if (record.schemaVersion !== DEFERRED_TURN_SCHEMA_VERSION) return null;
-  if (typeof record.sessionId !== "string" || typeof record.turnId !== "string" || typeof record.repoRoot !== "string" || typeof record.prompt !== "string" || typeof record.assistantResponse !== "string" || typeof record.submittedAt !== "string" || typeof record.deferredAt !== "string" || record.reason !== "current_branch_unbound" && record.reason !== "recovery_in_progress") {
+  if (typeof record.sessionId !== "string" || typeof record.turnId !== "string" || typeof record.repoRoot !== "string" || typeof record.prompt !== "string" || typeof record.assistantResponse !== "string" || typeof record.submittedAt !== "string" || typeof record.deferredAt !== "string" || record.reason !== "current_branch_unbound" && record.reason !== "recovery_in_progress" && record.reason !== "transient_recording_failure") {
     return null;
   }
   return {
@@ -7804,7 +7833,17 @@ async function readDeferredTurnFile(filePath) {
     submittedAt: record.submittedAt,
     deferredAt: record.deferredAt,
     reason: record.reason,
-    branchAtDefer: typeof record.branchAtDefer === "string" || record.branchAtDefer === null ? record.branchAtDefer : null
+    branchAtDefer: typeof record.branchAtDefer === "string" || record.branchAtDefer === null ? record.branchAtDefer : null,
+    // Additive fields: pre-appId-aware records on disk won't have these
+    // keys at all. Coerce missing/invalid to `null` (drainer treats
+    // null as "legacy, drain as today" — see drainer for the policy).
+    appIdAtDefer: typeof record.appIdAtDefer === "string" ? record.appIdAtDefer : null,
+    projectIdAtDefer: typeof record.projectIdAtDefer === "string" ? record.projectIdAtDefer : null,
+    // Pre-attemptCount records coerce to 0 — they've never been
+    // counted against the cap, so giving them the cap's full budget
+    // is correct (we'd rather over-retry a legacy record than drop it
+    // unexpectedly). Negative or non-finite values also coerce to 0.
+    attemptCount: typeof record.attemptCount === "number" && Number.isFinite(record.attemptCount) && record.attemptCount >= 0 ? Math.floor(record.attemptCount) : 0
   };
 }
 async function listDeferredTurnsForRepo(repoRoot) {
@@ -7856,10 +7895,24 @@ async function pruneStaleDeferredTurns(maxAgeMs = DEFERRED_TURN_TTL_MS) {
   }
   return pruned;
 }
+async function recordDeferredTurnFailedAttempt(filePath) {
+  const current = await readDeferredTurnFile(filePath);
+  if (!current) {
+    return { promoted: true, finalAttemptCount: DEFERRED_TURN_MAX_ATTEMPTS };
+  }
+  const newAttemptCount = current.attemptCount + 1;
+  if (newAttemptCount >= DEFERRED_TURN_MAX_ATTEMPTS) {
+    await deleteDeferredTurnFile(filePath);
+    return { promoted: true, finalAttemptCount: newAttemptCount };
+  }
+  const next = { ...current, attemptCount: newAttemptCount };
+  await writeDeferredTurn(next);
+  return { promoted: false, newAttemptCount };
+}
 
 // src/deferred-turn-drainer.ts
-var import_promises22 = __toESM(require("fs/promises"), 1);
-var import_node_path9 = __toESM(require("path"), 1);
+var import_promises23 = __toESM(require("fs/promises"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 var import_node_crypto3 = require("crypto");
 
 // node_modules/@remixhq/core/dist/collab.js
@@ -7885,6 +7938,8 @@ function buildAppDeltaCacheKey(appId, payload) {
     appId,
     payload.baseHeadHash,
     payload.targetHeadHash ?? "",
+    payload.baseRevisionId ?? "",
+    payload.targetRevisionId ?? "",
     payload.localSnapshotHash ?? "",
     payload.repoFingerprint ?? "",
     payload.remoteUrl ?? "",
@@ -8131,11 +8186,11 @@ async function readLocalBaseline(params) {
     const raw = await import_promises16.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") {
+    if (![1, 2].includes(Number(parsed.schemaVersion)) || typeof parsed.key !== "string" || typeof parsed.repoRoot !== "string") {
       return null;
     }
     return {
-      schemaVersion: 1,
+      schemaVersion: Number(parsed.schemaVersion) === 2 ? 2 : 1,
       key: parsed.key,
       repoRoot: parsed.repoRoot,
       repoFingerprint: parsed.repoFingerprint ?? null,
@@ -8144,6 +8199,8 @@ async function readLocalBaseline(params) {
       branchName: parsed.branchName ?? null,
       lastSnapshotId: parsed.lastSnapshotId ?? null,
       lastSnapshotHash: parsed.lastSnapshotHash ?? null,
+      lastServerRevisionId: parsed.lastServerRevisionId ?? null,
+      lastServerTreeHash: parsed.lastServerTreeHash ?? null,
       lastServerHeadHash: parsed.lastServerHeadHash ?? null,
       lastSeenLocalCommitHash: parsed.lastSeenLocalCommitHash ?? null,
       updatedAt: String(parsed.updatedAt ?? "")
@@ -8155,7 +8212,7 @@ async function readLocalBaseline(params) {
 async function writeLocalBaseline(baseline) {
   const key = buildLaneStateKey(baseline);
   const normalized = {
-    schemaVersion: 1,
+    schemaVersion: 2,
     key,
     repoRoot: baseline.repoRoot,
     repoFingerprint: baseline.repoFingerprint ?? null,
@@ -8164,6 +8221,8 @@ async function writeLocalBaseline(baseline) {
     branchName: baseline.branchName ?? null,
     lastSnapshotId: baseline.lastSnapshotId ?? null,
     lastSnapshotHash: baseline.lastSnapshotHash ?? null,
+    lastServerRevisionId: baseline.lastServerRevisionId ?? null,
+    lastServerTreeHash: baseline.lastServerTreeHash ?? null,
     lastServerHeadHash: baseline.lastServerHeadHash ?? null,
     lastSeenLocalCommitHash: baseline.lastSeenLocalCommitHash ?? null,
     updatedAt: baseline.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
@@ -8468,6 +8527,7 @@ function normalizeJob2(input) {
     prompt: input.prompt,
     assistantResponse: input.assistantResponse,
     baselineSnapshotId: input.baselineSnapshotId ?? null,
+    baselineServerRevisionId: input.baselineServerRevisionId ?? null,
     baselineServerHeadHash: input.baselineServerHeadHash ?? null,
     currentSnapshotId: input.currentSnapshotId,
     capturedAt: input.capturedAt ?? now,
@@ -8502,6 +8562,7 @@ async function readPendingFinalizeJob(jobId) {
       prompt: String(parsed.prompt ?? ""),
       assistantResponse: String(parsed.assistantResponse ?? ""),
       baselineSnapshotId: parsed.baselineSnapshotId ?? null,
+      baselineServerRevisionId: parsed.baselineServerRevisionId ?? null,
       baselineServerHeadHash: parsed.baselineServerHeadHash ?? null,
       currentSnapshotId: String(parsed.currentSnapshotId ?? ""),
       capturedAt: parsed.capturedAt,
@@ -8766,6 +8827,15 @@ function shouldRequireRemoteLaneForCurrentBranch(params) {
   if (params.currentBranch === defaultBranch) return false;
   return !params.binding.laneId || params.binding.currentAppId === params.binding.upstreamAppId;
 }
+function resolveLaneLookupProjectId(params) {
+  const currentBranch = normalizeBranchName2(params.currentBranch);
+  const defaultBranch = normalizeBranchName2(params.defaultBranch);
+  const localProjectId = params.localBinding.projectId ?? null;
+  if (currentBranch && currentBranch !== defaultBranch && localProjectId) {
+    return localProjectId;
+  }
+  return params.explicitRootProjectId ?? (params.requireRemoteLane ? void 0 : localProjectId ?? params.fallbackProjectId ?? void 0);
+}
 async function persistResolvedLane(repoRoot, binding) {
   await writeCollabBinding(repoRoot, {
     projectId: binding.projectId,
@@ -8844,7 +8914,14 @@ async function resolveActiveLaneBindingUncached(params, state) {
       };
     }
     const laneResp2 = await params.api.resolveProjectLaneBinding({
-      projectId: state.explicitRootBinding?.projectId ?? (requireRemoteLane ? void 0 : localBinding.projectId ?? state.projectId ?? void 0),
+      projectId: resolveLaneLookupProjectId({
+        explicitRootProjectId: state.explicitRootBinding?.projectId,
+        localBinding,
+        currentBranch,
+        defaultBranch: state.defaultBranch,
+        requireRemoteLane,
+        fallbackProjectId: state.projectId
+      }),
       repoFingerprint: state.repoFingerprint ?? void 0,
       remoteUrl: state.remoteUrl ?? void 0,
       defaultBranch: state.defaultBranch ?? void 0,
@@ -9003,6 +9080,8 @@ function buildBaseState() {
     branchName: null,
     localCommitHash: null,
     currentSnapshotHash: null,
+    currentServerRevisionId: null,
+    currentServerTreeHash: null,
     currentServerHeadHash: null,
     currentServerHeadCommitId: null,
     worktreeClean: false,
@@ -9036,6 +9115,8 @@ function buildBaseState() {
     baseline: {
       lastSnapshotId: null,
       lastSnapshotHash: null,
+      lastServerRevisionId: null,
+      lastServerTreeHash: null,
       lastServerHeadHash: null,
       lastSeenLocalCommitHash: null
     }
@@ -9162,6 +9243,8 @@ async function collabDetectRepoState(params) {
       summarizeAsyncJobs({ repoRoot, branchName: binding.branchName ?? null })
     ]);
     const appHead = unwrapResponseObject(headResp, "app head");
+    detected.currentServerRevisionId = appHead.headRevisionId ?? null;
+    detected.currentServerTreeHash = appHead.treeHash ?? null;
     detected.currentServerHeadHash = appHead.headCommitHash;
     detected.currentServerHeadCommitId = appHead.headCommitId;
     detected.currentSnapshotHash = inspection.snapshotHash;
@@ -9170,6 +9253,8 @@ async function collabDetectRepoState(params) {
     detected.baseline = {
       lastSnapshotId: baseline?.lastSnapshotId ?? null,
       lastSnapshotHash: baseline?.lastSnapshotHash ?? null,
+      lastServerRevisionId: baseline?.lastServerRevisionId ?? null,
+      lastServerTreeHash: baseline?.lastServerTreeHash ?? null,
       lastServerHeadHash: baseline?.lastServerHeadHash ?? null,
       lastSeenLocalCommitHash: baseline?.lastSeenLocalCommitHash ?? null
     };
@@ -9179,6 +9264,7 @@ async function collabDetectRepoState(params) {
           const bootstrapResp = await params.api.getAppDelta(binding.currentAppId, {
             baseHeadHash: localCommitHash,
             targetHeadHash: appHead.headCommitHash,
+            targetRevisionId: appHead.headRevisionId,
             repoFingerprint: binding.repoFingerprint ?? void 0,
             remoteUrl: binding.remoteUrl ?? void 0,
             defaultBranch: binding.defaultBranch ?? void 0
@@ -9201,7 +9287,7 @@ async function collabDetectRepoState(params) {
         }
       }
       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.";
+      detected.hint = "No local Remix revision baseline exists for this lane yet. Run `remix collab init` or sync this lane to seed the baseline.";
       return detected;
     }
     const localHeadMovedSinceBaseline = Boolean(baseline.lastSeenLocalCommitHash) && localCommitHash !== baseline.lastSeenLocalCommitHash;
@@ -9220,7 +9306,30 @@ async function collabDetectRepoState(params) {
       return detected;
     }
     const localChanged = inspection.snapshotHash !== baseline.lastSnapshotHash;
-    const serverChanged = appHead.headCommitHash !== baseline.lastServerHeadHash;
+    const serverHeadChanged = appHead.headCommitHash !== baseline.lastServerHeadHash;
+    const revisionChanged = Boolean(
+      baseline.lastServerRevisionId && (appHead.headRevisionId ?? null) !== baseline.lastServerRevisionId
+    );
+    const equivalentRevisionDrift = revisionChanged && !serverHeadChanged;
+    if (equivalentRevisionDrift) {
+      await writeLocalBaseline({
+        repoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        laneId: binding.laneId,
+        currentAppId: binding.currentAppId,
+        branchName: binding.branchName,
+        lastSnapshotId: baseline.lastSnapshotId,
+        lastSnapshotHash: baseline.lastSnapshotHash,
+        lastServerRevisionId: appHead.headRevisionId ?? null,
+        lastServerTreeHash: appHead.treeHash ?? baseline.lastServerTreeHash ?? null,
+        lastServerHeadHash: appHead.headCommitHash,
+        lastSeenLocalCommitHash: baseline.lastSeenLocalCommitHash
+      });
+      detected.baseline.lastServerRevisionId = appHead.headRevisionId ?? null;
+      detected.baseline.lastServerTreeHash = appHead.treeHash ?? baseline.lastServerTreeHash ?? null;
+      detected.baseline.lastServerHeadHash = appHead.headCommitHash;
+    }
+    const serverChanged = serverHeadChanged;
     if (!localChanged && !serverChanged) {
       detected.repoState = "idle";
       return detected;
@@ -9644,6 +9753,7 @@ function buildWorkspaceMetadata(params) {
     recordingMode: "boundary_delta",
     baselineSnapshotId: params.baselineSnapshotId,
     currentSnapshotId: params.currentSnapshotId,
+    baselineServerRevisionId: params.baselineServerRevisionId ?? null,
     baselineServerHeadHash: params.baselineServerHeadHash,
     currentSnapshotHash: params.currentSnapshotHash,
     localCommitHash: params.localCommitHash,
@@ -9662,6 +9772,59 @@ function buildWorkspaceMetadata(params) {
   }
   return metadata;
 }
+async function findExistingChangeStepByIdempotency(params) {
+  const idempotencyKey = params.idempotencyKey?.trim();
+  if (!idempotencyKey) return null;
+  const resp = await params.api.listChangeSteps(params.appId, { limit: 1, idempotencyKey });
+  const responseObject = unwrapResponseObject(
+    resp,
+    "change step list"
+  );
+  const steps = Array.isArray(responseObject) ? responseObject : Array.isArray(responseObject.items) ? responseObject.items : [];
+  return steps.find((step) => step.idempotencyKey === idempotencyKey) ?? null;
+}
+async function writeBaselineFromSucceededChangeStep(params) {
+  const nextServerHeadHash = typeof params.changeStep.headCommitHash === "string" ? params.changeStep.headCommitHash.trim() : "";
+  if (!nextServerHeadHash) {
+    throw buildFinalizeCliError({
+      message: "Backend returned a succeeded change step without a head commit hash.",
+      exitCode: 1,
+      hint: "This is a backend invariant violation; retry will not help. Run `remix collab status` before trying again.",
+      disposition: "terminal",
+      reason: "missing_head_commit_hash"
+    });
+  }
+  let nextServerRevisionId = typeof params.changeStep.resultRevisionId === "string" ? params.changeStep.resultRevisionId.trim() : "";
+  let nextServerTreeHash = null;
+  if (!nextServerRevisionId) {
+    const freshHeadResp = await params.api.getAppHead(params.job.currentAppId);
+    const freshHead = unwrapResponseObject(freshHeadResp, "app head");
+    if (freshHead.headCommitHash !== nextServerHeadHash || !freshHead.headRevisionId) {
+      throw buildFinalizeCliError({
+        message: "Backend returned a succeeded change step without a matching result revision.",
+        exitCode: 1,
+        hint: "The local baseline was not advanced because the post-step revision could not be verified. Restart the backend/CLI and retry after checking `remix collab status`.",
+        disposition: "terminal",
+        reason: "missing_result_revision_id"
+      });
+    }
+    nextServerRevisionId = freshHead.headRevisionId;
+    nextServerTreeHash = freshHead.treeHash ?? null;
+  }
+  await writeLocalBaseline({
+    repoRoot: params.job.repoRoot,
+    repoFingerprint: params.job.repoFingerprint,
+    laneId: params.job.laneId,
+    currentAppId: params.job.currentAppId,
+    branchName: params.job.branchName,
+    lastSnapshotId: params.snapshot.id,
+    lastSnapshotHash: params.snapshot.snapshotHash,
+    lastServerRevisionId: nextServerRevisionId,
+    lastServerTreeHash: nextServerTreeHash,
+    lastServerHeadHash: nextServerHeadHash,
+    lastSeenLocalCommitHash: params.snapshot.localCommitHash
+  });
+}
 async function harvestPreTurnEvents(repoRoot, fromCommit, toCommit) {
   if (!toCommit) return null;
   try {
@@ -9722,12 +9885,12 @@ async function processClaimedPendingFinalizeJobInner(params) {
     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.",
+      hint: "Run `remix collab init` to seed this checkout's revision baseline.",
       disposition: "terminal",
       reason: "baseline_missing"
     });
   }
-  const baselineDrifted = baseline.lastSnapshotId !== job.baselineSnapshotId || baseline.lastServerHeadHash !== job.baselineServerHeadHash;
+  const baselineDrifted = baseline.lastSnapshotId !== job.baselineSnapshotId || (job.baselineServerRevisionId ? baseline.lastServerRevisionId !== job.baselineServerRevisionId : false) || baseline.lastServerHeadHash !== job.baselineServerHeadHash;
   const appHead = unwrapResponseObject(appHeadResp, "app head");
   const remoteUrl = readMetadataString(job, "remoteUrl");
   const defaultBranch = readMetadataString(job, "defaultBranch");
@@ -9750,12 +9913,13 @@ async function processClaimedPendingFinalizeJobInner(params) {
       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.",
+        hint: "Process queued finalize jobs in capture order, or run `remix collab init` to refresh the revision baseline before retrying.",
         disposition: "terminal",
         reason: "baseline_drifted"
       });
     }
-    if (appHead.headCommitHash !== job.baselineServerHeadHash) {
+    const serverStillAtBaseline = job.baselineServerRevisionId ? appHead.headRevisionId === job.baselineServerRevisionId : appHead.headCommitHash === job.baselineServerHeadHash;
+    if (!serverStillAtBaseline) {
       throw buildFinalizeCliError({
         message: "Server lane changed before a no-diff turn could be recorded.",
         exitCode: 2,
@@ -9777,6 +9941,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
         defaultBranch,
         baselineSnapshotId: job.baselineSnapshotId,
         currentSnapshotId: job.currentSnapshotId,
+        baselineServerRevisionId: job.baselineServerRevisionId,
         baselineServerHeadHash: job.baselineServerHeadHash,
         currentSnapshotHash: snapshot.snapshotHash,
         localCommitHash: snapshot.localCommitHash,
@@ -9797,6 +9962,8 @@ async function processClaimedPendingFinalizeJobInner(params) {
       branchName: job.branchName,
       lastSnapshotId: snapshot.id,
       lastSnapshotHash: snapshot.snapshotHash,
+      lastServerRevisionId: appHead.headRevisionId ?? null,
+      lastServerTreeHash: appHead.treeHash ?? null,
       lastServerHeadHash: appHead.headCommitHash,
       lastSeenLocalCommitHash: snapshot.localCommitHash
     });
@@ -9817,14 +9984,14 @@ async function processClaimedPendingFinalizeJobInner(params) {
     };
   }
   const localBaselineAdvanced = baseline.lastSnapshotId !== job.baselineSnapshotId;
-  const serverHeadAdvanced = appHead.headCommitHash !== job.baselineServerHeadHash;
+  const serverHeadAdvanced = job.baselineServerRevisionId ? appHead.headRevisionId !== job.baselineServerRevisionId : appHead.headCommitHash !== job.baselineServerHeadHash;
   if (baselineDrifted) {
     const consistentAdvance = localBaselineAdvanced && serverHeadAdvanced;
     if (!consistentAdvance) {
       throw buildFinalizeCliError({
         message: `Finalize queue baseline advanced inconsistently before this job was processed (localBaselineAdvanced=${localBaselineAdvanced}, serverHeadAdvanced=${serverHeadAdvanced}, jobBaselineSnapshotId=${job.baselineSnapshotId ?? "null"}, liveBaselineSnapshotId=${baseline.lastSnapshotId ?? "null"}, jobBaselineServerHeadHash=${job.baselineServerHeadHash ?? "null"}, liveBaselineServerHeadHash=${baseline.lastServerHeadHash ?? "null"}, currentAppHeadHash=${appHead.headCommitHash}). This indicates local Remix state diverged from the backend in a way that should not be reachable in normal operation; please report this as a bug.`,
         exitCode: 1,
-        hint: "Run `remix collab status` to inspect, then `remix collab re-anchor` only if the lane has no valid baseline.",
+        hint: "Run `remix collab status` to inspect, then sync or reconcile before retrying.",
         disposition: "terminal",
         reason: "baseline_drifted"
       });
@@ -9832,6 +9999,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
   }
   let submissionDiff = diffResult.diff;
   let submissionBaseHeadHash = job.baselineServerHeadHash;
+  let submissionBaseRevisionId = job.baselineServerRevisionId;
   let replayedFromBaseHash = null;
   if (!submissionBaseHeadHash) {
     throw buildFinalizeCliError({
@@ -9842,6 +10010,34 @@ async function processClaimedPendingFinalizeJobInner(params) {
     });
   }
   const replayNeeded = appHead.headCommitHash !== submissionBaseHeadHash || baselineDrifted;
+  if (replayNeeded) {
+    const existingChangeStep = await findExistingChangeStepByIdempotency({
+      api: params.api,
+      appId: job.currentAppId,
+      idempotencyKey: job.idempotencyKey
+    });
+    if (existingChangeStep) {
+      const changeStep2 = existingChangeStep.status === "succeeded" ? existingChangeStep : await pollChangeStep(params.api, job.currentAppId, existingChangeStep.id);
+      invalidateAppHeadCache(job.currentAppId);
+      invalidateAppDeltaCacheForApp(job.currentAppId);
+      await writeBaselineFromSucceededChangeStep({ api: params.api, job, snapshot, changeStep: changeStep2 });
+      await updatePendingFinalizeJob(job.id, {
+        status: "completed",
+        metadata: { changeStepId: String(changeStep2.id ?? "") }
+      });
+      return {
+        mode: "changed_turn",
+        idempotencyKey: job.idempotencyKey ?? "",
+        queued: false,
+        jobId: job.id,
+        repoState,
+        changeStep: changeStep2,
+        collabTurn: null,
+        autoSync: null,
+        warnings: []
+      };
+    }
+  }
   if (replayNeeded) {
     try {
       const replayResp = await params.api.startChangeStepReplay(job.currentAppId, {
@@ -9849,7 +10045,9 @@ async function processClaimedPendingFinalizeJobInner(params) {
         assistantResponse: job.assistantResponse,
         diff: diffResult.diff,
         baseCommitHash: submissionBaseHeadHash,
+        baseRevisionId: job.baselineServerRevisionId,
         targetHeadCommitHash: appHead.headCommitHash,
+        targetRevisionId: appHead.headRevisionId,
         expectedPaths: diffResult.changedPaths,
         actor,
         workspaceMetadata: buildWorkspaceMetadata({
@@ -9859,6 +10057,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
           defaultBranch,
           baselineSnapshotId: job.baselineSnapshotId,
           currentSnapshotId: job.currentSnapshotId,
+          baselineServerRevisionId: job.baselineServerRevisionId,
           baselineServerHeadHash: job.baselineServerHeadHash,
           currentSnapshotHash: snapshot.snapshotHash,
           localCommitHash: snapshot.localCommitHash,
@@ -9884,6 +10083,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
       submissionDiff = replayDiff.diff;
       replayedFromBaseHash = submissionBaseHeadHash;
       submissionBaseHeadHash = appHead.headCommitHash;
+      submissionBaseRevisionId = appHead.headRevisionId;
     } catch (error) {
       if (error instanceof RemixError && error.finalizeDisposition === void 0) {
         const detail = error.hint ? `${error.message} (${error.hint})` : error.message;
@@ -9905,6 +10105,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
     assistantResponse: job.assistantResponse,
     diff: submissionDiff,
     baseCommitHash: submissionBaseHeadHash,
+    baseRevisionId: submissionBaseRevisionId,
     headCommitHash: submissionBaseHeadHash,
     changedFilesCount: diffResult.stats.changedFilesCount,
     insertions: diffResult.stats.insertions,
@@ -9917,6 +10118,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
       defaultBranch,
       baselineSnapshotId: job.baselineSnapshotId,
       currentSnapshotId: job.currentSnapshotId,
+      baselineServerRevisionId: job.baselineServerRevisionId,
       baselineServerHeadHash: job.baselineServerHeadHash,
       currentSnapshotHash: snapshot.snapshotHash,
       localCommitHash: snapshot.localCommitHash,
@@ -9933,27 +10135,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
   const changeStep = await pollChangeStep(params.api, job.currentAppId, String(createdStep.id));
   invalidateAppHeadCache(job.currentAppId);
   invalidateAppDeltaCacheForApp(job.currentAppId);
-  const nextServerHeadHash = typeof changeStep.headCommitHash === "string" ? changeStep.headCommitHash.trim() : "";
-  if (!nextServerHeadHash) {
-    throw buildFinalizeCliError({
-      message: "Backend returned a succeeded change step without a head commit hash.",
-      exitCode: 1,
-      hint: "This is a backend invariant violation; retry will not help. Re-anchor and try again.",
-      disposition: "terminal",
-      reason: "missing_head_commit_hash"
-    });
-  }
-  await writeLocalBaseline({
-    repoRoot: job.repoRoot,
-    repoFingerprint: job.repoFingerprint,
-    laneId: job.laneId,
-    currentAppId: job.currentAppId,
-    branchName: job.branchName,
-    lastSnapshotId: snapshot.id,
-    lastSnapshotHash: snapshot.snapshotHash,
-    lastServerHeadHash: nextServerHeadHash,
-    lastSeenLocalCommitHash: snapshot.localCommitHash
-  });
+  await writeBaselineFromSucceededChangeStep({ api: params.api, job, snapshot, changeStep });
   await updatePendingFinalizeJob(job.id, {
     status: "completed",
     metadata: { changeStepId: String(changeStep.id ?? "") }
@@ -9982,6 +10164,7 @@ async function enqueueCapturedFinalizeTurn(params) {
     prompt: params.prompt,
     assistantResponse: params.assistantResponse,
     baselineSnapshotId: params.baselineSnapshotId,
+    baselineServerRevisionId: params.baselineServerRevisionId ?? null,
     baselineServerHeadHash: params.baselineServerHeadHash,
     currentSnapshotId: params.currentSnapshotId,
     idempotencyKey: params.idempotencyKey,
@@ -10080,17 +10263,6 @@ async function collabFinalizeTurn(params) {
       });
     }
   }
-  const pendingReAnchor = await findPendingAsyncJob({
-    repoRoot,
-    branchName: binding.branchName ?? null,
-    kind: "re_anchor"
-  });
-  if (pendingReAnchor) {
-    throw new RemixError("Cannot finalize a turn while a re-anchor is still processing.", {
-      exitCode: 2,
-      hint: `Re-anchor job ${pendingReAnchor.id} is still in the background queue. Run \`remix collab status\` to check progress.`
-    });
-  }
   const detected = await collabDetectRepoState({
     api: params.api,
     cwd: repoRoot,
@@ -10131,9 +10303,16 @@ async function collabFinalizeTurn(params) {
       hint: detected.hint
     });
   }
+  if (detected.repoState === "both_changed") {
+    throw new RemixError("Local and server changes must be reconciled before finalizing this turn.", {
+      code: "reconcile_required",
+      exitCode: 2,
+      hint: detected.hint || "Run `remix collab reconcile --dry-run` to inspect recovery options before retrying."
+    });
+  }
   if (detected.repoState === "external_local_base_changed") {
-    throw new RemixError("The local checkout must be re-anchored before finalizing this turn.", {
-      code: "re_anchor_required",
+    throw new RemixError("The local checkout is missing a Remix revision baseline for this lane.", {
+      code: "baseline_missing",
       exitCode: 2,
       hint: detected.hint
     });
@@ -10145,8 +10324,9 @@ async function collabFinalizeTurn(params) {
   });
   if (!baseline) {
     throw new RemixError("Local Remix baseline is missing for this lane.", {
+      code: "baseline_missing",
       exitCode: 2,
-      hint: "Run `remix collab re-anchor` to create a fresh baseline."
+      hint: "Run `remix collab init` or sync this lane to create a fresh revision baseline."
     });
   }
   const snapshot = await captureLocalSnapshot({
@@ -10157,10 +10337,11 @@ async function collabFinalizeTurn(params) {
   });
   const mode = snapshot.snapshotHash === baseline.lastSnapshotHash ? "no_diff_turn" : "changed_turn";
   const idempotencyKey = params.idempotencyKey?.trim() || buildDeterministicIdempotencyKey({
-    kind: "collab_finalize_turn_boundary_v1",
+    kind: "collab_finalize_turn_boundary_v2",
     appId: binding.currentAppId,
     laneId: binding.laneId,
     baselineSnapshotId: baseline.lastSnapshotId,
+    baselineServerRevisionId: baseline.lastServerRevisionId,
     baselineServerHeadHash: baseline.lastServerHeadHash,
     currentSnapshotId: snapshot.id,
     currentSnapshotHash: snapshot.snapshotHash,
@@ -10180,6 +10361,7 @@ async function collabFinalizeTurn(params) {
     prompt,
     assistantResponse,
     baselineSnapshotId: baseline.lastSnapshotId,
+    baselineServerRevisionId: baseline.lastServerRevisionId,
     baselineServerHeadHash: baseline.lastServerHeadHash,
     currentSnapshotId: snapshot.id,
     idempotencyKey,
@@ -10226,13 +10408,538 @@ var FINALIZE_PREFLIGHT_FAILURE_CODES = [
   // Server has commits we don't. Fix: `remix collab sync` (safe to
   // auto-run for fast-forward; non-FF refused by the command itself).
   "pull_required",
-  // Local base hash doesn't match the recorded baseline (force-push,
-  // hard reset, rebase). Fix: `remix collab re-anchor`.
-  "re_anchor_required"
+  // Both local and server changed. Fix: inspect and apply reconcile.
+  "reconcile_required",
+  // Local revision baseline is missing. Fix: `remix collab init` or sync.
+  "baseline_missing"
 ];
 var CODE_SET = new Set(FINALIZE_PREFLIGHT_FAILURE_CODES);
+function isFinalizePreflightFailureCode(value) {
+  return typeof value === "string" && CODE_SET.has(value);
+}
+
+// src/auto-fix-dispatcher.ts
+var import_node_child_process6 = require("child_process");
+var import_node_fs6 = require("fs");
+var import_node_path10 = __toESM(require("path"), 1);
+
+// src/finalize-failure-marker.ts
+var import_promises19 = __toESM(require("fs/promises"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
+var FINALIZE_FAILURE_MARKER_REL = import_node_path7.default.join(".remix", ".last-finalize-failure.json");
+function markerPath(repoRoot) {
+  return import_node_path7.default.join(repoRoot, FINALIZE_FAILURE_MARKER_REL);
+}
+async function readFinalizeFailureMarker(repoRoot) {
+  const raw = await import_promises19.default.readFile(markerPath(repoRoot), "utf8").catch(() => null);
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.schemaVersion !== 1) return null;
+    if (typeof parsed.repoRoot !== "string" || typeof parsed.failedAt !== "string") return null;
+    if (typeof parsed.message !== "string") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeFinalizeFailureMarker(marker) {
+  const filePath = markerPath(marker.repoRoot);
+  await import_promises19.default.mkdir(import_node_path7.default.dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  await import_promises19.default.writeFile(tmpPath, JSON.stringify(marker, null, 2), "utf8");
+  await import_promises19.default.rename(tmpPath, filePath);
+}
+function buildFreshFailureMarker(params) {
+  return {
+    schemaVersion: 1,
+    failedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    repoRoot: params.repoRoot,
+    preflightCode: params.preflightCode,
+    message: params.message,
+    hint: params.hint,
+    recommendedCommand: params.recommendedCommand,
+    autoFix: {
+      status: "not_attempted",
+      command: null,
+      pid: null,
+      logPath: null,
+      attemptedAt: null,
+      failureMessage: null
+    }
+  };
+}
+
+// src/hook-diagnostics.ts
+var import_node_crypto2 = require("crypto");
+var import_promises21 = __toESM(require("fs/promises"), 1);
+var import_node_os6 = __toESM(require("os"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
+
+// src/hook-state.ts
+var import_promises20 = __toESM(require("fs/promises"), 1);
+var import_node_os5 = __toESM(require("os"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
+var import_node_crypto = require("crypto");
+function stateRoot2() {
+  const configured = process.env.REMIX_CLAUDE_PLUGIN_HOOK_STATE_ROOT?.trim();
+  return configured || import_node_path8.default.join(import_node_os5.default.tmpdir(), "remix-claude-plugin-hooks");
+}
+function statePath(sessionId) {
+  return import_node_path8.default.join(stateRoot2(), `${sessionId}.json`);
+}
+function stateLockPath(sessionId) {
+  return import_node_path8.default.join(stateRoot2(), `${sessionId}.lock`);
+}
+function stateLockMetaPath(sessionId) {
+  return import_node_path8.default.join(stateLockPath(sessionId), "owner.json");
+}
+async function writeJsonAtomic2(filePath, value) {
+  await import_promises20.default.mkdir(import_node_path8.default.dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  await import_promises20.default.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  await import_promises20.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 sleep2(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function readStateLockMetadata(sessionId) {
+  const raw = await import_promises20.default.readFile(stateLockMetaPath(sessionId), "utf8").catch(() => null);
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.ownerId !== "string" || typeof parsed.pid !== "number" || typeof parsed.createdAt !== "string" || typeof parsed.heartbeatAt !== "string") {
+      return null;
+    }
+    return {
+      ownerId: parsed.ownerId,
+      pid: parsed.pid,
+      createdAt: parsed.createdAt,
+      heartbeatAt: parsed.heartbeatAt
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeStateLockMetadata(sessionId, metadata) {
+  await writeJsonAtomic2(stateLockMetaPath(sessionId), metadata);
+}
+async function tryRemoveStaleStateLock(sessionId) {
+  const lockPath = stateLockPath(sessionId);
+  const metadata = await readStateLockMetadata(sessionId);
+  const staleByHeartbeat = metadata && Date.now() - new Date(metadata.heartbeatAt).getTime() > STATE_LOCK_STALE_MS;
+  if (staleByHeartbeat) {
+    await import_promises20.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+    return true;
+  }
+  if (!metadata) {
+    const lockStat = await import_promises20.default.stat(lockPath).catch(() => null);
+    if (lockStat && Date.now() - lockStat.mtimeMs > STATE_LOCK_STALE_MS) {
+      await import_promises20.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+      return true;
+    }
+  }
+  return false;
+}
+async function acquireStateLock(sessionId) {
+  const lockPath = stateLockPath(sessionId);
+  const deadline = Date.now() + STATE_LOCK_WAIT_MS;
+  await import_promises20.default.mkdir(stateRoot2(), { recursive: true });
+  while (true) {
+    try {
+      await import_promises20.default.mkdir(lockPath);
+      const ownerId = (0, import_node_crypto.randomUUID)();
+      const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+      const metadata = {
+        ownerId,
+        pid: process.pid,
+        createdAt,
+        heartbeatAt: createdAt
+      };
+      await writeStateLockMetadata(sessionId, metadata);
+      let released = false;
+      const heartbeat = setInterval(() => {
+        if (released) return;
+        void writeStateLockMetadata(sessionId, {
+          ...metadata,
+          heartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
+        }).catch(() => void 0);
+      }, STATE_LOCK_HEARTBEAT_MS);
+      heartbeat.unref?.();
+      return async () => {
+        if (released) return;
+        released = true;
+        clearInterval(heartbeat);
+        const currentMetadata = await readStateLockMetadata(sessionId);
+        if (currentMetadata?.ownerId === ownerId) {
+          await import_promises20.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+        }
+      };
+    } catch (error) {
+      const code = error && typeof error === "object" && "code" in error ? error.code : null;
+      if (code !== "EEXIST") {
+        throw error;
+      }
+      if (await tryRemoveStaleStateLock(sessionId)) {
+        continue;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out acquiring hook state lock for session ${sessionId}.`);
+      }
+      await sleep2(STATE_LOCK_POLL_MS);
+    }
+  }
+}
+async function withStateLock(sessionId, fn) {
+  const release = await acquireStateLock(sessionId);
+  try {
+    return await fn();
+  } finally {
+    await release();
+  }
+}
+async function savePendingTurnState(state) {
+  await writeJsonAtomic2(statePath(state.sessionId), state);
+}
+async function createPendingTurnState(params) {
+  return withStateLock(params.sessionId, async () => {
+    const state = {
+      sessionId: params.sessionId,
+      turnId: (0, import_node_crypto.randomUUID)(),
+      prompt: params.prompt,
+      initialCwd: params.initialCwd?.trim() || null,
+      intent: params.intent,
+      submittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      consultedMemory: false,
+      touchedRepos: {},
+      turnFailureMessage: null,
+      turnFailureHint: null,
+      turnFailedAt: null
+    };
+    await savePendingTurnState(state);
+    return state;
+  });
+}
+
+// package.json
+var package_default = {
+  name: "@remixhq/claude-plugin",
+  version: "0.1.24",
+  description: "Claude Code plugin for Remix collaboration workflows",
+  homepage: "https://github.com/RemixDotOne/remix-claude-plugin",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/RemixDotOne/remix-claude-plugin.git"
+  },
+  type: "module",
+  engines: {
+    node: ">=20"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  files: [
+    "dist",
+    ".claude-plugin/plugin.json",
+    ".mcp.json",
+    "skills",
+    "hooks",
+    "agents"
+  ],
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    }
+  },
+  scripts: {
+    build: "tsup",
+    postbuild: `node -e "const fs=require('node:fs'); for (const p of ['dist/mcp-server.cjs','dist/hook-pre-git.cjs','dist/hook-user-prompt.cjs','dist/hook-post-collab.cjs','dist/hook-stop-collab.cjs']) fs.chmodSync(p, 0o755);"`,
+    dev: "tsx src/mcp-server.ts",
+    typecheck: "tsc -p tsconfig.json --noEmit",
+    test: "node --import tsx --test 'src/**/*.test.ts'",
+    prepack: "npm run build"
+  },
+  dependencies: {
+    "@remixhq/core": "^0.1.19",
+    "@remixhq/mcp": "^0.1.19"
+  },
+  devDependencies: {
+    "@types/node": "^25.4.0",
+    tsup: "^8.5.1",
+    tsx: "^4.21.0",
+    typescript: "^5.9.3"
+  }
+};
+
+// src/metadata.ts
+var pluginMetadata = {
+  name: package_default.name,
+  version: package_default.version,
+  description: package_default.description,
+  pluginId: "remix",
+  agentName: "remix-collab"
+};
+
+// src/hook-diagnostics.ts
+var MAX_LOG_BYTES = 512 * 1024;
+function resolveClaudeRoot() {
+  const configured = process.env.CLAUDE_CONFIG_DIR?.trim();
+  return configured || import_node_path9.default.join(import_node_os6.default.homedir(), ".claude");
+}
+function resolvePluginDataDirName() {
+  return `${pluginMetadata.pluginId}-${pluginMetadata.pluginId}`;
+}
+function getHookDiagnosticsDirPath() {
+  const configured = process.env.REMIX_CLAUDE_PLUGIN_HOOK_DIAGNOSTICS_DIR?.trim();
+  return configured || import_node_path9.default.join(resolveClaudeRoot(), "plugins", "data", resolvePluginDataDirName());
+}
+function getHookDiagnosticsLogPath() {
+  return import_node_path9.default.join(getHookDiagnosticsDirPath(), "hooks.ndjson");
+}
+function toFieldValue(value) {
+  if (value === null) return null;
+  if (typeof value === "string") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "boolean") return value;
+  return void 0;
+}
+function normalizeFields(fields) {
+  if (!fields) return {};
+  const normalizedEntries = Object.entries(fields).map(([key, value]) => {
+    const normalized = toFieldValue(value);
+    return normalized === void 0 ? null : [key, normalized];
+  }).filter((entry) => entry !== null);
+  return Object.fromEntries(normalizedEntries);
+}
+async function rotateLogIfNeeded(logPath) {
+  const stat = await import_promises21.default.stat(logPath).catch(() => null);
+  if (!stat || stat.size < MAX_LOG_BYTES) {
+    return;
+  }
+  const rotatedPath = `${logPath}.1`;
+  await import_promises21.default.rm(rotatedPath, { force: true }).catch(() => void 0);
+  await import_promises21.default.rename(logPath, rotatedPath).catch(() => void 0);
+}
+function summarizeText(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return {
+      present: false,
+      length: 0,
+      sha256Prefix: null
+    };
+  }
+  const trimmed = value.trim();
+  return {
+    present: true,
+    length: trimmed.length,
+    sha256Prefix: (0, import_node_crypto2.createHash)("sha256").update(trimmed).digest("hex").slice(0, 12)
+  };
+}
+async function appendHookDiagnosticsEvent(params) {
+  try {
+    const logPath = getHookDiagnosticsLogPath();
+    await import_promises21.default.mkdir(import_node_path9.default.dirname(logPath), { recursive: true });
+    await rotateLogIfNeeded(logPath);
+    const event = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      hook: params.hook,
+      pluginVersion: pluginMetadata.version,
+      pid: process.pid,
+      sessionId: params.sessionId?.trim() || null,
+      turnId: params.turnId?.trim() || null,
+      stage: params.stage.trim(),
+      result: params.result,
+      reason: params.reason?.trim() || null,
+      toolName: params.toolName?.trim() || null,
+      repoRoot: params.repoRoot?.trim() || null,
+      message: params.message?.trim() || null,
+      fields: normalizeFields(params.fields)
+    };
+    await import_promises21.default.appendFile(logPath, `${JSON.stringify(event)}
+`, "utf8");
+  } catch {
+  }
+}
+
+// src/auto-fix-dispatcher.ts
+var AUTO_FIX_COMMAND = {
+  // Already auto-spawned by hook-user-prompt's branch-init path, but we
+  // include it here too so a finalize-time failure (e.g. binding got
+  // deleted between init and the next finalize) also self-heals.
+  branch_binding_missing: ["collab", "init"],
+  // Local revision baseline is missing. Init seeds the branch/lane baseline
+  // without requiring the user to know about the recording internals.
+  baseline_missing: ["collab", "init"],
+  // Server moved ahead. `collab sync` is fast-forward-safe by default;
+  // it refuses non-FF on its own, so we don't need to gate here.
+  pull_required: ["collab", "sync"]
+};
+var RECOMMENDED_USER_COMMAND = {
+  not_bound: "remix collab init",
+  branch_binding_missing: "remix collab init",
+  family_ambiguous: "remix collab status",
+  metadata_conflict: "remix collab status",
+  branch_mismatch: "remix collab status",
+  missing_head: "remix collab status",
+  remote_error: "remix collab status",
+  pull_required: "remix collab sync",
+  baseline_missing: "remix collab init"
+};
+var SPAWN_LOCK_REL = (cmdSlug) => import_node_path10.default.join(".remix", `.${cmdSlug}-spawning`);
+var SPAWN_LOG_REL = (cmdSlug) => import_node_path10.default.join(".remix", `${cmdSlug}.log`);
+var SPAWN_THROTTLE_MS = 5 * 60 * 1e3;
+function commandSlug(args) {
+  return args.join("-").replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function spawnFixDetached(repoRoot, args) {
+  const slug = commandSlug(args);
+  const command = `remix ${args.join(" ")}`;
+  const remixDir = import_node_path10.default.join(repoRoot, ".remix");
+  const lockPath = import_node_path10.default.join(repoRoot, SPAWN_LOCK_REL(slug));
+  const logPath = import_node_path10.default.join(repoRoot, SPAWN_LOG_REL(slug));
+  try {
+    if ((0, import_node_fs6.existsSync)(lockPath)) {
+      const ageMs = Date.now() - (0, import_node_fs6.statSync)(lockPath).mtimeMs;
+      if (ageMs < SPAWN_THROTTLE_MS) {
+        return { kind: "spawn_throttled", command, reason: "spawn_lock_held" };
+      }
+    }
+  } catch {
+  }
+  try {
+    (0, import_node_fs6.mkdirSync)(remixDir, { recursive: true });
+  } catch {
+  }
+  let out;
+  let err;
+  try {
+    out = (0, import_node_fs6.openSync)(logPath, "a");
+    err = (0, import_node_fs6.openSync)(logPath, "a");
+  } catch (logErr) {
+    return {
+      kind: "spawn_failed",
+      command,
+      reason: "log_open_failed",
+      message: logErr instanceof Error ? logErr.message : String(logErr)
+    };
+  }
+  try {
+    const child = (0, import_node_child_process6.spawn)("remix", [...args], {
+      cwd: repoRoot,
+      detached: true,
+      stdio: ["ignore", out, err],
+      env: { ...process.env, REMIX_AUTO_FIX_SPAWN: "1" }
+    });
+    child.unref();
+    try {
+      (0, import_node_fs6.writeFileSync)(lockPath, String(child.pid ?? ""), "utf8");
+      (0, import_node_fs6.utimesSync)(lockPath, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+    } catch {
+    }
+    return { kind: "spawned", command, pid: child.pid, logPath };
+  } catch (spawnErr) {
+    return {
+      kind: "spawn_failed",
+      command,
+      reason: "spawn_failed",
+      message: spawnErr instanceof Error ? spawnErr.message : String(spawnErr)
+    };
+  }
+}
+async function dispatchFinalizeFailure(input) {
+  const recommendedCommand = input.preflightCode ? RECOMMENDED_USER_COMMAND[input.preflightCode] ?? null : null;
+  const marker = buildFreshFailureMarker({
+    repoRoot: input.repoRoot,
+    preflightCode: input.preflightCode,
+    message: input.message,
+    hint: input.hint,
+    recommendedCommand
+  });
+  let outcome;
+  const autoFixArgs = input.preflightCode ? AUTO_FIX_COMMAND[input.preflightCode] : void 0;
+  if (!autoFixArgs) {
+    outcome = {
+      kind: "warn_only",
+      reason: input.preflightCode ? "no_auto_fix_for_code" : "unknown_code"
+    };
+  } else {
+    outcome = spawnFixDetached(input.repoRoot, autoFixArgs);
+    marker.autoFix = mergeOutcomeIntoMarker(marker.autoFix, outcome);
+  }
+  try {
+    await writeFinalizeFailureMarker(marker);
+  } catch (writeErr) {
+    await appendHookDiagnosticsEvent({
+      hook: input.hook,
+      sessionId: input.sessionId,
+      turnId: input.turnId ?? void 0,
+      stage: "finalize_failure_marker_write_failed",
+      result: "error",
+      reason: "exception",
+      repoRoot: input.repoRoot,
+      message: writeErr instanceof Error ? writeErr.message : String(writeErr)
+    });
+  }
+  await appendHookDiagnosticsEvent({
+    hook: input.hook,
+    sessionId: input.sessionId,
+    turnId: input.turnId ?? void 0,
+    stage: "auto_fix_dispatched",
+    result: outcome.kind === "spawned" ? "success" : outcome.kind === "warn_only" ? "info" : "error",
+    reason: outcome.kind,
+    repoRoot: input.repoRoot,
+    fields: {
+      preflightCode: input.preflightCode,
+      command: "command" in outcome ? outcome.command : null,
+      pid: outcome.kind === "spawned" ? outcome.pid ?? null : null,
+      logPath: outcome.kind === "spawned" ? outcome.logPath : null,
+      recommendedCommand
+    },
+    message: outcome.kind === "spawn_failed" ? outcome.message : null
+  });
+  return outcome;
+}
+function mergeOutcomeIntoMarker(existing, outcome) {
+  if (outcome.kind === "spawned") {
+    return {
+      status: "in_progress",
+      command: outcome.command,
+      pid: outcome.pid ?? null,
+      logPath: outcome.logPath,
+      attemptedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      failureMessage: null
+    };
+  }
+  if (outcome.kind === "spawn_throttled") {
+    return {
+      status: "in_progress",
+      command: outcome.command,
+      pid: existing.pid,
+      logPath: existing.logPath,
+      attemptedAt: existing.attemptedAt,
+      failureMessage: null
+    };
+  }
+  if (outcome.kind === "spawn_failed") {
+    return {
+      status: "spawn_failed",
+      command: outcome.command,
+      pid: null,
+      logPath: null,
+      attemptedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      failureMessage: outcome.message
+    };
+  }
+  return existing;
+}
 
-// node_modules/@remixhq/core/dist/chunk-US5SM7ZC.js
+// node_modules/@remixhq/core/dist/chunk-C2FOZ3O7.js
 async function readJsonSafe(res) {
   const ct = res.headers.get("content-type") ?? "";
   if (!ct.toLowerCase().includes("application/json")) return null;
@@ -10245,8 +10952,13 @@ async function readJsonSafe(res) {
 function createApiClient(config, opts) {
   const apiKey = (opts?.apiKey ?? "").trim();
   const tokenProvider = opts?.tokenProvider;
+  const defaultTimeoutMs = typeof opts?.defaultRequestTimeoutMs === "number" && opts.defaultRequestTimeoutMs > 0 ? opts.defaultRequestTimeoutMs : null;
   const CLIENT_KEY_HEADER = "x-comerge-api-key";
-  async function request(path16, init) {
+  function makeTimeoutSignal(timeoutMs) {
+    const ms = typeof timeoutMs === "number" && timeoutMs > 0 ? timeoutMs : defaultTimeoutMs;
+    return ms != null ? AbortSignal.timeout(ms) : void 0;
+  }
+  async function request(path17, init, opts2) {
     if (!tokenProvider) {
       throw new RemixError("API client is missing a token provider.", {
         exitCode: 1,
@@ -10254,9 +10966,10 @@ function createApiClient(config, opts) {
       });
     }
     const auth = await tokenProvider();
-    const url = new URL(path16, config.apiUrl).toString();
+    const url = new URL(path17, config.apiUrl).toString();
     const doFetch = async (bearer) => fetch(url, {
       ...init,
+      signal: makeTimeoutSignal(opts2?.timeoutMs),
       headers: {
         Accept: "application/json",
         "Content-Type": "application/json",
@@ -10273,12 +10986,16 @@ function createApiClient(config, opts) {
     if (!res.ok) {
       const body = await readJsonSafe(res);
       const msg = (body && typeof body === "object" && body && "message" in body && typeof body.message === "string" ? body.message : null) ?? `Request failed (status ${res.status})`;
-      throw new RemixError(msg, { exitCode: 1, hint: body ? JSON.stringify(body, null, 2) : null });
+      throw new RemixError(msg, {
+        exitCode: 1,
+        hint: body ? JSON.stringify(body, null, 2) : null,
+        statusCode: res.status
+      });
     }
     const json = await readJsonSafe(res);
     return json ?? null;
   }
-  async function requestBinary(path16, init) {
+  async function requestBinary(path17, init, opts2) {
     if (!tokenProvider) {
       throw new RemixError("API client is missing a token provider.", {
         exitCode: 1,
@@ -10286,9 +11003,10 @@ function createApiClient(config, opts) {
       });
     }
     const auth = await tokenProvider();
-    const url = new URL(path16, config.apiUrl).toString();
+    const url = new URL(path17, config.apiUrl).toString();
     const doFetch = async (bearer) => fetch(url, {
       ...init,
+      signal: makeTimeoutSignal(opts2?.timeoutMs),
       headers: {
         Accept: "*/*",
         ...init?.headers ?? {},
@@ -10304,7 +11022,11 @@ function createApiClient(config, opts) {
     if (!res.ok) {
       const body = await readJsonSafe(res);
       const msg = (body && typeof body === "object" && body && "message" in body && typeof body.message === "string" ? body.message : null) ?? `Request failed (status ${res.status})`;
-      throw new RemixError(msg, { exitCode: 1, hint: body ? JSON.stringify(body, null, 2) : null });
+      throw new RemixError(msg, {
+        exitCode: 1,
+        hint: body ? JSON.stringify(body, null, 2) : null,
+        statusCode: res.status
+      });
     }
     const contentDisposition = res.headers.get("content-disposition") ?? "";
     const fileNameMatch = contentDisposition.match(/filename=\"([^\"]+)\"/i);
@@ -10411,6 +11133,14 @@ function createApiClient(config, opts) {
       method: "POST",
       body: JSON.stringify(payload)
     }),
+    listChangeSteps: (appId, params) => {
+      const qs = new URLSearchParams();
+      if (params?.limit !== void 0) qs.set("limit", String(params.limit));
+      if (params?.offset !== void 0) qs.set("offset", String(params.offset));
+      if (params?.idempotencyKey) qs.set("idempotencyKey", params.idempotencyKey);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/change-steps${suffix}`, { method: "GET" });
+    },
     createCollabTurn: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/collab-turns`, {
       method: "POST",
       body: JSON.stringify(payload)
@@ -11136,8 +11866,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path16, errorMaps, issueData } = params;
-  const fullPath = [...path16, ...issueData.path || []];
+  const { data, path: path17, errorMaps, issueData } = params;
+  const fullPath = [...path17, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -11253,11 +11983,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path16, key) {
+  constructor(parent, value, path17, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path16;
+    this._path = path17;
     this._key = key;
   }
   get path() {
@@ -14699,8 +15429,8 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// node_modules/@remixhq/core/dist/chunk-P6JHXOV4.js
-var import_promises19 = __toESM(require("fs/promises"), 1);
+// node_modules/@remixhq/core/dist/chunk-XETDXVGM.js
+var import_promises22 = __toESM(require("fs/promises"), 1);
 var import_os3 = __toESM(require("os"), 1);
 var import_path7 = __toESM(require("path"), 1);
 
@@ -15108,7 +15838,7 @@ var PostgrestError = class extends Error {
     };
   }
 };
-function sleep2(ms, signal) {
+function sleep3(ms, signal) {
   return new Promise((resolve) => {
     if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
       resolve();
@@ -15304,7 +16034,7 @@ var PostgrestBuilder = class {
           if (_this.retryEnabled && attemptCount < DEFAULT_MAX_RETRIES) {
             const delay = getRetryDelay(attemptCount);
             attemptCount++;
-            await sleep2(delay, _this.signal);
+            await sleep3(delay, _this.signal);
             continue;
           }
           throw fetchError;
@@ -15315,7 +16045,7 @@ var PostgrestBuilder = class {
           const delay = retryAfterHeader !== null ? Math.max(0, parseInt(retryAfterHeader, 10) || 0) * 1e3 : getRetryDelay(attemptCount);
           await res$1.text();
           attemptCount++;
-          await sleep2(delay, _this.signal);
+          await sleep3(delay, _this.signal);
           continue;
         }
         return await _this.processResponse(res$1);
@@ -23805,8 +24535,8 @@ var IcebergError = class extends Error {
     return this.status === 419;
   }
 };
-function buildUrl(baseUrl, path16, query) {
-  const url = new URL(path16, baseUrl);
+function buildUrl(baseUrl, path17, query) {
+  const url = new URL(path17, baseUrl);
   if (query) {
     for (const [key, value] of Object.entries(query)) {
       if (value !== void 0) {
@@ -23836,12 +24566,12 @@ function createFetchClient(options) {
   return {
     async request({
       method,
-      path: path16,
+      path: path17,
       query,
       body,
       headers
     }) {
-      const url = buildUrl(options.baseUrl, path16, query);
+      const url = buildUrl(options.baseUrl, path17, query);
       const authHeaders = await buildAuthHeaders(options.auth);
       const res = await fetchFn(url, {
         method,
@@ -24679,7 +25409,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, path16, fileBody, fileOptions) {
+  async uploadOrUpdate(method, path17, fileBody, fileOptions) {
     var _this = this;
     return _this.handleOperation(async () => {
       let body;
@@ -24703,7 +25433,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) for (const [key, value] of Object.entries(fileOptions.headers)) headers = setHeader(headers, key, value);
-      const cleanPath = _this._removeEmptyFolders(path16);
+      const cleanPath = _this._removeEmptyFolders(path17);
       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 {
@@ -24764,8 +25494,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(path16, fileBody, fileOptions) {
-    return this.uploadOrUpdate("POST", path16, fileBody, fileOptions);
+  async upload(path17, fileBody, fileOptions) {
+    return this.uploadOrUpdate("POST", path17, fileBody, fileOptions);
   }
   /**
   * Upload a file with a token generated from `createSignedUploadUrl`.
@@ -24804,9 +25534,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(path16, token, fileBody, fileOptions) {
+  async uploadToSignedUrl(path17, token, fileBody, fileOptions) {
     var _this3 = this;
-    const cleanPath = _this3._removeEmptyFolders(path16);
+    const cleanPath = _this3._removeEmptyFolders(path17);
     const _path = _this3._getFinalPath(cleanPath);
     const url = new URL(_this3.url + `/object/upload/sign/${_path}`);
     url.searchParams.set("token", token);
@@ -24868,10 +25598,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(path16, options) {
+  async createSignedUploadUrl(path17, options) {
     var _this4 = this;
     return _this4.handleOperation(async () => {
-      let _path = _this4._getFinalPath(path16);
+      let _path = _this4._getFinalPath(path17);
       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 });
@@ -24880,7 +25610,7 @@ var StorageFileApi = class extends BaseApiClient {
       if (!token) throw new StorageError("No token returned by API");
       return {
         signedUrl: url.toString(),
-        path: path16,
+        path: path17,
         token
       };
     });
@@ -24936,8 +25666,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(path16, fileBody, fileOptions) {
-    return this.uploadOrUpdate("PUT", path16, fileBody, fileOptions);
+  async update(path17, fileBody, fileOptions) {
+    return this.uploadOrUpdate("PUT", path17, fileBody, fileOptions);
   }
   /**
   * Moves an existing file to a new path in the same bucket.
@@ -25085,10 +25815,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(path16, expiresIn, options) {
+  async createSignedUrl(path17, expiresIn, options) {
     var _this8 = this;
     return _this8.handleOperation(async () => {
-      let _path = _this8._getFinalPath(path16);
+      let _path = _this8._getFinalPath(path17);
       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 query = new URLSearchParams();
@@ -25222,13 +25952,13 @@ 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(path16, options, parameters) {
+  download(path17, options, parameters) {
     const renderPath = typeof (options === null || options === void 0 ? void 0 : options.transform) === "object" && options.transform !== null && Object.keys(options.transform).length > 0 ? "render/image/authenticated" : "object";
     const query = new URLSearchParams();
     if (options === null || options === void 0 ? void 0 : options.transform) this.applyTransformOptsToQuery(query, options.transform);
     if ((options === null || options === void 0 ? void 0 : options.cacheNonce) != null) query.set("cacheNonce", String(options.cacheNonce));
     const queryString = query.toString();
-    const _path = this._getFinalPath(path16);
+    const _path = this._getFinalPath(path17);
     const downloadFn = () => get(this.fetch, `${this.url}/${renderPath}/${_path}${queryString ? `?${queryString}` : ""}`, {
       headers: this.headers,
       noResolveJson: true
@@ -25258,9 +25988,9 @@ var StorageFileApi = class extends BaseApiClient {
   * }
   * ```
   */
-  async info(path16) {
+  async info(path17) {
     var _this10 = this;
-    const _path = _this10._getFinalPath(path16);
+    const _path = _this10._getFinalPath(path17);
     return _this10.handleOperation(async () => {
       return recursiveToCamel(await get(_this10.fetch, `${_this10.url}/object/info/${_path}`, { headers: _this10.headers }));
     });
@@ -25280,9 +26010,9 @@ var StorageFileApi = class extends BaseApiClient {
   *   .exists('folder/avatar1.png')
   * ```
   */
-  async exists(path16) {
+  async exists(path17) {
     var _this11 = this;
-    const _path = _this11._getFinalPath(path16);
+    const _path = _this11._getFinalPath(path17);
     try {
       await head(_this11.fetch, `${_this11.url}/object/${_path}`, { headers: _this11.headers });
       return {
@@ -25360,8 +26090,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(path16, options) {
-    const _path = this._getFinalPath(path16);
+  getPublicUrl(path17, options) {
+    const _path = this._getFinalPath(path17);
     const query = new URLSearchParams();
     if (options === null || options === void 0 ? void 0 : options.download) query.set("download", options.download === true ? "" : options.download);
     if (options === null || options === void 0 ? void 0 : options.transform) this.applyTransformOptsToQuery(query, options.transform);
@@ -25498,10 +26228,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(path16, options, parameters) {
+  async list(path17, options, parameters) {
     var _this13 = this;
     return _this13.handleOperation(async () => {
-      const body = _objectSpread22(_objectSpread22(_objectSpread22({}, DEFAULT_SEARCH_OPTIONS), options), {}, { prefix: path16 || "" });
+      const body = _objectSpread22(_objectSpread22(_objectSpread22({}, DEFAULT_SEARCH_OPTIONS), options), {}, { prefix: path17 || "" });
       return await post(_this13.fetch, `${_this13.url}/object/list/${_this13.bucketId}`, body, { headers: _this13.headers }, parameters);
     });
   }
@@ -25565,11 +26295,11 @@ var StorageFileApi = class extends BaseApiClient {
     if (typeof Buffer !== "undefined") return Buffer.from(data).toString("base64");
     return btoa(data);
   }
-  _getFinalPath(path16) {
-    return `${this.bucketId}/${path16.replace(/^\/+/, "")}`;
+  _getFinalPath(path17) {
+    return `${this.bucketId}/${path17.replace(/^\/+/, "")}`;
   }
-  _removeEmptyFolders(path16) {
-    return path16.replace(/^\/|\/$/g, "").replace(/\/+/g, "/");
+  _removeEmptyFolders(path17) {
+    return path17.replace(/^\/|\/$/g, "").replace(/\/+/g, "/");
   }
   /** Modifies the `query`, appending values the from `transform` */
   applyTransformOptsToQuery(query, transform) {
@@ -27312,7 +28042,7 @@ function decodeJWT(token) {
   };
   return data;
 }
-async function sleep3(time) {
+async function sleep4(time) {
   return await new Promise((accept) => {
     setTimeout(() => accept(null), time);
   });
@@ -33105,7 +33835,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 sleep4(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`, {
@@ -34644,7 +35374,7 @@ function shouldShowDeprecationWarning() {
 }
 if (shouldShowDeprecationWarning()) console.warn("\u26A0\uFE0F  Node.js 18 and below are deprecated and will no longer be supported in future versions of @supabase/supabase-js. Please upgrade to Node.js 20 or later. For more information, visit: https://github.com/orgs/supabase/discussions/37217");
 
-// node_modules/@remixhq/core/dist/chunk-P6JHXOV4.js
+// node_modules/@remixhq/core/dist/chunk-XETDXVGM.js
 var storedSessionSchema = external_exports.object({
   access_token: external_exports.string().min(1),
   refresh_token: external_exports.string().min(1),
@@ -34677,24 +35407,24 @@ async function maybeLoadKeytar() {
 }
 async function ensurePathPermissions(filePath) {
   const dir = import_path7.default.dirname(filePath);
-  await import_promises19.default.mkdir(dir, { recursive: true });
+  await import_promises22.default.mkdir(dir, { recursive: true });
   try {
-    await import_promises19.default.chmod(dir, 448);
+    await import_promises22.default.chmod(dir, 448);
   } catch {
   }
   try {
-    await import_promises19.default.chmod(filePath, 384);
+    await import_promises22.default.chmod(filePath, 384);
   } catch {
   }
 }
-async function writeJsonAtomic2(filePath, value) {
-  await import_promises19.default.mkdir(import_path7.default.dirname(filePath), { recursive: true });
+async function writeJsonAtomic3(filePath, value) {
+  await import_promises22.default.mkdir(import_path7.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_promises22.default.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  await import_promises22.default.rename(tmpPath, filePath);
 }
 async function writeSessionFileFallback(filePath, session) {
-  await writeJsonAtomic2(filePath, session);
+  await writeJsonAtomic3(filePath, session);
   await ensurePathPermissions(filePath);
 }
 function createLocalSessionStore(params) {
@@ -34714,7 +35444,7 @@ function createLocalSessionStore(params) {
     }
   }
   async function readFile() {
-    const raw = await import_promises19.default.readFile(filePath, "utf8").catch(() => null);
+    const raw = await import_promises22.default.readFile(filePath, "utf8").catch(() => null);
     if (!raw) return null;
     try {
       const parsed = storedSessionSchema.safeParse(JSON.parse(raw));
@@ -34858,7 +35588,7 @@ function createSupabaseAuthHelpers(config) {
   };
 }
 
-// node_modules/@remixhq/core/dist/chunk-VM3CGCNX.js
+// node_modules/@remixhq/core/dist/chunk-XCZRNB35.js
 var DEFAULT_API_URL = "https://api.remix.one";
 var DEFAULT_SUPABASE_URL = "https://xtfxwbckjpfmqubnsusu.supabase.co";
 var DEFAULT_SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Inh0Znh3YmNranBmbXF1Ym5zdXN1Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjA2MDEyMzAsImV4cCI6MjA3NjE3NzIzMH0.dzWGAWrK4CvrmHVHzf8w7JlUZohdap0ZPnLZnABMV8s";
@@ -34896,6 +35626,7 @@ async function resolveConfig(_opts) {
 }
 
 // src/hook-auth.ts
+var HOOK_API_REQUEST_TIMEOUT_MS = 6e4;
 async function createHookCollabApiClient() {
   const config = await resolveConfig();
   const sessionStore = createLocalSessionStore();
@@ -34908,307 +35639,11 @@ async function createHookCollabApiClient() {
     }
   });
   return createApiClient(config, {
-    tokenProvider
+    tokenProvider,
+    defaultRequestTimeoutMs: HOOK_API_REQUEST_TIMEOUT_MS
   });
 }
 
-// src/hook-diagnostics.ts
-var import_node_crypto2 = require("crypto");
-var import_promises21 = __toESM(require("fs/promises"), 1);
-var import_node_os6 = __toESM(require("os"), 1);
-var import_node_path8 = __toESM(require("path"), 1);
-
-// src/hook-state.ts
-var import_promises20 = __toESM(require("fs/promises"), 1);
-var import_node_os5 = __toESM(require("os"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
-var import_node_crypto = require("crypto");
-function stateRoot2() {
-  const configured = process.env.REMIX_CLAUDE_PLUGIN_HOOK_STATE_ROOT?.trim();
-  return configured || import_node_path7.default.join(import_node_os5.default.tmpdir(), "remix-claude-plugin-hooks");
-}
-function statePath(sessionId) {
-  return import_node_path7.default.join(stateRoot2(), `${sessionId}.json`);
-}
-function stateLockPath(sessionId) {
-  return import_node_path7.default.join(stateRoot2(), `${sessionId}.lock`);
-}
-function stateLockMetaPath(sessionId) {
-  return import_node_path7.default.join(stateLockPath(sessionId), "owner.json");
-}
-async function writeJsonAtomic3(filePath, value) {
-  await import_promises20.default.mkdir(import_node_path7.default.dirname(filePath), { recursive: true });
-  const tmpPath = `${filePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  await import_promises20.default.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
-  await import_promises20.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) {
-  await new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function readStateLockMetadata(sessionId) {
-  const raw = await import_promises20.default.readFile(stateLockMetaPath(sessionId), "utf8").catch(() => null);
-  if (!raw) return null;
-  try {
-    const parsed = JSON.parse(raw);
-    if (typeof parsed.ownerId !== "string" || typeof parsed.pid !== "number" || typeof parsed.createdAt !== "string" || typeof parsed.heartbeatAt !== "string") {
-      return null;
-    }
-    return {
-      ownerId: parsed.ownerId,
-      pid: parsed.pid,
-      createdAt: parsed.createdAt,
-      heartbeatAt: parsed.heartbeatAt
-    };
-  } catch {
-    return null;
-  }
-}
-async function writeStateLockMetadata(sessionId, metadata) {
-  await writeJsonAtomic3(stateLockMetaPath(sessionId), metadata);
-}
-async function tryRemoveStaleStateLock(sessionId) {
-  const lockPath = stateLockPath(sessionId);
-  const metadata = await readStateLockMetadata(sessionId);
-  const staleByHeartbeat = metadata && Date.now() - new Date(metadata.heartbeatAt).getTime() > STATE_LOCK_STALE_MS;
-  if (staleByHeartbeat) {
-    await import_promises20.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
-    return true;
-  }
-  if (!metadata) {
-    const lockStat = await import_promises20.default.stat(lockPath).catch(() => null);
-    if (lockStat && Date.now() - lockStat.mtimeMs > STATE_LOCK_STALE_MS) {
-      await import_promises20.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
-      return true;
-    }
-  }
-  return false;
-}
-async function acquireStateLock(sessionId) {
-  const lockPath = stateLockPath(sessionId);
-  const deadline = Date.now() + STATE_LOCK_WAIT_MS;
-  await import_promises20.default.mkdir(stateRoot2(), { recursive: true });
-  while (true) {
-    try {
-      await import_promises20.default.mkdir(lockPath);
-      const ownerId = (0, import_node_crypto.randomUUID)();
-      const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-      const metadata = {
-        ownerId,
-        pid: process.pid,
-        createdAt,
-        heartbeatAt: createdAt
-      };
-      await writeStateLockMetadata(sessionId, metadata);
-      let released = false;
-      const heartbeat = setInterval(() => {
-        if (released) return;
-        void writeStateLockMetadata(sessionId, {
-          ...metadata,
-          heartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
-        }).catch(() => void 0);
-      }, STATE_LOCK_HEARTBEAT_MS);
-      heartbeat.unref?.();
-      return async () => {
-        if (released) return;
-        released = true;
-        clearInterval(heartbeat);
-        const currentMetadata = await readStateLockMetadata(sessionId);
-        if (currentMetadata?.ownerId === ownerId) {
-          await import_promises20.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
-        }
-      };
-    } catch (error) {
-      const code = error && typeof error === "object" && "code" in error ? error.code : null;
-      if (code !== "EEXIST") {
-        throw error;
-      }
-      if (await tryRemoveStaleStateLock(sessionId)) {
-        continue;
-      }
-      if (Date.now() >= deadline) {
-        throw new Error(`Timed out acquiring hook state lock for session ${sessionId}.`);
-      }
-      await sleep4(STATE_LOCK_POLL_MS);
-    }
-  }
-}
-async function withStateLock(sessionId, fn) {
-  const release = await acquireStateLock(sessionId);
-  try {
-    return await fn();
-  } finally {
-    await release();
-  }
-}
-async function savePendingTurnState(state) {
-  await writeJsonAtomic3(statePath(state.sessionId), state);
-}
-async function createPendingTurnState(params) {
-  return withStateLock(params.sessionId, async () => {
-    const state = {
-      sessionId: params.sessionId,
-      turnId: (0, import_node_crypto.randomUUID)(),
-      prompt: params.prompt,
-      initialCwd: params.initialCwd?.trim() || null,
-      intent: params.intent,
-      submittedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      consultedMemory: false,
-      touchedRepos: {},
-      turnFailureMessage: null,
-      turnFailureHint: null,
-      turnFailedAt: null
-    };
-    await savePendingTurnState(state);
-    return state;
-  });
-}
-
-// package.json
-var package_default = {
-  name: "@remixhq/claude-plugin",
-  version: "0.1.22",
-  description: "Claude Code plugin for Remix collaboration workflows",
-  homepage: "https://github.com/RemixDotOne/remix-claude-plugin",
-  license: "MIT",
-  repository: {
-    type: "git",
-    url: "https://github.com/RemixDotOne/remix-claude-plugin.git"
-  },
-  type: "module",
-  engines: {
-    node: ">=20"
-  },
-  publishConfig: {
-    access: "public"
-  },
-  files: [
-    "dist",
-    ".claude-plugin/plugin.json",
-    ".mcp.json",
-    "skills",
-    "hooks",
-    "agents"
-  ],
-  exports: {
-    ".": {
-      types: "./dist/index.d.ts",
-      import: "./dist/index.js"
-    }
-  },
-  scripts: {
-    build: "tsup",
-    postbuild: `node -e "const fs=require('node:fs'); for (const p of ['dist/mcp-server.cjs','dist/hook-pre-git.cjs','dist/hook-user-prompt.cjs','dist/hook-post-collab.cjs','dist/hook-stop-collab.cjs']) fs.chmodSync(p, 0o755);"`,
-    dev: "tsx src/mcp-server.ts",
-    typecheck: "tsc -p tsconfig.json --noEmit",
-    test: "node --import tsx --test 'src/**/*.test.ts'",
-    prepack: "npm run build"
-  },
-  dependencies: {
-    "@remixhq/core": "^0.1.17",
-    "@remixhq/mcp": "^0.1.17"
-  },
-  devDependencies: {
-    "@types/node": "^25.4.0",
-    tsup: "^8.5.1",
-    tsx: "^4.21.0",
-    typescript: "^5.9.3"
-  }
-};
-
-// src/metadata.ts
-var pluginMetadata = {
-  name: package_default.name,
-  version: package_default.version,
-  description: package_default.description,
-  pluginId: "remix",
-  agentName: "remix-collab"
-};
-
-// src/hook-diagnostics.ts
-var MAX_LOG_BYTES = 512 * 1024;
-function resolveClaudeRoot() {
-  const configured = process.env.CLAUDE_CONFIG_DIR?.trim();
-  return configured || import_node_path8.default.join(import_node_os6.default.homedir(), ".claude");
-}
-function resolvePluginDataDirName() {
-  return `${pluginMetadata.pluginId}-${pluginMetadata.pluginId}`;
-}
-function getHookDiagnosticsDirPath() {
-  const configured = process.env.REMIX_CLAUDE_PLUGIN_HOOK_DIAGNOSTICS_DIR?.trim();
-  return configured || import_node_path8.default.join(resolveClaudeRoot(), "plugins", "data", resolvePluginDataDirName());
-}
-function getHookDiagnosticsLogPath() {
-  return import_node_path8.default.join(getHookDiagnosticsDirPath(), "hooks.ndjson");
-}
-function toFieldValue(value) {
-  if (value === null) return null;
-  if (typeof value === "string") return value;
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "boolean") return value;
-  return void 0;
-}
-function normalizeFields(fields) {
-  if (!fields) return {};
-  const normalizedEntries = Object.entries(fields).map(([key, value]) => {
-    const normalized = toFieldValue(value);
-    return normalized === void 0 ? null : [key, normalized];
-  }).filter((entry) => entry !== null);
-  return Object.fromEntries(normalizedEntries);
-}
-async function rotateLogIfNeeded(logPath) {
-  const stat = await import_promises21.default.stat(logPath).catch(() => null);
-  if (!stat || stat.size < MAX_LOG_BYTES) {
-    return;
-  }
-  const rotatedPath = `${logPath}.1`;
-  await import_promises21.default.rm(rotatedPath, { force: true }).catch(() => void 0);
-  await import_promises21.default.rename(logPath, rotatedPath).catch(() => void 0);
-}
-function summarizeText(value) {
-  if (typeof value !== "string" || !value.trim()) {
-    return {
-      present: false,
-      length: 0,
-      sha256Prefix: null
-    };
-  }
-  const trimmed = value.trim();
-  return {
-    present: true,
-    length: trimmed.length,
-    sha256Prefix: (0, import_node_crypto2.createHash)("sha256").update(trimmed).digest("hex").slice(0, 12)
-  };
-}
-async function appendHookDiagnosticsEvent(params) {
-  try {
-    const logPath = getHookDiagnosticsLogPath();
-    await import_promises21.default.mkdir(import_node_path8.default.dirname(logPath), { recursive: true });
-    await rotateLogIfNeeded(logPath);
-    const event = {
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      hook: params.hook,
-      pluginVersion: pluginMetadata.version,
-      pid: process.pid,
-      sessionId: params.sessionId?.trim() || null,
-      turnId: params.turnId?.trim() || null,
-      stage: params.stage.trim(),
-      result: params.result,
-      reason: params.reason?.trim() || null,
-      toolName: params.toolName?.trim() || null,
-      repoRoot: params.repoRoot?.trim() || null,
-      message: params.message?.trim() || null,
-      fields: normalizeFields(params.fields)
-    };
-    await import_promises21.default.appendFile(logPath, `${JSON.stringify(event)}
-`, "utf8");
-  } catch {
-  }
-}
-
 // src/deferred-turn-drainer.ts
 var collabFinalizeTurn2 = collabFinalizeTurn;
 var drainPendingFinalizeQueue2 = drainPendingFinalizeQueue;
@@ -35218,6 +35653,16 @@ var HOOK_ACTOR = {
   version: pluginMetadata.version,
   provider: "anthropic"
 };
+function getDrainerErrorDetails(error) {
+  if (error instanceof Error) {
+    const hint = typeof error.hint === "string" ? String(error.hint) : null;
+    const codeRaw = error.code;
+    const preflightCode = isFinalizePreflightFailureCode(codeRaw) ? codeRaw : null;
+    return { message: error.message || "Deferred turn recording failed.", hint, preflightCode };
+  }
+  const message = typeof error === "string" && error.trim() ? error.trim() : "Deferred turn recording failed.";
+  return { message, hint: null, preflightCode: null };
+}
 var DEFERRED_TURN_DRAIN_POLL_INTERVAL_MS = 3e3;
 var DEFERRED_TURN_DRAIN_MAX_WAIT_MS = 15 * 60 * 1e3;
 var DEFERRED_TURN_DRAIN_LOCK_HEARTBEAT_MS = 3e4;
@@ -35236,10 +35681,10 @@ function repoLockFileName(repoRoot) {
   return `.drainer-${hash}.lock`;
 }
 function repoLockPath(repoRoot) {
-  return import_node_path9.default.join(getDeferredTurnDirPath(), repoLockFileName(repoRoot));
+  return import_node_path11.default.join(getDeferredTurnDirPath(), repoLockFileName(repoRoot));
 }
 async function readDrainLockMetadata(lockPath) {
-  const raw = await import_promises22.default.readFile(lockPath, "utf8").catch(() => null);
+  const raw = await import_promises23.default.readFile(lockPath, "utf8").catch(() => null);
   if (!raw) return null;
   try {
     const parsed = JSON.parse(raw);
@@ -35253,15 +35698,15 @@ async function readDrainLockMetadata(lockPath) {
 }
 async function writeDrainLockMetadata(lockPath, metadata) {
   const tmpPath = `${lockPath}.tmp-${process.pid}-${Date.now()}`;
-  await import_promises22.default.writeFile(tmpPath, JSON.stringify(metadata), "utf8");
-  await import_promises22.default.rename(tmpPath, lockPath);
+  await import_promises23.default.writeFile(tmpPath, JSON.stringify(metadata), "utf8");
+  await import_promises23.default.rename(tmpPath, lockPath);
 }
 async function tryAcquireDrainLock(repoRoot) {
   const lockPath = repoLockPath(repoRoot);
-  await import_promises22.default.mkdir(import_node_path9.default.dirname(lockPath), { recursive: true });
+  await import_promises23.default.mkdir(import_node_path11.default.dirname(lockPath), { recursive: true });
   const existingMeta = await readDrainLockMetadata(lockPath);
   if (existingMeta) {
-    const lockStat = await import_promises22.default.stat(lockPath).catch(() => null);
+    const lockStat = await import_promises23.default.stat(lockPath).catch(() => null);
     const ageMs = lockStat ? Date.now() - lockStat.mtimeMs : Number.POSITIVE_INFINITY;
     const fresh = ageMs <= DEFERRED_TURN_DRAIN_LOCK_STALE_MS;
     const alive = isPidAlive(existingMeta.pid);
@@ -35279,11 +35724,11 @@ async function tryAcquireDrainLock(repoRoot) {
 async function releaseDrainLock(lockPath) {
   const meta = await readDrainLockMetadata(lockPath);
   if (meta && meta.pid !== process.pid) return;
-  await import_promises22.default.rm(lockPath, { force: true }).catch(() => void 0);
+  await import_promises23.default.rm(lockPath, { force: true }).catch(() => void 0);
 }
 async function heartbeatDrainLock(lockPath) {
   const now = /* @__PURE__ */ new Date();
-  await import_promises22.default.utimes(lockPath, now, now).catch(() => void 0);
+  await import_promises23.default.utimes(lockPath, now, now).catch(() => void 0);
 }
 async function sleep5(ms) {
   await new Promise((resolve) => setTimeout(resolve, ms));
@@ -35383,6 +35828,7 @@ async function runStandaloneDeferredTurnDrainer(repoRoot) {
   let api = null;
   let recordedTotal = 0;
   let failedTotal = 0;
+  let droppedTotal = 0;
   let exitReason = "queue_empty";
   try {
     while (true) {
@@ -35413,7 +35859,49 @@ async function runStandaloneDeferredTurnDrainer(repoRoot) {
       const bindingState = await readCollabBindingState(repoRoot).catch(() => null);
       const currentBranch = bindingState?.currentBranch ?? null;
       const isCurrentBranchBound = bindingState?.binding != null;
-      const attemptable = entries.filter(
+      const currentAppId = bindingState?.binding?.currentAppId ?? null;
+      const currentProjectId = bindingState?.binding?.projectId ?? bindingState?.projectId ?? null;
+      let droppedThisPass = 0;
+      const liveEntries = [];
+      for (const entry of entries) {
+        const appIdMismatch = entry.record.appIdAtDefer != null && currentAppId != null && entry.record.appIdAtDefer !== currentAppId;
+        const projectIdMismatch = entry.record.projectIdAtDefer != null && currentProjectId != null && entry.record.projectIdAtDefer !== currentProjectId;
+        if (appIdMismatch || projectIdMismatch) {
+          await deleteDeferredTurnFile(entry.filePath);
+          droppedThisPass += 1;
+          await appendHookDiagnosticsEvent({
+            hook: "deferredTurnDrainer",
+            sessionId: sessionMarker,
+            stage: "deferred_turn_dropped",
+            result: "info",
+            reason: appIdMismatch ? "app_id_mismatch" : "project_id_mismatch",
+            repoRoot,
+            fields: {
+              deferredTurnId: entry.record.turnId,
+              deferredSessionId: entry.record.sessionId,
+              appIdAtDefer: entry.record.appIdAtDefer,
+              projectIdAtDefer: entry.record.projectIdAtDefer,
+              currentAppId,
+              currentProjectId
+            }
+          });
+          continue;
+        }
+        liveEntries.push(entry);
+      }
+      if (droppedThisPass > 0) {
+        droppedTotal += droppedThisPass;
+      }
+      if (liveEntries.length === 0) {
+        const remaining = await listDeferredTurnsForRepo(repoRoot).catch(() => []);
+        if (remaining.length === 0) {
+          exitReason = "queue_empty";
+          break;
+        }
+        await sleep5(DEFERRED_TURN_DRAIN_POLL_INTERVAL_MS);
+        continue;
+      }
+      const attemptable = liveEntries.filter(
         (e) => isCurrentBranchBound && (!e.record.branchAtDefer || e.record.branchAtDefer === currentBranch)
       );
       if (attemptable.length === 0) {
@@ -35462,6 +35950,8 @@ async function runStandaloneDeferredTurnDrainer(repoRoot) {
         } else {
           failedThisPass += 1;
           failedTotal += 1;
+          const outcome = await recordDeferredTurnFailedAttempt(entry.filePath).catch(() => null);
+          const promoted = outcome?.promoted === true;
           await appendHookDiagnosticsEvent({
             hook: "deferredTurnDrainer",
             sessionId: sessionMarker,
@@ -35472,9 +35962,43 @@ async function runStandaloneDeferredTurnDrainer(repoRoot) {
             message: result.error instanceof Error ? result.error.message : String(result.error ?? ""),
             fields: {
               deferredTurnId: entry.record.turnId,
-              deferredSessionId: entry.record.sessionId
+              deferredSessionId: entry.record.sessionId,
+              attemptCount: outcome?.promoted === false ? outcome.newAttemptCount : outcome?.promoted === true ? outcome.finalAttemptCount : null,
+              promoted
             }
           });
+          if (promoted) {
+            const errorDetails = getDrainerErrorDetails(result.error);
+            await dispatchFinalizeFailure({
+              // The dispatcher only knows about the two real Claude hook
+              // entrypoints. The standalone drainer is logically a
+              // post-Stop background process and the marker we're about
+              // to write is consumed by the next prompt's UserPromptSubmit
+              // hook, so attributing the failure to "Stop" matches what
+              // the user will see.
+              hook: "Stop",
+              sessionId: sessionMarker,
+              turnId: entry.record.turnId,
+              repoRoot,
+              preflightCode: errorDetails.preflightCode,
+              message: `Deferred turn could not be recorded after ${outcome?.finalAttemptCount ?? "max"} attempts: ${errorDetails.message}`,
+              hint: errorDetails.hint
+            }).catch(async (dispatchErr) => {
+              await appendHookDiagnosticsEvent({
+                hook: "deferredTurnDrainer",
+                sessionId: sessionMarker,
+                stage: "deferred_turn_promotion_dispatch_failed",
+                result: "error",
+                reason: "exception",
+                repoRoot,
+                message: dispatchErr instanceof Error ? dispatchErr.message : String(dispatchErr),
+                fields: {
+                  deferredTurnId: entry.record.turnId,
+                  deferredSessionId: entry.record.sessionId
+                }
+              });
+            });
+          }
         }
       }
       if (recordedThisPass > 0) {
@@ -35527,6 +36051,7 @@ async function runStandaloneDeferredTurnDrainer(repoRoot) {
       fields: {
         recordedTotal,
         failedTotal,
+        droppedTotal,
         elapsedMs: Date.now() - startedAt
       }
     });
@@ -35555,34 +36080,13 @@ async function maybeRunDeferredTurnDrainerFromArgv() {
   return true;
 }
 
-// src/finalize-failure-marker.ts
-var import_promises23 = __toESM(require("fs/promises"), 1);
-var import_node_path10 = __toESM(require("path"), 1);
-var FINALIZE_FAILURE_MARKER_REL = import_node_path10.default.join(".remix", ".last-finalize-failure.json");
-function markerPath(repoRoot) {
-  return import_node_path10.default.join(repoRoot, FINALIZE_FAILURE_MARKER_REL);
-}
-async function readFinalizeFailureMarker(repoRoot) {
-  const raw = await import_promises23.default.readFile(markerPath(repoRoot), "utf8").catch(() => null);
-  if (!raw) return null;
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed.schemaVersion !== 1) return null;
-    if (typeof parsed.repoRoot !== "string" || typeof parsed.failedAt !== "string") return null;
-    if (typeof parsed.message !== "string") return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-
 // src/spawn-helpers.ts
-var import_node_child_process6 = require("child_process");
+var import_node_child_process7 = require("child_process");
 function spawnDeferredTurnDrainer(repoRoot) {
   const entrypoint = process.argv[1];
   if (!entrypoint) return;
   if (!repoRoot) return;
-  const child = (0, import_node_child_process6.spawn)(
+  const child = (0, import_node_child_process7.spawn)(
     process.execPath,
     [...process.execArgv, entrypoint, "--drain-deferred-turns", repoRoot],
     {
@@ -35596,7 +36100,7 @@ function spawnDeferredTurnDrainer(repoRoot) {
 
 // src/hook-utils.ts
 var import_promises24 = __toESM(require("fs/promises"), 1);
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
 async function readJsonStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -35622,16 +36126,16 @@ function extractString(input, keys) {
 }
 async function findBoundRepo(startPath) {
   if (!startPath) return null;
-  let current = import_node_path11.default.resolve(startPath);
+  let current = import_node_path12.default.resolve(startPath);
   let stats = await import_promises24.default.stat(current).catch(() => null);
   if (stats?.isFile()) {
-    current = import_node_path11.default.dirname(current);
+    current = import_node_path12.default.dirname(current);
   }
   while (true) {
-    const bindingPath = import_node_path11.default.join(current, ".remix", "config.json");
+    const bindingPath = import_node_path12.default.join(current, ".remix", "config.json");
     const bindingStats = await import_promises24.default.stat(bindingPath).catch(() => null);
     if (bindingStats?.isFile()) return current;
-    const parent = import_node_path11.default.dirname(current);
+    const parent = import_node_path12.default.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -35655,8 +36159,8 @@ function buildRuntimeStatusOverride() {
     "Use `remix_collab_drain_finalize_queue` only for explicit recovery flows, such as status reporting `await_finalize` before a merge-related operation."
   ].join("\n");
 }
-var COLLAB_INIT_LOG_REL = import_node_path12.default.join(".remix", "collab-init.log");
-var COLLAB_INIT_SPAWN_LOCK_REL = import_node_path12.default.join(".remix", ".collab-init-spawning");
+var COLLAB_INIT_LOG_REL = import_node_path13.default.join(".remix", "collab-init.log");
+var COLLAB_INIT_SPAWN_LOCK_REL = import_node_path13.default.join(".remix", ".collab-init-spawning");
 var COLLAB_INIT_SPAWN_LOCK_STALE_MS = 90 * 1e3;
 function isPidAlive2(pid) {
   if (!Number.isFinite(pid) || pid <= 0) return false;
@@ -35667,31 +36171,44 @@ function isPidAlive2(pid) {
     return false;
   }
 }
-function readLockPid(spawnLockPath) {
+function readSpawnLock(spawnLockPath) {
   try {
-    const raw = (0, import_node_fs6.readFileSync)(spawnLockPath, "utf8").trim();
+    const raw = (0, import_node_fs7.readFileSync)(spawnLockPath, "utf8").trim();
     if (!raw) return null;
+    if (raw.startsWith("{")) {
+      const parsed = JSON.parse(raw);
+      const pid2 = Number(parsed?.pid ?? 0);
+      return {
+        pid: Number.isFinite(pid2) && pid2 > 0 ? pid2 : null,
+        branchName: typeof parsed?.branchName === "string" && parsed.branchName.trim() ? parsed.branchName : null
+      };
+    }
     const pid = Number.parseInt(raw, 10);
-    return Number.isFinite(pid) && pid > 0 ? pid : null;
+    return {
+      pid: Number.isFinite(pid) && pid > 0 ? pid : null,
+      branchName: null
+    };
   } catch {
     return null;
   }
 }
-function maybeAutoSpawnBranchInit(repoRoot) {
-  const remixDir = import_node_path12.default.join(repoRoot, ".remix");
-  const spawnLockPath = import_node_path12.default.join(repoRoot, COLLAB_INIT_SPAWN_LOCK_REL);
-  const logPath = import_node_path12.default.join(repoRoot, COLLAB_INIT_LOG_REL);
+function maybeAutoSpawnBranchInit(repoRoot, branchName) {
+  const remixDir = import_node_path13.default.join(repoRoot, ".remix");
+  const spawnLockPath = import_node_path13.default.join(repoRoot, COLLAB_INIT_SPAWN_LOCK_REL);
+  const logPath = import_node_path13.default.join(repoRoot, COLLAB_INIT_LOG_REL);
   try {
-    if ((0, import_node_fs6.existsSync)(spawnLockPath)) {
-      const lockPid = readLockPid(spawnLockPath);
+    if ((0, import_node_fs7.existsSync)(spawnLockPath)) {
+      const lock = readSpawnLock(spawnLockPath);
+      const lockPid = lock?.pid ?? null;
       const lockAlive = lockPid !== null && isPidAlive2(lockPid);
-      const ageMs = Date.now() - (0, import_node_fs6.statSync)(spawnLockPath).mtimeMs;
-      if (lockAlive && ageMs < COLLAB_INIT_SPAWN_LOCK_STALE_MS) {
+      const sameBranch = !lock?.branchName || !branchName || lock.branchName === branchName;
+      const ageMs = Date.now() - (0, import_node_fs7.statSync)(spawnLockPath).mtimeMs;
+      if (lockAlive && sameBranch && ageMs < COLLAB_INIT_SPAWN_LOCK_STALE_MS) {
         return { spawned: false, reason: "spawn_lock_held" };
       }
       if (!lockAlive) {
         try {
-          (0, import_node_fs6.unlinkSync)(spawnLockPath);
+          (0, import_node_fs7.unlinkSync)(spawnLockPath);
         } catch {
         }
       }
@@ -35699,14 +36216,14 @@ function maybeAutoSpawnBranchInit(repoRoot) {
   } catch {
   }
   try {
-    (0, import_node_fs6.mkdirSync)(remixDir, { recursive: true });
+    (0, import_node_fs7.mkdirSync)(remixDir, { recursive: true });
   } catch {
   }
   let out;
   let err;
   try {
-    out = (0, import_node_fs6.openSync)(logPath, "a");
-    err = (0, import_node_fs6.openSync)(logPath, "a");
+    out = (0, import_node_fs7.openSync)(logPath, "a");
+    err = (0, import_node_fs7.openSync)(logPath, "a");
   } catch (logErr) {
     return {
       spawned: false,
@@ -35715,7 +36232,14 @@ function maybeAutoSpawnBranchInit(repoRoot) {
     };
   }
   try {
-    const child = (0, import_node_child_process7.spawn)("remix", ["collab", "init"], {
+    (0, import_node_fs7.appendFileSync)(
+      logPath,
+      `
+[${(/* @__PURE__ */ new Date()).toISOString()}] auto-spawning remix collab init for branch=${branchName ?? "(unknown)"} repo=${repoRoot}
+`,
+      "utf8"
+    );
+    const child = (0, import_node_child_process8.spawn)("remix", ["collab", "init"], {
       cwd: repoRoot,
       detached: true,
       stdio: ["ignore", out, err],
@@ -35723,8 +36247,17 @@ function maybeAutoSpawnBranchInit(repoRoot) {
     });
     child.unref();
     try {
-      (0, import_node_fs6.writeFileSync)(spawnLockPath, String(child.pid ?? ""), "utf8");
-      (0, import_node_fs6.utimesSync)(spawnLockPath, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+      const lock = {
+        schemaVersion: 1,
+        pid: child.pid ?? null,
+        branchName,
+        repoRoot,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        command: "remix collab init"
+      };
+      (0, import_node_fs7.writeFileSync)(spawnLockPath, `${JSON.stringify(lock, null, 2)}
+`, "utf8");
+      (0, import_node_fs7.utimesSync)(spawnLockPath, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
     } catch {
     }
     return { spawned: true, pid: child.pid, logPath };
@@ -35742,7 +36275,7 @@ function buildBranchInitContextMessage(branch, repoRoot, logPath) {
     "[Remix recovery in progress]:",
     `Remix is initializing recording for ${branchLabel} in ${repoRoot} in the background.`,
     "This turn may be recorded retroactively once init finishes (it may appear in the timeline with a small delay).",
-    "Do NOT call any Remix MCP tool to initialize, re-anchor, or sync this branch \u2014 the plugin is handling it automatically.",
+    "Do NOT call any Remix MCP tool to initialize, repair, or sync this branch \u2014 the plugin is handling it automatically.",
     `Init log: ${logPath}`
   ].join("\n");
 }
@@ -35942,7 +36475,7 @@ async function runHookUserPrompt(payload) {
   }
   if (isCurrentBranchUnbound) {
     const currentBranch = bindingState?.currentBranch ?? null;
-    const outcome = maybeAutoSpawnBranchInit(boundRepo);
+    const outcome = maybeAutoSpawnBranchInit(boundRepo, currentBranch);
     if (outcome.spawned) {
       advisorySections.push(buildBranchInitContextMessage(currentBranch, boundRepo, outcome.logPath));
       await appendHookDiagnosticsEvent({