@remixhq/core 0.1.13 → 0.1.14

package/dist/collab.js

@@ -38,6 +38,75 @@ import {
   RemixError
 } from "./chunk-YZ34ICNN.js";
 
+// src/application/collab/appDeltaCache.ts
+var APP_DELTA_CACHE_TTL_MS = 5e3;
+var appDeltaCache = /* @__PURE__ */ new Map();
+var cacheClock = () => Date.now();
+function buildAppDeltaCacheKey(appId, payload) {
+  return [
+    appId,
+    payload.baseHeadHash,
+    payload.targetHeadHash ?? "",
+    payload.localSnapshotHash ?? "",
+    payload.repoFingerprint ?? "",
+    payload.remoteUrl ?? "",
+    payload.defaultBranch ?? ""
+  ].join("|");
+}
+function readAppDeltaCache(key) {
+  const entry = appDeltaCache.get(key);
+  if (!entry) return void 0;
+  if (cacheClock() - entry.cachedAt > APP_DELTA_CACHE_TTL_MS) {
+    appDeltaCache.delete(key);
+    return void 0;
+  }
+  return entry.value;
+}
+function writeAppDeltaCache(key, value) {
+  appDeltaCache.set(key, { value, cachedAt: cacheClock() });
+}
+async function getAppDeltaCached(api, appId, payload) {
+  const key = buildAppDeltaCacheKey(appId, payload);
+  const cached = readAppDeltaCache(key);
+  if (cached !== void 0) return cached;
+  const fresh = await api.getAppDelta(appId, payload);
+  writeAppDeltaCache(key, fresh);
+  return fresh;
+}
+function invalidateAppDeltaCacheForApp(appId) {
+  const prefix = `${appId}|`;
+  for (const key of appDeltaCache.keys()) {
+    if (key.startsWith(prefix)) appDeltaCache.delete(key);
+  }
+}
+
+// src/application/collab/appHeadCache.ts
+var APP_HEAD_CACHE_TTL_MS = 5e3;
+var appHeadCache = /* @__PURE__ */ new Map();
+var cacheClock2 = () => Date.now();
+function readAppHeadCache(appId) {
+  const entry = appHeadCache.get(appId);
+  if (!entry) return void 0;
+  if (cacheClock2() - entry.cachedAt > APP_HEAD_CACHE_TTL_MS) {
+    appHeadCache.delete(appId);
+    return void 0;
+  }
+  return entry.value;
+}
+function writeAppHeadCache(appId, value) {
+  appHeadCache.set(appId, { value, cachedAt: cacheClock2() });
+}
+async function getAppHeadCached(api, appId) {
+  const cached = readAppHeadCache(appId);
+  if (cached !== void 0) return cached;
+  const fresh = await api.getAppHead(appId);
+  writeAppHeadCache(appId, fresh);
+  return fresh;
+}
+function invalidateAppHeadCache(appId) {
+  appHeadCache.delete(appId);
+}
+
 // src/application/collab/branchPolicy.ts
 function describeBranch(value) {
   const normalized = String(value ?? "").trim();
@@ -71,7 +140,8 @@ function assertBoundBranchMatch(params) {
   });
 }
 
-// src/infrastructure/collab/localBaselineStore.ts
+// src/infrastructure/collab/asyncJobStore.ts
+import { randomUUID } from "crypto";
 import fs from "fs/promises";
 import path2 from "path";
 
