@remixhq/claude-plugin 0.1.18 → 0.1.19

package/dist/hook-stop-collab.cjs

@@ -37,8 +37,8 @@ var require_windows = __commonJS({
     "use strict";
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs8 = require("fs");
-    function checkPathExt(path12, options) {
+    var fs10 = require("fs");
+    function checkPathExt(path13, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
         return true;
@@ -49,25 +49,25 @@ var require_windows = __commonJS({
       }
       for (var i2 = 0; i2 < pathext.length; i2++) {
         var p = pathext[i2].toLowerCase();
-        if (p && path12.substr(-p.length).toLowerCase() === p) {
+        if (p && path13.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat, path12, options) {
+    function checkStat(stat, path13, options) {
       if (!stat.isSymbolicLink() && !stat.isFile()) {
         return false;
       }
-      return checkPathExt(path12, options);
+      return checkPathExt(path13, options);
     }
-    function isexe(path12, options, cb) {
-      fs8.stat(path12, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path12, options));
+    function isexe(path13, options, cb) {
+      fs10.stat(path13, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path13, options));
       });
     }
-    function sync(path12, options) {
-      return checkStat(fs8.statSync(path12), path12, options);
+    function sync(path13, options) {
+      return checkStat(fs10.statSync(path13), path13, options);
     }
   }
 });
@@ -78,14 +78,14 @@ var require_mode = __commonJS({
     "use strict";
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs8 = require("fs");
-    function isexe(path12, options, cb) {
-      fs8.stat(path12, function(er, stat) {
+    var fs10 = require("fs");
+    function isexe(path13, options, cb) {
+      fs10.stat(path13, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
-    function sync(path12, options) {
-      return checkStat(fs8.statSync(path12), options);
+    function sync(path13, options) {
+      return checkStat(fs10.statSync(path13), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -110,7 +110,7 @@ var require_mode = __commonJS({
 var require_isexe = __commonJS({
   "node_modules/isexe/index.js"(exports2, module2) {
     "use strict";
-    var fs8 = require("fs");
+    var fs10 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -119,7 +119,7 @@ var require_isexe = __commonJS({
     }
     module2.exports = isexe;
     isexe.sync = sync;
-    function isexe(path12, options, cb) {
+    function isexe(path13, options, cb) {
       if (typeof options === "function") {
         cb = options;
         options = {};
@@ -129,7 +129,7 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve, reject) {
-          isexe(path12, options || {}, function(er, is) {
+          isexe(path13, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -138,7 +138,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path12, options || {}, function(er, is) {
+      core(path13, options || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options && options.ignoreErrors) {
             er = null;
@@ -148,9 +148,9 @@ var require_isexe = __commonJS({
         cb(er, is);
       });
     }
-    function sync(path12, options) {
+    function sync(path13, options) {
       try {
-        return core.sync(path12, options || {});
+        return core.sync(path13, options || {});
       } catch (er) {
         if (options && options.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -167,7 +167,7 @@ var require_which = __commonJS({
   "node_modules/which/which.js"(exports2, module2) {
     "use strict";
     var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-    var path12 = require("path");
+    var path13 = require("path");
     var COLON = isWindows ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -205,7 +205,7 @@ var require_which = __commonJS({
           return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i2];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path12.join(pathPart, cmd);
+        const pCmd = path13.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         resolve(subStep(p, i2, 0));
       });
@@ -232,7 +232,7 @@ var require_which = __commonJS({
       for (let i2 = 0; i2 < pathEnv.length; i2++) {
         const ppRaw = pathEnv[i2];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path12.join(pathPart, cmd);
+        const pCmd = path13.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         for (let j = 0; j < pathExt.length; j++) {
           const cur = p + pathExt[j];
@@ -280,7 +280,7 @@ var require_path_key = __commonJS({
 var require_resolveCommand = __commonJS({
   "node_modules/cross-spawn/lib/util/resolveCommand.js"(exports2, module2) {
     "use strict";
-    var path12 = require("path");
+    var path13 = require("path");
     var which = require_which();
     var getPathKey = require_path_key();
     function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -298,7 +298,7 @@ var require_resolveCommand = __commonJS({
       try {
         resolved = which.sync(parsed.command, {
           path: env[getPathKey({ env })],
-          pathExt: withoutPathExt ? path12.delimiter : void 0
+          pathExt: withoutPathExt ? path13.delimiter : void 0
         });
       } catch (e) {
       } finally {
@@ -307,7 +307,7 @@ var require_resolveCommand = __commonJS({
         }
       }
       if (resolved) {
-        resolved = path12.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+        resolved = path13.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
       }
       return resolved;
     }
@@ -361,8 +361,8 @@ var require_shebang_command = __commonJS({
       if (!match) {
         return null;
       }
-      const [path12, argument] = match[0].replace(/#! ?/, "").split(" ");
-      const binary = path12.split("/").pop();
+      const [path13, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path13.split("/").pop();
       if (binary === "env") {
         return argument;
       }
@@ -375,16 +375,16 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "node_modules/cross-spawn/lib/util/readShebang.js"(exports2, module2) {
     "use strict";
-    var fs8 = require("fs");
+    var fs10 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
       const buffer = Buffer.alloc(size);
       let fd;
       try {
-        fd = fs8.openSync(command, "r");
-        fs8.readSync(fd, buffer, 0, size, 0);
-        fs8.closeSync(fd);
+        fd = fs10.openSync(command, "r");
+        fs10.readSync(fd, buffer, 0, size, 0);
+        fs10.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -397,7 +397,7 @@ var require_readShebang = __commonJS({
 var require_parse = __commonJS({
   "node_modules/cross-spawn/lib/parse.js"(exports2, module2) {
     "use strict";
-    var path12 = require("path");
+    var path13 = require("path");
     var resolveCommand = require_resolveCommand();
     var escape = require_escape();
     var readShebang = require_readShebang();
@@ -422,7 +422,7 @@ var require_parse = __commonJS({
       const needsShell = !isExecutableRegExp.test(commandFile);
       if (parsed.options.forceShell || needsShell) {
         const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-        parsed.command = path12.normalize(parsed.command);
+        parsed.command = path13.normalize(parsed.command);
         parsed.command = escape.command(parsed.command);
         parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
         const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -518,7 +518,7 @@ var require_cross_spawn = __commonJS({
       enoent.hookChildProcess(spawned, parsed);
       return spawned;
     }
-    function spawnSync2(command, args, options) {
+    function spawnSync3(command, args, options) {
       const parsed = parse(command, args, options);
       const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
@@ -526,7 +526,7 @@ var require_cross_spawn = __commonJS({
     }
     module2.exports = spawn3;
     module2.exports.spawn = spawn3;
-    module2.exports.sync = spawnSync2;
+    module2.exports.sync = spawnSync3;
     module2.exports._parse = parse;
     module2.exports._enoent = enoent;
   }
@@ -538,7 +538,9 @@ __export(hook_stop_collab_exports, {
   runHookStopCollab: () => runHookStopCollab
 });
 module.exports = __toCommonJS(hook_stop_collab_exports);
-var import_node_child_process6 = require("child_process");
+var import_node_child_process7 = require("child_process");
+var import_node_fs7 = require("fs");
+var import_node_path10 = __toESM(require("path"), 1);
 
 // node_modules/@remixhq/core/dist/chunk-YZ34ICNN.js
 var RemixError = class extends Error {
@@ -4935,13 +4937,13 @@ var logOutputSync = ({ serializedResult, fdNumber, state, verboseInfo, encoding,
   }
 };
 var writeToFiles = (serializedResult, stdioItems, outputFiles) => {
-  for (const { path: path12, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
-    const pathString = typeof path12 === "string" ? path12 : path12.toString();
+  for (const { path: path13, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
+    const pathString = typeof path13 === "string" ? path13 : path13.toString();
     if (append || outputFiles.has(pathString)) {
-      (0, import_node_fs4.appendFileSync)(path12, serializedResult);
+      (0, import_node_fs4.appendFileSync)(path13, serializedResult);
     } else {
       outputFiles.add(pathString);
-      (0, import_node_fs4.writeFileSync)(path12, serializedResult);
+      (0, import_node_fs4.writeFileSync)(path13, serializedResult);
     }
   }
 };
@@ -7662,18 +7664,84 @@ async function writeCollabBinding(repoRoot, binding) {
 
 // node_modules/@remixhq/core/dist/collab.js
 var import_promises14 = __toESM(require("fs/promises"), 1);
-var import_path3 = __toESM(require("path"), 1);
 var import_crypto = require("crypto");
 var import_os = __toESM(require("os"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var import_promises15 = __toESM(require("fs/promises"), 1);
 var import_path4 = __toESM(require("path"), 1);
 var import_crypto2 = require("crypto");
-var import_promises15 = __toESM(require("fs/promises"), 1);
+var import_promises16 = __toESM(require("fs/promises"), 1);
 var import_os2 = __toESM(require("os"), 1);
 var import_path5 = __toESM(require("path"), 1);
 var import_crypto3 = require("crypto");
-var import_promises16 = __toESM(require("fs/promises"), 1);
+var import_promises17 = __toESM(require("fs/promises"), 1);
 var import_path6 = __toESM(require("path"), 1);
 var import_crypto4 = require("crypto");
+var APP_DELTA_CACHE_TTL_MS = 5e3;
+var appDeltaCache = /* @__PURE__ */ new Map();
+var cacheClock = () => Date.now();
+function buildAppDeltaCacheKey(appId, payload) {
+  return [
+    appId,
+    payload.baseHeadHash,
+    payload.targetHeadHash ?? "",
+    payload.localSnapshotHash ?? "",
+    payload.repoFingerprint ?? "",
+    payload.remoteUrl ?? "",
+    payload.defaultBranch ?? ""
+  ].join("|");
+}
+function readAppDeltaCache(key) {
+  const entry = appDeltaCache.get(key);
+  if (!entry) return void 0;
+  if (cacheClock() - entry.cachedAt > APP_DELTA_CACHE_TTL_MS) {
+    appDeltaCache.delete(key);
+    return void 0;
+  }
+  return entry.value;
+}
+function writeAppDeltaCache(key, value) {
+  appDeltaCache.set(key, { value, cachedAt: cacheClock() });
+}
+async function getAppDeltaCached(api, appId, payload) {
+  const key = buildAppDeltaCacheKey(appId, payload);
+  const cached = readAppDeltaCache(key);
+  if (cached !== void 0) return cached;
+  const fresh = await api.getAppDelta(appId, payload);
+  writeAppDeltaCache(key, fresh);
+  return fresh;
+}
+function invalidateAppDeltaCacheForApp(appId) {
+  const prefix = `${appId}|`;
+  for (const key of appDeltaCache.keys()) {
+    if (key.startsWith(prefix)) appDeltaCache.delete(key);
+  }
+}
+var APP_HEAD_CACHE_TTL_MS = 5e3;
+var appHeadCache = /* @__PURE__ */ new Map();
+var cacheClock2 = () => Date.now();
+function readAppHeadCache(appId) {
+  const entry = appHeadCache.get(appId);
+  if (!entry) return void 0;
+  if (cacheClock2() - entry.cachedAt > APP_HEAD_CACHE_TTL_MS) {
+    appHeadCache.delete(appId);
+    return void 0;
+  }
+  return entry.value;
+}
+function writeAppHeadCache(appId, value) {
+  appHeadCache.set(appId, { value, cachedAt: cacheClock2() });
+}
+async function getAppHeadCached(api, appId) {
+  const cached = readAppHeadCache(appId);
+  if (cached !== void 0) return cached;
+  const fresh = await api.getAppHead(appId);
+  writeAppHeadCache(appId, fresh);
+  return fresh;
+}
+function invalidateAppHeadCache(appId) {
+  appHeadCache.delete(appId);
+}
 function describeBranch(value) {
   const normalized = String(value ?? "").trim();
   return normalized || "(detached)";
@@ -7697,7 +7765,7 @@ function sha256Hex(value) {
 }
 function getCollabStateRoot() {
   const configured = process.env.REMIX_COLLAB_STATE_ROOT?.trim();
-  return configured || import_path4.default.join(import_os.default.homedir(), ".remix", "collab-state");
+  return configured || import_path3.default.join(import_os.default.homedir(), ".remix", "collab-state");
 }
 function buildLaneStateKey(params) {
   const fingerprint = params.repoFingerprint?.trim();
@@ -7709,26 +7777,158 @@ function buildLaneStateKey(params) {
   return sha256Hex(`${stableSource}::${fingerprintSource}::${laneSource}`);
 }
 function getSnapshotsRoot() {
-  return import_path4.default.join(getCollabStateRoot(), "snapshots");
+  return import_path3.default.join(getCollabStateRoot(), "snapshots");
 }
 function getSnapshotRecordsRoot() {
-  return import_path4.default.join(getSnapshotsRoot(), "records");
+  return import_path3.default.join(getSnapshotsRoot(), "records");
 }
 function getSnapshotBlobsRoot() {
-  return import_path4.default.join(getSnapshotsRoot(), "blobs");
+  return import_path3.default.join(getSnapshotsRoot(), "blobs");
 }
 function getBaselinesRoot() {
-  return import_path4.default.join(getCollabStateRoot(), "baselines");
+  return import_path3.default.join(getCollabStateRoot(), "baselines");
 }
 function getFinalizeQueueRoot() {
-  return import_path4.default.join(getCollabStateRoot(), "finalize-queue");
+  return import_path3.default.join(getCollabStateRoot(), "finalize-queue");
+}
+function getAsyncJobsRoot() {
+  return import_path3.default.join(getCollabStateRoot(), "jobs");
+}
+function getAsyncJobDir(jobId) {
+  return import_path3.default.join(getAsyncJobsRoot(), jobId);
+}
+function getAsyncJobFilePath(jobId) {
+  return import_path3.default.join(getAsyncJobDir(jobId), "job.json");
+}
+var ASYNC_JOB_LOCK_STALE_MS = 10 * 60 * 1e3;
+var TERMINAL_ASYNC_JOB_RETENTION_MS = 24 * 60 * 60 * 1e3;
+function isTerminalStatus(status) {
+  return status === "completed" || status === "failed";
+}
+function isProcessingStatus(status) {
+  return status === "submitting" || status === "uploading" || status === "server_processing";
+}
+function createEmptySummary() {
+  return {
+    state: "idle",
+    activeJobCount: 0,
+    queuedJobCount: 0,
+    processingJobCount: 0,
+    failedJobCount: 0,
+    oldestCreatedAt: null,
+    newestCreatedAt: null,
+    latestError: null,
+    kinds: []
+  };
+}
+function parseAsyncJob(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const data = raw;
+  if (data.schemaVersion !== 1) return null;
+  if (typeof data.id !== "string") return null;
+  if (data.kind !== "init" && data.kind !== "init_post" && data.kind !== "re_anchor") return null;
+  if (!data.payload || typeof data.payload !== "object") return null;
+  return data;
+}
+async function readAsyncJob(jobId) {
+  try {
+    const raw = await import_promises14.default.readFile(getAsyncJobFilePath(jobId), "utf8");
+    const parsed = JSON.parse(raw);
+    return parseAsyncJob(parsed);
+  } catch {
+    return null;
+  }
+}
+async function listAsyncJobs() {
+  const root = getAsyncJobsRoot();
+  let entries;
+  try {
+    entries = await import_promises14.default.readdir(root, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === "ENOENT") return [];
+    throw error;
+  }
+  const jobs = await Promise.all(
+    entries.filter((entry) => entry.isDirectory()).map((entry) => readAsyncJob(entry.name))
+  );
+  return jobs.filter((job) => Boolean(job)).sort((a2, b) => a2.createdAt.localeCompare(b.createdAt));
+}
+async function listAsyncJobsForRepo(params) {
+  const jobs = await listAsyncJobs();
+  return jobs.filter((job) => {
+    if (job.repoRoot !== params.repoRoot) return false;
+    if (params.branchName && job.branchName && job.branchName !== params.branchName) return false;
+    if (params.kind && job.kind !== params.kind) return false;
+    return true;
+  });
+}
+async function findPendingAsyncJob(params) {
+  const jobs = await listAsyncJobsForRepo({
+    repoRoot: params.repoRoot,
+    branchName: params.branchName,
+    kind: params.kind
+  });
+  return jobs.find((job) => !isTerminalStatus(job.status)) ?? null;
+}
+async function summarizeAsyncJobs(params) {
+  const jobs = await listAsyncJobsForRepo({ repoRoot: params.repoRoot, branchName: params.branchName ?? null });
+  const active = jobs.filter((job) => !isTerminalStatus(job.status) || job.status === "failed");
+  const summary = createEmptySummary();
+  if (active.length === 0) return summary;
+  const kinds = /* @__PURE__ */ new Set();
+  for (const job of active) {
+    kinds.add(job.kind);
+    if (job.error) summary.latestError = job.error;
+    if (job.status === "failed") {
+      summary.failedJobCount += 1;
+    } else if (isProcessingStatus(job.status)) {
+      summary.processingJobCount += 1;
+    } else {
+      summary.queuedJobCount += 1;
+    }
+  }
+  summary.activeJobCount = summary.queuedJobCount + summary.processingJobCount;
+  summary.kinds = Array.from(kinds);
+  summary.oldestCreatedAt = active[0]?.createdAt ?? null;
+  summary.newestCreatedAt = active[active.length - 1]?.createdAt ?? null;
+  if (summary.processingJobCount > 0) summary.state = "processing";
+  else if (summary.queuedJobCount > 0) summary.state = "queued";
+  else if (summary.failedJobCount > 0) summary.state = "failed";
+  return summary;
+}
+async function awaitAsyncJob(params) {
+  const pollIntervalMs = Math.max(50, params.pollIntervalMs ?? 500);
+  const deadline = Date.now() + params.timeoutMs;
+  let lastSeen = null;
+  while (Date.now() < deadline) {
+    const job = await readAsyncJob(params.jobId);
+    if (job) {
+      lastSeen = job;
+      if (job.status === "completed") return { status: "completed", job };
+      if (job.status === "failed") return { status: "failed", job };
+    } else if (lastSeen) {
+      return { status: "timeout", job: lastSeen };
+    } else {
+      return { status: "timeout", job: null };
+    }
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) break;
+    await new Promise((resolve) => setTimeout(resolve, Math.min(pollIntervalMs, remaining)));
+  }
+  const final = await readAsyncJob(params.jobId);
+  if (final) {
+    if (final.status === "completed") return { status: "completed", job: final };
+    if (final.status === "failed") return { status: "failed", job: final };
+    return { status: "timeout", job: final };
+  }
+  return { status: "timeout", job: lastSeen };
 }
 function getBaselinePath(params) {
-  return import_path3.default.join(getBaselinesRoot(), `${buildLaneStateKey(params)}.json`);
+  return import_path4.default.join(getBaselinesRoot(), `${buildLaneStateKey(params)}.json`);
 }
 async function readLocalBaseline(params) {
   try {
-    const raw = await import_promises14.default.readFile(getBaselinePath(params), "utf8");
+    const raw = await import_promises15.default.readFile(getBaselinePath(params), "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") return null;
     if (parsed.schemaVersion !== 1 || typeof parsed.key !== "string" || typeof parsed.repoRoot !== "string") {
@@ -7797,7 +7997,7 @@ async function listWorkspaceFiles(repoRoot) {
     if (!relativePath || seen.has(relativePath)) continue;
     const absolutePath = import_path5.default.join(repoRoot, relativePath);
     try {
-      const stat = await import_promises15.default.lstat(absolutePath);
+      const stat = await import_promises16.default.lstat(absolutePath);
       if (stat.isFile() || stat.isSymbolicLink()) {
         seen.add(relativePath);
         result.push(relativePath);
@@ -7810,13 +8010,13 @@ async function listWorkspaceFiles(repoRoot) {
 async function persistBlob(blobHash, content) {
   const blobPath = getBlobPath(blobHash);
   try {
-    await import_promises15.default.access(blobPath);
+    await import_promises16.default.access(blobPath);
   } catch {
-    await import_promises15.default.mkdir(import_path5.default.dirname(blobPath), { recursive: true });
+    await import_promises16.default.mkdir(import_path5.default.dirname(blobPath), { recursive: true });
     if (typeof content === "string") {
-      await import_promises15.default.writeFile(blobPath, content, "utf8");
+      await import_promises16.default.writeFile(blobPath, content, "utf8");
     } else {
-      await import_promises15.default.writeFile(blobPath, content);
+      await import_promises16.default.writeFile(blobPath, content);
     }
   }
 }
@@ -7830,9 +8030,9 @@ async function inspectLocalSnapshot(params) {
   const manifest = [];
   for (const relativePath of files) {
     const absolutePath = import_path5.default.join(repoRoot, relativePath);
-    const stat = await import_promises15.default.lstat(absolutePath);
+    const stat = await import_promises16.default.lstat(absolutePath);
     if (stat.isSymbolicLink()) {
-      const linkTarget = await import_promises15.default.readlink(absolutePath);
+      const linkTarget = await import_promises16.default.readlink(absolutePath);
       const blobHash2 = sha256Hex2(`symlink:${linkTarget}`);
       if (params.persistBlobs !== false) {
         await persistBlob(blobHash2, linkTarget);
@@ -7845,7 +8045,7 @@ async function inspectLocalSnapshot(params) {
       });
       continue;
     }
-    const content = await import_promises15.default.readFile(absolutePath);
+    const content = await import_promises16.default.readFile(absolutePath);
     const blobHash = sha256Hex2(content);
     if (params.persistBlobs !== false) {
       await persistBlob(blobHash, content);
@@ -7882,7 +8082,7 @@ async function captureLocalSnapshot(params) {
 async function readLocalSnapshot(snapshotId) {
   if (!snapshotId) return null;
   try {
-    const raw = await import_promises15.default.readFile(getSnapshotRecordPath(snapshotId), "utf8");
+    const raw = await import_promises16.default.readFile(getSnapshotRecordPath(snapshotId), "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || parsed.schemaVersion !== 1) return null;
     return parsed;
@@ -7892,34 +8092,34 @@ async function readLocalSnapshot(snapshotId) {
 }
 async function materializeLocalSnapshot(snapshotId, targetDir) {
   const snapshot = await readLocalSnapshot(snapshotId);
-  await import_promises15.default.mkdir(targetDir, { recursive: true });
+  await import_promises16.default.mkdir(targetDir, { recursive: true });
   if (!snapshot) return;
   for (const entry of snapshot.files) {
     const destination = import_path5.default.join(targetDir, entry.path);
-    await import_promises15.default.mkdir(import_path5.default.dirname(destination), { recursive: true });
+    await import_promises16.default.mkdir(import_path5.default.dirname(destination), { recursive: true });
     const blobPath = getBlobPath(entry.blobHash);
     if (entry.mode === "symlink") {
-      const linkTarget = await import_promises15.default.readFile(blobPath, "utf8");
-      await import_promises15.default.symlink(linkTarget, destination);
+      const linkTarget = await import_promises16.default.readFile(blobPath, "utf8");
+      await import_promises16.default.symlink(linkTarget, destination);
       continue;
     }
-    await import_promises15.default.copyFile(blobPath, destination);
+    await import_promises16.default.copyFile(blobPath, destination);
     if (entry.mode === "executable") {
-      await import_promises15.default.chmod(destination, 493);
+      await import_promises16.default.chmod(destination, 493);
     }
   }
 }
 async function clearDirectoryExceptGit(targetDir) {
-  const entries = await import_promises15.default.readdir(targetDir, { withFileTypes: true });
+  const entries = await import_promises16.default.readdir(targetDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".git") continue;
-    await import_promises15.default.rm(import_path5.default.join(targetDir, entry.name), { recursive: true, force: true });
+    await import_promises16.default.rm(import_path5.default.join(targetDir, entry.name), { recursive: true, force: true });
   }
 }
 async function diffLocalSnapshots(params) {
-  const tempRoot = await import_promises15.default.mkdtemp(import_path5.default.join(import_os2.default.tmpdir(), "remix-snapshot-diff-"));
+  const tempRoot = await import_promises16.default.mkdtemp(import_path5.default.join(import_os2.default.tmpdir(), "remix-snapshot-diff-"));
   const repoDir = import_path5.default.join(tempRoot, "repo");
-  await import_promises15.default.mkdir(repoDir, { recursive: true });
+  await import_promises16.default.mkdir(repoDir, { recursive: true });
   try {
     await materializeLocalSnapshot(params.baseSnapshotId, repoDir);
     await execa("git", ["init"], { cwd: repoDir, stderr: "ignore" });
@@ -7955,15 +8155,16 @@ async function diffLocalSnapshots(params) {
       stats: summarizeUnifiedDiff(diff)
     };
   } finally {
-    await import_promises15.default.rm(tempRoot, { recursive: true, force: true });
+    await import_promises16.default.rm(tempRoot, { recursive: true, force: true });
   }
 }
-var FINALIZE_JOB_LOCK_STALE_MS = 10 * 60 * 1e3;
+var FINALIZE_JOB_LOCK_STALE_MS = 90 * 1e3;
+var FINALIZE_ATTEMPT_STALE_MS = 10 * 60 * 1e3;
 var TERMINAL_FINALIZE_JOB_RETENTION_MS = 24 * 60 * 60 * 1e3;
 function getJobPath(id) {
   return import_path6.default.join(getFinalizeQueueRoot(), `${id}.json`);
 }
-function getJobLockPath(id) {
+function getJobLockPath2(id) {
   return import_path6.default.join(getFinalizeQueueRoot(), `${id}.lock`);
 }
 function isPastDue(isoTimestamp) {
@@ -7976,7 +8177,7 @@ function isStaleAttempt(job) {
   if (!job.lastAttemptAt) return true;
   const parsed = Date.parse(job.lastAttemptAt);
   if (!Number.isFinite(parsed)) return true;
-  return Date.now() - parsed >= FINALIZE_JOB_LOCK_STALE_MS;
+  return Date.now() - parsed >= FINALIZE_ATTEMPT_STALE_MS;
 }
 function readMetadataDisposition(job) {
   const value = job.metadata.failureDisposition;
@@ -8005,6 +8206,7 @@ function createEmptyPendingFinalizeQueueSummary() {
     queuedJobCount: 0,
     processingJobCount: 0,
     retryScheduledJobCount: 0,
+    awaitingUsageJobCount: 0,
     failedJobCount: 0,
     oldestCapturedAt: null,
     newestCapturedAt: null,
@@ -8012,10 +8214,10 @@ function createEmptyPendingFinalizeQueueSummary() {
     latestError: null
   };
 }
-async function acquireJobLock(jobId) {
-  const lockPath = getJobLockPath(jobId);
+async function acquireJobLock2(jobId) {
+  const lockPath = getJobLockPath2(jobId);
   try {
-    await import_promises16.default.mkdir(lockPath);
+    await import_promises17.default.mkdir(lockPath);
     return true;
   } catch (error) {
     if (error?.code !== "EEXIST") {
@@ -8023,18 +8225,18 @@ async function acquireJobLock(jobId) {
     }
   }
   try {
-    const stat = await import_promises16.default.stat(lockPath);
+    const stat = await import_promises17.default.stat(lockPath);
     if (Date.now() - stat.mtimeMs < FINALIZE_JOB_LOCK_STALE_MS) {
       return false;
     }
-    await import_promises16.default.rm(lockPath, { recursive: true, force: true });
+    await import_promises17.default.rm(lockPath, { recursive: true, force: true });
   } catch (error) {
     if (error?.code !== "ENOENT") {
       throw error;
     }
   }
   try {
-    await import_promises16.default.mkdir(lockPath);
+    await import_promises17.default.mkdir(lockPath);
     return true;
   } catch (error) {
     if (error?.code === "EEXIST") {
@@ -8043,7 +8245,15 @@ async function acquireJobLock(jobId) {
     throw error;
   }
 }
-function normalizeJob(input) {
+async function heartbeatJobLock(jobId) {
+  const lockPath = getJobLockPath2(jobId);
+  const now = /* @__PURE__ */ new Date();
+  try {
+    await import_promises17.default.utimes(lockPath, now, now);
+  } catch {
+  }
+}
+function normalizeJob2(input) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
     schemaVersion: 1,
@@ -8071,16 +8281,16 @@ function normalizeJob(input) {
   };
 }
 async function enqueuePendingFinalizeJob(input) {
-  const job = normalizeJob(input);
+  const job = normalizeJob2(input);
   await writeJsonAtomic(getJobPath(job.id), job);
   return job;
 }
 async function readPendingFinalizeJob(jobId) {
   try {
-    const raw = await import_promises16.default.readFile(getJobPath(jobId), "utf8");
+    const raw = await import_promises17.default.readFile(getJobPath(jobId), "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || parsed.schemaVersion !== 1 || typeof parsed.id !== "string") return null;
-    return normalizeJob({
+    return normalizeJob2({
       id: parsed.id,
       status: parsed.status ?? "queued",
       repoRoot: String(parsed.repoRoot ?? ""),
@@ -8109,7 +8319,7 @@ async function readPendingFinalizeJob(jobId) {
 }
 async function listPendingFinalizeJobs() {
   try {
-    const entries = await import_promises16.default.readdir(getFinalizeQueueRoot(), { withFileTypes: true });
+    const entries = await import_promises17.default.readdir(getFinalizeQueueRoot(), { withFileTypes: true });
     const jobs = await Promise.all(
       entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => readPendingFinalizeJob(entry.name.replace(/\.json$/, "")))
     );
@@ -8150,18 +8360,24 @@ async function summarizePendingFinalizeJobs(scope) {
       continue;
     }
     if (!isPastDue(job.nextRetryAt)) {
-      summary.retryScheduledJobCount += 1;
+      if (job.retryCount === 0 && !job.error) {
+        summary.awaitingUsageJobCount += 1;
+      } else {
+        summary.retryScheduledJobCount += 1;
+      }
       continue;
     }
     summary.queuedJobCount += 1;
   }
-  summary.activeJobCount = summary.queuedJobCount + summary.processingJobCount + summary.retryScheduledJobCount;
+  summary.activeJobCount = summary.queuedJobCount + summary.processingJobCount + summary.retryScheduledJobCount + summary.awaitingUsageJobCount;
   if (summary.processingJobCount > 0) {
     summary.state = "processing";
   } else if (summary.queuedJobCount > 0) {
     summary.state = "queued";
   } else if (summary.retryScheduledJobCount > 0) {
     summary.state = "retry_scheduled";
+  } else if (summary.awaitingUsageJobCount > 0) {
+    summary.state = "awaiting_usage";
   } else if (summary.failedJobCount > 0) {
     summary.state = "failed";
   }
@@ -8183,14 +8399,14 @@ async function updatePendingFinalizeJob(jobId, update) {
   return next;
 }
 async function claimPendingFinalizeJob(jobId) {
-  const lockPath = getJobLockPath(jobId);
-  const lockAcquired = await acquireJobLock(jobId);
+  const lockPath = getJobLockPath2(jobId);
+  const lockAcquired = await acquireJobLock2(jobId);
   if (!lockAcquired) return null;
   let released = false;
   const release = async () => {
     if (released) return;
     released = true;
-    await import_promises16.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+    await import_promises17.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
   };
   try {
     let existing = await readPendingFinalizeJob(jobId);
@@ -8241,13 +8457,13 @@ async function claimPendingFinalizeJob(jobId) {
 }
 async function removePendingFinalizeJob(jobId) {
   try {
-    await import_promises16.default.unlink(getJobPath(jobId));
+    await import_promises17.default.unlink(getJobPath(jobId));
   } catch (error) {
     if (error?.code !== "ENOENT") {
       throw error;
     }
   }
-  await import_promises16.default.rm(getJobLockPath(jobId), { recursive: true, force: true }).catch(() => void 0);
+  await import_promises17.default.rm(getJobLockPath2(jobId), { recursive: true, force: true }).catch(() => void 0);
 }
 function unwrapResponseObject(resp, label) {
   const obj = resp?.responseObject;
@@ -8375,8 +8591,39 @@ function buildAmbiguousResolution(params) {
     defaultBranch: params.lane.defaultBranch ?? params.state.defaultBranch
   };
 }
+var RESOLUTION_CACHE_TTL_MS = 5e3;
+var resolutionCache = /* @__PURE__ */ new Map();
+var cacheClock3 = () => Date.now();
+function buildResolutionCacheKey(params) {
+  return `${params.repoRoot}|${params.currentBranch ?? ""}|${params.hasApi ? "1" : "0"}`;
+}
+function readResolutionCache(key) {
+  const entry = resolutionCache.get(key);
+  if (!entry) return null;
+  if (cacheClock3() - entry.cachedAt > RESOLUTION_CACHE_TTL_MS) {
+    resolutionCache.delete(key);
+    return null;
+  }
+  return entry.resolution;
+}
+function writeResolutionCache(key, resolution) {
+  if (resolution.status !== "resolved") return;
+  resolutionCache.set(key, { resolution, cachedAt: cacheClock3() });
+}
 async function resolveActiveLaneBinding(params) {
   const state = await readCollabBindingState(params.repoRoot);
+  const cacheKey = buildResolutionCacheKey({
+    repoRoot: params.repoRoot,
+    currentBranch: state ? normalizeBranchName2(state.currentBranch) : null,
+    hasApi: Boolean(params.api)
+  });
+  const cached = readResolutionCache(cacheKey);
+  if (cached) return cached;
+  const resolution = await resolveActiveLaneBindingUncached(params, state);
+  writeResolutionCache(cacheKey, resolution);
+  return resolution;
+}
+async function resolveActiveLaneBindingUncached(params, state) {
   if (!state) {
     return { status: "not_bound", currentBranch: null };
   }
@@ -8565,12 +8812,24 @@ function buildBaseState() {
       queuedJobCount: 0,
       processingJobCount: 0,
       retryScheduledJobCount: 0,
+      awaitingUsageJobCount: 0,
       failedJobCount: 0,
       oldestCapturedAt: null,
       newestCapturedAt: null,
       nextRetryAt: null,
       latestError: null
     },
+    pendingAsyncJobs: {
+      state: "idle",
+      activeJobCount: 0,
+      queuedJobCount: 0,
+      processingJobCount: 0,
+      failedJobCount: 0,
+      oldestCreatedAt: null,
+      newestCreatedAt: null,
+      latestError: null,
+      kinds: []
+    },
     warnings: [],
     hint: null,
     metadataWarnings: [],
@@ -8649,7 +8908,7 @@ async function collabDetectRepoState(params) {
     return detected;
   }
   if (!params.api) {
-    const [inspection, pendingFinalize] = await Promise.all([
+    const [inspection, pendingFinalize, pendingAsyncJobs] = await Promise.all([
       inspectLocalSnapshot({
         repoRoot,
         repoFingerprint: binding.repoFingerprint,
@@ -8662,15 +8921,30 @@ async function collabDetectRepoState(params) {
         repoFingerprint: binding.repoFingerprint,
         currentAppId: binding.currentAppId,
         laneId: binding.laneId
-      })
+      }),
+      summarizeAsyncJobs({ repoRoot, branchName: binding.branchName ?? null })
     ]);
     detected.currentSnapshotHash = inspection.snapshotHash;
     detected.pendingFinalize = pendingFinalize;
+    detected.pendingAsyncJobs = pendingAsyncJobs;
     return detected;
   }
   try {
-    const [headResp, inspection, baseline, pendingFinalize] = await Promise.all([
-      params.api.getAppHead(binding.currentAppId),
+    const baseline = await readLocalBaseline({
+      repoFingerprint: binding.repoFingerprint,
+      laneId: binding.laneId,
+      repoRoot
+    });
+    const hasFullBaseline = Boolean(baseline?.lastSnapshotHash && baseline?.lastServerHeadHash);
+    const metadataIdentityPromise = hasFullBaseline ? getAppDeltaCached(params.api, binding.currentAppId, {
+      baseHeadHash: baseline.lastServerHeadHash,
+      targetHeadHash: baseline.lastServerHeadHash,
+      repoFingerprint: binding.repoFingerprint ?? void 0,
+      remoteUrl: binding.remoteUrl ?? void 0,
+      defaultBranch: binding.defaultBranch ?? void 0
+    }) : Promise.resolve(null);
+    const [headResp, inspection, parallelMetadataResp, pendingFinalize, pendingAsyncJobs] = await Promise.all([
+      getAppHeadCached(params.api, binding.currentAppId),
       inspectLocalSnapshot({
         repoRoot,
         repoFingerprint: binding.repoFingerprint,
@@ -8678,23 +8952,21 @@ async function collabDetectRepoState(params) {
         branchName: binding.branchName,
         persistBlobs: false
       }),
-      readLocalBaseline({
-        repoFingerprint: binding.repoFingerprint,
-        laneId: binding.laneId,
-        repoRoot
-      }),
+      metadataIdentityPromise,
       summarizePendingFinalizeJobs({
         repoRoot,
         repoFingerprint: binding.repoFingerprint,
         currentAppId: binding.currentAppId,
         laneId: binding.laneId
-      })
+      }),
+      summarizeAsyncJobs({ repoRoot, branchName: binding.branchName ?? null })
     ]);
     const appHead = unwrapResponseObject(headResp, "app head");
     detected.currentServerHeadHash = appHead.headCommitHash;
     detected.currentServerHeadCommitId = appHead.headCommitId;
     detected.currentSnapshotHash = inspection.snapshotHash;
     detected.pendingFinalize = pendingFinalize;
+    detected.pendingAsyncJobs = pendingAsyncJobs;
     detected.baseline = {
       lastSnapshotId: baseline?.lastSnapshotId ?? null,
       lastSnapshotHash: baseline?.lastSnapshotHash ?? null,
@@ -8738,15 +9010,7 @@ async function collabDetectRepoState(params) {
         "Local Git HEAD changed since the last Remix baseline. Remix will use the current workspace snapshot to detect divergence."
       );
     }
-    const metadataBaseHeadHash = baseline.lastServerHeadHash || appHead.headCommitHash;
-    const metadataResp = await params.api.getAppDelta(binding.currentAppId, {
-      baseHeadHash: metadataBaseHeadHash,
-      targetHeadHash: metadataBaseHeadHash,
-      repoFingerprint: binding.repoFingerprint ?? void 0,
-      remoteUrl: binding.remoteUrl ?? void 0,
-      defaultBranch: binding.defaultBranch ?? void 0
-    });
-    const metadataCheck = unwrapResponseObject(metadataResp, "app delta metadata");
+    const metadataCheck = unwrapResponseObject(parallelMetadataResp, "app delta metadata");
     detected.metadataWarnings = metadataCheck.warnings;
     detected.warnings.push(...metadataCheck.warnings);
     if (metadataCheck.status === "conflict_risk") {
@@ -8779,8 +9043,322 @@ async function collabDetectRepoState(params) {
     return detected;
   }
 }
+var GIT_TIMEOUT_MS = 1e4;
+var GIT_MAX_BUFFER = 64 * 1024 * 1024;
+var MAX_COMMITS = 100;
+var RECORD_SEPARATOR = "";
+var FIELD_SEPARATOR = "";
+var LOG_FORMAT = `${RECORD_SEPARATOR}%H${FIELD_SEPARATOR}%P${FIELD_SEPARATOR}%an${FIELD_SEPARATOR}%ae${FIELD_SEPARATOR}%cn${FIELD_SEPARATOR}%ce${FIELD_SEPARATOR}%aI${FIELD_SEPARATOR}%cI${FIELD_SEPARATOR}%s`;
+function sanitizedEnv() {
+  const env = { ...process.env };
+  delete env.GIT_DIR;
+  delete env.GIT_WORK_TREE;
+  delete env.GIT_COMMON_DIR;
+  delete env.GIT_INDEX_FILE;
+  return env;
+}
+async function runGitEvent(args, cwd) {
+  const res = await execa("git", args, {
+    cwd,
+    reject: false,
+    stderr: "pipe",
+    timeout: GIT_TIMEOUT_MS,
+    env: sanitizedEnv(),
+    maxBuffer: GIT_MAX_BUFFER
+  });
+  return {
+    exitCode: res.exitCode ?? -1,
+    stdout: String(res.stdout ?? ""),
+    stderr: String(res.stderr ?? ""),
+    timedOut: res.timedOut === true
+  };
+}
+function parseNumstatLine(line) {
+  const tab1 = line.indexOf("	");
+  if (tab1 < 0) return null;
+  const tab2 = line.indexOf("	", tab1 + 1);
+  if (tab2 < 0) return null;
+  const addedRaw = line.slice(0, tab1);
+  const removedRaw = line.slice(tab1 + 1, tab2);
+  const filePath = line.slice(tab2 + 1);
+  if (!filePath) return null;
+  const added = addedRaw === "-" ? 0 : Number.parseInt(addedRaw, 10);
+  const removed = removedRaw === "-" ? 0 : Number.parseInt(removedRaw, 10);
+  return {
+    added: Number.isFinite(added) ? added : 0,
+    removed: Number.isFinite(removed) ? removed : 0,
+    path: filePath
+  };
+}
+function parseLogOutput(stdout) {
+  const records = [];
+  const parts = stdout.split(RECORD_SEPARATOR);
+  for (const part of parts) {
+    if (!part) continue;
+    const newlineIdx = part.indexOf("\n");
+    const metadataLine = newlineIdx === -1 ? part : part.slice(0, newlineIdx);
+    const rest = newlineIdx === -1 ? "" : part.slice(newlineIdx + 1);
+    const fields = metadataLine.split(FIELD_SEPARATOR);
+    if (fields.length < 9) continue;
+    const [hash, parentsField, authorName, authorEmail, committerName, committerEmail, authorDateIso, committerDateIso, subject] = fields;
+    const parents = parentsField ? parentsField.split(" ").filter(Boolean) : [];
+    const commit = {
+      hash,
+      parents,
+      authorName,
+      authorEmail,
+      committerName,
+      committerEmail,
+      authorDateIso,
+      committerDateIso,
+      subject,
+      filesChanged: 0,
+      linesAdded: 0,
+      linesRemoved: 0
+    };
+    const touchedPaths = /* @__PURE__ */ new Set();
+    for (const rawLine of rest.split("\n")) {
+      if (!rawLine) continue;
+      const parsed = parseNumstatLine(rawLine);
+      if (!parsed) continue;
+      commit.linesAdded += parsed.added;
+      commit.linesRemoved += parsed.removed;
+      touchedPaths.add(parsed.path);
+    }
+    commit.filesChanged = touchedPaths.size;
+    records.push(commit);
+  }
+  return records;
+}
+function buildCommitEvent(raw) {
+  return {
+    hash: raw.hash,
+    shortHash: raw.hash.slice(0, 7),
+    isMerge: raw.parents.length >= 2,
+    parents: raw.parents,
+    author: { name: raw.authorName, email: raw.authorEmail },
+    committer: { name: raw.committerName, email: raw.committerEmail },
+    message: raw.subject,
+    timestamp: raw.authorDateIso,
+    filesChanged: raw.filesChanged,
+    linesAdded: raw.linesAdded,
+    linesRemoved: raw.linesRemoved
+  };
+}
+var MERGE_BRANCH_REGEXES = [
+  /^Merge branch '([^']+)'(?: into .+)?$/,
+  /^Merge remote-tracking branch '([^']+)'(?: into .+)?$/,
+  /^Merge pull request #\d+ from (\S+)$/
+];
+function parseBranchFromMergeMessage(subject) {
+  for (const re of MERGE_BRANCH_REGEXES) {
+    const match = re.exec(subject);
+    if (!match) continue;
+    const raw = match[1];
+    if (!raw) continue;
+    return raw.startsWith("origin/") ? raw.slice("origin/".length) : raw;
+  }
+  return null;
+}
+async function resolveBranchFromNameRev(secondParent, repoRoot) {
+  const res = await runGitEvent(
+    ["name-rev", "--name-only", "--no-undefined", secondParent],
+    repoRoot
+  );
+  if (res.exitCode !== 0 || res.timedOut) return null;
+  let name = res.stdout.trim();
+  if (!name) return null;
+  if (name.startsWith("remotes/origin/")) name = name.slice("remotes/origin/".length);
+  else if (name.startsWith("origin/")) name = name.slice("origin/".length);
+  if (name.includes("~") || name.includes("^") || name.startsWith("tags/") || name === "undefined") return null;
+  return name;
+}
+async function collectUncommittedSummary(repoRoot) {
+  const summary = {
+    filesChanged: 0,
+    linesAdded: 0,
+    linesRemoved: 0,
+    staged: 0,
+    unstaged: 0,
+    untracked: 0
+  };
+  const statusRes = await runGitEvent(["status", "--porcelain=v1"], repoRoot);
+  if (statusRes.exitCode === 0 && !statusRes.timedOut) {
+    const uniquePaths = /* @__PURE__ */ new Set();
+    for (const rawLine of statusRes.stdout.split("\n")) {
+      if (!rawLine) continue;
+      if (rawLine.startsWith("??")) {
+        summary.untracked += 1;
+        uniquePaths.add(rawLine.slice(3));
+        continue;
+      }
+      if (rawLine.length < 3) continue;
+      const indexCode = rawLine.charCodeAt(0);
+      const worktreeCode = rawLine.charCodeAt(1);
+      const indexCh = rawLine[0];
+      const worktreeCh = rawLine[1];
+      const pathPart = rawLine.slice(3);
+      if (indexCh !== " " && indexCode !== 63) summary.staged += 1;
+      if ((worktreeCh === "M" || worktreeCh === "D") && worktreeCode !== 63) summary.unstaged += 1;
+      uniquePaths.add(pathPart);
+    }
+    summary.filesChanged = uniquePaths.size;
+  }
+  const diffRes = await runGitEvent(["diff", "--numstat", "HEAD"], repoRoot);
+  if (diffRes.exitCode === 0 && !diffRes.timedOut) {
+    for (const rawLine of diffRes.stdout.split("\n")) {
+      if (!rawLine) continue;
+      const parsed = parseNumstatLine(rawLine);
+      if (!parsed) continue;
+      summary.linesAdded += parsed.added;
+      summary.linesRemoved += parsed.removed;
+    }
+  }
+  return summary;
+}
+function buildEmptyPreTurnEvents(params) {
+  return {
+    commits: [],
+    merges: [],
+    uncommittedAtFinalize: params.uncommitted,
+    summary: {
+      totalCommits: 0,
+      totalMerges: 0,
+      totalFilesChanged: 0,
+      totalLinesAdded: 0,
+      totalLinesRemoved: 0,
+      elapsedMs: null,
+      truncated: false,
+      rewritten: params.rewritten
+    },
+    range: { fromCommit: params.fromCommit, toCommit: params.toCommit },
+    schemaVersion: 1
+  };
+}
+async function collectPreTurnGitEvents(params) {
+  try {
+    const uncommitted = await collectUncommittedSummary(params.repoRoot);
+    if (!params.fromCommit || params.fromCommit === params.toCommit) {
+      return buildEmptyPreTurnEvents({
+        fromCommit: params.fromCommit,
+        toCommit: params.toCommit,
+        uncommitted,
+        rewritten: false
+      });
+    }
+    const reachabilityRes = await runGitEvent(
+      ["merge-base", "--is-ancestor", params.fromCommit, params.toCommit],
+      params.repoRoot
+    );
+    if (reachabilityRes.timedOut) return null;
+    if (reachabilityRes.exitCode === 1) {
+      return buildEmptyPreTurnEvents({
+        fromCommit: null,
+        toCommit: params.toCommit,
+        uncommitted,
+        rewritten: true
+      });
+    }
+    if (reachabilityRes.exitCode !== 0) return null;
+    const logRes = await runGitEvent(
+      [
+        "log",
+        "--first-parent",
+        "-m",
+        "--numstat",
+        "--no-renames",
+        `--format=${LOG_FORMAT}`,
+        `${params.fromCommit}..${params.toCommit}`
+      ],
+      params.repoRoot
+    );
+    if (logRes.timedOut || logRes.exitCode !== 0) return null;
+    const rawCommits = parseLogOutput(logRes.stdout);
+    const totalCommits = rawCommits.length;
+    const totalMerges = rawCommits.reduce((n2, c3) => n2 + (c3.parents.length >= 2 ? 1 : 0), 0);
+    const ordered = [...rawCommits].reverse();
+    const truncated = ordered.length > MAX_COMMITS;
+    const kept = truncated ? ordered.slice(ordered.length - MAX_COMMITS) : ordered;
+    const commits = kept.map(buildCommitEvent);
+    const merges = [];
+    for (const raw of rawCommits) {
+      if (raw.parents.length < 2) continue;
+      const secondParent = raw.parents[1];
+      const fromBranchFromMessage = parseBranchFromMergeMessage(raw.subject);
+      const fromBranchFromNameRev = await resolveBranchFromNameRev(secondParent, params.repoRoot);
+      merges.push({
+        hash: raw.hash,
+        shortHash: raw.hash.slice(0, 7),
+        fromBranchFromMessage,
+        fromBranchFromNameRev,
+        fromCommit: secondParent,
+        filesChanged: raw.filesChanged,
+        linesAdded: raw.linesAdded,
+        linesRemoved: raw.linesRemoved,
+        message: raw.subject
+      });
+    }
+    let totalFilesChanged = 0;
+    let totalLinesAdded = 0;
+    let totalLinesRemoved = 0;
+    const diffRes = await runGitEvent(
+      ["diff", "--numstat", "--no-renames", params.fromCommit, params.toCommit],
+      params.repoRoot
+    );
+    if (diffRes.exitCode === 0 && !diffRes.timedOut) {
+      const uniquePaths = /* @__PURE__ */ new Set();
+      for (const rawLine of diffRes.stdout.split("\n")) {
+        if (!rawLine) continue;
+        const parsed = parseNumstatLine(rawLine);
+        if (!parsed) continue;
+        uniquePaths.add(parsed.path);
+        totalLinesAdded += parsed.added;
+        totalLinesRemoved += parsed.removed;
+      }
+      totalFilesChanged = uniquePaths.size;
+    }
+    let elapsedMs = null;
+    if (rawCommits.length > 0) {
+      const committerTimes = rawCommits.map((c3) => Date.parse(c3.committerDateIso)).filter((t) => Number.isFinite(t));
+      if (committerTimes.length > 0) {
+        const min = Math.min(...committerTimes);
+        const max = Math.max(...committerTimes);
+        elapsedMs = max - min;
+      }
+    }
+    return {
+      // commits[] is a first-parent view: it contains the commits on the
+      // receiving branch plus merges as single entries. Commits that entered
+      // via merges are represented by the MergeEvent, not listed individually.
+      commits,
+      merges,
+      uncommittedAtFinalize: uncommitted,
+      summary: {
+        totalCommits,
+        totalMerges,
+        totalFilesChanged,
+        totalLinesAdded,
+        totalLinesRemoved,
+        elapsedMs,
+        truncated,
+        rewritten: false
+      },
+      range: { fromCommit: params.fromCommit, toCommit: params.toCommit },
+      schemaVersion: 1
+    };
+  } catch (err) {
+    console.warn(
+      `[remix-core] preTurnEvents harvester failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+}
 var FINALIZE_RETRY_BASE_DELAY_MS = 15e3;
 var FINALIZE_RETRY_MAX_DELAY_MS = 5 * 60 * 1e3;
+var FINALIZE_JOB_PROCESSING_TIMEOUT_MS_DEFAULT = 90 * 1e3;
+var finalizeJobProcessingTimeoutMs = FINALIZE_JOB_PROCESSING_TIMEOUT_MS_DEFAULT;
+var FINALIZE_LOCK_HEARTBEAT_MS = Math.max(15e3, Math.floor(FINALIZE_JOB_LOCK_STALE_MS / 3));
+var FINALIZE_AUTO_TERMINAL_THRESHOLD = 5;
 function readMetadataString(job, key) {
   const value = job.metadata[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
@@ -8789,6 +9367,10 @@ function readMetadataActor(job) {
   const actor = job.metadata.actor;
   return actor && typeof actor === "object" ? actor : void 0;
 }
+function readMetadataTurnUsage(job) {
+  const value = job.metadata.turnUsage;
+  return value && typeof value === "object" ? value : null;
+}
 function buildNextRetryAt(retryCount) {
   const exponent = Math.max(0, retryCount - 1);
   const delayMs = Math.min(FINALIZE_RETRY_BASE_DELAY_MS * 2 ** exponent, FINALIZE_RETRY_MAX_DELAY_MS);
@@ -8811,8 +9393,50 @@ function classifyFinalizeError(error) {
     message: error instanceof Error ? error.message : String(error)
   };
 }
-function buildWorkspaceMetadata(params) {
+function runWithFinalizeTimeout(work, jobId) {
+  let timer;
+  const cap = finalizeJobProcessingTimeoutMs;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      reject(
+        buildFinalizeCliError({
+          message: `Finalize job ${jobId} exceeded the ${Math.round(
+            cap / 1e3
+          )}s drainer wall-clock timeout. The slow request will be retried by a future drainer pass.`,
+          exitCode: 1,
+          hint: "If this keeps recurring, run `remix collab finalize-queue list` to inspect the job, then `remix collab finalize-queue forget <id>` to drop it manually.",
+          disposition: "retryable",
+          reason: "processing_timeout"
+        })
+      );
+    }, cap);
+    timer.unref?.();
+  });
+  return Promise.race([work, timeout]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+function startLockHeartbeat(jobId) {
+  const handle = setInterval(() => {
+    void heartbeatJobLock(jobId);
+  }, FINALIZE_LOCK_HEARTBEAT_MS);
+  handle.unref?.();
+  return () => clearInterval(handle);
+}
+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 sameReason = previousReason === reason;
+  const next = sameReason ? previousCount + 1 : 1;
   return {
+    consecutiveFailures: next,
+    consecutiveFailureReason: reason,
+    shouldEscalateToTerminal: next >= FINALIZE_AUTO_TERMINAL_THRESHOLD
+  };
+}
+function buildWorkspaceMetadata(params) {
+  const metadata = {
     branch: params.branchName,
     repoRoot: params.repoRoot,
     remoteUrl: params.remoteUrl,
@@ -8824,126 +9448,202 @@ function buildWorkspaceMetadata(params) {
     currentSnapshotHash: params.currentSnapshotHash,
     localCommitHash: params.localCommitHash,
     repoStateAtCapture: params.repoState,
-    replayedFromBaseHash: params.replayedFromBaseHash ?? null
+    replayedFromBaseHash: params.replayedFromBaseHash ?? null,
+    previousLocalCommitHash: params.previousLocalCommitHash ?? null
   };
+  if (params.preTurnEvents) {
+    metadata.preTurnEvents = params.preTurnEvents;
+  }
+  if (params.turnUsage) {
+    metadata.turnUsage = params.turnUsage;
+  }
+  if (typeof params.promptedAt === "string" && params.promptedAt.trim()) {
+    metadata.promptedAt = params.promptedAt.trim();
+  }
+  return metadata;
+}
+async function harvestPreTurnEvents(repoRoot, fromCommit, toCommit) {
+  if (!toCommit) return null;
+  try {
+    return await collectPreTurnGitEvents({ repoRoot, fromCommit, toCommit });
+  } catch (err) {
+    console.warn(
+      `[remix-core] preTurnEvents harvester threw: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
 }
 async function processClaimedPendingFinalizeJob(params) {
   const job = params.job;
+  const stopHeartbeat = startLockHeartbeat(job.id);
   try {
-    const [snapshot, baseline, appHeadResp] = await Promise.all([
-      readLocalSnapshot(job.currentSnapshotId),
-      readLocalBaseline({
-        repoFingerprint: job.repoFingerprint,
-        laneId: job.laneId,
-        repoRoot: job.repoRoot
-      }),
-      params.api.getAppHead(job.currentAppId)
-    ]);
-    if (!snapshot) {
+    return await runWithFinalizeTimeout(processClaimedPendingFinalizeJobInner(params), job.id);
+  } catch (error) {
+    const classified = classifyFinalizeError(error);
+    const escalation = computeFailureEscalation(job, classified.reason);
+    const finalDisposition = classified.disposition === "terminal" || escalation.shouldEscalateToTerminal ? "terminal" : "retryable";
+    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,
+      nextRetryAt: finalDisposition === "terminal" ? null : buildNextRetryAt(job.retryCount),
+      metadata: {
+        failureDisposition: finalDisposition,
+        failureReason: classified.reason,
+        consecutiveFailures: escalation.consecutiveFailures,
+        consecutiveFailureReason: escalation.consecutiveFailureReason
+      }
+    });
+    throw error;
+  } finally {
+    stopHeartbeat();
+    await params.release();
+  }
+}
+async function processClaimedPendingFinalizeJobInner(params) {
+  const job = params.job;
+  const [snapshot, baseline, appHeadResp] = await Promise.all([
+    readLocalSnapshot(job.currentSnapshotId),
+    readLocalBaseline({
+      repoFingerprint: job.repoFingerprint,
+      laneId: job.laneId,
+      repoRoot: job.repoRoot
+    }),
+    getAppHeadCached(params.api, job.currentAppId)
+  ]);
+  if (!snapshot) {
+    throw buildFinalizeCliError({
+      message: "Captured snapshot is missing from the local snapshot store.",
+      exitCode: 1,
+      disposition: "terminal",
+      reason: "snapshot_missing"
+    });
+  }
+  if (!baseline) {
+    throw buildFinalizeCliError({
+      message: "Local baseline is missing for this queued finalize job.",
+      exitCode: 2,
+      hint: "Run `remix collab re-anchor` to anchor the repository again.",
+      disposition: "terminal",
+      reason: "baseline_missing"
+    });
+  }
+  const baselineDrifted = baseline.lastSnapshotId !== job.baselineSnapshotId || baseline.lastServerHeadHash !== job.baselineServerHeadHash;
+  const appHead = unwrapResponseObject(appHeadResp, "app head");
+  const remoteUrl = readMetadataString(job, "remoteUrl");
+  const defaultBranch = readMetadataString(job, "defaultBranch");
+  const repoState = readMetadataString(job, "repoState");
+  const actor = readMetadataActor(job);
+  const turnUsage = readMetadataTurnUsage(job);
+  const promptedAt = readMetadataString(job, "promptedAt");
+  const previousLocalCommitHash = baseline.lastSeenLocalCommitHash ?? null;
+  const preTurnEvents = await harvestPreTurnEvents(
+    job.repoRoot,
+    previousLocalCommitHash,
+    snapshot.localCommitHash
+  );
+  const diffResult = await diffLocalSnapshots({
+    baseSnapshotId: job.baselineSnapshotId,
+    targetSnapshotId: job.currentSnapshotId
+  });
+  if (!diffResult.diff.trim()) {
+    if (baselineDrifted && snapshot.snapshotHash !== baseline.lastSnapshotHash) {
       throw buildFinalizeCliError({
-        message: "Captured snapshot is missing from the local snapshot store.",
+        message: "Finalize queue baseline drifted before this job was processed.",
         exitCode: 1,
+        hint: "Process queued finalize jobs in capture order, or re-anchor the repository before retrying.",
         disposition: "terminal",
-        reason: "snapshot_missing"
+        reason: "baseline_drifted"
       });
     }
-    if (!baseline) {
+    if (appHead.headCommitHash !== job.baselineServerHeadHash) {
       throw buildFinalizeCliError({
-        message: "Local baseline is missing for this queued finalize job.",
+        message: "Server lane changed before a no-diff turn could be recorded.",
         exitCode: 2,
-        hint: "Run `remix collab re-anchor` to anchor the repository again.",
+        hint: "Pull the server changes locally before recording another no-diff turn.",
         disposition: "terminal",
-        reason: "baseline_missing"
+        reason: "server_lane_changed"
       });
     }
-    if (baseline.lastSnapshotId !== job.baselineSnapshotId || baseline.lastServerHeadHash !== job.baselineServerHeadHash) {
-      throw buildFinalizeCliError({
-        message: "Finalize queue baseline drifted before this job was processed.",
-        exitCode: 1,
-        hint: "Process queued finalize jobs in capture order, or re-anchor the repository before retrying.",
-        disposition: "terminal",
-        reason: "baseline_drifted"
-      });
-    }
-    const appHead = unwrapResponseObject(appHeadResp, "app head");
-    const remoteUrl = readMetadataString(job, "remoteUrl");
-    const defaultBranch = readMetadataString(job, "defaultBranch");
-    const repoState = readMetadataString(job, "repoState");
-    const actor = readMetadataActor(job);
-    const diffResult = await diffLocalSnapshots({
-      baseSnapshotId: job.baselineSnapshotId,
-      targetSnapshotId: job.currentSnapshotId
-    });
-    if (!diffResult.diff.trim()) {
-      if (appHead.headCommitHash !== job.baselineServerHeadHash) {
-        throw buildFinalizeCliError({
-          message: "Server lane changed before a no-diff turn could be recorded.",
-          exitCode: 2,
-          hint: "Pull the server changes locally before recording another no-diff turn.",
-          disposition: "terminal",
-          reason: "server_lane_changed"
-        });
-      }
-      const collabTurnResp = await params.api.createCollabTurn(job.currentAppId, {
-        threadId: job.threadId ?? void 0,
-        collabLaneId: job.laneId ?? void 0,
-        prompt: job.prompt,
-        assistantResponse: job.assistantResponse,
-        actor,
-        workspaceMetadata: buildWorkspaceMetadata({
-          repoRoot: job.repoRoot,
-          branchName: job.branchName,
-          remoteUrl,
-          defaultBranch,
-          baselineSnapshotId: job.baselineSnapshotId,
-          currentSnapshotId: job.currentSnapshotId,
-          baselineServerHeadHash: job.baselineServerHeadHash,
-          currentSnapshotHash: snapshot.snapshotHash,
-          localCommitHash: snapshot.localCommitHash,
-          repoState
-        }),
-        idempotencyKey: job.idempotencyKey ?? void 0
-      });
-      const collabTurn = unwrapResponseObject(collabTurnResp, "collab turn");
-      await writeLocalBaseline({
+    const collabTurnResp = await params.api.createCollabTurn(job.currentAppId, {
+      threadId: job.threadId ?? void 0,
+      collabLaneId: job.laneId ?? void 0,
+      prompt: job.prompt,
+      assistantResponse: job.assistantResponse,
+      actor,
+      workspaceMetadata: buildWorkspaceMetadata({
         repoRoot: job.repoRoot,
-        repoFingerprint: job.repoFingerprint,
-        laneId: job.laneId,
-        currentAppId: job.currentAppId,
         branchName: job.branchName,
-        lastSnapshotId: snapshot.id,
-        lastSnapshotHash: snapshot.snapshotHash,
-        lastServerHeadHash: appHead.headCommitHash,
-        lastSeenLocalCommitHash: snapshot.localCommitHash
-      });
-      await updatePendingFinalizeJob(job.id, {
-        status: "completed",
-        metadata: { collabTurnId: collabTurn.id }
-      });
-      return {
-        mode: "no_diff_turn",
-        idempotencyKey: job.idempotencyKey ?? "",
-        queued: false,
-        jobId: job.id,
+        remoteUrl,
+        defaultBranch,
+        baselineSnapshotId: job.baselineSnapshotId,
+        currentSnapshotId: job.currentSnapshotId,
+        baselineServerHeadHash: job.baselineServerHeadHash,
+        currentSnapshotHash: snapshot.snapshotHash,
+        localCommitHash: snapshot.localCommitHash,
         repoState,
-        changeStep: null,
-        collabTurn,
-        autoSync: null,
-        warnings: []
-      };
-    }
-    let submissionDiff = diffResult.diff;
-    let submissionBaseHeadHash = job.baselineServerHeadHash;
-    let replayedFromBaseHash = null;
-    if (!submissionBaseHeadHash) {
+        previousLocalCommitHash,
+        preTurnEvents,
+        turnUsage,
+        promptedAt
+      }),
+      idempotencyKey: job.idempotencyKey ?? void 0
+    });
+    const collabTurn = unwrapResponseObject(collabTurnResp, "collab turn");
+    await writeLocalBaseline({
+      repoRoot: job.repoRoot,
+      repoFingerprint: job.repoFingerprint,
+      laneId: job.laneId,
+      currentAppId: job.currentAppId,
+      branchName: job.branchName,
+      lastSnapshotId: snapshot.id,
+      lastSnapshotHash: snapshot.snapshotHash,
+      lastServerHeadHash: appHead.headCommitHash,
+      lastSeenLocalCommitHash: snapshot.localCommitHash
+    });
+    await updatePendingFinalizeJob(job.id, {
+      status: "completed",
+      metadata: { collabTurnId: collabTurn.id }
+    });
+    return {
+      mode: "no_diff_turn",
+      idempotencyKey: job.idempotencyKey ?? "",
+      queued: false,
+      jobId: job.id,
+      repoState,
+      changeStep: null,
+      collabTurn,
+      autoSync: null,
+      warnings: []
+    };
+  }
+  const localBaselineAdvanced = baseline.lastSnapshotId !== job.baselineSnapshotId;
+  const serverHeadAdvanced = appHead.headCommitHash !== job.baselineServerHeadHash;
+  if (baselineDrifted) {
+    const consistentAdvance = localBaselineAdvanced && serverHeadAdvanced;
+    if (!consistentAdvance) {
       throw buildFinalizeCliError({
-        message: "Baseline server head is missing for this finalize job.",
+        message: `Finalize queue baseline advanced inconsistently before this job was processed (localBaselineAdvanced=${localBaselineAdvanced}, serverHeadAdvanced=${serverHeadAdvanced}, jobBaselineSnapshotId=${job.baselineSnapshotId ?? "null"}, liveBaselineSnapshotId=${baseline.lastSnapshotId ?? "null"}, jobBaselineServerHeadHash=${job.baselineServerHeadHash ?? "null"}, liveBaselineServerHeadHash=${baseline.lastServerHeadHash ?? "null"}, currentAppHeadHash=${appHead.headCommitHash}). This indicates local Remix state diverged from the backend in a way that should not be reachable in normal operation; please report this as a bug.`,
         exitCode: 1,
+        hint: "Run `remix collab status` to inspect, then `remix collab re-anchor` only if the lane has no valid baseline.",
         disposition: "terminal",
-        reason: "baseline_server_head_missing"
+        reason: "baseline_drifted"
       });
     }
-    if (appHead.headCommitHash !== submissionBaseHeadHash) {
+  }
+  let submissionDiff = diffResult.diff;
+  let submissionBaseHeadHash = job.baselineServerHeadHash;
+  let replayedFromBaseHash = null;
+  if (!submissionBaseHeadHash) {
+    throw buildFinalizeCliError({
+      message: "Baseline server head is missing for this finalize job.",
+      exitCode: 1,
+      disposition: "terminal",
+      reason: "baseline_server_head_missing"
+    });
+  }
+  const replayNeeded = appHead.headCommitHash !== submissionBaseHeadHash || baselineDrifted;
+  if (replayNeeded) {
+    try {
       const replayResp = await params.api.startChangeStepReplay(job.currentAppId, {
         prompt: job.prompt,
         assistantResponse: job.assistantResponse,
@@ -8962,7 +9662,11 @@ async function processClaimedPendingFinalizeJob(params) {
           baselineServerHeadHash: job.baselineServerHeadHash,
           currentSnapshotHash: snapshot.snapshotHash,
           localCommitHash: snapshot.localCommitHash,
-          repoState
+          repoState,
+          previousLocalCommitHash,
+          preTurnEvents,
+          turnUsage,
+          promptedAt
         }),
         idempotencyKey: buildDeterministicIdempotencyKey({
           kind: "collab_finalize_turn_replay_v1",
@@ -8980,79 +9684,91 @@ async function processClaimedPendingFinalizeJob(params) {
       submissionDiff = replayDiff.diff;
       replayedFromBaseHash = submissionBaseHeadHash;
       submissionBaseHeadHash = appHead.headCommitHash;
+    } catch (error) {
+      if (error instanceof RemixError && error.finalizeDisposition === void 0) {
+        const detail = error.hint ? `${error.message} (${error.hint})` : error.message;
+        throw buildFinalizeCliError({
+          message: "Server-side replay could not adapt the captured diff to the current server head: " + detail,
+          exitCode: 1,
+          hint: error.hint ?? void 0,
+          disposition: "terminal",
+          reason: "replay_unrecoverable"
+        });
+      }
+      throw error;
     }
-    const changeStepResp = await params.api.createChangeStep(job.currentAppId, {
-      threadId: job.threadId ?? void 0,
-      collabLaneId: job.laneId ?? void 0,
-      prompt: job.prompt,
-      assistantResponse: job.assistantResponse,
-      diff: submissionDiff,
-      baseCommitHash: submissionBaseHeadHash,
-      headCommitHash: submissionBaseHeadHash,
-      changedFilesCount: diffResult.stats.changedFilesCount,
-      insertions: diffResult.stats.insertions,
-      deletions: diffResult.stats.deletions,
-      actor,
-      workspaceMetadata: buildWorkspaceMetadata({
-        repoRoot: job.repoRoot,
-        branchName: job.branchName,
-        remoteUrl,
-        defaultBranch,
-        baselineSnapshotId: job.baselineSnapshotId,
-        currentSnapshotId: job.currentSnapshotId,
-        baselineServerHeadHash: job.baselineServerHeadHash,
-        currentSnapshotHash: snapshot.snapshotHash,
-        localCommitHash: snapshot.localCommitHash,
-        repoState,
-        replayedFromBaseHash
-      }),
-      idempotencyKey: job.idempotencyKey ?? void 0
-    });
-    const createdStep = unwrapResponseObject(changeStepResp, "change step");
-    const changeStep = await pollChangeStep(params.api, job.currentAppId, String(createdStep.id));
-    const nextHeadResp = await params.api.getAppHead(job.currentAppId);
-    const nextHead = unwrapResponseObject(nextHeadResp, "app head");
-    await writeLocalBaseline({
+  }
+  const changeStepResp = await params.api.createChangeStep(job.currentAppId, {
+    threadId: job.threadId ?? void 0,
+    collabLaneId: job.laneId ?? void 0,
+    prompt: job.prompt,
+    assistantResponse: job.assistantResponse,
+    diff: submissionDiff,
+    baseCommitHash: submissionBaseHeadHash,
+    headCommitHash: submissionBaseHeadHash,
+    changedFilesCount: diffResult.stats.changedFilesCount,
+    insertions: diffResult.stats.insertions,
+    deletions: diffResult.stats.deletions,
+    actor,
+    workspaceMetadata: buildWorkspaceMetadata({
       repoRoot: job.repoRoot,
-      repoFingerprint: job.repoFingerprint,
-      laneId: job.laneId,
-      currentAppId: job.currentAppId,
       branchName: job.branchName,
-      lastSnapshotId: snapshot.id,
-      lastSnapshotHash: snapshot.snapshotHash,
-      lastServerHeadHash: nextHead.headCommitHash,
-      lastSeenLocalCommitHash: snapshot.localCommitHash
-    });
-    await updatePendingFinalizeJob(job.id, {
-      status: "completed",
-      metadata: { changeStepId: String(changeStep.id ?? "") }
-    });
-    return {
-      mode: "changed_turn",
-      idempotencyKey: job.idempotencyKey ?? "",
-      queued: false,
-      jobId: job.id,
+      remoteUrl,
+      defaultBranch,
+      baselineSnapshotId: job.baselineSnapshotId,
+      currentSnapshotId: job.currentSnapshotId,
+      baselineServerHeadHash: job.baselineServerHeadHash,
+      currentSnapshotHash: snapshot.snapshotHash,
+      localCommitHash: snapshot.localCommitHash,
       repoState,
-      changeStep,
-      collabTurn: null,
-      autoSync: null,
-      warnings: []
-    };
-  } catch (error) {
-    const classified = classifyFinalizeError(error);
-    await updatePendingFinalizeJob(job.id, {
-      status: classified.disposition === "terminal" ? "failed" : "queued",
-      error: classified.message,
-      nextRetryAt: classified.disposition === "terminal" ? null : buildNextRetryAt(job.retryCount),
-      metadata: {
-        failureDisposition: classified.disposition,
-        failureReason: classified.reason
-      }
-    });
-    throw error;
-  } finally {
-    await params.release();
-  }
+      replayedFromBaseHash,
+      previousLocalCommitHash,
+      preTurnEvents,
+      turnUsage,
+      promptedAt
+    }),
+    idempotencyKey: job.idempotencyKey ?? void 0
+  });
+  const createdStep = unwrapResponseObject(changeStepResp, "change step");
+  const changeStep = await pollChangeStep(params.api, job.currentAppId, String(createdStep.id));
+  invalidateAppHeadCache(job.currentAppId);
+  invalidateAppDeltaCacheForApp(job.currentAppId);
+  const nextServerHeadHash = typeof changeStep.headCommitHash === "string" ? changeStep.headCommitHash.trim() : "";
+  if (!nextServerHeadHash) {
+    throw buildFinalizeCliError({
+      message: "Backend returned a succeeded change step without a head commit hash.",
+      exitCode: 1,
+      hint: "This is a backend invariant violation; retry will not help. Re-anchor and try again.",
+      disposition: "terminal",
+      reason: "missing_head_commit_hash"
+    });
+  }
+  await writeLocalBaseline({
+    repoRoot: job.repoRoot,
+    repoFingerprint: job.repoFingerprint,
+    laneId: job.laneId,
+    currentAppId: job.currentAppId,
+    branchName: job.branchName,
+    lastSnapshotId: snapshot.id,
+    lastSnapshotHash: snapshot.snapshotHash,
+    lastServerHeadHash: nextServerHeadHash,
+    lastSeenLocalCommitHash: snapshot.localCommitHash
+  });
+  await updatePendingFinalizeJob(job.id, {
+    status: "completed",
+    metadata: { changeStepId: String(changeStep.id ?? "") }
+  });
+  return {
+    mode: "changed_turn",
+    idempotencyKey: job.idempotencyKey ?? "",
+    queued: false,
+    jobId: job.id,
+    repoState,
+    changeStep,
+    collabTurn: null,
+    autoSync: null,
+    warnings: []
+  };
 }
 async function enqueueCapturedFinalizeTurn(params) {
   return enqueuePendingFinalizeJob({
@@ -9072,7 +9788,7 @@ async function enqueueCapturedFinalizeTurn(params) {
     error: null,
     retryCount: 0,
     lastAttemptAt: null,
-    nextRetryAt: null,
+    nextRetryAt: params.nextRetryAt ?? null,
     metadata: params.metadata ?? {}
   });
 }
@@ -9096,6 +9812,7 @@ async function drainPendingFinalizeQueue(params) {
   }
   return results;
 }
+var FINALIZE_AWAIT_INIT_POST_TIMEOUT_MS = 6e4;
 function collectWarnings(value) {
   if (!Array.isArray(value)) return [];
   return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
@@ -9124,37 +9841,99 @@ async function collabFinalizeTurn(params) {
       hint: "Finalize turns now capture the real workspace boundary from the local snapshot store."
     });
   }
+  const pendingInit = await findPendingAsyncJob({
+    repoRoot,
+    branchName: binding.branchName ?? null,
+    kind: "init"
+  });
+  if (pendingInit) {
+    throw new RemixError("Cannot finalize a turn while the initial Remix import is still processing.", {
+      exitCode: 2,
+      hint: `Init job ${pendingInit.id} is still in the background queue. Run \`remix collab status\` to check progress.`
+    });
+  }
+  const pendingInitPost = await findPendingAsyncJob({
+    repoRoot,
+    branchName: binding.branchName ?? null,
+    kind: "init_post"
+  });
+  if (pendingInitPost) {
+    const result = await awaitAsyncJob({
+      jobId: pendingInitPost.id,
+      timeoutMs: FINALIZE_AWAIT_INIT_POST_TIMEOUT_MS,
+      pollIntervalMs: 500
+    });
+    if (result.status === "failed") {
+      throw new RemixError("The initial Remix import failed; this turn cannot be recorded.", {
+        exitCode: 2,
+        hint: (result.job?.error ? `Last error: ${result.job.error}
+
+` : "") + "Run `remix collab init` again to retry \u2014 the post-init drainer cleared the local binding so this is safe."
+      });
+    }
+    if (result.status === "timeout") {
+      throw new RemixError("Timed out waiting for the initial Remix import to finish provisioning.", {
+        exitCode: 2,
+        hint: `Init post job ${pendingInitPost.id} did not complete within ${Math.round(
+          FINALIZE_AWAIT_INIT_POST_TIMEOUT_MS / 1e3
+        )}s. Run \`remix collab status\` to check progress, then retry once it reports ready.`
+      });
+    }
+  }
+  const pendingReAnchor = await findPendingAsyncJob({
+    repoRoot,
+    branchName: binding.branchName ?? null,
+    kind: "re_anchor"
+  });
+  if (pendingReAnchor) {
+    throw new RemixError("Cannot finalize a turn while a re-anchor is still processing.", {
+      exitCode: 2,
+      hint: `Re-anchor job ${pendingReAnchor.id} is still in the background queue. Run \`remix collab status\` to check progress.`
+    });
+  }
   const detected = await collabDetectRepoState({
     api: params.api,
     cwd: repoRoot,
     allowBranchMismatch: params.allowBranchMismatch
   });
   if (detected.status === "not_bound") {
-    throw new RemixError("Repository is not bound to Remix.", { exitCode: 2, hint: detected.hint });
+    throw new RemixError("Repository is not bound to Remix.", {
+      code: "not_bound",
+      exitCode: 2,
+      hint: detected.hint
+    });
   }
   if (detected.status === "branch_binding_missing" || detected.status === "family_ambiguous") {
-    throw new RemixError(detected.hint || "Current branch is not ready for Remix recording.", { exitCode: 2, hint: detected.hint });
+    throw new RemixError(detected.hint || "Current branch is not ready for Remix recording.", {
+      code: detected.status,
+      exitCode: 2,
+      hint: detected.hint
+    });
   }
   if (detected.status === "metadata_conflict" || detected.status === "branch_mismatch") {
     throw new RemixError("Repository must be realigned before finalizing the turn.", {
+      code: detected.status,
       exitCode: 2,
       hint: detected.hint
     });
   }
   if (detected.status === "missing_head" || detected.status === "remote_error") {
     throw new RemixError(detected.hint || "Failed to determine the current repo state.", {
+      code: detected.status,
       exitCode: 1,
       hint: detected.hint
     });
   }
   if (detected.repoState === "server_only_changed") {
     throw new RemixError("Server changes must be pulled locally before finalizing this turn.", {
+      code: "pull_required",
       exitCode: 2,
       hint: detected.hint
     });
   }
   if (detected.repoState === "external_local_base_changed") {
     throw new RemixError("The local checkout must be re-anchored before finalizing this turn.", {
+      code: "re_anchor_required",
       exitCode: 2,
       hint: detected.hint
     });
@@ -9189,6 +9968,8 @@ async function collabFinalizeTurn(params) {
     prompt,
     assistantResponse
   });
+  const awaitingDeadlineMs = typeof params.awaitingUsageDeadlineMs === "number" && params.awaitingUsageDeadlineMs > 0 ? params.awaitingUsageDeadlineMs : null;
+  const nextRetryAt = awaitingDeadlineMs === null ? null : new Date(Date.now() + awaitingDeadlineMs).toISOString();
   const job = await enqueueCapturedFinalizeTurn({
     repoRoot,
     repoFingerprint: binding.repoFingerprint,
@@ -9206,8 +9987,11 @@ async function collabFinalizeTurn(params) {
       remoteUrl: binding.remoteUrl,
       defaultBranch: binding.defaultBranch,
       actor: params.actor ?? null,
-      repoState: detected.repoState
-    }
+      repoState: detected.repoState,
+      turnUsage: params.turnUsage ?? null,
+      promptedAt: typeof params.promptedAt === "string" && params.promptedAt.trim() ? params.promptedAt.trim() : null
+    },
+    nextRetryAt
   });
   return {
     mode,
@@ -9221,8 +10005,34 @@ async function collabFinalizeTurn(params) {
     warnings: [FINALIZE_QUEUED_WARNING, ...collectWarnings(detected.warnings)]
   };
 }
+var FINALIZE_PREFLIGHT_FAILURE_CODES = [
+  // Repo has no .remix/ binding at all. Fix: `remix collab init`.
+  "not_bound",
+  // Binding file exists but the current branch has no entry. Fix: same as
+  // not_bound — `remix collab init` records this branch into the binding.
+  "branch_binding_missing",
+  // Branch matches multiple lane families (very rare race). Fix: human
+  // investigation; auto-fixers should treat as warn-only.
+  "family_ambiguous",
+  // Local-vs-server metadata diverged on app id / lane id. Fix: human
+  // investigation; auto-fixers should treat as warn-only.
+  "metadata_conflict",
+  // Currently checked-out branch differs from the one in the binding.
+  // Fix: human (either checkout the recorded branch or update binding).
+  "branch_mismatch",
+  // HEAD ref unreadable / git reports an error. Fix: human investigation.
+  "missing_head",
+  "remote_error",
+  // Server has commits we don't. Fix: `remix collab sync` (safe to
+  // auto-run for fast-forward; non-FF refused by the command itself).
+  "pull_required",
+  // Local base hash doesn't match the recorded baseline (force-push,
+  // hard reset, rebase). Fix: `remix collab re-anchor`.
+  "re_anchor_required"
+];
+var CODE_SET = new Set(FINALIZE_PREFLIGHT_FAILURE_CODES);
 
-// node_modules/@remixhq/core/dist/chunk-R7FVSCQW.js
+// node_modules/@remixhq/core/dist/chunk-US5SM7ZC.js
 async function readJsonSafe(res) {
   const ct = res.headers.get("content-type") ?? "";
   if (!ct.toLowerCase().includes("application/json")) return null;
@@ -9236,7 +10046,7 @@ function createApiClient(config, opts) {
   const apiKey = (opts?.apiKey ?? "").trim();
   const tokenProvider = opts?.tokenProvider;
   const CLIENT_KEY_HEADER = "x-comerge-api-key";
-  async function request(path12, init) {
+  async function request(path13, init) {
     if (!tokenProvider) {
       throw new RemixError("API client is missing a token provider.", {
         exitCode: 1,
@@ -9244,7 +10054,7 @@ function createApiClient(config, opts) {
       });
     }
     const auth = await tokenProvider();
-    const url = new URL(path12, config.apiUrl).toString();
+    const url = new URL(path13, config.apiUrl).toString();
     const doFetch = async (bearer) => fetch(url, {
       ...init,
       headers: {
@@ -9268,7 +10078,7 @@ function createApiClient(config, opts) {
     const json = await readJsonSafe(res);
     return json ?? null;
   }
-  async function requestBinary(path12, init) {
+  async function requestBinary(path13, init) {
     if (!tokenProvider) {
       throw new RemixError("API client is missing a token provider.", {
         exitCode: 1,
@@ -9276,7 +10086,7 @@ function createApiClient(config, opts) {
       });
     }
     const auth = await tokenProvider();
-    const url = new URL(path12, config.apiUrl).toString();
+    const url = new URL(path13, config.apiUrl).toString();
     const doFetch = async (bearer) => fetch(url, {
       ...init,
       headers: {
@@ -9405,6 +10215,10 @@ function createApiClient(config, opts) {
       method: "POST",
       body: JSON.stringify(payload)
     }),
+    attachCollabTurnUsage: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/collab-turns/attach-usage`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
     listCollabTurns: (appId, params) => {
       const qs = new URLSearchParams();
       if (params?.limit !== void 0) qs.set("limit", String(params.limit));
@@ -9626,7 +10440,21 @@ function createApiClient(config, opts) {
         method: "GET"
       });
     },
-    getSandboxStatus: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/sandbox/status`, { method: "GET" })
+    getSandboxStatus: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/sandbox/status`, { method: "GET" }),
+    importHistory: async (payload) => {
+      const res = await request("/v1/history/import", {
+        method: "POST",
+        body: JSON.stringify(payload)
+      });
+      const envelope = res;
+      if (!envelope || typeof envelope !== "object" || !envelope.responseObject) {
+        throw new RemixError("Malformed importHistory response from server.", {
+          exitCode: 1,
+          hint: "Expected `{ responseObject: ImportHistoryResponse }`."
+        });
+      }
+      return envelope.responseObject;
+    }
   };
 }
 
@@ -10108,8 +10936,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path12, errorMaps, issueData } = params;
-  const fullPath = [...path12, ...issueData.path || []];
+  const { data, path: path13, errorMaps, issueData } = params;
+  const fullPath = [...path13, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -10225,11 +11053,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path12, key) {
+  constructor(parent, value, path13, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path12;
+    this._path = path13;
     this._key = key;
   }
   get path() {
@@ -13671,8 +14499,8 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// node_modules/@remixhq/core/dist/chunk-EVWDYCBL.js
-var import_promises17 = __toESM(require("fs/promises"), 1);
+// node_modules/@remixhq/core/dist/chunk-P6JHXOV4.js
+var import_promises18 = __toESM(require("fs/promises"), 1);
 var import_os3 = __toESM(require("os"), 1);
 var import_path7 = __toESM(require("path"), 1);
 
@@ -13731,6 +14559,13 @@ var FunctionsError = class extends Error {
     this.name = name;
     this.context = context;
   }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      context: this.context
+    };
+  }
 };
 var FunctionsFetchError = class extends FunctionsError {
   constructor(context) {
@@ -13771,24 +14606,22 @@ var FunctionsClient = class {
   /**
    * Creates a new Functions client bound to an Edge Functions URL.
    *
-   * @example
+   * @example Using supabase-js (recommended)
    * ```ts
-   * import { FunctionsClient, FunctionRegion } from '@supabase/functions-js'
+   * import { createClient } from '@supabase/supabase-js'
    *
-   * const functions = new FunctionsClient('https://xyzcompany.supabase.co/functions/v1', {
-   *   headers: { apikey: 'public-anon-key' },
-   *   region: FunctionRegion.UsEast1,
-   * })
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'publishable-or-anon-key')
+   * const { data, error } = await supabase.functions.invoke('hello-world')
    * ```
    *
    * @category Functions
    *
-   * @example Creating a Functions client
+   * @example Standalone import for bundle-sensitive environments
    * ```ts
    * import { FunctionsClient, FunctionRegion } from '@supabase/functions-js'
    *
    * const functions = new FunctionsClient('https://xyzcompany.supabase.co/functions/v1', {
-   *   headers: { apikey: 'public-anon-key' },
+   *   headers: { apikey: 'publishable-or-anon-key' },
    *   region: FunctionRegion.UsEast1,
    * })
    * ```
@@ -14036,6 +14869,14 @@ var FunctionsClient = class {
 };
 
 // node_modules/@supabase/postgrest-js/dist/index.mjs
+var DEFAULT_MAX_RETRIES = 3;
+var getRetryDelay = (attemptIndex) => Math.min(1e3 * 2 ** attemptIndex, 3e4);
+var RETRYABLE_STATUS_CODES = [520, 503];
+var RETRYABLE_METHODS = [
+  "GET",
+  "HEAD",
+  "OPTIONS"
+];
 var PostgrestError = class extends Error {
   /**
   * @example
@@ -14057,36 +14898,67 @@ var PostgrestError = class extends Error {
     this.hint = context.hint;
     this.code = context.code;
   }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      details: this.details,
+      hint: this.hint,
+      code: this.code
+    };
+  }
 };
+function sleep2(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+      resolve();
+      return;
+    }
+    const id = setTimeout(() => {
+      signal === null || signal === void 0 || signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    function onAbort() {
+      clearTimeout(id);
+      resolve();
+    }
+    signal === null || signal === void 0 || signal.addEventListener("abort", onAbort);
+  });
+}
+function shouldRetry(method, status, attemptCount, retryEnabled) {
+  if (!retryEnabled || attemptCount >= DEFAULT_MAX_RETRIES) return false;
+  if (!RETRYABLE_METHODS.includes(method)) return false;
+  if (!RETRYABLE_STATUS_CODES.includes(status)) return false;
+  return true;
+}
 var PostgrestBuilder = class {
   /**
   * Creates a builder configured for a specific PostgREST request.
   *
-  * @example
+  * @example Using supabase-js (recommended)
   * ```ts
-  * import { PostgrestQueryBuilder } from '@supabase/postgrest-js'
+  * import { createClient } from '@supabase/supabase-js'
   *
-  * const builder = new PostgrestQueryBuilder(
-  *   new URL('https://xyzcompany.supabase.co/rest/v1/users'),
-  *   { headers: new Headers({ apikey: 'public-anon-key' }) }
-  * )
+  * const supabase = createClient('https://xyzcompany.supabase.co', 'publishable-or-anon-key')
+  * const { data, error } = await supabase.from('users').select('*')
   * ```
   *
   * @category Database
   *
-  * @example Creating a Postgrest query builder
+  * @example Standalone import for bundle-sensitive environments
   * ```ts
   * import { PostgrestQueryBuilder } from '@supabase/postgrest-js'
   *
   * const builder = new PostgrestQueryBuilder(
   *   new URL('https://xyzcompany.supabase.co/rest/v1/users'),
-  *   { headers: new Headers({ apikey: 'public-anon-key' }) }
+  *   { headers: new Headers({ apikey: 'publishable-or-anon-key' }) }
   * )
   * ```
   */
   constructor(builder) {
-    var _builder$shouldThrowO, _builder$isMaybeSingl, _builder$urlLengthLim;
+    var _builder$shouldThrowO, _builder$isMaybeSingl, _builder$shouldStripN, _builder$urlLengthLim, _builder$retry;
     this.shouldThrowOnError = false;
+    this.retryEnabled = true;
     this.method = builder.method;
     this.url = builder.url;
     this.headers = new Headers(builder.headers);
@@ -14095,7 +14967,9 @@ var PostgrestBuilder = class {
     this.shouldThrowOnError = (_builder$shouldThrowO = builder.shouldThrowOnError) !== null && _builder$shouldThrowO !== void 0 ? _builder$shouldThrowO : false;
     this.signal = builder.signal;
     this.isMaybeSingle = (_builder$isMaybeSingl = builder.isMaybeSingle) !== null && _builder$isMaybeSingl !== void 0 ? _builder$isMaybeSingl : false;
+    this.shouldStripNulls = (_builder$shouldStripN = builder.shouldStripNulls) !== null && _builder$shouldStripN !== void 0 ? _builder$shouldStripN : false;
     this.urlLengthLimit = (_builder$urlLengthLim = builder.urlLengthLimit) !== null && _builder$urlLengthLim !== void 0 ? _builder$urlLengthLim : 8e3;
+    this.retryEnabled = (_builder$retry = builder.retry) !== null && _builder$retry !== void 0 ? _builder$retry : true;
     if (builder.fetch) this.fetch = builder.fetch;
     else this.fetch = fetch;
   }
@@ -14112,6 +14986,60 @@ var PostgrestBuilder = class {
     return this;
   }
   /**
+  * Strip null values from the response data. Properties with `null` values
+  * will be omitted from the returned JSON objects.
+  *
+  * Requires PostgREST 11.2.0+.
+  *
+  * {@link https://docs.postgrest.org/en/stable/references/api/resource_representation.html#stripped-nulls}
+  *
+  * @category Database
+  *
+  * @example With `select()`
+  * ```ts
+  * const { data, error } = await supabase
+  *   .from('characters')
+  *   .select()
+  *   .stripNulls()
+  * ```
+  *
+  * @exampleSql With `select()`
+  * ```sql
+  * create table
+  *   characters (id int8 primary key, name text, bio text);
+  *
+  * insert into
+  *   characters (id, name, bio)
+  * values
+  *   (1, 'Luke', null),
+  *   (2, 'Leia', 'Princess of Alderaan');
+  * ```
+  *
+  * @exampleResponse With `select()`
+  * ```json
+  * {
+  *   "data": [
+  *     {
+  *       "id": 1,
+  *       "name": "Luke"
+  *     },
+  *     {
+  *       "id": 2,
+  *       "name": "Leia",
+  *       "bio": "Princess of Alderaan"
+  *     }
+  *   ],
+  *   "status": 200,
+  *   "statusText": "OK"
+  * }
+  * ```
+  */
+  stripNulls() {
+    if (this.headers.get("Accept") === "text/csv") throw new Error("stripNulls() cannot be used with csv()");
+    this.shouldStripNulls = true;
+    return this;
+  }
+  /**
   * Set an HTTP header for the request.
   *
   * @category Database
@@ -14121,79 +15049,79 @@ var PostgrestBuilder = class {
     this.headers.set(name, value);
     return this;
   }
-  /**  *
+  /**
   * @category Database
+  *
+  * Configure retry behavior for this request.
+  *
+  * By default, retries are enabled for idempotent requests (GET, HEAD, OPTIONS)
+  * that fail with network errors or specific HTTP status codes (503, 520).
+  * Retries use exponential backoff (1s, 2s, 4s) with a maximum of 3 attempts.
+  *
+  * @param enabled - Whether to enable retries for this request
+  *
+  * @example
+  * ```ts
+  * // Disable retries for a specific query
+  * const { data, error } = await supabase
+  *   .from('users')
+  *   .select()
+  *   .retry(false)
+  * ```
   */
+  retry(enabled) {
+    this.retryEnabled = enabled;
+    return this;
+  }
   then(onfulfilled, onrejected) {
     var _this = this;
     if (this.schema === void 0) {
     } else if (["GET", "HEAD"].includes(this.method)) this.headers.set("Accept-Profile", this.schema);
     else this.headers.set("Content-Profile", this.schema);
     if (this.method !== "GET" && this.method !== "HEAD") this.headers.set("Content-Type", "application/json");
+    if (this.shouldStripNulls) {
+      const currentAccept = this.headers.get("Accept");
+      if (currentAccept === "application/vnd.pgrst.object+json") this.headers.set("Accept", "application/vnd.pgrst.object+json;nulls=stripped");
+      else if (!currentAccept || currentAccept === "application/json") this.headers.set("Accept", "application/vnd.pgrst.array+json;nulls=stripped");
+    }
     const _fetch = this.fetch;
-    let res = _fetch(this.url.toString(), {
-      method: this.method,
-      headers: this.headers,
-      body: JSON.stringify(this.body),
-      signal: this.signal
-    }).then(async (res$1) => {
-      let error = null;
-      let data = null;
-      let count2 = null;
-      let status = res$1.status;
-      let statusText = res$1.statusText;
-      if (res$1.ok) {
-        var _this$headers$get2, _res$headers$get;
-        if (_this.method !== "HEAD") {
-          var _this$headers$get;
-          const body = await res$1.text();
-          if (body === "") {
-          } else if (_this.headers.get("Accept") === "text/csv") data = body;
-          else if (_this.headers.get("Accept") && ((_this$headers$get = _this.headers.get("Accept")) === null || _this$headers$get === void 0 ? void 0 : _this$headers$get.includes("application/vnd.pgrst.plan+text"))) data = body;
-          else data = JSON.parse(body);
-        }
-        const countHeader = (_this$headers$get2 = _this.headers.get("Prefer")) === null || _this$headers$get2 === void 0 ? void 0 : _this$headers$get2.match(/count=(exact|planned|estimated)/);
-        const contentRange = (_res$headers$get = res$1.headers.get("content-range")) === null || _res$headers$get === void 0 ? void 0 : _res$headers$get.split("/");
-        if (countHeader && contentRange && contentRange.length > 1) count2 = parseInt(contentRange[1]);
-        if (_this.isMaybeSingle && Array.isArray(data)) if (data.length > 1) {
-          error = {
-            code: "PGRST116",
-            details: `Results contain ${data.length} rows, application/vnd.pgrst.object+json requires 1 row`,
-            hint: null,
-            message: "JSON object requested, multiple (or no) rows returned"
-          };
-          data = null;
-          count2 = null;
-          status = 406;
-          statusText = "Not Acceptable";
-        } else if (data.length === 1) data = data[0];
-        else data = null;
-      } else {
-        const body = await res$1.text();
+    const executeWithRetry = async () => {
+      let attemptCount = 0;
+      while (true) {
+        const requestHeaders = new Headers(_this.headers);
+        if (attemptCount > 0) requestHeaders.set("X-Retry-Count", String(attemptCount));
+        let res$1;
         try {
-          error = JSON.parse(body);
-          if (Array.isArray(error) && res$1.status === 404) {
-            data = [];
-            error = null;
-            status = 200;
-            statusText = "OK";
+          res$1 = await _fetch(_this.url.toString(), {
+            method: _this.method,
+            headers: requestHeaders,
+            body: JSON.stringify(_this.body, (_, value) => typeof value === "bigint" ? value.toString() : value),
+            signal: _this.signal
+          });
+        } catch (fetchError) {
+          if ((fetchError === null || fetchError === void 0 ? void 0 : fetchError.name) === "AbortError" || (fetchError === null || fetchError === void 0 ? void 0 : fetchError.code) === "ABORT_ERR") throw fetchError;
+          if (!RETRYABLE_METHODS.includes(_this.method)) throw fetchError;
+          if (_this.retryEnabled && attemptCount < DEFAULT_MAX_RETRIES) {
+            const delay = getRetryDelay(attemptCount);
+            attemptCount++;
+            await sleep2(delay, _this.signal);
+            continue;
           }
-        } catch (_unused) {
-          if (res$1.status === 404 && body === "") {
-            status = 204;
-            statusText = "No Content";
-          } else error = { message: body };
+          throw fetchError;
+        }
+        if (shouldRetry(_this.method, res$1.status, attemptCount, _this.retryEnabled)) {
+          var _res$headers$get, _res$headers;
+          const retryAfterHeader = (_res$headers$get = (_res$headers = res$1.headers) === null || _res$headers === void 0 ? void 0 : _res$headers.get("Retry-After")) !== null && _res$headers$get !== void 0 ? _res$headers$get : null;
+          const delay = retryAfterHeader !== null ? Math.max(0, parseInt(retryAfterHeader, 10) || 0) * 1e3 : getRetryDelay(attemptCount);
+          await res$1.text();
+          attemptCount++;
+          await sleep2(delay, _this.signal);
+          continue;
         }
-        if (error && _this.shouldThrowOnError) throw new PostgrestError(error);
+        return await _this.processResponse(res$1);
       }
-      return {
-        error,
-        data,
-        count: count2,
-        status,
-        statusText
-      };
-    });
+    };
+    let res = executeWithRetry();
     if (!this.shouldThrowOnError) res = res.catch((fetchError) => {
       var _fetchError$name2;
       let errorDetails = "";
@@ -14226,6 +15154,7 @@ ${cause.stack}`;
         if (urlLength > this.urlLengthLimit) hint += `. Your request URL is ${urlLength} characters. If selecting many fields, consider using views. If filtering with large arrays (e.g., .in('id', [200+ IDs])), consider using an RPC function instead.`;
       }
       return {
+        success: false,
         error: {
           message: `${(_fetchError$name2 = fetchError === null || fetchError === void 0 ? void 0 : fetchError.name) !== null && _fetchError$name2 !== void 0 ? _fetchError$name2 : "FetchError"}: ${fetchError === null || fetchError === void 0 ? void 0 : fetchError.message}`,
           details: errorDetails,
@@ -14241,6 +15170,69 @@ ${cause.stack}`;
     return res.then(onfulfilled, onrejected);
   }
   /**
+  * Process a fetch response and return the standardized postgrest response.
+  */
+  async processResponse(res) {
+    var _this2 = this;
+    let error = null;
+    let data = null;
+    let count2 = null;
+    let status = res.status;
+    let statusText = res.statusText;
+    if (res.ok) {
+      var _this$headers$get2, _res$headers$get2;
+      if (_this2.method !== "HEAD") {
+        var _this$headers$get;
+        const body = await res.text();
+        if (body === "") {
+        } else if (_this2.headers.get("Accept") === "text/csv") data = body;
+        else if (_this2.headers.get("Accept") && ((_this$headers$get = _this2.headers.get("Accept")) === null || _this$headers$get === void 0 ? void 0 : _this$headers$get.includes("application/vnd.pgrst.plan+text"))) data = body;
+        else data = JSON.parse(body);
+      }
+      const countHeader = (_this$headers$get2 = _this2.headers.get("Prefer")) === null || _this$headers$get2 === void 0 ? void 0 : _this$headers$get2.match(/count=(exact|planned|estimated)/);
+      const contentRange = (_res$headers$get2 = res.headers.get("content-range")) === null || _res$headers$get2 === void 0 ? void 0 : _res$headers$get2.split("/");
+      if (countHeader && contentRange && contentRange.length > 1) count2 = parseInt(contentRange[1]);
+      if (_this2.isMaybeSingle && Array.isArray(data)) if (data.length > 1) {
+        error = {
+          code: "PGRST116",
+          details: `Results contain ${data.length} rows, application/vnd.pgrst.object+json requires 1 row`,
+          hint: null,
+          message: "JSON object requested, multiple (or no) rows returned"
+        };
+        data = null;
+        count2 = null;
+        status = 406;
+        statusText = "Not Acceptable";
+      } else if (data.length === 1) data = data[0];
+      else data = null;
+    } else {
+      const body = await res.text();
+      try {
+        error = JSON.parse(body);
+        if (Array.isArray(error) && res.status === 404) {
+          data = [];
+          error = null;
+          status = 200;
+          statusText = "OK";
+        }
+      } catch (_unused) {
+        if (res.status === 404 && body === "") {
+          status = 204;
+          statusText = "No Content";
+        } else error = { message: body };
+      }
+      if (error && _this2.shouldThrowOnError) throw new PostgrestError(error);
+    }
+    return {
+      success: error === null,
+      error,
+      data,
+      count: count2,
+      status,
+      statusText
+    };
+  }
+  /**
   * Override the type of the returned `data`.
   *
   * @typeParam NewResult - The new result type to override with
@@ -16913,22 +17905,39 @@ var PostgrestQueryBuilder = class {
   *
   * @category Database
   *
-  * @example Creating a Postgrest query builder
+  * @param url - The URL for the query
+  * @param options - Named parameters
+  * @param options.headers - Custom headers
+  * @param options.schema - Postgres schema to use
+  * @param options.fetch - Custom fetch implementation
+  * @param options.urlLengthLimit - Maximum URL length before warning
+  * @param options.retry - Enable automatic retries for transient errors (default: true)
+  *
+  * @example Using supabase-js (recommended)
+  * ```ts
+  * import { createClient } from '@supabase/supabase-js'
+  *
+  * const supabase = createClient('https://xyzcompany.supabase.co', 'publishable-or-anon-key')
+  * const { data, error } = await supabase.from('users').select('*')
+  * ```
+  *
+  * @example Standalone import for bundle-sensitive environments
   * ```ts
   * import { PostgrestQueryBuilder } from '@supabase/postgrest-js'
   *
   * const query = new PostgrestQueryBuilder(
   *   new URL('https://xyzcompany.supabase.co/rest/v1/users'),
-  *   { headers: { apikey: 'public-anon-key' } }
+  *   { headers: { apikey: 'publishable-or-anon-key' }, retry: true }
   * )
   * ```
   */
-  constructor(url, { headers = {}, schema, fetch: fetch$1, urlLengthLimit = 8e3 }) {
+  constructor(url, { headers = {}, schema, fetch: fetch$1, urlLengthLimit = 8e3, retry }) {
     this.url = url;
     this.headers = new Headers(headers);
     this.schema = schema;
     this.fetch = fetch$1;
     this.urlLengthLimit = urlLengthLimit;
+    this.retry = retry;
   }
   /**
   * Clone URL and headers to prevent shared state between operations.
@@ -17736,7 +18745,8 @@ var PostgrestQueryBuilder = class {
       headers,
       schema: this.schema,
       fetch: this.fetch,
-      urlLengthLimit: this.urlLengthLimit
+      urlLengthLimit: this.urlLengthLimit,
+      retry: this.retry
     });
   }
   /**
@@ -17870,7 +18880,8 @@ var PostgrestQueryBuilder = class {
       schema: this.schema,
       body: values,
       fetch: (_this$fetch = this.fetch) !== null && _this$fetch !== void 0 ? _this$fetch : fetch,
-      urlLengthLimit: this.urlLengthLimit
+      urlLengthLimit: this.urlLengthLimit,
+      retry: this.retry
     });
   }
   /**
@@ -18103,7 +19114,8 @@ var PostgrestQueryBuilder = class {
       schema: this.schema,
       body: values,
       fetch: (_this$fetch2 = this.fetch) !== null && _this$fetch2 !== void 0 ? _this$fetch2 : fetch,
-      urlLengthLimit: this.urlLengthLimit
+      urlLengthLimit: this.urlLengthLimit,
+      retry: this.retry
     });
   }
   /**
@@ -18257,7 +19269,8 @@ var PostgrestQueryBuilder = class {
       schema: this.schema,
       body: values,
       fetch: (_this$fetch3 = this.fetch) !== null && _this$fetch3 !== void 0 ? _this$fetch3 : fetch,
-      urlLengthLimit: this.urlLengthLimit
+      urlLengthLimit: this.urlLengthLimit,
+      retry: this.retry
     });
   }
   /**
@@ -18389,7 +19402,8 @@ var PostgrestQueryBuilder = class {
       headers,
       schema: this.schema,
       fetch: (_this$fetch4 = this.fetch) !== null && _this$fetch4 !== void 0 ? _this$fetch4 : fetch,
-      urlLengthLimit: this.urlLengthLimit
+      urlLengthLimit: this.urlLengthLimit,
+      retry: this.retry
     });
   }
 };
@@ -18455,15 +19469,16 @@ var PostgrestClient = class PostgrestClient2 {
   * @param options.fetch - Custom fetch
   * @param options.timeout - Optional timeout in milliseconds for all requests. When set, requests will automatically abort after this duration to prevent indefinite hangs.
   * @param options.urlLengthLimit - Maximum URL length in characters before warnings/errors are triggered. Defaults to 8000.
-  * @example
+  * @param options.retry - Enable or disable automatic retries for transient errors.
+  *   When enabled, idempotent requests (GET, HEAD, OPTIONS) that fail with network
+  *   errors or HTTP 503/520 responses will be automatically retried up to 3 times
+  *   with exponential backoff (1s, 2s, 4s). Defaults to `true`.
+  * @example Using supabase-js (recommended)
   * ```ts
-  * import { PostgrestClient } from '@supabase/postgrest-js'
+  * import { createClient } from '@supabase/supabase-js'
   *
-  * const postgrest = new PostgrestClient('https://xyzcompany.supabase.co/rest/v1', {
-  *   headers: { apikey: 'public-anon-key' },
-  *   schema: 'public',
-  *   timeout: 30000, // 30 second timeout
-  * })
+  * const supabase = createClient('https://xyzcompany.supabase.co', 'publishable-or-anon-key')
+  * const { data, error } = await supabase.from('profiles').select('*')
   * ```
   *
   * @category Database
@@ -18472,28 +19487,18 @@ var PostgrestClient = class PostgrestClient2 {
   * - A `timeout` option (in milliseconds) can be set to automatically abort requests that take too long.
   * - A `urlLengthLimit` option (default: 8000) can be set to control when URL length warnings are included in error messages for aborted requests.
   *
-  * @example Creating a Postgrest client
+  * @example Standalone import for bundle-sensitive environments
   * ```ts
   * import { PostgrestClient } from '@supabase/postgrest-js'
   *
   * const postgrest = new PostgrestClient('https://xyzcompany.supabase.co/rest/v1', {
-  *   headers: { apikey: 'public-anon-key' },
-  *   schema: 'public',
-  * })
-  * ```
-  *
-  * @example With timeout
-  * ```ts
-  * import { PostgrestClient } from '@supabase/postgrest-js'
-  *
-  * const postgrest = new PostgrestClient('https://xyzcompany.supabase.co/rest/v1', {
-  *   headers: { apikey: 'public-anon-key' },
+  *   headers: { apikey: 'publishable-or-anon-key' },
   *   schema: 'public',
   *   timeout: 30000, // 30 second timeout
   * })
   * ```
   */
-  constructor(url, { headers = {}, schema, fetch: fetch$1, timeout, urlLengthLimit = 8e3 } = {}) {
+  constructor(url, { headers = {}, schema, fetch: fetch$1, timeout, urlLengthLimit = 8e3, retry } = {}) {
     this.url = url;
     this.headers = new Headers(headers);
     this.schemaName = schema;
@@ -18521,6 +19526,7 @@ var PostgrestClient = class PostgrestClient2 {
       return originalFetch(input, _objectSpread2(_objectSpread2({}, init), {}, { signal: controller.signal })).finally(() => clearTimeout(timeoutId));
     };
     else this.fetch = originalFetch;
+    this.retry = retry;
   }
   /**
   * Perform a query on a table or a view.
@@ -18535,7 +19541,8 @@ var PostgrestClient = class PostgrestClient2 {
       headers: new Headers(this.headers),
       schema: this.schemaName,
       fetch: this.fetch,
-      urlLengthLimit: this.urlLengthLimit
+      urlLengthLimit: this.urlLengthLimit,
+      retry: this.retry
     });
   }
   /**
@@ -18552,7 +19559,8 @@ var PostgrestClient = class PostgrestClient2 {
       headers: this.headers,
       schema,
       fetch: this.fetch,
-      urlLengthLimit: this.urlLengthLimit
+      urlLengthLimit: this.urlLengthLimit,
+      retry: this.retry
     });
   }
   /**
@@ -18749,7 +19757,8 @@ var PostgrestClient = class PostgrestClient2 {
       schema: this.schemaName,
       body,
       fetch: (_this$fetch = this.fetch) !== null && _this$fetch !== void 0 ? _this$fetch : fetch,
-      urlLengthLimit: this.urlLengthLimit
+      urlLengthLimit: this.urlLengthLimit,
+      retry: this.retry
     });
   }
 };
@@ -18868,7 +19877,7 @@ Suggested solution: ${env.workaround}`;
 var websocket_factory_default = WebSocketFactory;
 
 // node_modules/@supabase/realtime-js/dist/module/lib/version.js
-var version = "2.100.1";
+var version = "2.104.1";
 
 // node_modules/@supabase/realtime-js/dist/module/lib/constants.js
 var DEFAULT_VERSION = `realtime-js/${version}`;
@@ -21143,7 +22152,7 @@ var ChannelAdapter = class {
     try {
       push = this.channel.push(event, payload, timeout);
     } catch (error) {
-      throw `tried to push '${event}' to '${this.channel.topic}' before joining. Use channel.subscribe() before pushing events`;
+      throw new Error(`tried to push '${event}' to '${this.channel.topic}' before joining. Use channel.subscribe() before pushing events`);
     }
     if (this.channel.pushBuffer.length > MAX_PUSH_BUFFER_SIZE) {
       const removedPush = this.channel.pushBuffer.shift();
@@ -21243,12 +22252,23 @@ var RealtimeChannel = class _RealtimeChannel {
    *
    * @category Realtime
    *
-   * @example Example for a public channel
+   * @example Using supabase-js (recommended)
+   * ```ts
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'publishable-or-anon-key')
+   * const channel = supabase.channel('room1')
+   * channel
+   *   .on('broadcast', { event: 'cursor-pos' }, (payload) => console.log(payload))
+   *   .subscribe()
+   * ```
+   *
+   * @example Standalone import for bundle-sensitive environments
    * ```ts
    * import RealtimeClient from '@supabase/realtime-js'
    *
    * const client = new RealtimeClient('https://xyzcompany.supabase.co/realtime/v1', {
-   *   params: { apikey: 'public-anon-key' },
+   *   params: { apikey: 'publishable-or-anon-key' },
    * })
    * const channel = new RealtimeChannel('realtime:public:messages', { config: {} }, client)
    * ```
@@ -21274,7 +22294,7 @@ var RealtimeChannel = class _RealtimeChannel {
     this.broadcastEndpointURL = httpEndpointURL(this.socket.socketAdapter.endPointURL());
     this.private = this.params.config.private || false;
     if (!this.private && ((_b = (_a = this.params.config) === null || _a === void 0 ? void 0 : _a.broadcast) === null || _b === void 0 ? void 0 : _b.replay)) {
-      throw `tried to use replay on public channel '${this.topic}'. It must be a private channel.`;
+      throw new Error(`tried to use replay on public channel '${this.topic}'. It must be a private channel.`);
     }
   }
   /**
@@ -21542,9 +22562,11 @@ var RealtimeChannel = class _RealtimeChannel {
    * ```
    */
   on(type, filter, callback) {
-    if (this.channelAdapter.isJoined() && type === REALTIME_LISTEN_TYPES.PRESENCE) {
-      this.socket.log("channel", `cannot add presence callbacks for ${this.topic} after joining.`);
-      throw new Error("cannot add presence callbacks after joining a channel");
+    const stateCheck = this.channelAdapter.isJoined() || this.channelAdapter.isJoining();
+    const typeCheck = type === REALTIME_LISTEN_TYPES.PRESENCE || type === REALTIME_LISTEN_TYPES.POSTGRES_CHANGES;
+    if (stateCheck && typeCheck) {
+      this.socket.log("channel", `cannot add \`${type}\` callbacks for ${this.topic} after \`subscribe()\`.`);
+      throw new Error(`cannot add \`${type}\` callbacks for ${this.topic} after \`subscribe()\`.`);
     }
     return this._on(type, filter, callback);
   }
@@ -21564,7 +22586,7 @@ var RealtimeChannel = class _RealtimeChannel {
   async httpSend(event, payload, opts = {}) {
     var _a;
     if (payload === void 0 || payload === null) {
-      return Promise.reject("Payload is required for httpSend()");
+      return Promise.reject(new Error("Payload is required for httpSend()"));
     }
     const headers = {
       apikey: this.socket.apiKey ? this.socket.apiKey : "",
@@ -21794,8 +22816,8 @@ var RealtimeChannel = class _RealtimeChannel {
   }
   /** @internal */
   _notThisChannelEvent(event, ref) {
-    const { close, error, leave, join } = CHANNEL_EVENTS;
-    const events = [close, error, leave, join];
+    const { close, error, leave, join: join2 } = CHANNEL_EVENTS;
+    const events = [close, error, leave, join2];
     return ref && events.includes(event) && ref !== this.joinPush.ref;
   }
   /** @internal */
@@ -21818,6 +22840,16 @@ var RealtimeChannel = class _RealtimeChannel {
       return payload;
     });
   }
+  copyBindings(other) {
+    if (this.joinedOnce) {
+      throw new Error("cannot copy bindings into joined channel");
+    }
+    for (const kind in other.bindings) {
+      for (const binding of other.bindings[kind]) {
+        this._on(binding.type, binding.filter, binding.callback);
+      }
+    }
+  }
   /**
    * Compares two optional filter values for equality.
    * Treats undefined, null, and empty string as equivalent empty values.
@@ -22038,12 +23070,23 @@ var RealtimeClient = class {
    *
    * @category Realtime
    *
-   * @example Example for a public channel
+   * @example Using supabase-js (recommended)
+   * ```ts
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'publishable-or-anon-key')
+   * const channel = supabase.channel('room1')
+   * channel
+   *   .on('broadcast', { event: 'cursor-pos' }, (payload) => console.log(payload))
+   *   .subscribe()
+   * ```
+   *
+   * @example Standalone import for bundle-sensitive environments
    * ```ts
    * import RealtimeClient from '@supabase/realtime-js'
    *
    * const client = new RealtimeClient('https://xyzcompany.supabase.co/realtime/v1', {
-   *   params: { apikey: 'public-anon-key' },
+   *   params: { apikey: 'publishable-or-anon-key' },
    * })
    * client.connect()
    * ```
@@ -22562,8 +23605,8 @@ var IcebergError = class extends Error {
     return this.status === 419;
   }
 };
-function buildUrl(baseUrl, path12, query) {
-  const url = new URL(path12, baseUrl);
+function buildUrl(baseUrl, path13, query) {
+  const url = new URL(path13, baseUrl);
   if (query) {
     for (const [key, value] of Object.entries(query)) {
       if (value !== void 0) {
@@ -22593,12 +23636,12 @@ function createFetchClient(options) {
   return {
     async request({
       method,
-      path: path12,
+      path: path13,
       query,
       body,
       headers
     }) {
-      const url = buildUrl(options.baseUrl, path12, query);
+      const url = buildUrl(options.baseUrl, path13, query);
       const authHeaders = await buildAuthHeaders(options.auth);
       const res = await fetchFn(url, {
         method,
@@ -23066,6 +24109,57 @@ var IcebergRestCatalog = class {
 };
 
 // node_modules/@supabase/storage-js/dist/index.mjs
+function _typeof2(o2) {
+  "@babel/helpers - typeof";
+  return _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+    return typeof o$1;
+  } : function(o$1) {
+    return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+  }, _typeof2(o2);
+}
+function toPrimitive2(t, r) {
+  if ("object" != _typeof2(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i2 = e.call(t, r || "default");
+    if ("object" != _typeof2(i2)) return i2;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function toPropertyKey2(t) {
+  var i2 = toPrimitive2(t, "string");
+  return "symbol" == _typeof2(i2) ? i2 : i2 + "";
+}
+function _defineProperty2(e, r, t) {
+  return (r = toPropertyKey2(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+function ownKeys2(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o2 = Object.getOwnPropertySymbols(e);
+    r && (o2 = o2.filter(function(r$1) {
+      return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+    })), t.push.apply(t, o2);
+  }
+  return t;
+}
+function _objectSpread22(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys2(Object(t), true).forEach(function(r$1) {
+      _defineProperty2(e, r$1, t[r$1]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys2(Object(t)).forEach(function(r$1) {
+      Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+    });
+  }
+  return e;
+}
 var StorageError = class extends Error {
   constructor(message, namespace = "storage", status, statusCode) {
     super(message);
@@ -23075,6 +24169,14 @@ var StorageError = class extends Error {
     this.status = status;
     this.statusCode = statusCode;
   }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      status: this.status,
+      statusCode: this.statusCode
+    };
+  }
 };
 function isStorageError(error) {
   return typeof error === "object" && error !== null && "__isStorageError" in error;
@@ -23087,12 +24189,7 @@ var StorageApiError = class extends StorageError {
     this.statusCode = statusCode;
   }
   toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      status: this.status,
-      statusCode: this.statusCode
-    };
+    return _objectSpread22({}, super.toJSON());
   }
 };
 var StorageUnknownError = class extends StorageError {
@@ -23102,6 +24199,18 @@ var StorageUnknownError = class extends StorageError {
     this.originalError = originalError;
   }
 };
+function setHeader(headers, name, value) {
+  const result = _objectSpread22({}, headers);
+  const nameLower = name.toLowerCase();
+  for (const key of Object.keys(result)) if (key.toLowerCase() === nameLower) delete result[key];
+  result[nameLower] = value;
+  return result;
+}
+function normalizeHeaders(headers) {
+  const result = {};
+  for (const [key, value] of Object.entries(headers)) result[key.toLowerCase()] = value;
+  return result;
+}
 var resolveFetch2 = (customFetch) => {
   if (customFetch) return (...args) => customFetch(...args);
   return (...args) => fetch(...args);
@@ -23128,57 +24237,6 @@ var isValidBucketName = (bucketName) => {
   if (bucketName.includes("/") || bucketName.includes("\\")) return false;
   return /^[\w!.\*'() &$@=;:+,?-]+$/.test(bucketName);
 };
-function _typeof2(o2) {
-  "@babel/helpers - typeof";
-  return _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
-    return typeof o$1;
-  } : function(o$1) {
-    return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
-  }, _typeof2(o2);
-}
-function toPrimitive2(t, r) {
-  if ("object" != _typeof2(t) || !t) return t;
-  var e = t[Symbol.toPrimitive];
-  if (void 0 !== e) {
-    var i2 = e.call(t, r || "default");
-    if ("object" != _typeof2(i2)) return i2;
-    throw new TypeError("@@toPrimitive must return a primitive value.");
-  }
-  return ("string" === r ? String : Number)(t);
-}
-function toPropertyKey2(t) {
-  var i2 = toPrimitive2(t, "string");
-  return "symbol" == _typeof2(i2) ? i2 : i2 + "";
-}
-function _defineProperty2(e, r, t) {
-  return (r = toPropertyKey2(r)) in e ? Object.defineProperty(e, r, {
-    value: t,
-    enumerable: true,
-    configurable: true,
-    writable: true
-  }) : e[r] = t, e;
-}
-function ownKeys2(e, r) {
-  var t = Object.keys(e);
-  if (Object.getOwnPropertySymbols) {
-    var o2 = Object.getOwnPropertySymbols(e);
-    r && (o2 = o2.filter(function(r$1) {
-      return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
-    })), t.push.apply(t, o2);
-  }
-  return t;
-}
-function _objectSpread22(e) {
-  for (var r = 1; r < arguments.length; r++) {
-    var t = null != arguments[r] ? arguments[r] : {};
-    r % 2 ? ownKeys2(Object(t), true).forEach(function(r$1) {
-      _defineProperty2(e, r$1, t[r$1]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys2(Object(t)).forEach(function(r$1) {
-      Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
-    });
-  }
-  return e;
-}
 var _getErrorMessage = (err) => {
   var _err$error;
   return err.msg || err.message || err.error_description || (typeof err.error === "string" ? err.error : (_err$error = err.error) === null || _err$error === void 0 ? void 0 : _err$error.message) || JSON.stringify(err);
@@ -23204,7 +24262,11 @@ var _getRequestParams = (method, options, parameters, body) => {
   };
   if (method === "GET" || method === "HEAD" || !body) return _objectSpread22(_objectSpread22({}, params), parameters);
   if (isPlainObject2(body)) {
-    params.headers = _objectSpread22({ "Content-Type": "application/json" }, options === null || options === void 0 ? void 0 : options.headers);
+    var _contentType;
+    const headers = (options === null || options === void 0 ? void 0 : options.headers) || {};
+    let contentType;
+    for (const [key, value] of Object.entries(headers)) if (key.toLowerCase() === "content-type") contentType = value;
+    params.headers = setHeader(headers, "Content-Type", (_contentType = contentType) !== null && _contentType !== void 0 ? _contentType : "application/json");
     params.body = JSON.stringify(body);
   } else params.body = body;
   if (options === null || options === void 0 ? void 0 : options.duplex) params.duplex = options.duplex;
@@ -23257,7 +24319,7 @@ var BaseApiClient = class {
   constructor(url, headers = {}, fetch$1, namespace = "storage") {
     this.shouldThrowOnError = false;
     this.url = url;
-    this.headers = headers;
+    this.headers = normalizeHeaders(headers);
     this.fetch = resolveFetch2(fetch$1);
     this.namespace = namespace;
   }
@@ -23280,7 +24342,7 @@ var BaseApiClient = class {
   * @returns this - For method chaining
   */
   setHeader(name, value) {
-    this.headers = _objectSpread22(_objectSpread22({}, this.headers), {}, { [name]: value });
+    this.headers = setHeader(this.headers, name, value);
     return this;
   }
   /**
@@ -23417,7 +24479,7 @@ var StorageFileApi = class extends BaseApiClient {
   * @param path The relative file path. Should be of the format `folder/subfolder/filename.png`. The bucket must already exist before attempting to upload.
   * @param fileBody The body of the file to be stored in the bucket.
   */
-  async uploadOrUpdate(method, path12, fileBody, fileOptions) {
+  async uploadOrUpdate(method, path13, fileBody, fileOptions) {
     var _this = this;
     return _this.handleOperation(async () => {
       let body;
@@ -23440,8 +24502,8 @@ var StorageFileApi = class extends BaseApiClient {
         if (metadata) headers["x-metadata"] = _this.toBase64(_this.encodeMetadata(metadata));
         if ((typeof ReadableStream !== "undefined" && body instanceof ReadableStream || body && typeof body === "object" && "pipe" in body && typeof body.pipe === "function") && !options.duplex) options.duplex = "half";
       }
-      if (fileOptions === null || fileOptions === void 0 ? void 0 : fileOptions.headers) headers = _objectSpread22(_objectSpread22({}, headers), fileOptions.headers);
-      const cleanPath = _this._removeEmptyFolders(path12);
+      if (fileOptions === null || fileOptions === void 0 ? void 0 : fileOptions.headers) for (const [key, value] of Object.entries(fileOptions.headers)) headers = setHeader(headers, key, value);
+      const cleanPath = _this._removeEmptyFolders(path13);
       const _path = _this._getFinalPath(cleanPath);
       const data = await (method == "PUT" ? put : post)(_this.fetch, `${_this.url}/object/${_path}`, body, _objectSpread22({ headers }, (options === null || options === void 0 ? void 0 : options.duplex) ? { duplex: options.duplex } : {}));
       return {
@@ -23502,8 +24564,8 @@ var StorageFileApi = class extends BaseApiClient {
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   * - For React Native, using either `Blob`, `File` or `FormData` does not work as intended. Upload file using `ArrayBuffer` from base64 file data instead, see example below.
   */
-  async upload(path12, fileBody, fileOptions) {
-    return this.uploadOrUpdate("POST", path12, fileBody, fileOptions);
+  async upload(path13, fileBody, fileOptions) {
+    return this.uploadOrUpdate("POST", path13, fileBody, fileOptions);
   }
   /**
   * Upload a file with a token generated from `createSignedUploadUrl`.
@@ -23542,9 +24604,9 @@ var StorageFileApi = class extends BaseApiClient {
   *   - `objects` table permissions: none
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   */
-  async uploadToSignedUrl(path12, token, fileBody, fileOptions) {
+  async uploadToSignedUrl(path13, token, fileBody, fileOptions) {
     var _this3 = this;
-    const cleanPath = _this3._removeEmptyFolders(path12);
+    const cleanPath = _this3._removeEmptyFolders(path13);
     const _path = _this3._getFinalPath(cleanPath);
     const url = new URL(_this3.url + `/object/upload/sign/${_path}`);
     url.searchParams.set("token", token);
@@ -23606,10 +24668,10 @@ var StorageFileApi = class extends BaseApiClient {
   *   - `objects` table permissions: `insert`
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   */
-  async createSignedUploadUrl(path12, options) {
+  async createSignedUploadUrl(path13, options) {
     var _this4 = this;
     return _this4.handleOperation(async () => {
-      let _path = _this4._getFinalPath(path12);
+      let _path = _this4._getFinalPath(path13);
       const headers = _objectSpread22({}, _this4.headers);
       if (options === null || options === void 0 ? void 0 : options.upsert) headers["x-upsert"] = "true";
       const data = await post(_this4.fetch, `${_this4.url}/object/upload/sign/${_path}`, {}, { headers });
@@ -23618,7 +24680,7 @@ var StorageFileApi = class extends BaseApiClient {
       if (!token) throw new StorageError("No token returned by API");
       return {
         signedUrl: url.toString(),
-        path: path12,
+        path: path13,
         token
       };
     });
@@ -23674,8 +24736,8 @@ var StorageFileApi = class extends BaseApiClient {
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   * - For React Native, using either `Blob`, `File` or `FormData` does not work as intended. Update file using `ArrayBuffer` from base64 file data instead, see example below.
   */
-  async update(path12, fileBody, fileOptions) {
-    return this.uploadOrUpdate("PUT", path12, fileBody, fileOptions);
+  async update(path13, fileBody, fileOptions) {
+    return this.uploadOrUpdate("PUT", path13, fileBody, fileOptions);
   }
   /**
   * Moves an existing file to a new path in the same bucket.
@@ -23773,6 +24835,7 @@ var StorageFileApi = class extends BaseApiClient {
   * @param expiresIn The number of seconds until the signed URL expires. For example, `60` for a URL which is valid for one minute.
   * @param options.download triggers the file as a download if set to true. Set this parameter as the name of the file if you want to trigger the download with a different filename.
   * @param options.transform Transform the asset before serving it to the client.
+  * @param options.cacheNonce Append a cache nonce parameter to the URL to invalidate the cache.
   * @returns Promise with response containing signed URL or error
   *
   * @example Create Signed URL
@@ -23822,15 +24885,17 @@ var StorageFileApi = class extends BaseApiClient {
   *   - `objects` table permissions: `select`
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   */
-  async createSignedUrl(path12, expiresIn, options) {
+  async createSignedUrl(path13, expiresIn, options) {
     var _this8 = this;
     return _this8.handleOperation(async () => {
-      let _path = _this8._getFinalPath(path12);
+      let _path = _this8._getFinalPath(path13);
       const hasTransform = typeof (options === null || options === void 0 ? void 0 : options.transform) === "object" && options.transform !== null && Object.keys(options.transform).length > 0;
       let data = await post(_this8.fetch, `${_this8.url}/object/sign/${_path}`, _objectSpread22({ expiresIn }, hasTransform ? { transform: options.transform } : {}), { headers: _this8.headers });
-      const downloadQueryParam = (options === null || options === void 0 ? void 0 : options.download) ? `&download=${options.download === true ? "" : options.download}` : "";
-      const returnedPath = hasTransform && data.signedURL.includes("/object/sign/") ? data.signedURL.replace("/object/sign/", "/render/image/sign/") : data.signedURL;
-      return { signedUrl: encodeURI(`${_this8.url}${returnedPath}${downloadQueryParam}`) };
+      const query = new URLSearchParams();
+      if (options === null || options === void 0 ? void 0 : options.download) query.set("download", options.download === true ? "" : options.download);
+      if ((options === null || options === void 0 ? void 0 : options.cacheNonce) != null) query.set("cacheNonce", String(options.cacheNonce));
+      const queryString = query.toString();
+      return { signedUrl: encodeURI(`${_this8.url}${data.signedURL}${queryString ? `&${queryString}` : ""}`) };
     });
   }
   /**
@@ -23840,6 +24905,7 @@ var StorageFileApi = class extends BaseApiClient {
   * @param paths The file paths to be downloaded, including the current file names. For example `['folder/image.png', 'folder2/image2.png']`.
   * @param expiresIn The number of seconds until the signed URLs expire. For example, `60` for URLs which are valid for one minute.
   * @param options.download triggers the file as a download if set to true. Set this parameter as the name of the file if you want to trigger the download with a different filename.
+  * @param options.cacheNonce Append a cache nonce parameter to the URL to invalidate the cache.
   * @returns Promise with response containing array of objects with signedUrl, path, and error or error
   *
   * @example Create Signed URLs
@@ -23884,8 +24950,11 @@ var StorageFileApi = class extends BaseApiClient {
         expiresIn,
         paths
       }, { headers: _this9.headers });
-      const downloadQueryParam = (options === null || options === void 0 ? void 0 : options.download) ? `&download=${options.download === true ? "" : options.download}` : "";
-      return data.map((datum) => _objectSpread22(_objectSpread22({}, datum), {}, { signedUrl: datum.signedURL ? encodeURI(`${_this9.url}${datum.signedURL}${downloadQueryParam}`) : null }));
+      const query = new URLSearchParams();
+      if (options === null || options === void 0 ? void 0 : options.download) query.set("download", options.download === true ? "" : options.download);
+      if ((options === null || options === void 0 ? void 0 : options.cacheNonce) != null) query.set("cacheNonce", String(options.cacheNonce));
+      const queryString = query.toString();
+      return data.map((datum) => _objectSpread22(_objectSpread22({}, datum), {}, { signedUrl: datum.signedURL ? encodeURI(`${_this9.url}${datum.signedURL}${queryString ? `&${queryString}` : ""}`) : null }));
     });
   }
   /**
@@ -23894,6 +24963,7 @@ var StorageFileApi = class extends BaseApiClient {
   * @category File Buckets
   * @param path The full path and file name of the file to be downloaded. For example `folder/image.png`.
   * @param options.transform Transform the asset before serving it to the client.
+  * @param options.cacheNonce Append a cache nonce parameter to the URL to invalidate the cache.
   * @param parameters Additional fetch parameters like signal for cancellation. Supports standard fetch options including cache control.
   * @returns BlobDownloadBuilder instance for downloading the file
   *
@@ -23952,12 +25022,14 @@ var StorageFileApi = class extends BaseApiClient {
   *   - `objects` table permissions: `select`
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   */
-  download(path12, options, parameters) {
-    const renderPath = typeof (options === null || options === void 0 ? void 0 : options.transform) !== "undefined" ? "render/image/authenticated" : "object";
-    const transformationQuery = this.transformOptsToQueryString((options === null || options === void 0 ? void 0 : options.transform) || {});
-    const queryString = transformationQuery ? `?${transformationQuery}` : "";
-    const _path = this._getFinalPath(path12);
-    const downloadFn = () => get(this.fetch, `${this.url}/${renderPath}/${_path}${queryString}`, {
+  download(path13, options, parameters) {
+    const renderPath = typeof (options === null || options === void 0 ? void 0 : options.transform) === "object" && options.transform !== null && Object.keys(options.transform).length > 0 ? "render/image/authenticated" : "object";
+    const query = new URLSearchParams();
+    if (options === null || options === void 0 ? void 0 : options.transform) this.applyTransformOptsToQuery(query, options.transform);
+    if ((options === null || options === void 0 ? void 0 : options.cacheNonce) != null) query.set("cacheNonce", String(options.cacheNonce));
+    const queryString = query.toString();
+    const _path = this._getFinalPath(path13);
+    const downloadFn = () => get(this.fetch, `${this.url}/${renderPath}/${_path}${queryString ? `?${queryString}` : ""}`, {
       headers: this.headers,
       noResolveJson: true
     }, parameters);
@@ -23986,9 +25058,9 @@ var StorageFileApi = class extends BaseApiClient {
   * }
   * ```
   */
-  async info(path12) {
+  async info(path13) {
     var _this10 = this;
-    const _path = _this10._getFinalPath(path12);
+    const _path = _this10._getFinalPath(path13);
     return _this10.handleOperation(async () => {
       return recursiveToCamel(await get(_this10.fetch, `${_this10.url}/object/info/${_path}`, { headers: _this10.headers }));
     });
@@ -24008,9 +25080,9 @@ var StorageFileApi = class extends BaseApiClient {
   *   .exists('folder/avatar1.png')
   * ```
   */
-  async exists(path12) {
+  async exists(path13) {
     var _this11 = this;
-    const _path = _this11._getFinalPath(path12);
+    const _path = _this11._getFinalPath(path13);
     try {
       await head(_this11.fetch, `${_this11.url}/object/${_path}`, { headers: _this11.headers });
       return {
@@ -24038,6 +25110,7 @@ var StorageFileApi = class extends BaseApiClient {
   * @param path The path and name of the file to generate the public URL for. For example `folder/image.png`.
   * @param options.download Triggers the file as a download if set to true. Set this parameter as the name of the file if you want to trigger the download with a different filename.
   * @param options.transform Transform the asset before serving it to the client.
+  * @param options.cacheNonce Append a cache nonce parameter to the URL to invalidate the cache.
   * @returns Object with public URL
   *
   * @example Returns the URL for an asset in a public bucket
@@ -24087,17 +25160,15 @@ var StorageFileApi = class extends BaseApiClient {
   *   - `objects` table permissions: none
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   */
-  getPublicUrl(path12, options) {
-    const _path = this._getFinalPath(path12);
-    const _queryString = [];
-    const downloadQueryParam = (options === null || options === void 0 ? void 0 : options.download) ? `download=${options.download === true ? "" : options.download}` : "";
-    if (downloadQueryParam !== "") _queryString.push(downloadQueryParam);
-    const renderPath = typeof (options === null || options === void 0 ? void 0 : options.transform) !== "undefined" ? "render/image" : "object";
-    const transformationQuery = this.transformOptsToQueryString((options === null || options === void 0 ? void 0 : options.transform) || {});
-    if (transformationQuery !== "") _queryString.push(transformationQuery);
-    let queryString = _queryString.join("&");
-    if (queryString !== "") queryString = `?${queryString}`;
-    return { data: { publicUrl: encodeURI(`${this.url}/${renderPath}/public/${_path}${queryString}`) } };
+  getPublicUrl(path13, options) {
+    const _path = this._getFinalPath(path13);
+    const query = new URLSearchParams();
+    if (options === null || options === void 0 ? void 0 : options.download) query.set("download", options.download === true ? "" : options.download);
+    if (options === null || options === void 0 ? void 0 : options.transform) this.applyTransformOptsToQuery(query, options.transform);
+    if ((options === null || options === void 0 ? void 0 : options.cacheNonce) != null) query.set("cacheNonce", String(options.cacheNonce));
+    const queryString = query.toString();
+    const renderPath = typeof (options === null || options === void 0 ? void 0 : options.transform) === "object" && options.transform !== null && Object.keys(options.transform).length > 0 ? "render/image" : "object";
+    return { data: { publicUrl: encodeURI(`${this.url}/${renderPath}/public/${_path}`) + (queryString ? `?${queryString}` : "") } };
   }
   /**
   * Deletes files within the same bucket
@@ -24227,10 +25298,10 @@ var StorageFileApi = class extends BaseApiClient {
   *   - `objects` table permissions: `select`
   * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
   */
-  async list(path12, options, parameters) {
+  async list(path13, options, parameters) {
     var _this13 = this;
     return _this13.handleOperation(async () => {
-      const body = _objectSpread22(_objectSpread22(_objectSpread22({}, DEFAULT_SEARCH_OPTIONS), options), {}, { prefix: path12 || "" });
+      const body = _objectSpread22(_objectSpread22(_objectSpread22({}, DEFAULT_SEARCH_OPTIONS), options), {}, { prefix: path13 || "" });
       return await post(_this13.fetch, `${_this13.url}/object/list/${_this13.bucketId}`, body, { headers: _this13.headers }, parameters);
     });
   }
@@ -24294,23 +25365,23 @@ var StorageFileApi = class extends BaseApiClient {
     if (typeof Buffer !== "undefined") return Buffer.from(data).toString("base64");
     return btoa(data);
   }
-  _getFinalPath(path12) {
-    return `${this.bucketId}/${path12.replace(/^\/+/, "")}`;
+  _getFinalPath(path13) {
+    return `${this.bucketId}/${path13.replace(/^\/+/, "")}`;
   }
-  _removeEmptyFolders(path12) {
-    return path12.replace(/^\/|\/$/g, "").replace(/\/+/g, "/");
+  _removeEmptyFolders(path13) {
+    return path13.replace(/^\/|\/$/g, "").replace(/\/+/g, "/");
   }
-  transformOptsToQueryString(transform) {
-    const params = [];
-    if (transform.width) params.push(`width=${transform.width}`);
-    if (transform.height) params.push(`height=${transform.height}`);
-    if (transform.resize) params.push(`resize=${transform.resize}`);
-    if (transform.format) params.push(`format=${transform.format}`);
-    if (transform.quality) params.push(`quality=${transform.quality}`);
-    return params.join("&");
+  /** Modifies the `query`, appending values the from `transform` */
+  applyTransformOptsToQuery(query, transform) {
+    if (transform.width) query.set("width", transform.width.toString());
+    if (transform.height) query.set("height", transform.height.toString());
+    if (transform.resize) query.set("resize", transform.resize);
+    if (transform.format) query.set("format", transform.format);
+    if (transform.quality) query.set("quality", transform.quality.toString());
+    return query;
   }
 };
-var version2 = "2.100.1";
+var version2 = "2.104.1";
 var DEFAULT_HEADERS = { "X-Client-Info": `storage-js/${version2}` };
 var StorageBucketApi = class extends BaseApiClient {
   constructor(url, headers = {}, fetch$1, opts) {
@@ -24619,8 +25690,18 @@ var StorageAnalyticsClient = class extends BaseApiClient {
   * @param headers - HTTP headers to include in requests
   * @param fetch - Optional custom fetch implementation
   *
-  * @example Creating a StorageAnalyticsClient instance
+  * @example Using supabase-js (recommended)
   * ```typescript
+  * import { createClient } from '@supabase/supabase-js'
+  *
+  * const supabase = createClient('https://xyzcompany.supabase.co', 'publishable-or-anon-key')
+  * const { data, error } = await supabase.storage.analytics.listBuckets()
+  * ```
+  *
+  * @example Standalone import for bundle-sensitive environments
+  * ```typescript
+  * import { StorageAnalyticsClient } from '@supabase/storage-js'
+  *
   * const client = new StorageAnalyticsClient(url, headers)
   * ```
   */
@@ -25075,8 +26156,18 @@ var StorageVectorsClient = class extends VectorBucketApi {
   * @param options.headers - Optional headers (for example `Authorization`) applied to every request.
   * @param options.fetch - Optional custom `fetch` implementation for non-browser runtimes.
   *
-  * @example Creating a StorageVectorsClient instance
+  * @example Using supabase-js (recommended)
   * ```typescript
+  * import { createClient } from '@supabase/supabase-js'
+  *
+  * const supabase = createClient('https://xyzcompany.supabase.co', 'publishable-or-anon-key')
+  * const bucket = supabase.storage.vectors.from('embeddings-prod')
+  * ```
+  *
+  * @example Standalone import for bundle-sensitive environments
+  * ```typescript
+  * import { StorageVectorsClient } from '@supabase/storage-js'
+  *
   * const client = new StorageVectorsClient(url, options)
   * ```
   */
@@ -25541,12 +26632,20 @@ var StorageClient = class extends StorageBucketApi {
   * Creates a client for Storage buckets, files, analytics, and vectors.
   *
   * @category File Buckets
-  * @example Creating a Storage client
+  * @example Using supabase-js (recommended)
+  * ```ts
+  * import { createClient } from '@supabase/supabase-js'
+  *
+  * const supabase = createClient('https://xyzcompany.supabase.co', 'publishable-or-anon-key')
+  * const avatars = supabase.storage.from('avatars')
+  * ```
+  *
+  * @example Standalone import for bundle-sensitive environments
   * ```ts
   * import { StorageClient } from '@supabase/storage-js'
   *
   * const storage = new StorageClient('https://xyzcompany.supabase.co/storage/v1', {
-  *   apikey: 'public-anon-key',
+  *   apikey: 'publishable-or-anon-key',
   * })
   * const avatars = storage.from('avatars')
   * ```
@@ -25602,7 +26701,7 @@ var StorageClient = class extends StorageBucketApi {
 };
 
 // node_modules/@supabase/auth-js/dist/module/lib/version.js
-var version3 = "2.100.1";
+var version3 = "2.104.1";
 
 // node_modules/@supabase/auth-js/dist/module/lib/constants.js
 var AUTO_REFRESH_TICK_DURATION_MS = 30 * 1e3;
@@ -25630,6 +26729,14 @@ var AuthError = class extends Error {
     this.status = status;
     this.code = code;
   }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      status: this.status,
+      code: this.code
+    };
+  }
 };
 function isAuthError(error) {
   return typeof error === "object" && error !== null && "__isAuthError" in error;
@@ -25684,12 +26791,7 @@ var AuthImplicitGrantRedirectError = class extends CustomAuthError {
     this.details = details;
   }
   toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      status: this.status,
-      details: this.details
-    };
+    return Object.assign(Object.assign({}, super.toJSON()), { details: this.details });
   }
 };
 function isAuthImplicitGrantRedirectError(error) {
@@ -25702,12 +26804,7 @@ var AuthPKCEGrantCodeExchangeError = class extends CustomAuthError {
     this.details = details;
   }
   toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      status: this.status,
-      details: this.details
-    };
+    return Object.assign(Object.assign({}, super.toJSON()), { details: this.details });
   }
 };
 var AuthPKCECodeVerifierMissingError = class extends CustomAuthError {
@@ -25728,6 +26825,9 @@ var AuthWeakPasswordError = class extends CustomAuthError {
     super(message, "AuthWeakPasswordError", status, "weak_password");
     this.reasons = reasons;
   }
+  toJSON() {
+    return Object.assign(Object.assign({}, super.toJSON()), { reasons: this.reasons });
+  }
 };
 var AuthInvalidJwtError = class extends CustomAuthError {
   constructor(message) {
@@ -26012,7 +27112,7 @@ function decodeJWT(token) {
   };
   return data;
 }
-async function sleep2(time) {
+async function sleep3(time) {
   return await new Promise((accept) => {
     setTimeout(() => accept(null), time);
   });
@@ -26077,7 +27177,7 @@ async function getCodeChallengeAndMethod(storage, storageKey, isPasswordRecovery
   const codeVerifier = generatePKCEVerifier();
   let storedCodeVerifier = codeVerifier;
   if (isPasswordRecovery) {
-    storedCodeVerifier += "/PASSWORD_RECOVERY";
+    storedCodeVerifier += "/recovery";
   }
   await setItemAsync(storage, `${storageKey}-code-verifier`, storedCodeVerifier);
   const codeChallenge = await generatePKCEChallenge(codeVerifier);
@@ -26181,7 +27281,7 @@ function deepClone(obj) {
 
 // node_modules/@supabase/auth-js/dist/module/lib/fetch.js
 var _getErrorMessage2 = (err) => err.msg || err.message || err.error_description || err.error || JSON.stringify(err);
-var NETWORK_ERROR_CODES = [502, 503, 504];
+var NETWORK_ERROR_CODES = [502, 503, 504, 520, 521, 522, 523, 524, 530];
 async function handleError2(error) {
   var _a;
   if (!looksLikeFetchResponse(error)) {
@@ -26324,7 +27424,15 @@ var GoTrueAdminApi = class {
   /**
    * Creates an admin API client that can be used to manage users and OAuth clients.
    *
-   * @example
+   * @example Using supabase-js (recommended)
+   * ```ts
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'secret-or-service-role-key')
+   * const { data, error } = await supabase.auth.admin.listUsers()
+   * ```
+   *
+   * @example Standalone import for bundle-sensitive environments
    * ```ts
    * import { GoTrueAdminApi } from '@supabase/auth-js'
    *
@@ -28283,13 +29391,21 @@ var GoTrueClient = class _GoTrueClient {
   /**
    * Create a new client for use in the browser.
    *
-   * @example
+   * @example Using supabase-js (recommended)
+   * ```ts
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'publishable-or-anon-key')
+   * const { data, error } = await supabase.auth.getUser()
+   * ```
+   *
+   * @example Standalone import for bundle-sensitive environments
    * ```ts
    * import { GoTrueClient } from '@supabase/auth-js'
    *
    * const auth = new GoTrueClient({
    *   url: 'https://xyzcompany.supabase.co/auth/v1',
-   *   headers: { apikey: 'public-anon-key' },
+   *   headers: { apikey: 'publishable-or-anon-key' },
    *   storageKey: 'supabase-auth',
    * })
    * ```
@@ -29599,7 +30715,7 @@ var GoTrueClient = class _GoTrueClient {
       }
       if (data.session) {
         await this._saveSession(data.session);
-        await this._notifyAllSubscribers("SIGNED_IN", data.session);
+        await this._notifyAllSubscribers(redirectType === "recovery" ? "PASSWORD_RECOVERY" : "SIGNED_IN", data.session);
       }
       return this._returnResult({ data: Object.assign(Object.assign({}, data), { redirectType: redirectType !== null && redirectType !== void 0 ? redirectType : null }), error });
     } catch (error) {
@@ -31082,6 +32198,7 @@ var GoTrueClient = class _GoTrueClient {
    * Gets the session data from a URL string
    */
   async _getSessionFromURL(params, callbackUrlType) {
+    var _a;
     try {
       if (!isBrowser())
         throw new AuthImplicitGrantRedirectError("No browser detected.");
@@ -31114,7 +32231,10 @@ var GoTrueClient = class _GoTrueClient {
         const url = new URL(window.location.href);
         url.searchParams.delete("code");
         window.history.replaceState(window.history.state, "", url.toString());
-        return { data: { session: data2.session, redirectType: null }, error: null };
+        return {
+          data: { session: data2.session, redirectType: (_a = data2.redirectType) !== null && _a !== void 0 ? _a : null },
+          error: null
+        };
       }
       const { provider_token, provider_refresh_token, access_token, refresh_token, expires_in, expires_at, token_type } = params;
       if (!access_token || !expires_in || !refresh_token || !token_type) {
@@ -31457,7 +32577,11 @@ var GoTrueClient = class _GoTrueClient {
       } catch (err) {
         await ((_b = this.stateChangeEmitters.get(id)) === null || _b === void 0 ? void 0 : _b.callback("INITIAL_SESSION", null));
         this._debug("INITIAL_SESSION", "callback id", id, "error", err);
-        console.error(err);
+        if (isAuthSessionMissingError(err)) {
+          console.warn(err);
+        } else {
+          console.error(err);
+        }
       }
     });
   }
@@ -31781,7 +32905,7 @@ var GoTrueClient = class _GoTrueClient {
       const startedAt = Date.now();
       return await retryable(async (attempt) => {
         if (attempt > 0) {
-          await sleep2(200 * Math.pow(2, attempt - 1));
+          await sleep3(200 * Math.pow(2, attempt - 1));
         }
         this._debug(debugName, "refreshing attempt", attempt);
         return await _request(this.fetch, "POST", `${this.url}/token?grant_type=refresh_token`, {
@@ -32787,7 +33911,7 @@ var AuthClient = GoTrueClient_default;
 var AuthClient_default = AuthClient;
 
 // node_modules/@supabase/supabase-js/dist/index.mjs
-var version4 = "2.100.1";
+var version4 = "2.104.1";
 var JS_ENV = "";
 if (typeof Deno !== "undefined") JS_ENV = "deno";
 else if (typeof document !== "undefined") JS_ENV = "web";
@@ -33090,7 +34214,7 @@ var SupabaseClient = class {
   * ```ts
   * import { createClient } from '@supabase/supabase-js'
   *
-  * const supabase = createClient('https://xyzcompany.supabase.co', 'public-anon-key')
+  * const supabase = createClient('https://xyzcompany.supabase.co', 'publishable-or-anon-key')
   *
   * const { data } = await supabase.from('profiles').select('*')
   * ```
@@ -33128,7 +34252,8 @@ var SupabaseClient = class {
     this.fetch = fetchWithAuth(supabaseKey, this._getAccessToken.bind(this), settings.global.fetch);
     this.realtime = this._initRealtimeClient(_objectSpread23({
       headers: this.headers,
-      accessToken: this._getAccessToken.bind(this)
+      accessToken: this._getAccessToken.bind(this),
+      fetch: this.fetch
     }, settings.realtime));
     if (this.accessToken) Promise.resolve(this.accessToken()).then((token) => this.realtime.setAuth(token)).catch((e) => console.warn("Failed to set initial Realtime auth token:", e));
     this.rest = new PostgrestClient(new URL("rest/v1", baseUrl).href, {
@@ -33319,7 +34444,7 @@ function shouldShowDeprecationWarning() {
 }
 if (shouldShowDeprecationWarning()) console.warn("\u26A0\uFE0F  Node.js 18 and below are deprecated and will no longer be supported in future versions of @supabase/supabase-js. Please upgrade to Node.js 20 or later. For more information, visit: https://github.com/orgs/supabase/discussions/37217");
 
-// node_modules/@remixhq/core/dist/chunk-EVWDYCBL.js
+// node_modules/@remixhq/core/dist/chunk-P6JHXOV4.js
 var storedSessionSchema = external_exports.object({
   access_token: external_exports.string().min(1),
   refresh_token: external_exports.string().min(1),
@@ -33352,21 +34477,21 @@ async function maybeLoadKeytar() {
 }
 async function ensurePathPermissions(filePath) {
   const dir = import_path7.default.dirname(filePath);
-  await import_promises17.default.mkdir(dir, { recursive: true });
+  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 writeJsonAtomic2(filePath, value) {
-  await import_promises17.default.mkdir(import_path7.default.dirname(filePath), { recursive: true });
+  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 writeJsonAtomic2(filePath, session);
@@ -33376,40 +34501,53 @@ function createLocalSessionStore(params) {
   const service = params?.service?.trim() || "remix-cli";
   const account = params?.account?.trim() || "default";
   const filePath = params?.filePath?.trim() || import_path7.default.join(xdgConfigHome(), "remix", "session.json");
+  async function readKeytar() {
+    const keytar = await maybeLoadKeytar();
+    if (!keytar) return null;
+    const raw = await keytar.getPassword(service, account).catch(() => null);
+    if (!raw) return null;
+    try {
+      const parsed = storedSessionSchema.safeParse(JSON.parse(raw));
+      return parsed.success ? parsed.data : null;
+    } catch {
+      return null;
+    }
+  }
+  async function readFile() {
+    const raw = await import_promises18.default.readFile(filePath, "utf8").catch(() => null);
+    if (!raw) return null;
+    try {
+      const parsed = storedSessionSchema.safeParse(JSON.parse(raw));
+      if (!parsed.success) return null;
+      await ensurePathPermissions(filePath);
+      return parsed.data;
+    } catch {
+      return null;
+    }
+  }
+  function pickFreshest(a2, b) {
+    if (!a2) return b;
+    if (!b) return a2;
+    return a2.expires_at >= b.expires_at ? a2 : b;
+  }
   return {
     async getSession() {
-      const keytar = await maybeLoadKeytar();
-      if (keytar) {
-        const raw2 = await keytar.getPassword(service, account);
-        if (!raw2) return null;
-        try {
-          const parsed = storedSessionSchema.safeParse(JSON.parse(raw2));
-          return parsed.success ? parsed.data : null;
-        } catch {
-          return null;
-        }
-      }
-      const raw = await import_promises17.default.readFile(filePath, "utf8").catch(() => null);
-      if (!raw) return null;
-      try {
-        const parsed = storedSessionSchema.safeParse(JSON.parse(raw));
-        if (!parsed.success) return null;
-        await ensurePathPermissions(filePath);
-        return parsed.data;
-      } catch {
-        return null;
-      }
+      const [k, f] = await Promise.all([readKeytar(), readFile()]);
+      return pickFreshest(k, f);
     },
     async setSession(session) {
       const parsed = storedSessionSchema.safeParse(session);
       if (!parsed.success) {
         throw new Error("Session data is invalid and was not stored.");
       }
+      await writeSessionFileFallback(filePath, parsed.data);
       const keytar = await maybeLoadKeytar();
       if (keytar) {
-        await keytar.setPassword(service, account, JSON.stringify(parsed.data));
+        try {
+          await keytar.setPassword(service, account, JSON.stringify(parsed.data));
+        } catch {
+        }
       }
-      await writeSessionFileFallback(filePath, parsed.data);
     }
   };
 }
@@ -33576,12 +34714,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");
@@ -33599,20 +34737,20 @@ function stateLockMetaPath(sessionId) {
   return import_node_path6.default.join(stateLockPath(sessionId), "owner.json");
 }
 async function writeJsonAtomic3(filePath, value) {
-  await import_promises18.default.mkdir(import_node_path6.default.dirname(filePath), { recursive: true });
+  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;
 var STATE_LOCK_STALE_MS = 3e4;
 var STATE_LOCK_HEARTBEAT_MS = 5e3;
-async function sleep3(ms) {
+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);
@@ -33637,13 +34775,13 @@ async function tryRemoveStaleStateLock(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;
     }
   }
@@ -33652,10 +34790,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 = {
@@ -33680,7 +34818,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) {
@@ -33694,7 +34832,7 @@ async function acquireStateLock(sessionId) {
       if (Date.now() >= deadline) {
         throw new Error(`Timed out acquiring hook state lock for session ${sessionId}.`);
       }
-      await sleep3(STATE_LOCK_POLL_MS);
+      await sleep4(STATE_LOCK_POLL_MS);
     }
   }
 }
@@ -33798,7 +34936,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);
@@ -33886,6 +35024,36 @@ async function markTouchedRepoRecordingFailure(sessionId, repoRoot, params) {
     current.lastTouchedAt = (/* @__PURE__ */ new Date()).toISOString();
   });
 }
+function lastFinalizedPath(sessionId) {
+  return import_node_path6.default.join(stateRoot(), `${sessionId}.last-finalized.json`);
+}
+async function markLastFinalizedTurn(sessionId, turnId, prompt) {
+  const record = {
+    sessionId,
+    turnId,
+    prompt,
+    finalizedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeJsonAtomic3(lastFinalizedPath(sessionId), record);
+}
+async function loadLastFinalizedTurn(sessionId) {
+  const raw = await import_promises19.default.readFile(lastFinalizedPath(sessionId), "utf8").catch(() => null);
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.sessionId === "string" && typeof parsed.turnId === "string" && typeof parsed.prompt === "string" && typeof parsed.finalizedAt === "string") {
+      return {
+        sessionId: parsed.sessionId,
+        turnId: parsed.turnId,
+        prompt: parsed.prompt,
+        finalizedAt: parsed.finalizedAt
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 async function markPendingTurnFailure(sessionId, params) {
   await updatePendingTurnState(sessionId, (existing) => {
     existing.turnFailureMessage = params.message.trim();
@@ -33900,14 +35068,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.18",
+  version: "0.1.19",
   description: "Claude Code plugin for Remix collaboration workflows",
   homepage: "https://github.com/RemixDotOne/remix-claude-plugin",
   license: "MIT",
@@ -33930,16 +35098,27 @@ var package_default = {
     "hooks",
     "agents"
   ],
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./historical": {
+      types: "./dist/historical.d.ts",
+      import: "./dist/historical.js"
+    }
+  },
   scripts: {
     build: "tsup",
     postbuild: `node -e "const fs=require('node:fs'); for (const p of ['dist/mcp-server.cjs','dist/hook-pre-git.cjs','dist/hook-user-prompt.cjs','dist/hook-post-collab.cjs','dist/hook-stop-collab.cjs']) fs.chmodSync(p, 0o755);"`,
     dev: "tsx src/mcp-server.ts",
     typecheck: "tsc -p tsconfig.json --noEmit",
+    test: "node --import tsx --test src/**/*.test.ts",
     prepack: "npm run build"
   },
   dependencies: {
-    "@remixhq/core": "^0.1.13",
-    "@remixhq/mcp": "^0.1.13"
+    "@remixhq/core": "^0.1.14",
+    "@remixhq/mcp": "^0.1.14"
   },
   devDependencies: {
     "@types/node": "^25.4.0",
@@ -33990,13 +35169,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()) {
@@ -34016,7 +35195,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(),
@@ -34033,15 +35212,597 @@ 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/usage/claudeCodeUsageHarvester.ts
+var BOUNDARY_TIMESTAMP_TOLERANCE_MS = 500;
+function parseTimestamp(value) {
+  if (typeof value !== "string") return null;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? ms : null;
+}
+function extractUserContentText(message) {
+  if (!message || typeof message !== "object") return null;
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const textBlocks = content.filter((block) => Boolean(block) && typeof block === "object").filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text);
+    if (textBlocks.length === 0) return null;
+    return textBlocks.join("\n");
+  }
+  return null;
+}
+function isUserBoundary(event) {
+  return event.type === "user" && event.isMeta !== true && event.isSidechain !== true;
+}
+function findBoundary(sessionEvents, promptText, submittedAt, upperMs) {
+  const isWithinUpperBound = (ev) => {
+    if (upperMs === null) return true;
+    const ms = parseTimestamp(ev.timestamp);
+    return ms !== null && ms < upperMs;
+  };
+  let contentMatch = null;
+  for (let i2 = sessionEvents.length - 1; i2 >= 0; i2--) {
+    const ev = sessionEvents[i2];
+    if (!isUserBoundary(ev)) continue;
+    if (!isWithinUpperBound(ev)) continue;
+    const text = extractUserContentText(ev.message);
+    if (text !== null && text === promptText) {
+      contentMatch = ev;
+      break;
+    }
+  }
+  if (contentMatch) return { boundary: contentMatch, usedFallback: false };
+  const submittedMs = parseTimestamp(submittedAt);
+  if (submittedMs === null) return { boundary: null, usedFallback: false };
+  for (let i2 = sessionEvents.length - 1; i2 >= 0; i2--) {
+    const ev = sessionEvents[i2];
+    if (!isUserBoundary(ev)) continue;
+    if (!isWithinUpperBound(ev)) continue;
+    const ms = parseTimestamp(ev.timestamp);
+    if (ms === null) continue;
+    if (ms >= submittedMs - BOUNDARY_TIMESTAMP_TOLERANCE_MS) {
+      return { boundary: ev, usedFallback: true };
+    }
+  }
+  return { boundary: null, usedFallback: false };
+}
+function asNumberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asStringOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function extractAssistantMessage(event) {
+  const message = event.message;
+  if (!message || typeof message !== "object") return null;
+  const msg = message;
+  if (msg.role !== "assistant" && msg.role !== void 0) {
+  }
+  const content = Array.isArray(msg.content) ? msg.content : [];
+  const usage = msg.usage && typeof msg.usage === "object" ? msg.usage : null;
+  return {
+    id: asStringOrNull(msg.id),
+    model: asStringOrNull(msg.model),
+    content,
+    usage
+  };
+}
+function usageIsComplete(usage) {
+  if (!usage) return false;
+  const hasInput = typeof usage.input_tokens === "number";
+  const hasOutput = typeof usage.output_tokens === "number";
+  const hasCacheRead = typeof usage.cache_read_input_tokens === "number";
+  return hasInput && hasOutput && hasCacheRead;
+}
+function buildModelCall(event, msg) {
+  const usage = msg.usage ?? {};
+  const cacheCreation = usage.cache_creation && typeof usage.cache_creation === "object" ? usage.cache_creation : null;
+  const has5m = cacheCreation && typeof cacheCreation.ephemeral_5m_input_tokens === "number";
+  const has1h = cacheCreation && typeof cacheCreation.ephemeral_1h_input_tokens === "number";
+  const cacheWrite5mTokens = has5m ? cacheCreation.ephemeral_5m_input_tokens : null;
+  const cacheWrite1hTokens = has1h ? cacheCreation.ephemeral_1h_input_tokens : null;
+  const splitAvailable = has5m || has1h;
+  const cacheWriteTokens = splitAvailable ? null : asNumberOrNull(usage.cache_creation_input_tokens);
+  return {
+    provider: "anthropic",
+    model: msg.model,
+    tier: asStringOrNull(usage.service_tier),
+    requestId: asStringOrNull(event.requestId),
+    timestamp: asStringOrNull(event.timestamp),
+    isSidechain: event.isSidechain === true,
+    inputTokens: asNumberOrNull(usage.input_tokens),
+    outputTokens: asNumberOrNull(usage.output_tokens),
+    cacheReadTokens: asNumberOrNull(usage.cache_read_input_tokens),
+    cacheWriteTokens,
+    cacheWrite5mTokens,
+    cacheWrite1hTokens,
+    reasoningTokens: null,
+    audioInputTokens: null,
+    imageInputTokens: null
+  };
+}
+function scanServerToolUses(content) {
+  const uses = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const b = block;
+    const id = b.id;
+    if (typeof id !== "string" || !id.startsWith("srvtoolu_")) continue;
+    const name = typeof b.name === "string" ? b.name : "";
+    switch (name) {
+      case "web_search":
+        uses.push({ tool: "web_search", unit: "per_request", isKnown: true, id, source: "direct" });
+        break;
+      case "web_fetch":
+        uses.push({ tool: "web_fetch", unit: "per_request", isKnown: true, id, source: "direct" });
+        break;
+      case "code_execution":
+        uses.push({ tool: "code_execution", unit: "invocation", isKnown: true, id, source: "direct" });
+        break;
+      default:
+        uses.push({ tool: name || "unknown", unit: "invocation", isKnown: false, id, source: "direct" });
+        break;
+    }
+  }
+  return uses;
+}
+function buildClientToolNameMap(turnEvents) {
+  const map = /* @__PURE__ */ new Map();
+  for (const ev of turnEvents) {
+    if (ev.type !== "assistant") continue;
+    const msg = ev.message;
+    if (!msg || typeof msg !== "object") continue;
+    const content = msg.content;
+    if (!Array.isArray(content)) continue;
+    for (const block of content) {
+      if (!block || typeof block !== "object") continue;
+      const b = block;
+      if (b.type !== "tool_use") continue;
+      const id = b.id;
+      const name = b.name;
+      if (typeof id !== "string" || typeof name !== "string") continue;
+      if (!id.startsWith("toolu_")) continue;
+      map.set(id, name);
+    }
+  }
+  return map;
+}
+function scanEmbeddedServerToolUses(turnEvents, clientToolNames) {
+  const uses = [];
+  for (const ev of turnEvents) {
+    if (ev.type !== "user") continue;
+    const tur = ev.toolUseResult;
+    if (!tur || typeof tur !== "object") continue;
+    const results = tur.results;
+    if (!Array.isArray(results)) continue;
+    let parentToolName = "";
+    const userMsg = ev.message;
+    if (userMsg && typeof userMsg === "object") {
+      const userContent = userMsg.content;
+      if (Array.isArray(userContent)) {
+        for (const block of userContent) {
+          if (!block || typeof block !== "object") continue;
+          const b = block;
+          if (b.type !== "tool_result") continue;
+          const parentId = b.tool_use_id;
+          if (typeof parentId === "string") {
+            parentToolName = clientToolNames.get(parentId) ?? "";
+            break;
+          }
+        }
+      }
+    }
+    for (const entry of results) {
+      if (!entry || typeof entry !== "object") continue;
+      const srvId = entry.tool_use_id;
+      if (typeof srvId !== "string" || !srvId.startsWith("srvtoolu_")) continue;
+      if (parentToolName === "WebFetch") {
+        uses.push({ tool: "web_fetch", unit: "per_request", isKnown: true, id: srvId, source: "embedded" });
+      } else {
+        uses.push({ tool: "web_search", unit: "per_request", isKnown: true, id: srvId, source: "embedded" });
+      }
+    }
+  }
+  return uses;
+}
+function dedupeByServerToolId(records) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const existing = seen.get(r.id);
+    if (!existing) {
+      seen.set(r.id, r);
+      continue;
+    }
+    if (existing.source === "embedded" && r.source === "direct") {
+      seen.set(r.id, r);
+    }
+  }
+  return Array.from(seen.values());
+}
+function aggregateServerTools(uses) {
+  const map = /* @__PURE__ */ new Map();
+  let sawUnknown = false;
+  let sawEmbedded = false;
+  for (const use of uses) {
+    if (!use.isKnown) sawUnknown = true;
+    if (use.source === "embedded") sawEmbedded = true;
+    const key = `anthropic|${use.tool}|${use.unit}`;
+    const existing = map.get(key);
+    if (existing) {
+      existing.quantity += 1;
+    } else {
+      map.set(key, { provider: "anthropic", tool: use.tool, unit: use.unit, quantity: 1 });
+    }
+  }
+  return { serverTools: Array.from(map.values()), sawUnknown, sawEmbedded };
+}
+function sumCrossCheckCounts(usageBlocks) {
+  const totals = /* @__PURE__ */ new Map();
+  const keyFor = (raw) => {
+    if (raw === "web_search_requests") return "web_search";
+    if (raw === "web_fetch_requests") return "web_fetch";
+    return null;
+  };
+  for (const usage of usageBlocks) {
+    const stu = usage.server_tool_use;
+    if (!stu || typeof stu !== "object") continue;
+    for (const [rawKey, rawVal] of Object.entries(stu)) {
+      const mapped = keyFor(rawKey);
+      if (!mapped) continue;
+      if (typeof rawVal !== "number" || !Number.isFinite(rawVal)) continue;
+      totals.set(mapped, (totals.get(mapped) ?? 0) + rawVal);
+    }
+  }
+  return totals;
+}
+function primaryToolCounts(serverTools) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of serverTools) {
+    map.set(entry.tool, (map.get(entry.tool) ?? 0) + entry.quantity);
+  }
+  return map;
+}
+function resolveVersion(events) {
+  for (const ev of events) {
+    if (typeof ev.version === "string" && ev.version.trim()) return ev.version.trim();
+  }
+  return null;
+}
+function buildTurnUsage(args) {
+  const assistantEvents = args.turnEvents.filter((ev) => ev.type === "assistant");
+  if (assistantEvents.length === 0) {
+    return { ok: false, reason: "no_messages_for_turn" };
+  }
+  const warnings = [...args.initialWarnings];
+  const calls = [];
+  const usageBlocks = [];
+  let anyIncomplete = false;
+  let anyComplete = false;
+  let sawLumpSumFallback = false;
+  const collectedServerToolUses = [];
+  const mainModels = /* @__PURE__ */ new Set();
+  const sidechainModels = /* @__PURE__ */ new Set();
+  for (const ev of assistantEvents) {
+    const msg = extractAssistantMessage(ev);
+    if (!msg) continue;
+    if (usageIsComplete(msg.usage)) {
+      anyComplete = true;
+    } else {
+      anyIncomplete = true;
+    }
+    if (msg.usage) usageBlocks.push(msg.usage);
+    const call = buildModelCall(ev, msg);
+    calls.push(call);
+    if (call.cacheWrite5mTokens === null && call.cacheWrite1hTokens === null && call.cacheWriteTokens !== null) {
+      sawLumpSumFallback = true;
+    }
+    collectedServerToolUses.push(...scanServerToolUses(msg.content));
+    if (call.model) {
+      if (call.isSidechain) sidechainModels.add(call.model);
+      else mainModels.add(call.model);
+    }
+  }
+  if (calls.length === 0) {
+    return { ok: false, reason: "no_messages_for_turn" };
+  }
+  if (sawLumpSumFallback) {
+    warnings.push({
+      code: "cache_split_unavailable",
+      message: "Assistant message reported lump-sum cache_creation_input_tokens without the 5m/1h split."
+    });
+  }
+  const clientToolNames = buildClientToolNameMap(args.turnEvents);
+  const embeddedUses = scanEmbeddedServerToolUses(args.turnEvents, clientToolNames);
+  const merged = dedupeByServerToolId([...collectedServerToolUses, ...embeddedUses]);
+  const { serverTools, sawUnknown, sawEmbedded } = aggregateServerTools(merged);
+  if (sawUnknown) {
+    warnings.push({
+      code: "unknown_server_tool",
+      message: "Encountered a server tool whose name is not in the known list (web_search, web_fetch, code_execution)."
+    });
+  }
+  const crossCheck = sumCrossCheckCounts(usageBlocks);
+  const primary = primaryToolCounts(serverTools);
+  const allTools = /* @__PURE__ */ new Set([...crossCheck.keys(), ...primary.keys()]);
+  for (const tool of allTools) {
+    const crossVal = crossCheck.get(tool) ?? 0;
+    const primVal = primary.get(tool) ?? 0;
+    if (crossVal === primVal) continue;
+    if (sawEmbedded && crossVal === 0) continue;
+    warnings.push({
+      code: "server_tool_count_mismatch",
+      message: `Server-tool ${tool} count mismatch: srvtoolu_ scan=${primVal}, usage.server_tool_use=${crossVal}. Trusting srvtoolu_ count.`
+    });
+    break;
+  }
+  const subagentMismatch = mainModels.size > 0 && sidechainModels.size > 0 && [...sidechainModels].some((m) => !mainModels.has(m));
+  if (subagentMismatch) {
+    warnings.push({
+      code: "subagent_model_differs",
+      message: "At least one sidechain ModelCall uses a model different from the main-chain model in this turn."
+    });
+  }
+  let confidence;
+  if (!anyComplete && anyIncomplete) confidence = "unknown";
+  else if (anyIncomplete) confidence = "partial";
+  else if (anyComplete) confidence = "exact";
+  else confidence = "unknown";
+  if (args.checkSubsequentEvent) {
+    const lastAssistantMs = (() => {
+      const msList = assistantEvents.map((ev) => parseTimestamp(ev.timestamp)).filter((ms) => ms !== null);
+      return msList.length ? Math.max(...msList) : null;
+    })();
+    const hasSubsequent = lastAssistantMs !== null && args.sessionEvents.some((ev) => {
+      const ms = parseTimestamp(ev.timestamp);
+      if (ms === null || ms <= lastAssistantMs) return false;
+      if (args.upperMs !== null && ms >= args.upperMs) return false;
+      return true;
+    });
+    if (!hasSubsequent && confidence === "exact") {
+      confidence = "partial";
+      warnings.push({
+        code: "transcript_truncated",
+        message: "Previous turn has no subsequent event after its last assistant message; transcript may be truncated."
+      });
+    }
+  }
+  const resolvedVersion = args.agent.version ?? resolveVersion(args.turnEvents) ?? resolveVersion(args.sessionEvents);
+  const usage = {
+    schemaVersion: 1,
+    capturedAt: args.capturedAt,
+    captureSource: args.captureSource,
+    confidence,
+    agent: {
+      name: args.agent.name,
+      version: resolvedVersion,
+      sessionId: args.agent.sessionId,
+      turnId: args.agent.turnId,
+      plan: args.agent.plan
+    },
+    calls,
+    serverTools,
+    warnings,
+    extensions: args.extensions
+  };
+  return { ok: true, usage };
+}
+function harvestClaudeCodeUsage(input) {
+  const sessionEvents = input.events.filter((ev) => ev.sessionId === input.sessionId);
+  const upperMs = input.nextBoundaryAt ? parseTimestamp(input.nextBoundaryAt) : null;
+  const { boundary, usedFallback } = findBoundary(
+    sessionEvents,
+    input.promptText,
+    input.submittedAt,
+    upperMs
+  );
+  if (!boundary) {
+    return { ok: false, reason: "no_user_boundary_found" };
+  }
+  const boundaryMs = parseTimestamp(boundary.timestamp);
+  if (boundaryMs === null) {
+    return { ok: false, reason: "no_user_boundary_found" };
+  }
+  const turnEvents = sessionEvents.filter((ev) => {
+    const ms = parseTimestamp(ev.timestamp);
+    if (ms === null || ms <= boundaryMs) return false;
+    if (upperMs !== null && ms >= upperMs) return false;
+    return true;
+  });
+  const initialWarnings = [];
+  if (usedFallback) {
+    initialWarnings.push({
+      code: "transcript_truncated",
+      message: "Prompt-text equality match failed; used timestamp-tolerance fallback to locate the user boundary."
+    });
+  }
+  const built = buildTurnUsage({
+    sessionEvents,
+    turnEvents,
+    upperMs,
+    initialWarnings,
+    agent: input.agent,
+    capturedAt: input.capturedAt,
+    captureSource: "hook",
+    extensions: input.extensions,
+    checkSubsequentEvent: input.checkSubsequentEvent === true
+  });
+  if (!built.ok) return built;
+  return {
+    ok: true,
+    usage: built.usage,
+    boundaryAt: typeof boundary.timestamp === "string" ? boundary.timestamp : null
+  };
+}
+
+// src/usage/claudeCodeSession.ts
+var import_node_child_process6 = require("child_process");
+var import_node_fs6 = require("fs");
+var import_node_os6 = require("os");
+var import_node_path8 = require("path");
+var CACHE_SCHEMA_VERSION = 1;
+var SUCCESS_TTL_MS = 60 * 60 * 1e3;
+var FAILURE_TTL_MS = 5 * 60 * 1e3;
+var DEFAULT_SPAWN_TIMEOUT_MS = 5e3;
+var inProcessCache = null;
+var spawnerImpl = defaultSpawnClaudeAuthStatus;
+function defaultSpawnClaudeAuthStatus(timeoutMs) {
+  let result;
+  try {
+    result = (0, import_node_child_process6.spawnSync)("claude", ["auth", "status", "--json"], {
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: timeoutMs,
+      env: process.env
+    });
+  } catch {
+    return { stdout: "", status: -1, failed: true };
+  }
+  if (result.error) {
+    return { stdout: "", status: -1, failed: true };
+  }
+  return {
+    stdout: result.stdout?.toString("utf8") ?? "",
+    status: result.status ?? -1,
+    failed: false
+  };
+}
+function getCollabStateRoot2() {
+  const configured = process.env.REMIX_COLLAB_STATE_ROOT?.trim();
+  return configured || (0, import_node_path8.join)((0, import_node_os6.homedir)(), ".remix", "collab-state");
+}
+function getAuthCachePath() {
+  return (0, import_node_path8.join)(getCollabStateRoot2(), "claude-auth-cache.json");
+}
+function getSpawnTimeoutMs() {
+  const raw = process.env.REMIX_CLAUDE_AUTH_TIMEOUT_MS?.trim();
+  if (!raw) return DEFAULT_SPAWN_TIMEOUT_MS;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_SPAWN_TIMEOUT_MS;
+  return parsed;
+}
+function readAuthCache() {
+  let raw;
+  try {
+    raw = (0, import_node_fs6.readFileSync)(getAuthCachePath(), "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const record = parsed;
+  if (record.schemaVersion !== CACHE_SCHEMA_VERSION) return null;
+  const planRaw = record.plan;
+  const capturedAtRaw = record.capturedAt;
+  const ttlRaw = record.ttlMs;
+  const plan = planRaw === null ? null : typeof planRaw === "string" && planRaw.trim().length > 0 ? planRaw.trim() : null;
+  if (typeof capturedAtRaw !== "string") return null;
+  if (typeof ttlRaw !== "number" || !Number.isFinite(ttlRaw) || ttlRaw <= 0) return null;
+  return { schemaVersion: CACHE_SCHEMA_VERSION, plan, capturedAt: capturedAtRaw, ttlMs: ttlRaw };
+}
+function isCacheFresh(record) {
+  const captured = Date.parse(record.capturedAt);
+  if (!Number.isFinite(captured)) return false;
+  return Date.now() - captured < record.ttlMs;
+}
+function writeAuthCache(record) {
+  const cachePath = getAuthCachePath();
+  try {
+    (0, import_node_fs6.mkdirSync)((0, import_node_path8.dirname)(cachePath), { recursive: true });
+    const tmpPath = `${cachePath}.${process.pid}.${Date.now()}.tmp`;
+    (0, import_node_fs6.writeFileSync)(tmpPath, JSON.stringify(record), "utf8");
+    (0, import_node_fs6.renameSync)(tmpPath, cachePath);
+  } catch {
+  }
+}
+function parseAuthStatusJson(stdout) {
+  if (!stdout) return { plan: null };
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return { plan: null };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { plan: null };
+  const root = parsed;
+  if (root.loggedIn === false) return { plan: null };
+  const subscriptionTypeRaw = root.subscriptionType;
+  if (typeof subscriptionTypeRaw !== "string") return { plan: null };
+  const plan = subscriptionTypeRaw.trim();
+  return { plan: plan.length > 0 ? plan : null };
+}
+function probeClaudePlan() {
+  if (inProcessCache) return inProcessCache;
+  const cached = readAuthCache();
+  if (cached && isCacheFresh(cached)) {
+    inProcessCache = { plan: cached.plan };
+    return inProcessCache;
+  }
+  const result = spawnerImpl(getSpawnTimeoutMs());
+  let probed;
+  if (result.failed || result.status !== 0) {
+    probed = { plan: null };
+  } else {
+    probed = parseAuthStatusJson(result.stdout);
+  }
+  inProcessCache = probed;
+  writeAuthCache({
+    schemaVersion: CACHE_SCHEMA_VERSION,
+    plan: probed.plan,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ttlMs: probed.plan === null ? FAILURE_TTL_MS : SUCCESS_TTL_MS
+  });
+  return probed;
+}
+function resolveClaudeCodeSession(hookPayload) {
+  const sessionIdRaw = hookPayload?.session_id;
+  const sessionId = typeof sessionIdRaw === "string" && sessionIdRaw.trim() ? sessionIdRaw.trim() : null;
+  const probe = probeClaudePlan();
+  return {
+    agent: { name: "claude-code", sessionId, plan: probe.plan },
+    extensions: null
+  };
+}
+
+// src/usage/claudeCodeTranscript.ts
+var import_promises21 = __toESM(require("fs/promises"), 1);
+async function readAndParseTranscript(transcriptPath) {
+  let raw;
+  try {
+    raw = await import_promises21.default.readFile(transcriptPath, "utf8");
+  } catch (err) {
+    const code = err && typeof err === "object" && "code" in err ? err.code : null;
+    if (code === "ENOENT") {
+      return { ok: false, reason: "transcript_not_found" };
+    }
+    return { ok: false, reason: "transcript_unreadable" };
+  }
+  const events = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        events.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return { ok: true, events };
+}
+
 // src/hook-utils.ts
-var import_promises20 = __toESM(require("fs/promises"), 1);
-var import_node_path8 = __toESM(require("path"), 1);
+var import_promises22 = __toESM(require("fs/promises"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 async function readJsonStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -34103,16 +35864,16 @@ 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 current = import_node_path9.default.resolve(startPath);
+  let stats = await import_promises22.default.stat(current).catch(() => null);
   if (stats?.isFile()) {
-    current = import_node_path8.default.dirname(current);
+    current = import_node_path9.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 bindingPath = import_node_path9.default.join(current, ".remix", "config.json");
+    const bindingStats = await import_promises22.default.stat(bindingPath).catch(() => null);
     if (bindingStats?.isFile()) return current;
-    const parent = import_node_path8.default.dirname(current);
+    const parent = import_node_path9.default.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -34201,8 +35962,240 @@ function createFallbackTouchedRepo(params) {
     recordingFailedAt: null
   };
 }
+var TRANSCRIPT_FLUSH_RETRY_DELAYS_MS = [50, 100, 200];
+function sleep5(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function harvestTurnUsage(params) {
+  const { hook, sessionId, state, payload } = params;
+  const transcriptPath = extractString(payload, ["transcript_path"]);
+  if (!transcriptPath) return null;
+  const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const session = resolveClaudeCodeSession(payload);
+    const resolvedSessionId = session.agent.sessionId ?? sessionId;
+    let parsed = await readAndParseTranscript(transcriptPath);
+    if (!parsed.ok) {
+      await appendHookDiagnosticsEvent({
+        hook,
+        sessionId,
+        turnId: state.turnId,
+        stage: "usage_harvest_transcript_read",
+        result: "info",
+        reason: parsed.reason
+      });
+      return null;
+    }
+    let events = parsed.events;
+    const runCurrentHarvest = () => harvestClaudeCodeUsage({
+      events,
+      sessionId: resolvedSessionId,
+      promptText: state.prompt,
+      submittedAt: state.submittedAt,
+      agent: {
+        name: "claude-code",
+        version: null,
+        sessionId: resolvedSessionId,
+        turnId: state.turnId,
+        plan: session.agent.plan
+      },
+      capturedAt,
+      extensions: session.extensions
+    });
+    let currentResult = runCurrentHarvest();
+    let retriesUsed = 0;
+    let totalBackoffMs = 0;
+    while (!currentResult.ok && currentResult.reason === "no_messages_for_turn") {
+      if (retriesUsed >= TRANSCRIPT_FLUSH_RETRY_DELAYS_MS.length) break;
+      const delayMs = TRANSCRIPT_FLUSH_RETRY_DELAYS_MS[retriesUsed];
+      await sleep5(delayMs);
+      retriesUsed += 1;
+      totalBackoffMs += delayMs;
+      const reparsed = await readAndParseTranscript(transcriptPath);
+      if (!reparsed.ok) break;
+      events = reparsed.events;
+      currentResult = runCurrentHarvest();
+    }
+    let currentUsage = null;
+    let currentBoundaryAt = null;
+    if (currentResult.ok) {
+      currentUsage = currentResult.usage;
+      currentBoundaryAt = currentResult.boundaryAt;
+      if (retriesUsed > 0) {
+        await appendHookDiagnosticsEvent({
+          hook,
+          sessionId,
+          turnId: state.turnId,
+          stage: "usage_harvest_current",
+          result: "info",
+          reason: "recovered_after_flush_retry",
+          fields: { retriesUsed, totalBackoffMs }
+        });
+      }
+    } else {
+      await appendHookDiagnosticsEvent({
+        hook,
+        sessionId,
+        turnId: state.turnId,
+        stage: "usage_harvest_current",
+        result: "info",
+        reason: currentResult.reason,
+        fields: retriesUsed > 0 ? { retriesUsed, totalBackoffMs } : void 0
+      });
+    }
+    let previousPatch = null;
+    const lastFinalized = await loadLastFinalizedTurn(sessionId);
+    if (lastFinalized && lastFinalized.sessionId && lastFinalized.turnId && lastFinalized.prompt) {
+      const prevResult = harvestClaudeCodeUsage({
+        events,
+        sessionId: lastFinalized.sessionId,
+        promptText: lastFinalized.prompt,
+        submittedAt: lastFinalized.finalizedAt,
+        checkSubsequentEvent: true,
+        // Constrain the previous-turn harvest to events strictly before this
+        // turn's actual user-event timestamp in the JSONL. Using the hook's
+        // submittedAt is too loose: Claude Code records the user event
+        // ~100–200 ms before the hook fires, so the current turn's own user
+        // message slips under that bound and findBoundary locks onto it.
+        // Prefer the timestamp returned by the current-turn harvest; fall
+        // back to submittedAt only if the current harvest failed.
+        nextBoundaryAt: currentBoundaryAt ?? state.submittedAt,
+        agent: {
+          name: "claude-code",
+          version: null,
+          sessionId: lastFinalized.sessionId,
+          turnId: lastFinalized.turnId,
+          plan: session.agent.plan
+        },
+        capturedAt,
+        extensions: session.extensions
+      });
+      if (prevResult.ok) {
+        previousPatch = {
+          previousAgentTurnId: lastFinalized.turnId,
+          previousSessionId: lastFinalized.sessionId,
+          usage: prevResult.usage
+        };
+      } else {
+        await appendHookDiagnosticsEvent({
+          hook,
+          sessionId,
+          turnId: state.turnId,
+          stage: "usage_harvest_previous",
+          result: "info",
+          reason: prevResult.reason
+        });
+      }
+    }
+    if (!currentUsage && !previousPatch) return null;
+    return { schemaVersion: 1, currentTurn: currentUsage, previousTurn: previousPatch };
+  } catch (err) {
+    await appendHookDiagnosticsEvent({
+      hook,
+      sessionId,
+      turnId: state.turnId,
+      stage: "usage_harvest_threw",
+      result: "error",
+      message: err instanceof Error ? err.message : String(err)
+    });
+    return null;
+  }
+}
+async function attachUsageToPendingMcpJobs(params) {
+  const { hook, sessionId, turnId, repo, turnUsage } = params;
+  const listPendingFinalizeJobs2 = listPendingFinalizeJobs;
+  const updatePendingFinalizeJob2 = updatePendingFinalizeJob;
+  if (typeof listPendingFinalizeJobs2 !== "function" || typeof updatePendingFinalizeJob2 !== "function") {
+    await appendHookDiagnosticsEvent({
+      hook,
+      sessionId,
+      turnId,
+      stage: "usage_attach_skipped",
+      result: "info",
+      reason: "queue_helpers_unavailable",
+      repoRoot: repo.repoRoot
+    });
+    return;
+  }
+  let pending;
+  try {
+    pending = await listPendingFinalizeJobs2();
+  } catch (err) {
+    await appendHookDiagnosticsEvent({
+      hook,
+      sessionId,
+      turnId,
+      stage: "usage_attach_list_failed",
+      result: "error",
+      reason: "exception",
+      repoRoot: repo.repoRoot,
+      message: err instanceof Error ? err.message : String(err)
+    });
+    return;
+  }
+  const now = Date.now();
+  const matches = pending.filter(
+    (job) => job.status === "queued" && job.repoRoot === repo.repoRoot && job.retryCount === 0 && !job.error && job.nextRetryAt !== null && Number.isFinite(Date.parse(job.nextRetryAt)) && Date.parse(job.nextRetryAt) > now
+  );
+  if (matches.length === 0) {
+    await appendHookDiagnosticsEvent({
+      hook,
+      sessionId,
+      turnId,
+      stage: "usage_attach_no_match",
+      result: "info",
+      reason: turnUsage ? "no_pending_mcp_job" : "no_pending_mcp_job_no_usage",
+      repoRoot: repo.repoRoot
+    });
+    return;
+  }
+  let updated = 0;
+  let skipped = 0;
+  let failed = 0;
+  for (const job of matches) {
+    try {
+      const next = await updatePendingFinalizeJob2(job.id, {
+        metadata: turnUsage ? { turnUsage } : {},
+        nextRetryAt: null
+      });
+      if (next) {
+        updated += 1;
+      } else {
+        skipped += 1;
+      }
+    } catch (err) {
+      failed += 1;
+      await appendHookDiagnosticsEvent({
+        hook,
+        sessionId,
+        turnId,
+        stage: "usage_attach_update_failed",
+        result: "error",
+        reason: "exception",
+        repoRoot: repo.repoRoot,
+        message: err instanceof Error ? err.message : String(err),
+        fields: { jobId: job.id }
+      });
+    }
+  }
+  await appendHookDiagnosticsEvent({
+    hook,
+    sessionId,
+    turnId,
+    stage: "usage_attach_completed",
+    result: failed > 0 ? "error" : "success",
+    repoRoot: repo.repoRoot,
+    fields: {
+      matchedJobCount: matches.length,
+      updatedJobCount: updated,
+      skippedJobCount: skipped,
+      failedJobCount: failed,
+      hasUsage: Boolean(turnUsage)
+    }
+  });
+}
 async function recordTouchedRepo(params) {
-  const { hook, sessionId, turnId, repo, prompt, assistantResponse, api } = params;
+  const { hook, sessionId, turnId, repo, prompt, assistantResponse, api, turnUsage, promptedAt } = params;
   await markTouchedRepoStopAttempted(sessionId, repo.repoRoot);
   await appendHookDiagnosticsEvent({
     hook,
@@ -34241,7 +36234,9 @@ async function recordTouchedRepo(params) {
       prompt,
       assistantResponse,
       idempotencyKey: buildRepoIdempotencyKey(turnId, repo),
-      actor: HOOK_ACTOR
+      actor: HOOK_ACTOR,
+      turnUsage,
+      promptedAt: promptedAt ?? null
     });
     await markTouchedRepoStopRecorded(sessionId, repo.repoRoot, { mode: result.mode });
     await appendHookDiagnosticsEvent({
@@ -34276,13 +36271,61 @@ async function recordTouchedRepo(params) {
 function spawnFinalizeQueueDrainer() {
   const entrypoint = process.argv[1];
   if (!entrypoint) return;
-  const child = (0, import_node_child_process6.spawn)(process.execPath, [...process.execArgv, entrypoint, "--drain-finalize-queue"], {
+  const child = (0, import_node_child_process7.spawn)(process.execPath, [...process.execArgv, entrypoint, "--drain-finalize-queue"], {
     detached: true,
     stdio: "ignore",
     env: process.env
   });
   child.unref();
 }
+var HISTORY_IMPORT_MARKER_REL = import_node_path10.default.join(".remix", ".history-imported");
+var HISTORY_IMPORT_LOG_REL = import_node_path10.default.join(".remix", "history-import.log");
+function maybeAutoSpawnHistoryImportFromStopHook(repoRoot) {
+  try {
+    if ((0, import_node_fs7.existsSync)(import_node_path10.default.join(repoRoot, HISTORY_IMPORT_MARKER_REL))) {
+      return { spawned: false, reason: "marker_present" };
+    }
+  } catch (markerErr) {
+    return {
+      spawned: false,
+      reason: "marker_check_failed",
+      message: markerErr instanceof Error ? markerErr.message : String(markerErr)
+    };
+  }
+  const remixDir = import_node_path10.default.join(repoRoot, ".remix");
+  try {
+    (0, import_node_fs7.mkdirSync)(remixDir, { recursive: true });
+  } catch {
+  }
+  const logPath = import_node_path10.default.join(repoRoot, HISTORY_IMPORT_LOG_REL);
+  let out;
+  let err;
+  try {
+    out = (0, import_node_fs7.openSync)(logPath, "a");
+    err = (0, import_node_fs7.openSync)(logPath, "a");
+  } catch (logErr) {
+    return {
+      spawned: false,
+      reason: "log_open_failed",
+      message: logErr instanceof Error ? logErr.message : String(logErr)
+    };
+  }
+  try {
+    const child = (0, import_node_child_process7.spawn)("remix", ["history", "import", "--repo", repoRoot, "--include-prompt-text"], {
+      detached: true,
+      stdio: ["ignore", out, err],
+      env: { ...process.env, REMIX_HISTORY_AUTO_SPAWN: "1" }
+    });
+    child.unref();
+    return { spawned: true, pid: child.pid, logPath };
+  } catch (spawnErr) {
+    return {
+      spawned: false,
+      reason: "spawn_failed",
+      message: spawnErr instanceof Error ? spawnErr.message : String(spawnErr)
+    };
+  }
+}
 async function runHookStopCollab(payload) {
   const hook = "Stop";
   if (extractBoolean(payload, ["stop_hook_active"])) {
@@ -34343,6 +36386,21 @@ async function runHookStopCollab(payload) {
     if (touchedRepos.length === 0) {
       const fallbackRepo = await resolveBoundRepoSummary(state.initialCwd);
       if (!fallbackRepo) {
+        let skipReason = "no_bound_repo_for_fallback";
+        let unboundBranchRepoRoot = null;
+        let unboundBranchName = null;
+        let unboundBranchKnownCount = 0;
+        const candidateRepoRoot = await findBoundRepo(state.initialCwd).catch(() => null);
+        if (candidateRepoRoot) {
+          const bindingState = await readCollabBindingState(candidateRepoRoot).catch(() => null);
+          const knownBoundBranches = bindingState ? Object.keys(bindingState.branchBindings) : [];
+          if (bindingState && !bindingState.binding && knownBoundBranches.length > 0) {
+            skipReason = "current_branch_unbound";
+            unboundBranchRepoRoot = candidateRepoRoot;
+            unboundBranchName = bindingState.currentBranch;
+            unboundBranchKnownCount = knownBoundBranches.length;
+          }
+        }
         await clearPendingTurnState(sessionId);
         await appendHookDiagnosticsEvent({
           hook,
@@ -34350,7 +36408,12 @@ async function runHookStopCollab(payload) {
           turnId: state.turnId,
           stage: "fallback_repo_lookup",
           result: "skip",
-          reason: "no_bound_repo_for_fallback"
+          reason: skipReason,
+          repoRoot: unboundBranchRepoRoot,
+          fields: skipReason === "current_branch_unbound" ? {
+            currentBranch: unboundBranchName,
+            knownBoundBranchCount: unboundBranchKnownCount
+          } : {}
         });
         await appendHookDiagnosticsEvent({
           hook,
@@ -34428,8 +36491,16 @@ async function runHookStopCollab(payload) {
         touchedRepoCount: touchedRepos.length
       }
     });
+    const turnUsage = await harvestTurnUsage({
+      hook,
+      sessionId,
+      state: { turnId: state.turnId, prompt, submittedAt: state.submittedAt },
+      payload
+    });
     let hadFailure = false;
     let queuedFinalizeWork = false;
+    let anyRecorded = false;
+    let anyTurnExists = false;
     for (const repo of touchedRepos) {
       if (shouldSkipStopRecording(repo)) {
         const backupDrainQueued = repo.manuallyRecordedByTool === "remix_collab_finalize_turn" && repo.manualRecordingScope === "full_turn";
@@ -34445,9 +36516,20 @@ async function runHookStopCollab(payload) {
           fields: {
             manuallyRecorded: repo.manuallyRecorded,
             stopRecorded: repo.stopRecorded,
-            backupDrainQueued
+            backupDrainQueued,
+            willAttachUsage: Boolean(turnUsage)
           }
         });
+        anyTurnExists = true;
+        if (backupDrainQueued) {
+          await attachUsageToPendingMcpJobs({
+            hook,
+            sessionId,
+            turnId: state.turnId,
+            repo,
+            turnUsage
+          });
+        }
         continue;
       }
       const recording = await recordTouchedRepo({
@@ -34457,13 +36539,44 @@ async function runHookStopCollab(payload) {
         repo,
         prompt,
         assistantResponse,
-        api
+        api,
+        turnUsage,
+        promptedAt: state.submittedAt
       });
       queuedFinalizeWork = queuedFinalizeWork || recording.queued;
-      if (!recording.recorded) {
+      if (recording.recorded) {
+        anyRecorded = true;
+        anyTurnExists = true;
+        const autoSpawn = maybeAutoSpawnHistoryImportFromStopHook(repo.repoRoot);
+        if (autoSpawn.spawned) {
+          await appendHookDiagnosticsEvent({
+            hook,
+            sessionId,
+            turnId: state.turnId,
+            stage: "history_import_auto_spawned_from_stop",
+            result: "success",
+            repoRoot: repo.repoRoot,
+            fields: { pid: autoSpawn.pid ?? null, logPath: autoSpawn.logPath }
+          });
+        } else if (autoSpawn.reason !== "marker_present") {
+          await appendHookDiagnosticsEvent({
+            hook,
+            sessionId,
+            turnId: state.turnId,
+            stage: "history_import_auto_spawn_skipped",
+            result: "info",
+            reason: autoSpawn.reason,
+            repoRoot: repo.repoRoot,
+            message: autoSpawn.message ?? null
+          });
+        }
+      } else {
         hadFailure = true;
       }
     }
+    if (anyRecorded || anyTurnExists) {
+      await markLastFinalizedTurn(sessionId, state.turnId, prompt);
+    }
     if (queuedFinalizeWork) {
       spawnFinalizeQueueDrainer();
     }