@remixhq/core 0.1.32 → 0.1.34

package/dist/api.d.ts

@@ -1,5 +1,5 @@
 import { CoreConfig } from './config.js';
-import { T as TokenProvider } from './tokenProvider-BWTusyj4.js';
+import { T as TokenProvider } from './tokenProvider-B9so5Pm3.js';
 import { T as TurnUsage } from './contracts-WCYiMqwB.js';
 import 'zod';
 
@@ -790,6 +790,7 @@ type ApiClient = {
     }): Promise<Json>;
     getAppContext(appId: string): Promise<Json>;
     getAppOverview(appId: string): Promise<Json>;
+    getAppMergePreview(appId: string): Promise<Json>;
     listAppTimeline(appId: string, params?: {
         limit?: number;
         cursor?: string;

package/dist/api.js

@@ -1,6 +1,6 @@
 import {
   createApiClient
-} from "./chunk-DOMO3LNV.js";
+} from "./chunk-KURN7YZ5.js";
 import "./chunk-7XJGOKEO.js";
 export {
   createApiClient

package/dist/auth.d.ts

@@ -1,5 +1,5 @@
-import { S as SessionStore, a as StoredSession } from './tokenProvider-BWTusyj4.js';
-export { R as RefreshStoredSession, d as ResolvedAuthToken, T as TokenProvider, c as createStoredSessionTokenProvider, s as shouldRefreshSoon, b as storedSessionSchema } from './tokenProvider-BWTusyj4.js';
+import { W as WithRefreshLock, S as SessionStore, a as StoredSession } from './tokenProvider-B9so5Pm3.js';
+export { R as RefreshLockOptions, e as RefreshStoredSession, f as ResolvedAuthToken, T as TokenProvider, c as createRefreshLock, b as createStoredSessionTokenProvider, s as shouldRefreshSoon, d as storedSessionSchema } from './tokenProvider-B9so5Pm3.js';
 import { CoreConfig } from './config.js';
 import 'zod';
 
@@ -8,6 +8,43 @@ declare function createLocalSessionStore(params?: {
     account?: string;
     filePath?: string;
 }): SessionStore;
+/**
+ * Resolve the on-disk session file path that `createLocalSessionStore`
+ * uses by default. Exposed so callers can wire the matching refresh
+ * lock without duplicating the xdg lookup.
+ */
+declare function defaultSessionFilePath(): string;
+/**
+ * Build a `WithRefreshLock` bound to the session file's `.lock`
+ * sibling. Every process that touches a given session file should use
+ * the same lock so concurrent refreshes serialize correctly across
+ * the CLI, the desktop helper subprocess, and the MCP plugin host.
+ */
+declare function createDefaultRefreshLock(filePath?: string): WithRefreshLock;
+
+/**
+ * Classification helpers for refresh-token failures.
+ *
+ * The token provider needs to react very differently depending on
+ * WHY a refresh failed:
+ *
+ *   - `isNetworkError`: transient — DNS / TCP / TLS / undici fetch
+ *     dropped mid-flight. Keep the existing session (it may already
+ *     be unusable but the *refresh token* is most likely still alive
+ *     server-side, especially within Supabase's reuse interval). The
+ *     next attempt will retry.
+ *
+ *   - `isInvalidGrantError`: terminal — Supabase explicitly said the
+ *     refresh token is dead (revoked, reused outside the grace
+ *     window, user signed out elsewhere). No amount of retrying will
+ *     fix it; the user must re-authenticate.
+ *
+ * Anything else (5xx, unexpected) is treated like a network error by
+ * default — better to keep the session and retry than to log the
+ * user out on a transient backend hiccup.
+ */
+declare function isNetworkError(err: unknown): boolean;
+declare function isInvalidGrantError(err: unknown): boolean;
 
 type SupabaseAuthHelpers = {
     startGoogleLogin(params: {
@@ -24,4 +61,4 @@ type SupabaseAuthHelpers = {
 };
 declare function createSupabaseAuthHelpers(config: CoreConfig): SupabaseAuthHelpers;
 
-export { SessionStore, StoredSession, type SupabaseAuthHelpers, createLocalSessionStore, createSupabaseAuthHelpers };
+export { SessionStore, StoredSession, type SupabaseAuthHelpers, WithRefreshLock, createDefaultRefreshLock, createLocalSessionStore, createSupabaseAuthHelpers, defaultSessionFilePath, isInvalidGrantError, isNetworkError };

package/dist/auth.js

@@ -1,15 +1,25 @@
 import {
+  createDefaultRefreshLock,
   createLocalSessionStore,
+  createRefreshLock,
   createStoredSessionTokenProvider,
   createSupabaseAuthHelpers,
+  defaultSessionFilePath,
+  isInvalidGrantError,
+  isNetworkError,
   shouldRefreshSoon,
   storedSessionSchema
-} from "./chunk-MAM4CGDF.js";
+} from "./chunk-OMJ4JDME.js";
 import "./chunk-7XJGOKEO.js";
 export {
+  createDefaultRefreshLock,
   createLocalSessionStore,
+  createRefreshLock,
   createStoredSessionTokenProvider,
   createSupabaseAuthHelpers,
+  defaultSessionFilePath,
+  isInvalidGrantError,
+  isNetworkError,
   shouldRefreshSoon,
   storedSessionSchema
 };

package/dist/{chunk-DOMO3LNV.js → chunk-KURN7YZ5.js}

@@ -366,6 +366,7 @@ function createApiClient(config, opts) {
     openApp: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/open`, { method: "POST", body: JSON.stringify(payload ?? {}) }),
     getAppContext: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/context`, { method: "GET" }),
     getAppOverview: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/overview`, { method: "GET" }),
+    getAppMergePreview: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/merge-preview`, { method: "GET" }),
     listAppTimeline: (appId, params) => request(`/v1/apps/${encodeURIComponent(appId)}/timeline${buildAppTimelineQuery(params)}`, { method: "GET" }),
     getAppTimelineEvent: (appId, eventId) => request(`/v1/apps/${encodeURIComponent(appId)}/timeline/${encodeURIComponent(eventId)}`, { method: "GET" }),
     listAppEditQueue: (appId, params) => request(`/v1/apps/${encodeURIComponent(appId)}/edit-queue${buildAppEditQueueQuery(params)}`, { method: "GET" }),

package/dist/{chunk-MAM4CGDF.js → chunk-OMJ4JDME.js}

@@ -16,14 +16,82 @@ var storedSessionSchema = z.object({
 });
 
 // src/auth/localSessionStore.ts
+import fs2 from "fs/promises";
+import os2 from "os";
+import path2 from "path";
+
+// src/auth/refreshLock.ts
 import fs from "fs/promises";
 import os from "os";
 import path from "path";
+var DEFAULT_STALE_MS = 3e4;
+var DEFAULT_MAX_WAIT_MS = 15e3;
+var DEFAULT_POLL_MS = 50;
+function createRefreshLock(opts) {
+  const staleMs = opts.staleMs ?? DEFAULT_STALE_MS;
+  const maxWaitMs = opts.maxWaitMs ?? DEFAULT_MAX_WAIT_MS;
+  const pollMs = opts.pollMs ?? DEFAULT_POLL_MS;
+  let inProcess = null;
+  return async function withRefreshLock(fn) {
+    if (inProcess) {
+      await inProcess.catch(() => {
+      });
+    }
+    const job = (async () => {
+      const start = Date.now();
+      while (true) {
+        try {
+          await fs.mkdir(path.dirname(opts.lockPath), { recursive: true });
+          const fh = await fs.open(opts.lockPath, "wx");
+          try {
+            await fh.writeFile(`${process.pid}
+${Date.now()}
+${os.hostname()}
+`);
+          } finally {
+            await fh.close().catch(() => {
+            });
+          }
+          try {
+            return await fn();
+          } finally {
+            await fs.unlink(opts.lockPath).catch(() => {
+            });
+          }
+        } catch (err) {
+          const code = err?.code;
+          if (code !== "EEXIST") throw err;
+          const stat = await fs.stat(opts.lockPath).catch(() => null);
+          if (stat && Date.now() - stat.mtimeMs > staleMs) {
+            await fs.unlink(opts.lockPath).catch(() => {
+            });
+            continue;
+          }
+          if (Date.now() - start > maxWaitMs) {
+            return await fn();
+          }
+          await sleep(pollMs);
+        }
+      }
+    })();
+    inProcess = job;
+    try {
+      return await job;
+    } finally {
+      if (inProcess === job) inProcess = null;
+    }
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/auth/localSessionStore.ts
 var loadKeytarModule = () => new Function("return import('keytar')")();
 function xdgConfigHome() {
   const value = process.env.XDG_CONFIG_HOME;
   if (typeof value === "string" && value.trim()) return value;
-  return path.join(os.homedir(), ".config");
+  return path2.join(os2.homedir(), ".config");
 }
 async function maybeLoadKeytar() {
   try {
@@ -41,22 +109,22 @@ async function maybeLoadKeytar() {
   return null;
 }
 async function ensurePathPermissions(filePath) {
-  const dir = path.dirname(filePath);
-  await fs.mkdir(dir, { recursive: true });
+  const dir = path2.dirname(filePath);
+  await fs2.mkdir(dir, { recursive: true });
   try {
-    await fs.chmod(dir, 448);
+    await fs2.chmod(dir, 448);
   } catch {
   }
   try {
-    await fs.chmod(filePath, 384);
+    await fs2.chmod(filePath, 384);
   } catch {
   }
 }
 async function writeJsonAtomic(filePath, value) {
-  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs2.mkdir(path2.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  await fs.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
-  await fs.rename(tmpPath, filePath);
+  await fs2.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  await fs2.rename(tmpPath, filePath);
 }
 async function writeSessionFileFallback(filePath, session) {
   await writeJsonAtomic(filePath, session);
@@ -65,7 +133,7 @@ async function writeSessionFileFallback(filePath, session) {
 function createLocalSessionStore(params) {
   const service = params?.service?.trim() || "remix-cli";
   const account = params?.account?.trim() || "default";
-  const filePath = params?.filePath?.trim() || path.join(xdgConfigHome(), "remix", "session.json");
+  const filePath = params?.filePath?.trim() || path2.join(xdgConfigHome(), "remix", "session.json");
   async function readKeytar() {
     const keytar = await maybeLoadKeytar();
     if (!keytar) return null;
@@ -79,7 +147,7 @@ function createLocalSessionStore(params) {
     }
   }
   async function readFile() {
-    const raw = await fs.readFile(filePath, "utf8").catch(() => null);
+    const raw = await fs2.readFile(filePath, "utf8").catch(() => null);
     if (!raw) return null;
     try {
       const parsed = storedSessionSchema.safeParse(JSON.parse(raw));
@@ -116,6 +184,42 @@ function createLocalSessionStore(params) {
     }
   };
 }
+function defaultSessionFilePath() {
+  return path2.join(xdgConfigHome(), "remix", "session.json");
+}
+function createDefaultRefreshLock(filePath) {
+  const target = filePath?.trim() || defaultSessionFilePath();
+  return createRefreshLock({ lockPath: `${target}.lock` });
+}
+
+// src/auth/refreshErrors.ts
+var NETWORK_CODE_PATTERN = /^(ECONNRESET|ECONNREFUSED|ETIMEDOUT|EAI_AGAIN|ENETUNREACH|ENOTFOUND|EPIPE|EHOSTUNREACH|EADDRNOTAVAIL|UND_ERR_)/;
+var NETWORK_MESSAGE_PATTERN = /fetch failed|failed to fetch|network request failed|socket hang up|network error|aborted/i;
+function isNetworkError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  const code = typeof e.code === "string" ? e.code : void 0;
+  const errno = typeof e.errno === "string" ? e.errno : void 0;
+  const msg = typeof e.message === "string" ? e.message : "";
+  if (code && NETWORK_CODE_PATTERN.test(code)) return true;
+  if (errno && NETWORK_CODE_PATTERN.test(errno)) return true;
+  if (e.name === "TypeError" && NETWORK_MESSAGE_PATTERN.test(msg)) return true;
+  if (e.name === "AbortError") return true;
+  if (NETWORK_MESSAGE_PATTERN.test(msg)) return true;
+  if (e.cause) return isNetworkError(e.cause);
+  return false;
+}
+var INVALID_GRANT_MESSAGE_PATTERN = /invalid[_ ]grant|invalid refresh token|refresh[_ ]token[_ ]not[_ ]found|token has expired or (been )?revoked|already used|user from sub claim in jwt does not exist/i;
+function isInvalidGrantError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  const code = typeof e.code === "string" ? e.code : "";
+  const msg = typeof e.message === "string" ? e.message : "";
+  if (code === "invalid_grant" || code === "refresh_token_not_found") return true;
+  if (INVALID_GRANT_MESSAGE_PATTERN.test(msg)) return true;
+  if (e.cause) return isInvalidGrantError(e.cause);
+  return false;
+}
 
 // src/auth/tokenProvider.ts
 function shouldRefreshSoon(session, skewSeconds = 60) {
@@ -123,6 +227,7 @@ function shouldRefreshSoon(session, skewSeconds = 60) {
   return session.expires_at <= nowSec + skewSeconds;
 }
 function createStoredSessionTokenProvider(params) {
+  const withLock = params.withRefreshLock ?? (async (fn) => fn());
   return async (opts) => {
     const forceRefresh = Boolean(opts?.forceRefresh);
     const envToken = process.env.COMERGE_ACCESS_TOKEN;
@@ -137,11 +242,38 @@ function createStoredSessionTokenProvider(params) {
       });
     }
     if (forceRefresh || shouldRefreshSoon(session)) {
+      const sessionAtEntry = session;
       try {
-        session = await params.refreshStoredSession({ config: params.config, session });
-        await params.sessionStore.setSession(session);
+        session = await withLock(async () => {
+          const latest = await params.sessionStore.getSession();
+          const base = latest ?? sessionAtEntry;
+          if (!base) {
+            throw new RemixError("Not signed in.", {
+              exitCode: 2,
+              hint: "Run `remix login`, or set COMERGE_ACCESS_TOKEN for CI."
+            });
+          }
+          const siblingRefreshed = latest != null && latest.access_token !== sessionAtEntry.access_token;
+          if (siblingRefreshed && !forceRefresh && !shouldRefreshSoon(base, 5)) {
+            return base;
+          }
+          const refreshed = await params.refreshStoredSession({
+            config: params.config,
+            session: base
+          });
+          await params.sessionStore.setSession(refreshed);
+          return refreshed;
+        });
       } catch (err) {
-        void err;
+        if (isInvalidGrantError(err)) {
+          throw new RemixError("Session expired. Please sign in again.", {
+            exitCode: 2,
+            hint: "Run `remix login` to re-authenticate."
+          });
+        }
+        if (isNetworkError(err)) {
+        } else {
+        }
       }
     }
     return { token: session.access_token, session, fromEnv: false };
@@ -217,8 +349,7 @@ function createSupabaseAuthHelpers(config) {
       return toStoredSession(data.session);
     },
     async refreshWithStoredSession(params) {
-      const { data, error } = await supabase.auth.setSession({
-        access_token: params.session.access_token,
+      const { data, error } = await supabase.auth.refreshSession({
         refresh_token: params.session.refresh_token
       });
       if (error) throw error;
@@ -230,7 +361,12 @@ function createSupabaseAuthHelpers(config) {
 
 export {
   storedSessionSchema,
+  createRefreshLock,
   createLocalSessionStore,
+  defaultSessionFilePath,
+  createDefaultRefreshLock,
+  isNetworkError,
+  isInvalidGrantError,
   shouldRefreshSoon,
   createStoredSessionTokenProvider,
   createSupabaseAuthHelpers

package/dist/collab.js

@@ -509,6 +509,13 @@ import path3 from "path";
 function getBaselinePath(params) {
   return path3.join(getBaselinesRoot(), `${buildLaneStateKey(params)}.json`);
 }
+function normalizeNullableString(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || null;
+}
+function isSameBaselineIdentity(left, right) {
+  return left.repoRoot === right.repoRoot && (left.repoFingerprint ?? null) === (right.repoFingerprint ?? null) && (left.laneId ?? null) === (right.laneId ?? null) && left.currentAppId === right.currentAppId && (left.branchName ?? null) === (right.branchName ?? null);
+}
 async function readLocalBaseline(params) {
   try {
     const raw = await fs2.readFile(getBaselinePath(params), "utf8");
@@ -558,6 +565,105 @@ async function writeLocalBaseline(baseline) {
   await writeJsonAtomic(getBaselinePath(baseline), normalized);
   return normalized;
 }
+async function readAllLocalBaselines() {
+  let entries;
+  try {
+    entries = await fs2.readdir(getBaselinesRoot());
+  } catch (error) {
+    if (error?.code === "ENOENT") return [];
+    throw error;
+  }
+  const baselines = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    try {
+      const raw = await fs2.readFile(path3.join(getBaselinesRoot(), entry), "utf8");
+      const parsed = JSON.parse(raw);
+      if (!parsed || typeof parsed !== "object") continue;
+      if (![1, 2].includes(Number(parsed.schemaVersion)) || typeof parsed.key !== "string" || typeof parsed.repoRoot !== "string") {
+        continue;
+      }
+      baselines.push({
+        schemaVersion: Number(parsed.schemaVersion) === 2 ? 2 : 1,
+        key: parsed.key,
+        repoRoot: parsed.repoRoot,
+        repoFingerprint: parsed.repoFingerprint ?? null,
+        laneId: parsed.laneId ?? null,
+        currentAppId: String(parsed.currentAppId ?? ""),
+        branchName: parsed.branchName ?? null,
+        lastSnapshotId: parsed.lastSnapshotId ?? null,
+        lastSnapshotHash: parsed.lastSnapshotHash ?? null,
+        lastServerRevisionId: parsed.lastServerRevisionId ?? null,
+        lastServerTreeHash: parsed.lastServerTreeHash ?? null,
+        lastServerHeadHash: parsed.lastServerHeadHash ?? null,
+        lastSeenLocalCommitHash: parsed.lastSeenLocalCommitHash ?? null,
+        updatedAt: String(parsed.updatedAt ?? "")
+      });
+    } catch {
+      continue;
+    }
+  }
+  return baselines;
+}
+async function migrateLocalBaselineForLaneChange(params) {
+  if ((params.fromLaneId ?? null) === (params.toLaneId ?? null)) {
+    return { status: "same_lane" };
+  }
+  const target = await readLocalBaseline({
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.repoFingerprint,
+    laneId: params.toLaneId
+  });
+  if (target) {
+    return { status: "target_exists" };
+  }
+  const source = await readLocalBaseline({
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.repoFingerprint,
+    laneId: params.fromLaneId
+  });
+  if (!source) {
+    return { status: "source_missing" };
+  }
+  const expectedSource = {
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.repoFingerprint,
+    laneId: params.fromLaneId,
+    currentAppId: params.currentAppId,
+    branchName: params.branchName
+  };
+  const actualSource = {
+    repoRoot: source.repoRoot,
+    repoFingerprint: source.repoFingerprint,
+    laneId: source.laneId,
+    currentAppId: source.currentAppId,
+    branchName: source.branchName
+  };
+  if (!isSameBaselineIdentity(actualSource, expectedSource)) {
+    return { status: "source_missing" };
+  }
+  const baseline = await writeLocalBaseline({
+    ...source,
+    laneId: params.toLaneId
+  });
+  return { status: "migrated", baseline };
+}
+async function findCompatibleLocalBaseline(params) {
+  const targetKey = buildLaneStateKey(params);
+  const branchName = normalizeNullableString(params.branchName);
+  const candidates = (await readAllLocalBaselines()).filter((baseline) => {
+    if (baseline.key === targetKey) return false;
+    if (baseline.repoRoot !== params.repoRoot) return false;
+    if ((baseline.repoFingerprint ?? null) !== (params.repoFingerprint ?? null)) return false;
+    if (baseline.currentAppId !== params.currentAppId) return false;
+    return true;
+  });
+  const branchMatches = candidates.filter((baseline) => normalizeNullableString(baseline.branchName) === branchName);
+  const compatible = branchMatches.length > 0 ? branchMatches : candidates.filter((baseline) => normalizeNullableString(baseline.branchName) === null);
+  if (compatible.length === 0) return { status: "none", candidateCount: 0 };
+  if (compatible.length > 1) return { status: "ambiguous", candidateCount: compatible.length };
+  return { status: "found", baseline: compatible[0] };
+}
 async function clearLocalBaseline(params) {
   try {
     await fs2.unlink(getBaselinePath(params));
@@ -1500,6 +1606,7 @@ function resolveLaneLookupProjectId(params) {
   return params.explicitRootProjectId ?? (params.requireRemoteLane ? void 0 : localProjectId ?? params.fallbackProjectId ?? void 0);
 }
 async function persistResolvedLane(repoRoot, binding) {
+  const previousBinding = await readCollabBinding(repoRoot);
   await writeCollabBinding(repoRoot, {
     projectId: binding.projectId,
     currentAppId: binding.currentAppId,
@@ -1512,6 +1619,16 @@ async function persistResolvedLane(repoRoot, binding) {
     branchName: binding.branchName,
     bindingMode: binding.bindingMode
   });
+  if (previousBinding && (previousBinding.laneId ?? null) !== (binding.laneId ?? null)) {
+    await migrateLocalBaselineForLaneChange({
+      repoRoot,
+      repoFingerprint: binding.repoFingerprint,
+      currentAppId: binding.currentAppId,
+      branchName: binding.branchName,
+      fromLaneId: previousBinding.laneId,
+      toLaneId: binding.laneId
+    });
+  }
   return readCollabBinding(repoRoot);
 }
 function buildAmbiguousResolution(params) {
@@ -1911,11 +2028,36 @@ async function collabDetectRepoState(params) {
     return detected;
   }
   try {
-    const baseline = await readLocalBaseline({
+    let baseline = await readLocalBaseline({
       repoFingerprint: binding.repoFingerprint,
       laneId: binding.laneId,
       repoRoot
     });
+    let ambiguousBaselineCandidateCount = null;
+    if (!baseline) {
+      const compatibleBaseline = await findCompatibleLocalBaseline({
+        repoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        laneId: binding.laneId,
+        currentAppId: binding.currentAppId,
+        branchName: binding.branchName
+      });
+      if (compatibleBaseline.status === "found") {
+        baseline = await writeLocalBaseline({
+          ...compatibleBaseline.baseline,
+          repoRoot,
+          repoFingerprint: binding.repoFingerprint,
+          laneId: binding.laneId,
+          currentAppId: binding.currentAppId,
+          branchName: binding.branchName
+        });
+        detected.warnings.push(
+          `Recovered local Remix baseline after lane id changed from ${compatibleBaseline.baseline.laneId ?? "null"} to ${binding.laneId ?? "null"} for app ${binding.currentAppId} on branch ${binding.branchName ?? "(unknown)"}.`
+        );
+      } else if (compatibleBaseline.status === "ambiguous") {
+        ambiguousBaselineCandidateCount = compatibleBaseline.candidateCount;
+      }
+    }
     const hasFullBaseline = Boolean(baseline?.lastSnapshotHash && baseline?.lastServerHeadHash);
     const metadataIdentityPromise = hasFullBaseline ? getAppDeltaCached(params.api, binding.currentAppId, {
       baseHeadHash: baseline.lastServerHeadHash,
@@ -1988,7 +2130,7 @@ async function collabDetectRepoState(params) {
         }
       }
       detected.repoState = "external_local_base_changed";
-      detected.hint = "No local Remix revision baseline exists for this lane yet. Run `remix collab init` or sync this lane to seed the baseline.";
+      detected.hint = ambiguousBaselineCandidateCount !== null ? `No local Remix revision baseline exists for this lane, and multiple compatible local baselines were found (${ambiguousBaselineCandidateCount}). Run \`remix collab status\` or sync this lane to seed an unambiguous baseline.` : "No local Remix revision baseline exists for this lane yet. Run `remix collab init` or sync this lane to seed the baseline.";
       return detected;
     }
     const localHeadMovedSinceBaseline = Boolean(baseline.lastSeenLocalCommitHash) && localCommitHash !== baseline.lastSeenLocalCommitHash;
@@ -2506,6 +2648,7 @@ function buildWorkspaceMetadata(params) {
 
 // src/application/collab/finalizeDecision.ts
 var FINALIZE_AUTO_TERMINAL_THRESHOLD = 5;
+var FINALIZE_AUTO_TERMINAL_TOTAL_RETRY_THRESHOLD = 8;
 function classifyFinalizeError(error) {
   const tagged = error;
   return {
@@ -2518,12 +2661,20 @@ function computeFailureEscalation(job, reason) {
   const previousReason = job.metadata.consecutiveFailureReason;
   const previousCountRaw = job.metadata.consecutiveFailures;
   const previousCount = typeof previousCountRaw === "number" && Number.isFinite(previousCountRaw) && previousCountRaw > 0 ? Math.floor(previousCountRaw) : 0;
+  const previousTotalRaw = job.metadata.totalFailures;
+  const previousTotal = typeof previousTotalRaw === "number" && Number.isFinite(previousTotalRaw) && previousTotalRaw > 0 ? Math.floor(previousTotalRaw) : 0;
   const sameReason = previousReason === reason;
   const next = sameReason ? previousCount + 1 : 1;
+  const totalFailures = previousTotal + 1;
+  const consecutiveTripped = next >= FINALIZE_AUTO_TERMINAL_THRESHOLD;
+  const totalTripped = totalFailures >= FINALIZE_AUTO_TERMINAL_TOTAL_RETRY_THRESHOLD;
+  const escalationTrigger = consecutiveTripped ? "consecutive_same_reason" : totalTripped ? "total_retries" : "none";
   return {
     consecutiveFailures: next,
     consecutiveFailureReason: reason,
-    shouldEscalateToTerminal: next >= FINALIZE_AUTO_TERMINAL_THRESHOLD
+    totalFailures,
+    shouldEscalateToTerminal: consecutiveTripped || totalTripped,
+    escalationTrigger
   };
 }
 function hasFinalizeBaselineDrifted(params) {
@@ -2703,15 +2854,25 @@ async function processClaimedPendingFinalizeJob(params) {
     const classified = classifyFinalizeError(error);
     const escalation = computeFailureEscalation(job, classified.reason);
     const finalDisposition = classified.disposition === "terminal" || escalation.shouldEscalateToTerminal ? "terminal" : "retryable";
+    const autoEscalated = finalDisposition === "terminal" && escalation.shouldEscalateToTerminal && classified.disposition !== "terminal";
+    let escalationSuffix = "";
+    if (autoEscalated) {
+      if (escalation.escalationTrigger === "consecutive_same_reason") {
+        escalationSuffix = ` (auto-escalated to terminal after ${escalation.consecutiveFailures} consecutive ${classified.reason} failures)`;
+      } else if (escalation.escalationTrigger === "total_retries") {
+        escalationSuffix = ` (auto-escalated to terminal after ${escalation.totalFailures} total retries with mixed failure reasons; latest=${classified.reason})`;
+      }
+    }
     await updatePendingFinalizeJob(job.id, {
       status: finalDisposition === "terminal" ? "failed" : "queued",
-      error: finalDisposition === "terminal" && escalation.shouldEscalateToTerminal && classified.disposition !== "terminal" ? `${classified.message} (auto-escalated to terminal after ${escalation.consecutiveFailures} consecutive ${classified.reason} failures)` : classified.message,
+      error: `${classified.message}${escalationSuffix}`,
       nextRetryAt: finalDisposition === "terminal" ? null : buildNextRetryAt(job.retryCount),
       metadata: {
         failureDisposition: finalDisposition,
         failureReason: classified.reason,
         consecutiveFailures: escalation.consecutiveFailures,
-        consecutiveFailureReason: escalation.consecutiveFailureReason
+        consecutiveFailureReason: escalation.consecutiveFailureReason,
+        totalFailures: escalation.totalFailures
       }
     });
     throw error;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { CliError, REMIX_ERROR_CODES, CliError as RemixError, RemixErrorCode } from './errors.js';
 export { CoreConfig, ResolveConfigOptions, configSchema, resolveConfig } from './config.js';
-export { S as SessionStore, a as StoredSession, c as createStoredSessionTokenProvider, s as shouldRefreshSoon, b as storedSessionSchema } from './tokenProvider-BWTusyj4.js';
-export { createLocalSessionStore, createSupabaseAuthHelpers } from './auth.js';
+export { S as SessionStore, a as StoredSession, W as WithRefreshLock, c as createRefreshLock, b as createStoredSessionTokenProvider, s as shouldRefreshSoon, d as storedSessionSchema } from './tokenProvider-B9so5Pm3.js';
+export { createDefaultRefreshLock, createLocalSessionStore, createSupabaseAuthHelpers, defaultSessionFilePath, isInvalidGrantError, isNetworkError } from './auth.js';
 export { AgentMemoryItem, AgentMemoryKind, AgentMemorySearchItem, AgentMemorySearchResponse, AgentMemorySummary, AgentMemoryTimelineResponse, ApiClient, AppContext, AppContextAccessPath, AppPreviewExpectedKind, AppPreviewProcessStatus, AppPreviewQuery, AppPreviewResponse, AppReconcileResponse, AppSandboxCommandRun, Bundle, BundlePlatform, BundleStatus, ChangeStepDiffResponse, DetectProjectRuntimeTargetsPayload, ImportProjectRuntimeEnvPayload, InitiateBundleRequest, InvitationRecord, MergeRequest, MergeRequestReview, MergeRequestStatus, ProjectRuntimeEnvMetadata, ProjectRuntimeEnvScope, ProjectRuntimeTargetMetadata, ProjectRuntimeTargetScope, ProjectTrigger, ProjectTriggerPayload, ProjectTriggerScope, ProjectTriggerStep, ProjectTriggerStepPayload, ReconcilePreflightResponse, ResolveProjectRuntimeEnvForLocalPullResponse, RunAppRuntimeTargetPayload, RunAppSandboxCommandPayload, RunAppTriggerEventPayload, RunAppTriggerPayload, RuntimeCommandKind, RuntimeTargetKind, SetProjectRuntimeEnvPayload, SetProjectRuntimeTargetPayload, SyncLocalResponse, SyncUpstreamResponse, TriggerEventMetadata, TriggerEventSource, TriggerIntegrationStatus, TriggerMode, TriggerRun, TriggerStepRun, TriggerStepType, UpdateProjectTriggerPayload, createApiClient } from './api.js';
 import 'zod';
 import './contracts-WCYiMqwB.js';

package/dist/index.js

@@ -1,13 +1,18 @@
 import {
   createApiClient
-} from "./chunk-DOMO3LNV.js";
+} from "./chunk-KURN7YZ5.js";
 import {
+  createDefaultRefreshLock,
   createLocalSessionStore,
+  createRefreshLock,
   createStoredSessionTokenProvider,
   createSupabaseAuthHelpers,
+  defaultSessionFilePath,
+  isInvalidGrantError,
+  isNetworkError,
   shouldRefreshSoon,
   storedSessionSchema
-} from "./chunk-MAM4CGDF.js";
+} from "./chunk-OMJ4JDME.js";
 import {
   configSchema,
   resolveConfig
@@ -25,9 +30,14 @@ export {
   RemixError,
   configSchema,
   createApiClient,
+  createDefaultRefreshLock,
   createLocalSessionStore,
+  createRefreshLock,
   createStoredSessionTokenProvider,
   createSupabaseAuthHelpers,
+  defaultSessionFilePath,
+  isInvalidGrantError,
+  isNetworkError,
   resolveConfig,
   shouldRefreshSoon,
   storedSessionSchema

package/dist/tokenProvider-B9so5Pm3.d.ts

@@ -0,0 +1,123 @@
+import { CoreConfig } from './config.js';
+import { z } from 'zod';
+
+type RefreshLockOptions = {
+    /** Lock file path. Conventionally `<sessionFile>.lock`. */
+    lockPath: string;
+    /** Treat an existing lock as stale when older than this. */
+    staleMs?: number;
+    /** Give up waiting and proceed without the lock after this. */
+    maxWaitMs?: number;
+    /** Sleep between EEXIST retries while waiting. */
+    pollMs?: number;
+};
+type WithRefreshLock = <T>(fn: () => Promise<T>) => Promise<T>;
+declare function createRefreshLock(opts: RefreshLockOptions): WithRefreshLock;
+
+declare const storedSessionSchema: z.ZodObject<{
+    access_token: z.ZodString;
+    refresh_token: z.ZodString;
+    expires_at: z.ZodNumber;
+    token_type: z.ZodOptional<z.ZodString>;
+    user: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        email: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        email?: string | null | undefined;
+    }, {
+        id: string;
+        email?: string | null | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+    token_type?: string | undefined;
+    user?: {
+        id: string;
+        email?: string | null | undefined;
+    } | undefined;
+}, {
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+    token_type?: string | undefined;
+    user?: {
+        id: string;
+        email?: string | null | undefined;
+    } | undefined;
+}>;
+type StoredSession = z.infer<typeof storedSessionSchema>;
+type SessionStore = {
+    getSession(): Promise<StoredSession | null>;
+    setSession(session: StoredSession): Promise<void>;
+};
+
+type RefreshStoredSession = (params: {
+    config: CoreConfig;
+    session: StoredSession;
+}) => Promise<StoredSession>;
+type ResolvedAuthToken = {
+    token: string;
+    session: StoredSession | null;
+    fromEnv: boolean;
+};
+type TokenProvider = (opts?: {
+    forceRefresh?: boolean;
+}) => Promise<ResolvedAuthToken>;
+declare function shouldRefreshSoon(session: StoredSession, skewSeconds?: number): boolean;
+/**
+ * Token provider that resolves a fresh access token from a stored
+ * Supabase session, refreshing it through `refreshStoredSession` when
+ * the cached token is at/near expiry.
+ *
+ * # Why this code is more careful than it looks
+ *
+ * Supabase rotates refresh tokens: every successful refresh server-
+ * side invalidates the old refresh token and issues a new one. If we
+ * lose the new token before persisting it (network drop after the
+ * server processed our request; multiple processes refreshing the
+ * same session in parallel; a `getUser` call after refresh that
+ * fails) the session is permanently dead even though the user did
+ * nothing wrong. Real-world incident: a laptop coming out of sleep
+ * during the 60-second drainer interval lost the rotated token and
+ * appeared as a "silent logout" to the user.
+ *
+ * Three properties protect against this:
+ *
+ *   1. **Single-flight via `withRefreshLock`** — at most one refresh
+ *      runs at a time across the whole machine (lock file shared
+ *      between CLI, desktop, MCP). Inside the lock we re-read the
+ *      session so we don't double-refresh if another process beat us
+ *      to it.
+ *
+ *   2. **Persist-before-return** — `refreshStoredSession` returns the
+ *      new pair, we write it to disk via `setSession`, and only
+ *      THEN return to the caller. If the write fails we throw and
+ *      the caller will retry rather than acting on a token we
+ *      couldn't durably store.
+ *
+ *   3. **Network-vs-auth error classification** — `fetch failed`
+ *      keeps the existing session (the refresh may or may not have
+ *      landed server-side; we'll find out on the next attempt, ideally
+ *      within Supabase's reuse interval). Only `invalid_grant` /
+ *      "refresh token not found" clears state and surfaces a clean
+ *      sign-in prompt — by then the token is definitively dead and
+ *      retrying won't help.
+ */
+declare function createStoredSessionTokenProvider(params: {
+    config: CoreConfig;
+    sessionStore: SessionStore;
+    refreshStoredSession: RefreshStoredSession;
+    /**
+     * Optional cross-process lock around the refresh-and-persist step.
+     * Omitting this is safe for tests and single-process scenarios; in
+     * production every caller should provide one bound to the session
+     * file's `.lock` sibling so concurrent CLI / desktop / plugin
+     * processes serialize correctly.
+     */
+    withRefreshLock?: WithRefreshLock;
+}): TokenProvider;
+
+export { type RefreshLockOptions as R, type SessionStore as S, type TokenProvider as T, type WithRefreshLock as W, type StoredSession as a, createStoredSessionTokenProvider as b, createRefreshLock as c, storedSessionSchema as d, type RefreshStoredSession as e, type ResolvedAuthToken as f, shouldRefreshSoon as s };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remixhq/core",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "description": "Remix core library",
   "homepage": "https://github.com/RemixDotOne/remix-core",
   "license": "MIT",

package/dist/tokenProvider-BWTusyj4.d.ts

@@ -1,63 +0,0 @@
-import { CoreConfig } from './config.js';
-import { z } from 'zod';
-
-declare const storedSessionSchema: z.ZodObject<{
-    access_token: z.ZodString;
-    refresh_token: z.ZodString;
-    expires_at: z.ZodNumber;
-    token_type: z.ZodOptional<z.ZodString>;
-    user: z.ZodOptional<z.ZodObject<{
-        id: z.ZodString;
-        email: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        email?: string | null | undefined;
-    }, {
-        id: string;
-        email?: string | null | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    access_token: string;
-    refresh_token: string;
-    expires_at: number;
-    token_type?: string | undefined;
-    user?: {
-        id: string;
-        email?: string | null | undefined;
-    } | undefined;
-}, {
-    access_token: string;
-    refresh_token: string;
-    expires_at: number;
-    token_type?: string | undefined;
-    user?: {
-        id: string;
-        email?: string | null | undefined;
-    } | undefined;
-}>;
-type StoredSession = z.infer<typeof storedSessionSchema>;
-type SessionStore = {
-    getSession(): Promise<StoredSession | null>;
-    setSession(session: StoredSession): Promise<void>;
-};
-
-type RefreshStoredSession = (params: {
-    config: CoreConfig;
-    session: StoredSession;
-}) => Promise<StoredSession>;
-type ResolvedAuthToken = {
-    token: string;
-    session: StoredSession | null;
-    fromEnv: boolean;
-};
-type TokenProvider = (opts?: {
-    forceRefresh?: boolean;
-}) => Promise<ResolvedAuthToken>;
-declare function shouldRefreshSoon(session: StoredSession, skewSeconds?: number): boolean;
-declare function createStoredSessionTokenProvider(params: {
-    config: CoreConfig;
-    sessionStore: SessionStore;
-    refreshStoredSession: RefreshStoredSession;
-}): TokenProvider;
-
-export { type RefreshStoredSession as R, type SessionStore as S, type TokenProvider as T, type StoredSession as a, storedSessionSchema as b, createStoredSessionTokenProvider as c, type ResolvedAuthToken as d, shouldRefreshSoon as s };