@@ -110,14 +180,317 @@ function getBaselinesRoot() {
 function getFinalizeQueueRoot() {
   return path.join(getCollabStateRoot(), "finalize-queue");
 }
+function getAsyncJobsRoot() {
+  return path.join(getCollabStateRoot(), "jobs");
+}
+function getAsyncJobDir(jobId) {
+  return path.join(getAsyncJobsRoot(), jobId);
+}
+function getAsyncJobFilePath(jobId) {
+  return path.join(getAsyncJobDir(jobId), "job.json");
+}
+function getAsyncJobBundlePath(jobId) {
+  return path.join(getAsyncJobDir(jobId), "bundle.bundle");
+}
+function getLogsRoot() {
+  return path.join(getCollabStateRoot(), "logs");
+}
+function getDrainerLogPath() {
+  return path.join(getLogsRoot(), "drainer.log");
+}
+function getDrainerPidPath() {
+  return path.join(getCollabStateRoot(), "drainer.pid");
+}
+
+// src/infrastructure/collab/asyncJobStore.ts
+var ASYNC_JOB_LOCK_STALE_MS = 10 * 60 * 1e3;
+var TERMINAL_ASYNC_JOB_RETENTION_MS = 24 * 60 * 60 * 1e3;
+function getJobLockPath(id) {
+  return path2.join(getAsyncJobDir(id), "lock");
+}
+function isTerminalStatus(status) {
+  return status === "completed" || status === "failed";
+}
+function isProcessingStatus(status) {
+  return status === "submitting" || status === "uploading" || status === "server_processing";
+}
+function createEmptySummary() {
+  return {
+    state: "idle",
+    activeJobCount: 0,
+    queuedJobCount: 0,
+    processingJobCount: 0,
+    failedJobCount: 0,
+    oldestCreatedAt: null,
+    newestCreatedAt: null,
+    latestError: null,
+    kinds: []
+  };
+}
+function normalizeJob(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const base = {
+    schemaVersion: 1,
+    id: input.id ?? randomUUID(),
+    kind: input.kind,
+    status: input.status,
+    repoRoot: input.repoRoot,
+    repoFingerprint: input.repoFingerprint ?? null,
+    branchName: input.branchName ?? null,
+    laneId: input.laneId ?? null,
+    createdAt: input.createdAt ?? now,
+    updatedAt: input.updatedAt ?? now,
+    retryCount: Number.isFinite(input.retryCount) ? Math.max(0, Number(input.retryCount)) : 0,
+    error: input.error ?? null,
+    idempotencyKey: input.idempotencyKey ?? null
+  };
+  if (input.kind === "init") {
+    return { ...base, kind: "init", payload: input.payload };
+  }
+  if (input.kind === "init_post") {
+    return { ...base, kind: "init_post", payload: input.payload };
+  }
+  return { ...base, kind: "re_anchor", payload: input.payload };
+}
+async function enqueueAsyncJob(input) {
+  const job = normalizeJob(input);
+  await fs.mkdir(getAsyncJobDir(job.id), { recursive: true });
+  await writeJsonAtomic(getAsyncJobFilePath(job.id), job);
+  return job;
+}
+function parseAsyncJob(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const data = raw;
+  if (data.schemaVersion !== 1) return null;
+  if (typeof data.id !== "string") return null;
+  if (data.kind !== "init" && data.kind !== "init_post" && data.kind !== "re_anchor") return null;
+  if (!data.payload || typeof data.payload !== "object") return null;
+  return data;
+}
+async function readAsyncJob(jobId) {
+  try {
+    const raw = await fs.readFile(getAsyncJobFilePath(jobId), "utf8");
+    const parsed = JSON.parse(raw);
+    return parseAsyncJob(parsed);
+  } catch {
+    return null;
+  }
+}
+async function listAsyncJobs() {
+  const root = getAsyncJobsRoot();
+  let entries;
+  try {
+    entries = await fs.readdir(root, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === "ENOENT") return [];
+    throw error;
+  }
+  const jobs = await Promise.all(
+    entries.filter((entry) => entry.isDirectory()).map((entry) => readAsyncJob(entry.name))
+  );
+  return jobs.filter((job) => Boolean(job)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+async function listAsyncJobsForRepo(params) {
+  const jobs = await listAsyncJobs();
+  return jobs.filter((job) => {
+    if (job.repoRoot !== params.repoRoot) return false;
+    if (params.branchName && job.branchName && job.branchName !== params.branchName) return false;
+    if (params.kind && job.kind !== params.kind) return false;
+    return true;
+  });
+}
+async function findPendingAsyncJob(params) {
+  const jobs = await listAsyncJobsForRepo({
+    repoRoot: params.repoRoot,
+    branchName: params.branchName,
+    kind: params.kind
+  });
+  return jobs.find((job) => !isTerminalStatus(job.status)) ?? null;
+}
+async function findFailedAsyncJob(params) {
+  const jobs = await listAsyncJobsForRepo({
+    repoRoot: params.repoRoot,
+    branchName: params.branchName,
+    kind: params.kind
+  });
+  return jobs.find((job) => job.status === "failed") ?? null;
+}
+async function updateAsyncJob(jobId, update) {
+  const existing = await readAsyncJob(jobId);
+  if (!existing) return null;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (existing.kind === "init") {
+    const nextPayload2 = update.payload ?? existing.payload;
+    const next2 = {
+      ...existing,
+      ...update,
+      schemaVersion: 1,
+      id: existing.id,
+      kind: "init",
+      createdAt: existing.createdAt,
+      updatedAt: now,
+      payload: nextPayload2
+    };
+    await writeJsonAtomic(getAsyncJobFilePath(jobId), next2);
+    return next2;
+  }
+  if (existing.kind === "init_post") {
+    const nextPayload2 = update.payload ?? existing.payload;
+    const next2 = {
+      ...existing,
+      ...update,
+      schemaVersion: 1,
+      id: existing.id,
+      kind: "init_post",
+      createdAt: existing.createdAt,
+      updatedAt: now,
+      payload: nextPayload2
+    };
+    await writeJsonAtomic(getAsyncJobFilePath(jobId), next2);
+    return next2;
+  }
+  const nextPayload = update.payload ?? existing.payload;
+  const next = {
+    ...existing,
+    ...update,
+    schemaVersion: 1,
+    id: existing.id,
+    kind: "re_anchor",
+    createdAt: existing.createdAt,
+    updatedAt: now,
+    payload: nextPayload
+  };
+  await writeJsonAtomic(getAsyncJobFilePath(jobId), next);
+  return next;
+}
+async function deleteAsyncJob(jobId) {
+  await fs.rm(getAsyncJobDir(jobId), { recursive: true, force: true });
+}
+async function acquireJobLock(jobId) {
+  const lockPath = getJobLockPath(jobId);
+  await fs.mkdir(getAsyncJobDir(jobId), { recursive: true });
+  try {
+    await fs.mkdir(lockPath);
+    return true;
+  } catch (error) {
+    if (error?.code !== "EEXIST") throw error;
+  }
+  try {
+    const stat = await fs.stat(lockPath);
+    if (Date.now() - stat.mtimeMs < ASYNC_JOB_LOCK_STALE_MS) return false;
+    await fs.rm(lockPath, { recursive: true, force: true });
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+  }
+  try {
+    await fs.mkdir(lockPath);
+    return true;
+  } catch (error) {
+    if (error?.code === "EEXIST") return false;
+    throw error;
+  }
+}
+async function claimAsyncJob(jobId) {
+  const acquired = await acquireJobLock(jobId);
+  if (!acquired) return null;
+  const lockPath = getJobLockPath(jobId);
+  let released = false;
+  const release = async () => {
+    if (released) return;
+    released = true;
+    await fs.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+  };
+  try {
+    const job = await readAsyncJob(jobId);
+    if (!job) {
+      await release();
+      return null;
+    }
+    if (isTerminalStatus(job.status)) {
+      await release();
+      return null;
+    }
+    return { job, release };
+  } catch (error) {
+    await release();
+    throw error;
+  }
+}
+async function summarizeAsyncJobs(params) {
+  const jobs = await listAsyncJobsForRepo({ repoRoot: params.repoRoot, branchName: params.branchName ?? null });
+  const active = jobs.filter((job) => !isTerminalStatus(job.status) || job.status === "failed");
+  const summary = createEmptySummary();
+  if (active.length === 0) return summary;
+  const kinds = /* @__PURE__ */ new Set();
+  for (const job of active) {
+    kinds.add(job.kind);
+    if (job.error) summary.latestError = job.error;
+    if (job.status === "failed") {
+      summary.failedJobCount += 1;
+    } else if (isProcessingStatus(job.status)) {
+      summary.processingJobCount += 1;
+    } else {
+      summary.queuedJobCount += 1;
+    }
+  }
+  summary.activeJobCount = summary.queuedJobCount + summary.processingJobCount;
+  summary.kinds = Array.from(kinds);
+  summary.oldestCreatedAt = active[0]?.createdAt ?? null;
+  summary.newestCreatedAt = active[active.length - 1]?.createdAt ?? null;
+  if (summary.processingJobCount > 0) summary.state = "processing";
+  else if (summary.queuedJobCount > 0) summary.state = "queued";
+  else if (summary.failedJobCount > 0) summary.state = "failed";
+  return summary;
+}
+async function pruneTerminalAsyncJobs() {
+  const jobs = await listAsyncJobs();
+  const now = Date.now();
+  await Promise.all(
+    jobs.filter((job) => {
+      if (!isTerminalStatus(job.status)) return false;
+      const updated = Date.parse(job.updatedAt);
+      if (!Number.isFinite(updated)) return true;
+      return now - updated >= TERMINAL_ASYNC_JOB_RETENTION_MS;
+    }).map((job) => deleteAsyncJob(job.id))
+  );
+}
+async function awaitAsyncJob(params) {
+  const pollIntervalMs = Math.max(50, params.pollIntervalMs ?? 500);
+  const deadline = Date.now() + params.timeoutMs;
+  let lastSeen = null;
+  while (Date.now() < deadline) {
+    const job = await readAsyncJob(params.jobId);
+    if (job) {
+      lastSeen = job;
+      if (job.status === "completed") return { status: "completed", job };
+      if (job.status === "failed") return { status: "failed", job };
+    } else if (lastSeen) {
+      return { status: "timeout", job: lastSeen };
+    } else {
+      return { status: "timeout", job: null };
+    }
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) break;
+    await new Promise((resolve) => setTimeout(resolve, Math.min(pollIntervalMs, remaining)));
+  }
+  const final = await readAsyncJob(params.jobId);
+  if (final) {
+    if (final.status === "completed") return { status: "completed", job: final };
+    if (final.status === "failed") return { status: "failed", job: final };
+    return { status: "timeout", job: final };
+  }
+  return { status: "timeout", job: lastSeen };
+}
 
 // src/infrastructure/collab/localBaselineStore.ts
+import fs2 from "fs/promises";
+import path3 from "path";
 function getBaselinePath(params) {
-  return path2.join(getBaselinesRoot(), `${buildLaneStateKey(params)}.json`);
+  return path3.join(getBaselinesRoot(), `${buildLaneStateKey(params)}.json`);
 }
 async function readLocalBaseline(params) {
   try {
-    const raw = await fs.readFile(getBaselinePath(params), "utf8");
+    const raw = await fs2.readFile(getBaselinePath(params), "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") return null;
     if (parsed.schemaVersion !== 1 || typeof parsed.key !== "string" || typeof parsed.repoRoot !== "string") {
@@ -162,19 +535,19 @@ async function writeLocalBaseline(baseline) {
 }
 
 // src/infrastructure/collab/localSnapshotStore.ts
-import { createHash as createHash2, randomUUID } from "crypto";
-import fs2 from "fs/promises";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
+import fs3 from "fs/promises";
 import os2 from "os";
-import path3 from "path";
+import path4 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`);
+  return path4.join(getSnapshotRecordsRoot(), `${snapshotId}.json`);
 }
 function getBlobPath(blobHash) {
-  return path3.join(getSnapshotBlobsRoot(), blobHash.slice(0, 2), blobHash);
+  return path4.join(getSnapshotBlobsRoot(), blobHash.slice(0, 2), blobHash);
 }
 async function runGitZ(args, cwd) {
   const res = await execa("git", args, {
@@ -191,9 +564,9 @@ async function listWorkspaceFiles(repoRoot) {
   for (const entry of raw.split("\0")) {
     const relativePath = entry.trim();
     if (!relativePath || seen.has(relativePath)) continue;
-    const absolutePath = path3.join(repoRoot, relativePath);
+    const absolutePath = path4.join(repoRoot, relativePath);
     try {
-      const stat = await fs2.lstat(absolutePath);
+      const stat = await fs3.lstat(absolutePath);
       if (stat.isFile() || stat.isSymbolicLink()) {
         seen.add(relativePath);
         result.push(relativePath);
@@ -206,13 +579,13 @@ async function listWorkspaceFiles(repoRoot) {
 async function persistBlob(blobHash, content) {
   const blobPath = getBlobPath(blobHash);
   try {
-    await fs2.access(blobPath);
+    await fs3.access(blobPath);
   } catch {
-    await fs2.mkdir(path3.dirname(blobPath), { recursive: true });
+    await fs3.mkdir(path4.dirname(blobPath), { recursive: true });
     if (typeof content === "string") {
-      await fs2.writeFile(blobPath, content, "utf8");
+      await fs3.writeFile(blobPath, content, "utf8");
     } else {
-      await fs2.writeFile(blobPath, content);
+      await fs3.writeFile(blobPath, content);
     }
   }
 }
@@ -225,10 +598,10 @@ async function inspectLocalSnapshot(params) {
   const files = await listWorkspaceFiles(repoRoot);
   const manifest = [];
   for (const relativePath of files) {
-    const absolutePath = path3.join(repoRoot, relativePath);
-    const stat = await fs2.lstat(absolutePath);
+    const absolutePath = path4.join(repoRoot, relativePath);
+    const stat = await fs3.lstat(absolutePath);
     if (stat.isSymbolicLink()) {
-      const linkTarget = await fs2.readlink(absolutePath);
+      const linkTarget = await fs3.readlink(absolutePath);
       const blobHash2 = sha256Hex2(`symlink:${linkTarget}`);
       if (params.persistBlobs !== false) {
         await persistBlob(blobHash2, linkTarget);
@@ -241,7 +614,7 @@ async function inspectLocalSnapshot(params) {
       });
       continue;
     }
-    const content = await fs2.readFile(absolutePath);
+    const content = await fs3.readFile(absolutePath);
     const blobHash = sha256Hex2(content);
     if (params.persistBlobs !== false) {
       await persistBlob(blobHash, content);
@@ -269,7 +642,7 @@ async function captureLocalSnapshot(params) {
   const inspection = await inspectLocalSnapshot({ ...params, persistBlobs: true });
   const snapshot = {
     schemaVersion: 1,
-    id: randomUUID(),
+    id: randomUUID2(),
     ...inspection
   };
   await writeJsonAtomic(getSnapshotRecordPath(snapshot.id), snapshot);
@@ -278,7 +651,7 @@ async function captureLocalSnapshot(params) {
 async function readLocalSnapshot(snapshotId) {
   if (!snapshotId) return null;
   try {
-    const raw = await fs2.readFile(getSnapshotRecordPath(snapshotId), "utf8");
+    const raw = await fs3.readFile(getSnapshotRecordPath(snapshotId), "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || parsed.schemaVersion !== 1) return null;
     return parsed;
@@ -288,71 +661,71 @@ async function readLocalSnapshot(snapshotId) {
 }
 async function materializeLocalSnapshot(snapshotId, targetDir) {
   const snapshot = await readLocalSnapshot(snapshotId);
-  await fs2.mkdir(targetDir, { recursive: true });
+  await fs3.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 destination = path4.join(targetDir, entry.path);
+    await fs3.mkdir(path4.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);
+      const linkTarget = await fs3.readFile(blobPath, "utf8");
+      await fs3.symlink(linkTarget, destination);
       continue;
     }
-    await fs2.copyFile(blobPath, destination);
+    await fs3.copyFile(blobPath, destination);
     if (entry.mode === "executable") {
-      await fs2.chmod(destination, 493);
+      await fs3.chmod(destination, 493);
     }
   }
 }
 async function pruneEmptyParentDirectories(repoRoot, filePath) {
-  let current = path3.dirname(filePath);
+  let current = path4.dirname(filePath);
   while (current !== repoRoot) {
-    const entries = await fs2.readdir(current).catch(() => null);
+    const entries = await fs3.readdir(current).catch(() => null);
     if (!entries || entries.length > 0) return;
-    await fs2.rmdir(current).catch(() => void 0);
-    current = path3.dirname(current);
+    await fs3.rmdir(current).catch(() => void 0);
+    current = path4.dirname(current);
   }
 }
 async function restoreLocalSnapshotToWorktree(snapshotId, repoRoot) {
   const snapshot = await readLocalSnapshot(snapshotId);
-  await fs2.mkdir(repoRoot, { recursive: true });
+  await fs3.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);
+    const absolutePath = path4.join(repoRoot, relativePath);
+    await fs3.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 destination = path4.join(repoRoot, entry.path);
+    await fs3.mkdir(path4.dirname(destination), { recursive: true });
+    await fs3.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);
+      const linkTarget = await fs3.readFile(blobPath, "utf8");
+      await fs3.symlink(linkTarget, destination);
       continue;
     }
-    await fs2.copyFile(blobPath, destination);
+    await fs3.copyFile(blobPath, destination);
     if (entry.mode === "executable") {
-      await fs2.chmod(destination, 493);
+      await fs3.chmod(destination, 493);
     }
   }
 }
 async function clearDirectoryExceptGit(targetDir) {
-  const entries = await fs2.readdir(targetDir, { withFileTypes: true });
+  const entries = await fs3.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 });
+    await fs3.rm(path4.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 });
+  const tempRoot = await fs3.mkdtemp(path4.join(os2.tmpdir(), "remix-snapshot-diff-"));
+  const repoDir = path4.join(tempRoot, "repo");
+  await fs3.mkdir(repoDir, { recursive: true });
   try {
     await materializeLocalSnapshot(params.baseSnapshotId, repoDir);
     await execa("git", ["init"], { cwd: repoDir, stderr: "ignore" });
@@ -388,21 +761,22 @@ async function diffLocalSnapshots(params) {
       stats: summarizeUnifiedDiff(diff)
     };
   } finally {
-    await fs2.rm(tempRoot, { recursive: true, force: true });
+    await fs3.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;
+import { randomUUID as randomUUID3 } from "crypto";
+import fs4 from "fs/promises";
+import path5 from "path";
+var FINALIZE_JOB_LOCK_STALE_MS = 90 * 1e3;
+var FINALIZE_ATTEMPT_STALE_MS = 10 * 60 * 1e3;
 var TERMINAL_FINALIZE_JOB_RETENTION_MS = 24 * 60 * 60 * 1e3;
 function getJobPath(id) {
-  return path4.join(getFinalizeQueueRoot(), `${id}.json`);
+  return path5.join(getFinalizeQueueRoot(), `${id}.json`);
 }
-function getJobLockPath(id) {
-  return path4.join(getFinalizeQueueRoot(), `${id}.lock`);
+function getJobLockPath2(id) {
+  return path5.join(getFinalizeQueueRoot(), `${id}.lock`);
 }
 function isPastDue(isoTimestamp) {
   if (!isoTimestamp) return true;
@@ -414,7 +788,7 @@ function isStaleAttempt(job) {
   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;
+  return Date.now() - parsed >= FINALIZE_ATTEMPT_STALE_MS;
 }
 function readMetadataDisposition(job) {
   const value = job.metadata.failureDisposition;
@@ -443,6 +817,7 @@ function createEmptyPendingFinalizeQueueSummary() {
     queuedJobCount: 0,
     processingJobCount: 0,
     retryScheduledJobCount: 0,
+    awaitingUsageJobCount: 0,
     failedJobCount: 0,
     oldestCapturedAt: null,
     newestCapturedAt: null,
@@ -450,10 +825,10 @@ function createEmptyPendingFinalizeQueueSummary() {
     latestError: null
   };
 }
-async function acquireJobLock(jobId) {
-  const lockPath = getJobLockPath(jobId);
+async function acquireJobLock2(jobId) {
+  const lockPath = getJobLockPath2(jobId);
   try {
-    await fs3.mkdir(lockPath);
+    await fs4.mkdir(lockPath);
     return true;
   } catch (error) {
     if (error?.code !== "EEXIST") {
@@ -461,18 +836,18 @@ async function acquireJobLock(jobId) {
     }
   }
   try {
-    const stat = await fs3.stat(lockPath);
+    const stat = await fs4.stat(lockPath);
     if (Date.now() - stat.mtimeMs < FINALIZE_JOB_LOCK_STALE_MS) {
       return false;
     }
-    await fs3.rm(lockPath, { recursive: true, force: true });
+    await fs4.rm(lockPath, { recursive: true, force: true });
   } catch (error) {
     if (error?.code !== "ENOENT") {
       throw error;
     }
   }
   try {
-    await fs3.mkdir(lockPath);
+    await fs4.mkdir(lockPath);
     return true;
   } catch (error) {
     if (error?.code === "EEXIST") {
@@ -481,11 +856,52 @@ async function acquireJobLock(jobId) {
     throw error;
   }
 }
-function normalizeJob(input) {
+async function heartbeatJobLock(jobId) {
+  const lockPath = getJobLockPath2(jobId);
+  const now = /* @__PURE__ */ new Date();
+  try {
+    await fs4.utimes(lockPath, now, now);
+  } catch {
+  }
+}
+async function cleanStaleFinalizeJobLocks() {
+  const removed = [];
+  const skipped = [];
+  const errors = [];
+  let entries;
+  try {
+    const dirents = await fs4.readdir(getFinalizeQueueRoot(), { withFileTypes: true });
+    entries = dirents.map((d) => ({ name: d.name, isDir: d.isDirectory() }));
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return { removed, skipped, errors };
+    }
+    throw error;
+  }
+  for (const entry of entries) {
+    if (!entry.isDir || !entry.name.endsWith(".lock")) continue;
+    const jobId = entry.name.replace(/\.lock$/, "");
+    const lockPath = path5.join(getFinalizeQueueRoot(), entry.name);
+    try {
+      const stat = await fs4.stat(lockPath);
+      const ageMs = Date.now() - stat.mtimeMs;
+      if (ageMs < FINALIZE_JOB_LOCK_STALE_MS) {
+        skipped.push({ jobId, reason: `fresh (age=${Math.round(ageMs / 1e3)}s)` });
+        continue;
+      }
+      await fs4.rm(lockPath, { recursive: true, force: true });
+      removed.push(jobId);
+    } catch (error) {
+      errors.push({ jobId, error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return { removed, skipped, errors };
+}
+function normalizeJob2(input) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
     schemaVersion: 1,
-    id: input.id ?? randomUUID2(),
+    id: input.id ?? randomUUID3(),
     status: input.status,
     repoRoot: input.repoRoot,
     repoFingerprint: input.repoFingerprint ?? null,
@@ -509,16 +925,16 @@ function normalizeJob(input) {
   };
 }
 async function enqueuePendingFinalizeJob(input) {
-  const job = normalizeJob(input);
+  const job = normalizeJob2(input);
   await writeJsonAtomic(getJobPath(job.id), job);
   return job;
 }
 async function readPendingFinalizeJob(jobId) {
   try {
-    const raw = await fs3.readFile(getJobPath(jobId), "utf8");
+    const raw = await fs4.readFile(getJobPath(jobId), "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || parsed.schemaVersion !== 1 || typeof parsed.id !== "string") return null;
-    return normalizeJob({
+    return normalizeJob2({
       id: parsed.id,
       status: parsed.status ?? "queued",
       repoRoot: String(parsed.repoRoot ?? ""),
@@ -547,7 +963,7 @@ async function readPendingFinalizeJob(jobId) {
 }
 async function listPendingFinalizeJobs() {
   try {
-    const entries = await fs3.readdir(getFinalizeQueueRoot(), { withFileTypes: true });
+    const entries = await fs4.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$/, "")))
     );
@@ -588,18 +1004,24 @@ async function summarizePendingFinalizeJobs(scope) {
       continue;
     }
     if (!isPastDue(job.nextRetryAt)) {
-      summary.retryScheduledJobCount += 1;
+      if (job.retryCount === 0 && !job.error) {
+        summary.awaitingUsageJobCount += 1;
+      } else {
+        summary.retryScheduledJobCount += 1;
+      }
       continue;
     }
     summary.queuedJobCount += 1;
   }
-  summary.activeJobCount = summary.queuedJobCount + summary.processingJobCount + summary.retryScheduledJobCount;
+  summary.activeJobCount = summary.queuedJobCount + summary.processingJobCount + summary.retryScheduledJobCount + summary.awaitingUsageJobCount;
   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.awaitingUsageJobCount > 0) {
+    summary.state = "awaiting_usage";
   } else if (summary.failedJobCount > 0) {
     summary.state = "failed";
   }
@@ -621,14 +1043,14 @@ async function updatePendingFinalizeJob(jobId, update) {
   return next;
 }
 async function claimPendingFinalizeJob(jobId) {
-  const lockPath = getJobLockPath(jobId);
-  const lockAcquired = await acquireJobLock(jobId);
+  const lockPath = getJobLockPath2(jobId);
+  const lockAcquired = await acquireJobLock2(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);
+    await fs4.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
   };
   try {
     let existing = await readPendingFinalizeJob(jobId);
@@ -679,13 +1101,35 @@ async function claimPendingFinalizeJob(jobId) {
 }
 async function removePendingFinalizeJob(jobId) {
   try {
-    await fs3.unlink(getJobPath(jobId));
+    await fs4.unlink(getJobPath(jobId));
   } catch (error) {
     if (error?.code !== "ENOENT") {
       throw error;
     }
   }
-  await fs3.rm(getJobLockPath(jobId), { recursive: true, force: true }).catch(() => void 0);
+  await fs4.rm(getJobLockPath2(jobId), { recursive: true, force: true }).catch(() => void 0);
+}
+var forgetPendingFinalizeJob = removePendingFinalizeJob;
+async function requeuePendingFinalizeJob(jobId) {
+  const existing = await readPendingFinalizeJob(jobId);
+  if (!existing) return null;
+  await fs4.rm(getJobLockPath2(jobId), { recursive: true, force: true }).catch(() => void 0);
+  return updatePendingFinalizeJob(jobId, {
+    status: "queued",
+    error: null,
+    nextRetryAt: null,
+    metadata: {
+      // Reset the auto-terminal counter so an operator-initiated retry gets
+      // a fresh budget instead of being escalated to "failed" on the very
+      // next attempt.
+      consecutiveFailures: 0,
+      consecutiveFailureReason: null,
+      // Clear any previous terminal disposition so claim doesn't short-circuit.
+      failureDisposition: null,
+      failureReason: null,
+      requeuedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  });
 }
 
 // src/application/collab/shared.ts
@@ -811,6 +1255,52 @@ async function pollAppReady(api, appId) {
   }
   throw new RemixError("Timed out waiting for app to become ready.", { exitCode: 1 });
 }
+var DEFAULT_APP_IMPORTED_TIMEOUT_MS = 6e4;
+var APP_IMPORTED_SLOW_WARNING_MS = 3e4;
+function resolveImportedTimeoutMs(override) {
+  if (typeof override === "number" && Number.isFinite(override) && override > 0) return override;
+  const fromEnv = Number(process.env.REMIX_INIT_POLL_TIMEOUT_MS);
+  if (Number.isFinite(fromEnv) && fromEnv > 0) return fromEnv;
+  return DEFAULT_APP_IMPORTED_TIMEOUT_MS;
+}
+async function pollAppImported(api, appId, opts) {
+  const timeoutMs = resolveImportedTimeoutMs(opts?.timeoutMs);
+  const slowWarningMs = opts?.slowWarningMs ?? APP_IMPORTED_SLOW_WARNING_MS;
+  const started = Date.now();
+  let delay = 500;
+  let warnedSlow = false;
+  while (Date.now() - started < timeoutMs) {
+    const appResp = await api.getApp(appId);
+    const app = unwrapResponseObject(appResp, "app");
+    const status = typeof app.status === "string" ? app.status : "";
+    if (status === "error") {
+      throw new RemixError("App is in error state.", {
+        exitCode: 1,
+        hint: typeof app.statusError === "string" ? app.statusError : null
+      });
+    }
+    const headCommitId = typeof app.headCommitId === "string" ? app.headCommitId : null;
+    if (headCommitId) return app;
+    const elapsed = Date.now() - started;
+    if (!warnedSlow && elapsed >= slowWarningMs) {
+      warnedSlow = true;
+      const onSlow = opts?.onSlow;
+      if (onSlow) {
+        onSlow(elapsed);
+      } else {
+        console.warn(
+          `[remix init] still waiting for app import (>${Math.round(elapsed / 1e3)}s); will time out at ${Math.round(timeoutMs / 1e3)}s`
+        );
+      }
+    }
+    await sleep(delay);
+    delay = Math.min(2e3, Math.floor(delay * 1.4));
+  }
+  throw new RemixError("Timed out waiting for app to be imported.", {
+    exitCode: 1,
+    hint: `head_commit_id was not set within ${Math.round(timeoutMs / 1e3)}s. The backend import worker may have hung; check the app's status in the dashboard, or set REMIX_INIT_POLL_TIMEOUT_MS to a higher value if the bundle is unusually large.`
+  });
+}
 async function pollChangeStep(api, appId, changeStepId) {
   const started = Date.now();
   let delay = 1500;
@@ -997,8 +1487,39 @@ function buildAmbiguousResolution(params) {
     defaultBranch: params.lane.defaultBranch ?? params.state.defaultBranch
   };
 }
+var RESOLUTION_CACHE_TTL_MS = 5e3;
+var resolutionCache = /* @__PURE__ */ new Map();
+var cacheClock3 = () => Date.now();
+function buildResolutionCacheKey(params) {
+  return `${params.repoRoot}|${params.currentBranch ?? ""}|${params.hasApi ? "1" : "0"}`;
+}
+function readResolutionCache(key) {
+  const entry = resolutionCache.get(key);
+  if (!entry) return null;
+  if (cacheClock3() - entry.cachedAt > RESOLUTION_CACHE_TTL_MS) {
+    resolutionCache.delete(key);
+    return null;
+  }
+  return entry.resolution;
+}
+function writeResolutionCache(key, resolution) {
+  if (resolution.status !== "resolved") return;
+  resolutionCache.set(key, { resolution, cachedAt: cacheClock3() });
+}
 async function resolveActiveLaneBinding(params) {
   const state = await readCollabBindingState(params.repoRoot);
+  const cacheKey = buildResolutionCacheKey({
+    repoRoot: params.repoRoot,
+    currentBranch: state ? normalizeBranchName(state.currentBranch) : null,
+    hasApi: Boolean(params.api)
+  });
+  const cached = readResolutionCache(cacheKey);
+  if (cached) return cached;
+  const resolution = await resolveActiveLaneBindingUncached(params, state);
+  writeResolutionCache(cacheKey, resolution);
+  return resolution;
+}
+async function resolveActiveLaneBindingUncached(params, state) {
   if (!state) {
     return { status: "not_bound", currentBranch: null };
   }
@@ -1189,12 +1710,24 @@ function buildBaseState() {
       queuedJobCount: 0,
       processingJobCount: 0,
       retryScheduledJobCount: 0,
+      awaitingUsageJobCount: 0,
       failedJobCount: 0,
       oldestCapturedAt: null,
       newestCapturedAt: null,
       nextRetryAt: null,
       latestError: null
     },
+    pendingAsyncJobs: {
+      state: "idle",
+      activeJobCount: 0,
+      queuedJobCount: 0,
+      processingJobCount: 0,
+      failedJobCount: 0,
+      oldestCreatedAt: null,
+      newestCreatedAt: null,
+      latestError: null,
+      kinds: []
+    },
     warnings: [],
     hint: null,
     metadataWarnings: [],
@@ -1273,7 +1806,7 @@ async function collabDetectRepoState(params) {
     return detected;
   }
   if (!params.api) {
-    const [inspection, pendingFinalize] = await Promise.all([
+    const [inspection, pendingFinalize, pendingAsyncJobs] = await Promise.all([
       inspectLocalSnapshot({
         repoRoot,
         repoFingerprint: binding.repoFingerprint,
@@ -1286,15 +1819,30 @@ async function collabDetectRepoState(params) {
         repoFingerprint: binding.repoFingerprint,
         currentAppId: binding.currentAppId,
         laneId: binding.laneId
-      })
+      }),
+      summarizeAsyncJobs({ repoRoot, branchName: binding.branchName ?? null })
     ]);
     detected.currentSnapshotHash = inspection.snapshotHash;
     detected.pendingFinalize = pendingFinalize;
+    detected.pendingAsyncJobs = pendingAsyncJobs;
     return detected;
   }
   try {
-    const [headResp, inspection, baseline, pendingFinalize] = await Promise.all([
-      params.api.getAppHead(binding.currentAppId),
+    const baseline = await readLocalBaseline({
+      repoFingerprint: binding.repoFingerprint,
+      laneId: binding.laneId,
+      repoRoot
+    });
+    const hasFullBaseline = Boolean(baseline?.lastSnapshotHash && baseline?.lastServerHeadHash);
+    const metadataIdentityPromise = hasFullBaseline ? getAppDeltaCached(params.api, binding.currentAppId, {
+      baseHeadHash: baseline.lastServerHeadHash,
+      targetHeadHash: baseline.lastServerHeadHash,
+      repoFingerprint: binding.repoFingerprint ?? void 0,
+      remoteUrl: binding.remoteUrl ?? void 0,
+      defaultBranch: binding.defaultBranch ?? void 0
+    }) : Promise.resolve(null);
+    const [headResp, inspection, parallelMetadataResp, pendingFinalize, pendingAsyncJobs] = await Promise.all([
+      getAppHeadCached(params.api, binding.currentAppId),
       inspectLocalSnapshot({
         repoRoot,
         repoFingerprint: binding.repoFingerprint,
@@ -1302,23 +1850,21 @@ async function collabDetectRepoState(params) {
         branchName: binding.branchName,
         persistBlobs: false
       }),
-      readLocalBaseline({
-        repoFingerprint: binding.repoFingerprint,
-        laneId: binding.laneId,
-        repoRoot
-      }),
+      metadataIdentityPromise,
       summarizePendingFinalizeJobs({
         repoRoot,
         repoFingerprint: binding.repoFingerprint,
         currentAppId: binding.currentAppId,
         laneId: binding.laneId
-      })
+      }),
+      summarizeAsyncJobs({ repoRoot, branchName: binding.branchName ?? null })
     ]);
     const appHead = unwrapResponseObject(headResp, "app head");
     detected.currentServerHeadHash = appHead.headCommitHash;
     detected.currentServerHeadCommitId = appHead.headCommitId;
     detected.currentSnapshotHash = inspection.snapshotHash;
     detected.pendingFinalize = pendingFinalize;
+    detected.pendingAsyncJobs = pendingAsyncJobs;
     detected.baseline = {
       lastSnapshotId: baseline?.lastSnapshotId ?? null,
       lastSnapshotHash: baseline?.lastSnapshotHash ?? null,
@@ -1362,15 +1908,7 @@ async function collabDetectRepoState(params) {
         "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");
+    const metadataCheck = unwrapResponseObject(parallelMetadataResp, "app delta metadata");
     detected.metadataWarnings = metadataCheck.warnings;
     detected.warnings.push(...metadataCheck.warnings);
     if (metadataCheck.status === "conflict_risk") {
@@ -1404,26 +1942,347 @@ async function collabDetectRepoState(params) {
   }
 }
 
-// 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;
+// src/infrastructure/git/gitEventHarvester.ts
+import { execa as execa2 } from "execa";
+var GIT_TIMEOUT_MS = 1e4;
+var GIT_MAX_BUFFER = 64 * 1024 * 1024;
+var MAX_COMMITS = 100;
+var RECORD_SEPARATOR = "";
+var FIELD_SEPARATOR = "";
+var LOG_FORMAT = `${RECORD_SEPARATOR}%H${FIELD_SEPARATOR}%P${FIELD_SEPARATOR}%an${FIELD_SEPARATOR}%ae${FIELD_SEPARATOR}%cn${FIELD_SEPARATOR}%ce${FIELD_SEPARATOR}%aI${FIELD_SEPARATOR}%cI${FIELD_SEPARATOR}%s`;
+function sanitizedEnv() {
+  const env = { ...process.env };
+  delete env.GIT_DIR;
+  delete env.GIT_WORK_TREE;
+  delete env.GIT_COMMON_DIR;
+  delete env.GIT_INDEX_FILE;
+  return env;
+}
+async function runGitEvent(args, cwd) {
+  const res = await execa2("git", args, {
+    cwd,
+    reject: false,
+    stderr: "pipe",
+    timeout: GIT_TIMEOUT_MS,
+    env: sanitizedEnv(),
+    maxBuffer: GIT_MAX_BUFFER
+  });
+  return {
+    exitCode: res.exitCode ?? -1,
+    stdout: String(res.stdout ?? ""),
+    stderr: String(res.stderr ?? ""),
+    timedOut: res.timedOut === true
+  };
 }
-function readMetadataActor(job) {
-  const actor = job.metadata.actor;
-  return actor && typeof actor === "object" ? actor : void 0;
+function parseNumstatLine(line) {
+  const tab1 = line.indexOf("	");
+  if (tab1 < 0) return null;
+  const tab2 = line.indexOf("	", tab1 + 1);
+  if (tab2 < 0) return null;
+  const addedRaw = line.slice(0, tab1);
+  const removedRaw = line.slice(tab1 + 1, tab2);
+  const filePath = line.slice(tab2 + 1);
+  if (!filePath) return null;
+  const added = addedRaw === "-" ? 0 : Number.parseInt(addedRaw, 10);
+  const removed = removedRaw === "-" ? 0 : Number.parseInt(removedRaw, 10);
+  return {
+    added: Number.isFinite(added) ? added : 0,
+    removed: Number.isFinite(removed) ? removed : 0,
+    path: filePath
+  };
 }
-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();
+function parseLogOutput(stdout) {
+  const records = [];
+  const parts = stdout.split(RECORD_SEPARATOR);
+  for (const part of parts) {
+    if (!part) continue;
+    const newlineIdx = part.indexOf("\n");
+    const metadataLine = newlineIdx === -1 ? part : part.slice(0, newlineIdx);
+    const rest = newlineIdx === -1 ? "" : part.slice(newlineIdx + 1);
+    const fields = metadataLine.split(FIELD_SEPARATOR);
+    if (fields.length < 9) continue;
+    const [hash, parentsField, authorName, authorEmail, committerName, committerEmail, authorDateIso, committerDateIso, subject] = fields;
+    const parents = parentsField ? parentsField.split(" ").filter(Boolean) : [];
+    const commit = {
+      hash,
+      parents,
+      authorName,
+      authorEmail,
+      committerName,
+      committerEmail,
+      authorDateIso,
+      committerDateIso,
+      subject,
+      filesChanged: 0,
+      linesAdded: 0,
+      linesRemoved: 0
+    };
+    const touchedPaths = /* @__PURE__ */ new Set();
+    for (const rawLine of rest.split("\n")) {
+      if (!rawLine) continue;
+      const parsed = parseNumstatLine(rawLine);
+      if (!parsed) continue;
+      commit.linesAdded += parsed.added;
+      commit.linesRemoved += parsed.removed;
+      touchedPaths.add(parsed.path);
+    }
+    commit.filesChanged = touchedPaths.size;
+    records.push(commit);
+  }
+  return records;
 }
-function buildFinalizeCliError(params) {
-  const error = new RemixError(params.message, {
-    exitCode: params.exitCode,
-    hint: params.hint
+function buildCommitEvent(raw) {
+  return {
+    hash: raw.hash,
+    shortHash: raw.hash.slice(0, 7),
+    isMerge: raw.parents.length >= 2,
+    parents: raw.parents,
+    author: { name: raw.authorName, email: raw.authorEmail },
+    committer: { name: raw.committerName, email: raw.committerEmail },
+    message: raw.subject,
+    timestamp: raw.authorDateIso,
+    filesChanged: raw.filesChanged,
+    linesAdded: raw.linesAdded,
+    linesRemoved: raw.linesRemoved
+  };
+}
+var MERGE_BRANCH_REGEXES = [
+  /^Merge branch '([^']+)'(?: into .+)?$/,
+  /^Merge remote-tracking branch '([^']+)'(?: into .+)?$/,
+  /^Merge pull request #\d+ from (\S+)$/
+];
+function parseBranchFromMergeMessage(subject) {
+  for (const re of MERGE_BRANCH_REGEXES) {
+    const match = re.exec(subject);
+    if (!match) continue;
+    const raw = match[1];
+    if (!raw) continue;
+    return raw.startsWith("origin/") ? raw.slice("origin/".length) : raw;
+  }
+  return null;
+}
+async function resolveBranchFromNameRev(secondParent, repoRoot) {
+  const res = await runGitEvent(
+    ["name-rev", "--name-only", "--no-undefined", secondParent],
+    repoRoot
+  );
+  if (res.exitCode !== 0 || res.timedOut) return null;
+  let name = res.stdout.trim();
+  if (!name) return null;
+  if (name.startsWith("remotes/origin/")) name = name.slice("remotes/origin/".length);
+  else if (name.startsWith("origin/")) name = name.slice("origin/".length);
+  if (name.includes("~") || name.includes("^") || name.startsWith("tags/") || name === "undefined") return null;
+  return name;
+}
+async function collectUncommittedSummary(repoRoot) {
+  const summary = {
+    filesChanged: 0,
+    linesAdded: 0,
+    linesRemoved: 0,
+    staged: 0,
+    unstaged: 0,
+    untracked: 0
+  };
+  const statusRes = await runGitEvent(["status", "--porcelain=v1"], repoRoot);
+  if (statusRes.exitCode === 0 && !statusRes.timedOut) {
+    const uniquePaths = /* @__PURE__ */ new Set();
+    for (const rawLine of statusRes.stdout.split("\n")) {
+      if (!rawLine) continue;
+      if (rawLine.startsWith("??")) {
+        summary.untracked += 1;
+        uniquePaths.add(rawLine.slice(3));
+        continue;
+      }
+      if (rawLine.length < 3) continue;
+      const indexCode = rawLine.charCodeAt(0);
+      const worktreeCode = rawLine.charCodeAt(1);
+      const indexCh = rawLine[0];
+      const worktreeCh = rawLine[1];
+      const pathPart = rawLine.slice(3);
+      if (indexCh !== " " && indexCode !== 63) summary.staged += 1;
+      if ((worktreeCh === "M" || worktreeCh === "D") && worktreeCode !== 63) summary.unstaged += 1;
+      uniquePaths.add(pathPart);
+    }
+    summary.filesChanged = uniquePaths.size;
+  }
+  const diffRes = await runGitEvent(["diff", "--numstat", "HEAD"], repoRoot);
+  if (diffRes.exitCode === 0 && !diffRes.timedOut) {
+    for (const rawLine of diffRes.stdout.split("\n")) {
+      if (!rawLine) continue;
+      const parsed = parseNumstatLine(rawLine);
+      if (!parsed) continue;
+      summary.linesAdded += parsed.added;
+      summary.linesRemoved += parsed.removed;
+    }
+  }
+  return summary;
+}
+function buildEmptyPreTurnEvents(params) {
+  return {
+    commits: [],
+    merges: [],
+    uncommittedAtFinalize: params.uncommitted,
+    summary: {
+      totalCommits: 0,
+      totalMerges: 0,
+      totalFilesChanged: 0,
+      totalLinesAdded: 0,
+      totalLinesRemoved: 0,
+      elapsedMs: null,
+      truncated: false,
+      rewritten: params.rewritten
+    },
+    range: { fromCommit: params.fromCommit, toCommit: params.toCommit },
+    schemaVersion: 1
+  };
+}
+async function collectPreTurnGitEvents(params) {
+  try {
+    const uncommitted = await collectUncommittedSummary(params.repoRoot);
+    if (!params.fromCommit || params.fromCommit === params.toCommit) {
+      return buildEmptyPreTurnEvents({
+        fromCommit: params.fromCommit,
+        toCommit: params.toCommit,
+        uncommitted,
+        rewritten: false
+      });
+    }
+    const reachabilityRes = await runGitEvent(
+      ["merge-base", "--is-ancestor", params.fromCommit, params.toCommit],
+      params.repoRoot
+    );
+    if (reachabilityRes.timedOut) return null;
+    if (reachabilityRes.exitCode === 1) {
+      return buildEmptyPreTurnEvents({
+        fromCommit: null,
+        toCommit: params.toCommit,
+        uncommitted,
+        rewritten: true
+      });
+    }
+    if (reachabilityRes.exitCode !== 0) return null;
+    const logRes = await runGitEvent(
+      [
+        "log",
+        "--first-parent",
+        "-m",
+        "--numstat",
+        "--no-renames",
+        `--format=${LOG_FORMAT}`,
+        `${params.fromCommit}..${params.toCommit}`
+      ],
+      params.repoRoot
+    );
+    if (logRes.timedOut || logRes.exitCode !== 0) return null;
+    const rawCommits = parseLogOutput(logRes.stdout);
+    const totalCommits = rawCommits.length;
+    const totalMerges = rawCommits.reduce((n, c) => n + (c.parents.length >= 2 ? 1 : 0), 0);
+    const ordered = [...rawCommits].reverse();
+    const truncated = ordered.length > MAX_COMMITS;
+    const kept = truncated ? ordered.slice(ordered.length - MAX_COMMITS) : ordered;
+    const commits = kept.map(buildCommitEvent);
+    const merges = [];
+    for (const raw of rawCommits) {
+      if (raw.parents.length < 2) continue;
+      const secondParent = raw.parents[1];
+      const fromBranchFromMessage = parseBranchFromMergeMessage(raw.subject);
+      const fromBranchFromNameRev = await resolveBranchFromNameRev(secondParent, params.repoRoot);
+      merges.push({
+        hash: raw.hash,
+        shortHash: raw.hash.slice(0, 7),
+        fromBranchFromMessage,
+        fromBranchFromNameRev,
+        fromCommit: secondParent,
+        filesChanged: raw.filesChanged,
+        linesAdded: raw.linesAdded,
+        linesRemoved: raw.linesRemoved,
+        message: raw.subject
+      });
+    }
+    let totalFilesChanged = 0;
+    let totalLinesAdded = 0;
+    let totalLinesRemoved = 0;
+    const diffRes = await runGitEvent(
+      ["diff", "--numstat", "--no-renames", params.fromCommit, params.toCommit],
+      params.repoRoot
+    );
+    if (diffRes.exitCode === 0 && !diffRes.timedOut) {
+      const uniquePaths = /* @__PURE__ */ new Set();
+      for (const rawLine of diffRes.stdout.split("\n")) {
+        if (!rawLine) continue;
+        const parsed = parseNumstatLine(rawLine);
+        if (!parsed) continue;
+        uniquePaths.add(parsed.path);
+        totalLinesAdded += parsed.added;
+        totalLinesRemoved += parsed.removed;
+      }
+      totalFilesChanged = uniquePaths.size;
+    }
+    let elapsedMs = null;
+    if (rawCommits.length > 0) {
+      const committerTimes = rawCommits.map((c) => Date.parse(c.committerDateIso)).filter((t) => Number.isFinite(t));
+      if (committerTimes.length > 0) {
+        const min = Math.min(...committerTimes);
+        const max = Math.max(...committerTimes);
+        elapsedMs = max - min;
+      }
+    }
+    return {
+      // commits[] is a first-parent view: it contains the commits on the
+      // receiving branch plus merges as single entries. Commits that entered
+      // via merges are represented by the MergeEvent, not listed individually.
+      commits,
+      merges,
+      uncommittedAtFinalize: uncommitted,
+      summary: {
+        totalCommits,
+        totalMerges,
+        totalFilesChanged,
+        totalLinesAdded,
+        totalLinesRemoved,
+        elapsedMs,
+        truncated,
+        rewritten: false
+      },
+      range: { fromCommit: params.fromCommit, toCommit: params.toCommit },
+      schemaVersion: 1
+    };
+  } catch (err) {
+    console.warn(
+      `[remix-core] preTurnEvents harvester failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+}
+
+// src/application/collab/collabFinalizeProcessing.ts
+var FINALIZE_RETRY_BASE_DELAY_MS = 15e3;
+var FINALIZE_RETRY_MAX_DELAY_MS = 5 * 60 * 1e3;
+var FINALIZE_JOB_PROCESSING_TIMEOUT_MS_DEFAULT = 90 * 1e3;
+var finalizeJobProcessingTimeoutMs = FINALIZE_JOB_PROCESSING_TIMEOUT_MS_DEFAULT;
+var FINALIZE_LOCK_HEARTBEAT_MS = Math.max(15e3, Math.floor(FINALIZE_JOB_LOCK_STALE_MS / 3));
+var FINALIZE_AUTO_TERMINAL_THRESHOLD = 5;
+function readMetadataString(job, key) {
+  const value = job.metadata[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function readMetadataActor(job) {
+  const actor = job.metadata.actor;
+  return actor && typeof actor === "object" ? actor : void 0;
+}
+function readMetadataTurnUsage(job) {
+  const value = job.metadata.turnUsage;
+  return value && typeof value === "object" ? value : null;
+}
+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();
+}
+function buildFinalizeCliError(params) {
+  const error = new RemixError(params.message, {
+    exitCode: params.exitCode,
+    hint: params.hint
   });
   error.finalizeDisposition = params.disposition;
   error.finalizeReason = params.reason;
@@ -1437,8 +2296,50 @@ function classifyFinalizeError(error) {
     message: error instanceof Error ? error.message : String(error)
   };
 }
-function buildWorkspaceMetadata(params) {
+function runWithFinalizeTimeout(work, jobId) {
+  let timer;
+  const cap = finalizeJobProcessingTimeoutMs;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      reject(
+        buildFinalizeCliError({
+          message: `Finalize job ${jobId} exceeded the ${Math.round(
+            cap / 1e3
+          )}s drainer wall-clock timeout. The slow request will be retried by a future drainer pass.`,
+          exitCode: 1,
+          hint: "If this keeps recurring, run `remix collab finalize-queue list` to inspect the job, then `remix collab finalize-queue forget <id>` to drop it manually.",
+          disposition: "retryable",
+          reason: "processing_timeout"
+        })
+      );
+    }, cap);
+    timer.unref?.();
+  });
+  return Promise.race([work, timeout]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+function startLockHeartbeat(jobId) {
+  const handle = setInterval(() => {
+    void heartbeatJobLock(jobId);
+  }, FINALIZE_LOCK_HEARTBEAT_MS);
+  handle.unref?.();
+  return () => clearInterval(handle);
+}
+function computeFailureEscalation(job, reason) {
+  const previousReason = job.metadata.consecutiveFailureReason;
+  const previousCountRaw = job.metadata.consecutiveFailures;
+  const previousCount = typeof previousCountRaw === "number" && Number.isFinite(previousCountRaw) && previousCountRaw > 0 ? Math.floor(previousCountRaw) : 0;
+  const sameReason = previousReason === reason;
+  const next = sameReason ? previousCount + 1 : 1;
   return {
+    consecutiveFailures: next,
+    consecutiveFailureReason: reason,
+    shouldEscalateToTerminal: next >= FINALIZE_AUTO_TERMINAL_THRESHOLD
+  };
+}
+function buildWorkspaceMetadata(params) {
+  const metadata = {
     branch: params.branchName,
     repoRoot: params.repoRoot,
     remoteUrl: params.remoteUrl,
@@ -1450,126 +2351,202 @@ function buildWorkspaceMetadata(params) {
     currentSnapshotHash: params.currentSnapshotHash,
     localCommitHash: params.localCommitHash,
     repoStateAtCapture: params.repoState,
-    replayedFromBaseHash: params.replayedFromBaseHash ?? null
+    replayedFromBaseHash: params.replayedFromBaseHash ?? null,
+    previousLocalCommitHash: params.previousLocalCommitHash ?? null
   };
+  if (params.preTurnEvents) {
+    metadata.preTurnEvents = params.preTurnEvents;
+  }
+  if (params.turnUsage) {
+    metadata.turnUsage = params.turnUsage;
+  }
+  if (typeof params.promptedAt === "string" && params.promptedAt.trim()) {
+    metadata.promptedAt = params.promptedAt.trim();
+  }
+  return metadata;
+}
+async function harvestPreTurnEvents(repoRoot, fromCommit, toCommit) {
+  if (!toCommit) return null;
+  try {
+    return await collectPreTurnGitEvents({ repoRoot, fromCommit, toCommit });
+  } catch (err) {
+    console.warn(
+      `[remix-core] preTurnEvents harvester threw: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
 }
 async function processClaimedPendingFinalizeJob(params) {
   const job = params.job;
+  const stopHeartbeat = startLockHeartbeat(job.id);
   try {
-    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) {
+    return await runWithFinalizeTimeout(processClaimedPendingFinalizeJobInner(params), job.id);
+  } catch (error) {
+    const classified = classifyFinalizeError(error);
+    const escalation = computeFailureEscalation(job, classified.reason);
+    const finalDisposition = classified.disposition === "terminal" || escalation.shouldEscalateToTerminal ? "terminal" : "retryable";
+    await updatePendingFinalizeJob(job.id, {
+      status: finalDisposition === "terminal" ? "failed" : "queued",
+      error: finalDisposition === "terminal" && escalation.shouldEscalateToTerminal && classified.disposition !== "terminal" ? `${classified.message} (auto-escalated to terminal after ${escalation.consecutiveFailures} consecutive ${classified.reason} failures)` : classified.message,
+      nextRetryAt: finalDisposition === "terminal" ? null : buildNextRetryAt(job.retryCount),
+      metadata: {
+        failureDisposition: finalDisposition,
+        failureReason: classified.reason,
+        consecutiveFailures: escalation.consecutiveFailures,
+        consecutiveFailureReason: escalation.consecutiveFailureReason
+      }
+    });
+    throw error;
+  } finally {
+    stopHeartbeat();
+    await params.release();
+  }
+}
+async function processClaimedPendingFinalizeJobInner(params) {
+  const job = params.job;
+  const [snapshot, baseline, appHeadResp] = await Promise.all([
+    readLocalSnapshot(job.currentSnapshotId),
+    readLocalBaseline({
+      repoFingerprint: job.repoFingerprint,
+      laneId: job.laneId,
+      repoRoot: job.repoRoot
+    }),
+    getAppHeadCached(params.api, 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"
+    });
+  }
+  const baselineDrifted = baseline.lastSnapshotId !== job.baselineSnapshotId || baseline.lastServerHeadHash !== job.baselineServerHeadHash;
+  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 turnUsage = readMetadataTurnUsage(job);
+  const promptedAt = readMetadataString(job, "promptedAt");
+  const previousLocalCommitHash = baseline.lastSeenLocalCommitHash ?? null;
+  const preTurnEvents = await harvestPreTurnEvents(
+    job.repoRoot,
+    previousLocalCommitHash,
+    snapshot.localCommitHash
+  );
+  const diffResult = await diffLocalSnapshots({
+    baseSnapshotId: job.baselineSnapshotId,
+    targetSnapshotId: job.currentSnapshotId
+  });
+  if (!diffResult.diff.trim()) {
+    if (baselineDrifted && snapshot.snapshotHash !== baseline.lastSnapshotHash) {
       throw buildFinalizeCliError({
-        message: "Captured snapshot is missing from the local snapshot store.",
+        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: "snapshot_missing"
+        reason: "baseline_drifted"
       });
     }
-    if (!baseline) {
+    if (appHead.headCommitHash !== job.baselineServerHeadHash) {
       throw buildFinalizeCliError({
-        message: "Local baseline is missing for this queued finalize job.",
+        message: "Server lane changed before a no-diff turn could be recorded.",
         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.",
+        hint: "Pull the server changes locally before recording another no-diff turn.",
         disposition: "terminal",
-        reason: "baseline_drifted"
+        reason: "server_lane_changed"
       });
     }
-    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
-    });
-    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({
+    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,
-        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,
+        remoteUrl,
+        defaultBranch,
+        baselineSnapshotId: job.baselineSnapshotId,
+        currentSnapshotId: job.currentSnapshotId,
+        baselineServerHeadHash: job.baselineServerHeadHash,
+        currentSnapshotHash: snapshot.snapshotHash,
+        localCommitHash: snapshot.localCommitHash,
         repoState,
-        changeStep: null,
-        collabTurn,
-        autoSync: null,
-        warnings: []
-      };
-    }
-    let submissionDiff = diffResult.diff;
-    let submissionBaseHeadHash = job.baselineServerHeadHash;
-    let replayedFromBaseHash = null;
-    if (!submissionBaseHeadHash) {
+        previousLocalCommitHash,
+        preTurnEvents,
+        turnUsage,
+        promptedAt
+      }),
+      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: []
+    };
+  }
+  const localBaselineAdvanced = baseline.lastSnapshotId !== job.baselineSnapshotId;
+  const serverHeadAdvanced = appHead.headCommitHash !== job.baselineServerHeadHash;
+  if (baselineDrifted) {
+    const consistentAdvance = localBaselineAdvanced && serverHeadAdvanced;
+    if (!consistentAdvance) {
       throw buildFinalizeCliError({
-        message: "Baseline server head is missing for this finalize job.",
+        message: `Finalize queue baseline advanced inconsistently before this job was processed (localBaselineAdvanced=${localBaselineAdvanced}, serverHeadAdvanced=${serverHeadAdvanced}, jobBaselineSnapshotId=${job.baselineSnapshotId ?? "null"}, liveBaselineSnapshotId=${baseline.lastSnapshotId ?? "null"}, jobBaselineServerHeadHash=${job.baselineServerHeadHash ?? "null"}, liveBaselineServerHeadHash=${baseline.lastServerHeadHash ?? "null"}, currentAppHeadHash=${appHead.headCommitHash}). This indicates local Remix state diverged from the backend in a way that should not be reachable in normal operation; please report this as a bug.`,
         exitCode: 1,
+        hint: "Run `remix collab status` to inspect, then `remix collab re-anchor` only if the lane has no valid baseline.",
         disposition: "terminal",
-        reason: "baseline_server_head_missing"
+        reason: "baseline_drifted"
       });
     }
-    if (appHead.headCommitHash !== submissionBaseHeadHash) {
+  }
+  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"
+    });
+  }
+  const replayNeeded = appHead.headCommitHash !== submissionBaseHeadHash || baselineDrifted;
+  if (replayNeeded) {
+    try {
       const replayResp = await params.api.startChangeStepReplay(job.currentAppId, {
         prompt: job.prompt,
         assistantResponse: job.assistantResponse,
@@ -1588,7 +2565,11 @@ async function processClaimedPendingFinalizeJob(params) {
           baselineServerHeadHash: job.baselineServerHeadHash,
           currentSnapshotHash: snapshot.snapshotHash,
           localCommitHash: snapshot.localCommitHash,
-          repoState
+          repoState,
+          previousLocalCommitHash,
+          preTurnEvents,
+          turnUsage,
+          promptedAt
         }),
         idempotencyKey: buildDeterministicIdempotencyKey({
           kind: "collab_finalize_turn_replay_v1",
@@ -1606,79 +2587,91 @@ async function processClaimedPendingFinalizeJob(params) {
       submissionDiff = replayDiff.diff;
       replayedFromBaseHash = submissionBaseHeadHash;
       submissionBaseHeadHash = appHead.headCommitHash;
+    } catch (error) {
+      if (error instanceof RemixError && error.finalizeDisposition === void 0) {
+        const detail = error.hint ? `${error.message} (${error.hint})` : error.message;
+        throw buildFinalizeCliError({
+          message: "Server-side replay could not adapt the captured diff to the current server head: " + detail,
+          exitCode: 1,
+          hint: error.hint ?? void 0,
+          disposition: "terminal",
+          reason: "replay_unrecoverable"
+        });
+      }
+      throw error;
     }
-    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
-    });
-    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({
+  }
+  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,
-      repoFingerprint: job.repoFingerprint,
-      laneId: job.laneId,
-      currentAppId: job.currentAppId,
       branchName: job.branchName,
-      lastSnapshotId: snapshot.id,
-      lastSnapshotHash: snapshot.snapshotHash,
-      lastServerHeadHash: nextHead.headCommitHash,
-      lastSeenLocalCommitHash: snapshot.localCommitHash
-    });
-    await updatePendingFinalizeJob(job.id, {
-      status: "completed",
-      metadata: { changeStepId: String(changeStep.id ?? "") }
-    });
-    return {
-      mode: "changed_turn",
-      idempotencyKey: job.idempotencyKey ?? "",
-      queued: false,
-      jobId: job.id,
+      remoteUrl,
+      defaultBranch,
+      baselineSnapshotId: job.baselineSnapshotId,
+      currentSnapshotId: job.currentSnapshotId,
+      baselineServerHeadHash: job.baselineServerHeadHash,
+      currentSnapshotHash: snapshot.snapshotHash,
+      localCommitHash: snapshot.localCommitHash,
       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
-      }
+      replayedFromBaseHash,
+      previousLocalCommitHash,
+      preTurnEvents,
+      turnUsage,
+      promptedAt
+    }),
+    idempotencyKey: job.idempotencyKey ?? void 0
+  });
+  const createdStep = unwrapResponseObject(changeStepResp, "change step");
+  const changeStep = await pollChangeStep(params.api, job.currentAppId, String(createdStep.id));
+  invalidateAppHeadCache(job.currentAppId);
+  invalidateAppDeltaCacheForApp(job.currentAppId);
+  const nextServerHeadHash = typeof changeStep.headCommitHash === "string" ? changeStep.headCommitHash.trim() : "";
+  if (!nextServerHeadHash) {
+    throw buildFinalizeCliError({
+      message: "Backend returned a succeeded change step without a head commit hash.",
+      exitCode: 1,
+      hint: "This is a backend invariant violation; retry will not help. Re-anchor and try again.",
+      disposition: "terminal",
+      reason: "missing_head_commit_hash"
     });
-    throw error;
-  } finally {
-    await params.release();
   }
+  await writeLocalBaseline({
+    repoRoot: job.repoRoot,
+    repoFingerprint: job.repoFingerprint,
+    laneId: job.laneId,
+    currentAppId: job.currentAppId,
+    branchName: job.branchName,
+    lastSnapshotId: snapshot.id,
+    lastSnapshotHash: snapshot.snapshotHash,
+    lastServerHeadHash: nextServerHeadHash,
+    lastSeenLocalCommitHash: snapshot.localCommitHash
+  });
+  await updatePendingFinalizeJob(job.id, {
+    status: "completed",
+    metadata: { changeStepId: String(changeStep.id ?? "") }
+  });
+  return {
+    mode: "changed_turn",
+    idempotencyKey: job.idempotencyKey ?? "",
+    queued: false,
+    jobId: job.id,
+    repoState,
+    changeStep,
+    collabTurn: null,
+    autoSync: null,
+    warnings: []
+  };
 }
 async function processPendingFinalizeJob(params) {
   const claimed = await claimPendingFinalizeJob(params.jobId);
@@ -1715,7 +2708,7 @@ async function enqueueCapturedFinalizeTurn(params) {
     error: null,
     retryCount: 0,
     lastAttemptAt: null,
-    nextRetryAt: null,
+    nextRetryAt: params.nextRetryAt ?? null,
     metadata: params.metadata ?? {}
   });
 }
@@ -1741,6 +2734,7 @@ async function drainPendingFinalizeQueue(params) {
 }
 
 // src/application/collab/collabFinalizeTurn.ts
+var FINALIZE_AWAIT_INIT_POST_TIMEOUT_MS = 6e4;
 function collectWarnings(value) {
   if (!Array.isArray(value)) return [];
   return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
@@ -1769,37 +2763,99 @@ async function collabFinalizeTurn(params) {
       hint: "Finalize turns now capture the real workspace boundary from the local snapshot store."
     });
   }
