@remixhq/core 0.1.2

package/dist/index.cjs

@@ -0,0 +1,1269 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CliError: () => CliError,
+  buildRepoFingerprint: () => buildRepoFingerprint,
+  cloneGitBundleToDirectory: () => cloneGitBundleToDirectory,
+  collabAdd: () => collabAdd,
+  collabApprove: () => collabApprove,
+  collabInbox: () => collabInbox,
+  collabInit: () => collabInit,
+  collabInvite: () => collabInvite,
+  collabList: () => collabList,
+  collabReconcile: () => collabReconcile,
+  collabReject: () => collabReject,
+  collabRemix: () => collabRemix,
+  collabRequestMerge: () => collabRequestMerge,
+  collabSync: () => collabSync,
+  collabSyncUpstream: () => collabSyncUpstream,
+  collabView: () => collabView,
+  createBackupBranch: () => createBackupBranch,
+  createGitBundle: () => createGitBundle,
+  discardTrackedChanges: () => discardTrackedChanges,
+  ensureCleanWorktree: () => ensureCleanWorktree,
+  ensureCommitExists: () => ensureCommitExists,
+  ensureGitInfoExcludeEntries: () => ensureGitInfoExcludeEntries,
+  fastForwardToCommit: () => fastForwardToCommit,
+  findGitRoot: () => findGitRoot,
+  getCollabBindingPath: () => getCollabBindingPath,
+  getCurrentBranch: () => getCurrentBranch,
+  getDefaultBranch: () => getDefaultBranch,
+  getHeadCommitHash: () => getHeadCommitHash,
+  getRemoteOriginUrl: () => getRemoteOriginUrl,
+  getWorkingTreeDiff: () => getWorkingTreeDiff,
+  hardResetToCommit: () => hardResetToCommit,
+  importGitBundle: () => importGitBundle,
+  listUntrackedFiles: () => listUntrackedFiles,
+  normalizeGitRemote: () => normalizeGitRemote,
+  readCollabBinding: () => readCollabBinding,
+  requireCurrentBranch: () => requireCurrentBranch,
+  summarizeUnifiedDiff: () => summarizeUnifiedDiff,
+  writeCollabBinding: () => writeCollabBinding,
+  writeTempUnifiedDiffBackup: () => writeTempUnifiedDiffBackup
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors/cliError.ts
+var CliError = class extends Error {
+  exitCode;
+  hint;
+  constructor(message, opts) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = opts?.exitCode ?? 1;
+    this.hint = opts?.hint ?? null;
+  }
+};
+
+// src/infrastructure/binding/collabBindingStore.ts
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/shared/fs.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path = __toESM(require("path"), 1);
+async function pathExists(targetPath) {
+  try {
+    await import_promises.default.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findAvailableDirPath(preferredDir) {
+  if (!await pathExists(preferredDir)) return preferredDir;
+  const parent = import_node_path.default.dirname(preferredDir);
+  const base = import_node_path.default.basename(preferredDir);
+  for (let i = 2; i <= 1e3; i++) {
+    const candidate = import_node_path.default.join(parent, `${base}-${i}`);
+    if (!await pathExists(candidate)) return candidate;
+  }
+  throw new CliError("No available output directory name.", {
+    exitCode: 2,
+    hint: `Tried ${base}-2 through ${base}-1000 under ${parent}.`
+  });
+}
+async function writeJsonAtomic(filePath, value) {
+  const dir = import_node_path.default.dirname(filePath);
+  await import_promises.default.mkdir(dir, { recursive: true });
+  const tmp = `${filePath}.tmp-${Date.now()}`;
+  await import_promises.default.writeFile(tmp, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  await import_promises.default.rename(tmp, filePath);
+}
+
+// src/infrastructure/binding/collabBindingStore.ts
+function getCollabBindingPath(repoRoot) {
+  return import_node_path2.default.join(repoRoot, ".comerge", "config.json");
+}
+async function readCollabBinding(repoRoot) {
+  try {
+    const raw = await import_promises2.default.readFile(getCollabBindingPath(repoRoot), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed?.schemaVersion !== 1) return null;
+    if (!parsed.projectId || !parsed.currentAppId || !parsed.upstreamAppId) return null;
+    return {
+      schemaVersion: 1,
+      projectId: parsed.projectId,
+      currentAppId: parsed.currentAppId,
+      upstreamAppId: parsed.upstreamAppId,
+      threadId: parsed.threadId ?? null,
+      repoFingerprint: parsed.repoFingerprint ?? null,
+      remoteUrl: parsed.remoteUrl ?? null,
+      defaultBranch: parsed.defaultBranch ?? null
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeCollabBinding(repoRoot, binding) {
+  const filePath = getCollabBindingPath(repoRoot);
+  await writeJsonAtomic(filePath, {
+    schemaVersion: 1,
+    ...binding
+  });
+  return filePath;
+}
+
+// src/infrastructure/repo/gitRepo.ts
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_crypto = require("crypto");
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_execa = require("execa");
+var GIT_REMOTE_PROTOCOL_RE = /^(https?|ssh):\/\//i;
+var SCP_LIKE_GIT_REMOTE_RE = /^(?<user>[^@\s]+)@(?<host>[^:\s]+):(?<path>[^\\\s]+)$/;
+var CANONICAL_GIT_REMOTE_RE = /^(?<host>(?:localhost|[a-z0-9.-]+))\/(?<path>[^\\\s]+)$/i;
+async function runGit(args, cwd) {
+  const res = await (0, import_execa.execa)("git", args, { cwd, stderr: "ignore" });
+  return String(res.stdout || "").trim();
+}
+async function runGitRaw(args, cwd) {
+  const res = await (0, import_execa.execa)("git", args, { cwd, stderr: "ignore", stripFinalNewline: false });
+  return String(res.stdout || "");
+}
+async function runGitDetailed(args, cwd) {
+  const res = await (0, import_execa.execa)("git", args, { cwd, reject: false });
+  return {
+    exitCode: res.exitCode ?? 1,
+    stdout: String(res.stdout || ""),
+    stderr: String(res.stderr || "")
+  };
+}
+function cleanRepoPath(value) {
+  return value.trim().replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.git$/i, "");
+}
+function normalizeGitRemote(remote) {
+  const raw = String(remote ?? "").trim();
+  if (!raw) return null;
+  const canonicalMatch = raw.match(CANONICAL_GIT_REMOTE_RE);
+  if (canonicalMatch?.groups?.host && canonicalMatch.groups.path) {
+    const repoPath = cleanRepoPath(canonicalMatch.groups.path);
+    if (!repoPath) return null;
+    return `${canonicalMatch.groups.host}/${repoPath}`.toLowerCase();
+  }
+  if (GIT_REMOTE_PROTOCOL_RE.test(raw)) {
+    try {
+      const url = new URL(raw);
+      const repoPath = cleanRepoPath(url.pathname);
+      if (!url.hostname || !repoPath) return null;
+      return `${url.hostname}/${repoPath}`.toLowerCase();
+    } catch {
+      return null;
+    }
+  }
+  const scpMatch = raw.match(SCP_LIKE_GIT_REMOTE_RE);
+  if (scpMatch?.groups?.host && scpMatch.groups.path) {
+    const repoPath = cleanRepoPath(scpMatch.groups.path);
+    if (!repoPath) return null;
+    return `${scpMatch.groups.host}/${repoPath}`.toLowerCase();
+  }
+  return null;
+}
+function sanitizeRefFragment(value) {
+  return value.trim().replace(/[^A-Za-z0-9._/-]+/g, "-").replace(/\/{2,}/g, "/").replace(/^\/+|\/+$/g, "").replace(/^-+|-+$/g, "").slice(0, 120);
+}
+async function findGitRoot(startDir) {
+  try {
+    const root = await runGit(["rev-parse", "--show-toplevel"], startDir);
+    if (!root) throw new Error("empty");
+    return root;
+  } catch {
+    throw new CliError("Not inside a git repository.", {
+      exitCode: 2,
+      hint: "Run this command from the root of the repository or one of its subdirectories."
+    });
+  }
+}
+async function getCurrentBranch(cwd) {
+  try {
+    const branch = await runGit(["branch", "--show-current"], cwd);
+    return branch || null;
+  } catch {
+    return null;
+  }
+}
+async function getRemoteOriginUrl(cwd) {
+  try {
+    const url = await runGit(["config", "--get", "remote.origin.url"], cwd);
+    return url || null;
+  } catch {
+    return null;
+  }
+}
+async function getDefaultBranch(cwd) {
+  try {
+    const ref = await runGit(["symbolic-ref", "refs/remotes/origin/HEAD"], cwd);
+    if (!ref) return null;
+    const suffix = ref.replace(/^refs\/remotes\/origin\//, "").trim();
+    return suffix || null;
+  } catch {
+    return null;
+  }
+}
+async function listUntrackedFiles(cwd) {
+  try {
+    const out = await runGit(["ls-files", "--others", "--exclude-standard"], cwd);
+    return out.split("\n").map((line) => line.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function getWorkingTreeDiff(cwd) {
+  const untracked = await listUntrackedFiles(cwd);
+  if (untracked.length > 0) {
+    throw new CliError("Untracked files are not included in git diff mode.", {
+      exitCode: 2,
+      hint: "Provide `--diff-file`/`--diff-stdin`, or add the files to git before running `comerge collab add`."
+    });
+  }
+  try {
+    return await runGitRaw(["diff", "--binary", "--no-ext-diff", "HEAD"], cwd);
+  } catch {
+    throw new CliError("Failed to generate git diff.", { exitCode: 1 });
+  }
+}
+async function writeTempUnifiedDiffBackup(diff, prefix = "comerge-add-backup") {
+  const safePrefix = prefix.replace(/[^a-zA-Z0-9._-]+/g, "-") || "comerge-add-backup";
+  const tmpDir = await import_promises3.default.mkdtemp(import_node_path3.default.join(import_node_os.default.tmpdir(), `${safePrefix}-`));
+  const backupPath = import_node_path3.default.join(tmpDir, "submitted.diff");
+  await import_promises3.default.writeFile(backupPath, diff, "utf8");
+  return { backupPath };
+}
+async function getHeadCommitHash(cwd) {
+  try {
+    const hash = await runGit(["rev-parse", "HEAD"], cwd);
+    return hash || null;
+  } catch {
+    return null;
+  }
+}
+async function createGitBundle(cwd, bundleName = "repository.bundle") {
+  const headCommitHash = await getHeadCommitHash(cwd);
+  if (!headCommitHash) {
+    throw new CliError("Failed to resolve local HEAD commit.", { exitCode: 1 });
+  }
+  const safeName = bundleName.replace(/[^a-zA-Z0-9._-]+/g, "_");
+  const tmpDir = await import_promises3.default.mkdtemp(import_node_path3.default.join(import_node_os.default.tmpdir(), "comerge-bundle-"));
+  const bundlePath = import_node_path3.default.join(tmpDir, safeName);
+  const res = await runGitDetailed(["bundle", "create", bundlePath, "--all", "--tags"], cwd);
+  if (res.exitCode !== 0) {
+    const detail = [res.stderr.trim(), res.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new CliError("Failed to create repository bundle.", {
+      exitCode: 1,
+      hint: detail || "Git could not create the bundle artifact."
+    });
+  }
+  return { bundlePath, headCommitHash };
+}
+async function getWorktreeStatus(cwd) {
+  try {
+    const out = await runGit(["status", "--porcelain"], cwd);
+    const entries = out.split("\n").map((line) => line.trimEnd()).filter(Boolean);
+    return { isClean: entries.length === 0, entries };
+  } catch {
+    return { isClean: false, entries: [] };
+  }
+}
+async function ensureCleanWorktree(cwd, operation = "`comerge collab sync`") {
+  const status = await getWorktreeStatus(cwd);
+  if (status.isClean) return;
+  const preview = status.entries.slice(0, 10).join("\n");
+  const suffix = status.entries.length > 10 ? `
+...and ${status.entries.length - 10} more` : "";
+  throw new CliError(`Working tree must be clean before running ${operation}.`, {
+    exitCode: 2,
+    hint: `Commit, stash, or discard local changes first.
+
+${preview}${suffix}`
+  });
+}
+async function discardTrackedChanges(cwd, operation = "`comerge collab add`") {
+  const res = await runGitDetailed(["reset", "--hard", "HEAD"], cwd);
+  if (res.exitCode !== 0) {
+    const detail = [res.stderr.trim(), res.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new CliError(`Failed to discard local tracked changes while running ${operation}.`, {
+      exitCode: 1,
+      hint: detail || "Git could not reset tracked changes back to HEAD."
+    });
+  }
+  const hash = await getHeadCommitHash(cwd);
+  if (!hash) {
+    throw new CliError("Failed to resolve local HEAD after discarding tracked changes.", { exitCode: 1 });
+  }
+  return hash;
+}
+async function requireCurrentBranch(cwd) {
+  const branch = await getCurrentBranch(cwd);
+  if (!branch) {
+    throw new CliError("`comerge collab sync` requires a checked out local branch.", {
+      exitCode: 2,
+      hint: "Checkout a branch before syncing."
+    });
+  }
+  return branch;
+}
+async function importGitBundle(cwd, bundlePath, bundleRef) {
+  const verifyRes = await runGitDetailed(["bundle", "verify", bundlePath], cwd);
+  if (verifyRes.exitCode !== 0) {
+    const detail = [verifyRes.stderr.trim(), verifyRes.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new CliError("Failed to verify sync bundle.", {
+      exitCode: 1,
+      hint: detail || "Git bundle verification failed."
+    });
+  }
+  const fetchRes = await runGitDetailed(["fetch", "--quiet", bundlePath, bundleRef], cwd);
+  if (fetchRes.exitCode !== 0) {
+    const detail = [fetchRes.stderr.trim(), fetchRes.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new CliError("Failed to import sync bundle.", {
+      exitCode: 1,
+      hint: detail || "Git could not fetch objects from the sync bundle."
+    });
+  }
+}
+async function cloneGitBundleToDirectory(bundlePath, targetDir) {
+  const parentDir = import_node_path3.default.dirname(targetDir);
+  const cloneRes = await runGitDetailed(["clone", bundlePath, targetDir], parentDir);
+  if (cloneRes.exitCode !== 0) {
+    const detail = [cloneRes.stderr.trim(), cloneRes.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new CliError("Failed to create local remix checkout.", {
+      exitCode: 1,
+      hint: detail || "Git could not clone the remix repository bundle."
+    });
+  }
+  const remoteRemoveRes = await runGitDetailed(["remote", "remove", "origin"], targetDir);
+  if (remoteRemoveRes.exitCode !== 0) {
+    const detail = [remoteRemoveRes.stderr.trim(), remoteRemoveRes.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new CliError("Failed to finalize local remix checkout.", {
+      exitCode: 1,
+      hint: detail || "Git could not remove the temporary bundle origin."
+    });
+  }
+}
+async function ensureGitInfoExcludeEntries(cwd, entries) {
+  const excludePath = import_node_path3.default.join(cwd, ".git", "info", "exclude");
+  await import_promises3.default.mkdir(import_node_path3.default.dirname(excludePath), { recursive: true });
+  let current = "";
+  try {
+    current = await import_promises3.default.readFile(excludePath, "utf8");
+  } catch {
+  }
+  const lines = new Set(current.split("\n").map((line) => line.trim()).filter(Boolean));
+  let changed = false;
+  for (const entry of entries) {
+    const normalized = entry.trim();
+    if (!normalized || lines.has(normalized)) continue;
+    lines.add(normalized);
+    changed = true;
+  }
+  if (!changed) return;
+  await import_promises3.default.writeFile(excludePath, `${Array.from(lines).join("\n")}
+`, "utf8");
+}
+async function ensureCommitExists(cwd, commitHash) {
+  const res = await runGitDetailed(["cat-file", "-e", `${commitHash}^{commit}`], cwd);
+  if (res.exitCode === 0) return;
+  throw new CliError("Expected target commit is missing after bundle import.", {
+    exitCode: 1,
+    hint: `Commit ${commitHash} is not available in the local repository.`
+  });
+}
+async function fastForwardToCommit(cwd, commitHash) {
+  const res = await runGitDetailed(["merge", "--ff-only", commitHash], cwd);
+  if (res.exitCode !== 0) {
+    const detail = [res.stderr.trim(), res.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new CliError("Failed to fast-forward local branch.", {
+      exitCode: 1,
+      hint: detail || "Git could not fast-forward to the target commit."
+    });
+  }
+  const hash = await getHeadCommitHash(cwd);
+  if (!hash) throw new CliError("Failed to resolve local HEAD after fast-forward sync.", { exitCode: 1 });
+  return hash;
+}
+async function createBackupBranch(cwd, params) {
+  const sourceCommitHash = params?.sourceCommitHash?.trim() || await getHeadCommitHash(cwd);
+  if (!sourceCommitHash) {
+    throw new CliError("Failed to resolve local HEAD before creating reconcile backup.", { exitCode: 1 });
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const branchFragment = sanitizeRefFragment(params?.branchName?.trim() || "current-branch");
+  const prefix = sanitizeRefFragment(params?.prefix?.trim() || "comerge/reconcile-backup");
+  const backupBranchName = `${prefix}/${branchFragment}-${timestamp}`;
+  const createRes = await runGitDetailed(["branch", backupBranchName, sourceCommitHash], cwd);
+  if (createRes.exitCode !== 0) {
+    const detail = [createRes.stderr.trim(), createRes.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new CliError("Failed to create reconcile backup branch.", {
+      exitCode: 1,
+      hint: detail || "Git could not create the safety backup branch."
+    });
+  }
+  return { branchName: backupBranchName, commitHash: sourceCommitHash };
+}
+async function hardResetToCommit(cwd, commitHash, operation = "`comerge collab reconcile`") {
+  const res = await runGitDetailed(["reset", "--hard", commitHash], cwd);
+  if (res.exitCode !== 0) {
+    const detail = [res.stderr.trim(), res.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new CliError(`Failed to move local branch while running ${operation}.`, {
+      exitCode: 1,
+      hint: detail || `Git could not reset the current branch to ${commitHash}.`
+    });
+  }
+  const hash = await getHeadCommitHash(cwd);
+  if (!hash) {
+    throw new CliError("Failed to resolve local HEAD after resetting branch.", { exitCode: 1 });
+  }
+  return hash;
+}
+async function buildRepoFingerprint(params) {
+  const remote = normalizeGitRemote(params.remoteUrl);
+  const defaultBranch = params.defaultBranch?.trim().toLowerCase() || "";
+  const payload = remote ? { remote, defaultBranch } : { local: import_node_path3.default.resolve(params.gitRoot).toLowerCase(), defaultBranch };
+  return (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(payload)).digest("hex");
+}
+function summarizeUnifiedDiff(diff) {
+  const lines = diff.split("\n");
+  let changedFilesCount = 0;
+  let insertions = 0;
+  let deletions = 0;
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) changedFilesCount += 1;
+    if (line.startsWith("+") && !line.startsWith("+++")) insertions += 1;
+    if (line.startsWith("-") && !line.startsWith("---")) deletions += 1;
+  }
+  return { changedFilesCount, insertions, deletions };
+}
+
+// src/application/collab/collabInit.ts
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+
+// src/application/collab/shared.ts
+var import_node_crypto2 = require("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 CliError(message, { exitCode: 1, hint: resp ? JSON.stringify(resp, null, 2) : null });
+  }
+  return obj;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function buildDeterministicIdempotencyKey(parts) {
+  return (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(parts)).digest("hex");
+}
+function formatCliErrorDetail(err) {
+  if (err instanceof CliError) {
+    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 || "comerge-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 CliError("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 CliError("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 CliError("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 CliError("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 CliError("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 CliError("Reconciliation failed.", {
+        exitCode: 1,
+        hint: reconcile.statusError || null
+      });
+    }
+    await sleep(delay);
+    delay = Math.min(1e4, Math.floor(delay * 1.4));
+  }
+  throw new CliError("Timed out waiting for reconcile job.", { 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 CliError("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 CliError("Timed out waiting for upstream sync.", { exitCode: 1 });
+}
+
+// src/shared/hash.ts
+var import_node_crypto3 = __toESM(require("crypto"), 1);
+var import_node_fs = __toESM(require("fs"), 1);
+async function sha256FileHex(filePath) {
+  const hash = import_node_crypto3.default.createHash("sha256");
+  await new Promise((resolve, reject) => {
+    const stream = import_node_fs.default.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
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_stream = require("stream");
+async function uploadPresigned(params) {
+  const stats = await import_node_fs2.default.promises.stat(params.filePath).catch(() => null);
+  if (!stats || !stats.isFile()) {
+    throw new CliError("Upload file not found.", { exitCode: 2 });
+  }
+  const totalBytes = stats.size;
+  const fileStream = import_node_fs2.default.createReadStream(params.filePath);
+  const pass = new import_node_stream.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 CliError("Upload failed.", {
+      exitCode: 1,
+      hint: `Status: ${response.status}
+${text}`.trim() || null
+    });
+  }
+}
+
+// src/application/collab/collabInit.ts
+async function collabInit(params) {
+  const repoRoot = await findGitRoot(params.cwd);
+  await ensureCleanWorktree(repoRoot, "`comerge collab init`");
+  if (params.path?.trim()) {
+    throw new CliError("`comerge 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 repoFingerprint = await buildRepoFingerprint({ gitRoot: repoRoot, remoteUrl, defaultBranch });
+  if (!params.forceNew) {
+    const bindingResp = await params.api.resolveProjectBinding({
+      repoFingerprint,
+      remoteUrl: remoteUrl ?? void 0
+    });
+    const existing = bindingResp?.responseObject;
+    if (existing?.projectId && existing?.appId) {
+      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
+      });
+      return {
+        reused: true,
+        projectId: String(existing.projectId),
+        appId: String(existing.appId),
+        upstreamAppId: String(existing.upstreamAppId ?? existing.appId),
+        bindingPath: bindingPath2,
+        repoRoot
+      };
+    }
+  }
+  const { bundlePath, headCommitHash } = await createGitBundle(repoRoot, "repository.bundle");
+  const bundleSha = await sha256FileHex(bundlePath);
+  const bundleSize = (await import_promises4.default.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() || import_node_path4.default.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));
+  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
+  });
+  return {
+    reused: false,
+    projectId: String(app.projectId),
+    appId: String(app.id),
+    upstreamAppId: String(app.id),
+    bindingPath,
+    repoRoot,
+    remoteUrl,
+    defaultBranch
+  };
+}
+
+// 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/collabRemix.ts
+var import_promises5 = __toESM(require("fs/promises"), 1);
+var import_node_os2 = __toESM(require("os"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+async function collabRemix(params) {
+  const sourceAppId = params.appId?.trim() || null;
+  if (!sourceAppId) {
+    throw new CliError("No source app selected.", {
+      exitCode: 2,
+      hint: "Pass the source app id to remix."
+    });
+  }
+  const parentDir = import_node_path5.default.resolve(params.cwd);
+  const parentStats = await import_promises5.default.stat(parentDir).catch(() => null);
+  if (!parentStats?.isDirectory()) {
+    throw new CliError("Remix output parent directory does not exist.", {
+      exitCode: 2,
+      hint: `Create the directory first: ${parentDir}`
+    });
+  }
+  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 repoRoot = await findAvailableDirPath(import_node_path5.default.join(parentDir, baseDirName));
+  const bundleTempDir = await import_promises5.default.mkdtemp(import_node_path5.default.join(import_node_os2.default.tmpdir(), "comerge-remix-"));
+  const bundlePath = import_node_path5.default.join(bundleTempDir, "repository.bundle");
+  try {
+    const bundle = await params.api.downloadAppBundle(String(app.id));
+    await import_promises5.default.writeFile(bundlePath, bundle.data);
+    await cloneGitBundleToDirectory(bundlePath, repoRoot);
+    await ensureGitInfoExcludeEntries(repoRoot, [".comerge/"]);
+  } catch (err) {
+    await import_promises5.default.rm(repoRoot, { recursive: true, force: true }).catch(() => {
+    });
+    throw err;
+  } finally {
+    await import_promises5.default.rm(bundleTempDir, { recursive: true, force: true });
+  }
+  const remoteUrl = normalizeGitRemote(await getRemoteOriginUrl(repoRoot));
+  const defaultBranch = await getDefaultBranch(repoRoot) ?? await getCurrentBranch(repoRoot) ?? null;
+  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
+  });
+  return {
+    appId: String(app.id),
+    projectId: String(app.projectId),
+    upstreamAppId: String(app.forkedFromAppId ?? sourceAppId),
+    bindingPath,
+    repoRoot
+  };
+}
+
+// src/application/collab/collabAdd.ts
+var import_promises7 = __toESM(require("fs/promises"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
+
+// src/application/collab/collabSync.ts
+var import_promises6 = __toESM(require("fs/promises"), 1);
+var import_node_os3 = __toESM(require("os"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+async function collabSync(params) {
+  const repoRoot = await findGitRoot(params.cwd);
+  const binding = await readCollabBinding(repoRoot);
+  if (!binding) {
+    throw new CliError("Repository is not bound to Comerge.", {
+      exitCode: 2,
+      hint: "Run `comerge collab init` first."
+    });
+  }
+  await ensureCleanWorktree(repoRoot);
+  const branch = await requireCurrentBranch(repoRoot);
+  const headCommitHash = await getHeadCommitHash(repoRoot);
+  if (!headCommitHash) {
+    throw new CliError("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 CliError("Local repository metadata conflicts with the bound Comerge app.", {
+      exitCode: 2,
+      hint: sync.warnings.join("\n") || "Run the command from the correct bound repository."
+    });
+  }
+  if (sync.status === "base_unknown") {
+    throw new CliError("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 CliError("Sync bundle payload is missing.", { exitCode: 1 });
+  }
+  const tempDir = await import_promises6.default.mkdtemp(import_node_path6.default.join(import_node_os3.default.tmpdir(), "comerge-sync-"));
+  const bundlePath = import_node_path6.default.join(tempDir, "sync-local.bundle");
+  try {
+    await import_promises6.default.writeFile(bundlePath, Buffer.from(sync.bundleBase64, "base64"));
+    await importGitBundle(repoRoot, bundlePath, sync.bundleRef);
+    await ensureCommitExists(repoRoot, sync.targetCommitHash);
+    const localCommitHash = await fastForwardToCommit(repoRoot, sync.targetCommitHash);
+    return {
+      ...previewResult,
+      localCommitHash,
+      applied: true,
+      dryRun: false
+    };
+  } finally {
+    await import_promises6.default.rm(tempDir, { recursive: true, force: true });
+  }
+}
+
+// src/application/collab/collabAdd.ts
+async function collabAdd(params) {
+  const repoRoot = await findGitRoot(params.cwd);
+  const binding = await readCollabBinding(repoRoot);
+  if (!binding) {
+    throw new CliError("Repository is not bound to Comerge.", {
+      exitCode: 2,
+      hint: "Run `comerge collab init` first."
+    });
+  }
+  const prompt = params.prompt.trim();
+  if (!prompt) throw new CliError("Prompt is required.", { exitCode: 2 });
+  const diffSource = params.diffSource ?? (params.diff ? "external" : "worktree");
+  const diff = params.diff ?? await getWorkingTreeDiff(repoRoot);
+  if (!diff.trim()) {
+    throw new CliError("Diff is empty.", {
+      exitCode: 2,
+      hint: "Make changes first, or pass `--diff-file`/`--diff-stdin`."
+    });
+  }
+  const branch = await getCurrentBranch(repoRoot);
+  const headCommitHash = await getHeadCommitHash(repoRoot);
+  const stats = summarizeUnifiedDiff(diff);
+  const idempotencyKey = params.idempotencyKey?.trim() || buildDeterministicIdempotencyKey({
+    appId: binding.currentAppId,
+    upstreamAppId: binding.upstreamAppId,
+    headCommitHash,
+    prompt,
+    diff
+  });
+  const resp = await params.api.createChangeStep(binding.currentAppId, {
+    threadId: binding.threadId ?? void 0,
+    prompt,
+    diff,
+    baseCommitHash: 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 autoSyncEnabled = params.sync !== false;
+  const canAutoSyncLocally = autoSyncEnabled && diffSource === "worktree";
+  if (!autoSyncEnabled || !canAutoSyncLocally) {
+    return step;
+  }
+  const { backupPath } = await writeTempUnifiedDiffBackup(diff, "comerge-add");
+  try {
+    await discardTrackedChanges(repoRoot, "`comerge collab add`");
+    await collabSync({
+      api: params.api,
+      cwd: repoRoot,
+      dryRun: false
+    });
+    await import_promises7.default.rm(import_node_path7.default.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 `comerge collab sync`."
+    ].filter(Boolean).join("\n\n");
+    throw new CliError("Change step succeeded remotely, but automatic local sync failed.", {
+      exitCode: err instanceof CliError ? err.exitCode : 1,
+      hint
+    });
+  }
+  return step;
+}
+
+// src/application/collab/collabSyncUpstream.ts
+async function collabSyncUpstream(params) {
+  const repoRoot = await findGitRoot(params.cwd);
+  const binding = await readCollabBinding(repoRoot);
+  if (!binding) {
+    throw new CliError("Repository is not bound to Comerge.", {
+      exitCode: 2,
+      hint: "Run `comerge collab init` first."
+    });
+  }
+  await ensureCleanWorktree(repoRoot, "`comerge collab sync-upstream`");
+  await requireCurrentBranch(repoRoot);
+  if (binding.currentAppId === binding.upstreamAppId) {
+    throw new CliError("Current repository is not bound to a remix/fork app.", {
+      exitCode: 2,
+      hint: "`comerge 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 collabSync({
+    api: params.api,
+    cwd: repoRoot,
+    dryRun: false
+  });
+  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
+  };
+}
+
+// src/application/collab/collabReconcile.ts
+var import_promises8 = __toESM(require("fs/promises"), 1);
+var import_node_os4 = __toESM(require("os"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
+async function collabReconcile(params) {
+  const repoRoot = await findGitRoot(params.cwd);
+  const binding = await readCollabBinding(repoRoot);
+  if (!binding) {
+    throw new CliError("Repository is not bound to Comerge.", {
+      exitCode: 2,
+      hint: "Run `comerge collab init` first."
+    });
+  }
+  await ensureCleanWorktree(repoRoot, "`comerge collab reconcile`");
+  const branch = await requireCurrentBranch(repoRoot);
+  const headCommitHash = await getHeadCommitHash(repoRoot);
+  if (!headCommitHash) {
+    throw new CliError("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 CliError("Local repository metadata conflicts with the bound Comerge 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 CliError("Local repository metadata conflicts with the bound Comerge 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 = import_node_path8.default.dirname(bundlePath);
+  try {
+    const bundleStat = await import_promises8.default.stat(bundlePath);
+    const checksumSha256 = await sha256FileHex(bundlePath);
+    const presignResp = await params.api.presignImportUploadFirstParty({
+      file: {
+        name: import_node_path8.default.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 CliError("Reconcile completed without enough result metadata to update the local repository.", {
+        exitCode: 1
+      });
+    }
+    const backup = await createBackupBranch(repoRoot, {
+      branchName: branch,
+      sourceCommitHash: headCommitHash,
+      prefix: "comerge/reconcile-backup"
+    });
+    await hardResetToCommit(repoRoot, reconcile.mergeBaseCommitHash, "`comerge collab reconcile`");
+    const bundleResp = await params.api.downloadAppReconcileBundle(binding.currentAppId, reconcile.id);
+    const resultTempDir = await import_promises8.default.mkdtemp(import_node_path8.default.join(import_node_os4.default.tmpdir(), "comerge-reconcile-"));
+    const resultBundlePath = import_node_path8.default.join(resultTempDir, bundleResp.fileName ?? "reconcile-result.bundle");
+    try {
+      await import_promises8.default.writeFile(resultBundlePath, bundleResp.data);
+      await importGitBundle(repoRoot, resultBundlePath, reconcile.resultBundleRef);
+      await ensureCommitExists(repoRoot, reconcile.reconciledHeadCommitHash);
+      const localCommitHash = await fastForwardToCommit(repoRoot, reconcile.reconciledHeadCommitHash);
+      if (localCommitHash !== reconcile.reconciledHeadCommitHash) {
+        throw new CliError("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
+      };
+    } finally {
+      await import_promises8.default.rm(resultTempDir, { recursive: true, force: true });
+    }
+  } finally {
+    await import_promises8.default.rm(bundleTempDir, { recursive: true, force: true });
+  }
+}
+
+// src/application/collab/collabRequestMerge.ts
+async function collabRequestMerge(params) {
+  const repoRoot = await findGitRoot(params.cwd);
+  const binding = await readCollabBinding(repoRoot);
+  if (!binding) throw new CliError("Repository is not bound to Comerge.", { exitCode: 2 });
+  const resp = await params.api.openMergeRequest(binding.currentAppId);
+  return unwrapResponseObject(resp, "merge request");
+}
+
+// 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/collabView.ts
+async function collabView(params) {
+  const resp = await params.api.getMergeRequestReview(params.mrId);
+  return unwrapResponseObject(resp, "merge request review");
+}
+
+// src/application/collab/collabApprove.ts
+async function collabApprove(params) {
+  const resp = await params.api.updateMergeRequest(params.mrId, { status: "approved" });
+  return unwrapResponseObject(resp, "merge request");
+}
+
+// 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/collabInvite.ts
+async function collabInvite(params) {
+  const repoRoot = await findGitRoot(params.cwd);
+  const binding = await readCollabBinding(repoRoot);
+  if (!binding) throw new CliError("Repository is not bound to Comerge.", { exitCode: 2 });
+  const resp = await params.api.createProjectInvite(binding.projectId, {
+    email: params.email,
+    role: params.role?.trim() || "viewer"
+  });
+  return unwrapResponseObject(resp, "invite");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CliError,
+  buildRepoFingerprint,
+  cloneGitBundleToDirectory,
+  collabAdd,
+  collabApprove,
+  collabInbox,
+  collabInit,
+  collabInvite,
+  collabList,
+  collabReconcile,
+  collabReject,
+  collabRemix,
+  collabRequestMerge,
+  collabSync,
+  collabSyncUpstream,
+  collabView,
+  createBackupBranch,
+  createGitBundle,
+  discardTrackedChanges,
+  ensureCleanWorktree,
+  ensureCommitExists,
+  ensureGitInfoExcludeEntries,
+  fastForwardToCommit,
+  findGitRoot,
+  getCollabBindingPath,
+  getCurrentBranch,
+  getDefaultBranch,
+  getHeadCommitHash,
+  getRemoteOriginUrl,
+  getWorkingTreeDiff,
+  hardResetToCommit,
+  importGitBundle,
+  listUntrackedFiles,
+  normalizeGitRemote,
+  readCollabBinding,
+  requireCurrentBranch,
+  summarizeUnifiedDiff,
+  writeCollabBinding,
+  writeTempUnifiedDiffBackup
+});