@remixhq/claude-plugin 0.1.15 → 0.1.17

package/dist/hook-stop-collab.cjs

@@ -539,6 +539,15 @@ __export(hook_stop_collab_exports, {
 });
 module.exports = __toCommonJS(hook_stop_collab_exports);
 
+// node_modules/@remixhq/core/dist/chunk-GC2MOT3U.js
+var REMIX_ERROR_CODES = {
+  REPO_LOCK_HELD: "REPO_LOCK_HELD",
+  REPO_LOCK_TIMEOUT: "REPO_LOCK_TIMEOUT",
+  REPO_LOCK_STALE_RECOVERED: "REPO_LOCK_STALE_RECOVERED",
+  REPO_STATE_CHANGED_DURING_OPERATION: "REPO_STATE_CHANGED_DURING_OPERATION",
+  PREFERRED_BRANCH_MISMATCH: "PREFERRED_BRANCH_MISMATCH"
+};
+
 // node_modules/@remixhq/core/dist/chunk-YZ34ICNN.js
 var RemixError = class extends Error {
   code;
@@ -553,48 +562,11 @@ var RemixError = class extends Error {
   }
 };
 
-// node_modules/@remixhq/core/dist/chunk-GEHSFPCD.js
-var import_promises = __toESM(require("fs/promises"), 1);
-var import_path = __toESM(require("path"), 1);
-function getCollabBindingPath(repoRoot) {
-  return import_path.default.join(repoRoot, ".remix", "config.json");
-}
-async function readCollabBinding(repoRoot) {
-  try {
-    const raw = await import_promises.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,
-      preferredBranch: parsed.preferredBranch ?? parsed.defaultBranch ?? null
-    };
-  } catch {
-    return null;
-  }
-}
-
-// node_modules/@remixhq/core/dist/chunk-GC2MOT3U.js
-var REMIX_ERROR_CODES = {
-  REPO_LOCK_HELD: "REPO_LOCK_HELD",
-  REPO_LOCK_TIMEOUT: "REPO_LOCK_TIMEOUT",
-  REPO_LOCK_STALE_RECOVERED: "REPO_LOCK_STALE_RECOVERED",
-  REPO_STATE_CHANGED_DURING_OPERATION: "REPO_STATE_CHANGED_DURING_OPERATION",
-  PREFERRED_BRANCH_MISMATCH: "PREFERRED_BRANCH_MISMATCH"
-};
-
-// node_modules/@remixhq/core/dist/chunk-J3J4PBQ7.js
-var import_promises13 = __toESM(require("fs/promises"), 1);
+// node_modules/@remixhq/core/dist/chunk-RREREIGW.js
+var import_promises12 = __toESM(require("fs/promises"), 1);
 var import_crypto = require("crypto");
 var import_os = __toESM(require("os"), 1);
