@remixhq/core 0.1.2

package/dist/collab.js

@@ -0,0 +1,1917 @@
+import {
+  getCollabBindingPath,
+  readCollabBinding,
+  reserveAvailableDirPath,
+  reserveDirectory,
+  writeCollabBinding
+} from "./chunk-FAZUMWBS.js";
+import {
+  assertRepoSnapshotUnchanged,
+  buildRepoFingerprint,
+  captureRepoSnapshot,
+  checkoutLocalBranch,
+  cloneGitBundleToDirectory,
+  createBackupBranch,
+  createGitBundle,
+  discardCapturedUntrackedChanges,
+  discardTrackedChanges,
+  ensureCleanWorktree,
+  ensureCommitExists,
+  ensureGitInfoExcludeEntries,
+  fastForwardToCommit,
+  findGitRoot,
+  getCurrentBranch,
+  getDefaultBranch,
+  getGitCommonDir,
+  getHeadCommitHash,
+  getRemoteOriginUrl,
+  getWorkspaceSnapshot,
+  getWorktreeStatus,
+  hardResetToCommit,
+  importGitBundle,
+  normalizeGitRemote,
+  preserveWorkspaceChanges,
+  reapplyPreservedWorkspaceChanges,
+  requireCurrentBranch,
+  summarizeUnifiedDiff,
+  validateUnifiedDiff,
+  writeTempUnifiedDiffBackup
+} from "./chunk-UGKPOCN5.js";
+import {
+  REMIX_ERROR_CODES
+} from "./chunk-GC2MOT3U.js";
+import {
+  RemixError
+} from "./chunk-YZ34ICNN.js";
+
+// src/application/collab/collabAdd.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+
+// src/application/collab/branchPolicy.ts
+function describeBranch(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || "(detached)";
+}
+function isPreferredBranchMatch(currentBranch, preferredBranch) {
+  const current = String(currentBranch ?? "").trim();
+  const preferred = String(preferredBranch ?? "").trim();
+  if (!preferred || !current) return true;
+  return current === preferred;
+}
+function buildPreferredBranchMismatchHint(params) {
+  const overrideFlag = params.overrideFlag?.trim() || "--allow-branch-mismatch";
+  return [
+    `Current branch: ${describeBranch(params.currentBranch)}`,
+    `Preferred branch: ${describeBranch(params.preferredBranch)}`,
+    `Switch to ${describeBranch(params.preferredBranch)} or rerun with ${overrideFlag} if this is intentional.`
+  ].join("\n");
+}
+function assertPreferredBranchMatch(params) {
+  if (params.allowBranchMismatch) return;
+  if (isPreferredBranchMatch(params.currentBranch, params.preferredBranch)) return;
+  throw new RemixError(`Current branch does not match this checkout's Remix preferred branch while running ${params.operation}.`, {
+    code: REMIX_ERROR_CODES.PREFERRED_BRANCH_MISMATCH,
+    exitCode: 2,
+    hint: buildPreferredBranchMismatchHint({
+      currentBranch: params.currentBranch,
+      preferredBranch: params.preferredBranch,
+      overrideFlag: params.overrideFlag
+    })
+  });
+}
+
+// src/application/collab/shared.ts
+import { createHash } from "crypto";
+function unwrapResponseObject(resp, label) {
+  const obj = resp?.responseObject;
+  if (obj === void 0 || obj === null) {
+    const message = typeof resp?.message === "string" && resp.message.trim().length > 0 ? resp.message : `Missing ${label} response`;
+    throw new RemixError(message, { exitCode: 1, hint: resp ? JSON.stringify(resp, null, 2) : null });
+  }
+  return obj;
+}
+function unwrapMergeRequest(resp) {
+  return unwrapResponseObject(resp, "merge request");
+}
+function unwrapMergeRequestReview(resp) {
+  return unwrapResponseObject(resp, "merge request review");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function buildDeterministicIdempotencyKey(parts) {
+  return createHash("sha256").update(JSON.stringify(parts)).digest("hex");
+}
+function formatCliErrorDetail(err) {
+  if (err instanceof RemixError) {
+    return [err.message, err.hint].filter(Boolean).join("\n\n") || null;
+  }
+  if (err instanceof Error) {
+    return err.message || null;
+  }
+  return typeof err === "string" && err.trim() ? err.trim() : null;
+}
+function sanitizeCheckoutDirName(value) {
+  const sanitized = value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return sanitized || "remix-remix";
+}
+async function pollAppReady(api, appId) {
+  const started = Date.now();
+  let delay = 2e3;
+  while (Date.now() - started < 20 * 60 * 1e3) {
+    const appResp = await api.getApp(appId);
+    const app = unwrapResponseObject(appResp, "app");
+    const status = typeof app.status === "string" ? app.status : "";
+    if (status === "ready") return app;
+    if (status === "error") {
+      throw new RemixError("App is in error state.", {
+        exitCode: 1,
+        hint: typeof app.statusError === "string" ? app.statusError : null
+      });
+    }
+    await sleep(delay);
+    delay = Math.min(1e4, Math.floor(delay * 1.4));
+  }
+  throw new RemixError("Timed out waiting for app to become ready.", { exitCode: 1 });
+}
+async function pollChangeStep(api, appId, changeStepId) {
+  const started = Date.now();
+  let delay = 1500;
+  while (Date.now() - started < 20 * 60 * 1e3) {
+    const resp = await api.getChangeStep(appId, changeStepId);
+    const step = unwrapResponseObject(resp, "change step");
+    const status = typeof step.status === "string" ? step.status : "";
+    if (status === "succeeded") return step;
+    if (status === "failed") {
+      throw new RemixError("Change step failed.", {
+        exitCode: 1,
+        hint: typeof step.statusError === "string" ? step.statusError : null
+      });
+    }
+    await sleep(delay);
+    delay = Math.min(1e4, Math.floor(delay * 1.4));
+  }
+  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;
+  while (Date.now() - started < 30 * 60 * 1e3) {
+    const resp = await api.getChangeStepReplay(appId, replayId);
+    const replay = unwrapResponseObject(resp, "change step replay");
+    if (replay.status === "succeeded") return replay;
+    if (replay.status === "manual_resolution_required") {
+      throw new RemixError("AI-assisted replay requires manual intervention.", {
+        exitCode: 2,
+        hint: replay.statusError || "The server could not safely adapt the preserved local diff."
+      });
+    }
+    if (replay.status === "failed" || replay.status === "cancelled") {
+      throw new RemixError("AI-assisted replay failed.", {
+        exitCode: 1,
+        hint: replay.statusError || null
+      });
+    }
+    await sleep(delay);
+    delay = Math.min(1e4, Math.floor(delay * 1.4));
+  }
+  throw new RemixError("Timed out waiting for AI-assisted replay.", { exitCode: 1 });
+}
+async function pollUpstreamSyncCompletion(api, appId, params) {
+  const started = Date.now();
+  let delay = 1500;
+  let sawNonReady = params.initialStatus !== "ready";
+  while (Date.now() - started < 30 * 60 * 1e3) {
+    const appResp = await api.getApp(appId);
+    const app = unwrapResponseObject(appResp, "app");
+    const status = typeof app.status === "string" ? app.status : "";
+    const headCommitId = typeof app.headCommitId === "string" ? app.headCommitId : null;
+    if (status === "error") {
+      throw new RemixError("App upstream sync failed.", {
+        exitCode: 1,
+        hint: typeof app.statusError === "string" ? app.statusError : null
+      });
+    }
+    if (status !== "ready") sawNonReady = true;
+    if (status === "ready" && headCommitId && headCommitId !== params.initialHeadCommitId) {
+      return app;
+    }
+    if (status === "ready" && sawNonReady) {
+      return app;
+    }
+    await sleep(delay);
+    delay = Math.min(1e4, Math.floor(delay * 1.4));
+  }
+  throw new RemixError("Timed out waiting for upstream sync.", { exitCode: 1 });
+}
+async function pollMergeRequestCompletion(api, mrId, params) {
+  const started = Date.now();
+  let delay = 1500;
+  while (Date.now() - started < 30 * 60 * 1e3) {
+    const reviewResp = await api.getMergeRequestReview(mrId);
+    const review = unwrapMergeRequestReview(reviewResp);
+    const mergeRequest = review.mergeRequest;
+    if (mergeRequest.status === "merged") return mergeRequest;
+    if (mergeRequest.status === "rejected" || mergeRequest.status === "closed") {
+      throw new RemixError("Merge approval did not complete successfully.", {
+        exitCode: 1,
+        hint: `Merge request ended in status=${mergeRequest.status}.`
+      });
+    }
+    if (params?.targetAppId) {
+      const appResp = await api.getApp(params.targetAppId);
+      const app = unwrapResponseObject(appResp, "app");
+      const status = typeof app.status === "string" ? app.status : "";
+      if (status === "error") {
+        throw new RemixError("Merge job failed.", {
+          exitCode: 1,
+          hint: typeof app.statusError === "string" ? app.statusError : null
+        });
+      }
+    }
+    await sleep(delay);
+    delay = Math.min(1e4, Math.floor(delay * 1.4));
+  }
+  throw new RemixError("Timed out waiting for merge approval to complete.", { exitCode: 1 });
+}
+
+// src/infrastructure/locking/repoMutationLock.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+var DEFAULT_ACQUIRE_TIMEOUT_MS = 15e3;
+var DEFAULT_STALE_MS = 45e3;
+var DEFAULT_HEARTBEAT_MS = 5e3;
+var RETRY_DELAY_MS = 250;
+var heldLocks = /* @__PURE__ */ new Map();
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createOwner(params) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    operation: params.operation,
+    repoRoot: params.repoRoot,
+    pid: process.pid,
+    hostname: os.hostname(),
+    startedAt: now,
+    heartbeatAt: now,
+    version: process.version,
+    requestId: params.requestId?.trim() || null
+  };
+}
+async function writeOwnerMetadata(ownerPath, owner) {
+  await fs.writeFile(ownerPath, `${JSON.stringify(owner, null, 2)}
+`, "utf8");
+}
+async function readOwnerMetadata(ownerPath) {
+  try {
+    const raw = await fs.readFile(ownerPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    if (!parsed.operation || !parsed.repoRoot || typeof parsed.pid !== "number" || !parsed.startedAt || !parsed.heartbeatAt) {
+      return null;
+    }
+    return {
+      operation: parsed.operation,
+      repoRoot: parsed.repoRoot,
+      pid: parsed.pid,
+      hostname: typeof parsed.hostname === "string" ? parsed.hostname : "unknown",
+      startedAt: parsed.startedAt,
+      heartbeatAt: parsed.heartbeatAt,
+      version: typeof parsed.version === "string" ? parsed.version : "unknown",
+      requestId: typeof parsed.requestId === "string" ? parsed.requestId : null
+    };
+  } catch {
+    return null;
+  }
+}
+async function isProcessAlive(owner) {
+  if (!owner) return null;
+  if (owner.hostname !== os.hostname()) return null;
+  try {
+    process.kill(owner.pid, 0);
+    return true;
+  } catch (error) {
+    if (error?.code === "EPERM") return true;
+    if (error?.code === "ESRCH") return false;
+    return null;
+  }
+}
+async function getLastKnownUpdateMs(lockDir, ownerPath, owner) {
+  const heartbeatMs = owner ? Date.parse(owner.heartbeatAt) : Number.NaN;
+  if (Number.isFinite(heartbeatMs)) return heartbeatMs;
+  const startedMs = owner ? Date.parse(owner.startedAt) : Number.NaN;
+  if (Number.isFinite(startedMs)) return startedMs;
+  const stat = await fs.stat(ownerPath).catch(() => null);
+  if (stat) return stat.mtimeMs;
+  const dirStat = await fs.stat(lockDir).catch(() => null);
+  if (dirStat) return dirStat.mtimeMs;
+  return 0;
+}
+async function ensureLockDir(lockDir) {
+  await fs.mkdir(path.dirname(lockDir), { recursive: true });
+}
+async function tryAcquireLock(lockDir, ownerPath, owner) {
+  try {
+    await ensureLockDir(lockDir);
+    await fs.mkdir(lockDir);
+    try {
+      await writeOwnerMetadata(ownerPath, owner);
+    } catch (error) {
+      await fs.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+      throw error;
+    }
+    return true;
+  } catch (error) {
+    if (error?.code === "EEXIST") return false;
+    throw error;
+  }
+}
+function formatLockHint(params) {
+  const lines = [
+    params.observedHeldLock ? `Observed lock state: ${REMIX_ERROR_CODES.REPO_LOCK_HELD}.` : null,
+    params.owner ? `Active operation: ${params.owner.operation}` : "Active operation: unknown",
+    params.owner ? `Repo root: ${params.owner.repoRoot}` : null,
+    params.owner ? `Owner: pid=${params.owner.pid} host=${params.owner.hostname}` : null,
+    params.owner ? `Started at: ${params.owner.startedAt}` : null,
+    params.owner ? `Heartbeat at: ${params.owner.heartbeatAt}` : null,
+    `Waited ${params.waitedMs}ms for the repo mutation lock.`,
+    `Stale lock threshold: ${params.staleMs}ms.`,
+    "Retry after the active operation finishes. If the process crashed, wait for stale lock recovery or remove the stale lock manually if necessary."
+  ];
+  return lines.filter(Boolean).join("\n");
+}
+function formatOwnerSummary(owner) {
+  if (!owner) {
+    return "unknown owner";
+  }
+  return `operation=${owner.operation} pid=${owner.pid} host=${owner.hostname} startedAt=${owner.startedAt} heartbeatAt=${owner.heartbeatAt}`;
+}
+function buildStaleRecoveryNotice(owner) {
+  return {
+    code: REMIX_ERROR_CODES.REPO_LOCK_STALE_RECOVERED,
+    owner,
+    message: `[${REMIX_ERROR_CODES.REPO_LOCK_STALE_RECOVERED}] Recovered a stale Remix repo mutation lock (${formatOwnerSummary(owner)}).`
+  };
+}
+async function acquirePhysicalLock(lockDir, ownerPath, owner, options) {
+  const startedAt = Date.now();
+  const notices = [];
+  let observedHeldLock = false;
+  while (Date.now() - startedAt < options.acquireTimeoutMs) {
+    if (await tryAcquireLock(lockDir, ownerPath, owner)) return notices;
+    const currentOwner2 = await readOwnerMetadata(ownerPath);
+    observedHeldLock = true;
+    const lastUpdateMs = await getLastKnownUpdateMs(lockDir, ownerPath, currentOwner2);
+    const ageMs = Math.max(0, Date.now() - lastUpdateMs);
+    const alive = await isProcessAlive(currentOwner2);
+    if (ageMs >= options.staleMs && alive !== true) {
+      notices.push(buildStaleRecoveryNotice(currentOwner2));
+      await fs.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+      continue;
+    }
+    await sleep2(RETRY_DELAY_MS);
+  }
+  const currentOwner = await readOwnerMetadata(ownerPath);
+  throw new RemixError("Repository is busy with another Remix mutation.", {
+    code: REMIX_ERROR_CODES.REPO_LOCK_TIMEOUT,
+    exitCode: 2,
+    hint: formatLockHint({
+      owner: currentOwner,
+      waitedMs: Date.now() - startedAt,
+      staleMs: options.staleMs,
+      observedHeldLock
+    })
+  });
+}
+function startHeartbeat(lockDir, ownerPath, owner, heartbeatMs) {
+  return setInterval(() => {
+    const nextOwner = {
+      ...owner,
+      heartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    owner.heartbeatAt = nextOwner.heartbeatAt;
+    void writeOwnerMetadata(ownerPath, nextOwner).catch(() => void 0);
+    void fs.utimes(lockDir, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date()).catch(() => void 0);
+  }, heartbeatMs);
+}
+async function releaseReentrantLock(lockDir) {
+  const held = heldLocks.get(lockDir);
+  if (!held) return;
+  held.count -= 1;
+  if (held.count > 0) return;
+  clearInterval(held.heartbeatTimer);
+  heldLocks.delete(lockDir);
+  await fs.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+}
+async function withRepoMutationLock(options, fn) {
+  const repoRoot = await findGitRoot(options.cwd);
+  const gitCommonDir = await getGitCommonDir(repoRoot);
+  const lockDir = path.join(gitCommonDir, "remix", "locks", "repo-mutation.lock");
+  const owner = createOwner({
+    operation: options.operation,
+    repoRoot,
+    requestId: options.requestId
+  });
+  const heartbeatMs = options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
+  const acquireTimeoutMs = options.acquireTimeoutMs ?? DEFAULT_ACQUIRE_TIMEOUT_MS;
+  const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
+  const existing = heldLocks.get(lockDir);
+  let notices = [];
+  if (!existing) {
+    notices = await acquirePhysicalLock(lockDir, path.join(lockDir, "owner.json"), owner, {
+      acquireTimeoutMs,
+      staleMs
+    });
+    const ownerPath = path.join(lockDir, "owner.json");
+    heldLocks.set(lockDir, {
+      count: 1,
+      lockDir,
+      ownerPath,
+      owner,
+      heartbeatTimer: startHeartbeat(lockDir, ownerPath, owner, heartbeatMs)
+    });
+  } else {
+    existing.count += 1;
+  }
+  try {
+    return await fn({
+      repoRoot,
+      gitCommonDir,
+      lockDir,
+      notices,
+      warnings: notices.map((notice) => notice.message)
+    });
+  } finally {
+    await releaseReentrantLock(lockDir);
+  }
+}
+
+// src/application/collab/collabSync.ts
+import fs2 from "fs/promises";
+import os2 from "os";
+import path2 from "path";
+async function collabSync(params) {
+  const repoRoot = await findGitRoot(params.cwd);
+  const binding = await readCollabBinding(repoRoot);
+  if (!binding) {
+    throw new RemixError("Repository is not bound to Remix.", {
+      exitCode: 2,
+      hint: "Run `remix collab init` first."
+    });
+  }
+  await ensureCleanWorktree(repoRoot);
+  const branch = await requireCurrentBranch(repoRoot);
+  assertPreferredBranchMatch({
+    currentBranch: branch,
+    preferredBranch: binding.preferredBranch,
+    allowBranchMismatch: params.allowBranchMismatch,
+    operation: "`remix collab sync`"
+  });
+  const headCommitHash = await getHeadCommitHash(repoRoot);
+  const repoSnapshot = await captureRepoSnapshot(repoRoot);
+  if (!headCommitHash) {
+    throw new RemixError("Failed to resolve local HEAD commit.", { exitCode: 1 });
+  }
+  const resp = await params.api.syncLocalApp(binding.currentAppId, {
+    baseCommitHash: headCommitHash,
+    repoFingerprint: binding.repoFingerprint ?? void 0,
+    remoteUrl: binding.remoteUrl ?? void 0,
+    defaultBranch: binding.defaultBranch ?? void 0,
+    dryRun: params.dryRun
+  });
+  const sync = unwrapResponseObject(resp, "sync result");
+  if (sync.status === "conflict_risk") {
+    throw new RemixError("Local repository metadata conflicts with the bound Remix app.", {
+      exitCode: 2,
+      hint: sync.warnings.join("\n") || "Run the command from the correct bound repository."
+    });
+  }
+  if (sync.status === "base_unknown") {
+    throw new RemixError("Local repository cannot be fast-forward synced.", {
+      exitCode: 2,
+      hint: "Your local HEAD is not on the app sandbox history. Reconcile the repository manually before syncing."
+    });
+  }
+  if (sync.status === "up_to_date") {
+    return {
+      status: sync.status,
+      branch,
+      repoRoot,
+      baseCommitHash: sync.baseCommitHash,
+      targetCommitHash: sync.targetCommitHash,
+      targetCommitId: sync.targetCommitId,
+      stats: sync.stats,
+      localCommitHash: headCommitHash,
+      applied: false,
+      dryRun: params.dryRun
+    };
+  }
+  const previewResult = {
+    status: sync.status,
+    branch,
+    repoRoot,
+    baseCommitHash: sync.baseCommitHash,
+    targetCommitHash: sync.targetCommitHash,
+    targetCommitId: sync.targetCommitId,
+    stats: sync.stats,
+    bundleRef: sync.bundleRef,
+    bundleSizeBytes: sync.bundleSizeBytes,
+    localCommitHash: headCommitHash,
+    applied: false,
+    dryRun: params.dryRun
+  };
+  if (params.dryRun) {
+    return previewResult;
+  }
+  if (!sync.bundleBase64 || !sync.bundleRef) {
+    throw new RemixError("Sync bundle payload is missing.", { exitCode: 1 });
+  }
+  const bundleBase64 = sync.bundleBase64;
+  const bundleRef = sync.bundleRef;
+  return withRepoMutationLock(
+    {
+      cwd: repoRoot,
+      operation: "collabSync"
+    },
+    async ({ repoRoot: lockedRepoRoot, warnings }) => {
+      await assertRepoSnapshotUnchanged(lockedRepoRoot, repoSnapshot, {
+        operation: "`remix collab sync`",
+        recoveryHint: "The repository changed after sync was prepared. Review the local changes and rerun `remix collab sync`."
+      });
+      await ensureCleanWorktree(lockedRepoRoot);
+      const lockedBranch = await requireCurrentBranch(lockedRepoRoot);
+      assertPreferredBranchMatch({
+        currentBranch: lockedBranch,
+        preferredBranch: binding.preferredBranch,
+        allowBranchMismatch: params.allowBranchMismatch,
+        operation: "`remix collab sync`"
+      });
+      const tempDir = await fs2.mkdtemp(path2.join(os2.tmpdir(), "remix-sync-"));
+      const bundlePath = path2.join(tempDir, "sync-local.bundle");
+      try {
+        await fs2.writeFile(bundlePath, Buffer.from(bundleBase64, "base64"));
+        await importGitBundle(lockedRepoRoot, bundlePath, bundleRef);
+        await ensureCommitExists(lockedRepoRoot, sync.targetCommitHash);
+        const localCommitHash = await fastForwardToCommit(lockedRepoRoot, sync.targetCommitHash);
+        return {
+          ...previewResult,
+          localCommitHash,
+          applied: true,
+          dryRun: false,
+          ...warnings.length > 0 ? { warnings } : {}
+        };
+      } finally {
+        await fs2.rm(tempDir, { recursive: true, force: true });
+      }
+    }
+  );
+}
+
+// src/application/collab/collabAdd.ts
+async function preflightSyncStatus(params) {
+  const resp = await params.api.syncLocalApp(params.appId, {
+    baseCommitHash: params.headCommitHash,
+    repoFingerprint: params.repoFingerprint ?? void 0,
+    remoteUrl: params.remoteUrl ?? void 0,
+    defaultBranch: params.defaultBranch ?? void 0,
+    dryRun: true
+  });
+  return unwrapResponseObject(resp, "sync result");
+}
+function assertSupportedSyncStatus(sync) {
+  if (sync.status === "conflict_risk") {
+    throw new RemixError("Local repository metadata conflicts with the bound Remix app.", {
+      exitCode: 2,
+      hint: sync.warnings.join("\n") || "Run the command from the correct bound repository."
+    });
+  }
+  if (sync.status === "base_unknown") {
+    throw new RemixError("Local repository cannot be fast-forward synced.", {
+      exitCode: 2,
+      hint: "Run `remix collab reconcile` first because the local history is no longer fast-forward compatible with the app."
+    });
+  }
+}
+async function collabAdd(params) {
+  const repoRoot = await findGitRoot(params.cwd);
+  const binding = await readCollabBinding(repoRoot);
+  if (!binding) {
+    throw new RemixError("Repository is not bound to Remix.", {
+      exitCode: 2,
+      hint: "Run `remix collab init` first."
+    });
+  }
+  const prompt = params.prompt.trim();
+  if (!prompt) throw new RemixError("Prompt is required.", { exitCode: 2 });
+  const assistantResponse = params.assistantResponse?.trim() || null;
+  const attachWarnings = (value, warnings) => warnings.length > 0 ? { ...value, warnings } : value;
+  const diffSource = params.diffSource ?? (params.diff ? "external" : "worktree");
+  const autoSyncEnabled = params.sync !== false;
+  const run = async (lockWarnings = []) => {
+    const branch = await getCurrentBranch(repoRoot);
+    assertPreferredBranchMatch({
+      currentBranch: branch,
+      preferredBranch: binding.preferredBranch,
+      allowBranchMismatch: params.allowBranchMismatch,
+      operation: "`remix collab add`"
+    });
+    let headCommitHash = await getHeadCommitHash(repoRoot);
+    if (!headCommitHash) {
+      throw new RemixError("Failed to resolve local HEAD commit.", { exitCode: 1 });
+    }
+    const worktreeStatus = await getWorktreeStatus(repoRoot);
+    const syncPreview = await preflightSyncStatus({
+      api: params.api,
+      appId: binding.currentAppId,
+      headCommitHash,
+      repoFingerprint: binding.repoFingerprint ?? void 0,
+      remoteUrl: binding.remoteUrl ?? void 0,
+      defaultBranch: binding.defaultBranch ?? void 0
+    });
+    assertSupportedSyncStatus(syncPreview);
+    if (syncPreview.status === "ready_to_fast_forward") {
+      if (!autoSyncEnabled) {
+        throw new RemixError("Local repository is stale and `collab add` sync automation is disabled.", {
+          exitCode: 2,
+          hint: "Run `remix collab sync` first, or rerun without disabling sync automation."
+        });
+      }
+      if (!worktreeStatus.isClean && diffSource !== "worktree") {
+        throw new RemixError("Automatic stale-work replay requires the current worktree diff.", {
+          exitCode: 2,
+          hint: "Use `remix collab add` without an external diff while the local repo is dirty, or clean the repo before submitting an external diff."
+        });
+      }
+      if (worktreeStatus.isClean) {
+        await collabSync({
+          api: params.api,
+          cwd: repoRoot,
+          dryRun: false,
+          allowBranchMismatch: params.allowBranchMismatch
+        });
+        headCommitHash = await getHeadCommitHash(repoRoot);
+        if (!headCommitHash) {
+          throw new RemixError("Failed to resolve local HEAD after syncing.", { exitCode: 1 });
+        }
+      } else {
+        const staleWorkSnapshot = await captureRepoSnapshot(repoRoot, { includeWorkspaceDiffHash: true });
+        const preserved = await preserveWorkspaceChanges(repoRoot, "remix-add-preserve");
+        try {
+          await assertRepoSnapshotUnchanged(repoRoot, staleWorkSnapshot, {
+            operation: "`remix collab add` stale-work pre-sync",
+            recoveryHint: "The worktree changed while local changes were being preserved. Review the local changes and rerun `remix collab add`."
+          });
+          await discardTrackedChanges(repoRoot, "`remix collab add`");
+          await discardCapturedUntrackedChanges(repoRoot, preserved.includedUntrackedPaths);
+          await collabSync({
+            api: params.api,
+            cwd: repoRoot,
+            dryRun: false,
+            allowBranchMismatch: params.allowBranchMismatch
+          });
+        } catch (err) {
+          const detail = formatCliErrorDetail(err);
+          const hint = [
+            detail,
+            `The preserved local diff is available at: ${preserved.preservedDiffPath}`
+          ].filter(Boolean).join("\n\n");
+          throw new RemixError("Failed to sync the stale repository before submitting the change step.", {
+            exitCode: err instanceof RemixError ? err.exitCode : 1,
+            hint
+          });
+        }
+        headCommitHash = await getHeadCommitHash(repoRoot);
+        if (!headCommitHash) {
+          throw new RemixError("Failed to resolve local HEAD after syncing.", { exitCode: 1 });
+        }
+        const deterministicReapply = await reapplyPreservedWorkspaceChanges(repoRoot, preserved);
+        if (deterministicReapply.status === "failed") {
+          const hint = [
+            deterministicReapply.detail,
+            `The preserved local diff is available at: ${preserved.preservedDiffPath}`
+          ].filter(Boolean).join("\n\n");
+          throw new RemixError("Failed to restore preserved local changes after syncing.", {
+            exitCode: 1,
+            hint
+          });
+        }
+        if (deterministicReapply.status === "conflict") {
+          try {
+            const replayResp = await params.api.startChangeStepReplay(binding.currentAppId, {
+              prompt,
+              assistantResponse: assistantResponse ?? void 0,
+              diff: await fs3.readFile(preserved.preservedDiffPath, "utf8"),
+              baseCommitHash: preserved.baseHeadCommitHash,
+              targetHeadCommitHash: headCommitHash,
+              expectedPaths: preserved.stagePlan.expectedPaths,
+              actor: params.actor,
+              workspaceMetadata: {
+                branch,
+                repoRoot,
+                remoteUrl: binding.remoteUrl,
+                defaultBranch: binding.defaultBranch
+              },
+              idempotencyKey: buildDeterministicIdempotencyKey({
+                appId: binding.currentAppId,
+                baseCommitHash: preserved.baseHeadCommitHash,
+                targetHeadCommitHash: headCommitHash,
+                prompt,
+                assistantResponse,
+                preservedDiffSha256: preserved.preservedDiffSha256
+              })
+            });
+            const startedReplay = unwrapResponseObject(replayResp, "change step replay");
+            const replay = await pollChangeStepReplay(params.api, binding.currentAppId, String(startedReplay.id));
+            const replayDiffResp = await params.api.getChangeStepReplayDiff(binding.currentAppId, String(replay.id));
+            const replayDiff = unwrapResponseObject(replayDiffResp, "change step replay diff");
+            const { backupPath: backupPath2, diffSha256 } = await writeTempUnifiedDiffBackup(replayDiff.diff, "remix-add-ai-replay");
+            const replayApply = await reapplyPreservedWorkspaceChanges(repoRoot, {
+              baseHeadCommitHash: headCommitHash,
+              preservedDiffPath: backupPath2,
+              preservedDiffSha256: diffSha256,
+              includedUntrackedPaths: [],
+              stagePlan: preserved.stagePlan
+            });
+            if (replayApply.status !== "clean") {
+              const hint = [
+                replayApply.detail,
+                `The preserved local diff is available at: ${preserved.preservedDiffPath}`,
+                `The AI-replayed diff is available at: ${backupPath2}`
+              ].filter(Boolean).join("\n\n");
+              throw new RemixError("AI-assisted stale-work replay produced a diff that could not be applied locally.", {
+                exitCode: 1,
+                hint
+              });
+            }
+          } catch (err) {
+            const detail = formatCliErrorDetail(err);
+            const hint = [
+              detail,
+              `The preserved local diff is available at: ${preserved.preservedDiffPath}`,
+              "Resolve the local conflict manually if needed, then rerun `remix collab add`."
+            ].filter(Boolean).join("\n\n");
+            throw new RemixError("AI-assisted stale-work replay could not complete safely.", {
+              exitCode: err instanceof RemixError ? err.exitCode : 1,
+              hint
+            });
+          }
+        }
+      }
+    }
+    const workspaceSnapshot = diffSource === "external" ? null : await getWorkspaceSnapshot(repoRoot);
+    const submissionSnapshot = diffSource === "worktree" ? await captureRepoSnapshot(repoRoot, { includeWorkspaceDiffHash: true }) : null;
+    const diff = params.diff ?? workspaceSnapshot?.diff ?? "";
+    if (!diff.trim()) {
+      throw new RemixError("Diff is empty.", {
+        exitCode: 2,
+        hint: "Make changes first, or pass `--diff-file`/`--diff-stdin`."
+      });
+    }
+    if (diffSource === "external") {
+      const validation = await validateUnifiedDiff(repoRoot, diff);
+      if (!validation.ok) {
+        const actionHint = validation.kind === "malformed_patch" ? "The provided external diff is malformed. Recreate it with `git diff --binary --no-ext-diff`, avoid hand-editing patch hunks, and ensure the patch ends with a trailing newline." : validation.kind === "apply_conflict" ? "The external diff is valid patch syntax, but it does not apply cleanly to the current local HEAD. Sync or update the repo and regenerate the diff against the latest base." : "Git could not validate the provided external diff against the current repository state.";
+        const hint = [validation.detail, actionHint].filter(Boolean).join("\n\n");
+        throw new RemixError("External diff validation failed.", {
+          exitCode: validation.kind === "malformed_patch" ? 2 : 1,
+          hint
+        });
+      }
+    }
+    headCommitHash = await getHeadCommitHash(repoRoot);
+    if (!headCommitHash) {
+      throw new RemixError("Failed to resolve local HEAD before creating the change step.", { exitCode: 1 });
+    }
+    const stats = summarizeUnifiedDiff(diff);
+    const idempotencyKey = params.idempotencyKey?.trim() || buildDeterministicIdempotencyKey({
+      appId: binding.currentAppId,
+      upstreamAppId: binding.upstreamAppId,
+      headCommitHash,
+      prompt,
+      assistantResponse,
+      diff
+    });
+    const resp = await params.api.createChangeStep(binding.currentAppId, {
+      threadId: binding.threadId ?? void 0,
+      prompt,
+      assistantResponse: assistantResponse ?? void 0,
+      diff,
+      baseCommitHash: headCommitHash,
+      headCommitHash,
+      changedFilesCount: stats.changedFilesCount,
+      insertions: stats.insertions,
+      deletions: stats.deletions,
+      actor: params.actor,
+      workspaceMetadata: {
+        branch,
+        repoRoot,
+        remoteUrl: binding.remoteUrl,
+        defaultBranch: binding.defaultBranch
+      },
+      idempotencyKey
+    });
+    const created = unwrapResponseObject(resp, "change step");
+    const step = await pollChangeStep(params.api, binding.currentAppId, String(created.id));
+    const canAutoSyncLocally = autoSyncEnabled && diffSource === "worktree";
+    if (!autoSyncEnabled || !canAutoSyncLocally) {
+      return attachWarnings(step, lockWarnings);
+    }
+    const { backupPath } = await writeTempUnifiedDiffBackup(diff, "remix-add");
+    try {
+      if (submissionSnapshot) {
+        await assertRepoSnapshotUnchanged(repoRoot, submissionSnapshot, {
+          operation: "`remix collab add` auto-sync",
+          recoveryHint: "The repository changed after the change step was submitted. Review the local changes, inspect the preserved diff if needed, and rerun `remix collab sync` manually."
+        });
+      }
+      await discardTrackedChanges(repoRoot, "`remix collab add`");
+      await discardCapturedUntrackedChanges(repoRoot, workspaceSnapshot?.includedUntrackedPaths ?? []);
+      await collabSync({
+        api: params.api,
+        cwd: repoRoot,
+        dryRun: false,
+        allowBranchMismatch: params.allowBranchMismatch
+      });
+      await fs3.rm(path3.dirname(backupPath), { recursive: true, force: true }).catch(() => void 0);
+    } catch (err) {
+      const detail = formatCliErrorDetail(err);
+      const hint = [
+        detail,
+        `The submitted diff backup was preserved at: ${backupPath}`,
+        "The change step already succeeded remotely. Inspect or reapply that diff manually if needed, then run `remix collab sync`."
+      ].filter(Boolean).join("\n\n");
+      throw new RemixError("Change step succeeded remotely, but automatic local sync failed.", {
+        exitCode: err instanceof RemixError ? err.exitCode : 1,
+        hint
+      });
+    }
+    return attachWarnings(step, lockWarnings);
+  };
+  if (diffSource === "worktree") {
+    return withRepoMutationLock(
+      {
+        cwd: repoRoot,
+        operation: "collabAdd"
+      },
+      async ({ warnings }) => run(warnings)
+    );
+  }
+  return run();
+}
+
+// src/application/collab/collabRecordTurn.ts
+async function collabRecordTurn(params) {
+  const repoRoot = await findGitRoot(params.cwd);
+  const binding = await readCollabBinding(repoRoot);
+  if (!binding) {
+    throw new RemixError("Repository is not bound to Remix.", {
+      exitCode: 2,
+      hint: "Run `remix collab init` first."
+    });
+  }
+  const prompt = params.prompt.trim();
+  const assistantResponse = params.assistantResponse.trim();
+  if (!prompt) throw new RemixError("Prompt is required.", { exitCode: 2 });
+  if (!assistantResponse) throw new RemixError("Assistant response is required.", { exitCode: 2 });
+  const branch = await getCurrentBranch(repoRoot);
+  assertPreferredBranchMatch({
+    currentBranch: branch,
+    preferredBranch: binding.preferredBranch,
+    allowBranchMismatch: params.allowBranchMismatch,
+    operation: "`remix collab record-turn`"
+  });
+  const headCommitHash = await getHeadCommitHash(repoRoot);
+  const idempotencyKey = params.idempotencyKey?.trim() || buildDeterministicIdempotencyKey({
+    appId: binding.currentAppId,
+    upstreamAppId: binding.upstreamAppId,
+    headCommitHash,
+    prompt,
+    assistantResponse
+  });
+  const resp = await params.api.createCollabTurn(binding.currentAppId, {
+    threadId: binding.threadId ?? void 0,
+    prompt,
+    assistantResponse,
+    actor: params.actor,
+    workspaceMetadata: {
+      branch,
+      repoRoot,
+      remoteUrl: binding.remoteUrl,
+      defaultBranch: binding.defaultBranch,
+      headCommitHash
+    },
+    idempotencyKey
+  });
+  return unwrapResponseObject(resp, "collab turn");
+}
+
+// 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
+      });
+    }
+    return withRepoMutationLock(
+      {
+        cwd: params.cwd,
+        operation: "collabApproveSyncTarget"
+      },
+      async ({ repoRoot, warnings }) => {
+        const binding = await readCollabBinding(repoRoot);
+        if (!binding) {
+          throw new RemixError("Repository is not bound to Remix.", {
+            exitCode: 2,
+            hint: "Run `remix collab init` first, or use `--remote-only`."
+          });
+        }
+        await ensureCleanWorktree(repoRoot, "`remix collab approve --sync-target-repo`");
+        const branch = await requireCurrentBranch(repoRoot);
+        assertPreferredBranchMatch({
+          currentBranch: branch,
+          preferredBranch: binding.preferredBranch,
+          allowBranchMismatch: params.allowBranchMismatch,
+          operation: "`remix collab approve --sync-target-repo`"
+        });
+        const mrResp = await params.api.getMergeRequest(params.mrId);
+        const mergeRequest = unwrapMergeRequest(mrResp);
+        const targetAppId = mergeRequest.targetAppId;
+        if (binding.currentAppId !== targetAppId) {
+          throw new RemixError("Current repository is not the merge target for this merge request.", {
+            exitCode: 2,
+            hint: `Run the command from the repository bound to app ${targetAppId}, or use --remote-only.`
+          });
+        }
+        const resp2 = await params.api.updateMergeRequest(params.mrId, { status: "approved" });
+        const approvedMergeRequest2 = unwrapMergeRequest(resp2);
+        const completedMergeRequest2 = await pollMergeRequestCompletion(params.api, params.mrId, {
+          targetAppId: targetAppId ?? approvedMergeRequest2.targetAppId
+        });
+        const localSync = await collabSync({
+          api: params.api,
+          cwd: repoRoot,
+          dryRun: false,
+          allowBranchMismatch: params.allowBranchMismatch
+        });
+        const localSyncWarnings = Array.isArray(localSync.warnings) ? localSync.warnings ?? [] : [];
+        return {
+          mode: params.mode,
+          mergeRequestId: completedMergeRequest2.id,
+          terminalStatus: completedMergeRequest2.status,
+          targetAppId: completedMergeRequest2.targetAppId,
+          mergeRequest: completedMergeRequest2,
+          repoRoot,
+          localSync,
+          ...warnings.length > 0 || localSyncWarnings.length > 0 ? {
+            warnings: Array.from(/* @__PURE__ */ new Set([...warnings, ...localSyncWarnings]))
+          } : {}
+        };
+      }
+    );
+  }
+  const resp = await params.api.updateMergeRequest(params.mrId, { status: "approved" });
+  const approvedMergeRequest = unwrapMergeRequest(resp);
+  const completedMergeRequest = await pollMergeRequestCompletion(params.api, params.mrId, {
+    targetAppId: approvedMergeRequest.targetAppId
+  });
+  return {
+    mode: params.mode,
+    mergeRequestId: completedMergeRequest.id,
+    terminalStatus: completedMergeRequest.status,
+    targetAppId: completedMergeRequest.targetAppId,
+    mergeRequest: completedMergeRequest
+  };
+}
+
+// src/application/collab/collabInbox.ts
+async function collabInbox(params) {
+  const resp = await params.api.listMergeRequests({ status: "open", kind: "merge" });
+  const mergeRequests = unwrapResponseObject(resp, "merge requests");
+  return { mergeRequests };
+}
+
+// src/application/collab/collabInit.ts
+import fs6 from "fs/promises";
+import path4 from "path";
+
+// src/shared/hash.ts
+import crypto from "crypto";
+import fs4 from "fs";
+async function sha256FileHex(filePath) {
+  const hash = crypto.createHash("sha256");
+  await new Promise((resolve, reject) => {
+    const stream = fs4.createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve());
+  });
+  return hash.digest("hex");
+}
+
+// src/shared/upload.ts
+import fs5 from "fs";
+import { PassThrough } from "stream";
+async function uploadPresigned(params) {
+  const stats = await fs5.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 = fs5.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
+async function collabInit(params) {
+  return withRepoMutationLock(
+    {
+      cwd: params.cwd,
+      operation: "collabInit"
+    },
+    async ({ repoRoot, warnings }) => {
+      await ensureGitInfoExcludeEntries(repoRoot, [".remix/"]);
+      await ensureCleanWorktree(repoRoot, "`remix collab init`");
+      if (params.path?.trim()) {
+        throw new RemixError("`remix collab init --path` is not supported.", {
+          exitCode: 2,
+          hint: "History-preserving init imports the full git repository. Run the command from the repository root without --path."
+        });
+      }
+      const remoteUrl = normalizeGitRemote(await getRemoteOriginUrl(repoRoot));
+      const currentBranch = await getCurrentBranch(repoRoot);
+      const defaultBranch = await getDefaultBranch(repoRoot) ?? currentBranch;
+      const preferredBranch = currentBranch ?? defaultBranch ?? null;
+      const repoFingerprint = await buildRepoFingerprint({ gitRoot: repoRoot, remoteUrl, defaultBranch });
+      const repoSnapshot = await captureRepoSnapshot(repoRoot);
+      if (!params.forceNew) {
+        const bindingResp = await params.api.resolveProjectBinding({
+          repoFingerprint,
+          remoteUrl: remoteUrl ?? void 0
+        });
+        const existing = bindingResp?.responseObject;
+        if (existing?.projectId && existing?.appId) {
+          await assertRepoSnapshotUnchanged(repoRoot, repoSnapshot, {
+            operation: "`remix collab init`",
+            recoveryHint: "The repository changed while the local binding was being initialized. Review the local changes and rerun `remix collab init`."
+          });
+          const bindingPath2 = await writeCollabBinding(repoRoot, {
+            projectId: String(existing.projectId),
+            currentAppId: String(existing.appId),
+            upstreamAppId: String(existing.upstreamAppId ?? existing.appId),
+            threadId: existing.threadId ? String(existing.threadId) : null,
+            repoFingerprint,
+            remoteUrl,
+            defaultBranch: defaultBranch ?? null,
+            preferredBranch
+          });
+          return {
+            reused: true,
+            projectId: String(existing.projectId),
+            appId: String(existing.appId),
+            upstreamAppId: String(existing.upstreamAppId ?? existing.appId),
+            bindingPath: bindingPath2,
+            repoRoot,
+            ...warnings.length > 0 ? { warnings } : {}
+          };
+        }
+      }
+      const { bundlePath, headCommitHash } = await createGitBundle(repoRoot, "repository.bundle");
+      const bundleSha = await sha256FileHex(bundlePath);
+      const bundleSize = (await fs6.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 importResp = await params.api.importFromUploadFirstParty({
+        uploadId: String(presign.uploadId),
+        appName: params.appName?.trim() || path4.basename(repoRoot),
+        path: params.path?.trim() || void 0,
+        platform: "generic",
+        isPublic: false,
+        remoteUrl: remoteUrl ?? void 0,
+        defaultBranch: defaultBranch ?? void 0,
+        repoFingerprint,
+        headCommitHash
+      });
+      const imported = unwrapResponseObject(importResp, "import");
+      const app = await pollAppReady(params.api, String(imported.appId));
+      await assertRepoSnapshotUnchanged(repoRoot, repoSnapshot, {
+        operation: "`remix collab init`",
+        recoveryHint: "The repository changed before the Remix binding was written. Review the local changes and rerun `remix collab init`."
+      });
+      const bindingPath = await writeCollabBinding(repoRoot, {
+        projectId: String(app.projectId),
+        currentAppId: String(app.id),
+        upstreamAppId: String(app.id),
+        threadId: app.threadId ? String(app.threadId) : null,
+        repoFingerprint,
+        remoteUrl,
+        defaultBranch: defaultBranch ?? null,
+        preferredBranch
+      });
+      return {
+        reused: false,
+        projectId: String(app.projectId),
+        appId: String(app.id),
+        upstreamAppId: String(app.id),
+        bindingPath,
+        repoRoot,
+        remoteUrl,
+        defaultBranch,
+        preferredBranch,
+        ...warnings.length > 0 ? { warnings } : {}
+      };
+    }
+  );
+}
+
+// src/application/collab/collabInvite.ts
+async function resolveScopeTarget(params) {
+  if (params.targetId?.trim()) return params.targetId.trim();
+  const repoRoot = await findGitRoot(params.cwd);
+  const binding = await readCollabBinding(repoRoot);
+  if (!binding) {
+    throw new RemixError("Repository is not bound to Remix and no explicit target id was provided.", { exitCode: 2 });
+  }
+  if (params.scope === "project") return binding.projectId;
+  if (params.scope === "app") return binding.currentAppId;
+  const project = unwrapResponseObject(await params.api.getProject(binding.projectId), "project");
+  const organizationId = typeof project.organizationId === "string" ? project.organizationId : null;
+  if (!organizationId) {
+    throw new RemixError("Could not resolve the organization for the current repository binding.", { exitCode: 2 });
+  }
+  return organizationId;
+}
+async function collabInvite(params) {
+  const scope = params.scope ?? "project";
+  const targetId = await resolveScopeTarget({
+    api: params.api,
+    cwd: params.cwd,
+    scope,
+    targetId: params.targetId
+  });
+  const payload = {
+    email: params.email,
+    role: params.role?.trim() || (scope === "organization" ? "member" : "viewer"),
+    ttlDays: params.ttlDays
+  };
+  const resp = scope === "organization" ? await params.api.createOrganizationInvite(targetId, payload) : scope === "project" ? await params.api.createProjectInvite(targetId, payload) : await params.api.createAppInvite(targetId, payload);
+  const invite = unwrapResponseObject(resp, "invite");
+  return {
+    ...invite,
+    scopeType: scope,
+    targetId
+  };
+}
+
+// src/application/collab/collabList.ts
+async function collabList(params) {
+  const resp = await params.api.listApps({ forked: "all" });
+  const apps = unwrapResponseObject(resp, "apps");
+  return { apps };
+}
+
+// src/application/collab/collabReconcile.ts
+import fs7 from "fs/promises";
+import os3 from "os";
+import path5 from "path";
+async function collabReconcile(params) {
+  const repoRoot = await findGitRoot(params.cwd);
+  const binding = await readCollabBinding(repoRoot);
+  if (!binding) {
+    throw new RemixError("Repository is not bound to Remix.", {
+      exitCode: 2,
+      hint: "Run `remix collab init` first."
+    });
+  }
+  await ensureCleanWorktree(repoRoot, "`remix collab reconcile`");
+  const branch = await requireCurrentBranch(repoRoot);
+  assertPreferredBranchMatch({
+    currentBranch: branch,
+    preferredBranch: binding.preferredBranch,
+    allowBranchMismatch: params.allowBranchMismatch,
+    operation: "`remix collab reconcile`"
+  });
+  const headCommitHash = await getHeadCommitHash(repoRoot);
+  const repoSnapshot = await captureRepoSnapshot(repoRoot);
+  if (!headCommitHash) {
+    throw new RemixError("Failed to resolve local HEAD commit.", { exitCode: 1 });
+  }
+  const syncResp = await params.api.syncLocalApp(binding.currentAppId, {
+    baseCommitHash: headCommitHash,
+    repoFingerprint: binding.repoFingerprint ?? void 0,
+    remoteUrl: binding.remoteUrl ?? void 0,
+    defaultBranch: binding.defaultBranch ?? void 0,
+    dryRun: true
+  });
+  const sync = unwrapResponseObject(syncResp, "sync result");
+  if (sync.status === "conflict_risk") {
+    throw new RemixError("Local repository metadata conflicts with the bound Remix app.", {
+      exitCode: 2,
+      hint: sync.warnings.join("\n") || "Run the command from the correct bound repository."
+    });
+  }
+  if (sync.status !== "base_unknown") {
+    return collabSync(params);
+  }
+  const preflightResp = await params.api.preflightAppReconcile(binding.currentAppId, {
+    localHeadCommitHash: headCommitHash,
+    repoFingerprint: binding.repoFingerprint ?? void 0,
+    remoteUrl: binding.remoteUrl ?? void 0,
+    defaultBranch: binding.defaultBranch ?? void 0
+  });
+  const preflight = unwrapResponseObject(preflightResp, "reconcile preflight");
+  if (preflight.status === "metadata_conflict") {
+    throw new RemixError("Local repository metadata conflicts with the bound Remix app.", {
+      exitCode: 2,
+      hint: preflight.warnings.join("\n") || "Run the command from the correct bound repository."
+    });
+  }
+  if (preflight.status === "up_to_date") {
+    return collabSync(params);
+  }
+  const previewResult = {
+    status: preflight.status,
+    branch,
+    repoRoot,
+    localHeadCommitHash: headCommitHash,
+    targetHeadCommitId: preflight.targetHeadCommitId,
+    targetHeadCommitHash: preflight.targetHeadCommitHash,
+    warnings: preflight.warnings,
+    applied: false,
+    dryRun: params.dryRun
+  };
+  if (params.dryRun) {
+    return previewResult;
+  }
+  const { bundlePath, headCommitHash: bundledHeadCommitHash } = await createGitBundle(repoRoot, "reconcile-local.bundle");
+  const bundleTempDir = path5.dirname(bundlePath);
+  try {
+    const bundleStat = await fs7.stat(bundlePath);
+    const checksumSha256 = await sha256FileHex(bundlePath);
+    const presignResp = await params.api.presignImportUploadFirstParty({
+      file: {
+        name: path5.basename(bundlePath),
+        mimeType: "application/x-git-bundle",
+        size: bundleStat.size,
+        checksumSha256
+      }
+    });
+    const uploadTarget = unwrapResponseObject(presignResp, "reconcile upload target");
+    await uploadPresigned({
+      uploadUrl: String(uploadTarget.uploadUrl),
+      filePath: bundlePath,
+      headers: uploadTarget.headers ?? {}
+    });
+    const startResp = await params.api.startAppReconcile(binding.currentAppId, {
+      uploadId: String(uploadTarget.uploadId),
+      localHeadCommitHash: bundledHeadCommitHash,
+      repoFingerprint: binding.repoFingerprint ?? void 0,
+      remoteUrl: binding.remoteUrl ?? void 0,
+      defaultBranch: binding.defaultBranch ?? void 0,
+      idempotencyKey: buildDeterministicIdempotencyKey({
+        appId: binding.currentAppId,
+        localHeadCommitHash: bundledHeadCommitHash,
+        targetHeadCommitHash: preflight.targetHeadCommitHash
+      })
+    });
+    const started = unwrapResponseObject(startResp, "reconcile");
+    const reconcile = await pollReconcile(params.api, binding.currentAppId, started.id);
+    if (!reconcile.mergeBaseCommitHash || !reconcile.reconciledHeadCommitHash || !reconcile.resultBundleRef) {
+      throw new RemixError("Reconcile completed without enough result metadata to update the local repository.", {
+        exitCode: 1
+      });
+    }
+    const mergeBaseCommitHash = reconcile.mergeBaseCommitHash;
+    const reconciledHeadCommitHash = reconcile.reconciledHeadCommitHash;
+    const resultBundleRef = reconcile.resultBundleRef;
+    return withRepoMutationLock(
+      {
+        cwd: repoRoot,
+        operation: "collabReconcile"
+      },
+      async ({ repoRoot: lockedRepoRoot, warnings }) => {
+        await assertRepoSnapshotUnchanged(lockedRepoRoot, repoSnapshot, {
+          operation: "`remix collab reconcile`",
+          recoveryHint: "The repository changed after reconcile was prepared. Review the local changes and rerun `remix collab reconcile`."
+        });
+        await ensureCleanWorktree(lockedRepoRoot, "`remix collab reconcile`");
+        const lockedBranch = await requireCurrentBranch(lockedRepoRoot);
+        assertPreferredBranchMatch({
+          currentBranch: lockedBranch,
+          preferredBranch: binding.preferredBranch,
+          allowBranchMismatch: params.allowBranchMismatch,
+          operation: "`remix collab reconcile`"
+        });
+        const backup = await createBackupBranch(lockedRepoRoot, {
+          branchName: branch,
+          sourceCommitHash: headCommitHash,
+          prefix: "remix/reconcile-backup"
+        });
+        await hardResetToCommit(lockedRepoRoot, mergeBaseCommitHash, "`remix collab reconcile`");
+        const bundleResp = await params.api.downloadAppReconcileBundle(binding.currentAppId, reconcile.id);
+        const resultTempDir = await fs7.mkdtemp(path5.join(os3.tmpdir(), "remix-reconcile-"));
+        const resultBundlePath = path5.join(resultTempDir, bundleResp.fileName ?? "reconcile-result.bundle");
+        try {
+          await fs7.writeFile(resultBundlePath, bundleResp.data);
+          await importGitBundle(lockedRepoRoot, resultBundlePath, resultBundleRef);
+          await ensureCommitExists(lockedRepoRoot, reconciledHeadCommitHash);
+          const localCommitHash = await fastForwardToCommit(lockedRepoRoot, reconciledHeadCommitHash);
+          if (localCommitHash !== reconciledHeadCommitHash) {
+            throw new RemixError("Local reconcile completed but final HEAD does not match the server result.", { exitCode: 1 });
+          }
+          return {
+            ...previewResult,
+            status: reconcile.status,
+            reconcileId: reconcile.id,
+            mergeBaseCommitHash: reconcile.mergeBaseCommitHash,
+            reconciledHeadCommitId: reconcile.reconciledHeadCommitId,
+            reconciledHeadCommitHash: reconcile.reconciledHeadCommitHash,
+            backupBranchName: backup.branchName,
+            localCommitHash,
+            applied: true,
+            dryRun: false,
+            warnings: Array.from(/* @__PURE__ */ new Set([...previewResult.warnings, ...warnings]))
+          };
+        } finally {
+          await fs7.rm(resultTempDir, { recursive: true, force: true });
+        }
+      }
+    );
+  } finally {
+    await fs7.rm(bundleTempDir, { recursive: true, force: true });
+  }
+}
+
+// src/application/collab/collabReject.ts
+async function collabReject(params) {
+  const resp = await params.api.updateMergeRequest(params.mrId, { status: "rejected" });
+  return unwrapResponseObject(resp, "merge request");
+}
+
+// src/application/collab/collabRemix.ts
+import fs8 from "fs/promises";
+import os4 from "os";
+import path6 from "path";
+async function pathExists(targetPath) {
+  try {
+    await fs8.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function statIsDirectory(targetPath) {
+  const stats = await fs8.stat(targetPath).catch(() => null);
+  return Boolean(stats?.isDirectory());
+}
+async function findContainingGitRoot(startPath) {
+  let current = path6.resolve(startPath);
+  while (true) {
+    if (await pathExists(path6.join(current, ".git"))) return current;
+    const parent = path6.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function isSubpath(parentPath, candidatePath) {
+  const relative = path6.relative(parentPath, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path6.isAbsolute(relative);
+}
+function buildPreferredRemixBranch(appId) {
+  const normalized = appId.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return `remix/remix/${normalized || "app"}`;
+}
+async function resolveRemixDestination(params) {
+  if (params.outputDir?.trim()) {
+    const preferredRepoRoot = path6.resolve(params.outputDir.trim());
+    const parentDir2 = path6.dirname(preferredRepoRoot);
+    if (!await statIsDirectory(parentDir2)) {
+      throw new RemixError("Remix output parent directory does not exist.", {
+        exitCode: 2,
+        hint: `Create the directory first: ${parentDir2}`
+      });
+    }
+    return {
+      preferredRepoRoot,
+      parentDir: parentDir2,
+      explicitOutputDir: true
+    };
+  }
+  const parentDir = path6.resolve(params.cwd);
+  if (!await statIsDirectory(parentDir)) {
+    throw new RemixError("Remix output parent directory does not exist.", {
+      exitCode: 2,
+      hint: `Create the directory first: ${parentDir}`
+    });
+  }
+  return {
+    preferredRepoRoot: path6.join(parentDir, params.defaultDirName),
+    parentDir,
+    explicitOutputDir: false
+  };
+}
+async function assertSafeRemixDestination(params) {
+  const callerGitRoot = await findContainingGitRoot(params.cwd);
+  if (callerGitRoot && isSubpath(callerGitRoot, params.repoRoot)) {
+    throw new RemixError("Refusing to create a remix checkout inside an existing git repository.", {
+      exitCode: 2,
+      hint: params.explicitOutputDir ? `Choose a destination outside ${callerGitRoot}.` : `Pass --output-dir outside ${callerGitRoot}.`
+    });
+  }
+  const parentGitRoot = await findContainingGitRoot(params.parentDir);
+  if (parentGitRoot && isSubpath(parentGitRoot, params.repoRoot)) {
+    throw new RemixError("Refusing to create a remix checkout inside an existing git repository.", {
+      exitCode: 2,
+      hint: params.explicitOutputDir ? `Choose a destination outside ${parentGitRoot}.` : `Pass --output-dir outside ${parentGitRoot}.`
+    });
+  }
+}
+async function collabRemix(params) {
+  const sourceAppId = params.appId?.trim() || null;
+  if (!sourceAppId) {
+    throw new RemixError("No source app selected.", {
+      exitCode: 2,
+      hint: "Pass the source app id to remix."
+    });
+  }
+  const forkResp = await params.api.forkApp(sourceAppId, { name: params.name?.trim() || void 0, platform: "generic" });
+  const forked = unwrapResponseObject(forkResp, "fork");
+  const app = await pollAppReady(params.api, String(forked.id));
+  const baseDirName = sanitizeCheckoutDirName(String(params.name?.trim() || app.name || app.id));
+  const destination = await resolveRemixDestination({
+    cwd: params.cwd,
+    outputDir: params.outputDir ?? null,
+    defaultDirName: baseDirName
+  });
+  await assertSafeRemixDestination({
+    cwd: params.cwd,
+    repoRoot: destination.preferredRepoRoot,
+    parentDir: destination.parentDir,
+    explicitOutputDir: destination.explicitOutputDir
+  });
+  const repoRoot = destination.explicitOutputDir ? await reserveDirectory(destination.preferredRepoRoot) : await reserveAvailableDirPath(destination.preferredRepoRoot);
+  const bundleTempDir = await fs8.mkdtemp(path6.join(os4.tmpdir(), "remix-remix-"));
+  const bundlePath = path6.join(bundleTempDir, "repository.bundle");
+  try {
+    const bundle = await params.api.downloadAppBundle(String(app.id));
+    await fs8.writeFile(bundlePath, bundle.data);
+    await cloneGitBundleToDirectory(bundlePath, repoRoot);
+    await checkoutLocalBranch(repoRoot, buildPreferredRemixBranch(String(app.id)));
+    await ensureGitInfoExcludeEntries(repoRoot, [".remix/"]);
+  } catch (err) {
+    await fs8.rm(repoRoot, { recursive: true, force: true }).catch(() => {
+    });
+    throw err;
+  } finally {
+    await fs8.rm(bundleTempDir, { recursive: true, force: true });
+  }
+  const remoteUrl = normalizeGitRemote(await getRemoteOriginUrl(repoRoot));
+  const defaultBranch = await getDefaultBranch(repoRoot) ?? await getCurrentBranch(repoRoot) ?? null;
+  const preferredBranch = await getCurrentBranch(repoRoot) ?? buildPreferredRemixBranch(String(app.id));
+  const repoFingerprint = remoteUrl ? await buildRepoFingerprint({ gitRoot: repoRoot, remoteUrl, defaultBranch }) : null;
+  const bindingPath = await writeCollabBinding(repoRoot, {
+    projectId: String(app.projectId),
+    currentAppId: String(app.id),
+    upstreamAppId: String(app.forkedFromAppId ?? sourceAppId),
+    threadId: app.threadId ? String(app.threadId) : null,
+    repoFingerprint,
+    remoteUrl,
+    defaultBranch,
+    preferredBranch
+  });
+  return {
+    appId: String(app.id),
+    projectId: String(app.projectId),
+    upstreamAppId: String(app.forkedFromAppId ?? sourceAppId),
+    bindingPath,
+    repoRoot
+  };
+}
+
+// src/application/collab/collabRequestMerge.ts
+async function collabRequestMerge(params) {
+  const repoRoot = await findGitRoot(params.cwd);
+  const binding = await readCollabBinding(repoRoot);
+  if (!binding) throw new RemixError("Repository is not bound to Remix.", { exitCode: 2 });
+  const resp = await params.api.openMergeRequest(binding.currentAppId);
+  return unwrapResponseObject(resp, "merge request");
+}
+
+// src/application/collab/collabStatus.ts
+function createBaseStatus() {
+  return {
+    schemaVersion: 1,
+    repo: {
+      isGitRepo: false,
+      repoRoot: null,
+      branch: null,
+      branchMismatch: false,
+      headCommitHash: null,
+      worktree: {
+        isClean: true,
+        entryCount: 0,
+        hasTrackedChanges: false,
+        hasUntrackedFiles: false,
+        preview: []
+      }
+    },
+    binding: {
+      isBound: false,
+      path: null,
+      projectId: null,
+      currentAppId: null,
+      upstreamAppId: null,
+      isRemix: null,
+      threadId: null,
+      repoFingerprint: null,
+      remoteUrl: null,
+      defaultBranch: null,
+      preferredBranch: null
+    },
+    remote: {
+      checked: false,
+      error: null,
+      appStatus: null,
+      incomingOpenMergeRequestCount: null,
+      outgoingOpenMergeRequestCount: null
+    },
+    sync: {
+      checked: false,
+      error: null,
+      canApply: false,
+      status: "not_available",
+      blockedReasons: [],
+      warnings: [],
+      targetCommitHash: null,
+      targetCommitId: null,
+      stats: null
+    },
+    reconcile: {
+      checked: false,
+      error: null,
+      canApply: false,
+      status: "not_available",
+      blockedReasons: [],
+      warnings: [],
+      targetHeadCommitHash: null,
+      targetHeadCommitId: null
+    },
+    recommendedAction: "no_action",
+    warnings: []
+  };
+}
+function addWarning(status, message) {
+  const value = String(message ?? "").trim();
+  if (!value || status.warnings.includes(value)) return;
+  status.warnings.push(value);
+}
+function addBlockedReason(target, reason) {
+  if (!target.blockedReasons.includes(reason)) target.blockedReasons.push(reason);
+}
+function countMergeRequests(payload) {
+  if (Array.isArray(payload)) return payload.length;
+  if (!payload || typeof payload !== "object") return 0;
+  let total = 0;
+  for (const value of Object.values(payload)) {
+    if (Array.isArray(value)) total += value.length;
+  }
+  return total;
+}
+async function collabStatus(params) {
+  const status = createBaseStatus();
+  let repoRoot;
+  try {
+    repoRoot = await findGitRoot(params.cwd);
+  } catch (err) {
+    addBlockedReason(status.sync, "not_git_repo");
+    addBlockedReason(status.reconcile, "not_git_repo");
+    addWarning(status, formatCliErrorDetail(err));
+    return status;
+  }
+  status.repo.isGitRepo = true;
+  status.repo.repoRoot = repoRoot;
+  const [branch, headCommitHash, worktreeStatus, binding] = await Promise.all([
+    getCurrentBranch(repoRoot),
+    getHeadCommitHash(repoRoot),
+    getWorktreeStatus(repoRoot),
+    readCollabBinding(repoRoot)
+  ]);
+  status.repo.branch = branch;
+  status.repo.branchMismatch = false;
+  status.repo.headCommitHash = headCommitHash;
+  status.repo.worktree = {
+    isClean: worktreeStatus.isClean,
+    entryCount: worktreeStatus.entries.length,
+    hasTrackedChanges: worktreeStatus.entries.some((entry) => !entry.startsWith("??")),
+    hasUntrackedFiles: worktreeStatus.entries.some((entry) => entry.startsWith("??")),
+    preview: worktreeStatus.entries.slice(0, 10)
+  };
+  if (!status.repo.worktree.isClean) addWarning(status, "Working tree has local changes.");
+  if (!branch) addWarning(status, "Repository is in a detached HEAD state.");
+  if (!headCommitHash) addWarning(status, "Failed to resolve local HEAD commit.");
+  if (!binding) {
+    status.binding.path = null;
+    addBlockedReason(status.sync, "not_bound");
+    addBlockedReason(status.reconcile, "not_bound");
+    status.recommendedAction = "init";
+    return status;
+  }
+  status.binding = {
+    isBound: true,
+    path: getCollabBindingPath(repoRoot),
+    projectId: binding.projectId,
+    currentAppId: binding.currentAppId,
+    upstreamAppId: binding.upstreamAppId,
+    isRemix: binding.currentAppId !== binding.upstreamAppId,
+    threadId: binding.threadId,
+    repoFingerprint: binding.repoFingerprint,
+    remoteUrl: binding.remoteUrl,
+    defaultBranch: binding.defaultBranch,
+    preferredBranch: binding.preferredBranch
+  };
+  status.repo.branchMismatch = !isPreferredBranchMatch(branch, binding.preferredBranch);
+  if (status.repo.branchMismatch) {
+    addWarning(
+      status,
+      `Current branch ${branch ?? "(detached)"} does not match preferred branch ${binding.preferredBranch ?? "(unset)"}.`
+    );
+  }
+  if (!params.api) {
+    status.recommendedAction = "no_action";
+    return status;
+  }
+  const [appResult, incomingResult, outgoingResult, syncResult] = await Promise.allSettled([
+    params.api.getApp(binding.currentAppId),
+    params.api.listMergeRequests({ targetAppId: binding.currentAppId, status: "open", kind: "merge" }),
+    params.api.listMergeRequests({ sourceAppId: binding.currentAppId, status: "open", kind: "merge" }),
+    headCommitHash ? params.api.syncLocalApp(binding.currentAppId, {
+      baseCommitHash: headCommitHash,
+      repoFingerprint: binding.repoFingerprint ?? void 0,
+      remoteUrl: binding.remoteUrl ?? void 0,
+      defaultBranch: binding.defaultBranch ?? void 0,
+      dryRun: true
+    }) : Promise.resolve(null)
+  ]);
+  const remoteErrors = [];
+  if (appResult.status === "fulfilled") {
+    const app = unwrapResponseObject(appResult.value, "app");
+    status.remote.appStatus = typeof app.status === "string" ? app.status : null;
+  } else {
+    remoteErrors.push(formatCliErrorDetail(appResult.reason) ?? "Failed to fetch app status.");
+  }
+  if (incomingResult.status === "fulfilled") {
+    const incoming = unwrapResponseObject(incomingResult.value, "merge requests");
+    status.remote.incomingOpenMergeRequestCount = countMergeRequests(incoming);
+  } else {
+    remoteErrors.push(formatCliErrorDetail(incomingResult.reason) ?? "Failed to fetch incoming merge requests.");
+  }
+  if (outgoingResult.status === "fulfilled") {
+    const outgoing = unwrapResponseObject(outgoingResult.value, "merge requests");
+    status.remote.outgoingOpenMergeRequestCount = countMergeRequests(outgoing);
+  } else {
+    remoteErrors.push(formatCliErrorDetail(outgoingResult.reason) ?? "Failed to fetch outgoing merge requests.");
+  }
+  status.remote.checked = remoteErrors.length === 0;
+  status.remote.error = remoteErrors.length > 0 ? remoteErrors.join("\n\n") : null;
+  addWarning(status, status.remote.error);
+  if (!headCommitHash) {
+    addBlockedReason(status.sync, "missing_head");
+    addBlockedReason(status.reconcile, "missing_head");
+  } else if (syncResult.status === "fulfilled") {
+    const syncResp = syncResult.value;
+    if (syncResp) {
+      const sync = unwrapResponseObject(syncResp, "sync result");
+      status.sync.checked = true;
+      status.sync.status = sync.status;
+      status.sync.warnings = sync.warnings;
+      status.sync.targetCommitHash = sync.targetCommitHash;
+      status.sync.targetCommitId = sync.targetCommitId;
+      status.sync.stats = sync.stats;
+      if (!status.repo.worktree.isClean) addBlockedReason(status.sync, "dirty_worktree");
+      if (!branch) addBlockedReason(status.sync, "detached_head");
+      if (status.repo.branchMismatch) addBlockedReason(status.sync, "branch_mismatch");
+      if (sync.status === "conflict_risk") addBlockedReason(status.sync, "metadata_conflict");
+      status.sync.canApply = status.sync.status === "ready_to_fast_forward" && status.repo.worktree.isClean && Boolean(branch) && !status.sync.blockedReasons.includes("metadata_conflict");
+      if (sync.status === "conflict_risk") {
+        status.reconcile.checked = true;
+        status.reconcile.status = "metadata_conflict";
+        status.reconcile.warnings = sync.warnings;
+        status.reconcile.targetHeadCommitHash = sync.targetCommitHash;
+        status.reconcile.targetHeadCommitId = sync.targetCommitId;
+        addBlockedReason(status.reconcile, "metadata_conflict");
+        if (!status.repo.worktree.isClean) addBlockedReason(status.reconcile, "dirty_worktree");
+        if (!branch) addBlockedReason(status.reconcile, "detached_head");
+        if (status.repo.branchMismatch) addBlockedReason(status.reconcile, "branch_mismatch");
+      } else if (sync.status === "base_unknown") {
+        try {
+          const preflightResp = await params.api.preflightAppReconcile(binding.currentAppId, {
+            localHeadCommitHash: headCommitHash,
+            repoFingerprint: binding.repoFingerprint ?? void 0,
+            remoteUrl: binding.remoteUrl ?? void 0,
+            defaultBranch: binding.defaultBranch ?? void 0
+          });
+          const preflight = unwrapResponseObject(preflightResp, "reconcile preflight");
+          status.reconcile.checked = true;
+          status.reconcile.status = preflight.status;
+          status.reconcile.warnings = preflight.warnings;
+          status.reconcile.targetHeadCommitHash = preflight.targetHeadCommitHash;
+          status.reconcile.targetHeadCommitId = preflight.targetHeadCommitId;
+          if (!status.repo.worktree.isClean) addBlockedReason(status.reconcile, "dirty_worktree");
+          if (!branch) addBlockedReason(status.reconcile, "detached_head");
+          if (status.repo.branchMismatch) addBlockedReason(status.reconcile, "branch_mismatch");
+          if (preflight.status === "metadata_conflict") addBlockedReason(status.reconcile, "metadata_conflict");
+          status.reconcile.canApply = preflight.status === "ready_to_reconcile" && status.repo.worktree.isClean && Boolean(branch) && !status.reconcile.blockedReasons.includes("metadata_conflict");
+        } catch (err) {
+          status.reconcile.error = formatCliErrorDetail(err) ?? "Failed to fetch reconcile preflight.";
+          addBlockedReason(status.reconcile, "remote_error");
+          addWarning(status, status.reconcile.error);
+        }
+      } else {
+        status.reconcile.checked = true;
+        status.reconcile.status = "not_needed";
+        if (!status.repo.worktree.isClean) addBlockedReason(status.reconcile, "dirty_worktree");
+        if (!branch) addBlockedReason(status.reconcile, "detached_head");
+        if (status.repo.branchMismatch) addBlockedReason(status.reconcile, "branch_mismatch");
+      }
+    }
+  } else {
+    status.sync.error = formatCliErrorDetail(syncResult.reason) ?? "Failed to fetch sync status.";
+    addBlockedReason(status.sync, "remote_error");
+    addBlockedReason(status.reconcile, "remote_error");
+    addWarning(status, status.sync.error);
+  }
+  for (const warning of status.sync.warnings) addWarning(status, warning);
+  for (const warning of status.reconcile.warnings) addWarning(status, warning);
+  if (!status.binding.isBound) {
+    status.recommendedAction = "init";
+  } else if (status.sync.canApply && status.sync.status === "ready_to_fast_forward") {
+    status.recommendedAction = "sync";
+  } else if (status.reconcile.canApply && status.reconcile.status === "ready_to_reconcile") {
+    status.recommendedAction = "reconcile";
+  } else if ((status.remote.incomingOpenMergeRequestCount ?? 0) > 0) {
+    status.recommendedAction = "review_inbox";
+  } else {
+    status.recommendedAction = "no_action";
+  }
+  return status;
+}
+
+// src/application/collab/collabSyncUpstream.ts
+async function collabSyncUpstream(params) {
+  const repoRoot = await findGitRoot(params.cwd);
+  const binding = await readCollabBinding(repoRoot);
+  if (!binding) {
+    throw new RemixError("Repository is not bound to Remix.", {
+      exitCode: 2,
+      hint: "Run `remix collab init` first."
+    });
+  }
+  await ensureCleanWorktree(repoRoot, "`remix collab sync-upstream`");
+  await requireCurrentBranch(repoRoot);
+  const repoSnapshot = await captureRepoSnapshot(repoRoot);
+  if (binding.currentAppId === binding.upstreamAppId) {
+    throw new RemixError("Current repository is not bound to a remix/fork app.", {
+      exitCode: 2,
+      hint: "`remix collab sync-upstream` only applies to remixes/forks that have an upstream app."
+    });
+  }
+  const currentAppResp = await params.api.getApp(binding.currentAppId);
+  const currentApp = unwrapResponseObject(currentAppResp, "app");
+  const initialHeadCommitId = typeof currentApp.headCommitId === "string" ? currentApp.headCommitId : null;
+  const initialStatus = typeof currentApp.status === "string" ? currentApp.status : null;
+  const resp = await params.api.syncUpstreamApp(binding.currentAppId);
+  const syncUpstream = unwrapResponseObject(resp, "upstream sync");
+  if (syncUpstream.status === "up-to-date") {
+    return {
+      status: syncUpstream.status,
+      repoRoot,
+      appId: binding.currentAppId,
+      upstreamAppId: binding.upstreamAppId,
+      localUpdated: false
+    };
+  }
+  const completedApp = await pollUpstreamSyncCompletion(params.api, binding.currentAppId, {
+    initialHeadCommitId,
+    initialStatus
+  });
+  const localSyncResult = await withRepoMutationLock(
+    {
+      cwd: repoRoot,
+      operation: "collabSyncUpstream"
+    },
+    async ({ repoRoot: lockedRepoRoot, warnings }) => {
+      await assertRepoSnapshotUnchanged(lockedRepoRoot, repoSnapshot, {
+        operation: "`remix collab sync-upstream`",
+        recoveryHint: "The repository changed while upstream sync was in progress. Review the local changes and rerun `remix collab sync-upstream`."
+      });
+      await ensureCleanWorktree(lockedRepoRoot, "`remix collab sync-upstream`");
+      await requireCurrentBranch(lockedRepoRoot);
+      const localSync = await collabSync({
+        api: params.api,
+        cwd: lockedRepoRoot,
+        dryRun: false
+      });
+      const localSyncWarnings = Array.isArray(localSync.warnings) ? localSync.warnings ?? [] : [];
+      return {
+        ...localSync,
+        ...warnings.length > 0 || localSyncWarnings.length > 0 ? {
+          warnings: Array.from(/* @__PURE__ */ new Set([...warnings, ...localSyncWarnings]))
+        } : {}
+      };
+    }
+  );
+  return {
+    status: syncUpstream.status,
+    mergeRequestId: syncUpstream.mergeRequestId ?? null,
+    repoRoot,
+    appId: binding.currentAppId,
+    upstreamAppId: binding.upstreamAppId,
+    remoteHeadCommitId: typeof completedApp.headCommitId === "string" ? completedApp.headCommitId : null,
+    localSync: localSyncResult,
+    localUpdated: true,
+    ...Array.isArray(localSyncResult.warnings) && (localSyncResult.warnings?.length ?? 0) > 0 ? { warnings: localSyncResult.warnings } : {}
+  };
+}
+
+// src/application/collab/collabView.ts
+async function collabView(params) {
+  const resp = await params.api.getMergeRequestReview(params.mrId);
+  return unwrapMergeRequestReview(resp);
+}
+export {
+  collabAdd,
+  collabApprove,
+  collabInbox,
+  collabInit,
+  collabInvite,
+  collabList,
+  collabReconcile,
+  collabRecordTurn,
+  collabReject,
+  collabRemix,
+  collabRequestMerge,
+  collabStatus,
+  collabSync,
+  collabSyncUpstream,
+  collabView
+};