@remixhq/core 0.1.12 → 0.1.13

package/dist/collab.js

@@ -5,43 +5,32 @@ import {
   reserveAvailableDirPath,
   reserveDirectory,
   writeCollabBinding,
-  writeCollabBindingSnapshot
-} from "./chunk-IXWQWFYT.js";
+  writeCollabBindingSnapshot,
+  writeJsonAtomic
+} from "./chunk-YCFLOHJV.js";
 import "./chunk-HZNEDSRS.js";
 import {
+  applyUnifiedDiffToWorktree,
   assertRepoSnapshotUnchanged,
   buildRepoFingerprint,
   captureRepoSnapshot,
   checkoutLocalBranch,
   cloneGitBundleToDirectory,
-  createBackupBranch,
   createGitBundle,
-  discardCapturedUntrackedChanges,
-  discardTrackedChanges,
   ensureCleanWorktree,
-  ensureCommitExists,
   ensureGitInfoExcludeEntries,
-  fastForwardToCommit,
   findGitRoot,
   getCurrentBranch,
   getDefaultBranch,
   getGitCommonDir,
   getHeadCommitHash,
   getRemoteOriginUrl,
-  getWorkspaceDiff,
-  getWorkspaceSnapshot,
   getWorktreeStatus,
-  hardResetToCommit,
-  importGitBundle,
-  listUntrackedFiles,
   normalizeGitRemote,
-  preserveWorkspaceChanges,
-  reapplyPreservedWorkspaceChanges,
   requireCurrentBranch,
-  summarizeUnifiedDiff,
-  validateUnifiedDiff,
-  writeTempUnifiedDiffBackup
-} from "./chunk-RREREIGW.js";
+  setRemoteOriginUrl,
+  summarizeUnifiedDiff
+} from "./chunk-WT6VRLXU.js";
 import {
   REMIX_ERROR_CODES
 } from "./chunk-GC2MOT3U.js";
@@ -49,10 +38,6 @@ import {
   RemixError
 } from "./chunk-YZ34ICNN.js";
 
-// src/application/collab/collabAdd.ts
-import fs3 from "fs/promises";
-import path3 from "path";
-
 // src/application/collab/branchPolicy.ts
 function describeBranch(value) {
   const normalized = String(value ?? "").trim();
@@ -86,8 +71,625 @@ function assertBoundBranchMatch(params) {
   });
 }
 
-// src/application/collab/shared.ts
+// src/infrastructure/collab/localBaselineStore.ts
+import fs from "fs/promises";
+import path2 from "path";
+
+// src/infrastructure/collab/statePaths.ts
 import { createHash } from "crypto";