-var import_path2 = __toESM(require("path"), 1);
+var import_path = __toESM(require("path"), 1);
 
 // node_modules/is-plain-obj/index.js
 function isPlainObject(value) {
@@ -1526,7 +1498,7 @@ var npmRunPathEnv = ({ env = import_node_process5.default.env, ...options } = {}
 };
 
 // node_modules/execa/lib/terminate/kill.js
-var import_promises2 = require("timers/promises");
+var import_promises = require("timers/promises");
 
 // node_modules/execa/lib/return/final-error.js
 var getFinalError = (originalError, message, isSync) => {
@@ -2033,7 +2005,7 @@ var killOnTimeout = async ({ kill, forceKillAfterDelay, context, controllerSigna
     return;
   }
   try {
-    await (0, import_promises2.setTimeout)(forceKillAfterDelay, void 0, { signal: controllerSignal });
+    await (0, import_promises.setTimeout)(forceKillAfterDelay, void 0, { signal: controllerSignal });
     if (kill("SIGKILL")) {
       context.isForcefullyTerminated ??= true;
     }
@@ -2064,7 +2036,7 @@ var terminateOnCancel = async (subprocess, cancelSignal, context, { signal }) =>
 };
 
 // node_modules/execa/lib/ipc/graceful.js
-var import_promises4 = require("timers/promises");
+var import_promises3 = require("timers/promises");
 
 // node_modules/execa/lib/ipc/send.js
 var import_node_util5 = require("util");
@@ -2251,7 +2223,7 @@ var import_node_events4 = require("events");
 
 // node_modules/execa/lib/ipc/incoming.js
 var import_node_events3 = require("events");
-var import_promises3 = require("timers/promises");
+var import_promises2 = require("timers/promises");
 
 // node_modules/execa/lib/ipc/reference.js
 var addReference = (channel, reference) => {
@@ -2298,7 +2270,7 @@ var onMessage = async ({ anyProcess, channel, isSubprocess, ipcEmitter }, wrappe
   }
   while (incomingMessages.length > 0) {
     await waitForOutgoingMessages(anyProcess, ipcEmitter, wrappedMessage);
-    await import_promises3.scheduler.yield();
+    await import_promises2.scheduler.yield();
     const message = await handleStrictRequest({
       wrappedMessage: incomingMessages[0],
       anyProcess,
@@ -2578,7 +2550,7 @@ var startIpc = async ({ anyProcess, channel, isSubprocess, ipc }) => {
     return;
   }
   getIpcEmitter(anyProcess, channel, isSubprocess);
-  await import_promises4.scheduler.yield();
+  await import_promises3.scheduler.yield();
 };
 var cancelListening = false;
 var handleAbort = (wrappedMessage) => {
@@ -2651,7 +2623,7 @@ var getReason = ({ reason }) => {
 };
 
 // node_modules/execa/lib/terminate/timeout.js
-var import_promises5 = require("timers/promises");
+var import_promises4 = require("timers/promises");
 var validateTimeout = ({ timeout }) => {
   if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout < 0)) {
     throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
@@ -2659,7 +2631,7 @@ var validateTimeout = ({ timeout }) => {
 };
 var throwOnTimeout = (subprocess, timeout, context, controller) => timeout === 0 || timeout === void 0 ? [] : [killAfterTimeout(subprocess, timeout, context, controller)];
 var killAfterTimeout = async (subprocess, timeout, context, { signal }) => {
-  await (0, import_promises5.setTimeout)(timeout, void 0, { signal });
+  await (0, import_promises4.setTimeout)(timeout, void 0, { signal });
   context.terminationReason ??= "timeout";
   subprocess.kill();
   throw new DiscardedError();
@@ -2916,7 +2888,7 @@ var CR_BINARY = CR.codePointAt(0);
 
 // node_modules/get-stream/source/index.js
 var import_node_events6 = require("events");
-var import_promises6 = require("stream/promises");
+var import_promises5 = require("stream/promises");
 
 // node_modules/is-stream/index.js
 function isStream(stream, { checkOpen = true } = {}) {
@@ -3282,7 +3254,7 @@ var stringMethods = {
 };
 
 // node_modules/get-stream/source/index.js
-Object.assign(nodeImports, { on: import_node_events6.on, finished: import_promises6.finished });
+Object.assign(nodeImports, { on: import_node_events6.on, finished: import_promises5.finished });
 
 // node_modules/execa/lib/io/max-buffer.js
 var handleMaxBuffer = ({ error, stream, readableObjectMode, lines, encoding, fdNumber }) => {
@@ -5474,7 +5446,7 @@ var addPropertiesAsync = {
 // node_modules/@sindresorhus/merge-streams/index.js
 var import_node_events10 = require("events");
 var import_node_stream4 = require("stream");
-var import_promises7 = require("stream/promises");
+var import_promises6 = require("stream/promises");
 function mergeStreams(streams) {
   if (!Array.isArray(streams)) {
     throw new TypeError(`Expected an array, got \`${typeof streams}\`.`);
@@ -5557,7 +5529,7 @@ var onMergedStreamFinished = async (passThroughStream, streams, unpipeEvent) =>
 };
 var onMergedStreamEnd = async (passThroughStream, { signal }) => {
   try {
-    await (0, import_promises7.finished)(passThroughStream, { signal, cleanup: true });
+    await (0, import_promises6.finished)(passThroughStream, { signal, cleanup: true });
   } catch (error) {
     errorOrAbortStream(passThroughStream, error);
     throw error;
@@ -5624,7 +5596,7 @@ var afterMergedStreamFinished = async (onFinished, stream, { signal }) => {
 };
 var onInputStreamEnd = async ({ passThroughStream, stream, streams, ended, aborted: aborted2, controller: { signal } }) => {
   try {
-    await (0, import_promises7.finished)(stream, {
+    await (0, import_promises6.finished)(stream, {
       signal,
       cleanup: true,
       readable: true,
@@ -5689,7 +5661,7 @@ var PASSTHROUGH_LISTENERS_COUNT = 2;
 var PASSTHROUGH_LISTENERS_PER_STREAM = 1;
 
 // node_modules/execa/lib/io/pipeline.js
-var import_promises8 = require("stream/promises");
+var import_promises7 = require("stream/promises");
 var pipeStreams = (source, destination) => {
   source.pipe(destination);
   onSourceFinish(source, destination);
@@ -5700,7 +5672,7 @@ var onSourceFinish = async (source, destination) => {
     return;
   }
   try {
-    await (0, import_promises8.finished)(source, { cleanup: true, readable: true, writable: false });
+    await (0, import_promises7.finished)(source, { cleanup: true, readable: true, writable: false });
   } catch {
   }
   endDestinationStream(destination);
@@ -5715,7 +5687,7 @@ var onDestinationFinish = async (source, destination) => {
     return;
   }
   try {
-    await (0, import_promises8.finished)(destination, { cleanup: true, readable: false, writable: true });
+    await (0, import_promises7.finished)(destination, { cleanup: true, readable: false, writable: true });
   } catch {
   }
   abortSourceStream(source);
@@ -6186,7 +6158,7 @@ var waitForBothSubprocesses = async (subprocessPromises) => {
 };
 
 // node_modules/execa/lib/pipe/streaming.js
-var import_promises9 = require("stream/promises");
+var import_promises8 = require("stream/promises");
 var pipeSubprocessStream = (sourceStream, destinationStream, maxListenersController) => {
   const mergedStream = MERGED_STREAMS.has(destinationStream) ? pipeMoreSubprocessStream(sourceStream, destinationStream) : pipeFirstSubprocessStream(sourceStream, destinationStream);
   incrementMaxListeners(sourceStream, SOURCE_LISTENERS_PER_PIPE, maxListenersController.signal);
@@ -6207,7 +6179,7 @@ var pipeMoreSubprocessStream = (sourceStream, destinationStream) => {
 };
 var cleanupMergedStreamsMap = async (destinationStream) => {
   try {
-    await (0, import_promises9.finished)(destinationStream, { cleanup: true, readable: false, writable: true });
+    await (0, import_promises8.finished)(destinationStream, { cleanup: true, readable: false, writable: true });
   } catch {
   }
   MERGED_STREAMS.delete(destinationStream);
@@ -6291,7 +6263,7 @@ var handlePipePromise = async ({
 var getSubprocessPromises = (sourcePromise, destination) => Promise.allSettled([sourcePromise, destination]);
 
 // node_modules/execa/lib/io/contents.js
-var import_promises10 = require("timers/promises");
+var import_promises9 = require("timers/promises");
 
 // node_modules/execa/lib/io/iterate.js
 var import_node_events12 = require("events");
@@ -6443,7 +6415,7 @@ var logOutputAsync = async ({ stream, onStreamEnd, fdNumber, encoding, allMixed,
   await logLines(linesIterable, stream, fdNumber, verboseInfo);
 };
 var resumeStream = async (stream) => {
-  await (0, import_promises10.setImmediate)();
+  await (0, import_promises9.setImmediate)();
   if (stream.readableFlowing === null) {
     stream.resume();
   }
@@ -6478,14 +6450,14 @@ var getBufferedData = async (streamPromise) => {
 var handleBufferedData = ({ bufferedData }) => isArrayBuffer(bufferedData) ? new Uint8Array(bufferedData) : bufferedData;
 
 // node_modules/execa/lib/resolve/wait-stream.js
-var import_promises11 = require("stream/promises");
+var import_promises10 = require("stream/promises");
 var waitForStream = async (stream, fdNumber, streamInfo, { isSameDirection, stopOnExit = false } = {}) => {
   const state = handleStdinDestroy(stream, streamInfo);
   const abortController = new AbortController();
   try {
     await Promise.race([
       ...stopOnExit ? [streamInfo.exitPromise] : [],
-      (0, import_promises11.finished)(stream, { cleanup: true, signal: abortController.signal })
+      (0, import_promises10.finished)(stream, { cleanup: true, signal: abortController.signal })
     ]);
   } catch (error) {
     if (!state.stdinCleanedUp) {
@@ -6799,7 +6771,7 @@ var import_node_stream6 = require("stream");
 var import_node_util9 = require("util");
 
 // node_modules/execa/lib/convert/shared.js
-var import_promises12 = require("stream/promises");
+var import_promises11 = require("stream/promises");
 var safeWaitForSubprocessStdin = async (subprocessStdin) => {
   if (subprocessStdin === void 0) {
     return;
@@ -6819,10 +6791,10 @@ var safeWaitForSubprocessStdout = async (subprocessStdout) => {
   }
 };
 var waitForSubprocessStdin = async (subprocessStdin) => {
-  await (0, import_promises12.finished)(subprocessStdin, { cleanup: true, readable: false, writable: true });
+  await (0, import_promises11.finished)(subprocessStdin, { cleanup: true, readable: false, writable: true });
 };
 var waitForSubprocessStdout = async (subprocessStdout) => {
-  await (0, import_promises12.finished)(subprocessStdout, { cleanup: true, readable: true, writable: false });
+  await (0, import_promises11.finished)(subprocessStdout, { cleanup: true, readable: true, writable: false });
 };
 var waitForSubprocess = async (subprocess, error) => {
   await subprocess;
@@ -7371,7 +7343,7 @@ var {
   getCancelSignal: getCancelSignal2
 } = getIpcExport();
 
-// node_modules/@remixhq/core/dist/chunk-J3J4PBQ7.js
+// node_modules/@remixhq/core/dist/chunk-RREREIGW.js
 async function runGit(args, cwd) {
   const res = await execa("git", args, { cwd, stderr: "ignore" });
   return String(res.stdout || "").trim();
@@ -7393,8 +7365,8 @@ async function runGitDetailed(args, cwd) {
   };
 }
 function normalizeRepoRelativePath(value) {
-  const normalized = import_path2.default.posix.normalize(value.replace(/\\/g, "/").trim());
-  if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../") || import_path2.default.posix.isAbsolute(normalized)) {
+  const normalized = import_path.default.posix.normalize(value.replace(/\\/g, "/").trim());
+  if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../") || import_path.default.posix.isAbsolute(normalized)) {
     throw new RemixError("Git returned an invalid repository-relative path.", {
       exitCode: 1,
       hint: `Path: ${value}`
@@ -7403,11 +7375,11 @@ function normalizeRepoRelativePath(value) {
   return normalized;
 }
 function resolveRepoRelativePath(repoRoot, relativePath) {
-  return import_path2.default.resolve(repoRoot, ...relativePath.split("/"));
+  return import_path.default.resolve(repoRoot, ...relativePath.split("/"));
 }
 function isWithinRepoRoot(repoRoot, targetPath) {
-  const relative = import_path2.default.relative(repoRoot, targetPath);
-  return relative === "" || !relative.startsWith("..") && !import_path2.default.isAbsolute(relative);
+  const relative = import_path.default.relative(repoRoot, targetPath);
+  return relative === "" || !relative.startsWith("..") && !import_path.default.isAbsolute(relative);
 }
 function sha256Hex(value) {
   return (0, import_crypto.createHash)("sha256").update(value).digest("hex");
@@ -7417,7 +7389,7 @@ function resolveGitReportedPath(cwd, reportedPath) {
   if (!value) {
     throw new RemixError("Git returned an empty internal path.", { exitCode: 1 });
   }
-  return import_path2.default.isAbsolute(value) ? value : import_path2.default.resolve(cwd, value);
+  return import_path.default.isAbsolute(value) ? value : import_path.default.resolve(cwd, value);
 }
 function parseGitNameStatusZ(stdout) {
   const tokens = stdout.split("\0");
@@ -7488,12 +7460,12 @@ function classifyGitApplyFailure(detail) {
   return "unknown";
 }
 async function pruneEmptyParentDirectories(repoRoot, filePath) {
-  let current = import_path2.default.dirname(filePath);
+  let current = import_path.default.dirname(filePath);
   while (current !== repoRoot && isWithinRepoRoot(repoRoot, current)) {
-    const entries = await import_promises13.default.readdir(current).catch(() => null);
+    const entries = await import_promises12.default.readdir(current).catch(() => null);
     if (!entries || entries.length > 0) return;
-    await import_promises13.default.rmdir(current).catch(() => void 0);
-    current = import_path2.default.dirname(current);
+    await import_promises12.default.rmdir(current).catch(() => void 0);
+    current = import_path.default.dirname(current);
   }
 }
 async function findGitRoot(startDir) {
@@ -7548,8 +7520,8 @@ async function getWorkspaceSnapshot(cwd) {
     throw new RemixError("Failed to resolve local HEAD commit.", { exitCode: 1 });
   }
   const includedUntrackedPaths = Array.from(new Set((await listUntrackedFiles(cwd)).map((entry) => normalizeRepoRelativePath(entry))));
-  const tempDir = await import_promises13.default.mkdtemp(import_path2.default.join(import_os.default.tmpdir(), "remix-index-"));
-  const tempIndexPath = import_path2.default.join(tempDir, "index");
+  const tempDir = await import_promises12.default.mkdtemp(import_path.default.join(import_os.default.tmpdir(), "remix-index-"));
+  const tempIndexPath = import_path.default.join(tempDir, "index");
   const env = { ...process.env, GIT_INDEX_FILE: tempIndexPath };
   try {
     try {
@@ -7572,14 +7544,14 @@ async function getWorkspaceSnapshot(cwd) {
       });
     }
   } finally {
-    await import_promises13.default.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
+    await import_promises12.default.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 async function writeTempUnifiedDiffBackup(diff, prefix = "remix-add-backup") {
   const safePrefix = prefix.replace(/[^a-zA-Z0-9._-]+/g, "-") || "remix-add-backup";
-  const tmpDir = await import_promises13.default.mkdtemp(import_path2.default.join(import_os.default.tmpdir(), `${safePrefix}-`));
-  const backupPath = import_path2.default.join(tmpDir, "submitted.diff");
-  await import_promises13.default.writeFile(backupPath, diff, "utf8");
+  const tmpDir = await import_promises12.default.mkdtemp(import_path.default.join(import_os.default.tmpdir(), `${safePrefix}-`));
+  const backupPath = import_path.default.join(tmpDir, "submitted.diff");
+  await import_promises12.default.writeFile(backupPath, diff, "utf8");
   return { backupPath, diffSha256: sha256Hex(diff) };
 }
 async function validateUnifiedDiff(cwd, diff) {
@@ -7596,7 +7568,7 @@ async function validateUnifiedDiff(cwd, diff) {
       detail
     };
   } finally {
-    await import_promises13.default.rm(import_path2.default.dirname(backupPath), { recursive: true, force: true }).catch(() => void 0);
+    await import_promises12.default.rm(import_path.default.dirname(backupPath), { recursive: true, force: true }).catch(() => void 0);
   }
 }
 async function preserveWorkspaceChanges(cwd, prefix = "remix-add-preserve") {
@@ -7616,7 +7588,7 @@ async function preserveWorkspaceChanges(cwd, prefix = "remix-add-preserve") {
 }
 async function reapplyPreservedWorkspaceChanges(cwd, preserved, operation = "`remix collab add`") {
   const patchFilePath = preserved.preservedDiffPath;
-  const tempPatchHash = await import_promises13.default.readFile(patchFilePath, "utf8").then((content) => sha256Hex(content)).catch(() => null);
+  const tempPatchHash = await import_promises12.default.readFile(patchFilePath, "utf8").then((content) => sha256Hex(content)).catch(() => null);
   if (!tempPatchHash) {
     return { status: "failed", detail: "Preserved diff artifact is missing." };
   }
@@ -7748,7 +7720,7 @@ async function discardCapturedUntrackedChanges(repoRoot, capturedPaths) {
         hint: `Path: ${relativePath}`
       });
     }
-    await import_promises13.default.rm(absolutePath, { recursive: true, force: true }).catch((err) => {
+    await import_promises12.default.rm(absolutePath, { recursive: true, force: true }).catch((err) => {
       throw new RemixError("Failed to remove a captured untracked path before syncing.", {
         exitCode: 1,
         hint: err instanceof Error ? `${relativePath}
@@ -7823,43 +7795,319 @@ function summarizeUnifiedDiff(diff) {
   return { changedFilesCount, insertions, deletions };
 }
 
-// node_modules/@remixhq/core/dist/collab.js
+// node_modules/@remixhq/core/dist/chunk-IXWQWFYT.js
+var import_promises13 = __toESM(require("fs/promises"), 1);
+var import_path2 = __toESM(require("path"), 1);
 var import_promises14 = __toESM(require("fs/promises"), 1);
 var import_path3 = __toESM(require("path"), 1);
-var import_crypto2 = require("crypto");
+async function writeJsonAtomic(filePath, value) {
+  const dir = import_path3.default.dirname(filePath);
+  await import_promises14.default.mkdir(dir, { recursive: true });
+  const tmp = `${filePath}.tmp-${Date.now()}`;
+  await import_promises14.default.writeFile(tmp, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  await import_promises14.default.rename(tmp, filePath);
+}
+function getCollabBindingPath(repoRoot) {
+  return import_path2.default.join(repoRoot, ".remix", "config.json");
+}
+function buildBindingFileV3(params) {
+  return {
+    schemaVersion: 3,
+    repoFingerprint: params.repoFingerprint,
+    remoteUrl: params.remoteUrl,
+    defaultBranch: params.defaultBranch,
+    branchBindings: params.branchBindings,
+    ...params.explicitRootBinding ? { explicitRootBinding: params.explicitRootBinding } : {}
+  };
+}
+function normalizeBranchName(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || null;
+}
+function normalizeProjectId(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || null;
+}
+function normalizeBranchBinding(value) {
+  if (!value?.currentAppId || !value?.upstreamAppId) return null;
+  return {
+    projectId: normalizeProjectId(value.projectId),
+    currentAppId: value.currentAppId,
+    upstreamAppId: value.upstreamAppId,
+    threadId: value.threadId ?? null,
+    laneId: value.laneId ?? null,
+    bindingMode: value.bindingMode === "legacy" ? "legacy" : value.bindingMode === "explicit_root" ? "explicit_root" : "lane"
+  };
+}
+function buildResolvedBinding(params) {
+  if (!params.binding) return null;
+  return {
+    schemaVersion: 3,
+    projectId: params.binding.projectId ?? params.fallbackProjectId,
+    currentAppId: params.binding.currentAppId,
+    upstreamAppId: params.binding.upstreamAppId,
+    threadId: params.binding.threadId,
+    repoFingerprint: params.repoFingerprint,
+    remoteUrl: params.remoteUrl,
+    defaultBranch: params.defaultBranch,
+    laneId: params.binding.laneId,
+    branchName: params.branchName,
+    bindingMode: params.binding.bindingMode
+  };
+}
+function deriveFallbackProjectId(params) {
+  const candidates = [
+    params.currentBranch ? params.branchBindings[params.currentBranch]?.projectId ?? null : null,
+    params.defaultBranch ? params.branchBindings[params.defaultBranch]?.projectId ?? null : null,
+    ...Object.values(params.branchBindings).map((binding) => binding.projectId),
+    params.legacyProjectId
+  ];
+  for (const candidate of candidates) {
+    if (candidate) return candidate;
+  }
+  return null;
+}
+async function readCollabBindingState(repoRoot, options) {
+  try {
+    const persist = options?.persist === true;
+    const filePath = getCollabBindingPath(repoRoot);
+    const raw = await import_promises13.default.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    const currentBranch = normalizeBranchName(await getCurrentBranch(repoRoot).catch(() => null));
+    if (parsed.schemaVersion === 1) {
+      if (!parsed.currentAppId || !parsed.upstreamAppId) return null;
+      const projectId = normalizeProjectId(parsed.projectId);
+      const preferredBranch = normalizeBranchName(parsed.preferredBranch ?? parsed.defaultBranch ?? null);
+      const branchKey = preferredBranch ?? currentBranch ?? null;
+      const branchBindings2 = branchKey ? {
+        [branchKey]: {
+          projectId,
+          currentAppId: parsed.currentAppId,
+          upstreamAppId: parsed.upstreamAppId,
+          threadId: parsed.threadId ?? null,
+          laneId: null,
+          bindingMode: "legacy"
+        }
+      } : {};
+      const migratedFile = buildBindingFileV3({
+        repoFingerprint: parsed.repoFingerprint ?? null,
+        remoteUrl: parsed.remoteUrl ?? null,
+        defaultBranch: parsed.defaultBranch ?? null,
+        branchBindings: branchBindings2
+      });
+      if (persist) {
+        try {
+          await writeJsonAtomic(filePath, migratedFile);
+        } catch {
+        }
+      }
+      return {
+        schemaVersion: 3,
+        projectId,
+        repoFingerprint: migratedFile.repoFingerprint,
+        remoteUrl: migratedFile.remoteUrl,
+        defaultBranch: migratedFile.defaultBranch,
+        currentBranch,
+        branchBindings: migratedFile.branchBindings,
+        explicitRootBinding: null,
+        binding: buildResolvedBinding({
+          fallbackProjectId: projectId,
+          repoFingerprint: migratedFile.repoFingerprint,
+          remoteUrl: migratedFile.remoteUrl,
+          defaultBranch: migratedFile.defaultBranch,
+          branchName: branchKey,
+          binding: branchKey ? migratedFile.branchBindings[branchKey] : null
+        })
+      };
+    }
+    if (parsed.schemaVersion !== 2 && parsed.schemaVersion !== 3) return null;
+    const file = parsed;
+    let shouldPersistNormalizedBranchBindings = false;
+    const legacyProjectId = normalizeProjectId(file.projectId);
+    const branchBindings = Object.fromEntries(
+      Object.entries(file.branchBindings ?? {}).map(([branchName, branchBinding]) => {
+        const normalized = normalizeBranchBinding(branchBinding);
+        const rawProjectId = branchBinding && typeof branchBinding === "object" && "projectId" in branchBinding ? normalizeProjectId(branchBinding.projectId) : null;
+        const rawBindingMode = branchBinding && typeof branchBinding === "object" && "bindingMode" in branchBinding ? branchBinding.bindingMode : null;
+        const hasLegacyPreferredBranch = Boolean(branchBinding) && typeof branchBinding === "object" && "preferredBranch" in branchBinding;
+        let normalizedWithProject = normalized;
+        if (normalizedWithProject && !normalizedWithProject.projectId && legacyProjectId) {
+          normalizedWithProject = {
+            ...normalizedWithProject,
+            projectId: legacyProjectId
+          };
+        }
+        if (normalizedWithProject && (rawBindingMode !== normalizedWithProject.bindingMode || hasLegacyPreferredBranch || rawProjectId !== normalizedWithProject.projectId)) {
+          shouldPersistNormalizedBranchBindings = true;
+        }
+        return [branchName, normalizedWithProject];
+      }).filter((entry) => Boolean(entry[1]))
+    );
+    const legacyExplicitBinding = normalizeBranchBinding(file.explicitBinding ?? null);
+    const legacyExplicitBranch = currentBranch ?? normalizeBranchName(file.defaultBranch);
+    if (legacyExplicitBinding && legacyExplicitBranch) {
+      branchBindings[legacyExplicitBranch] = {
+        ...legacyExplicitBinding,
+        projectId: legacyExplicitBinding.projectId ?? branchBindings[legacyExplicitBranch]?.projectId ?? legacyProjectId,
+        bindingMode: "lane"
+      };
+      shouldPersistNormalizedBranchBindings = true;
+    }
+    let explicitRootBinding = normalizeBranchBinding(file.explicitRootBinding ?? null);
+    if (explicitRootBinding && !explicitRootBinding.projectId && legacyProjectId) {
+      explicitRootBinding = {
+        ...explicitRootBinding,
+        projectId: legacyProjectId
+      };
+      shouldPersistNormalizedBranchBindings = true;
+    }
+    if (explicitRootBinding && explicitRootBinding.bindingMode !== "explicit_root") {
+      explicitRootBinding = {
+        ...explicitRootBinding,
+        bindingMode: "explicit_root"
+      };
+      shouldPersistNormalizedBranchBindings = true;
+    }
+    if (persist && ("explicitBinding" in file || "explicitRootBinding" in file || shouldPersistNormalizedBranchBindings || parsed.schemaVersion === 2)) {
+      try {
+        await writeJsonAtomic(
+          filePath,
+          buildBindingFileV3({
+            repoFingerprint: file.repoFingerprint ?? null,
+            remoteUrl: file.remoteUrl ?? null,
+            defaultBranch: file.defaultBranch ?? null,
+            branchBindings,
+            explicitRootBinding
+          })
+        );
+      } catch {
+      }
+    }
+    const resolvedBranch = currentBranch ?? normalizeBranchName(file.defaultBranch);
+    const fallbackProjectId = deriveFallbackProjectId({
+      branchBindings,
+      currentBranch: resolvedBranch,
+      defaultBranch: normalizeBranchName(file.defaultBranch),
+      legacyProjectId: explicitRootBinding?.projectId ?? legacyProjectId
+    });
+    const resolvedBinding = buildResolvedBinding({
+      fallbackProjectId,
+      repoFingerprint: file.repoFingerprint ?? null,
+      remoteUrl: file.remoteUrl ?? null,
+      defaultBranch: file.defaultBranch ?? null,
+      branchName: resolvedBranch,
+      binding: resolvedBranch ? branchBindings[resolvedBranch] ?? null : null
+    }) ?? (resolvedBranch && resolvedBranch === normalizeBranchName(file.defaultBranch) && explicitRootBinding ? buildResolvedBinding({
+      fallbackProjectId,
+      repoFingerprint: file.repoFingerprint ?? null,
+      remoteUrl: file.remoteUrl ?? null,
+      defaultBranch: file.defaultBranch ?? null,
+      branchName: normalizeBranchName(file.defaultBranch),
+      binding: explicitRootBinding
+    }) : null);
+    return {
+      schemaVersion: parsed.schemaVersion,
+      projectId: fallbackProjectId,
+      repoFingerprint: file.repoFingerprint ?? null,
+      remoteUrl: file.remoteUrl ?? null,
+      defaultBranch: file.defaultBranch ?? null,
+      currentBranch,
+      branchBindings,
+      explicitRootBinding: buildResolvedBinding({
+        fallbackProjectId,
+        repoFingerprint: file.repoFingerprint ?? null,
+        remoteUrl: file.remoteUrl ?? null,
+        defaultBranch: file.defaultBranch ?? null,
+        branchName: normalizeBranchName(file.defaultBranch),
+        binding: explicitRootBinding
+      }),
+      binding: resolvedBinding
+    };
+  } catch {
+    return null;
+  }
+}
+async function readCollabBinding(repoRoot) {
+  const state = await readCollabBindingState(repoRoot);
+  return state?.binding ?? null;
+}
+async function writeCollabBinding(repoRoot, binding) {
+  const filePath = getCollabBindingPath(repoRoot);
+  const currentBranch = normalizeBranchName(await getCurrentBranch(repoRoot).catch(() => null));
+  const branchName = normalizeBranchName(binding.branchName) ?? currentBranch ?? binding.defaultBranch ?? "main";
+  const existing = await readCollabBindingState(repoRoot, { persist: true });
+  const branchBindings = { ...existing?.branchBindings ?? {} };
+  branchBindings[branchName] = {
+    projectId: normalizeProjectId(binding.projectId) ?? branchBindings[branchName]?.projectId ?? existing?.projectId ?? null,
+    currentAppId: binding.currentAppId,
+    upstreamAppId: binding.upstreamAppId,
+    threadId: binding.threadId ?? null,
+    laneId: binding.laneId ?? null,
+    bindingMode: binding.bindingMode ?? "lane"
+  };
+  const explicitRootBinding = binding.bindingMode === "explicit_root" ? {
+    ...branchBindings[branchName],
+    bindingMode: "explicit_root"
+  } : existing?.explicitRootBinding ? {
+    projectId: existing.explicitRootBinding.projectId,
+    currentAppId: existing.explicitRootBinding.currentAppId,
+    upstreamAppId: existing.explicitRootBinding.upstreamAppId,
+    threadId: existing.explicitRootBinding.threadId,
+    laneId: existing.explicitRootBinding.laneId,
+    bindingMode: "explicit_root"
+  } : null;
+  await writeJsonAtomic(
+    filePath,
+    buildBindingFileV3({
+      repoFingerprint: binding.repoFingerprint ?? null,
+      remoteUrl: binding.remoteUrl ?? null,
+      defaultBranch: binding.defaultBranch ?? null,
+      branchBindings,
+      explicitRootBinding
+    })
+  );
+  return filePath;
+}
+
+// node_modules/@remixhq/core/dist/collab.js
 var import_promises15 = __toESM(require("fs/promises"), 1);
-var import_os2 = __toESM(require("os"), 1);
 var import_path4 = __toESM(require("path"), 1);
+var import_crypto2 = require("crypto");
 var import_promises16 = __toESM(require("fs/promises"), 1);
-var import_os3 = __toESM(require("os"), 1);
+var import_os2 = __toESM(require("os"), 1);
 var import_path5 = __toESM(require("path"), 1);
+var import_promises17 = __toESM(require("fs/promises"), 1);
+var import_os3 = __toESM(require("os"), 1);
+var import_path6 = __toESM(require("path"), 1);
 function describeBranch(value) {
   const normalized = String(value ?? "").trim();
   return normalized || "(detached)";
 }
-function isPreferredBranchMatch(currentBranch, preferredBranch) {
+function isBoundBranchMatch(currentBranch, branchName) {
   const current = String(currentBranch ?? "").trim();
-  const preferred = String(preferredBranch ?? "").trim();
-  if (!preferred || !current) return true;
-  return current === preferred;
+  const expected = String(branchName ?? "").trim();
+  if (!expected || !current) return true;
+  return current === expected;
 }
-function buildPreferredBranchMismatchHint(params) {
+function buildBranchMismatchHint(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.`
+    `Bound branch: ${describeBranch(params.branchName)}`,
+    `Switch to ${describeBranch(params.branchName)} or rerun with ${overrideFlag} if this is intentional.`
   ].join("\n");
 }
-function assertPreferredBranchMatch(params) {
+function assertBoundBranchMatch(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}.`, {
+  if (isBoundBranchMatch(params.currentBranch, params.branchName)) return;
+  throw new RemixError(`Current branch does not match this checkout's bound Remix branch while running ${params.operation}.`, {
     code: REMIX_ERROR_CODES.PREFERRED_BRANCH_MISMATCH,
     exitCode: 2,
-    hint: buildPreferredBranchMismatchHint({
+    hint: buildBranchMismatchHint({
       currentBranch: params.currentBranch,
-      preferredBranch: params.preferredBranch,
+      branchName: params.branchName,
       overrideFlag: params.overrideFlag
     })
   });
@@ -7949,6 +8197,237 @@ async function pollChangeStepReplay(api, appId, replayId) {
   }
   throw new RemixError("Timed out waiting for AI-assisted replay.", { exitCode: 1 });
 }
+function normalizeBranchName2(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || null;
+}
+function buildBindingFromLane(state, lane) {
+  if (!lane.currentAppId || !lane.upstreamAppId) return null;
+  const resolvedBranch = normalizeBranchName2(lane.branchName) ?? state.currentBranch ?? null;
+  const resolvedDefaultBranch = normalizeBranchName2(lane.defaultBranch) ?? normalizeBranchName2(state.defaultBranch);
+  const explicitRootProjectId = state.explicitRootBinding?.projectId ?? null;
+  const bindingMode = explicitRootProjectId && lane.projectId === explicitRootProjectId && resolvedBranch && resolvedBranch === resolvedDefaultBranch ? "explicit_root" : "lane";
+  return {
+    schemaVersion: 3,
+    projectId: lane.projectId ?? state.projectId,
+    currentAppId: lane.currentAppId,
+    upstreamAppId: lane.upstreamAppId,
+    threadId: lane.threadId ?? null,
+    repoFingerprint: lane.repoFingerprint ?? state.repoFingerprint ?? null,
+    remoteUrl: lane.remoteUrl ?? state.remoteUrl ?? null,
+    defaultBranch: lane.defaultBranch ?? state.defaultBranch ?? null,
+    laneId: lane.laneId ?? null,
+    branchName: resolvedBranch,
+    bindingMode
+  };
+}
+function shouldPersistRemoteLaneMetadata(localBinding, lane) {
+  return Boolean(
+    !localBinding.laneId && lane.laneId || !localBinding.threadId && lane.threadId || !localBinding.repoFingerprint && lane.repoFingerprint || !localBinding.remoteUrl && lane.remoteUrl || !localBinding.defaultBranch && lane.defaultBranch || !localBinding.branchName && lane.branchName
+  );
+}
+function shouldRequireRemoteLaneForCurrentBranch(params) {
+  if (!params.currentBranch) return false;
+  const defaultBranch = normalizeBranchName2(params.defaultBranch);
+  if (params.currentBranch === defaultBranch) return false;
+  return !params.binding.laneId || params.binding.currentAppId === params.binding.upstreamAppId;
+}
+async function persistResolvedLane(repoRoot, binding) {
+  await writeCollabBinding(repoRoot, {
+    projectId: binding.projectId,
+    currentAppId: binding.currentAppId,
+    upstreamAppId: binding.upstreamAppId,
+    threadId: binding.threadId,
+    repoFingerprint: binding.repoFingerprint,
+    remoteUrl: binding.remoteUrl,
+    defaultBranch: binding.defaultBranch,
+    laneId: binding.laneId,
+    branchName: binding.branchName,
+    bindingMode: binding.bindingMode
+  });
+  return readCollabBinding(repoRoot);
+}
+function buildAmbiguousResolution(params) {
+  return {
+    status: "ambiguous_family_selection",
+    currentBranch: params.currentBranch,
+    projectIds: Array.isArray(params.lane.projectIds) ? params.lane.projectIds.filter((value) => typeof value === "string" && value.trim().length > 0) : [],
+    repoFingerprint: params.lane.repoFingerprint ?? params.state.repoFingerprint,
+    remoteUrl: params.lane.remoteUrl ?? params.state.remoteUrl,
+    defaultBranch: params.lane.defaultBranch ?? params.state.defaultBranch
+  };
+}
+async function resolveActiveLaneBinding(params) {
+  const state = await readCollabBindingState(params.repoRoot);
+  if (!state) {
+    return { status: "not_bound", currentBranch: null };
+  }
+  const currentBranch = normalizeBranchName2(state.currentBranch);
+  const localBinding = state.binding;
+  if (localBinding) {
+    const requireRemoteLane = shouldRequireRemoteLaneForCurrentBranch({
+      binding: localBinding,
+      currentBranch,
+      defaultBranch: state.defaultBranch
+    });
+    if (!params.api || !currentBranch) {
+      return {
+        status: "resolved",
+        source: "local",
+        binding: localBinding,
+        currentBranch
+      };
+    }
+    const laneResp2 = await params.api.resolveProjectLaneBinding({
+      projectId: state.explicitRootBinding?.projectId ?? (requireRemoteLane ? void 0 : localBinding.projectId ?? state.projectId ?? void 0),
+      repoFingerprint: state.repoFingerprint ?? void 0,
+      remoteUrl: state.remoteUrl ?? void 0,
+      defaultBranch: state.defaultBranch ?? void 0,
+      branchName: currentBranch
+    });
+    const lane2 = unwrapResponseObject(laneResp2, "project lane binding");
+    if (lane2.status === "ambiguous_family_selection") {
+      return buildAmbiguousResolution({ state, currentBranch, lane: lane2 });
+    }
+    if (lane2.status === "resolved") {
+      const resolvedBranch = normalizeBranchName2(lane2.branchName);
+      const resolvedProjectId = lane2.projectId ?? state.projectId;
+      const branchConflict = Boolean(resolvedBranch && localBinding.branchName && resolvedBranch !== localBinding.branchName);
+      const appConflict = Boolean(lane2.currentAppId && lane2.currentAppId !== localBinding.currentAppId);
+      const upstreamConflict = Boolean(lane2.upstreamAppId && lane2.upstreamAppId !== localBinding.upstreamAppId);
+      const projectConflict = Boolean(resolvedProjectId && localBinding.projectId && resolvedProjectId !== localBinding.projectId);
+      if (branchConflict || appConflict || upstreamConflict || projectConflict) {
+        if (requireRemoteLane) {
+          const binding = buildBindingFromLane(state, lane2);
+          if (binding) {
+            return {
+              status: "resolved",
+              source: "remote",
+              binding,
+              currentBranch
+            };
+          }
+        }
+        return {
+          status: "binding_conflict",
+          binding: localBinding,
+          resolvedLane: lane2,
+          currentBranch
+        };
+      }
+      if (shouldPersistRemoteLaneMetadata(localBinding, lane2)) {
+        const binding = buildBindingFromLane(state, lane2);
+        if (binding) {
+          return {
+            status: "resolved",
+            source: "remote",
+            binding,
+            currentBranch
+          };
+        }
+      }
+    }
+    if (requireRemoteLane) {
+      return {
+        status: "missing_branch_binding",
+        currentBranch,
+        projectId: lane2.projectId ?? state.projectId,
+        repoFingerprint: lane2.repoFingerprint ?? state.repoFingerprint,
+        remoteUrl: lane2.remoteUrl ?? state.remoteUrl,
+        defaultBranch: lane2.defaultBranch ?? state.defaultBranch,
+        upstreamAppId: lane2.upstreamAppId ?? localBinding.upstreamAppId ?? null,
+        threadId: lane2.threadId ?? localBinding.threadId ?? null
+      };
+    }
+    return {
+      status: "resolved",
+      source: "local",
+      binding: localBinding,
+      currentBranch
+    };
+  }
+  if (!params.api || !currentBranch) {
+    return {
+      status: "missing_branch_binding",
+      currentBranch,
+      projectId: state.projectId,
+      repoFingerprint: state.repoFingerprint,
+      remoteUrl: state.remoteUrl,
+      defaultBranch: state.defaultBranch,
+      upstreamAppId: null,
+      threadId: null
+    };
+  }
+  const laneResp = await params.api.resolveProjectLaneBinding({
+    projectId: state.explicitRootBinding?.projectId ?? state.projectId ?? void 0,
+    repoFingerprint: state.repoFingerprint ?? void 0,
+    remoteUrl: state.remoteUrl ?? void 0,
+    defaultBranch: state.defaultBranch ?? void 0,
+    branchName: currentBranch
+  });
+  const lane = unwrapResponseObject(laneResp, "project lane binding");
+  if (lane.status === "ambiguous_family_selection") {
+    return buildAmbiguousResolution({ state, currentBranch, lane });
+  }
+  if (lane.status === "resolved") {
+    const binding = buildBindingFromLane(state, lane);
+    if (binding) {
+      return {
+        status: "resolved",
+        source: "remote",
+        binding,
+        currentBranch
+      };
+    }
+  }
+  return {
+    status: "missing_branch_binding",
+    currentBranch,
+    projectId: lane.projectId ?? state.explicitRootBinding?.projectId ?? state.projectId,
+    repoFingerprint: lane.repoFingerprint ?? state.repoFingerprint,
+    remoteUrl: lane.remoteUrl ?? state.remoteUrl,
+    defaultBranch: lane.defaultBranch ?? state.defaultBranch,
+    upstreamAppId: lane.upstreamAppId ?? state.explicitRootBinding?.upstreamAppId ?? null,
+    threadId: lane.threadId ?? state.explicitRootBinding?.threadId ?? null
+  };
+}
+async function ensureActiveLaneBinding(params) {
+  const resolved = await resolveActiveLaneBinding({
+    repoRoot: params.repoRoot,
+    api: params.api
+  });
+  if (resolved.status === "resolved") {
+    if (resolved.source === "local") {
+      return resolved.binding;
+    }
+    return persistResolvedLane(params.repoRoot, resolved.binding);
+  }
+  if (resolved.status === "binding_conflict") {
+    throw new RemixError("Current branch binding conflicts with the server-resolved Remix lane.", {
+      exitCode: 2,
+      hint: `Local app ${resolved.binding.currentAppId}; server app ${resolved.resolvedLane.currentAppId ?? "(unknown)"}. Repair the branch binding before running ${params.operation ?? "this command"}.`
+    });
+  }
+  if (resolved.status === "ambiguous_family_selection") {
+    throw new RemixError("Multiple canonical Remix families match this repository.", {
+      exitCode: 2,
+      hint: "This checkout is not specific enough to choose a single family for the current branch. Continue from a checkout already bound to the intended family, or run `remix collab init --force-new` to create a new canonical family."
+    });
+  }
+  if (resolved.status === "not_bound") {
+    return null;
+  }
+  if (!resolved.currentBranch) {
+    throw new RemixError("Current branch is not yet bound to a Remix lane.", {
+      exitCode: 2,
+      hint: `Switch to a named branch before running ${params.operation ?? "this command"}.`
+    });
+  }
+  throw new RemixError("Current branch is not yet bound to a Remix lane.", {
+    exitCode: 2,
+    hint: `Run \`remix collab init\` on branch ${resolved.currentBranch} before running ${params.operation ?? "this command"}.`
+  });
+}
 async function collabRecordingPreflight(params) {
   let repoRoot;
   try {
@@ -7960,7 +8439,7 @@ async function collabRecordingPreflight(params) {
       repoRoot: null,
       appId: null,
       currentBranch: null,
-      preferredBranch: null,
+      branchName: null,
       headCommitHash: null,
       worktreeClean: false,
       syncStatus: null,
@@ -7972,14 +8451,14 @@ async function collabRecordingPreflight(params) {
       hint: message
     };
   }
-  const binding = await readCollabBinding(repoRoot);
-  if (!binding) {
+  const bindingResolution = await resolveActiveLaneBinding({ repoRoot, api: params.api });
+  if (bindingResolution.status === "not_bound") {
     return {
       status: "not_bound",
       repoRoot,
       appId: null,
       currentBranch: null,
-      preferredBranch: null,
+      branchName: null,
       headCommitHash: null,
       worktreeClean: false,
       syncStatus: null,
@@ -7991,19 +8470,74 @@ async function collabRecordingPreflight(params) {
       hint: "Run `remix collab init` first."
     };
   }
+  if (bindingResolution.status === "missing_branch_binding") {
+    return {
+      status: "branch_binding_missing",
+      repoRoot,
+      appId: null,
+      currentBranch: bindingResolution.currentBranch,
+      branchName: bindingResolution.currentBranch,
+      headCommitHash: null,
+      worktreeClean: false,
+      syncStatus: null,
+      syncTargetCommitHash: null,
+      syncTargetCommitId: null,
+      reconcileTargetHeadCommitHash: null,
+      reconcileTargetHeadCommitId: null,
+      warnings: [],
+      hint: `Current branch ${bindingResolution.currentBranch ?? "(detached)"} is not yet bound to a Remix lane.`
+    };
+  }
+  if (bindingResolution.status === "ambiguous_family_selection") {
+    return {
+      status: "family_ambiguous",
+      repoRoot,
+      appId: null,
+      currentBranch: bindingResolution.currentBranch,
+      branchName: bindingResolution.currentBranch,
+      headCommitHash: null,
+      worktreeClean: false,
+      syncStatus: null,
+      syncTargetCommitHash: null,
+      syncTargetCommitId: null,
+      reconcileTargetHeadCommitHash: null,
+      reconcileTargetHeadCommitId: null,
+      warnings: [],
+      hint: "Multiple canonical Remix families match this repository. Continue from a checkout already bound to the intended family, or run `remix collab init --force-new` to create a new canonical family."
+    };
+  }
+  if (bindingResolution.status === "binding_conflict") {
+    return {
+      status: "metadata_conflict",
+      repoRoot,
+      appId: bindingResolution.binding.currentAppId,
+      currentBranch: bindingResolution.currentBranch,
+      branchName: bindingResolution.binding.branchName,
+      headCommitHash: null,
+      worktreeClean: false,
+      syncStatus: null,
+      syncTargetCommitHash: null,
+      syncTargetCommitId: null,
+      reconcileTargetHeadCommitHash: null,
+      reconcileTargetHeadCommitId: null,
+      warnings: [],
+      hint: `Local binding for ${bindingResolution.currentBranch ?? "(detached)"} points to app ${bindingResolution.binding.currentAppId}, but the server resolved lane ${bindingResolution.resolvedLane.laneId ?? "(unknown)"} / app ${bindingResolution.resolvedLane.currentAppId ?? "(unknown)"}. Repair the branch binding before recording work.`
+    };
+  }
+  const binding = bindingResolution.binding;
   const [currentBranch, headCommitHash, worktreeStatus] = await Promise.all([
     getCurrentBranch(repoRoot),
     getHeadCommitHash(repoRoot),
     getWorktreeStatus(repoRoot)
   ]);
-  const preferredBranch = binding.preferredBranch ?? null;
+  const branchName = binding.branchName ?? null;
   if (!headCommitHash) {
     return {
       status: "missing_head",
       repoRoot,
       appId: binding.currentAppId,
       currentBranch,
-      preferredBranch,
+      branchName,
       headCommitHash: null,
       worktreeClean: worktreeStatus.isClean,
       syncStatus: null,
@@ -8015,13 +8549,13 @@ async function collabRecordingPreflight(params) {
       hint: "Failed to resolve local HEAD commit."
     };
   }
-  if (!params.allowBranchMismatch && !isPreferredBranchMatch(currentBranch, preferredBranch)) {
+  if (!params.allowBranchMismatch && !isBoundBranchMatch(currentBranch, branchName)) {
     return {
       status: "branch_mismatch",
       repoRoot,
       appId: binding.currentAppId,
       currentBranch,
-      preferredBranch,
+      branchName,
       headCommitHash,
       worktreeClean: worktreeStatus.isClean,
       syncStatus: null,
@@ -8030,9 +8564,9 @@ async function collabRecordingPreflight(params) {
       reconcileTargetHeadCommitHash: null,
       reconcileTargetHeadCommitId: null,
       warnings: [],
-      hint: buildPreferredBranchMismatchHint({
+      hint: buildBranchMismatchHint({
         currentBranch,
-        preferredBranch
+        branchName
       })
     };
   }
@@ -8050,7 +8584,7 @@ async function collabRecordingPreflight(params) {
       repoRoot,
       appId: binding.currentAppId,
       currentBranch,
-      preferredBranch,
+      branchName,
       headCommitHash,
       worktreeClean: worktreeStatus.isClean,
       syncStatus: sync.status,
@@ -8068,7 +8602,7 @@ async function collabRecordingPreflight(params) {
       repoRoot,
       appId: binding.currentAppId,
       currentBranch,
-      preferredBranch,
+      branchName,
       headCommitHash,
       worktreeClean: worktreeStatus.isClean,
       syncStatus: sync.status,
@@ -8093,7 +8627,7 @@ async function collabRecordingPreflight(params) {
       repoRoot,
       appId: binding.currentAppId,
       currentBranch,
-      preferredBranch,
+      branchName,
       headCommitHash,
       worktreeClean: worktreeStatus.isClean,
       syncStatus: sync.status,
@@ -8111,7 +8645,7 @@ async function collabRecordingPreflight(params) {
       repoRoot,
       appId: binding.currentAppId,
       currentBranch,
-      preferredBranch,
+      branchName,
       headCommitHash,
       worktreeClean: worktreeStatus.isClean,
       syncStatus: sync.status,
@@ -8128,7 +8662,7 @@ async function collabRecordingPreflight(params) {
     repoRoot,
     appId: binding.currentAppId,
     currentBranch,
-    preferredBranch,
+    branchName,
     headCommitHash,
     worktreeClean: worktreeStatus.isClean,
     syncStatus: sync.status,
@@ -8162,12 +8696,12 @@ function createOwner(params) {
   };
 }
 async function writeOwnerMetadata(ownerPath, owner) {
-  await import_promises15.default.writeFile(ownerPath, `${JSON.stringify(owner, null, 2)}
+  await import_promises16.default.writeFile(ownerPath, `${JSON.stringify(owner, null, 2)}
 `, "utf8");
 }
 async function readOwnerMetadata(ownerPath) {
   try {
-    const raw = await import_promises15.default.readFile(ownerPath, "utf8");
+    const raw = await import_promises16.default.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) {
@@ -8204,23 +8738,23 @@ async function getLastKnownUpdateMs(lockDir, ownerPath, owner) {
   if (Number.isFinite(heartbeatMs)) return heartbeatMs;
   const startedMs = owner ? Date.parse(owner.startedAt) : Number.NaN;
   if (Number.isFinite(startedMs)) return startedMs;
-  const stat = await import_promises15.default.stat(ownerPath).catch(() => null);
+  const stat = await import_promises16.default.stat(ownerPath).catch(() => null);
   if (stat) return stat.mtimeMs;
-  const dirStat = await import_promises15.default.stat(lockDir).catch(() => null);
+  const dirStat = await import_promises16.default.stat(lockDir).catch(() => null);
   if (dirStat) return dirStat.mtimeMs;
   return 0;
 }
 async function ensureLockDir(lockDir) {
-  await import_promises15.default.mkdir(import_path4.default.dirname(lockDir), { recursive: true });
+  await import_promises16.default.mkdir(import_path5.default.dirname(lockDir), { recursive: true });
 }
 async function tryAcquireLock(lockDir, ownerPath, owner) {
   try {
     await ensureLockDir(lockDir);
-    await import_promises15.default.mkdir(lockDir);
+    await import_promises16.default.mkdir(lockDir);
     try {
       await writeOwnerMetadata(ownerPath, owner);
     } catch (error) {
-      await import_promises15.default.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+      await import_promises16.default.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
       throw error;
     }
     return true;
@@ -8269,7 +8803,7 @@ async function acquirePhysicalLock(lockDir, ownerPath, owner, options) {
     const alive = await isProcessAlive(currentOwner2);
     if (ageMs >= options.staleMs && alive !== true) {
       notices.push(buildStaleRecoveryNotice(currentOwner2));
-      await import_promises15.default.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+      await import_promises16.default.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
       continue;
     }
     await sleep2(RETRY_DELAY_MS);
@@ -8294,7 +8828,7 @@ function startHeartbeat(lockDir, ownerPath, owner, heartbeatMs) {
     };
     owner.heartbeatAt = nextOwner.heartbeatAt;
     void writeOwnerMetadata(ownerPath, nextOwner).catch(() => void 0);
-    void import_promises15.default.utimes(lockDir, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date()).catch(() => void 0);
+    void import_promises16.default.utimes(lockDir, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date()).catch(() => void 0);
   }, heartbeatMs);
 }
 async function releaseReentrantLock(lockDir) {
@@ -8304,12 +8838,12 @@ async function releaseReentrantLock(lockDir) {
   if (held.count > 0) return;
   clearInterval(held.heartbeatTimer);
   heldLocks.delete(lockDir);
-  await import_promises15.default.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+  await import_promises16.default.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 = import_path4.default.join(gitCommonDir, "remix", "locks", "repo-mutation.lock");
+  const lockDir = import_path5.default.join(gitCommonDir, "remix", "locks", "repo-mutation.lock");
   const owner = createOwner({
     operation: options.operation,
     repoRoot,
@@ -8321,11 +8855,11 @@ async function withRepoMutationLock(options, fn) {
   const existing = heldLocks.get(lockDir);
   let notices = [];
   if (!existing) {
-    notices = await acquirePhysicalLock(lockDir, import_path4.default.join(lockDir, "owner.json"), owner, {
+    notices = await acquirePhysicalLock(lockDir, import_path5.default.join(lockDir, "owner.json"), owner, {
       acquireTimeoutMs,
       staleMs
     });
-    const ownerPath = import_path4.default.join(lockDir, "owner.json");
+    const ownerPath = import_path5.default.join(lockDir, "owner.json");
     heldLocks.set(lockDir, {
       count: 1,
       lockDir,
@@ -8350,7 +8884,11 @@ async function withRepoMutationLock(options, fn) {
 }
 async function collabSync(params) {
   const repoRoot = await findGitRoot(params.cwd);
-  const binding = await readCollabBinding(repoRoot);
+  const binding = await ensureActiveLaneBinding({
+    repoRoot,
+    api: params.api,
+    operation: "`remix collab sync`"
+  });
   if (!binding) {
     throw new RemixError("Repository is not bound to Remix.", {
       exitCode: 2,
@@ -8359,9 +8897,9 @@ async function collabSync(params) {
   }
   await ensureCleanWorktree(repoRoot);
   const branch = await requireCurrentBranch(repoRoot);
-  assertPreferredBranchMatch({
+  assertBoundBranchMatch({
     currentBranch: branch,
-    preferredBranch: binding.preferredBranch,
+    branchName: binding.branchName,
     allowBranchMismatch: params.allowBranchMismatch,
     operation: "`remix collab sync`"
   });
@@ -8438,16 +8976,16 @@ async function collabSync(params) {
       });
       await ensureCleanWorktree(lockedRepoRoot);
       const lockedBranch = await requireCurrentBranch(lockedRepoRoot);
-      assertPreferredBranchMatch({
+      assertBoundBranchMatch({
         currentBranch: lockedBranch,
-        preferredBranch: binding.preferredBranch,
+        branchName: binding.branchName,
         allowBranchMismatch: params.allowBranchMismatch,
         operation: "`remix collab sync`"
       });
-      const tempDir = await import_promises16.default.mkdtemp(import_path5.default.join(import_os3.default.tmpdir(), "remix-sync-"));
-      const bundlePath = import_path5.default.join(tempDir, "sync-local.bundle");
+      const tempDir = await import_promises17.default.mkdtemp(import_path6.default.join(import_os3.default.tmpdir(), "remix-sync-"));
+      const bundlePath = import_path6.default.join(tempDir, "sync-local.bundle");
       try {
-        await import_promises16.default.writeFile(bundlePath, Buffer.from(bundleBase64, "base64"));
+        await import_promises17.default.writeFile(bundlePath, Buffer.from(bundleBase64, "base64"));
         await importGitBundle(lockedRepoRoot, bundlePath, bundleRef);
         await ensureCommitExists(lockedRepoRoot, sync.targetCommitHash);
         const localCommitHash = await fastForwardToCommit(lockedRepoRoot, sync.targetCommitHash);
@@ -8459,7 +8997,7 @@ async function collabSync(params) {
           ...warnings.length > 0 ? { warnings } : {}
         };
       } finally {
-        await import_promises16.default.rm(tempDir, { recursive: true, force: true });
+        await import_promises17.default.rm(tempDir, { recursive: true, force: true });
       }
     }
   );
@@ -8471,6 +9009,18 @@ function assertSupportedRecordingPreflight(preflight) {
       hint: preflight.hint
     });
   }
+  if (preflight.status === "branch_binding_missing") {
+    throw new RemixError("Current branch is not yet bound to a Remix lane.", {
+      exitCode: 2,
+      hint: preflight.hint
+    });
+  }
+  if (preflight.status === "family_ambiguous") {
+    throw new RemixError("Multiple canonical Remix families match this repository.", {
+      exitCode: 2,
+      hint: preflight.hint
+    });
+  }
   if (preflight.status === "not_git_repo") {
     throw new RemixError(preflight.hint || "Not inside a git repository.", {
       exitCode: 2,
@@ -8484,9 +9034,9 @@ function assertSupportedRecordingPreflight(preflight) {
     });
   }
   if (preflight.status === "branch_mismatch") {
-    assertPreferredBranchMatch({
+    assertBoundBranchMatch({
       currentBranch: preflight.currentBranch,
-      preferredBranch: preflight.preferredBranch,
+      branchName: preflight.branchName,
       allowBranchMismatch: false,
       operation: "`remix collab add`"
     });
@@ -8506,7 +9056,11 @@ function assertSupportedRecordingPreflight(preflight) {
 }
 async function collabAdd(params) {
   const repoRoot = await findGitRoot(params.cwd);
-  const binding = await readCollabBinding(repoRoot);
+  const binding = await ensureActiveLaneBinding({
+    repoRoot,
+    api: params.api,
+    operation: "`remix collab add`"
+  });
   if (!binding) {
     throw new RemixError("Repository is not bound to Remix.", {
       exitCode: 2,
@@ -8527,9 +9081,9 @@ async function collabAdd(params) {
     });
     assertSupportedRecordingPreflight(preflight);
     const branch = preflight.currentBranch;
-    assertPreferredBranchMatch({
+    assertBoundBranchMatch({
       currentBranch: branch,
-      preferredBranch: binding.preferredBranch,
+      branchName: binding.branchName,
       allowBranchMismatch: params.allowBranchMismatch,
       operation: "`remix collab add`"
     });
@@ -8609,7 +9163,7 @@ async function collabAdd(params) {
             const replayResp = await params.api.startChangeStepReplay(binding.currentAppId, {
               prompt,
               assistantResponse: assistantResponse ?? void 0,
-              diff: await import_promises14.default.readFile(preserved.preservedDiffPath, "utf8"),
+              diff: await import_promises15.default.readFile(preserved.preservedDiffPath, "utf8"),
               baseCommitHash: preserved.baseHeadCommitHash,
               targetHeadCommitHash: headCommitHash,
               expectedPaths: preserved.stagePlan.expectedPaths,
@@ -8702,6 +9256,7 @@ async function collabAdd(params) {
     });
     const resp = await params.api.createChangeStep(binding.currentAppId, {
       threadId: binding.threadId ?? void 0,
+      collabLaneId: binding.laneId ?? void 0,
       prompt,
       assistantResponse: assistantResponse ?? void 0,
       diff,
@@ -8742,7 +9297,7 @@ async function collabAdd(params) {
         dryRun: false,
         allowBranchMismatch: params.allowBranchMismatch
       });
-      await import_promises14.default.rm(import_path3.default.dirname(backupPath), { recursive: true, force: true }).catch(() => void 0);
+      await import_promises15.default.rm(import_path4.default.dirname(backupPath), { recursive: true, force: true }).catch(() => void 0);
     } catch (err) {
       const detail = formatCliErrorDetail(err);
       const hint = [
@@ -8775,6 +9330,18 @@ function assertSupportedRecordingPreflight2(preflight) {
       hint: preflight.hint
     });
   }
+  if (preflight.status === "branch_binding_missing") {
+    throw new RemixError("Current branch is not yet bound to a Remix lane.", {
+      exitCode: 2,
+      hint: preflight.hint
+    });
+  }
+  if (preflight.status === "family_ambiguous") {
+    throw new RemixError("Multiple canonical Remix families match this repository.", {
+      exitCode: 2,
+      hint: preflight.hint
+    });
+  }
   if (preflight.status === "not_git_repo") {
     throw new RemixError(preflight.hint || "Not inside a git repository.", {
       exitCode: 2,
@@ -8788,9 +9355,9 @@ function assertSupportedRecordingPreflight2(preflight) {
     });
   }
   if (preflight.status === "branch_mismatch") {
-    assertPreferredBranchMatch({
+    assertBoundBranchMatch({
       currentBranch: preflight.currentBranch,
-      preferredBranch: preflight.preferredBranch,
+      branchName: preflight.branchName,
       allowBranchMismatch: false,
       operation: "`remix collab record-turn`"
     });
@@ -8810,7 +9377,11 @@ function assertSupportedRecordingPreflight2(preflight) {
 }
 async function collabRecordTurn(params) {
   const repoRoot = await findGitRoot(params.cwd);
-  const binding = await readCollabBinding(repoRoot);
+  const binding = await ensureActiveLaneBinding({
+    repoRoot,
+    api: params.api,
+    operation: "`remix collab record-turn`"
+  });
   if (!binding) {
     throw new RemixError("Repository is not bound to Remix.", {
       exitCode: 2,
@@ -8842,9 +9413,9 @@ async function collabRecordTurn(params) {
     });
   }
   const branch = await getCurrentBranch(repoRoot);
-  assertPreferredBranchMatch({
+  assertBoundBranchMatch({
     currentBranch: branch,
-    preferredBranch: binding.preferredBranch,
+    branchName: binding.branchName,
     allowBranchMismatch: params.allowBranchMismatch,
     operation: "`remix collab record-turn`"
   });
@@ -8858,6 +9429,7 @@ async function collabRecordTurn(params) {
   });
   const resp = await params.api.createCollabTurn(binding.currentAppId, {
     threadId: binding.threadId ?? void 0,
+    collabLaneId: binding.laneId ?? void 0,
     prompt,
     assistantResponse,
     actor: params.actor,
@@ -8870,10 +9442,11 @@ async function collabRecordTurn(params) {
     },
     idempotencyKey
   });
-  return unwrapResponseObject(resp, "collab turn");
+  const turn = unwrapResponseObject(resp, "collab turn");
+  return turn;
 }
 
-// node_modules/@remixhq/core/dist/chunk-B5S3PUIR.js
+// node_modules/@remixhq/core/dist/chunk-BNKPTE2U.js
 async function readJsonSafe(res) {
   const ct = res.headers.get("content-type") ?? "";
   if (!ct.toLowerCase().includes("application/json")) return null;
@@ -8971,8 +9544,20 @@ function createApiClient(config, opts) {
       const qs = new URLSearchParams();
       if (params.repoFingerprint) qs.set("repoFingerprint", params.repoFingerprint);
       if (params.remoteUrl) qs.set("remoteUrl", params.remoteUrl);
+      if (params.branchName) qs.set("branchName", params.branchName);
       return request(`/v1/projects/bindings/resolve?${qs.toString()}`, { method: "GET" });
     },
+    resolveProjectLaneBinding: (params) => {
+      const qs = new URLSearchParams();
+      if (params.projectId) qs.set("projectId", params.projectId);
+      if (params.repoFingerprint) qs.set("repoFingerprint", params.repoFingerprint);
+      if (params.remoteUrl) qs.set("remoteUrl", params.remoteUrl);
+      if (params.defaultBranch) qs.set("defaultBranch", params.defaultBranch);
+      qs.set("branchName", params.branchName);
+      return request(`/v1/projects/bindings/resolve-lane?${qs.toString()}`, { method: "GET" });
+    },
+    ensureProjectLaneBinding: (payload) => request("/v1/projects/bindings/ensure-lane", { method: "POST", body: JSON.stringify(payload) }),
+    bootstrapFreshProjectLane: (payload) => request("/v1/projects/bindings/bootstrap-fresh-lane", { method: "POST", body: JSON.stringify(payload) }),
     autoEnableDeveloper: () => request("/v1/developer/auto-enable", { method: "POST" }),
     listClientApps: (params) => {
       const qs = params?.orgId ? `?orgId=${encodeURIComponent(params.orgId)}` : "";
@@ -9036,6 +9621,7 @@ function createApiClient(config, opts) {
       if (params?.offset !== void 0) qs.set("offset", String(params.offset));
       if (params?.changeStepId) qs.set("changeStepId", params.changeStepId);
       if (params?.threadId) qs.set("threadId", params.threadId);
+      if (params?.collabLaneId) qs.set("collabLaneId", params.collabLaneId);
       if (params?.createdAfter) qs.set("createdAfter", params.createdAfter);
       if (params?.createdBefore) qs.set("createdBefore", params.createdBefore);
       const suffix = qs.toString() ? `?${qs.toString()}` : "";
@@ -13296,9 +13882,9 @@ var coerce = {
 var NEVER = INVALID;
 
 // node_modules/@remixhq/core/dist/chunk-EVWDYCBL.js
-var import_promises17 = __toESM(require("fs/promises"), 1);
+var import_promises18 = __toESM(require("fs/promises"), 1);
 var import_os4 = __toESM(require("os"), 1);
-var import_path6 = __toESM(require("path"), 1);
+var import_path7 = __toESM(require("path"), 1);
 
 // node_modules/tslib/tslib.es6.mjs
 function __rest(s, e) {
@@ -32957,7 +33543,7 @@ var storedSessionSchema = external_exports.object({
 function xdgConfigHome() {
   const value = process.env.XDG_CONFIG_HOME;
   if (typeof value === "string" && value.trim()) return value;
-  return import_path6.default.join(import_os4.default.homedir(), ".config");
+  return import_path7.default.join(import_os4.default.homedir(), ".config");
 }
 async function maybeLoadKeytar() {
   try {
@@ -32975,31 +33561,31 @@ async function maybeLoadKeytar() {
   return null;
 }
 async function ensurePathPermissions(filePath) {
-  const dir = import_path6.default.dirname(filePath);
-  await import_promises17.default.mkdir(dir, { recursive: true });
+  const dir = import_path7.default.dirname(filePath);
+  await import_promises18.default.mkdir(dir, { recursive: true });
   try {
-    await import_promises17.default.chmod(dir, 448);
+    await import_promises18.default.chmod(dir, 448);
   } catch {
   }
   try {
-    await import_promises17.default.chmod(filePath, 384);
+    await import_promises18.default.chmod(filePath, 384);
   } catch {
   }
 }
-async function writeJsonAtomic(filePath, value) {
-  await import_promises17.default.mkdir(import_path6.default.dirname(filePath), { recursive: true });
+async function writeJsonAtomic2(filePath, value) {
+  await import_promises18.default.mkdir(import_path7.default.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  await import_promises17.default.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
-  await import_promises17.default.rename(tmpPath, filePath);
+  await import_promises18.default.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  await import_promises18.default.rename(tmpPath, filePath);
 }
 async function writeSessionFileFallback(filePath, session) {
-  await writeJsonAtomic(filePath, session);
+  await writeJsonAtomic2(filePath, session);
   await ensurePathPermissions(filePath);
 }
 function createLocalSessionStore(params) {
   const service = params?.service?.trim() || "remix-cli";
   const account = params?.account?.trim() || "default";
-  const filePath = params?.filePath?.trim() || import_path6.default.join(xdgConfigHome(), "remix", "session.json");
+  const filePath = params?.filePath?.trim() || import_path7.default.join(xdgConfigHome(), "remix", "session.json");
   return {
     async getSession() {
       const keytar = await maybeLoadKeytar();
@@ -33013,7 +33599,7 @@ function createLocalSessionStore(params) {
           return null;
         }
       }
-      const raw = await import_promises17.default.readFile(filePath, "utf8").catch(() => null);
+      const raw = await import_promises18.default.readFile(filePath, "utf8").catch(() => null);
       if (!raw) return null;
       try {
         const parsed = storedSessionSchema.safeParse(JSON.parse(raw));
@@ -33200,12 +33786,12 @@ async function createHookCollabApiClient() {
 
 // src/hook-diagnostics.ts
 var import_node_crypto2 = require("crypto");
-var import_promises19 = __toESM(require("fs/promises"), 1);
+var import_promises20 = __toESM(require("fs/promises"), 1);
 var import_node_os5 = __toESM(require("os"), 1);
 var import_node_path7 = __toESM(require("path"), 1);
 
 // src/hook-state.ts
-var import_promises18 = __toESM(require("fs/promises"), 1);
+var import_promises19 = __toESM(require("fs/promises"), 1);
 var import_node_os4 = __toESM(require("os"), 1);
 var import_node_path6 = __toESM(require("path"), 1);
 var import_node_crypto = require("crypto");
@@ -33222,11 +33808,11 @@ function stateLockPath(sessionId) {
 function stateLockMetaPath(sessionId) {
   return import_node_path6.default.join(stateLockPath(sessionId), "owner.json");
 }
-async function writeJsonAtomic2(filePath, value) {
-  await import_promises18.default.mkdir(import_node_path6.default.dirname(filePath), { recursive: true });
+async function writeJsonAtomic3(filePath, value) {
+  await import_promises19.default.mkdir(import_node_path6.default.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  await import_promises18.default.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
-  await import_promises18.default.rename(tmpPath, filePath);
+  await import_promises19.default.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  await import_promises19.default.rename(tmpPath, filePath);
 }
 var STATE_LOCK_WAIT_MS = 2e3;
 var STATE_LOCK_POLL_MS = 25;
@@ -33236,7 +33822,7 @@ async function sleep4(ms) {
   await new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function readStateLockMetadata(sessionId) {
-  const raw = await import_promises18.default.readFile(stateLockMetaPath(sessionId), "utf8").catch(() => null);
+  const raw = await import_promises19.default.readFile(stateLockMetaPath(sessionId), "utf8").catch(() => null);
   if (!raw) return null;
   try {
     const parsed = JSON.parse(raw);
@@ -33254,20 +33840,20 @@ async function readStateLockMetadata(sessionId) {
   }
 }
 async function writeStateLockMetadata(sessionId, metadata) {
-  await writeJsonAtomic2(stateLockMetaPath(sessionId), metadata);
+  await writeJsonAtomic3(stateLockMetaPath(sessionId), metadata);
 }
 async function tryRemoveStaleStateLock(sessionId) {
   const lockPath = stateLockPath(sessionId);
   const metadata = await readStateLockMetadata(sessionId);
   const staleByHeartbeat = metadata && Date.now() - new Date(metadata.heartbeatAt).getTime() > STATE_LOCK_STALE_MS;
   if (staleByHeartbeat) {
-    await import_promises18.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+    await import_promises19.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
     return true;
   }
   if (!metadata) {
-    const lockStat = await import_promises18.default.stat(lockPath).catch(() => null);
+    const lockStat = await import_promises19.default.stat(lockPath).catch(() => null);
     if (lockStat && Date.now() - lockStat.mtimeMs > STATE_LOCK_STALE_MS) {
-      await import_promises18.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+      await import_promises19.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
       return true;
     }
   }
@@ -33276,10 +33862,10 @@ async function tryRemoveStaleStateLock(sessionId) {
 async function acquireStateLock(sessionId) {
   const lockPath = stateLockPath(sessionId);
   const deadline = Date.now() + STATE_LOCK_WAIT_MS;
-  await import_promises18.default.mkdir(stateRoot(), { recursive: true });
+  await import_promises19.default.mkdir(stateRoot(), { recursive: true });
   while (true) {
     try {
-      await import_promises18.default.mkdir(lockPath);
+      await import_promises19.default.mkdir(lockPath);
       const ownerId = (0, import_node_crypto.randomUUID)();
       const createdAt = (/* @__PURE__ */ new Date()).toISOString();
       const metadata = {
@@ -33304,7 +33890,7 @@ async function acquireStateLock(sessionId) {
         clearInterval(heartbeat);
         const currentMetadata = await readStateLockMetadata(sessionId);
         if (currentMetadata?.ownerId === ownerId) {
-          await import_promises18.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+          await import_promises19.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
         }
       };
     } catch (error) {
@@ -33416,7 +34002,7 @@ async function updatePendingTurnState(sessionId, updater) {
   });
 }
 async function loadPendingTurnState(sessionId) {
-  const raw = await import_promises18.default.readFile(statePath(sessionId), "utf8").catch(() => null);
+  const raw = await import_promises19.default.readFile(statePath(sessionId), "utf8").catch(() => null);
   if (!raw) return null;
   try {
     const parsed = JSON.parse(raw);
@@ -33442,7 +34028,7 @@ async function loadPendingTurnState(sessionId) {
   }
 }
 async function savePendingTurnState(state) {
-  await writeJsonAtomic2(statePath(state.sessionId), state);
+  await writeJsonAtomic3(statePath(state.sessionId), state);
 }
 async function upsertTouchedRepo(sessionId, params) {
   const normalizedRepoRoot = params.repoRoot.trim();
@@ -33518,14 +34104,14 @@ async function listTouchedRepos(sessionId) {
 }
 async function clearPendingTurnState(sessionId) {
   await withStateLock(sessionId, async () => {
-    await import_promises18.default.rm(statePath(sessionId), { force: true }).catch(() => void 0);
+    await import_promises19.default.rm(statePath(sessionId), { force: true }).catch(() => void 0);
   });
 }
 
 // package.json
 var package_default = {
   name: "@remixhq/claude-plugin",
-  version: "0.1.15",
+  version: "0.1.17",
   description: "Claude Code plugin for Remix collaboration workflows",
   homepage: "https://github.com/RemixDotOne/remix-claude-plugin",
   license: "MIT",
@@ -33556,8 +34142,8 @@ var package_default = {
     prepack: "npm run build"
   },
   dependencies: {
-    "@remixhq/core": "^0.1.10",
-    "@remixhq/mcp": "^0.1.10"
+    "@remixhq/core": "^0.1.12",
+    "@remixhq/mcp": "^0.1.12"
   },
   devDependencies: {
     "@types/node": "^25.4.0",
@@ -33608,13 +34194,13 @@ function normalizeFields(fields) {
   return Object.fromEntries(normalizedEntries);
 }
 async function rotateLogIfNeeded(logPath) {
-  const stat = await import_promises19.default.stat(logPath).catch(() => null);
+  const stat = await import_promises20.default.stat(logPath).catch(() => null);
   if (!stat || stat.size < MAX_LOG_BYTES) {
     return;
   }
   const rotatedPath = `${logPath}.1`;
-  await import_promises19.default.rm(rotatedPath, { force: true }).catch(() => void 0);
-  await import_promises19.default.rename(logPath, rotatedPath).catch(() => void 0);
+  await import_promises20.default.rm(rotatedPath, { force: true }).catch(() => void 0);
+  await import_promises20.default.rename(logPath, rotatedPath).catch(() => void 0);
 }
 function summarizeText(value) {
   if (typeof value !== "string" || !value.trim()) {
@@ -33634,7 +34220,7 @@ function summarizeText(value) {
 async function appendHookDiagnosticsEvent(params) {
   try {
     const logPath = getHookDiagnosticsLogPath();
-    await import_promises19.default.mkdir(import_node_path7.default.dirname(logPath), { recursive: true });
+    await import_promises20.default.mkdir(import_node_path7.default.dirname(logPath), { recursive: true });
     await rotateLogIfNeeded(logPath);
     const event = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -33651,14 +34237,14 @@ async function appendHookDiagnosticsEvent(params) {
       message: params.message?.trim() || null,
       fields: normalizeFields(params.fields)
     };
-    await import_promises19.default.appendFile(logPath, `${JSON.stringify(event)}
+    await import_promises20.default.appendFile(logPath, `${JSON.stringify(event)}
 `, "utf8");
   } catch {
   }
 }
 
 // src/hook-utils.ts
-var import_promises20 = __toESM(require("fs/promises"), 1);
+var import_promises21 = __toESM(require("fs/promises"), 1);
 var import_node_path8 = __toESM(require("path"), 1);
 async function readJsonStdin() {
   const chunks = [];
@@ -33722,13 +34308,13 @@ function extractBoolean(input, keys) {
 async function findBoundRepo(startPath) {
   if (!startPath) return null;
   let current = import_node_path8.default.resolve(startPath);
-  let stats = await import_promises20.default.stat(current).catch(() => null);
+  let stats = await import_promises21.default.stat(current).catch(() => null);
   if (stats?.isFile()) {
     current = import_node_path8.default.dirname(current);
   }
   while (true) {
     const bindingPath = import_node_path8.default.join(current, ".remix", "config.json");
-    const bindingStats = await import_promises20.default.stat(bindingPath).catch(() => null);
+    const bindingStats = await import_promises21.default.stat(bindingPath).catch(() => null);
     if (bindingStats?.isFile()) return current;
     const parent = import_node_path8.default.dirname(current);
     if (parent === current) return null;
@@ -33767,6 +34353,18 @@ function getErrorDetails(error) {
   return { message, hint: null };
 }
 function getRecordingBlockedMessage(status, repoRoot) {
+  if (status.status === "branch_binding_missing") {
+    return {
+      message: "Fallback Remix turn recording was blocked because the current branch does not have a Remix lane binding yet.",
+      hint: status.hint || `Run \`remix_collab_status\` for ${repoRoot}, then initialize or provision the current branch lane before recording work.`
+    };
+  }
+  if (status.status === "family_ambiguous") {
+    return {
+      message: "Fallback Remix turn recording was blocked because multiple canonical Remix families match this repository and the current checkout does not identify which family to use.",
+      hint: status.hint || `Continue from a checkout already bound to the intended family, or run \`remix_collab_init\` with forceNew=true for ${repoRoot} to create a new canonical family.`
+    };
+  }
   switch (status.status) {
     case "not_git_repo":
       return {
@@ -33785,8 +34383,8 @@ function getRecordingBlockedMessage(status, repoRoot) {
       };
     case "branch_mismatch":
       return {
-        message: "Fallback Remix turn recording was blocked by the checkout's preferred-branch policy.",
-        hint: status.hint || `Repo root: ${repoRoot}`
+        message: "Fallback Remix turn recording was blocked because the current checkout branch does not match the branch expected by the bound Remix lane.",
+        hint: status.hint || `Run \`remix_collab_status\` for ${repoRoot}, then switch back to the expected branch or refresh this branch's binding before recording or syncing.`
       };
     case "metadata_conflict":
       return {