+  const pendingInit = await findPendingAsyncJob({
+    repoRoot,
+    branchName: binding.branchName ?? null,
+    kind: "init"
+  });
+  if (pendingInit) {
+    throw new RemixError("Cannot finalize a turn while the initial Remix import is still processing.", {
+      exitCode: 2,
+      hint: `Init job ${pendingInit.id} is still in the background queue. Run \`remix collab status\` to check progress.`
+    });
+  }
+  const pendingInitPost = await findPendingAsyncJob({
+    repoRoot,
+    branchName: binding.branchName ?? null,
+    kind: "init_post"
+  });
+  if (pendingInitPost) {
+    const result = await awaitAsyncJob({
+      jobId: pendingInitPost.id,
+      timeoutMs: FINALIZE_AWAIT_INIT_POST_TIMEOUT_MS,
+      pollIntervalMs: 500
+    });
+    if (result.status === "failed") {
+      throw new RemixError("The initial Remix import failed; this turn cannot be recorded.", {
+        exitCode: 2,
+        hint: (result.job?.error ? `Last error: ${result.job.error}
+
+` : "") + "Run `remix collab init` again to retry \u2014 the post-init drainer cleared the local binding so this is safe."
+      });
+    }
+    if (result.status === "timeout") {
+      throw new RemixError("Timed out waiting for the initial Remix import to finish provisioning.", {
+        exitCode: 2,
+        hint: `Init post job ${pendingInitPost.id} did not complete within ${Math.round(
+          FINALIZE_AWAIT_INIT_POST_TIMEOUT_MS / 1e3
+        )}s. Run \`remix collab status\` to check progress, then retry once it reports ready.`
+      });
+    }
+  }
+  const pendingReAnchor = await findPendingAsyncJob({
+    repoRoot,
+    branchName: binding.branchName ?? null,
+    kind: "re_anchor"
+  });
+  if (pendingReAnchor) {
+    throw new RemixError("Cannot finalize a turn while a re-anchor is still processing.", {
+      exitCode: 2,
+      hint: `Re-anchor job ${pendingReAnchor.id} is still in the background queue. Run \`remix collab status\` to check progress.`
+    });
+  }
   const detected = await collabDetectRepoState({
     api: params.api,
     cwd: repoRoot,
     allowBranchMismatch: params.allowBranchMismatch
   });
   if (detected.status === "not_bound") {
-    throw new RemixError("Repository is not bound to Remix.", { exitCode: 2, hint: detected.hint });
+    throw new RemixError("Repository is not bound to Remix.", {
+      code: "not_bound",
+      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 });
+    throw new RemixError(detected.hint || "Current branch is not ready for Remix recording.", {
+      code: detected.status,
+      exitCode: 2,
+      hint: detected.hint
+    });
   }
   if (detected.status === "metadata_conflict" || detected.status === "branch_mismatch") {
     throw new RemixError("Repository must be realigned before finalizing the turn.", {
+      code: detected.status,
       exitCode: 2,
       hint: detected.hint
     });
   }
   if (detected.status === "missing_head" || detected.status === "remote_error") {
     throw new RemixError(detected.hint || "Failed to determine the current repo state.", {
+      code: detected.status,
       exitCode: 1,
       hint: detected.hint
     });
   }
   if (detected.repoState === "server_only_changed") {
     throw new RemixError("Server changes must be pulled locally before finalizing this turn.", {
+      code: "pull_required",
       exitCode: 2,
       hint: detected.hint
     });
   }
   if (detected.repoState === "external_local_base_changed") {
     throw new RemixError("The local checkout must be re-anchored before finalizing this turn.", {
+      code: "re_anchor_required",
       exitCode: 2,
       hint: detected.hint
     });
@@ -1834,6 +2890,8 @@ async function collabFinalizeTurn(params) {
     prompt,
     assistantResponse
   });
