@remixhq/claude-plugin 0.1.21 → 0.1.22

package/dist/hook-stop-collab.cjs

@@ -37,8 +37,8 @@ var require_windows = __commonJS({
     "use strict";
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs10 = require("fs");
-    function checkPathExt(path13, options) {
+    var fs13 = require("fs");
+    function checkPathExt(path16, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
         return true;
@@ -49,25 +49,25 @@ var require_windows = __commonJS({
       }
       for (var i2 = 0; i2 < pathext.length; i2++) {
         var p = pathext[i2].toLowerCase();
-        if (p && path13.substr(-p.length).toLowerCase() === p) {
+        if (p && path16.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat, path13, options) {
+    function checkStat(stat, path16, options) {
       if (!stat.isSymbolicLink() && !stat.isFile()) {
         return false;
       }
-      return checkPathExt(path13, options);
+      return checkPathExt(path16, options);
     }
-    function isexe(path13, options, cb) {
-      fs10.stat(path13, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path13, options));
+    function isexe(path16, options, cb) {
+      fs13.stat(path16, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path16, options));
       });
     }
-    function sync(path13, options) {
-      return checkStat(fs10.statSync(path13), path13, options);
+    function sync(path16, options) {
+      return checkStat(fs13.statSync(path16), path16, options);
     }
   }
 });
@@ -78,14 +78,14 @@ var require_mode = __commonJS({
     "use strict";
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs10 = require("fs");
-    function isexe(path13, options, cb) {
-      fs10.stat(path13, function(er, stat) {
+    var fs13 = require("fs");
+    function isexe(path16, options, cb) {
+      fs13.stat(path16, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
-    function sync(path13, options) {
-      return checkStat(fs10.statSync(path13), options);
+    function sync(path16, options) {
+      return checkStat(fs13.statSync(path16), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -110,7 +110,7 @@ var require_mode = __commonJS({
 var require_isexe = __commonJS({
   "node_modules/isexe/index.js"(exports2, module2) {
     "use strict";
-    var fs10 = require("fs");
+    var fs13 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -119,7 +119,7 @@ var require_isexe = __commonJS({
     }
     module2.exports = isexe;
     isexe.sync = sync;
-    function isexe(path13, options, cb) {
+    function isexe(path16, options, cb) {
       if (typeof options === "function") {
         cb = options;
         options = {};
@@ -129,7 +129,7 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve, reject) {
-          isexe(path13, options || {}, function(er, is) {
+          isexe(path16, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -138,7 +138,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path13, options || {}, function(er, is) {
+      core(path16, options || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options && options.ignoreErrors) {
             er = null;
@@ -148,9 +148,9 @@ var require_isexe = __commonJS({
         cb(er, is);
       });
     }
-    function sync(path13, options) {
+    function sync(path16, options) {
       try {
-        return core.sync(path13, options || {});
+        return core.sync(path16, options || {});
       } catch (er) {
         if (options && options.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -167,7 +167,7 @@ var require_which = __commonJS({
   "node_modules/which/which.js"(exports2, module2) {
     "use strict";
     var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-    var path13 = require("path");
+    var path16 = require("path");
     var COLON = isWindows ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -205,7 +205,7 @@ var require_which = __commonJS({
           return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i2];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path13.join(pathPart, cmd);
+        const pCmd = path16.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         resolve(subStep(p, i2, 0));
       });
@@ -232,7 +232,7 @@ var require_which = __commonJS({
       for (let i2 = 0; i2 < pathEnv.length; i2++) {
         const ppRaw = pathEnv[i2];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path13.join(pathPart, cmd);
+        const pCmd = path16.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         for (let j = 0; j < pathExt.length; j++) {
           const cur = p + pathExt[j];
@@ -280,7 +280,7 @@ var require_path_key = __commonJS({
 var require_resolveCommand = __commonJS({
   "node_modules/cross-spawn/lib/util/resolveCommand.js"(exports2, module2) {
     "use strict";
-    var path13 = require("path");
+    var path16 = require("path");
     var which = require_which();
     var getPathKey = require_path_key();
     function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -298,7 +298,7 @@ var require_resolveCommand = __commonJS({
       try {
         resolved = which.sync(parsed.command, {
           path: env[getPathKey({ env })],
-          pathExt: withoutPathExt ? path13.delimiter : void 0
+          pathExt: withoutPathExt ? path16.delimiter : void 0
         });
       } catch (e) {
       } finally {
@@ -307,7 +307,7 @@ var require_resolveCommand = __commonJS({
         }
       }
       if (resolved) {
-        resolved = path13.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+        resolved = path16.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
       }
       return resolved;
     }
@@ -361,8 +361,8 @@ var require_shebang_command = __commonJS({
       if (!match) {
         return null;
       }
-      const [path13, argument] = match[0].replace(/#! ?/, "").split(" ");
-      const binary = path13.split("/").pop();
+      const [path16, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path16.split("/").pop();
       if (binary === "env") {
         return argument;
       }
@@ -375,16 +375,16 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "node_modules/cross-spawn/lib/util/readShebang.js"(exports2, module2) {
     "use strict";
-    var fs10 = require("fs");
+    var fs13 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
       const buffer = Buffer.alloc(size);
       let fd;
       try {
-        fd = fs10.openSync(command, "r");
-        fs10.readSync(fd, buffer, 0, size, 0);
-        fs10.closeSync(fd);
+        fd = fs13.openSync(command, "r");
+        fs13.readSync(fd, buffer, 0, size, 0);
+        fs13.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -397,7 +397,7 @@ var require_readShebang = __commonJS({
 var require_parse = __commonJS({
   "node_modules/cross-spawn/lib/parse.js"(exports2, module2) {
     "use strict";
-    var path13 = require("path");
+    var path16 = require("path");
     var resolveCommand = require_resolveCommand();
     var escape = require_escape();
     var readShebang = require_readShebang();
@@ -422,7 +422,7 @@ var require_parse = __commonJS({
       const needsShell = !isExecutableRegExp.test(commandFile);
       if (parsed.options.forceShell || needsShell) {
         const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-        parsed.command = path13.normalize(parsed.command);
+        parsed.command = path16.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 spawn3(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 = spawn3;
-    module2.exports.spawn = spawn3;
+    module2.exports = spawn5;
+    module2.exports.spawn = spawn5;
     module2.exports.sync = spawnSync3;
     module2.exports._parse = parse;
     module2.exports._enoent = enoent;
@@ -538,9 +538,7 @@ __export(hook_stop_collab_exports, {
   runHookStopCollab: () => runHookStopCollab
 });
 module.exports = __toCommonJS(hook_stop_collab_exports);
-var import_node_child_process7 = require("child_process");
-var import_node_fs7 = require("fs");
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_child_process9 = require("child_process");
 
 // node_modules/@remixhq/core/dist/chunk-YZ34ICNN.js
 var RemixError = class extends Error {
@@ -4937,13 +4935,13 @@ var logOutputSync = ({ serializedResult, fdNumber, state, verboseInfo, encoding,
   }
 };
 var writeToFiles = (serializedResult, stdioItems, outputFiles) => {
-  for (const { path: path13, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
-    const pathString = typeof path13 === "string" ? path13 : path13.toString();
+  for (const { path: path16, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
+    const pathString = typeof path16 === "string" ? path16 : path16.toString();
     if (append || outputFiles.has(pathString)) {
-      (0, import_node_fs4.appendFileSync)(path13, serializedResult);
+      (0, import_node_fs4.appendFileSync)(path16, serializedResult);
     } else {
       outputFiles.add(pathString);
-      (0, import_node_fs4.writeFileSync)(path13, serializedResult);
+      (0, import_node_fs4.writeFileSync)(path16, serializedResult);
     }
   }
 };
@@ -10031,202 +10029,1059 @@ var FINALIZE_PREFLIGHT_FAILURE_CODES = [
   "re_anchor_required"
 ];
 var CODE_SET = new Set(FINALIZE_PREFLIGHT_FAILURE_CODES);
+function isFinalizePreflightFailureCode(value) {
+  return typeof value === "string" && CODE_SET.has(value);
+}
 
-// node_modules/@remixhq/core/dist/chunk-US5SM7ZC.js
-async function readJsonSafe(res) {
-  const ct = res.headers.get("content-type") ?? "";
-  if (!ct.toLowerCase().includes("application/json")) return null;
+// src/auto-fix-dispatcher.ts
+var import_node_child_process6 = require("child_process");
+var import_node_fs6 = require("fs");
+var import_node_path9 = __toESM(require("path"), 1);
+
+// src/finalize-failure-marker.ts
+var import_promises18 = __toESM(require("fs/promises"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var FINALIZE_FAILURE_MARKER_REL = import_node_path6.default.join(".remix", ".last-finalize-failure.json");
+function markerPath(repoRoot) {
+  return import_node_path6.default.join(repoRoot, FINALIZE_FAILURE_MARKER_REL);
+}
+async function writeFinalizeFailureMarker(marker) {
+  const filePath = markerPath(marker.repoRoot);
+  await import_promises18.default.mkdir(import_node_path6.default.dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  await import_promises18.default.writeFile(tmpPath, JSON.stringify(marker, null, 2), "utf8");
+  await import_promises18.default.rename(tmpPath, filePath);
+}
+async function clearFinalizeFailureMarker(repoRoot) {
+  await import_promises18.default.rm(markerPath(repoRoot), { force: true }).catch(() => void 0);
+}
+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_promises20 = __toESM(require("fs/promises"), 1);
+var import_node_os5 = __toESM(require("os"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
+
+// src/hook-state.ts
+var import_promises19 = __toESM(require("fs/promises"), 1);
+var import_node_os4 = __toESM(require("os"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
+var import_node_crypto = require("crypto");
+function stateRoot() {
+  const configured = process.env.REMIX_CLAUDE_PLUGIN_HOOK_STATE_ROOT?.trim();
+  return configured || import_node_path7.default.join(import_node_os4.default.tmpdir(), "remix-claude-plugin-hooks");
+}
+function statePath(sessionId) {
+  return import_node_path7.default.join(stateRoot(), `${sessionId}.json`);
+}
+function stateLockPath(sessionId) {
+  return import_node_path7.default.join(stateRoot(), `${sessionId}.lock`);
+}
+function stateLockMetaPath(sessionId) {
+  return import_node_path7.default.join(stateLockPath(sessionId), "owner.json");
+}
+async function writeJsonAtomic2(filePath, value) {
+  await import_promises19.default.mkdir(import_node_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);
+}
+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_promises19.default.readFile(stateLockMetaPath(sessionId), "utf8").catch(() => null);
+  if (!raw) return null;
   try {
-    return await res.json();
+    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;
   }
 }
-function createApiClient(config, opts) {
-  const apiKey = (opts?.apiKey ?? "").trim();
-  const tokenProvider = opts?.tokenProvider;
-  const CLIENT_KEY_HEADER = "x-comerge-api-key";
-  async function request(path13, init) {
-    if (!tokenProvider) {
-      throw new RemixError("API client is missing a token provider.", {
-        exitCode: 1,
-        hint: "Configure auth before creating the Remix API client."
-      });
+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_promises19.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+    return true;
+  }
+  if (!metadata) {
+    const lockStat = await import_promises19.default.stat(lockPath).catch(() => null);
+    if (lockStat && Date.now() - lockStat.mtimeMs > STATE_LOCK_STALE_MS) {
+      await import_promises19.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+      return true;
     }
-    const auth = await tokenProvider();
-    const url = new URL(path13, config.apiUrl).toString();
-    const doFetch = async (bearer) => fetch(url, {
-      ...init,
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json",
-        ...init?.headers ?? {},
-        Authorization: `Bearer ${bearer}`,
-        ...apiKey ? { [CLIENT_KEY_HEADER]: apiKey } : {}
+  }
+  return false;
+}
+async function acquireStateLock(sessionId) {
+  const lockPath = stateLockPath(sessionId);
+  const deadline = Date.now() + STATE_LOCK_WAIT_MS;
+  await import_promises19.default.mkdir(stateRoot(), { recursive: true });
+  while (true) {
+    try {
+      await import_promises19.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_promises19.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;
       }
-    });
-    let res = await doFetch(auth.token);
-    if (res.status === 401 && !auth.fromEnv && auth.session?.refresh_token) {
-      const refreshed = await tokenProvider({ forceRefresh: true });
-      res = await doFetch(refreshed.token);
-    }
-    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 });
+      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);
     }
-    const json = await readJsonSafe(res);
-    return json ?? null;
   }
-  async function requestBinary(path13, init) {
-    if (!tokenProvider) {
-      throw new RemixError("API client is missing a token provider.", {
-        exitCode: 1,
-        hint: "Configure auth before creating the Remix API client."
-      });
+}
+async function withStateLock(sessionId, fn) {
+  const release = await acquireStateLock(sessionId);
+  try {
+    return await fn();
+  } finally {
+    await release();
+  }
+}
+function normalizeIntent(value) {
+  return value === "memory_first" || value === "collab_state" || value === "git_facts" ? value : "neutral";
+}
+function normalizeString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return Array.from(
+    new Set(
+      value.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => entry.trim())
+    )
+  );
+}
+function normalizeManualRecordingScope(value) {
+  if (value === "full_turn") {
+    return "full_turn";
+  }
+  return null;
+}
+function normalizeTouchedRepo(value, repoRoot) {
+  if (!value || typeof value !== "object") return null;
+  const parsed = value;
+  const normalizedRepoRoot = normalizeString(parsed.repoRoot) ?? repoRoot.trim();
+  if (!normalizedRepoRoot) return null;
+  return {
+    repoRoot: normalizedRepoRoot,
+    projectId: normalizeString(parsed.projectId),
+    currentAppId: normalizeString(parsed.currentAppId),
+    upstreamAppId: normalizeString(parsed.upstreamAppId),
+    firstTouchedAt: normalizeString(parsed.firstTouchedAt) ?? (/* @__PURE__ */ new Date()).toISOString(),
+    lastTouchedAt: normalizeString(parsed.lastTouchedAt) ?? (/* @__PURE__ */ new Date()).toISOString(),
+    lastObservedWriteAt: normalizeString(parsed.lastObservedWriteAt),
+    touchedBy: normalizeStringArray(parsed.touchedBy),
+    hasObservedWrite: Boolean(parsed.hasObservedWrite),
+    manuallyRecorded: Boolean(parsed.manuallyRecorded),
+    manuallyRecordedAt: normalizeString(parsed.manuallyRecordedAt),
+    manuallyRecordedByTool: normalizeString(parsed.manuallyRecordedByTool),
+    manualRecordingScope: normalizeManualRecordingScope(parsed.manualRecordingScope),
+    manualRemoteChangeRecordedAt: normalizeString(parsed.manualRemoteChangeRecordedAt),
+    stopAttempted: Boolean(parsed.stopAttempted),
+    stopRecorded: Boolean(parsed.stopRecorded),
+    stopRecordedAt: normalizeString(parsed.stopRecordedAt),
+    stopRecordedMode: parsed.stopRecordedMode === "changed_turn" || parsed.stopRecordedMode === "no_diff_turn" ? parsed.stopRecordedMode : null,
+    recordingFailureMessage: normalizeString(parsed.recordingFailureMessage),
+    recordingFailureHint: normalizeString(parsed.recordingFailureHint),
+    recordingFailedAt: normalizeString(parsed.recordingFailedAt)
+  };
+}
+function normalizeTouchedRepos(value) {
+  if (!value || typeof value !== "object") return {};
+  const entries = Object.entries(value).map(([repoRoot, repo]) => normalizeTouchedRepo(repo, repoRoot)).filter((repo) => repo !== null).sort((a2, b) => a2.repoRoot.localeCompare(b.repoRoot));
+  return Object.fromEntries(entries.map((repo) => [repo.repoRoot, repo]));
+}
+function createTouchedRepo(params) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const touchedBy = params.touchedBy?.trim() ? [params.touchedBy.trim()] : [];
+  return {
+    repoRoot: params.repoRoot,
+    projectId: normalizeString(params.projectId),
+    currentAppId: normalizeString(params.currentAppId),
+    upstreamAppId: normalizeString(params.upstreamAppId),
+    firstTouchedAt: now,
+    lastTouchedAt: now,
+    lastObservedWriteAt: params.hasObservedWrite ? now : null,
+    touchedBy,
+    hasObservedWrite: Boolean(params.hasObservedWrite),
+    manuallyRecorded: false,
+    manuallyRecordedAt: null,
+    manuallyRecordedByTool: null,
+    manualRecordingScope: null,
+    manualRemoteChangeRecordedAt: null,
+    stopAttempted: false,
+    stopRecorded: false,
+    stopRecordedAt: null,
+    stopRecordedMode: null,
+    recordingFailureMessage: null,
+    recordingFailureHint: null,
+    recordingFailedAt: null
+  };
+}
+async function updatePendingTurnState(sessionId, updater) {
+  return withStateLock(sessionId, async () => {
+    const existing = await loadPendingTurnState(sessionId);
+    if (!existing) return null;
+    const result = updater(existing);
+    if (result === false) return existing;
+    await savePendingTurnState(existing);
+    return existing;
+  });
+}
+async function loadPendingTurnState(sessionId) {
+  const raw = await import_promises19.default.readFile(statePath(sessionId), "utf8").catch(() => null);
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    if (typeof parsed.sessionId !== "string" || typeof parsed.turnId !== "string" || typeof parsed.prompt !== "string") {
+      return null;
     }
-    const auth = await tokenProvider();
-    const url = new URL(path13, config.apiUrl).toString();
-    const doFetch = async (bearer) => fetch(url, {
-      ...init,
-      headers: {
-        Accept: "*/*",
-        ...init?.headers ?? {},
-        Authorization: `Bearer ${bearer}`,
-        ...apiKey ? { [CLIENT_KEY_HEADER]: apiKey } : {}
-      }
+    return {
+      sessionId: parsed.sessionId,
+      turnId: parsed.turnId,
+      prompt: parsed.prompt,
+      initialCwd: normalizeString(parsed.initialCwd),
+      intent: normalizeIntent(parsed.intent),
+      submittedAt: typeof parsed.submittedAt === "string" ? parsed.submittedAt : (/* @__PURE__ */ new Date()).toISOString(),
+      consultedMemory: Boolean(parsed.consultedMemory),
+      touchedRepos: normalizeTouchedRepos(parsed.touchedRepos),
+      turnFailureMessage: normalizeString(parsed.turnFailureMessage),
+      turnFailureHint: normalizeString(parsed.turnFailureHint),
+      turnFailedAt: normalizeString(parsed.turnFailedAt)
+    };
+  } catch {
+    return null;
+  }
+}
+async function savePendingTurnState(state) {
+  await writeJsonAtomic2(statePath(state.sessionId), state);
+}
+async function upsertTouchedRepo(sessionId, params) {
+  const normalizedRepoRoot = params.repoRoot.trim();
+  if (!normalizedRepoRoot) return null;
+  const state = await updatePendingTurnState(sessionId, (existing) => {
+    const current = existing.touchedRepos[normalizedRepoRoot] ?? createTouchedRepo({
+      repoRoot: normalizedRepoRoot,
+      projectId: params.projectId,
+      currentAppId: params.currentAppId,
+      upstreamAppId: params.upstreamAppId,
+      touchedBy: params.touchedBy,
+      hasObservedWrite: params.hasObservedWrite
     });
-    let res = await doFetch(auth.token);
-    if (res.status === 401 && !auth.fromEnv && auth.session?.refresh_token) {
-      const refreshed = await tokenProvider({ forceRefresh: true });
-      res = await doFetch(refreshed.token);
+    current.projectId = normalizeString(params.projectId) ?? current.projectId;
+    current.currentAppId = normalizeString(params.currentAppId) ?? current.currentAppId;
+    current.upstreamAppId = normalizeString(params.upstreamAppId) ?? current.upstreamAppId;
+    current.lastTouchedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (params.touchedBy?.trim() && !current.touchedBy.includes(params.touchedBy.trim())) {
+      current.touchedBy = [...current.touchedBy, params.touchedBy.trim()].sort((a2, b) => a2.localeCompare(b));
     }
-    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 });
+    if (params.hasObservedWrite) {
+      current.hasObservedWrite = true;
+      current.lastObservedWriteAt = (/* @__PURE__ */ new Date()).toISOString();
     }
-    const contentDisposition = res.headers.get("content-disposition") ?? "";
-    const fileNameMatch = contentDisposition.match(/filename=\"([^\"]+)\"/i);
-    return {
-      data: Buffer.from(await res.arrayBuffer()),
-      fileName: fileNameMatch?.[1] ?? null,
-      contentType: res.headers.get("content-type")
-    };
+    existing.touchedRepos[normalizedRepoRoot] = current;
+  });
+  return state?.touchedRepos[normalizedRepoRoot] ?? null;
+}
+async function markTouchedRepoStopAttempted(sessionId, repoRoot) {
+  await updatePendingTurnState(sessionId, (existing) => {
+    const current = existing.touchedRepos[repoRoot];
+    if (!current) return false;
+    current.stopAttempted = true;
+    current.lastTouchedAt = (/* @__PURE__ */ new Date()).toISOString();
+  });
+}
+async function markTouchedRepoStopRecorded(sessionId, repoRoot, params) {
+  await updatePendingTurnState(sessionId, (existing) => {
+    const current = existing.touchedRepos[repoRoot];
+    if (!current) return false;
+    current.stopAttempted = true;
+    current.stopRecorded = true;
+    current.stopRecordedAt = (/* @__PURE__ */ new Date()).toISOString();
+    current.stopRecordedMode = params.mode;
+    current.recordingFailureMessage = null;
+    current.recordingFailureHint = null;
+    current.recordingFailedAt = null;
+    current.lastTouchedAt = (/* @__PURE__ */ new Date()).toISOString();
+  });
+}
+async function markTouchedRepoRecordingFailure(sessionId, repoRoot, params) {
+  await updatePendingTurnState(sessionId, (existing) => {
+    const current = existing.touchedRepos[repoRoot];
+    if (!current) return false;
+    current.stopAttempted = true;
+    current.recordingFailureMessage = params.message.trim();
+    current.recordingFailureHint = params.hint?.trim() || null;
+    current.recordingFailedAt = (/* @__PURE__ */ new Date()).toISOString();
+    current.lastTouchedAt = (/* @__PURE__ */ new Date()).toISOString();
+  });
+}
+function lastFinalizedPath(sessionId) {
+  return import_node_path7.default.join(stateRoot(), `${sessionId}.last-finalized.json`);
+}
+async function markLastFinalizedTurn(sessionId, turnId, prompt) {
+  const record = {
+    sessionId,
+    turnId,
+    prompt,
+    finalizedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeJsonAtomic2(lastFinalizedPath(sessionId), record);
+}
+async function loadLastFinalizedTurn(sessionId) {
+  const raw = await import_promises19.default.readFile(lastFinalizedPath(sessionId), "utf8").catch(() => null);
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.sessionId === "string" && typeof parsed.turnId === "string" && typeof parsed.prompt === "string" && typeof parsed.finalizedAt === "string") {
+      return {
+        sessionId: parsed.sessionId,
+        turnId: parsed.turnId,
+        prompt: parsed.prompt,
+        finalizedAt: parsed.finalizedAt
+      };
+    }
+    return null;
+  } catch {
+    return null;
   }
-  return {
-    getMe: () => request("/v1/me", { method: "GET" }),
-    listOrganizations: () => request("/v1/organizations", { method: "GET" }),
-    getOrganization: (orgId) => request(`/v1/organizations/${encodeURIComponent(orgId)}`, { method: "GET" }),
-    listProjects: (params) => {
-      const qs = new URLSearchParams();
-      if (params?.organizationId) qs.set("organizationId", params.organizationId);
-      if (params?.clientAppId) qs.set("clientAppId", params.clientAppId);
-      const suffix = qs.toString() ? `?${qs.toString()}` : "";
-      return request(`/v1/projects${suffix}`, { method: "GET" });
-    },
-    getProject: (projectId) => request(`/v1/projects/${encodeURIComponent(projectId)}`, { method: "GET" }),
-    resolveProjectBinding: (params) => {
-      const qs = new URLSearchParams();
-      if (params.repoFingerprint) qs.set("repoFingerprint", params.repoFingerprint);
-      if (params.remoteUrl) qs.set("remoteUrl", params.remoteUrl);
-      if (params.branchName) qs.set("branchName", params.branchName);
-      return request(`/v1/projects/bindings/resolve?${qs.toString()}`, { method: "GET" });
-    },
-    resolveProjectLaneBinding: (params) => {
-      const qs = new URLSearchParams();
-      if (params.projectId) qs.set("projectId", params.projectId);
-      if (params.repoFingerprint) qs.set("repoFingerprint", params.repoFingerprint);
-      if (params.remoteUrl) qs.set("remoteUrl", params.remoteUrl);
-      if (params.defaultBranch) qs.set("defaultBranch", params.defaultBranch);
-      qs.set("branchName", params.branchName);
-      return request(`/v1/projects/bindings/resolve-lane?${qs.toString()}`, { method: "GET" });
-    },
-    ensureProjectLaneBinding: (payload) => request("/v1/projects/bindings/ensure-lane", { method: "POST", body: JSON.stringify(payload) }),
-    bootstrapFreshProjectLane: (payload) => request("/v1/projects/bindings/bootstrap-fresh-lane", { method: "POST", body: JSON.stringify(payload) }),
-    autoEnableDeveloper: () => request("/v1/developer/auto-enable", { method: "POST" }),
-    listClientApps: (params) => {
-      const qs = params?.orgId ? `?orgId=${encodeURIComponent(params.orgId)}` : "";
-      return request(`/v1/developer/client-apps${qs}`, { method: "GET" });
-    },
-    createClientApp: (payload) => request("/v1/developer/client-apps", { method: "POST", body: JSON.stringify(payload) }),
-    createClientAppKey: (clientAppId, payload) => request(`/v1/developer/client-apps/${encodeURIComponent(clientAppId)}/keys`, {
-      method: "POST",
-      body: JSON.stringify(payload ?? {})
-    }),
-    listApps: (params) => {
-      const qs = new URLSearchParams();
-      if (params?.projectId) qs.set("projectId", params.projectId);
-      if (params?.organizationId) qs.set("organizationId", params.organizationId);
-      if (params?.ownership) qs.set("ownership", params.ownership);
-      if (params?.accessScope) qs.set("accessScope", params.accessScope);
-      if (params?.createdBy) qs.set("createdBy", params.createdBy);
-      if (params?.forked) qs.set("forked", params.forked);
-      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
-      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
-      const suffix = qs.toString() ? `?${qs.toString()}` : "";
-      return request(`/v1/apps${suffix}`, { method: "GET" });
-    },
-    getApp: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}`, { method: "GET" }),
-    getAppContext: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/context`, { method: "GET" }),
-    getAppOverview: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/overview`, { method: "GET" }),
-    listAppTimeline: (appId, params) => {
-      const qs = new URLSearchParams();
-      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
-      if (params?.cursor) qs.set("cursor", params.cursor);
-      const suffix = qs.toString() ? `?${qs.toString()}` : "";
-      return request(`/v1/apps/${encodeURIComponent(appId)}/timeline${suffix}`, { method: "GET" });
-    },
-    getAppTimelineEvent: (appId, eventId) => request(`/v1/apps/${encodeURIComponent(appId)}/timeline/${encodeURIComponent(eventId)}`, { method: "GET" }),
-    listAppEditQueue: (appId, params) => {
-      const qs = new URLSearchParams();
-      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
-      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
-      const suffix = qs.toString() ? `?${qs.toString()}` : "";
-      return request(`/v1/apps/${encodeURIComponent(appId)}/edit-queue${suffix}`, { method: "GET" });
-    },
-    listAppJobQueue: (appId, params) => {
-      const qs = new URLSearchParams();
-      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
-      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
-      for (const kind of params?.kind ?? []) qs.append("kind", kind);
-      for (const status of params?.status ?? []) qs.append("status", status);
-      const suffix = qs.toString() ? `?${qs.toString()}` : "";
-      return request(`/v1/apps/${encodeURIComponent(appId)}/job-queue${suffix}`, { method: "GET" });
-    },
-    getMergeRequest: (mrId) => request(`/v1/merge-requests/${encodeURIComponent(mrId)}`, { method: "GET" }),
-    presignImportUpload: (payload) => request("/v1/apps/import/upload/presign", { method: "POST", body: JSON.stringify(payload) }),
-    importFromUpload: (payload) => request("/v1/apps/import/upload", { method: "POST", body: JSON.stringify(payload) }),
-    presignImportUploadFirstParty: (payload) => request("/v1/apps/import/upload/presign/first-party", { method: "POST", body: JSON.stringify(payload) }),
-    importFromUploadFirstParty: (payload) => request("/v1/apps/import/upload/first-party", { method: "POST", body: JSON.stringify(payload) }),
-    importFromGithubFirstParty: (payload) => request("/v1/apps/import/github/first-party", { method: "POST", body: JSON.stringify(payload) }),
-    forkApp: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/fork`, { method: "POST", body: JSON.stringify(payload ?? {}) }),
-    getAppHead: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/head`, { method: "GET" }),
-    getAppDelta: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/delta`, {
-      method: "POST",
-      body: JSON.stringify(payload)
-    }),
-    downloadAppBundle: (appId) => requestBinary(`/v1/apps/${encodeURIComponent(appId)}/download.bundle`, { method: "GET" }),
-    createChangeStep: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps`, {
-      method: "POST",
-      body: JSON.stringify(payload)
-    }),
-    createCollabTurn: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/collab-turns`, {
-      method: "POST",
-      body: JSON.stringify(payload)
-    }),
-    attachCollabTurnUsage: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/collab-turns/attach-usage`, {
-      method: "POST",
-      body: JSON.stringify(payload)
-    }),
-    listCollabTurns: (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?.changeStepId) qs.set("changeStepId", params.changeStepId);
-      if (params?.threadId) qs.set("threadId", params.threadId);
-      if (params?.collabLaneId) qs.set("collabLaneId", params.collabLaneId);
-      if (params?.createdAfter) qs.set("createdAfter", params.createdAfter);
+}
+async function markPendingTurnFailure(sessionId, params) {
+  await updatePendingTurnState(sessionId, (existing) => {
+    existing.turnFailureMessage = params.message.trim();
+    existing.turnFailureHint = params.hint?.trim() || null;
+    existing.turnFailedAt = (/* @__PURE__ */ new Date()).toISOString();
+  });
+}
+async function listTouchedRepos(sessionId) {
+  const existing = await loadPendingTurnState(sessionId);
+  if (!existing) return [];
+  return Object.values(existing.touchedRepos).sort((a2, b) => a2.repoRoot.localeCompare(b.repoRoot));
+}
+async function clearPendingTurnState(sessionId) {
+  await withStateLock(sessionId, async () => {
+    await import_promises19.default.rm(statePath(sessionId), { force: true }).catch(() => void 0);
+  });
+}
+
+// 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_os5.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_promises20.default.stat(logPath).catch(() => null);
+  if (!stat || stat.size < MAX_LOG_BYTES) {
+    return;
+  }
+  const rotatedPath = `${logPath}.1`;
+  await import_promises20.default.rm(rotatedPath, { force: true }).catch(() => void 0);
+  await import_promises20.default.rename(logPath, rotatedPath).catch(() => void 0);
+}
+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_promises20.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_promises20.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"],
+  // External base diverged. Re-anchor declares the new local state as
+  // truth. Risky if the user hard-reset to the wrong commit, but the
+  // worst case is "Remix forgets the previous anchor" — recorded turns
+  // are preserved on the server, so this is recoverable.
+  re_anchor_required: ["collab", "re-anchor"],
+  // 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"]
+};
+function isAutoFixableFinalizeFailureCode(code) {
+  return Boolean(code && AUTO_FIX_COMMAND[code]);
+}
+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",
+  re_anchor_required: "remix collab re-anchor"
+};
+var SPAWN_LOCK_REL = (cmdSlug) => import_node_path9.default.join(".remix", `.${cmdSlug}-spawning`);
+var SPAWN_LOG_REL = (cmdSlug) => import_node_path9.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_path9.default.join(repoRoot, ".remix");
+  const lockPath = import_node_path9.default.join(repoRoot, SPAWN_LOCK_REL(slug));
+  const logPath = import_node_path9.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;
+}
+
+// src/deferred-turn-queue.ts
+var import_promises21 = __toESM(require("fs/promises"), 1);
+var import_node_os6 = __toESM(require("os"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
+var DEFERRED_TURN_SCHEMA_VERSION = 1;
+var DEFERRED_TURN_TTL_MS = 24 * 60 * 60 * 1e3;
+var DEFERRED_TURN_DIR = "deferred-turns";
+function stateRoot2() {
+  const configured = process.env.REMIX_CLAUDE_PLUGIN_HOOK_STATE_ROOT?.trim();
+  return configured || import_node_path10.default.join(import_node_os6.default.tmpdir(), "remix-claude-plugin-hooks");
+}
+function getDeferredTurnDirPath() {
+  return import_node_path10.default.join(stateRoot2(), 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_path10.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_promises21.default.mkdir(dir, { recursive: true });
+  const filePath = getDeferredTurnFilePath(record.sessionId, record.turnId);
+  const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  await import_promises21.default.writeFile(tmpPath, JSON.stringify(record), "utf8");
+  await import_promises21.default.rename(tmpPath, filePath);
+  return filePath;
+}
+async function readDeferredTurnFile(filePath) {
+  const raw = await import_promises21.default.readFile(filePath, "utf8").catch(() => null);
+  if (!raw) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  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") {
+    return null;
+  }
+  return {
+    schemaVersion: DEFERRED_TURN_SCHEMA_VERSION,
+    sessionId: record.sessionId,
+    turnId: record.turnId,
+    repoRoot: record.repoRoot,
+    prompt: record.prompt,
+    assistantResponse: record.assistantResponse,
+    submittedAt: record.submittedAt,
+    deferredAt: record.deferredAt,
+    reason: record.reason,
+    branchAtDefer: typeof record.branchAtDefer === "string" || record.branchAtDefer === null ? record.branchAtDefer : null
+  };
+}
+async function listDeferredTurnsForRepo(repoRoot) {
+  const dir = getDeferredTurnDirPath();
+  const dirEntries = await import_promises21.default.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const entries = [];
+  for (const entry of dirEntries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    const filePath = import_node_path10.default.join(dir, entry.name);
+    const record = await readDeferredTurnFile(filePath);
+    if (!record) continue;
+    if (record.repoRoot !== repoRoot) continue;
+    entries.push({ filePath, record });
+  }
+  entries.sort((a2, b) => {
+    const aMs = Date.parse(a2.record.submittedAt);
+    const bMs = Date.parse(b.record.submittedAt);
+    if (Number.isFinite(aMs) && Number.isFinite(bMs)) return aMs - bMs;
+    return 0;
+  });
+  return entries;
+}
+async function deleteDeferredTurnFile(filePath) {
+  await import_promises21.default.rm(filePath, { force: true }).catch(() => void 0);
+}
+async function pruneStaleDeferredTurns(maxAgeMs = DEFERRED_TURN_TTL_MS) {
+  const dir = getDeferredTurnDirPath();
+  const dirEntries = await import_promises21.default.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const pruned = [];
+  const now = Date.now();
+  for (const entry of dirEntries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    const filePath = import_node_path10.default.join(dir, entry.name);
+    const record = await readDeferredTurnFile(filePath);
+    if (!record) {
+      const stat = await import_promises21.default.stat(filePath).catch(() => null);
+      if (stat && now - stat.mtimeMs > maxAgeMs) {
+        await deleteDeferredTurnFile(filePath);
+        pruned.push(filePath);
+      }
+      continue;
+    }
+    const deferredAtMs = Date.parse(record.deferredAt);
+    if (!Number.isFinite(deferredAtMs)) continue;
+    if (now - deferredAtMs > maxAgeMs) {
+      await deleteDeferredTurnFile(filePath);
+      pruned.push(filePath);
+    }
+  }
+  return pruned;
+}
+function buildDeferredTurnRecord(params) {
+  return {
+    schemaVersion: DEFERRED_TURN_SCHEMA_VERSION,
+    sessionId: params.sessionId,
+    turnId: params.turnId,
+    repoRoot: params.repoRoot,
+    prompt: params.prompt,
+    assistantResponse: params.assistantResponse,
+    submittedAt: params.submittedAt,
+    deferredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    reason: params.reason ?? "current_branch_unbound",
+    branchAtDefer: params.branchAtDefer
+  };
+}
+
+// src/deferred-turn-drainer.ts
+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/chunk-US5SM7ZC.js
+async function readJsonSafe(res) {
+  const ct = res.headers.get("content-type") ?? "";
+  if (!ct.toLowerCase().includes("application/json")) return null;
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+function createApiClient(config, opts) {
+  const apiKey = (opts?.apiKey ?? "").trim();
+  const tokenProvider = opts?.tokenProvider;
+  const CLIENT_KEY_HEADER = "x-comerge-api-key";
+  async function request(path16, init) {
+    if (!tokenProvider) {
+      throw new RemixError("API client is missing a token provider.", {
+        exitCode: 1,
+        hint: "Configure auth before creating the Remix API client."
+      });
+    }
+    const auth = await tokenProvider();
+    const url = new URL(path16, config.apiUrl).toString();
+    const doFetch = async (bearer) => fetch(url, {
+      ...init,
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        ...init?.headers ?? {},
+        Authorization: `Bearer ${bearer}`,
+        ...apiKey ? { [CLIENT_KEY_HEADER]: apiKey } : {}
+      }
+    });
+    let res = await doFetch(auth.token);
+    if (res.status === 401 && !auth.fromEnv && auth.session?.refresh_token) {
+      const refreshed = await tokenProvider({ forceRefresh: true });
+      res = await doFetch(refreshed.token);
+    }
+    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 });
+    }
+    const json = await readJsonSafe(res);
+    return json ?? null;
+  }
+  async function requestBinary(path16, init) {
+    if (!tokenProvider) {
+      throw new RemixError("API client is missing a token provider.", {
+        exitCode: 1,
+        hint: "Configure auth before creating the Remix API client."
+      });
+    }
+    const auth = await tokenProvider();
+    const url = new URL(path16, config.apiUrl).toString();
+    const doFetch = async (bearer) => fetch(url, {
+      ...init,
+      headers: {
+        Accept: "*/*",
+        ...init?.headers ?? {},
+        Authorization: `Bearer ${bearer}`,
+        ...apiKey ? { [CLIENT_KEY_HEADER]: apiKey } : {}
+      }
+    });
+    let res = await doFetch(auth.token);
+    if (res.status === 401 && !auth.fromEnv && auth.session?.refresh_token) {
+      const refreshed = await tokenProvider({ forceRefresh: true });
+      res = await doFetch(refreshed.token);
+    }
+    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 });
+    }
+    const contentDisposition = res.headers.get("content-disposition") ?? "";
+    const fileNameMatch = contentDisposition.match(/filename=\"([^\"]+)\"/i);
+    return {
+      data: Buffer.from(await res.arrayBuffer()),
+      fileName: fileNameMatch?.[1] ?? null,
+      contentType: res.headers.get("content-type")
+    };
+  }
+  return {
+    getMe: () => request("/v1/me", { method: "GET" }),
+    listOrganizations: () => request("/v1/organizations", { method: "GET" }),
+    getOrganization: (orgId) => request(`/v1/organizations/${encodeURIComponent(orgId)}`, { method: "GET" }),
+    listProjects: (params) => {
+      const qs = new URLSearchParams();
+      if (params?.organizationId) qs.set("organizationId", params.organizationId);
+      if (params?.clientAppId) qs.set("clientAppId", params.clientAppId);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/projects${suffix}`, { method: "GET" });
+    },
+    getProject: (projectId) => request(`/v1/projects/${encodeURIComponent(projectId)}`, { method: "GET" }),
+    resolveProjectBinding: (params) => {
+      const qs = new URLSearchParams();
+      if (params.repoFingerprint) qs.set("repoFingerprint", params.repoFingerprint);
+      if (params.remoteUrl) qs.set("remoteUrl", params.remoteUrl);
+      if (params.branchName) qs.set("branchName", params.branchName);
+      return request(`/v1/projects/bindings/resolve?${qs.toString()}`, { method: "GET" });
+    },
+    resolveProjectLaneBinding: (params) => {
+      const qs = new URLSearchParams();
+      if (params.projectId) qs.set("projectId", params.projectId);
+      if (params.repoFingerprint) qs.set("repoFingerprint", params.repoFingerprint);
+      if (params.remoteUrl) qs.set("remoteUrl", params.remoteUrl);
+      if (params.defaultBranch) qs.set("defaultBranch", params.defaultBranch);
+      qs.set("branchName", params.branchName);
+      return request(`/v1/projects/bindings/resolve-lane?${qs.toString()}`, { method: "GET" });
+    },
+    ensureProjectLaneBinding: (payload) => request("/v1/projects/bindings/ensure-lane", { method: "POST", body: JSON.stringify(payload) }),
+    bootstrapFreshProjectLane: (payload) => request("/v1/projects/bindings/bootstrap-fresh-lane", { method: "POST", body: JSON.stringify(payload) }),
+    autoEnableDeveloper: () => request("/v1/developer/auto-enable", { method: "POST" }),
+    listClientApps: (params) => {
+      const qs = params?.orgId ? `?orgId=${encodeURIComponent(params.orgId)}` : "";
+      return request(`/v1/developer/client-apps${qs}`, { method: "GET" });
+    },
+    createClientApp: (payload) => request("/v1/developer/client-apps", { method: "POST", body: JSON.stringify(payload) }),
+    createClientAppKey: (clientAppId, payload) => request(`/v1/developer/client-apps/${encodeURIComponent(clientAppId)}/keys`, {
+      method: "POST",
+      body: JSON.stringify(payload ?? {})
+    }),
+    listApps: (params) => {
+      const qs = new URLSearchParams();
+      if (params?.projectId) qs.set("projectId", params.projectId);
+      if (params?.organizationId) qs.set("organizationId", params.organizationId);
+      if (params?.ownership) qs.set("ownership", params.ownership);
+      if (params?.accessScope) qs.set("accessScope", params.accessScope);
+      if (params?.createdBy) qs.set("createdBy", params.createdBy);
+      if (params?.forked) qs.set("forked", params.forked);
+      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
+      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps${suffix}`, { method: "GET" });
+    },
+    getApp: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}`, { method: "GET" }),
+    getAppContext: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/context`, { method: "GET" }),
+    getAppOverview: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/overview`, { method: "GET" }),
+    listAppTimeline: (appId, params) => {
+      const qs = new URLSearchParams();
+      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
+      if (params?.cursor) qs.set("cursor", params.cursor);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/timeline${suffix}`, { method: "GET" });
+    },
+    getAppTimelineEvent: (appId, eventId) => request(`/v1/apps/${encodeURIComponent(appId)}/timeline/${encodeURIComponent(eventId)}`, { method: "GET" }),
+    listAppEditQueue: (appId, params) => {
+      const qs = new URLSearchParams();
+      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
+      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/edit-queue${suffix}`, { method: "GET" });
+    },
+    listAppJobQueue: (appId, params) => {
+      const qs = new URLSearchParams();
+      if (typeof params?.limit === "number") qs.set("limit", String(params.limit));
+      if (typeof params?.offset === "number") qs.set("offset", String(params.offset));
+      for (const kind of params?.kind ?? []) qs.append("kind", kind);
+      for (const status of params?.status ?? []) qs.append("status", status);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/job-queue${suffix}`, { method: "GET" });
+    },
+    getMergeRequest: (mrId) => request(`/v1/merge-requests/${encodeURIComponent(mrId)}`, { method: "GET" }),
+    presignImportUpload: (payload) => request("/v1/apps/import/upload/presign", { method: "POST", body: JSON.stringify(payload) }),
+    importFromUpload: (payload) => request("/v1/apps/import/upload", { method: "POST", body: JSON.stringify(payload) }),
+    presignImportUploadFirstParty: (payload) => request("/v1/apps/import/upload/presign/first-party", { method: "POST", body: JSON.stringify(payload) }),
+    importFromUploadFirstParty: (payload) => request("/v1/apps/import/upload/first-party", { method: "POST", body: JSON.stringify(payload) }),
+    importFromGithubFirstParty: (payload) => request("/v1/apps/import/github/first-party", { method: "POST", body: JSON.stringify(payload) }),
+    forkApp: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/fork`, { method: "POST", body: JSON.stringify(payload ?? {}) }),
+    getAppHead: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/head`, { method: "GET" }),
+    getAppDelta: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/delta`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    downloadAppBundle: (appId) => requestBinary(`/v1/apps/${encodeURIComponent(appId)}/download.bundle`, { method: "GET" }),
+    createChangeStep: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    createCollabTurn: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/collab-turns`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    attachCollabTurnUsage: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/collab-turns/attach-usage`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    listCollabTurns: (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?.changeStepId) qs.set("changeStepId", params.changeStepId);
+      if (params?.threadId) qs.set("threadId", params.threadId);
+      if (params?.collabLaneId) qs.set("collabLaneId", params.collabLaneId);
+      if (params?.createdAfter) qs.set("createdAfter", params.createdAfter);
       if (params?.createdBefore) qs.set("createdBefore", params.createdBefore);
       const suffix = qs.toString() ? `?${qs.toString()}` : "";
       return request(`/v1/apps/${encodeURIComponent(appId)}/collab-turns${suffix}`, { method: "GET" });
@@ -10936,8 +11791,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path13, errorMaps, issueData } = params;
-  const fullPath = [...path13, ...issueData.path || []];
+  const { data, path: path16, errorMaps, issueData } = params;
+  const fullPath = [...path16, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -11053,11 +11908,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path13, key) {
+  constructor(parent, value, path16, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path13;
+    this._path = path16;
     this._key = key;
   }
   get path() {
@@ -14500,7 +15355,7 @@ var coerce = {
 var NEVER = INVALID;
 
 // node_modules/@remixhq/core/dist/chunk-P6JHXOV4.js
-var import_promises18 = __toESM(require("fs/promises"), 1);
+var import_promises22 = __toESM(require("fs/promises"), 1);
 var import_os3 = __toESM(require("os"), 1);
 var import_path7 = __toESM(require("path"), 1);
 
@@ -14908,7 +15763,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();
@@ -15104,7 +15959,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;
@@ -15115,7 +15970,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);
@@ -23605,8 +24460,8 @@ var IcebergError = class extends Error {
     return this.status === 419;
   }
 };
-function buildUrl(baseUrl, path13, query) {
-  const url = new URL(path13, baseUrl);
+function buildUrl(baseUrl, path16, query) {
+  const url = new URL(path16, baseUrl);
   if (query) {
     for (const [key, value] of Object.entries(query)) {
       if (value !== void 0) {
@@ -23636,12 +24491,12 @@ function createFetchClient(options) {
   return {
     async request({
       method,
-      path: path13,
+      path: path16,
       query,
       body,
       headers
     }) {
-      const url = buildUrl(options.baseUrl, path13, query);
+      const url = buildUrl(options.baseUrl, path16, query);
       const authHeaders = await buildAuthHeaders(options.auth);
       const res = await fetchFn(url, {
         method,
@@ -24479,7 +25334,7 @@ var StorageFileApi = class extends BaseApiClient {
   * @param path The relative file path. Should be of the format `folder/subfolder/filename.png`. The bucket must already exist before attempting to upload.
   * @param fileBody The body of the file to be stored in the bucket.
   */
-  async uploadOrUpdate(method, path13, fileBody, fileOptions) {
+  async uploadOrUpdate(method, path16, fileBody, fileOptions) {
     var _this = this;
     return _this.handleOperation(async () => {
       let body;
@@ -24503,7 +25358,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(path13);
+      const cleanPath = _this._removeEmptyFolders(path16);
       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 {
@@ -24564,8 +25419,8 @@ var StorageFileApi = class extends BaseApiClient {
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   * - For React Native, using either `Blob`, `File` or `FormData` does not work as intended. Upload file using `ArrayBuffer` from base64 file data instead, see example below.
   */
-  async upload(path13, fileBody, fileOptions) {
-    return this.uploadOrUpdate("POST", path13, fileBody, fileOptions);
+  async upload(path16, fileBody, fileOptions) {
+    return this.uploadOrUpdate("POST", path16, fileBody, fileOptions);
   }
   /**
   * Upload a file with a token generated from `createSignedUploadUrl`.
@@ -24604,9 +25459,9 @@ var StorageFileApi = class extends BaseApiClient {
   *   - `objects` table permissions: none
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   */
-  async uploadToSignedUrl(path13, token, fileBody, fileOptions) {
+  async uploadToSignedUrl(path16, token, fileBody, fileOptions) {
     var _this3 = this;
-    const cleanPath = _this3._removeEmptyFolders(path13);
+    const cleanPath = _this3._removeEmptyFolders(path16);
     const _path = _this3._getFinalPath(cleanPath);
     const url = new URL(_this3.url + `/object/upload/sign/${_path}`);
     url.searchParams.set("token", token);
@@ -24668,10 +25523,10 @@ var StorageFileApi = class extends BaseApiClient {
   *   - `objects` table permissions: `insert`
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   */
-  async createSignedUploadUrl(path13, options) {
+  async createSignedUploadUrl(path16, options) {
     var _this4 = this;
     return _this4.handleOperation(async () => {
-      let _path = _this4._getFinalPath(path13);
+      let _path = _this4._getFinalPath(path16);
       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 });
@@ -24680,7 +25535,7 @@ var StorageFileApi = class extends BaseApiClient {
       if (!token) throw new StorageError("No token returned by API");
       return {
         signedUrl: url.toString(),
-        path: path13,
+        path: path16,
         token
       };
     });
@@ -24736,8 +25591,8 @@ var StorageFileApi = class extends BaseApiClient {
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   * - For React Native, using either `Blob`, `File` or `FormData` does not work as intended. Update file using `ArrayBuffer` from base64 file data instead, see example below.
   */
-  async update(path13, fileBody, fileOptions) {
-    return this.uploadOrUpdate("PUT", path13, fileBody, fileOptions);
+  async update(path16, fileBody, fileOptions) {
+    return this.uploadOrUpdate("PUT", path16, fileBody, fileOptions);
   }
   /**
   * Moves an existing file to a new path in the same bucket.
@@ -24885,10 +25740,10 @@ var StorageFileApi = class extends BaseApiClient {
   *   - `objects` table permissions: `select`
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   */
-  async createSignedUrl(path13, expiresIn, options) {
+  async createSignedUrl(path16, expiresIn, options) {
     var _this8 = this;
     return _this8.handleOperation(async () => {
-      let _path = _this8._getFinalPath(path13);
+      let _path = _this8._getFinalPath(path16);
       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();
@@ -25022,13 +25877,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(path13, options, parameters) {
+  download(path16, 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(path13);
+    const _path = this._getFinalPath(path16);
     const downloadFn = () => get(this.fetch, `${this.url}/${renderPath}/${_path}${queryString ? `?${queryString}` : ""}`, {
       headers: this.headers,
       noResolveJson: true
@@ -25058,9 +25913,9 @@ var StorageFileApi = class extends BaseApiClient {
   * }
   * ```
   */
-  async info(path13) {
+  async info(path16) {
     var _this10 = this;
-    const _path = _this10._getFinalPath(path13);
+    const _path = _this10._getFinalPath(path16);
     return _this10.handleOperation(async () => {
       return recursiveToCamel(await get(_this10.fetch, `${_this10.url}/object/info/${_path}`, { headers: _this10.headers }));
     });
@@ -25080,9 +25935,9 @@ var StorageFileApi = class extends BaseApiClient {
   *   .exists('folder/avatar1.png')
   * ```
   */
-  async exists(path13) {
+  async exists(path16) {
     var _this11 = this;
-    const _path = _this11._getFinalPath(path13);
+    const _path = _this11._getFinalPath(path16);
     try {
       await head(_this11.fetch, `${_this11.url}/object/${_path}`, { headers: _this11.headers });
       return {
@@ -25160,8 +26015,8 @@ var StorageFileApi = class extends BaseApiClient {
   *   - `objects` table permissions: none
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   */
-  getPublicUrl(path13, options) {
-    const _path = this._getFinalPath(path13);
+  getPublicUrl(path16, options) {
+    const _path = this._getFinalPath(path16);
     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);
@@ -25298,10 +26153,10 @@ var StorageFileApi = class extends BaseApiClient {
   *   - `objects` table permissions: `select`
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   */
-  async list(path13, options, parameters) {
+  async list(path16, options, parameters) {
     var _this13 = this;
     return _this13.handleOperation(async () => {
-      const body = _objectSpread22(_objectSpread22(_objectSpread22({}, DEFAULT_SEARCH_OPTIONS), options), {}, { prefix: path13 || "" });
+      const body = _objectSpread22(_objectSpread22(_objectSpread22({}, DEFAULT_SEARCH_OPTIONS), options), {}, { prefix: path16 || "" });
       return await post(_this13.fetch, `${_this13.url}/object/list/${_this13.bucketId}`, body, { headers: _this13.headers }, parameters);
     });
   }
@@ -25365,11 +26220,11 @@ var StorageFileApi = class extends BaseApiClient {
     if (typeof Buffer !== "undefined") return Buffer.from(data).toString("base64");
     return btoa(data);
   }
-  _getFinalPath(path13) {
-    return `${this.bucketId}/${path13.replace(/^\/+/, "")}`;
+  _getFinalPath(path16) {
+    return `${this.bucketId}/${path16.replace(/^\/+/, "")}`;
   }
-  _removeEmptyFolders(path13) {
-    return path13.replace(/^\/|\/$/g, "").replace(/\/+/g, "/");
+  _removeEmptyFolders(path16) {
+    return path16.replace(/^\/|\/$/g, "").replace(/\/+/g, "/");
   }
   /** Modifies the `query`, appending values the from `transform` */
   applyTransformOptsToQuery(query, transform) {
@@ -27112,7 +27967,7 @@ function decodeJWT(token) {
   };
   return data;
 }
-async function sleep3(time) {
+async function sleep4(time) {
   return await new Promise((accept) => {
     setTimeout(() => accept(null), time);
   });
@@ -32905,7 +33760,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`, {
@@ -34477,24 +35332,24 @@ async function maybeLoadKeytar() {
 }
 async function ensurePathPermissions(filePath) {
   const dir = import_path7.default.dirname(filePath);
-  await import_promises18.default.mkdir(dir, { recursive: true });
+  await import_promises22.default.mkdir(dir, { recursive: true });
   try {
-    await import_promises18.default.chmod(dir, 448);
+    await import_promises22.default.chmod(dir, 448);
   } catch {
   }
   try {
-    await import_promises18.default.chmod(filePath, 384);
+    await import_promises22.default.chmod(filePath, 384);
   } catch {
   }
 }
-async function writeJsonAtomic2(filePath, value) {
-  await import_promises18.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_promises18.default.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
-  await import_promises18.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) {
@@ -34514,7 +35369,7 @@ function createLocalSessionStore(params) {
     }
   }
   async function readFile() {
-    const raw = await import_promises18.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));
@@ -34712,514 +35567,376 @@ async function createHookCollabApiClient() {
   });
 }
 
-// src/hook-diagnostics.ts
-var import_node_crypto2 = require("crypto");
-var import_promises20 = __toESM(require("fs/promises"), 1);
-var import_node_os5 = __toESM(require("os"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
-
-// src/hook-state.ts
-var import_promises19 = __toESM(require("fs/promises"), 1);
-var import_node_os4 = __toESM(require("os"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
-var import_node_crypto = require("crypto");
-function stateRoot() {
-  const configured = process.env.REMIX_CLAUDE_PLUGIN_HOOK_STATE_ROOT?.trim();
-  return configured || import_node_path6.default.join(import_node_os4.default.tmpdir(), "remix-claude-plugin-hooks");
-}
-function statePath(sessionId) {
-  return import_node_path6.default.join(stateRoot(), `${sessionId}.json`);
-}
-function stateLockPath(sessionId) {
-  return import_node_path6.default.join(stateRoot(), `${sessionId}.lock`);
-}
-function stateLockMetaPath(sessionId) {
-  return import_node_path6.default.join(stateLockPath(sessionId), "owner.json");
+// src/deferred-turn-drainer.ts
+var collabFinalizeTurn2 = collabFinalizeTurn;
+var drainPendingFinalizeQueue2 = drainPendingFinalizeQueue;
+var HOOK_ACTOR = {
+  type: "agent",
+  name: "claude-code",
+  version: pluginMetadata.version,
+  provider: "anthropic"
+};
+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;
+var DEFERRED_TURN_DRAIN_LOCK_STALE_MS = 9e4;
+function isPidAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
 }
-async function writeJsonAtomic3(filePath, value) {
-  await import_promises19.default.mkdir(import_node_path6.default.dirname(filePath), { recursive: true });
-  const tmpPath = `${filePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  await import_promises19.default.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
-  await import_promises19.default.rename(tmpPath, filePath);
+function repoLockFileName(repoRoot) {
+  const hash = (0, import_node_crypto3.createHash)("sha256").update(repoRoot).digest("hex").slice(0, 16);
+  return `.drainer-${hash}.lock`;
 }
-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));
+function repoLockPath(repoRoot) {
+  return import_node_path11.default.join(getDeferredTurnDirPath(), repoLockFileName(repoRoot));
 }
-async function readStateLockMetadata(sessionId) {
-  const raw = await import_promises19.default.readFile(stateLockMetaPath(sessionId), "utf8").catch(() => null);
+async function readDrainLockMetadata(lockPath) {
+  const raw = await import_promises23.default.readFile(lockPath, "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") {
+    if (typeof parsed.pid !== "number" || typeof parsed.repoRoot !== "string" || typeof parsed.startedAt !== "string") {
       return null;
     }
-    return {
-      ownerId: parsed.ownerId,
-      pid: parsed.pid,
-      createdAt: parsed.createdAt,
-      heartbeatAt: parsed.heartbeatAt
-    };
+    return { pid: parsed.pid, repoRoot: parsed.repoRoot, startedAt: parsed.startedAt };
   } catch {
     return null;
   }
 }
-async function writeStateLockMetadata(sessionId, metadata) {
-  await writeJsonAtomic3(stateLockMetaPath(sessionId), metadata);
+async function writeDrainLockMetadata(lockPath, metadata) {
+  const tmpPath = `${lockPath}.tmp-${process.pid}-${Date.now()}`;
+  await import_promises23.default.writeFile(tmpPath, JSON.stringify(metadata), "utf8");
+  await import_promises23.default.rename(tmpPath, lockPath);
 }
-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_promises19.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
-    return true;
-  }
-  if (!metadata) {
-    const lockStat = await import_promises19.default.stat(lockPath).catch(() => null);
-    if (lockStat && Date.now() - lockStat.mtimeMs > STATE_LOCK_STALE_MS) {
-      await import_promises19.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
-      return true;
-    }
-  }
-  return false;
-}
-async function acquireStateLock(sessionId) {
-  const lockPath = stateLockPath(sessionId);
-  const deadline = Date.now() + STATE_LOCK_WAIT_MS;
-  await import_promises19.default.mkdir(stateRoot(), { recursive: true });
-  while (true) {
-    try {
-      await import_promises19.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_promises19.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 tryAcquireDrainLock(repoRoot) {
+  const lockPath = repoLockPath(repoRoot);
+  await import_promises23.default.mkdir(import_node_path11.default.dirname(lockPath), { recursive: true });
+  const existingMeta = await readDrainLockMetadata(lockPath);
+  if (existingMeta) {
+    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);
+    if (fresh && alive) {
+      return { acquired: false, lockPath };
     }
   }
+  await writeDrainLockMetadata(lockPath, {
+    pid: process.pid,
+    repoRoot,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return { acquired: true, lockPath };
 }
-async function withStateLock(sessionId, fn) {
-  const release = await acquireStateLock(sessionId);
-  try {
-    return await fn();
-  } finally {
-    await release();
-  }
+async function releaseDrainLock(lockPath) {
+  const meta = await readDrainLockMetadata(lockPath);
+  if (meta && meta.pid !== process.pid) return;
+  await import_promises23.default.rm(lockPath, { force: true }).catch(() => void 0);
 }
-function normalizeIntent(value) {
-  return value === "memory_first" || value === "collab_state" || value === "git_facts" ? value : "neutral";
+async function heartbeatDrainLock(lockPath) {
+  const now = /* @__PURE__ */ new Date();
+  await import_promises23.default.utimes(lockPath, now, now).catch(() => void 0);
 }
-function normalizeString(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : null;
+async function sleep5(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
 }
-function normalizeStringArray(value) {
-  if (!Array.isArray(value)) return [];
-  return Array.from(
-    new Set(
-      value.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => entry.trim())
-    )
-  );
+function buildIdempotencyKey(turnId, repoRoot) {
+  return `${turnId}:${repoRoot}:finalize_turn`;
 }
-function normalizeManualRecordingScope(value) {
-  if (value === "full_turn") {
-    return "full_turn";
+async function pushPendingFinalizeQueueToServer(params) {
+  if (typeof drainPendingFinalizeQueue2 !== "function") {
+    await appendHookDiagnosticsEvent({
+      hook: "deferredTurnDrainer",
+      sessionId: params.sessionMarker,
+      stage: "finalize_queue_push_skipped",
+      result: "info",
+      reason: "drain_pending_finalize_queue_unavailable",
+      repoRoot: params.repoRoot
+    });
+    return;
   }
-  return null;
-}
-function normalizeTouchedRepo(value, repoRoot) {
-  if (!value || typeof value !== "object") return null;
-  const parsed = value;
-  const normalizedRepoRoot = normalizeString(parsed.repoRoot) ?? repoRoot.trim();
-  if (!normalizedRepoRoot) return null;
-  return {
-    repoRoot: normalizedRepoRoot,
-    projectId: normalizeString(parsed.projectId),
-    currentAppId: normalizeString(parsed.currentAppId),
-    upstreamAppId: normalizeString(parsed.upstreamAppId),
-    firstTouchedAt: normalizeString(parsed.firstTouchedAt) ?? (/* @__PURE__ */ new Date()).toISOString(),
-    lastTouchedAt: normalizeString(parsed.lastTouchedAt) ?? (/* @__PURE__ */ new Date()).toISOString(),
-    lastObservedWriteAt: normalizeString(parsed.lastObservedWriteAt),
-    touchedBy: normalizeStringArray(parsed.touchedBy),
-    hasObservedWrite: Boolean(parsed.hasObservedWrite),
-    manuallyRecorded: Boolean(parsed.manuallyRecorded),
-    manuallyRecordedAt: normalizeString(parsed.manuallyRecordedAt),
-    manuallyRecordedByTool: normalizeString(parsed.manuallyRecordedByTool),
-    manualRecordingScope: normalizeManualRecordingScope(parsed.manualRecordingScope),
-    manualRemoteChangeRecordedAt: normalizeString(parsed.manualRemoteChangeRecordedAt),
-    stopAttempted: Boolean(parsed.stopAttempted),
-    stopRecorded: Boolean(parsed.stopRecorded),
-    stopRecordedAt: normalizeString(parsed.stopRecordedAt),
-    stopRecordedMode: parsed.stopRecordedMode === "changed_turn" || parsed.stopRecordedMode === "no_diff_turn" ? parsed.stopRecordedMode : null,
-    recordingFailureMessage: normalizeString(parsed.recordingFailureMessage),
-    recordingFailureHint: normalizeString(parsed.recordingFailureHint),
-    recordingFailedAt: normalizeString(parsed.recordingFailedAt)
-  };
-}
-function normalizeTouchedRepos(value) {
-  if (!value || typeof value !== "object") return {};
-  const entries = Object.entries(value).map(([repoRoot, repo]) => normalizeTouchedRepo(repo, repoRoot)).filter((repo) => repo !== null).sort((a2, b) => a2.repoRoot.localeCompare(b.repoRoot));
-  return Object.fromEntries(entries.map((repo) => [repo.repoRoot, repo]));
-}
-function createTouchedRepo(params) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const touchedBy = params.touchedBy?.trim() ? [params.touchedBy.trim()] : [];
-  return {
-    repoRoot: params.repoRoot,
-    projectId: normalizeString(params.projectId),
-    currentAppId: normalizeString(params.currentAppId),
-    upstreamAppId: normalizeString(params.upstreamAppId),
-    firstTouchedAt: now,
-    lastTouchedAt: now,
-    lastObservedWriteAt: params.hasObservedWrite ? now : null,
-    touchedBy,
-    hasObservedWrite: Boolean(params.hasObservedWrite),
-    manuallyRecorded: false,
-    manuallyRecordedAt: null,
-    manuallyRecordedByTool: null,
-    manualRecordingScope: null,
-    manualRemoteChangeRecordedAt: null,
-    stopAttempted: false,
-    stopRecorded: false,
-    stopRecordedAt: null,
-    stopRecordedMode: null,
-    recordingFailureMessage: null,
-    recordingFailureHint: null,
-    recordingFailedAt: null
-  };
-}
-async function updatePendingTurnState(sessionId, updater) {
-  return withStateLock(sessionId, async () => {
-    const existing = await loadPendingTurnState(sessionId);
-    if (!existing) return null;
-    const result = updater(existing);
-    if (result === false) return existing;
-    await savePendingTurnState(existing);
-    return existing;
-  });
-}
-async function loadPendingTurnState(sessionId) {
-  const raw = await import_promises19.default.readFile(statePath(sessionId), "utf8").catch(() => null);
-  if (!raw) return null;
   try {
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object") return null;
-    if (typeof parsed.sessionId !== "string" || typeof parsed.turnId !== "string" || typeof parsed.prompt !== "string") {
-      return null;
-    }
-    return {
-      sessionId: parsed.sessionId,
-      turnId: parsed.turnId,
-      prompt: parsed.prompt,
-      initialCwd: normalizeString(parsed.initialCwd),
-      intent: normalizeIntent(parsed.intent),
-      submittedAt: typeof parsed.submittedAt === "string" ? parsed.submittedAt : (/* @__PURE__ */ new Date()).toISOString(),
-      consultedMemory: Boolean(parsed.consultedMemory),
-      touchedRepos: normalizeTouchedRepos(parsed.touchedRepos),
-      turnFailureMessage: normalizeString(parsed.turnFailureMessage),
-      turnFailureHint: normalizeString(parsed.turnFailureHint),
-      turnFailedAt: normalizeString(parsed.turnFailedAt)
-    };
-  } catch {
-    return null;
+    await drainPendingFinalizeQueue2({ api: params.api });
+    await appendHookDiagnosticsEvent({
+      hook: "deferredTurnDrainer",
+      sessionId: params.sessionMarker,
+      stage: "finalize_queue_pushed",
+      result: "success",
+      repoRoot: params.repoRoot
+    });
+  } catch (err) {
+    await appendHookDiagnosticsEvent({
+      hook: "deferredTurnDrainer",
+      sessionId: params.sessionMarker,
+      stage: "finalize_queue_push_failed",
+      result: "error",
+      reason: "exception",
+      repoRoot: params.repoRoot,
+      message: err instanceof Error ? err.message : String(err)
+    });
   }
 }
-async function savePendingTurnState(state) {
-  await writeJsonAtomic3(statePath(state.sessionId), state);
+async function recordOneDeferredTurn(params) {
+  const { entry, api } = params;
+  const { record, filePath } = entry;
+  try {
+    await collabFinalizeTurn2({
+      api,
+      cwd: record.repoRoot,
+      prompt: record.prompt,
+      assistantResponse: record.assistantResponse,
+      idempotencyKey: buildIdempotencyKey(record.turnId, record.repoRoot),
+      actor: HOOK_ACTOR,
+      turnUsage: null,
+      // The deferred queue can hold a turn for a long time (until the next
+      // `remix collab init` lands a binding), so the server's ingestion
+      // timestamp would otherwise be hours/days off from the real prompt
+      // time. Forward the original submit time so the dashboard timeline
+      // sorts this turn into its true position relative to siblings.
+      promptedAt: record.submittedAt
+    });
+    await deleteDeferredTurnFile(filePath);
+    return { recorded: true };
+  } catch (error) {
+    return { recorded: false, error };
+  }
 }
-async function upsertTouchedRepo(sessionId, params) {
-  const normalizedRepoRoot = params.repoRoot.trim();
-  if (!normalizedRepoRoot) return null;
-  const state = await updatePendingTurnState(sessionId, (existing) => {
-    const current = existing.touchedRepos[normalizedRepoRoot] ?? createTouchedRepo({
-      repoRoot: normalizedRepoRoot,
-      projectId: params.projectId,
-      currentAppId: params.currentAppId,
-      upstreamAppId: params.upstreamAppId,
-      touchedBy: params.touchedBy,
-      hasObservedWrite: params.hasObservedWrite
+async function runStandaloneDeferredTurnDrainer(repoRoot) {
+  const startedAt = Date.now();
+  const sessionMarker = `drainer-${process.pid}-${Math.random().toString(36).slice(2, 10)}`;
+  const acquireResult = await tryAcquireDrainLock(repoRoot);
+  if (!acquireResult.acquired) {
+    await appendHookDiagnosticsEvent({
+      hook: "deferredTurnDrainer",
+      sessionId: sessionMarker,
+      stage: "lock_skipped",
+      result: "skip",
+      reason: "another_drainer_active",
+      repoRoot
     });
-    current.projectId = normalizeString(params.projectId) ?? current.projectId;
-    current.currentAppId = normalizeString(params.currentAppId) ?? current.currentAppId;
-    current.upstreamAppId = normalizeString(params.upstreamAppId) ?? current.upstreamAppId;
-    current.lastTouchedAt = (/* @__PURE__ */ new Date()).toISOString();
-    if (params.touchedBy?.trim() && !current.touchedBy.includes(params.touchedBy.trim())) {
-      current.touchedBy = [...current.touchedBy, params.touchedBy.trim()].sort((a2, b) => a2.localeCompare(b));
-    }
-    if (params.hasObservedWrite) {
-      current.hasObservedWrite = true;
-      current.lastObservedWriteAt = (/* @__PURE__ */ new Date()).toISOString();
+    return;
+  }
+  await appendHookDiagnosticsEvent({
+    hook: "deferredTurnDrainer",
+    sessionId: sessionMarker,
+    stage: "drainer_started",
+    result: "info",
+    repoRoot,
+    fields: {
+      pid: process.pid,
+      maxWaitMs: DEFERRED_TURN_DRAIN_MAX_WAIT_MS,
+      pollIntervalMs: DEFERRED_TURN_DRAIN_POLL_INTERVAL_MS
     }
-    existing.touchedRepos[normalizedRepoRoot] = current;
-  });
-  return state?.touchedRepos[normalizedRepoRoot] ?? null;
-}
-async function markTouchedRepoStopAttempted(sessionId, repoRoot) {
-  await updatePendingTurnState(sessionId, (existing) => {
-    const current = existing.touchedRepos[repoRoot];
-    if (!current) return false;
-    current.stopAttempted = true;
-    current.lastTouchedAt = (/* @__PURE__ */ new Date()).toISOString();
   });
-}
-async function markTouchedRepoStopRecorded(sessionId, repoRoot, params) {
-  await updatePendingTurnState(sessionId, (existing) => {
-    const current = existing.touchedRepos[repoRoot];
-    if (!current) return false;
-    current.stopAttempted = true;
-    current.stopRecorded = true;
-    current.stopRecordedAt = (/* @__PURE__ */ new Date()).toISOString();
-    current.stopRecordedMode = params.mode;
-    current.recordingFailureMessage = null;
-    current.recordingFailureHint = null;
-    current.recordingFailedAt = null;
-    current.lastTouchedAt = (/* @__PURE__ */ new Date()).toISOString();
-  });
-}
-async function markTouchedRepoRecordingFailure(sessionId, repoRoot, params) {
-  await updatePendingTurnState(sessionId, (existing) => {
-    const current = existing.touchedRepos[repoRoot];
-    if (!current) return false;
-    current.stopAttempted = true;
-    current.recordingFailureMessage = params.message.trim();
-    current.recordingFailureHint = params.hint?.trim() || null;
-    current.recordingFailedAt = (/* @__PURE__ */ new Date()).toISOString();
-    current.lastTouchedAt = (/* @__PURE__ */ new Date()).toISOString();
-  });
-}
-function lastFinalizedPath(sessionId) {
-  return import_node_path6.default.join(stateRoot(), `${sessionId}.last-finalized.json`);
-}
-async function markLastFinalizedTurn(sessionId, turnId, prompt) {
-  const record = {
-    sessionId,
-    turnId,
-    prompt,
-    finalizedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  await writeJsonAtomic3(lastFinalizedPath(sessionId), record);
-}
-async function loadLastFinalizedTurn(sessionId) {
-  const raw = await import_promises19.default.readFile(lastFinalizedPath(sessionId), "utf8").catch(() => null);
-  if (!raw) return null;
+  const heartbeat = setInterval(() => {
+    void heartbeatDrainLock(acquireResult.lockPath).catch(() => void 0);
+  }, DEFERRED_TURN_DRAIN_LOCK_HEARTBEAT_MS);
+  heartbeat.unref?.();
+  let api = null;
+  let recordedTotal = 0;
+  let failedTotal = 0;
+  let exitReason = "queue_empty";
   try {
-    const parsed = JSON.parse(raw);
-    if (typeof parsed.sessionId === "string" && typeof parsed.turnId === "string" && typeof parsed.prompt === "string" && typeof parsed.finalizedAt === "string") {
-      return {
-        sessionId: parsed.sessionId,
-        turnId: parsed.turnId,
-        prompt: parsed.prompt,
-        finalizedAt: parsed.finalizedAt
-      };
+    while (true) {
+      if (Date.now() - startedAt > DEFERRED_TURN_DRAIN_MAX_WAIT_MS) {
+        exitReason = "timeout";
+        break;
+      }
+      let entries = [];
+      try {
+        entries = await listDeferredTurnsForRepo(repoRoot);
+      } catch (listErr) {
+        await appendHookDiagnosticsEvent({
+          hook: "deferredTurnDrainer",
+          sessionId: sessionMarker,
+          stage: "list_failed",
+          result: "error",
+          reason: "exception",
+          repoRoot,
+          message: listErr instanceof Error ? listErr.message : String(listErr)
+        });
+        await sleep5(DEFERRED_TURN_DRAIN_POLL_INTERVAL_MS);
+        continue;
+      }
+      if (entries.length === 0) {
+        exitReason = "queue_empty";
+        break;
+      }
+      const bindingState = await readCollabBindingState(repoRoot).catch(() => null);
+      const currentBranch = bindingState?.currentBranch ?? null;
+      const isCurrentBranchBound = bindingState?.binding != null;
+      const attemptable = entries.filter(
+        (e) => isCurrentBranchBound && (!e.record.branchAtDefer || e.record.branchAtDefer === currentBranch)
+      );
+      if (attemptable.length === 0) {
+        await sleep5(DEFERRED_TURN_DRAIN_POLL_INTERVAL_MS);
+        continue;
+      }
+      if (!api) {
+        try {
+          api = await createHookCollabApiClient();
+        } catch (apiErr) {
+          await appendHookDiagnosticsEvent({
+            hook: "deferredTurnDrainer",
+            sessionId: sessionMarker,
+            stage: "api_client_failed",
+            result: "error",
+            reason: "exception",
+            repoRoot,
+            message: apiErr instanceof Error ? apiErr.message : String(apiErr)
+          });
+          exitReason = "api_init_failed";
+          break;
+        }
+      }
+      let recordedThisPass = 0;
+      let failedThisPass = 0;
+      for (const entry of attemptable) {
+        const result = await recordOneDeferredTurn({ entry, api });
+        if (result.recorded) {
+          recordedThisPass += 1;
+          recordedTotal += 1;
+          await appendHookDiagnosticsEvent({
+            hook: "deferredTurnDrainer",
+            sessionId: sessionMarker,
+            stage: "deferred_turn_recorded",
+            result: "success",
+            repoRoot,
+            fields: {
+              deferredTurnId: entry.record.turnId,
+              deferredSessionId: entry.record.sessionId,
+              deferredAt: entry.record.deferredAt,
+              submittedAt: entry.record.submittedAt,
+              recordingDelayMs: Math.max(0, Date.now() - Date.parse(entry.record.deferredAt)),
+              recoveredBy: "standalone_drainer"
+            }
+          });
+        } else {
+          failedThisPass += 1;
+          failedTotal += 1;
+          await appendHookDiagnosticsEvent({
+            hook: "deferredTurnDrainer",
+            sessionId: sessionMarker,
+            stage: "deferred_turn_record_failed",
+            result: "error",
+            reason: "exception",
+            repoRoot,
+            message: result.error instanceof Error ? result.error.message : String(result.error ?? ""),
+            fields: {
+              deferredTurnId: entry.record.turnId,
+              deferredSessionId: entry.record.sessionId
+            }
+          });
+        }
+      }
+      if (recordedThisPass > 0) {
+        await pushPendingFinalizeQueueToServer({
+          sessionMarker,
+          repoRoot,
+          api
+        });
+      }
+      if (recordedThisPass > 0 && failedThisPass === 0) {
+        const remaining = await listDeferredTurnsForRepo(repoRoot).catch(() => []);
+        if (remaining.length === 0) {
+          exitReason = "queue_empty";
+          break;
+        }
+      }
+      await sleep5(DEFERRED_TURN_DRAIN_POLL_INTERVAL_MS);
     }
-    return null;
-  } catch {
-    return null;
-  }
-}
-async function markPendingTurnFailure(sessionId, params) {
-  await updatePendingTurnState(sessionId, (existing) => {
-    existing.turnFailureMessage = params.message.trim();
-    existing.turnFailureHint = params.hint?.trim() || null;
-    existing.turnFailedAt = (/* @__PURE__ */ new Date()).toISOString();
-  });
-}
-async function listTouchedRepos(sessionId) {
-  const existing = await loadPendingTurnState(sessionId);
-  if (!existing) return [];
-  return Object.values(existing.touchedRepos).sort((a2, b) => a2.repoRoot.localeCompare(b.repoRoot));
-}
-async function clearPendingTurnState(sessionId) {
-  await withStateLock(sessionId, async () => {
-    await import_promises19.default.rm(statePath(sessionId), { force: true }).catch(() => void 0);
-  });
-}
-
-// package.json
-var package_default = {
-  name: "@remixhq/claude-plugin",
-  version: "0.1.21",
-  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"
+    if (recordedTotal > 0 && api) {
+      await pushPendingFinalizeQueueToServer({
+        sessionMarker,
+        repoRoot,
+        api
+      });
     }
-  },
-  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.15",
-    "@remixhq/mcp": "^0.1.16"
-  },
-  devDependencies: {
-    "@types/node": "^25.4.0",
-    tsup: "^8.5.1",
-    tsx: "^4.21.0",
-    typescript: "^5.9.3"
+    try {
+      const pruned = await pruneStaleDeferredTurns();
+      if (pruned.length > 0) {
+        await appendHookDiagnosticsEvent({
+          hook: "deferredTurnDrainer",
+          sessionId: sessionMarker,
+          stage: "ttl_pruned",
+          result: "info",
+          repoRoot,
+          fields: { prunedCount: pruned.length }
+        });
+      }
+    } catch {
+    }
+  } finally {
+    clearInterval(heartbeat);
+    await releaseDrainLock(acquireResult.lockPath);
+    await appendHookDiagnosticsEvent({
+      hook: "deferredTurnDrainer",
+      sessionId: sessionMarker,
+      stage: "drainer_completed",
+      result: exitReason === "queue_empty" ? "success" : "info",
+      reason: exitReason,
+      repoRoot,
+      fields: {
+        recordedTotal,
+        failedTotal,
+        elapsedMs: Date.now() - startedAt
+      }
+    });
   }
-};
-
-// 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_path7.default.join(import_node_os5.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_path7.default.join(resolveClaudeRoot(), "plugins", "data", resolvePluginDataDirName());
-}
-function getHookDiagnosticsLogPath() {
-  return import_node_path7.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_promises20.default.stat(logPath).catch(() => null);
-  if (!stat || stat.size < MAX_LOG_BYTES) {
-    return;
+function parseDeferredTurnDrainerArgv(argv) {
+  for (let i2 = 0; i2 < argv.length; i2 += 1) {
+    const arg = argv[i2];
+    if (!arg) continue;
+    if (arg === "--drain-deferred-turns") {
+      const next = argv[i2 + 1];
+      if (next && !next.startsWith("--")) return next;
+      return null;
+    }
+    if (arg.startsWith("--drain-deferred-turns=")) {
+      const value = arg.slice("--drain-deferred-turns=".length);
+      return value || null;
+    }
   }
-  const rotatedPath = `${logPath}.1`;
-  await import_promises20.default.rm(rotatedPath, { force: true }).catch(() => void 0);
-  await import_promises20.default.rename(logPath, rotatedPath).catch(() => void 0);
+  return null;
 }
-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 maybeRunDeferredTurnDrainerFromArgv() {
+  const repoRoot = parseDeferredTurnDrainerArgv(process.argv);
+  if (!repoRoot) return false;
+  await runStandaloneDeferredTurnDrainer(repoRoot);
+  return true;
 }
-async function appendHookDiagnosticsEvent(params) {
-  try {
-    const logPath = getHookDiagnosticsLogPath();
-    await import_promises20.default.mkdir(import_node_path7.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_promises20.default.appendFile(logPath, `${JSON.stringify(event)}
-`, "utf8");
-  } catch {
-  }
+
+// src/spawn-helpers.ts
+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_process7.spawn)(
+    process.execPath,
+    [...process.execArgv, entrypoint, "--drain-deferred-turns", repoRoot],
+    {
+      detached: true,
+      stdio: "ignore",
+      env: process.env
+    }
+  );
+  child.unref();
 }
 
 // node_modules/@remixhq/core/dist/history.js
-var import_promises21 = __toESM(require("fs/promises"), 1);
+var import_promises24 = __toESM(require("fs/promises"), 1);
 async function readAndParseTranscript(transcriptPath) {
   let raw;
   try {
-    raw = await import_promises21.default.readFile(transcriptPath, "utf8");
+    raw = await import_promises24.default.readFile(transcriptPath, "utf8");
   } catch (err) {
     const code = err && typeof err === "object" && "code" in err ? err.code : null;
     if (code === "ENOENT") {
@@ -35662,10 +36379,10 @@ function harvestClaudeCodeUsage(input) {
 }
 
 // src/usage/claudeCodeSession.ts
-var import_node_child_process6 = require("child_process");
-var import_node_fs6 = require("fs");
-var import_node_os6 = require("os");
-var import_node_path8 = require("path");
+var import_node_child_process8 = require("child_process");
+var import_node_fs7 = require("fs");
+var import_node_os7 = require("os");
+var import_node_path12 = require("path");
 var CACHE_SCHEMA_VERSION = 1;
 var SUCCESS_TTL_MS = 60 * 60 * 1e3;
 var FAILURE_TTL_MS = 5 * 60 * 1e3;
@@ -35675,7 +36392,7 @@ var spawnerImpl = defaultSpawnClaudeAuthStatus;
 function defaultSpawnClaudeAuthStatus(timeoutMs) {
   let result;
   try {
-    result = (0, import_node_child_process6.spawnSync)("claude", ["auth", "status", "--json"], {
+    result = (0, import_node_child_process8.spawnSync)("claude", ["auth", "status", "--json"], {
       stdio: ["ignore", "pipe", "pipe"],
       timeout: timeoutMs,
       env: process.env
@@ -35694,10 +36411,10 @@ function defaultSpawnClaudeAuthStatus(timeoutMs) {
 }
 function getCollabStateRoot2() {
   const configured = process.env.REMIX_COLLAB_STATE_ROOT?.trim();
-  return configured || (0, import_node_path8.join)((0, import_node_os6.homedir)(), ".remix", "collab-state");
+  return configured || (0, import_node_path12.join)((0, import_node_os7.homedir)(), ".remix", "collab-state");
 }
 function getAuthCachePath() {
-  return (0, import_node_path8.join)(getCollabStateRoot2(), "claude-auth-cache.json");
+  return (0, import_node_path12.join)(getCollabStateRoot2(), "claude-auth-cache.json");
 }
 function getSpawnTimeoutMs() {
   const raw = process.env.REMIX_CLAUDE_AUTH_TIMEOUT_MS?.trim();
@@ -35709,7 +36426,7 @@ function getSpawnTimeoutMs() {
 function readAuthCache() {
   let raw;
   try {
-    raw = (0, import_node_fs6.readFileSync)(getAuthCachePath(), "utf8");
+    raw = (0, import_node_fs7.readFileSync)(getAuthCachePath(), "utf8");
   } catch {
     return null;
   }
@@ -35738,10 +36455,10 @@ function isCacheFresh(record) {
 function writeAuthCache(record) {
   const cachePath = getAuthCachePath();
   try {
-    (0, import_node_fs6.mkdirSync)((0, import_node_path8.dirname)(cachePath), { recursive: true });
+    (0, import_node_fs7.mkdirSync)((0, import_node_path12.dirname)(cachePath), { recursive: true });
     const tmpPath = `${cachePath}.${process.pid}.${Date.now()}.tmp`;
-    (0, import_node_fs6.writeFileSync)(tmpPath, JSON.stringify(record), "utf8");
-    (0, import_node_fs6.renameSync)(tmpPath, cachePath);
+    (0, import_node_fs7.writeFileSync)(tmpPath, JSON.stringify(record), "utf8");
+    (0, import_node_fs7.renameSync)(tmpPath, cachePath);
   } catch {
   }
 }
@@ -35795,8 +36512,8 @@ function resolveClaudeCodeSession(hookPayload) {
 }
 
 // src/hook-utils.ts
-var import_promises22 = __toESM(require("fs/promises"), 1);
-var import_node_path9 = __toESM(require("path"), 1);
+var import_promises25 = __toESM(require("fs/promises"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 async function readJsonStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -35858,16 +36575,16 @@ function extractBoolean(input, keys) {
 }
 async function findBoundRepo(startPath) {
   if (!startPath) return null;
-  let current = import_node_path9.default.resolve(startPath);
-  let stats = await import_promises22.default.stat(current).catch(() => null);
+  let current = import_node_path13.default.resolve(startPath);
+  let stats = await import_promises25.default.stat(current).catch(() => null);
   if (stats?.isFile()) {
-    current = import_node_path9.default.dirname(current);
+    current = import_node_path13.default.dirname(current);
   }
   while (true) {
-    const bindingPath = import_node_path9.default.join(current, ".remix", "config.json");
-    const bindingStats = await import_promises22.default.stat(bindingPath).catch(() => null);
+    const bindingPath = import_node_path13.default.join(current, ".remix", "config.json");
+    const bindingStats = await import_promises25.default.stat(bindingPath).catch(() => null);
     if (bindingStats?.isFile()) return current;
-    const parent = import_node_path9.default.dirname(current);
+    const parent = import_node_path13.default.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -35886,23 +36603,26 @@ async function resolveBoundRepoSummary(startPath) {
 }
 
 // src/hook-stop-collab.ts
-var HOOK_ACTOR = {
+var HOOK_ACTOR2 = {
   type: "agent",
   name: "claude-code",
   version: pluginMetadata.version,
   provider: "anthropic"
 };
-var collabFinalizeTurn2 = collabFinalizeTurn;
+var collabFinalizeTurn3 = collabFinalizeTurn;
 function getErrorDetails(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 || "Fallback Remix turn recording failed.",
-      hint
+      hint,
+      preflightCode
     };
   }
   const message = typeof error === "string" && error.trim() ? error.trim() : "Fallback Remix turn recording failed.";
-  return { message, hint: null };
+  return { message, hint: null, preflightCode: null };
 }
 function buildRepoIdempotencyKey(turnId, repo) {
   const repoToken = repo.currentAppId?.trim() || repo.repoRoot;
@@ -35957,7 +36677,7 @@ function createFallbackTouchedRepo(params) {
   };
 }
 var TRANSCRIPT_FLUSH_RETRY_DELAYS_MS = [50, 100, 200];
-function sleep5(ms) {
+function sleep6(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function harvestTurnUsage(params) {
@@ -36002,7 +36722,7 @@ async function harvestTurnUsage(params) {
     while (!currentResult.ok && currentResult.reason === "no_messages_for_turn") {
       if (retriesUsed >= TRANSCRIPT_FLUSH_RETRY_DELAYS_MS.length) break;
       const delayMs = TRANSCRIPT_FLUSH_RETRY_DELAYS_MS[retriesUsed];
-      await sleep5(delayMs);
+      await sleep6(delayMs);
       retriesUsed += 1;
       totalBackoffMs += delayMs;
       const reparsed = await readAndParseTranscript(transcriptPath);
@@ -36207,9 +36927,18 @@ async function recordTouchedRepo(params) {
   try {
     const binding = await readCollabBinding(repo.repoRoot).catch(() => null);
     if (!binding) {
-      await markTouchedRepoRecordingFailure(sessionId, repo.repoRoot, {
+      const failure = {
+        repoRoot: repo.repoRoot,
         message: "Fallback Remix turn recording failed because the repository is no longer bound to Remix.",
-        hint: `Repo root: ${repo.repoRoot}`
+        hint: `Repo root: ${repo.repoRoot}`,
+        // Equivalent to the not_bound preflight code — the binding
+        // disappeared between touch-time and finalize-time. Reusing the
+        // code lets the dispatcher route this through the same recovery.
+        preflightCode: "not_bound"
+      };
+      await markTouchedRepoRecordingFailure(sessionId, repo.repoRoot, {
+        message: failure.message,
+        hint: failure.hint
       });
       await appendHookDiagnosticsEvent({
         hook,
@@ -36220,19 +36949,20 @@ async function recordTouchedRepo(params) {
         reason: "repo_not_bound",
         repoRoot: repo.repoRoot
       });
-      return { recorded: false, queued: false };
+      return { recorded: false, queued: false, failure };
     }
-    const result = await collabFinalizeTurn2({
+    const result = await collabFinalizeTurn3({
       api,
       cwd: repo.repoRoot,
       prompt,
       assistantResponse,
       idempotencyKey: buildRepoIdempotencyKey(turnId, repo),
-      actor: HOOK_ACTOR,
+      actor: HOOK_ACTOR2,
       turnUsage,
       promptedAt: promptedAt ?? null
     });
     await markTouchedRepoStopRecorded(sessionId, repo.repoRoot, { mode: result.mode });
+    await clearFinalizeFailureMarker(repo.repoRoot).catch(() => void 0);
     await appendHookDiagnosticsEvent({
       hook,
       sessionId,
@@ -36242,10 +36972,17 @@ async function recordTouchedRepo(params) {
       reason: result.mode,
       repoRoot: repo.repoRoot
     });
-    return { recorded: true, queued: result.queued === true };
+    return {
+      recorded: true,
+      queued: result.queued === true,
+      failure: null
+    };
   } catch (error) {
     const details = getErrorDetails(error);
-    await markTouchedRepoRecordingFailure(sessionId, repo.repoRoot, details);
+    await markTouchedRepoRecordingFailure(sessionId, repo.repoRoot, {
+      message: details.message,
+      hint: details.hint
+    });
     await appendHookDiagnosticsEvent({
       hook,
       sessionId,
@@ -36256,68 +36993,246 @@ async function recordTouchedRepo(params) {
       repoRoot: repo.repoRoot,
       message: details.message,
       fields: {
-        hint: details.hint
+        hint: details.hint,
+        preflightCode: details.preflightCode
       }
     });
-    return { recorded: false, queued: false };
+    return {
+      recorded: false,
+      queued: false,
+      failure: {
+        repoRoot: repo.repoRoot,
+        message: details.message,
+        hint: details.hint,
+        preflightCode: details.preflightCode
+      }
+    };
   }
 }
 function spawnFinalizeQueueDrainer() {
   const entrypoint = process.argv[1];
   if (!entrypoint) return;
-  const child = (0, import_node_child_process7.spawn)(process.execPath, [...process.execArgv, entrypoint, "--drain-finalize-queue"], {
+  const child = (0, import_node_child_process9.spawn)(process.execPath, [...process.execArgv, entrypoint, "--drain-finalize-queue"], {
     detached: true,
     stdio: "ignore",
     env: process.env
   });
   child.unref();
 }
-var HISTORY_IMPORT_MARKER_REL = import_node_path10.default.join(".remix", ".history-imported");
-var HISTORY_IMPORT_LOG_REL = import_node_path10.default.join(".remix", "history-import.log");
-function maybeAutoSpawnHistoryImportFromStopHook(repoRoot) {
+var DEFERRED_TURN_PRUNE_LOG_LIMIT = 5;
+async function drainDeferredTurnsForRepo(params) {
+  const { hook, sessionId, triggerTurnId, repoRoot, api } = params;
+  let entries = [];
   try {
-    if ((0, import_node_fs7.existsSync)(import_node_path10.default.join(repoRoot, HISTORY_IMPORT_MARKER_REL))) {
-      return { spawned: false, reason: "marker_present" };
+    entries = await listDeferredTurnsForRepo(repoRoot);
+  } catch (listErr) {
+    await appendHookDiagnosticsEvent({
+      hook,
+      sessionId,
+      turnId: triggerTurnId,
+      stage: "deferred_turn_list_failed",
+      result: "error",
+      reason: "exception",
+      repoRoot,
+      message: listErr instanceof Error ? listErr.message : String(listErr)
+    });
+    return;
+  }
+  if (entries.length === 0) return;
+  const bindingState = await readCollabBindingState(repoRoot).catch(() => null);
+  const currentBranch = bindingState?.currentBranch ?? null;
+  const isCurrentBranchBound = bindingState?.binding != null;
+  await appendHookDiagnosticsEvent({
+    hook,
+    sessionId,
+    turnId: triggerTurnId,
+    stage: "deferred_turn_drain_started",
+    result: "info",
+    repoRoot,
+    fields: {
+      candidateCount: entries.length,
+      currentBranch,
+      currentBranchBound: isCurrentBranchBound
+    }
+  });
+  let recordedCount = 0;
+  let skippedCount = 0;
+  let failedCount = 0;
+  for (const entry of entries) {
+    const { record, filePath } = entry;
+    if (!isCurrentBranchBound || record.branchAtDefer && record.branchAtDefer !== currentBranch) {
+      skippedCount += 1;
+      await appendHookDiagnosticsEvent({
+        hook,
+        sessionId,
+        turnId: triggerTurnId,
+        stage: "deferred_turn_skipped",
+        result: "info",
+        reason: "branch_mismatch",
+        repoRoot,
+        fields: {
+          deferredTurnId: record.turnId,
+          deferredSessionId: record.sessionId,
+          branchAtDefer: record.branchAtDefer,
+          currentBranch
+        }
+      });
+      continue;
+    }
+    try {
+      const idempotencyKey = `${record.turnId}:${repoRoot}:finalize_turn`;
+      await collabFinalizeTurn3({
+        api,
+        cwd: repoRoot,
+        prompt: record.prompt,
+        assistantResponse: record.assistantResponse,
+        idempotencyKey,
+        actor: HOOK_ACTOR2,
+        turnUsage: null,
+        promptedAt: record.submittedAt
+      });
+      await deleteDeferredTurnFile(filePath);
+      recordedCount += 1;
+      await appendHookDiagnosticsEvent({
+        hook,
+        sessionId,
+        turnId: triggerTurnId,
+        stage: "deferred_turn_recorded",
+        result: "success",
+        repoRoot,
+        fields: {
+          deferredTurnId: record.turnId,
+          deferredSessionId: record.sessionId,
+          deferredAt: record.deferredAt,
+          submittedAt: record.submittedAt,
+          recordingDelayMs: Math.max(0, Date.now() - Date.parse(record.deferredAt))
+        }
+      });
+    } catch (recordErr) {
+      failedCount += 1;
+      await appendHookDiagnosticsEvent({
+        hook,
+        sessionId,
+        turnId: triggerTurnId,
+        stage: "deferred_turn_record_failed",
+        result: "error",
+        reason: "exception",
+        repoRoot,
+        message: recordErr instanceof Error ? recordErr.message : String(recordErr),
+        fields: {
+          deferredTurnId: record.turnId,
+          deferredSessionId: record.sessionId
+        }
+      });
     }
-  } catch (markerErr) {
-    return {
-      spawned: false,
-      reason: "marker_check_failed",
-      message: markerErr instanceof Error ? markerErr.message : String(markerErr)
-    };
   }
-  const remixDir = import_node_path10.default.join(repoRoot, ".remix");
   try {
-    (0, import_node_fs7.mkdirSync)(remixDir, { recursive: true });
+    const pruned = await pruneStaleDeferredTurns();
+    for (const prunedPath of pruned.slice(0, DEFERRED_TURN_PRUNE_LOG_LIMIT)) {
+      await appendHookDiagnosticsEvent({
+        hook,
+        sessionId,
+        turnId: triggerTurnId,
+        stage: "deferred_turn_pruned",
+        result: "info",
+        reason: "stale",
+        repoRoot,
+        fields: { prunedFilePath: prunedPath }
+      });
+    }
+    if (pruned.length > DEFERRED_TURN_PRUNE_LOG_LIMIT) {
+      await appendHookDiagnosticsEvent({
+        hook,
+        sessionId,
+        turnId: triggerTurnId,
+        stage: "deferred_turn_pruned",
+        result: "info",
+        reason: "stale_truncated",
+        repoRoot,
+        fields: {
+          totalPruned: pruned.length,
+          loggedPruned: DEFERRED_TURN_PRUNE_LOG_LIMIT
+        }
+      });
+    }
   } catch {
   }
-  const logPath = import_node_path10.default.join(repoRoot, HISTORY_IMPORT_LOG_REL);
-  let out;
-  let err;
-  try {
-    out = (0, import_node_fs7.openSync)(logPath, "a");
-    err = (0, import_node_fs7.openSync)(logPath, "a");
-  } catch (logErr) {
-    return {
-      spawned: false,
-      reason: "log_open_failed",
-      message: logErr instanceof Error ? logErr.message : String(logErr)
-    };
-  }
+  await appendHookDiagnosticsEvent({
+    hook,
+    sessionId,
+    turnId: triggerTurnId,
+    stage: "deferred_turn_drain_completed",
+    result: "info",
+    repoRoot,
+    fields: {
+      recordedCount,
+      skippedCount,
+      failedCount
+    }
+  });
+}
+async function deferTurnForRecoveryInProgress(params) {
+  const { hook, sessionId, turnId, repoRoot, prompt, assistantResponse, submittedAt, preflightCode } = params;
+  const bindingState = await readCollabBindingState(repoRoot).catch(() => null);
+  const branchAtDefer = bindingState?.currentBranch ?? null;
   try {
-    const child = (0, import_node_child_process7.spawn)("remix", ["history", "import", "--repo", repoRoot, "--include-prompt-text"], {
-      detached: true,
-      stdio: ["ignore", out, err],
-      env: { ...process.env, REMIX_HISTORY_AUTO_SPAWN: "1" }
+    const deferredFilePath = await writeDeferredTurn(
+      buildDeferredTurnRecord({
+        sessionId,
+        turnId,
+        repoRoot,
+        prompt,
+        assistantResponse,
+        submittedAt,
+        branchAtDefer,
+        reason: "recovery_in_progress"
+      })
+    );
+    await appendHookDiagnosticsEvent({
+      hook,
+      sessionId,
+      turnId,
+      stage: "turn_deferred",
+      result: "success",
+      reason: "recovery_in_progress",
+      repoRoot,
+      fields: {
+        deferredFilePath,
+        promptLength: prompt.length,
+        assistantResponseLength: assistantResponse.length,
+        branchAtDefer,
+        preflightCode
+      }
     });
-    child.unref();
-    return { spawned: true, pid: child.pid, logPath };
-  } catch (spawnErr) {
-    return {
-      spawned: false,
-      reason: "spawn_failed",
-      message: spawnErr instanceof Error ? spawnErr.message : String(spawnErr)
-    };
+    spawnDeferredTurnDrainer(repoRoot);
+    await appendHookDiagnosticsEvent({
+      hook,
+      sessionId,
+      turnId,
+      stage: "deferred_turn_drainer_spawned",
+      result: "info",
+      repoRoot,
+      fields: {
+        triggeredBy: "recovery_in_progress",
+        preflightCode
+      }
+    });
+    return deferredFilePath;
+  } catch (deferErr) {
+    await appendHookDiagnosticsEvent({
+      hook,
+      sessionId,
+      turnId,
+      stage: "deferred_turn_write_failed",
+      result: "error",
+      reason: "exception",
+      repoRoot,
+      message: deferErr instanceof Error ? deferErr.message : String(deferErr),
+      fields: {
+        preflightCode
+      }
+    });
+    return null;
   }
 }
 async function runHookStopCollab(payload) {
@@ -36395,6 +37310,35 @@ async function runHookStopCollab(payload) {
             unboundBranchKnownCount = knownBoundBranches.length;
           }
         }
+        const promptTextForDefer = state.prompt.trim();
+        const assistantResponseForDefer = (extractAssistantResponse(payload) || "").trim();
+        let deferredFilePath = null;
+        if (skipReason === "current_branch_unbound" && unboundBranchRepoRoot && promptTextForDefer && assistantResponseForDefer) {
+          try {
+            deferredFilePath = await writeDeferredTurn(
+              buildDeferredTurnRecord({
+                sessionId,
+                turnId: state.turnId,
+                repoRoot: unboundBranchRepoRoot,
+                prompt: promptTextForDefer,
+                assistantResponse: assistantResponseForDefer,
+                submittedAt: state.submittedAt,
+                branchAtDefer: unboundBranchName
+              })
+            );
+          } catch (deferErr) {
+            await appendHookDiagnosticsEvent({
+              hook,
+              sessionId,
+              turnId: state.turnId,
+              stage: "deferred_turn_write_failed",
+              result: "error",
+              reason: "exception",
+              repoRoot: unboundBranchRepoRoot,
+              message: deferErr instanceof Error ? deferErr.message : String(deferErr)
+            });
+          }
+        }
         await clearPendingTurnState(sessionId);
         await appendHookDiagnosticsEvent({
           hook,
@@ -36406,16 +37350,44 @@ async function runHookStopCollab(payload) {
           repoRoot: unboundBranchRepoRoot,
           fields: skipReason === "current_branch_unbound" ? {
             currentBranch: unboundBranchName,
-            knownBoundBranchCount: unboundBranchKnownCount
+            knownBoundBranchCount: unboundBranchKnownCount,
+            deferredForRetry: deferredFilePath !== null
           } : {}
         });
+        if (deferredFilePath && unboundBranchRepoRoot) {
+          await appendHookDiagnosticsEvent({
+            hook,
+            sessionId,
+            turnId: state.turnId,
+            stage: "turn_deferred",
+            result: "success",
+            reason: "current_branch_unbound",
+            repoRoot: unboundBranchRepoRoot,
+            fields: {
+              deferredFilePath,
+              promptLength: promptTextForDefer.length,
+              assistantResponseLength: assistantResponseForDefer.length,
+              branchAtDefer: unboundBranchName
+            }
+          });
+          spawnDeferredTurnDrainer(unboundBranchRepoRoot);
+          await appendHookDiagnosticsEvent({
+            hook,
+            sessionId,
+            turnId: state.turnId,
+            stage: "deferred_turn_drainer_spawned",
+            result: "info",
+            repoRoot: unboundBranchRepoRoot,
+            fields: { triggeredBy: "defer" }
+          });
+        }
         await appendHookDiagnosticsEvent({
           hook,
           sessionId,
           turnId: state.turnId,
           stage: "state_cleanup",
           result: "success",
-          reason: "cleared_without_bound_repo"
+          reason: deferredFilePath ? "cleared_after_defer" : "cleared_without_bound_repo"
         });
         return;
       }
@@ -36491,10 +37463,20 @@ async function runHookStopCollab(payload) {
       state: { turnId: state.turnId, prompt, submittedAt: state.submittedAt },
       payload
     });
+    for (const repo of touchedRepos) {
+      await drainDeferredTurnsForRepo({
+        hook,
+        sessionId,
+        triggerTurnId: state.turnId,
+        repoRoot: repo.repoRoot,
+        api
+      }).catch(() => void 0);
+    }
     let hadFailure = false;
     let queuedFinalizeWork = false;
     let anyRecorded = false;
     let anyTurnExists = false;
+    const failures = [];
     for (const repo of touchedRepos) {
       if (shouldSkipStopRecording(repo)) {
         const legacyMcpFinalizeQueued = repo.manuallyRecordedByTool === "remix_collab_finalize_turn" && repo.manualRecordingScope === "full_turn";
@@ -36541,31 +37523,11 @@ async function runHookStopCollab(payload) {
       if (recording.recorded) {
         anyRecorded = true;
         anyTurnExists = true;
-        const autoSpawn = maybeAutoSpawnHistoryImportFromStopHook(repo.repoRoot);
-        if (autoSpawn.spawned) {
-          await appendHookDiagnosticsEvent({
-            hook,
-            sessionId,
-            turnId: state.turnId,
-            stage: "history_import_auto_spawned_from_stop",
-            result: "success",
-            repoRoot: repo.repoRoot,
-            fields: { pid: autoSpawn.pid ?? null, logPath: autoSpawn.logPath }
-          });
-        } else if (autoSpawn.reason !== "marker_present") {
-          await appendHookDiagnosticsEvent({
-            hook,
-            sessionId,
-            turnId: state.turnId,
-            stage: "history_import_auto_spawn_skipped",
-            result: "info",
-            reason: autoSpawn.reason,
-            repoRoot: repo.repoRoot,
-            message: autoSpawn.message ?? null
-          });
-        }
       } else {
         hadFailure = true;
+        if (recording.failure) {
+          failures.push(recording.failure);
+        }
       }
     }
     if (anyRecorded || anyTurnExists) {
@@ -36574,7 +37536,48 @@ async function runHookStopCollab(payload) {
     if (queuedFinalizeWork) {
       spawnFinalizeQueueDrainer();
     }
-    if (!hadFailure) {
+    let deferredFailureCount = 0;
+    let dispatchFailureCount = 0;
+    for (const failure of failures) {
+      const outcome = await dispatchFinalizeFailure({
+        hook: "Stop",
+        sessionId,
+        turnId: state.turnId,
+        repoRoot: failure.repoRoot,
+        preflightCode: failure.preflightCode,
+        message: failure.message,
+        hint: failure.hint
+      }).catch((dispatchErr) => {
+        dispatchFailureCount += 1;
+        return appendHookDiagnosticsEvent({
+          hook,
+          sessionId,
+          turnId: state.turnId,
+          stage: "auto_fix_dispatch_failed",
+          result: "error",
+          reason: "exception",
+          repoRoot: failure.repoRoot,
+          message: dispatchErr instanceof Error ? dispatchErr.message : String(dispatchErr)
+        }).then(() => null);
+      });
+      if (outcome && isAutoFixableFinalizeFailureCode(failure.preflightCode) && (outcome.kind === "spawned" || outcome.kind === "spawn_throttled")) {
+        const deferredFilePath = await deferTurnForRecoveryInProgress({
+          hook,
+          sessionId,
+          turnId: state.turnId,
+          repoRoot: failure.repoRoot,
+          prompt,
+          assistantResponse,
+          submittedAt: state.submittedAt,
+          preflightCode: failure.preflightCode
+        });
+        if (deferredFilePath) {
+          deferredFailureCount += 1;
+        }
+      }
+    }
+    const allFailuresDeferred = failures.length > 0 && deferredFailureCount === failures.length && dispatchFailureCount === 0;
+    if (!hadFailure || allFailuresDeferred) {
       await clearPendingTurnState(sessionId);
       await appendHookDiagnosticsEvent({
         hook,
@@ -36582,7 +37585,10 @@ async function runHookStopCollab(payload) {
         turnId: state.turnId,
         stage: "state_cleanup",
         result: "success",
-        reason: "cleared_after_success"
+        reason: allFailuresDeferred ? "cleared_after_recovery_defer" : "cleared_after_success",
+        fields: allFailuresDeferred ? {
+          deferredFailureCount
+        } : void 0
       });
       return;
     }
@@ -36596,7 +37602,7 @@ async function runHookStopCollab(payload) {
     });
   } catch (error) {
     const details = getErrorDetails(error);
-    await markPendingTurnFailure(sessionId, details);
+    await markPendingTurnFailure(sessionId, { message: details.message, hint: details.hint });
     await appendHookDiagnosticsEvent({
       hook,
       sessionId,
@@ -36606,17 +37612,21 @@ async function runHookStopCollab(payload) {
       reason: "exception",
       message: details.message,
       fields: {
-        hint: details.hint
+        hint: details.hint,
+        preflightCode: details.preflightCode
       }
     });
   }
 }
 async function main() {
+  if (await maybeRunDeferredTurnDrainerFromArgv()) {
+    return;
+  }
   if (process.argv.includes("--drain-finalize-queue")) {
     const api = await createHookCollabApiClient();
-    const drainPendingFinalizeQueue2 = drainPendingFinalizeQueue;
-    if (typeof drainPendingFinalizeQueue2 === "function") {
-      await drainPendingFinalizeQueue2({ api });
+    const drainPendingFinalizeQueue3 = drainPendingFinalizeQueue;
+    if (typeof drainPendingFinalizeQueue3 === "function") {
+      await drainPendingFinalizeQueue3({ api });
     }
     return;
   }