@remixhq/core 0.1.17 → 0.1.19

package/dist/collab.js

@@ -8,7 +8,7 @@ import {
   writeCollabBinding,
   writeCollabBindingSnapshot,
   writeJsonAtomic
-} from "./chunk-YCFLOHJV.js";
+} from "./chunk-DBVN42RF.js";
 import {
   applyUnifiedDiffToWorktree,
   assertRepoSnapshotUnchanged,
@@ -30,13 +30,13 @@ import {
   requireCurrentBranch,
   setRemoteOriginUrl,
   summarizeUnifiedDiff
-} from "./chunk-WT6VRLXU.js";
+} from "./chunk-S4ECO35X.js";
 import {
   REMIX_ERROR_CODES
 } from "./chunk-GC2MOT3U.js";
 import {
   RemixError
-} from "./chunk-YZ34ICNN.js";
+} from "./chunk-7XJGOKEO.js";
 
 // src/application/collab/appDeltaCache.ts
 var APP_DELTA_CACHE_TTL_MS = 5e3;
@@ -47,6 +47,8 @@ function buildAppDeltaCacheKey(appId, payload) {
     appId,
     payload.baseHeadHash,
     payload.targetHeadHash ?? "",
+    payload.baseRevisionId ?? "",
+    payload.targetRevisionId ?? "",
     payload.localSnapshotHash ?? "",
     payload.repoFingerprint ?? "",
     payload.remoteUrl ?? "",
@@ -189,9 +191,6 @@ function getAsyncJobDir(jobId) {
 function getAsyncJobFilePath(jobId) {
   return path.join(getAsyncJobDir(jobId), "job.json");
 }
-function getAsyncJobBundlePath(jobId) {
-  return path.join(getAsyncJobDir(jobId), "bundle.bundle");
-}
 function getLogsRoot() {
   return path.join(getCollabStateRoot(), "logs");
 }
@@ -493,11 +492,11 @@ async function readLocalBaseline(params) {
     const raw = await fs2.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,
@@ -506,6 +505,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 ?? "")
@@ -517,7 +518,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,
@@ -526,6 +527,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()
@@ -912,6 +915,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,
@@ -946,6 +950,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,
@@ -1462,6 +1467,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 = normalizeBranchName(params.currentBranch);
+  const defaultBranch = normalizeBranchName(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,
@@ -1540,7 +1554,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,
@@ -1701,6 +1722,8 @@ function buildBaseState() {
     branchName: null,
     localCommitHash: null,
     currentSnapshotHash: null,
+    currentServerRevisionId: null,
+    currentServerTreeHash: null,
     currentServerHeadHash: null,
     currentServerHeadCommitId: null,
     worktreeClean: false,
@@ -1734,6 +1757,8 @@ function buildBaseState() {
     baseline: {
       lastSnapshotId: null,
       lastSnapshotHash: null,
+      lastServerRevisionId: null,
+      lastServerTreeHash: null,
       lastServerHeadHash: null,
       lastSeenLocalCommitHash: null
     }
@@ -1860,6 +1885,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;
@@ -1868,6 +1895,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
     };
@@ -1877,6 +1906,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
@@ -1899,7 +1929,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;
@@ -1918,7 +1948,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;
@@ -2347,6 +2400,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,
@@ -2365,6 +2419,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 {
@@ -2425,12 +2532,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");
@@ -2453,12 +2560,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,
@@ -2480,6 +2588,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
         defaultBranch,
         baselineSnapshotId: job.baselineSnapshotId,
         currentSnapshotId: job.currentSnapshotId,
+        baselineServerRevisionId: job.baselineServerRevisionId,
         baselineServerHeadHash: job.baselineServerHeadHash,
         currentSnapshotHash: snapshot.snapshotHash,
         localCommitHash: snapshot.localCommitHash,
@@ -2500,6 +2609,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
     });
@@ -2520,14 +2631,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"
       });
@@ -2535,6 +2646,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
   }
   let submissionDiff = diffResult.diff;
   let submissionBaseHeadHash = job.baselineServerHeadHash;