+  const awaitingDeadlineMs = typeof params.awaitingUsageDeadlineMs === "number" && params.awaitingUsageDeadlineMs > 0 ? params.awaitingUsageDeadlineMs : null;
+  const nextRetryAt = awaitingDeadlineMs === null ? null : new Date(Date.now() + awaitingDeadlineMs).toISOString();
   const job = await enqueueCapturedFinalizeTurn({
     repoRoot,
     repoFingerprint: binding.repoFingerprint,
@@ -1851,8 +2909,11 @@ async function collabFinalizeTurn(params) {
       remoteUrl: binding.remoteUrl,
       defaultBranch: binding.defaultBranch,
       actor: params.actor ?? null,
-      repoState: detected.repoState
-    }
+      repoState: detected.repoState,
+      turnUsage: params.turnUsage ?? null,
+      promptedAt: typeof params.promptedAt === "string" && params.promptedAt.trim() ? params.promptedAt.trim() : null
+    },
+    nextRetryAt
   });
   return {
     mode,
@@ -1867,6 +2928,37 @@ async function collabFinalizeTurn(params) {
   };
 }
 
+// src/application/collab/finalizePreflightCodes.ts
+var FINALIZE_PREFLIGHT_FAILURE_CODES = [
+  // Repo has no .remix/ binding at all. Fix: `remix collab init`.
+  "not_bound",
+  // Binding file exists but the current branch has no entry. Fix: same as
+  // not_bound — `remix collab init` records this branch into the binding.
+  "branch_binding_missing",
+  // Branch matches multiple lane families (very rare race). Fix: human
+  // investigation; auto-fixers should treat as warn-only.
+  "family_ambiguous",
+  // Local-vs-server metadata diverged on app id / lane id. Fix: human
+  // investigation; auto-fixers should treat as warn-only.
+  "metadata_conflict",
+  // Currently checked-out branch differs from the one in the binding.
+  // Fix: human (either checkout the recorded branch or update binding).
+  "branch_mismatch",
+  // HEAD ref unreadable / git reports an error. Fix: human investigation.
+  "missing_head",
+  "remote_error",
+  // Server has commits we don't. Fix: `remix collab sync` (safe to
+  // auto-run for fast-forward; non-FF refused by the command itself).
+  "pull_required",
+  // Local base hash doesn't match the recorded baseline (force-push,
+  // hard reset, rebase). Fix: `remix collab re-anchor`.
+  "re_anchor_required"
+];
+var CODE_SET = new Set(FINALIZE_PREFLIGHT_FAILURE_CODES);
+function isFinalizePreflightFailureCode(value) {
+  return typeof value === "string" && CODE_SET.has(value);
+}
+
 // src/application/collab/recordingPreflight.ts
 async function collabRecordingPreflight(params) {
   const detected = await collabDetectRepoState({
@@ -1924,9 +3016,9 @@ async function collabRecordingPreflight(params) {
 }
 
 // src/infrastructure/locking/repoMutationLock.ts
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
 import os3 from "os";
-import path5 from "path";
+import path6 from "path";
 var DEFAULT_ACQUIRE_TIMEOUT_MS = 15e3;
 var DEFAULT_STALE_MS = 45e3;
 var DEFAULT_HEARTBEAT_MS = 5e3;
@@ -1949,12 +3041,12 @@ function createOwner(params) {
   };
 }
 async function writeOwnerMetadata(ownerPath, owner) {
-  await fs4.writeFile(ownerPath, `${JSON.stringify(owner, null, 2)}
+  await fs5.writeFile(ownerPath, `${JSON.stringify(owner, null, 2)}
 `, "utf8");
 }
 async function readOwnerMetadata(ownerPath) {
   try {
-    const raw = await fs4.readFile(ownerPath, "utf8");
+    const raw = await fs5.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) {
@@ -1991,23 +3083,23 @@ async function getLastKnownUpdateMs(lockDir, ownerPath, owner) {
   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);
+  const stat = await fs5.stat(ownerPath).catch(() => null);
   if (stat) return stat.mtimeMs;
-  const dirStat = await fs4.stat(lockDir).catch(() => null);
+  const dirStat = await fs5.stat(lockDir).catch(() => null);
   if (dirStat) return dirStat.mtimeMs;
   return 0;
 }
 async function ensureLockDir(lockDir) {
-  await fs4.mkdir(path5.dirname(lockDir), { recursive: true });
+  await fs5.mkdir(path6.dirname(lockDir), { recursive: true });
 }
 async function tryAcquireLock(lockDir, ownerPath, owner) {
   try {
     await ensureLockDir(lockDir);
-    await fs4.mkdir(lockDir);
+    await fs5.mkdir(lockDir);
     try {
       await writeOwnerMetadata(ownerPath, owner);
     } catch (error) {
-      await fs4.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+      await fs5.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
       throw error;
     }
     return true;
@@ -2056,7 +3148,7 @@ async function acquirePhysicalLock(lockDir, ownerPath, owner, options) {
     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);
+      await fs5.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
       continue;
     }
     await sleep2(RETRY_DELAY_MS);
@@ -2081,7 +3173,7 @@ function startHeartbeat(lockDir, ownerPath, owner, heartbeatMs) {
     };
     owner.heartbeatAt = nextOwner.heartbeatAt;
     void writeOwnerMetadata(ownerPath, nextOwner).catch(() => void 0);
-    void fs4.utimes(lockDir, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date()).catch(() => void 0);
+    void fs5.utimes(lockDir, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date()).catch(() => void 0);
   }, heartbeatMs);
 }
 async function releaseReentrantLock(lockDir) {
@@ -2091,12 +3183,12 @@ async function releaseReentrantLock(lockDir) {
   if (held.count > 0) return;
   clearInterval(held.heartbeatTimer);
   heldLocks.delete(lockDir);
-  await fs4.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+  await fs5.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 lockDir = path6.join(gitCommonDir, "remix", "locks", "repo-mutation.lock");
   const owner = createOwner({
     operation: options.operation,
     repoRoot,
@@ -2108,11 +3200,11 @@ async function withRepoMutationLock(options, fn) {
   const existing = heldLocks.get(lockDir);
   let notices = [];
   if (!existing) {
-    notices = await acquirePhysicalLock(lockDir, path5.join(lockDir, "owner.json"), owner, {
+    notices = await acquirePhysicalLock(lockDir, path6.join(lockDir, "owner.json"), owner, {
       acquireTimeoutMs,
       staleMs
     });
-    const ownerPath = path5.join(lockDir, "owner.json");
+    const ownerPath = path6.join(lockDir, "owner.json");
     heldLocks.set(lockDir, {
       count: 1,
       lockDir,
@@ -2224,7 +3316,7 @@ async function collabSync(params) {
     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."
+        hint: "Retry after Git HEAD is available, or run `remix collab re-anchor` if this checkout has no local Remix baseline yet."
       });
     }
     baselineServerHeadHash = headCommitHash;
@@ -2275,7 +3367,7 @@ async function collabSync(params) {
   if (delta.status === "base_unknown") {
     throw new RemixError("Direct pull is unavailable because Remix can no longer diff from the last acknowledged server head.", {
       exitCode: 2,
-      hint: "Run `remix collab reconcile --dry-run` to inspect recovery options before retrying. If this checkout moved independently outside Remix, `remix collab re-anchor` may be required."
+      hint: "Run `remix collab reconcile --dry-run` to inspect recovery options before retrying. If this checkout has no local Remix baseline yet for this lane, `remix collab re-anchor` may be required."
     });
   }
   if (delta.status !== "delta_ready") {
@@ -2418,38 +3510,38 @@ async function collabApprove(params) {
 }
 
 // src/application/collab/checkoutWorkspace.ts
-import fs5 from "fs/promises";
+import fs6 from "fs/promises";
 import os4 from "os";
-import path6 from "path";
+import path7 from "path";
 async function pathExists(targetPath) {
   try {
-    await fs5.access(targetPath);
+    await fs6.access(targetPath);
     return true;
   } catch {
     return false;
   }
 }
 async function statIsDirectory(targetPath) {
-  const stats = await fs5.stat(targetPath).catch(() => null);
+  const stats = await fs6.stat(targetPath).catch(() => null);
   return Boolean(stats?.isDirectory());
 }
 async function findContainingGitRoot(startPath) {
-  let current = path6.resolve(startPath);
+  let current = path7.resolve(startPath);
   while (true) {
-    if (await pathExists(path6.join(current, ".git"))) return current;
-    const parent = path6.dirname(current);
+    if (await pathExists(path7.join(current, ".git"))) return current;
+    const parent = path7.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function isSubpath(parentPath, candidatePath) {
-  const relative = path6.relative(parentPath, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !path6.isAbsolute(relative);
+  const relative = path7.relative(parentPath, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path7.isAbsolute(relative);
 }
 async function resolveCheckoutDestination(params) {
   if (params.outputDir?.trim()) {
-    const preferredRepoRoot = path6.resolve(params.outputDir.trim());
-    const parentDir2 = path6.dirname(preferredRepoRoot);
+    const preferredRepoRoot = path7.resolve(params.outputDir.trim());
+    const parentDir2 = path7.dirname(preferredRepoRoot);
     if (!await statIsDirectory(parentDir2)) {
       throw new RemixError("Remix output parent directory does not exist.", {
         exitCode: 2,
@@ -2462,7 +3554,7 @@ async function resolveCheckoutDestination(params) {
       explicitOutputDir: true
     };
   }
-  const parentDir = path6.resolve(params.cwd);
+  const parentDir = path7.resolve(params.cwd);
   if (!await statIsDirectory(parentDir)) {
     throw new RemixError("Remix output parent directory does not exist.", {
       exitCode: 2,
@@ -2470,7 +3562,7 @@ async function resolveCheckoutDestination(params) {
     });
   }
   return {
-    preferredRepoRoot: path6.join(parentDir, params.defaultDirName),
+    preferredRepoRoot: path7.join(parentDir, params.defaultDirName),
     parentDir,
     explicitOutputDir: false
   };
@@ -2504,11 +3596,11 @@ async function materializeAppCheckout(params) {
     explicitOutputDir: destination.explicitOutputDir
   });
   const repoRoot = destination.explicitOutputDir ? await reserveDirectory(destination.preferredRepoRoot) : await reserveAvailableDirPath(destination.preferredRepoRoot);
-  const bundleTempDir = await fs5.mkdtemp(path6.join(os4.tmpdir(), "remix-checkout-"));
-  const bundlePath = path6.join(bundleTempDir, "repository.bundle");
+  const bundleTempDir = await fs6.mkdtemp(path7.join(os4.tmpdir(), "remix-checkout-"));
+  const bundlePath = path7.join(bundleTempDir, "repository.bundle");
   try {
     const bundle = await params.api.downloadAppBundle(params.appId);
-    await fs5.writeFile(bundlePath, bundle.data);
+    await fs6.writeFile(bundlePath, bundle.data);
     await cloneGitBundleToDirectory(bundlePath, repoRoot);
     if (params.expectedBranchName?.trim()) {
       await checkoutLocalBranch(repoRoot, params.expectedBranchName.trim());
@@ -2518,11 +3610,11 @@ async function materializeAppCheckout(params) {
     }
     await ensureGitInfoExcludeEntries(repoRoot, [".remix/"]);
   } catch (err) {
-    await fs5.rm(repoRoot, { recursive: true, force: true }).catch(() => {
+    await fs6.rm(repoRoot, { recursive: true, force: true }).catch(() => {
     });
     throw err;
   } finally {
-    await fs5.rm(bundleTempDir, { recursive: true, force: true });
+    await fs6.rm(bundleTempDir, { recursive: true, force: true });
   }
   const branchName = await getCurrentBranch(repoRoot) ?? params.expectedBranchName?.trim() ?? null;
   const remoteUrl = normalizeGitRemote(params.expectedRemoteUrl ?? await getRemoteOriginUrl(repoRoot));
@@ -2652,7 +3744,7 @@ async function resolveQueueAppId(params) {
   if (bindingResolution.status === "missing_branch_binding") {
     throw new RemixError("Current branch is not yet bound to a Remix lane.", {
       exitCode: 2,
-      hint: `Switch back to a bound branch or create a lane by recording work on ${bindingResolution.currentBranch ?? "this branch"}.`
+      hint: `Switch back to a bound branch, or run \`remix collab init\` on ${bindingResolution.currentBranch ?? "this branch"} before listing merge requests.`
     });
   }
   if (bindingResolution.status === "binding_conflict") {
@@ -2797,16 +3889,38 @@ async function collabUpdateMemberRole(params) {
 }
 
 // src/application/collab/collabInit.ts
-import fs8 from "fs/promises";
-import path7 from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+import fs10 from "fs/promises";
+import path9 from "path";
+
+// src/infrastructure/collab/drainerLog.ts
+import fs7 from "fs/promises";
+import path8 from "path";
+async function logDrainerEvent(jobId, event, fields = {}) {
+  const entry = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    jobId,
+    event,
+    ...fields
+  };
+  try {
+    await fs7.mkdir(getLogsRoot(), { recursive: true });
+    await fs7.appendFile(getDrainerLogPath(), `${JSON.stringify(entry)}
+`, "utf8");
+  } catch {
+  }
+}
+function drainerLogPath() {
+  return getDrainerLogPath();
+}
 
 // src/shared/hash.ts
 import crypto from "crypto";
-import fs6 from "fs";
+import fs8 from "fs";
 async function sha256FileHex(filePath) {
   const hash = crypto.createHash("sha256");
   await new Promise((resolve, reject) => {
-    const stream = fs6.createReadStream(filePath);
+    const stream = fs8.createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
     stream.on("end", () => resolve());
@@ -2815,15 +3929,15 @@ async function sha256FileHex(filePath) {
 }
 
 // src/shared/upload.ts
-import fs7 from "fs";
+import fs9 from "fs";
 import { PassThrough } from "stream";
 async function uploadPresigned(params) {
-  const stats = await fs7.promises.stat(params.filePath).catch(() => null);
+  const stats = await fs9.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 = fs7.createReadStream(params.filePath);
+  const fileStream = fs9.createReadStream(params.filePath);
   const pass = new PassThrough();
   let sentBytes = 0;
   fileStream.on("data", (chunk) => {
@@ -3122,6 +4236,60 @@ async function collabInit(params) {
       const remoteUrl = persistedRemoteUrl ?? normalizeGitRemote(await getRemoteOriginUrl(repoRoot));
       const repoFingerprint = localBindingState?.repoFingerprint ?? await buildRepoFingerprint({ gitRoot: repoRoot, remoteUrl, defaultBranch });
       const repoSnapshot = await captureRepoSnapshot(repoRoot);
+      if (params.asyncSubmit) {
+        if (params.forceNew) {
+          for (const kind of ["init", "init_post"]) {
+            const existing = await listAsyncJobsForRepo({ repoRoot, branchName, kind });
+            for (const job of existing) {
+              await deleteAsyncJob(job.id);
+              await logDrainerEvent(job.id, "replaced", {
+                kind,
+                reason: "force_new",
+                previousStatus: job.status,
+                previousError: job.error
+              });
+            }
+          }
+        } else {
+          const pendingPost = await findPendingAsyncJob({ repoRoot, branchName, kind: "init_post" });
+          const pending = pendingPost ?? await findPendingAsyncJob({ repoRoot, branchName, kind: "init" });
+          if (pending) {
+            const existingBinding = await readCollabBinding(repoRoot);
+            if (existingBinding && existingBinding.currentAppId) {
+              return {
+                queued: true,
+                jobId: pending.id,
+                repoRoot,
+                projectId: existingBinding.projectId ?? "",
+                appId: existingBinding.currentAppId,
+                upstreamAppId: existingBinding.upstreamAppId ?? existingBinding.currentAppId,
+                dashboardUrl: buildDashboardAppUrl(existingBinding.currentAppId),
+                bindingPath: getCollabBindingPath(repoRoot),
+                bindingMode: existingBinding.bindingMode,
+                createdCanonicalFamily: false,
+                remoteUrl: existingBinding.remoteUrl ?? remoteUrl,
+                defaultBranch: existingBinding.defaultBranch ?? defaultBranch ?? null,
+                ...warnings.length > 0 ? { warnings } : {}
+              };
+            }
+            return {
+              queued: true,
+              jobId: pending.id,
+              repoRoot,
+              projectId: "",
+              appId: "",
+              upstreamAppId: "",
+              dashboardUrl: "",
+              bindingPath: getCollabBindingPath(repoRoot),
+              bindingMode: "lane",
+              createdCanonicalFamily: false,
+              remoteUrl,
+              defaultBranch: defaultBranch ?? null,
+              ...warnings.length > 0 ? { warnings } : {}
+            };
+          }
+        }
+      }
       if (!params.forceNew && localBindingState?.explicitRootBinding && branchName) {
         const explicitRoot = localBindingState.explicitRootBinding;
         const explicitProjectId = explicitRoot.projectId ?? localBindingState.projectId;
@@ -3172,7 +4340,7 @@ async function collabInit(params) {
           boundThreadId2 = canonicalLane2.threadId ?? boundThreadId2;
           boundLaneId2 = canonicalLane2.laneId ?? null;
         }
-        const readyApp = await pollAppReady(params.api, boundCurrentAppId2);
+        const readyApp = await pollAppImported(params.api, boundCurrentAppId2);
         boundProjectId2 = String(readyApp.projectId ?? boundProjectId2);
         boundThreadId2 = readyApp.threadId ? String(readyApp.threadId) : boundThreadId2;
         await assertRepoSnapshotUnchanged(repoRoot, repoSnapshot, {
@@ -3211,7 +4379,7 @@ async function collabInit(params) {
           appId: boundCurrentAppId2,
           dashboardUrl: buildDashboardAppUrl(boundCurrentAppId2),
           upstreamAppId: boundUpstreamAppId2,
-          bindingPath: path7.join(repoRoot, ".remix", "config.json"),
+          bindingPath: path9.join(repoRoot, ".remix", "config.json"),
           repoRoot,
           bindingMode: defaultBranch && branchName !== defaultBranch ? "lane" : "explicit_root",
           createdCanonicalFamily: false,
@@ -3284,7 +4452,7 @@ async function collabInit(params) {
           boundThreadId2 = canonicalLane2.threadId ?? boundThreadId2;
           boundLaneId2 = canonicalLane2.laneId ?? null;
         }
-        const readyApp = await pollAppReady(params.api, boundCurrentAppId2);
+        const readyApp = await pollAppImported(params.api, boundCurrentAppId2);
         boundProjectId2 = String(readyApp.projectId ?? boundProjectId2);
         boundThreadId2 = readyApp.threadId ? String(readyApp.threadId) : boundThreadId2;
         await assertRepoSnapshotUnchanged(repoRoot, repoSnapshot, {
@@ -3413,7 +4581,7 @@ async function collabInit(params) {
             }
           }
           if (boundCurrentAppId2) {
-            const readyApp = await pollAppReady(params.api, boundCurrentAppId2);
+            const readyApp = await pollAppImported(params.api, boundCurrentAppId2);
             boundProjectId2 = String(readyApp.projectId ?? boundProjectId2);
             boundThreadId2 = readyApp.threadId ? String(readyApp.threadId) : boundThreadId2;
           }
@@ -3435,46 +4603,251 @@ async function collabInit(params) {
               bindingMode: "lane"
             });
           }
-          const bindingPath2 = await writeCollabBinding(repoRoot, {
-            projectId: boundProjectId2,
-            currentAppId: boundCurrentAppId2,
-            upstreamAppId: boundUpstreamAppId2,
-            threadId: boundThreadId2,
+          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,
+            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 } : {}
+          };
+        }
+      }
+      if (params.asyncSubmit) {
+        if (!params.forceNew) {
+          const failed = await findFailedAsyncJob({ repoRoot, branchName, kind: "init" });
+          if (failed) {
+            await deleteAsyncJob(failed.id);
+          }
+          const failedPost = await findFailedAsyncJob({ repoRoot, branchName, kind: "init_post" });
+          if (failedPost) {
+            await deleteAsyncJob(failedPost.id);
+          }
+        }
+        const syncPhaseStartedAt = Date.now();
+        const { bundlePath: bundleFilePath, headCommitHash: bundledHeadCommitHash } = await createGitBundle(
+          repoRoot,
+          "repository.bundle"
+        );
+        const tmpBundleDir = path9.dirname(bundleFilePath);
+        try {
+          const bundleSha2 = await sha256FileHex(bundleFilePath);
+          const bundleSize2 = (await fs10.stat(bundleFilePath)).size;
+          const presignResp2 = await params.api.presignImportUploadFirstParty({
+            file: {
+              name: "repository.bundle",
+              mimeType: "application/x-git-bundle",
+              size: bundleSize2,
+              checksumSha256: bundleSha2
+            }
+          });
+          const presign2 = unwrapResponseObject(presignResp2, "upload");
+          await uploadPresigned({
+            uploadUrl: String(presign2.uploadUrl),
+            headers: presign2.headers ?? {},
+            filePath: bundleFilePath
+          });
+          const importResp2 = await params.api.importFromUploadFirstParty({
+            uploadId: String(presign2.uploadId),
+            appName: params.appName?.trim() || path9.basename(repoRoot),
+            platform: "generic",
+            isPublic: false,
+            branch: defaultBranch && branchName && branchName !== defaultBranch ? defaultBranch : currentBranch ?? void 0,
+            remoteUrl: remoteUrl ?? void 0,
+            defaultBranch: defaultBranch ?? void 0,
+            repoFingerprint,
+            headCommitHash: bundledHeadCommitHash,
+            forceNew: params.forceNew
+          });
+          const imported2 = unwrapResponseObject(importResp2, "import");
+          const importedAppId = String(imported2.appId);
+          let boundProjectId2 = String(imported2.projectId ?? "");
+          let boundCurrentAppId2 = importedAppId;
+          let boundUpstreamAppId2 = importedAppId;
+          let boundThreadId2 = imported2.threadId ? String(imported2.threadId) : null;
+          let boundLaneId2 = null;
+          let canonicalLane2 = null;
+          if (branchName) {
+            if (defaultBranch && branchName !== defaultBranch) {
+              canonicalLane2 = await resolveOrEnsureLaneBinding({
+                api: params.api,
+                projectId: boundProjectId2 || void 0,
+                repoFingerprint,
+                remoteUrl,
+                defaultBranch,
+                branchName: defaultBranch,
+                seedAppId: importedAppId,
+                operation: "`remix collab init`"
+              });
+              const lane = await resolveOrEnsureLaneBinding({
+                api: params.api,
+                projectId: canonicalLane2.projectId ?? boundProjectId2 ?? void 0,
+                repoFingerprint,
+                remoteUrl,
+                defaultBranch,
+                branchName,
+                seedHeadCommitHash: bundledHeadCommitHash,
+                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 {
+              const lane = await resolveOrEnsureLaneBinding({
+                api: params.api,
+                projectId: boundProjectId2 || void 0,
+                repoFingerprint,
+                remoteUrl,
+                defaultBranch,
+                branchName,
+                seedAppId: importedAppId,
+                operation: "`remix collab init`"
+              });
+              canonicalLane2 = lane;
+              boundProjectId2 = lane.projectId ?? boundProjectId2;
+              boundCurrentAppId2 = lane.currentAppId ?? boundCurrentAppId2;
+              boundUpstreamAppId2 = lane.upstreamAppId ?? boundUpstreamAppId2;
+              boundThreadId2 = lane.threadId ?? boundThreadId2;
+              boundLaneId2 = lane.laneId ?? null;
+            }
+          }
+          await assertRepoSnapshotUnchanged(repoRoot, repoSnapshot, {
+            operation: "`remix collab init`",
+            recoveryHint: "The repository changed before the Remix binding was written. Review the local changes and rerun `remix collab init`."
+          });
+          const bindingMode2 = params.forceNew && (!defaultBranch || branchName === defaultBranch) ? "explicit_root" : "lane";
+          let bindingPath2;
+          if (params.forceNew && defaultBranch && canonicalLane2) {
+            const canonicalBinding = branchBindingFromLane(canonicalLane2, "explicit_root", {
+              projectId: canonicalLane2.projectId ?? boundProjectId2,
+              currentAppId: canonicalLane2.currentAppId ?? boundCurrentAppId2,
+              upstreamAppId: canonicalLane2.upstreamAppId ?? canonicalLane2.currentAppId ?? boundCurrentAppId2,
+              threadId: canonicalLane2.threadId ?? boundThreadId2
+            });
+            const branchBindings = {
+              [defaultBranch]: canonicalBinding
+            };
+            if (branchName && branchName !== defaultBranch) {
+              branchBindings[branchName] = {
+                projectId: boundProjectId2,
+                currentAppId: boundCurrentAppId2,
+                upstreamAppId: boundUpstreamAppId2,
+                threadId: boundThreadId2,
+                laneId: boundLaneId2,
+                bindingMode: "lane"
+              };
+            }
+            bindingPath2 = await writeCollabBindingSnapshot({
+              repoRoot,
+              repoFingerprint,
+              remoteUrl,
+              defaultBranch,
+              branchBindings,
+              explicitRootBinding: canonicalBinding
+            });
+          } else {
+            if (canonicalLane2 && defaultBranch && branchName && branchName !== defaultBranch) {
+              await writeCollabBinding(repoRoot, {
+                projectId: canonicalLane2.projectId ?? null,
+                currentAppId: canonicalLane2.currentAppId ?? boundCurrentAppId2,
+                upstreamAppId: canonicalLane2.upstreamAppId ?? canonicalLane2.currentAppId ?? boundCurrentAppId2,
+                threadId: canonicalLane2.threadId ?? null,
+                repoFingerprint: canonicalLane2.repoFingerprint ?? repoFingerprint,
+                remoteUrl: canonicalLane2.remoteUrl ?? remoteUrl,
+                defaultBranch: canonicalLane2.defaultBranch ?? defaultBranch,
+                laneId: canonicalLane2.laneId ?? null,
+                branchName: defaultBranch,
+                bindingMode: params.forceNew ? "explicit_root" : "lane"
+              });
+            }
+            bindingPath2 = await writeCollabBinding(repoRoot, {
+              projectId: boundProjectId2,
+              currentAppId: boundCurrentAppId2,
+              upstreamAppId: boundUpstreamAppId2,
+              threadId: boundThreadId2,
+              repoFingerprint,
+              remoteUrl,
+              defaultBranch: defaultBranch ?? null,
+              laneId: boundLaneId2,
+              branchName,
+              bindingMode: bindingMode2
+            });
+          }
+          const syncPhaseFinishedAt = Date.now();
+          const jobId = randomUUID4();
+          const job = await enqueueAsyncJob({
+            id: jobId,
+            kind: "init_post",
+            status: "queued",
+            repoRoot,
             repoFingerprint,
-            remoteUrl,
-            defaultBranch: defaultBranch ?? null,
-            laneId: boundLaneId2,
             branchName,
-            bindingMode: "lane"
+            laneId: boundLaneId2,
+            retryCount: 0,
+            error: null,
+            idempotencyKey: null,
+            payload: {
+              appId: boundCurrentAppId2,
+              syncPhaseStartedAt,
+              syncPhaseFinishedAt
+            }
+          });
+          await logDrainerEvent(job.id, "submitted", {
+            kind: "init_post",
+            appId: boundCurrentAppId2,
+            ["init.sync_phase_ms"]: syncPhaseFinishedAt - syncPhaseStartedAt
           });
           return {
-            reused: true,
+            queued: true,
+            jobId: job.id,
+            repoRoot,
             projectId: boundProjectId2,
             appId: boundCurrentAppId2,
-            dashboardUrl: buildDashboardAppUrl(boundCurrentAppId2),
             upstreamAppId: boundUpstreamAppId2,
+            dashboardUrl: buildDashboardAppUrl(boundCurrentAppId2),
             bindingPath: bindingPath2,
-            repoRoot,
-            bindingMode: "lane",
-            createdCanonicalFamily: false,
-            baselineStatus: await resolveInitBaselineStatus({
-              api: params.api,
-              repoRoot,
-              repoFingerprint,
-              laneId: boundLaneId2,
-              currentAppId: boundCurrentAppId2,
-              upstreamAppId: boundUpstreamAppId2,
-              branchName,
-              remoteUrl,
-              defaultBranch
-            }),
+            bindingMode: bindingMode2,
+            createdCanonicalFamily: Boolean(params.forceNew),
+            remoteUrl,
+            defaultBranch,
             ...warnings.length > 0 ? { warnings } : {}
           };
+        } finally {
+          await fs10.rm(tmpBundleDir, { recursive: true, force: true }).catch(() => void 0);
         }
       }
       const { bundlePath, headCommitHash } = await createGitBundle(repoRoot, "repository.bundle");
       const bundleSha = await sha256FileHex(bundlePath);
-      const bundleSize = (await fs8.stat(bundlePath)).size;
+      const bundleSize = (await fs10.stat(bundlePath)).size;
       const presignResp = await params.api.presignImportUploadFirstParty({
         file: {
           name: "repository.bundle",
@@ -3491,7 +4864,7 @@ async function collabInit(params) {
       });
       const importResp = await params.api.importFromUploadFirstParty({
         uploadId: String(presign.uploadId),
-        appName: params.appName?.trim() || path7.basename(repoRoot),
+        appName: params.appName?.trim() || path9.basename(repoRoot),
         path: params.path?.trim() || void 0,
         platform: "generic",
         isPublic: false,
@@ -3499,10 +4872,11 @@ async function collabInit(params) {
         remoteUrl: remoteUrl ?? void 0,
         defaultBranch: defaultBranch ?? void 0,
         repoFingerprint,
-        headCommitHash
+        headCommitHash,
+        forceNew: params.forceNew
       });
       const imported = unwrapResponseObject(importResp, "import");
-      const app = await pollAppReady(params.api, String(imported.appId));
+      const app = await pollAppImported(params.api, String(imported.appId));
       let boundProjectId = String(app.projectId);
       let boundCurrentAppId = String(app.id);
       let boundUpstreamAppId = String(app.id);
@@ -3556,7 +4930,7 @@ async function collabInit(params) {
         }
       }
       if (boundCurrentAppId) {
-        const readyApp = await pollAppReady(params.api, boundCurrentAppId);
+        const readyApp = await pollAppImported(params.api, boundCurrentAppId);
         boundProjectId = String(readyApp.projectId ?? boundProjectId);
         boundThreadId = readyApp.threadId ? String(readyApp.threadId) : boundThreadId;
       }
@@ -3648,6 +5022,9 @@ async function collabInit(params) {
     }
   );
 }
+async function collabInitSubmit(params) {
+  return collabInit({ ...params, asyncSubmit: true });
+}
 
 // src/application/collab/collabInvite.ts
 async function collabInvite(params) {
@@ -3692,8 +5069,9 @@ async function collabList(params) {
 }
 
 // src/application/collab/collabReAnchor.ts
-import fs9 from "fs/promises";
-import path8 from "path";
+import { randomUUID as randomUUID5 } from "crypto";
+import fs11 from "fs/promises";
+import path10 from "path";
 
 // src/application/collab/pendingFinalize.ts
 function hasPendingFinalize(summary) {
@@ -3723,7 +5101,7 @@ async function collabReAnchor(params) {
     allowBranchMismatch: params.allowBranchMismatch
   });
   if (detected.status === "metadata_conflict" || detected.status === "branch_mismatch") {
-    throw new RemixError("Repository must be realigned before re-anchoring upstream history.", {
+    throw new RemixError("Repository must be realigned before seeding a fresh local Remix baseline.", {
       exitCode: 2,
       hint: detected.hint
     });
@@ -3753,15 +5131,15 @@ async function collabReAnchor(params) {
         hint: buildPendingFinalizeHint()
       });
     }
-    throw new RemixError("Re-anchor is not needed while only local boundary changes are pending.", {
+    throw new RemixError("Re-anchor is not the right command for local content changes.", {
       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."
+      hint: "Remix is source-blind: any local content change since the last recorded turn \u2014 including manual commits, pulls, merges, and rebases \u2014 is recorded with `remix collab finalize-turn`. Use `remix collab re-anchor` only when no local Remix baseline exists yet for this lane (status reports `re_anchor`)."
     });
   }
   if (detected.repoState === "idle") {
     throw new RemixError("This checkout is already aligned with Remix.", {
       exitCode: 2,
-      hint: "No re-anchor step is needed right now unless you are explicitly re-anchoring to external Git/GitHub history."
+      hint: "No re-anchor step is needed. Re-anchor only applies when no local Remix baseline exists yet for this lane."
     });
   }
   await ensureCleanWorktree(repoRoot, "`remix collab re-anchor`");
@@ -3770,6 +5148,25 @@ async function collabReAnchor(params) {
   if (!headCommitHash) {
     throw new RemixError("Failed to resolve local HEAD commit.", { exitCode: 1 });
   }
+  if (params.asyncSubmit && !params.dryRun) {
+    const pending = await findPendingAsyncJob({
+      repoRoot,
+      branchName: binding.branchName ?? branch,
+      kind: "re_anchor"
+    });
+    if (pending) {
+      return {
+        status: "queued",
+        queued: true,
+        jobId: pending.id,
+        repoRoot,
+        branch,
+        currentAppId: binding.currentAppId,
+        dryRun: false,
+        applied: false
+      };
+    }
+  }
   const preflightResp = await params.api.preflightAppReconcile(binding.currentAppId, {
     localHeadCommitHash: headCommitHash,
     repoFingerprint: binding.repoFingerprint ?? void 0,
@@ -3799,15 +5196,78 @@ async function collabReAnchor(params) {
     return preview;
   }
   let anchoredServerHeadHash = preflight.targetHeadCommitHash;
+  if (params.asyncSubmit && preflight.status === "ready_to_reconcile") {
+    const failed = await findFailedAsyncJob({
+      repoRoot,
+      branchName: binding.branchName ?? branch,
+      kind: "re_anchor"
+    });
+    if (failed) {
+      await deleteAsyncJob(failed.id);
+    }
+    const { bundlePath: tmpBundlePath, headCommitHash: bundledHeadCommitHash } = await createGitBundle(
+      repoRoot,
+      "re-anchor.bundle"
+    );
+    const tmpBundleDir = path10.dirname(tmpBundlePath);
+    try {
+      const jobId = randomUUID5();
+      const durableBundlePath = getAsyncJobBundlePath(jobId);
+      await fs11.mkdir(getAsyncJobDir(jobId), { recursive: true });
+      try {
+        await fs11.rename(tmpBundlePath, durableBundlePath);
+      } catch (error) {
+        if (error?.code !== "EXDEV") throw error;
+        await fs11.copyFile(tmpBundlePath, durableBundlePath);
+        await fs11.unlink(tmpBundlePath).catch(() => void 0);
+      }
+      const bundleSha = await sha256FileHex(durableBundlePath);
+      const job = await enqueueAsyncJob({
+        id: jobId,
+        kind: "re_anchor",
+        status: "queued",
+        repoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        branchName: binding.branchName ?? branch,
+        laneId: binding.laneId,
+        retryCount: 0,
+        error: null,
+        idempotencyKey: null,
+        payload: {
+          bundlePath: durableBundlePath,
+          bundleSha256: bundleSha,
+          localHeadCommitHash: bundledHeadCommitHash,
+          targetHeadCommitHash: preflight.targetHeadCommitHash,
+          appId: binding.currentAppId
+        }
+      });
+      await logDrainerEvent(job.id, "submitted", { kind: "re_anchor" });
+      return {
+        status: "queued",
+        queued: true,
+        jobId: job.id,
+        repoRoot,
+        branch,
+        currentAppId: binding.currentAppId,
+        localHeadCommitHash: bundledHeadCommitHash,
+        targetHeadCommitHash: preflight.targetHeadCommitHash,
+        warnings: preflight.warnings,
+        dryRun: false,
+        applied: false
+      };
+    } finally {
+      await fs11.rm(tmpBundleDir, { recursive: true, force: true }).catch(() => void 0);
+    }
+  }
   if (preflight.status === "ready_to_reconcile") {
     const { bundlePath, headCommitHash: bundledHeadCommitHash } = await createGitBundle(repoRoot, "re-anchor.bundle");
-    const bundleTempDir = path8.dirname(bundlePath);
+    const bundleTempDir = path10.dirname(bundlePath);
     try {
-      const bundleStat = await fs9.stat(bundlePath);
+      const bundleStat = await fs11.stat(bundlePath);
       const checksumSha256 = await sha256FileHex(bundlePath);
       const presignResp = await params.api.presignImportUploadFirstParty({
         file: {
-          name: path8.basename(bundlePath),
+          name: path10.basename(bundlePath),
           mimeType: "application/x-git-bundle",
           size: bundleStat.size,
           checksumSha256
@@ -3836,7 +5296,7 @@ async function collabReAnchor(params) {
       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 });
+      await fs11.rm(bundleTempDir, { recursive: true, force: true });
     }
   }
   const snapshot = await captureLocalSnapshot({
@@ -3864,12 +5324,15 @@ async function collabReAnchor(params) {
     dryRun: false
   };
 }
+async function collabReAnchorSubmit(params) {
+  return collabReAnchor({ ...params, asyncSubmit: true });
+}
 
 // src/application/collab/collabReconcile.ts
-import fs10 from "fs/promises";
+import fs12 from "fs/promises";
 import os5 from "os";
-import path9 from "path";
-import { execa as execa2 } from "execa";
+import path11 from "path";
+import { execa as execa3 } from "execa";
 async function reconcileBothChanged(params) {
   const repoRoot = await findGitRoot(params.cwd);
   const binding = await ensureActiveLaneBinding({
@@ -3989,13 +5452,13 @@ async function reconcileBothChanged(params) {
   const replay = await pollChangeStepReplay(params.api, binding.currentAppId, String(replayStart.id));
   const replayDiffResp = await params.api.getChangeStepReplayDiff(binding.currentAppId, replay.id);
   const replayDiff = unwrapResponseObject(replayDiffResp, "change step replay diff");
-  const tempRoot = await fs10.mkdtemp(path9.join(os5.tmpdir(), "remix-reconcile-"));
+  const tempRoot = await fs12.mkdtemp(path11.join(os5.tmpdir(), "remix-reconcile-"));
   let serverHeadSnapshot = null;
   let mergedSnapshot = null;
   try {
-    const tempRepoRoot = path9.join(tempRoot, "repo");
-    await fs10.mkdir(tempRepoRoot, { recursive: true });
-    await execa2("git", ["init"], { cwd: tempRepoRoot, stderr: "ignore" });
+    const tempRepoRoot = path11.join(tempRoot, "repo");
+    await fs12.mkdir(tempRepoRoot, { recursive: true });
+    await execa3("git", ["init"], { cwd: tempRepoRoot, stderr: "ignore" });
     await materializeLocalSnapshot(baseline.lastSnapshotId, tempRepoRoot);
     if (delta.status === "delta_ready" && delta.diff.trim()) {
       await applyUnifiedDiffToWorktree(tempRepoRoot, delta.diff, "`remix collab reconcile`");
@@ -4016,7 +5479,7 @@ async function reconcileBothChanged(params) {
       branchName: binding.branchName
     });
   } finally {
-    await fs10.rm(tempRoot, { recursive: true, force: true }).catch(() => void 0);
+    await fs12.rm(tempRoot, { recursive: true, force: true }).catch(() => void 0);
   }
   if (!serverHeadSnapshot || !mergedSnapshot) {
     throw new RemixError("Failed to materialize the reconciled local workspace.", { exitCode: 1 });
@@ -4239,7 +5702,7 @@ async function collabRequestMerge(params) {
 
 // src/application/collab/collabStatus.ts
 function isFinalizeQueueBlocking(state) {
-  return state === "queued" || state === "processing" || state === "retry_scheduled";
+  return state === "queued" || state === "processing" || state === "retry_scheduled" || state === "awaiting_usage";
 }
 function createBaseStatus() {
   return {
@@ -4268,6 +5731,7 @@ function createBaseStatus() {
       threadId: null,
       repoFingerprint: null,
       remoteUrl: null,
+      dashboardUrl: null,
       defaultBranch: null,
       laneId: null,
       branchName: null,
@@ -4312,6 +5776,7 @@ function createBaseStatus() {
         queuedJobCount: 0,
         processingJobCount: 0,
         retryScheduledJobCount: 0,
+        awaitingUsageJobCount: 0,
         failedJobCount: 0,
         oldestCapturedAt: null,
         newestCapturedAt: null,
@@ -4394,6 +5859,10 @@ async function collabStatus(params) {
       threadId: detected.binding.threadId,
       repoFingerprint: detected.binding.repoFingerprint,
       remoteUrl: detected.binding.remoteUrl,
+      // Dashboard URL is derived (not stored on the binding) — compute it
+      // here so every status caller, including MCP/agent tools, gets it
+      // alongside `remoteUrl` without having to know the URL convention.
+      dashboardUrl: detected.binding.currentAppId ? buildDashboardAppUrl(detected.binding.currentAppId) : null,
       defaultBranch: detected.binding.defaultBranch,
       laneId: detected.binding.laneId,
       branchName: detected.binding.branchName,
@@ -4633,16 +6102,534 @@ async function collabView(params) {
   const resp = await params.api.getMergeRequestReview(params.mrId);
   return unwrapMergeRequestReview(resp);
 }
+
+// src/application/collab/collabAsyncProcessing.ts
+import fs13 from "fs/promises";
+import path12 from "path";
+var MAX_TRANSIENT_RETRIES = 5;
+var TRANSIENT_NETWORK_CODES = /* @__PURE__ */ new Set([
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ETIMEDOUT",
+  "EAI_AGAIN",
+  "ENOTFOUND",
+  "ENETUNREACH",
+  "EHOSTUNREACH",
+  "EPIPE",
+  "UND_ERR_SOCKET",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT"
+]);
+function formatError(error) {
+  if (error instanceof RemixError) {
+    return [error.message, error.hint].filter(Boolean).join("\n\n") || error.message || "Unknown error.";
+  }
+  if (error instanceof Error) {
+    return error.message || "Unknown error.";
+  }
+  if (typeof error === "string") return error;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return "Unknown error.";
+  }
+}
+function readNumberCandidate(error, key) {
+  if (!error || typeof error !== "object") return null;
+  const value = error[key];
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  return null;
+}
+function readStringCandidate(error, key) {
+  if (!error || typeof error !== "object") return null;
+  const value = error[key];
+  if (typeof value === "string" && value.length > 0) return value;
+  return null;
+}
+function classifyError(error) {
+  if (error instanceof RemixError) return "jobSpecific";
+  const candidates = [error];
+  if (error && typeof error === "object" && "cause" in error) {
+    candidates.push(error.cause);
+  }
+  for (const candidate of candidates) {
+    const status = readNumberCandidate(candidate, "status") ?? readNumberCandidate(candidate, "statusCode");
+    if (status !== null) {
+      if (status === 401 || status === 403) return "transient";
+      if (status >= 500 && status < 600) return "transient";
+      if (status >= 400 && status < 500) return "jobSpecific";
+    }
+    const code = readStringCandidate(candidate, "code");
+    if (code && TRANSIENT_NETWORK_CODES.has(code)) return "transient";
+    if (code === "ENOENT" || code === "EACCES") return "jobSpecific";
+    const name = readStringCandidate(candidate, "name");
+    if (name === "AbortError" || name === "TimeoutError") return "transient";
+    if (name === "SyntaxError") return "jobSpecific";
+  }
+  return "jobSpecific";
+}
+async function handleProcessError(job, error) {
+  const message = formatError(error);
+  const kind = classifyError(error);
+  if (kind === "transient") {
+    const nextRetry = (job.retryCount ?? 0) + 1;
+    if (nextRetry < MAX_TRANSIENT_RETRIES) {
+      await updateAsyncJob(job.id, {
+        status: "queued",
+        retryCount: nextRetry,
+        error: message
+      });
+      await logDrainerEvent(job.id, "retrying", {
+        kind: job.kind,
+        retryCount: nextRetry,
+        error: message
+      });
+      return { status: "retry_scheduled", jobId: job.id, error: message, retryCount: nextRetry };
+    }
+    const finalMessage = `exceeded retry limit (${MAX_TRANSIENT_RETRIES} attempts). Last error: ${message}`;
+    await updateAsyncJob(job.id, { status: "failed", error: finalMessage, retryCount: nextRetry });
+    await logDrainerEvent(job.id, "failed", { kind: job.kind, error: finalMessage, retryCount: nextRetry });
+    return { status: "failed", jobId: job.id, error: finalMessage };
+  }
+  await updateAsyncJob(job.id, { status: "failed", error: message });
+  await logDrainerEvent(job.id, "failed", { kind: job.kind, error: message });
+  return { status: "failed", jobId: job.id, error: message };
+}
+async function processInitJob(job, api) {
+  if (job.kind !== "init") return { status: "skipped", jobId: job.id };
+  const startedAt = Date.now();
+  try {
+    await updateAsyncJob(job.id, { status: "submitting", error: null });
+    await logDrainerEvent(job.id, "claimed", { kind: "init" });
+    const bundleStat = await fs13.stat(job.payload.bundlePath);
+    const presignResp = await api.presignImportUploadFirstParty({
+      file: {
+        name: path12.basename(job.payload.bundlePath),
+        mimeType: "application/x-git-bundle",
+        size: bundleStat.size,
+        checksumSha256: job.payload.bundleSha256
+      }
+    });
+    const presign = unwrapResponseObject(presignResp, "upload");
+    await updateAsyncJob(job.id, { status: "uploading" });
+    await logDrainerEvent(job.id, "uploading", { kind: "init" });
+    await uploadPresigned({
+      uploadUrl: String(presign.uploadUrl),
+      headers: presign.headers ?? {},
+      filePath: job.payload.bundlePath
+    });
+    await updateAsyncJob(job.id, { status: "server_processing" });
+    const importResp = await api.importFromUploadFirstParty({
+      uploadId: String(presign.uploadId),
+      appName: job.payload.appName?.trim() || path12.basename(job.repoRoot),
+      platform: "generic",
+      isPublic: false,
+      branch: job.payload.defaultBranch && job.branchName && job.branchName !== job.payload.defaultBranch ? job.payload.defaultBranch : job.branchName ?? void 0,
+      remoteUrl: job.payload.remoteUrl ?? void 0,
+      defaultBranch: job.payload.defaultBranch ?? void 0,
+      repoFingerprint: job.repoFingerprint ?? void 0,
+      headCommitHash: job.payload.headCommitHash
+    });
+    const imported = unwrapResponseObject(importResp, "import");
+    await logDrainerEvent(job.id, "server_accepted", { kind: "init", appId: String(imported.appId ?? "") });
+    const app = await pollAppReady(api, String(imported.appId));
+    let boundProjectId = String(app.projectId);
+    let boundCurrentAppId = String(app.id);
+    let boundUpstreamAppId = String(app.id);
+    let boundThreadId = app.threadId ? String(app.threadId) : null;
+    let boundLaneId = null;
+    let canonicalLane = null;
+    const branchName = job.branchName;
+    const defaultBranch = job.payload.defaultBranch;
+    const repoRoot = job.repoRoot;
+    const repoFingerprint = job.repoFingerprint;
+    const remoteUrl = job.payload.remoteUrl;
+    const headCommitHash = job.payload.headCommitHash;
+    if (branchName) {
+      if (defaultBranch && branchName !== defaultBranch) {
+        canonicalLane = await resolveOrEnsureLaneBinding({
+          api,
+          projectId: boundProjectId,
+          repoFingerprint: repoFingerprint ?? "",
+          remoteUrl,
+          defaultBranch,
+          branchName: defaultBranch,
+          seedAppId: String(app.id),
+          operation: "`remix collab init` (background)"
+        });
+        const lane = await resolveOrEnsureLaneBinding({
+          api,
+          projectId: canonicalLane.projectId ?? boundProjectId,
+          repoFingerprint: repoFingerprint ?? "",
+          remoteUrl,
+          defaultBranch,
+          branchName,
+          seedHeadCommitHash: headCommitHash,
+          operation: "`remix collab init` (background)"
+        });
+        boundProjectId = lane.projectId ?? boundProjectId;
+        boundCurrentAppId = lane.currentAppId ?? boundCurrentAppId;
+        boundUpstreamAppId = lane.upstreamAppId ?? boundUpstreamAppId;
+        boundThreadId = lane.threadId ?? boundThreadId;
+        boundLaneId = lane.laneId ?? null;
+      } else {
+        const lane = await resolveOrEnsureLaneBinding({
+          api,
+          projectId: boundProjectId,
+          repoFingerprint: repoFingerprint ?? "",
+          remoteUrl,
+          defaultBranch,
+          branchName,
+          seedAppId: String(app.id),
+          operation: "`remix collab init` (background)"
+        });
+        canonicalLane = lane;
+        boundProjectId = lane.projectId ?? boundProjectId;
+        boundCurrentAppId = lane.currentAppId ?? boundCurrentAppId;
+        boundUpstreamAppId = lane.upstreamAppId ?? boundUpstreamAppId;
+        boundThreadId = lane.threadId ?? boundThreadId;
+        boundLaneId = lane.laneId ?? null;
+      }
+    }
+    if (boundCurrentAppId) {
+      const readyApp = await pollAppReady(api, boundCurrentAppId);
+      boundProjectId = String(readyApp.projectId ?? boundProjectId);
+      boundThreadId = readyApp.threadId ? String(readyApp.threadId) : boundThreadId;
+    }
+    const bindingMode = job.payload.forceNew && (!defaultBranch || branchName === defaultBranch) ? "explicit_root" : "lane";
+    if (job.payload.forceNew && defaultBranch && canonicalLane) {
+      const canonicalBinding = branchBindingFromLane(canonicalLane, "explicit_root", {
+        projectId: canonicalLane.projectId ?? boundProjectId,
+        currentAppId: canonicalLane.currentAppId ?? boundCurrentAppId,
+        upstreamAppId: canonicalLane.upstreamAppId ?? canonicalLane.currentAppId ?? boundCurrentAppId,
+        threadId: canonicalLane.threadId ?? boundThreadId
+      });
+      const branchBindings = { [defaultBranch]: canonicalBinding };
+      if (branchName && branchName !== defaultBranch) {
+        branchBindings[branchName] = {
+          projectId: boundProjectId,
+          currentAppId: boundCurrentAppId,
+          upstreamAppId: boundUpstreamAppId,
+          threadId: boundThreadId,
+          laneId: boundLaneId,
+          bindingMode: "lane"
+        };
+      }
+      await writeCollabBindingSnapshot({
+        repoRoot,
+        repoFingerprint: repoFingerprint ?? "",
+        remoteUrl,
+        defaultBranch,
+        branchBindings,
+        explicitRootBinding: canonicalBinding
+      });
+    } else {
+      if (canonicalLane && defaultBranch && branchName && branchName !== defaultBranch) {
+        await writeCollabBinding(repoRoot, {
+          projectId: canonicalLane.projectId ?? null,
+          currentAppId: canonicalLane.currentAppId ?? boundCurrentAppId,
+          upstreamAppId: canonicalLane.upstreamAppId ?? canonicalLane.currentAppId ?? boundCurrentAppId,
+          threadId: canonicalLane.threadId ?? null,
+          repoFingerprint: canonicalLane.repoFingerprint ?? repoFingerprint ?? "",
+          remoteUrl: canonicalLane.remoteUrl ?? remoteUrl,
+          defaultBranch: canonicalLane.defaultBranch ?? defaultBranch,
+          laneId: canonicalLane.laneId ?? null,
+          branchName: defaultBranch,
+          bindingMode: job.payload.forceNew ? "explicit_root" : "lane"
+        });
+      }
+      await writeCollabBinding(repoRoot, {
+        projectId: boundProjectId,
+        currentAppId: boundCurrentAppId,
+        upstreamAppId: boundUpstreamAppId,
+        threadId: boundThreadId,
+        repoFingerprint: repoFingerprint ?? "",
+        remoteUrl,
+        defaultBranch: defaultBranch ?? null,
+        laneId: boundLaneId,
+        branchName,
+        bindingMode
+      });
+    }
+    await seedImportedInitBaseline({
+      api,
+      repoRoot,
+      repoFingerprint: repoFingerprint ?? "",
+      laneId: boundLaneId,
+      currentAppId: boundCurrentAppId,
+      branchName
+    });
+    await logDrainerEvent(job.id, "server_completed", {
+      kind: "init",
+      appId: boundCurrentAppId,
+      dashboardUrl: buildDashboardAppUrl(boundCurrentAppId),
+      durationMs: Date.now() - startedAt
+    });
+    await updateAsyncJob(job.id, { status: "completed", error: null });
+    await logDrainerEvent(job.id, "completed", { kind: "init", durationMs: Date.now() - startedAt });
+    return { status: "completed", jobId: job.id };
+  } catch (error) {
+    return await handleProcessError(job, error);
+  }
+}
+async function processInitPostJob(job, api) {
+  if (job.kind !== "init_post") return { status: "skipped", jobId: job.id };
+  const startedAt = Date.now();
+  const syncPhaseMs = Math.max(0, job.payload.syncPhaseFinishedAt - job.payload.syncPhaseStartedAt);
+  try {
+    await updateAsyncJob(job.id, { status: "server_processing", error: null });
+    await logDrainerEvent(job.id, "claimed", {
+      kind: "init_post",
+      appId: job.payload.appId,
+      syncPhaseMs
+    });
+    await pollAppReady(api, job.payload.appId);
+    await seedImportedInitBaseline({
+      api,
+      repoRoot: job.repoRoot,
+      repoFingerprint: job.repoFingerprint ?? "",
+      laneId: job.laneId,
+      currentAppId: job.payload.appId,
+      branchName: job.branchName
+    });
+    const asyncPhaseMs = Date.now() - startedAt;
+    await updateAsyncJob(job.id, { status: "completed", error: null });
+    await logDrainerEvent(job.id, "completed", {
+      kind: "init_post",
+      appId: job.payload.appId,
+      durationMs: asyncPhaseMs,
+      // Top-level metrics requested in the rollout PR description so the
+      // sync vs async timing breakdown is grep-able in one place.
+      ["init.sync_phase_ms"]: syncPhaseMs,
+      ["init.async_phase_ms"]: asyncPhaseMs,
+      ["init.total_ms"]: syncPhaseMs + asyncPhaseMs
+    });
+    return { status: "completed", jobId: job.id };
+  } catch (error) {
+    const outcome = await handleProcessError(job, error);
+    if (outcome.status === "failed") {
+      const bindingPath = getCollabBindingPath(job.repoRoot);
+      try {
+        await fs13.unlink(bindingPath);
+        await logDrainerEvent(job.id, "binding_cleared", {
+          kind: "init_post",
+          appId: job.payload.appId,
+          repoRoot: job.repoRoot,
+          bindingPath,
+          reason: "init_post_terminal_failure"
+        });
+      } catch (cleanupError) {
+        await logDrainerEvent(job.id, "binding_cleared", {
+          kind: "init_post",
+          appId: job.payload.appId,
+          repoRoot: job.repoRoot,
+          bindingPath,
+          reason: "init_post_terminal_failure",
+          cleanupError: formatError(cleanupError)
+        });
+      }
+    }
+    return outcome;
+  }
+}
+async function processReAnchorJob(job, api) {
+  if (job.kind !== "re_anchor") return { status: "skipped", jobId: job.id };
+  const startedAt = Date.now();
+  try {
+    await updateAsyncJob(job.id, { status: "submitting", error: null });
+    await logDrainerEvent(job.id, "claimed", { kind: "re_anchor" });
+    const preflightResp = await api.preflightAppReconcile(job.payload.appId, {
+      localHeadCommitHash: job.payload.localHeadCommitHash,
+      repoFingerprint: job.repoFingerprint ?? 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") || null
+      });
+    }
+    let anchoredServerHeadHash = preflight.targetHeadCommitHash;
+    if (preflight.status === "ready_to_reconcile") {
+      const bundleStat = await fs13.stat(job.payload.bundlePath);
+      const presignResp = await api.presignImportUploadFirstParty({
+        file: {
+          name: path12.basename(job.payload.bundlePath),
+          mimeType: "application/x-git-bundle",
+          size: bundleStat.size,
+          checksumSha256: job.payload.bundleSha256
+        }
+      });
+      const uploadTarget = unwrapResponseObject(presignResp, "import upload target");
+      await updateAsyncJob(job.id, { status: "uploading" });
+      await logDrainerEvent(job.id, "uploading", { kind: "re_anchor" });
+      await uploadPresigned({
+        uploadUrl: String(uploadTarget.uploadUrl),
+        filePath: job.payload.bundlePath,
+        headers: uploadTarget.headers ?? {}
+      });
+      await updateAsyncJob(job.id, { status: "server_processing" });
+      const startResp = await api.startAppReconcile(job.payload.appId, {
+        uploadId: String(uploadTarget.uploadId),
+        localHeadCommitHash: job.payload.localHeadCommitHash,
+        repoFingerprint: job.repoFingerprint ?? void 0,
+        idempotencyKey: buildDeterministicIdempotencyKey({
+          kind: "collab_re_anchor_v1",
+          appId: job.payload.appId,
+          localHeadCommitHash: job.payload.localHeadCommitHash,
+          targetHeadCommitHash: job.payload.targetHeadCommitHash
+        })
+      });
+      const started = unwrapResponseObject(startResp, "reconcile");
+      await logDrainerEvent(job.id, "server_accepted", { kind: "re_anchor", appId: job.payload.appId });
+      const reconcile = await pollReconcile(api, job.payload.appId, started.id);
+      anchoredServerHeadHash = reconcile.reconciledHeadCommitHash ?? reconcile.targetHeadCommitHash ?? preflight.targetHeadCommitHash;
+    }
+    const snapshot = await captureLocalSnapshot({
+      repoRoot: job.repoRoot,
+      repoFingerprint: job.repoFingerprint,
+      laneId: job.laneId,
+      branchName: job.branchName
+    });
+    await writeLocalBaseline({
+      repoRoot: job.repoRoot,
+      repoFingerprint: job.repoFingerprint,
+      laneId: job.laneId,
+      currentAppId: job.payload.appId,
+      branchName: job.branchName,
+      lastSnapshotId: snapshot.id,
+      lastSnapshotHash: snapshot.snapshotHash,
+      lastServerHeadHash: anchoredServerHeadHash,
+      lastSeenLocalCommitHash: snapshot.localCommitHash
+    });
+    await logDrainerEvent(job.id, "server_completed", {
+      kind: "re_anchor",
+      appId: job.payload.appId,
+      durationMs: Date.now() - startedAt
+    });
+    await updateAsyncJob(job.id, { status: "completed", error: null });
+    await logDrainerEvent(job.id, "completed", { kind: "re_anchor", durationMs: Date.now() - startedAt });
+    return { status: "completed", jobId: job.id };
+  } catch (error) {
+    return await handleProcessError(job, error);
+  }
+}
+async function collabInitProcess(jobId, opts) {
+  const claim = await claimAsyncJob(jobId);
+  if (!claim) {
+    const job = await readAsyncJob(jobId);
+    if (!job) return { status: "skipped", jobId };
+    return { status: "skipped", jobId };
+  }
+  try {
+    if (claim.job.kind !== "init") return { status: "skipped", jobId };
+    return await processInitJob(claim.job, opts.api);
+  } finally {
+    await claim.release();
+  }
+}
+async function collabInitPostProcess(jobId, opts) {
+  const claim = await claimAsyncJob(jobId);
+  if (!claim) {
+    const job = await readAsyncJob(jobId);
+    if (!job) return { status: "skipped", jobId };
+    return { status: "skipped", jobId };
+  }
+  try {
+    if (claim.job.kind !== "init_post") return { status: "skipped", jobId };
+    return await processInitPostJob(claim.job, opts.api);
+  } finally {
+    await claim.release();
+  }
+}
+async function collabReAnchorProcess(jobId, opts) {
+  const claim = await claimAsyncJob(jobId);
+  if (!claim) {
+    const job = await readAsyncJob(jobId);
+    if (!job) return { status: "skipped", jobId };
+    return { status: "skipped", jobId };
+  }
+  try {
+    if (claim.job.kind !== "re_anchor") return { status: "skipped", jobId };
+    return await processReAnchorJob(claim.job, opts.api);
+  } finally {
+    await claim.release();
+  }
+}
+async function acquireDrainerPidLock() {
+  const pidPath = getDrainerPidPath();
+  await fs13.mkdir(path12.dirname(pidPath), { recursive: true });
+  try {
+    const existing = await fs13.readFile(pidPath, "utf8").catch(() => "");
+    const existingPid = parseInt(existing.trim(), 10);
+    if (Number.isFinite(existingPid) && existingPid > 0 && existingPid !== process.pid) {
+      try {
+        process.kill(existingPid, 0);
+        return null;
+      } catch (error) {
+        if (error?.code !== "ESRCH") return null;
+      }
+    }
+    await fs13.writeFile(pidPath, String(process.pid), "utf8");
+    return {
+      release: async () => {
+        try {
+          const current = (await fs13.readFile(pidPath, "utf8")).trim();
+          if (current === String(process.pid)) {
+            await fs13.unlink(pidPath).catch(() => void 0);
+          }
+        } catch {
+        }
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+async function drainAsyncJobs(opts) {
+  const lockHandle = opts.respectPidLock === false ? null : await acquireDrainerPidLock();
+  if (opts.respectPidLock !== false && !lockHandle) return [];
+  const outcomes = [];
+  try {
+    await pruneTerminalAsyncJobs().catch(() => void 0);
+    const jobs = await listAsyncJobs();
+    const drainable = jobs.filter(
+      (job) => job.status !== "completed" && job.status !== "failed"
+    );
+    for (const job of drainable) {
+      let outcome;
+      if (job.kind === "init") {
+        outcome = await collabInitProcess(job.id, { api: opts.api });
+      } else if (job.kind === "init_post") {
+        outcome = await collabInitPostProcess(job.id, { api: opts.api });
+      } else {
+        outcome = await collabReAnchorProcess(job.id, { api: opts.api });
+      }
+      outcomes.push(outcome);
+    }
+  } finally {
+    if (lockHandle) await lockHandle.release();
+  }
+  return outcomes;
+}
 export {
+  FINALIZE_JOB_LOCK_STALE_MS,
+  FINALIZE_PREFLIGHT_FAILURE_CODES,
+  awaitAsyncJob,
+  cleanStaleFinalizeJobLocks,
   collabApprove,
   collabCheckout,
   collabFinalizeTurn,
   collabInit,
+  collabInitProcess,
+  collabInitSubmit,
   collabInvite,
   collabList,
   collabListMembers,
   collabListMergeRequests,
   collabReAnchor,
+  collabReAnchorProcess,
+  collabReAnchorSubmit,
   collabReconcile,
   collabRecordingPreflight,
   collabReject,
@@ -4653,8 +6640,26 @@ export {
   collabSyncUpstream,
   collabUpdateMemberRole,
   collabView,
+  deleteAsyncJob,
+  drainAsyncJobs,
   drainPendingFinalizeQueue,
+  drainerLogPath,
+  findFailedAsyncJob,
+  findPendingAsyncJob,
+  forgetPendingFinalizeJob,
+  getDrainerLogPath,
+  getDrainerPidPath,
   getMemberRolesForScope,
+  isFinalizePreflightFailureCode,
+  listAsyncJobs,
+  listAsyncJobsForRepo,
+  listPendingFinalizeJobs,
   processPendingFinalizeJob,
+  pruneTerminalAsyncJobs,
+  readAsyncJob,
+  readPendingFinalizeJob,
+  requeuePendingFinalizeJob,
+  summarizeAsyncJobs,
+  updatePendingFinalizeJob,
   validateMemberRole
 };