@remixhq/claude-plugin 0.1.22 → 0.1.24

package/dist/hook-stop-collab.cjs

@@ -540,17 +540,23 @@ __export(hook_stop_collab_exports, {
 module.exports = __toCommonJS(hook_stop_collab_exports);
 var import_node_child_process9 = require("child_process");
 
-// node_modules/@remixhq/core/dist/chunk-YZ34ICNN.js
+// node_modules/@remixhq/core/dist/chunk-7XJGOKEO.js
 var RemixError = class extends Error {
   code;
   exitCode;
   hint;
+  // HTTP status code when this error originates from an API response.
+  // null for non-HTTP errors (validation, local IO, programming bugs).
+  // Callers use this to distinguish transient (5xx) from permanent (4xx)
+  // API failures without resorting to error-message string matching.
+  statusCode;
   constructor(message, opts) {
     super(message);
     this.name = "RemixError";
     this.code = opts?.code ?? null;
     this.exitCode = opts?.exitCode ?? 1;
     this.hint = opts?.hint ?? null;
+    this.statusCode = opts?.statusCode ?? null;
   }
 };
 
@@ -7329,7 +7335,7 @@ var {
   getCancelSignal: getCancelSignal2
 } = getIpcExport();
 
-// node_modules/@remixhq/core/dist/chunk-WT6VRLXU.js
+// node_modules/@remixhq/core/dist/chunk-S4ECO35X.js
 async function runGit(args, cwd) {
   const res = await execa("git", args, { cwd, stderr: "ignore" });
   return String(res.stdout || "").trim();
@@ -7384,7 +7390,7 @@ function summarizeUnifiedDiff(diff) {
   return { changedFilesCount, insertions, deletions };
 }
 
-// node_modules/@remixhq/core/dist/chunk-YCFLOHJV.js
+// node_modules/@remixhq/core/dist/chunk-DBVN42RF.js
 var import_promises12 = __toESM(require("fs/promises"), 1);
 var import_path = __toESM(require("path"), 1);
 var import_promises13 = __toESM(require("fs/promises"), 1);
@@ -7683,6 +7689,8 @@ function buildAppDeltaCacheKey(appId, payload) {
     appId,
     payload.baseHeadHash,
     payload.targetHeadHash ?? "",
+    payload.baseRevisionId ?? "",
+    payload.targetRevisionId ?? "",
     payload.localSnapshotHash ?? "",
     payload.repoFingerprint ?? "",
     payload.remoteUrl ?? "",
@@ -7929,11 +7937,11 @@ async function readLocalBaseline(params) {
     const raw = await import_promises15.default.readFile(getBaselinePath(params), "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") return null;
-    if (parsed.schemaVersion !== 1 || typeof parsed.key !== "string" || typeof parsed.repoRoot !== "string") {
+    if (![1, 2].includes(Number(parsed.schemaVersion)) || typeof parsed.key !== "string" || typeof parsed.repoRoot !== "string") {
       return null;
     }
     return {
-      schemaVersion: 1,
+      schemaVersion: Number(parsed.schemaVersion) === 2 ? 2 : 1,
       key: parsed.key,
       repoRoot: parsed.repoRoot,
       repoFingerprint: parsed.repoFingerprint ?? null,
@@ -7942,6 +7950,8 @@ async function readLocalBaseline(params) {
       branchName: parsed.branchName ?? null,
       lastSnapshotId: parsed.lastSnapshotId ?? null,
       lastSnapshotHash: parsed.lastSnapshotHash ?? null,
+      lastServerRevisionId: parsed.lastServerRevisionId ?? null,
+      lastServerTreeHash: parsed.lastServerTreeHash ?? null,
       lastServerHeadHash: parsed.lastServerHeadHash ?? null,
       lastSeenLocalCommitHash: parsed.lastSeenLocalCommitHash ?? null,
       updatedAt: String(parsed.updatedAt ?? "")
@@ -7953,7 +7963,7 @@ async function readLocalBaseline(params) {
 async function writeLocalBaseline(baseline) {
   const key = buildLaneStateKey(baseline);
   const normalized = {
-    schemaVersion: 1,
+    schemaVersion: 2,
     key,
     repoRoot: baseline.repoRoot,
     repoFingerprint: baseline.repoFingerprint ?? null,
@@ -7962,6 +7972,8 @@ async function writeLocalBaseline(baseline) {
     branchName: baseline.branchName ?? null,
     lastSnapshotId: baseline.lastSnapshotId ?? null,
     lastSnapshotHash: baseline.lastSnapshotHash ?? null,
+    lastServerRevisionId: baseline.lastServerRevisionId ?? null,
+    lastServerTreeHash: baseline.lastServerTreeHash ?? null,
     lastServerHeadHash: baseline.lastServerHeadHash ?? null,
     lastSeenLocalCommitHash: baseline.lastSeenLocalCommitHash ?? null,
     updatedAt: baseline.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
@@ -8266,6 +8278,7 @@ function normalizeJob2(input) {
     prompt: input.prompt,
     assistantResponse: input.assistantResponse,
     baselineSnapshotId: input.baselineSnapshotId ?? null,
+    baselineServerRevisionId: input.baselineServerRevisionId ?? null,
     baselineServerHeadHash: input.baselineServerHeadHash ?? null,
     currentSnapshotId: input.currentSnapshotId,
     capturedAt: input.capturedAt ?? now,
@@ -8300,6 +8313,7 @@ async function readPendingFinalizeJob(jobId) {
       prompt: String(parsed.prompt ?? ""),
       assistantResponse: String(parsed.assistantResponse ?? ""),
       baselineSnapshotId: parsed.baselineSnapshotId ?? null,
+      baselineServerRevisionId: parsed.baselineServerRevisionId ?? null,
       baselineServerHeadHash: parsed.baselineServerHeadHash ?? null,
       currentSnapshotId: String(parsed.currentSnapshotId ?? ""),
       capturedAt: parsed.capturedAt,
@@ -8564,6 +8578,15 @@ function shouldRequireRemoteLaneForCurrentBranch(params) {
   if (params.currentBranch === defaultBranch) return false;
   return !params.binding.laneId || params.binding.currentAppId === params.binding.upstreamAppId;
 }
+function resolveLaneLookupProjectId(params) {
+  const currentBranch = normalizeBranchName2(params.currentBranch);
+  const defaultBranch = normalizeBranchName2(params.defaultBranch);
+  const localProjectId = params.localBinding.projectId ?? null;
+  if (currentBranch && currentBranch !== defaultBranch && localProjectId) {
+    return localProjectId;
+  }
+  return params.explicitRootProjectId ?? (params.requireRemoteLane ? void 0 : localProjectId ?? params.fallbackProjectId ?? void 0);
+}
 async function persistResolvedLane(repoRoot, binding) {
   await writeCollabBinding(repoRoot, {
     projectId: binding.projectId,
@@ -8642,7 +8665,14 @@ async function resolveActiveLaneBindingUncached(params, state) {
       };
     }
     const laneResp2 = await params.api.resolveProjectLaneBinding({
-      projectId: state.explicitRootBinding?.projectId ?? (requireRemoteLane ? void 0 : localBinding.projectId ?? state.projectId ?? void 0),
+      projectId: resolveLaneLookupProjectId({
+        explicitRootProjectId: state.explicitRootBinding?.projectId,
+        localBinding,
+        currentBranch,
+        defaultBranch: state.defaultBranch,
+        requireRemoteLane,
+        fallbackProjectId: state.projectId
+      }),
       repoFingerprint: state.repoFingerprint ?? void 0,
       remoteUrl: state.remoteUrl ?? void 0,
       defaultBranch: state.defaultBranch ?? void 0,
@@ -8801,6 +8831,8 @@ function buildBaseState() {
     branchName: null,
     localCommitHash: null,
     currentSnapshotHash: null,
+    currentServerRevisionId: null,
+    currentServerTreeHash: null,
     currentServerHeadHash: null,
     currentServerHeadCommitId: null,
     worktreeClean: false,
@@ -8834,6 +8866,8 @@ function buildBaseState() {
     baseline: {
       lastSnapshotId: null,
       lastSnapshotHash: null,
+      lastServerRevisionId: null,
+      lastServerTreeHash: null,
       lastServerHeadHash: null,
       lastSeenLocalCommitHash: null
     }
@@ -8960,6 +8994,8 @@ async function collabDetectRepoState(params) {
       summarizeAsyncJobs({ repoRoot, branchName: binding.branchName ?? null })
     ]);
     const appHead = unwrapResponseObject(headResp, "app head");
+    detected.currentServerRevisionId = appHead.headRevisionId ?? null;
+    detected.currentServerTreeHash = appHead.treeHash ?? null;
     detected.currentServerHeadHash = appHead.headCommitHash;
     detected.currentServerHeadCommitId = appHead.headCommitId;
     detected.currentSnapshotHash = inspection.snapshotHash;
@@ -8968,6 +9004,8 @@ async function collabDetectRepoState(params) {
     detected.baseline = {
       lastSnapshotId: baseline?.lastSnapshotId ?? null,
       lastSnapshotHash: baseline?.lastSnapshotHash ?? null,
+      lastServerRevisionId: baseline?.lastServerRevisionId ?? null,
+      lastServerTreeHash: baseline?.lastServerTreeHash ?? null,
       lastServerHeadHash: baseline?.lastServerHeadHash ?? null,
       lastSeenLocalCommitHash: baseline?.lastSeenLocalCommitHash ?? null
     };
@@ -8977,6 +9015,7 @@ async function collabDetectRepoState(params) {
           const bootstrapResp = await params.api.getAppDelta(binding.currentAppId, {
             baseHeadHash: localCommitHash,
             targetHeadHash: appHead.headCommitHash,
+            targetRevisionId: appHead.headRevisionId,
             repoFingerprint: binding.repoFingerprint ?? void 0,
             remoteUrl: binding.remoteUrl ?? void 0,
             defaultBranch: binding.defaultBranch ?? void 0
@@ -8999,7 +9038,7 @@ async function collabDetectRepoState(params) {
         }
       }
       detected.repoState = "external_local_base_changed";
-      detected.hint = "No local Remix baseline exists for this lane yet. Run `remix collab re-anchor` to anchor this checkout.";
+      detected.hint = "No local Remix revision baseline exists for this lane yet. Run `remix collab init` or sync this lane to seed the baseline.";
       return detected;
     }
     const localHeadMovedSinceBaseline = Boolean(baseline.lastSeenLocalCommitHash) && localCommitHash !== baseline.lastSeenLocalCommitHash;
@@ -9018,7 +9057,30 @@ async function collabDetectRepoState(params) {
       return detected;
     }
     const localChanged = inspection.snapshotHash !== baseline.lastSnapshotHash;
-    const serverChanged = appHead.headCommitHash !== baseline.lastServerHeadHash;
+    const serverHeadChanged = appHead.headCommitHash !== baseline.lastServerHeadHash;
+    const revisionChanged = Boolean(
+      baseline.lastServerRevisionId && (appHead.headRevisionId ?? null) !== baseline.lastServerRevisionId
+    );
+    const equivalentRevisionDrift = revisionChanged && !serverHeadChanged;
+    if (equivalentRevisionDrift) {
+      await writeLocalBaseline({
+        repoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        laneId: binding.laneId,
+        currentAppId: binding.currentAppId,
+        branchName: binding.branchName,
+        lastSnapshotId: baseline.lastSnapshotId,
+        lastSnapshotHash: baseline.lastSnapshotHash,
+        lastServerRevisionId: appHead.headRevisionId ?? null,
+        lastServerTreeHash: appHead.treeHash ?? baseline.lastServerTreeHash ?? null,
+        lastServerHeadHash: appHead.headCommitHash,
+        lastSeenLocalCommitHash: baseline.lastSeenLocalCommitHash
+      });
+      detected.baseline.lastServerRevisionId = appHead.headRevisionId ?? null;
+      detected.baseline.lastServerTreeHash = appHead.treeHash ?? baseline.lastServerTreeHash ?? null;
+      detected.baseline.lastServerHeadHash = appHead.headCommitHash;
+    }
+    const serverChanged = serverHeadChanged;
     if (!localChanged && !serverChanged) {
       detected.repoState = "idle";
       return detected;
@@ -9442,6 +9504,7 @@ function buildWorkspaceMetadata(params) {
     recordingMode: "boundary_delta",
     baselineSnapshotId: params.baselineSnapshotId,
     currentSnapshotId: params.currentSnapshotId,
+    baselineServerRevisionId: params.baselineServerRevisionId ?? null,
     baselineServerHeadHash: params.baselineServerHeadHash,
     currentSnapshotHash: params.currentSnapshotHash,
     localCommitHash: params.localCommitHash,
@@ -9460,6 +9523,59 @@ function buildWorkspaceMetadata(params) {
   }
   return metadata;
 }
+async function findExistingChangeStepByIdempotency(params) {
+  const idempotencyKey = params.idempotencyKey?.trim();
+  if (!idempotencyKey) return null;
+  const resp = await params.api.listChangeSteps(params.appId, { limit: 1, idempotencyKey });
+  const responseObject = unwrapResponseObject(
+    resp,
+    "change step list"
+  );
+  const steps = Array.isArray(responseObject) ? responseObject : Array.isArray(responseObject.items) ? responseObject.items : [];
+  return steps.find((step) => step.idempotencyKey === idempotencyKey) ?? null;
+}
+async function writeBaselineFromSucceededChangeStep(params) {
+  const nextServerHeadHash = typeof params.changeStep.headCommitHash === "string" ? params.changeStep.headCommitHash.trim() : "";
+  if (!nextServerHeadHash) {
+    throw buildFinalizeCliError({
+      message: "Backend returned a succeeded change step without a head commit hash.",
+      exitCode: 1,
+      hint: "This is a backend invariant violation; retry will not help. Run `remix collab status` before trying again.",
+      disposition: "terminal",
+      reason: "missing_head_commit_hash"
+    });
+  }
+  let nextServerRevisionId = typeof params.changeStep.resultRevisionId === "string" ? params.changeStep.resultRevisionId.trim() : "";
+  let nextServerTreeHash = null;
+  if (!nextServerRevisionId) {
+    const freshHeadResp = await params.api.getAppHead(params.job.currentAppId);
+    const freshHead = unwrapResponseObject(freshHeadResp, "app head");
+    if (freshHead.headCommitHash !== nextServerHeadHash || !freshHead.headRevisionId) {
+      throw buildFinalizeCliError({
+        message: "Backend returned a succeeded change step without a matching result revision.",
+        exitCode: 1,
+        hint: "The local baseline was not advanced because the post-step revision could not be verified. Restart the backend/CLI and retry after checking `remix collab status`.",
+        disposition: "terminal",
+        reason: "missing_result_revision_id"
+      });
+    }
+    nextServerRevisionId = freshHead.headRevisionId;
+    nextServerTreeHash = freshHead.treeHash ?? null;
+  }
+  await writeLocalBaseline({
+    repoRoot: params.job.repoRoot,
+    repoFingerprint: params.job.repoFingerprint,
+    laneId: params.job.laneId,
+    currentAppId: params.job.currentAppId,
+    branchName: params.job.branchName,
+    lastSnapshotId: params.snapshot.id,
+    lastSnapshotHash: params.snapshot.snapshotHash,
+    lastServerRevisionId: nextServerRevisionId,
+    lastServerTreeHash: nextServerTreeHash,
+    lastServerHeadHash: nextServerHeadHash,
+    lastSeenLocalCommitHash: params.snapshot.localCommitHash
+  });
+}
 async function harvestPreTurnEvents(repoRoot, fromCommit, toCommit) {
   if (!toCommit) return null;
   try {
@@ -9520,12 +9636,12 @@ async function processClaimedPendingFinalizeJobInner(params) {
     throw buildFinalizeCliError({
       message: "Local baseline is missing for this queued finalize job.",
       exitCode: 2,
-      hint: "Run `remix collab re-anchor` to anchor the repository again.",
+      hint: "Run `remix collab init` to seed this checkout's revision baseline.",
       disposition: "terminal",
       reason: "baseline_missing"
     });
   }
-  const baselineDrifted = baseline.lastSnapshotId !== job.baselineSnapshotId || baseline.lastServerHeadHash !== job.baselineServerHeadHash;
+  const baselineDrifted = baseline.lastSnapshotId !== job.baselineSnapshotId || (job.baselineServerRevisionId ? baseline.lastServerRevisionId !== job.baselineServerRevisionId : false) || baseline.lastServerHeadHash !== job.baselineServerHeadHash;
   const appHead = unwrapResponseObject(appHeadResp, "app head");
   const remoteUrl = readMetadataString(job, "remoteUrl");
   const defaultBranch = readMetadataString(job, "defaultBranch");
@@ -9548,12 +9664,13 @@ async function processClaimedPendingFinalizeJobInner(params) {
       throw buildFinalizeCliError({
         message: "Finalize queue baseline drifted before this job was processed.",
         exitCode: 1,
-        hint: "Process queued finalize jobs in capture order, or re-anchor the repository before retrying.",
+        hint: "Process queued finalize jobs in capture order, or run `remix collab init` to refresh the revision baseline before retrying.",
         disposition: "terminal",
         reason: "baseline_drifted"
       });
     }
-    if (appHead.headCommitHash !== job.baselineServerHeadHash) {
+    const serverStillAtBaseline = job.baselineServerRevisionId ? appHead.headRevisionId === job.baselineServerRevisionId : appHead.headCommitHash === job.baselineServerHeadHash;
+    if (!serverStillAtBaseline) {
       throw buildFinalizeCliError({
         message: "Server lane changed before a no-diff turn could be recorded.",
         exitCode: 2,
@@ -9575,6 +9692,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
         defaultBranch,
         baselineSnapshotId: job.baselineSnapshotId,
         currentSnapshotId: job.currentSnapshotId,
+        baselineServerRevisionId: job.baselineServerRevisionId,
         baselineServerHeadHash: job.baselineServerHeadHash,
         currentSnapshotHash: snapshot.snapshotHash,
         localCommitHash: snapshot.localCommitHash,
@@ -9595,6 +9713,8 @@ async function processClaimedPendingFinalizeJobInner(params) {
       branchName: job.branchName,
       lastSnapshotId: snapshot.id,
       lastSnapshotHash: snapshot.snapshotHash,
+      lastServerRevisionId: appHead.headRevisionId ?? null,
+      lastServerTreeHash: appHead.treeHash ?? null,
       lastServerHeadHash: appHead.headCommitHash,
       lastSeenLocalCommitHash: snapshot.localCommitHash
     });
@@ -9615,14 +9735,14 @@ async function processClaimedPendingFinalizeJobInner(params) {
     };
   }
   const localBaselineAdvanced = baseline.lastSnapshotId !== job.baselineSnapshotId;
-  const serverHeadAdvanced = appHead.headCommitHash !== job.baselineServerHeadHash;
+  const serverHeadAdvanced = job.baselineServerRevisionId ? appHead.headRevisionId !== job.baselineServerRevisionId : appHead.headCommitHash !== job.baselineServerHeadHash;
   if (baselineDrifted) {
     const consistentAdvance = localBaselineAdvanced && serverHeadAdvanced;
     if (!consistentAdvance) {
       throw buildFinalizeCliError({
         message: `Finalize queue baseline advanced inconsistently before this job was processed (localBaselineAdvanced=${localBaselineAdvanced}, serverHeadAdvanced=${serverHeadAdvanced}, jobBaselineSnapshotId=${job.baselineSnapshotId ?? "null"}, liveBaselineSnapshotId=${baseline.lastSnapshotId ?? "null"}, jobBaselineServerHeadHash=${job.baselineServerHeadHash ?? "null"}, liveBaselineServerHeadHash=${baseline.lastServerHeadHash ?? "null"}, currentAppHeadHash=${appHead.headCommitHash}). This indicates local Remix state diverged from the backend in a way that should not be reachable in normal operation; please report this as a bug.`,
         exitCode: 1,
-        hint: "Run `remix collab status` to inspect, then `remix collab re-anchor` only if the lane has no valid baseline.",
+        hint: "Run `remix collab status` to inspect, then sync or reconcile before retrying.",
         disposition: "terminal",
         reason: "baseline_drifted"
       });
@@ -9630,6 +9750,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
   }
   let submissionDiff = diffResult.diff;
   let submissionBaseHeadHash = job.baselineServerHeadHash;
+  let submissionBaseRevisionId = job.baselineServerRevisionId;
   let replayedFromBaseHash = null;
   if (!submissionBaseHeadHash) {
     throw buildFinalizeCliError({
@@ -9640,6 +9761,34 @@ async function processClaimedPendingFinalizeJobInner(params) {
     });
   }
   const replayNeeded = appHead.headCommitHash !== submissionBaseHeadHash || baselineDrifted;
+  if (replayNeeded) {
+    const existingChangeStep = await findExistingChangeStepByIdempotency({
+      api: params.api,
+      appId: job.currentAppId,
+      idempotencyKey: job.idempotencyKey
+    });
+    if (existingChangeStep) {
+      const changeStep2 = existingChangeStep.status === "succeeded" ? existingChangeStep : await pollChangeStep(params.api, job.currentAppId, existingChangeStep.id);
+      invalidateAppHeadCache(job.currentAppId);
+      invalidateAppDeltaCacheForApp(job.currentAppId);
+      await writeBaselineFromSucceededChangeStep({ api: params.api, job, snapshot, changeStep: changeStep2 });
+      await updatePendingFinalizeJob(job.id, {
+        status: "completed",
+        metadata: { changeStepId: String(changeStep2.id ?? "") }
+      });
+      return {
+        mode: "changed_turn",
+        idempotencyKey: job.idempotencyKey ?? "",
+        queued: false,
+        jobId: job.id,
+        repoState,
+        changeStep: changeStep2,
+        collabTurn: null,
+        autoSync: null,
+        warnings: []
+      };
+    }
+  }
   if (replayNeeded) {
     try {
       const replayResp = await params.api.startChangeStepReplay(job.currentAppId, {
@@ -9647,7 +9796,9 @@ async function processClaimedPendingFinalizeJobInner(params) {
         assistantResponse: job.assistantResponse,
         diff: diffResult.diff,
         baseCommitHash: submissionBaseHeadHash,
+        baseRevisionId: job.baselineServerRevisionId,
         targetHeadCommitHash: appHead.headCommitHash,
+        targetRevisionId: appHead.headRevisionId,
         expectedPaths: diffResult.changedPaths,
         actor,
         workspaceMetadata: buildWorkspaceMetadata({
@@ -9657,6 +9808,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
           defaultBranch,
           baselineSnapshotId: job.baselineSnapshotId,
           currentSnapshotId: job.currentSnapshotId,
+          baselineServerRevisionId: job.baselineServerRevisionId,
           baselineServerHeadHash: job.baselineServerHeadHash,
           currentSnapshotHash: snapshot.snapshotHash,
           localCommitHash: snapshot.localCommitHash,
@@ -9682,6 +9834,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
       submissionDiff = replayDiff.diff;
       replayedFromBaseHash = submissionBaseHeadHash;
       submissionBaseHeadHash = appHead.headCommitHash;
+      submissionBaseRevisionId = appHead.headRevisionId;
     } catch (error) {
       if (error instanceof RemixError && error.finalizeDisposition === void 0) {
         const detail = error.hint ? `${error.message} (${error.hint})` : error.message;
@@ -9703,6 +9856,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
     assistantResponse: job.assistantResponse,
     diff: submissionDiff,
     baseCommitHash: submissionBaseHeadHash,
+    baseRevisionId: submissionBaseRevisionId,
     headCommitHash: submissionBaseHeadHash,
     changedFilesCount: diffResult.stats.changedFilesCount,
     insertions: diffResult.stats.insertions,
@@ -9715,6 +9869,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
       defaultBranch,
       baselineSnapshotId: job.baselineSnapshotId,
       currentSnapshotId: job.currentSnapshotId,
+      baselineServerRevisionId: job.baselineServerRevisionId,
       baselineServerHeadHash: job.baselineServerHeadHash,
       currentSnapshotHash: snapshot.snapshotHash,
       localCommitHash: snapshot.localCommitHash,
@@ -9731,27 +9886,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
   const changeStep = await pollChangeStep(params.api, job.currentAppId, String(createdStep.id));
   invalidateAppHeadCache(job.currentAppId);
   invalidateAppDeltaCacheForApp(job.currentAppId);
-  const nextServerHeadHash = typeof changeStep.headCommitHash === "string" ? changeStep.headCommitHash.trim() : "";
-  if (!nextServerHeadHash) {
-    throw buildFinalizeCliError({
-      message: "Backend returned a succeeded change step without a head commit hash.",
-      exitCode: 1,
-      hint: "This is a backend invariant violation; retry will not help. Re-anchor and try again.",
-      disposition: "terminal",
-      reason: "missing_head_commit_hash"
-    });
-  }
-  await writeLocalBaseline({
-    repoRoot: job.repoRoot,
-    repoFingerprint: job.repoFingerprint,
-    laneId: job.laneId,
-    currentAppId: job.currentAppId,
-    branchName: job.branchName,
-    lastSnapshotId: snapshot.id,
-    lastSnapshotHash: snapshot.snapshotHash,
-    lastServerHeadHash: nextServerHeadHash,
-    lastSeenLocalCommitHash: snapshot.localCommitHash
-  });
+  await writeBaselineFromSucceededChangeStep({ api: params.api, job, snapshot, changeStep });
   await updatePendingFinalizeJob(job.id, {
     status: "completed",
     metadata: { changeStepId: String(changeStep.id ?? "") }
@@ -9780,6 +9915,7 @@ async function enqueueCapturedFinalizeTurn(params) {
     prompt: params.prompt,
     assistantResponse: params.assistantResponse,
     baselineSnapshotId: params.baselineSnapshotId,
+    baselineServerRevisionId: params.baselineServerRevisionId ?? null,
     baselineServerHeadHash: params.baselineServerHeadHash,
     currentSnapshotId: params.currentSnapshotId,
     idempotencyKey: params.idempotencyKey,
@@ -9878,17 +10014,6 @@ async function collabFinalizeTurn(params) {
       });
     }
   }
-  const pendingReAnchor = await findPendingAsyncJob({
-    repoRoot,
-    branchName: binding.branchName ?? null,
-    kind: "re_anchor"
-  });
-  if (pendingReAnchor) {
-    throw new RemixError("Cannot finalize a turn while a re-anchor is still processing.", {
-      exitCode: 2,
-      hint: `Re-anchor job ${pendingReAnchor.id} is still in the background queue. Run \`remix collab status\` to check progress.`
-    });
-  }
   const detected = await collabDetectRepoState({
     api: params.api,
     cwd: repoRoot,
@@ -9929,9 +10054,16 @@ async function collabFinalizeTurn(params) {
       hint: detected.hint
     });
   }
+  if (detected.repoState === "both_changed") {
+    throw new RemixError("Local and server changes must be reconciled before finalizing this turn.", {
+      code: "reconcile_required",
+      exitCode: 2,
+      hint: detected.hint || "Run `remix collab reconcile --dry-run` to inspect recovery options before retrying."
+    });
+  }
   if (detected.repoState === "external_local_base_changed") {
-    throw new RemixError("The local checkout must be re-anchored before finalizing this turn.", {
-      code: "re_anchor_required",
+    throw new RemixError("The local checkout is missing a Remix revision baseline for this lane.", {
+      code: "baseline_missing",
       exitCode: 2,
       hint: detected.hint
     });
@@ -9943,8 +10075,9 @@ async function collabFinalizeTurn(params) {
   });
   if (!baseline) {
     throw new RemixError("Local Remix baseline is missing for this lane.", {
+      code: "baseline_missing",
       exitCode: 2,
-      hint: "Run `remix collab re-anchor` to create a fresh baseline."
+      hint: "Run `remix collab init` or sync this lane to create a fresh revision baseline."
     });
   }
   const snapshot = await captureLocalSnapshot({
@@ -9955,10 +10088,11 @@ async function collabFinalizeTurn(params) {
   });
   const mode = snapshot.snapshotHash === baseline.lastSnapshotHash ? "no_diff_turn" : "changed_turn";
   const idempotencyKey = params.idempotencyKey?.trim() || buildDeterministicIdempotencyKey({
-    kind: "collab_finalize_turn_boundary_v1",
+    kind: "collab_finalize_turn_boundary_v2",
     appId: binding.currentAppId,
     laneId: binding.laneId,
     baselineSnapshotId: baseline.lastSnapshotId,
+    baselineServerRevisionId: baseline.lastServerRevisionId,
     baselineServerHeadHash: baseline.lastServerHeadHash,
     currentSnapshotId: snapshot.id,
     currentSnapshotHash: snapshot.snapshotHash,
@@ -9978,6 +10112,7 @@ async function collabFinalizeTurn(params) {
     prompt,
     assistantResponse,
     baselineSnapshotId: baseline.lastSnapshotId,
+    baselineServerRevisionId: baseline.lastServerRevisionId,
     baselineServerHeadHash: baseline.lastServerHeadHash,
     currentSnapshotId: snapshot.id,
     idempotencyKey,
@@ -10024,9 +10159,10 @@ var FINALIZE_PREFLIGHT_FAILURE_CODES = [
   // Server has commits we don't. Fix: `remix collab sync` (safe to
   // auto-run for fast-forward; non-FF refused by the command itself).
   "pull_required",
-  // Local base hash doesn't match the recorded baseline (force-push,
-  // hard reset, rebase). Fix: `remix collab re-anchor`.
-  "re_anchor_required"
+  // Both local and server changed. Fix: inspect and apply reconcile.
+  "reconcile_required",
+  // Local revision baseline is missing. Fix: `remix collab init` or sync.
+  "baseline_missing"
 ];
 var CODE_SET = new Set(FINALIZE_PREFLIGHT_FAILURE_CODES);
 function isFinalizePreflightFailureCode(value) {
@@ -10438,7 +10574,7 @@ async function clearPendingTurnState(sessionId) {
 // package.json
 var package_default = {
   name: "@remixhq/claude-plugin",
-  version: "0.1.22",
+  version: "0.1.24",
   description: "Claude Code plugin for Remix collaboration workflows",
   homepage: "https://github.com/RemixDotOne/remix-claude-plugin",
   license: "MIT",
@@ -10476,8 +10612,8 @@ var package_default = {
     prepack: "npm run build"
   },
   dependencies: {
-    "@remixhq/core": "^0.1.17",
-    "@remixhq/mcp": "^0.1.17"
+    "@remixhq/core": "^0.1.19",
+    "@remixhq/mcp": "^0.1.19"
   },
   devDependencies: {
     "@types/node": "^25.4.0",
@@ -10583,11 +10719,9 @@ var AUTO_FIX_COMMAND = {
   // 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"],
+  // Local revision baseline is missing. Init seeds the branch/lane baseline
+  // without requiring the user to know about the recording internals.
+  baseline_missing: ["collab", "init"],
   // Server moved ahead. `collab sync` is fast-forward-safe by default;
   // it refuses non-FF on its own, so we don't need to gate here.
   pull_required: ["collab", "sync"]
@@ -10604,7 +10738,7 @@ var RECOMMENDED_USER_COMMAND = {
   missing_head: "remix collab status",
   remote_error: "remix collab status",
   pull_required: "remix collab sync",
-  re_anchor_required: "remix collab re-anchor"
+  baseline_missing: "remix collab init"
 };
 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`);
@@ -10759,6 +10893,7 @@ 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_MAX_ATTEMPTS = 10;
 var DEFERRED_TURN_TTL_MS = 24 * 60 * 60 * 1e3;
 var DEFERRED_TURN_DIR = "deferred-turns";
 function stateRoot2() {
@@ -10802,7 +10937,7 @@ async function readDeferredTurnFile(filePath) {
   if (!parsed || typeof parsed !== "object") return null;
   const record = parsed;
   if (record.schemaVersion !== DEFERRED_TURN_SCHEMA_VERSION) return null;
-  if (typeof record.sessionId !== "string" || typeof record.turnId !== "string" || typeof record.repoRoot !== "string" || typeof record.prompt !== "string" || typeof record.assistantResponse !== "string" || typeof record.submittedAt !== "string" || typeof record.deferredAt !== "string" || record.reason !== "current_branch_unbound" && record.reason !== "recovery_in_progress") {
+  if (typeof record.sessionId !== "string" || typeof record.turnId !== "string" || typeof record.repoRoot !== "string" || typeof record.prompt !== "string" || typeof record.assistantResponse !== "string" || typeof record.submittedAt !== "string" || typeof record.deferredAt !== "string" || record.reason !== "current_branch_unbound" && record.reason !== "recovery_in_progress" && record.reason !== "transient_recording_failure") {
     return null;
   }
   return {
@@ -10815,7 +10950,17 @@ async function readDeferredTurnFile(filePath) {
     submittedAt: record.submittedAt,
     deferredAt: record.deferredAt,
     reason: record.reason,
-    branchAtDefer: typeof record.branchAtDefer === "string" || record.branchAtDefer === null ? record.branchAtDefer : null
+    branchAtDefer: typeof record.branchAtDefer === "string" || record.branchAtDefer === null ? record.branchAtDefer : null,
+    // Additive fields: pre-appId-aware records on disk won't have these
+    // keys at all. Coerce missing/invalid to `null` (drainer treats
+    // null as "legacy, drain as today" — see drainer for the policy).
+    appIdAtDefer: typeof record.appIdAtDefer === "string" ? record.appIdAtDefer : null,
+    projectIdAtDefer: typeof record.projectIdAtDefer === "string" ? record.projectIdAtDefer : null,
+    // Pre-attemptCount records coerce to 0 — they've never been
+    // counted against the cap, so giving them the cap's full budget
+    // is correct (we'd rather over-retry a legacy record than drop it
+    // unexpectedly). Negative or non-finite values also coerce to 0.
+    attemptCount: typeof record.attemptCount === "number" && Number.isFinite(record.attemptCount) && record.attemptCount >= 0 ? Math.floor(record.attemptCount) : 0
   };
 }
 async function listDeferredTurnsForRepo(repoRoot) {
@@ -10878,16 +11023,35 @@ function buildDeferredTurnRecord(params) {
     submittedAt: params.submittedAt,
     deferredAt: (/* @__PURE__ */ new Date()).toISOString(),
     reason: params.reason ?? "current_branch_unbound",
-    branchAtDefer: params.branchAtDefer
+    branchAtDefer: params.branchAtDefer,
+    appIdAtDefer: params.appIdAtDefer ?? null,
+    projectIdAtDefer: params.projectIdAtDefer ?? null,
+    // Fresh records start at zero attempts — the next drain pass will
+    // be the first attempt and bump this to 1 if it fails.
+    attemptCount: 0
   };
 }
+async function recordDeferredTurnFailedAttempt(filePath) {
+  const current = await readDeferredTurnFile(filePath);
+  if (!current) {
+    return { promoted: true, finalAttemptCount: DEFERRED_TURN_MAX_ATTEMPTS };
+  }
+  const newAttemptCount = current.attemptCount + 1;
+  if (newAttemptCount >= DEFERRED_TURN_MAX_ATTEMPTS) {
+    await deleteDeferredTurnFile(filePath);
+    return { promoted: true, finalAttemptCount: newAttemptCount };
+  }
+  const next = { ...current, attemptCount: newAttemptCount };
+  await writeDeferredTurn(next);
+  return { promoted: false, newAttemptCount };
+}
 
 // src/deferred-turn-drainer.ts
 var import_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
+// node_modules/@remixhq/core/dist/chunk-C2FOZ3O7.js
 async function readJsonSafe(res) {
   const ct = res.headers.get("content-type") ?? "";
   if (!ct.toLowerCase().includes("application/json")) return null;
@@ -10900,8 +11064,13 @@ async function readJsonSafe(res) {
 function createApiClient(config, opts) {
   const apiKey = (opts?.apiKey ?? "").trim();
   const tokenProvider = opts?.tokenProvider;
+  const defaultTimeoutMs = typeof opts?.defaultRequestTimeoutMs === "number" && opts.defaultRequestTimeoutMs > 0 ? opts.defaultRequestTimeoutMs : null;
   const CLIENT_KEY_HEADER = "x-comerge-api-key";
-  async function request(path16, init) {
+  function makeTimeoutSignal(timeoutMs) {
+    const ms = typeof timeoutMs === "number" && timeoutMs > 0 ? timeoutMs : defaultTimeoutMs;
+    return ms != null ? AbortSignal.timeout(ms) : void 0;
+  }
+  async function request(path16, init, opts2) {
     if (!tokenProvider) {
       throw new RemixError("API client is missing a token provider.", {
         exitCode: 1,
@@ -10912,6 +11081,7 @@ function createApiClient(config, opts) {
     const url = new URL(path16, config.apiUrl).toString();
     const doFetch = async (bearer) => fetch(url, {
       ...init,
+      signal: makeTimeoutSignal(opts2?.timeoutMs),
       headers: {
         Accept: "application/json",
         "Content-Type": "application/json",
@@ -10928,12 +11098,16 @@ function createApiClient(config, opts) {
     if (!res.ok) {
       const body = await readJsonSafe(res);
       const msg = (body && typeof body === "object" && body && "message" in body && typeof body.message === "string" ? body.message : null) ?? `Request failed (status ${res.status})`;
-      throw new RemixError(msg, { exitCode: 1, hint: body ? JSON.stringify(body, null, 2) : null });
+      throw new RemixError(msg, {
+        exitCode: 1,
+        hint: body ? JSON.stringify(body, null, 2) : null,
+        statusCode: res.status
+      });
     }
     const json = await readJsonSafe(res);
     return json ?? null;
   }
-  async function requestBinary(path16, init) {
+  async function requestBinary(path16, init, opts2) {
     if (!tokenProvider) {
       throw new RemixError("API client is missing a token provider.", {
         exitCode: 1,
@@ -10944,6 +11118,7 @@ function createApiClient(config, opts) {
     const url = new URL(path16, config.apiUrl).toString();
     const doFetch = async (bearer) => fetch(url, {
       ...init,
+      signal: makeTimeoutSignal(opts2?.timeoutMs),
       headers: {
         Accept: "*/*",
         ...init?.headers ?? {},
@@ -10959,7 +11134,11 @@ function createApiClient(config, opts) {
     if (!res.ok) {
       const body = await readJsonSafe(res);
       const msg = (body && typeof body === "object" && body && "message" in body && typeof body.message === "string" ? body.message : null) ?? `Request failed (status ${res.status})`;
-      throw new RemixError(msg, { exitCode: 1, hint: body ? JSON.stringify(body, null, 2) : null });
+      throw new RemixError(msg, {
+        exitCode: 1,
+        hint: body ? JSON.stringify(body, null, 2) : null,
+        statusCode: res.status
+      });
     }
     const contentDisposition = res.headers.get("content-disposition") ?? "";
     const fileNameMatch = contentDisposition.match(/filename=\"([^\"]+)\"/i);
@@ -11066,6 +11245,14 @@ function createApiClient(config, opts) {
       method: "POST",
       body: JSON.stringify(payload)
     }),
+    listChangeSteps: (appId, params) => {
+      const qs = new URLSearchParams();
+      if (params?.limit !== void 0) qs.set("limit", String(params.limit));
+      if (params?.offset !== void 0) qs.set("offset", String(params.offset));
+      if (params?.idempotencyKey) qs.set("idempotencyKey", params.idempotencyKey);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/change-steps${suffix}`, { method: "GET" });
+    },
     createCollabTurn: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/collab-turns`, {
       method: "POST",
       body: JSON.stringify(payload)
@@ -15354,7 +15541,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// node_modules/@remixhq/core/dist/chunk-P6JHXOV4.js
+// node_modules/@remixhq/core/dist/chunk-XETDXVGM.js
 var import_promises22 = __toESM(require("fs/promises"), 1);
 var import_os3 = __toESM(require("os"), 1);
 var import_path7 = __toESM(require("path"), 1);
@@ -35299,7 +35486,7 @@ function shouldShowDeprecationWarning() {
 }
 if (shouldShowDeprecationWarning()) console.warn("\u26A0\uFE0F  Node.js 18 and below are deprecated and will no longer be supported in future versions of @supabase/supabase-js. Please upgrade to Node.js 20 or later. For more information, visit: https://github.com/orgs/supabase/discussions/37217");
 
-// node_modules/@remixhq/core/dist/chunk-P6JHXOV4.js
+// node_modules/@remixhq/core/dist/chunk-XETDXVGM.js
 var storedSessionSchema = external_exports.object({
   access_token: external_exports.string().min(1),
   refresh_token: external_exports.string().min(1),
@@ -35513,7 +35700,7 @@ function createSupabaseAuthHelpers(config) {
   };
 }
 
-// node_modules/@remixhq/core/dist/chunk-VM3CGCNX.js
+// node_modules/@remixhq/core/dist/chunk-XCZRNB35.js
 var DEFAULT_API_URL = "https://api.remix.one";
 var DEFAULT_SUPABASE_URL = "https://xtfxwbckjpfmqubnsusu.supabase.co";
 var DEFAULT_SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Inh0Znh3YmNranBmbXF1Ym5zdXN1Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjA2MDEyMzAsImV4cCI6MjA3NjE3NzIzMH0.dzWGAWrK4CvrmHVHzf8w7JlUZohdap0ZPnLZnABMV8s";
@@ -35551,6 +35738,7 @@ async function resolveConfig(_opts) {
 }
 
 // src/hook-auth.ts
+var HOOK_API_REQUEST_TIMEOUT_MS = 6e4;
 async function createHookCollabApiClient() {
   const config = await resolveConfig();
   const sessionStore = createLocalSessionStore();
@@ -35563,7 +35751,8 @@ async function createHookCollabApiClient() {
     }
   });
   return createApiClient(config, {
-    tokenProvider
+    tokenProvider,
+    defaultRequestTimeoutMs: HOOK_API_REQUEST_TIMEOUT_MS
   });
 }
 
@@ -35576,6 +35765,16 @@ var HOOK_ACTOR = {
   version: pluginMetadata.version,
   provider: "anthropic"
 };
+function getDrainerErrorDetails(error) {
+  if (error instanceof Error) {
+    const hint = typeof error.hint === "string" ? String(error.hint) : null;
+    const codeRaw = error.code;
+    const preflightCode = isFinalizePreflightFailureCode(codeRaw) ? codeRaw : null;
+    return { message: error.message || "Deferred turn recording failed.", hint, preflightCode };
+  }
+  const message = typeof error === "string" && error.trim() ? error.trim() : "Deferred turn recording failed.";
+  return { message, hint: null, preflightCode: null };
+}
 var DEFERRED_TURN_DRAIN_POLL_INTERVAL_MS = 3e3;
 var DEFERRED_TURN_DRAIN_MAX_WAIT_MS = 15 * 60 * 1e3;
 var DEFERRED_TURN_DRAIN_LOCK_HEARTBEAT_MS = 3e4;
@@ -35741,6 +35940,7 @@ async function runStandaloneDeferredTurnDrainer(repoRoot) {
   let api = null;
   let recordedTotal = 0;
   let failedTotal = 0;
+  let droppedTotal = 0;
   let exitReason = "queue_empty";
   try {
     while (true) {
@@ -35771,7 +35971,49 @@ async function runStandaloneDeferredTurnDrainer(repoRoot) {
       const bindingState = await readCollabBindingState(repoRoot).catch(() => null);
       const currentBranch = bindingState?.currentBranch ?? null;
       const isCurrentBranchBound = bindingState?.binding != null;
-      const attemptable = entries.filter(
+      const currentAppId = bindingState?.binding?.currentAppId ?? null;
+      const currentProjectId = bindingState?.binding?.projectId ?? bindingState?.projectId ?? null;
+      let droppedThisPass = 0;
+      const liveEntries = [];
+      for (const entry of entries) {
+        const appIdMismatch = entry.record.appIdAtDefer != null && currentAppId != null && entry.record.appIdAtDefer !== currentAppId;
+        const projectIdMismatch = entry.record.projectIdAtDefer != null && currentProjectId != null && entry.record.projectIdAtDefer !== currentProjectId;
+        if (appIdMismatch || projectIdMismatch) {
+          await deleteDeferredTurnFile(entry.filePath);
+          droppedThisPass += 1;
+          await appendHookDiagnosticsEvent({
+            hook: "deferredTurnDrainer",
+            sessionId: sessionMarker,
+            stage: "deferred_turn_dropped",
+            result: "info",
+            reason: appIdMismatch ? "app_id_mismatch" : "project_id_mismatch",
+            repoRoot,
+            fields: {
+              deferredTurnId: entry.record.turnId,
+              deferredSessionId: entry.record.sessionId,
+              appIdAtDefer: entry.record.appIdAtDefer,
+              projectIdAtDefer: entry.record.projectIdAtDefer,
+              currentAppId,
+              currentProjectId
+            }
+          });
+          continue;
+        }
+        liveEntries.push(entry);
+      }
+      if (droppedThisPass > 0) {
+        droppedTotal += droppedThisPass;
+      }
+      if (liveEntries.length === 0) {
+        const remaining = await listDeferredTurnsForRepo(repoRoot).catch(() => []);
+        if (remaining.length === 0) {
+          exitReason = "queue_empty";
+          break;
+        }
+        await sleep5(DEFERRED_TURN_DRAIN_POLL_INTERVAL_MS);
+        continue;
+      }
+      const attemptable = liveEntries.filter(
         (e) => isCurrentBranchBound && (!e.record.branchAtDefer || e.record.branchAtDefer === currentBranch)
       );
       if (attemptable.length === 0) {
@@ -35820,6 +36062,8 @@ async function runStandaloneDeferredTurnDrainer(repoRoot) {
         } else {
           failedThisPass += 1;
           failedTotal += 1;
+          const outcome = await recordDeferredTurnFailedAttempt(entry.filePath).catch(() => null);
+          const promoted = outcome?.promoted === true;
           await appendHookDiagnosticsEvent({
             hook: "deferredTurnDrainer",
             sessionId: sessionMarker,
@@ -35830,9 +36074,43 @@ async function runStandaloneDeferredTurnDrainer(repoRoot) {
             message: result.error instanceof Error ? result.error.message : String(result.error ?? ""),
             fields: {
               deferredTurnId: entry.record.turnId,
-              deferredSessionId: entry.record.sessionId
+              deferredSessionId: entry.record.sessionId,
+              attemptCount: outcome?.promoted === false ? outcome.newAttemptCount : outcome?.promoted === true ? outcome.finalAttemptCount : null,
+              promoted
             }
           });
+          if (promoted) {
+            const errorDetails = getDrainerErrorDetails(result.error);
+            await dispatchFinalizeFailure({
+              // The dispatcher only knows about the two real Claude hook
+              // entrypoints. The standalone drainer is logically a
+              // post-Stop background process and the marker we're about
+              // to write is consumed by the next prompt's UserPromptSubmit
+              // hook, so attributing the failure to "Stop" matches what
+              // the user will see.
+              hook: "Stop",
+              sessionId: sessionMarker,
+              turnId: entry.record.turnId,
+              repoRoot,
+              preflightCode: errorDetails.preflightCode,
+              message: `Deferred turn could not be recorded after ${outcome?.finalAttemptCount ?? "max"} attempts: ${errorDetails.message}`,
+              hint: errorDetails.hint
+            }).catch(async (dispatchErr) => {
+              await appendHookDiagnosticsEvent({
+                hook: "deferredTurnDrainer",
+                sessionId: sessionMarker,
+                stage: "deferred_turn_promotion_dispatch_failed",
+                result: "error",
+                reason: "exception",
+                repoRoot,
+                message: dispatchErr instanceof Error ? dispatchErr.message : String(dispatchErr),
+                fields: {
+                  deferredTurnId: entry.record.turnId,
+                  deferredSessionId: entry.record.sessionId
+                }
+              });
+            });
+          }
         }
       }
       if (recordedThisPass > 0) {
@@ -35885,6 +36163,7 @@ async function runStandaloneDeferredTurnDrainer(repoRoot) {
       fields: {
         recordedTotal,
         failedTotal,
+        droppedTotal,
         elapsedMs: Date.now() - startedAt
       }
     });
@@ -35931,6 +36210,20 @@ function spawnDeferredTurnDrainer(repoRoot) {
   child.unref();
 }
 
+// src/transient-failure.ts
+function isTransientRecordingFailure(error) {
+  if (!error || typeof error !== "object") return false;
+  if (error instanceof Error) {
+    if (error.name === "AbortError" || error.name === "TimeoutError") return true;
+    if (error instanceof TypeError && /fetch failed/i.test(error.message)) return true;
+  }
+  const candidate = error;
+  if (typeof candidate.statusCode === "number" && candidate.statusCode >= 500 && candidate.statusCode < 600) {
+    return true;
+  }
+  return false;
+}
+
 // node_modules/@remixhq/core/dist/history.js
 var import_promises24 = __toESM(require("fs/promises"), 1);
 async function readAndParseTranscript(transcriptPath) {
@@ -36618,11 +36911,12 @@ function getErrorDetails(error) {
     return {
       message: error.message || "Fallback Remix turn recording failed.",
       hint,
-      preflightCode
+      preflightCode,
+      isTransient: isTransientRecordingFailure(error)
     };
   }
   const message = typeof error === "string" && error.trim() ? error.trim() : "Fallback Remix turn recording failed.";
-  return { message, hint: null, preflightCode: null };
+  return { message, hint: null, preflightCode: null, isTransient: false };
 }
 function buildRepoIdempotencyKey(turnId, repo) {
   const repoToken = repo.currentAppId?.trim() || repo.repoRoot;
@@ -36934,7 +37228,12 @@ async function recordTouchedRepo(params) {
         // 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"
+        preflightCode: "not_bound",
+        // Missing-binding is a permanent state mismatch (the user
+        // unbinded mid-flight); not transient. Spell it out so the
+        // upstream loop routes via dispatchFinalizeFailure instead of
+        // silent defer.
+        isTransient: false
       };
       await markTouchedRepoRecordingFailure(sessionId, repo.repoRoot, {
         message: failure.message,
@@ -36994,7 +37293,11 @@ async function recordTouchedRepo(params) {
       message: details.message,
       fields: {
         hint: details.hint,
-        preflightCode: details.preflightCode
+        preflightCode: details.preflightCode,
+        // Logged so a hung backend or DNS hiccup is greppable in the
+        // diagnostics file alongside the Cursor mirror — the next
+        // prompt's drain log will pair with this for the recovery.
+        isTransient: details.isTransient
       }
     });
     return {
@@ -37004,7 +37307,8 @@ async function recordTouchedRepo(params) {
         repoRoot: repo.repoRoot,
         message: details.message,
         hint: details.hint,
-        preflightCode: details.preflightCode
+        preflightCode: details.preflightCode,
+        isTransient: details.isTransient
       }
     };
   }
@@ -37042,6 +37346,8 @@ async function drainDeferredTurnsForRepo(params) {
   const bindingState = await readCollabBindingState(repoRoot).catch(() => null);
   const currentBranch = bindingState?.currentBranch ?? null;
   const isCurrentBranchBound = bindingState?.binding != null;
+  const currentAppId = bindingState?.binding?.currentAppId ?? null;
+  const currentProjectId = bindingState?.binding?.projectId ?? bindingState?.projectId ?? null;
   await appendHookDiagnosticsEvent({
     hook,
     sessionId,
@@ -37052,14 +37358,41 @@ async function drainDeferredTurnsForRepo(params) {
     fields: {
       candidateCount: entries.length,
       currentBranch,
-      currentBranchBound: isCurrentBranchBound
+      currentBranchBound: isCurrentBranchBound,
+      currentAppId,
+      currentProjectId
     }
   });
   let recordedCount = 0;
   let skippedCount = 0;
   let failedCount = 0;
+  let droppedCount = 0;
   for (const entry of entries) {
     const { record, filePath } = entry;
+    const appIdMismatch = record.appIdAtDefer != null && currentAppId != null && record.appIdAtDefer !== currentAppId;
+    const projectIdMismatch = record.projectIdAtDefer != null && currentProjectId != null && record.projectIdAtDefer !== currentProjectId;
+    if (appIdMismatch || projectIdMismatch) {
+      droppedCount += 1;
+      await deleteDeferredTurnFile(filePath);
+      await appendHookDiagnosticsEvent({
+        hook,
+        sessionId,
+        turnId: triggerTurnId,
+        stage: "deferred_turn_dropped",
+        result: "info",
+        reason: appIdMismatch ? "app_id_mismatch" : "project_id_mismatch",
+        repoRoot,
+        fields: {
+          deferredTurnId: record.turnId,
+          deferredSessionId: record.sessionId,
+          appIdAtDefer: record.appIdAtDefer,
+          projectIdAtDefer: record.projectIdAtDefer,
+          currentAppId,
+          currentProjectId
+        }
+      });
+      continue;
+    }
     if (!isCurrentBranchBound || record.branchAtDefer && record.branchAtDefer !== currentBranch) {
       skippedCount += 1;
       await appendHookDiagnosticsEvent({
@@ -37110,6 +37443,8 @@ async function drainDeferredTurnsForRepo(params) {
       });
     } catch (recordErr) {
       failedCount += 1;
+      const outcome = await recordDeferredTurnFailedAttempt(filePath).catch(() => null);
+      const promoted = outcome?.promoted === true;
       await appendHookDiagnosticsEvent({
         hook,
         sessionId,
@@ -37121,9 +37456,38 @@ async function drainDeferredTurnsForRepo(params) {
         message: recordErr instanceof Error ? recordErr.message : String(recordErr),
         fields: {
           deferredTurnId: record.turnId,
-          deferredSessionId: record.sessionId
+          deferredSessionId: record.sessionId,
+          attemptCount: outcome?.promoted === false ? outcome.newAttemptCount : outcome?.promoted === true ? outcome.finalAttemptCount : null,
+          promoted
         }
       });
+      if (promoted) {
+        const errorDetails = getErrorDetails(recordErr);
+        await dispatchFinalizeFailure({
+          hook,
+          sessionId,
+          turnId: triggerTurnId,
+          repoRoot,
+          preflightCode: errorDetails.preflightCode,
+          message: `Deferred turn could not be recorded after ${outcome?.finalAttemptCount ?? "max"} attempts: ${errorDetails.message}`,
+          hint: errorDetails.hint
+        }).catch(async (dispatchErr) => {
+          await appendHookDiagnosticsEvent({
+            hook,
+            sessionId,
+            turnId: triggerTurnId,
+            stage: "deferred_turn_promotion_dispatch_failed",
+            result: "error",
+            reason: "exception",
+            repoRoot,
+            message: dispatchErr instanceof Error ? dispatchErr.message : String(dispatchErr),
+            fields: {
+              deferredTurnId: record.turnId,
+              deferredSessionId: record.sessionId
+            }
+          });
+        });
+      }
     }
   }
   try {
@@ -37167,14 +37531,75 @@ async function drainDeferredTurnsForRepo(params) {
     fields: {
       recordedCount,
       skippedCount,
-      failedCount
+      failedCount,
+      droppedCount
     }
   });
 }
+async function deferTurnForTransientFailure(params) {
+  const { hook, sessionId, turnId, repoRoot, prompt, assistantResponse, submittedAt, failureMessage } = params;
+  const bindingState = await readCollabBindingState(repoRoot).catch(() => null);
+  const branchAtDefer = bindingState?.currentBranch ?? null;
+  const appIdAtDefer = bindingState?.binding?.currentAppId ?? null;
+  const projectIdAtDefer = bindingState?.binding?.projectId ?? bindingState?.projectId ?? null;
+  try {
+    const deferredFilePath = await writeDeferredTurn(
+      buildDeferredTurnRecord({
+        sessionId,
+        turnId,
+        repoRoot,
+        prompt,
+        assistantResponse,
+        submittedAt,
+        branchAtDefer,
+        appIdAtDefer,
+        projectIdAtDefer,
+        reason: "transient_recording_failure"
+      })
+    );
+    await appendHookDiagnosticsEvent({
+      hook,
+      sessionId,
+      turnId,
+      stage: "turn_deferred",
+      result: "success",
+      reason: "transient_recording_failure",
+      repoRoot,
+      fields: {
+        deferredFilePath,
+        promptLength: prompt.length,
+        assistantResponseLength: assistantResponse.length,
+        branchAtDefer,
+        // Forwarded so the diagnostics timeline pairs the defer with
+        // the originating recording_failed event without needing a
+        // join across stages.
+        failureMessage
+      }
+    });
+    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: {
+        triggeredBy: "transient_recording_failure"
+      }
+    });
+    return null;
+  }
+}
 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;
+  const appIdAtDefer = bindingState?.binding?.currentAppId ?? null;
+  const projectIdAtDefer = bindingState?.binding?.projectId ?? bindingState?.projectId ?? null;
   try {
     const deferredFilePath = await writeDeferredTurn(
       buildDeferredTurnRecord({
@@ -37185,6 +37610,8 @@ async function deferTurnForRecoveryInProgress(params) {
         assistantResponse,
         submittedAt,
         branchAtDefer,
+        appIdAtDefer,
+        projectIdAtDefer,
         reason: "recovery_in_progress"
       })
     );
@@ -37299,6 +37726,7 @@ async function runHookStopCollab(payload) {
         let unboundBranchRepoRoot = null;
         let unboundBranchName = null;
         let unboundBranchKnownCount = 0;
+        let unboundProjectIdAtDefer = null;
         const candidateRepoRoot = await findBoundRepo(state.initialCwd).catch(() => null);
         if (candidateRepoRoot) {
           const bindingState = await readCollabBindingState(candidateRepoRoot).catch(() => null);
@@ -37308,6 +37736,7 @@ async function runHookStopCollab(payload) {
             unboundBranchRepoRoot = candidateRepoRoot;
             unboundBranchName = bindingState.currentBranch;
             unboundBranchKnownCount = knownBoundBranches.length;
+            unboundProjectIdAtDefer = bindingState.projectId ?? null;
           }
         }
         const promptTextForDefer = state.prompt.trim();
@@ -37323,7 +37752,12 @@ async function runHookStopCollab(payload) {
                 prompt: promptTextForDefer,
                 assistantResponse: assistantResponseForDefer,
                 submittedAt: state.submittedAt,
-                branchAtDefer: unboundBranchName
+                branchAtDefer: unboundBranchName,
+                // No appId for an unbound lane (the binding is null
+                // by construction); project id still anchors against
+                // `force-new`-style identity rotations.
+                appIdAtDefer: null,
+                projectIdAtDefer: unboundProjectIdAtDefer
               })
             );
           } catch (deferErr) {
@@ -37539,6 +37973,22 @@ async function runHookStopCollab(payload) {
     let deferredFailureCount = 0;
     let dispatchFailureCount = 0;
     for (const failure of failures) {
+      if (failure.isTransient) {
+        const deferredFilePath = await deferTurnForTransientFailure({
+          hook,
+          sessionId,
+          turnId: state.turnId,
+          repoRoot: failure.repoRoot,
+          prompt,
+          assistantResponse,
+          submittedAt: state.submittedAt,
+          failureMessage: failure.message
+        });
+        if (deferredFilePath) {
+          deferredFailureCount += 1;
+        }
+        continue;
+      }
       const outcome = await dispatchFinalizeFailure({
         hook: "Stop",
         sessionId,