+  let submissionBaseRevisionId = job.baselineServerRevisionId;
   let replayedFromBaseHash = null;
   if (!submissionBaseHeadHash) {
     throw buildFinalizeCliError({
@@ -2545,6 +2657,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, {
@@ -2552,7 +2692,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({
@@ -2562,6 +2704,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
           defaultBranch,
           baselineSnapshotId: job.baselineSnapshotId,
           currentSnapshotId: job.currentSnapshotId,
+          baselineServerRevisionId: job.baselineServerRevisionId,
           baselineServerHeadHash: job.baselineServerHeadHash,
           currentSnapshotHash: snapshot.snapshotHash,
           localCommitHash: snapshot.localCommitHash,
@@ -2587,6 +2730,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;
@@ -2608,6 +2752,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
     assistantResponse: job.assistantResponse,
     diff: submissionDiff,
     baseCommitHash: submissionBaseHeadHash,
+    baseRevisionId: submissionBaseRevisionId,
     headCommitHash: submissionBaseHeadHash,
     changedFilesCount: diffResult.stats.changedFilesCount,
     insertions: diffResult.stats.insertions,
@@ -2620,6 +2765,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
       defaultBranch,
       baselineSnapshotId: job.baselineSnapshotId,
       currentSnapshotId: job.currentSnapshotId,
+      baselineServerRevisionId: job.baselineServerRevisionId,
       baselineServerHeadHash: job.baselineServerHeadHash,
       currentSnapshotHash: snapshot.snapshotHash,
       localCommitHash: snapshot.localCommitHash,
@@ -2636,27 +2782,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 ?? "") }
@@ -2702,6 +2828,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,
@@ -2802,17 +2929,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,
@@ -2853,9 +2969,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
     });
@@ -2867,8 +2990,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({
@@ -2879,10 +3003,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,
@@ -2902,6 +3027,7 @@ async function collabFinalizeTurn(params) {
     prompt,
     assistantResponse,
     baselineSnapshotId: baseline.lastSnapshotId,
+    baselineServerRevisionId: baseline.lastServerRevisionId,
     baselineServerHeadHash: baseline.lastServerHeadHash,
     currentSnapshotId: snapshot.id,
     idempotencyKey,
@@ -2950,9 +3076,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) {
@@ -3011,7 +3138,7 @@ async function collabRecordingPreflight(params) {
   if (detected.status === "branch_mismatch") return { status: "branch_mismatch", ...base };
   if (detected.repoState === "server_only_changed") return { status: "pull_required", ...base };
   if (detected.repoState === "both_changed") return { status: "reconcile_required", ...base };
-  if (detected.repoState === "external_local_base_changed") return { status: "re_anchor_required", ...base };
+  if (detected.repoState === "external_local_base_changed") return { status: "baseline_missing", ...base };
   return { status: "ready", ...base };
 }
 
@@ -3238,7 +3365,7 @@ async function ensureWorkspaceMatchesBaseline(params) {
   if (!baseline?.lastSnapshotHash || !baseline.lastServerHeadHash) {
     throw new RemixError("Local Remix baseline is missing for this lane.", {
       exitCode: 2,
-      hint: "Run `remix collab re-anchor` to create a fresh baseline before applying server changes."
+      hint: "Run `remix collab init` or sync from a checkout with a valid revision baseline before applying server changes."
     });
   }
   const inspection = await inspectLocalSnapshot({
@@ -3312,11 +3439,12 @@ async function collabSync(params) {
   const repoSnapshot = await captureRepoSnapshot(repoRoot, { includeWorkspaceDiffHash: true });
   const bootstrapFromLocalHead = !detected.baseline.lastSnapshotHash || !detected.baseline.lastServerHeadHash;
   let baselineServerHeadHash;
+  let baselineServerRevisionId = null;
   if (bootstrapFromLocalHead) {
     if (!headCommitHash) {
       throw new RemixError("Failed to resolve local HEAD commit for the initial sync bootstrap.", {
         exitCode: 1,
-        hint: "Retry after Git HEAD is available, or run `remix collab re-anchor` if this checkout has no local Remix baseline yet."
+        hint: "Retry after Git HEAD is available, or run `remix collab init` to seed this checkout's revision baseline."
       });
     }
     baselineServerHeadHash = headCommitHash;
@@ -3331,13 +3459,15 @@ async function collabSync(params) {
     if (!baseline.lastServerHeadHash) {
       throw new RemixError("Local Remix baseline is missing the last acknowledged server head.", {
         exitCode: 2,
-        hint: "Run `remix collab re-anchor` to create a fresh baseline before pulling server changes."
+        hint: "Run `remix collab init` or sync from a checkout with a valid revision baseline before pulling server changes."
       });
     }
     baselineServerHeadHash = baseline.lastServerHeadHash;
+    baselineServerRevisionId = baseline.lastServerRevisionId;
   }
   const deltaResp = await params.api.getAppDelta(binding.currentAppId, {
     baseHeadHash: baselineServerHeadHash,
+    baseRevisionId: baselineServerRevisionId,
     repoFingerprint: binding.repoFingerprint ?? void 0,
     remoteUrl: binding.remoteUrl ?? void 0,
     defaultBranch: binding.defaultBranch ?? void 0
@@ -3361,13 +3491,54 @@ async function collabSync(params) {
     applied: false,
     dryRun: params.dryRun
   };
-  if (params.dryRun || delta.status === "up_to_date") {
+  if (params.dryRun) {
     return previewResult;
   }
+  if (delta.status === "up_to_date") {
+    if (!bootstrapFromLocalHead) {
+      return previewResult;
+    }
+    return withRepoMutationLock(
+      {
+        cwd: repoRoot,
+        operation: "collabSync"
+      },
+      async ({ repoRoot: lockedRepoRoot, warnings }) => {
+        await assertRepoSnapshotUnchanged(lockedRepoRoot, repoSnapshot, {
+          operation: "`remix collab sync`",
+          recoveryHint: "The repository changed before the first local Remix baseline could be created. Review the local changes and rerun `remix collab sync`."
+        });
+        const snapshot = await captureLocalSnapshot({
+          repoRoot: lockedRepoRoot,
+          repoFingerprint: binding.repoFingerprint,
+          laneId: binding.laneId,
+          branchName: binding.branchName
+        });
+        await writeLocalBaseline({
+          repoRoot: lockedRepoRoot,
+          repoFingerprint: binding.repoFingerprint,
+          laneId: binding.laneId,
+          currentAppId: binding.currentAppId,
+          branchName: binding.branchName,
+          lastSnapshotId: snapshot.id,
+          lastSnapshotHash: snapshot.snapshotHash,
+          lastServerRevisionId: delta.targetRevisionId ?? null,
+          lastServerTreeHash: delta.targetTreeHash ?? null,
+          lastServerHeadHash: delta.targetHeadHash,
+          lastSeenLocalCommitHash: snapshot.localCommitHash
+        });
+        return {
+          ...previewResult,
+          localCommitHash: snapshot.localCommitHash,
+          ...warnings.length > 0 ? { warnings } : {}
+        };
+      }
+    );
+  }
   if (delta.status === "base_unknown") {
     throw new RemixError("Direct pull is unavailable because Remix can no longer diff from the last acknowledged server head.", {
       exitCode: 2,
-      hint: "Run `remix collab reconcile --dry-run` to inspect recovery options before retrying. If this checkout has no local Remix baseline yet for this lane, `remix collab re-anchor` may be required."
+      hint: "Run `remix collab reconcile --dry-run` to inspect recovery options before retrying. If this checkout has no local Remix baseline yet for this lane, run `remix collab init` to seed one."
     });
   }
   if (delta.status !== "delta_ready") {
@@ -3411,6 +3582,8 @@ async function collabSync(params) {
         branchName: binding.branchName,
         lastSnapshotId: snapshot.id,
         lastSnapshotHash: snapshot.snapshotHash,
+        lastServerRevisionId: delta.targetRevisionId ?? null,
+        lastServerTreeHash: delta.targetTreeHash ?? null,
         lastServerHeadHash: delta.targetHeadHash,
         lastSeenLocalCommitHash: snapshot.localCommitHash
       });
@@ -3705,6 +3878,8 @@ async function collabCheckout(params) {
     branchName: branchNameForBaseline,
     lastSnapshotId: snapshot.id,
     lastSnapshotHash: snapshot.snapshotHash,
+    lastServerRevisionId: appHead.headRevisionId ?? null,
+    lastServerTreeHash: appHead.treeHash ?? null,
     lastServerHeadHash: appHead.headCommitHash,
     lastSeenLocalCommitHash: snapshot.localCommitHash
   });
@@ -4090,25 +4265,21 @@ async function trySeedEquivalentBranchBaseline(params) {
     branchName: params.branchName,
     persistBlobs: false
   });
-  if (inspection.snapshotHash !== defaultBaseline.lastSnapshotHash) {
+  if (inspection.snapshotHash !== defaultBaseline.lastSnapshotHash && inspection.localCommitHash !== defaultBaseline.lastSeenLocalCommitHash) {
     return null;
   }
-  const snapshot = await captureLocalSnapshot({
-    repoRoot: params.repoRoot,
-    repoFingerprint: params.repoFingerprint,
-    laneId: params.laneId,
-    branchName: params.branchName
-  });
   await writeLocalBaseline({
     repoRoot: params.repoRoot,
     repoFingerprint: params.repoFingerprint,
     laneId: params.laneId,
     currentAppId: params.currentAppId,
     branchName: params.branchName,
-    lastSnapshotId: snapshot.id,
-    lastSnapshotHash: snapshot.snapshotHash,
+    lastSnapshotId: defaultBaseline.lastSnapshotId,
+    lastSnapshotHash: defaultBaseline.lastSnapshotHash,
+    lastServerRevisionId: params.appHeadRevisionId,
+    lastServerTreeHash: params.appTreeHash,
     lastServerHeadHash: params.appHeadHash,
-    lastSeenLocalCommitHash: snapshot.localCommitHash
+    lastSeenLocalCommitHash: inspection.localCommitHash
   });
   return "seeded";
 }
@@ -4118,11 +4289,11 @@ async function resolveInitBaselineStatus(params) {
     laneId: params.laneId,
     repoRoot: params.repoRoot
   });
-  if (baseline?.lastSnapshotHash && baseline.lastServerHeadHash) {
+  if (baseline?.lastSnapshotHash && (baseline.lastServerRevisionId || baseline.lastServerHeadHash)) {
     return "existing";
   }
   const localHeadCommitHash = await getHeadCommitHash(params.repoRoot);
-  if (!localHeadCommitHash) return "requires_re_anchor";
+  if (!localHeadCommitHash) return "baseline_missing";
   const appHead = unwrapResponseObject(
     await params.api.getAppHead(params.currentAppId),
     "app head"
@@ -4149,6 +4320,7 @@ async function resolveInitBaselineStatus(params) {
     const deltaResp = await params.api.getAppDelta(params.currentAppId, {
       baseHeadHash: localHeadCommitHash,
       targetHeadHash: appHead.headCommitHash,
+      targetRevisionId: appHead.headRevisionId,
       localSnapshotHash,
       repoFingerprint: params.repoFingerprint,
       remoteUrl: params.remoteUrl ?? void 0,
@@ -4156,6 +4328,21 @@ async function resolveInitBaselineStatus(params) {
     });
     const delta = unwrapResponseObject(deltaResp, "app delta");
     if (delta.status === "up_to_date" || delta.status === "delta_ready") {
+      const equivalentBaseline = await trySeedEquivalentBranchBaseline({
+        repoRoot: params.repoRoot,
+        repoFingerprint: params.repoFingerprint,
+        laneId: params.laneId,
+        currentAppId: params.currentAppId,
+        upstreamAppId: params.upstreamAppId ?? null,
+        branchName: params.branchName,
+        defaultBranch: params.defaultBranch,
+        appHeadHash: appHead.headCommitHash,
+        appHeadRevisionId: appHead.headRevisionId ?? null,
+        appTreeHash: appHead.treeHash ?? null
+      });
+      if (equivalentBaseline) {
+        return equivalentBaseline;
+      }
       return "requires_sync";
     }
     if (delta.status === "content_equivalent") {
@@ -4178,7 +4365,9 @@ async function resolveInitBaselineStatus(params) {
         upstreamAppId: params.upstreamAppId ?? null,
         branchName: params.branchName,
         defaultBranch: params.defaultBranch,
-        appHeadHash: appHead.headCommitHash
+        appHeadHash: appHead.headCommitHash,
+        appHeadRevisionId: appHead.headRevisionId ?? null,
+        appTreeHash: appHead.treeHash ?? null
       });
       if (equivalentBaseline) {
         return equivalentBaseline;
@@ -4186,7 +4375,7 @@ async function resolveInitBaselineStatus(params) {
     }
   } catch {
   }
-  return "requires_re_anchor";
+  return "baseline_missing";
 }
 async function seedImportedInitBaseline(params) {
   const appHead = unwrapResponseObject(
@@ -4207,6 +4396,8 @@ async function seedImportedInitBaseline(params) {
     branchName: params.branchName,
     lastSnapshotId: snapshot.id,
     lastSnapshotHash: snapshot.snapshotHash,
+    lastServerRevisionId: appHead.headRevisionId ?? null,
+    lastServerTreeHash: appHead.treeHash ?? null,
     lastServerHeadHash: appHead.headCommitHash,
     lastSeenLocalCommitHash: snapshot.localCommitHash
   });
@@ -4220,7 +4411,6 @@ async function collabInit(params) {
     },
     async ({ repoRoot, warnings }) => {
       await ensureGitInfoExcludeEntries(repoRoot, [".remix/"]);
-      await ensureCleanWorktree(repoRoot, "`remix collab init`");
       if (params.path?.trim()) {
         throw new RemixError("`remix collab init --path` is not supported.", {
           exitCode: 2,
@@ -4228,6 +4418,10 @@ async function collabInit(params) {
         });
       }
       const localBindingState = await readCollabBindingState(repoRoot, { persist: true });
+      const hasExistingBinding = localBindingState != null && Object.keys(localBindingState.branchBindings ?? {}).length > 0;
+      if (params.forceNew || !hasExistingBinding) {
+        await ensureCleanWorktree(repoRoot, "`remix collab init`");
+      }
       const persistedRemoteUrl = normalizeGitRemote(localBindingState?.remoteUrl ?? null);
       const currentBranch = await getCurrentBranch(repoRoot);
       const defaultBranch = localBindingState?.defaultBranch ?? await getDefaultBranch(repoRoot) ?? currentBranch;
@@ -5081,10 +5275,11 @@ async function collabList(params) {
   };
 }
 
-// src/application/collab/collabReAnchor.ts
-import { randomUUID as randomUUID5 } from "crypto";
+// src/application/collab/collabReconcile.ts
 import fs11 from "fs/promises";
+import os5 from "os";
 import path10 from "path";
+import { execa as execa3 } from "execa";
 
 // src/application/collab/pendingFinalize.ts
 function hasPendingFinalize(summary) {
@@ -5094,258 +5289,7 @@ function buildPendingFinalizeHint() {
   return "Drain or await the local finalize queue first, then retry after the queued Remix turn finishes recording remotely.";
 }
 
-// src/application/collab/collabReAnchor.ts
-async function collabReAnchor(params) {
-  const repoRoot = await findGitRoot(params.cwd);
-  const binding = await ensureActiveLaneBinding({
-    repoRoot,
-    api: params.api,
-    operation: "`remix collab re-anchor`"
-  });
-  if (!binding) {
-    throw new RemixError("Repository is not bound to Remix.", {
-      exitCode: 2,
-      hint: "Run `remix collab init` first."
-    });
-  }
-  const detected = await collabDetectRepoState({
-    api: params.api,
-    cwd: repoRoot,
-    allowBranchMismatch: params.allowBranchMismatch
-  });
-  if (detected.status === "metadata_conflict" || detected.status === "branch_mismatch") {
-    throw new RemixError("Repository must be realigned before seeding a fresh local Remix baseline.", {
-      exitCode: 2,
-      hint: detected.hint
-    });
-  }
-  if (detected.status !== "ready" || !detected.binding) {
-    throw new RemixError(detected.hint || "Repository is not ready for re-anchor.", {
-      exitCode: 2,
-      hint: detected.hint
-    });
-  }
-  if (detected.repoState === "server_only_changed") {
-    throw new RemixError("This checkout is already on a server-known base and only needs a local pull.", {
-      exitCode: 2,
-      hint: "Run `remix collab sync` instead of `remix collab re-anchor`."
-    });
-  }
-  if (detected.repoState === "both_changed") {
-    throw new RemixError("Both the local workspace and the server lane changed since the last agreed baseline.", {
-      exitCode: 2,
-      hint: "Run `remix collab reconcile` to replay the local boundary onto the newer server head."
-    });
-  }
-  if (detected.repoState === "local_only_changed") {
-    if (hasPendingFinalize(detected.pendingFinalize)) {
-      throw new RemixError("Re-anchor is not needed while queued Remix turn recording is still processing.", {
-        exitCode: 2,
-        hint: buildPendingFinalizeHint()
-      });
-    }
-    throw new RemixError("Re-anchor is not the right command for local content changes.", {
-      exitCode: 2,
-      hint: "Remix is source-blind: any local content change since the last recorded turn \u2014 including manual commits, pulls, merges, and rebases \u2014 is recorded with `remix collab finalize-turn`. Use `remix collab re-anchor` only when no local Remix baseline exists yet for this lane (status reports `re_anchor`)."
-    });
-  }
-  if (detected.repoState === "idle") {
-    throw new RemixError("This checkout is already aligned with Remix.", {
-      exitCode: 2,
-      hint: "No re-anchor step is needed. Re-anchor only applies when no local Remix baseline exists yet for this lane."
-    });
-  }
-  await ensureCleanWorktree(repoRoot, "`remix collab re-anchor`");
-  const branch = await requireCurrentBranch(repoRoot);
-  const headCommitHash = await getHeadCommitHash(repoRoot);
-  if (!headCommitHash) {
-    throw new RemixError("Failed to resolve local HEAD commit.", { exitCode: 1 });
-  }
-  if (params.asyncSubmit && !params.dryRun) {
-    const pending = await findPendingAsyncJob({
-      repoRoot,
-      branchName: binding.branchName ?? branch,
-      kind: "re_anchor"
-    });
-    if (pending) {
-      return {
-        status: "queued",
-        queued: true,
-        jobId: pending.id,
-        repoRoot,
-        branch,
-        currentAppId: binding.currentAppId,
-        dryRun: false,
-        applied: false
-      };
-    }
-  }
-  const preflightResp = await params.api.preflightAppReconcile(binding.currentAppId, {
-    localHeadCommitHash: headCommitHash,
-    repoFingerprint: binding.repoFingerprint ?? void 0,
-    remoteUrl: binding.remoteUrl ?? void 0,
-    defaultBranch: binding.defaultBranch ?? void 0
-  });
-  const preflight = unwrapResponseObject(preflightResp, "reconcile preflight");
-  if (preflight.status === "metadata_conflict") {
-    throw new RemixError("Local repository metadata conflicts with the bound Remix app.", {
-      exitCode: 2,
-      hint: preflight.warnings.join("\n") || "Run the command from the correct bound repository."
-    });
-  }
-  const preview = {
-    status: preflight.status === "up_to_date" ? "reanchored" : "re_anchor_required",
-    repoRoot,
-    branch,
-    currentAppId: binding.currentAppId,
-    localHeadCommitHash: headCommitHash,
-    targetHeadCommitHash: preflight.targetHeadCommitHash,
-    targetHeadCommitId: preflight.targetHeadCommitId,
-    warnings: preflight.warnings,
-    applied: false,
-    dryRun: params.dryRun === true
-  };
-  if (params.dryRun) {
-    return preview;
-  }
-  let anchoredServerHeadHash = preflight.targetHeadCommitHash;
-  if (params.asyncSubmit && preflight.status === "ready_to_reconcile") {
-    const failed = await findFailedAsyncJob({
-      repoRoot,
-      branchName: binding.branchName ?? branch,
-      kind: "re_anchor"
-    });
-    if (failed) {
-      await deleteAsyncJob(failed.id);
-    }
-    const { bundlePath: tmpBundlePath, headCommitHash: bundledHeadCommitHash } = await createGitBundle(
-      repoRoot,
-      "re-anchor.bundle"
-    );
-    const tmpBundleDir = path10.dirname(tmpBundlePath);
-    try {
-      const jobId = randomUUID5();
-      const durableBundlePath = getAsyncJobBundlePath(jobId);
-      await fs11.mkdir(getAsyncJobDir(jobId), { recursive: true });
-      try {
-        await fs11.rename(tmpBundlePath, durableBundlePath);
-      } catch (error) {
-        if (error?.code !== "EXDEV") throw error;
-        await fs11.copyFile(tmpBundlePath, durableBundlePath);
-        await fs11.unlink(tmpBundlePath).catch(() => void 0);
-      }
-      const bundleSha = await sha256FileHex(durableBundlePath);
-      const job = await enqueueAsyncJob({
-        id: jobId,
-        kind: "re_anchor",
-        status: "queued",
-        repoRoot,
-        repoFingerprint: binding.repoFingerprint,
-        branchName: binding.branchName ?? branch,
-        laneId: binding.laneId,
-        retryCount: 0,
-        error: null,
-        idempotencyKey: null,
-        payload: {
-          bundlePath: durableBundlePath,
-          bundleSha256: bundleSha,
-          localHeadCommitHash: bundledHeadCommitHash,
-          targetHeadCommitHash: preflight.targetHeadCommitHash,
-          appId: binding.currentAppId
-        }
-      });
-      await logDrainerEvent(job.id, "submitted", { kind: "re_anchor" });
-      return {
-        status: "queued",
-        queued: true,
-        jobId: job.id,
-        repoRoot,
-        branch,
-        currentAppId: binding.currentAppId,
-        localHeadCommitHash: bundledHeadCommitHash,
-        targetHeadCommitHash: preflight.targetHeadCommitHash,
-        warnings: preflight.warnings,
-        dryRun: false,
-        applied: false
-      };
-    } finally {
-      await fs11.rm(tmpBundleDir, { recursive: true, force: true }).catch(() => void 0);
-    }
-  }
-  if (preflight.status === "ready_to_reconcile") {
-    const { bundlePath, headCommitHash: bundledHeadCommitHash } = await createGitBundle(repoRoot, "re-anchor.bundle");
-    const bundleTempDir = path10.dirname(bundlePath);
-    try {
-      const bundleStat = await fs11.stat(bundlePath);
-      const checksumSha256 = await sha256FileHex(bundlePath);
-      const presignResp = await params.api.presignImportUploadFirstParty({
-        file: {
-          name: path10.basename(bundlePath),
-          mimeType: "application/x-git-bundle",
-          size: bundleStat.size,
-          checksumSha256
-        }
-      });
-      const uploadTarget = unwrapResponseObject(presignResp, "import upload target");
-      await uploadPresigned({
-        uploadUrl: String(uploadTarget.uploadUrl),
-        filePath: bundlePath,
-        headers: uploadTarget.headers ?? {}
-      });
-      const startResp = await params.api.startAppReconcile(binding.currentAppId, {
-        uploadId: String(uploadTarget.uploadId),
-        localHeadCommitHash: bundledHeadCommitHash,
-        repoFingerprint: binding.repoFingerprint ?? void 0,
-        remoteUrl: binding.remoteUrl ?? void 0,
-        defaultBranch: binding.defaultBranch ?? void 0,
-        idempotencyKey: buildDeterministicIdempotencyKey({
-          kind: "collab_re_anchor_v1",
-          appId: binding.currentAppId,
-          localHeadCommitHash: bundledHeadCommitHash,
-          targetHeadCommitHash: preflight.targetHeadCommitHash
-        })
-      });
-      const started = unwrapResponseObject(startResp, "reconcile");
-      const reconcile = await pollReconcile(params.api, binding.currentAppId, started.id);
-      anchoredServerHeadHash = reconcile.reconciledHeadCommitHash ?? reconcile.targetHeadCommitHash ?? preflight.targetHeadCommitHash;
-    } finally {
-      await fs11.rm(bundleTempDir, { recursive: true, force: true });
-    }
-  }
-  const snapshot = await captureLocalSnapshot({
-    repoRoot,
-    repoFingerprint: binding.repoFingerprint,
-    laneId: binding.laneId,
-    branchName: binding.branchName
-  });
-  await writeLocalBaseline({
-    repoRoot,
-    repoFingerprint: binding.repoFingerprint,
-    laneId: binding.laneId,
-    currentAppId: binding.currentAppId,
-    branchName: binding.branchName,
-    lastSnapshotId: snapshot.id,
-    lastSnapshotHash: snapshot.snapshotHash,
-    lastServerHeadHash: anchoredServerHeadHash,
-    lastSeenLocalCommitHash: snapshot.localCommitHash
-  });
-  return {
-    ...preview,
-    status: "reanchored",
-    targetHeadCommitHash: anchoredServerHeadHash,
-    applied: true,
-    dryRun: false
-  };
-}
-async function collabReAnchorSubmit(params) {
-  return collabReAnchor({ ...params, asyncSubmit: true });
-}
-
 // src/application/collab/collabReconcile.ts
-import fs12 from "fs/promises";
-import os5 from "os";
-import path11 from "path";
-import { execa as execa3 } from "execa";
 async function reconcileBothChanged(params) {
   const repoRoot = await findGitRoot(params.cwd);
   const binding = await ensureActiveLaneBinding({
@@ -5368,7 +5312,7 @@ async function reconcileBothChanged(params) {
   if (!baseline?.lastSnapshotId || !baseline.lastServerHeadHash) {
     throw new RemixError("Local Remix baseline is missing for this lane.", {
       exitCode: 2,
-      hint: "Run `remix collab re-anchor` to create a fresh baseline first."
+      hint: "Run `remix collab init` or sync from a checkout with a valid revision baseline first."
     });
   }
   const currentSnapshot = await captureLocalSnapshot({
@@ -5391,6 +5335,7 @@ async function reconcileBothChanged(params) {
     params.api.getAppHead(binding.currentAppId),
     params.api.getAppDelta(binding.currentAppId, {
       baseHeadHash: baseline.lastServerHeadHash,
+      baseRevisionId: baseline.lastServerRevisionId,
       repoFingerprint: binding.repoFingerprint ?? void 0,
       remoteUrl: binding.remoteUrl ?? void 0,
       defaultBranch: binding.defaultBranch ?? void 0
@@ -5408,7 +5353,7 @@ async function reconcileBothChanged(params) {
   if (delta.status === "base_unknown") {
     throw new RemixError("Reconcile cannot pull the newer server state from the last acknowledged baseline.", {
       exitCode: 2,
-      hint: "Run `remix collab re-anchor` to re-anchor this checkout before retrying."
+      hint: "Run `remix collab init` to seed a fresh revision baseline for this checkout before retrying."
     });
   }
   if (delta.status !== "delta_ready" && delta.status !== "up_to_date") {
@@ -5439,7 +5384,9 @@ async function reconcileBothChanged(params) {
     assistantResponse: "Replay the local boundary delta onto the latest server head without recording a new change step.",
     diff: diffResult.diff,
     baseCommitHash: baseline.lastServerHeadHash,
+    baseRevisionId: baseline.lastServerRevisionId,
     targetHeadCommitHash: appHead.headCommitHash,
+    targetRevisionId: appHead.headRevisionId,
     expectedPaths: diffResult.changedPaths,
     workspaceMetadata: {
       recordingMode: "boundary_delta",
@@ -5447,6 +5394,7 @@ async function reconcileBothChanged(params) {
       branch,
       baselineSnapshotId: baseline.lastSnapshotId,
       currentSnapshotId: currentSnapshot.id,
+      baselineServerRevisionId: baseline.lastServerRevisionId,
       baselineServerHeadHash: baseline.lastServerHeadHash,
       currentSnapshotHash: currentSnapshot.snapshotHash,
       localCommitHash: currentSnapshot.localCommitHash,
@@ -5465,12 +5413,12 @@ async function reconcileBothChanged(params) {
   const replay = await pollChangeStepReplay(params.api, binding.currentAppId, String(replayStart.id));
   const replayDiffResp = await params.api.getChangeStepReplayDiff(binding.currentAppId, replay.id);
   const replayDiff = unwrapResponseObject(replayDiffResp, "change step replay diff");
-  const tempRoot = await fs12.mkdtemp(path11.join(os5.tmpdir(), "remix-reconcile-"));
+  const tempRoot = await fs11.mkdtemp(path10.join(os5.tmpdir(), "remix-reconcile-"));
   let serverHeadSnapshot = null;
   let mergedSnapshot = null;
   try {
-    const tempRepoRoot = path11.join(tempRoot, "repo");
-    await fs12.mkdir(tempRepoRoot, { recursive: true });
+    const tempRepoRoot = path10.join(tempRoot, "repo");
+    await fs11.mkdir(tempRepoRoot, { recursive: true });
     await execa3("git", ["init"], { cwd: tempRepoRoot, stderr: "ignore" });
     await materializeLocalSnapshot(baseline.lastSnapshotId, tempRepoRoot);
     if (delta.status === "delta_ready" && delta.diff.trim()) {
@@ -5492,7 +5440,7 @@ async function reconcileBothChanged(params) {
       branchName: binding.branchName
     });
   } finally {
-    await fs12.rm(tempRoot, { recursive: true, force: true }).catch(() => void 0);
+    await fs11.rm(tempRoot, { recursive: true, force: true }).catch(() => void 0);
   }
   if (!serverHeadSnapshot || !mergedSnapshot) {
     throw new RemixError("Failed to materialize the reconciled local workspace.", { exitCode: 1 });
@@ -5529,6 +5477,8 @@ async function reconcileBothChanged(params) {
         branchName: binding.branchName,
         lastSnapshotId: serverHeadSnapshot.id,
         lastSnapshotHash: serverHeadSnapshot.snapshotHash,
+        lastServerRevisionId: appHead.headRevisionId ?? null,
+        lastServerTreeHash: appHead.treeHash ?? null,
         lastServerHeadHash: appHead.headCommitHash,
         lastSeenLocalCommitHash: restoredSnapshot.localCommitHash
       });
@@ -5564,7 +5514,10 @@ async function collabReconcile(params) {
     return reconcileBothChanged(params);
   }
   if (detected.repoState === "external_local_base_changed") {
-    return collabReAnchor(params);
+    throw new RemixError("This checkout needs a local Remix revision baseline before reconciliation.", {
+      exitCode: 2,
+      hint: detected.hint || "Run `remix collab init` or `remix collab sync` to seed the baseline."
+    });
   }
   if (detected.repoState === "local_only_changed") {
     if (hasPendingFinalize(detected.pendingFinalize)) {
@@ -5675,6 +5628,8 @@ async function collabRemix(params) {
     branchName: branchNameForBaseline,
     lastSnapshotId: snapshot.id,
     lastSnapshotHash: snapshot.snapshotHash,
+    lastServerRevisionId: appHead.headRevisionId ?? null,
+    lastServerTreeHash: appHead.treeHash ?? null,
     lastServerHeadHash: appHead.headCommitHash,
     lastSeenLocalCommitHash: snapshot.localCommitHash
   });
@@ -5799,11 +5754,15 @@ function createBaseStatus() {
       baseline: {
         lastSnapshotId: null,
         lastSnapshotHash: null,
+        lastServerRevisionId: null,
+        lastServerTreeHash: null,
         lastServerHeadHash: null,
         lastSeenLocalCommitHash: null
       },
       current: {
         snapshotHash: null,
+        serverRevisionId: null,
+        serverTreeHash: null,
         serverHeadHash: null,
         serverHeadCommitId: null,
         localCommitHash: null
@@ -5890,6 +5849,8 @@ async function collabStatus(params) {
   status.alignment.baseline = detected.baseline;
   status.alignment.current = {
     snapshotHash: detected.currentSnapshotHash,
+    serverRevisionId: detected.currentServerRevisionId,
+    serverTreeHash: detected.currentServerTreeHash,
     serverHeadHash: detected.currentServerHeadHash,
     serverHeadCommitId: detected.currentServerHeadCommitId,
     localCommitHash: detected.localCommitHash
@@ -5953,7 +5914,7 @@ async function collabStatus(params) {
     status.reconcile.canApply = !status.repo.branchMismatch;
     status.recommendedAction = "reconcile";
   } else if (detected.repoState === "external_local_base_changed") {
-    status.recommendedAction = "re_anchor";
+    status.recommendedAction = "init";
     addBlockedReason(status.sync, "baseline_missing");
     addBlockedReason(status.reconcile, "baseline_missing");
   } else if (detected.repoState === "local_only_changed") {
@@ -6117,8 +6078,8 @@ async function collabView(params) {
 }
 
 // src/application/collab/collabAsyncProcessing.ts
-import fs13 from "fs/promises";
-import path12 from "path";
+import fs12 from "fs/promises";
+import path11 from "path";
 var MAX_TRANSIENT_RETRIES = 5;
 var TRANSIENT_NETWORK_CODES = /* @__PURE__ */ new Set([
   "ECONNREFUSED",
@@ -6214,10 +6175,10 @@ async function processInitJob(job, api) {
   try {
     await updateAsyncJob(job.id, { status: "submitting", error: null });
     await logDrainerEvent(job.id, "claimed", { kind: "init" });
-    const bundleStat = await fs13.stat(job.payload.bundlePath);
+    const bundleStat = await fs12.stat(job.payload.bundlePath);
     const presignResp = await api.presignImportUploadFirstParty({
       file: {
-        name: path12.basename(job.payload.bundlePath),
+        name: path11.basename(job.payload.bundlePath),
         mimeType: "application/x-git-bundle",
         size: bundleStat.size,
         checksumSha256: job.payload.bundleSha256
@@ -6234,7 +6195,7 @@ async function processInitJob(job, api) {
     await updateAsyncJob(job.id, { status: "server_processing" });
     const importResp = await api.importFromUploadFirstParty({
       uploadId: String(presign.uploadId),
-      appName: job.payload.appName?.trim() || path12.basename(job.repoRoot),
+      appName: job.payload.appName?.trim() || path11.basename(job.repoRoot),
       platform: "generic",
       isPublic: false,
       branch: job.payload.defaultBranch && job.branchName && job.branchName !== job.payload.defaultBranch ? job.payload.defaultBranch : job.branchName ?? void 0,
@@ -6428,7 +6389,7 @@ async function processInitPostJob(job, api) {
     if (outcome.status === "failed") {
       const bindingPath = getCollabBindingPath(job.repoRoot);
       try {
-        await fs13.unlink(bindingPath);
+        await fs12.unlink(bindingPath);
         await logDrainerEvent(job.id, "binding_cleared", {
           kind: "init_post",
           appId: job.payload.appId,
@@ -6469,10 +6430,10 @@ async function processReAnchorJob(job, api) {
     }
     let anchoredServerHeadHash = preflight.targetHeadCommitHash;
     if (preflight.status === "ready_to_reconcile") {
-      const bundleStat = await fs13.stat(job.payload.bundlePath);
+      const bundleStat = await fs12.stat(job.payload.bundlePath);
       const presignResp = await api.presignImportUploadFirstParty({
         file: {
-          name: path12.basename(job.payload.bundlePath),
+          name: path11.basename(job.payload.bundlePath),
           mimeType: "application/x-git-bundle",
           size: bundleStat.size,
           checksumSha256: job.payload.bundleSha256
@@ -6576,9 +6537,9 @@ async function collabReAnchorProcess(jobId, opts) {
 }
 async function acquireDrainerPidLock() {
   const pidPath = getDrainerPidPath();
-  await fs13.mkdir(path12.dirname(pidPath), { recursive: true });
+  await fs12.mkdir(path11.dirname(pidPath), { recursive: true });
   try {
-    const existing = await fs13.readFile(pidPath, "utf8").catch(() => "");
+    const existing = await fs12.readFile(pidPath, "utf8").catch(() => "");
     const existingPid = parseInt(existing.trim(), 10);
     if (Number.isFinite(existingPid) && existingPid > 0 && existingPid !== process.pid) {
       try {
@@ -6588,13 +6549,13 @@ async function acquireDrainerPidLock() {
         if (error?.code !== "ESRCH") return null;
       }
     }
-    await fs13.writeFile(pidPath, String(process.pid), "utf8");
+    await fs12.writeFile(pidPath, String(process.pid), "utf8");
     return {
       release: async () => {
         try {
-          const current = (await fs13.readFile(pidPath, "utf8")).trim();
+          const current = (await fs12.readFile(pidPath, "utf8")).trim();
           if (current === String(process.pid)) {
-            await fs13.unlink(pidPath).catch(() => void 0);
+            await fs12.unlink(pidPath).catch(() => void 0);
           }
         } catch {
         }
@@ -6645,9 +6606,6 @@ export {
   collabList,
   collabListMembers,
   collabListMergeRequests,
-  collabReAnchor,
-  collabReAnchorProcess,
-  collabReAnchorSubmit,
   collabReconcile,
   collabRecordingPreflight,
   collabReject,
@@ -6675,6 +6633,7 @@ export {
   processPendingFinalizeJob,
   pruneTerminalAsyncJobs,
   readAsyncJob,
+  readLocalSnapshot,
   readPendingFinalizeJob,
   requeuePendingFinalizeJob,
   summarizeAsyncJobs,