@remixhq/core 0.1.24 → 0.1.26

package/dist/collab.js

@@ -8,7 +8,7 @@ import {
   writeCollabBinding,
   writeCollabBindingSnapshot,
   writeJsonAtomic
-} from "./chunk-P4XIICU3.js";
+} from "./chunk-GNW6FA4J.js";
 import {
   applyUnifiedDiffToWorktree,
   assertRepoSnapshotUnchanged,
@@ -17,6 +17,8 @@ import {
   checkoutLocalBranch,
   cloneGitBundleToDirectory,
   createGitBundle,
+  createGitCommandPlan,
+  createSystemGitAdapter,
   ensureCleanWorktree,
   ensureGitInfoExcludeEntries,
   findGitRoot,
@@ -30,7 +32,7 @@ import {
   requireCurrentBranch,
   setRemoteOriginUrl,
   summarizeUnifiedDiff
-} from "./chunk-S4ECO35X.js";
+} from "./chunk-FA6PTZQI.js";
 import {
   REMIX_ERROR_CODES
 } from "./chunk-GC2MOT3U.js";
@@ -191,6 +193,9 @@ function getAsyncJobDir(jobId) {
 function getAsyncJobFilePath(jobId) {
   return path.join(getAsyncJobDir(jobId), "job.json");
 }
+function getAsyncJobBundlePath(jobId) {
+  return path.join(getAsyncJobDir(jobId), "bundle.bundle");
+}
 function getLogsRoot() {
   return path.join(getCollabStateRoot(), "logs");
 }
@@ -204,6 +209,7 @@ function getDrainerPidPath() {
 // src/infrastructure/collab/asyncJobStore.ts
 var ASYNC_JOB_LOCK_STALE_MS = 10 * 60 * 1e3;
 var TERMINAL_ASYNC_JOB_RETENTION_MS = 24 * 60 * 60 * 1e3;
+var REMOVED_ASYNC_JOB_KINDS = /* @__PURE__ */ new Set([["re", "anchor"].join("_")]);
 function getJobLockPath(id) {
   return path2.join(getAsyncJobDir(id), "lock");
 }
@@ -249,7 +255,7 @@ function normalizeJob(input) {
   if (input.kind === "init_post") {
     return { ...base, kind: "init_post", payload: input.payload };
   }
-  return { ...base, kind: "re_anchor", payload: input.payload };
+  throw new Error(`Unsupported async job kind: ${input.kind ?? "unknown"}`);
 }
 async function enqueueAsyncJob(input) {
   const job = normalizeJob(input);
@@ -262,7 +268,7 @@ function parseAsyncJob(raw) {
   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.kind !== "init" && data.kind !== "init_post") return null;
   if (!data.payload || typeof data.payload !== "object") return null;
   return data;
 }
@@ -289,6 +295,30 @@ async function listAsyncJobs() {
   );
   return jobs.filter((job) => Boolean(job)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
 }
+async function pruneRemovedAsyncJobKinds() {
+  const root = getAsyncJobsRoot();
+  let entries;
+  try {
+    entries = await fs.readdir(root, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === "ENOENT") return;
+    throw error;
+  }
+  await Promise.all(
+    entries.filter((entry) => entry.isDirectory()).map(async (entry) => {
+      let parsed;
+      try {
+        const raw = await fs.readFile(getAsyncJobFilePath(entry.name), "utf8");
+        parsed = JSON.parse(raw);
+      } catch {
+        return;
+      }
+      if (parsed.schemaVersion === 1 && typeof parsed.id === "string" && typeof parsed.kind === "string" && REMOVED_ASYNC_JOB_KINDS.has(parsed.kind)) {
+        await deleteAsyncJob(entry.name);
+      }
+    })
+  );
+}
 async function listAsyncJobsForRepo(params) {
   const jobs = await listAsyncJobs();
   return jobs.filter((job) => {
@@ -319,8 +349,8 @@ async function updateAsyncJob(jobId, update) {
   if (!existing) return null;
   const now = (/* @__PURE__ */ new Date()).toISOString();
   if (existing.kind === "init") {
-    const nextPayload2 = update.payload ?? existing.payload;
-    const next2 = {
+    const nextPayload = update.payload ?? existing.payload;
+    const next = {
       ...existing,
       ...update,
       schemaVersion: 1,
@@ -328,14 +358,14 @@ async function updateAsyncJob(jobId, update) {
       kind: "init",
       createdAt: existing.createdAt,
       updatedAt: now,
-      payload: nextPayload2
+      payload: nextPayload
     };
-    await writeJsonAtomic(getAsyncJobFilePath(jobId), next2);
-    return next2;
+    await writeJsonAtomic(getAsyncJobFilePath(jobId), next);
+    return next;
   }
   if (existing.kind === "init_post") {
-    const nextPayload2 = update.payload ?? existing.payload;
-    const next2 = {
+    const nextPayload = update.payload ?? existing.payload;
+    const next = {
       ...existing,
       ...update,
       schemaVersion: 1,
@@ -343,24 +373,12 @@ async function updateAsyncJob(jobId, update) {
       kind: "init_post",
       createdAt: existing.createdAt,
       updatedAt: now,
-      payload: nextPayload2
+      payload: nextPayload
     };
-    await writeJsonAtomic(getAsyncJobFilePath(jobId), next2);
-    return next2;
+    await writeJsonAtomic(getAsyncJobFilePath(jobId), next);
+    return next;
   }
-  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;
+  throw new Error(`Unsupported async job kind: ${existing.kind ?? "unknown"}`);
 }
 async function deleteAsyncJob(jobId) {
   await fs.rm(getAsyncJobDir(jobId), { recursive: true, force: true });
@@ -434,14 +452,15 @@ async function summarizeAsyncJobs(params) {
   }
   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;
+  summary.oldestCreatedAt = active[0].createdAt;
+  summary.newestCreatedAt = active[active.length - 1].createdAt;
   if (summary.processingJobCount > 0) summary.state = "processing";
   else if (summary.queuedJobCount > 0) summary.state = "queued";
   else summary.state = "failed";
   return summary;
 }
 async function pruneTerminalAsyncJobs() {
+  await pruneRemovedAsyncJobKinds();
   const jobs = await listAsyncJobs();
   const now = Date.now();
   await Promise.all(
@@ -453,6 +472,9 @@ async function pruneTerminalAsyncJobs() {
     }).map((job) => deleteAsyncJob(job.id))
   );
 }
+function getAsyncJobBundleFilePath(jobId) {
+  return getAsyncJobBundlePath(jobId);
+}
 async function awaitAsyncJob(params) {
   const pollIntervalMs = Math.max(50, params.pollIntervalMs ?? 500);
   const deadline = Date.now() + params.timeoutMs;
@@ -536,6 +558,15 @@ async function writeLocalBaseline(baseline) {
   await writeJsonAtomic(getBaselinePath(baseline), normalized);
   return normalized;
 }
+async function clearLocalBaseline(params) {
+  try {
+    await fs2.unlink(getBaselinePath(params));
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
 
 // src/infrastructure/collab/localSnapshotStore.ts
 import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
@@ -1207,7 +1238,9 @@ async function resolveProjectLaneIfAuthoritative(api, params) {
       repoFingerprint: params.repoFingerprint ?? void 0,
       remoteUrl: params.remoteUrl ?? void 0,
       defaultBranch: params.defaultBranch ?? void 0,
-      branchName
+      branchName,
+      currentAppId: params.currentAppId ?? void 0,
+      upstreamAppId: params.expectedUpstreamAppId ?? void 0
     });
     return unwrapResponseObject(laneResp, "project lane binding");
   };
@@ -1222,6 +1255,8 @@ async function resolveProjectLaneIfAuthoritative(api, params) {
       remoteUrl: params.remoteUrl ?? void 0,
       defaultBranch: params.defaultBranch ?? void 0,
       branchName,
+      currentAppId: params.currentAppId ?? void 0,
+      upstreamAppId: params.expectedUpstreamAppId ?? void 0,
       seedAppId: params.seedAppId
     });
     lane = unwrapResponseObject(ensuredResp, "project lane binding");
@@ -1233,6 +1268,8 @@ async function resolveProjectLaneIfAuthoritative(api, params) {
       remoteUrl: params.remoteUrl ?? void 0,
       defaultBranch: params.defaultBranch ?? void 0,
       branchName,
+      currentAppId: params.currentAppId ?? void 0,
+      upstreamAppId: params.expectedUpstreamAppId ?? void 0,
       seedAppId: params.seedAppId
     });
     lane = unwrapResponseObject(ensuredResp, "project lane binding");
@@ -1243,10 +1280,12 @@ async function resolveProjectLaneIfAuthoritative(api, params) {
   if (params.expectedUpstreamAppId && lane.upstreamAppId && lane.upstreamAppId !== params.expectedUpstreamAppId) return null;
   return lane;
 }
-async function pollAppReady(api, appId) {
-  const started = Date.now();
+async function pollAppReady(api, appId, deps = {}) {
+  const now = deps.clock?.now ?? Date.now;
+  const sleepFn = deps.timers?.sleep ?? sleep;
+  const started = now();
   let delay = 2e3;
-  while (Date.now() - started < 20 * 60 * 1e3) {
+  while (now() - started < 20 * 60 * 1e3) {
     const appResp = await api.getApp(appId);
     const app = unwrapResponseObject(appResp, "app");
     const status = typeof app.status === "string" ? app.status : "";
@@ -1257,7 +1296,7 @@ async function pollAppReady(api, appId) {
         hint: typeof app.statusError === "string" ? app.statusError : null
       });
     }
-    await sleep(delay);
+    await sleepFn(delay);
     delay = Math.min(1e4, Math.floor(delay * 1.4));
   }
   throw new RemixError("Timed out waiting for app to become ready.", { exitCode: 1 });
@@ -1327,30 +1366,6 @@ async function pollChangeStep(api, appId, changeStepId) {
   }
   throw new RemixError("Timed out waiting for change step.", { exitCode: 1 });
 }
-async function pollReconcile(api, appId, reconcileId) {
-  const started = Date.now();
-  let delay = 1500;
-  while (Date.now() - started < 30 * 60 * 1e3) {
-    const resp = await api.getAppReconcile(appId, reconcileId);
-    const reconcile = unwrapResponseObject(resp, "reconcile");
-    if (reconcile.status === "succeeded") return reconcile;
-    if (reconcile.status === "manual_reconcile_required") {
-      throw new RemixError("Reconciliation requires manual intervention.", {
-        exitCode: 2,
-        hint: reconcile.statusError || "The server could not safely replay the local-only commits."
-      });
-    }
-    if (reconcile.status === "failed" || reconcile.status === "cancelled") {
-      throw new RemixError("Reconciliation failed.", {
-        exitCode: 1,
-        hint: reconcile.statusError || null
-      });
-    }
-    await sleep(delay);
-    delay = Math.min(1e4, Math.floor(delay * 1.4));
-  }
-  throw new RemixError("Timed out waiting for reconcile job.", { exitCode: 1 });
-}
 async function pollChangeStepReplay(api, appId, replayId) {
   const started = Date.now();
   let delay = 1500;
@@ -1507,7 +1522,14 @@ 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"}`;
+  return [
+    params.repoRoot,
+    params.currentBranch ?? "",
+    params.hasApi ? "1" : "0",
+    params.currentAppId ?? "",
+    params.upstreamAppId ?? "",
+    params.laneId ?? ""
+  ].join("|");
 }
 function readResolutionCache(key) {
   const entry = resolutionCache.get(key);
@@ -1527,7 +1549,10 @@ async function resolveActiveLaneBinding(params) {
   const cacheKey = buildResolutionCacheKey({
     repoRoot: params.repoRoot,
     currentBranch: state ? normalizeBranchName(state.currentBranch) : null,
-    hasApi: Boolean(params.api)
+    hasApi: Boolean(params.api),
+    currentAppId: state?.binding?.currentAppId ?? null,
+    upstreamAppId: state?.binding?.upstreamAppId ?? null,
+    laneId: state?.binding?.laneId ?? null
   });
   const cached = readResolutionCache(cacheKey);
   if (cached) return cached;
@@ -1567,7 +1592,9 @@ async function resolveActiveLaneBindingUncached(params, state) {
       repoFingerprint: state.repoFingerprint ?? void 0,
       remoteUrl: state.remoteUrl ?? void 0,
       defaultBranch: state.defaultBranch ?? void 0,
-      branchName: currentBranch
+      branchName: currentBranch,
+      currentAppId: localBinding.currentAppId,
+      upstreamAppId: localBinding.upstreamAppId
     });
     const lane2 = unwrapResponseObject(laneResp2, "project lane binding");
     if (lane2.status === "ambiguous_family_selection") {
@@ -1647,7 +1674,9 @@ async function resolveActiveLaneBindingUncached(params, state) {
     repoFingerprint: state.repoFingerprint ?? void 0,
     remoteUrl: state.remoteUrl ?? void 0,
     defaultBranch: state.defaultBranch ?? void 0,
-    branchName: currentBranch
+    branchName: currentBranch,
+    currentAppId: state.binding?.currentAppId,
+    upstreamAppId: state.binding?.upstreamAppId
   });
   const lane = unwrapResponseObject(laneResp, "project lane binding");
   if (lane.status === "ambiguous_family_selection") {
@@ -1768,6 +1797,21 @@ function buildBaseState() {
     }
   };
 }
+async function refreshEquivalentRevisionBaseline(params) {
+  return writeLocalBaseline({
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.binding.repoFingerprint,
+    laneId: params.binding.laneId,
+    currentAppId: params.binding.currentAppId,
+    branchName: params.binding.branchName,
+    lastSnapshotId: params.baseline.lastSnapshotId,
+    lastSnapshotHash: params.baseline.lastSnapshotHash,
+    lastServerRevisionId: params.appHead.headRevisionId ?? null,
+    lastServerTreeHash: params.appHead.treeHash ?? params.baseline.lastServerTreeHash ?? null,
+    lastServerHeadHash: params.appHead.headCommitHash,
+    lastSeenLocalCommitHash: params.baseline.lastSeenLocalCommitHash
+  });
+}
 async function collabDetectRepoState(params) {
   const detected = buildBaseState();
   let repoRoot;
@@ -1963,22 +2007,15 @@ async function collabDetectRepoState(params) {
     );
     const equivalentRevisionDrift = revisionChanged && !serverHeadChanged;
     if (equivalentRevisionDrift) {
-      await writeLocalBaseline({
+      const refreshedBaseline = await refreshEquivalentRevisionBaseline({
         repoRoot,
-        repoFingerprint: binding.repoFingerprint,
-        laneId: binding.laneId,
-        currentAppId: binding.currentAppId,
-        branchName: binding.branchName,
-        lastSnapshotId: baseline.lastSnapshotId,
-        lastSnapshotHash: baseline.lastSnapshotHash,
-        lastServerRevisionId: appHead.headRevisionId ?? null,
-        lastServerTreeHash: appHead.treeHash ?? baseline.lastServerTreeHash ?? null,
-        lastServerHeadHash: appHead.headCommitHash,
-        lastSeenLocalCommitHash: baseline.lastSeenLocalCommitHash
+        binding,
+        baseline,
+        appHead
       });
-      detected.baseline.lastServerRevisionId = appHead.headRevisionId ?? null;
-      detected.baseline.lastServerTreeHash = appHead.treeHash ?? baseline.lastServerTreeHash ?? null;
-      detected.baseline.lastServerHeadHash = appHead.headCommitHash;
+      detected.baseline.lastServerRevisionId = refreshedBaseline.lastServerRevisionId;
+      detected.baseline.lastServerTreeHash = refreshedBaseline.lastServerTreeHash;
+      detected.baseline.lastServerHeadHash = refreshedBaseline.lastServerHeadHash;
     }
     const serverChanged = serverHeadChanged;
     if (!localChanged && !serverChanged) {
@@ -2005,13 +2042,38 @@ async function collabDetectRepoState(params) {
 }
 
 // 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 buildGitEventStatusArgs() {
+  return ["status", "--porcelain=v1"];
+}
+function buildGitEventDiffNumstatArgs(params) {
+  if (params.kind === "uncommitted") {
+    return ["diff", "--numstat", "HEAD"];
+  }
+  return ["diff", "--numstat", "--no-renames", params.fromCommit, params.toCommit];
+}
+function buildGitEventReachabilityArgs(fromCommit, toCommit) {
+  return ["merge-base", "--is-ancestor", fromCommit, toCommit];
+}
+function buildGitEventLogArgs(fromCommit, toCommit) {
+  return [
+    "log",
+    "--first-parent",
+    "-m",
+    "--numstat",
+    "--no-renames",
+    `--format=${LOG_FORMAT}`,
+    `${fromCommit}..${toCommit}`
+  ];
+}
+function buildGitEventNameRevArgs(secondParent) {
+  return ["name-rev", "--name-only", "--no-undefined", secondParent];
+}
 function sanitizedEnv() {
   const env = { ...process.env };
   delete env.GIT_DIR;
@@ -2020,21 +2082,16 @@ function sanitizedEnv() {
   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
-  };
+async function runGitEvent(args, cwd, adapter = createSystemGitAdapter()) {
+  return adapter.run(
+    createGitCommandPlan({
+      args,
+      cwd,
+      env: sanitizedEnv(),
+      timeoutMs: GIT_TIMEOUT_MS,
+      maxBuffer: GIT_MAX_BUFFER
+    })
+  );
 }
 function parseNumstatLine(line) {
   const tab1 = line.indexOf("	");
@@ -2123,10 +2180,11 @@ function parseBranchFromMergeMessage(subject) {
   }
   return null;
 }
-async function resolveBranchFromNameRev(secondParent, repoRoot) {
+async function resolveBranchFromNameRev(secondParent, repoRoot, adapter) {
   const res = await runGitEvent(
-    ["name-rev", "--name-only", "--no-undefined", secondParent],
-    repoRoot
+    buildGitEventNameRevArgs(secondParent),
+    repoRoot,
+    adapter
   );
   if (res.exitCode !== 0 || res.timedOut) return null;
   let name = res.stdout.trim();
@@ -2136,7 +2194,35 @@ async function resolveBranchFromNameRev(secondParent, repoRoot) {
   if (name.includes("~") || name.includes("^") || name.startsWith("tags/") || name === "undefined") return null;
   return name;
 }
-async function collectUncommittedSummary(repoRoot) {
+function summarizePorcelainStatus(stdout) {
+  const summary = {
+    filesChanged: 0,
+    staged: 0,
+    unstaged: 0,
+    untracked: 0
+  };
+  const uniquePaths = /* @__PURE__ */ new Set();
+  for (const rawLine of 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;
+  return summary;
+}
+async function collectUncommittedSummary(repoRoot, adapter) {
   const summary = {
     filesChanged: 0,
     linesAdded: 0,
@@ -2145,29 +2231,11 @@ async function collectUncommittedSummary(repoRoot) {
     unstaged: 0,
     untracked: 0
   };
-  const statusRes = await runGitEvent(["status", "--porcelain=v1"], repoRoot);
+  const statusRes = await runGitEvent(buildGitEventStatusArgs(), repoRoot, adapter);
   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;
+    Object.assign(summary, summarizePorcelainStatus(statusRes.stdout));
   }
-  const diffRes = await runGitEvent(["diff", "--numstat", "HEAD"], repoRoot);
+  const diffRes = await runGitEvent(buildGitEventDiffNumstatArgs({ kind: "uncommitted" }), repoRoot, adapter);
   if (diffRes.exitCode === 0 && !diffRes.timedOut) {
     for (const rawLine of diffRes.stdout.split("\n")) {
       if (!rawLine) continue;
@@ -2200,7 +2268,8 @@ function buildEmptyPreTurnEvents(params) {
 }
 async function collectPreTurnGitEvents(params) {
   try {
-    const uncommitted = await collectUncommittedSummary(params.repoRoot);
+    const git = params.git ?? createSystemGitAdapter();
+    const uncommitted = await collectUncommittedSummary(params.repoRoot, git);
     if (!params.fromCommit || params.fromCommit === params.toCommit) {
       return buildEmptyPreTurnEvents({
         fromCommit: params.fromCommit,
@@ -2210,8 +2279,9 @@ async function collectPreTurnGitEvents(params) {
       });
     }
     const reachabilityRes = await runGitEvent(
-      ["merge-base", "--is-ancestor", params.fromCommit, params.toCommit],
-      params.repoRoot
+      buildGitEventReachabilityArgs(params.fromCommit, params.toCommit),
+      params.repoRoot,
+      git
     );
     if (reachabilityRes.timedOut) return null;
     if (reachabilityRes.exitCode === 1) {
@@ -2224,16 +2294,9 @@ async function collectPreTurnGitEvents(params) {
     }
     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
+      buildGitEventLogArgs(params.fromCommit, params.toCommit),
+      params.repoRoot,
+      git
     );
     if (logRes.timedOut || logRes.exitCode !== 0) return null;
     const rawCommits = parseLogOutput(logRes.stdout);
@@ -2248,7 +2311,7 @@ async function collectPreTurnGitEvents(params) {
       if (raw.parents.length < 2) continue;
       const secondParent = raw.parents[1];
       const fromBranchFromMessage = parseBranchFromMergeMessage(raw.subject);
-      const fromBranchFromNameRev = await resolveBranchFromNameRev(secondParent, params.repoRoot);
+      const fromBranchFromNameRev = await resolveBranchFromNameRev(secondParent, params.repoRoot, git);
       merges.push({
         hash: raw.hash,
         shortHash: raw.hash.slice(0, 7),
@@ -2265,8 +2328,9 @@ async function collectPreTurnGitEvents(params) {
     let totalLinesAdded = 0;
     let totalLinesRemoved = 0;
     const diffRes = await runGitEvent(
-      ["diff", "--numstat", "--no-renames", params.fromCommit, params.toCommit],
-      params.repoRoot
+      buildGitEventDiffNumstatArgs({ kind: "range", fromCommit: params.fromCommit, toCommit: params.toCommit }),
+      params.repoRoot,
+      git
     );
     if (diffRes.exitCode === 0 && !diffRes.timedOut) {
       const uniquePaths = /* @__PURE__ */ new Set();
@@ -2317,13 +2381,184 @@ async function collectPreTurnGitEvents(params) {
   }
 }
 
+// src/application/collab/jobRunner.ts
+async function drainClaimedJobs(params) {
+  await params.prune();
+  const jobs = await params.list();
+  const results = [];
+  for (const listedJob of jobs) {
+    if (params.isTerminal(listedJob)) continue;
+    const claimed = await params.claim(listedJob);
+    if (!claimed) continue;
+    try {
+      const result = await params.process(claimed);
+      results.push(result);
+      await params.afterSuccess?.({ listedJob, job: claimed.job, result });
+    } catch (error) {
+      await claimed.release();
+      if (params.onError === "throw") throw error;
+    }
+  }
+  return results;
+}
+
+// src/application/collab/workflowState.ts
+function asyncJobWorkflowState(status) {
+  if (status === "completed" || status === "failed" || status === "queued") return status;
+  return "processing";
+}
+function planAsyncJobDrainTransition(job) {
+  const state = asyncJobWorkflowState(job.status);
+  if (state === "completed" || state === "failed") {
+    return { workflow: "async_job_drain", state, action: "skip_terminal", terminal: true };
+  }
+  return {
+    workflow: "async_job_drain",
+    state,
+    action: job.kind === "init" ? "process_init" : "process_init_post",
+    terminal: false
+  };
+}
+function planFinalizeQueueTransition(job) {
+  if (job.status === "completed" || job.status === "failed" && job.metadata.failureDisposition === "terminal") {
+    return { workflow: "finalize", state: job.status, action: "skip_terminal", terminal: true };
+  }
+  if (job.status === "failed") {
+    return { workflow: "finalize", state: "retryable_failed", action: "claim_and_process", terminal: false };
+  }
+  return { workflow: "finalize", state: job.status, action: "claim_and_process", terminal: false };
+}
+function planCheckoutWorkflowTransition(params) {
+  if (!params.appId?.trim()) {
+    return { workflow: "checkout", state: "failed", action: "require_app", terminal: true };
+  }
+  return { workflow: "checkout", state: "selected", action: "checkout", terminal: false };
+}
+function planApproveWorkflowTransition(params) {
+  if (params.mode === "sync-target-repo") {
+    return params.hasCwd ? { workflow: "approve", state: "sync_target_repo", action: "sync_target_repo", terminal: false } : { workflow: "approve", state: "failed", action: "require_cwd", terminal: true };
+  }
+  return { workflow: "approve", state: "remote_only", action: "approve_remote", terminal: false };
+}
+function planRequestMergeWorkflowTransition(params) {
+  if (!params.hasBinding) {
+    return { workflow: "request_merge", state: "failed", action: "require_binding", terminal: true };
+  }
+  if (params.hasPendingFinalize) {
+    return { workflow: "request_merge", state: "pending_finalize", action: "require_finalize_drain", terminal: true };
+  }
+  return { workflow: "request_merge", state: "bound", action: "open_merge_request", terminal: false };
+}
+
+// src/application/collab/finalizeQueueRunner.ts
+async function drainPendingFinalizeQueueJobs(params) {
+  return drainClaimedJobs({
+    prune: prunePendingFinalizeJobs,
+    list: listPendingFinalizeJobs,
+    isTerminal: (job) => planFinalizeQueueTransition(job).terminal,
+    claim: (job) => claimPendingFinalizeJob(job.id),
+    process: (claimed) => params.processClaimedJob({
+      api: params.api,
+      job: claimed.job,
+      release: claimed.release
+    }),
+    afterSuccess: async ({ listedJob }) => {
+      await removePendingFinalizeJob(listedJob.id);
+    }
+  });
+}
+
+// src/application/collab/finalizeWorkspaceMetadata.ts
+function buildWorkspaceMetadata(params) {
+  const metadata = {
+    branch: params.branchName,
+    repoRoot: params.repoRoot,
+    remoteUrl: params.remoteUrl,
+    defaultBranch: params.defaultBranch,
+    recordingMode: "boundary_delta",
+    baselineSnapshotId: params.baselineSnapshotId,
+    currentSnapshotId: params.currentSnapshotId,
+    baselineServerRevisionId: params.baselineServerRevisionId ?? null,
+    baselineServerHeadHash: params.baselineServerHeadHash,
+    currentSnapshotHash: params.currentSnapshotHash,
+    localCommitHash: params.localCommitHash,
+    repoStateAtCapture: params.repoState,
+    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;
+}
+
+// src/application/collab/finalizeDecision.ts
+var FINALIZE_AUTO_TERMINAL_THRESHOLD = 5;
+function classifyFinalizeError(error) {
+  const tagged = error;
+  return {
+    disposition: tagged.finalizeDisposition ?? "retryable",
+    reason: tagged.finalizeReason ?? "unknown",
+    message: error instanceof Error ? error.message : String(error)
+  };
+}
+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 hasFinalizeBaselineDrifted(params) {
+  return params.liveSnapshotId !== params.jobSnapshotId || (params.jobServerRevisionId ? params.liveServerRevisionId !== params.jobServerRevisionId : false) || params.liveServerHeadHash !== params.jobServerHeadHash;
+}
+function canSalvageNoDiffFinalize(params) {
+  if (params.baselineDrifted && params.currentSnapshotHash !== params.liveBaselineSnapshotHash) return false;
+  return params.serverStillAtBaseline;
+}
+function classifyChangedFinalizeDrift(params) {
+  if (!params.baselineDrifted) return "no_drift";
+  return params.localBaselineAdvanced && params.serverHeadAdvanced ? "consistent_advance" : "inconsistent_drift";
+}
+function shouldReplayChangedFinalize(params) {
+  return params.currentServerHeadHash !== params.submissionBaseHeadHash || params.baselineDrifted;
+}
+function shouldAdoptExistingChangeStepBeforeReplay(params) {
+  return params.replayNeeded && Boolean(params.idempotencyKey?.trim());
+}
+function validateSucceededChangeStepForBaseline(params) {
+  const nextServerHeadHash = typeof params.headCommitHash === "string" ? params.headCommitHash.trim() : "";
+  if (!nextServerHeadHash) {
+    throw new RemixError("Backend returned a succeeded change step without a head commit hash.", {
+      exitCode: 1,
+      hint: "This is a backend invariant violation; retry will not help. Run `remix collab status` before trying again."
+    });
+  }
+  const nextServerRevisionId = typeof params.resultRevisionId === "string" ? params.resultRevisionId.trim() : "";
+  return {
+    nextServerHeadHash,
+    nextServerRevisionId: nextServerRevisionId || null,
+    needsFreshHeadVerification: !nextServerRevisionId
+  };
+}
+
 // 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;
@@ -2350,14 +2585,6 @@ function buildFinalizeCliError(params) {
   error.finalizeReason = params.reason;
   return error;
 }
-function classifyFinalizeError(error) {
-  const tagged = error;
-  return {
-    disposition: tagged.finalizeDisposition ?? "retryable",
-    reason: tagged.finalizeReason ?? "unknown",
-    message: error instanceof Error ? error.message : String(error)
-  };
-}
 function runWithFinalizeTimeout(work, jobId) {
   let timer;
   const cap = finalizeJobProcessingTimeoutMs;
@@ -2388,46 +2615,6 @@ function startLockHeartbeat(jobId) {
   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,
-    defaultBranch: params.defaultBranch,
-    recordingMode: "boundary_delta",
-    baselineSnapshotId: params.baselineSnapshotId,
-    currentSnapshotId: params.currentSnapshotId,
-    baselineServerRevisionId: params.baselineServerRevisionId ?? null,
-    baselineServerHeadHash: params.baselineServerHeadHash,
-    currentSnapshotHash: params.currentSnapshotHash,
-    localCommitHash: params.localCommitHash,
-    repoStateAtCapture: params.repoState,
-    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 findExistingChangeStepByIdempotency(params) {
   const idempotencyKey = params.idempotencyKey?.trim();
   if (!idempotencyKey) return null;
@@ -2440,19 +2627,28 @@ async function findExistingChangeStepByIdempotency(params) {
   return steps.find((step) => step.idempotencyKey === idempotencyKey) ?? null;
 }
 async function writeBaselineFromSucceededChangeStep(params) {
-  const nextServerHeadHash = typeof params.changeStep.headCommitHash === "string" ? params.changeStep.headCommitHash.trim() : "";
-  if (!nextServerHeadHash) {
-    throw buildFinalizeCliError({
-      message: "Backend returned a succeeded change step without a head commit hash.",
-      exitCode: 1,
-      hint: "This is a backend invariant violation; retry will not help. Run `remix collab status` before trying again.",
-      disposition: "terminal",
-      reason: "missing_head_commit_hash"
+  let baselineAdvance;
+  try {
+    baselineAdvance = validateSucceededChangeStepForBaseline({
+      headCommitHash: params.changeStep.headCommitHash,
+      resultRevisionId: params.changeStep.resultRevisionId
     });
+  } catch (error) {
+    if (error instanceof RemixError) {
+      throw buildFinalizeCliError({
+        message: error.message,
+        exitCode: error.exitCode,
+        hint: error.hint ?? void 0,
+        disposition: "terminal",
+        reason: "missing_head_commit_hash"
+      });
+    }
+    throw error;
   }
-  let nextServerRevisionId = typeof params.changeStep.resultRevisionId === "string" ? params.changeStep.resultRevisionId.trim() : "";
+  const nextServerHeadHash = baselineAdvance.nextServerHeadHash;
+  let nextServerRevisionId = baselineAdvance.nextServerRevisionId ?? "";
   let nextServerTreeHash = null;
-  if (!nextServerRevisionId) {
+  if (baselineAdvance.needsFreshHeadVerification) {
     const freshHeadResp = await params.api.getAppHead(params.job.currentAppId);
     const freshHead = unwrapResponseObject(freshHeadResp, "app head");
     if (freshHead.headCommitHash !== nextServerHeadHash || !freshHead.headRevisionId) {
@@ -2546,7 +2742,14 @@ async function processClaimedPendingFinalizeJobInner(params) {
       reason: "baseline_missing"
     });
   }
-  const baselineDrifted = baseline.lastSnapshotId !== job.baselineSnapshotId || (job.baselineServerRevisionId ? baseline.lastServerRevisionId !== job.baselineServerRevisionId : false) || baseline.lastServerHeadHash !== job.baselineServerHeadHash;
+  const baselineDrifted = hasFinalizeBaselineDrifted({
+    liveSnapshotId: baseline.lastSnapshotId,
+    jobSnapshotId: job.baselineSnapshotId,
+    liveServerRevisionId: baseline.lastServerRevisionId,
+    jobServerRevisionId: job.baselineServerRevisionId,
+    liveServerHeadHash: baseline.lastServerHeadHash,
+    jobServerHeadHash: job.baselineServerHeadHash
+  });
   const appHead = unwrapResponseObject(appHeadResp, "app head");
   const remoteUrl = readMetadataString(job, "remoteUrl");
   const defaultBranch = readMetadataString(job, "defaultBranch");
@@ -2565,7 +2768,13 @@ async function processClaimedPendingFinalizeJobInner(params) {
     targetSnapshotId: job.currentSnapshotId
   });
   if (!diffResult.diff.trim()) {
-    if (baselineDrifted && snapshot.snapshotHash !== baseline.lastSnapshotHash) {
+    const serverStillAtBaseline = job.baselineServerRevisionId ? appHead.headRevisionId === job.baselineServerRevisionId : appHead.headCommitHash === job.baselineServerHeadHash;
+    if (baselineDrifted && !canSalvageNoDiffFinalize({
+      baselineDrifted,
+      currentSnapshotHash: snapshot.snapshotHash,
+      liveBaselineSnapshotHash: baseline.lastSnapshotHash,
+      serverStillAtBaseline: true
+    })) {
       throw buildFinalizeCliError({
         message: "Finalize queue baseline drifted before this job was processed.",
         exitCode: 1,
@@ -2574,8 +2783,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
         reason: "baseline_drifted"
       });
     }
-    const serverStillAtBaseline = job.baselineServerRevisionId ? appHead.headRevisionId === job.baselineServerRevisionId : appHead.headCommitHash === job.baselineServerHeadHash;
-    if (!serverStillAtBaseline) {
+    if (!canSalvageNoDiffFinalize({ baselineDrifted: false, currentSnapshotHash: "", liveBaselineSnapshotHash: "", serverStillAtBaseline })) {
       throw buildFinalizeCliError({
         message: "Server lane changed before a no-diff turn could be recorded.",
         exitCode: 2,
@@ -2641,9 +2849,9 @@ async function processClaimedPendingFinalizeJobInner(params) {
   }
   const localBaselineAdvanced = baseline.lastSnapshotId !== job.baselineSnapshotId;
   const serverHeadAdvanced = job.baselineServerRevisionId ? appHead.headRevisionId !== job.baselineServerRevisionId : appHead.headCommitHash !== job.baselineServerHeadHash;
-  if (baselineDrifted) {
-    const consistentAdvance = localBaselineAdvanced && serverHeadAdvanced;
-    if (!consistentAdvance) {
+  const changedDrift = classifyChangedFinalizeDrift({ baselineDrifted, localBaselineAdvanced, serverHeadAdvanced });
+  if (changedDrift !== "no_drift") {
+    if (changedDrift === "inconsistent_drift") {
       throw buildFinalizeCliError({
         message: `Finalize queue baseline advanced inconsistently before this job was processed (localBaselineAdvanced=${localBaselineAdvanced}, serverHeadAdvanced=${serverHeadAdvanced}, jobBaselineSnapshotId=${job.baselineSnapshotId ?? "null"}, liveBaselineSnapshotId=${baseline.lastSnapshotId ?? "null"}, jobBaselineServerHeadHash=${job.baselineServerHeadHash ?? "null"}, liveBaselineServerHeadHash=${baseline.lastServerHeadHash ?? "null"}, currentAppHeadHash=${appHead.headCommitHash}). This indicates local Remix state diverged from the backend in a way that should not be reachable in normal operation; please report this as a bug.`,
         exitCode: 1,
@@ -2665,8 +2873,12 @@ async function processClaimedPendingFinalizeJobInner(params) {
       reason: "baseline_server_head_missing"
     });
   }
-  const replayNeeded = appHead.headCommitHash !== submissionBaseHeadHash || baselineDrifted;
-  if (replayNeeded) {
+  const replayNeeded = shouldReplayChangedFinalize({
+    currentServerHeadHash: appHead.headCommitHash,
+    submissionBaseHeadHash,
+    baselineDrifted
+  });
+  if (shouldAdoptExistingChangeStepBeforeReplay({ replayNeeded, idempotencyKey: job.idempotencyKey })) {
     const existingChangeStep = await findExistingChangeStepByIdempotency({
       api: params.api,
       appId: job.currentAppId,
@@ -2853,24 +3065,10 @@ async function enqueueCapturedFinalizeTurn(params) {
   });
 }
 async function drainPendingFinalizeQueue(params) {
-  await prunePendingFinalizeJobs();
-  const jobs = await listPendingFinalizeJobs();
-  const results = [];
-  for (const job of jobs) {
-    const claimed = await claimPendingFinalizeJob(job.id);
-    if (!claimed) continue;
-    try {
-      const result = await processClaimedPendingFinalizeJob({
-        api: params.api,
-        job: claimed.job,
-        release: claimed.release
-      });
-      results.push(result);
-      await removePendingFinalizeJob(job.id);
-    } catch {
-    }
-  }
-  return results;
+  return drainPendingFinalizeQueueJobs({
+    api: params.api,
+    processClaimedJob: processClaimedPendingFinalizeJob
+  });
 }
 
 // src/application/collab/collabFinalizeTurn.ts
@@ -3123,12 +3321,7 @@ function isFinalizePreflightFailureCode(value) {
 }
 
 // src/application/collab/recordingPreflight.ts
-async function collabRecordingPreflight(params) {
-  const detected = await collabDetectRepoState({
-    api: params.api,
-    cwd: params.cwd,
-    allowBranchMismatch: params.allowBranchMismatch
-  });
+function mapDetectedRepoStateToRecordingPreflight(detected) {
   if (detected.status === "not_git_repo") {
     return {
       status: "not_git_repo",
@@ -3177,6 +3370,14 @@ async function collabRecordingPreflight(params) {
   if (detected.repoState === "external_local_base_changed") return { status: "baseline_missing", ...base };
   return { status: "ready", ...base };
 }
+async function collabRecordingPreflight(params) {
+  const detected = await collabDetectRepoState({
+    api: params.api,
+    cwd: params.cwd,
+    allowBranchMismatch: params.allowBranchMismatch
+  });
+  return mapDetectedRepoStateToRecordingPreflight(detected);
+}
 
 // src/infrastructure/locking/repoMutationLock.ts
 import fs5 from "fs/promises";
@@ -3638,15 +3839,14 @@ async function collabSync(params) {
 
 // src/application/collab/collabApprove.ts
 async function collabApprove(params) {
-  if (params.mode === "sync-target-repo") {
-    if (!params.cwd?.trim()) {
-      throw new RemixError("Working directory is required for `--sync-target-repo`.", {
-        exitCode: 2
-      });
-    }
+  const transition = planApproveWorkflowTransition({
+    mode: params.mode,
+    hasCwd: Boolean(params.cwd?.trim())
+  });
+  if (transition.action === "sync_target_repo") {
     return withRepoMutationLock(
       {
-        cwd: params.cwd,
+        cwd: params.cwd ?? "",
         operation: "collabApproveSyncTarget"
       },
       async ({ repoRoot, warnings }) => {
@@ -3705,6 +3905,11 @@ async function collabApprove(params) {
       }
     );
   }
+  if (transition.action === "require_cwd") {
+    throw new RemixError("Working directory is required for `--sync-target-repo`.", {
+      exitCode: 2
+    });
+  }
   const resp = await params.api.updateMergeRequest(params.mrId, { status: "approved" });
   const approvedMergeRequest = unwrapMergeRequest(resp);
   const completedMergeRequest = await pollMergeRequestCompletion(params.api, params.mrId, {
@@ -3841,13 +4046,14 @@ async function materializeAppCheckout(params) {
 
 // src/application/collab/collabCheckout.ts
 async function collabCheckout(params) {
-  const appId = params.appId?.trim() || null;
-  if (!appId) {
+  const transition = planCheckoutWorkflowTransition({ appId: params.appId });
+  if (transition.action === "require_app") {
     throw new RemixError("No app selected.", {
       exitCode: 2,
       hint: "Pass the app id to checkout."
     });
   }
+  const appId = params.appId?.trim() ?? "";
   const app = await pollAppReady(params.api, appId);
   const collab = app.collab && typeof app.collab === "object" ? app.collab : null;
   const source = app.source && typeof app.source === "object" ? app.source : null;
@@ -4101,38 +4307,16 @@ async function collabUpdateMemberRole(params) {
 }
 
 // src/application/collab/collabInit.ts
-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();
-}
+import fs11 from "fs/promises";
+import path10 from "path";
 
 // src/shared/hash.ts
 import crypto from "crypto";
-import fs8 from "fs";
+import fs7 from "fs";
 async function sha256FileHex(filePath) {
   const hash = crypto.createHash("sha256");
   await new Promise((resolve, reject) => {
-    const stream = fs8.createReadStream(filePath);
+    const stream = fs7.createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
     stream.on("end", () => resolve());
@@ -4140,145 +4324,52 @@ async function sha256FileHex(filePath) {
   return hash.digest("hex");
 }
 
-// src/shared/upload.ts
-import fs9 from "fs";
-import { PassThrough } from "stream";
-async function uploadPresigned(params) {
-  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 = fs9.createReadStream(params.filePath);
-  const pass = new PassThrough();
-  let sentBytes = 0;
-  fileStream.on("data", (chunk) => {
-    sentBytes += chunk.length;
-    params.onProgress?.({ sentBytes, totalBytes });
-  });
-  fileStream.on("error", (err) => pass.destroy(err));
-  fileStream.pipe(pass);
-  const response = await fetch(params.uploadUrl, {
-    method: "PUT",
-    headers: params.headers,
-    body: pass,
-    duplex: "half"
-  });
-  if (!response.ok) {
-    const text = await response.text().catch(() => "");
-    throw new RemixError("Upload failed.", {
-      exitCode: 1,
-      hint: `Status: ${response.status}
-${text}`.trim() || null
-    });
-  }
-}
-
-// src/application/collab/collabInit.ts
-function requireResolvedLaneBinding(lane, params) {
-  if (lane.status === "resolved" && lane.currentAppId && lane.upstreamAppId) {
-    return lane;
-  }
-  const branchLabel = params.branchName ?? "the current branch";
-  const laneStatus = String(lane.status ?? "");
-  throw new RemixError(`Failed to resolve a Remix lane for ${branchLabel}.`, {
-    exitCode: 1,
-    hint: laneStatus === "binding_not_found" ? `Run ${params.operation} again after the repository has been initialized.` : laneStatus === "ambiguous_family_selection" ? "Multiple canonical Remix families match this repository. Continue from a checkout already bound to the intended family, or rerun with `--force-new` to create a new family." : `Remix did not return complete lane metadata for ${branchLabel}.`
-  });
+// src/application/collab/collabInitDecision.ts
+function shouldRequireCleanWorktreeForInit(params) {
+  return Boolean(params.forceNew) || !params.hasExistingBinding;
 }
-function resolveProjectBindingResult(response) {
-  const payload = response?.responseObject;
-  if (!payload || typeof payload !== "object") {
-    return { status: "not_found" };
-  }
-  if (payload.status === "ambiguous_family_selection") {
-    const projectIds = Array.isArray(payload.projectIds) ? payload.projectIds.filter((value) => typeof value === "string" && value.trim().length > 0) : [];
-    return {
-      status: "ambiguous_family_selection",
-      candidateCount: typeof payload.candidateCount === "number" && Number.isFinite(payload.candidateCount) ? payload.candidateCount : projectIds.length,
-      projectIds
-    };
-  }
-  if (payload.projectId && payload.appId) {
-    return {
-      status: "resolved",
-      projectId: String(payload.projectId),
-      appId: String(payload.appId),
-      upstreamAppId: String(payload.upstreamAppId ?? payload.appId),
-      threadId: payload.threadId ? String(payload.threadId) : null
-    };
-  }
-  return { status: "not_found" };
+function classifyExistingInitBaseline(baseline) {
+  return baseline?.lastSnapshotHash && (baseline.lastServerRevisionId || baseline.lastServerHeadHash) ? "existing" : null;
 }
-function throwAmbiguousFamilyError(params) {
-  const familyCount = params.candidateCount || params.projectIds.length;
-  const projectHint = params.projectIds.length > 0 ? ` Matching project ids: ${params.projectIds.join(", ")}.` : "";
-  const remoteHint = params.remoteUrl ? ` (${params.remoteUrl})` : "";
-  throw new RemixError("Multiple canonical Remix families already match this repository.", {
-    exitCode: 2,
-    hint: `Plain \`remix collab init\` cannot safely choose among ${familyCount} matching canonical families for repo fingerprint ${params.repoFingerprint}${remoteHint}.${projectHint} Run \`remix collab init --force-new\` to create a new canonical family, or continue from a checkout already bound to the intended family.`
-  });
-}
-async function resolveOrEnsureLaneBinding(params) {
-  const resolvePayload = {
-    projectId: params.projectId ?? void 0,
-    repoFingerprint: params.repoFingerprint,
-    remoteUrl: params.remoteUrl ?? void 0,
-    defaultBranch: params.defaultBranch ?? void 0,
-    branchName: params.branchName
-  };
-  let lane = unwrapResponseObject(
-    await params.api.resolveProjectLaneBinding(resolvePayload),
-    "project lane binding"
-  );
-  if (lane.status !== "resolved") {
-    lane = unwrapResponseObject(
-      await params.api.ensureProjectLaneBinding({
-        ...resolvePayload,
-        seedAppId: params.seedAppId ?? void 0,
-        seedHeadCommitHash: params.seedHeadCommitHash ?? void 0
-      }),
-      "project lane binding"
-    );
-  }
-  return requireResolvedLaneBinding(lane, {
-    branchName: params.branchName,
-    operation: params.operation
-  });
+function classifyInitBaselineDelta(params) {
+  if (params.equivalentBaselineStatus) return params.equivalentBaselineStatus;
+  if (params.deltaStatus === "content_equivalent") return "seeded";
+  if (params.deltaStatus === "up_to_date" || params.deltaStatus === "delta_ready") return "requires_sync";
+  return null;
 }
-function branchBindingFromLane(lane, mode, fallback) {
-  return {
-    projectId: lane.projectId ?? fallback.projectId,
-    currentAppId: lane.currentAppId ?? fallback.currentAppId,
-    upstreamAppId: lane.upstreamAppId ?? fallback.upstreamAppId,
-    threadId: lane.threadId ?? fallback.threadId,
-    laneId: lane.laneId ?? null,
-    bindingMode: mode
-  };
+function canSeedEquivalentBranchBaseline(params) {
+  if (!params.branchName || !params.defaultBranch || params.branchName === params.defaultBranch) return false;
+  if (!params.defaultBranchCurrentAppId) return false;
+  if (params.upstreamAppId && params.defaultBranchCurrentAppId !== params.upstreamAppId) return false;
+  if (!params.defaultBaselineSnapshotHash || !params.defaultBaselineServerHeadHash) return false;
+  if (params.defaultBaselineServerHeadHash !== params.appHeadHash) return false;
+  return params.localSnapshotHash === params.defaultBaselineSnapshotHash || params.localCommitHash === params.defaultBaselineLocalCommitHash;
 }
 function resolveStoredBindingAnchor(params) {
   const currentBranchBinding = params.currentBranch ? params.state.branchBindings[params.currentBranch] ?? null : null;
   if (currentBranchBinding?.currentAppId) {
-    return {
-      binding: currentBranchBinding,
-      branchName: params.currentBranch
-    };
+    return { binding: currentBranchBinding, branchName: params.currentBranch };
   }
   const defaultBranchBinding = params.defaultBranch ? params.state.branchBindings[params.defaultBranch] ?? null : null;
   if (defaultBranchBinding?.currentAppId) {
-    return {
-      binding: defaultBranchBinding,
-      branchName: params.defaultBranch
-    };
+    return { binding: defaultBranchBinding, branchName: params.defaultBranch };
   }
   return null;
 }
+function shouldReplaceAsyncInitJobs(params) {
+  return Boolean(params.forceNew);
+}
+function shouldReturnPendingAsyncInit(params) {
+  return !params.forceNew && params.pendingJobFound;
+}
+
+// src/application/collab/collabInitBaseline.ts
 async function trySeedEquivalentBranchBaseline(params) {
   if (!params.branchName || !params.defaultBranch || params.branchName === params.defaultBranch) {
     return null;
   }
   const bindingState = await readCollabBindingState(params.repoRoot);
-  const defaultBranchBinding = bindingState?.branchBindings[params.defaultBranch] ?? null;
+  const defaultBranchBinding = params.defaultBranch ? bindingState?.branchBindings[params.defaultBranch] ?? null : null;
   if (!defaultBranchBinding?.currentAppId) {
     return null;
   }
@@ -4303,7 +4394,18 @@ async function trySeedEquivalentBranchBaseline(params) {
     branchName: params.branchName,
     persistBlobs: false
   });
-  if (inspection.snapshotHash !== defaultBaseline.lastSnapshotHash && inspection.localCommitHash !== defaultBaseline.lastSeenLocalCommitHash) {
+  if (!canSeedEquivalentBranchBaseline({
+    branchName: params.branchName,
+    defaultBranch: params.defaultBranch,
+    upstreamAppId: params.upstreamAppId,
+    defaultBranchCurrentAppId: defaultBranchBinding?.currentAppId ?? null,
+    defaultBaselineSnapshotHash: defaultBaseline?.lastSnapshotHash ?? null,
+    defaultBaselineServerHeadHash: defaultBaseline?.lastServerHeadHash ?? null,
+    defaultBaselineLocalCommitHash: defaultBaseline?.lastSeenLocalCommitHash ?? null,
+    appHeadHash: params.appHeadHash,
+    localSnapshotHash: inspection.snapshotHash,
+    localCommitHash: inspection.localCommitHash
+  })) {
     return null;
   }
   await writeLocalBaseline({
@@ -4327,9 +4429,8 @@ async function resolveInitBaselineStatus(params) {
     laneId: params.laneId,
     repoRoot: params.repoRoot
   });
-  if (baseline?.lastSnapshotHash && (baseline.lastServerRevisionId || baseline.lastServerHeadHash)) {
-    return "existing";
-  }
+  const existingBaselineStatus = classifyExistingInitBaseline(baseline);
+  if (existingBaselineStatus) return existingBaselineStatus;
   const localHeadCommitHash = await getHeadCommitHash(params.repoRoot);
   if (!localHeadCommitHash) return "baseline_missing";
   const appHead = unwrapResponseObject(
@@ -4381,7 +4482,7 @@ async function resolveInitBaselineStatus(params) {
       if (equivalentBaseline) {
         return equivalentBaseline;
       }
-      return "requires_sync";
+      return classifyInitBaselineDelta({ deltaStatus: delta.status }) ?? "baseline_missing";
     }
     if (delta.status === "content_equivalent") {
       await seedImportedInitBaseline({
@@ -4392,7 +4493,7 @@ async function resolveInitBaselineStatus(params) {
         currentAppId: params.currentAppId,
         branchName: params.branchName
       });
-      return "seeded";
+      return classifyInitBaselineDelta({ deltaStatus: delta.status }) ?? "baseline_missing";
     }
     if (delta.status === "base_unknown") {
       const equivalentBaseline = await trySeedEquivalentBranchBaseline({
@@ -4413,34 +4514,317 @@ async function resolveInitBaselineStatus(params) {
     }
   } catch {
   }
-  return "baseline_missing";
+  return "baseline_missing";
+}
+async function seedImportedInitBaseline(params) {
+  const appHead = unwrapResponseObject(
+    await params.api.getAppHead(params.currentAppId),
+    "app head"
+  );
+  const snapshot = await captureLocalSnapshot({
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.repoFingerprint,
+    laneId: params.laneId,
+    branchName: params.branchName
+  });
+  await writeLocalBaseline({
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.repoFingerprint,
+    laneId: params.laneId,
+    currentAppId: params.currentAppId,
+    branchName: params.branchName,
+    lastSnapshotId: snapshot.id,
+    lastSnapshotHash: snapshot.snapshotHash,
+    lastServerRevisionId: appHead.headRevisionId ?? null,
+    lastServerTreeHash: appHead.treeHash ?? null,
+    lastServerHeadHash: appHead.headCommitHash,
+    lastSeenLocalCommitHash: snapshot.localCommitHash
+  });
+  return "seeded";
+}
+
+// src/application/collab/collabInitBinding.ts
+function requireResolvedLaneBinding(lane, params) {
+  if (lane.status === "resolved" && lane.currentAppId && lane.upstreamAppId) {
+    return lane;
+  }
+  const branchLabel = params.branchName ?? "the current branch";
+  const laneStatus = String(lane.status ?? "");
+  throw new RemixError(`Failed to resolve a Remix lane for ${branchLabel}.`, {
+    exitCode: 1,
+    hint: laneStatus === "binding_not_found" ? `Run ${params.operation} again after the repository has been initialized.` : laneStatus === "ambiguous_family_selection" ? "Multiple canonical Remix families match this repository. Continue from a checkout already bound to the intended family, or rerun with `--force-new` to create a new family." : `Remix did not return complete lane metadata for ${branchLabel}.`
+  });
+}
+function resolveProjectBindingResult(response) {
+  const payload = response?.responseObject;
+  if (!payload || typeof payload !== "object") {
+    return { status: "not_found" };
+  }
+  if (payload.status === "ambiguous_family_selection") {
+    const projectIds = Array.isArray(payload.projectIds) ? payload.projectIds.filter((value) => typeof value === "string" && value.trim().length > 0) : [];
+    return {
+      status: "ambiguous_family_selection",
+      candidateCount: typeof payload.candidateCount === "number" && Number.isFinite(payload.candidateCount) ? payload.candidateCount : projectIds.length,
+      projectIds
+    };
+  }
+  if (payload.projectId && payload.appId) {
+    return {
+      status: "resolved",
+      projectId: String(payload.projectId),
+      appId: String(payload.appId),
+      upstreamAppId: String(payload.upstreamAppId ?? payload.appId),
+      threadId: payload.threadId ? String(payload.threadId) : null
+    };
+  }
+  return { status: "not_found" };
+}
+function throwAmbiguousFamilyError(params) {
+  const familyCount = params.candidateCount || params.projectIds.length;
+  const projectHint = params.projectIds.length > 0 ? ` Matching project ids: ${params.projectIds.join(", ")}.` : "";
+  const remoteHint = params.remoteUrl ? ` (${params.remoteUrl})` : "";
+  throw new RemixError("Multiple canonical Remix families already match this repository.", {
+    exitCode: 2,
+    hint: `Plain \`remix collab init\` cannot safely choose among ${familyCount} matching canonical families for repo fingerprint ${params.repoFingerprint}${remoteHint}.${projectHint} Run \`remix collab init --force-new\` to create a new canonical family, or continue from a checkout already bound to the intended family.`
+  });
+}
+async function resolveOrEnsureLaneBinding(params) {
+  const resolvePayload = {
+    projectId: params.projectId ?? void 0,
+    repoFingerprint: params.repoFingerprint,
+    remoteUrl: params.remoteUrl ?? void 0,
+    defaultBranch: params.defaultBranch ?? void 0,
+    branchName: params.branchName
+  };
+  let lane = unwrapResponseObject(
+    await params.api.resolveProjectLaneBinding(resolvePayload),
+    "project lane binding"
+  );
+  if (lane.status !== "resolved") {
+    lane = unwrapResponseObject(
+      await params.api.ensureProjectLaneBinding({
+        ...resolvePayload,
+        seedAppId: params.seedAppId ?? void 0,
+        seedHeadCommitHash: params.seedHeadCommitHash ?? void 0
+      }),
+      "project lane binding"
+    );
+  }
+  return requireResolvedLaneBinding(lane, {
+    branchName: params.branchName,
+    operation: params.operation
+  });
+}
+function branchBindingFromLane(lane, mode, fallback) {
+  return {
+    projectId: lane.projectId ?? fallback.projectId,
+    currentAppId: lane.currentAppId ?? fallback.currentAppId,
+    upstreamAppId: lane.upstreamAppId ?? fallback.upstreamAppId,
+    threadId: lane.threadId ?? fallback.threadId,
+    laneId: lane.laneId ?? null,
+    bindingMode: mode
+  };
+}
+
+// src/application/collab/collabInitAsync.ts
+import { randomUUID as randomUUID4 } from "crypto";
+
+// src/infrastructure/collab/drainerLog.ts
+import fs8 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 fs8.mkdir(getLogsRoot(), { recursive: true });
+    await fs8.appendFile(getDrainerLogPath(), `${JSON.stringify(entry)}
+`, "utf8");
+  } catch {
+  }
+}
+function drainerLogPath() {
+  return getDrainerLogPath();
+}
+
+// src/application/collab/collabInitAsync.ts
+async function resolvePendingAsyncInitResult(params) {
+  if (shouldReplaceAsyncInitJobs({ forceNew: params.forceNew })) {
+    for (const kind of ["init", "init_post"]) {
+      const existing = await listAsyncJobsForRepo({ repoRoot: params.repoRoot, branchName: params.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
+        });
+      }
+    }
+    return null;
+  }
+  const pendingPost = await findPendingAsyncJob({ repoRoot: params.repoRoot, branchName: params.branchName, kind: "init_post" });
+  const pending = pendingPost ?? await findPendingAsyncJob({ repoRoot: params.repoRoot, branchName: params.branchName, kind: "init" });
+  if (!shouldReturnPendingAsyncInit({ forceNew: params.forceNew, pendingJobFound: Boolean(pending) }) || !pending) {
+    return null;
+  }
+  const existingBinding = await readCollabBinding(params.repoRoot);
+  if (existingBinding && existingBinding.currentAppId) {
+    return {
+      queued: true,
+      jobId: pending.id,
+      repoRoot: params.repoRoot,
+      projectId: existingBinding.projectId ?? "",
+      appId: existingBinding.currentAppId,
+      upstreamAppId: existingBinding.upstreamAppId ?? existingBinding.currentAppId,
+      dashboardUrl: buildDashboardAppUrl(existingBinding.currentAppId),
+      bindingPath: getCollabBindingPath(params.repoRoot),
+      repoFingerprint: existingBinding.repoFingerprint ?? params.repoFingerprint,
+      bindingMode: existingBinding.bindingMode,
+      createdCanonicalFamily: false,
+      remoteUrl: existingBinding.remoteUrl ?? params.remoteUrl,
+      defaultBranch: existingBinding.defaultBranch ?? params.defaultBranch ?? null,
+      ...params.warnings.length > 0 ? { warnings: params.warnings } : {}
+    };
+  }
+  return {
+    queued: true,
+    jobId: pending.id,
+    repoRoot: params.repoRoot,
+    projectId: "",
+    appId: "",
+    upstreamAppId: "",
+    dashboardUrl: "",
+    bindingPath: getCollabBindingPath(params.repoRoot),
+    repoFingerprint: params.repoFingerprint,
+    bindingMode: "lane",
+    createdCanonicalFamily: false,
+    remoteUrl: params.remoteUrl,
+    defaultBranch: params.defaultBranch ?? null,
+    ...params.warnings.length > 0 ? { warnings: params.warnings } : {}
+  };
+}
+async function clearFailedAsyncInitJobs(params) {
+  if (params.forceNew) return;
+  const failed = await findFailedAsyncJob({ repoRoot: params.repoRoot, branchName: params.branchName, kind: "init" });
+  if (failed) {
+    await deleteAsyncJob(failed.id);
+  }
+  const failedPost = await findFailedAsyncJob({ repoRoot: params.repoRoot, branchName: params.branchName, kind: "init_post" });
+  if (failedPost) {
+    await deleteAsyncJob(failedPost.id);
+  }
+}
+async function enqueueInitPostJob(params) {
+  const job = await enqueueAsyncJob({
+    id: randomUUID4(),
+    kind: "init_post",
+    status: "queued",
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.repoFingerprint,
+    branchName: params.branchName,
+    laneId: params.laneId,
+    retryCount: 0,
+    error: null,
+    idempotencyKey: null,
+    payload: {
+      appId: params.appId,
+      syncPhaseStartedAt: params.syncPhaseStartedAt,
+      syncPhaseFinishedAt: params.syncPhaseFinishedAt
+    }
+  });
+  await logDrainerEvent(job.id, "submitted", {
+    kind: "init_post",
+    appId: params.appId,
+    ["init.sync_phase_ms"]: params.syncPhaseFinishedAt - params.syncPhaseStartedAt
+  });
+  return job;
+}
+
+// src/application/collab/collabInitImport.ts
+import fs10 from "fs/promises";
+import path9 from "path";
+
+// src/shared/upload.ts
+import fs9 from "fs";
+import { PassThrough } from "stream";
+async function uploadPresigned(params) {
+  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 = fs9.createReadStream(params.filePath);
+  const pass = new PassThrough();
+  let sentBytes = 0;
+  fileStream.on("data", (chunk) => {
+    sentBytes += chunk.length;
+    params.onProgress?.({ sentBytes, totalBytes });
+  });
+  fileStream.on("error", (err) => pass.destroy(err));
+  fileStream.pipe(pass);
+  const response = await fetch(params.uploadUrl, {
+    method: "PUT",
+    headers: params.headers,
+    body: pass,
+    duplex: "half"
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new RemixError("Upload failed.", {
+      exitCode: 1,
+      hint: `Status: ${response.status}
+${text}`.trim() || null
+    });
+  }
 }
-async function seedImportedInitBaseline(params) {
-  const appHead = unwrapResponseObject(
-    await params.api.getAppHead(params.currentAppId),
-    "app head"
-  );
-  const snapshot = await captureLocalSnapshot({
-    repoRoot: params.repoRoot,
-    repoFingerprint: params.repoFingerprint,
-    laneId: params.laneId,
-    branchName: params.branchName
+
+// src/application/collab/collabInitImport.ts
+async function uploadInitBundle(params) {
+  const bundleName = params.bundleName ?? path9.basename(params.bundlePath);
+  const bundleSize = (await fs10.stat(params.bundlePath)).size;
+  const presignResp = await params.api.presignImportUploadFirstParty({
+    file: {
+      name: bundleName,
+      mimeType: "application/x-git-bundle",
+      size: bundleSize,
+      checksumSha256: params.bundleSha
+    }
   });
-  await writeLocalBaseline({
-    repoRoot: params.repoRoot,
-    repoFingerprint: params.repoFingerprint,
-    laneId: params.laneId,
-    currentAppId: params.currentAppId,
-    branchName: params.branchName,
-    lastSnapshotId: snapshot.id,
-    lastSnapshotHash: snapshot.snapshotHash,
-    lastServerRevisionId: appHead.headRevisionId ?? null,
-    lastServerTreeHash: appHead.treeHash ?? null,
-    lastServerHeadHash: appHead.headCommitHash,
-    lastSeenLocalCommitHash: snapshot.localCommitHash
+  const presign = unwrapResponseObject(presignResp, "upload");
+  await uploadPresigned({
+    uploadUrl: String(presign.uploadUrl),
+    headers: presign.headers ?? {},
+    filePath: params.bundlePath
   });
-  return "seeded";
+  return String(presign.uploadId);
+}
+async function importUploadedInitBundle(params) {
+  const importPayload = {
+    uploadId: params.uploadId,
+    appName: params.appName,
+    platform: "generic",
+    profile: params.profile ?? void 0,
+    isPublic: false,
+    branch: params.branch ?? void 0,
+    remoteUrl: params.remoteUrl ?? void 0,
+    defaultBranch: params.defaultBranch ?? void 0,
+    repoFingerprint: params.repoFingerprint,
+    headCommitHash: params.headCommitHash,
+    forceNew: params.forceNew
+  };
+  if ("path" in params) {
+    importPayload.path = params.path?.trim() || void 0;
+  }
+  const importResp = await params.api.importFromUploadFirstParty(importPayload);
+  return unwrapResponseObject(importResp, "import");
 }
+
+// src/application/collab/collabInit.ts
 async function collabInit(params) {
   return withRepoMutationLock(
     {
@@ -4457,7 +4841,7 @@ async function collabInit(params) {
       }
       const localBindingState = await readCollabBindingState(repoRoot, { persist: true });
       const hasExistingBinding = localBindingState != null && Object.keys(localBindingState.branchBindings ?? {}).length > 0;
-      if (params.forceNew || !hasExistingBinding) {
+      if (shouldRequireCleanWorktreeForInit({ forceNew: params.forceNew, hasExistingBinding })) {
         await ensureCleanWorktree(repoRoot, "`remix collab init`");
       }
       const persistedRemoteUrl = normalizeGitRemote(localBindingState?.remoteUrl ?? null);
@@ -4469,59 +4853,17 @@ async function collabInit(params) {
       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),
-                repoFingerprint: existingBinding.repoFingerprint ?? repoFingerprint,
-                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),
-              repoFingerprint,
-              bindingMode: "lane",
-              createdCanonicalFamily: false,
-              remoteUrl,
-              defaultBranch: defaultBranch ?? null,
-              ...warnings.length > 0 ? { warnings } : {}
-            };
-          }
+        const pendingResult = await resolvePendingAsyncInitResult({
+          forceNew: params.forceNew,
+          repoRoot,
+          branchName,
+          repoFingerprint,
+          remoteUrl,
+          defaultBranch: defaultBranch ?? null,
+          warnings
+        });
+        if (pendingResult) {
+          return pendingResult;
         }
       }
       if (!params.forceNew && localBindingState?.explicitRootBinding && branchName) {
@@ -4613,7 +4955,7 @@ async function collabInit(params) {
           appId: boundCurrentAppId2,
           dashboardUrl: buildDashboardAppUrl(boundCurrentAppId2),
           upstreamAppId: boundUpstreamAppId2,
-          bindingPath: path9.join(repoRoot, ".remix", "config.json"),
+          bindingPath: path10.join(repoRoot, ".remix", "config.json"),
           repoRoot,
           repoFingerprint,
           bindingMode: defaultBranch && branchName !== defaultBranch ? "lane" : "explicit_root",
@@ -4878,53 +5220,33 @@ async function collabInit(params) {
         }
       }
       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);
-          }
-        }
+        await clearFailedAsyncInitJobs({ forceNew: params.forceNew, repoRoot, branchName });
         const syncPhaseStartedAt = Date.now();
         const { bundlePath: bundleFilePath, headCommitHash: bundledHeadCommitHash } = await createGitBundle(
           repoRoot,
           "repository.bundle"
         );
-        const tmpBundleDir = path9.dirname(bundleFilePath);
+        const tmpBundleDir = path10.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 uploadId2 = await uploadInitBundle({
+            api: params.api,
+            bundlePath: bundleFilePath,
+            bundleSha: bundleSha2,
+            bundleName: "repository.bundle"
           });
-          const importResp2 = await params.api.importFromUploadFirstParty({
-            uploadId: String(presign2.uploadId),
-            appName: params.appName?.trim() || path9.basename(repoRoot),
-            platform: "generic",
+          const imported2 = await importUploadedInitBundle({
+            api: params.api,
+            uploadId: uploadId2,
+            appName: params.appName?.trim() || path10.basename(repoRoot),
             profile: params.profile ?? void 0,
-            isPublic: false,
             branch: defaultBranch && branchName && branchName !== defaultBranch ? defaultBranch : currentBranch ?? void 0,
-            remoteUrl: remoteUrl ?? void 0,
-            defaultBranch: defaultBranch ?? void 0,
+            remoteUrl,
+            defaultBranch: defaultBranch ?? null,
             repoFingerprint,
             headCommitHash: bundledHeadCommitHash,
             forceNew: params.forceNew
           });
-          const imported2 = unwrapResponseObject(importResp2, "import");
           const importedAppId = String(imported2.appId);
           let boundProjectId2 = String(imported2.projectId ?? "");
           let boundCurrentAppId2 = importedAppId;
@@ -5049,28 +5371,14 @@ async function collabInit(params) {
             });
           }
           const syncPhaseFinishedAt = Date.now();
-          const jobId = randomUUID4();
-          const job = await enqueueAsyncJob({
-            id: jobId,
-            kind: "init_post",
-            status: "queued",
+          const job = await enqueueInitPostJob({
             repoRoot,
             repoFingerprint,
             branchName,
             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
+            syncPhaseStartedAt,
+            syncPhaseFinishedAt
           });
           return {
             queued: true,
@@ -5089,41 +5397,30 @@ async function collabInit(params) {
             ...warnings.length > 0 ? { warnings } : {}
           };
         } finally {
-          await fs10.rm(tmpBundleDir, { recursive: true, force: true }).catch(() => void 0);
+          await fs11.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 fs10.stat(bundlePath)).size;
-      const presignResp = await params.api.presignImportUploadFirstParty({
-        file: {
-          name: "repository.bundle",
-          mimeType: "application/x-git-bundle",
-          size: bundleSize,
-          checksumSha256: bundleSha
-        }
-      });
-      const presign = unwrapResponseObject(presignResp, "upload");
-      await uploadPresigned({
-        uploadUrl: String(presign.uploadUrl),
-        headers: presign.headers ?? {},
-        filePath: bundlePath
+      const uploadId = await uploadInitBundle({
+        api: params.api,
+        bundlePath,
+        bundleSha,
+        bundleName: "repository.bundle"
       });
-      const importResp = await params.api.importFromUploadFirstParty({
-        uploadId: String(presign.uploadId),
-        appName: params.appName?.trim() || path9.basename(repoRoot),
+      const imported = await importUploadedInitBundle({
+        api: params.api,
+        uploadId,
+        appName: params.appName?.trim() || path10.basename(repoRoot),
         path: params.path?.trim() || void 0,
-        platform: "generic",
         profile: params.profile ?? void 0,
-        isPublic: false,
         branch: defaultBranch && branchName && branchName !== defaultBranch ? defaultBranch : currentBranch ?? void 0,
-        remoteUrl: remoteUrl ?? void 0,
-        defaultBranch: defaultBranch ?? void 0,
+        remoteUrl,
+        defaultBranch: defaultBranch ?? null,
         repoFingerprint,
         headCommitHash,
         forceNew: params.forceNew
       });
-      const imported = unwrapResponseObject(importResp, "import");
       const app = await pollAppImported(params.api, String(imported.appId));
       let boundProjectId = String(app.projectId);
       let boundCurrentAppId = String(app.id);
@@ -5323,10 +5620,10 @@ async function collabList(params) {
 }
 
 // src/application/collab/collabReconcile.ts
-import fs11 from "fs/promises";
+import fs12 from "fs/promises";
 import os5 from "os";
-import path10 from "path";
-import { execa as execa3 } from "execa";
+import path11 from "path";
+import { execa as execa2 } from "execa";
 
 // src/application/collab/pendingFinalize.ts
 function hasPendingFinalize(summary) {
@@ -5336,6 +5633,50 @@ function buildPendingFinalizeHint() {
   return "Drain or await the local finalize queue first, then retry after the queued Remix turn finishes recording remotely.";
 }
 
+// src/application/collab/reconcileDecision.ts
+function classifyReconcileDelta(delta) {
+  if (delta.status === "conflict_risk") {
+    return {
+      action: "metadata_conflict",
+      message: "Local repository metadata conflicts with the bound Remix app.",
+      exitCode: 2,
+      hint: delta.warnings.join("\n") || "Run the command from the correct bound repository."
+    };
+  }
+  if (delta.status === "base_unknown") {
+    return {
+      action: "base_unknown",
+      message: "Reconcile cannot pull the newer server state from the last acknowledged baseline.",
+      exitCode: 2,
+      hint: "Run `remix collab init` to seed a fresh revision baseline for this checkout before retrying."
+    };
+  }
+  if (delta.status !== "delta_ready" && delta.status !== "up_to_date") {
+    return {
+      action: "unsupported_delta",
+      message: "Reconcile could not determine the server delta for this lane.",
+      exitCode: 1,
+      hint: delta.warnings.join("\n") || "Run `remix collab status` and retry once the lane is healthy."
+    };
+  }
+  return { action: "ready" };
+}
+function classifyReconcileDetectedState(detected) {
+  if (detected.status === "metadata_conflict" || detected.status === "branch_mismatch") {
+    return { action: "realign", hint: detected.hint };
+  }
+  if (detected.repoState === "server_only_changed" || detected.repoState === "idle") return { action: "sync_instead" };
+  if (detected.repoState === "both_changed") return { action: "reconcile" };
+  if (detected.repoState === "external_local_base_changed") {
+    return { action: "external_local_base_changed", hint: detected.hint };
+  }
+  if (detected.repoState === "local_only_changed") return { action: "local_only_finalize" };
+  return { action: "not_reconcilable", hint: detected.hint };
+}
+function shouldApplyServerDeltaBeforeReplay(params) {
+  return params.deltaStatus === "delta_ready" && params.diff.trim().length > 0;
+}
+
 // src/application/collab/collabReconcile.ts
 async function reconcileBothChanged(params) {
   const repoRoot = await findGitRoot(params.cwd);
@@ -5391,22 +5732,11 @@ async function reconcileBothChanged(params) {
   ]);
   const appHead = unwrapResponseObject(appHeadResp, "app head");
   const delta = unwrapResponseObject(deltaResp, "app delta");
-  if (delta.status === "conflict_risk") {
-    throw new RemixError("Local repository metadata conflicts with the bound Remix app.", {
-      exitCode: 2,
-      hint: delta.warnings.join("\n") || "Run the command from the correct bound repository."
-    });
-  }
-  if (delta.status === "base_unknown") {
-    throw new RemixError("Reconcile cannot pull the newer server state from the last acknowledged baseline.", {
-      exitCode: 2,
-      hint: "Run `remix collab init` to seed a fresh revision baseline for this checkout before retrying."
-    });
-  }
-  if (delta.status !== "delta_ready" && delta.status !== "up_to_date") {
-    throw new RemixError("Reconcile could not determine the server delta for this lane.", {
-      exitCode: 1,
-      hint: delta.warnings.join("\n") || "Run `remix collab status` and retry once the lane is healthy."
+  const deltaDecision = classifyReconcileDelta(delta);
+  if (deltaDecision.action !== "ready") {
+    throw new RemixError(deltaDecision.message, {
+      exitCode: deltaDecision.exitCode,
+      hint: deltaDecision.hint
     });
   }
   const preview = {
@@ -5460,15 +5790,15 @@ 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 fs11.mkdtemp(path10.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 = path10.join(tempRoot, "repo");
-    await fs11.mkdir(tempRepoRoot, { recursive: true });
-    await execa3("git", ["init"], { cwd: tempRepoRoot, stderr: "ignore" });
+    const tempRepoRoot = path11.join(tempRoot, "repo");
+    await fs12.mkdir(tempRepoRoot, { recursive: true });
+    await execa2("git", ["init"], { cwd: tempRepoRoot, stderr: "ignore" });
     await materializeLocalSnapshot(baseline.lastSnapshotId, tempRepoRoot);
-    if (delta.status === "delta_ready" && delta.diff.trim()) {
+    if (shouldApplyServerDeltaBeforeReplay({ deltaStatus: delta.status, diff: delta.diff })) {
       await applyUnifiedDiffToWorktree(tempRepoRoot, delta.diff, "`remix collab reconcile`");
     }
     serverHeadSnapshot = await captureLocalSnapshot({
@@ -5487,7 +5817,7 @@ async function reconcileBothChanged(params) {
       branchName: binding.branchName
     });
   } finally {
-    await fs11.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 });
@@ -5548,25 +5878,30 @@ async function collabReconcile(params) {
     cwd: params.cwd,
     allowBranchMismatch: params.allowBranchMismatch
   });
-  if (detected.status === "metadata_conflict" || detected.status === "branch_mismatch") {
+  const detectedDecision = classifyReconcileDetectedState({
+    status: detected.status,
+    repoState: detected.repoState,
+    hint: detected.hint
+  });
+  if (detectedDecision.action === "realign") {
     throw new RemixError("Repository must be realigned before reconciliation.", {
       exitCode: 2,
-      hint: detected.hint
+      hint: detectedDecision.hint
     });
   }
-  if (detected.repoState === "server_only_changed" || detected.repoState === "idle") {
+  if (detectedDecision.action === "sync_instead") {
     return collabSync(params);
   }
-  if (detected.repoState === "both_changed") {
+  if (detectedDecision.action === "reconcile") {
     return reconcileBothChanged(params);
   }
-  if (detected.repoState === "external_local_base_changed") {
+  if (detectedDecision.action === "external_local_base_changed") {
     throw new RemixError("This checkout needs a local Remix revision baseline before reconciliation.", {
       exitCode: 2,
-      hint: detected.hint || "Run `remix collab init` or `remix collab sync` to seed the baseline."
+      hint: detectedDecision.hint || "Run `remix collab init` or `remix collab sync` to seed the baseline."
     });
   }
-  if (detected.repoState === "local_only_changed") {
+  if (detectedDecision.action === "local_only_finalize") {
     if (hasPendingFinalize(detected.pendingFinalize)) {
       throw new RemixError("Reconcile is not needed while queued Remix turn recording is still processing.", {
         exitCode: 2,
@@ -5690,7 +6025,85 @@ async function collabRemix(params) {
   };
 }
 
+// src/infrastructure/collab/localStateRepository.ts
+var defaultLocalStateRepository = {
+  baselines: {
+    read: readLocalBaseline,
+    write: writeLocalBaseline,
+    clear: clearLocalBaseline
+  },
+  snapshots: {
+    inspect: inspectLocalSnapshot,
+    capture: captureLocalSnapshot,
+    read: readLocalSnapshot,
+    materialize: materializeLocalSnapshot,
+    restoreToWorktree: restoreLocalSnapshotToWorktree,
+    diff: diffLocalSnapshots
+  },
+  asyncJobs: {
+    enqueue: enqueueAsyncJob,
+    read: readAsyncJob,
+    list: listAsyncJobs,
+    listForRepo: listAsyncJobsForRepo,
+    findPending: findPendingAsyncJob,
+    findFailed: findFailedAsyncJob,
+    update: updateAsyncJob,
+    delete: deleteAsyncJob,
+    claim: claimAsyncJob,
+    summarize: summarizeAsyncJobs,
+    pruneTerminal: pruneTerminalAsyncJobs,
+    getBundleFilePath: getAsyncJobBundleFilePath,
+    await: awaitAsyncJob
+  },
+  finalizeJobs: {
+    enqueue: enqueuePendingFinalizeJob,
+    read: readPendingFinalizeJob,
+    list: listPendingFinalizeJobs,
+    update: updatePendingFinalizeJob,
+    claim: claimPendingFinalizeJob,
+    remove: removePendingFinalizeJob,
+    forget: forgetPendingFinalizeJob,
+    requeue: requeuePendingFinalizeJob,
+    heartbeatLock: heartbeatJobLock,
+    cleanStaleLocks: cleanStaleFinalizeJobLocks,
+    prune: prunePendingFinalizeJobs,
+    summarize: summarizePendingFinalizeJobs
+  },
+  bindings: {
+    getPath: getCollabBindingPath,
+    read: readCollabBinding,
+    readState: readCollabBindingState,
+    write: writeCollabBinding,
+    writeSnapshot: writeCollabBindingSnapshot
+  }
+};
+function createLocalStateRepository(overrides = {}) {
+  return {
+    baselines: {
+      ...defaultLocalStateRepository.baselines,
+      ...overrides.baselines
+    },
+    snapshots: {
+      ...defaultLocalStateRepository.snapshots,
+      ...overrides.snapshots
+    },
+    asyncJobs: {
+      ...defaultLocalStateRepository.asyncJobs,
+      ...overrides.asyncJobs
+    },
+    finalizeJobs: {
+      ...defaultLocalStateRepository.finalizeJobs,
+      ...overrides.finalizeJobs
+    },
+    bindings: {
+      ...defaultLocalStateRepository.bindings,
+      ...overrides.bindings
+    }
+  };
+}
+
 // src/application/collab/collabRequestMerge.ts
+var localState = createLocalStateRepository();
 async function collabRequestMerge(params) {
   const repoRoot = await findGitRoot(params.cwd);
   const binding = await ensureActiveLaneBinding({
@@ -5698,14 +6111,24 @@ async function collabRequestMerge(params) {
     api: params.api,
     operation: "`remix collab request-merge`"
   });
-  if (!binding) throw new RemixError("Repository is not bound to Remix.", { exitCode: 2 });
-  const pendingFinalize = await summarizePendingFinalizeJobs({
+  if (!binding) {
+    const transition2 = planRequestMergeWorkflowTransition({ hasBinding: false, hasPendingFinalize: false });
+    if (transition2.action === "require_binding") {
+      throw new RemixError("Repository is not bound to Remix.", { exitCode: 2 });
+    }
+    throw new RemixError("Repository is not bound to Remix.", { exitCode: 2 });
+  }
+  const pendingFinalize = await localState.finalizeJobs.summarize({
     repoRoot,
     repoFingerprint: binding.repoFingerprint,
     currentAppId: binding.currentAppId,
     laneId: binding.laneId
   });
-  if (hasPendingFinalize(pendingFinalize)) {
+  const transition = planRequestMergeWorkflowTransition({
+    hasBinding: true,
+    hasPendingFinalize: hasPendingFinalize(pendingFinalize)
+  });
+  if (transition.action === "require_finalize_drain") {
     throw new RemixError("Pending Remix turn recording still processing.", {
       exitCode: 2,
       hint: buildPendingFinalizeHint()
@@ -6125,9 +6548,34 @@ async function collabView(params) {
 }
 
 // src/application/collab/collabAsyncProcessing.ts
-import fs12 from "fs/promises";
-import path11 from "path";
-var MAX_TRANSIENT_RETRIES = 5;
+import fs13 from "fs/promises";
+import path12 from "path";
+
+// src/application/collab/collabDependencies.ts
+import { randomUUID as randomUUID5 } from "crypto";
+function isFullLocalStateRepository(value) {
+  return typeof value.bindings?.getPath === "function" && typeof value.bindings.read === "function" && typeof value.bindings.readState === "function" && typeof value.bindings.write === "function" && typeof value.bindings.writeSnapshot === "function" && typeof value.baselines?.read === "function" && typeof value.baselines.write === "function" && typeof value.baselines.clear === "function" && typeof value.snapshots?.inspect === "function" && typeof value.snapshots.capture === "function" && typeof value.snapshots.read === "function" && typeof value.snapshots.materialize === "function" && typeof value.snapshots.restoreToWorktree === "function" && typeof value.snapshots.diff === "function" && typeof value.asyncJobs?.enqueue === "function" && typeof value.asyncJobs.read === "function" && typeof value.asyncJobs.list === "function" && typeof value.asyncJobs.listForRepo === "function" && typeof value.asyncJobs.findPending === "function" && typeof value.asyncJobs.findFailed === "function" && typeof value.asyncJobs.update === "function" && typeof value.asyncJobs.delete === "function" && typeof value.asyncJobs.claim === "function" && typeof value.asyncJobs.summarize === "function" && typeof value.asyncJobs.pruneTerminal === "function" && typeof value.asyncJobs.getBundleFilePath === "function" && typeof value.asyncJobs.await === "function" && typeof value.finalizeJobs?.enqueue === "function" && typeof value.finalizeJobs.read === "function" && typeof value.finalizeJobs.list === "function" && typeof value.finalizeJobs.update === "function" && typeof value.finalizeJobs.claim === "function" && typeof value.finalizeJobs.remove === "function" && typeof value.finalizeJobs.forget === "function" && typeof value.finalizeJobs.requeue === "function" && typeof value.finalizeJobs.heartbeatLock === "function" && typeof value.finalizeJobs.cleanStaleLocks === "function" && typeof value.finalizeJobs.prune === "function" && typeof value.finalizeJobs.summarize === "function";
+}
+function createCollabDependencies(overrides = {}) {
+  const defaultClock = {
+    now: () => Date.now(),
+    isoNow: () => (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const defaultTimers = {
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+  };
+  const localState3 = overrides.localState ? isFullLocalStateRepository(overrides.localState) ? overrides.localState : createLocalStateRepository(overrides.localState) : createLocalStateRepository();
+  return {
+    clock: { ...defaultClock, ...overrides.clock },
+    ids: { randomUUID: randomUUID5, ...overrides.ids },
+    timers: { ...defaultTimers, ...overrides.timers },
+    git: overrides.git ?? createSystemGitAdapter(),
+    localState: localState3,
+    uploadPresigned: overrides.uploadPresigned ?? uploadPresigned
+  };
+}
+
+// src/application/collab/errorTaxonomy.ts
 var TRANSIENT_NETWORK_CODES = /* @__PURE__ */ new Set([
   "ECONNREFUSED",
   "ECONNRESET",
@@ -6139,9 +6587,10 @@ var TRANSIENT_NETWORK_CODES = /* @__PURE__ */ new Set([
   "EPIPE",
   "UND_ERR_SOCKET",
   "UND_ERR_CONNECT_TIMEOUT",
-  "UND_ERR_HEADERS_TIMEOUT"
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_BODY_TIMEOUT"
 ]);
-function formatError(error) {
+function formatWorkflowError(error) {
   if (error instanceof RemixError) {
     return [error.message, error.hint].filter(Boolean).join("\n\n") || error.message || "Unknown error.";
   }
@@ -6167,8 +6616,15 @@ function readStringCandidate(error, key) {
   if (typeof value === "string" && value.length > 0) return value;
   return null;
 }
-function classifyError(error) {
-  if (error instanceof RemixError) return "jobSpecific";
+function buildClassification(category, retryable) {
+  return {
+    category,
+    retryable,
+    terminal: !retryable,
+    disposition: retryable ? "transient" : "jobSpecific"
+  };
+}
+function classifyWorkflowError(error) {
   const candidates = [error];
   if (error && typeof error === "object" && "cause" in error) {
     candidates.push(error.cause);
@@ -6176,31 +6632,42 @@ function classifyError(error) {
   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";
+      if (status === 401 || status === 403) return buildClassification("transient_backend", true);
+      if (status >= 500 && status < 600) return buildClassification("transient_backend", true);
+      if (status >= 400 && status < 500) return buildClassification("backend_contract_failure", false);
     }
     const code = readStringCandidate(candidate, "code");
-    if (code && TRANSIENT_NETWORK_CODES.has(code)) return "transient";
-    if (code === "ENOENT" || code === "EACCES") return "jobSpecific";
+    if (code && TRANSIENT_NETWORK_CODES.has(code)) return buildClassification("transient_network", true);
+    if (code === "ENOENT" || code === "EACCES") return buildClassification("persisted_state_corruption", false);
     const name = readStringCandidate(candidate, "name");
-    if (name === "AbortError" || name === "TimeoutError") return "transient";
-    if (name === "SyntaxError") return "jobSpecific";
+    if (name === "AbortError" || name === "TimeoutError") return buildClassification("transient_network", true);
+    if (name === "SyntaxError") return buildClassification("backend_contract_failure", false);
   }
-  return "jobSpecific";
+  if (error instanceof RemixError) return buildClassification("user_action_needed", false);
+  return buildClassification("backend_contract_failure", false);
+}
+
+// src/application/collab/workflowEvents.ts
+async function logDrainerWorkflowEvent(jobId, event, fields = {}) {
+  await logDrainerEvent(jobId, event, fields);
 }
+
+// src/application/collab/collabAsyncProcessing.ts
+var MAX_TRANSIENT_RETRIES = 5;
+var collabDependencies = createCollabDependencies();
+var localState2 = collabDependencies.localState;
 async function handleProcessError(job, error) {
-  const message = formatError(error);
-  const kind = classifyError(error);
+  const message = formatWorkflowError(error);
+  const { disposition: kind } = classifyWorkflowError(error);
   if (kind === "transient") {
     const nextRetry = (job.retryCount ?? 0) + 1;
     if (nextRetry < MAX_TRANSIENT_RETRIES) {
-      await updateAsyncJob(job.id, {
+      await localState2.asyncJobs.update(job.id, {
         status: "queued",
         retryCount: nextRetry,
         error: message
       });
-      await logDrainerEvent(job.id, "retrying", {
+      await logDrainerWorkflowEvent(job.id, "retrying", {
         kind: job.kind,
         retryCount: nextRetry,
         error: message
@@ -6208,41 +6675,41 @@ async function handleProcessError(job, error) {
       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 });
+    await localState2.asyncJobs.update(job.id, { status: "failed", error: finalMessage, retryCount: nextRetry });
+    await logDrainerWorkflowEvent(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 });
+  await localState2.asyncJobs.update(job.id, { status: "failed", error: message });
+  await logDrainerWorkflowEvent(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();
+  const startedAt = collabDependencies.clock.now();
   try {
-    await updateAsyncJob(job.id, { status: "submitting", error: null });
-    await logDrainerEvent(job.id, "claimed", { kind: "init" });
-    const bundleStat = await fs12.stat(job.payload.bundlePath);
+    await localState2.asyncJobs.update(job.id, { status: "submitting", error: null });
+    await logDrainerWorkflowEvent(job.id, "claimed", { kind: "init" });
+    const bundleStat = await fs13.stat(job.payload.bundlePath);
     const presignResp = await api.presignImportUploadFirstParty({
       file: {
-        name: path11.basename(job.payload.bundlePath),
+        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({
+    await localState2.asyncJobs.update(job.id, { status: "uploading" });
+    await logDrainerWorkflowEvent(job.id, "uploading", { kind: "init" });
+    await collabDependencies.uploadPresigned({
       uploadUrl: String(presign.uploadUrl),
       headers: presign.headers ?? {},
       filePath: job.payload.bundlePath
     });
-    await updateAsyncJob(job.id, { status: "server_processing" });
+    await localState2.asyncJobs.update(job.id, { status: "server_processing" });
     const importResp = await api.importFromUploadFirstParty({
       uploadId: String(presign.uploadId),
-      appName: job.payload.appName?.trim() || path11.basename(job.repoRoot),
+      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,
@@ -6252,11 +6719,14 @@ async function processInitJob(job, api) {
       headCommitHash: job.payload.headCommitHash
     });
     const imported = unwrapResponseObject(importResp, "import");
-    await logDrainerEvent(job.id, "server_accepted", {
+    await logDrainerWorkflowEvent(job.id, "server_accepted", {
       kind: "init",
       appId: String(imported.appId ?? "")
     });
-    const app = await pollAppReady(api, String(imported.appId));
+    const app = await pollAppReady(api, String(imported.appId), {
+      clock: collabDependencies.clock,
+      timers: collabDependencies.timers
+    });
     let boundProjectId = String(app.projectId);
     let boundCurrentAppId = String(app.id);
     let boundUpstreamAppId = String(app.id);
@@ -6316,7 +6786,10 @@ async function processInitJob(job, api) {
       }
     }
     if (boundCurrentAppId) {
-      const readyApp = await pollAppReady(api, boundCurrentAppId);
+      const readyApp = await pollAppReady(api, boundCurrentAppId, {
+        clock: collabDependencies.clock,
+        timers: collabDependencies.timers
+      });
       boundProjectId = String(readyApp.projectId ?? boundProjectId);
       boundThreadId = readyApp.threadId ? String(readyApp.threadId) : boundThreadId;
     }
@@ -6339,7 +6812,7 @@ async function processInitJob(job, api) {
           bindingMode: "lane"
         };
       }
-      await writeCollabBindingSnapshot({
+      await localState2.bindings.writeSnapshot({
         repoRoot,
         repoFingerprint: repoFingerprint ?? "",
         remoteUrl,
@@ -6349,7 +6822,7 @@ async function processInitJob(job, api) {
       });
     } else {
       if (canonicalLane && defaultBranch && branchName && branchName !== defaultBranch) {
-        await writeCollabBinding(repoRoot, {
+        await localState2.bindings.write(repoRoot, {
           projectId: canonicalLane.projectId ?? null,
           currentAppId: canonicalLane.currentAppId ?? boundCurrentAppId,
           upstreamAppId: canonicalLane.upstreamAppId ?? canonicalLane.currentAppId ?? boundCurrentAppId,
@@ -6367,7 +6840,7 @@ async function processInitJob(job, api) {
           bindingMode: "explicit_root"
         });
       }
-      await writeCollabBinding(repoRoot, {
+      await localState2.bindings.write(repoRoot, {
         projectId: boundProjectId,
         currentAppId: boundCurrentAppId,
         upstreamAppId: boundUpstreamAppId,
@@ -6388,14 +6861,14 @@ async function processInitJob(job, api) {
       currentAppId: boundCurrentAppId,
       branchName
     });
-    await logDrainerEvent(job.id, "server_completed", {
+    await logDrainerWorkflowEvent(job.id, "server_completed", {
       kind: "init",
       appId: boundCurrentAppId,
       dashboardUrl: buildDashboardAppUrl(boundCurrentAppId),
-      durationMs: Date.now() - startedAt
+      durationMs: collabDependencies.clock.now() - startedAt
     });
-    await updateAsyncJob(job.id, { status: "completed", error: null });
-    await logDrainerEvent(job.id, "completed", { kind: "init", durationMs: Date.now() - startedAt });
+    await localState2.asyncJobs.update(job.id, { status: "completed", error: null });
+    await logDrainerWorkflowEvent(job.id, "completed", { kind: "init", durationMs: collabDependencies.clock.now() - startedAt });
     return { status: "completed", jobId: job.id };
   } catch (error) {
     return await handleProcessError(job, error);
@@ -6403,16 +6876,19 @@ async function processInitJob(job, api) {
 }
 async function processInitPostJob(job, api) {
   if (job.kind !== "init_post") return { status: "skipped", jobId: job.id };
-  const startedAt = Date.now();
+  const startedAt = collabDependencies.clock.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", {
+    await localState2.asyncJobs.update(job.id, { status: "server_processing", error: null });
+    await logDrainerWorkflowEvent(job.id, "claimed", {
       kind: "init_post",
       appId: job.payload.appId,
       syncPhaseMs
     });
-    await pollAppReady(api, job.payload.appId);
+    await pollAppReady(api, job.payload.appId, {
+      clock: collabDependencies.clock,
+      timers: collabDependencies.timers
+    });
     await seedImportedInitBaseline({
       api,
       repoRoot: job.repoRoot,
@@ -6421,9 +6897,9 @@ async function processInitPostJob(job, api) {
       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", {
+    const asyncPhaseMs = collabDependencies.clock.now() - startedAt;
+    await localState2.asyncJobs.update(job.id, { status: "completed", error: null });
+    await logDrainerWorkflowEvent(job.id, "completed", {
       kind: "init_post",
       appId: job.payload.appId,
       durationMs: asyncPhaseMs,
@@ -6437,10 +6913,10 @@ async function processInitPostJob(job, api) {
   } catch (error) {
     const outcome = await handleProcessError(job, error);
     if (outcome.status === "failed") {
-      const bindingPath = getCollabBindingPath(job.repoRoot);
+      const bindingPath = localState2.bindings.getPath(job.repoRoot);
       try {
-        await fs12.unlink(bindingPath);
-        await logDrainerEvent(job.id, "binding_cleared", {
+        await fs13.unlink(bindingPath);
+        await logDrainerWorkflowEvent(job.id, "binding_cleared", {
           kind: "init_post",
           appId: job.payload.appId,
           repoRoot: job.repoRoot,
@@ -6448,105 +6924,23 @@ async function processInitPostJob(job, api) {
           reason: "init_post_terminal_failure"
         });
       } catch (cleanupError) {
-        await logDrainerEvent(job.id, "binding_cleared", {
+        await logDrainerWorkflowEvent(job.id, "binding_cleared", {
           kind: "init_post",
           appId: job.payload.appId,
           repoRoot: job.repoRoot,
           bindingPath,
           reason: "init_post_terminal_failure",
-          cleanupError: formatError(cleanupError)
+          cleanupError: formatWorkflowError(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 fs12.stat(job.payload.bundlePath);
-      const presignResp = await api.presignImportUploadFirstParty({
-        file: {
-          name: path11.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);
+  const claim = await localState2.asyncJobs.claim(jobId);
   if (!claim) {
-    const job = await readAsyncJob(jobId);
+    const job = await localState2.asyncJobs.read(jobId);
     if (!job) return { status: "skipped", jobId };
     return { status: "skipped", jobId };
   }
@@ -6558,9 +6952,9 @@ async function collabInitProcess(jobId, opts) {
   }
 }
 async function collabInitPostProcess(jobId, opts) {
-  const claim = await claimAsyncJob(jobId);
+  const claim = await localState2.asyncJobs.claim(jobId);
   if (!claim) {
-    const job = await readAsyncJob(jobId);
+    const job = await localState2.asyncJobs.read(jobId);
     if (!job) return { status: "skipped", jobId };
     return { status: "skipped", jobId };
   }
@@ -6571,25 +6965,11 @@ async function collabInitPostProcess(jobId, opts) {
     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 fs12.mkdir(path11.dirname(pidPath), { recursive: true });
+  await fs13.mkdir(path12.dirname(pidPath), { recursive: true });
   try {
-    const existing = await fs12.readFile(pidPath, "utf8").catch(() => "");
+    const existing = await fs13.readFile(pidPath, "utf8").catch(() => "");
     const existingPid = parseInt(existing.trim(), 10);
     if (Number.isFinite(existingPid) && existingPid > 0 && existingPid !== process.pid) {
       try {
@@ -6599,13 +6979,13 @@ async function acquireDrainerPidLock() {
         if (error?.code !== "ESRCH") return null;
       }
     }
-    await fs12.writeFile(pidPath, String(process.pid), "utf8");
+    await fs13.writeFile(pidPath, String(process.pid), "utf8");
     return {
       release: async () => {
         try {
-          const current = (await fs12.readFile(pidPath, "utf8")).trim();
+          const current = (await fs13.readFile(pidPath, "utf8")).trim();
           if (current === String(process.pid)) {
-            await fs12.unlink(pidPath).catch(() => void 0);
+            await fs13.unlink(pidPath).catch(() => void 0);
           }
         } catch {
         }
@@ -6618,31 +6998,30 @@ async function acquireDrainerPidLock() {
 async function drainAsyncJobs(opts) {
   const lockHandle = opts.respectPidLock === false ? null : await acquireDrainerPidLock();
   if (opts.respectPidLock !== false && !lockHandle) return [];
-  const outcomes = [];
   try {
-    try {
-      await pruneTerminalAsyncJobs();
-    } catch {
-    }
-    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);
-    }
+    return await drainClaimedJobs({
+      prune: async () => {
+        try {
+          await localState2.asyncJobs.pruneTerminal();
+        } catch {
+        }
+      },
+      list: () => localState2.asyncJobs.list(),
+      isTerminal: (job) => planAsyncJobDrainTransition(job).terminal,
+      claim: async (job) => ({
+        job,
+        /* v8 ignore next -- async job processors perform their own claim/release cycle. */
+        release: async () => void 0
+      }),
+      process: async ({ job }) => {
+        const transition = planAsyncJobDrainTransition(job);
+        return transition.action === "process_init" ? collabInitProcess(job.id, { api: opts.api }) : collabInitPostProcess(job.id, { api: opts.api });
+      },
+      onError: "throw"
+    });
   } finally {
     if (lockHandle) await lockHandle.release();
   }
-  return outcomes;
 }
 export {
   FINALIZE_JOB_LOCK_STALE_MS,