+import os from "os";
+import path from "path";
+function sha256Hex(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function getCollabStateRoot() {
+  const configured = process.env.REMIX_COLLAB_STATE_ROOT?.trim();
+  return configured || path.join(os.homedir(), ".remix", "collab-state");
+}
+function buildLaneStateKey(params) {
+  const fingerprint = params.repoFingerprint?.trim();
+  const laneId = params.laneId?.trim();
+  const repoRoot = params.repoRoot?.trim();
+  const stableSource = repoRoot || "unknown-repo-root";
+  const fingerprintSource = fingerprint || "unknown-repo-fingerprint";
+  const laneSource = laneId || "unknown-lane";
+  return sha256Hex(`${stableSource}::${fingerprintSource}::${laneSource}`);
+}
+function getSnapshotsRoot() {
+  return path.join(getCollabStateRoot(), "snapshots");
+}
+function getSnapshotRecordsRoot() {
+  return path.join(getSnapshotsRoot(), "records");
+}
+function getSnapshotBlobsRoot() {
+  return path.join(getSnapshotsRoot(), "blobs");
+}
+function getBaselinesRoot() {
+  return path.join(getCollabStateRoot(), "baselines");
+}
+function getFinalizeQueueRoot() {
+  return path.join(getCollabStateRoot(), "finalize-queue");
+}
+
+// src/infrastructure/collab/localBaselineStore.ts
+function getBaselinePath(params) {
+  return path2.join(getBaselinesRoot(), `${buildLaneStateKey(params)}.json`);
+}
+async function readLocalBaseline(params) {
+  try {
+    const raw = await fs.readFile(getBaselinePath(params), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    if (parsed.schemaVersion !== 1 || typeof parsed.key !== "string" || typeof parsed.repoRoot !== "string") {
+      return null;
+    }
+    return {
+      schemaVersion: 1,
+      key: parsed.key,
+      repoRoot: parsed.repoRoot,
+      repoFingerprint: parsed.repoFingerprint ?? null,
+      laneId: parsed.laneId ?? null,
+      currentAppId: String(parsed.currentAppId ?? ""),
+      branchName: parsed.branchName ?? null,
+      lastSnapshotId: parsed.lastSnapshotId ?? null,
+      lastSnapshotHash: parsed.lastSnapshotHash ?? null,
+      lastServerHeadHash: parsed.lastServerHeadHash ?? null,
+      lastSeenLocalCommitHash: parsed.lastSeenLocalCommitHash ?? null,
+      updatedAt: String(parsed.updatedAt ?? "")
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeLocalBaseline(baseline) {
+  const key = buildLaneStateKey(baseline);
+  const normalized = {
+    schemaVersion: 1,
+    key,
+    repoRoot: baseline.repoRoot,
+    repoFingerprint: baseline.repoFingerprint ?? null,
+    laneId: baseline.laneId ?? null,
+    currentAppId: baseline.currentAppId,
+    branchName: baseline.branchName ?? null,
+    lastSnapshotId: baseline.lastSnapshotId ?? null,
+    lastSnapshotHash: baseline.lastSnapshotHash ?? null,
+    lastServerHeadHash: baseline.lastServerHeadHash ?? null,
+    lastSeenLocalCommitHash: baseline.lastSeenLocalCommitHash ?? null,
+    updatedAt: baseline.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeJsonAtomic(getBaselinePath(baseline), normalized);
+  return normalized;
+}
+
+// src/infrastructure/collab/localSnapshotStore.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+import fs2 from "fs/promises";
+import os2 from "os";
+import path3 from "path";
+import { execa } from "execa";
+function sha256Hex2(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+function getSnapshotRecordPath(snapshotId) {
+  return path3.join(getSnapshotRecordsRoot(), `${snapshotId}.json`);
+}
+function getBlobPath(blobHash) {
+  return path3.join(getSnapshotBlobsRoot(), blobHash.slice(0, 2), blobHash);
+}
+async function runGitZ(args, cwd) {
+  const res = await execa("git", args, {
+    cwd,
+    stderr: "ignore",
+    stripFinalNewline: false
+  });
+  return String(res.stdout || "");
+}
+async function listWorkspaceFiles(repoRoot) {
+  const raw = await runGitZ(["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--deduplicate"], repoRoot);
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const entry of raw.split("\0")) {
+    const relativePath = entry.trim();
+    if (!relativePath || seen.has(relativePath)) continue;
+    const absolutePath = path3.join(repoRoot, relativePath);
+    try {
+      const stat = await fs2.lstat(absolutePath);
+      if (stat.isFile() || stat.isSymbolicLink()) {
+        seen.add(relativePath);
+        result.push(relativePath);
+      }
+    } catch {
+    }
+  }
+  return result.sort((a, b) => a.localeCompare(b));
+}
+async function persistBlob(blobHash, content) {
+  const blobPath = getBlobPath(blobHash);
+  try {
+    await fs2.access(blobPath);
+  } catch {
+    await fs2.mkdir(path3.dirname(blobPath), { recursive: true });
+    if (typeof content === "string") {
+      await fs2.writeFile(blobPath, content, "utf8");
+    } else {
+      await fs2.writeFile(blobPath, content);
+    }
+  }
+}
+function buildSnapshotHash(files) {
+  const manifest = files.map((file) => `${file.path}	${file.mode}	${file.blobHash}	${file.size}`).join("\n");
+  return sha256Hex2(manifest);
+}
+async function inspectLocalSnapshot(params) {
+  const repoRoot = params.repoRoot;
+  const files = await listWorkspaceFiles(repoRoot);
+  const manifest = [];
+  for (const relativePath of files) {
+    const absolutePath = path3.join(repoRoot, relativePath);
+    const stat = await fs2.lstat(absolutePath);
+    if (stat.isSymbolicLink()) {
+      const linkTarget = await fs2.readlink(absolutePath);
+      const blobHash2 = sha256Hex2(`symlink:${linkTarget}`);
+      if (params.persistBlobs !== false) {
+        await persistBlob(blobHash2, linkTarget);
+      }
+      manifest.push({
+        path: relativePath,
+        mode: "symlink",
+        blobHash: blobHash2,
+        size: Buffer.byteLength(linkTarget)
+      });
+      continue;
+    }
+    const content = await fs2.readFile(absolutePath);
+    const blobHash = sha256Hex2(content);
+    if (params.persistBlobs !== false) {
+      await persistBlob(blobHash, content);
+    }
+    manifest.push({
+      path: relativePath,
+      mode: stat.mode & 73 ? "executable" : "file",
+      blobHash,
+      size: stat.size
+    });
+  }
+  const normalizedManifest = manifest.sort((a, b) => a.path.localeCompare(b.path));
+  return {
+    repoRoot,
+    repoFingerprint: params.repoFingerprint ?? null,
+    laneId: params.laneId ?? null,
+    branchName: params.branchName ?? await getCurrentBranch(repoRoot).catch(() => null),
+    localCommitHash: await getHeadCommitHash(repoRoot).catch(() => null),
+    snapshotHash: buildSnapshotHash(normalizedManifest),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: normalizedManifest
+  };
+}
+async function captureLocalSnapshot(params) {
+  const inspection = await inspectLocalSnapshot({ ...params, persistBlobs: true });
+  const snapshot = {
+    schemaVersion: 1,
+    id: randomUUID(),
+    ...inspection
+  };
+  await writeJsonAtomic(getSnapshotRecordPath(snapshot.id), snapshot);
+  return snapshot;
+}
+async function readLocalSnapshot(snapshotId) {
+  if (!snapshotId) return null;
+  try {
+    const raw = await fs2.readFile(getSnapshotRecordPath(snapshotId), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || parsed.schemaVersion !== 1) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function materializeLocalSnapshot(snapshotId, targetDir) {
+  const snapshot = await readLocalSnapshot(snapshotId);
+  await fs2.mkdir(targetDir, { recursive: true });
+  if (!snapshot) return;
+  for (const entry of snapshot.files) {
+    const destination = path3.join(targetDir, entry.path);
+    await fs2.mkdir(path3.dirname(destination), { recursive: true });
+    const blobPath = getBlobPath(entry.blobHash);
+    if (entry.mode === "symlink") {
+      const linkTarget = await fs2.readFile(blobPath, "utf8");
+      await fs2.symlink(linkTarget, destination);
+      continue;
+    }
+    await fs2.copyFile(blobPath, destination);
+    if (entry.mode === "executable") {
+      await fs2.chmod(destination, 493);
+    }
+  }
+}
+async function pruneEmptyParentDirectories(repoRoot, filePath) {
+  let current = path3.dirname(filePath);
+  while (current !== repoRoot) {
+    const entries = await fs2.readdir(current).catch(() => null);
+    if (!entries || entries.length > 0) return;
+    await fs2.rmdir(current).catch(() => void 0);
+    current = path3.dirname(current);
+  }
+}
+async function restoreLocalSnapshotToWorktree(snapshotId, repoRoot) {
+  const snapshot = await readLocalSnapshot(snapshotId);
+  await fs2.mkdir(repoRoot, { recursive: true });
+  const desiredPaths = new Set(snapshot?.files.map((entry) => entry.path) ?? []);
+  const currentPaths = await listWorkspaceFiles(repoRoot);
+  for (const relativePath of currentPaths) {
+    if (desiredPaths.has(relativePath)) continue;
+    const absolutePath = path3.join(repoRoot, relativePath);
+    await fs2.rm(absolutePath, { recursive: true, force: true }).catch(() => void 0);
+    await pruneEmptyParentDirectories(repoRoot, absolutePath);
+  }
+  if (!snapshot) return;
+  for (const entry of snapshot.files) {
+    const destination = path3.join(repoRoot, entry.path);
+    await fs2.mkdir(path3.dirname(destination), { recursive: true });
+    await fs2.rm(destination, { recursive: true, force: true }).catch(() => void 0);
+    const blobPath = getBlobPath(entry.blobHash);
+    if (entry.mode === "symlink") {
+      const linkTarget = await fs2.readFile(blobPath, "utf8");
+      await fs2.symlink(linkTarget, destination);
+      continue;
+    }
+    await fs2.copyFile(blobPath, destination);
+    if (entry.mode === "executable") {
+      await fs2.chmod(destination, 493);
+    }
+  }
+}
+async function clearDirectoryExceptGit(targetDir) {
+  const entries = await fs2.readdir(targetDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === ".git") continue;
+    await fs2.rm(path3.join(targetDir, entry.name), { recursive: true, force: true });
+  }
+}
+async function diffLocalSnapshots(params) {
+  const tempRoot = await fs2.mkdtemp(path3.join(os2.tmpdir(), "remix-snapshot-diff-"));
+  const repoDir = path3.join(tempRoot, "repo");
+  await fs2.mkdir(repoDir, { recursive: true });
+  try {
+    await materializeLocalSnapshot(params.baseSnapshotId, repoDir);
+    await execa("git", ["init"], { cwd: repoDir, stderr: "ignore" });
+    await execa("git", ["add", "-A"], { cwd: repoDir, stderr: "ignore" });
+    await execa(
+      "git",
+      ["-c", "user.name=Remix", "-c", "user.email=remix@local", "commit", "--allow-empty", "-m", "baseline snapshot"],
+      { cwd: repoDir, stderr: "ignore" }
+    );
+    await clearDirectoryExceptGit(repoDir);
+    await materializeLocalSnapshot(params.targetSnapshotId, repoDir);
+    await execa("git", ["add", "-A"], { cwd: repoDir, stderr: "ignore" });
+    const diffRes = await execa("git", ["diff", "--binary", "--no-ext-diff", "--cached", "HEAD"], {
+      cwd: repoDir,
+      reject: false,
+      stderr: "ignore",
+      stripFinalNewline: false
+    });
+    const pathsRes = await execa("git", ["diff", "--name-only", "--cached", "HEAD", "-z"], {
+      cwd: repoDir,
+      reject: false,
+      stderr: "ignore",
+      stripFinalNewline: false
+    });
+    const diff = String(diffRes.stdout || "");
+    const changedPaths = String(pathsRes.stdout || "").split("\0").map((value) => value.trim()).filter(Boolean);
+    return {
+      baseSnapshotId: params.baseSnapshotId,
+      targetSnapshotId: params.targetSnapshotId,
+      diff,
+      diffSha256: diff ? sha256Hex2(diff) : null,
+      changedPaths,
+      stats: summarizeUnifiedDiff(diff)
+    };
+  } finally {
+    await fs2.rm(tempRoot, { recursive: true, force: true });
+  }
+}
+
+// src/infrastructure/collab/pendingFinalizeQueue.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import fs3 from "fs/promises";
+import path4 from "path";
+var FINALIZE_JOB_LOCK_STALE_MS = 10 * 60 * 1e3;
+var TERMINAL_FINALIZE_JOB_RETENTION_MS = 24 * 60 * 60 * 1e3;
+function getJobPath(id) {
+  return path4.join(getFinalizeQueueRoot(), `${id}.json`);
+}
+function getJobLockPath(id) {
+  return path4.join(getFinalizeQueueRoot(), `${id}.lock`);
+}
+function isPastDue(isoTimestamp) {
+  if (!isoTimestamp) return true;
+  const parsed = Date.parse(isoTimestamp);
+  return Number.isFinite(parsed) && parsed <= Date.now();
+}
+function isStaleAttempt(job) {
+  if (job.status !== "processing") return false;
+  if (!job.lastAttemptAt) return true;
+  const parsed = Date.parse(job.lastAttemptAt);
+  if (!Number.isFinite(parsed)) return true;
+  return Date.now() - parsed >= FINALIZE_JOB_LOCK_STALE_MS;
+}
+function readMetadataDisposition(job) {
+  const value = job.metadata.failureDisposition;
+  return value === "retryable" || value === "terminal" ? value : null;
+}
+function isTerminalFailure(job) {
+  return job.status === "failed" && readMetadataDisposition(job) === "terminal";
+}
+function isTerminalFailureExpired(job) {
+  if (!isTerminalFailure(job)) return false;
+  const updatedAtMs = Date.parse(job.updatedAt);
+  if (!Number.isFinite(updatedAtMs)) return false;
+  return Date.now() - updatedAtMs >= TERMINAL_FINALIZE_JOB_RETENTION_MS;
+}
+function matchesJobScope(job, scope) {
+  if (job.repoRoot !== scope.repoRoot) return false;
+  if (scope.currentAppId && job.currentAppId !== scope.currentAppId) return false;
+  if (scope.laneId && job.laneId !== scope.laneId) return false;
+  if (scope.repoFingerprint && job.repoFingerprint && job.repoFingerprint !== scope.repoFingerprint) return false;
+  return true;
+}
+function createEmptyPendingFinalizeQueueSummary() {
+  return {
+    state: "idle",
+    activeJobCount: 0,
+    queuedJobCount: 0,
+    processingJobCount: 0,
+    retryScheduledJobCount: 0,
+    failedJobCount: 0,
+    oldestCapturedAt: null,
+    newestCapturedAt: null,
+    nextRetryAt: null,
+    latestError: null
+  };
+}
+async function acquireJobLock(jobId) {
+  const lockPath = getJobLockPath(jobId);
+  try {
+    await fs3.mkdir(lockPath);
+    return true;
+  } catch (error) {
+    if (error?.code !== "EEXIST") {
+      throw error;
+    }
+  }
+  try {
+    const stat = await fs3.stat(lockPath);
+    if (Date.now() - stat.mtimeMs < FINALIZE_JOB_LOCK_STALE_MS) {
+      return false;
+    }
+    await fs3.rm(lockPath, { recursive: true, force: true });
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  try {
+    await fs3.mkdir(lockPath);
+    return true;
+  } catch (error) {
+    if (error?.code === "EEXIST") {
+      return false;
+    }
+    throw error;
+  }
+}
+function normalizeJob(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    schemaVersion: 1,
+    id: input.id ?? randomUUID2(),
+    status: input.status,
+    repoRoot: input.repoRoot,
+    repoFingerprint: input.repoFingerprint ?? null,
+    currentAppId: input.currentAppId,
+    laneId: input.laneId ?? null,
+    threadId: input.threadId ?? null,
+    branchName: input.branchName ?? null,
+    prompt: input.prompt,
+    assistantResponse: input.assistantResponse,
+    baselineSnapshotId: input.baselineSnapshotId ?? null,
+    baselineServerHeadHash: input.baselineServerHeadHash ?? null,
+    currentSnapshotId: input.currentSnapshotId,
+    capturedAt: input.capturedAt ?? now,
+    updatedAt: input.updatedAt ?? now,
+    idempotencyKey: input.idempotencyKey ?? null,
+    error: input.error ?? null,
+    retryCount: Number.isFinite(input.retryCount) ? Math.max(0, Number(input.retryCount)) : 0,
+    lastAttemptAt: input.lastAttemptAt ?? null,
+    nextRetryAt: input.nextRetryAt ?? null,
+    metadata: input.metadata ?? {}
+  };
+}
+async function enqueuePendingFinalizeJob(input) {
+  const job = normalizeJob(input);
+  await writeJsonAtomic(getJobPath(job.id), job);
+  return job;
+}
+async function readPendingFinalizeJob(jobId) {
+  try {
+    const raw = await fs3.readFile(getJobPath(jobId), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || parsed.schemaVersion !== 1 || typeof parsed.id !== "string") return null;
+    return normalizeJob({
+      id: parsed.id,
+      status: parsed.status ?? "queued",
+      repoRoot: String(parsed.repoRoot ?? ""),
+      repoFingerprint: parsed.repoFingerprint ?? null,
+      currentAppId: String(parsed.currentAppId ?? ""),
+      laneId: parsed.laneId ?? null,
+      threadId: parsed.threadId ?? null,
+      branchName: parsed.branchName ?? null,
+      prompt: String(parsed.prompt ?? ""),
+      assistantResponse: String(parsed.assistantResponse ?? ""),
+      baselineSnapshotId: parsed.baselineSnapshotId ?? null,
+      baselineServerHeadHash: parsed.baselineServerHeadHash ?? null,
+      currentSnapshotId: String(parsed.currentSnapshotId ?? ""),
+      capturedAt: parsed.capturedAt,
+      updatedAt: parsed.updatedAt,
+      idempotencyKey: parsed.idempotencyKey ?? null,
+      error: parsed.error ?? null,
+      retryCount: parsed.retryCount ?? 0,
+      lastAttemptAt: parsed.lastAttemptAt ?? null,
+      nextRetryAt: parsed.nextRetryAt ?? null,
+      metadata: parsed.metadata ?? {}
+    });
+  } catch {
+    return null;
+  }
+}
+async function listPendingFinalizeJobs() {
+  try {
+    const entries = await fs3.readdir(getFinalizeQueueRoot(), { withFileTypes: true });
+    const jobs = await Promise.all(
+      entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => readPendingFinalizeJob(entry.name.replace(/\.json$/, "")))
+    );
+    return jobs.filter((job) => Boolean(job)).sort((a, b) => a.capturedAt.localeCompare(b.capturedAt));
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function prunePendingFinalizeJobs() {
+  const jobs = await listPendingFinalizeJobs();
+  await Promise.all(
+    jobs.filter((job) => job.status === "completed" || isTerminalFailureExpired(job)).map((job) => removePendingFinalizeJob(job.id))
+  );
+}
+async function summarizePendingFinalizeJobs(scope) {
+  const jobs = (await listPendingFinalizeJobs()).filter((job) => matchesJobScope(job, scope));
+  const summary = createEmptyPendingFinalizeQueueSummary();
+  const relevantJobs = jobs.filter((job) => job.status !== "completed");
+  if (relevantJobs.length === 0) return summary;
+  summary.oldestCapturedAt = relevantJobs[0]?.capturedAt ?? null;
+  summary.newestCapturedAt = relevantJobs[relevantJobs.length - 1]?.capturedAt ?? null;
+  for (const job of relevantJobs) {
+    if (job.error) {
+      summary.latestError = job.error;
+    }
+    if (job.nextRetryAt && (!summary.nextRetryAt || job.nextRetryAt < summary.nextRetryAt)) {
+      summary.nextRetryAt = job.nextRetryAt;
+    }
+    if (job.status === "processing") {
+      summary.processingJobCount += 1;
+      continue;
+    }
+    if (job.status === "failed") {
+      summary.failedJobCount += 1;
+      continue;
+    }
+    if (!isPastDue(job.nextRetryAt)) {
+      summary.retryScheduledJobCount += 1;
+      continue;
+    }
+    summary.queuedJobCount += 1;
+  }
+  summary.activeJobCount = summary.queuedJobCount + summary.processingJobCount + summary.retryScheduledJobCount;
+  if (summary.processingJobCount > 0) {
+    summary.state = "processing";
+  } else if (summary.queuedJobCount > 0) {
+    summary.state = "queued";
+  } else if (summary.retryScheduledJobCount > 0) {
+    summary.state = "retry_scheduled";
+  } else if (summary.failedJobCount > 0) {
+    summary.state = "failed";
+  }
+  return summary;
+}
+async function updatePendingFinalizeJob(jobId, update) {
+  const existing = await readPendingFinalizeJob(jobId);
+  if (!existing) return null;
+  const next = {
+    ...existing,
+    ...update,
+    schemaVersion: 1,
+    id: existing.id,
+    capturedAt: existing.capturedAt,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    metadata: update.metadata ? { ...existing.metadata, ...update.metadata } : existing.metadata
+  };
+  await writeJsonAtomic(getJobPath(jobId), next);
+  return next;
+}
+async function claimPendingFinalizeJob(jobId) {
+  const lockPath = getJobLockPath(jobId);
+  const lockAcquired = await acquireJobLock(jobId);
+  if (!lockAcquired) return null;
+  let released = false;
+  const release = async () => {
+    if (released) return;
+    released = true;
+    await fs3.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+  };
+  try {
+    let existing = await readPendingFinalizeJob(jobId);
+    if (!existing) {
+      await release();
+      return null;
+    }
+    if (isStaleAttempt(existing)) {
+      const recovered = await updatePendingFinalizeJob(jobId, {
+        status: "queued",
+        error: existing.error ?? "Recovered a stale finalize processing lease.",
+        nextRetryAt: null
+      });
+      existing = recovered ?? existing;
+    }
+    if (existing.status === "failed") {
+      if (isTerminalFailure(existing)) {
+        await release();
+        return null;
+      }
+      const recovered = await updatePendingFinalizeJob(jobId, {
+        status: "queued",
+        nextRetryAt: existing.nextRetryAt ?? null
+      });
+      existing = recovered ?? existing;
+    }
+    if (existing.status !== "queued" || !isPastDue(existing.nextRetryAt)) {
+      await release();
+      return null;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const claimed = await updatePendingFinalizeJob(jobId, {
+      status: "processing",
+      error: null,
+      retryCount: existing.retryCount + 1,
+      lastAttemptAt: now,
+      nextRetryAt: null
+    });
+    if (!claimed) {
+      await release();
+      return null;
+    }
+    return { job: claimed, release };
+  } catch (error) {
+    await release();
+    throw error;
+  }
+}
+async function removePendingFinalizeJob(jobId) {
+  try {
+    await fs3.unlink(getJobPath(jobId));
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  await fs3.rm(getJobLockPath(jobId), { recursive: true, force: true }).catch(() => void 0);
+}
+
+// src/application/collab/shared.ts
+import { createHash as createHash3 } from "crypto";
 function unwrapResponseObject(resp, label) {
   const obj = resp?.responseObject;
   if (obj === void 0 || obj === null) {
@@ -126,7 +728,7 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function buildDeterministicIdempotencyKey(parts) {
-  return createHash("sha256").update(JSON.stringify(parts)).digest("hex");
+  return createHash3("sha256").update(JSON.stringify(parts)).digest("hex");
 }
 function formatCliErrorDetail(err) {
   if (err instanceof RemixError) {
@@ -567,974 +1169,1009 @@ async function ensureActiveLaneBinding(params) {
   });
 }
 
-// src/application/collab/recordingPreflight.ts
-async function collabRecordingPreflight(params) {
+// src/application/collab/collabDetectRepoState.ts
+function buildBaseState() {
+  return {
+    status: "ready",
+    repoState: null,
+    repoRoot: null,
+    binding: null,
+    currentBranch: null,
+    branchName: null,
+    localCommitHash: null,
+    currentSnapshotHash: null,
+    currentServerHeadHash: null,
+    currentServerHeadCommitId: null,
+    worktreeClean: false,
+    pendingFinalize: {
+      state: "idle",
+      activeJobCount: 0,
+      queuedJobCount: 0,
+      processingJobCount: 0,
+      retryScheduledJobCount: 0,
+      failedJobCount: 0,
+      oldestCapturedAt: null,
+      newestCapturedAt: null,
+      nextRetryAt: null,
+      latestError: null
+    },
+    warnings: [],
+    hint: null,
+    metadataWarnings: [],
+    baseline: {
+      lastSnapshotId: null,
+      lastSnapshotHash: null,
+      lastServerHeadHash: null,
+      lastSeenLocalCommitHash: null
+    }
+  };
+}
+async function collabDetectRepoState(params) {
+  const detected = buildBaseState();
   let repoRoot;
   try {
     repoRoot = await findGitRoot(params.cwd);
   } catch (error) {
-    const message = error instanceof Error ? error.message : "Not inside a git repository.";
-    return {
-      status: "not_git_repo",
-      repoRoot: null,
-      appId: null,
-      currentBranch: null,
-      branchName: null,
-      headCommitHash: null,
-      worktreeClean: false,
-      syncStatus: null,
-      syncTargetCommitHash: null,
-      syncTargetCommitId: null,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: [],
-      hint: message
-    };
+    detected.status = "not_git_repo";
+    detected.hint = formatCliErrorDetail(error) ?? "Not inside a git repository.";
+    return detected;
   }
-  const bindingResolution = await resolveActiveLaneBinding({ repoRoot, api: params.api });
+  detected.repoRoot = repoRoot;
+  const bindingResolution = await resolveActiveLaneBinding({ repoRoot, api: params.api ?? void 0 });
   if (bindingResolution.status === "not_bound") {
-    return {
-      status: "not_bound",
-      repoRoot,
-      appId: null,
-      currentBranch: null,
-      branchName: null,
-      headCommitHash: null,
-      worktreeClean: false,
-      syncStatus: null,
-      syncTargetCommitHash: null,
-      syncTargetCommitId: null,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: [],
-      hint: "Run `remix collab init` first."
-    };
+    detected.status = "not_bound";
+    detected.repoState = "binding_problem";
+    detected.hint = "Run `remix collab init` first.";
+    return detected;
   }
   if (bindingResolution.status === "missing_branch_binding") {
-    return {
-      status: "branch_binding_missing",
-      repoRoot,
-      appId: null,
-      currentBranch: bindingResolution.currentBranch,
-      branchName: bindingResolution.currentBranch,
-      headCommitHash: null,
-      worktreeClean: false,
-      syncStatus: null,
-      syncTargetCommitHash: null,
-      syncTargetCommitId: null,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: [],
-      hint: `Current branch ${bindingResolution.currentBranch ?? "(detached)"} is not yet bound to a Remix lane.`
-    };
+    detected.status = "branch_binding_missing";
+    detected.repoState = "binding_problem";
+    detected.currentBranch = bindingResolution.currentBranch;
+    detected.branchName = bindingResolution.currentBranch;
+    detected.hint = `Current branch ${bindingResolution.currentBranch ?? "(detached)"} is not yet bound to a Remix lane.`;
+    return detected;
   }
   if (bindingResolution.status === "ambiguous_family_selection") {
-    return {
-      status: "family_ambiguous",
-      repoRoot,
-      appId: null,
-      currentBranch: bindingResolution.currentBranch,
-      branchName: bindingResolution.currentBranch,
-      headCommitHash: null,
-      worktreeClean: false,
-      syncStatus: null,
-      syncTargetCommitHash: null,
-      syncTargetCommitId: null,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: [],
-      hint: "Multiple canonical Remix families match this repository. Continue from a checkout already bound to the intended family, or run `remix collab init --force-new` to create a new canonical family."
-    };
+    detected.status = "family_ambiguous";
+    detected.repoState = "binding_problem";
+    detected.currentBranch = bindingResolution.currentBranch;
+    detected.branchName = bindingResolution.currentBranch;
+    detected.hint = "Multiple canonical Remix families match this repository. Continue from a checkout already bound to the intended family, or run `remix collab init --force-new`.";
+    return detected;
   }
   if (bindingResolution.status === "binding_conflict") {
-    return {
-      status: "metadata_conflict",
-      repoRoot,
-      appId: bindingResolution.binding.currentAppId,
-      currentBranch: bindingResolution.currentBranch,
-      branchName: bindingResolution.binding.branchName,
-      headCommitHash: null,
-      worktreeClean: false,
-      syncStatus: null,
-      syncTargetCommitHash: null,
-      syncTargetCommitId: null,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: [],
-      hint: `Local binding for ${bindingResolution.currentBranch ?? "(detached)"} points to app ${bindingResolution.binding.currentAppId}, but the server resolved lane ${bindingResolution.resolvedLane.laneId ?? "(unknown)"} / app ${bindingResolution.resolvedLane.currentAppId ?? "(unknown)"}. Repair the branch binding before recording work.`
-    };
+    detected.status = "metadata_conflict";
+    detected.repoState = "metadata_conflict";
+    detected.binding = bindingResolution.binding;
+    detected.currentBranch = bindingResolution.currentBranch;
+    detected.branchName = bindingResolution.binding.branchName;
+    detected.hint = `Local binding for ${bindingResolution.currentBranch ?? "(detached)"} points to app ${bindingResolution.binding.currentAppId}, but the server resolved lane ${bindingResolution.resolvedLane.laneId ?? "(unknown)"} / app ${bindingResolution.resolvedLane.currentAppId ?? "(unknown)"}.`;
+    return detected;
   }
   const binding = bindingResolution.binding;
-  const [currentBranch, headCommitHash, worktreeStatus] = await Promise.all([
+  detected.binding = binding;
+  const [currentBranch, localCommitHash, worktreeStatus] = await Promise.all([
     getCurrentBranch(repoRoot),
     getHeadCommitHash(repoRoot),
     getWorktreeStatus(repoRoot)
   ]);
-  const branchName = binding.branchName ?? null;
-  if (!headCommitHash) {
-    return {
-      status: "missing_head",
-      repoRoot,
-      appId: binding.currentAppId,
-      currentBranch,
-      branchName,
-      headCommitHash: null,
-      worktreeClean: worktreeStatus.isClean,
-      syncStatus: null,
-      syncTargetCommitHash: null,
-      syncTargetCommitId: null,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: [],
-      hint: "Failed to resolve local HEAD commit."
-    };
+  detected.currentBranch = currentBranch;
+  detected.branchName = binding.branchName ?? null;
+  detected.localCommitHash = localCommitHash;
+  detected.worktreeClean = worktreeStatus.isClean;
+  if (!localCommitHash) {
+    detected.status = "missing_head";
+    detected.repoState = "binding_problem";
+    detected.hint = "Failed to resolve local HEAD commit.";
+    return detected;
   }
-  if (!params.allowBranchMismatch && !isBoundBranchMatch(currentBranch, branchName)) {
-    return {
-      status: "branch_mismatch",
-      repoRoot,
-      appId: binding.currentAppId,
-      currentBranch,
-      branchName,
-      headCommitHash,
-      worktreeClean: worktreeStatus.isClean,
-      syncStatus: null,
-      syncTargetCommitHash: null,
-      syncTargetCommitId: null,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: [],
-      hint: buildBranchMismatchHint({
-        currentBranch,
-        branchName
-      })
-    };
+  if (!params.allowBranchMismatch && !isBoundBranchMatch(currentBranch, binding.branchName ?? null)) {
+    detected.status = "branch_mismatch";
+    detected.repoState = "binding_problem";
+    detected.hint = buildBranchMismatchHint({ currentBranch, branchName: binding.branchName ?? null });
+    return detected;
   }
-  const syncResp = await params.api.syncLocalApp(binding.currentAppId, {
-    baseCommitHash: headCommitHash,
-    repoFingerprint: binding.repoFingerprint ?? void 0,
-    remoteUrl: binding.remoteUrl ?? void 0,
-    defaultBranch: binding.defaultBranch ?? void 0,
-    dryRun: true
-  });
-  const sync = unwrapResponseObject(syncResp, "sync result");
-  if (sync.status === "conflict_risk") {
-    return {
-      status: "metadata_conflict",
-      repoRoot,
-      appId: binding.currentAppId,
-      currentBranch,
-      branchName,
-      headCommitHash,
-      worktreeClean: worktreeStatus.isClean,
-      syncStatus: sync.status,
-      syncTargetCommitHash: sync.targetCommitHash,
-      syncTargetCommitId: sync.targetCommitId,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: sync.warnings,
-      hint: sync.warnings.join("\n") || "Run the command from the correct bound repository."
-    };
-  }
-  if (sync.status === "up_to_date" || sync.status === "ready_to_fast_forward") {
-    return {
-      status: sync.status,
-      repoRoot,
-      appId: binding.currentAppId,
-      currentBranch,
-      branchName,
-      headCommitHash,
-      worktreeClean: worktreeStatus.isClean,
-      syncStatus: sync.status,
-      syncTargetCommitHash: sync.targetCommitHash,
-      syncTargetCommitId: sync.targetCommitId,
-      reconcileTargetHeadCommitHash: null,
-      reconcileTargetHeadCommitId: null,
-      warnings: sync.warnings,
-      hint: null
-    };
-  }
-  const reconcileResp = await params.api.preflightAppReconcile(binding.currentAppId, {
-    localHeadCommitHash: headCommitHash,
-    repoFingerprint: binding.repoFingerprint ?? void 0,
-    remoteUrl: binding.remoteUrl ?? void 0,
-    defaultBranch: binding.defaultBranch ?? void 0
-  });
-  const reconcile = unwrapResponseObject(reconcileResp, "reconcile preflight");
-  if (reconcile.status === "metadata_conflict") {
-    return {
-      status: "metadata_conflict",
-      repoRoot,
-      appId: binding.currentAppId,
-      currentBranch,
-      branchName,
-      headCommitHash,
-      worktreeClean: worktreeStatus.isClean,
-      syncStatus: sync.status,
-      syncTargetCommitHash: sync.targetCommitHash,
-      syncTargetCommitId: sync.targetCommitId,
-      reconcileTargetHeadCommitHash: reconcile.targetHeadCommitHash,
-      reconcileTargetHeadCommitId: reconcile.targetHeadCommitId,
-      warnings: reconcile.warnings,
-      hint: reconcile.warnings.join("\n") || "Run the command from the correct bound repository."
-    };
-  }
-  if (reconcile.status === "up_to_date") {
-    return {
-      status: "up_to_date",
-      repoRoot,
-      appId: binding.currentAppId,
-      currentBranch,
-      branchName,
-      headCommitHash,
-      worktreeClean: worktreeStatus.isClean,
-      syncStatus: sync.status,
-      syncTargetCommitHash: sync.targetCommitHash,
-      syncTargetCommitId: sync.targetCommitId,
-      reconcileTargetHeadCommitHash: reconcile.targetHeadCommitHash,
-      reconcileTargetHeadCommitId: reconcile.targetHeadCommitId,
-      warnings: reconcile.warnings,
-      hint: null
-    };
+  if (!params.api) {
+    const [inspection, pendingFinalize] = await Promise.all([
+      inspectLocalSnapshot({
+        repoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        laneId: binding.laneId,
+        branchName: binding.branchName,
+        persistBlobs: false
+      }),
+      summarizePendingFinalizeJobs({
+        repoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        currentAppId: binding.currentAppId,
+        laneId: binding.laneId
+      })
+    ]);
+    detected.currentSnapshotHash = inspection.snapshotHash;
+    detected.pendingFinalize = pendingFinalize;
+    return detected;
   }
-  return {
-    status: "reconcile_required",
-    repoRoot,
-    appId: binding.currentAppId,
-    currentBranch,
-    branchName,
-    headCommitHash,
-    worktreeClean: worktreeStatus.isClean,
-    syncStatus: sync.status,
-    syncTargetCommitHash: sync.targetCommitHash,
-    syncTargetCommitId: sync.targetCommitId,
-    reconcileTargetHeadCommitHash: reconcile.targetHeadCommitHash,
-    reconcileTargetHeadCommitId: reconcile.targetHeadCommitId,
-    warnings: reconcile.warnings,
-    hint: reconcile.warnings.join("\n") || "Run `remix collab reconcile` first because the local history is no longer fast-forward compatible with the app."
-  };
-}
-
-// src/infrastructure/locking/repoMutationLock.ts
-import fs from "fs/promises";
-import os from "os";
-import path from "path";
-var DEFAULT_ACQUIRE_TIMEOUT_MS = 15e3;
-var DEFAULT_STALE_MS = 45e3;
-var DEFAULT_HEARTBEAT_MS = 5e3;
-var RETRY_DELAY_MS = 250;
-var heldLocks = /* @__PURE__ */ new Map();
-function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function createOwner(params) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  return {
-    operation: params.operation,
-    repoRoot: params.repoRoot,
-    pid: process.pid,
-    hostname: os.hostname(),
-    startedAt: now,
-    heartbeatAt: now,
-    version: process.version,
-    requestId: params.requestId?.trim() || null
-  };
-}
-async function writeOwnerMetadata(ownerPath, owner) {
-  await fs.writeFile(ownerPath, `${JSON.stringify(owner, null, 2)}
-`, "utf8");
-}
-async function readOwnerMetadata(ownerPath) {
   try {
-    const raw = await fs.readFile(ownerPath, "utf8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object") return null;
-    if (!parsed.operation || !parsed.repoRoot || typeof parsed.pid !== "number" || !parsed.startedAt || !parsed.heartbeatAt) {
-      return null;
-    }
-    return {
-      operation: parsed.operation,
-      repoRoot: parsed.repoRoot,
-      pid: parsed.pid,
-      hostname: typeof parsed.hostname === "string" ? parsed.hostname : "unknown",
-      startedAt: parsed.startedAt,
-      heartbeatAt: parsed.heartbeatAt,
-      version: typeof parsed.version === "string" ? parsed.version : "unknown",
-      requestId: typeof parsed.requestId === "string" ? parsed.requestId : null
+    const [headResp, inspection, baseline, pendingFinalize] = await Promise.all([
+      params.api.getAppHead(binding.currentAppId),
+      inspectLocalSnapshot({
+        repoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        laneId: binding.laneId,
+        branchName: binding.branchName,
+        persistBlobs: false
+      }),
+      readLocalBaseline({
+        repoFingerprint: binding.repoFingerprint,
+        laneId: binding.laneId,
+        repoRoot
+      }),
+      summarizePendingFinalizeJobs({
+        repoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        currentAppId: binding.currentAppId,
+        laneId: binding.laneId
+      })
+    ]);
+    const appHead = unwrapResponseObject(headResp, "app head");
+    detected.currentServerHeadHash = appHead.headCommitHash;
+    detected.currentServerHeadCommitId = appHead.headCommitId;
+    detected.currentSnapshotHash = inspection.snapshotHash;
+    detected.pendingFinalize = pendingFinalize;
+    detected.baseline = {
+      lastSnapshotId: baseline?.lastSnapshotId ?? null,
+      lastSnapshotHash: baseline?.lastSnapshotHash ?? null,
+      lastServerHeadHash: baseline?.lastServerHeadHash ?? null,
+      lastSeenLocalCommitHash: baseline?.lastSeenLocalCommitHash ?? null
     };
-  } catch {
-    return null;
-  }
-}
-async function isProcessAlive(owner) {
-  if (!owner) return null;
-  if (owner.hostname !== os.hostname()) return null;
-  try {
-    process.kill(owner.pid, 0);
-    return true;
-  } catch (error) {
-    if (error?.code === "EPERM") return true;
-    if (error?.code === "ESRCH") return false;
-    return null;
-  }
-}
-async function getLastKnownUpdateMs(lockDir, ownerPath, owner) {
-  const heartbeatMs = owner ? Date.parse(owner.heartbeatAt) : Number.NaN;
-  if (Number.isFinite(heartbeatMs)) return heartbeatMs;
-  const startedMs = owner ? Date.parse(owner.startedAt) : Number.NaN;
-  if (Number.isFinite(startedMs)) return startedMs;
-  const stat = await fs.stat(ownerPath).catch(() => null);
-  if (stat) return stat.mtimeMs;
-  const dirStat = await fs.stat(lockDir).catch(() => null);
-  if (dirStat) return dirStat.mtimeMs;
-  return 0;
-}
-async function ensureLockDir(lockDir) {
-  await fs.mkdir(path.dirname(lockDir), { recursive: true });
-}
-async function tryAcquireLock(lockDir, ownerPath, owner) {
-  try {
-    await ensureLockDir(lockDir);
-    await fs.mkdir(lockDir);
-    try {
-      await writeOwnerMetadata(ownerPath, owner);
-    } catch (error) {
-      await fs.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
-      throw error;
+    if (!baseline?.lastSnapshotHash || !baseline.lastServerHeadHash) {
+      if (detected.worktreeClean && localCommitHash && localCommitHash !== appHead.headCommitHash) {
+        try {
+          const bootstrapResp = await params.api.getAppDelta(binding.currentAppId, {
+            baseHeadHash: localCommitHash,
+            targetHeadHash: appHead.headCommitHash,
+            repoFingerprint: binding.repoFingerprint ?? void 0,
+            remoteUrl: binding.remoteUrl ?? void 0,
+            defaultBranch: binding.defaultBranch ?? void 0
+          });
+          const bootstrapDelta = unwrapResponseObject(bootstrapResp, "app delta");
+          detected.metadataWarnings = Array.from(/* @__PURE__ */ new Set([...detected.metadataWarnings, ...bootstrapDelta.warnings]));
+          detected.warnings.push(...bootstrapDelta.warnings);
+          if (bootstrapDelta.status === "conflict_risk") {
+            detected.status = "metadata_conflict";
+            detected.repoState = "metadata_conflict";
+            detected.hint = bootstrapDelta.warnings.join("\n") || "Run the command from the correct bound repository.";
+            return detected;
+          }
+          if (bootstrapDelta.status === "delta_ready" || bootstrapDelta.status === "up_to_date") {
+            detected.repoState = "server_only_changed";
+            detected.hint = "This checkout has not stored a local Remix baseline yet, but its current Git HEAD is already known to Remix. Pull the server delta locally to create the first baseline for this checkout.";
+            return detected;
+          }
+        } catch {
+        }
+      }
+      detected.repoState = "external_local_base_changed";
+      detected.hint = "No local Remix baseline exists for this lane yet. Run `remix collab re-anchor` to anchor this checkout.";
+      return detected;
     }
-    return true;
+    const localHeadMovedSinceBaseline = Boolean(baseline.lastSeenLocalCommitHash) && localCommitHash !== baseline.lastSeenLocalCommitHash;
+    if (localHeadMovedSinceBaseline) {
+      detected.warnings.push(
+        "Local Git HEAD changed since the last Remix baseline. Remix will use the current workspace snapshot to detect divergence."
+      );
+    }
+    const metadataBaseHeadHash = baseline.lastServerHeadHash || appHead.headCommitHash;
+    const metadataResp = await params.api.getAppDelta(binding.currentAppId, {
+      baseHeadHash: metadataBaseHeadHash,
+      targetHeadHash: metadataBaseHeadHash,
+      repoFingerprint: binding.repoFingerprint ?? void 0,
+      remoteUrl: binding.remoteUrl ?? void 0,
+      defaultBranch: binding.defaultBranch ?? void 0
+    });
+    const metadataCheck = unwrapResponseObject(metadataResp, "app delta metadata");
+    detected.metadataWarnings = metadataCheck.warnings;
+    detected.warnings.push(...metadataCheck.warnings);
+    if (metadataCheck.status === "conflict_risk") {
+      detected.status = "metadata_conflict";
+      detected.repoState = "metadata_conflict";
+      detected.hint = metadataCheck.warnings.join("\n") || "Run the command from the correct bound repository.";
+      return detected;
+    }
+    const localChanged = inspection.snapshotHash !== baseline.lastSnapshotHash;
+    const serverChanged = appHead.headCommitHash !== baseline.lastServerHeadHash;
+    if (!localChanged && !serverChanged) {
+      detected.repoState = "idle";
+      return detected;
+    }
+    if (localChanged && !serverChanged) {
+      detected.repoState = "local_only_changed";
+      return detected;
+    }
+    if (!localChanged && serverChanged) {
+      detected.repoState = "server_only_changed";
+      detected.hint = "The server lane advanced since the last agreed baseline. Pull the server delta locally before continuing.";
+      return detected;
+    }
+    detected.repoState = "both_changed";
+    detected.hint = "Both the local workspace and the server lane changed since the last agreed baseline. Replay or reconcile is required before normal recording continues.";
+    return detected;
   } catch (error) {
-    if (error?.code === "EEXIST") return false;
-    throw error;
+    detected.status = "remote_error";
+    detected.hint = formatCliErrorDetail(error) ?? "Failed to detect the current Remix repo state.";
+    return detected;
   }
 }
-function formatLockHint(params) {
-  const lines = [
-    params.observedHeldLock ? `Observed lock state: ${REMIX_ERROR_CODES.REPO_LOCK_HELD}.` : null,
-    params.owner ? `Active operation: ${params.owner.operation}` : "Active operation: unknown",
-    params.owner ? `Repo root: ${params.owner.repoRoot}` : null,
-    params.owner ? `Owner: pid=${params.owner.pid} host=${params.owner.hostname}` : null,
-    params.owner ? `Started at: ${params.owner.startedAt}` : null,
-    params.owner ? `Heartbeat at: ${params.owner.heartbeatAt}` : null,
-    `Waited ${params.waitedMs}ms for the repo mutation lock.`,
-    `Stale lock threshold: ${params.staleMs}ms.`,
-    "Retry after the active operation finishes. If the process crashed, wait for stale lock recovery or remove the stale lock manually if necessary."
-  ];
-  return lines.filter(Boolean).join("\n");
+
+// src/application/collab/collabFinalizeProcessing.ts
+var FINALIZE_RETRY_BASE_DELAY_MS = 15e3;
+var FINALIZE_RETRY_MAX_DELAY_MS = 5 * 60 * 1e3;
+function readMetadataString(job, key) {
+  const value = job.metadata[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function formatOwnerSummary(owner) {
-  if (!owner) {
-    return "unknown owner";
-  }
-  return `operation=${owner.operation} pid=${owner.pid} host=${owner.hostname} startedAt=${owner.startedAt} heartbeatAt=${owner.heartbeatAt}`;
+function readMetadataActor(job) {
+  const actor = job.metadata.actor;
+  return actor && typeof actor === "object" ? actor : void 0;
 }
-function buildStaleRecoveryNotice(owner) {
-  return {
-    code: REMIX_ERROR_CODES.REPO_LOCK_STALE_RECOVERED,
-    owner,
-    message: `[${REMIX_ERROR_CODES.REPO_LOCK_STALE_RECOVERED}] Recovered a stale Remix repo mutation lock (${formatOwnerSummary(owner)}).`
-  };
+function buildNextRetryAt(retryCount) {
+  const exponent = Math.max(0, retryCount - 1);
+  const delayMs = Math.min(FINALIZE_RETRY_BASE_DELAY_MS * 2 ** exponent, FINALIZE_RETRY_MAX_DELAY_MS);
+  return new Date(Date.now() + delayMs).toISOString();
 }
-async function acquirePhysicalLock(lockDir, ownerPath, owner, options) {
-  const startedAt = Date.now();
-  const notices = [];
-  let observedHeldLock = false;
-  while (Date.now() - startedAt < options.acquireTimeoutMs) {
-    if (await tryAcquireLock(lockDir, ownerPath, owner)) return notices;
-    const currentOwner2 = await readOwnerMetadata(ownerPath);
-    observedHeldLock = true;
-    const lastUpdateMs = await getLastKnownUpdateMs(lockDir, ownerPath, currentOwner2);
-    const ageMs = Math.max(0, Date.now() - lastUpdateMs);
-    const alive = await isProcessAlive(currentOwner2);
-    if (ageMs >= options.staleMs && alive !== true) {
-      notices.push(buildStaleRecoveryNotice(currentOwner2));
-      await fs.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
-      continue;
-    }
-    await sleep2(RETRY_DELAY_MS);
-  }
-  const currentOwner = await readOwnerMetadata(ownerPath);
-  throw new RemixError("Repository is busy with another Remix mutation.", {
-    code: REMIX_ERROR_CODES.REPO_LOCK_TIMEOUT,
-    exitCode: 2,
-    hint: formatLockHint({
-      owner: currentOwner,
-      waitedMs: Date.now() - startedAt,
-      staleMs: options.staleMs,
-      observedHeldLock
-    })
+function buildFinalizeCliError(params) {
+  const error = new RemixError(params.message, {
+    exitCode: params.exitCode,
+    hint: params.hint
   });
+  error.finalizeDisposition = params.disposition;
+  error.finalizeReason = params.reason;
+  return error;
 }
-function startHeartbeat(lockDir, ownerPath, owner, heartbeatMs) {
-  return setInterval(() => {
-    const nextOwner = {
-      ...owner,
-      heartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    owner.heartbeatAt = nextOwner.heartbeatAt;
-    void writeOwnerMetadata(ownerPath, nextOwner).catch(() => void 0);
-    void fs.utimes(lockDir, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date()).catch(() => void 0);
-  }, heartbeatMs);
+function classifyFinalizeError(error) {
+  const tagged = error;
+  return {
+    disposition: tagged.finalizeDisposition ?? "retryable",
+    reason: tagged.finalizeReason ?? "unknown",
+    message: error instanceof Error ? error.message : String(error)
+  };
 }
-async function releaseReentrantLock(lockDir) {
-  const held = heldLocks.get(lockDir);
-  if (!held) return;
-  held.count -= 1;
-  if (held.count > 0) return;
-  clearInterval(held.heartbeatTimer);
-  heldLocks.delete(lockDir);
-  await fs.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+function buildWorkspaceMetadata(params) {
+  return {
+    branch: params.branchName,
+    repoRoot: params.repoRoot,
+    remoteUrl: params.remoteUrl,
+    defaultBranch: params.defaultBranch,
+    recordingMode: "boundary_delta",
+    baselineSnapshotId: params.baselineSnapshotId,
+    currentSnapshotId: params.currentSnapshotId,
+    baselineServerHeadHash: params.baselineServerHeadHash,
+    currentSnapshotHash: params.currentSnapshotHash,
+    localCommitHash: params.localCommitHash,
+    repoStateAtCapture: params.repoState,
+    replayedFromBaseHash: params.replayedFromBaseHash ?? null
+  };
 }
-async function withRepoMutationLock(options, fn) {
-  const repoRoot = await findGitRoot(options.cwd);
-  const gitCommonDir = await getGitCommonDir(repoRoot);
-  const lockDir = path.join(gitCommonDir, "remix", "locks", "repo-mutation.lock");
-  const owner = createOwner({
-    operation: options.operation,
-    repoRoot,
-    requestId: options.requestId
-  });
-  const heartbeatMs = options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
-  const acquireTimeoutMs = options.acquireTimeoutMs ?? DEFAULT_ACQUIRE_TIMEOUT_MS;
-  const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
-  const existing = heldLocks.get(lockDir);
-  let notices = [];
-  if (!existing) {
-    notices = await acquirePhysicalLock(lockDir, path.join(lockDir, "owner.json"), owner, {
-      acquireTimeoutMs,
-      staleMs
-    });
-    const ownerPath = path.join(lockDir, "owner.json");
-    heldLocks.set(lockDir, {
-      count: 1,
-      lockDir,
-      ownerPath,
-      owner,
-      heartbeatTimer: startHeartbeat(lockDir, ownerPath, owner, heartbeatMs)
-    });
-  } else {
-    existing.count += 1;
-  }
+async function processClaimedPendingFinalizeJob(params) {
+  const job = params.job;
   try {
-    return await fn({
-      repoRoot,
-      gitCommonDir,
-      lockDir,
-      notices,
-      warnings: notices.map((notice) => notice.message)
+    const [snapshot, baseline, appHeadResp] = await Promise.all([
+      readLocalSnapshot(job.currentSnapshotId),
+      readLocalBaseline({
+        repoFingerprint: job.repoFingerprint,
+        laneId: job.laneId,
+        repoRoot: job.repoRoot
+      }),
+      params.api.getAppHead(job.currentAppId)
+    ]);
+    if (!snapshot) {
+      throw buildFinalizeCliError({
+        message: "Captured snapshot is missing from the local snapshot store.",
+        exitCode: 1,
+        disposition: "terminal",
+        reason: "snapshot_missing"
+      });
+    }
+    if (!baseline) {
+      throw buildFinalizeCliError({
+        message: "Local baseline is missing for this queued finalize job.",
+        exitCode: 2,
+        hint: "Run `remix collab re-anchor` to anchor the repository again.",
+        disposition: "terminal",
+        reason: "baseline_missing"
+      });
+    }
+    if (baseline.lastSnapshotId !== job.baselineSnapshotId || baseline.lastServerHeadHash !== job.baselineServerHeadHash) {
+      throw buildFinalizeCliError({
+        message: "Finalize queue baseline drifted before this job was processed.",
+        exitCode: 1,
+        hint: "Process queued finalize jobs in capture order, or re-anchor the repository before retrying.",
+        disposition: "terminal",
+        reason: "baseline_drifted"
+      });
+    }
+    const appHead = unwrapResponseObject(appHeadResp, "app head");
+    const remoteUrl = readMetadataString(job, "remoteUrl");
+    const defaultBranch = readMetadataString(job, "defaultBranch");
+    const repoState = readMetadataString(job, "repoState");
+    const actor = readMetadataActor(job);
+    const diffResult = await diffLocalSnapshots({
+      baseSnapshotId: job.baselineSnapshotId,
+      targetSnapshotId: job.currentSnapshotId
     });
-  } finally {
-    await releaseReentrantLock(lockDir);
-  }
-}
-
-// src/application/collab/collabSync.ts
-import fs2 from "fs/promises";
-import os2 from "os";
-import path2 from "path";
-async function collabSync(params) {
-  const repoRoot = await findGitRoot(params.cwd);
-  const binding = await ensureActiveLaneBinding({
-    repoRoot,
-    api: params.api,
-    operation: "`remix collab sync`"
-  });
-  if (!binding) {
-    throw new RemixError("Repository is not bound to Remix.", {
-      exitCode: 2,
-      hint: "Run `remix collab init` first."
+    if (!diffResult.diff.trim()) {
+      if (appHead.headCommitHash !== job.baselineServerHeadHash) {
+        throw buildFinalizeCliError({
+          message: "Server lane changed before a no-diff turn could be recorded.",
+          exitCode: 2,
+          hint: "Pull the server changes locally before recording another no-diff turn.",
+          disposition: "terminal",
+          reason: "server_lane_changed"
+        });
+      }
+      const collabTurnResp = await params.api.createCollabTurn(job.currentAppId, {
+        threadId: job.threadId ?? void 0,
+        collabLaneId: job.laneId ?? void 0,
+        prompt: job.prompt,
+        assistantResponse: job.assistantResponse,
+        actor,
+        workspaceMetadata: buildWorkspaceMetadata({
+          repoRoot: job.repoRoot,
+          branchName: job.branchName,
+          remoteUrl,
+          defaultBranch,
+          baselineSnapshotId: job.baselineSnapshotId,
+          currentSnapshotId: job.currentSnapshotId,
+          baselineServerHeadHash: job.baselineServerHeadHash,
+          currentSnapshotHash: snapshot.snapshotHash,
+          localCommitHash: snapshot.localCommitHash,
+          repoState
+        }),
+        idempotencyKey: job.idempotencyKey ?? void 0
+      });
+      const collabTurn = unwrapResponseObject(collabTurnResp, "collab turn");
+      await writeLocalBaseline({
+        repoRoot: job.repoRoot,
+        repoFingerprint: job.repoFingerprint,
+        laneId: job.laneId,
+        currentAppId: job.currentAppId,
+        branchName: job.branchName,
+        lastSnapshotId: snapshot.id,
+        lastSnapshotHash: snapshot.snapshotHash,
+        lastServerHeadHash: appHead.headCommitHash,
+        lastSeenLocalCommitHash: snapshot.localCommitHash
+      });
+      await updatePendingFinalizeJob(job.id, {
+        status: "completed",
+        metadata: { collabTurnId: collabTurn.id }
+      });
+      return {
+        mode: "no_diff_turn",
+        idempotencyKey: job.idempotencyKey ?? "",
+        queued: false,
+        jobId: job.id,
+        repoState,
+        changeStep: null,
+        collabTurn,
+        autoSync: null,
+        warnings: []
+      };
+    }
+    let submissionDiff = diffResult.diff;
+    let submissionBaseHeadHash = job.baselineServerHeadHash;
+    let replayedFromBaseHash = null;
+    if (!submissionBaseHeadHash) {
+      throw buildFinalizeCliError({
+        message: "Baseline server head is missing for this finalize job.",
+        exitCode: 1,
+        disposition: "terminal",
+        reason: "baseline_server_head_missing"
+      });
+    }
+    if (appHead.headCommitHash !== submissionBaseHeadHash) {
+      const replayResp = await params.api.startChangeStepReplay(job.currentAppId, {
+        prompt: job.prompt,
+        assistantResponse: job.assistantResponse,
+        diff: diffResult.diff,
+        baseCommitHash: submissionBaseHeadHash,
+        targetHeadCommitHash: appHead.headCommitHash,
+        expectedPaths: diffResult.changedPaths,
+        actor,
+        workspaceMetadata: buildWorkspaceMetadata({
+          repoRoot: job.repoRoot,
+          branchName: job.branchName,
+          remoteUrl,
+          defaultBranch,
+          baselineSnapshotId: job.baselineSnapshotId,
+          currentSnapshotId: job.currentSnapshotId,
+          baselineServerHeadHash: job.baselineServerHeadHash,
+          currentSnapshotHash: snapshot.snapshotHash,
+          localCommitHash: snapshot.localCommitHash,
+          repoState
+        }),
+        idempotencyKey: buildDeterministicIdempotencyKey({
+          kind: "collab_finalize_turn_replay_v1",
+          appId: job.currentAppId,
+          baseCommitHash: submissionBaseHeadHash,
+          targetHeadCommitHash: appHead.headCommitHash,
+          currentSnapshotId: job.currentSnapshotId,
+          diffSha256: diffResult.diffSha256
+        })
+      });
+      const replayStart = unwrapResponseObject(replayResp, "change step replay");
+      const replay = await pollChangeStepReplay(params.api, job.currentAppId, String(replayStart.id));
+      const replayDiffResp = await params.api.getChangeStepReplayDiff(job.currentAppId, replay.id);
+      const replayDiff = unwrapResponseObject(replayDiffResp, "change step replay diff");
+      submissionDiff = replayDiff.diff;
+      replayedFromBaseHash = submissionBaseHeadHash;
+      submissionBaseHeadHash = appHead.headCommitHash;
+    }
+    const changeStepResp = await params.api.createChangeStep(job.currentAppId, {
+      threadId: job.threadId ?? void 0,
+      collabLaneId: job.laneId ?? void 0,
+      prompt: job.prompt,
+      assistantResponse: job.assistantResponse,
+      diff: submissionDiff,
+      baseCommitHash: submissionBaseHeadHash,
+      headCommitHash: submissionBaseHeadHash,
+      changedFilesCount: diffResult.stats.changedFilesCount,
+      insertions: diffResult.stats.insertions,
+      deletions: diffResult.stats.deletions,
+      actor,
+      workspaceMetadata: buildWorkspaceMetadata({
+        repoRoot: job.repoRoot,
+        branchName: job.branchName,
+        remoteUrl,
+        defaultBranch,
+        baselineSnapshotId: job.baselineSnapshotId,
+        currentSnapshotId: job.currentSnapshotId,
+        baselineServerHeadHash: job.baselineServerHeadHash,
+        currentSnapshotHash: snapshot.snapshotHash,
+        localCommitHash: snapshot.localCommitHash,
+        repoState,
+        replayedFromBaseHash
+      }),
+      idempotencyKey: job.idempotencyKey ?? void 0
     });
-  }
-  await ensureCleanWorktree(repoRoot);
-  const branch = await requireCurrentBranch(repoRoot);
-  assertBoundBranchMatch({
-    currentBranch: branch,
-    branchName: binding.branchName,
-    allowBranchMismatch: params.allowBranchMismatch,
-    operation: "`remix collab sync`"
-  });
-  const headCommitHash = await getHeadCommitHash(repoRoot);
-  const repoSnapshot = await captureRepoSnapshot(repoRoot);
-  if (!headCommitHash) {
-    throw new RemixError("Failed to resolve local HEAD commit.", { exitCode: 1 });
-  }
-  const resp = await params.api.syncLocalApp(binding.currentAppId, {
-    baseCommitHash: headCommitHash,
-    repoFingerprint: binding.repoFingerprint ?? void 0,
-    remoteUrl: binding.remoteUrl ?? void 0,
-    defaultBranch: binding.defaultBranch ?? void 0,
-    dryRun: params.dryRun
-  });
-  const sync = unwrapResponseObject(resp, "sync result");
-  if (sync.status === "conflict_risk") {
-    throw new RemixError("Local repository metadata conflicts with the bound Remix app.", {
-      exitCode: 2,
-      hint: sync.warnings.join("\n") || "Run the command from the correct bound repository."
+    const createdStep = unwrapResponseObject(changeStepResp, "change step");
+    const changeStep = await pollChangeStep(params.api, job.currentAppId, String(createdStep.id));
+    const nextHeadResp = await params.api.getAppHead(job.currentAppId);
+    const nextHead = unwrapResponseObject(nextHeadResp, "app head");
+    await writeLocalBaseline({
+      repoRoot: job.repoRoot,
+      repoFingerprint: job.repoFingerprint,
+      laneId: job.laneId,
+      currentAppId: job.currentAppId,
+      branchName: job.branchName,
+      lastSnapshotId: snapshot.id,
+      lastSnapshotHash: snapshot.snapshotHash,
+      lastServerHeadHash: nextHead.headCommitHash,
+      lastSeenLocalCommitHash: snapshot.localCommitHash
     });
-  }
-  if (sync.status === "base_unknown") {
-    throw new RemixError("Local repository cannot be fast-forward synced.", {
-      exitCode: 2,
-      hint: "Your local HEAD is not on the app sandbox history. Reconcile the repository manually before syncing."
+    await updatePendingFinalizeJob(job.id, {
+      status: "completed",
+      metadata: { changeStepId: String(changeStep.id ?? "") }
     });
-  }
-  if (sync.status === "up_to_date") {
     return {
-      status: sync.status,
-      branch,
-      repoRoot,
-      baseCommitHash: sync.baseCommitHash,
-      targetCommitHash: sync.targetCommitHash,
-      targetCommitId: sync.targetCommitId,
-      stats: sync.stats,
-      localCommitHash: headCommitHash,
-      applied: false,
-      dryRun: params.dryRun
+      mode: "changed_turn",
+      idempotencyKey: job.idempotencyKey ?? "",
+      queued: false,
+      jobId: job.id,
+      repoState,
+      changeStep,
+      collabTurn: null,
+      autoSync: null,
+      warnings: []
     };
+  } catch (error) {
+    const classified = classifyFinalizeError(error);
+    await updatePendingFinalizeJob(job.id, {
+      status: classified.disposition === "terminal" ? "failed" : "queued",
+      error: classified.message,
+      nextRetryAt: classified.disposition === "terminal" ? null : buildNextRetryAt(job.retryCount),
+      metadata: {
+        failureDisposition: classified.disposition,
+        failureReason: classified.reason
+      }
+    });
+    throw error;
+  } finally {
+    await params.release();
   }
-  const previewResult = {
-    status: sync.status,
-    branch,
-    repoRoot,
-    baseCommitHash: sync.baseCommitHash,
-    targetCommitHash: sync.targetCommitHash,
-    targetCommitId: sync.targetCommitId,
-    stats: sync.stats,
-    bundleRef: sync.bundleRef,
-    bundleSizeBytes: sync.bundleSizeBytes,
-    localCommitHash: headCommitHash,
-    applied: false,
-    dryRun: params.dryRun
-  };
-  if (params.dryRun) {
-    return previewResult;
-  }
-  if (!sync.bundleBase64 || !sync.bundleRef) {
-    throw new RemixError("Sync bundle payload is missing.", { exitCode: 1 });
-  }
-  const bundleBase64 = sync.bundleBase64;
-  const bundleRef = sync.bundleRef;
-  return withRepoMutationLock(
-    {
-      cwd: repoRoot,
-      operation: "collabSync"
-    },
-    async ({ repoRoot: lockedRepoRoot, warnings }) => {
-      await assertRepoSnapshotUnchanged(lockedRepoRoot, repoSnapshot, {
-        operation: "`remix collab sync`",
-        recoveryHint: "The repository changed after sync was prepared. Review the local changes and rerun `remix collab sync`."
+}
+async function processPendingFinalizeJob(params) {
+  const claimed = await claimPendingFinalizeJob(params.jobId);
+  if (!claimed) {
+    const job = await readPendingFinalizeJob(params.jobId);
+    if (job?.status === "processing") {
+      throw new RemixError("Finalize job is already being processed.", { exitCode: 1 });
+    }
+    if (job?.status === "failed") {
+      throw new RemixError("Finalize job failed permanently and will not retry automatically.", {
+        exitCode: 1,
+        hint: job.error ?? "Review the local finalize queue and record a fresh Remix turn if needed."
       });
-      await ensureCleanWorktree(lockedRepoRoot);
-      const lockedBranch = await requireCurrentBranch(lockedRepoRoot);
-      assertBoundBranchMatch({
-        currentBranch: lockedBranch,
-        branchName: binding.branchName,
-        allowBranchMismatch: params.allowBranchMismatch,
-        operation: "`remix collab sync`"
+    }
+    throw new RemixError("Finalize job was not found.", { exitCode: 1 });
+  }
+  return processClaimedPendingFinalizeJob({ api: params.api, job: claimed.job, release: claimed.release });
+}
+async function enqueueCapturedFinalizeTurn(params) {
+  return enqueuePendingFinalizeJob({
+    status: "queued",
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.repoFingerprint,
+    currentAppId: params.currentAppId,
+    laneId: params.laneId,
+    threadId: params.threadId,
+    branchName: params.branchName,
+    prompt: params.prompt,
+    assistantResponse: params.assistantResponse,
+    baselineSnapshotId: params.baselineSnapshotId,
+    baselineServerHeadHash: params.baselineServerHeadHash,
+    currentSnapshotId: params.currentSnapshotId,
+    idempotencyKey: params.idempotencyKey,
+    error: null,
+    retryCount: 0,
+    lastAttemptAt: null,
+    nextRetryAt: null,
+    metadata: params.metadata ?? {}
+  });
+}
+async function drainPendingFinalizeQueue(params) {
+  await prunePendingFinalizeJobs();
+  const jobs = await listPendingFinalizeJobs();
+  const results = [];
+  for (const job of jobs) {
+    const claimed = await claimPendingFinalizeJob(job.id);
+    if (!claimed) continue;
+    try {
+      const result = await processClaimedPendingFinalizeJob({
+        api: params.api,
+        job: claimed.job,
+        release: claimed.release
       });
-      const tempDir = await fs2.mkdtemp(path2.join(os2.tmpdir(), "remix-sync-"));
-      const bundlePath = path2.join(tempDir, "sync-local.bundle");
-      try {
-        await fs2.writeFile(bundlePath, Buffer.from(bundleBase64, "base64"));
-        await importGitBundle(lockedRepoRoot, bundlePath, bundleRef);
-        await ensureCommitExists(lockedRepoRoot, sync.targetCommitHash);
-        const localCommitHash = await fastForwardToCommit(lockedRepoRoot, sync.targetCommitHash);
-        return {
-          ...previewResult,
-          localCommitHash,
-          applied: true,
-          dryRun: false,
-          ...warnings.length > 0 ? { warnings } : {}
-        };
-      } finally {
-        await fs2.rm(tempDir, { recursive: true, force: true });
-      }
+      results.push(result);
+      await removePendingFinalizeJob(job.id);
+    } catch {
     }
-  );
+  }
+  return results;
 }
 
-// src/application/collab/collabAdd.ts
-function assertSupportedRecordingPreflight(preflight) {
-  if (preflight.status === "not_bound") {
+// src/application/collab/collabFinalizeTurn.ts
+function collectWarnings(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+}
+var FINALIZE_QUEUED_WARNING = "Queued only: the local Remix turn was captured, but no remote change step or collab turn exists yet. Drain or await finalize before merge-related flows.";
+async function collabFinalizeTurn(params) {
+  const repoRoot = await findGitRoot(params.cwd);
+  const binding = await ensureActiveLaneBinding({
+    repoRoot,
+    api: params.api,
+    operation: "`remix collab finalize-turn`"
+  });
+  if (!binding) {
     throw new RemixError("Repository is not bound to Remix.", {
       exitCode: 2,
-      hint: preflight.hint
+      hint: "Run `remix collab init` first."
     });
   }
-  if (preflight.status === "branch_binding_missing") {
-    throw new RemixError("Current branch is not yet bound to a Remix lane.", {
+  const prompt = params.prompt.trim();
+  const assistantResponse = params.assistantResponse.trim();
+  if (!prompt) throw new RemixError("Prompt is required.", { exitCode: 2 });
+  if (!assistantResponse) throw new RemixError("Assistant response is required.", { exitCode: 2 });
+  if (params.diff?.trim()) {
+    throw new RemixError("External diff submission is no longer supported for `finalize_turn`.", {
       exitCode: 2,
-      hint: preflight.hint
+      hint: "Finalize turns now capture the real workspace boundary from the local snapshot store."
     });
   }
-  if (preflight.status === "family_ambiguous") {
-    throw new RemixError("Multiple canonical Remix families match this repository.", {
-      exitCode: 2,
-      hint: preflight.hint
-    });
+  const detected = await collabDetectRepoState({
+    api: params.api,
+    cwd: repoRoot,
+    allowBranchMismatch: params.allowBranchMismatch
+  });
+  if (detected.status === "not_bound") {
+    throw new RemixError("Repository is not bound to Remix.", { exitCode: 2, hint: detected.hint });
+  }
+  if (detected.status === "branch_binding_missing" || detected.status === "family_ambiguous") {
+    throw new RemixError(detected.hint || "Current branch is not ready for Remix recording.", { exitCode: 2, hint: detected.hint });
   }
-  if (preflight.status === "not_git_repo") {
-    throw new RemixError(preflight.hint || "Not inside a git repository.", {
+  if (detected.status === "metadata_conflict" || detected.status === "branch_mismatch") {
+    throw new RemixError("Repository must be realigned before finalizing the turn.", {
       exitCode: 2,
-      hint: preflight.hint
+      hint: detected.hint
     });
   }
-  if (preflight.status === "missing_head") {
-    throw new RemixError("Failed to resolve local HEAD commit.", {
+  if (detected.status === "missing_head" || detected.status === "remote_error") {
+    throw new RemixError(detected.hint || "Failed to determine the current repo state.", {
       exitCode: 1,
-      hint: preflight.hint
+      hint: detected.hint
     });
   }
-  if (preflight.status === "branch_mismatch") {
-    assertBoundBranchMatch({
-      currentBranch: preflight.currentBranch,
-      branchName: preflight.branchName,
-      allowBranchMismatch: false,
-      operation: "`remix collab add`"
+  if (detected.repoState === "server_only_changed") {
+    throw new RemixError("Server changes must be pulled locally before finalizing this turn.", {
+      exitCode: 2,
+      hint: detected.hint
     });
   }
-  if (preflight.status === "metadata_conflict") {
-    throw new RemixError("Local repository metadata conflicts with the bound Remix app.", {
+  if (detected.repoState === "external_local_base_changed") {
+    throw new RemixError("The local checkout must be re-anchored before finalizing this turn.", {
       exitCode: 2,
-      hint: preflight.hint
+      hint: detected.hint
     });
   }
-  if (preflight.status === "reconcile_required") {
-    throw new RemixError("Local repository cannot be fast-forward synced.", {
+  const baseline = await readLocalBaseline({
+    repoFingerprint: binding.repoFingerprint,
+    laneId: binding.laneId,
+    repoRoot
+  });
+  if (!baseline) {
+    throw new RemixError("Local Remix baseline is missing for this lane.", {
       exitCode: 2,
-      hint: preflight.hint
+      hint: "Run `remix collab re-anchor` to create a fresh baseline."
     });
   }
-}
-async function collabAdd(params) {
-  const repoRoot = await findGitRoot(params.cwd);
-  const binding = await ensureActiveLaneBinding({
+  const snapshot = await captureLocalSnapshot({
+    repoRoot,
+    repoFingerprint: binding.repoFingerprint,
+    laneId: binding.laneId,
+    branchName: binding.branchName
+  });
+  const mode = snapshot.snapshotHash === baseline.lastSnapshotHash ? "no_diff_turn" : "changed_turn";
+  const idempotencyKey = params.idempotencyKey?.trim() || buildDeterministicIdempotencyKey({
+    kind: "collab_finalize_turn_boundary_v1",
+    appId: binding.currentAppId,
+    laneId: binding.laneId,
+    baselineSnapshotId: baseline.lastSnapshotId,
+    baselineServerHeadHash: baseline.lastServerHeadHash,
+    currentSnapshotId: snapshot.id,
+    currentSnapshotHash: snapshot.snapshotHash,
+    repoState: detected.repoState,
+    prompt,
+    assistantResponse
+  });
+  const job = await enqueueCapturedFinalizeTurn({
     repoRoot,
+    repoFingerprint: binding.repoFingerprint,
+    currentAppId: binding.currentAppId,
+    laneId: binding.laneId,
+    threadId: binding.threadId,
+    branchName: binding.branchName,
+    prompt,
+    assistantResponse,
+    baselineSnapshotId: baseline.lastSnapshotId,
+    baselineServerHeadHash: baseline.lastServerHeadHash,
+    currentSnapshotId: snapshot.id,
+    idempotencyKey,
+    metadata: {
+      remoteUrl: binding.remoteUrl,
+      defaultBranch: binding.defaultBranch,
+      actor: params.actor ?? null,
+      repoState: detected.repoState
+    }
+  });
+  return {
+    mode,
+    idempotencyKey,
+    queued: true,
+    jobId: job.id,
+    repoState: detected.repoState,
+    changeStep: null,
+    collabTurn: null,
+    autoSync: null,
+    warnings: [FINALIZE_QUEUED_WARNING, ...collectWarnings(detected.warnings)]
+  };
+}
+
+// src/application/collab/recordingPreflight.ts
+async function collabRecordingPreflight(params) {
+  const detected = await collabDetectRepoState({
     api: params.api,
-    operation: "`remix collab add`"
+    cwd: params.cwd,
+    allowBranchMismatch: params.allowBranchMismatch
   });
-  if (!binding) {
-    throw new RemixError("Repository is not bound to Remix.", {
-      exitCode: 2,
-      hint: "Run `remix collab init` first."
-    });
+  if (detected.status === "not_git_repo") {
+    return {
+      status: "not_git_repo",
+      repoState: detected.repoState,
+      repoRoot: null,
+      appId: null,
+      currentBranch: null,
+      branchName: null,
+      headCommitHash: null,
+      worktreeClean: false,
+      syncStatus: null,
+      syncTargetCommitHash: null,
+      syncTargetCommitId: null,
+      reconcileTargetHeadCommitHash: null,
+      reconcileTargetHeadCommitId: null,
+      warnings: detected.warnings,
+      hint: detected.hint
+    };
   }
-  const prompt = params.prompt.trim();
-  if (!prompt) throw new RemixError("Prompt is required.", { exitCode: 2 });
-  const assistantResponse = params.assistantResponse?.trim() || null;
-  const attachWarnings = (value, warnings) => warnings.length > 0 ? { ...value, warnings } : value;
-  const diffSource = params.diffSource ?? (params.diff ? "external" : "worktree");
-  const autoSyncEnabled = params.sync !== false;
-  const run = async (lockWarnings = []) => {
-    const preflight = await collabRecordingPreflight({
-      api: params.api,
-      cwd: repoRoot,
-      allowBranchMismatch: params.allowBranchMismatch
-    });
-    assertSupportedRecordingPreflight(preflight);
-    const branch = preflight.currentBranch;
-    assertBoundBranchMatch({
-      currentBranch: branch,
-      branchName: binding.branchName,
-      allowBranchMismatch: params.allowBranchMismatch,
-      operation: "`remix collab add`"
-    });
-    let headCommitHash = preflight.headCommitHash;
-    if (!headCommitHash) {
-      throw new RemixError("Failed to resolve local HEAD commit.", { exitCode: 1 });
-    }
-    const worktreeStatus = await getWorktreeStatus(repoRoot);
-    if (preflight.status === "ready_to_fast_forward") {
-      if (!autoSyncEnabled) {
-        throw new RemixError("Local repository is stale and `collab add` sync automation is disabled.", {
-          exitCode: 2,
-          hint: "Run `remix collab sync` first, or rerun without disabling sync automation."
-        });
-      }
-      if (!worktreeStatus.isClean && diffSource !== "worktree") {
-        throw new RemixError("Automatic stale-work replay requires the current worktree diff.", {
-          exitCode: 2,
-          hint: "Use `remix collab add` without an external diff while the local repo is dirty, or clean the repo before submitting an external diff."
-        });
-      }
-      if (worktreeStatus.isClean) {
-        await collabSync({
-          api: params.api,
-          cwd: repoRoot,
-          dryRun: false,
-          allowBranchMismatch: params.allowBranchMismatch
-        });
-        headCommitHash = await getHeadCommitHash(repoRoot);
-        if (!headCommitHash) {
-          throw new RemixError("Failed to resolve local HEAD after syncing.", { exitCode: 1 });
-        }
-      } else {
-        const staleWorkSnapshot = await captureRepoSnapshot(repoRoot, { includeWorkspaceDiffHash: true });
-        const preserved = await preserveWorkspaceChanges(repoRoot, "remix-add-preserve");
-        try {
-          await assertRepoSnapshotUnchanged(repoRoot, staleWorkSnapshot, {
-            operation: "`remix collab add` stale-work pre-sync",
-            recoveryHint: "The worktree changed while local changes were being preserved. Review the local changes and rerun `remix collab add`."
-          });
-          await discardTrackedChanges(repoRoot, "`remix collab add`");
-          await discardCapturedUntrackedChanges(repoRoot, preserved.includedUntrackedPaths);
-          await collabSync({
-            api: params.api,
-            cwd: repoRoot,
-            dryRun: false,
-            allowBranchMismatch: params.allowBranchMismatch
-          });
-        } catch (err) {
-          const detail = formatCliErrorDetail(err);
-          const hint = [
-            detail,
-            `The preserved local diff is available at: ${preserved.preservedDiffPath}`
-          ].filter(Boolean).join("\n\n");
-          throw new RemixError("Failed to sync the stale repository before submitting the change step.", {
-            exitCode: err instanceof RemixError ? err.exitCode : 1,
-            hint
-          });
-        }
-        headCommitHash = await getHeadCommitHash(repoRoot);
-        if (!headCommitHash) {
-          throw new RemixError("Failed to resolve local HEAD after syncing.", { exitCode: 1 });
-        }
-        const deterministicReapply = await reapplyPreservedWorkspaceChanges(repoRoot, preserved);
-        if (deterministicReapply.status === "failed") {
-          const hint = [
-            deterministicReapply.detail,
-            `The preserved local diff is available at: ${preserved.preservedDiffPath}`
-          ].filter(Boolean).join("\n\n");
-          throw new RemixError("Failed to restore preserved local changes after syncing.", {
-            exitCode: 1,
-            hint
-          });
-        }
-        if (deterministicReapply.status === "conflict") {
-          try {
-            const replayResp = await params.api.startChangeStepReplay(binding.currentAppId, {
-              prompt,
-              assistantResponse: assistantResponse ?? void 0,
-              diff: await fs3.readFile(preserved.preservedDiffPath, "utf8"),
-              baseCommitHash: preserved.baseHeadCommitHash,
-              targetHeadCommitHash: headCommitHash,
-              expectedPaths: preserved.stagePlan.expectedPaths,
-              actor: params.actor,
-              workspaceMetadata: {
-                branch,
-                repoRoot,
-                remoteUrl: binding.remoteUrl,
-                defaultBranch: binding.defaultBranch
-              },
-              idempotencyKey: buildDeterministicIdempotencyKey({
-                appId: binding.currentAppId,
-                baseCommitHash: preserved.baseHeadCommitHash,
-                targetHeadCommitHash: headCommitHash,
-                prompt,
-                assistantResponse,
-                preservedDiffSha256: preserved.preservedDiffSha256
-              })
-            });
-            const startedReplay = unwrapResponseObject(replayResp, "change step replay");
-            const replay = await pollChangeStepReplay(params.api, binding.currentAppId, String(startedReplay.id));
-            const replayDiffResp = await params.api.getChangeStepReplayDiff(binding.currentAppId, String(replay.id));
-            const replayDiff = unwrapResponseObject(replayDiffResp, "change step replay diff");
-            const { backupPath: backupPath2, diffSha256 } = await writeTempUnifiedDiffBackup(replayDiff.diff, "remix-add-ai-replay");
-            const replayApply = await reapplyPreservedWorkspaceChanges(repoRoot, {
-              baseHeadCommitHash: headCommitHash,
-              preservedDiffPath: backupPath2,
-              preservedDiffSha256: diffSha256,
-              includedUntrackedPaths: [],
-              stagePlan: preserved.stagePlan
-            });
-            if (replayApply.status !== "clean") {
-              const hint = [
-                replayApply.detail,
-                `The preserved local diff is available at: ${preserved.preservedDiffPath}`,
-                `The AI-replayed diff is available at: ${backupPath2}`
-              ].filter(Boolean).join("\n\n");
-              throw new RemixError("AI-assisted stale-work replay produced a diff that could not be applied locally.", {
-                exitCode: 1,
-                hint
-              });
-            }
-          } catch (err) {
-            const detail = formatCliErrorDetail(err);
-            const hint = [
-              detail,
-              `The preserved local diff is available at: ${preserved.preservedDiffPath}`,
-              "Resolve the local conflict manually if needed, then rerun `remix collab add`."
-            ].filter(Boolean).join("\n\n");
-            throw new RemixError("AI-assisted stale-work replay could not complete safely.", {
-              exitCode: err instanceof RemixError ? err.exitCode : 1,
-              hint
-            });
-          }
-        }
-      }
-    }
-    const workspaceSnapshot = diffSource === "external" ? null : await getWorkspaceSnapshot(repoRoot);
-    const submissionSnapshot = diffSource === "worktree" ? await captureRepoSnapshot(repoRoot, { includeWorkspaceDiffHash: true }) : null;
-    const diff = params.diff ?? workspaceSnapshot?.diff ?? "";
-    if (!diff.trim()) {
-      throw new RemixError("Diff is empty.", {
-        exitCode: 2,
-        hint: "Make changes first, or pass `--diff-file`/`--diff-stdin`."
-      });
-    }
-    if (diffSource === "external") {
-      const validation = await validateUnifiedDiff(repoRoot, diff);
-      if (!validation.ok) {
-        const actionHint = validation.kind === "malformed_patch" ? "The provided external diff is malformed. Recreate it with `git diff --binary --no-ext-diff`, avoid hand-editing patch hunks, and ensure the patch ends with a trailing newline." : validation.kind === "apply_conflict" ? "The external diff is valid patch syntax, but it does not apply cleanly to the current local HEAD. Sync or update the repo and regenerate the diff against the latest base." : "Git could not validate the provided external diff against the current repository state.";
-        const hint = [validation.detail, actionHint].filter(Boolean).join("\n\n");
-        throw new RemixError("External diff validation failed.", {
-          exitCode: validation.kind === "malformed_patch" ? 2 : 1,
-          hint
-        });
-      }
-    }
-    headCommitHash = await getHeadCommitHash(repoRoot);
-    if (!headCommitHash) {
-      throw new RemixError("Failed to resolve local HEAD before creating the change step.", { exitCode: 1 });
-    }
-    const stats = summarizeUnifiedDiff(diff);
-    const idempotencyKey = params.idempotencyKey?.trim() || buildDeterministicIdempotencyKey({
-      appId: binding.currentAppId,
-      upstreamAppId: binding.upstreamAppId,
-      headCommitHash,
-      prompt,
-      assistantResponse,
-      diff
-    });
-    const resp = await params.api.createChangeStep(binding.currentAppId, {
-      threadId: binding.threadId ?? void 0,
-      collabLaneId: binding.laneId ?? void 0,
-      prompt,
-      assistantResponse: assistantResponse ?? void 0,
-      diff,
-      baseCommitHash: headCommitHash,
-      headCommitHash,
-      changedFilesCount: stats.changedFilesCount,
-      insertions: stats.insertions,
-      deletions: stats.deletions,
-      actor: params.actor,
-      workspaceMetadata: {
-        branch,
-        repoRoot,
-        remoteUrl: binding.remoteUrl,
-        defaultBranch: binding.defaultBranch
-      },
-      idempotencyKey
-    });
-    const created = unwrapResponseObject(resp, "change step");
-    const step = await pollChangeStep(params.api, binding.currentAppId, String(created.id));
-    const canAutoSyncLocally = autoSyncEnabled && diffSource === "worktree";
-    if (!autoSyncEnabled || !canAutoSyncLocally) {
-      return attachWarnings(step, lockWarnings);
+  const syncTargetCommitHash = detected.currentServerHeadHash;
+  const syncTargetCommitId = detected.currentServerHeadCommitId;
+  const base = {
+    repoState: detected.repoState,
+    repoRoot: detected.repoRoot,
+    appId: detected.binding?.currentAppId ?? null,
+    currentBranch: detected.currentBranch,
+    branchName: detected.branchName,
+    headCommitHash: detected.localCommitHash,
+    worktreeClean: detected.worktreeClean,
+    syncStatus: detected.repoState === "server_only_changed" ? "delta_ready" : detected.status === "metadata_conflict" ? "conflict_risk" : null,
+    syncTargetCommitHash,
+    syncTargetCommitId,
+    reconcileTargetHeadCommitHash: detected.currentServerHeadHash,
+    reconcileTargetHeadCommitId: detected.currentServerHeadCommitId,
+    warnings: detected.warnings,
+    hint: detected.hint
+  };
+  if (detected.status === "not_bound") return { status: "not_bound", ...base };
+  if (detected.status === "branch_binding_missing") return { status: "branch_binding_missing", ...base };
+  if (detected.status === "family_ambiguous") return { status: "family_ambiguous", ...base };
+  if (detected.status === "metadata_conflict") return { status: "metadata_conflict", ...base };
+  if (detected.status === "missing_head") return { status: "missing_head", ...base };
+  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 };
+  return { status: "ready", ...base };
+}
+
+// src/infrastructure/locking/repoMutationLock.ts
+import fs4 from "fs/promises";
+import os3 from "os";
+import path5 from "path";
+var DEFAULT_ACQUIRE_TIMEOUT_MS = 15e3;
+var DEFAULT_STALE_MS = 45e3;
+var DEFAULT_HEARTBEAT_MS = 5e3;
+var RETRY_DELAY_MS = 250;
+var heldLocks = /* @__PURE__ */ new Map();
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createOwner(params) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    operation: params.operation,
+    repoRoot: params.repoRoot,
+    pid: process.pid,
+    hostname: os3.hostname(),
+    startedAt: now,
+    heartbeatAt: now,
+    version: process.version,
+    requestId: params.requestId?.trim() || null
+  };
+}
+async function writeOwnerMetadata(ownerPath, owner) {
+  await fs4.writeFile(ownerPath, `${JSON.stringify(owner, null, 2)}
+`, "utf8");
+}
+async function readOwnerMetadata(ownerPath) {
+  try {
+    const raw = await fs4.readFile(ownerPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    if (!parsed.operation || !parsed.repoRoot || typeof parsed.pid !== "number" || !parsed.startedAt || !parsed.heartbeatAt) {
+      return null;
     }
-    const { backupPath } = await writeTempUnifiedDiffBackup(diff, "remix-add");
+    return {
+      operation: parsed.operation,
+      repoRoot: parsed.repoRoot,
+      pid: parsed.pid,
+      hostname: typeof parsed.hostname === "string" ? parsed.hostname : "unknown",
+      startedAt: parsed.startedAt,
+      heartbeatAt: parsed.heartbeatAt,
+      version: typeof parsed.version === "string" ? parsed.version : "unknown",
+      requestId: typeof parsed.requestId === "string" ? parsed.requestId : null
+    };
+  } catch {
+    return null;
+  }
+}
+async function isProcessAlive(owner) {
+  if (!owner) return null;
+  if (owner.hostname !== os3.hostname()) return null;
+  try {
+    process.kill(owner.pid, 0);
+    return true;
+  } catch (error) {
+    if (error?.code === "EPERM") return true;
+    if (error?.code === "ESRCH") return false;
+    return null;
+  }
+}
+async function getLastKnownUpdateMs(lockDir, ownerPath, owner) {
+  const heartbeatMs = owner ? Date.parse(owner.heartbeatAt) : Number.NaN;
+  if (Number.isFinite(heartbeatMs)) return heartbeatMs;
+  const startedMs = owner ? Date.parse(owner.startedAt) : Number.NaN;
+  if (Number.isFinite(startedMs)) return startedMs;
+  const stat = await fs4.stat(ownerPath).catch(() => null);
+  if (stat) return stat.mtimeMs;
+  const dirStat = await fs4.stat(lockDir).catch(() => null);
+  if (dirStat) return dirStat.mtimeMs;
+  return 0;
+}
+async function ensureLockDir(lockDir) {
+  await fs4.mkdir(path5.dirname(lockDir), { recursive: true });
+}
+async function tryAcquireLock(lockDir, ownerPath, owner) {
+  try {
+    await ensureLockDir(lockDir);
+    await fs4.mkdir(lockDir);
     try {
-      await pollAppReady(params.api, binding.currentAppId);
-      if (submissionSnapshot) {
-        await assertRepoSnapshotUnchanged(repoRoot, submissionSnapshot, {
-          operation: "`remix collab add` auto-sync",
-          recoveryHint: "The repository changed after the change step was submitted. Review the local changes, inspect the preserved diff if needed, and rerun `remix collab sync` manually."
-        });
-      }
-      await discardTrackedChanges(repoRoot, "`remix collab add`");
-      await discardCapturedUntrackedChanges(repoRoot, workspaceSnapshot?.includedUntrackedPaths ?? []);
-      await collabSync({
-        api: params.api,
-        cwd: repoRoot,
-        dryRun: false,
-        allowBranchMismatch: params.allowBranchMismatch
-      });
-      await fs3.rm(path3.dirname(backupPath), { recursive: true, force: true }).catch(() => void 0);
-    } catch (err) {
-      const detail = formatCliErrorDetail(err);
-      const hint = [
-        detail,
-        `The submitted diff backup was preserved at: ${backupPath}`,
-        "The change step already succeeded remotely. Inspect or reapply that diff manually if needed, then run `remix collab sync`."
-      ].filter(Boolean).join("\n\n");
-      throw new RemixError("Change step succeeded remotely, but automatic local sync failed.", {
-        exitCode: err instanceof RemixError ? err.exitCode : 1,
-        hint
-      });
+      await writeOwnerMetadata(ownerPath, owner);
+    } catch (error) {
+      await fs4.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+      throw error;
     }
-    return attachWarnings(step, lockWarnings);
-  };
-  if (diffSource === "worktree") {
-    return withRepoMutationLock(
-      {
-        cwd: repoRoot,
-        operation: "collabAdd"
-      },
-      async ({ warnings }) => run(warnings)
-    );
+    return true;
+  } catch (error) {
+    if (error?.code === "EEXIST") return false;
+    throw error;
   }
-  return run();
 }
-
-// src/application/collab/collabRecordTurn.ts
-function assertSupportedRecordingPreflight2(preflight) {
-  if (preflight.status === "not_bound") {
-    throw new RemixError("Repository is not bound to Remix.", {
-      exitCode: 2,
-      hint: preflight.hint
-    });
-  }
-  if (preflight.status === "branch_binding_missing") {
-    throw new RemixError("Current branch is not yet bound to a Remix lane.", {
-      exitCode: 2,
-      hint: preflight.hint
-    });
+function formatLockHint(params) {
+  const lines = [
+    params.observedHeldLock ? `Observed lock state: ${REMIX_ERROR_CODES.REPO_LOCK_HELD}.` : null,
+    params.owner ? `Active operation: ${params.owner.operation}` : "Active operation: unknown",
+    params.owner ? `Repo root: ${params.owner.repoRoot}` : null,
+    params.owner ? `Owner: pid=${params.owner.pid} host=${params.owner.hostname}` : null,
+    params.owner ? `Started at: ${params.owner.startedAt}` : null,
+    params.owner ? `Heartbeat at: ${params.owner.heartbeatAt}` : null,
+    `Waited ${params.waitedMs}ms for the repo mutation lock.`,
+    `Stale lock threshold: ${params.staleMs}ms.`,
+    "Retry after the active operation finishes. If the process crashed, wait for stale lock recovery or remove the stale lock manually if necessary."
+  ];
+  return lines.filter(Boolean).join("\n");
+}
+function formatOwnerSummary(owner) {
+  if (!owner) {
+    return "unknown owner";
   }
-  if (preflight.status === "family_ambiguous") {
-    throw new RemixError("Multiple canonical Remix families match this repository.", {
-      exitCode: 2,
-      hint: preflight.hint
-    });
+  return `operation=${owner.operation} pid=${owner.pid} host=${owner.hostname} startedAt=${owner.startedAt} heartbeatAt=${owner.heartbeatAt}`;
+}
+function buildStaleRecoveryNotice(owner) {
+  return {
+    code: REMIX_ERROR_CODES.REPO_LOCK_STALE_RECOVERED,
+    owner,
+    message: `[${REMIX_ERROR_CODES.REPO_LOCK_STALE_RECOVERED}] Recovered a stale Remix repo mutation lock (${formatOwnerSummary(owner)}).`
+  };
+}
+async function acquirePhysicalLock(lockDir, ownerPath, owner, options) {
+  const startedAt = Date.now();
+  const notices = [];
+  let observedHeldLock = false;
+  while (Date.now() - startedAt < options.acquireTimeoutMs) {
+    if (await tryAcquireLock(lockDir, ownerPath, owner)) return notices;
+    const currentOwner2 = await readOwnerMetadata(ownerPath);
+    observedHeldLock = true;
+    const lastUpdateMs = await getLastKnownUpdateMs(lockDir, ownerPath, currentOwner2);
+    const ageMs = Math.max(0, Date.now() - lastUpdateMs);
+    const alive = await isProcessAlive(currentOwner2);
+    if (ageMs >= options.staleMs && alive !== true) {
+      notices.push(buildStaleRecoveryNotice(currentOwner2));
+      await fs4.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+      continue;
+    }
+    await sleep2(RETRY_DELAY_MS);
   }
-  if (preflight.status === "not_git_repo") {
-    throw new RemixError(preflight.hint || "Not inside a git repository.", {
-      exitCode: 2,
-      hint: preflight.hint
+  const currentOwner = await readOwnerMetadata(ownerPath);
+  throw new RemixError("Repository is busy with another Remix mutation.", {
+    code: REMIX_ERROR_CODES.REPO_LOCK_TIMEOUT,
+    exitCode: 2,
+    hint: formatLockHint({
+      owner: currentOwner,
+      waitedMs: Date.now() - startedAt,
+      staleMs: options.staleMs,
+      observedHeldLock
+    })
+  });
+}
+function startHeartbeat(lockDir, ownerPath, owner, heartbeatMs) {
+  return setInterval(() => {
+    const nextOwner = {
+      ...owner,
+      heartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    owner.heartbeatAt = nextOwner.heartbeatAt;
+    void writeOwnerMetadata(ownerPath, nextOwner).catch(() => void 0);
+    void fs4.utimes(lockDir, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date()).catch(() => void 0);
+  }, heartbeatMs);
+}
+async function releaseReentrantLock(lockDir) {
+  const held = heldLocks.get(lockDir);
+  if (!held) return;
+  held.count -= 1;
+  if (held.count > 0) return;
+  clearInterval(held.heartbeatTimer);
+  heldLocks.delete(lockDir);
+  await fs4.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+}
+async function withRepoMutationLock(options, fn) {
+  const repoRoot = await findGitRoot(options.cwd);
+  const gitCommonDir = await getGitCommonDir(repoRoot);
+  const lockDir = path5.join(gitCommonDir, "remix", "locks", "repo-mutation.lock");
+  const owner = createOwner({
+    operation: options.operation,
+    repoRoot,
+    requestId: options.requestId
+  });
+  const heartbeatMs = options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
+  const acquireTimeoutMs = options.acquireTimeoutMs ?? DEFAULT_ACQUIRE_TIMEOUT_MS;
+  const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
+  const existing = heldLocks.get(lockDir);
+  let notices = [];
+  if (!existing) {
+    notices = await acquirePhysicalLock(lockDir, path5.join(lockDir, "owner.json"), owner, {
+      acquireTimeoutMs,
+      staleMs
     });
-  }
-  if (preflight.status === "missing_head") {
-    throw new RemixError("Failed to resolve local HEAD commit.", {
-      exitCode: 1,
-      hint: preflight.hint
+    const ownerPath = path5.join(lockDir, "owner.json");
+    heldLocks.set(lockDir, {
+      count: 1,
+      lockDir,
+      ownerPath,
+      owner,
+      heartbeatTimer: startHeartbeat(lockDir, ownerPath, owner, heartbeatMs)
     });
+  } else {
+    existing.count += 1;
   }
-  if (preflight.status === "branch_mismatch") {
-    assertBoundBranchMatch({
-      currentBranch: preflight.currentBranch,
-      branchName: preflight.branchName,
-      allowBranchMismatch: false,
-      operation: "`remix collab record-turn`"
+  try {
+    return await fn({
+      repoRoot,
+      gitCommonDir,
+      lockDir,
+      notices,
+      warnings: notices.map((notice) => notice.message)
     });
+  } finally {
+    await releaseReentrantLock(lockDir);
   }
-  if (preflight.status === "metadata_conflict") {
-    throw new RemixError("Local repository metadata conflicts with the bound Remix app.", {
+}
+
+// src/application/collab/workspaceBaseline.ts
+async function ensureWorkspaceMatchesBaseline(params) {
+  const baseline = await readLocalBaseline({
+    repoFingerprint: params.repoFingerprint,
+    laneId: params.laneId,
+    repoRoot: params.repoRoot
+  });
+  if (!baseline?.lastSnapshotHash || !baseline.lastServerHeadHash) {
+    throw new RemixError("Local Remix baseline is missing for this lane.", {
       exitCode: 2,
-      hint: preflight.hint
+      hint: "Run `remix collab re-anchor` to create a fresh baseline before applying server changes."
     });
   }
-  if (preflight.status === "reconcile_required") {
-    throw new RemixError("Local repository cannot be fast-forward synced.", {
+  const inspection = await inspectLocalSnapshot({
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.repoFingerprint,
+    laneId: params.laneId,
+    branchName: params.branchName,
+    persistBlobs: false
+  });
+  if (inspection.snapshotHash !== baseline.lastSnapshotHash) {
+    throw new RemixError(`Local boundary changes must be recorded or discarded before running ${params.operation}.`, {
       exitCode: 2,
-      hint: preflight.hint
+      hint: "This checkout contains workspace changes that are not part of the current Remix baseline. Record them first, or restore the workspace back to the last agreed baseline before retrying."
     });
   }
+  return { baseline, inspection };
 }
-async function collabRecordTurn(params) {
+
+// src/application/collab/collabSync.ts
+async function collabSync(params) {
   const repoRoot = await findGitRoot(params.cwd);
   const binding = await ensureActiveLaneBinding({
     repoRoot,
     api: params.api,
-    operation: "`remix collab record-turn`"
+    operation: "`remix collab sync`"
   });
   if (!binding) {
     throw new RemixError("Repository is not bound to Remix.", {
@@ -1542,167 +2179,159 @@ async function collabRecordTurn(params) {
       hint: "Run `remix collab init` first."
     });
   }
-  const prompt = params.prompt.trim();
-  const assistantResponse = params.assistantResponse.trim();
-  if (!prompt) throw new RemixError("Prompt is required.", { exitCode: 2 });
-  if (!assistantResponse) throw new RemixError("Assistant response is required.", { exitCode: 2 });
-  const preflight = await collabRecordingPreflight({
+  const detected = await collabDetectRepoState({
     api: params.api,
     cwd: repoRoot,
     allowBranchMismatch: params.allowBranchMismatch
   });
-  assertSupportedRecordingPreflight2(preflight);
-  if (!preflight.worktreeClean) {
-    throw new RemixError("Cannot record a no-diff turn while the worktree has local changes.", {
-      exitCode: 2,
-      hint: "Record the pending code changes as a Remix change step with `remix collab add`, or clean the worktree before retrying `remix collab record-turn`."
-    });
+  if (!detected.binding) {
+    throw new RemixError("Repository is not bound to Remix.", { exitCode: 2, hint: detected.hint });
   }
-  if (preflight.status === "ready_to_fast_forward") {
-    await collabSync({
-      api: params.api,
-      cwd: repoRoot,
-      dryRun: false,
-      allowBranchMismatch: params.allowBranchMismatch
+  if (detected.repoState === "idle") {
+    const headCommitHash2 = await getHeadCommitHash(repoRoot);
+    const branch2 = await requireCurrentBranch(repoRoot);
+    if (!detected.currentServerHeadHash || !detected.currentServerHeadCommitId) {
+      throw new RemixError("Failed to resolve the current Remix server head for this lane.", {
+        exitCode: 1,
+        hint: "Run `remix collab status` and retry after the repository is fully connected to Remix."
+      });
+    }
+    return {
+      status: "up_to_date",
+      branch: branch2,
+      repoRoot,
+      baseCommitHash: detected.currentServerHeadHash,
+      targetCommitHash: detected.currentServerHeadHash,
+      targetCommitId: detected.currentServerHeadCommitId,
+      stats: { changedFilesCount: 0, insertions: 0, deletions: 0 },
+      localCommitHash: headCommitHash2,
+      applied: false,
+      dryRun: params.dryRun
+    };
+  }
+  if (detected.repoState !== "server_only_changed") {
+    throw new RemixError("A direct pull is only available when the server changed and the local workspace did not.", {
+      exitCode: 2,
+      hint: detected.hint
     });
   }
-  const branch = await getCurrentBranch(repoRoot);
-  assertBoundBranchMatch({
-    currentBranch: branch,
-    branchName: binding.branchName,
-    allowBranchMismatch: params.allowBranchMismatch,
-    operation: "`remix collab record-turn`"
-  });
+  const branch = await requireCurrentBranch(repoRoot);
   const headCommitHash = await getHeadCommitHash(repoRoot);
-  const idempotencyKey = params.idempotencyKey?.trim() || buildDeterministicIdempotencyKey({
-    appId: binding.currentAppId,
-    upstreamAppId: binding.upstreamAppId,
-    headCommitHash,
-    prompt,
-    assistantResponse
-  });
-  const resp = await params.api.createCollabTurn(binding.currentAppId, {
-    threadId: binding.threadId ?? void 0,
-    collabLaneId: binding.laneId ?? void 0,
-    prompt,
-    assistantResponse,
-    actor: params.actor,
-    workspaceMetadata: {
-      branch,
+  const repoSnapshot = await captureRepoSnapshot(repoRoot, { includeWorkspaceDiffHash: true });
+  const bootstrapFromLocalHead = !detected.baseline.lastSnapshotHash || !detected.baseline.lastServerHeadHash;
+  let baselineServerHeadHash;
+  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 needs an explicit external-history re-anchor."
+      });
+    }
+    baselineServerHeadHash = headCommitHash;
+  } else {
+    const { baseline } = await ensureWorkspaceMatchesBaseline({
       repoRoot,
-      remoteUrl: binding.remoteUrl,
-      defaultBranch: binding.defaultBranch,
-      headCommitHash
-    },
-    idempotencyKey
+      repoFingerprint: binding.repoFingerprint,
+      laneId: binding.laneId,
+      branchName: binding.branchName,
+      operation: "`remix collab sync`"
+    });
+    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."
+      });
+    }
+    baselineServerHeadHash = baseline.lastServerHeadHash;
+  }
+  const deltaResp = await params.api.getAppDelta(binding.currentAppId, {
+    baseHeadHash: baselineServerHeadHash,
+    repoFingerprint: binding.repoFingerprint ?? void 0,
+    remoteUrl: binding.remoteUrl ?? void 0,
+    defaultBranch: binding.defaultBranch ?? void 0
   });
-  const turn = unwrapResponseObject(resp, "collab turn");
-  return turn;
-}
-
-// src/application/collab/collabFinalizeTurn.ts
-function collectWarnings(value) {
-  if (!Array.isArray(value)) return [];
-  return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
-}
-async function collabFinalizeTurn(params) {
-  const repoRoot = await findGitRoot(params.cwd);
-  const binding = await ensureActiveLaneBinding({
+  const delta = unwrapResponseObject(deltaResp, "app delta");
+  if (delta.status === "conflict_risk") {
+    throw new RemixError("Local repository metadata conflicts with the bound Remix app.", {
+      exitCode: 2,
+      hint: delta.warnings.join("\n") || "Run the command from the correct bound repository."
+    });
+  }
+  const previewResult = {
+    status: delta.status === "content_equivalent" ? "base_unknown" : delta.status,
+    branch,
     repoRoot,
-    api: params.api,
-    operation: "`remix collab finalize-turn`"
-  });
-  if (!binding) {
-    throw new RemixError("Repository is not bound to Remix.", {
+    baseCommitHash: baselineServerHeadHash,
+    targetCommitHash: delta.targetHeadHash,
+    targetCommitId: delta.targetHeadCommitId,
+    stats: delta.stats,
+    localCommitHash: headCommitHash,
+    applied: false,
+    dryRun: params.dryRun
+  };
+  if (params.dryRun || delta.status === "up_to_date") {
+    return previewResult;
+  }
+  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 init` first."
+      hint: "Run `remix collab reconcile --dry-run` to inspect recovery options before retrying. If this checkout moved independently outside Remix, `remix collab re-anchor` may be required."
     });
   }
-  const prompt = params.prompt.trim();
-  const assistantResponse = params.assistantResponse.trim();
-  if (!prompt) throw new RemixError("Prompt is required.", { exitCode: 2 });
-  if (!assistantResponse) throw new RemixError("Assistant response is required.", { exitCode: 2 });
-  const diffSource = params.diffSource ?? (params.diff ? "external" : "worktree");
-  const externalDiff = params.diff?.trim() ?? "";
-  const workspaceDiff = diffSource === "worktree" ? await getWorkspaceDiff(repoRoot) : null;
-  const hasChangedTurn = diffSource === "external" ? externalDiff.length > 0 : Boolean(workspaceDiff?.diff.trim());
-  const currentHeadCommitHash = await getHeadCommitHash(repoRoot);
-  const idempotencyKey = params.idempotencyKey?.trim() || buildDeterministicIdempotencyKey({
-    kind: "collab_finalize_turn_v1",
-    appId: binding.currentAppId,
-    upstreamAppId: binding.upstreamAppId,
-    headCommitHash: currentHeadCommitHash,
-    modeHint: hasChangedTurn ? "changed_turn" : "no_diff_turn",
-    prompt,
-    assistantResponse,
-    externalDiff: diffSource === "external" ? externalDiff : null
-  });
-  if (diffSource === "external" && !hasChangedTurn) {
-    throw new RemixError("External diff is empty.", {
+  if (delta.status !== "delta_ready") {
+    throw new RemixError("Direct pull is not available for the current repository state.", {
       exitCode: 2,
-      hint: "Pass a non-empty diff when using external diff submission, or omit the external diff so finalize-turn can inspect the live worktree."
+      hint: delta.warnings.join("\n") || "Run `remix collab status` to inspect the current alignment state."
     });
   }
-  if (hasChangedTurn) {
-    const localHeadBefore = currentHeadCommitHash;
-    const capturedUntrackedPathsCandidate = diffSource === "worktree" ? await listUntrackedFiles(repoRoot) : [];
-    const changeStep = await collabAdd({
-      api: params.api,
+  return withRepoMutationLock(
+    {
       cwd: repoRoot,
-      prompt,
-      assistantResponse,
-      diff: diffSource === "external" ? externalDiff : null,
-      diffSource,
-      sync: params.sync,
-      allowBranchMismatch: params.allowBranchMismatch,
-      idempotencyKey,
-      actor: params.actor
-    });
-    const localHeadAfter = await getHeadCommitHash(repoRoot);
-    const warnings = [
-      ...collectWarnings(changeStep.warnings),
-      ...diffSource === "external" && params.sync !== false ? [
-        "Automatic local discard+sync was skipped because the diff came from an external source and may not match the current worktree."
-      ] : []
-    ];
-    const autoSyncRequested = params.sync !== false;
-    const autoSyncEligible = diffSource === "worktree";
-    return {
-      mode: "changed_turn",
-      idempotencyKey,
-      changeStep,
-      collabTurn: null,
-      autoSync: {
-        requested: autoSyncRequested,
-        eligible: autoSyncEligible,
-        attempted: autoSyncRequested && autoSyncEligible,
-        applied: autoSyncRequested && autoSyncEligible,
-        trackedChangesDiscarded: autoSyncRequested && autoSyncEligible,
-        capturedUntrackedPathsCandidate,
-        localHeadBefore,
-        localHeadAfter,
-        localRepoMutated: autoSyncRequested && autoSyncEligible && localHeadBefore !== localHeadAfter
-      },
-      warnings
-    };
-  }
-  const collabTurn = await collabRecordTurn({
-    api: params.api,
-    cwd: repoRoot,
-    prompt,
-    assistantResponse,
-    allowBranchMismatch: params.allowBranchMismatch,
-    idempotencyKey,
-    actor: params.actor
-  });
-  return {
-    mode: "no_diff_turn",
-    idempotencyKey,
-    changeStep: null,
-    collabTurn,
-    autoSync: null,
-    warnings: []
-  };
+      operation: "collabSync"
+    },
+    async ({ repoRoot: lockedRepoRoot, warnings }) => {
+      if (bootstrapFromLocalHead) {
+        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`."
+        });
+      } else {
+        await ensureWorkspaceMatchesBaseline({
+          repoRoot: lockedRepoRoot,
+          repoFingerprint: binding.repoFingerprint,
+          laneId: binding.laneId,
+          branchName: binding.branchName,
+          operation: "`remix collab sync`"
+        });
+      }
+      await applyUnifiedDiffToWorktree(lockedRepoRoot, delta.diff, "`remix collab pull`");
+      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,
+        lastServerHeadHash: delta.targetHeadHash,
+        lastSeenLocalCommitHash: snapshot.localCommitHash
+      });
+      return {
+        ...previewResult,
+        status: "delta_ready",
+        localCommitHash: snapshot.localCommitHash,
+        applied: true,
+        dryRun: false,
+        ...warnings.length > 0 ? { warnings } : {}
+      };
+    }
+  );
 }
 
 // src/application/collab/collabApprove.ts
@@ -1788,39 +2417,39 @@ async function collabApprove(params) {
   };
 }
 
-// src/application/collab/checkoutWorkspace.ts
-import fs4 from "fs/promises";
-import os3 from "os";
-import path4 from "path";
+// src/application/collab/checkoutWorkspace.ts
+import fs5 from "fs/promises";
+import os4 from "os";
+import path6 from "path";
 async function pathExists(targetPath) {
   try {
-    await fs4.access(targetPath);
+    await fs5.access(targetPath);
     return true;
   } catch {
     return false;
   }
 }
 async function statIsDirectory(targetPath) {
-  const stats = await fs4.stat(targetPath).catch(() => null);
+  const stats = await fs5.stat(targetPath).catch(() => null);
   return Boolean(stats?.isDirectory());
 }
 async function findContainingGitRoot(startPath) {
-  let current = path4.resolve(startPath);
+  let current = path6.resolve(startPath);
   while (true) {
-    if (await pathExists(path4.join(current, ".git"))) return current;
-    const parent = path4.dirname(current);
+    if (await pathExists(path6.join(current, ".git"))) return current;
+    const parent = path6.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function isSubpath(parentPath, candidatePath) {
-  const relative = path4.relative(parentPath, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
+  const relative = path6.relative(parentPath, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path6.isAbsolute(relative);
 }
 async function resolveCheckoutDestination(params) {
   if (params.outputDir?.trim()) {
-    const preferredRepoRoot = path4.resolve(params.outputDir.trim());
-    const parentDir2 = path4.dirname(preferredRepoRoot);
+    const preferredRepoRoot = path6.resolve(params.outputDir.trim());
+    const parentDir2 = path6.dirname(preferredRepoRoot);
     if (!await statIsDirectory(parentDir2)) {
       throw new RemixError("Remix output parent directory does not exist.", {
         exitCode: 2,
@@ -1833,7 +2462,7 @@ async function resolveCheckoutDestination(params) {
       explicitOutputDir: true
     };
   }
-  const parentDir = path4.resolve(params.cwd);
+  const parentDir = path6.resolve(params.cwd);
   if (!await statIsDirectory(parentDir)) {
     throw new RemixError("Remix output parent directory does not exist.", {
       exitCode: 2,
@@ -1841,7 +2470,7 @@ async function resolveCheckoutDestination(params) {
     });
   }
   return {
-    preferredRepoRoot: path4.join(parentDir, params.defaultDirName),
+    preferredRepoRoot: path6.join(parentDir, params.defaultDirName),
     parentDir,
     explicitOutputDir: false
   };
@@ -1875,22 +2504,25 @@ async function materializeAppCheckout(params) {
     explicitOutputDir: destination.explicitOutputDir
   });
   const repoRoot = destination.explicitOutputDir ? await reserveDirectory(destination.preferredRepoRoot) : await reserveAvailableDirPath(destination.preferredRepoRoot);
-  const bundleTempDir = await fs4.mkdtemp(path4.join(os3.tmpdir(), "remix-checkout-"));
-  const bundlePath = path4.join(bundleTempDir, "repository.bundle");
+  const bundleTempDir = await fs5.mkdtemp(path6.join(os4.tmpdir(), "remix-checkout-"));
+  const bundlePath = path6.join(bundleTempDir, "repository.bundle");
   try {
     const bundle = await params.api.downloadAppBundle(params.appId);
-    await fs4.writeFile(bundlePath, bundle.data);
+    await fs5.writeFile(bundlePath, bundle.data);
     await cloneGitBundleToDirectory(bundlePath, repoRoot);
     if (params.expectedBranchName?.trim()) {
       await checkoutLocalBranch(repoRoot, params.expectedBranchName.trim());
     }
+    if (params.expectedRemoteUrl?.trim()) {
+      await setRemoteOriginUrl(repoRoot, params.expectedRemoteUrl);
+    }
     await ensureGitInfoExcludeEntries(repoRoot, [".remix/"]);
   } catch (err) {
-    await fs4.rm(repoRoot, { recursive: true, force: true }).catch(() => {
+    await fs5.rm(repoRoot, { recursive: true, force: true }).catch(() => {
     });
     throw err;
   } finally {
-    await fs4.rm(bundleTempDir, { recursive: true, force: true });
+    await fs5.rm(bundleTempDir, { recursive: true, force: true });
   }
   const branchName = await getCurrentBranch(repoRoot) ?? params.expectedBranchName?.trim() ?? null;
   const remoteUrl = normalizeGitRemote(params.expectedRemoteUrl ?? await getRemoteOriginUrl(repoRoot));
@@ -1959,9 +2591,34 @@ async function collabCheckout(params) {
     branchName: authoritativeLane?.branchName ?? branchName,
     bindingMode: "lane"
   });
+  const currentAppId = authoritativeLane?.currentAppId ?? String(app.id);
+  const repoFingerprintForBaseline = authoritativeLane?.repoFingerprint ?? repoFingerprint;
+  const laneIdForBaseline = authoritativeLane?.laneId ?? laneId;
+  const branchNameForBaseline = authoritativeLane?.branchName ?? branchName;
+  const appHead = unwrapResponseObject(
+    await params.api.getAppHead(currentAppId),
+    "app head"
+  );
+  const snapshot = await captureLocalSnapshot({
+    repoRoot: checkout.repoRoot,
+    repoFingerprint: repoFingerprintForBaseline,
+    laneId: laneIdForBaseline,
+    branchName: branchNameForBaseline
+  });
+  await writeLocalBaseline({
+    repoRoot: checkout.repoRoot,
+    repoFingerprint: repoFingerprintForBaseline,
+    laneId: laneIdForBaseline,
+    currentAppId,
+    branchName: branchNameForBaseline,
+    lastSnapshotId: snapshot.id,
+    lastSnapshotHash: snapshot.snapshotHash,
+    lastServerHeadHash: appHead.headCommitHash,
+    lastSeenLocalCommitHash: snapshot.localCommitHash
+  });
   return {
-    appId: authoritativeLane?.currentAppId ?? String(app.id),
-    dashboardUrl: buildDashboardAppUrl(authoritativeLane?.currentAppId ?? String(app.id)),
+    appId: currentAppId,
+    dashboardUrl: buildDashboardAppUrl(currentAppId),
     projectId: authoritativeLane?.projectId ?? String(app.projectId),
     upstreamAppId: authoritativeLane?.upstreamAppId ?? upstreamAppId,
     bindingPath,
@@ -2140,16 +2797,16 @@ async function collabUpdateMemberRole(params) {
 }
 
 // src/application/collab/collabInit.ts
-import fs7 from "fs/promises";
-import path5 from "path";
+import fs8 from "fs/promises";
+import path7 from "path";
 
 // src/shared/hash.ts
 import crypto from "crypto";
-import fs5 from "fs";
+import fs6 from "fs";
 async function sha256FileHex(filePath) {
   const hash = crypto.createHash("sha256");
   await new Promise((resolve, reject) => {
-    const stream = fs5.createReadStream(filePath);
+    const stream = fs6.createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
     stream.on("end", () => resolve());
@@ -2158,15 +2815,15 @@ async function sha256FileHex(filePath) {
 }
 
 // src/shared/upload.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import { PassThrough } from "stream";
 async function uploadPresigned(params) {
-  const stats = await fs6.promises.stat(params.filePath).catch(() => null);
+  const stats = await fs7.promises.stat(params.filePath).catch(() => null);
   if (!stats || !stats.isFile()) {
     throw new RemixError("Upload file not found.", { exitCode: 2 });
   }
   const totalBytes = stats.size;
-  const fileStream = fs6.createReadStream(params.filePath);
+  const fileStream = fs7.createReadStream(params.filePath);
   const pass = new PassThrough();
   let sentBytes = 0;
   fileStream.on("data", (chunk) => {
@@ -2251,7 +2908,8 @@ async function resolveOrEnsureLaneBinding(params) {
     lane = unwrapResponseObject(
       await params.api.ensureProjectLaneBinding({
         ...resolvePayload,
-        seedAppId: params.seedAppId ?? void 0
+        seedAppId: params.seedAppId ?? void 0,
+        seedHeadCommitHash: params.seedHeadCommitHash ?? void 0
       }),
       "project lane binding"
     );
@@ -2271,6 +2929,175 @@ function branchBindingFromLane(lane, mode, fallback) {
     bindingMode: mode
   };
 }
+function resolveStoredBindingAnchor(params) {
+  const currentBranchBinding = params.currentBranch ? params.state.branchBindings[params.currentBranch] ?? null : null;
+  if (currentBranchBinding?.currentAppId) {
+    return {
+      binding: currentBranchBinding,
+      branchName: params.currentBranch
+    };
+  }
+  const defaultBranchBinding = params.defaultBranch ? params.state.branchBindings[params.defaultBranch] ?? null : null;
+  if (defaultBranchBinding?.currentAppId) {
+    return {
+      binding: defaultBranchBinding,
+      branchName: params.defaultBranch
+    };
+  }
+  return null;
+}
+async function trySeedEquivalentBranchBaseline(params) {
+  if (!params.branchName || !params.defaultBranch || params.branchName === params.defaultBranch) {
+    return null;
+  }
+  const bindingState = await readCollabBindingState(params.repoRoot);
+  const defaultBranchBinding = bindingState?.branchBindings[params.defaultBranch] ?? null;
+  if (!defaultBranchBinding?.currentAppId) {
+    return null;
+  }
+  if (params.upstreamAppId && defaultBranchBinding.currentAppId !== params.upstreamAppId) {
+    return null;
+  }
+  const defaultBaseline = await readLocalBaseline({
+    repoFingerprint: params.repoFingerprint,
+    laneId: defaultBranchBinding.laneId,
+    repoRoot: params.repoRoot
+  });
+  if (!defaultBaseline?.lastSnapshotHash || !defaultBaseline.lastServerHeadHash) {
+    return null;
+  }
+  if (defaultBaseline.lastServerHeadHash !== params.appHeadHash) {
+    return null;
+  }
+  const inspection = await inspectLocalSnapshot({
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.repoFingerprint,
+    laneId: params.laneId,
+    branchName: params.branchName,
+    persistBlobs: false
+  });
+  if (inspection.snapshotHash !== defaultBaseline.lastSnapshotHash) {
+    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,
+    lastServerHeadHash: params.appHeadHash,
+    lastSeenLocalCommitHash: snapshot.localCommitHash
+  });
+  return "seeded";
+}
+async function resolveInitBaselineStatus(params) {
+  const baseline = await readLocalBaseline({
+    repoFingerprint: params.repoFingerprint,
+    laneId: params.laneId,
+    repoRoot: params.repoRoot
+  });
+  if (baseline?.lastSnapshotHash && baseline.lastServerHeadHash) {
+    return "existing";
+  }
+  const localHeadCommitHash = await getHeadCommitHash(params.repoRoot);
+  if (!localHeadCommitHash) return "requires_re_anchor";
+  const appHead = unwrapResponseObject(
+    await params.api.getAppHead(params.currentAppId),
+    "app head"
+  );
+  if (localHeadCommitHash === appHead.headCommitHash) {
+    await seedImportedInitBaseline({
+      api: params.api,
+      repoRoot: params.repoRoot,
+      repoFingerprint: params.repoFingerprint,
+      laneId: params.laneId,
+      currentAppId: params.currentAppId,
+      branchName: params.branchName
+    });
+    return "seeded";
+  }
+  const localSnapshotHash = params.branchName && params.defaultBranch && params.branchName !== params.defaultBranch ? (await inspectLocalSnapshot({
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.repoFingerprint,
+    laneId: params.laneId,
+    branchName: params.branchName,
+    persistBlobs: false
+  })).snapshotHash : void 0;
+  try {
+    const deltaResp = await params.api.getAppDelta(params.currentAppId, {
+      baseHeadHash: localHeadCommitHash,
+      targetHeadHash: appHead.headCommitHash,
+      localSnapshotHash,
+      repoFingerprint: params.repoFingerprint,
+      remoteUrl: params.remoteUrl ?? void 0,
+      defaultBranch: params.defaultBranch ?? void 0
+    });
+    const delta = unwrapResponseObject(deltaResp, "app delta");
+    if (delta.status === "up_to_date" || delta.status === "delta_ready") {
+      return "requires_sync";
+    }
+    if (delta.status === "content_equivalent") {
+      await seedImportedInitBaseline({
+        api: params.api,
+        repoRoot: params.repoRoot,
+        repoFingerprint: params.repoFingerprint,
+        laneId: params.laneId,
+        currentAppId: params.currentAppId,
+        branchName: params.branchName
+      });
+      return "seeded";
+    }
+    if (delta.status === "base_unknown") {
+      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
+      });
+      if (equivalentBaseline) {
+        return equivalentBaseline;
+      }
+    }
+  } catch {
+  }
+  return "requires_re_anchor";
+}
+async function seedImportedInitBaseline(params) {
+  const appHead = unwrapResponseObject(
+    await params.api.getAppHead(params.currentAppId),
+    "app head"
+  );
+  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,
+    lastServerHeadHash: appHead.headCommitHash,
+    lastSeenLocalCommitHash: snapshot.localCommitHash
+  });
+  return "seeded";
+}
 async function collabInit(params) {
   return withRepoMutationLock(
     {
@@ -2286,13 +3113,15 @@ async function collabInit(params) {
           hint: "History-preserving init imports the full git repository. Run the command from the repository root without --path."
         });
       }
-      const remoteUrl = normalizeGitRemote(await getRemoteOriginUrl(repoRoot));
+      const localBindingState = await readCollabBindingState(repoRoot, { persist: true });
+      const persistedRemoteUrl = normalizeGitRemote(localBindingState?.remoteUrl ?? null);
       const currentBranch = await getCurrentBranch(repoRoot);
-      const defaultBranch = await getDefaultBranch(repoRoot) ?? currentBranch;
+      const defaultBranch = localBindingState?.defaultBranch ?? await getDefaultBranch(repoRoot) ?? currentBranch;
       const branchName = currentBranch ?? defaultBranch ?? null;
-      const repoFingerprint = await buildRepoFingerprint({ gitRoot: repoRoot, remoteUrl, defaultBranch });
+      const localHeadCommitHash = await getHeadCommitHash(repoRoot);
+      const remoteUrl = persistedRemoteUrl ?? normalizeGitRemote(await getRemoteOriginUrl(repoRoot));
+      const repoFingerprint = localBindingState?.repoFingerprint ?? await buildRepoFingerprint({ gitRoot: repoRoot, remoteUrl, defaultBranch });
       const repoSnapshot = await captureRepoSnapshot(repoRoot);
-      const localBindingState = await readCollabBindingState(repoRoot, { persist: true });
       if (!params.forceNew && localBindingState?.explicitRootBinding && branchName) {
         const explicitRoot = localBindingState.explicitRootBinding;
         const explicitProjectId = explicitRoot.projectId ?? localBindingState.projectId;
@@ -2319,6 +3148,7 @@ async function collabInit(params) {
             remoteUrl,
             defaultBranch,
             branchName,
+            seedHeadCommitHash: localHeadCommitHash,
             operation: "`remix collab init`"
           });
           boundProjectId2 = lane.projectId ?? boundProjectId2;
@@ -2381,10 +3211,133 @@ async function collabInit(params) {
           appId: boundCurrentAppId2,
           dashboardUrl: buildDashboardAppUrl(boundCurrentAppId2),
           upstreamAppId: boundUpstreamAppId2,
-          bindingPath: path5.join(repoRoot, ".remix", "config.json"),
+          bindingPath: path7.join(repoRoot, ".remix", "config.json"),
           repoRoot,
           bindingMode: defaultBranch && branchName !== defaultBranch ? "lane" : "explicit_root",
           createdCanonicalFamily: false,
+          baselineStatus: await resolveInitBaselineStatus({
+            api: params.api,
+            repoRoot,
+            repoFingerprint,
+            laneId: boundLaneId2,
+            currentAppId: boundCurrentAppId2,
+            upstreamAppId: boundUpstreamAppId2,
+            branchName,
+            remoteUrl,
+            defaultBranch
+          }),
+          ...warnings.length > 0 ? { warnings } : {}
+        };
+      }
+      const storedBindingAnchor = localBindingState && branchName ? resolveStoredBindingAnchor({
+        state: localBindingState,
+        currentBranch,
+        defaultBranch
+      }) : null;
+      if (!params.forceNew && localBindingState && storedBindingAnchor && branchName) {
+        const existingBinding = storedBindingAnchor.binding;
+        const existingProjectId = existingBinding.projectId ?? localBindingState.projectId;
+        let canonicalLane2 = null;
+        let boundProjectId2 = existingProjectId;
+        let boundCurrentAppId2 = existingBinding.currentAppId;
+        let boundUpstreamAppId2 = existingBinding.upstreamAppId;
+        let boundThreadId2 = existingBinding.threadId;
+        let boundLaneId2 = existingBinding.laneId;
+        if (defaultBranch && branchName !== defaultBranch) {
+          canonicalLane2 = await resolveOrEnsureLaneBinding({
+            api: params.api,
+            projectId: existingProjectId ?? void 0,
+            repoFingerprint,
+            remoteUrl,
+            defaultBranch,
+            branchName: defaultBranch,
+            operation: "`remix collab init`"
+          });
+          const lane = await resolveOrEnsureLaneBinding({
+            api: params.api,
+            projectId: canonicalLane2.projectId ?? existingProjectId ?? void 0,
+            repoFingerprint,
+            remoteUrl,
+            defaultBranch,
+            branchName,
+            seedHeadCommitHash: localHeadCommitHash,
+            operation: "`remix collab init`"
+          });
+          boundProjectId2 = lane.projectId ?? boundProjectId2;
+          boundCurrentAppId2 = lane.currentAppId ?? boundCurrentAppId2;
+          boundUpstreamAppId2 = lane.upstreamAppId ?? boundUpstreamAppId2;
+          boundThreadId2 = lane.threadId ?? boundThreadId2;
+          boundLaneId2 = lane.laneId ?? null;
+        } else {
+          canonicalLane2 = await resolveOrEnsureLaneBinding({
+            api: params.api,
+            projectId: existingProjectId ?? void 0,
+            repoFingerprint,
+            remoteUrl,
+            defaultBranch,
+            branchName,
+            operation: "`remix collab init`"
+          });
+          boundProjectId2 = canonicalLane2.projectId ?? boundProjectId2;
+          boundCurrentAppId2 = canonicalLane2.currentAppId ?? boundCurrentAppId2;
+          boundUpstreamAppId2 = canonicalLane2.upstreamAppId ?? boundUpstreamAppId2;
+          boundThreadId2 = canonicalLane2.threadId ?? boundThreadId2;
+          boundLaneId2 = canonicalLane2.laneId ?? null;
+        }
+        const readyApp = await pollAppReady(params.api, boundCurrentAppId2);
+        boundProjectId2 = String(readyApp.projectId ?? boundProjectId2);
+        boundThreadId2 = readyApp.threadId ? String(readyApp.threadId) : boundThreadId2;
+        await assertRepoSnapshotUnchanged(repoRoot, repoSnapshot, {
+          operation: "`remix collab init`",
+          recoveryHint: "The repository changed while the local binding was being initialized. Review the local changes and rerun `remix collab init`."
+        });
+        if (canonicalLane2 && defaultBranch && branchName !== defaultBranch) {
+          await writeCollabBinding(repoRoot, {
+            projectId: canonicalLane2.projectId ?? existingProjectId ?? null,
+            currentAppId: canonicalLane2.currentAppId ?? existingBinding.currentAppId,
+            upstreamAppId: canonicalLane2.upstreamAppId ?? canonicalLane2.currentAppId ?? existingBinding.upstreamAppId ?? existingBinding.currentAppId,
+            threadId: canonicalLane2.threadId ?? existingBinding.threadId,
+            repoFingerprint: canonicalLane2.repoFingerprint ?? localBindingState.repoFingerprint ?? repoFingerprint,
+            remoteUrl: canonicalLane2.remoteUrl ?? localBindingState.remoteUrl ?? remoteUrl,
+            defaultBranch: canonicalLane2.defaultBranch ?? localBindingState.defaultBranch ?? defaultBranch ?? null,
+            laneId: canonicalLane2.laneId ?? null,
+            branchName: defaultBranch,
+            bindingMode: "lane"
+          });
+        }
+        const bindingPath2 = await writeCollabBinding(repoRoot, {
+          projectId: boundProjectId2,
+          currentAppId: boundCurrentAppId2,
+          upstreamAppId: boundUpstreamAppId2,
+          threadId: boundThreadId2,
+          repoFingerprint,
+          remoteUrl,
+          defaultBranch: defaultBranch ?? null,
+          laneId: boundLaneId2,
+          branchName,
+          bindingMode: "lane"
+        });
+        return {
+          reused: true,
+          projectId: boundProjectId2 ?? existingProjectId ?? "",
+          appId: boundCurrentAppId2,
+          dashboardUrl: buildDashboardAppUrl(boundCurrentAppId2),
+          upstreamAppId: boundUpstreamAppId2,
+          bindingPath: bindingPath2,
+          repoRoot,
+          bindingMode: "lane",
+          createdCanonicalFamily: false,
+          baselineStatus: await resolveInitBaselineStatus({
+            api: params.api,
+            repoRoot,
+            repoFingerprint,
+            laneId: boundLaneId2,
+            currentAppId: boundCurrentAppId2,
+            upstreamAppId: boundUpstreamAppId2,
+            branchName,
+            remoteUrl,
+            defaultBranch
+          }),
           ...warnings.length > 0 ? { warnings } : {}
         };
       }
@@ -2433,6 +3386,7 @@ async function collabInit(params) {
                 remoteUrl,
                 defaultBranch,
                 branchName,
+                seedHeadCommitHash: localHeadCommitHash,
                 operation: "`remix collab init`"
               });
               boundProjectId2 = lane.projectId ?? boundProjectId2;
@@ -2503,13 +3457,24 @@ async function collabInit(params) {
             repoRoot,
             bindingMode: "lane",
             createdCanonicalFamily: false,
+            baselineStatus: await resolveInitBaselineStatus({
+              api: params.api,
+              repoRoot,
+              repoFingerprint,
+              laneId: boundLaneId2,
+              currentAppId: boundCurrentAppId2,
+              upstreamAppId: boundUpstreamAppId2,
+              branchName,
+              remoteUrl,
+              defaultBranch
+            }),
             ...warnings.length > 0 ? { warnings } : {}
           };
         }
       }
       const { bundlePath, headCommitHash } = await createGitBundle(repoRoot, "repository.bundle");
       const bundleSha = await sha256FileHex(bundlePath);
-      const bundleSize = (await fs7.stat(bundlePath)).size;
+      const bundleSize = (await fs8.stat(bundlePath)).size;
       const presignResp = await params.api.presignImportUploadFirstParty({
         file: {
           name: "repository.bundle",
@@ -2526,7 +3491,7 @@ async function collabInit(params) {
       });
       const importResp = await params.api.importFromUploadFirstParty({
         uploadId: String(presign.uploadId),
-        appName: params.appName?.trim() || path5.basename(repoRoot),
+        appName: params.appName?.trim() || path7.basename(repoRoot),
         path: params.path?.trim() || void 0,
         platform: "generic",
         isPublic: false,
@@ -2563,6 +3528,7 @@ async function collabInit(params) {
             remoteUrl,
             defaultBranch,
             branchName,
+            seedHeadCommitHash: headCommitHash,
             operation: "`remix collab init`"
           });
           boundProjectId = lane.projectId ?? boundProjectId;
@@ -2656,6 +3622,14 @@ async function collabInit(params) {
           bindingMode
         });
       }
+      const baselineStatus = await seedImportedInitBaseline({
+        api: params.api,
+        repoRoot,
+        repoFingerprint,
+        laneId: boundLaneId,
+        currentAppId: boundCurrentAppId,
+        branchName
+      });
       return {
         reused: false,
         projectId: boundProjectId,
@@ -2666,6 +3640,7 @@ async function collabInit(params) {
         repoRoot,
         bindingMode,
         createdCanonicalFamily: Boolean(params.forceNew),
+        baselineStatus,
         remoteUrl,
         defaultBranch,
         ...warnings.length > 0 ? { warnings } : {}
@@ -2695,32 +3670,207 @@ async function collabInvite(params) {
     scopeType: scope,
     targetId
   };
-}
-
-// src/application/collab/collabList.ts
-async function collabList(params) {
-  const pageRequest = normalizePagination(params);
-  const resp = await params.api.listApps({
-    ownership: params.ownership ?? "all",
-    accessScope: params.accessScope ?? "explicit_member",
-    createdBy: params.createdBy,
-    forked: params.forked ?? "all",
-    limit: pageRequest.limit + 1,
-    offset: pageRequest.offset
+}
+
+// src/application/collab/collabList.ts
+async function collabList(params) {
+  const pageRequest = normalizePagination(params);
+  const resp = await params.api.listApps({
+    ownership: params.ownership ?? "all",
+    accessScope: params.accessScope ?? "explicit_member",
+    createdBy: params.createdBy,
+    forked: params.forked ?? "all",
+    limit: pageRequest.limit + 1,
+    offset: pageRequest.offset
+  });
+  const apps = unwrapResponseObject(resp, "apps");
+  const page = paginateOverfetchedItems(apps, params);
+  return {
+    apps: page.items,
+    pagination: page.pagination
+  };
+}
+
+// src/application/collab/collabReAnchor.ts
+import fs9 from "fs/promises";
+import path8 from "path";
+
+// src/application/collab/pendingFinalize.ts
+function hasPendingFinalize(summary) {
+  return Boolean(summary && summary.state !== "idle" && summary.activeJobCount > 0);
+}
+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 re-anchoring upstream history.", {
+      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 needed while only local boundary changes are pending.", {
+      exitCode: 2,
+      hint: "Record the local work with `remix collab finalize-turn` instead. Use `remix collab re-anchor` only when you need to adopt external Git/GitHub history as the new Remix anchor."
+    });
+  }
+  if (detected.repoState === "idle") {
+    throw new RemixError("This checkout is already aligned with Remix.", {
+      exitCode: 2,
+      hint: "No re-anchor step is needed right now unless you are explicitly re-anchoring to external Git/GitHub history."
+    });
+  }
+  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 });
+  }
+  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 (preflight.status === "ready_to_reconcile") {
+    const { bundlePath, headCommitHash: bundledHeadCommitHash } = await createGitBundle(repoRoot, "re-anchor.bundle");
+    const bundleTempDir = path8.dirname(bundlePath);
+    try {
+      const bundleStat = await fs9.stat(bundlePath);
+      const checksumSha256 = await sha256FileHex(bundlePath);
+      const presignResp = await params.api.presignImportUploadFirstParty({
+        file: {
+          name: path8.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 fs9.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
   });
-  const apps = unwrapResponseObject(resp, "apps");
-  const page = paginateOverfetchedItems(apps, params);
   return {
-    apps: page.items,
-    pagination: page.pagination
+    ...preview,
+    status: "reanchored",
+    targetHeadCommitHash: anchoredServerHeadHash,
+    applied: true,
+    dryRun: false
   };
 }
 
 // src/application/collab/collabReconcile.ts
-import fs8 from "fs/promises";
-import os4 from "os";
-import path6 from "path";
-async function collabReconcile(params) {
+import fs10 from "fs/promises";
+import os5 from "os";
+import path9 from "path";
+import { execa as execa2 } from "execa";
+async function reconcileBothChanged(params) {
   const repoRoot = await findGitRoot(params.cwd);
   const binding = await ensureActiveLaneBinding({
     repoRoot,
@@ -2733,163 +3883,229 @@ async function collabReconcile(params) {
       hint: "Run `remix collab init` first."
     });
   }
-  await ensureCleanWorktree(repoRoot, "`remix collab reconcile`");
   const branch = await requireCurrentBranch(repoRoot);
-  assertBoundBranchMatch({
-    currentBranch: branch,
-    branchName: binding.branchName,
-    allowBranchMismatch: params.allowBranchMismatch,
-    operation: "`remix collab reconcile`"
+  const baseline = await readLocalBaseline({
+    repoFingerprint: binding.repoFingerprint,
+    laneId: binding.laneId,
+    repoRoot
   });
-  const headCommitHash = await getHeadCommitHash(repoRoot);
-  const repoSnapshot = await captureRepoSnapshot(repoRoot);
-  if (!headCommitHash) {
-    throw new RemixError("Failed to resolve local HEAD commit.", { exitCode: 1 });
+  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."
+    });
   }
-  const syncResp = await params.api.syncLocalApp(binding.currentAppId, {
-    baseCommitHash: headCommitHash,
-    repoFingerprint: binding.repoFingerprint ?? void 0,
-    remoteUrl: binding.remoteUrl ?? void 0,
-    defaultBranch: binding.defaultBranch ?? void 0,
-    dryRun: true
+  const currentSnapshot = await captureLocalSnapshot({
+    repoRoot,
+    repoFingerprint: binding.repoFingerprint,
+    laneId: binding.laneId,
+    branchName: binding.branchName
   });
-  const sync = unwrapResponseObject(syncResp, "sync result");
-  if (sync.status === "conflict_risk") {
-    throw new RemixError("Local repository metadata conflicts with the bound Remix app.", {
+  const diffResult = await diffLocalSnapshots({
+    baseSnapshotId: baseline.lastSnapshotId,
+    targetSnapshotId: currentSnapshot.id
+  });
+  if (!diffResult.diff.trim()) {
+    throw new RemixError("No local boundary delta was found to reconcile.", {
       exitCode: 2,
-      hint: sync.warnings.join("\n") || "Run the command from the correct bound repository."
+      hint: "Pull the server delta locally, or make local changes before running `remix collab reconcile`."
     });
   }
-  if (sync.status !== "base_unknown") {
-    return collabSync(params);
-  }
-  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") {
+  const [appHeadResp, deltaResp, repoSnapshot] = await Promise.all([
+    params.api.getAppHead(binding.currentAppId),
+    params.api.getAppDelta(binding.currentAppId, {
+      baseHeadHash: baseline.lastServerHeadHash,
+      repoFingerprint: binding.repoFingerprint ?? void 0,
+      remoteUrl: binding.remoteUrl ?? void 0,
+      defaultBranch: binding.defaultBranch ?? void 0
+    }),
+    captureRepoSnapshot(repoRoot, { includeWorkspaceDiffHash: true })
+  ]);
+  const appHead = unwrapResponseObject(appHeadResp, "app head");
+  const delta = unwrapResponseObject(deltaResp, "app delta");
+  if (delta.status === "conflict_risk") {
     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."
+      hint: delta.warnings.join("\n") || "Run the command from the correct bound repository."
     });
   }
-  if (preflight.status === "up_to_date") {
-    return collabSync(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."
+    });
   }
-  const previewResult = {
-    status: preflight.status,
-    branch,
+  if (delta.status !== "delta_ready" && delta.status !== "up_to_date") {
+    throw new RemixError("Reconcile could not determine the server delta for this lane.", {
+      exitCode: 1,
+      hint: delta.warnings.join("\n") || "Run `remix collab status` and retry once the lane is healthy."
+    });
+  }
+  const preview = {
+    status: "ready_to_reconcile",
     repoRoot,
-    localHeadCommitHash: headCommitHash,
-    targetHeadCommitId: preflight.targetHeadCommitId,
-    targetHeadCommitHash: preflight.targetHeadCommitHash,
-    warnings: preflight.warnings,
+    branch,
+    currentAppId: binding.currentAppId,
+    localHeadCommitHash: currentSnapshot.localCommitHash,
+    baseHeadCommitHash: baseline.lastServerHeadHash,
+    targetHeadCommitHash: appHead.headCommitHash,
+    targetHeadCommitId: appHead.headCommitId,
+    stats: diffResult.stats,
+    warnings: delta.warnings,
     applied: false,
     dryRun: params.dryRun
   };
   if (params.dryRun) {
-    return previewResult;
+    return preview;
   }
-  const { bundlePath, headCommitHash: bundledHeadCommitHash } = await createGitBundle(repoRoot, "reconcile-local.bundle");
-  const bundleTempDir = path6.dirname(bundlePath);
+  const replayResp = await params.api.startChangeStepReplay(binding.currentAppId, {
+    prompt: "Reconcile local boundary delta onto the latest server head.",
+    assistantResponse: "Replay the local boundary delta onto the latest server head without recording a new change step.",
+    diff: diffResult.diff,
+    baseCommitHash: baseline.lastServerHeadHash,
+    targetHeadCommitHash: appHead.headCommitHash,
+    expectedPaths: diffResult.changedPaths,
+    workspaceMetadata: {
+      recordingMode: "boundary_delta",
+      repoRoot,
+      branch,
+      baselineSnapshotId: baseline.lastSnapshotId,
+      currentSnapshotId: currentSnapshot.id,
+      baselineServerHeadHash: baseline.lastServerHeadHash,
+      currentSnapshotHash: currentSnapshot.snapshotHash,
+      localCommitHash: currentSnapshot.localCommitHash,
+      repoStateAtCapture: "both_changed"
+    },
+    idempotencyKey: buildDeterministicIdempotencyKey({
+      kind: "collab_reconcile_replay_v1",
+      appId: binding.currentAppId,
+      baseCommitHash: baseline.lastServerHeadHash,
+      targetHeadCommitHash: appHead.headCommitHash,
+      currentSnapshotId: currentSnapshot.id,
+      diffSha256: diffResult.diffSha256
+    })
+  });
+  const replayStart = unwrapResponseObject(replayResp, "change step replay");
+  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 fs10.mkdtemp(path9.join(os5.tmpdir(), "remix-reconcile-"));
+  let serverHeadSnapshot = null;
+  let mergedSnapshot = null;
   try {
-    const bundleStat = await fs8.stat(bundlePath);
-    const checksumSha256 = await sha256FileHex(bundlePath);
-    const presignResp = await params.api.presignImportUploadFirstParty({
-      file: {
-        name: path6.basename(bundlePath),
-        mimeType: "application/x-git-bundle",
-        size: bundleStat.size,
-        checksumSha256
-      }
-    });
-    const uploadTarget = unwrapResponseObject(presignResp, "reconcile upload target");
-    await uploadPresigned({
-      uploadUrl: String(uploadTarget.uploadUrl),
-      filePath: bundlePath,
-      headers: uploadTarget.headers ?? {}
+    const tempRepoRoot = path9.join(tempRoot, "repo");
+    await fs10.mkdir(tempRepoRoot, { recursive: true });
+    await execa2("git", ["init"], { cwd: tempRepoRoot, stderr: "ignore" });
+    await materializeLocalSnapshot(baseline.lastSnapshotId, tempRepoRoot);
+    if (delta.status === "delta_ready" && delta.diff.trim()) {
+      await applyUnifiedDiffToWorktree(tempRepoRoot, delta.diff, "`remix collab reconcile`");
+    }
+    serverHeadSnapshot = await captureLocalSnapshot({
+      repoRoot: tempRepoRoot,
+      repoFingerprint: binding.repoFingerprint,
+      laneId: binding.laneId,
+      branchName: binding.branchName
     });
-    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({
-        appId: binding.currentAppId,
-        localHeadCommitHash: bundledHeadCommitHash,
-        targetHeadCommitHash: preflight.targetHeadCommitHash
-      })
+    if (replayDiff.diff.trim()) {
+      await applyUnifiedDiffToWorktree(tempRepoRoot, replayDiff.diff, "`remix collab reconcile`");
+    }
+    mergedSnapshot = await captureLocalSnapshot({
+      repoRoot: tempRepoRoot,
+      repoFingerprint: binding.repoFingerprint,
+      laneId: binding.laneId,
+      branchName: binding.branchName
     });
-    const started = unwrapResponseObject(startResp, "reconcile");
-    const reconcile = await pollReconcile(params.api, binding.currentAppId, started.id);
-    if (!reconcile.mergeBaseCommitHash || !reconcile.reconciledHeadCommitHash || !reconcile.resultBundleRef) {
-      throw new RemixError("Reconcile completed without enough result metadata to update the local repository.", {
-        exitCode: 1
+  } finally {
+    await fs10.rm(tempRoot, { recursive: true, force: true }).catch(() => void 0);
+  }
+  if (!serverHeadSnapshot || !mergedSnapshot) {
+    throw new RemixError("Failed to materialize the reconciled local workspace.", { exitCode: 1 });
+  }
+  const workspaceChanged = currentSnapshot.snapshotHash !== mergedSnapshot.snapshotHash;
+  return withRepoMutationLock(
+    {
+      cwd: repoRoot,
+      operation: "collabReconcile"
+    },
+    async ({ repoRoot: lockedRepoRoot, warnings }) => {
+      await assertRepoSnapshotUnchanged(lockedRepoRoot, repoSnapshot, {
+        operation: "`remix collab reconcile`",
+        recoveryHint: "The repository changed while reconcile was preparing the replay. Review the local changes and rerun `remix collab reconcile`."
       });
-    }
-    const mergeBaseCommitHash = reconcile.mergeBaseCommitHash;
-    const reconciledHeadCommitHash = reconcile.reconciledHeadCommitHash;
-    const resultBundleRef = reconcile.resultBundleRef;
-    return withRepoMutationLock(
-      {
-        cwd: repoRoot,
-        operation: "collabReconcile"
-      },
-      async ({ repoRoot: lockedRepoRoot, warnings }) => {
-        await assertRepoSnapshotUnchanged(lockedRepoRoot, repoSnapshot, {
-          operation: "`remix collab reconcile`",
-          recoveryHint: "The repository changed after reconcile was prepared. Review the local changes and rerun `remix collab reconcile`."
-        });
-        await ensureCleanWorktree(lockedRepoRoot, "`remix collab reconcile`");
-        const lockedBranch = await requireCurrentBranch(lockedRepoRoot);
-        assertBoundBranchMatch({
-          currentBranch: lockedBranch,
-          branchName: binding.branchName,
-          allowBranchMismatch: params.allowBranchMismatch,
-          operation: "`remix collab reconcile`"
-        });
-        const backup = await createBackupBranch(lockedRepoRoot, {
-          branchName: branch,
-          sourceCommitHash: headCommitHash,
-          prefix: "remix/reconcile-backup"
+      await restoreLocalSnapshotToWorktree(mergedSnapshot.id, lockedRepoRoot);
+      const restoredSnapshot = await captureLocalSnapshot({
+        repoRoot: lockedRepoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        laneId: binding.laneId,
+        branchName: binding.branchName
+      });
+      if (restoredSnapshot.snapshotHash !== mergedSnapshot.snapshotHash) {
+        throw new RemixError("Failed to restore the reconciled workspace into the local checkout.", {
+          exitCode: 1,
+          hint: "The local worktree did not match the reconciled snapshot after restore."
         });
-        await hardResetToCommit(lockedRepoRoot, mergeBaseCommitHash, "`remix collab reconcile`");
-        const bundleResp = await params.api.downloadAppReconcileBundle(binding.currentAppId, reconcile.id);
-        const resultTempDir = await fs8.mkdtemp(path6.join(os4.tmpdir(), "remix-reconcile-"));
-        const resultBundlePath = path6.join(resultTempDir, bundleResp.fileName ?? "reconcile-result.bundle");
-        try {
-          await fs8.writeFile(resultBundlePath, bundleResp.data);
-          await importGitBundle(lockedRepoRoot, resultBundlePath, resultBundleRef);
-          await ensureCommitExists(lockedRepoRoot, reconciledHeadCommitHash);
-          const localCommitHash = await fastForwardToCommit(lockedRepoRoot, reconciledHeadCommitHash);
-          if (localCommitHash !== reconciledHeadCommitHash) {
-            throw new RemixError("Local reconcile completed but final HEAD does not match the server result.", { exitCode: 1 });
-          }
-          return {
-            ...previewResult,
-            status: reconcile.status,
-            reconcileId: reconcile.id,
-            mergeBaseCommitHash: reconcile.mergeBaseCommitHash,
-            reconciledHeadCommitId: reconcile.reconciledHeadCommitId,
-            reconciledHeadCommitHash: reconcile.reconciledHeadCommitHash,
-            backupBranchName: backup.branchName,
-            localCommitHash,
-            applied: true,
-            dryRun: false,
-            warnings: Array.from(/* @__PURE__ */ new Set([...previewResult.warnings, ...warnings]))
-          };
-        } finally {
-          await fs8.rm(resultTempDir, { recursive: true, force: true });
-        }
       }
-    );
-  } finally {
-    await fs8.rm(bundleTempDir, { recursive: true, force: true });
+      await writeLocalBaseline({
+        repoRoot: lockedRepoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        laneId: binding.laneId,
+        currentAppId: binding.currentAppId,
+        branchName: binding.branchName,
+        lastSnapshotId: serverHeadSnapshot.id,
+        lastSnapshotHash: serverHeadSnapshot.snapshotHash,
+        lastServerHeadHash: appHead.headCommitHash,
+        lastSeenLocalCommitHash: restoredSnapshot.localCommitHash
+      });
+      return {
+        ...preview,
+        status: "reconciled",
+        localHeadCommitHash: restoredSnapshot.localCommitHash,
+        applied: workspaceChanged,
+        dryRun: false,
+        ...warnings.length > 0 ? {
+          warnings: Array.from(/* @__PURE__ */ new Set([...delta.warnings, ...warnings]))
+        } : {}
+      };
+    }
+  );
+}
+async function collabReconcile(params) {
+  const detected = await collabDetectRepoState({
+    api: params.api,
+    cwd: params.cwd,
+    allowBranchMismatch: params.allowBranchMismatch
+  });
+  if (detected.status === "metadata_conflict" || detected.status === "branch_mismatch") {
+    throw new RemixError("Repository must be realigned before reconciliation.", {
+      exitCode: 2,
+      hint: detected.hint
+    });
+  }
+  if (detected.repoState === "server_only_changed" || detected.repoState === "idle") {
+    return collabSync(params);
+  }
+  if (detected.repoState === "both_changed") {
+    return reconcileBothChanged(params);
+  }
+  if (detected.repoState === "external_local_base_changed") {
+    return collabReAnchor(params);
   }
+  if (detected.repoState === "local_only_changed") {
+    if (hasPendingFinalize(detected.pendingFinalize)) {
+      throw new RemixError("Reconcile is not needed while queued Remix turn recording is still processing.", {
+        exitCode: 2,
+        hint: buildPendingFinalizeHint()
+      });
+    }
+    throw new RemixError("Reconcile is not needed while only local boundary changes are pending.", {
+      exitCode: 2,
+      hint: "Record the local work with `remix collab finalize-turn` instead."
+    });
+  }
+  throw new RemixError(detected.hint || "Repository is not ready for reconciliation.", {
+    exitCode: 2,
+    hint: detected.hint
+  });
 }
 
 // src/application/collab/collabReject.ts
@@ -2961,9 +4177,34 @@ async function collabRemix(params) {
     branchName: authoritativeLane?.branchName ?? branchName,
     bindingMode: "lane"
   });
+  const currentAppId = authoritativeLane?.currentAppId ?? String(app.id);
+  const repoFingerprintForBaseline = authoritativeLane?.repoFingerprint ?? repoFingerprint;
+  const laneIdForBaseline = authoritativeLane?.laneId ?? laneId;
+  const branchNameForBaseline = authoritativeLane?.branchName ?? branchName;
+  const appHead = unwrapResponseObject(
+    await params.api.getAppHead(currentAppId),
+    "app head"
+  );
+  const snapshot = await captureLocalSnapshot({
+    repoRoot: checkout.repoRoot,
+    repoFingerprint: repoFingerprintForBaseline,
+    laneId: laneIdForBaseline,
+    branchName: branchNameForBaseline
+  });
+  await writeLocalBaseline({
+    repoRoot: checkout.repoRoot,
+    repoFingerprint: repoFingerprintForBaseline,
+    laneId: laneIdForBaseline,
+    currentAppId,
+    branchName: branchNameForBaseline,
+    lastSnapshotId: snapshot.id,
+    lastSnapshotHash: snapshot.snapshotHash,
+    lastServerHeadHash: appHead.headCommitHash,
+    lastSeenLocalCommitHash: snapshot.localCommitHash
+  });
   return {
-    appId: authoritativeLane?.currentAppId ?? String(app.id),
-    dashboardUrl: buildDashboardAppUrl(authoritativeLane?.currentAppId ?? String(app.id)),
+    appId: currentAppId,
+    dashboardUrl: buildDashboardAppUrl(currentAppId),
     projectId: authoritativeLane?.projectId ?? String(app.projectId),
     upstreamAppId: authoritativeLane?.upstreamAppId ?? String(app.forkedFromAppId ?? sourceAppId),
     bindingPath,
@@ -2980,11 +4221,26 @@ async function collabRequestMerge(params) {
     operation: "`remix collab request-merge`"
   });
   if (!binding) throw new RemixError("Repository is not bound to Remix.", { exitCode: 2 });
+  const pendingFinalize = await summarizePendingFinalizeJobs({
+    repoRoot,
+    repoFingerprint: binding.repoFingerprint,
+    currentAppId: binding.currentAppId,
+    laneId: binding.laneId
+  });
+  if (hasPendingFinalize(pendingFinalize)) {
+    throw new RemixError("Pending Remix turn recording still processing.", {
+      exitCode: 2,
+      hint: buildPendingFinalizeHint()
+    });
+  }
   const resp = await params.api.openMergeRequest(binding.currentAppId);
   return unwrapResponseObject(resp, "merge request");
 }
 
 // src/application/collab/collabStatus.ts
+function isFinalizeQueueBlocking(state) {
+  return state === "queued" || state === "processing" || state === "retry_scheduled";
+}
 function createBaseStatus() {
   return {
     schemaVersion: 1,
@@ -3045,6 +4301,36 @@ function createBaseStatus() {
       targetHeadCommitHash: null,
       targetHeadCommitId: null
     },
+    alignment: {
+      checked: false,
+      error: null,
+      repoState: null,
+      canRecordTurn: false,
+      pendingFinalize: {
+        state: "idle",
+        activeJobCount: 0,
+        queuedJobCount: 0,
+        processingJobCount: 0,
+        retryScheduledJobCount: 0,
+        failedJobCount: 0,
+        oldestCapturedAt: null,
+        newestCapturedAt: null,
+        nextRetryAt: null,
+        latestError: null
+      },
+      baseline: {
+        lastSnapshotId: null,
+        lastSnapshotHash: null,
+        lastServerHeadHash: null,
+        lastSeenLocalCommitHash: null
+      },
+      current: {
+        snapshotHash: null,
+        serverHeadHash: null,
+        serverHeadCommitId: null,
+        localCommitHash: null
+      }
+    },
     recommendedAction: "no_action",
     warnings: []
   };
@@ -3079,15 +4365,13 @@ async function collabStatus(params) {
   }
   status.repo.isGitRepo = true;
   status.repo.repoRoot = repoRoot;
-  const [branch, initialHeadCommitHash, worktreeStatus, bindingResolution] = await Promise.all([
+  const [branch, headCommitHash, worktreeStatus, detected] = await Promise.all([
     getCurrentBranch(repoRoot),
     getHeadCommitHash(repoRoot),
     getWorktreeStatus(repoRoot),
-    resolveActiveLaneBinding({ repoRoot, api: params.api ?? void 0 })
+    collabDetectRepoState({ api: params.api ?? void 0, cwd: repoRoot })
   ]);
-  let headCommitHash = initialHeadCommitHash;
   status.repo.branch = branch;
-  status.repo.branchMismatch = false;
   status.repo.headCommitHash = headCommitHash;
   status.repo.worktree = {
     isClean: worktreeStatus.isClean,
@@ -3099,213 +4383,154 @@ async function collabStatus(params) {
   if (!status.repo.worktree.isClean) addWarning(status, "Working tree has local changes.");
   if (!branch) addWarning(status, "Repository is in a detached HEAD state.");
   if (!headCommitHash) addWarning(status, "Failed to resolve local HEAD commit.");
-  if (bindingResolution.status === "not_bound") {
-    status.binding.path = null;
-    addBlockedReason(status.sync, "not_bound");
-    addBlockedReason(status.reconcile, "not_bound");
-    status.recommendedAction = "init";
-    return status;
-  }
-  if (bindingResolution.status === "missing_branch_binding") {
-    status.binding = {
-      isBound: true,
-      path: getCollabBindingPath(repoRoot),
-      projectId: bindingResolution.projectId,
-      currentAppId: null,
-      upstreamAppId: bindingResolution.upstreamAppId,
-      isRemix: null,
-      threadId: bindingResolution.threadId,
-      repoFingerprint: bindingResolution.repoFingerprint,
-      remoteUrl: bindingResolution.remoteUrl,
-      defaultBranch: bindingResolution.defaultBranch,
-      laneId: null,
-      branchName: bindingResolution.currentBranch,
-      bindingMode: "lane"
-    };
-    addBlockedReason(status.sync, "branch_binding_missing");
-    addBlockedReason(status.reconcile, "branch_binding_missing");
-    addWarning(status, `Current branch ${bindingResolution.currentBranch ?? "(detached)"} is not yet bound to a Remix lane.`);
-    status.recommendedAction = "init";
-    return status;
-  }
-  if (bindingResolution.status === "ambiguous_family_selection") {
+  if (detected.binding) {
     status.binding = {
       isBound: true,
       path: getCollabBindingPath(repoRoot),
-      projectId: null,
-      currentAppId: null,
-      upstreamAppId: null,
-      isRemix: null,
-      threadId: null,
-      repoFingerprint: bindingResolution.repoFingerprint,
-      remoteUrl: bindingResolution.remoteUrl,
-      defaultBranch: bindingResolution.defaultBranch,
-      laneId: null,
-      branchName: bindingResolution.currentBranch,
-      bindingMode: null
+      projectId: detected.binding.projectId,
+      currentAppId: detected.binding.currentAppId,
+      upstreamAppId: detected.binding.upstreamAppId,
+      isRemix: detected.binding.currentAppId !== detected.binding.upstreamAppId,
+      threadId: detected.binding.threadId,
+      repoFingerprint: detected.binding.repoFingerprint,
+      remoteUrl: detected.binding.remoteUrl,
+      defaultBranch: detected.binding.defaultBranch,
+      laneId: detected.binding.laneId,
+      branchName: detected.binding.branchName,
+      bindingMode: detected.binding.bindingMode
     };
-    addBlockedReason(status.sync, "family_ambiguous");
-    addBlockedReason(status.reconcile, "family_ambiguous");
-    addWarning(
-      status,
-      `Multiple canonical Remix families match ${bindingResolution.currentBranch ?? "the current branch"}. Switch to a checkout already bound to the intended family or run \`remix collab init --force-new\`.`
-    );
-    status.recommendedAction = "choose_family";
-    return status;
+    status.repo.branchMismatch = branch !== detected.binding.branchName;
   }
-  const binding = bindingResolution.binding;
-  status.binding = {
-    isBound: true,
-    path: getCollabBindingPath(repoRoot),
-    projectId: binding.projectId,
-    currentAppId: binding.currentAppId,
-    upstreamAppId: binding.upstreamAppId,
-    isRemix: binding.currentAppId !== binding.upstreamAppId,
-    threadId: binding.threadId,
-    repoFingerprint: binding.repoFingerprint,
-    remoteUrl: binding.remoteUrl,
-    defaultBranch: binding.defaultBranch,
-    laneId: binding.laneId,
-    branchName: binding.branchName,
-    bindingMode: binding.bindingMode
+  status.alignment.checked = Boolean(params.api);
+  status.alignment.repoState = detected.repoState;
+  status.alignment.error = detected.status === "remote_error" ? detected.hint : null;
+  status.alignment.pendingFinalize = detected.pendingFinalize;
+  status.alignment.baseline = detected.baseline;
+  status.alignment.current = {
+    snapshotHash: detected.currentSnapshotHash,
+    serverHeadHash: detected.currentServerHeadHash,
+    serverHeadCommitId: detected.currentServerHeadCommitId,
+    localCommitHash: detected.localCommitHash
   };
-  status.repo.branchMismatch = !isBoundBranchMatch(branch, binding.branchName);
-  if (status.repo.branchMismatch) {
+  status.alignment.canRecordTurn = !isFinalizeQueueBlocking(detected.pendingFinalize.state) && (detected.repoState === "idle" || detected.repoState === "local_only_changed");
+  switch (detected.status) {
+    case "not_bound":
+      addBlockedReason(status.sync, "not_bound");
+      addBlockedReason(status.reconcile, "not_bound");
+      status.recommendedAction = "init";
+      break;
+    case "branch_binding_missing":
+      addBlockedReason(status.sync, "branch_binding_missing");
+      addBlockedReason(status.reconcile, "branch_binding_missing");
+      status.recommendedAction = "init";
+      break;
+    case "family_ambiguous":
+      addBlockedReason(status.sync, "family_ambiguous");
+      addBlockedReason(status.reconcile, "family_ambiguous");
+      status.recommendedAction = "choose_family";
+      break;
+    case "missing_head":
+      addBlockedReason(status.sync, "missing_head");
+      addBlockedReason(status.reconcile, "missing_head");
+      break;
+    case "branch_mismatch":
+      addBlockedReason(status.sync, "branch_mismatch");
+      addBlockedReason(status.reconcile, "branch_mismatch");
+      break;
+    case "metadata_conflict":
+      addBlockedReason(status.sync, "metadata_conflict");
+      addBlockedReason(status.reconcile, "metadata_conflict");
+      status.sync.checked = true;
+      status.sync.status = "conflict_risk";
+      status.sync.warnings = detected.metadataWarnings;
+      status.reconcile.checked = true;
+      status.reconcile.status = "metadata_conflict";
+      status.reconcile.warnings = detected.metadataWarnings;
+      break;
+    case "remote_error":
+      addBlockedReason(status.sync, "remote_error");
+      addBlockedReason(status.reconcile, "remote_error");
+      status.sync.error = detected.hint;
+      status.reconcile.error = detected.hint;
+      break;
+    default:
+      break;
+  }
+  if (detected.repoState === "server_only_changed") {
+    status.sync.checked = true;
+    status.sync.status = "delta_ready";
+    status.sync.targetCommitHash = detected.currentServerHeadHash;
+    status.sync.targetCommitId = detected.currentServerHeadCommitId;
+    status.sync.canApply = !status.repo.branchMismatch;
+    status.recommendedAction = "pull";
+  } else if (detected.repoState === "both_changed") {
+    status.reconcile.checked = true;
+    status.reconcile.status = "ready_to_reconcile";
+    status.reconcile.targetHeadCommitHash = detected.currentServerHeadHash;
+    status.reconcile.targetHeadCommitId = detected.currentServerHeadCommitId;
+    status.reconcile.canApply = !status.repo.branchMismatch;
+    status.recommendedAction = "reconcile";
+  } else if (detected.repoState === "external_local_base_changed") {
+    status.recommendedAction = "re_anchor";
+    addBlockedReason(status.sync, "baseline_missing");
+    addBlockedReason(status.reconcile, "baseline_missing");
+  } else if (detected.repoState === "local_only_changed") {
+    status.recommendedAction = isFinalizeQueueBlocking(detected.pendingFinalize.state) ? "await_finalize" : "record";
+  } else if (detected.repoState === "idle") {
+    status.recommendedAction = isFinalizeQueueBlocking(detected.pendingFinalize.state) ? "await_finalize" : "no_action";
+  }
+  if (isFinalizeQueueBlocking(detected.pendingFinalize.state) && detected.status === "ready" && status.recommendedAction !== "init" && status.recommendedAction !== "choose_family") {
+    status.recommendedAction = "await_finalize";
     addWarning(
       status,
-      `Current branch ${branch ?? "(detached)"} does not match bound branch ${binding.branchName ?? "(unset)"}.`
+      "A captured Remix turn is still pending locally. Drain or await finalize before opening a merge request or starting another recovery flow."
     );
+    addWarning(status, detected.pendingFinalize.latestError);
   }
-  if (bindingResolution.status === "binding_conflict") {
+  if (detected.pendingFinalize.failedJobCount > 0) {
     addWarning(
       status,
-      `Local binding app ${binding.currentAppId} conflicts with server-resolved app ${bindingResolution.resolvedLane.currentAppId ?? "(unknown)"} for branch ${bindingResolution.currentBranch ?? "(detached)"}.`
+      "One or more queued finalize jobs failed permanently and will not retry automatically. Review the local finalize queue state before relying on those older captured turns."
     );
+    addWarning(status, detected.pendingFinalize.latestError);
   }
-  if (!params.api) {
-    status.recommendedAction = "no_action";
-    return status;
-  }
-  const [appResult, incomingResult, outgoingResult, syncResult] = await Promise.allSettled([
-    params.api.getApp(binding.currentAppId),
-    params.api.listMergeRequests({ queue: "app_reviewable", appId: binding.currentAppId, status: "open", kind: "merge" }),
-    params.api.listMergeRequests({ queue: "app_outgoing", appId: binding.currentAppId, status: "open", kind: "merge" }),
-    headCommitHash ? params.api.syncLocalApp(binding.currentAppId, {
-      baseCommitHash: headCommitHash,
-      repoFingerprint: binding.repoFingerprint ?? void 0,
-      remoteUrl: binding.remoteUrl ?? void 0,
-      defaultBranch: binding.defaultBranch ?? void 0,
-      dryRun: true
-    }) : Promise.resolve(null)
-  ]);
-  const remoteErrors = [];
-  if (appResult.status === "fulfilled") {
-    const app = unwrapResponseObject(appResult.value, "app");
-    status.remote.appStatus = typeof app.status === "string" ? app.status : null;
-  } else {
-    remoteErrors.push(formatCliErrorDetail(appResult.reason) ?? "Failed to fetch app status.");
-  }
-  if (incomingResult.status === "fulfilled") {
-    const incoming = unwrapResponseObject(incomingResult.value, "merge requests");
-    status.remote.incomingOpenMergeRequestCount = countMergeRequests(incoming);
-  } else {
-    remoteErrors.push(formatCliErrorDetail(incomingResult.reason) ?? "Failed to fetch incoming merge requests.");
-  }
-  if (outgoingResult.status === "fulfilled") {
-    const outgoing = unwrapResponseObject(outgoingResult.value, "merge requests");
-    status.remote.outgoingOpenMergeRequestCount = countMergeRequests(outgoing);
-  } else {
-    remoteErrors.push(formatCliErrorDetail(outgoingResult.reason) ?? "Failed to fetch outgoing merge requests.");
-  }
-  status.remote.checked = remoteErrors.length === 0;
-  status.remote.error = remoteErrors.length > 0 ? remoteErrors.join("\n\n") : null;
-  addWarning(status, status.remote.error);
-  if (!headCommitHash) {
-    addBlockedReason(status.sync, "missing_head");
-    addBlockedReason(status.reconcile, "missing_head");
-  } else if (syncResult.status === "fulfilled") {
-    const syncResp = syncResult.value;
-    if (syncResp) {
-      const sync = unwrapResponseObject(syncResp, "sync result");
-      const latestHeadCommitHash = sync.targetCommitHash && sync.status !== "up_to_date" ? await getHeadCommitHash(repoRoot) : headCommitHash;
-      if (latestHeadCommitHash) {
-        headCommitHash = latestHeadCommitHash;
-        status.repo.headCommitHash = latestHeadCommitHash;
-      }
-      const normalizedSyncStatus = headCommitHash && sync.targetCommitHash && headCommitHash === sync.targetCommitHash ? "up_to_date" : sync.status;
-      status.sync.checked = true;
-      status.sync.status = normalizedSyncStatus;
-      status.sync.warnings = sync.warnings;
-      status.sync.targetCommitHash = sync.targetCommitHash;
-      status.sync.targetCommitId = sync.targetCommitId;
-      status.sync.stats = sync.stats;
-      if (!status.repo.worktree.isClean) addBlockedReason(status.sync, "dirty_worktree");
-      if (!branch) addBlockedReason(status.sync, "detached_head");
-      if (status.repo.branchMismatch) addBlockedReason(status.sync, "branch_mismatch");
-      if (normalizedSyncStatus === "conflict_risk") addBlockedReason(status.sync, "metadata_conflict");
-      status.sync.canApply = status.sync.status === "ready_to_fast_forward" && status.repo.worktree.isClean && Boolean(branch) && !status.sync.blockedReasons.includes("metadata_conflict");
-      if (normalizedSyncStatus === "conflict_risk") {
-        status.reconcile.checked = true;
-        status.reconcile.status = "metadata_conflict";
-        status.reconcile.warnings = sync.warnings;
-        status.reconcile.targetHeadCommitHash = sync.targetCommitHash;
-        status.reconcile.targetHeadCommitId = sync.targetCommitId;
-        addBlockedReason(status.reconcile, "metadata_conflict");
-        if (!status.repo.worktree.isClean) addBlockedReason(status.reconcile, "dirty_worktree");
-        if (!branch) addBlockedReason(status.reconcile, "detached_head");
-        if (status.repo.branchMismatch) addBlockedReason(status.reconcile, "branch_mismatch");
-      } else if (normalizedSyncStatus === "base_unknown") {
-        try {
-          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");
-          status.reconcile.checked = true;
-          status.reconcile.status = preflight.status;
-          status.reconcile.warnings = preflight.warnings;
-          status.reconcile.targetHeadCommitHash = preflight.targetHeadCommitHash;
-          status.reconcile.targetHeadCommitId = preflight.targetHeadCommitId;
-          if (!status.repo.worktree.isClean) addBlockedReason(status.reconcile, "dirty_worktree");
-          if (!branch) addBlockedReason(status.reconcile, "detached_head");
-          if (status.repo.branchMismatch) addBlockedReason(status.reconcile, "branch_mismatch");
-          if (preflight.status === "metadata_conflict") addBlockedReason(status.reconcile, "metadata_conflict");
-          status.reconcile.canApply = preflight.status === "ready_to_reconcile" && status.repo.worktree.isClean && Boolean(branch) && !status.reconcile.blockedReasons.includes("metadata_conflict");
-        } catch (err) {
-          status.reconcile.error = formatCliErrorDetail(err) ?? "Failed to fetch reconcile preflight.";
-          addBlockedReason(status.reconcile, "remote_error");
-          addWarning(status, status.reconcile.error);
-        }
-      } else {
-        status.reconcile.checked = true;
-        status.reconcile.status = "not_needed";
-        if (!status.repo.worktree.isClean) addBlockedReason(status.reconcile, "dirty_worktree");
-        if (!branch) addBlockedReason(status.reconcile, "detached_head");
-        if (status.repo.branchMismatch) addBlockedReason(status.reconcile, "branch_mismatch");
-      }
+  if (params.api && status.binding.currentAppId) {
+    const [appResult, incomingResult, outgoingResult] = await Promise.allSettled([
+      params.api.getApp(status.binding.currentAppId),
+      params.api.listMergeRequests({ queue: "app_reviewable", appId: status.binding.currentAppId, status: "open", kind: "merge" }),
+      params.api.listMergeRequests({ queue: "app_outgoing", appId: status.binding.currentAppId, status: "open", kind: "merge" })
+    ]);
+    const remoteErrors = [];
+    if (appResult.status === "fulfilled") {
+      const app = unwrapResponseObject(appResult.value, "app");
+      status.remote.appStatus = typeof app.status === "string" ? app.status : null;
+    } else {
+      remoteErrors.push(formatCliErrorDetail(appResult.reason) ?? "Failed to fetch app status.");
     }
-  } else {
-    status.sync.error = formatCliErrorDetail(syncResult.reason) ?? "Failed to fetch sync status.";
-    addBlockedReason(status.sync, "remote_error");
-    addBlockedReason(status.reconcile, "remote_error");
-    addWarning(status, status.sync.error);
+    if (incomingResult.status === "fulfilled") {
+      status.remote.incomingOpenMergeRequestCount = countMergeRequests(
+        unwrapResponseObject(incomingResult.value, "merge requests")
+      );
+    } else {
+      remoteErrors.push(formatCliErrorDetail(incomingResult.reason) ?? "Failed to fetch incoming merge requests.");
+    }
+    if (outgoingResult.status === "fulfilled") {
+      status.remote.outgoingOpenMergeRequestCount = countMergeRequests(
+        unwrapResponseObject(outgoingResult.value, "merge requests")
+      );
+    } else {
+      remoteErrors.push(formatCliErrorDetail(outgoingResult.reason) ?? "Failed to fetch outgoing merge requests.");
+    }
+    status.remote.checked = remoteErrors.length === 0;
+    status.remote.error = remoteErrors.length > 0 ? remoteErrors.join("\n\n") : null;
   }
+  addWarning(status, detected.hint);
+  addWarning(status, status.remote.error);
+  for (const warning of detected.warnings) addWarning(status, warning);
   for (const warning of status.sync.warnings) addWarning(status, warning);
   for (const warning of status.reconcile.warnings) addWarning(status, warning);
-  if (!status.binding.isBound) {
-    status.recommendedAction = "init";
-  } else if (status.sync.canApply && status.sync.status === "ready_to_fast_forward") {
-    status.recommendedAction = "sync";
-  } else if (status.reconcile.canApply && status.reconcile.status === "ready_to_reconcile") {
-    status.recommendedAction = "reconcile";
-  } else if ((status.remote.incomingOpenMergeRequestCount ?? 0) > 0) {
+  if ((status.remote.incomingOpenMergeRequestCount ?? 0) > 0 && status.recommendedAction === "no_action") {
     status.recommendedAction = "review_queue";
-  } else if (status.sync.blockedReasons.includes("family_ambiguous") || status.reconcile.blockedReasons.includes("family_ambiguous")) {
-    status.recommendedAction = "choose_family";
-  } else {
-    status.recommendedAction = "no_action";
   }
   return status;
 }
@@ -3324,7 +4549,13 @@ async function collabSyncUpstream(params) {
       hint: "Run `remix collab init` first."
     });
   }
-  await ensureCleanWorktree(repoRoot, "`remix collab sync-upstream`");
+  await ensureWorkspaceMatchesBaseline({
+    repoRoot,
+    repoFingerprint: binding.repoFingerprint,
+    laneId: binding.laneId,
+    branchName: binding.branchName,
+    operation: "`remix collab sync-upstream`"
+  });
   await requireCurrentBranch(repoRoot);
   const repoSnapshot = await captureRepoSnapshot(repoRoot);
   if (binding.currentAppId === binding.upstreamAppId) {
@@ -3362,7 +4593,13 @@ async function collabSyncUpstream(params) {
         operation: "`remix collab sync-upstream`",
         recoveryHint: "The repository changed while upstream sync was in progress. Review the local changes and rerun `remix collab sync-upstream`."
       });
-      await ensureCleanWorktree(lockedRepoRoot, "`remix collab sync-upstream`");
+      await ensureWorkspaceMatchesBaseline({
+        repoRoot: lockedRepoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        laneId: binding.laneId,
+        branchName: binding.branchName,
+        operation: "`remix collab sync-upstream`"
+      });
       await requireCurrentBranch(lockedRepoRoot);
       const localSync = await collabSync({
         api: params.api,
@@ -3397,7 +4634,6 @@ async function collabView(params) {
   return unwrapMergeRequestReview(resp);
 }
 export {
-  collabAdd,
   collabApprove,
   collabCheckout,
   collabFinalizeTurn,
@@ -3406,8 +4642,8 @@ export {
   collabList,
   collabListMembers,
   collabListMergeRequests,
+  collabReAnchor,
   collabReconcile,
-  collabRecordTurn,
   collabRecordingPreflight,
   collabReject,
   collabRemix,
@@ -3417,6 +4653,8 @@ export {
   collabSyncUpstream,
   collabUpdateMemberRole,
   collabView,
+  drainPendingFinalizeQueue,
   getMemberRolesForScope,
+  processPendingFinalizeJob,
   validateMemberRole
 };