@remixhq/claude-plugin 0.1.16 → 0.1.17

package/dist/mcp-server.cjs

@@ -49218,7 +49218,7 @@ function summarizeUnifiedDiff(diff) {
   return { changedFilesCount, insertions, deletions };
 }
 
-// node_modules/@remixhq/core/dist/chunk-4L3ZBZUQ.js
+// node_modules/@remixhq/core/dist/chunk-IXWQWFYT.js
 var import_promises14 = __toESM(require("fs/promises"), 1);
 var import_path3 = __toESM(require("path"), 1);
 var import_promises15 = __toESM(require("fs/promises"), 1);
@@ -49272,7 +49272,8 @@ function buildBindingFileV3(params) {
     repoFingerprint: params.repoFingerprint,
     remoteUrl: params.remoteUrl,
     defaultBranch: params.defaultBranch,
-    branchBindings: params.branchBindings
+    branchBindings: params.branchBindings,
+    ...params.explicitRootBinding ? { explicitRootBinding: params.explicitRootBinding } : {}
   };
 }
 function normalizeBranchName(value) {
@@ -49291,7 +49292,7 @@ function normalizeBranchBinding(value) {
     upstreamAppId: value.upstreamAppId,
     threadId: value.threadId ?? null,
     laneId: value.laneId ?? null,
-    bindingMode: value.bindingMode === "legacy" ? "legacy" : "lane"
+    bindingMode: value.bindingMode === "legacy" ? "legacy" : value.bindingMode === "explicit_root" ? "explicit_root" : "lane"
   };
 }
 function buildResolvedBinding(params) {
@@ -49365,6 +49366,7 @@ async function readCollabBindingState(repoRoot, options) {
         defaultBranch: migratedFile.defaultBranch,
         currentBranch,
         branchBindings: migratedFile.branchBindings,
+        explicitRootBinding: null,
         binding: buildResolvedBinding({
           fallbackProjectId: projectId,
           repoFingerprint: migratedFile.repoFingerprint,
@@ -49408,7 +49410,22 @@ async function readCollabBindingState(repoRoot, options) {
       };
       shouldPersistNormalizedBranchBindings = true;
     }
-    if (persist && ("explicitBinding" in file || shouldPersistNormalizedBranchBindings || parsed.schemaVersion === 2)) {
+    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 writeJsonAtomic2(
           filePath,
@@ -49416,7 +49433,8 @@ async function readCollabBindingState(repoRoot, options) {
             repoFingerprint: file.repoFingerprint ?? null,
             remoteUrl: file.remoteUrl ?? null,
             defaultBranch: file.defaultBranch ?? null,
-            branchBindings
+            branchBindings,
+            explicitRootBinding
           })
         );
       } catch {
@@ -49427,8 +49445,23 @@ async function readCollabBindingState(repoRoot, options) {
       branchBindings,
       currentBranch: resolvedBranch,
       defaultBranch: normalizeBranchName(file.defaultBranch),
-      legacyProjectId
+      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,
@@ -49437,14 +49470,15 @@ async function readCollabBindingState(repoRoot, options) {
       defaultBranch: file.defaultBranch ?? null,
       currentBranch,
       branchBindings,
-      binding: buildResolvedBinding({
+      explicitRootBinding: buildResolvedBinding({
         fallbackProjectId,
         repoFingerprint: file.repoFingerprint ?? null,
         remoteUrl: file.remoteUrl ?? null,
         defaultBranch: file.defaultBranch ?? null,
-        branchName: resolvedBranch,
-        binding: resolvedBranch ? branchBindings[resolvedBranch] ?? null : null
-      })
+        branchName: normalizeBranchName(file.defaultBranch),
+        binding: explicitRootBinding
+      }),
+      binding: resolvedBinding
     };
   } catch {
     return null;
@@ -49468,13 +49502,39 @@ async function writeCollabBinding(repoRoot, binding) {
     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 writeJsonAtomic2(
     filePath,
     buildBindingFileV3({
       repoFingerprint: binding.repoFingerprint ?? null,
       remoteUrl: binding.remoteUrl ?? null,
       defaultBranch: binding.defaultBranch ?? null,
-      branchBindings
+      branchBindings,
+      explicitRootBinding
+    })
+  );
+  return filePath;
+}
+async function writeCollabBindingSnapshot(params) {
+  const filePath = getCollabBindingPath(params.repoRoot);
+  await writeJsonAtomic2(
+    filePath,
+    buildBindingFileV3({
+      repoFingerprint: params.repoFingerprint,
+      remoteUrl: params.remoteUrl,
+      defaultBranch: params.defaultBranch,
+      branchBindings: params.branchBindings,
+      explicitRootBinding: params.explicitRootBinding ?? null
     })
   );
   return filePath;
@@ -49784,6 +49844,10 @@ function normalizeBranchName2(value) {
 }
 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,
@@ -49794,8 +49858,8 @@ function buildBindingFromLane(state, lane) {
     remoteUrl: lane.remoteUrl ?? state.remoteUrl ?? null,
     defaultBranch: lane.defaultBranch ?? state.defaultBranch ?? null,
     laneId: lane.laneId ?? null,
-    branchName: lane.branchName ?? state.currentBranch ?? null,
-    bindingMode: "lane"
+    branchName: resolvedBranch,
+    bindingMode
   };
 }
 function shouldPersistRemoteLaneMetadata(localBinding, lane) {
@@ -49824,6 +49888,16 @@ async function persistResolvedLane(repoRoot, binding) {
   });
   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) {
@@ -49846,13 +49920,16 @@ async function resolveActiveLaneBinding(params) {
       };
     }
     const laneResp2 = await params.api.resolveProjectLaneBinding({
-      projectId: localBinding.projectId ?? state.projectId ?? void 0,
+      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;
@@ -49895,12 +49972,12 @@ async function resolveActiveLaneBinding(params) {
       return {
         status: "missing_branch_binding",
         currentBranch,
-        projectId: state.projectId,
-        repoFingerprint: state.repoFingerprint,
-        remoteUrl: state.remoteUrl,
-        defaultBranch: state.defaultBranch,
-        upstreamAppId: localBinding.upstreamAppId ?? null,
-        threadId: localBinding.threadId ?? null
+        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 {
@@ -49923,13 +50000,16 @@ async function resolveActiveLaneBinding(params) {
     };
   }
   const laneResp = await params.api.resolveProjectLaneBinding({
-    projectId: state.projectId ?? void 0,
+    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) {
@@ -49941,18 +50021,15 @@ async function resolveActiveLaneBinding(params) {
       };
     }
   }
-  if (lane.status === "binding_not_found") {
-    return { status: "not_bound", currentBranch };
-  }
   return {
     status: "missing_branch_binding",
     currentBranch,
-    projectId: lane.projectId ?? state.projectId,
+    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 ?? null,
-    threadId: lane.threadId ?? null
+    upstreamAppId: lane.upstreamAppId ?? state.explicitRootBinding?.upstreamAppId ?? null,
+    threadId: lane.threadId ?? state.explicitRootBinding?.threadId ?? null
   };
 }
 async function ensureActiveLaneBinding(params) {
@@ -49972,6 +50049,12 @@ async function ensureActiveLaneBinding(params) {
       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;
   }
@@ -49986,65 +50069,6 @@ async function ensureActiveLaneBinding(params) {
     hint: `Run \`remix collab init\` on branch ${resolved.currentBranch} before running ${params.operation ?? "this command"}.`
   });
 }
-async function provisionActiveLaneBinding(params) {
-  const resolved = await resolveActiveLaneBinding(params);
-  if (resolved.status === "resolved") {
-    if (resolved.source === "local") {
-      return { binding: resolved.binding, warnings: [] };
-    }
-    const persisted2 = await persistResolvedLane(params.repoRoot, resolved.binding);
-    return { binding: persisted2, warnings: [] };
-  }
-  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}.`
-    });
-  }
-  if (resolved.status === "not_bound") {
-    return { binding: null, warnings: [] };
-  }
-  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}.`
-    });
-  }
-  let lane;
-  try {
-    const laneResp = await params.api.ensureProjectLaneBinding({
-      projectId: resolved.projectId ?? void 0,
-      repoFingerprint: resolved.repoFingerprint ?? void 0,
-      remoteUrl: resolved.remoteUrl ?? void 0,
-      defaultBranch: resolved.defaultBranch ?? void 0,
-      branchName: resolved.currentBranch
-    });
-    lane = unwrapResponseObject(laneResp, "project lane binding");
-  } catch (error2) {
-    throw new RemixError(`Failed to provision a Remix lane for branch ${resolved.currentBranch}.`, {
-      exitCode: error2 instanceof RemixError ? error2.exitCode : 1,
-      hint: formatCliErrorDetail(error2) || `Remix could not create or recover the branch lane required before ${params.operation}.`
-    });
-  }
-  const state = await readCollabBindingState(params.repoRoot);
-  if (!state) {
-    return { binding: null, warnings: [] };
-  }
-  const binding = buildBindingFromLane(state, lane);
-  if (!binding) {
-    throw new RemixError(`Failed to provision a Remix lane for branch ${resolved.currentBranch}.`, {
-      exitCode: 1,
-      hint: "The server returned incomplete lane binding metadata."
-    });
-  }
-  const persisted = await persistResolvedLane(params.repoRoot, binding);
-  return {
-    binding: persisted,
-    warnings: [
-      lane.created ? `Provisioned Remix lane for branch ${resolved.currentBranch}.` : `Recovered existing Remix lane binding for branch ${resolved.currentBranch}.`
-    ]
-  };
-}
 async function collabRecordingPreflight(params) {
   let repoRoot;
   try {
@@ -50105,6 +50129,24 @@ async function collabRecordingPreflight(params) {
       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",
@@ -50614,6 +50656,12 @@ function assertSupportedRecordingPreflight(preflight) {
       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,
@@ -50929,6 +50977,12 @@ function assertSupportedRecordingPreflight2(preflight) {
       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,
@@ -51424,6 +51478,12 @@ async function resolveQueueAppId(params) {
       hint: `Local app ${bindingResolution.binding.currentAppId}; server app ${bindingResolution.resolvedLane.currentAppId ?? "(unknown)"}.`
     });
   }
+  if (bindingResolution.status === "ambiguous_family_selection") {
+    throw new RemixError("Multiple canonical Remix families match this repository.", {
+      exitCode: 2,
+      hint: "This checkout does not identify a single canonical family. Continue from a checkout already bound to the intended family, or pass `appId` explicitly for the queue request."
+    });
+  }
   return bindingResolution.binding.currentAppId;
 }
 async function collabListMergeRequests(params) {
@@ -51468,6 +51528,12 @@ async function resolveScopeTarget(params) {
       hint: `Local app ${bindingResolution.binding.currentAppId}; server app ${bindingResolution.resolvedLane.currentAppId ?? "(unknown)"}.`
     });
   }
+  if (bindingResolution.status === "ambiguous_family_selection") {
+    throw new RemixError("Multiple canonical Remix families match this repository and no explicit target id was provided.", {
+      exitCode: 2,
+      hint: "This checkout does not identify a single canonical family. Continue from a checkout already bound to the intended family, or pass `targetId` explicitly."
+    });
+  }
   const binding = bindingResolution.binding;
   if (params.scope === "project") {
     if (!binding.projectId) {
@@ -51582,6 +51648,85 @@ ${text}`.trim() || null
     });
   }
 }
+function requireResolvedLaneBinding(lane, params) {
+  if (lane.status === "resolved" && lane.currentAppId && lane.upstreamAppId) {
+    return lane;
+  }
+  const branchLabel = params.branchName ?? "the current branch";
+  const laneStatus = String(lane.status ?? "");
+  throw new RemixError(`Failed to resolve a Remix lane for ${branchLabel}.`, {
+    exitCode: 1,
+    hint: laneStatus === "binding_not_found" ? `Run ${params.operation} again after the repository has been initialized.` : laneStatus === "ambiguous_family_selection" ? "Multiple canonical Remix families match this repository. Continue from a checkout already bound to the intended family, or rerun with `--force-new` to create a new family." : `Remix did not return complete lane metadata for ${branchLabel}.`
+  });
+}
+function resolveProjectBindingResult(response) {
+  const payload = response?.responseObject;
+  if (!payload || typeof payload !== "object") {
+    return { status: "not_found" };
+  }
+  if (payload.status === "ambiguous_family_selection") {
+    const projectIds = Array.isArray(payload.projectIds) ? payload.projectIds.filter((value) => typeof value === "string" && value.trim().length > 0) : [];
+    return {
+      status: "ambiguous_family_selection",
+      candidateCount: typeof payload.candidateCount === "number" && Number.isFinite(payload.candidateCount) ? payload.candidateCount : projectIds.length,
+      projectIds
+    };
+  }
+  if (payload.projectId && payload.appId) {
+    return {
+      status: "resolved",
+      projectId: String(payload.projectId),
+      appId: String(payload.appId),
+      upstreamAppId: String(payload.upstreamAppId ?? payload.appId),
+      threadId: payload.threadId ? String(payload.threadId) : null
+    };
+  }
+  return { status: "not_found" };
+}
+function throwAmbiguousFamilyError(params) {
+  const familyCount = params.candidateCount || params.projectIds.length;
+  const projectHint = params.projectIds.length > 0 ? ` Matching project ids: ${params.projectIds.join(", ")}.` : "";
+  throw new RemixError("Multiple canonical Remix families already match this repository.", {
+    exitCode: 2,
+    hint: `Plain \`remix collab init\` cannot safely choose among ${familyCount} matching canonical families for repo fingerprint ${params.repoFingerprint}${params.remoteUrl ? ` (${params.remoteUrl})` : ""}.${projectHint} Run \`remix collab init --force-new\` to create a new canonical family, or continue from a checkout already bound to the intended family.`
+  });
+}
+async function resolveOrEnsureLaneBinding(params) {
+  const resolvePayload = {
+    projectId: params.projectId ?? void 0,
+    repoFingerprint: params.repoFingerprint,
+    remoteUrl: params.remoteUrl ?? void 0,
+    defaultBranch: params.defaultBranch ?? void 0,
+    branchName: params.branchName
+  };
+  let lane = unwrapResponseObject(
+    await params.api.resolveProjectLaneBinding(resolvePayload),
+    "project lane binding"
+  );
+  if (lane.status !== "resolved") {
+    lane = unwrapResponseObject(
+      await params.api.ensureProjectLaneBinding({
+        ...resolvePayload,
+        seedAppId: params.seedAppId ?? void 0
+      }),
+      "project lane binding"
+    );
+  }
+  return requireResolvedLaneBinding(lane, {
+    branchName: params.branchName,
+    operation: params.operation
+  });
+}
+function branchBindingFromLane(lane, mode, fallback) {
+  return {
+    projectId: lane.projectId ?? fallback.projectId,
+    currentAppId: lane.currentAppId ?? fallback.currentAppId,
+    upstreamAppId: lane.upstreamAppId ?? fallback.upstreamAppId,
+    threadId: lane.threadId ?? fallback.threadId,
+    laneId: lane.laneId ?? null,
+    bindingMode: mode
+  };
+}
 async function collabInit(params) {
   return withRepoMutationLock(
     {
@@ -51603,72 +51748,207 @@ async function collabInit(params) {
       const branchName = currentBranch ?? defaultBranch ?? null;
       const repoFingerprint = await buildRepoFingerprint({ gitRoot: repoRoot, remoteUrl, defaultBranch });
       const repoSnapshot = await captureRepoSnapshot(repoRoot);
-      if (params.forceNew) {
-        const bindingResp = await params.api.resolveProjectBinding({
-          repoFingerprint,
-          remoteUrl: remoteUrl ?? void 0,
-          branchName: branchName ?? void 0
-        });
-        const existing = bindingResp?.responseObject;
-        if (existing?.projectId && existing?.appId) {
-          throw new RemixError("`remix collab init --force-new` is not allowed for repositories already known to Remix.", {
-            exitCode: 2,
-            hint: "This repository already resolves to an existing Remix lineage. Run `remix collab init` without `--force-new`, or use an explicit checkout/remix flow instead of creating a duplicate imported app."
+      const localBindingState = await readCollabBindingState(repoRoot, { persist: true });
+      if (!params.forceNew && localBindingState?.explicitRootBinding && branchName) {
+        const explicitRoot = localBindingState.explicitRootBinding;
+        const explicitProjectId = explicitRoot.projectId ?? localBindingState.projectId;
+        let canonicalLane2 = null;
+        let boundProjectId2 = explicitProjectId;
+        let boundCurrentAppId2 = explicitRoot.currentAppId;
+        let boundUpstreamAppId2 = explicitRoot.upstreamAppId;
+        let boundThreadId2 = explicitRoot.threadId;
+        let boundLaneId2 = explicitRoot.laneId;
+        if (defaultBranch && branchName !== defaultBranch) {
+          canonicalLane2 = await resolveOrEnsureLaneBinding({
+            api: params.api,
+            projectId: explicitProjectId ?? void 0,
+            repoFingerprint,
+            remoteUrl,
+            defaultBranch,
+            branchName: defaultBranch,
+            operation: "`remix collab init`"
           });
-        }
-      }
-      if (!params.forceNew) {
-        const bindingResp = await params.api.resolveProjectBinding({
-          repoFingerprint,
-          remoteUrl: remoteUrl ?? void 0,
-          branchName: branchName ?? void 0
-        });
-        const existing = bindingResp?.responseObject;
-        if (existing?.projectId && existing?.appId) {
-          await assertRepoSnapshotUnchanged(repoRoot, repoSnapshot, {
-            operation: "`remix collab init`",
-            recoveryHint: "The repository changed while the local binding was being initialized. Review the local changes and rerun `remix collab init`."
+          const lane = await resolveOrEnsureLaneBinding({
+            api: params.api,
+            projectId: canonicalLane2.projectId ?? explicitProjectId ?? void 0,
+            repoFingerprint,
+            remoteUrl,
+            defaultBranch,
+            branchName,
+            operation: "`remix collab init`"
           });
-          const initialProjectId = String(existing.projectId);
-          const initialCurrentAppId = String(existing.appId);
-          const initialUpstreamAppId = String(existing.upstreamAppId ?? existing.appId);
-          const initialThreadId = existing.threadId ? String(existing.threadId) : null;
-          const bindingPath2 = await writeCollabBinding(repoRoot, {
-            projectId: initialProjectId,
-            currentAppId: initialCurrentAppId,
-            upstreamAppId: initialUpstreamAppId,
-            threadId: initialThreadId,
+          boundProjectId2 = lane.projectId ?? boundProjectId2;
+          boundCurrentAppId2 = lane.currentAppId ?? boundCurrentAppId2;
+          boundUpstreamAppId2 = lane.upstreamAppId ?? boundUpstreamAppId2;
+          boundThreadId2 = lane.threadId ?? boundThreadId2;
+          boundLaneId2 = lane.laneId ?? null;
+        } else {
+          canonicalLane2 = await resolveOrEnsureLaneBinding({
+            api: params.api,
+            projectId: explicitProjectId ?? void 0,
+            repoFingerprint,
+            remoteUrl,
+            defaultBranch,
+            branchName,
+            operation: "`remix collab init`"
+          });
+          boundProjectId2 = canonicalLane2.projectId ?? boundProjectId2;
+          boundCurrentAppId2 = canonicalLane2.currentAppId ?? boundCurrentAppId2;
+          boundUpstreamAppId2 = canonicalLane2.upstreamAppId ?? boundUpstreamAppId2;
+          boundThreadId2 = canonicalLane2.threadId ?? boundThreadId2;
+          boundLaneId2 = canonicalLane2.laneId ?? null;
+        }
+        const readyApp = await pollAppReady(params.api, boundCurrentAppId2);
+        boundProjectId2 = String(readyApp.projectId ?? boundProjectId2);
+        boundThreadId2 = readyApp.threadId ? String(readyApp.threadId) : boundThreadId2;
+        await assertRepoSnapshotUnchanged(repoRoot, repoSnapshot, {
+          operation: "`remix collab init`",
+          recoveryHint: "The repository changed while the local binding was being initialized. Review the local changes and rerun `remix collab init`."
+        });
+        await writeCollabBinding(repoRoot, {
+          projectId: canonicalLane2?.projectId ?? explicitProjectId ?? null,
+          currentAppId: canonicalLane2?.currentAppId ?? explicitRoot.currentAppId,
+          upstreamAppId: canonicalLane2?.upstreamAppId ?? canonicalLane2?.currentAppId ?? explicitRoot.upstreamAppId ?? explicitRoot.currentAppId,
+          threadId: canonicalLane2?.threadId ?? explicitRoot.threadId,
+          repoFingerprint: canonicalLane2?.repoFingerprint ?? explicitRoot.repoFingerprint ?? repoFingerprint,
+          remoteUrl: canonicalLane2?.remoteUrl ?? explicitRoot.remoteUrl ?? remoteUrl,
+          defaultBranch: canonicalLane2?.defaultBranch ?? explicitRoot.defaultBranch ?? defaultBranch ?? null,
+          laneId: canonicalLane2?.laneId ?? explicitRoot.laneId,
+          branchName: defaultBranch,
+          bindingMode: "explicit_root"
+        });
+        if (defaultBranch && branchName !== defaultBranch) {
+          await writeCollabBinding(repoRoot, {
+            projectId: boundProjectId2,
+            currentAppId: boundCurrentAppId2,
+            upstreamAppId: boundUpstreamAppId2,
+            threadId: boundThreadId2,
             repoFingerprint,
             remoteUrl,
             defaultBranch: defaultBranch ?? null,
-            laneId: null,
+            laneId: boundLaneId2,
             branchName,
             bindingMode: "lane"
           });
+        }
+        return {
+          reused: true,
+          projectId: boundProjectId2 ?? explicitProjectId ?? "",
+          appId: boundCurrentAppId2,
+          dashboardUrl: buildDashboardAppUrl(boundCurrentAppId2),
+          upstreamAppId: boundUpstreamAppId2,
+          bindingPath: import_path9.default.join(repoRoot, ".remix", "config.json"),
+          repoRoot,
+          bindingMode: defaultBranch && branchName !== defaultBranch ? "lane" : "explicit_root",
+          createdCanonicalFamily: false,
+          ...warnings.length > 0 ? { warnings } : {}
+        };
+      }
+      if (!params.forceNew) {
+        const bindingResolution = resolveProjectBindingResult(
+          await params.api.resolveProjectBinding({
+            repoFingerprint,
+            remoteUrl: remoteUrl ?? void 0,
+            branchName: branchName ?? void 0
+          })
+        );
+        if (bindingResolution.status === "ambiguous_family_selection") {
+          throwAmbiguousFamilyError({
+            repoFingerprint,
+            remoteUrl,
+            projectIds: bindingResolution.projectIds,
+            candidateCount: bindingResolution.candidateCount
+          });
+        }
+        if (bindingResolution.status === "resolved") {
+          const initialProjectId = bindingResolution.projectId;
+          const initialCurrentAppId = bindingResolution.appId;
+          const initialUpstreamAppId = bindingResolution.upstreamAppId;
+          const initialThreadId = bindingResolution.threadId;
           let boundProjectId2 = initialProjectId;
           let boundCurrentAppId2 = initialCurrentAppId;
           let boundUpstreamAppId2 = initialUpstreamAppId;
           let boundThreadId2 = initialThreadId;
-          let finalWarnings = [...warnings];
+          let boundLaneId2 = null;
+          let canonicalLane2 = null;
           if (branchName) {
-            const provisioned = await provisionActiveLaneBinding({
-              repoRoot,
-              api: params.api,
-              operation: "`remix collab init`"
-            });
-            if (provisioned.binding) {
-              boundProjectId2 = provisioned.binding.projectId ?? boundProjectId2;
-              boundCurrentAppId2 = provisioned.binding.currentAppId;
-              boundUpstreamAppId2 = provisioned.binding.upstreamAppId;
-              boundThreadId2 = provisioned.binding.threadId;
+            if (defaultBranch && branchName !== defaultBranch) {
+              canonicalLane2 = await resolveOrEnsureLaneBinding({
+                api: params.api,
+                repoFingerprint,
+                remoteUrl,
+                defaultBranch,
+                branchName: defaultBranch,
+                seedAppId: initialCurrentAppId,
+                operation: "`remix collab init`"
+              });
+              const lane = await resolveOrEnsureLaneBinding({
+                api: params.api,
+                projectId: canonicalLane2.projectId ?? void 0,
+                repoFingerprint,
+                remoteUrl,
+                defaultBranch,
+                branchName,
+                operation: "`remix collab init`"
+              });
+              boundProjectId2 = lane.projectId ?? boundProjectId2;
+              boundCurrentAppId2 = lane.currentAppId ?? boundCurrentAppId2;
+              boundUpstreamAppId2 = lane.upstreamAppId ?? boundUpstreamAppId2;
+              boundThreadId2 = lane.threadId ?? boundThreadId2;
+              boundLaneId2 = lane.laneId ?? null;
+            } else {
+              const lane = await resolveOrEnsureLaneBinding({
+                api: params.api,
+                repoFingerprint,
+                remoteUrl,
+                defaultBranch,
+                branchName,
+                seedAppId: initialCurrentAppId,
+                operation: "`remix collab init`"
+              });
+              canonicalLane2 = lane;
+              boundProjectId2 = lane.projectId ?? boundProjectId2;
+              boundCurrentAppId2 = lane.currentAppId ?? boundCurrentAppId2;
+              boundUpstreamAppId2 = lane.upstreamAppId ?? boundUpstreamAppId2;
+              boundThreadId2 = lane.threadId ?? boundThreadId2;
+              boundLaneId2 = lane.laneId ?? null;
             }
-            finalWarnings = [...finalWarnings, ...provisioned.warnings];
           }
           if (boundCurrentAppId2) {
             const readyApp = await pollAppReady(params.api, boundCurrentAppId2);
             boundProjectId2 = String(readyApp.projectId ?? boundProjectId2);
             boundThreadId2 = readyApp.threadId ? String(readyApp.threadId) : boundThreadId2;
           }
+          await assertRepoSnapshotUnchanged(repoRoot, repoSnapshot, {
+            operation: "`remix collab init`",
+            recoveryHint: "The repository changed while the local binding was being initialized. Review the local changes and rerun `remix collab init`."
+          });
+          if (canonicalLane2 && defaultBranch && branchName && branchName !== defaultBranch) {
+            await writeCollabBinding(repoRoot, {
+              projectId: canonicalLane2.projectId ?? null,
+              currentAppId: canonicalLane2.currentAppId ?? boundCurrentAppId2,
+              upstreamAppId: canonicalLane2.upstreamAppId ?? canonicalLane2.currentAppId ?? boundCurrentAppId2,
+              threadId: canonicalLane2.threadId ?? null,
+              repoFingerprint: canonicalLane2.repoFingerprint ?? repoFingerprint,
+              remoteUrl: canonicalLane2.remoteUrl ?? remoteUrl,
+              defaultBranch: canonicalLane2.defaultBranch ?? defaultBranch,
+              laneId: canonicalLane2.laneId ?? null,
+              branchName: defaultBranch,
+              bindingMode: "lane"
+            });
+          }
+          const bindingPath2 = await writeCollabBinding(repoRoot, {
+            projectId: boundProjectId2,
+            currentAppId: boundCurrentAppId2,
+            upstreamAppId: boundUpstreamAppId2,
+            threadId: boundThreadId2,
+            repoFingerprint,
+            remoteUrl,
+            defaultBranch: defaultBranch ?? null,
+            laneId: boundLaneId2,
+            branchName,
+            bindingMode: "lane"
+          });
           return {
             reused: true,
             projectId: boundProjectId2,
@@ -51677,7 +51957,9 @@ async function collabInit(params) {
             upstreamAppId: boundUpstreamAppId2,
             bindingPath: bindingPath2,
             repoRoot,
-            ...finalWarnings.length > 0 ? { warnings: finalWarnings } : {}
+            bindingMode: "lane",
+            createdCanonicalFamily: false,
+            ...warnings.length > 0 ? { warnings } : {}
           };
         }
       }
@@ -51704,7 +51986,7 @@ async function collabInit(params) {
         path: params.path?.trim() || void 0,
         platform: "generic",
         isPublic: false,
-        branch: currentBranch ?? void 0,
+        branch: defaultBranch && branchName && branchName !== defaultBranch ? defaultBranch : currentBranch ?? void 0,
         remoteUrl: remoteUrl ?? void 0,
         defaultBranch: defaultBranch ?? void 0,
         repoFingerprint,
@@ -51717,28 +51999,51 @@ async function collabInit(params) {
       let boundUpstreamAppId = String(app.id);
       let boundThreadId = app.threadId ? String(app.threadId) : null;
       let boundLaneId = null;
+      let canonicalLane = null;
       if (branchName) {
-        const laneResp = defaultBranch && branchName !== defaultBranch ? await params.api.bootstrapFreshProjectLane({
-          projectId: boundProjectId,
-          repoFingerprint,
-          remoteUrl: remoteUrl ?? void 0,
-          defaultBranch: defaultBranch ?? void 0,
-          branchName,
-          seedAppId: String(app.id)
-        }) : await params.api.ensureProjectLaneBinding({
-          projectId: boundProjectId,
-          repoFingerprint,
-          remoteUrl: remoteUrl ?? void 0,
-          defaultBranch: defaultBranch ?? void 0,
-          branchName,
-          seedAppId: String(app.id)
-        });
-        const lane = unwrapResponseObject(laneResp, "project lane binding");
-        boundProjectId = typeof lane.projectId === "string" && lane.projectId ? lane.projectId : boundProjectId;
-        boundCurrentAppId = typeof lane.currentAppId === "string" && lane.currentAppId ? lane.currentAppId : boundCurrentAppId;
-        boundUpstreamAppId = typeof lane.upstreamAppId === "string" && lane.upstreamAppId ? lane.upstreamAppId : boundUpstreamAppId;
-        boundThreadId = typeof lane.threadId === "string" && lane.threadId ? lane.threadId : boundThreadId;
-        boundLaneId = typeof lane.laneId === "string" && lane.laneId ? lane.laneId : null;
+        if (defaultBranch && branchName !== defaultBranch) {
+          canonicalLane = await resolveOrEnsureLaneBinding({
+            api: params.api,
+            projectId: boundProjectId,
+            repoFingerprint,
+            remoteUrl,
+            defaultBranch,
+            branchName: defaultBranch,
+            seedAppId: String(app.id),
+            operation: "`remix collab init`"
+          });
+          const lane = await resolveOrEnsureLaneBinding({
+            api: params.api,
+            projectId: canonicalLane.projectId ?? boundProjectId,
+            repoFingerprint,
+            remoteUrl,
+            defaultBranch,
+            branchName,
+            operation: "`remix collab init`"
+          });
+          boundProjectId = lane.projectId ?? boundProjectId;
+          boundCurrentAppId = lane.currentAppId ?? boundCurrentAppId;
+          boundUpstreamAppId = lane.upstreamAppId ?? boundUpstreamAppId;
+          boundThreadId = lane.threadId ?? boundThreadId;
+          boundLaneId = lane.laneId ?? null;
+        } else {
+          const lane = await resolveOrEnsureLaneBinding({
+            api: params.api,
+            projectId: boundProjectId,
+            repoFingerprint,
+            remoteUrl,
+            defaultBranch,
+            branchName,
+            seedAppId: String(app.id),
+            operation: "`remix collab init`"
+          });
+          canonicalLane = lane;
+          boundProjectId = lane.projectId ?? boundProjectId;
+          boundCurrentAppId = lane.currentAppId ?? boundCurrentAppId;
+          boundUpstreamAppId = lane.upstreamAppId ?? boundUpstreamAppId;
+          boundThreadId = lane.threadId ?? boundThreadId;
+          boundLaneId = lane.laneId ?? null;
+        }
       }
       if (boundCurrentAppId) {
         const readyApp = await pollAppReady(params.api, boundCurrentAppId);
@@ -51749,18 +52054,64 @@ async function collabInit(params) {
         operation: "`remix collab init`",
         recoveryHint: "The repository changed before the Remix binding was written. Review the local changes and rerun `remix collab init`."
       });
-      const bindingPath = await writeCollabBinding(repoRoot, {
-        projectId: boundProjectId,
-        currentAppId: boundCurrentAppId,
-        upstreamAppId: boundUpstreamAppId,
-        threadId: boundThreadId,
-        repoFingerprint,
-        remoteUrl,
-        defaultBranch: defaultBranch ?? null,
-        laneId: boundLaneId,
-        branchName,
-        bindingMode: "lane"
-      });
+      const bindingMode = params.forceNew && (!defaultBranch || branchName === defaultBranch) ? "explicit_root" : "lane";
+      let bindingPath;
+      if (params.forceNew && defaultBranch && canonicalLane) {
+        const canonicalBinding = branchBindingFromLane(canonicalLane, "explicit_root", {
+          projectId: canonicalLane.projectId ?? boundProjectId,
+          currentAppId: canonicalLane.currentAppId ?? boundCurrentAppId,
+          upstreamAppId: canonicalLane.upstreamAppId ?? canonicalLane.currentAppId ?? boundCurrentAppId,
+          threadId: canonicalLane.threadId ?? boundThreadId
+        });
+        const branchBindings = {
+          [defaultBranch]: canonicalBinding
+        };
+        if (branchName && branchName !== defaultBranch) {
+          branchBindings[branchName] = {
+            projectId: boundProjectId,
+            currentAppId: boundCurrentAppId,
+            upstreamAppId: boundUpstreamAppId,
+            threadId: boundThreadId,
+            laneId: boundLaneId,
+            bindingMode: "lane"
+          };
+        }
+        bindingPath = await writeCollabBindingSnapshot({
+          repoRoot,
+          repoFingerprint,
+          remoteUrl,
+          defaultBranch,
+          branchBindings,
+          explicitRootBinding: canonicalBinding
+        });
+      } else {
+        if (canonicalLane && defaultBranch && branchName && branchName !== defaultBranch) {
+          await writeCollabBinding(repoRoot, {
+            projectId: canonicalLane.projectId ?? null,
+            currentAppId: canonicalLane.currentAppId ?? boundCurrentAppId,
+            upstreamAppId: canonicalLane.upstreamAppId ?? canonicalLane.currentAppId ?? boundCurrentAppId,
+            threadId: canonicalLane.threadId ?? null,
+            repoFingerprint: canonicalLane.repoFingerprint ?? repoFingerprint,
+            remoteUrl: canonicalLane.remoteUrl ?? remoteUrl,
+            defaultBranch: canonicalLane.defaultBranch ?? defaultBranch,
+            laneId: canonicalLane.laneId ?? null,
+            branchName: defaultBranch,
+            bindingMode: params.forceNew ? "explicit_root" : "lane"
+          });
+        }
+        bindingPath = await writeCollabBinding(repoRoot, {
+          projectId: boundProjectId,
+          currentAppId: boundCurrentAppId,
+          upstreamAppId: boundUpstreamAppId,
+          threadId: boundThreadId,
+          repoFingerprint,
+          remoteUrl,
+          defaultBranch: defaultBranch ?? null,
+          laneId: boundLaneId,
+          branchName,
+          bindingMode
+        });
+      }
       return {
         reused: false,
         projectId: boundProjectId,
@@ -51769,6 +52120,8 @@ async function collabInit(params) {
         upstreamAppId: boundUpstreamAppId,
         bindingPath,
         repoRoot,
+        bindingMode,
+        createdCanonicalFamily: Boolean(params.forceNew),
         remoteUrl,
         defaultBranch,
         ...warnings.length > 0 ? { warnings } : {}
@@ -52211,7 +52564,32 @@ async function collabStatus(params) {
     addBlockedReason(status.sync, "branch_binding_missing");
     addBlockedReason(status.reconcile, "branch_binding_missing");
     addWarning(status, `Current branch ${bindingResolution.currentBranch ?? "(detached)"} is not yet bound to a Remix lane.`);
-    status.recommendedAction = "no_action";
+    status.recommendedAction = "init";
+    return status;
+  }
+  if (bindingResolution.status === "ambiguous_family_selection") {
+    status.binding = {
+      isBound: true,
+      path: getCollabBindingPath(repoRoot),
+      projectId: null,
+      currentAppId: null,
+      upstreamAppId: null,
+      isRemix: null,
+      threadId: null,
+      repoFingerprint: bindingResolution.repoFingerprint,
+      remoteUrl: bindingResolution.remoteUrl,
+      defaultBranch: bindingResolution.defaultBranch,
+      laneId: null,
+      branchName: bindingResolution.currentBranch,
+      bindingMode: null
+    };
+    addBlockedReason(status.sync, "family_ambiguous");
+    addBlockedReason(status.reconcile, "family_ambiguous");
+    addWarning(
+      status,
+      `Multiple canonical Remix families match ${bindingResolution.currentBranch ?? "the current branch"}. Switch to a checkout already bound to the intended family or run \`remix collab init --force-new\`.`
+    );
+    status.recommendedAction = "choose_family";
     return status;
   }
   const binding = bindingResolution.binding;
@@ -52363,6 +52741,8 @@ async function collabStatus(params) {
     status.recommendedAction = "reconcile";
   } else if ((status.remote.incomingOpenMergeRequestCount ?? 0) > 0) {
     status.recommendedAction = "review_queue";
+  } else if (status.sync.blockedReasons.includes("family_ambiguous") || status.reconcile.blockedReasons.includes("family_ambiguous")) {
+    status.recommendedAction = "choose_family";
   } else {
     status.recommendedAction = "no_action";
   }
@@ -52506,6 +52886,7 @@ var ERROR_CODES = {
   DIRTY_WORKTREE: "DIRTY_WORKTREE",
   DETACHED_HEAD: "DETACHED_HEAD",
   PREFERRED_BRANCH_MISMATCH: "PREFERRED_BRANCH_MISMATCH",
+  FAMILY_SELECTION_AMBIGUOUS: "FAMILY_SELECTION_AMBIGUOUS",
   MISSING_HEAD: "MISSING_HEAD",
   REPO_LOCK_HELD: "REPO_LOCK_HELD",
   REPO_LOCK_TIMEOUT: "REPO_LOCK_TIMEOUT",
@@ -52640,6 +53021,14 @@ function normalizeByMessage(err) {
       category: "local_state"
     });
   }
+  if (message.includes("Multiple canonical Remix families") || message.includes("family selection is ambiguous")) {
+    return makeNormalized({
+      code: ERROR_CODES.FAMILY_SELECTION_AMBIGUOUS,
+      message,
+      hint,
+      category: "local_state"
+    });
+  }
   if (message.includes("Failed to resolve local HEAD")) {
     return makeNormalized({
       code: ERROR_CODES.MISSING_HEAD,
@@ -53036,7 +53425,9 @@ var initDataSchema = external_exports.object({
   dashboardUrl: external_exports.string().url(),
   upstreamAppId: external_exports.string(),
   bindingPath: external_exports.string(),
-  repoRoot: external_exports.string()
+  repoRoot: external_exports.string(),
+  bindingMode: external_exports.enum(["legacy", "lane", "explicit_root"]).optional(),
+  createdCanonicalFamily: external_exports.boolean().optional()
 });
 var listDataSchema = external_exports.object({
   apps: genericArraySchema,
@@ -53164,6 +53555,7 @@ var accessDebugSuccessSchema = makeSuccessSchema(accessDebugDataSchema);
 var updateMemberRoleSuccessSchema = makeSuccessSchema(updateMemberRoleDataSchema);
 function getRiskLevel(status) {
   if (status.recommendedAction === "reconcile") return "high";
+  if (status.recommendedAction === "choose_family") return "medium";
   if (status.recommendedAction === "sync" || status.remote.incomingOpenMergeRequestCount) return "medium";
   if (status.repo.branchMismatch || !status.repo.isGitRepo || !status.binding.isBound || !status.repo.worktree.isClean) return "medium";
   return "low";
@@ -53183,6 +53575,10 @@ function getRecommendedNextActions(status) {
       return ["Run remix_collab_reconcile_preview before attempting remix_collab_reconcile_apply. Reconcile is the explicit Remix recovery path when fast-forward sync is no longer possible."];
     case "review_queue":
       return ["Run remix_collab_review_queue to inspect reviewable merge requests instead of using local git merge flows."];
+    case "choose_family":
+      return [
+        "This checkout is ambiguous across multiple canonical Remix families. Continue from a checkout already bound to the intended family, or run remix_collab_init with forceNew=true to create and bind a new canonical family."
+      ];
     default:
       return [];
   }
@@ -56133,7 +56529,7 @@ async function listPendingTurnStateSummaries() {
 // package.json
 var package_default = {
   name: "@remixhq/claude-plugin",
-  version: "0.1.16",
+  version: "0.1.17",
   description: "Claude Code plugin for Remix collaboration workflows",
   homepage: "https://github.com/RemixDotOne/remix-claude-plugin",
   license: "MIT",
@@ -56164,8 +56560,8 @@ var package_default = {
     prepack: "npm run build"
   },
   dependencies: {
-    "@remixhq/core": "^0.1.11",
-    "@remixhq/mcp": "^0.1.11"
+    "@remixhq/core": "^0.1.12",
+    "@remixhq/mcp": "^0.1.12"
   },
   devDependencies: {
     "@types/node": "^25.4.0",