@cortexkit/anthropic-auth-core 2.2.1 → 2.2.3

package/dist/index.js

@@ -241,7 +241,7 @@ async function select(terminal, items, options) {
 import { createHash, randomBytes, randomUUID as randomUUID4 } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import { chmod, mkdir as mkdir3, open as open3, readFile as readFile3, realpath, rename as rename4, stat as stat2, unlink as unlink2 } from "node:fs/promises";
-import { basename, dirname as dirname4, extname, isAbsolute, join as join2, resolve as resolve2 } from "node:path";
+import { basename, dirname as dirname4, extname, isAbsolute, join as join3, resolve as resolve2 } from "node:path";
 import { ClaustrumCredentialError, ClaustrumClient as ClaustrumWireClient, writeEnrollmentTokenFile } from "@cortexkit/claustrum-client";
 
 // ../../node_modules/@cortexkit/common-auth/dist/fs/atomic-write.js
@@ -252,7 +252,8 @@ import { dirname as dirname2 } from "node:path";
 // ../../node_modules/@cortexkit/common-auth/dist/fs/private-files.js
 import { randomUUID } from "node:crypto";
 import { lstat, readFile, rename, unlink } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
 var windowsPrivateFiles = process.platform === "win32";
 var migrationNotices = new Set;
 function ioCode(detail) {
@@ -265,8 +266,32 @@ function ioCode(detail) {
   return detail?.code ?? "ERR_PRIVATE_FILE";
 }
 var backend;
+var PRIVATE_FILES_UNAVAILABLE_REASON = "native-addon-unavailable";
+function privateFilesUnavailable(cause) {
+  return Object.assign(new Error("Windows private-files native addon is unavailable", { cause }), {
+    code: "ERR_PRIVATE_FILES_UNAVAILABLE",
+    reason: PRIVATE_FILES_UNAVAILABLE_REASON
+  });
+}
+function isUnavailable(api, error) {
+  return error instanceof api.PrivateFilesUnavailableError || error?.code === "ERR_PRIVATE_FILES_UNAVAILABLE";
+}
+async function assertNativeAddonLoads(api) {
+  try {
+    await api.verifyPrivatePath(join(tmpdir(), `.common-auth-private-files-probe-${randomUUID()}`), "file");
+  } catch (error) {
+    if (isUnavailable(api, error))
+      throw privateFilesUnavailable(error);
+  }
+}
 function loadBackend() {
-  backend ??= import("@cortexkit/private-files");
+  backend ??= import("@cortexkit/private-files").then(async (api) => {
+    if (windowsPrivateFiles)
+      await assertNativeAddonLoads(api);
+    return api;
+  }, (cause) => {
+    throw windowsPrivateFiles ? privateFilesUnavailable(cause) : cause;
+  });
   return backend;
 }
 
@@ -284,7 +309,7 @@ class PrivateFileError extends Error {
   orphanPath;
   constructor(path, stage, cause) {
     const detail = cause;
-    super(`Private file refused at ${stage}: ${path} (${detail?.reason ?? detail?.code ?? "io-error"}). Use a safe parent directory. Repair only a named secret file in safe ancestry whose owner the published policy trusts, without changing its owner or any existing directory. Previously exposed credentials may need rotation. Windows requires the private-files native prebuild and an ACL-persisting local filesystem such as NTFS.`, { cause });
+    super(detail?.code === "ERR_PRIVATE_FILES_UNAVAILABLE" ? `Private file refused at ${stage}: ${path} (${PRIVATE_FILES_UNAVAILABLE_REASON}). The Windows native addon of @cortexkit/private-files could not be loaded, so owner-only access cannot be enforced and nothing was read or written. Reinstall the plugin so the private-files Windows prebuild for this architecture is present; Windows has no safe fallback to permission bits.` : `Private file refused at ${stage}: ${path} (${detail?.reason ?? detail?.code ?? "io-error"}). Keep this file in a folder that only you, the system or administrators can change, such as a folder in your home directory. If other users could read the file before, sign in again to replace the credentials it held. On Windows the file must also be on a local drive that keeps Windows file permissions, such as NTFS.`, { cause });
     this.path = path;
     this.stage = stage;
     this.name = "PrivateFileError";
@@ -617,7 +642,7 @@ var WRITER_LOCK_CONSTANTS = Object.freeze({
 // ../../node_modules/@cortexkit/common-auth/dist/fs/refresh-file-lock.js
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { mkdir as mkdir2, open as open2, readFile as readFile2, rename as rename3, rm as rm2, stat } from "node:fs/promises";
-import { dirname as dirname3, join } from "node:path";
+import { dirname as dirname3, join as join2 } from "node:path";
 
 // ../../node_modules/@cortexkit/common-auth/dist/fs/with-lock.js
 function lockPathFor(target, name) {
@@ -644,6 +669,7 @@ class LockOwnershipError extends Error {
 async function withLock(target, options, fn) {
   const started = performance.now();
   for (;; ) {
+    options.signal?.throwIfAborted();
     const lock = await acquireRefreshFileLock({
       path: target,
       name: options.name,
@@ -654,6 +680,7 @@ async function withLock(target, options, fn) {
     });
     if (lock) {
       try {
+        options.signal?.throwIfAborted();
         return await fn(lock);
       } finally {
         await lock.release();
@@ -691,7 +718,7 @@ function acquireRefreshFileLock(options) {
 }
 async function acquireRefreshFileLockWithClock(options) {
   const lockPath = lockPathFor(options.path, options.name);
-  const legacyOwnerPath = join(lockPath, "owner.json");
+  const legacyOwnerPath = join2(lockPath, "owner.json");
   const ownerId = randomUUID3();
   const now = options.now ?? Date.now;
   let renewTimer = null;
@@ -732,7 +759,7 @@ async function acquireRefreshFileLockWithClock(options) {
   let terminalIOError;
   let renewalInFlight = null;
   const evictPath = `${lockPath}.evicting`;
-  const evictOwnerPath = join(evictPath, "owner.json");
+  const evictOwnerPath = join2(evictPath, "owner.json");
   const evictOwnerId = randomUUID3();
   const EVICT_TTL = 5000;
   const MAX_STEAL_ATTEMPTS = 8;
@@ -1296,7 +1323,9 @@ var ENROLLMENT_SCHEMA = 1;
 var ENROLLMENT_FILE_MAX_BYTES = 16 * 1024;
 var ENROLLMENT_LOCK_TTL_MS = 30000;
 var TOKEN_RE = /^[0-9a-f]{64}$/;
+var UNSUPPORTED_ENROLLMENT_CODE = "unknown_method";
 var TERMINAL_ENROLLMENT_CODES = new Set([
+  UNSUPPORTED_ENROLLMENT_CODE,
   "invalid_params",
   "pending_exists",
   "not_found",
@@ -1326,7 +1355,7 @@ function getClaustrumEnrollmentPaths(tokenPath) {
   const extension = extname(tokenPath) || ".json";
   const stem = basename(tokenPath, extname(tokenPath));
   return {
-    statePath: join2(dirname4(tokenPath), `${stem}-state${extension}`),
+    statePath: join3(dirname4(tokenPath), `${stem}-state${extension}`),
     tokenPath
   };
 }
@@ -1334,7 +1363,7 @@ function hostEnrollmentPaths(input) {
   const override = input.override?.trim();
   if (override && !isAbsolute(override) && !input.cwd)
     throw new ClaustrumConsumerError("invalid-state", "A relative Claustrum enrollment override needs a base directory");
-  const tokenPath = override ? isAbsolute(override) ? override : resolve2(input.cwd, override) : join2(input.stateDir, `${input.host}-enrollment.json`);
+  const tokenPath = override ? isAbsolute(override) ? override : resolve2(input.cwd, override) : join3(input.stateDir, `${input.host}-enrollment.json`);
   return getClaustrumEnrollmentPaths(tokenPath);
 }
 function isRecord(value) {
@@ -1570,7 +1599,7 @@ async function writeStateAtomic(path, state, ancestorOptions = {}) {
   }
   if (windowsPrivateFiles)
     return writePrivateAtomic(path, bytes);
-  const temporary = join2(parent, `.${basename(path)}.${process.pid}.${randomUUID4()}.tmp`);
+  const temporary = join3(parent, `.${basename(path)}.${process.pid}.${randomUUID4()}.tmp`);
   let descriptor;
   let created = false;
   try {
@@ -1799,6 +1828,18 @@ class ClaustrumEnrollmentManager {
               retryCode: refusal.code
             };
           }
+          if (refusal.code === UNSUPPORTED_ENROLLMENT_CODE) {
+            await lock.assertOwned();
+            await unlink2(this.#paths.statePath).catch((cause) => {
+              if (cause.code !== "ENOENT")
+                throw cause;
+            });
+            return {
+              state: "unavailable",
+              proposedName: state.proposedName,
+              code: refusal.code
+            };
+          }
           return this.#block(state, refusal.code);
         }
       }
@@ -2187,8 +2228,8 @@ function setupEnrollment(error) {
 // ../../node_modules/@cortexkit/common-auth/dist/setup/detect.js
 import { accessSync, constants, existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { mkdtemp, rm as rm3 } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join as join3 } from "node:path";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join4 } from "node:path";
 import { parse } from "jsonc-parser";
 
 // ../../node_modules/@cortexkit/common-auth/dist/setup/paths.js
@@ -2357,7 +2398,7 @@ async function detectHosts(plugin, io = {}) {
       return null;
     let root;
     try {
-      root = await mkdtemp(join3(tmpdir(), "common-auth-setup-version-"));
+      root = await mkdtemp(join4(tmpdir2(), "common-auth-setup-version-"));
       const probeEnv = {
         ...env,
         HOME: root,
@@ -2425,6 +2466,8 @@ import { writeEnrollmentTokenFile as writeEnrollmentTokenFile2 } from "@cortexki
 var WINDOWS_CIM_TIMEOUT_MS = 45000;
 var HOSTS = new Set(["opencode", "litecode", "opencode2", "pi"]);
 var RUNTIMES = new Set(["node", "bun"]);
+var WINDOWS_FENCE_FILTER = [...HOSTS, ...RUNTIMES].map((name) => `Name LIKE '${name}%'`).join(" OR ");
+var WINDOWS_FENCE_QUERY = `$ErrorActionPreference = 'Stop'; $rows = @(Get-CimInstance Win32_Process -Filter "${WINDOWS_FENCE_FILTER}" | Select-Object Name,ProcessId,CommandLine); ConvertTo-Json -Compress -Depth 3 -InputObject @{ complete = $true; processes = $rows }`;
 var PI_SCRIPT_PATTERN = /(?:^|[/\\])pi-coding-agent[/\\]dist[/\\](?:(?:bundle|bun)[/\\])?cli\.m?js$/i;
 function commandArguments(command) {
   return [...command.matchAll(/"([^"]*)"|(\S+)/g)].map((match) => match[1] ?? match[2] ?? "");
@@ -2530,6 +2573,7 @@ Please quit all OpenCode, LiteCode, and Pi processes before running setup.`);
 }
 async function listSetupProcesses(runner = defaultCommandRunner, options = {}) {
   const windows = (options.platform ?? process.platform) === "win32";
+  const selfPid = options.selfPid ?? process.pid;
   let inspection = {
     step: windows ? "tasklist" : "ps",
     exitCode: null,
@@ -2566,6 +2610,29 @@ async function listSetupProcesses(runner = defaultCommandRunner, options = {}) {
     }
   };
   try {
+    if (windows && options.hostImagesOnly) {
+      const details = await inspect("CIM", "powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", WINDOWS_FENCE_QUERY], WINDOWS_CIM_TIMEOUT_MS);
+      if (details.exitCode !== 0)
+        throw new ProcessInspectionError(inspection);
+      const value = JSON.parse(details.stdout);
+      if (!value || typeof value !== "object" || !("complete" in value) || value.complete !== true || !("processes" in value))
+        throw new ProcessInspectionError(inspection);
+      const listed = value.processes;
+      const rows = listed === null ? [] : Array.isArray(listed) ? listed : [listed];
+      const processes2 = [];
+      for (const row of rows) {
+        if (!row || typeof row !== "object" || !("Name" in row) || typeof row.Name !== "string" || !("ProcessId" in row) || !Number.isSafeInteger(row.ProcessId) || row.ProcessId < 0 || !("CommandLine" in row))
+          throw new ProcessInspectionError(inspection);
+        const pid = row.ProcessId;
+        if (!/^(?:node|bun)\.exe$/i.test(row.Name))
+          processes2.push({ pid, command: row.Name });
+        else if (typeof row.CommandLine === "string")
+          processes2.push({ pid, command: row.CommandLine });
+        else if (pid !== selfPid)
+          throw new ProcessInspectionError(inspection);
+      }
+      return processes2;
+    }
     const result = await inspect(windows ? "tasklist" : "ps", windows ? "tasklist.exe" : "ps", windows ? ["/fo", "csv", "/nh"] : ["-eo", "pid,command"]);
     if (result.exitCode !== 0)
       throw new ProcessInspectionError(inspection);
@@ -2598,7 +2665,7 @@ async function listSetupProcesses(runner = defaultCommandRunner, options = {}) {
     }
     if (!processes.length)
       throw new ProcessInspectionError(inspection);
-    const runtimes = processes.filter((entry) => entry.pid !== process.pid && /^(?:node|bun)\.exe$/i.test(entry.command));
+    const runtimes = processes.filter((entry) => entry.pid !== selfPid && /^(?:node|bun)\.exe$/i.test(entry.command));
     if (windows && runtimes.length && options.inspectRuntimes !== false) {
       const details = await inspect("CIM", "powershell.exe", [
         "-NoProfile",
@@ -2631,10 +2698,15 @@ async function listSetupProcesses(runner = defaultCommandRunner, options = {}) {
   }
 }
 function createProcessFence(runner = defaultCommandRunner, options = {}) {
-  const isHost = (entry) => entry.pid !== process.pid && hostName(entry.command) !== null;
+  const selfPid = options.selfPid ?? process.pid;
+  const isHost = (entry) => entry.pid !== selfPid && hostName(entry.command) !== null;
   return {
     async listRunningHosts(env) {
-      return (await listSetupProcesses(runner, { ...options, env })).filter(isHost);
+      return (await listSetupProcesses(runner, {
+        ...options,
+        env,
+        hostImagesOnly: true
+      })).filter(isHost);
     },
     async previewRunningHosts(env) {
       const processes = await listSetupProcesses(runner, {
@@ -2645,7 +2717,7 @@ function createProcessFence(runner = defaultCommandRunner, options = {}) {
       const windows = (options.platform ?? process.platform) === "win32";
       return {
         hosts: processes.filter(isHost),
-        uncheckedRuntimes: windows ? processes.filter((entry) => entry.pid !== process.pid && /^(?:node|bun)\.exe$/i.test(entry.command)).length : 0
+        uncheckedRuntimes: windows ? processes.filter((entry) => entry.pid !== selfPid && /^(?:node|bun)\.exe$/i.test(entry.command)).length : 0
       };
     }
   };
@@ -2658,8 +2730,27 @@ async function assertHostsStopped(fence, env) {
 
 // ../../node_modules/@cortexkit/common-auth/dist/setup/enroll.js
 var ENROLLMENT_INCOMPLETE_MESSAGE = "Claustrum enrollment did not complete. Inspect and approve with ck, then rerun setup.";
+var UNSUPPORTED_VAULT_MESSAGE = "This Claustrum vault does not support connecting plugins yet, so setup cannot connect to it. Run setup without --claustrum to use local accounts.";
+var ENROLLMENT_WAIT_MS = 300000;
+var APPROVAL_POLL_MS = 1000;
+var PROPOSE_BACKOFF_MS = [1000, 2000, 4000, 8000, 16000, 30000];
+function safeCode(code) {
+  return code && /^[a-z][a-z0-9_]{0,63}$/.test(code) ? code : "unknown";
+}
 
 class HostNotEnrolledError extends Error {
+  reason;
+  lastErrorCode;
+  constructor(message, details) {
+    super(message);
+    this.name = "HostNotEnrolledError";
+    this.reason = details.reason;
+    if (details.lastErrorCode !== undefined)
+      this.lastErrorCode = safeCode(details.lastErrorCode);
+  }
+}
+function approveCommand(requestId, name) {
+  return `ck auth enroll approve --request-id ${requestId} --name ${name}`;
 }
 async function connectSetupHost(plugin, host, io, terminal, fence) {
   const { name, paths: input } = plugin.vault.hosts[host];
@@ -2669,54 +2760,89 @@ async function connectSetupHost(plugin, host, io, terminal, fence) {
     connectionFile: plugin.vault.connectionFile,
     handshakeTimeoutMs: 2000
   }).catch(() => {
-    throw new HostNotEnrolledError("Claustrum connection failed; start ck and rerun setup.");
+    throw new HostNotEnrolledError("Claustrum connection failed; start ck and rerun setup.", { reason: "connection-failed" });
   });
+  const now = io.now ?? (() => performance.now());
+  const wait = io.wait ?? delay;
   try {
     const manager = new ClaustrumEnrollmentManager({
       proposedName: name,
       paths,
-      client: {
-        enrollPropose: async (input2) => {
-          await fence();
-          return client.enrollPropose(input2);
-        },
-        enrollPoll: async (input2) => {
-          await fence();
-          return client.enrollPoll(input2);
-        }
-      },
+      client,
       writeTokenFile: async (path, file) => {
         await fence();
         await writeEnrollmentTokenFile2(path, file);
       }
     });
+    printLine(terminal, `Asking the vault to connect ${name}…`);
+    const deadline = now() + ENROLLMENT_WAIT_MS;
     let printedRequest;
-    for (let tick = 0;tick < 300; tick++) {
+    let lastCode;
+    let reportedCode;
+    let failedProposals = 0;
+    for (;; ) {
       await fence();
       const status = await manager.reconcile();
       if (status.state === "approved") {
         printLine(terminal, `Connected ${host} to Claustrum.`);
         return;
       }
+      if (status.state === "unavailable" && status.code === UNSUPPORTED_ENROLLMENT_CODE)
+        throw new HostNotEnrolledError(UNSUPPORTED_VAULT_MESSAGE, {
+          reason: "unsupported-vault",
+          lastErrorCode: status.code
+        });
       if (status.state !== "pending" && status.state !== "busy")
-        throw new HostNotEnrolledError("Claustrum enrollment refused; inspect its status with ck before rerunning setup.");
-      if (status.state === "pending" && status.requestId && status.requestId !== printedRequest) {
-        if (!/^[a-zA-Z0-9_-]+$/.test(status.requestId))
-          throw new HostNotEnrolledError("Invalid enrollment request id.");
-        printedRequest = status.requestId;
-        printLine(terminal, "Waiting for approval. In another terminal, run:");
-        printLine(terminal, `  ck auth enroll approve --request-id ${status.requestId} --name ${name}`);
-        printLine(terminal, `Enrollment files: ${paths.statePath}, ${paths.tokenPath}`);
-      }
-      await (io.wait ?? delay)(1000);
-    }
-    throw new HostNotEnrolledError("Claustrum approval is still pending; approve with ck and rerun setup.");
+        throw new HostNotEnrolledError("Claustrum enrollment refused; inspect its status with ck before rerunning setup.", {
+          reason: "refused",
+          ..."code" in status && { lastErrorCode: status.code }
+        });
+      let pause = APPROVAL_POLL_MS;
+      if (status.state === "busy")
+        lastCode = "busy";
+      else if (status.retryCode)
+        lastCode = status.retryCode;
+      if (status.state === "pending" && status.requestId) {
+        failedProposals = 0;
+        if (status.requestId !== printedRequest) {
+          if (!/^[a-zA-Z0-9_-]+$/.test(status.requestId))
+            throw new HostNotEnrolledError("Invalid enrollment request id.", {
+              reason: "invalid-request"
+            });
+          printedRequest = status.requestId;
+          printLine(terminal, "Waiting for approval. In another terminal, run:");
+          printLine(terminal, `  ${approveCommand(status.requestId, name)}`);
+          printLine(terminal, `Enrollment files: ${paths.statePath}, ${paths.tokenPath}`);
+        }
+      } else if (status.state === "pending" && status.retryCode) {
+        pause = PROPOSE_BACKOFF_MS[Math.min(failedProposals, PROPOSE_BACKOFF_MS.length - 1)] ?? APPROVAL_POLL_MS;
+        failedProposals++;
+        const code2 = safeCode(status.retryCode);
+        if (code2 !== reportedCode) {
+          reportedCode = code2;
+          printLine(terminal, `The vault has not created the request yet (${code2}); retrying.`);
+        }
+      }
+      const remaining = deadline - now();
+      if (remaining <= 0)
+        break;
+      await wait(Math.min(pause, remaining));
+    }
+    if (printedRequest)
+      throw new HostNotEnrolledError(`Claustrum approval is still pending. In another terminal, run: ${approveCommand(printedRequest, name)} and then rerun setup.`, {
+        reason: "approval-pending",
+        ...lastCode !== undefined && { lastErrorCode: lastCode }
+      });
+    const code = safeCode(lastCode);
+    throw new HostNotEnrolledError(`The vault never created the enrollment request (last error: ${code}). Check that ck is running, then rerun setup.`, { reason: "request-not-created", lastErrorCode: code });
   } catch (error) {
-    if (error instanceof ProcessFenceViolationError || error instanceof ProcessInspectionError)
+    if (error instanceof ProcessFenceViolationError || error instanceof ProcessInspectionError || error instanceof HostNotEnrolledError)
       throw error;
-    if (error instanceof HostNotEnrolledError)
-      throw new HostNotEnrolledError(ENROLLMENT_INCOMPLETE_MESSAGE);
-    throw new Error(ENROLLMENT_INCOMPLETE_MESSAGE);
+    const code = error?.code;
+    throw new HostNotEnrolledError(ENROLLMENT_INCOMPLETE_MESSAGE, {
+      reason: "incomplete",
+      ...typeof code === "string" && { lastErrorCode: code }
+    });
   } finally {
     client.close();
   }
@@ -2754,7 +2880,7 @@ import { applyEdits, createScanner, findNodeAtLocation, modify, parse as parse2,
 // ../../node_modules/@cortexkit/common-auth/dist/setup/config-write.js
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { mkdir as mkdir4, open as open4, rename as rename5, stat as stat4, unlink as unlink3 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname5, join as join4 } from "node:path";
+import { basename as basename2, dirname as dirname5, join as join5 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 async function writeHostConfigAtomic(file, content, options = {}) {
   const windows = (options.platform ?? process.platform) === "win32";
@@ -2769,7 +2895,7 @@ async function writeHostConfigAtomic(file, content, options = {}) {
         throw error;
     }
   }
-  const stage = join4(parent, `.${basename2(file)}.${(options.stageName ?? randomUUID5)()}.tmp`);
+  const stage = join5(parent, `.${basename2(file)}.${(options.stageName ?? randomUUID5)()}.tmp`);
   let created = false;
   try {
     const handle = await open4(stage, "wx", mode ?? 438);
@@ -3137,13 +3263,13 @@ ${write.content}`);
 import { createHash as createHash2, randomUUID as randomUUID6 } from "node:crypto";
 import { mkdir as mkdir5, readFile as readFile5, rename as rename6, rm as rm4, stat as stat5, writeFile } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname6, join as join6 } from "node:path";
+import { dirname as dirname6, join as join7 } from "node:path";
 
 // src/claustrum.ts
 import { readdirSync, statSync as statSync2 } from "node:fs";
 import * as fs from "node:fs/promises";
-import { tmpdir as tmpdir2, userInfo } from "node:os";
-import { join as join5 } from "node:path";
+import { tmpdir as tmpdir3, userInfo } from "node:os";
+import { join as join6 } from "node:path";
 function errorCode(error) {
   return error && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : "unknown";
 }
@@ -3171,7 +3297,7 @@ function listSubcTempConnectionFiles(dir) {
     if (!name.startsWith(CLAUSTRUM_TEMP_PREFIX) || !name.endsWith(CLAUSTRUM_TEMP_SUFFIX)) {
       continue;
     }
-    const candidate = join5(dir, name);
+    const candidate = join6(dir, name);
     if (safeIsFile(candidate))
       matches.push(candidate);
   }
@@ -3181,13 +3307,13 @@ function listSubcTempConnectionFiles(dir) {
 function findExistingClaustrumConnectionPath(env = process.env) {
   const runtime = env.XDG_RUNTIME_DIR?.trim();
   if (runtime) {
-    const candidate = join5(runtime, PRODUCTION_CLAUSTRUM_CONNECTION_FILE_NAME);
+    const candidate = join6(runtime, PRODUCTION_CLAUSTRUM_CONNECTION_FILE_NAME);
     if (safeIsFile(candidate))
       return candidate;
   }
   const home = env.HOME?.trim();
   if (home) {
-    const candidate = join5(home, ".local", "share", "cortexkit", "run", PRODUCTION_CLAUSTRUM_CONNECTION_FILE_NAME);
+    const candidate = join6(home, ".local", "share", "cortexkit", "run", PRODUCTION_CLAUSTRUM_CONNECTION_FILE_NAME);
     if (safeIsFile(candidate))
       return candidate;
   }
@@ -3195,7 +3321,7 @@ function findExistingClaustrumConnectionPath(env = process.env) {
   const linuxRun = `/run/user/${uid}/${PRODUCTION_CLAUSTRUM_CONNECTION_FILE_NAME}`;
   if (safeIsFile(linuxRun))
     return linuxRun;
-  const tempMatches = listSubcTempConnectionFiles(tmpdir2());
+  const tempMatches = listSubcTempConnectionFiles(tmpdir3());
   if (tempMatches.length === 1)
     return tempMatches[0];
   return;
@@ -3206,11 +3332,11 @@ function getDefaultClaustrumConnectionPath(env = process.env) {
     return existing;
   const runtime = env.XDG_RUNTIME_DIR?.trim();
   if (runtime && (process.platform !== "darwin" || safeIsFile(runtime))) {
-    return join5(runtime, PRODUCTION_CLAUSTRUM_CONNECTION_FILE_NAME);
+    return join6(runtime, PRODUCTION_CLAUSTRUM_CONNECTION_FILE_NAME);
   }
   if (process.platform === "darwin") {
     const home = env.HOME?.trim() || userInfo().homedir;
-    return join5(home, ".local", "share", "cortexkit", "run", PRODUCTION_CLAUSTRUM_CONNECTION_FILE_NAME);
+    return join6(home, ".local", "share", "cortexkit", "run", PRODUCTION_CLAUSTRUM_CONNECTION_FILE_NAME);
   }
   const uid = process.getuid?.() ?? userInfo().uid;
   return `/run/user/${uid}/${PRODUCTION_CLAUSTRUM_CONNECTION_FILE_NAME}`;
@@ -3312,6 +3438,345 @@ function assertNotCustodyTombstone(refreshToken, provider) {
   }
 }
 
+// src/model-capabilities.ts
+var PER_TURN_CONTROL_BETA = "per-turn-control-2026-07-01";
+var TURN_END_NOTE_BETA = "mid-conversation-system-clear-at-2026-08-21";
+var CLAUDE_CODE_BETA = "claude-code-20250219";
+var PROMPT_CACHING_SCOPE_BETA = "prompt-caching-scope-2026-01-05";
+var CLAUDE_CODE_FULL_AGENT_BETAS = [
+  CLAUDE_CODE_BETA,
+  "oauth-2025-04-20",
+  "interleaved-thinking-2025-05-14",
+  "thinking-token-count-2026-05-13",
+  "context-management-2025-06-27",
+  PROMPT_CACHING_SCOPE_BETA,
+  "mid-conversation-tool-changes-2026-07-01",
+  "advanced-tool-use-2025-11-20",
+  TURN_END_NOTE_BETA,
+  "effort-2025-11-24",
+  "thinking-binding-controls-2026-08-01",
+  "thinking-display-updates-2026-08-18",
+  "extended-cache-ttl-2025-04-11",
+  "cache-diagnosis-2026-04-07"
+];
+var CLAUDE_CODE_TITLE_BETAS = [
+  "oauth-2025-04-20",
+  "interleaved-thinking-2025-05-14",
+  "redact-thinking-2026-02-12",
+  "thinking-token-count-2026-05-13",
+  "context-management-2025-06-27",
+  PROMPT_CACHING_SCOPE_BETA,
+  "mid-conversation-tool-changes-2026-07-01",
+  TURN_END_NOTE_BETA,
+  "effort-2025-11-24",
+  "cache-diagnosis-2026-04-07"
+];
+var CLAUDE_CODE_QUOTA_BETAS = [
+  "oauth-2025-04-20",
+  "interleaved-thinking-2025-05-14",
+  "redact-thinking-2026-02-12",
+  "thinking-token-count-2026-05-13",
+  "context-management-2025-06-27",
+  PROMPT_CACHING_SCOPE_BETA
+];
+var CLAUDE_CODE_DEFAULT_BETAS = {
+  main: CLAUDE_CODE_FULL_AGENT_BETAS,
+  title: CLAUDE_CODE_TITLE_BETAS,
+  quota: CLAUDE_CODE_QUOTA_BETAS
+};
+function claudeCodeBetaLists(options) {
+  const adjust = (list) => {
+    const selected = [...list];
+    if (options.claudeCodeBetaAfterCachingScope) {
+      const codeIndex = selected.indexOf(CLAUDE_CODE_BETA);
+      if (codeIndex >= 0) {
+        selected.splice(codeIndex, 1);
+        selected.splice(selected.indexOf(PROMPT_CACHING_SCOPE_BETA) + 1, 0, CLAUDE_CODE_BETA);
+      }
+    }
+    if (options.perTurnControl) {
+      let index = selected.indexOf(PROMPT_CACHING_SCOPE_BETA);
+      if (index >= 0 && selected[index + 1] === CLAUDE_CODE_BETA)
+        index += 1;
+      if (index >= 0)
+        selected.splice(index + 1, 0, PER_TURN_CONTROL_BETA);
+      else
+        selected.push(PER_TURN_CONTROL_BETA);
+    }
+    return selected;
+  };
+  return {
+    main: adjust(CLAUDE_CODE_FULL_AGENT_BETAS),
+    title: adjust(CLAUDE_CODE_TITLE_BETAS),
+    quota: adjust(CLAUDE_CODE_QUOTA_BETAS)
+  };
+}
+var ALL_ADAPTIVE_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+var FABLE_MYTHOS_5_CATALOGUE = {
+  releaseDate: "2026-06-09",
+  contextWindow: 1e6,
+  maxOutputTokens: 128000,
+  pricing: {
+    input: 10,
+    output: 50,
+    cacheRead: 1,
+    cacheWrite5m: 12.5,
+    cacheWrite1h: 20
+  }
+};
+var FABLE_MYTHOS_5_1_CATALOGUE = {
+  releaseDate: "2026-09-01",
+  contextWindow: 1e6,
+  maxOutputTokens: 128000,
+  pricing: {
+    input: 10,
+    output: 50,
+    cacheRead: 0.25,
+    cacheWrite5m: 12.5,
+    cacheWrite1h: 20
+  }
+};
+var CLAUDE_MODEL_CAPABILITIES = [
+  {
+    id: "claude-fable-5",
+    name: "Claude Fable 5",
+    family: "fable",
+    idSuffixes: "any",
+    catalogue: FABLE_MYTHOS_5_CATALOGUE,
+    thinkingModes: ["adaptive"],
+    rejectsForcedToolChoice: false,
+    efforts: { default: "high" },
+    effortMarkers: "none",
+    turnEndNote: false,
+    thinkingBindingControls: false,
+    claudeCodeBetas: CLAUDE_CODE_DEFAULT_BETAS,
+    serverSideFallback: true,
+    refusalRecoveryFamily: "fable-5",
+    scopedQuota: "fable",
+    fastMode: false
+  },
+  {
+    id: "claude-mythos-5",
+    name: "Claude Mythos 5",
+    family: "mythos",
+    idSuffixes: "any",
+    limited: true,
+    catalogue: FABLE_MYTHOS_5_CATALOGUE,
+    thinkingModes: ["adaptive"],
+    rejectsForcedToolChoice: false,
+    efforts: { default: "high" },
+    effortMarkers: "none",
+    turnEndNote: false,
+    thinkingBindingControls: false,
+    claudeCodeBetas: CLAUDE_CODE_DEFAULT_BETAS,
+    serverSideFallback: false,
+    scopedQuota: "mythos",
+    fastMode: false
+  },
+  {
+    id: "claude-fable-5-1",
+    name: "Claude Fable 5.1",
+    family: "fable",
+    idSuffixes: "any",
+    catalogue: FABLE_MYTHOS_5_1_CATALOGUE,
+    thinkingModes: ["adaptive"],
+    rejectsForcedToolChoice: true,
+    efforts: { variants: ALL_ADAPTIVE_EFFORTS, default: "high" },
+    effortMarkers: "always",
+    turnEndNote: true,
+    thinkingBindingControls: true,
+    claudeCodeBetas: claudeCodeBetaLists({ perTurnControl: true }),
+    serverSideFallback: true,
+    refusalRecoveryFamily: "fable-5-1",
+    scopedQuota: "fable",
+    fastMode: false
+  },
+  {
+    id: "claude-mythos-5-1",
+    name: "Claude Mythos 5.1",
+    family: "mythos",
+    idSuffixes: "any",
+    limited: true,
+    catalogue: FABLE_MYTHOS_5_1_CATALOGUE,
+    thinkingModes: ["adaptive"],
+    rejectsForcedToolChoice: true,
+    efforts: { default: "high" },
+    effortMarkers: "none",
+    turnEndNote: false,
+    thinkingBindingControls: false,
+    claudeCodeBetas: CLAUDE_CODE_DEFAULT_BETAS,
+    serverSideFallback: false,
+    scopedQuota: "mythos",
+    fastMode: false
+  },
+  {
+    id: "claude-opus-5",
+    name: "Claude Opus 5",
+    family: "opus",
+    idSuffixes: "any",
+    thinkingModes: ["adaptive", "disabled"],
+    rejectsForcedToolChoice: false,
+    efforts: { variants: ALL_ADAPTIVE_EFFORTS, default: "high" },
+    effortMarkers: "none",
+    turnEndNote: false,
+    thinkingBindingControls: false,
+    claudeCodeBetas: CLAUDE_CODE_DEFAULT_BETAS,
+    serverSideFallback: true,
+    refusalRecoveryFamily: "opus-5",
+    fastMode: true
+  },
+  {
+    id: "claude-opus-5-5",
+    name: "Claude Opus 5.5",
+    family: "opus",
+    idSuffixes: "any",
+    catalogue: {
+      releaseDate: "2026-09-18",
+      contextWindow: 1e6,
+      maxOutputTokens: 128000,
+      pricing: {
+        input: 4,
+        output: 20,
+        cacheRead: 0.2,
+        cacheWrite5m: 5,
+        cacheWrite1h: 8
+      }
+    },
+    thinkingModes: ["adaptive"],
+    rejectsForcedToolChoice: true,
+    efforts: { variants: ALL_ADAPTIVE_EFFORTS, default: "medium" },
+    effortMarkers: "with-adaptive-thinking",
+    turnEndNote: true,
+    thinkingBindingControls: true,
+    claudeCodeBetas: claudeCodeBetaLists({ perTurnControl: true }),
+    serverSideFallback: true,
+    refusalRecoveryFamily: "opus-5-5",
+    fastMode: true
+  },
+  {
+    id: "claude-sonnet-5",
+    name: "Claude Sonnet 5",
+    family: "sonnet",
+    idSuffixes: "any",
+    thinkingModes: ["adaptive", "disabled"],
+    rejectsForcedToolChoice: false,
+    efforts: { default: "high" },
+    effortMarkers: "none",
+    turnEndNote: false,
+    thinkingBindingControls: false,
+    claudeCodeBetas: CLAUDE_CODE_DEFAULT_BETAS,
+    serverSideFallback: false,
+    fastMode: false
+  },
+  {
+    id: "claude-sonnet-5-5",
+    name: "Claude Sonnet 5.5",
+    family: "sonnet",
+    idSuffixes: "any",
+    catalogue: {
+      releaseDate: "2026-09-28",
+      contextWindow: 1e6,
+      maxOutputTokens: 128000,
+      pricing: {
+        input: 2,
+        output: 10,
+        cacheRead: 0.2,
+        cacheWrite5m: 2.5,
+        cacheWrite1h: 4
+      }
+    },
+    thinkingModes: ["adaptive", "between_tools"],
+    rejectsForcedToolChoice: true,
+    efforts: { variants: ALL_ADAPTIVE_EFFORTS, default: "high" },
+    effortMarkers: "with-adaptive-thinking",
+    turnEndNote: true,
+    thinkingBindingControls: true,
+    claudeCodeBetas: claudeCodeBetaLists({ perTurnControl: true }),
+    serverSideFallback: false,
+    fastMode: false
+  },
+  {
+    id: "claude-haiku-5-5",
+    name: "Claude Haiku 5.5",
+    family: "haiku",
+    idSuffixes: "dated",
+    catalogue: {
+      releaseDate: "2026-10-07",
+      contextWindow: 1e6,
+      maxOutputTokens: 128000,
+      pricing: {
+        input: 0.1,
+        output: 0.5,
+        cacheRead: 0.01,
+        cacheWrite5m: 0.125,
+        cacheWrite1h: 0.2
+      },
+      longContext: {
+        inputTokensAbove: 1e5,
+        pricing: {
+          input: 0.5,
+          output: 2.5,
+          cacheRead: 0.05,
+          cacheWrite5m: 0.625,
+          cacheWrite1h: 1
+        }
+      }
+    },
+    thinkingModes: ["adaptive", "disabled"],
+    rejectsForcedToolChoice: false,
+    efforts: { variants: ALL_ADAPTIVE_EFFORTS, default: "medium" },
+    effortMarkers: "none",
+    turnEndNote: true,
+    thinkingBindingControls: true,
+    claudeCodeBetas: claudeCodeBetaLists({
+      perTurnControl: true,
+      claudeCodeBetaAfterCachingScope: true
+    }),
+    serverSideFallback: false,
+    fastMode: false
+  }
+];
+function normalizeAnthropicModelId(model) {
+  return model.endsWith("[1m]") ? model.slice(0, -4) : model;
+}
+function matchesRow(row, normalized) {
+  if (normalized === row.id)
+    return true;
+  if (!normalized.startsWith(`${row.id}-`))
+    return false;
+  if (row.idSuffixes === "any")
+    return true;
+  return /^\d{8}$/.test(normalized.slice(row.id.length + 1));
+}
+function resolveClaudeModelCapabilities(model) {
+  if (typeof model !== "string")
+    return;
+  const normalized = normalizeAnthropicModelId(model);
+  let resolved;
+  for (const row of CLAUDE_MODEL_CAPABILITIES) {
+    if (!matchesRow(row, normalized))
+      continue;
+    if (!resolved || row.id.length > resolved.id.length)
+      resolved = row;
+  }
+  return resolved;
+}
+function getClaudeModelCapabilities(id) {
+  const row = CLAUDE_MODEL_CAPABILITIES.find((entry) => entry.id === id);
+  if (!row)
+    throw new Error(`No model capability row for ${id}`);
+  return row;
+}
+function getClaudeModelCatalogue(id) {
+  const catalogue = getClaudeModelCapabilities(id).catalogue;
+  if (!catalogue)
+    throw new Error(`No catalogue facts for ${id}`);
+  return catalogue;
+}
+function pinsEffortOnEveryRequest(model) {
+  return resolveClaudeModelCapabilities(model)?.effortMarkers === "always";
+}
+
 // src/constants.ts
 var CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
 var AUTHORIZE_URLS = {
@@ -3342,7 +3807,7 @@ function mergeAnthropicBetas(existing, betas) {
   return [...new Set([...incoming, ...betas])].join(",");
 }
 function isFastModeSupportedModel(model) {
-  return typeof model === "string" && (model.startsWith("claude-opus-4-8") || model.startsWith("claude-opus-5"));
+  return typeof model === "string" && (model.startsWith("claude-opus-4-8") || model.startsWith("claude-opus-5") || resolveClaudeModelCapabilities(model)?.fastMode === true);
 }
 var OPENCODE_IDENTITY_PREFIX = "You are OpenCode";
 var CLAUDE_CODE_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
@@ -3659,16 +4124,16 @@ function getConfigDir() {
   if (process.env.OPENCODE_CONFIG_DIR?.trim()) {
     return process.env.OPENCODE_CONFIG_DIR.trim();
   }
-  return join6(process.env.XDG_CONFIG_HOME || join6(homedir2(), ".config"), "opencode");
+  return join7(process.env.XDG_CONFIG_HOME || join7(homedir2(), ".config"), "opencode");
 }
 function getAccountStoragePath() {
-  return process.env.OPENCODE_ANTHROPIC_AUTH_FILE?.trim() || join6(getConfigDir(), ACCOUNT_FILE_NAME);
+  return process.env.OPENCODE_ANTHROPIC_AUTH_FILE?.trim() || join7(getConfigDir(), ACCOUNT_FILE_NAME);
 }
 function getAccountStatePath(configPath = getAccountStoragePath()) {
   const explicit = process.env.OPENCODE_ANTHROPIC_AUTH_STATE_FILE?.trim();
   if (explicit)
     return explicit;
-  return configPath.endsWith(ACCOUNT_FILE_NAME) ? join6(dirname6(configPath), ACCOUNT_STATE_FILE_NAME) : `${configPath}.state.json`;
+  return configPath.endsWith(ACCOUNT_FILE_NAME) ? join7(dirname6(configPath), ACCOUNT_STATE_FILE_NAME) : `${configPath}.state.json`;
 }
 function createEmptyStorage() {
   return {
@@ -3789,7 +4254,7 @@ function getClaustrumMode(storage) {
 async function acquireRefreshFileLock2(options) {
   const accountPath = options.path ?? getAccountStoragePath();
   const lockPath = `${accountPath}.${options.name}.lock`;
-  const legacyOwnerPath = join6(lockPath, "owner.json");
+  const legacyOwnerPath = join7(lockPath, "owner.json");
   const ownerId = randomUUID6();
   const now = Date.now;
   let renewTimer = null;
@@ -3843,7 +4308,7 @@ async function acquireRefreshFileLock2(options) {
   let acquired = await tryAcquire();
   if (!acquired) {
     const evictPath = `${lockPath}.evicting`;
-    const evictOwnerPath = join6(evictPath, "owner.json");
+    const evictOwnerPath = join7(evictPath, "owner.json");
     const evictOwnerId = randomUUID6();
     const EVICT_TTL = 5000;
     const MAX_STEAL_ATTEMPTS = 8;
@@ -4789,374 +5254,32 @@ function extractBillingPromptId(body) {
 }
 function stripBillingLineageFields(value) {
   return value.replace(BILLING_LINEAGE_FIELD_PATTERN, "");
-}
-function stripBillingLineageFromBody(body) {
-  if (!body || typeof body !== "object")
-    return 0;
-  const system = body.system;
-  if (!Array.isArray(system))
-    return 0;
-  let stripped = 0;
-  for (const block of system) {
-    if (!block || typeof block !== "object")
-      continue;
-    const text = block.text;
-    if (typeof text !== "string" || !text.startsWith("x-anthropic-billing-header:")) {
-      continue;
-    }
-    const clean = stripBillingLineageFields(text);
-    if (clean === text)
-      continue;
-    block.text = clean;
-    stripped += 1;
-  }
-  return stripped;
-}
-
-// src/claude-code.ts
-import { randomBytes as randomBytes2, randomUUID as randomUUID7 } from "node:crypto";
-
-// src/models.ts
-var CLAUDE_FABLE_5_MODEL_ID = "claude-fable-5";
-var CLAUDE_MYTHOS_5_MODEL_ID = "claude-mythos-5";
-var CLAUDE_FABLE_5_1_MODEL_ID = "claude-fable-5-1";
-var CLAUDE_MYTHOS_5_1_MODEL_ID = "claude-mythos-5-1";
-var CLAUDE_HAIKU_4_5_MODEL_ID = "claude-haiku-4-5";
-function normalizeAnthropicModelId(model) {
-  return model.endsWith("[1m]") ? model.slice(0, -4) : model;
-}
-var CLAUDE_HAIKU_4_5_PRICING = {
-  input: 1,
-  output: 5
-};
-var CLAUDE_FABLE_MYTHOS_5_1_MODEL_IDS = [
-  CLAUDE_FABLE_5_1_MODEL_ID,
-  CLAUDE_MYTHOS_5_1_MODEL_ID
-];
-var CLAUDE_FABLE_MYTHOS_5_MODEL_IDS = [
-  CLAUDE_FABLE_5_MODEL_ID,
-  CLAUDE_MYTHOS_5_MODEL_ID,
-  ...CLAUDE_FABLE_MYTHOS_5_1_MODEL_IDS
-];
-var CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING = {
-  type: "adaptive",
-  display: "summarized"
-};
-var CLAUDE_FABLE_MYTHOS_5_PRICING = {
-  input: 10,
-  output: 50,
-  cacheRead: 1,
-  cacheWrite5m: 12.5,
-  cacheWrite1h: 20
-};
-var CLAUDE_FABLE_MYTHOS_5_1_PRICING = {
-  input: 10,
-  output: 50,
-  cacheRead: 0.25,
-  cacheWrite5m: 12.5,
-  cacheWrite1h: 20
-};
-var CLAUDE_FABLE_MYTHOS_5_CONTEXT_WINDOW = 1e6;
-var CLAUDE_FABLE_MYTHOS_5_MAX_OUTPUT_TOKENS = 128000;
-var CLAUDE_FABLE_MYTHOS_5_RELEASE_DATE = "2026-06-09";
-var CLAUDE_FABLE_MYTHOS_5_1_RELEASE_DATE = "2026-09-01";
-var CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS = {
-  [CLAUDE_FABLE_5_MODEL_ID]: {
-    id: CLAUDE_FABLE_5_MODEL_ID,
-    name: "Claude Fable 5"
-  },
-  [CLAUDE_MYTHOS_5_MODEL_ID]: {
-    id: CLAUDE_MYTHOS_5_MODEL_ID,
-    name: "Claude Mythos 5",
-    limited: true
-  },
-  [CLAUDE_FABLE_5_1_MODEL_ID]: {
-    id: CLAUDE_FABLE_5_1_MODEL_ID,
-    name: "Claude Fable 5.1"
-  },
-  [CLAUDE_MYTHOS_5_1_MODEL_ID]: {
-    id: CLAUDE_MYTHOS_5_1_MODEL_ID,
-    name: "Claude Mythos 5.1",
-    limited: true
-  }
-};
-var CLAUDE_FABLE_MYTHOS_5_1_MODEL_SPECS = {
-  [CLAUDE_FABLE_5_1_MODEL_ID]: CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS[CLAUDE_FABLE_5_1_MODEL_ID],
-  [CLAUDE_MYTHOS_5_1_MODEL_ID]: CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS[CLAUDE_MYTHOS_5_1_MODEL_ID]
-};
-function isClaudeFableOrMythos5Model(model) {
-  if (typeof model !== "string")
-    return false;
-  const normalized = normalizeAnthropicModelId(model);
-  return CLAUDE_FABLE_MYTHOS_5_MODEL_IDS.some((id) => normalized === id || normalized.startsWith(`${id}-`));
-}
-function isClaudeFableOrMythos51Model(model) {
-  if (typeof model !== "string")
-    return false;
-  const normalized = normalizeAnthropicModelId(model);
-  return CLAUDE_FABLE_MYTHOS_5_1_MODEL_IDS.some((id) => normalized === id || normalized.startsWith(`${id}-`));
-}
-function isClaudeFable51Model(model) {
-  if (typeof model !== "string")
-    return false;
-  const normalized = normalizeAnthropicModelId(model);
-  return normalized === CLAUDE_FABLE_5_1_MODEL_ID || normalized.startsWith(`${CLAUDE_FABLE_5_1_MODEL_ID}-`);
-}
-function getClaudeFableMythos5ReleaseDate(model) {
-  return isClaudeFableOrMythos51Model(model) ? CLAUDE_FABLE_MYTHOS_5_1_RELEASE_DATE : CLAUDE_FABLE_MYTHOS_5_RELEASE_DATE;
-}
-var CLAUDE_SONNET_5_MODEL_ID = "claude-sonnet-5";
-var CLAUDE_SONNET_5_ADAPTIVE_THINKING = CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING;
-function isClaudeSonnet5Model(model) {
-  if (typeof model !== "string")
-    return false;
-  const normalized = normalizeAnthropicModelId(model);
-  return !isClaudeSonnet55Model(normalized) && (normalized === CLAUDE_SONNET_5_MODEL_ID || normalized.startsWith(`${CLAUDE_SONNET_5_MODEL_ID}-`));
-}
-var CLAUDE_SONNET_5_5_MODEL_ID = "claude-sonnet-5-5";
-var CLAUDE_SONNET_5_5_RELEASE_DATE = "2026-09-28";
-var CLAUDE_SONNET_5_5_CONTEXT_WINDOW = 1e6;
-var CLAUDE_SONNET_5_5_MAX_OUTPUT_TOKENS = 128000;
-var CLAUDE_SONNET_5_5_PRICING = {
-  input: 2,
-  output: 10,
-  cacheRead: 0.2,
-  cacheWrite5m: 2.5,
-  cacheWrite1h: 4
-};
-var CLAUDE_SONNET_5_5_ADAPTIVE_THINKING = CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING;
-function isClaudeSonnet55Model(model) {
-  if (typeof model !== "string")
-    return false;
-  const normalized = normalizeAnthropicModelId(model);
-  return normalized === CLAUDE_SONNET_5_5_MODEL_ID || normalized.startsWith(`${CLAUDE_SONNET_5_5_MODEL_ID}-`);
-}
-var CLAUDE_HAIKU_5_5_MODEL_ID = "claude-haiku-5-5";
-var CLAUDE_HAIKU_5_5_RELEASE_DATE = "2026-10-07";
-var CLAUDE_HAIKU_5_5_CONTEXT_WINDOW = 1e6;
-var CLAUDE_HAIKU_5_5_MAX_OUTPUT_TOKENS = 128000;
-var CLAUDE_HAIKU_5_5_LONG_CONTEXT_THRESHOLD = 1e5;
-var CLAUDE_HAIKU_5_5_PRICING = {
-  input: 0.1,
-  output: 0.5,
-  cacheRead: 0.01,
-  cacheWrite5m: 0.125,
-  cacheWrite1h: 0.2
-};
-var CLAUDE_HAIKU_5_5_LONG_CONTEXT_PRICING = {
-  input: 0.5,
-  output: 2.5,
-  cacheRead: 0.05,
-  cacheWrite5m: 0.625,
-  cacheWrite1h: 1
-};
-var CLAUDE_HAIKU_5_5_ADAPTIVE_THINKING = CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING;
-function isClaudeHaiku55Model(model) {
-  if (typeof model !== "string")
-    return false;
-  const normalized = normalizeAnthropicModelId(model);
-  return normalized === CLAUDE_HAIKU_5_5_MODEL_ID || /^claude-haiku-5-5-\d{8}$/.test(normalized);
-}
-var CLAUDE_OPUS_5_MODEL_ID = "claude-opus-5";
-var CLAUDE_OPUS_5_ADAPTIVE_THINKING = CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING;
-function isClaudeOpus5Model(model) {
-  if (typeof model !== "string")
-    return false;
-  const normalized = normalizeAnthropicModelId(model);
-  return !isClaudeOpus55Model(normalized) && (normalized === CLAUDE_OPUS_5_MODEL_ID || normalized.startsWith(`${CLAUDE_OPUS_5_MODEL_ID}-`));
-}
-var CLAUDE_OPUS_5_5_MODEL_ID = "claude-opus-5-5";
-var CLAUDE_OPUS_5_5_RELEASE_DATE = "2026-09-18";
-var CLAUDE_OPUS_5_5_CONTEXT_WINDOW = 1e6;
-var CLAUDE_OPUS_5_5_MAX_OUTPUT_TOKENS = 128000;
-var CLAUDE_OPUS_5_5_PRICING = {
-  input: 4,
-  output: 20,
-  cacheRead: 0.2,
-  cacheWrite5m: 5,
-  cacheWrite1h: 8
-};
-var CLAUDE_OPUS_5_5_ADAPTIVE_THINKING = CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING;
-function isClaudeOpus55Model(model) {
-  if (typeof model !== "string")
-    return false;
-  const normalized = normalizeAnthropicModelId(model);
-  return normalized === CLAUDE_OPUS_5_5_MODEL_ID || normalized.startsWith(`${CLAUDE_OPUS_5_5_MODEL_ID}-`);
-}
-function isClaudeOpus5FamilyModel(model) {
-  return isClaudeOpus5Model(model) || isClaudeOpus55Model(model);
-}
-function isOpenAIReasoningSignature(value) {
-  if (typeof value !== "string")
-    return false;
-  if (value.startsWith("gAAAA"))
-    return true;
-  if (!value.startsWith("{"))
-    return false;
-  try {
-    const parsed = JSON.parse(value);
-    return parsed.type === "reasoning" && typeof parsed.id === "string" && parsed.id.startsWith("rs_") && typeof parsed.encrypted_content === "string" && parsed.encrypted_content.startsWith("gAAAA");
-  } catch {
-    return false;
-  }
-}
-
-// src/mid-conversation-output-config.ts
-var PER_TURN_CONTROL_BETA = "per-turn-control-2026-07-01";
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeAdaptiveEffort(value) {
-  if (value === "minimal")
-    return "low";
-  if (value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max") {
-    return value;
-  }
-  return;
-}
-function usesPerTurnControl(model) {
-  return isClaudeOpus55Model(model) || isClaudeSonnet55Model(model);
-}
-function sendsPerTurnControlBeta(model) {
-  return usesPerTurnControl(model) || isClaudeFable51Model(model) || isClaudeHaiku55Model(model);
-}
-function supportsPerMessageEffort(body) {
-  if (isClaudeFable51Model(body.model))
-    return true;
-  return usesPerTurnControl(body.model) && isRecord3(body.thinking) && body.thinking.type === "adaptive";
-}
-function defaultAdaptiveEffort(model) {
-  return isClaudeOpus55Model(model) || isClaudeHaiku55Model(model) ? "medium" : "high";
-}
-function compactTransitions(transitions) {
-  const compacted = [];
-  for (const transition of transitions) {
-    if (!Number.isSafeInteger(transition.afterAssistantMessages) || transition.afterAssistantMessages < 0 || !normalizeAdaptiveEffort(transition.effort)) {
-      continue;
-    }
-    const normalized = {
-      afterAssistantMessages: transition.afterAssistantMessages,
-      effort: transition.effort
-    };
-    const previous = compacted.at(-1);
-    if (previous && previous.afterAssistantMessages === normalized.afterAssistantMessages) {
-      previous.effort = normalized.effort;
-      continue;
-    }
-    if (previous?.effort === normalized.effort)
-      continue;
-    compacted.push(normalized);
-  }
-  return compacted;
-}
-function applyMidConversationOutputConfig(body, transitions) {
-  if (!supportsPerMessageEffort(body) || !Array.isArray(body.messages)) {
-    return { applied: false, inserted: 0 };
-  }
-  const compacted = compactTransitions(transitions);
-  const pinsEveryRequest = isClaudeFable51Model(body.model);
-  if (!pinsEveryRequest && compacted.length < 2) {
-    return { applied: false, inserted: 0 };
-  }
-  const currentOutputConfig = isRecord3(body.output_config) ? body.output_config : {};
-  const baseline = compacted[0]?.effort ?? normalizeAdaptiveEffort(currentOutputConfig.effort) ?? defaultAdaptiveEffort(body.model);
-  const pinnedOutputConfig = { ...currentOutputConfig, effort: baseline };
-  if (pinsEveryRequest)
-    body.output_config = pinnedOutputConfig;
-  if (compacted.length < 2)
-    return { applied: true, inserted: 0 };
-  const messages = body.messages;
-  const transitionsByBoundary = new Map;
-  for (const transition of compacted.slice(1)) {
-    transitionsByBoundary.set(transition.afterAssistantMessages, transition.effort);
-  }
-  let assistantMessages = 0;
-  let activeEffort = baseline;
-  let inserted = 0;
-  const rewritten = [];
-  for (const message of messages) {
-    if (isRecord3(message) && message.role === "user" && transitionsByBoundary.has(assistantMessages)) {
-      const effort = transitionsByBoundary.get(assistantMessages);
-      if (effort && effort !== activeEffort) {
-        rewritten.push({
-          role: "system",
-          content: [],
-          output_config: { effort }
-        });
-        activeEffort = effort;
-        inserted++;
-      }
-    }
-    rewritten.push(message);
-    if (isRecord3(message) && message.role === "assistant")
-      assistantMessages++;
-  }
-  if (!pinsEveryRequest && inserted === 0) {
-    return { applied: false, inserted: 0 };
-  }
-  body.output_config = pinnedOutputConfig;
-  body.messages = rewritten;
-  return { applied: true, inserted };
-}
-
-// src/turn-end-note.ts
-var TURN_END_NOTE_BETA = "mid-conversation-system-clear-at-2026-08-21";
-var TURN_END_NOTE_MIN_VISIBLE_CHARACTERS = 350;
-var TURN_END_NOTE_CONTENT = "Your reply above has already reached the user. The tool call after it was housekeeping and changed nothing they need to know. Do not repeat, summarize or rewrite that reply. If no new work remains, end the turn without restating anything.";
-var DEFAULT_TOOLS = ["board", "ctx_reduce"];
-function isRecord4(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function supportsTurnEndNote(model) {
-  return isClaudeFable51Model(model) || isClaudeHaiku55Model(model) || isClaudeOpus55Model(model) || isClaudeSonnet55Model(model);
-}
-function applyTurnEndNotes(body, options = {}) {
-  if (!supportsTurnEndNote(body.model) || !Array.isArray(body.messages))
+}
+function stripBillingLineageFromBody(body) {
+  if (!body || typeof body !== "object")
     return 0;
-  const allowed = new Set((options.tools ?? DEFAULT_TOOLS).map((name) => options.mapToolName?.(name) ?? name));
-  if (!allowed.size)
+  const system = body.system;
+  if (!Array.isArray(system))
     return 0;
-  const messages = body.messages;
-  const rewritten = [];
-  let inserted = 0;
-  for (let index = 0;index < messages.length; index++) {
-    const results = messages[index];
-    rewritten.push(results);
-    let preceding = index - 1;
-    while (preceding >= 0) {
-      const control = messages[preceding];
-      if (!isRecord4(control) || control.role !== "system" || !Array.isArray(control.content) || control.content.length !== 0 || !isRecord4(control.output_config))
-        break;
-      preceding--;
-    }
-    const assistant = messages[preceding];
-    if (!isRecord4(assistant) || assistant.role !== "assistant" || !Array.isArray(assistant.content) || !isRecord4(results) || results.role !== "user" || !Array.isArray(results.content))
-      continue;
-    const visible = options.visibleText ? options.visibleText(assistant) : assistant.content.filter((block) => isRecord4(block) && block.type === "text" && typeof block.text === "string" && block.text.trim().length > 0).map((block) => block.text).join("");
-    if (visible.length < TURN_END_NOTE_MIN_VISIBLE_CHARACTERS)
-      continue;
-    const calls = assistant.content.filter((block) => isRecord4(block) && block.type === "tool_use");
-    if (!calls.length || !calls.every((call) => allowed.has(call.name)))
+  let stripped = 0;
+  for (const block of system) {
+    if (!block || typeof block !== "object")
       continue;
-    const resultIds = new Set(results.content.filter((block) => isRecord4(block) && block.type === "tool_result").map((block) => block.tool_use_id));
-    if (!calls.every((call) => typeof call.id === "string" && resultIds.has(call.id)))
+    const text = block.text;
+    if (typeof text !== "string" || !text.startsWith("x-anthropic-billing-header:")) {
       continue;
-    const next = messages[index + 1];
-    if (isRecord4(next) && next.role === "user")
+    }
+    const clean = stripBillingLineageFields(text);
+    if (clean === text)
       continue;
-    rewritten.push({
-      role: "system",
-      clear_at: "next_user_message",
-      content: TURN_END_NOTE_CONTENT
-    });
-    inserted++;
+    block.text = clean;
+    stripped += 1;
   }
-  if (inserted)
-    body.messages = rewritten;
-  return inserted;
+  return stripped;
 }
 
 // src/claude-code.ts
+import { randomBytes as randomBytes2, randomUUID as randomUUID7 } from "node:crypto";
 var IDENTITY_CACHE_LIMIT = 1000;
 var identityCache = new Map;
 function setBounded(map, key, value, limit = IDENTITY_CACHE_LIMIT) {
@@ -5369,7 +5492,7 @@ async function resolveClaudeCodeAccountIdentity(accessToken, model, accountIdent
     throw new ClaudeUnsupportedAccessError;
   return resolveClaudeCodeIdentity(accessToken, model, accountIdentity);
 }
-function isRecord5(value) {
+function isRecord3(value) {
   return value != null && typeof value === "object" && !Array.isArray(value);
 }
 function buildClaudeCodeMetadataUserId(identity) {
@@ -5384,55 +5507,17 @@ function buildClaudeCodeMetadataUserId(identity) {
 function applyClaudeCodeMetadata(body, identity) {
   const userId = buildClaudeCodeMetadataUserId(identity);
   if (!userId) {
-    if (isRecord5(body.metadata))
+    if (isRecord3(body.metadata))
       delete body.metadata.user_id;
     return false;
   }
-  if (!isRecord5(body.metadata))
+  if (!isRecord3(body.metadata))
     body.metadata = {};
   const metadata = body.metadata;
-  if (isRecord5(metadata))
+  if (isRecord3(metadata))
     metadata.user_id = userId;
   return true;
 }
-var CLAUDE_CODE_FULL_AGENT_BETAS = [
-  "claude-code-20250219",
-  "oauth-2025-04-20",
-  "interleaved-thinking-2025-05-14",
-  "thinking-token-count-2026-05-13",
-  "context-management-2025-06-27",
-  "prompt-caching-scope-2026-01-05",
-  "mid-conversation-tool-changes-2026-07-01",
-  "advanced-tool-use-2025-11-20",
-  TURN_END_NOTE_BETA,
-  "effort-2025-11-24",
-  "thinking-binding-controls-2026-08-01",
-  "thinking-display-updates-2026-08-18",
-  "extended-cache-ttl-2025-04-11",
-  "cache-diagnosis-2026-04-07"
-];
-var CLAUDE_CODE_TITLE_BETAS = [
-  "oauth-2025-04-20",
-  "interleaved-thinking-2025-05-14",
-  "redact-thinking-2026-02-12",
-  "thinking-token-count-2026-05-13",
-  "context-management-2025-06-27",
-  "prompt-caching-scope-2026-01-05",
-  "mid-conversation-tool-changes-2026-07-01",
-  "mid-conversation-system-clear-at-2026-08-21",
-  "effort-2025-11-24",
-  "cache-diagnosis-2026-04-07"
-];
-var CLAUDE_CODE_QUOTA_BETAS = [
-  "oauth-2025-04-20",
-  "interleaved-thinking-2025-05-14",
-  "redact-thinking-2026-02-12",
-  "thinking-token-count-2026-05-13",
-  "context-management-2025-06-27",
-  "prompt-caching-scope-2026-01-05"
-];
-var CLAUDE_CODE_BETA = "claude-code-20250219";
-var PROMPT_CACHING_SCOPE_BETA = "prompt-caching-scope-2026-01-05";
 function hasStructuredOutput(body) {
   const outputConfig = body.output_config;
   const format = outputConfig?.format;
@@ -5442,25 +5527,10 @@ function isQuotaProbe(body) {
   return body.max_tokens === 1 && !body.stream && !body.thinking && (!Array.isArray(body.tools) || body.tools.length === 0) && !hasStructuredOutput(body);
 }
 function selectClaudeCodeBetas(body, extraBetas = [], requestClass = "main") {
-  const selected = requestClass === "main" ? [...CLAUDE_CODE_FULL_AGENT_BETAS] : body && isQuotaProbe(body) ? [...CLAUDE_CODE_QUOTA_BETAS] : [...CLAUDE_CODE_TITLE_BETAS];
-  if (Array.isArray(body?.messages) && body.messages.some((message) => isRecord5(message) && message.clear_at === "next_user_message") && !selected.includes(TURN_END_NOTE_BETA))
+  const lists = body && resolveClaudeModelCapabilities(body.model)?.claudeCodeBetas || CLAUDE_CODE_DEFAULT_BETAS;
+  const selected = requestClass === "main" ? [...lists.main] : body && isQuotaProbe(body) ? [...lists.quota] : [...lists.title];
+  if (Array.isArray(body?.messages) && body.messages.some((message) => isRecord3(message) && message.clear_at === "next_user_message") && !selected.includes(TURN_END_NOTE_BETA))
     selected.push(TURN_END_NOTE_BETA);
-  if (body && isClaudeHaiku55Model(body.model)) {
-    const codeIndex = selected.indexOf(CLAUDE_CODE_BETA);
-    if (codeIndex >= 0) {
-      selected.splice(codeIndex, 1);
-      selected.splice(selected.indexOf(PROMPT_CACHING_SCOPE_BETA) + 1, 0, CLAUDE_CODE_BETA);
-    }
-  }
-  if (body && sendsPerTurnControlBeta(body.model)) {
-    let index = selected.indexOf(PROMPT_CACHING_SCOPE_BETA);
-    if (index >= 0 && selected[index + 1] === CLAUDE_CODE_BETA)
-      index += 1;
-    if (index >= 0)
-      selected.splice(index + 1, 0, PER_TURN_CONTROL_BETA);
-    else
-      selected.push(PER_TURN_CONTROL_BETA);
-  }
   if (body && hasStructuredOutput(body)) {
     const index = selected.indexOf("cache-diagnosis-2026-04-07");
     selected.splice(index < 0 ? selected.length : index, 0, "structured-outputs-2025-12-15");
@@ -5574,8 +5644,8 @@ import {
   unlink as unlink4,
   writeFile as writeFile2
 } from "node:fs/promises";
-import { tmpdir as tmpdir4 } from "node:os";
-import { join as join8, resolve as resolve3 } from "node:path";
+import { tmpdir as tmpdir5 } from "node:os";
+import { join as join9, resolve as resolve3 } from "node:path";
 
 // src/json.ts
 function parseJsonRedacted(text) {
@@ -5846,7 +5916,7 @@ var DUMP_USAGE_TITLE = "## Claude Dump Usage";
 var DUMP_USAGE = "Usage: `/claude-dump`, `/claude-dump on`, or `/claude-dump off`.";
 var DUMP_DIR_ENV = "OPENCODE_ANTHROPIC_AUTH_DUMP_DIR";
 var DUMP_MAX_BYTES_ENV = "OPENCODE_ANTHROPIC_AUTH_DUMP_MAX_BYTES";
-var DEFAULT_DUMP_DIR = join8(tmpdir4(), "opencode-anthropic-auth-dumps");
+var DEFAULT_DUMP_DIR = join9(tmpdir5(), "opencode-anthropic-auth-dumps");
 var DEFAULT_DUMP_MAX_BYTES = 512 * 1024 * 1024;
 var DUMP_SWEEP_INTERVAL_MS = 5 * 60 * 1000;
 var DUMP_SWEEP_NEWNESS_FLOOR_MS = 60 * 1000;
@@ -5949,7 +6019,7 @@ async function sweepDumpDirectory(options) {
       const partial = isDumpPartialFileName(entry.name);
       if (!partial && !isDumpArtifactFileName(entry.name))
         return;
-      const path2 = join8(dumpDir, entry.name);
+      const path2 = join9(dumpDir, entry.name);
       try {
         const stats = await lstat2(path2);
         if (!stats.isFile() || stats.isSymbolicLink())
@@ -6154,7 +6224,7 @@ async function loadLatestDumpBody(input) {
   const candidates = names.map((name) => ({ name, tag: dumpBodyTagForAffinity(name, affinity) })).filter((candidate) => candidate.tag !== undefined).sort((a, b) => b.name.localeCompare(a.name));
   for (const candidate of candidates) {
     try {
-      const path2 = join8(dumpDir, candidate.name);
+      const path2 = join9(dumpDir, candidate.name);
       const metadataPath = path2.replace(/\.body\.json$/, ".meta.json");
       if (!(await lstat2(path2)).isFile())
         continue;
@@ -6281,7 +6351,7 @@ async function dumpRequest(input) {
   const tagSegment = dumpTagSegment(input.tag);
   const id = `${new Date().toISOString().replace(/[:.]/g, "-")}-${String(nextDumpId).padStart(6, "0")}-${dumpFileSessionSegment(affinity, 80 - tagSegment.length)}${tagSegment}-${dumpRequestSegment(input)}`;
   const dumpDir = getDumpDirectory();
-  const prefix = join8(dumpDir, id);
+  const prefix = join9(dumpDir, id);
   const files = {
     body: `${prefix}.body.json`,
     metadata: `${prefix}.meta.json`,
@@ -8491,8 +8561,8 @@ import {
   rm as rm5,
   writeFile as writeFile3
 } from "node:fs/promises";
-import { tmpdir as tmpdir5 } from "node:os";
-import { join as join9 } from "node:path";
+import { tmpdir as tmpdir6 } from "node:os";
+import { join as join10 } from "node:path";
 var CACHE_KEEP_REGISTRY_LEASE_MS = 3 * 60000;
 function normalizeSession(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
@@ -8527,7 +8597,7 @@ function isExpiredRecord(record, now, leaseMs) {
   return record.updatedAt <= now && now - record.updatedAt > leaseMs;
 }
 function getDefaultCacheKeepRegistryDirectory(scope) {
-  return join9(tmpdir5(), "opencode-anthropic-auth", "cachekeep-sessions", scope);
+  return join10(tmpdir6(), "opencode-anthropic-auth", "cachekeep-sessions", scope);
 }
 
 class CacheKeepSessionRegistry {
@@ -8538,7 +8608,7 @@ class CacheKeepSessionRegistry {
   constructor(options) {
     this.options = options;
     const instanceId = options.instanceId ?? `${process.pid}-${randomUUID8()}`;
-    this.filePath = join9(options.directory, `${instanceId}.json`);
+    this.filePath = join10(options.directory, `${instanceId}.json`);
   }
   publish(sessions) {
     const snapshot = sessions.map((session) => ({ ...session }));
@@ -8578,7 +8648,7 @@ class CacheKeepSessionRegistry {
     }
     const records = await Promise.all(names.map(async (name) => {
       try {
-        const raw = await readFile7(join9(this.options.directory, name), "utf8");
+        const raw = await readFile7(join10(this.options.directory, name), "utf8");
         return normalizeRecord(JSON.parse(raw));
       } catch {
         return;
@@ -8620,7 +8690,7 @@ class CacheKeepSessionRegistry {
       return;
     }
     await Promise.all(names.map(async (name) => {
-      const recordPath = join9(this.options.directory, name);
+      const recordPath = join10(this.options.directory, name);
       if (recordPath === this.filePath)
         return;
       let initialRecord;
@@ -8701,7 +8771,7 @@ import {
   dirname as dirname8,
   extname as extname2,
   isAbsolute as isAbsolute2,
-  join as join10,
+  join as join11,
   resolve as resolve4
 } from "node:path";
 import {
@@ -8855,16 +8925,16 @@ function getClaustrumEnrollmentPaths2(tokenPath) {
   const extension = extname2(tokenPath) || ".json";
   const stem = basename3(tokenPath, extname2(tokenPath));
   return {
-    statePath: join10(dirname8(tokenPath), `${stem}-state${extension}`),
+    statePath: join11(dirname8(tokenPath), `${stem}-state${extension}`),
     tokenPath
   };
 }
 function getHostClaustrumEnrollmentPaths(host, env = process.env, cwd = process.cwd()) {
   const configured = env[`${host.toUpperCase()}_ANTHROPIC_AUTH_CLAUSTRUM_ENROLLMENT_FILE`]?.trim();
-  const tokenPath = configured ? isAbsolute2(configured) ? configured : resolve4(cwd, configured) : join10(env.XDG_STATE_HOME || join10(homedir3(), ".local", "state"), "cortexkit", "anthropic-auth", `${host}-enrollment.json`);
+  const tokenPath = configured ? isAbsolute2(configured) ? configured : resolve4(cwd, configured) : join11(env.XDG_STATE_HOME || join11(homedir3(), ".local", "state"), "cortexkit", "anthropic-auth", `${host}-enrollment.json`);
   return getClaustrumEnrollmentPaths2(tokenPath);
 }
-function isRecord6(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validTimestamp2(value) {
@@ -8874,7 +8944,7 @@ function validGeneration2(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 1;
 }
 function decodeEnrollmentState2(value) {
-  if (!isRecord6(value) || value.version !== ENROLLMENT_SCHEMA2 || typeof value.proposedName !== "string" || value.proposedName.length === 0) {
+  if (!isRecord4(value) || value.version !== ENROLLMENT_SCHEMA2 || typeof value.proposedName !== "string" || value.proposedName.length === 0) {
     throw new Error("invalid Claustrum enrollment state");
   }
   if (value.phase === "pending") {
@@ -8925,7 +8995,7 @@ function decodeEnrollmentState2(value) {
   throw new Error("invalid Claustrum enrollment state");
 }
 function decodeTokenFile2(value) {
-  if (!isRecord6(value) || !TOKEN_RE2.test(String(value.token ?? "")) || !validGeneration2(value.token_generation)) {
+  if (!isRecord4(value) || !TOKEN_RE2.test(String(value.token ?? "")) || !validGeneration2(value.token_generation)) {
     throw new Error("invalid Claustrum enrollment token file");
   }
   return {
@@ -9006,7 +9076,7 @@ async function writeStateAtomic2(path2, state, beforeRename) {
   if (Buffer.byteLength(bytes) > ENROLLMENT_FILE_MAX_BYTES2) {
     throw new Error("Claustrum enrollment state is too large");
   }
-  const temporary = join10(parent, `.${basename3(path2)}.${process.pid}.${randomUUID9()}.tmp`);
+  const temporary = join11(parent, `.${basename3(path2)}.${process.pid}.${randomUUID9()}.tmp`);
   let descriptor;
   try {
     const nativeCreated = await createWindowsOwnerOnly(temporary, bytes);
@@ -9025,7 +9095,7 @@ async function writeStateAtomic2(path2, state, beforeRename) {
   }
 }
 async function writeTokenAtomic(path2, value, writeTokenFile, beforeRename) {
-  const staged = join10(dirname8(path2), `.${basename3(path2)}.${process.pid}.${randomUUID9()}.tmp`);
+  const staged = join11(dirname8(path2), `.${basename3(path2)}.${process.pid}.${randomUUID9()}.tmp`);
   try {
     await writeTokenFile(staged, value);
     await beforeRename();
@@ -9487,7 +9557,9 @@ function formatEnrollmentStatus(status, scopedServing = false) {
     case "busy":
       return ["- Enrollment: setup is busy"];
     case "unavailable":
-      return ["- Enrollment: temporarily unavailable"];
+      return [
+        "- Enrollment: this Claustrum vault does not support connecting plugins"
+      ];
     case "pending":
       return status.requestId && /^[A-Za-z0-9_-]{1,128}$/.test(status.requestId) ? [`- Enrollment: pending approval (${status.requestId})`, setup] : [
         status.requestId ? "- Enrollment: pending approval" : "- Enrollment: request not sent",
@@ -10069,6 +10141,102 @@ function executeLoggingCommand(input) {
   ].join(`
 `);
 }
+// src/mid-conversation-output-config.ts
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeAdaptiveEffort(value) {
+  if (value === "minimal")
+    return "low";
+  if (value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max") {
+    return value;
+  }
+  return;
+}
+function usesPerTurnControl(model) {
+  return resolveClaudeModelCapabilities(model)?.effortMarkers === "with-adaptive-thinking";
+}
+function sendsPerTurnControlBeta(model) {
+  return resolveClaudeModelCapabilities(model)?.claudeCodeBetas.main.includes(PER_TURN_CONTROL_BETA) ?? false;
+}
+function supportsPerMessageEffort(body) {
+  if (pinsEffortOnEveryRequest(body.model))
+    return true;
+  return usesPerTurnControl(body.model) && isRecord5(body.thinking) && body.thinking.type === "adaptive";
+}
+function defaultAdaptiveEffort(model) {
+  return resolveClaudeModelCapabilities(model)?.efforts.default ?? "high";
+}
+function compactTransitions(transitions) {
+  const compacted = [];
+  for (const transition of transitions) {
+    if (!Number.isSafeInteger(transition.afterAssistantMessages) || transition.afterAssistantMessages < 0 || !normalizeAdaptiveEffort(transition.effort)) {
+      continue;
+    }
+    const normalized = {
+      afterAssistantMessages: transition.afterAssistantMessages,
+      effort: transition.effort
+    };
+    const previous = compacted.at(-1);
+    if (previous && previous.afterAssistantMessages === normalized.afterAssistantMessages) {
+      previous.effort = normalized.effort;
+      continue;
+    }
+    if (previous?.effort === normalized.effort)
+      continue;
+    compacted.push(normalized);
+  }
+  return compacted;
+}
+function applyMidConversationOutputConfig(body, transitions) {
+  if (!supportsPerMessageEffort(body) || !Array.isArray(body.messages)) {
+    return { applied: false, inserted: 0 };
+  }
+  const compacted = compactTransitions(transitions);
+  const pinsEveryRequest = pinsEffortOnEveryRequest(body.model);
+  if (!pinsEveryRequest && compacted.length < 2) {
+    return { applied: false, inserted: 0 };
+  }
+  const currentOutputConfig = isRecord5(body.output_config) ? body.output_config : {};
+  const baseline = compacted[0]?.effort ?? normalizeAdaptiveEffort(currentOutputConfig.effort) ?? defaultAdaptiveEffort(body.model);
+  const pinnedOutputConfig = { ...currentOutputConfig, effort: baseline };
+  if (pinsEveryRequest)
+    body.output_config = pinnedOutputConfig;
+  if (compacted.length < 2)
+    return { applied: true, inserted: 0 };
+  const messages = body.messages;
+  const transitionsByBoundary = new Map;
+  for (const transition of compacted.slice(1)) {
+    transitionsByBoundary.set(transition.afterAssistantMessages, transition.effort);
+  }
+  let assistantMessages = 0;
+  let activeEffort = baseline;
+  let inserted = 0;
+  const rewritten = [];
+  for (const message of messages) {
+    if (isRecord5(message) && message.role === "user" && transitionsByBoundary.has(assistantMessages)) {
+      const effort = transitionsByBoundary.get(assistantMessages);
+      if (effort && effort !== activeEffort) {
+        rewritten.push({
+          role: "system",
+          content: [],
+          output_config: { effort }
+        });
+        activeEffort = effort;
+        inserted++;
+      }
+    }
+    rewritten.push(message);
+    if (isRecord5(message) && message.role === "assistant")
+      assistantMessages++;
+  }
+  if (!pinsEveryRequest && inserted === 0) {
+    return { applied: false, inserted: 0 };
+  }
+  body.output_config = pinnedOutputConfig;
+  body.messages = rewritten;
+  return { applied: true, inserted };
+}
 // src/model-remap.ts
 function getEnv(name) {
   const value = process.env[name]?.trim();
@@ -10116,6 +10284,130 @@ function remapRequestBodyModel(parsed) {
   parsed.model = remapped;
   return true;
 }
+// src/models.ts
+var CLAUDE_FABLE_5_MODEL_ID = "claude-fable-5";
+var CLAUDE_MYTHOS_5_MODEL_ID = "claude-mythos-5";
+var CLAUDE_FABLE_5_1_MODEL_ID = "claude-fable-5-1";
+var CLAUDE_MYTHOS_5_1_MODEL_ID = "claude-mythos-5-1";
+var CLAUDE_HAIKU_4_5_MODEL_ID = "claude-haiku-4-5";
+var CLAUDE_HAIKU_4_5_PRICING = {
+  input: 1,
+  output: 5
+};
+var CLAUDE_FABLE_MYTHOS_5_1_MODEL_IDS = [
+  CLAUDE_FABLE_5_1_MODEL_ID,
+  CLAUDE_MYTHOS_5_1_MODEL_ID
+];
+var CLAUDE_FABLE_MYTHOS_5_MODEL_IDS = [
+  CLAUDE_FABLE_5_MODEL_ID,
+  CLAUDE_MYTHOS_5_MODEL_ID,
+  ...CLAUDE_FABLE_MYTHOS_5_1_MODEL_IDS
+];
+var CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING = {
+  type: "adaptive",
+  display: "summarized"
+};
+var FABLE_5_CATALOGUE = getClaudeModelCatalogue(CLAUDE_FABLE_5_MODEL_ID);
+var FABLE_5_1_CATALOGUE = getClaudeModelCatalogue(CLAUDE_FABLE_5_1_MODEL_ID);
+var CLAUDE_FABLE_MYTHOS_5_PRICING = FABLE_5_CATALOGUE.pricing;
+var CLAUDE_FABLE_MYTHOS_5_1_PRICING = FABLE_5_1_CATALOGUE.pricing;
+var CLAUDE_FABLE_MYTHOS_5_CONTEXT_WINDOW = FABLE_5_CATALOGUE.contextWindow;
+var CLAUDE_FABLE_MYTHOS_5_MAX_OUTPUT_TOKENS = FABLE_5_CATALOGUE.maxOutputTokens;
+var CLAUDE_FABLE_MYTHOS_5_RELEASE_DATE = FABLE_5_CATALOGUE.releaseDate;
+var CLAUDE_FABLE_MYTHOS_5_1_RELEASE_DATE = FABLE_5_1_CATALOGUE.releaseDate;
+function isFableOrMythosRow(row) {
+  return row?.family === "fable" || row?.family === "mythos";
+}
+var CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS = Object.fromEntries(CLAUDE_FABLE_MYTHOS_5_MODEL_IDS.map((id) => {
+  const row = getClaudeModelCapabilities(id);
+  return [
+    id,
+    { id, name: row.name, ...row.limited && { limited: true } }
+  ];
+}));
+var CLAUDE_FABLE_MYTHOS_5_1_MODEL_SPECS = {
+  [CLAUDE_FABLE_5_1_MODEL_ID]: CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS[CLAUDE_FABLE_5_1_MODEL_ID],
+  [CLAUDE_MYTHOS_5_1_MODEL_ID]: CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS[CLAUDE_MYTHOS_5_1_MODEL_ID]
+};
+function resolvedModelId(model) {
+  return resolveClaudeModelCapabilities(model)?.id;
+}
+function isClaudeFableOrMythos5Model(model) {
+  return isFableOrMythosRow(resolveClaudeModelCapabilities(model));
+}
+function isClaudeFableOrMythos51Model(model) {
+  const id = resolvedModelId(model);
+  return CLAUDE_FABLE_MYTHOS_5_1_MODEL_IDS.includes(id);
+}
+function isClaudeFable51Model(model) {
+  return resolvedModelId(model) === CLAUDE_FABLE_5_1_MODEL_ID;
+}
+function getClaudeFableMythos5ReleaseDate(model) {
+  return isClaudeFableOrMythos51Model(model) ? CLAUDE_FABLE_MYTHOS_5_1_RELEASE_DATE : CLAUDE_FABLE_MYTHOS_5_RELEASE_DATE;
+}
+var CLAUDE_SONNET_5_MODEL_ID = "claude-sonnet-5";
+var CLAUDE_SONNET_5_ADAPTIVE_THINKING = CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING;
+function isClaudeSonnet5Model(model) {
+  return resolvedModelId(model) === CLAUDE_SONNET_5_MODEL_ID;
+}
+var CLAUDE_SONNET_5_5_MODEL_ID = "claude-sonnet-5-5";
+var SONNET_5_5_CATALOGUE = getClaudeModelCatalogue(CLAUDE_SONNET_5_5_MODEL_ID);
+var CLAUDE_SONNET_5_5_RELEASE_DATE = SONNET_5_5_CATALOGUE.releaseDate;
+var CLAUDE_SONNET_5_5_CONTEXT_WINDOW = SONNET_5_5_CATALOGUE.contextWindow;
+var CLAUDE_SONNET_5_5_MAX_OUTPUT_TOKENS = SONNET_5_5_CATALOGUE.maxOutputTokens;
+var CLAUDE_SONNET_5_5_PRICING = SONNET_5_5_CATALOGUE.pricing;
+var CLAUDE_SONNET_5_5_ADAPTIVE_THINKING = CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING;
+function isClaudeSonnet55Model(model) {
+  return resolvedModelId(model) === CLAUDE_SONNET_5_5_MODEL_ID;
+}
+var CLAUDE_HAIKU_5_5_MODEL_ID = "claude-haiku-5-5";
+var HAIKU_5_5_CATALOGUE = getClaudeModelCatalogue(CLAUDE_HAIKU_5_5_MODEL_ID);
+var HAIKU_5_5_LONG_CONTEXT = HAIKU_5_5_CATALOGUE.longContext;
+if (!HAIKU_5_5_LONG_CONTEXT) {
+  throw new Error("Haiku 5.5 capability row lacks long-context pricing");
+}
+var CLAUDE_HAIKU_5_5_RELEASE_DATE = HAIKU_5_5_CATALOGUE.releaseDate;
+var CLAUDE_HAIKU_5_5_CONTEXT_WINDOW = HAIKU_5_5_CATALOGUE.contextWindow;
+var CLAUDE_HAIKU_5_5_MAX_OUTPUT_TOKENS = HAIKU_5_5_CATALOGUE.maxOutputTokens;
+var CLAUDE_HAIKU_5_5_LONG_CONTEXT_THRESHOLD = HAIKU_5_5_LONG_CONTEXT.inputTokensAbove;
+var CLAUDE_HAIKU_5_5_PRICING = HAIKU_5_5_CATALOGUE.pricing;
+var CLAUDE_HAIKU_5_5_LONG_CONTEXT_PRICING = HAIKU_5_5_LONG_CONTEXT.pricing;
+var CLAUDE_HAIKU_5_5_ADAPTIVE_THINKING = CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING;
+function isClaudeHaiku55Model(model) {
+  return resolvedModelId(model) === CLAUDE_HAIKU_5_5_MODEL_ID;
+}
+var CLAUDE_OPUS_5_MODEL_ID = "claude-opus-5";
+var CLAUDE_OPUS_5_ADAPTIVE_THINKING = CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING;
+function isClaudeOpus5Model(model) {
+  return resolvedModelId(model) === CLAUDE_OPUS_5_MODEL_ID;
+}
+var CLAUDE_OPUS_5_5_MODEL_ID = "claude-opus-5-5";
+var OPUS_5_5_CATALOGUE = getClaudeModelCatalogue(CLAUDE_OPUS_5_5_MODEL_ID);
+var CLAUDE_OPUS_5_5_RELEASE_DATE = OPUS_5_5_CATALOGUE.releaseDate;
+var CLAUDE_OPUS_5_5_CONTEXT_WINDOW = OPUS_5_5_CATALOGUE.contextWindow;
+var CLAUDE_OPUS_5_5_MAX_OUTPUT_TOKENS = OPUS_5_5_CATALOGUE.maxOutputTokens;
+var CLAUDE_OPUS_5_5_PRICING = OPUS_5_5_CATALOGUE.pricing;
+var CLAUDE_OPUS_5_5_ADAPTIVE_THINKING = CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING;
+function isClaudeOpus55Model(model) {
+  return resolvedModelId(model) === CLAUDE_OPUS_5_5_MODEL_ID;
+}
+function isClaudeOpus5FamilyModel(model) {
+  return isClaudeOpus5Model(model) || isClaudeOpus55Model(model);
+}
+function isOpenAIReasoningSignature(value) {
+  if (typeof value !== "string")
+    return false;
+  if (value.startsWith("gAAAA"))
+    return true;
+  if (!value.startsWith("{"))
+    return false;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed.type === "reasoning" && typeof parsed.id === "string" && parsed.id.startsWith("rs_") && typeof parsed.encrypted_content === "string" && parsed.encrypted_content.startsWith("gAAAA");
+  } catch {
+    return false;
+  }
+}
 // src/native-account-runtime.ts
 import { randomUUID as randomUUID15 } from "node:crypto";
 
@@ -10356,7 +10648,7 @@ function canonicalJson(value) {
   const encode = (item) => {
     if (Array.isArray(item))
       return `[${item.map(encode).join(",")}]`;
-    if (isRecord7(item))
+    if (isRecord6(item))
       return `{${Object.keys(item).sort().map((key) => `${JSON.stringify(key)}:${encode(item[key])}`).join(",")}}`;
     return JSON.stringify(item);
   };
@@ -10366,12 +10658,12 @@ function canonicalDigest(value) {
   return createHash6("sha256").update(canonicalJson(value)).digest("hex");
 }
 function parseReservation(raw) {
-  if (!isRecord7(raw) || Object.keys(raw).length !== 1 || typeof raw.reservation !== "string" || !raw.reservation)
+  if (!isRecord6(raw) || Object.keys(raw).length !== 1 || typeof raw.reservation !== "string" || !raw.reservation)
     return;
   return { reservation: raw.reservation };
 }
 function parseStagedStamp(raw) {
-  if (!isRecord7(raw) || typeof raw.reservation !== "string" || !raw.reservation || typeof raw.disabledReason !== "string")
+  if (!isRecord6(raw) || typeof raw.reservation !== "string" || !raw.reservation || typeof raw.disabledReason !== "string")
     return;
   if (Object.keys(raw).some((key) => !["reservation", "label", "disabledReason", "providerState"].includes(key)))
     return;
@@ -10382,7 +10674,7 @@ function parseStagedStamp(raw) {
   return raw;
 }
 var PROVIDER_STATE_KEY = "commonAuthProviderState";
-function isRecord7(value) {
+function isRecord6(value) {
   return value != null && typeof value === "object" && !Array.isArray(value);
 }
 var UNSAFE_IDS = new Set(["__proto__", "constructor", "prototype"]);
@@ -10446,7 +10738,7 @@ function providerStateDigest(codec, value) {
 function boundProviderStateDigest(account, credential, credentialEpoch, identity) {
   if (!credential || credentialEpoch === undefined)
     return;
-  if (!isRecord7(account) || !Object.hasOwn(account, PROVIDER_STATE_KEY))
+  if (!isRecord6(account) || !Object.hasOwn(account, PROVIDER_STATE_KEY))
     return;
   const stamp = parseStamp(account[CREDENTIAL_STAMP_KEY]);
   if (!stamp || stamp.providerState === undefined || stamp.digest !== credentialDigest(credential) || stamp.credentialEpoch !== credentialEpoch || stamp.binding?.identity !== identity)
@@ -10457,7 +10749,7 @@ function isCredentialEpoch(value) {
   return Number.isSafeInteger(value) && value >= 1;
 }
 function parseStamp(raw) {
-  if (!isRecord7(raw))
+  if (!isRecord6(raw))
     return;
   const epoch = raw.credentialEpoch;
   if (!isCredentialEpoch(epoch))
@@ -10482,7 +10774,7 @@ function parseStamp(raw) {
   if (!("binding" in raw))
     return "dispatch" in raw || "replace" in raw || "providerState" in raw || "staged" in raw ? undefined : { credentialEpoch: epoch, digest: raw.digest };
   const binding = raw.binding;
-  if (!isRecord7(binding))
+  if (!isRecord6(binding))
     return;
   if ("identity" in binding && (typeof binding.identity !== "string" || !binding.identity))
     return;
@@ -10513,7 +10805,7 @@ function bindingAgrees(binding, credential, identity) {
 function stampStatusOf(credential, credentialEpoch, identity, account) {
   if (!credential)
     return "none";
-  if (!isRecord7(account) || !Object.hasOwn(account, CREDENTIAL_STAMP_KEY))
+  if (!isRecord6(account) || !Object.hasOwn(account, CREDENTIAL_STAMP_KEY))
     return "missing";
   const stamp = parseStamp(account[CREDENTIAL_STAMP_KEY]);
   if (!stamp)
@@ -10536,7 +10828,7 @@ function classifyConfig(read) {
   if ("parseError" in read)
     return { status: "error", reason: "config file is not valid JSON" };
   const value = read.value;
-  if (!isRecord7(value))
+  if (!isRecord6(value))
     return { status: "error", reason: "config root is not an object" };
   if ("accounts" in value && !Array.isArray(value.accounts))
     return { status: "error", reason: "config accounts is not an array" };
@@ -10544,7 +10836,7 @@ function classifyConfig(read) {
     return Array.isArray(value.accounts) ? { status: "pending-migration", config: value } : { status: "ready", exists: true, config: value };
   }
   const pool = value[POOL_KEY];
-  if (!isRecord7(pool))
+  if (!isRecord6(pool))
     return { status: "error", reason: `${POOL_KEY} is not an object` };
   const version = pool.schemaVersion;
   if (typeof version !== "number" || !Number.isInteger(version) || version < 1)
@@ -10554,7 +10846,7 @@ function classifyConfig(read) {
       status: "error",
       reason: `${POOL_KEY}.schemaVersion ${version} is newer than ${POOL_SCHEMA_VERSION}`
     };
-  if (POOL_ROWS_KEY in pool && !isRecord7(pool[POOL_ROWS_KEY]))
+  if (POOL_ROWS_KEY in pool && !isRecord6(pool[POOL_ROWS_KEY]))
     return {
       status: "error",
       reason: `${POOL_KEY}.${POOL_ROWS_KEY} is not an object`
@@ -10566,9 +10858,9 @@ function classifyState(read) {
     return { status: "ready", exists: false, state: {} };
   if ("parseError" in read)
     return { status: "error", reason: "state file is not valid JSON" };
-  if (!isRecord7(read.value))
+  if (!isRecord6(read.value))
     return { status: "error", reason: "state root is not an object" };
-  if ("accounts" in read.value && !isRecord7(read.value.accounts))
+  if ("accounts" in read.value && !isRecord6(read.value.accounts))
     return { status: "error", reason: "state accounts is not an object" };
   return { status: "ready", exists: true, state: read.value };
 }
@@ -10577,16 +10869,16 @@ function rosterOf(config) {
 }
 function entriesOf(config) {
   const pool = config[POOL_KEY];
-  if (!isRecord7(pool))
+  if (!isRecord6(pool))
     return {};
   const rows = pool[POOL_ROWS_KEY];
-  return isRecord7(rows) ? rows : {};
+  return isRecord6(rows) ? rows : {};
 }
 function stateAccountsOf(state) {
-  return isRecord7(state.accounts) ? state.accounts : {};
+  return isRecord6(state.accounts) ? state.accounts : {};
 }
 function rosterRowProblem(raw) {
-  if (!isRecord7(raw))
+  if (!isRecord6(raw))
     return "not an object";
   const problem = idProblem(raw.id);
   if (problem)
@@ -10598,7 +10890,7 @@ function rosterRowProblem(raw) {
   return "unknown type";
 }
 function parseEntry(raw, codec) {
-  if (!isRecord7(raw))
+  if (!isRecord6(raw))
     return;
   const epoch = raw.credentialEpoch;
   if (!isCredentialEpoch(epoch))
@@ -10620,7 +10912,7 @@ function parseEntry(raw, codec) {
   };
 }
 function credentialFor(raw, stateEntry) {
-  if (!isRecord7(stateEntry))
+  if (!isRecord6(stateEntry))
     return;
   if (raw.type === "api") {
     const apiKey = typeof stateEntry.apiKey === "string" ? stateEntry.apiKey.trim() : "";
@@ -10647,23 +10939,23 @@ function credentialFor(raw, stateEntry) {
   };
 }
 function rosterRowIn(config, id) {
-  return rosterOf(config).find((raw) => isRecord7(raw) && raw.id === id);
+  return rosterOf(config).find((raw) => isRecord6(raw) && raw.id === id);
 }
 function ensurePool(config) {
-  if (!isRecord7(config[POOL_KEY]))
+  if (!isRecord6(config[POOL_KEY]))
     config[POOL_KEY] = {};
   return config[POOL_KEY];
 }
 function ensureEntries(config) {
   const pool = ensurePool(config);
-  if (!isRecord7(pool[POOL_ROWS_KEY]))
+  if (!isRecord6(pool[POOL_ROWS_KEY]))
     pool[POOL_ROWS_KEY] = {};
   return pool[POOL_ROWS_KEY];
 }
 function entryIn(config, id) {
   const entries = entriesOf(config);
   const entry = Object.hasOwn(entries, id) ? entries[id] : undefined;
-  return isRecord7(entry) ? entry : undefined;
+  return isRecord6(entry) ? entry : undefined;
 }
 function setEntryIn(config, id, entry) {
   Object.defineProperty(ensureEntries(config), id, {
@@ -10675,10 +10967,10 @@ function setEntryIn(config, id, entry) {
 }
 function retiredEpochIn(config, id) {
   const pool = config[POOL_KEY];
-  if (!isRecord7(pool))
+  if (!isRecord6(pool))
     return;
   const retired = pool[POOL_RETIRED_EPOCHS_KEY];
-  if (!isRecord7(retired) || !Object.hasOwn(retired, id))
+  if (!isRecord6(retired) || !Object.hasOwn(retired, id))
     return;
   const epoch = retired[id];
   return isCredentialEpoch(epoch) ? epoch : undefined;
@@ -10695,7 +10987,7 @@ function retireEpochsIn(config, dropped) {
   if (ids.length === 0)
     return;
   const pool = ensurePool(config);
-  const previous = isRecord7(pool[POOL_RETIRED_EPOCHS_KEY]) ? pool[POOL_RETIRED_EPOCHS_KEY] : {};
+  const previous = isRecord6(pool[POOL_RETIRED_EPOCHS_KEY]) ? pool[POOL_RETIRED_EPOCHS_KEY] : {};
   const next = {};
   const define = (id, epoch) => Object.defineProperty(next, id, {
     value: epoch,
@@ -10717,17 +11009,17 @@ function buildRawRows(config, state, codec, providerCodec) {
   const rows = [];
   for (const raw of rosterOf(config)) {
     const problem = rosterRowProblem(raw);
-    const id = isRecord7(raw) && typeof raw.id === "string" ? raw.id : undefined;
+    const id = isRecord6(raw) && typeof raw.id === "string" ? raw.id : undefined;
     const rawEntry = id === undefined ? undefined : entries[id];
-    const reserved = isRecord7(rawEntry) && Object.hasOwn(rawEntry, "staged");
+    const reserved = isRecord6(rawEntry) && Object.hasOwn(rawEntry, "staged");
     const staged = reserved ? parseReservation(rawEntry.staged) : undefined;
-    if (problem || !isRecord7(raw) || id === undefined || seen.has(id)) {
+    if (problem || !isRecord6(raw) || id === undefined || seen.has(id)) {
       if (id !== undefined && !seen.has(id))
         seen.add(id);
       if (id !== undefined)
         rows.push({
           id,
-          type: isRecord7(raw) && raw.type === "api" ? "api" : "oauth",
+          type: isRecord6(raw) && raw.type === "api" ? "api" : "oauth",
           enabled: false,
           needsFirstReading: true,
           hasEntry: Object.hasOwn(entries, id),
@@ -10774,7 +11066,7 @@ function buildRawRows(config, state, codec, providerCodec) {
   return rows;
 }
 function providerStateFields(account, credential, credentialEpoch, identity, codec) {
-  if (!isRecord7(account) || !Object.hasOwn(account, PROVIDER_STATE_KEY))
+  if (!isRecord6(account) || !Object.hasOwn(account, PROVIDER_STATE_KEY))
     return {};
   const digest = boundProviderStateDigest(account, credential, credentialEpoch, identity);
   if (digest === undefined)
@@ -10834,7 +11126,7 @@ function storedCredential(credential, lastRefreshedAt) {
   };
 }
 function credentialProblem(credential, options = {}) {
-  if (!isRecord7(credential))
+  if (!isRecord6(credential))
     return "credential must be an object";
   if (credential.type === "oauth") {
     if (typeof credential.refresh !== "string" || !credential.refresh.trim())
@@ -10858,10 +11150,10 @@ function credentialProblem(credential, options = {}) {
 var TRANSITION_STAMP_KEY = "transition";
 var TRANSITION_MARK_KEY = "transitionMark";
 function stampedTransition(rawStamp) {
-  if (!isRecord7(rawStamp))
+  if (!isRecord6(rawStamp))
     return;
   const raw = rawStamp[TRANSITION_STAMP_KEY];
-  if (!isRecord7(raw))
+  if (!isRecord6(raw))
     return;
   if (typeof raw.mark !== "string" || raw.mark.length === 0)
     return;
@@ -10904,13 +11196,13 @@ function isReplaceStamp(stamp) {
   return stamp.replace === true || stamp.dispatch === undefined;
 }
 function tornStamps(config, state, codec, options = {}) {
-  const accounts = isRecord7(state.accounts) ? state.accounts : {};
+  const accounts = isRecord6(state.accounts) ? state.accounts : {};
   const torn = new Map;
   for (const row of buildRawRows(config, state, codec)) {
     if (row.invalid || row.staged || !row.credential)
       continue;
     const account = Object.hasOwn(accounts, row.id) ? accounts[row.id] : undefined;
-    if (!isRecord7(account))
+    if (!isRecord6(account))
       continue;
     const stamp = parseStamp(account[CREDENTIAL_STAMP_KEY]);
     if (!stamp?.binding)
@@ -11115,7 +11407,7 @@ class Transaction {
       return entry && Object.hasOwn(entry, "staged") ? entry.staged : undefined;
     }
     const stamp = this.stateAccount(id)?.[CREDENTIAL_STAMP_KEY];
-    return isRecord7(stamp) && Object.hasOwn(stamp, "staged") ? stamp.staged : undefined;
+    return isRecord6(stamp) && Object.hasOwn(stamp, "staged") ? stamp.staged : undefined;
   }
   assertNotStaged(id) {
     assertNotReserved(this.info.operation, id, this.reservation(id));
@@ -11131,7 +11423,7 @@ class Transaction {
   }
   dropRosterRows(id) {
     const roster = this.roster();
-    const kept = roster.filter((raw) => !(isRecord7(raw) && raw.id === id));
+    const kept = roster.filter((raw) => !(isRecord6(raw) && raw.id === id));
     this.config.accounts = kept;
     return roster.length - kept.length;
   }
@@ -11153,16 +11445,16 @@ class Transaction {
     await this.commitConfig({ counted: false });
   }
   stateAccount(id) {
-    const accounts = isRecord7(this.state.accounts) ? this.state.accounts : {};
+    const accounts = isRecord6(this.state.accounts) ? this.state.accounts : {};
     const entry = Object.hasOwn(accounts, id) ? accounts[id] : undefined;
-    return isRecord7(entry) ? entry : undefined;
+    return isRecord6(entry) ? entry : undefined;
   }
   dropStateAccount(id) {
-    if (isRecord7(this.state.accounts) && Object.hasOwn(this.state.accounts, id))
+    if (isRecord6(this.state.accounts) && Object.hasOwn(this.state.accounts, id))
       delete this.state.accounts[id];
   }
   setStateAccount(id, fields) {
-    if (!isRecord7(this.state.accounts))
+    if (!isRecord6(this.state.accounts))
       this.state.accounts = {};
     Object.defineProperty(this.state.accounts, id, {
       value: fields,
@@ -11175,11 +11467,11 @@ class Transaction {
     const roster = this.roster();
     const rosterIds = new Set;
     for (const raw of roster)
-      if (isRecord7(raw) && typeof raw.id === "string")
+      if (isRecord6(raw) && typeof raw.id === "string")
         rosterIds.add(raw.id);
     const dropped = new Set;
     for (const raw of rosterOf(this.snapshot.config))
-      if (isRecord7(raw) && typeof raw.id === "string" && !rosterIds.has(raw.id))
+      if (isRecord6(raw) && typeof raw.id === "string" && !rosterIds.has(raw.id))
         dropped.add(raw.id);
     for (const id of Object.keys(this.entries()))
       if (!rosterIds.has(id))
@@ -11221,7 +11513,7 @@ class Transaction {
     const next = {
       ...this.state,
       version: LEGACY_STORE_VERSION,
-      accounts: isRecord7(this.state.accounts) ? this.state.accounts : {}
+      accounts: isRecord6(this.state.accounts) ? this.state.accounts : {}
     };
     await this.write(this.ctx.statePath, next, "state", true, options.durable ?? false);
     this.state = next;
@@ -11416,11 +11708,11 @@ async function readRow(rt, operation, id) {
   const row = result.rows.find((candidate) => candidate.id === id);
   const entry = entryIn(result.config, id);
   const accounts = result.state.accounts;
-  const account = isRecord7(accounts) && Object.hasOwn(accounts, id) ? accounts[id] : undefined;
-  const stamp = isRecord7(account) ? account[CREDENTIAL_STAMP_KEY] : undefined;
+  const account = isRecord6(accounts) && Object.hasOwn(accounts, id) ? accounts[id] : undefined;
+  const stamp = isRecord6(account) ? account[CREDENTIAL_STAMP_KEY] : undefined;
   if (row && !["enable", "disable"].includes(operation) && entry && Object.hasOwn(entry, "staged"))
     assertNotReserved(operation, id, entry.staged);
-  if (!row && isRecord7(stamp) && Object.hasOwn(stamp, "staged"))
+  if (!row && isRecord6(stamp) && Object.hasOwn(stamp, "staged"))
     assertNotReserved(operation, id, stamp.staged);
   if (!row)
     throw unknownRow(operation, id);
@@ -11552,7 +11844,7 @@ async function updateProviderStateRow(rt, id, fence, mutator, options = {}) {
       throw refusal(operation, id, "invalid-input", "the store was opened without a provider-state codec");
     if (typeof mutator !== "function")
       throw refusal(operation, id, "invalid-input", "a mutator is required");
-    const captured = isRecord7(fence) ? fence.credentialEpoch : undefined;
+    const captured = isRecord6(fence) ? fence.credentialEpoch : undefined;
     if (!isCredentialEpoch(captured))
       throw refusal(operation, id, "invalid-input", "the credential epoch the provider state was read at is required");
     const { row: seen } = await readRow(rt, operation, id);
@@ -11596,7 +11888,7 @@ async function planProviderStateIn(tx, codec, operation, row, mutator, declinabl
   const account = tx.stateAccount(id);
   const rawStamp = account?.[CREDENTIAL_STAMP_KEY];
   const stamp = parseStamp(rawStamp);
-  if (!isRecord7(rawStamp) || !stamp?.binding || stamp.digest !== credentialDigest(credential) || stamp.credentialEpoch !== epoch || stamp.binding.identity !== row.identity)
+  if (!isRecord6(rawStamp) || !stamp?.binding || stamp.digest !== credentialDigest(credential) || stamp.credentialEpoch !== epoch || stamp.binding.identity !== row.identity)
     throw refusal(operation, id, "unbound-credential", `row ${id}'s credential carries no stamp of this store to bind a provider state to (stamp ${row.stamp}); rotate or replace it first`);
   const current = row.providerState === undefined ? undefined : structuredClone(row.providerState);
   const returned = await runInsideHook(operation, () => mutator(current, row));
@@ -11672,7 +11964,7 @@ function onRowEndpoint(tx, id, credential) {
   if (credential.type !== "api")
     return credential;
   const raw = tx.rosterRow(id);
-  if (!isRecord7(raw)) {
+  if (!isRecord6(raw)) {
     if (credential.baseURL === undefined)
       throw refusal(tx.info.operation, id, "invalid-input", "api credential needs a valid baseURL");
     return { ...credential, baseURL: credential.baseURL };
@@ -11691,7 +11983,7 @@ function onRowEndpoint(tx, id, credential) {
 function bindingInTx(tx, id, stored, learnt) {
   const raw = tx.rosterRow(id);
   const projected = tx.row(id);
-  const identity = learnt ?? (projected ? projected.identity : isRecord7(raw) && typeof raw.accountId === "string" && raw.accountId ? raw.accountId : undefined);
+  const identity = learnt ?? (projected ? projected.identity : isRecord6(raw) && typeof raw.accountId === "string" && raw.accountId ? raw.accountId : undefined);
   return {
     ...identity !== undefined ? { identity } : {},
     ...stored.type === "api" ? {
@@ -11775,7 +12067,7 @@ function requireUsableRow(operation, id, row, credential) {
   return row;
 }
 function validateAttribution(operation, id, fence) {
-  if (fence !== undefined && !isCredentialEpoch(isRecord7(fence) ? fence.credentialEpoch : undefined))
+  if (fence !== undefined && !isCredentialEpoch(isRecord6(fence) ? fence.credentialEpoch : undefined))
     throw refusal(operation, id, "invalid-input", "the attribution must name a credential epoch that is a positive safe integer");
 }
 function assertRowAttribution(operation, id, row, fence) {
@@ -11930,7 +12222,7 @@ async function addRow(rt, input, options = {}) {
     const mode = options.onExisting ?? "rotate";
     if (input.stage !== undefined && mode === "rotate")
       throw refusal("add", id, "invalid-input", "a staged add needs onExisting: 'refuse' or 'stage-duplicate'");
-    if (!["rotate", "refuse", "stage-duplicate"].includes(mode) || input.stage !== undefined && (label !== undefined && typeof label !== "string" || identity !== undefined && (typeof identity !== "string" || !identity)) || input.disabled !== undefined && (!isRecord7(input.disabled) || typeof input.disabled.reason !== "string") || input.stage !== undefined && (!isRecord7(input.stage) || typeof input.stage.reservation !== "string" || !input.stage.reservation || !input.disabled) || mode === "stage-duplicate" && (!input.disabled || !input.stage))
+    if (!["rotate", "refuse", "stage-duplicate"].includes(mode) || input.stage !== undefined && (label !== undefined && typeof label !== "string" || identity !== undefined && (typeof identity !== "string" || !identity)) || input.disabled !== undefined && (!isRecord6(input.disabled) || typeof input.disabled.reason !== "string") || input.stage !== undefined && (!isRecord6(input.stage) || typeof input.stage.reservation !== "string" || !input.stage.reservation || !input.disabled) || mode === "stage-duplicate" && (!input.disabled || !input.stage))
       throw refusal("add", id, "invalid-input", "staging requires a reservation and a disabled reason");
     const incoming = input.providerState === undefined ? undefined : acceptProviderState(ctx.providerState, "add", id, input.providerState);
     await locks.acquire(rowLockSpec(rt, { id, identity }));
@@ -11940,12 +12232,12 @@ async function addRow(rt, input, options = {}) {
       await locks.acquire(extra);
     return withTransaction(ctx, locks, progress, { operation: "add", rowId: id }, async (tx) => {
       await protectIn(tx, id, options.protect);
-      const stateAccounts = isRecord7(tx.state.accounts) ? tx.state.accounts : {};
+      const stateAccounts = isRecord6(tx.state.accounts) ? tx.state.accounts : {};
       const stagedOrphan = Object.entries(stateAccounts).find(([orphanId, account]) => {
-        if (orphanId === id || tx.rosterRow(orphanId) || !isRecord7(account))
+        if (orphanId === id || tx.rosterRow(orphanId) || !isRecord6(account))
           return false;
         const stamp = account[CREDENTIAL_STAMP_KEY];
-        if (!isRecord7(stamp) || !Object.hasOwn(stamp, "staged"))
+        if (!isRecord6(stamp) || !Object.hasOwn(stamp, "staged"))
           return false;
         return credential.type === "oauth" ? account.refresh === credential.refresh : typeof account.apiKey === "string" && account.apiKey.trim() === credential.apiKey.trim();
       });
@@ -11963,9 +12255,9 @@ async function addRow(rt, input, options = {}) {
       }
       if (mode === "refuse") {
         const holder = tx.rows().find((row) => row.fingerprint === fingerprintOf(credential) || row.id === id && row.credential);
-        const accounts = isRecord7(tx.state.accounts) ? tx.state.accounts : {};
+        const accounts = isRecord6(tx.state.accounts) ? tx.state.accounts : {};
         const stateHolder = Object.entries(accounts).find(([, account]) => {
-          if (!isRecord7(account))
+          if (!isRecord6(account))
             return false;
           if (credential.type === "oauth")
             return account.refresh === credential.refresh;
@@ -12298,7 +12590,7 @@ async function removeRow(rt, id, options = {}) {
       throw refusal("remove", id, "invalid-input", "id must be non-empty");
     const fence = options.attribution;
     validateAttribution("remove", id, fence);
-    if (options.staged !== undefined && (!isRecord7(options.staged) || typeof options.staged.reservation !== "string" || !options.staged.reservation))
+    if (options.staged !== undefined && (!isRecord6(options.staged) || typeof options.staged.reservation !== "string" || !options.staged.reservation))
       throw refusal("remove", id, "invalid-input", "a staged removal needs a reservation");
     const result = await readPool(ctx);
     if (result.status !== "ready")
@@ -12313,7 +12605,7 @@ async function removeRow(rt, id, options = {}) {
     return withTransaction(ctx, locks, progress, { operation: "remove", rowId: id }, async (tx) => {
       const reservation = tx.reservation(id);
       if (reservation !== undefined) {
-        if (!isRecord7(reservation) || !options.staged || reservation.reservation !== options.staged.reservation)
+        if (!isRecord6(reservation) || !options.staged || reservation.reservation !== options.staged.reservation)
           throw refusal("remove", id, "row-staged", `row ${id} is reserved for roster publication`);
       } else if (options.staged)
         throw refusal("remove", id, "attribution", `row ${id} is no longer reserved`);
@@ -12401,10 +12693,10 @@ function assertOrphanAttribution(rt, tx, id, fence) {
 }
 function hasStateAccount(state, id) {
   const accounts = state.accounts;
-  return isRecord7(accounts) && Object.hasOwn(accounts, id);
+  return isRecord6(accounts) && Object.hasOwn(accounts, id);
 }
 function rosterIdOf(raw) {
-  return isRecord7(raw) && typeof raw.id === "string" ? raw.id : undefined;
+  return isRecord6(raw) && typeof raw.id === "string" ? raw.id : undefined;
 }
 function orderProblem(roster, ids) {
   if (!Array.isArray(ids))
@@ -12479,7 +12771,7 @@ async function recordRowIdentity(rt, id, identity, attribution, options = {}) {
   return runOperation(rt.ctx, "recordIdentity", id, options.onFailure, async (locks, progress) => {
     if (typeof identity !== "string" || identity.length === 0)
       throw refusal("recordIdentity", id, "invalid-input", "identity must be non-empty");
-    const captured = isRecord7(attribution) ? attribution.credentialEpoch : undefined;
+    const captured = isRecord6(attribution) ? attribution.credentialEpoch : undefined;
     if (!isCredentialEpoch(captured))
       throw refusal("recordIdentity", id, "invalid-input", "the credential epoch the identity lookup was issued for is required");
     const { row: seen } = await readRow(rt, "recordIdentity", id);
@@ -12508,14 +12800,14 @@ async function recordRowIdentity(rt, id, identity, attribution, options = {}) {
 // ../../node_modules/@cortexkit/common-auth/dist/store/publication.js
 function receiptsIn(config) {
   const pool = config[POOL_KEY];
-  return isRecord7(pool) && isRecord7(pool.publications) ? pool.publications : {};
+  return isRecord6(pool) && isRecord6(pool.publications) ? pool.publications : {};
 }
 function receiptIn(config, operationId) {
   const receipts = receiptsIn(config);
   if (!Object.hasOwn(receipts, operationId))
     return;
   const raw = receipts[operationId];
-  if (!isRecord7(raw) || raw.operationId !== operationId || typeof raw.planDigest !== "string" || !/^[a-f0-9]{64}$/.test(raw.planDigest) || !["committed", "cleaned"].includes(String(raw.phase)) || !Array.isArray(raw.removed) || !Array.isArray(raw.finalized) || raw.removed.some((ref) => !isRecord7(ref) || typeof ref.id !== "string" || !isCredentialEpoch(ref.credentialEpoch)) || raw.finalized.some((ref) => !isRecord7(ref) || typeof ref.id !== "string" || !isCredentialEpoch(ref.credentialEpoch) || typeof ref.reservation !== "string" || !ref.reservation || typeof ref.enabled !== "boolean"))
+  if (!isRecord6(raw) || raw.operationId !== operationId || typeof raw.planDigest !== "string" || !/^[a-f0-9]{64}$/.test(raw.planDigest) || !["committed", "cleaned"].includes(String(raw.phase)) || !Array.isArray(raw.removed) || !Array.isArray(raw.finalized) || raw.removed.some((ref) => !isRecord6(ref) || typeof ref.id !== "string" || !isCredentialEpoch(ref.credentialEpoch)) || raw.finalized.some((ref) => !isRecord6(ref) || typeof ref.id !== "string" || !isCredentialEpoch(ref.credentialEpoch) || typeof ref.reservation !== "string" || !ref.reservation || typeof ref.enabled !== "boolean"))
     throw refusal("publishRoster", operationId, "invalid-input", "the stored publication receipt is malformed");
   return structuredClone(raw);
 }
@@ -12529,11 +12821,11 @@ function validatePlan(rt, plan) {
   const fail = () => {
     throw refusal("publishRoster", plan?.operationId ?? "", "invalid-input", "the publication plan is invalid");
   };
-  if (!isRecord7(plan) || typeof plan.operationId !== "string" || !plan.operationId || !Array.isArray(plan.remove) || !Array.isArray(plan.finalize) || !Array.isArray(plan.order))
+  if (!isRecord6(plan) || typeof plan.operationId !== "string" || !plan.operationId || !Array.isArray(plan.remove) || !Array.isArray(plan.finalize) || !Array.isArray(plan.order))
     fail();
   const ids = new Set;
   for (const ref of [...plan.remove, ...plan.finalize]) {
-    if (!isRecord7(ref) || typeof ref.id !== "string" || idProblem(ref.id) || ids.has(ref.id) || !ref.attribution)
+    if (!isRecord6(ref) || typeof ref.id !== "string" || idProblem(ref.id) || ids.has(ref.id) || !ref.attribution)
       fail();
     ids.add(ref.id);
     validateAttribution("publishRoster", ref.id, ref.attribution);
@@ -12565,7 +12857,7 @@ function saveReceipt(tx, receipt) {
 function publicationSurvivors(tx, plan, rows) {
   const rosterIds = new Set;
   for (const raw of rosterOf(tx.config)) {
-    if (!isRecord7(raw) || typeof raw.id !== "string")
+    if (!isRecord6(raw) || typeof raw.id !== "string")
       continue;
     if (rosterIds.has(raw.id))
       throw refusal("publishRoster", plan.operationId, "invalid-input", "publication needs a roster of unique named rows");
@@ -12604,14 +12896,14 @@ async function cleanup(tx, receipt) {
 async function publishRoster(rt, plan, options = {}) {
   assertNotInsideHook("publishRoster");
   return runOperation(rt.ctx, "publishRoster", plan?.operationId ?? "", options.onFailure, async (locks, progress) => {
-    if (!isRecord7(plan) || typeof plan.operationId !== "string" || !plan.operationId)
+    if (!isRecord6(plan) || typeof plan.operationId !== "string" || !plan.operationId)
       throw refusal("publishRoster", plan?.operationId ?? "", "invalid-input", "the publication needs an operation id");
     plan = structuredClone(plan);
     const planDigest = canonicalDigest(plan);
     const named = [
       ...Array.isArray(plan.remove) ? plan.remove : [],
       ...Array.isArray(plan.finalize) ? plan.finalize : []
-    ].filter((ref) => isRecord7(ref) && typeof ref.id === "string");
+    ].filter((ref) => isRecord6(ref) && typeof ref.id === "string");
     for (let attempt = 0;; attempt++) {
       const seen = await readPool(rt.ctx);
       if (seen.status !== "ready")
@@ -12715,7 +13007,7 @@ async function publishRoster(rt, plan, options = {}) {
             entry.disabledReason = ref.disabledReason;
           tx.setEntry(ref.id, entry);
         }
-        const preserved = tx.roster().filter((raw) => !isRecord7(raw) || typeof raw.id !== "string" || rows.find((row) => row.id === raw.id)?.invalid === "roster");
+        const preserved = tx.roster().filter((raw) => !isRecord6(raw) || typeof raw.id !== "string" || rows.find((row) => row.id === raw.id)?.invalid === "roster");
         tx.config.accounts = [
           ...plan.order.map((id) => tx.rosterRow(id)),
           ...preserved
@@ -13089,7 +13381,7 @@ async function updatePoolSettings(rt, mutator, options = {}) {
       const draft = structuredClone(current);
       const returned = await runInsideHook("updateSettings", () => mutator(draft));
       const next = returned === undefined ? draft : returned;
-      if (!isRecord7(next))
+      if (!isRecord6(next))
         throw settingsRefusal("the settings mutator must produce an object");
       const owned = POOL_OWNED_KEYS.filter((key) => Object.hasOwn(next, key));
       if (owned.length > 0)
@@ -13226,7 +13518,7 @@ function entryTime(entry) {
 function limitKey(scope, label) {
   return JSON.stringify([scope, label]);
 }
-function isRecord8(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isFiniteNumber(value) {
@@ -13245,7 +13537,7 @@ function isString(value) {
   return typeof value === "string";
 }
 function isQuotaEntry(value) {
-  if (!isRecord8(value) || !isName(value.scope) || !isName(value.label)) {
+  if (!isRecord7(value) || !isName(value.scope) || !isName(value.label)) {
     return false;
   }
   switch (value.kind) {
@@ -13260,20 +13552,26 @@ function isQuotaEntry(value) {
   }
 }
 function isCreditBudgetEntry(value) {
-  if (!isRecord8(value) || !isFiniteNumber(value.checkedAt))
+  if (!isRecord7(value) || !isFiniteNumber(value.checkedAt))
     return false;
   if (value.kind === "cleared")
     return true;
   return value.kind === "reading" && typeof value.reached === "boolean" && optional(value, "remainingPercent", isFiniteNumber) && optional(value, "usedPercent", isFiniteNumber) && optional(value, "resetsAt", isString) && optional(value, "limit", isFiniteNumber) && optional(value, "used", isFiniteNumber) && optional(value, "remaining", isFiniteNumber) && optional(value, "unit", isString);
 }
 function isQuotaCounter(value) {
-  return isRecord8(value) && isFiniteNumber(value.value) && Number.isInteger(value.value) && value.value >= 0 && isFiniteNumber(value.checkedAt);
+  return isRecord7(value) && isFiniteNumber(value.value) && Number.isInteger(value.value) && value.value >= 0 && isFiniteNumber(value.checkedAt);
 }
 function isQuotaCounters(value) {
-  return isRecord8(value) && Object.values(value).every(isQuotaCounter);
+  return isRecord7(value) && Object.values(value).every(isQuotaCounter);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isQuotaCredits(value) {
+  return isRecord7(value) && typeof value.hasCredits === "boolean" && typeof value.unlimited === "boolean" && optional(value, "balance", isFiniteNumber) && optional(value, "overageLimitReached", isBoolean) && isFiniteNumber(value.checkedAt);
 }
 function readQuotaCounters(value) {
-  if (!isRecord8(value))
+  if (!isRecord7(value))
     return;
   const entries = Object.entries(value).filter(([, entry]) => isQuotaCounter(entry));
   return entries.length === 0 ? undefined : Object.fromEntries(entries);
@@ -13281,16 +13579,21 @@ function readQuotaCounters(value) {
 function decodeQuotaMap(value) {
   if (isQuotaMap(value))
     return value;
-  if (!isRecord8(value))
+  if (!isRecord7(value))
     return;
-  const { counters: rawCounters, ...rest } = value;
+  const { counters: rawCounters, credits: rawCredits, ...rest } = value;
   if (!isQuotaMap(rest))
     return;
   const counters = readQuotaCounters(rawCounters);
-  return { ...rest, ...counters === undefined ? {} : { counters } };
+  const credits = isQuotaCredits(rawCredits) ? rawCredits : undefined;
+  return {
+    ...rest,
+    ...counters === undefined ? {} : { counters },
+    ...credits === undefined ? {} : { credits }
+  };
 }
 function isQuotaMap(value) {
-  if (!isRecord8(value) || !Array.isArray(value.limits))
+  if (!isRecord7(value) || !Array.isArray(value.limits))
     return false;
   const seen = new Set;
   for (const entry of value.limits) {
@@ -13301,7 +13604,7 @@ function isQuotaMap(value) {
       return false;
     seen.add(key);
   }
-  return optional(value, "budget", isCreditBudgetEntry) && optional(value, "counters", isQuotaCounters);
+  return optional(value, "budget", isCreditBudgetEntry) && optional(value, "counters", isQuotaCounters) && optional(value, "credits", isQuotaCredits);
 }
 
 // ../../node_modules/@cortexkit/common-auth/dist/quota/merge.js
@@ -13311,7 +13614,7 @@ class QuotaCodecError extends TypeError {
     this.name = "QuotaCodecError";
   }
 }
-function isRecord9(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isFiniteNumber2(value) {
@@ -13330,20 +13633,20 @@ function optionalString(record, key) {
   return record[key] === undefined || typeof record[key] === "string";
 }
 function isObservedReading(value) {
-  return isRecord9(value) && isScope(value.scope) && isLabel(value.label) && isFiniteNumber2(value.usedPercent) && optionalString(value, "resetsAt") && (value.windowMinutes === undefined || isFiniteNumber2(value.windowMinutes) && value.windowMinutes > 0);
+  return isRecord8(value) && isScope(value.scope) && isLabel(value.label) && isFiniteNumber2(value.usedPercent) && optionalString(value, "resetsAt") && (value.windowMinutes === undefined || isFiniteNumber2(value.windowMinutes) && value.windowMinutes > 0);
 }
 function isObservedPair(value) {
-  return isRecord9(value) && isScope(value.scope) && isLabel(value.label);
+  return isRecord8(value) && isScope(value.scope) && isLabel(value.label);
 }
 function isObservedBudget(value) {
-  if (!isRecord9(value))
+  if (!isRecord8(value))
     return false;
   if (value.kind === "cleared")
     return true;
   return value.kind === "reading" && typeof value.reached === "boolean" && optionalFinite(value, "remainingPercent") && optionalFinite(value, "usedPercent") && optionalString(value, "resetsAt") && optionalFinite(value, "limit") && optionalFinite(value, "used") && optionalFinite(value, "remaining") && optionalString(value, "unit");
 }
 function isQuotaObservation(value) {
-  if (!isRecord9(value) || !isFiniteNumber2(value.checkedAt))
+  if (!isRecord8(value) || !isFiniteNumber2(value.checkedAt))
     return false;
   const readings = value.readings ?? [];
   const coverage = value.coverage ?? [];
@@ -13360,7 +13663,7 @@ function isQuotaObservation(value) {
   }
   if (!coverage.every(isObservedPair))
     return false;
-  return (value.budget === undefined || isObservedBudget(value.budget)) && (value.counters === undefined || isQuotaCounters(value.counters));
+  return (value.budget === undefined || isObservedBudget(value.budget)) && (value.counters === undefined || isQuotaCounters(value.counters)) && (value.credits === undefined || isQuotaCredits(value.credits));
 }
 function compareEntries(left, right) {
   if (left.scope !== right.scope)
@@ -13386,6 +13689,14 @@ function mergeCounters(stored, observed) {
   }
   return counters.size === 0 ? undefined : Object.fromEntries(counters);
 }
+function mergeCredits(stored, observed) {
+  if (observed === undefined)
+    return stored;
+  if (stored !== undefined && observed.checkedAt < stored.checkedAt) {
+    return stored;
+  }
+  return { ...observed };
+}
 function mergeQuotaObservation(stored, observation) {
   const decoded = stored === undefined ? undefined : decodeQuotaMap(stored);
   if (stored !== undefined && decoded === undefined) {
@@ -13429,14 +13740,16 @@ function mergeQuotaObservation(stored, observation) {
     const existing = entries.get(key);
     entries.set(key, existing === undefined || existing.kind === "absent" ? { scope, label: pair.label, kind: "absent", checkedAt: at } : { scope, label: pair.label, kind: "retired", retiredAt: at });
   }
-  const { limits: _limits, budget: _budget, counters: _counters, ...unknownKeys } = base;
+  const { limits: _limits, budget: _budget, counters: _counters, credits: _credits, ...unknownKeys } = base;
   const budget = mergeBudget(base.budget, observation.budget, at);
   const counters = mergeCounters(base.counters, observation.counters);
+  const credits = mergeCredits(base.credits, observation.credits);
   return {
     ...unknownKeys,
     limits: [...entries.values()].sort(compareEntries),
     ...budget === undefined ? {} : { budget },
-    ...counters === undefined ? {} : { counters }
+    ...counters === undefined ? {} : { counters },
+    ...credits === undefined ? {} : { credits }
   };
 }
 
@@ -13512,6 +13825,13 @@ function quotaWindowParts(quota, options) {
   const parts = windows.map(({ part }) => part);
   return age === undefined ? { windows: parts } : { windows: parts, age };
 }
+function withShortNames(windows) {
+  const abbreviations = scopeAbbreviations(windows.filter(({ part, scope }) => part.kind === "window" && scope !== ALL_SCOPE).map(({ scope }) => scope));
+  for (const window of windows) {
+    window.part.short = window.part.kind === "budget" ? "cr" : window.scope === ALL_SCOPE ? window.part.name : abbreviations.get(window.scope) ?? window.scope;
+  }
+  return windows;
+}
 function scopedWindowParts(quota, options) {
   if (!quota)
     return { windows: [] };
@@ -13525,6 +13845,7 @@ function scopedWindowParts(quota, options) {
       part: {
         kind: "window",
         name: quotaWindowName(limit),
+        short: "",
         figure: percentLeft(limit.remainingPercent ?? 0),
         remainingPercent,
         checkedAt: limit.checkedAt,
@@ -13542,6 +13863,7 @@ function scopedWindowParts(quota, options) {
       part: {
         kind: "budget",
         name: "credits",
+        short: "",
         figure,
         ...remainingPercent === undefined ? {} : { remainingPercent: clampPercent2(remainingPercent) },
         checkedAt: budget.checkedAt,
@@ -13549,6 +13871,7 @@ function scopedWindowParts(quota, options) {
       }
     });
   }
+  withShortNames(windows);
   if (windows.length > 0) {
     const age = now - Math.min(...windows.map(({ part }) => part.checkedAt));
     if (age > (options.staleAfterMs ?? QUOTA_STALE_AFTER_MS)) {
@@ -13629,15 +13952,14 @@ function narrowTextParts(quota, options) {
     return grouped;
   const general = windows.filter(({ part, scope }) => part.kind === "window" && scope === ALL_SCOPE);
   const scoped = windows.filter(({ part, scope }) => part.kind === "window" && scope !== ALL_SCOPE);
-  const abbreviations = scopeAbbreviations(scoped.map(({ scope }) => scope));
   const budget = windows.find(({ part }) => part.kind === "budget");
   const budgetLeft = budget?.spent ? 0 : budget?.part.remainingPercent;
   const extras = [
-    ...scoped.map(({ scope, part }) => ({
-      label: abbreviations.get(scope) ?? scope,
+    ...scoped.map(({ part }) => ({
+      label: part.short,
       remaining: part.remainingPercent ?? 0
     })),
-    ...budgetLeft === undefined ? [] : [{ label: "cr", remaining: budgetLeft }]
+    ...budgetLeft === undefined || budget === undefined ? [] : [{ label: budget.part.short, remaining: budgetLeft }]
   ];
   const tightest = extras.reduce((best, item) => best === undefined || item.remaining < best.remaining ? item : best, undefined);
   const pieces = general.map(({ part }) => `${part.name} ${wholePercent(part.remainingPercent ?? 0)}%`);
@@ -13894,7 +14216,7 @@ var nativeQuotaCodec = {
 import { randomUUID as randomUUID12 } from "node:crypto";
 import { constants as constants2 } from "node:fs";
 import { lstat as lstat5, mkdir as mkdir9, open as open6, rename as rename11, rm as rm6 } from "node:fs/promises";
-import { basename as basename4, dirname as dirname9, isAbsolute as isAbsolute3, join as join11 } from "node:path";
+import { basename as basename4, dirname as dirname9, isAbsolute as isAbsolute3, join as join12 } from "node:path";
 import { types as utilTypes5 } from "node:util";
 
 // src/pool-binding.ts
@@ -15354,7 +15676,7 @@ async function writeNativeRuntimeOutcome(path2, storageId, change, hooks, firstI
       assertTransitions(current, next, firstIdentity);
       const bytes = `${JSON.stringify(next, null, 2)}
 `;
-      const stage = join11(dirname9(path2), `${basename4(path2)}.native-runtime.${randomUUID12()}.partial`);
+      const stage = join12(dirname9(path2), `${basename4(path2)}.native-runtime.${randomUUID12()}.partial`);
       let ownsStage = false;
       try {
         const nativeCreated = await createWindowsOwnerOnly(stage, bytes);
@@ -17774,8 +18096,12 @@ class ClaustrumScopedCustody {
   }
 }
 
+// ../../node_modules/@cortexkit/common-auth/dist/claustrum/quota-writer.js
+import { resolve as resolve8 } from "node:path";
+
 // ../../node_modules/@cortexkit/common-auth/dist/claustrum/roster.js
 import { createHash as createHash12 } from "node:crypto";
+import { resolve as resolve7 } from "node:path";
 
 // ../../node_modules/@cortexkit/common-auth/dist/claustrum/interlock.js
 function matches(entry2, credentialId, accountIdentity) {
@@ -17950,15 +18276,15 @@ function vaultRoutingRows(roster) {
     ...row.quota !== undefined && { quota: row.quota }
   }));
 }
-function isRecord10(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalString2(value) {
   return value === undefined || typeof value === "string";
 }
 function decodeRow(value) {
-  const quota2 = isRecord10(value) ? decodeQuotaMap(value.quota) : undefined;
-  if (!isRecord10(value) || typeof value.routeId !== "string" || typeof value.credentialId !== "string" || value.credentialType !== "oauth" && value.credentialType !== "api_key" || typeof value.state !== "string" || typeof value.label !== "string" || typeof value.enabled !== "boolean" || typeof value.addedAt !== "number" || !optionalString2(value.accountIdentity) || !optionalString2(value.email) || !optionalString2(value.orgName) || value.aliases !== undefined && (!Array.isArray(value.aliases) || !value.aliases.every((alias) => typeof alias === "string")) || value.quota !== undefined && quota2 === undefined || value.stale !== undefined && value.stale !== true || value.unclaimed !== undefined && value.unclaimed !== true)
+  const quota2 = isRecord9(value) ? decodeQuotaMap(value.quota) : undefined;
+  if (!isRecord9(value) || typeof value.routeId !== "string" || typeof value.credentialId !== "string" || value.credentialType !== "oauth" && value.credentialType !== "api_key" || typeof value.state !== "string" || typeof value.label !== "string" || typeof value.enabled !== "boolean" || typeof value.addedAt !== "number" || !optionalString2(value.accountIdentity) || !optionalString2(value.email) || !optionalString2(value.orgName) || value.aliases !== undefined && (!Array.isArray(value.aliases) || !value.aliases.every((alias) => typeof alias === "string")) || value.quota !== undefined && quota2 === undefined || value.stale !== undefined && value.stale !== true || value.unclaimed !== undefined && value.unclaimed !== true)
     return;
   return {
     ...value,
@@ -17976,14 +18302,14 @@ function decodeRejected(value) {
     return;
   const records = [];
   for (const entry2 of value) {
-    if (!isRecord10(entry2) || !optionalString2(entry2.credentialId) || typeof entry2.reason !== "string" || !SKIPPED_REASONS.has(entry2.reason))
+    if (!isRecord9(entry2) || !optionalString2(entry2.credentialId) || typeof entry2.reason !== "string" || !SKIPPED_REASONS.has(entry2.reason))
       return;
     records.push(entry2);
   }
   return records;
 }
 function decodeRoster(value) {
-  if (!isRecord10(value) || value.version !== 1 || !optionalString2(value.view) || !Array.isArray(value.rows) || !Array.isArray(value.declined) || value.complete !== undefined && typeof value.complete !== "boolean" || value.rejected !== undefined && !decodeRejected(value.rejected))
+  if (!isRecord9(value) || value.version !== 1 || !optionalString2(value.view) || !Array.isArray(value.rows) || !Array.isArray(value.declined) || value.complete !== undefined && typeof value.complete !== "boolean" || value.rejected !== undefined && !decodeRejected(value.rejected))
     throw new ClaustrumConsumerError("invalid-state", "Claustrum roster file is not valid");
   const rows = [];
   for (const entry2 of value.rows) {
@@ -17994,7 +18320,7 @@ function decodeRoster(value) {
   }
   const declined = [];
   for (const entry2 of value.declined) {
-    if (!isRecord10(entry2) || typeof entry2.credentialId !== "string" || !optionalString2(entry2.accountIdentity))
+    if (!isRecord9(entry2) || typeof entry2.credentialId !== "string" || !optionalString2(entry2.accountIdentity))
       throw new ClaustrumConsumerError("invalid-state", "Claustrum roster file is not valid");
     declined.push(entry2);
   }
@@ -18028,11 +18354,12 @@ async function readVaultRoster(path2) {
 var WRITE_LOCK = {
   name: "claustrum-roster-write",
   ttlMs: 1e4,
-  timeoutMs: 5000
+  timeoutMs: 5000,
+  renew: true
 };
 var DISCOVERY_LEASE = { name: "claustrum-roster", ttlMs: 30000 };
 async function mutateVaultRoster(path2, change, options = {}) {
-  return withLock(path2, WRITE_LOCK, async (lock) => {
+  return withLock(path2, { ...WRITE_LOCK, signal: options.signal }, async (lock) => {
     const current = await readVaultRoster(path2);
     const { next, result } = await change(current, {
       assertOwned: () => lock.assertOwned()
@@ -18042,6 +18369,7 @@ async function mutateVaultRoster(path2, change, options = {}) {
       await writeJsonAtomic(path2, next, {
         beforeRename: async () => {
           await options.beforePublish?.();
+          options.signal?.throwIfAborted();
           await lock.assertOwned();
         }
       });
@@ -18091,43 +18419,52 @@ function receiptFence(row, receipt) {
     return "bind";
   return "refuse";
 }
-function recordVaultQuota(path2, input) {
-  return mutateVaultRoster(path2, (current) => {
-    const row = current?.rows.find((entry2) => entry2.routeId === input.routeId);
-    const fence = !current || !row ? "refuse" : receiptFence(row, input);
-    if (!current || !row || fence === "refuse")
-      return { result: false };
-    const quota2 = mergeQuotaObservation(row.quota, input.observation);
-    const bound = fence === "bind" ? { accountIdentity: input.accountIdentity, unclaimed: true } : {};
-    return {
-      next: {
-        ...current,
-        rows: current.rows.map((entry2) => entry2 === row ? { ...entry2, ...bound, quota: quota2 } : entry2)
-      },
-      result: true
-    };
+async function recordVaultQuota(path2, input) {
+  const { routeId, observation, ...receipt } = input;
+  return enqueueFencedVaultQuota(path2, {
+    routeId,
+    observation,
+    accountIdentity: receipt.accountIdentity,
+    receipt
   });
 }
+async function enqueueFencedVaultQuota(path2, publication2) {
+  if (!isQuotaObservation(publication2.observation))
+    return false;
+  const current = pendingVaultQuota(path2, await readVaultRoster(path2));
+  if (!applyVaultQuota(current, publication2).kept)
+    return false;
+  return enqueueVaultQuota(path2, publication2);
+}
 function recordVaultAccountQuota(path2, input) {
-  return mutateVaultRoster(path2, (current) => {
-    const row = current?.rows.find((entry2) => entry2.routeId === input.routeId);
-    if (!current || !row || row.accountIdentity === undefined || row.accountIdentity !== input.accountIdentity)
-      return { result: false };
-    const quota2 = mergeQuotaObservation(row.quota, input.observation);
-    return {
-      next: {
-        ...current,
-        rows: current.rows.map((entry2) => entry2 === row ? { ...entry2, quota: quota2 } : entry2)
-      },
-      result: true
-    };
-  });
+  return enqueueFencedVaultQuota(path2, input);
+}
+function applyVaultQuota(current, input) {
+  const row = current?.rows.find((entry2) => entry2.routeId === input.routeId);
+  const fence = !row ? "refuse" : input.receipt ? receiptFence(row, input.receipt) : row.accountIdentity !== undefined && row.accountIdentity === input.accountIdentity ? "hold" : "refuse";
+  if (!current || !row || fence === "refuse")
+    return { roster: current, kept: false };
+  const quota2 = mergeQuotaObservation(row.quota, input.observation);
+  const bound = fence === "bind" ? { accountIdentity: input.accountIdentity, unclaimed: true } : {};
+  return {
+    roster: {
+      ...current,
+      rows: current.rows.map((entry2) => entry2 === row ? { ...entry2, ...bound, quota: quota2 } : entry2)
+    },
+    kept: true
+  };
+}
+var pendingDiscoveries = new Map;
+function forgetPendingVaultDiscovery(path2) {
+  pendingDiscoveries.delete(resolve7(path2));
 }
 async function refreshVaultRoster(options) {
   options.signal?.throwIfAborted();
   const active = async () => await options.isActive?.() ?? true;
-  if (!await active())
+  if (!await active()) {
+    forgetPendingVaultDiscovery(options.path);
     return;
+  }
   const lease = await acquireRefreshFileLock({
     ...DISCOVERY_LEASE,
     path: options.path,
@@ -18140,8 +18477,18 @@ async function refreshVaultRoster(options) {
       throw new ClaustrumConsumerError("roster-busy", "Claustrum account discovery is already in progress");
     return persisted;
   }
+  const key = resolve7(options.path);
+  let discovered;
   try {
-    const inventory = await options.custody.discover(options.signal);
+    const previous = await readVaultRoster(options.path);
+    const pending = pendingDiscoveries.get(key);
+    discovered = pending && (pending.previousView === previous?.view || pending.inventory.view === previous?.view) ? pending : {
+      inventory: await options.custody.discover(options.signal),
+      previousView: previous?.view
+    };
+    pendingDiscoveries.delete(key);
+    const { inventory } = discovered;
+    options.onInventory?.(inventory);
     options.signal?.throwIfAborted();
     return await mutateVaultRoster(options.path, async (current) => {
       if (!await active())
@@ -18152,12 +18499,238 @@ async function refreshVaultRoster(options) {
       const next = projectVaultRoster(current, inventory, projection);
       const changed = JSON.stringify(current) !== JSON.stringify(next);
       return { ...changed && { next }, result: next };
+    }, {
+      beforePublish: async () => {
+        options.signal?.throwIfAborted();
+        await lease.assertOwned();
+      }
     });
+  } catch (error) {
+    if (error instanceof LockContentionError && discovered && !options.signal?.aborted && await active())
+      pendingDiscoveries.set(key, discovered);
+    throw error;
   } finally {
     await lease.release();
   }
 }
 
+// ../../node_modules/@cortexkit/common-auth/dist/claustrum/quota-writer.js
+var writers = new Map;
+var logger2 = createLogger("claustrum");
+var COALESCE_MS = 100;
+function writerFor(path2) {
+  const key = resolve8(path2);
+  let writer = writers.get(key);
+  if (!writer) {
+    writer = {
+      path: key,
+      pending: new Map,
+      listeners: new Set,
+      wake: new Set,
+      abort: new AbortController,
+      failures: 0,
+      draining: false,
+      order: 0
+    };
+    writers.set(key, writer);
+  }
+  return writer;
+}
+function retainVaultQuotaWriter(path2, listener) {
+  const writer = writerFor(path2);
+  writer.listeners.add(listener);
+  let released;
+  return () => released ??= (() => {
+    writer.listeners.delete(listener);
+    return writer.listeners.size ? Promise.resolve() : drainVaultQuota(path2);
+  })();
+}
+function fields(publication2) {
+  const result = new Map;
+  const { observation } = publication2;
+  const witness = JSON.stringify([
+    publication2.routeId,
+    publication2.receipt?.credentialId,
+    publication2.receipt?.accountIdentitySource,
+    publication2.receipt?.expectedAccountIdentity
+  ]);
+  const add = (key, at, part) => result.set(`${witness}:${key}`, {
+    at,
+    order: 0,
+    publication: { ...publication2, observation: part }
+  });
+  const keyFor = (scope, label) => JSON.stringify([scope ?? "all", label]);
+  const read = new Set;
+  for (const reading2 of observation.readings ?? []) {
+    const key = keyFor(reading2.scope, reading2.label);
+    read.add(key);
+    add(key, observation.checkedAt, {
+      checkedAt: observation.checkedAt,
+      readings: [{ ...reading2 }]
+    });
+  }
+  for (const pair of observation.coverage ?? []) {
+    const key = keyFor(pair.scope, pair.label);
+    if (!read.has(key))
+      add(key, observation.checkedAt, {
+        checkedAt: observation.checkedAt,
+        coverage: [{ ...pair }]
+      });
+  }
+  if (observation.budget)
+    add("budget", observation.checkedAt, {
+      checkedAt: observation.checkedAt,
+      budget: { ...observation.budget }
+    });
+  for (const [name, counter2] of Object.entries(observation.counters ?? {})) {
+    add(`counter:${name}`, counter2.checkedAt, {
+      checkedAt: observation.checkedAt,
+      counters: { [name]: { ...counter2 } }
+    });
+  }
+  if (observation.credits)
+    add("credits", observation.credits.checkedAt, {
+      checkedAt: observation.checkedAt,
+      credits: { ...observation.credits }
+    });
+  if (!result.size)
+    add("empty", observation.checkedAt, { checkedAt: observation.checkedAt });
+  return result;
+}
+function enqueueVaultQuota(path2, publication2) {
+  if (!isQuotaObservation(publication2.observation))
+    return Promise.resolve(false);
+  const writer = writerFor(path2);
+  const account = JSON.stringify([
+    publication2.accountIdentity ?? null,
+    publication2.accountIdentity === undefined ? publication2.routeId : null
+  ]);
+  const pending = writer.pending.get(account) ?? new Map;
+  for (const [key, field] of fields(publication2)) {
+    const previous = pending.get(key);
+    if (!previous || field.at >= previous.at) {
+      field.order = ++writer.order;
+      if (field.publication.observation.coverage)
+        field.priorReading = previous?.publication.observation.readings ? previous.publication : previous?.priorReading;
+      pending.set(key, field);
+    }
+  }
+  if (pending.size)
+    writer.pending.set(account, pending);
+  for (const listener of writer.listeners)
+    listener(publication2);
+  schedule(writer, COALESCE_MS);
+  return Promise.resolve(true);
+}
+function orderedFields(pending) {
+  return [...pending.values()].flatMap((account) => [...account.values()]).sort((a, b) => a.order - b.order);
+}
+function pendingVaultQuota(path2, roster) {
+  const writer = writers.get(resolve8(path2));
+  if (writer) {
+    for (const field of orderedFields(writer.pending)) {
+      if (field.priorReading)
+        roster = applyVaultQuota(roster, field.priorReading).roster;
+      roster = applyVaultQuota(roster, field.publication).roster;
+    }
+  }
+  return roster;
+}
+function schedule(writer, delay3) {
+  if (writer.running || writer.timer || !writer.pending.size || writer.abort.signal.aborted)
+    return;
+  writer.timer = setTimeout(() => {
+    writer.timer = undefined;
+    flush2(writer);
+  }, delay3);
+  if (!writer.draining)
+    writer.timer.unref?.();
+}
+function flush2(writer) {
+  if (writer.running || writer.abort.signal.aborted)
+    return;
+  const batch = new Map([...writer.pending].map(([account, pending]) => [
+    account,
+    new Map(pending)
+  ]));
+  writer.running = (async () => {
+    try {
+      await mutateVaultRoster(writer.path, (current) => {
+        let next = current;
+        for (const field of orderedFields(batch)) {
+          if (field.priorReading)
+            next = applyVaultQuota(next, field.priorReading).roster;
+          next = applyVaultQuota(next, field.publication).roster;
+        }
+        return { ...next !== current && { next }, result: undefined };
+      }, { signal: writer.abort.signal });
+      for (const [account, fields2] of batch) {
+        const pending = writer.pending.get(account);
+        for (const [key, field] of fields2) {
+          if (pending?.get(key) === field)
+            pending.delete(key);
+        }
+        if (!pending?.size)
+          writer.pending.delete(account);
+      }
+      writer.failures = 0;
+    } catch (error) {
+      if (!writer.abort.signal.aborted && writer.failures++ === 0) {
+        logger2.warn("vault quota publication delayed; retrying", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    } finally {
+      writer.running = undefined;
+      for (const wake of writer.wake)
+        wake();
+      const backoff = writer.failures ? Math.min(5000, 100 * 2 ** Math.min(writer.failures, 6)) * (0.5 + Math.random()) : COALESCE_MS;
+      schedule(writer, backoff);
+    }
+  })();
+}
+async function drainVaultQuota(path2, timeoutMs = 1000) {
+  const key = resolve8(path2);
+  const writer = writers.get(key);
+  if (!writer)
+    return;
+  writer.draining = true;
+  clearTimeout(writer.timer);
+  writer.timer = undefined;
+  let deadline;
+  let wake;
+  const drained = new Promise((done) => {
+    wake = () => {
+      if (!writer.pending.size || writer.abort.signal.aborted)
+        done();
+    };
+    writer.wake.add(wake);
+    wake();
+  });
+  try {
+    if (writer.pending.size)
+      flush2(writer);
+    await Promise.race([
+      drained,
+      new Promise((done) => {
+        deadline = setTimeout(done, Math.max(0, timeoutMs));
+      })
+    ]);
+  } finally {
+    clearTimeout(deadline);
+    if (wake)
+      writer.wake.delete(wake);
+    writer.draining = false;
+    if (!writer.listeners.size) {
+      writer.abort.abort();
+      clearTimeout(writer.timer);
+      writer.pending.clear();
+      if (writers.get(key) === writer)
+        writers.delete(key);
+    }
+  }
+}
+
 // ../../node_modules/@cortexkit/common-auth/dist/claustrum/consumer.js
 class ClaustrumConsumer {
   #options;
@@ -18175,9 +18748,13 @@ class ClaustrumConsumer {
   #releaseInsulaWatch;
   #insulaSkips = new Map;
   #discoveredAt;
+  #releaseQuotaWriter;
   constructor(options) {
     this.#options = options;
     this.#logger = options.logger ?? createLogger("claustrum");
+    this.#releaseQuotaWriter = retainVaultQuotaWriter(options.rosterPath, (publication2) => {
+      this.#roster = applyVaultQuota(this.#roster, publication2).roster;
+    });
   }
   #assertOpen(signal) {
     this.#shutdown.signal.throwIfAborted();
@@ -18191,7 +18768,7 @@ class ClaustrumConsumer {
       this.#shutdown.signal,
       ...signal ? [signal] : []
     ]);
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve9, reject) => {
       const cleanup2 = () => {
         combined.signal.removeEventListener("abort", abort);
         combined.dispose();
@@ -18206,7 +18783,7 @@ class ClaustrumConsumer {
         if (combined.signal.aborted)
           reject(combined.signal.reason);
         else
-          resolve7(value);
+          resolve9(value);
       }, (error) => {
         cleanup2();
         reject(error);
@@ -18292,11 +18869,9 @@ class ClaustrumConsumer {
       let discovered;
       const roster = await refreshVaultRoster({
         path: this.#options.rosterPath,
-        custody: {
-          discover: async (signal) => {
-            discovered = await custody.discover(signal);
-            return discovered;
-          }
+        custody,
+        onInventory: (inventory) => {
+          discovered = inventory;
         },
         isActive: () => this.#active(),
         signal: this.#shutdown.signal,
@@ -18309,7 +18884,7 @@ class ClaustrumConsumer {
       });
       this.#assertOpen();
       const changed = roster?.view !== this.#roster?.view;
-      this.#roster = roster;
+      this.#roster = pendingVaultQuota(this.#options.rosterPath, roster);
       custody.retain(roster?.rows ?? []);
       if (discovered && roster?.view !== undefined)
         this.#grantReach = discovered.grantReach ? { view: roster.view, reach: discovered.grantReach } : undefined;
@@ -18406,7 +18981,7 @@ class ClaustrumConsumer {
       return;
     try {
       await readClaustrumEnrollmentToken(this.#options.tokenPath);
-      const roster = await readVaultRoster(this.#options.rosterPath);
+      const roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
       const row = roster?.rows.find((entry2) => entry2.routeId === routeId);
       return this.#normalizeInsulaQuota(row?.accountIdentity);
     } catch {
@@ -18419,7 +18994,7 @@ class ClaustrumConsumer {
       return { miss: "unreachable" };
     try {
       await readClaustrumEnrollmentToken(this.#options.tokenPath);
-      const roster = await readVaultRoster(this.#options.rosterPath);
+      const roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
       const account = roster?.rows.find((row) => row.routeId === routeId)?.accountIdentity;
       if (!account || !this.#insula)
         return { miss: "unreachable" };
@@ -18463,7 +19038,7 @@ class ClaustrumConsumer {
       this.#insula = undefined;
       throw new ClaustrumConsumerError("not-active", "Claustrum scoped custody is not active");
     }
-    const current = await readVaultRoster(this.#options.rosterPath);
+    const current = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
     this.#assertOpen(signal);
     const observed = roster.rows.find((row) => row.routeId === routeId);
     const configured = current?.rows.find((row) => row.routeId === routeId);
@@ -18531,17 +19106,17 @@ class ClaustrumConsumer {
   async decline(routeId) {
     this.#assertOpen();
     await declineVaultRoute(this.#options.rosterPath, routeId);
-    this.#roster = await readVaultRoster(this.#options.rosterPath);
+    this.#roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
     this.#custody?.retain(this.#roster?.rows ?? []);
   }
   async accept(routeId) {
     this.#assertOpen();
     await acceptVaultRoute(this.#options.rosterPath, routeId);
-    this.#roster = await readVaultRoster(this.#options.rosterPath);
+    this.#roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
   }
   async recordQuota(routeId, observation, attempt) {
     this.#assertOpen();
-    const kept = await recordVaultQuota(this.#options.rosterPath, {
+    return recordVaultQuota(this.#options.rosterPath, {
       routeId,
       observation,
       credentialId: attempt.credentialId,
@@ -18553,20 +19128,14 @@ class ClaustrumConsumer {
         expectedAccountIdentity: attempt.expectedAccountIdentity
       }
     });
-    if (kept)
-      this.#roster = await readVaultRoster(this.#options.rosterPath);
-    return kept;
   }
   async recordAccountQuota(routeId, accountIdentity, observation) {
     this.#assertOpen();
-    const kept = await recordVaultAccountQuota(this.#options.rosterPath, {
+    return recordVaultAccountQuota(this.#options.rosterPath, {
       routeId,
       accountIdentity,
       observation
     });
-    if (kept)
-      this.#roster = await readVaultRoster(this.#options.rosterPath);
-    return kept;
   }
   close() {
     if (this.#shutdown.signal.aborted)
@@ -18581,6 +19150,12 @@ class ClaustrumConsumer {
     this.#insula = undefined;
     this.#roster = undefined;
     this.#grantReach = undefined;
+    this.#releaseQuotaWriter();
+    forgetPendingVaultDiscovery(this.#options.rosterPath);
+  }
+  async dispose() {
+    this.close();
+    await this.#releaseQuotaWriter();
   }
 }
 
@@ -18621,16 +19196,16 @@ function nativeCode(value) {
 class NativeCustodyError extends Error {
   code;
   constructor(code) {
-    const safeCode = nativeCode(code);
-    super(`Native custody refused: ${safeCode}`);
+    const safeCode2 = nativeCode(code);
+    super(`Native custody refused: ${safeCode2}`);
     this.name = "NativeCustodyError";
-    this.code = safeCode;
+    this.code = safeCode2;
   }
 }
 function createNativeCustody(options) {
   const env = { ...options.env ?? process.env };
   const connect = options.connect;
-  const logger2 = options.logger;
+  const logger3 = options.logger;
   let closed = false;
   let revoked = false;
   let client;
@@ -18677,8 +19252,8 @@ function createNativeCustody(options) {
     let stopped = false;
     let inner;
     let finish = () => {};
-    const ended = new Promise((resolve7) => {
-      finish = resolve7;
+    const ended = new Promise((resolve9) => {
+      finish = resolve9;
     });
     const failed = (error) => stopped || closed || error instanceof NativeCustodyError ? { kind: "stopped" } : classifyVaultFailure(error) === "unreachable" ? { kind: "transport_lost", error: new ClaustrumUnreachableError } : { kind: "ended" };
     Promise.resolve().then(connection).then((owned) => {
@@ -18727,8 +19302,8 @@ function createNativeCustody(options) {
     ...options.setTimeout && { setTimeoutImpl: options.setTimeout },
     ...options.clearTimeout && { clearTimeoutImpl: options.clearTimeout },
     logger: {
-      warn: () => logger2?.warn("Native custody inventory record skipped"),
-      debug: () => logger2?.debug("Native custody failure reported")
+      warn: () => logger3?.warn("Native custody inventory record skipped"),
+      debug: () => logger3?.debug("Native custody failure reported")
     }
   });
   async function run(operation, signal) {
@@ -18852,13 +19427,13 @@ function createNativeCustody(options) {
 }
 
 // src/native-vault-invalidation.ts
-import { resolve as resolve7 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 var holders = new Set;
 function watchNativeVaultAuthority(holder) {
   const held = {
     ...holder,
-    roster: resolve7(holder.roster),
-    tokenPath: resolve7(holder.tokenPath)
+    roster: resolve9(holder.roster),
+    tokenPath: resolve9(holder.tokenPath)
   };
   holders.add(held);
   return () => {
@@ -18867,12 +19442,12 @@ function watchNativeVaultAuthority(holder) {
 }
 function retainNativeVaultRoster(path2, roster) {
   for (const holder of holders)
-    if (holder.roster === resolve7(path2))
+    if (holder.roster === resolve9(path2))
       holder.retain(roster);
 }
 function closeNativeVaultAuthority(tokenPath) {
   for (const holder of holders)
-    if (holder.tokenPath === resolve7(tokenPath))
+    if (holder.tokenPath === resolve9(tokenPath))
       holder.close();
 }
 
@@ -18906,9 +19481,18 @@ var reasons = new Set([
   "ETIMEDOUT",
   "ERR_PRIVATE_FILES_SECURITY"
 ]);
+var addonUnavailable = new Set([
+  "ERR_PRIVATE_FILES_UNAVAILABLE",
+  "native-addon-unavailable"
+]);
+var privateFilesUnavailableReasons = new Set([
+  "unsupported-filesystem",
+  "native-addon-unavailable"
+]);
 async function logRefusal(host, paths, readStatus) {
   let stage = "enrollment";
   let reason = "unreadable";
+  let unavailable = false;
   try {
     await readStatus(paths, `anthropic-auth-${host}`);
   } catch (error) {
@@ -18917,17 +19501,31 @@ async function logRefusal(host, paths, readStatus) {
       const detail = current;
       if (detail.stage && stages.has(detail.stage))
         stage = detail.stage;
-      for (const value of [detail.kind, detail.code, detail.reason])
+      for (const value of [detail.kind, detail.code, detail.reason]) {
         if (value && reasons.has(value))
           reason = value;
+        if (value && addonUnavailable.has(value))
+          unavailable = true;
+      }
       current = detail.cause;
     }
   }
+  if (unavailable)
+    reason = "native-addon-unavailable";
   logger.warn("enrollment", "Native enrollment authority refused", {
     host,
     stage,
     reason
   });
+  return reason;
+}
+var PRIVATE_FILES_UNAVAILABLE_MESSAGE = "Private file support didn't load on this machine (@cortexkit/private-files). Reinstall the plugin; if this persists, report it with your OS and Node version.";
+
+class NativePrivateFilesUnavailableError extends NativeCustodyError {
+  constructor() {
+    super("invalid-token");
+    this.message = PRIVATE_FILES_UNAVAILABLE_MESSAGE;
+  }
 }
 async function readNativeEnrollmentMode(host, env = process.env, dependencies = { enrollmentAuthority, readClaustrumEnrollmentStatus }) {
   const paths = getHostClaustrumEnrollmentPaths(host, env);
@@ -18935,7 +19533,9 @@ async function readNativeEnrollmentMode(host, env = process.env, dependencies =
   if (authority !== "vault")
     closeNativeVaultAuthority(getHostClaustrumEnrollmentPaths(host, env).tokenPath);
   if (authority === "unreadable") {
-    await logRefusal(host, paths, dependencies.readClaustrumEnrollmentStatus);
+    const reason = await logRefusal(host, paths, dependencies.readClaustrumEnrollmentStatus);
+    if (privateFilesUnavailableReasons.has(reason))
+      throw new NativePrivateFilesUnavailableError;
     throw new NativeCustodyError("invalid-token");
   }
   return authority === "vault" ? "claustrum" : "local";
@@ -19118,12 +19718,12 @@ async function joinNativePoolWrite(paths, signals, check, onLockEvent) {
 function pause(ms, signals) {
   if (signals.some((signal) => signal.aborted))
     return Promise.resolve();
-  return new Promise((resolve8) => {
+  return new Promise((resolve10) => {
     const wake = () => {
       clearTimeout(timer);
       for (const signal of signals)
         signal.removeEventListener("abort", wake);
-      resolve8();
+      resolve10();
     };
     const timer = setTimeout(wake, ms);
     for (const signal of signals)
@@ -19379,7 +19979,7 @@ function createNativeRefreshCoordinator(options) {
           name: spec.name,
           timeoutMs: POOL_LOCK_DEFAULTS.timeoutMs
         });
-      await new Promise((resolve8) => setTimeout(resolve8, Math.min(POOL_LOCK_DEFAULTS.retryMs, remaining)));
+      await new Promise((resolve10) => setTimeout(resolve10, Math.min(POOL_LOCK_DEFAULTS.retryMs, remaining)));
     }
   }
   async function run(job, request) {
@@ -19949,7 +20549,7 @@ class NativeMigrationSourceError extends Error {
   }
 }
 var MAX_SOURCE_BYTES = 4 * 1024 * 1024;
-function isRecord11(value) {
+function isRecord10(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function freezeJson(root) {
@@ -20029,7 +20629,7 @@ async function readNativeMigrationSource(role, path2, hooks = {}) {
     } catch {
       throw new NativeMigrationSourceError(role, "invalid-source");
     }
-    if (!isRecord11(data))
+    if (!isRecord10(data))
       throw new NativeMigrationSourceError(role, "invalid-source");
     return sourceSnapshot({
       role,
@@ -20081,7 +20681,7 @@ class NativeAuthorityError extends Error {
   code;
   constructor(code) {
     super({
-      "migration-required": "Anthropic account migration is required. Stop OpenCode, LiteCode and Pi, then run npx @cortexkit/opencode-anthropic-auth@2.0.0 setup",
+      "migration-required": "Anthropic account migration is required. Stop OpenCode, LiteCode and Pi, then run npx @cortexkit/opencode-anthropic-auth setup",
       "migration-incomplete": "Anthropic account migration is incomplete; resume setup",
       "invalid-journal": "Anthropic account migration journal is invalid",
       "journal-conflict": "Anthropic account migration journal changed"
@@ -20090,7 +20690,7 @@ class NativeAuthorityError extends Error {
     this.name = "NativeAuthorityError";
   }
 }
-function isRecord12(value) {
+function isRecord11(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function captureJournalJson(value) {
@@ -20126,19 +20726,19 @@ function isCapturedPath(value) {
   return typeof value === "string" && isAbsolute4(value) && !/\p{Cc}/u.test(value) && !value.endsWith(sep) && normalize(value) === value && (sep !== "\\" || parse3(value).root !== sep) && !value.split(sep).some((part) => part === "." || part === "..");
 }
 function isSources(value) {
-  return isRecord12(value) && hasKeys(value, ["config", "state", "hostAuth", "routing"]) && isFileDigest(value.config) && isFileDigest(value.state) && isHostEntry(value.hostAuth) && isFileDigest(value.routing);
+  return isRecord11(value) && hasKeys(value, ["config", "state", "hostAuth", "routing"]) && isFileDigest(value.config) && isFileDigest(value.state) && isHostEntry(value.hostAuth) && isFileDigest(value.routing);
 }
 function isRoutingPaths(value) {
-  return isRecord12(value) && hasKeys(value, ["source", "destination"]) && isCapturedPath(value.source) && isCapturedPath(value.destination);
+  return isRecord11(value) && hasKeys(value, ["source", "destination"]) && isCapturedPath(value.source) && isCapturedPath(value.destination);
 }
 function isText(value) {
   return typeof value === "string" && value.length > 0;
 }
 function decodeRoster2(value) {
-  if (!isRecord12(value) || !hasKeys(value, ["version", "view", "complete", "rows", "declined"]) || value.version !== 1 || !isText(value.view) || value.complete !== true || !Array.isArray(value.rows) || !Array.isArray(value.declined))
+  if (!isRecord11(value) || !hasKeys(value, ["version", "view", "complete", "rows", "declined"]) || value.version !== 1 || !isText(value.view) || value.complete !== true || !Array.isArray(value.rows) || !Array.isArray(value.declined))
     throw new NativeAuthorityError("invalid-journal");
   const rows = value.rows.map((row) => {
-    if (!isRecord12(row) || !hasKeys(row, [
+    if (!isRecord11(row) || !hasKeys(row, [
       "routeId",
       "credentialId",
       "credentialType",
@@ -20161,7 +20761,7 @@ function decodeRoster2(value) {
     };
   });
   const declined = value.declined.map((entry2) => {
-    if (!isRecord12(entry2) || !isText(entry2.credentialId) || !(hasKeys(entry2, ["credentialId"]) || hasKeys(entry2, ["credentialId", "accountIdentity"]) && isText(entry2.accountIdentity)))
+    if (!isRecord11(entry2) || !isText(entry2.credentialId) || !(hasKeys(entry2, ["credentialId"]) || hasKeys(entry2, ["credentialId", "accountIdentity"]) && isText(entry2.accountIdentity)))
       throw new NativeAuthorityError("invalid-journal");
     return isText(entry2.accountIdentity) ? {
       credentialId: entry2.credentialId,
@@ -20173,7 +20773,7 @@ function decodeRoster2(value) {
   return { version: 1, view: value.view, complete: true, rows, declined };
 }
 function decodeDigestPair(value, keys4, valid) {
-  if (!isRecord12(value) || !hasKeys(value, [...keys4]) || !keys4.every((key) => valid(value[key])))
+  if (!isRecord11(value) || !hasKeys(value, [...keys4]) || !keys4.every((key) => valid(value[key])))
     throw new NativeAuthorityError("invalid-journal");
   return Object.fromEntries(keys4.map((key) => [key, value[key]]));
 }
@@ -20181,7 +20781,7 @@ var ACTIVATION_PHASES = ["prepared", "published", "committed"];
 function decodeActivation(value, phase) {
   if (value === null)
     return null;
-  if (!isRecord12(value))
+  if (!isRecord11(value))
     throw new NativeAuthorityError("invalid-journal");
   if (value.kind === "requested" && hasKeys(value, ["kind"]))
     return { kind: "requested" };
@@ -20195,7 +20795,7 @@ function decodeActivation(value, phase) {
     "settings",
     "runtime",
     "hostAuth"
-  ]) || !ACTIVATION_PHASES.some((item) => item === value.phase) || !isRecord12(value.primary) || !hasKeys(value.primary, ["routeId", "credentialId", "accountIdentity"]) || !isText(value.primary.routeId) || !isText(value.primary.credentialId) || !isText(value.primary.accountIdentity) || !Array.isArray(value.removeIds) || !value.removeIds.every(isText))
+  ]) || !ACTIVATION_PHASES.some((item) => item === value.phase) || !isRecord11(value.primary) || !hasKeys(value.primary, ["routeId", "credentialId", "accountIdentity"]) || !isText(value.primary.routeId) || !isText(value.primary.credentialId) || !isText(value.primary.accountIdentity) || !Array.isArray(value.removeIds) || !value.removeIds.every(isText))
     throw new NativeAuthorityError("invalid-journal");
   const primary = {
     routeId: value.primary.routeId,
@@ -20222,7 +20822,7 @@ function decodeActivation(value, phase) {
 }
 function decodeJournal(input, storageId) {
   const value = captureJournalJson(input);
-  if (!isRecord12(value) || value.storageId !== storageId)
+  if (!isRecord11(value) || value.storageId !== storageId)
     throw new NativeAuthorityError("invalid-journal");
   if (value.version === 5 && value.kind === "empty-init") {
     if (!hasKeys(value, ["version", "kind", "storageId", "host", "phase"]) || value.host !== "opencode" || value.phase !== "committed")
@@ -20398,7 +20998,7 @@ async function beginNativeMigration(paths, input, hooks = {}) {
 }
 async function recordNativeMigrationExpectations(paths, expectations, hooks = {}) {
   const captured = captureJournalJson(expectations);
-  if (!isRecord12(captured) || !hasKeys(captured, [
+  if (!isRecord11(captured) || !hasKeys(captured, [
     "expectedHostAuth",
     "expectedRouting",
     "preparedProof"
@@ -20473,7 +21073,7 @@ function journalLock(hooks) {
 }
 async function recordNativeCustodyActivation(paths, plan, hooks = {}) {
   const captured = captureJournalJson(plan);
-  if (!isRecord12(captured) || captured.phase !== "prepared")
+  if (!isRecord11(captured) || captured.phase !== "prepared")
     throw new NativeAuthorityError("journal-conflict");
   const decoded = decodeActivation(captured, "retired");
   if (decoded?.kind !== "activation")
@@ -20819,7 +21419,7 @@ function createNativeUsagePublisher(channel) {
   return {
     observe,
     publish(write) {
-      observe(new Promise((resolve8) => setTimeout(resolve8, 0)).then(write));
+      observe(new Promise((resolve10) => setTimeout(resolve10, 0)).then(write));
     },
     async drain() {
       while (pending.size)
@@ -20895,7 +21495,7 @@ class NativeQuotaObservations extends Map {
 }
 
 // src/native-runtime-registry.ts
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 var identities = new WeakMap;
 var nextIdentity = 0;
 function nativeRuntimeOptionIdentity(value) {
@@ -20924,14 +21524,14 @@ function nativeRuntimeStorageKey(options) {
       "runtime",
       "journal",
       "roster"
-    ].map((field) => resolve8(paths[field])),
-    resolve8(enrollment.tokenPath),
-    resolve8(enrollment.statePath),
-    resolve8(connection)
+    ].map((field) => resolve10(paths[field])),
+    resolve10(enrollment.tokenPath),
+    resolve10(enrollment.statePath),
+    resolve10(connection)
   ]);
 }
 function nativeRuntimeConnectionFile(host, env) {
-  return resolve8(resolveClaustrumConnectionPath(host === "pi" ? env.PI_ANTHROPIC_AUTH_CLAUSTRUM_CONNECTION_FILE : undefined, host === "pi" ? {
+  return resolve10(resolveClaustrumConnectionPath(host === "pi" ? env.PI_ANTHROPIC_AUTH_CLAUSTRUM_CONNECTION_FILE : undefined, host === "pi" ? {
     ...env,
     OPENCODE_ANTHROPIC_AUTH_CLAUSTRUM_CONNECTION_FILE: undefined
   } : env));
@@ -20970,9 +21570,9 @@ class NativeRuntimeRegistry {
 
 // src/native-vault-paths.ts
 import { createHash as createHash15 } from "node:crypto";
-import { basename as basename5, dirname as dirname11, join as join12 } from "node:path";
+import { basename as basename5, dirname as dirname11, join as join13 } from "node:path";
 function sibling(path2, expected, name, suffix) {
-  return basename5(path2) === expected ? join12(dirname11(path2), name) : path2.replace(/(?:\.json)?$/, `.${suffix}.json`);
+  return basename5(path2) === expected ? join13(dirname11(path2), name) : path2.replace(/(?:\.json)?$/, `.${suffix}.json`);
 }
 function nativeVaultPaths(local) {
   const config = sibling(local.legacyConfig, "anthropic-auth.json", "anthropic-auth-vault-settings.json", "vault-settings");
@@ -21185,10 +21785,10 @@ function seedCode(value) {
 class NativeRosterSeedError extends Error {
   code;
   constructor(code) {
-    const safeCode = seedCode(code);
-    super(`Native roster seed refused: ${safeCode}`);
+    const safeCode2 = seedCode(code);
+    super(`Native roster seed refused: ${safeCode2}`);
     this.name = "NativeRosterSeedError";
-    this.code = safeCode;
+    this.code = safeCode2;
   }
 }
 function guarded(body) {
@@ -21533,8 +22133,8 @@ function mergeHeaderQuotaSnapshot(existing, incoming) {
 // src/quota-manager.ts
 var nativeSetTimeout = globalThis.setTimeout;
 function pauseOnRealTimer(ms) {
-  return new Promise((resolve9) => {
-    const id2 = nativeSetTimeout(resolve9, ms);
+  return new Promise((resolve11) => {
+    const id2 = nativeSetTimeout(resolve11, ms);
     if (typeof id2 === "object" && "unref" in id2)
       id2.unref();
   });
@@ -22301,7 +22901,8 @@ async function publishNativeVaultRosterSeed(paths, input, options = {}) {
 }
 async function publishNativeVaultRuntimeSeed(paths, state, options = {}) {
   const imported = decodeNativeRuntime(captureNativePlainData(state), paths.storageId);
-  await mutateVaultRoster(paths.roster, async (roster, lease) => {
+  const assertPinned = async () => {
+    const roster = await readVaultRoster(paths.roster);
     for (const [id2, entry2] of Object.entries(imported.accounts)) {
       if (entry2.binding.kind !== "custody")
         continue;
@@ -22310,13 +22911,13 @@ async function publishNativeVaultRuntimeSeed(paths, state, options = {}) {
       if (!row?.accountIdentity || row.accountIdentity !== binding2.accountIdentity || row.credentialId !== binding2.credentialId && !row.aliases?.includes(binding2.credentialId))
         throw new NativeRuntimeError("publication-refused");
     }
-    await updateNativeRuntime(paths.runtime, paths.storageId, () => imported, {
-      beforeRename: async () => {
-        await options.assertOwned?.();
-        await lease.assertOwned();
-      }
-    });
-    return { result: undefined };
+  };
+  await assertPinned();
+  await updateNativeRuntime(paths.runtime, paths.storageId, () => imported, {
+    beforeRename: async () => {
+      await options.assertOwned?.();
+      await assertPinned();
+    }
   });
 }
 var NATIVE_VAULT_CONNECT_TIMEOUT_MS = 2000;
@@ -22363,11 +22964,6 @@ function createNativeVaultRuntime(options) {
     onLockEvent: options.onLockEvent
   });
   const observeLock = nativeLockObserver(options.onLockEvent);
-  const observeRosterLock = () => observeLock?.({
-    type: "acquiring",
-    name: "claustrum-roster-write",
-    path: paths.roster
-  });
   let rosterWatch;
   let rosterWatching = false;
   let rosterView;
@@ -22584,46 +23180,49 @@ function createNativeVaultRuntime(options) {
     await requireActive(signal);
     if (absentOnly && !await nativeVaultFileAbsent(paths.config))
       return;
-    observeRosterLock();
-    await mutateVaultRoster(paths.roster, async (roster, lease) => {
-      if (absentOnly && !await nativeVaultFileAbsent(paths.config))
-        return { result: undefined };
-      const primary = roster?.rows.find((row) => (row.credentialId === NATIVE_PRIMARY_CREDENTIAL_ID || row.aliases?.includes(NATIVE_PRIMARY_CREDENTIAL_ID)) && row.credentialType === "oauth" && !row.stale && !row.unclaimed && typeof row.accountIdentity === "string" && row.accountIdentity.length > 0);
-      const read = await store.readSettings();
-      if (read.status !== "ready")
-        throw new NativeCustodyError("invalid-state");
-      const previous = nativeVaultPrimaryPin(read.settings);
-      if (!absentOnly && (!primary && !previous || primary && previous?.routeId === primary.routeId && previous.credentialId === NATIVE_PRIMARY_CREDENTIAL_ID && previous.accountIdentity === primary.accountIdentity))
-        return { result: undefined };
-      const writer = createNativePoolStore({
-        paths,
-        quota: nativeQuotaCodec,
-        onLockEvent: options.onLockEvent,
-        onStep: async (point) => {
-          if (point === "before-config-write" || point === "before-state-write") {
-            await requireActive(signal);
-            await lease.assertOwned();
-          }
-        }
-      });
-      await writer.updateSettings(async (settings) => {
-        if (absentOnly && !await nativeVaultFileAbsent(paths.config))
-          return settings;
-        if (primary) {
-          settings.mainAccountId = primary.routeId;
-          settings.claustrum = {
-            primaryAccount: {
-              credentialId: NATIVE_PRIMARY_CREDENTIAL_ID,
-              accountId: primary.accountIdentity
-            }
-          };
-        } else {
-          delete settings.mainAccountId;
-          delete settings.claustrum;
+    const roster = await readVaultRoster(paths.roster);
+    if (absentOnly && !await nativeVaultFileAbsent(paths.config))
+      return;
+    const primaryFor = (roster2) => roster2?.rows.find((row) => (row.credentialId === NATIVE_PRIMARY_CREDENTIAL_ID || row.aliases?.includes(NATIVE_PRIMARY_CREDENTIAL_ID)) && row.credentialType === "oauth" && !row.stale && !row.unclaimed && typeof row.accountIdentity === "string" && row.accountIdentity.length > 0);
+    const primary = primaryFor(roster);
+    const read = await store.readSettings();
+    if (read.status !== "ready")
+      throw new NativeCustodyError("invalid-state");
+    const previous = nativeVaultPrimaryPin(read.settings);
+    if (!absentOnly && (!primary && !previous || primary && previous?.routeId === primary.routeId && previous.credentialId === NATIVE_PRIMARY_CREDENTIAL_ID && previous.accountIdentity === primary.accountIdentity))
+      return;
+    const assertPrimary = async () => {
+      await requireActive(signal);
+      const pinned = primaryFor(await readVaultRoster(paths.roster));
+      if (pinned?.routeId !== primary?.routeId || pinned?.accountIdentity !== primary?.accountIdentity)
+        throw new NativeRuntimeError("publication-refused");
+    };
+    const writer = createNativePoolStore({
+      paths,
+      quota: nativeQuotaCodec,
+      onLockEvent: options.onLockEvent,
+      onStep: async (point) => {
+        if (point === "before-config-write" || point === "before-state-write") {
+          await assertPrimary();
         }
+      }
+    });
+    await writer.updateSettings(async (settings) => {
+      if (absentOnly && !await nativeVaultFileAbsent(paths.config))
         return settings;
-      });
-      return { result: undefined };
+      if (primary) {
+        settings.mainAccountId = primary.routeId;
+        settings.claustrum = {
+          primaryAccount: {
+            credentialId: NATIVE_PRIMARY_CREDENTIAL_ID,
+            accountId: primary.accountIdentity
+          }
+        };
+      } else {
+        delete settings.mainAccountId;
+        delete settings.claustrum;
+      }
+      return settings;
     });
   }
   async function rowFor(roster, routeId) {
@@ -23003,56 +23602,52 @@ function createNativeVaultRuntime(options) {
     ]);
     if ((versions.get(key) ?? 0) > receipt.recordVersion)
       return false;
-    observeRosterLock();
-    return mutateVaultRoster(paths.roster, async (roster, lease) => {
-      const row = await rowFor(roster, route.logicalId);
-      if (!row?.accountIdentity || row.routeId !== route.routeId || row.accountIdentity !== receipt.assertedAccountIdentity || row.credentialId !== receipt.credentialId && !row.aliases?.includes(receipt.credentialId))
-        return { result: false };
-      const accountIdentity = row.accountIdentity;
-      let kept = false;
-      try {
-        const outcome = await updateNativeRuntimeOptional(paths.runtime, paths.storageId, (current) => {
-          const old = current.accounts[route.routeId];
-          const binding2 = old?.binding;
-          if (binding2?.kind === "custody" && binding2.credentialId === receipt.credentialId && binding2.accountIdentity === receipt.assertedAccountIdentity && binding2.recordVersion > receipt.recordVersion)
-            throw new NativeRuntimeError("runtime-conflict");
-          const same = binding2?.kind === "custody" && binding2.accountIdentity === receipt.assertedAccountIdentity;
-          current.accounts[route.routeId] = change({
-            ...same ? old : {},
-            binding: {
-              kind: "custody",
-              storageId: paths.storageId,
-              routeId: route.routeId,
-              credentialId: receipt.credentialId,
-              accountIdentity,
-              recordVersion: receipt.recordVersion
-            }
-          });
-          kept = true;
-          return current;
-        }, {
-          onLockEvent: options.onLockEvent,
-          beforeRename: async () => {
-            await requireActive();
-            const pinned = await rowFor(roster, route.logicalId);
-            if (!pinned || pinned.routeId !== route.routeId || pinned.accountIdentity !== receipt.assertedAccountIdentity)
-              throw new NativeRuntimeError("publication-refused");
-            const superseded = (versions.get(key) ?? 0) > receipt.recordVersion;
-            if (superseded && onSuperseded === "refuse")
-              throw new NativeRuntimeError("runtime-conflict");
-            await lease.assertOwned();
-            return superseded ? "skip" : "publish";
+    const row = await rowFor(await readVaultRoster(paths.roster), route.logicalId);
+    if (!row?.accountIdentity || row.routeId !== route.routeId || row.accountIdentity !== receipt.assertedAccountIdentity || row.credentialId !== receipt.credentialId && !row.aliases?.includes(receipt.credentialId))
+      return false;
+    const accountIdentity = row.accountIdentity;
+    let kept = false;
+    try {
+      const outcome = await updateNativeRuntimeOptional(paths.runtime, paths.storageId, (current) => {
+        const old = current.accounts[route.routeId];
+        const binding2 = old?.binding;
+        if (binding2?.kind === "custody" && binding2.credentialId === receipt.credentialId && binding2.accountIdentity === receipt.assertedAccountIdentity && binding2.recordVersion > receipt.recordVersion)
+          throw new NativeRuntimeError("runtime-conflict");
+        const same = binding2?.kind === "custody" && binding2.accountIdentity === receipt.assertedAccountIdentity && (binding2.credentialId === row.credentialId || row.aliases?.includes(binding2.credentialId));
+        current.accounts[route.routeId] = change({
+          ...same ? old : {},
+          binding: {
+            kind: "custody",
+            storageId: paths.storageId,
+            routeId: route.routeId,
+            credentialId: receipt.credentialId,
+            accountIdentity,
+            recordVersion: receipt.recordVersion
           }
         });
-        if (outcome.status === "skipped")
-          return { result: false };
-      } catch (error) {
-        if (error instanceof NativeRuntimeError && error.code === "runtime-conflict")
-          return { result: false };
-        throw error;
-      }
-      return { result: kept };
-    });
+        kept = true;
+        return current;
+      }, {
+        onLockEvent: options.onLockEvent,
+        beforeRename: async () => {
+          await requireActive();
+          const pinned = await rowFor(await readVaultRoster(paths.roster), route.logicalId);
+          if (!pinned || pinned.routeId !== route.routeId || pinned.accountIdentity !== receipt.assertedAccountIdentity || pinned.credentialId !== receipt.credentialId && !pinned.aliases?.includes(receipt.credentialId))
+            throw new NativeRuntimeError("publication-refused");
+          const superseded = (versions.get(key) ?? 0) > receipt.recordVersion;
+          if (superseded && onSuperseded === "refuse")
+            throw new NativeRuntimeError("runtime-conflict");
+          return superseded ? "skip" : "publish";
+        }
+      });
+      if (outcome.status === "skipped")
+        return false;
+    } catch (error) {
+      if (error instanceof NativeRuntimeError && error.code === "runtime-conflict")
+        return false;
+      throw error;
+    }
+    return kept;
   }
   async function fetchReading(routeId, fetchImpl, signal, read, onFailure, dispatch) {
     const combined = signalFor(signal);
@@ -23136,7 +23731,7 @@ function recencyOnly(patch) {
   return keys4.length === 1 && keys4[0] === "lastUsed" && typeof patch.lastUsed === "number";
 }
 function waitFor(pending, signal) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve11, reject) => {
     const abort = () => {
       cleanup2();
       reject(signal.reason);
@@ -23145,7 +23740,7 @@ function waitFor(pending, signal) {
     signal.addEventListener("abort", abort, { once: true });
     pending.then((value) => {
       cleanup2();
-      signal.aborted ? reject(signal.reason) : resolve9(value);
+      signal.aborted ? reject(signal.reason) : resolve11(value);
     }, (error) => {
       cleanup2();
       reject(error);
@@ -23219,12 +23814,12 @@ function leaseNativeVaultRuntime(use, close) {
 // src/pool-paths.ts
 import { createHash as createHash17 } from "node:crypto";
 import { realpath as realpath3 } from "node:fs/promises";
-import { basename as basename7, dirname as dirname13, join as join14, resolve as resolve9 } from "node:path";
+import { basename as basename7, dirname as dirname13, join as join15, resolve as resolve11 } from "node:path";
 
 // src/sticky-routing.ts
 import { createHash as createHash16, randomUUID as randomUUID14 } from "node:crypto";
 import { mkdir as mkdir10, readFile as readFile9, rename as rename12, rm as rm7, stat as stat7, writeFile as writeFile4 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname12, join as join13 } from "node:path";
+import { basename as basename6, dirname as dirname12, join as join14 } from "node:path";
 var STICKY_ROUTING_MAIN_ACCOUNT_ID = "main";
 var STICKY_ROUTING_SHORT_RESET_GRACE_MS = 15 * 60000;
 var STICKY_ROUTING_ASSIGNMENT_TTL_MS = 7 * 24 * 60 * 60000;
@@ -23274,14 +23869,14 @@ function createStickyNoRouteResponse(input) {
     }
   });
 }
-function isRecord13(value) {
+function isRecord12(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function finiteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
 function normalizeAssignment(value) {
-  if (!isRecord13(value))
+  if (!isRecord12(value))
     return;
   if (typeof value.accountId !== "string" || !["fable", "opus", "general"].includes(String(value.family))) {
     return;
@@ -23310,7 +23905,7 @@ function normalizeAssignment(value) {
   };
 }
 function normalizeState(value) {
-  if (!isRecord13(value) || value.version !== 1 || !isRecord13(value.assignments)) {
+  if (!isRecord12(value) || value.version !== 1 || !isRecord12(value.assignments)) {
     return;
   }
   const assignments = {};
@@ -23328,7 +23923,7 @@ function normalizeState(value) {
 }
 function migrateStickyRoutingState(source2, rowIdMap) {
   try {
-    if (!isRecord13(source2) || !isRecord13(source2.assignments))
+    if (!isRecord12(source2) || !isRecord12(source2.assignments))
       throw new Error;
     const entries = Object.entries(source2.assignments);
     const state = normalizeState({
@@ -23346,10 +23941,10 @@ function migrateStickyRoutingState(source2, rowIdMap) {
     const assignments = Object.create(null);
     for (const [index, [key, original]] of entries.entries()) {
       const assignment = state.assignments[String(index)];
-      if (!isRecord13(original) || !assignment)
+      if (!isRecord12(original) || !assignment)
         throw new Error;
-      const fields = Object.keys(assignment).filter((field) => field !== "affinityModelId" || Object.hasOwn(original, "affinityModelId"));
-      if (Object.keys(original).length !== fields.length || fields.some((field) => !Object.hasOwn(original, field) || !Object.is(original[field], Reflect.get(assignment, field)))) {
+      const fields2 = Object.keys(assignment).filter((field) => field !== "affinityModelId" || Object.hasOwn(original, "affinityModelId"));
+      if (Object.keys(original).length !== fields2.length || fields2.some((field) => !Object.hasOwn(original, field) || !Object.is(original[field], Reflect.get(assignment, field)))) {
         throw new Error;
       }
       const accountId = rowIdMap.get(assignment.accountId);
@@ -23474,7 +24069,7 @@ function decideStickyQuotaFailure(input) {
 function getStickyRoutingStatePath(accountStoragePath) {
   const name = basename6(accountStoragePath);
   const stem = name.endsWith(".json") ? name.slice(0, -5) : name;
-  return join13(dirname12(accountStoragePath), `${stem}-routing-state.json`);
+  return join14(dirname12(accountStoragePath), `${stem}-routing-state.json`);
 }
 function stickyRetryAfterWithJitter(sessionId, retryAfterSeconds) {
   const hash2 = createHash16("sha256").update(sessionId).digest().readUInt32BE(0);
@@ -23575,7 +24170,7 @@ class StickySessionRouter {
       if (!wait || performance.now() >= deadline) {
         throw new Error("Timed out acquiring sticky routing state lock");
       }
-      await new Promise((resolve9) => setTimeout(resolve9, STICKY_ROUTING_LOCK_POLL_MS));
+      await new Promise((resolve11) => setTimeout(resolve11, STICKY_ROUTING_LOCK_POLL_MS));
     }
   }
   recoverLocalPins() {
@@ -23690,7 +24285,7 @@ class StickySessionRouter {
         const source2 = await readNativeVaultLegacyJson(seed.legacyConfig);
         const routes = nativeVaultLegacyRoutes(source2, roster);
         const legacy = await readNativeVaultLegacyJson(getStickyRoutingStatePath(seed.legacyConfig));
-        if (isRecord13(legacy) && legacy.version === 1 && isRecord13(legacy.assignments)) {
+        if (isRecord12(legacy) && legacy.version === 1 && isRecord12(legacy.assignments)) {
           for (const [key, raw] of Object.entries(legacy.assignments)) {
             if (!/^[0-9a-f]{64}$/.test(key) || Object.hasOwn(state.assignments, key))
               continue;
@@ -23941,7 +24536,7 @@ function resolveLocalRoutingDestination(host, paths, env) {
   return (host === "opencode" ? env.OPENCODE_ANTHROPIC_AUTH_ROUTING_STATE_FILE : env.PI_ANTHROPIC_AUTH_ROUTING_STATE_FILE) || getStickyRoutingStatePath(paths.config);
 }
 async function canonicalPath(path2) {
-  const absolute = resolve9(path2);
+  const absolute = resolve11(path2);
   try {
     return await realpath3(absolute);
   } catch (error) {
@@ -23952,10 +24547,10 @@ async function canonicalPath(path2) {
   const parent = dirname13(absolute);
   if (parent === absolute)
     return absolute;
-  return join14(await canonicalPath(parent), basename7(absolute));
+  return join15(await canonicalPath(parent), basename7(absolute));
 }
 function sibling2(path2, legacyName, name, suffix) {
-  return basename7(path2) === legacyName ? join14(dirname13(path2), name) : `${path2}.${suffix}.json`;
+  return basename7(path2) === legacyName ? join15(dirname13(path2), name) : `${path2}.${suffix}.json`;
 }
 async function resolveNativePoolPaths(legacyConfig = getAccountStoragePath(), legacyState = getAccountStatePath(legacyConfig)) {
   const [sourceConfig, sourceState] = await Promise.all([
@@ -24532,7 +25127,7 @@ class PersistentRelaySession {
       return;
     if (this.connecting)
       return await this.connecting;
-    this.connecting = new Promise((resolve10, reject) => {
+    this.connecting = new Promise((resolve12, reject) => {
       const url = toWebSocketUrl(this.config.url, this.config.token);
       const parsed = new URL(url);
       parsed.searchParams.set("affinity", this.affinity);
@@ -24554,7 +25149,7 @@ class PersistentRelaySession {
           if (message.type === "ready") {
             this.timers.clearTimeout(timeout);
             this.serverState = message.state;
-            resolve10();
+            resolve12();
             return;
           }
           this.handleMessage(message);
@@ -24606,15 +25201,15 @@ class PersistentRelaySession {
     const sentAt = perfNowMs();
     let resolveDone;
     let rejectDone;
-    const done = new Promise((resolve10, reject) => {
-      resolveDone = resolve10;
+    const done = new Promise((resolve12, reject) => {
+      resolveDone = resolve12;
       rejectDone = reject;
     });
-    const response = new Promise((resolve10, reject) => {
+    const response = new Promise((resolve12, reject) => {
       const pending = {
         payload,
         bodyText,
-        resolve: resolve10,
+        resolve: resolve12,
         reject,
         streamDone: false,
         accepted: false,
@@ -25938,7 +26533,7 @@ function createNativeAccountRuntime(options) {
       const { mode, paths: paths2, store: store2 } = await selectedStorage();
       for (let attempt = 0;attempt < 4; attempt++) {
         if (attempt)
-          await new Promise((resolve10) => setTimeout(resolve10, 10));
+          await new Promise((resolve12) => setTimeout(resolve12, 10));
         const settings = await store2.readSettings();
         if (settings.status !== "ready")
           throw new NativeRuntimeError("publication-refused");
@@ -26648,7 +27243,7 @@ function relayGeneration(input) {
 // src/native-host-auth-write.ts
 import { randomUUID as randomUUID16 } from "node:crypto";
 import { lstat as lstat7, open as open9, rename as rename13, unlink as unlink6 } from "node:fs/promises";
-import { dirname as dirname14, isAbsolute as isAbsolute5, join as join15 } from "node:path";
+import { dirname as dirname14, isAbsolute as isAbsolute5, join as join16 } from "node:path";
 class NativeHostAuthWriteError extends Error {
   code;
   effect;
@@ -26709,7 +27304,7 @@ async function writeNativeHostAuth(input, hooks = {}) {
     const removingFile = host === "pi" && Object.keys(next).length === 0;
     const outcome = Object.freeze(host === "pi" ? { status: "removed", file: removingFile ? "unlinked" : "replaced" } : { status: snapshot.data === undefined ? "created" : "replaced" });
     if (!removingFile) {
-      stage = join15(dirname14(authPath), `.native-host-auth-write.${randomUUID16()}.tmp`);
+      stage = join16(dirname14(authPath), `.native-host-auth-write.${randomUUID16()}.tmp`);
       const bytes = `${JSON.stringify(next, null, 2)}
 `;
       const nativeCreated = await createWindowsOwnerOnly(stage, bytes);
@@ -27584,7 +28179,7 @@ class NativeCustodyActivationError extends Error {
 function refuse4(code) {
   throw new NativeCustodyActivationError(code);
 }
-function isRecord14(value) {
+function isRecord13(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function sameJson(left, right) {
@@ -27669,7 +28264,7 @@ var ACCOUNT_RUNTIME_FIELDS = [
   "quotaErrorGeneration"
 ];
 function vaultSettings(settings, primary) {
-  const custody = isRecord14(settings.claustrum) ? settings.claustrum : {};
+  const custody = isRecord13(settings.claustrum) ? settings.claustrum : {};
   return {
     ...settings,
     claustrum: {
@@ -27779,7 +28374,7 @@ async function preparePlan(options, journal, store) {
   const main = pool.settings.mainAccountId;
   if (typeof main !== "string" || !main)
     refuse4("invalid-state");
-  const custody = isRecord14(pool.settings.claustrum) ? pool.settings.claustrum : {};
+  const custody = isRecord13(pool.settings.claustrum) ? pool.settings.claustrum : {};
   const host = await readHostEntry(options.host, journal.hostAuthPath);
   const hostAuth = {
     source: host.digest,
@@ -27810,7 +28405,7 @@ async function preparePlan(options, journal, store) {
   let roster;
   let targetSettings;
   if (custody.mode === "claustrum") {
-    const pin = isRecord14(custody.primaryAccount) ? custody.primaryAccount : {};
+    const pin = isRecord13(custody.primaryAccount) ? custody.primaryAccount : {};
     if (oauth.length > 0 || pin.credentialId !== primary.credentialId || pin.accountId !== primary.accountIdentity)
       refuse4("primary-mismatch");
     if (!existing)
@@ -27861,7 +28456,7 @@ async function preparePlan(options, journal, store) {
     } catch (error) {
       if (error instanceof NativeCustodyActivationError)
         throw error;
-      return refuse4(isRecord14(error) && error.code === "unenrolled-local-row" ? "unenrolled-local-row" : "roster-conflict");
+      return refuse4(isRecord13(error) && error.code === "unenrolled-local-row" ? "unenrolled-local-row" : "roster-conflict");
     }
     roster = existing ?? rosterProjection(seed);
     targetSettings = vaultSettings(pool.settings, primary);
@@ -28013,7 +28608,7 @@ async function runNativeCustodyActivation(options, hooks = {}) {
         if (settings.status !== "ready")
           refuse4("invalid-state");
         const custody = settings.settings.claustrum;
-        if (isRecord14(custody) && custody.mode === "claustrum")
+        if (isRecord13(custody) && custody.mode === "claustrum")
           return { status: "already-vault", journal };
       }
       if (journal.activation?.kind === "activation" && journal.activation.phase === "committed")
@@ -28234,8 +28829,8 @@ async function runNativeCustodyActivation(options, hooks = {}) {
 }
 async function commitMode(paths, routingPath, plan, context) {
   let openGate = () => {};
-  const gate = new Promise((resolve10) => {
-    openGate = resolve10;
+  const gate = new Promise((resolve12) => {
+    openGate = resolve12;
   });
   let leases;
   let scope;
@@ -28864,7 +29459,7 @@ function readPlain(value, allowed) {
   const prototype = Object.getPrototypeOf(value);
   if (prototype !== Object.prototype && prototype !== null)
     return "malformed";
-  const fields = new Map;
+  const fields2 = new Map;
   let unknownKey = false;
   for (const key of Reflect.ownKeys(value)) {
     if (typeof key !== "string")
@@ -28875,9 +29470,9 @@ function readPlain(value, allowed) {
     if (!allowed.includes(key))
       unknownKey = true;
     else
-      fields.set(key, descriptor.value);
+      fields2.set(key, descriptor.value);
   }
-  return unknownKey ? "unknown-key" : fields;
+  return unknownKey ? "unknown-key" : fields2;
 }
 function readArray(value) {
   if (value === null || typeof value !== "object")
@@ -28931,13 +29526,13 @@ function readKillswitchEntries(value) {
     return;
   const entries = [];
   for (const item of items2) {
-    const fields = readPlain(item, ENTRY_KEYS);
-    if (!(fields instanceof Map))
+    const fields2 = readPlain(item, ENTRY_KEYS);
+    if (!(fields2 instanceof Map))
       return;
-    const account = fields.get("account");
-    const fh = fields.get("fh");
-    const sd = fields.get("sd");
-    const scoped = fields.get("scoped");
+    const account = fields2.get("account");
+    const fh = fields2.get("fh");
+    const sd = fields2.get("sd");
+    const scoped = fields2.get("scoped");
     if (!isKillswitchAccount(account))
       return;
     if (!isDigitInteger(fh) || !isDigitInteger(sd))
@@ -29021,14 +29616,14 @@ var CONTEXT_KEYS = [
   "signal"
 ];
 function readContext(value) {
-  const fields = readPlain(value, CONTEXT_KEYS);
-  if (!(fields instanceof Map))
+  const fields2 = readPlain(value, CONTEXT_KEYS);
+  if (!(fields2 instanceof Map))
     return;
-  const interactive = fields.get("interactive");
-  const custodyMode = fields.get("custodyMode");
-  const confirmed = fields.get("confirmed");
-  const sessionId = fields.get("sessionId");
-  const rawSignal = fields.get("signal");
+  const interactive = fields2.get("interactive");
+  const custodyMode = fields2.get("custodyMode");
+  const confirmed = fields2.get("confirmed");
+  const sessionId = fields2.get("sessionId");
+  const rawSignal = fields2.get("signal");
   if (typeof interactive !== "boolean")
     return;
   if (custodyMode !== "local" && custodyMode !== "claustrum")
@@ -29128,9 +29723,9 @@ var DISCONNECT_RESULTS = new Set([
   "conflict"
 ]);
 function readOutcome(action, outcome) {
-  const fields = readPlain(outcome, ["ok", "text"]);
-  const ok = fields instanceof Map ? fields.get("ok") : undefined;
-  const text5 = fields instanceof Map ? fields.get("text") : undefined;
+  const fields2 = readPlain(outcome, ["ok", "text"]);
+  const ok = fields2 instanceof Map ? fields2.get("ok") : undefined;
+  const text5 = fields2 instanceof Map ? fields2.get("text") : undefined;
   if (typeof ok !== "boolean" || typeof text5 !== "string")
     return Object.freeze({ status: "failed", action, code: "invalid-outcome" });
   return Object.freeze({ status: "executed", action, ok, text: text5 });
@@ -29173,12 +29768,12 @@ function disconnectFailureCode(error) {
   return "execution-failed";
 }
 function createNativeMenuExecutor(options) {
-  const fields = readPlain(options, ["host", "dispatch", "disconnectVault"]);
-  if (!(fields instanceof Map))
+  const fields2 = readPlain(options, ["host", "dispatch", "disconnectVault"]);
+  if (!(fields2 instanceof Map))
     throw new TypeError("Native menu executor options are invalid");
-  const host = fields.get("host");
-  const dispatch = fields.get("dispatch");
-  const disconnectVault = fields.get("disconnectVault");
+  const host = fields2.get("host");
+  const dispatch = fields2.get("dispatch");
+  const disconnectVault = fields2.get("disconnectVault");
   if (!HOSTS2.has(host))
     throw invalidOption2("host");
   if (typeof dispatch !== "function" || utilTypes7.isProxy(dispatch))
@@ -29634,8 +30229,8 @@ function showSignInLink(text5, scrub) {
   const links = new Set((text5.match(/https:\/\/\S+/g) ?? []).filter(isSignInLink));
   const [link2] = links;
   if (links.size !== 1 || link2 === undefined)
-    return scrub(text5);
-  return text5.split(link2).map(scrub).join(link2);
+    return { text: scrub(text5) };
+  return { text: text5.split(link2).map(scrub).join(link2), link: link2 };
 }
 var DISCONNECT_OUTCOMES = {
   disconnected: {
@@ -29834,12 +30429,16 @@ function createNativeUi(options) {
           safe = safe.split(value).join("[REDACTED]");
         return redact2(safe);
       };
-      const finish = async (result2, signInLink = false) => ({
-        command: "claude",
-        ...result2,
-        text: signInLink ? showSignInLink(result2.text, scrub) : scrub(result2.text),
-        menu: await model(invocation, scrub, readable)
-      });
+      const finish = async (result2, signInLink = false) => {
+        const shown = signInLink ? showSignInLink(result2.text, scrub) : { text: scrub(result2.text) };
+        return {
+          command: "claude",
+          ...result2,
+          text: shown.text,
+          ...shown.link !== undefined ? { authorizationUrl: shown.link } : {},
+          menu: await model(invocation, scrub, readable)
+        };
+      };
       if (request?.command !== "claude" || !action || request.itemId !== undefined || request.sessionId !== undefined && request.sessionId !== invocation.sessionId) {
         return finish({
           ok: false,
@@ -29933,11 +30532,11 @@ async function refreshForRequest(runtime2, ready) {
         break;
       if (combined.aborted)
         break;
-      await new Promise((resolve10) => {
+      await new Promise((resolve12) => {
         const finish = () => {
           clearTimeout(pause2);
           combined.removeEventListener("abort", finish);
-          resolve10();
+          resolve12();
         };
         const pause2 = setTimeout(finish, 25);
         combined.addEventListener("abort", finish, { once: true });
@@ -29953,16 +30552,16 @@ async function refreshForRequest(runtime2, ready) {
 function waitForRequest(pending, signal) {
   if (!signal)
     return pending;
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve12, reject) => {
     const abort = () => reject(signal.reason);
     signal.addEventListener("abort", abort, { once: true });
-    pending.then(resolve10, reject).finally(() => signal.removeEventListener("abort", abort));
+    pending.then(resolve12, reject).finally(() => signal.removeEventListener("abort", abort));
     if (signal.aborted)
       abort();
   });
 }
 // src/native-vault-connection.ts
-import { dirname as dirname17, join as join16, resolve as resolve11 } from "node:path";
+import { dirname as dirname17, join as join17, resolve as resolve13 } from "node:path";
 // ../../node_modules/@cortexkit/common-auth/dist/opencode2/integration.js
 var PLACEHOLDER_PREFIX = "common-auth-placeholder";
 var PLACEHOLDER_LIFETIME_MS = 365 * 24 * 60 * 60 * 1000;
@@ -29973,7 +30572,7 @@ function placeholderSecret(integrationID) {
 import { createHash as createHash20 } from "node:crypto";
 import { constants as constants4 } from "node:fs";
 import { lstat as lstat9, mkdir as mkdir13, open as open10, unlink as unlink8 } from "node:fs/promises";
-import { dirname as dirname16, resolve as resolve10 } from "node:path";
+import { dirname as dirname16, resolve as resolve12 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 
 // ../../node_modules/@cortexkit/common-auth/dist/pi-slot/lock.js
@@ -30066,7 +30665,7 @@ async function acquirePiLock(authPath, onCompromised, onRenew) {
     if (!released && lastUpdate + RENEWAL_STALE < Date.now())
       compromise();
   }
-  function schedule(delay3 = UPDATE) {
+  function schedule2(delay3 = UPDATE) {
     if (released)
       return;
     timer = setTimeout(() => {
@@ -30080,7 +30679,7 @@ async function acquirePiLock(authPath, onCompromised, onRenew) {
     if (errorCode2(error) === "ENOENT" || lastUpdate + RENEWAL_STALE < Date.now())
       compromise();
     else
-      schedule(1000);
+      schedule2(1000);
   }
   async function update() {
     assertFresh();
@@ -30113,14 +30712,14 @@ async function acquirePiLock(authPath, onCompromised, onRenew) {
     mtime = next.getTime();
     lastUpdate = Date.now();
     active.set(path2, { ...identity2, mtime, renewedAt: lastUpdate });
-    schedule();
+    schedule2();
   }
   onRenew?.(async () => {
     if (timer)
       clearTimeout(timer);
     await update();
   });
-  schedule();
+  schedule2();
   return {
     assertFresh,
     async release() {
@@ -30361,8 +30960,8 @@ function createPiSlot(options, onStep, hooks) {
   if (!provider || !options.authPath || !options.stashPath || !placeholderKey || placeholderKey.startsWith("!") || placeholderKey.includes("$") || !Number.isFinite(timeout) || timeout < 0) {
     throw new PiSlotError("invalid-options");
   }
-  const authPath = resolve10(options.authPath);
-  const stashPath = resolve10(options.stashPath);
+  const authPath = resolve12(options.authPath);
+  const stashPath = resolve12(options.stashPath);
   if (authPath === stashPath || stashPath === `${authPath}.lock`) {
     throw new PiSlotError("invalid-options");
   }
@@ -30500,8 +31099,8 @@ function createPiSlot(options, onStep, hooks) {
 // src/native-vault-connection.ts
 function nativePiAuthSlotPaths(options) {
   return {
-    authPath: resolve11(options.authPath),
-    stashPath: join16(dirname17(getHostClaustrumEnrollmentPaths("pi", options.env).tokenPath), "pi-auth-slot", "anthropic.json"),
+    authPath: resolve13(options.authPath),
+    stashPath: join17(dirname17(getHostClaustrumEnrollmentPaths("pi", options.env).tokenPath), "pi-auth-slot", "anthropic.json"),
     provider: "anthropic",
     placeholderKey: placeholderSecret("anthropic")
   };
@@ -30522,8 +31121,8 @@ async function disconnectNativeVaultForHost(options) {
 import { createHash as createHash21 } from "node:crypto";
 import { realpathSync as realpathSync2 } from "node:fs";
 import { mkdir as mkdir14, readdir as readdir3, rm as rm8, stat as stat9, writeFile as writeFile5 } from "node:fs/promises";
-import { tmpdir as tmpdir6 } from "node:os";
-import { join as join17, resolve as resolve12 } from "node:path";
+import { tmpdir as tmpdir7 } from "node:os";
+import { join as join18, resolve as resolve14 } from "node:path";
 var CLAUDE_PRIME_COMMAND_NAME = "claude-prime";
 var PRIME_TICK_MS = 60000;
 var PRIME_DUE_OFFSET_MS = 60000;
@@ -30711,10 +31310,10 @@ function buildPrimeRequestBody() {
   return JSON.parse(JSON.stringify(PRIME_REQUEST_BODY));
 }
 function defaultMarkerDir() {
-  return join17(tmpdir6(), "opencode-anthropic-auth", "prime");
+  return join18(tmpdir7(), "opencode-anthropic-auth", "prime");
 }
 function primeStorageFingerprint(storagePath) {
-  const absolutePath = resolve12(storagePath);
+  const absolutePath = resolve14(storagePath);
   let canonicalPath2;
   try {
     canonicalPath2 = realpathSync2(absolutePath);
@@ -30726,19 +31325,19 @@ function primeStorageFingerprint(storagePath) {
   return createHash21("sha256").update(canonicalPath2).digest("hex").slice(0, 12);
 }
 function primeMarkerNamespaceDir(markerDir, storagePath) {
-  return join17(markerDir, primeStorageFingerprint(storagePath));
+  return join18(markerDir, primeStorageFingerprint(storagePath));
 }
 function primeAccountMarkerDir(markerDir, storagePath, accountFingerprint) {
   if (!/^[a-f0-9]{12,}$/i.test(accountFingerprint)) {
     throw new Error("Prime account fingerprint must be a hexadecimal digest");
   }
-  return join17(primeMarkerNamespaceDir(markerDir, storagePath), accountFingerprint.toLowerCase().slice(0, 12));
+  return join18(primeMarkerNamespaceDir(markerDir, storagePath), accountFingerprint.toLowerCase().slice(0, 12));
 }
 function primeMarkerPath(markerDir, accountId2, resetsAtEpochMs) {
-  return join17(markerDir, `${encodeURIComponent(accountId2)}-${resetsAtEpochMs}`);
+  return join18(markerDir, `${encodeURIComponent(accountId2)}-${resetsAtEpochMs}`);
 }
 function primeBootstrapMarkerPath(markerDir, accountId2) {
-  return join17(markerDir, `${encodeURIComponent(accountId2)}-bootstrap`);
+  return join18(markerDir, `${encodeURIComponent(accountId2)}-bootstrap`);
 }
 function primeAccountLabel(id2, fallback) {
   if (id2 === "main")
@@ -31162,7 +31761,7 @@ class PrimeManager {
     let swept = 0;
     for (const entry2 of entries) {
       try {
-        const path2 = join17(dir, entry2);
+        const path2 = join18(dir, entry2);
         const s = await stat9(path2);
         if (s.isDirectory()) {
           swept += await this.sweepMarkerDirectory(path2, now);
@@ -31196,12 +31795,12 @@ import {
   stat as stat10,
   writeFile as writeFile6
 } from "node:fs/promises";
-import { tmpdir as tmpdir7 } from "node:os";
-import { join as join18 } from "node:path";
+import { tmpdir as tmpdir8 } from "node:os";
+import { join as join19 } from "node:path";
 var QUOTA_HEADER_FEED_SCHEMA_VERSION = 3;
 var QUOTA_HEADER_FEED_LEASE_MS = 180000;
 function getDefaultQuotaHeaderFeedDirectory() {
-  return process.env.OPENCODE_ANTHROPIC_AUTH_QUOTA_FEED_DIR ?? join18(tmpdir7(), "opencode-anthropic-auth", "quota-header-feed");
+  return process.env.OPENCODE_ANTHROPIC_AUTH_QUOTA_FEED_DIR ?? join19(tmpdir8(), "opencode-anthropic-auth", "quota-header-feed");
 }
 function configuredAnthropicOAuthAccountCount(input) {
   const fallbackCount = input.storage?.accounts.filter(isOAuthAccount).length ?? 0;
@@ -31360,7 +31959,7 @@ class QuotaHeaderFeedRegistry {
   constructor(options = {}) {
     this.options = options;
     const instanceId = options.instanceId ?? `${process.pid}-${randomUUID17()}`;
-    this.filePath = join18(options.directory ?? getDefaultQuotaHeaderFeedDirectory(), `${instanceId}.json`);
+    this.filePath = join19(options.directory ?? getDefaultQuotaHeaderFeedDirectory(), `${instanceId}.json`);
   }
   publish(entry2) {
     const { accountKey, quota: quota2 } = entry2;
@@ -31421,7 +32020,7 @@ class QuotaHeaderFeedRegistry {
       return;
     }
     await Promise.all(names2.filter((name) => /^\d+-[0-9a-f-]+\.json$/i.test(name)).map(async (name) => {
-      const path2 = join18(directory, name);
+      const path2 = join19(directory, name);
       if (path2 === this.filePath)
         return;
       try {
@@ -31450,7 +32049,7 @@ class QuotaHeaderFeedRegistry {
     const newest = new Map;
     await Promise.all(names2.map(async (name) => {
       try {
-        const record9 = JSON.parse(await readFile10(join18(directory, name), "utf8"));
+        const record9 = JSON.parse(await readFile10(join19(directory, name), "utf8"));
         if (record9.version !== QUOTA_HEADER_FEED_SCHEMA_VERSION || !record9.entries || typeof record9.entries !== "object")
           return;
         for (const [accountKey, candidate] of Object.entries(record9.entries)) {
@@ -31631,7 +32230,7 @@ function buildClaudeQuotaSummary(input) {
 }
 // src/request-gzip.ts
 import { mkdir as mkdir16, readFile as readFile11, rename as rename15, rm as rm10, writeFile as writeFile7 } from "node:fs/promises";
-import { basename as basename8, dirname as dirname18, join as join19 } from "node:path";
+import { basename as basename8, dirname as dirname18, join as join20 } from "node:path";
 import { promisify } from "node:util";
 import { gzip } from "node:zlib";
 var gzipAsync = promisify(gzip);
@@ -31777,7 +32376,7 @@ function getRequestGzipLatch(path2) {
 function getRequestGzipLatchPath(accountStoragePath) {
   const name = basename8(accountStoragePath);
   const stem = name.endsWith(".json") ? name.slice(0, -5) : name;
-  return join19(dirname18(accountStoragePath), `${stem}-request-gzip.json`);
+  return join20(dirname18(accountStoragePath), `${stem}-request-gzip.json`);
 }
 async function decideRequestGzip(options) {
   if (!CLAUDE_CODE_GZIPS_REQUEST_BODIES)
@@ -31922,7 +32521,7 @@ var REPORTED_BLOCK_TYPES = new Set([
   "document"
 ]);
 var EMPTY_TEXT_BLOCK_KEYS = new Set(["type", "text", "cache_control"]);
-function isRecord15(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isProvablyEmptyContent(content) {
@@ -31930,14 +32529,14 @@ function isProvablyEmptyContent(content) {
     return content.trim() === "";
   if (!Array.isArray(content))
     return false;
-  return content.every((block) => isRecord15(block) && block.type === "text" && typeof block.text === "string" && block.text.trim() === "" && Object.keys(block).every((key) => EMPTY_TEXT_BLOCK_KEYS.has(key)));
+  return content.every((block) => isRecord14(block) && block.type === "text" && typeof block.text === "string" && block.text.trim() === "" && Object.keys(block).every((key) => EMPTY_TEXT_BLOCK_KEYS.has(key)));
 }
 function describeContent(content) {
   if (Array.isArray(content)) {
     return {
       contentShape: "array",
       contentBlockCount: content.length,
-      contentBlockTypes: content.map((block) => isRecord15(block) && typeof block.type === "string" && REPORTED_BLOCK_TYPES.has(block.type) ? block.type : "other")
+      contentBlockTypes: content.map((block) => isRecord14(block) && typeof block.type === "string" && REPORTED_BLOCK_TYPES.has(block.type) ? block.type : "other")
     };
   }
   if (typeof content === "string")
@@ -31950,7 +32549,7 @@ function assertNoMeaningfulTrailingAssistant(messages) {
   let end = messages.length;
   while (end > 0) {
     const last = messages[end - 1];
-    if (!isRecord15(last) || last.role !== "assistant")
+    if (!isRecord14(last) || last.role !== "assistant")
       break;
     if (!isProvablyEmptyContent(last.content)) {
       throw new TrailingAssistantHistoryError({
@@ -32093,11 +32692,11 @@ function executeLaneStartCommand(input) {
 }
 // src/thinking-binding.ts
 var THINKING_BINDING_CONTROLS_BETA = "thinking-binding-controls-2026-08-01";
-function isRecord16(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isReplayableThinkingBlock(block) {
-  if (!isRecord16(block))
+  if (!isRecord15(block))
     return false;
   if (block.type === "thinking") {
     return typeof block.signature === "string" && block.signature.length > 0;
@@ -32115,7 +32714,7 @@ function hasReplayableThinkingBlocks(body) {
   if (!Array.isArray(body.messages))
     return false;
   return body.messages.some((message) => {
-    if (!isRecord16(message) || message.role !== "assistant")
+    if (!isRecord15(message) || message.role !== "assistant")
       return false;
     return Array.isArray(message.content) && message.content.some(isReplayableThinkingBlock);
   });
@@ -32123,11 +32722,11 @@ function hasReplayableThinkingBlocks(body) {
 function applyThinkingBindingControls(body, behavior = "account-default") {
   if (behavior === "account-default")
     return false;
-  if (!isClaudeFable51Model(body.model) && !isClaudeOpus55Model(body.model) && !isClaudeSonnet55Model(body.model) && !isClaudeHaiku55Model(body.model))
+  if (!resolveClaudeModelCapabilities(body.model)?.thinkingBindingControls)
     return false;
   if (!hasReplayableThinkingBlocks(body))
     return false;
-  if (!isRecord16(body.thinking) || body.thinking.type !== "adaptive")
+  if (!isRecord15(body.thinking) || body.thinking.type !== "adaptive")
     return false;
   body.thinking.block_binding = {
     prefix_mismatch_behavior: behavior
@@ -32135,13 +32734,68 @@ function applyThinkingBindingControls(body, behavior = "account-default") {
   return true;
 }
 function hasThinkingBindingControls(body) {
-  if (!isRecord16(body.thinking))
+  if (!isRecord15(body.thinking))
     return false;
-  if (!isRecord16(body.thinking.block_binding))
+  if (!isRecord15(body.thinking.block_binding))
     return false;
   const behavior = body.thinking.block_binding.prefix_mismatch_behavior;
   return behavior === "error" || behavior === "drop_block";
 }
+// src/turn-end-note.ts
+var TURN_END_NOTE_MIN_VISIBLE_CHARACTERS = 350;
+var TURN_END_NOTE_CONTENT = "Your reply above has already reached the user. The tool call after it was housekeeping and changed nothing they need to know. Do not repeat, summarize or rewrite that reply. If no new work remains, end the turn without restating anything.";
+var DEFAULT_TOOLS = ["board", "ctx_reduce"];
+function isRecord16(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function supportsTurnEndNote(model) {
+  return resolveClaudeModelCapabilities(model)?.turnEndNote === true;
+}
+function applyTurnEndNotes(body, options = {}) {
+  if (!supportsTurnEndNote(body.model) || !Array.isArray(body.messages))
+    return 0;
+  const allowed = new Set((options.tools ?? DEFAULT_TOOLS).map((name) => options.mapToolName?.(name) ?? name));
+  if (!allowed.size)
+    return 0;
+  const messages = body.messages;
+  const rewritten = [];
+  let inserted = 0;
+  for (let index = 0;index < messages.length; index++) {
+    const results = messages[index];
+    rewritten.push(results);
+    let preceding = index - 1;
+    while (preceding >= 0) {
+      const control = messages[preceding];
+      if (!isRecord16(control) || control.role !== "system" || !Array.isArray(control.content) || control.content.length !== 0 || !isRecord16(control.output_config))
+        break;
+      preceding--;
+    }
+    const assistant = messages[preceding];
+    if (!isRecord16(assistant) || assistant.role !== "assistant" || !Array.isArray(assistant.content) || !isRecord16(results) || results.role !== "user" || !Array.isArray(results.content))
+      continue;
+    const visible = options.visibleText ? options.visibleText(assistant) : assistant.content.filter((block) => isRecord16(block) && block.type === "text" && typeof block.text === "string" && block.text.trim().length > 0).map((block) => block.text).join("");
+    if (visible.length < TURN_END_NOTE_MIN_VISIBLE_CHARACTERS)
+      continue;
+    const calls = assistant.content.filter((block) => isRecord16(block) && block.type === "tool_use");
+    if (!calls.length || !calls.every((call) => allowed.has(call.name)))
+      continue;
+    const resultIds = new Set(results.content.filter((block) => isRecord16(block) && block.type === "tool_result").map((block) => block.tool_use_id));
+    if (!calls.every((call) => typeof call.id === "string" && resultIds.has(call.id)))
+      continue;
+    const next = messages[index + 1];
+    if (isRecord16(next) && next.role === "user")
+      continue;
+    rewritten.push({
+      role: "system",
+      clear_at: "next_user_message",
+      content: TURN_END_NOTE_CONTENT
+    });
+    inserted++;
+  }
+  if (inserted)
+    body.messages = rewritten;
+  return inserted;
+}
 export {
   writeNativeHostAuth,
   writeDumpFile,
@@ -32183,6 +32837,7 @@ export {
   resolveNativePoolPaths,
   resolveLocalRoutingDestination,
   resolveClaustrumConnectionPath,
+  resolveClaudeModelCapabilities,
   resolveClaudeCodeIdentity,
   resolveClaudeCodeAccountIdentity,
   resetFastModeState,
@@ -32227,6 +32882,7 @@ export {
   primeEligibilityReasonLabel,
   primeAccountMarkerDir,
   prepareNativeMigration,
+  pinsEffortOnEveryRequest,
   parseSseFrame,
   parseRoutingCommandAction,
   parseRetryAfterHeader,
@@ -32352,6 +33008,8 @@ export {
   getDefaultCacheKeepRegistryDirectory,
   getClaustrumMode,
   getClaustrumEnrollmentPaths2 as getClaustrumEnrollmentPaths,
+  getClaudeModelCatalogue,
+  getClaudeModelCapabilities,
   getClaudeFableMythos5ReleaseDate,
   getClaudeCodeIdentityForVerifiedAccount,
   getClaudeCodeIdentity,
@@ -32496,6 +33154,7 @@ export {
   PrimeManager,
   PROFILE_TTL_MS,
   PRODUCTION_CLAUSTRUM_CONNECTION_FILE_NAME,
+  PRIVATE_FILES_UNAVAILABLE_MESSAGE,
   PRIME_TICK_MS,
   PRIME_REQUEST_BODY,
   PRIME_POST_FIRE_REFRESH_MS,
@@ -32511,6 +33170,7 @@ export {
   NativeTransientAccountError,
   NativeRuntimeError,
   NativeQuotaObservations,
+  NativePrivateFilesUnavailableError,
   PiSlotError as NativePiAuthSlotError,
   NativeMigrationError,
   NativeHostAuthError,
@@ -32563,6 +33223,7 @@ export {
   CLAUDE_OPUS_5_5_ADAPTIVE_THINKING,
   CLAUDE_MYTHOS_5_MODEL_ID,
   CLAUDE_MYTHOS_5_1_MODEL_ID,
+  CLAUDE_MODEL_CAPABILITIES,
   CLAUDE_LOGGING_COMMAND_NAME,
   CLAUDE_HAIKU_5_5_RELEASE_DATE,
   CLAUDE_HAIKU_5_5_PRICING,
@@ -32597,6 +33258,7 @@ export {
   CLAUDE_CODE_GZIPS_REQUEST_BODIES,
   CLAUDE_CODE_FULL_AGENT_BETAS,
   CLAUDE_CODE_ENTRYPOINT,
+  CLAUDE_CODE_DEFAULT_BETAS,
   CLAUDE_CACHE_KEEP_COMMAND_NAME,
   CLAUDE_ACCOUNT_COMMAND_NAME,
   CCH_SALT,