@cortexkit/anthropic-auth-core 2.2.4 → 2.2.6

package/dist/index.js

@@ -2730,7 +2730,7 @@ 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 UNSUPPORTED_VAULT_MESSAGE = 'This Claustrum vault is too old to connect plugins. Run ck upgrade to move to Claustrum v0.2.0 or newer (read "Upgrading from v0.1.3" in its release notes first), or 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];
@@ -18408,6 +18408,52 @@ function acceptVaultRoute(path2, routeId) {
     };
   });
 }
+function invalidOrder(message) {
+  return new ClaustrumConsumerError("invalid-order", message);
+}
+function vaultOrderProblem(rows, routeIds) {
+  if (!Array.isArray(routeIds))
+    return "route ids must be an array of route ids";
+  const rosterIds = new Set(rows.map((row) => row.routeId));
+  const given = new Set;
+  for (const id2 of routeIds) {
+    if (typeof id2 !== "string")
+      return "route ids must be an array of route ids";
+    if (given.has(id2))
+      return `route id ${id2} appears more than once`;
+    if (!rosterIds.has(id2))
+      return `route id ${id2} is not in the roster`;
+    given.add(id2);
+  }
+  const missing2 = [...rosterIds].filter((id2) => !given.has(id2)).length;
+  if (missing2 > 0)
+    return `the order leaves out ${missing2} roster route id${missing2 === 1 ? "" : "s"}`;
+  return;
+}
+function reorderVaultRoster(path2, routeIds, options = {}) {
+  return mutateVaultRoster(path2, (current) => {
+    const rows = current?.rows ?? [];
+    const problem = vaultOrderProblem(rows, routeIds);
+    if (problem)
+      throw invalidOrder(problem);
+    const byId = new Map;
+    for (const row of rows) {
+      const group = byId.get(row.routeId);
+      if (group)
+        group.push(row);
+      else
+        byId.set(row.routeId, [row]);
+    }
+    const ids = [...routeIds];
+    const next = ids.flatMap((id2) => byId.get(id2) ?? []);
+    if (!current || next.every((row, index) => row === rows[index]))
+      return { result: { ids, outcome: "unchanged" } };
+    return {
+      next: { ...current, rows: next },
+      result: { ids, outcome: "reordered" }
+    };
+  }, { ...options.signal && { signal: options.signal } });
+}
 function receiptFence(row, receipt) {
   if (!memberIds(row).includes(receipt.credentialId))
     return "refuse";
@@ -19087,7 +19133,11 @@ class ClaustrumConsumer {
       let current;
       try {
         current = await this.authorize(routeId, signal);
-      } catch {}
+        signal?.throwIfAborted();
+      } catch (error) {
+        if (signal?.aborted)
+          throw error;
+      }
       if (decideScopedRetryAfter401(options.site, served, current, this.#logger)) {
         await response.body?.cancel().catch(() => {});
         served = current;
@@ -19114,6 +19164,12 @@ class ClaustrumConsumer {
     await acceptVaultRoute(this.#options.rosterPath, routeId);
     this.#roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
   }
+  async reorder(routeIds) {
+    this.#assertOpen();
+    const result = await reorderVaultRoster(this.#options.rosterPath, routeIds);
+    this.#roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
+    return result;
+  }
   async recordQuota(routeId, observation, attempt) {
     this.#assertOpen();
     return recordVaultQuota(this.#options.rosterPath, {
@@ -19187,6 +19243,7 @@ function nativeCode(value) {
     case "host-slot-login":
     case "host-slot-placeholder":
     case "placeholder-refresh":
+    case "invalid-order":
       return value;
     default:
       return "unavailable";
@@ -21323,6 +21380,77 @@ function createNativeLocalCredentialService(options) {
   return Object.freeze({ authorize: authorize2 });
 }
 
+// src/native-local-publication.ts
+var publishers = new Map;
+function acquireNativeLocalPublisher(key) {
+  let owned = publishers.get(key);
+  if (!owned) {
+    owned = { writer: createPublisher(), leases: 0 };
+    publishers.set(key, owned);
+  }
+  owned.leases++;
+  let released = false;
+  return {
+    ...owned.writer,
+    release() {
+      if (released)
+        return;
+      released = true;
+      if (--owned.leases === 0)
+        publishers.delete(key);
+    }
+  };
+}
+function createPublisher() {
+  let tail = Promise.resolve();
+  const pending = new Map;
+  const run = (write) => {
+    const result = tail.then(write);
+    tail = result.catch(() => {});
+    return result;
+  };
+  return {
+    run,
+    enqueue(key, patch, write) {
+      const queued = pending.get(key);
+      if (queued) {
+        const previous = queued.patch;
+        if (previous.quota && patch.quota && patch.quota.source !== "headers" && quotaSnapshotCheckedAt(previous.quota) > quotaSnapshotCheckedAt(patch.quota))
+          return Promise.resolve(false);
+        queued.patch = { ...previous, ...patch };
+        if (previous.quota && patch.quota)
+          queued.patch.quota = fromNativeQuotaMap(nativeQuotaCodec.merge(toNativeQuotaMap(previous.quota), toNativeQuotaMap(patch.quota)));
+        if (previous.lastUsed !== undefined || patch.lastUsed !== undefined)
+          queued.patch.lastUsed = Math.max(previous.lastUsed ?? 0, patch.lastUsed ?? 0);
+        for (const field of [
+          "quotaErrorClearedAt",
+          "quotaErrorGeneration"
+        ])
+          if (previous[field] !== undefined || patch[field] !== undefined)
+            queued.patch[field] = Math.max(previous[field] ?? 0, patch[field] ?? 0);
+        if (previous.lastQuotaRefreshError && patch.lastQuotaRefreshError && previous.lastQuotaRefreshError.checkedAt > patch.lastQuotaRefreshError.checkedAt)
+          queued.patch.lastQuotaRefreshError = previous.lastQuotaRefreshError;
+        return queued.result;
+      }
+      const batch = { patch, result: Promise.resolve(false) };
+      pending.set(key, batch);
+      batch.result = run(async () => {
+        await new Promise((resolve10) => setTimeout(resolve10, 0));
+        pending.delete(key);
+        return write(batch.patch);
+      });
+      return batch.result;
+    },
+    async drain() {
+      let observed;
+      do {
+        observed = tail;
+        await observed;
+      } while (observed !== tail);
+    }
+  };
+}
+
 // src/native-usage-publication.ts
 import { types as types3 } from "node:util";
 function usagePublicationRefusalIsFatal(error) {
@@ -21364,6 +21492,7 @@ var codes = new Set([
   "host-slot-login",
   "host-slot-placeholder",
   "placeholder-refresh",
+  "invalid-order",
   "publication-refused",
   "unsafe-runtime",
   "invalid-runtime",
@@ -21468,7 +21597,7 @@ class NativeQuotaObservations extends Map {
     let clearAt;
     let matched = false;
     for (const observation of this.values()) {
-      if (observation.entry.quota.source === "headers")
+      if (observation.entry.quota.source === "headers" && observation.routeBeforeSave !== true)
         continue;
       if (observation.lineage !== lineage || observation.accountUuid !== accountUuid2 || getQuotaNextRefreshAt(observation.entry.quota, storage, observation.entry.checkedAt) <= now)
         continue;
@@ -21498,6 +21627,17 @@ class NativeQuotaObservations extends Map {
       }
     }));
   }
+  hold(accountId, observation) {
+    const current = this.get(accountId);
+    if (current && current.lineage === observation.lineage && quotaSnapshotCheckedAt(current.entry.quota) > quotaSnapshotCheckedAt(observation.entry.quota))
+      return false;
+    this.set(accountId, observation);
+    return true;
+  }
+  forget(accountId, observation) {
+    if (this.get(accountId) === observation)
+      this.delete(accountId);
+  }
   drain() {
     return this.publications.drain();
   }
@@ -24505,7 +24645,7 @@ class StickySessionRouter {
     }) > 0) : undefined;
     const selected = preferred ?? this.selectCandidate({ ...input, candidates, state });
     if (!selected) {
-      if (current) {
+      if (current && !input.preserveOnNoCandidate) {
         delete state.assignments[key];
         save("delete");
       }
@@ -26207,11 +26347,12 @@ function acquireNativeAccountRuntime(options) {
   const quotaObservations = use().quotaObservations;
   const onLockEvent = use().onLockEvent;
   const drainRoutingPublications = use().drainRoutingPublications;
+  const drainQuotaPublications = use().drainQuotaPublications;
   return {
     onLockEvent,
     vault,
     quotaObservations,
-    drainQuotaPublications: () => quotaObservations.drain(),
+    drainQuotaPublications,
     drainRoutingPublications,
     getRelayConfig: () => use().getRelayConfig(),
     getSettingsPath: () => use().getSettingsPath(),
@@ -26239,7 +26380,10 @@ function acquireNativeAccountRuntime(options) {
     fetchProfileForDisplay: (id2, transport, signal) => use().fetchProfileForDisplay(id2, transport, signal),
     close: () => {
       vault.close();
-      return drainRoutingPublications();
+      return Promise.all([
+        drainQuotaPublications(),
+        drainRoutingPublications()
+      ]).then(() => {});
     }
   };
 }
@@ -26279,6 +26423,9 @@ function createNativeAccountRuntime(options) {
     }
   });
   const shutdown = new AbortController;
+  let closing;
+  const quotaPublications = acquireNativeLocalPublisher(paths.config);
+  const metadataPublications = acquireNativeLocalPublisher(paths.runtime);
   const store = createNativePoolStore({
     paths,
     quota: nativeQuotaCodec,
@@ -26401,6 +26548,51 @@ function createNativeAccountRuntime(options) {
       throw error;
     }
   }
+  async function localMetadataMatches(subject) {
+    const binding2 = subject.binding;
+    const row = await poolRow(binding2.rowId);
+    if (row?.stamp !== "bound" || !row.credential || !nativeLocalPoolBindingMatches(binding2, paths, row))
+      return false;
+    if ("kind" in subject)
+      return row.credential.type === "api" && fingerprintOf(row.credential) === subject.credentialFingerprint && row.credential.baseURL === subject.baseURL && row.credential.authHeader === subject.authHeader;
+    return row.credential.type === "oauth" && fingerprintOf(row.credential) === subject.credentialFingerprint && nativeLocalCredentialValidationMatches(subject, binding2, row.credential);
+  }
+  async function localMetadataWrite(subject, change) {
+    const binding2 = subject.binding;
+    if (await authority() !== "local")
+      return false;
+    const matches2 = await localMetadataMatches(subject);
+    await localAuthority();
+    if (!matches2)
+      return false;
+    try {
+      await updateNativeRuntime(paths.runtime, paths.storageId, (current) => {
+        const old = current.accounts[binding2.rowId];
+        const previous = old?.binding;
+        const same = previous?.kind === "local" && previous.rowId === binding2.rowId && previous.identity === binding2.identity && previous.credentialEpoch === binding2.credentialEpoch;
+        current.accounts[binding2.rowId] = change(same && old ? old : { binding: binding2 });
+        return current;
+      }, {
+        onLockEvent: options.local?.onLockEvent,
+        beforeRename: async () => {
+          if (!await localMetadataMatches(subject))
+            throw new NativeRuntimeError("publication-refused");
+          await localAuthority();
+        },
+        beforePublish: () => localAuthority()
+      });
+      if (await authority() !== "local")
+        throw new NativeRuntimeError("publication-refused");
+      return true;
+    } catch (error) {
+      if (error instanceof NativeRuntimeError && (error.code === "runtime-conflict" || error.code === "publication-refused")) {
+        if (await authority() !== "local")
+          throw error;
+        return false;
+      }
+      throw error;
+    }
+  }
   async function initializeCredentialEpoch(id2) {
     const row = await poolRow(id2);
     if (!row?.credential || row.credentialEpoch === undefined)
@@ -26536,7 +26728,13 @@ function createNativeAccountRuntime(options) {
     onLockEvent,
     vault,
     quotaObservations: vault.quotaObservations,
-    drainQuotaPublications: () => vault.quotaObservations.drain(),
+    drainQuotaPublications: async () => {
+      await vault.quotaObservations.drain();
+      await Promise.all([
+        quotaPublications.drain(),
+        metadataPublications.drain()
+      ]);
+    },
     drainRoutingPublications: () => vaultRouter.drain(),
     async getRelayConfig() {
       const { mode, paths: paths2, store: store2 } = await selectedStorage();
@@ -26994,30 +27192,45 @@ function createNativeAccountRuntime(options) {
       };
     },
     async publishLocal(subject, rawPatch) {
-      const patch = captureNativeMetadataPatch(rawPatch);
-      if (await authority() !== "local")
-        return false;
-      const { quota: quota2, ...metadata2 } = patch;
-      const quotaOnly = quota2 !== undefined && Object.keys(metadata2).length === 0;
-      const row = await poolRow(subject.binding.rowId);
-      if (row?.stamp !== "bound" || row.credential?.type !== "oauth" || !nativeLocalPoolBindingMatches(subject.binding, paths, row) || !quotaOnly && !nativeLocalCredentialValidationMatches(subject, subject.binding, row.credential))
-        return false;
-      if (quota2) {
-        if (quota2.source !== "headers" && row.quota && quotaSnapshotCheckedAt(fromNativeQuotaMap(row.quota)) > quotaSnapshotCheckedAt(quota2))
+      const captured = captureNativeMetadataPatch(rawPatch);
+      const { quota: _quota, ...metadata2 } = captured;
+      const mixed = captured.quota !== undefined && Object.keys(metadata2).length > 0;
+      let admission;
+      const admitted = () => admission ??= (async () => {
+        if (await authority() !== "local")
           return false;
-        if (quota2.accountIdentity !== subject.binding.identity)
-          throw new NativeRuntimeError("publication-refused");
-        await store.recordQuota(subject.binding.rowId, {
-          credentialEpoch: subject.binding.credentialEpoch,
-          identity: subject.binding.identity
-        }, toNativeQuotaMap(quota2));
-      }
-      return localWrite(subject, (old) => applyNativeMetadataPatch(old, metadata2), quotaOnly ? "binding" : true);
+        const matches2 = await localMetadataMatches(subject);
+        await localAuthority();
+        return matches2;
+      })();
+      const key = JSON.stringify(subject);
+      const writes = [];
+      if (captured.quota)
+        writes.push(quotaPublications.enqueue(mixed ? `${key}:mixed` : key, { quota: captured.quota }, async ({ quota: quota2 }) => {
+          if (mixed && !await admitted())
+            return false;
+          if (!quota2 || await authority() !== "local")
+            return false;
+          const row = await poolRow(subject.binding.rowId);
+          if (row?.stamp !== "bound" || row.credential?.type !== "oauth" || !nativeLocalPoolBindingMatches(subject.binding, paths, row) || quota2.accountIdentity !== subject.binding.identity)
+            return false;
+          if (quota2.source !== "headers" && row.quota && quotaSnapshotCheckedAt(fromNativeQuotaMap(row.quota)) > quotaSnapshotCheckedAt(quota2))
+            return false;
+          await store.recordQuota(subject.binding.rowId, {
+            credentialEpoch: subject.binding.credentialEpoch,
+            identity: subject.binding.identity
+          }, toNativeQuotaMap(quota2));
+          return true;
+        }));
+      if (Object.keys(metadata2).length)
+        writes.push(metadataPublications.enqueue(mixed ? `${key}:mixed` : key, metadata2, async (patch) => {
+          if (mixed && !await admitted())
+            return false;
+          return localMetadataWrite(subject, (old) => applyNativeMetadataPatch(old, patch));
+        }));
+      return (await Promise.all(writes)).every(Boolean);
     },
-    publishApi: (subject, patch) => localWrite(subject, (old) => ({
-      ...old,
-      lastUsed: Math.max(old.lastUsed ?? 0, patch.lastUsed)
-    })),
+    publishApi: (subject, patch) => metadataPublications.enqueue(JSON.stringify(subject), patch, (merged) => localMetadataWrite(subject, (old) => applyNativeMetadataPatch(old, merged))),
     async resetBackoff(routeId, fence, kind = "all") {
       if ("accessToken" in fence)
         return vault.resetBackoff(fence, kind);
@@ -27049,13 +27262,13 @@ function createNativeAccountRuntime(options) {
       if (await physicalId(routeId) !== fence.binding.rowId)
         return;
       let lineage;
-      const kept = await localWrite(fence, (old) => {
+      const kept = await metadataPublications.run(() => localMetadataWrite(fence, (old) => {
         lineage = old.authLineageId ?? randomUUID15();
         return {
           ...old,
           authLineageId: lineage
         };
-      });
+      }));
       return kept ? lineage : undefined;
     },
     async incrementPrimeUsage(routeId, fence, delta = {}) {
@@ -27066,7 +27279,7 @@ function createNativeAccountRuntime(options) {
       if (await physicalId(routeId) !== fence.binding.rowId)
         return false;
       const captured = primeDelta(delta);
-      return localWrite(fence, (old) => ({
+      return metadataPublications.run(() => localMetadataWrite(fence, (old) => ({
         ...old,
         prime: {
           count: (old.prime?.count ?? 0) + 1,
@@ -27074,7 +27287,7 @@ function createNativeAccountRuntime(options) {
           outputTokens: (old.prime?.outputTokens ?? 0) + captured.outputTokens,
           since: old.prime?.since ?? now()
         }
-      }));
+      })));
     },
     async fetchQuota(routeId, fetchImpl = fetch, signal, dispatch, purpose) {
       const snapshot = await runtime2.read();
@@ -27138,11 +27351,16 @@ function createNativeAccountRuntime(options) {
       });
     },
     close() {
-      if (!shutdown.signal.aborted) {
+      if (closing)
+        return closing;
+      const draining = runtime2.drainQuotaPublications();
+      vault.close();
+      closing = Promise.all([draining, vaultRouter.drain()]).then(() => {}).finally(() => {
         shutdown.abort(new NativeCustodyError("closed"));
-        vault.close();
-      }
-      return vaultRouter.drain();
+        quotaPublications.release();
+        metadataPublications.release();
+      });
+      return closing;
     }
   };
   function readLocalProfile(id2, fetchImpl, signal) {

package/dist/internal-types/claustrum/consumer.d.ts

@@ -4,7 +4,7 @@ import type { RoutingRow } from '../routing/index.js';
 import { type ClaustrumFamily, type ClaustrumScopedAttempt, type ClaustrumScopedClient, type IdentityParser, type KeptReceiptState, type VaultGrantReach } from './custody.js';
 import { type ClaustrumLogger } from './errors.js';
 import { type InsulaQuotaOptions, type InsulaQuotaResult } from './insula.js';
-import { type AccountMapper, type QuotaReceipt, type VaultRosterFile } from './roster.js';
+import { type AccountMapper, type QuotaReceipt, type ReorderVaultRosterResult, type VaultRosterFile } from './roster.js';
 import { type WatchMode } from './watch.js';
 export interface ClaustrumConsumerOptions<Q = QuotaObservation> {
     /**
@@ -157,6 +157,12 @@ export declare class ClaustrumConsumer<Q = QuotaObservation> {
     /** Decline a vault account: it stays listed and never routes until accepted. */
     decline(routeId: string): Promise<void>;
     accept(routeId: string): Promise<void>;
+    /**
+     * Set the order vault accounts are tried in (`reorderVaultRoster`), then
+     * re-read the roster, so the next routing decision in this process uses
+     * the new order without waiting for a discovery. Never contacts the vault.
+     */
+    reorder(routeIds: readonly string[]): Promise<ReorderVaultRosterResult>;
     /**
      * Store a quota or profile observation for a vault route. The receipt the
      * reading was taken with is required: the observation lands only while the

package/dist/internal-types/claustrum/errors.d.ts

@@ -4,7 +4,7 @@
  * `code`, a `class` and an `action`), so callers can tell the vault's verdict
  * apart from a check made on this side.
  */
-export type ClaustrumConsumerFailureKind = 'closed' | 'not-enrolled' | 'invalid-token' | 'unavailable' | 'identity-changed' | 'identity-unasserted' | 'insufficient-validity' | 'invalid-material' | 'not-active' | 'route-unavailable' | 'route-declined' | 'no-receipt' | 'unsafe-file' | 'invalid-state' | 'wrong-consumer' | 'roster-busy' | 'host-slot-login' | 'host-slot-placeholder' | 'placeholder-refresh';
+export type ClaustrumConsumerFailureKind = 'closed' | 'not-enrolled' | 'invalid-token' | 'unavailable' | 'identity-changed' | 'identity-unasserted' | 'insufficient-validity' | 'invalid-material' | 'not-active' | 'route-unavailable' | 'route-declined' | 'no-receipt' | 'unsafe-file' | 'invalid-state' | 'wrong-consumer' | 'roster-busy' | 'host-slot-login' | 'host-slot-placeholder' | 'placeholder-refresh' | 'invalid-order';
 export declare class ClaustrumConsumerError extends Error {
     readonly kind: ClaustrumConsumerFailureKind;
     constructor(kind: ClaustrumConsumerFailureKind, message: string);

package/dist/internal-types/claustrum/index.d.ts

@@ -10,7 +10,7 @@ export { assertHostSlotMatchesMode, assertNotCustodyPlaceholder, CUSTODY_PLACEHO
 export { acquireInsulaQuotaSource, type InsulaQuotaContext, type InsulaQuotaLookup, type InsulaQuotaMiss, type InsulaQuotaOptions, type InsulaQuotaReading, type InsulaQuotaResult, type InsulaQuotaSource, type InsulaUsageEntry, type InsulaUsageTransport, type InsulaUsageWatch, type InsulaUsageWindow, type InsulaWatchOptions, } from './insula.js';
 export { acceptAccount, type DeclinedAccount, declineAccount, isDeclined, } from './interlock.js';
 export { drainVaultQuota } from './quota-writer.js';
-export { type AccountMapper, acceptVaultRoute, DEFAULT_ROUTE_PREFIX, declineVaultRoute, type MutateVaultRosterOptions, mutateVaultRoster, type ProjectionOptions, projectVaultRoster, type QuotaReceipt, readVaultRoster, recordVaultAccountQuota, recordVaultQuota, refreshVaultRoster, resolveVaultPrimary, type VaultPrimary, type VaultPrimaryBinding, type VaultPrimaryUnavailableReason, type VaultRosterFile, type VaultRosterLockContext, type VaultRosterRow, vaultRoutingRows, } from './roster.js';
+export { type AccountMapper, acceptVaultRoute, DEFAULT_ROUTE_PREFIX, declineVaultRoute, type MutateVaultRosterOptions, mutateVaultRoster, type ProjectionOptions, projectVaultRoster, type QuotaReceipt, type ReorderVaultRosterOptions, type ReorderVaultRosterResult, readVaultRoster, recordVaultAccountQuota, recordVaultQuota, refreshVaultRoster, reorderVaultRoster, resolveVaultPrimary, type VaultPrimary, type VaultPrimaryBinding, type VaultPrimaryUnavailableReason, type VaultRosterFile, type VaultRosterLockContext, type VaultRosterRow, vaultRoutingRows, } from './roster.js';
 export { type ChangeNotice, ChangeNoticeReader, RESUBSCRIBE_BACKOFF_MS, SAFETY_POLL_MS, ScopedRosterWatch, type ScopedRosterWatchOptions, type ScopedWatchEnd, type ScopedWatchHandle, type ScopedWatchNoticeShape, type ScopedWatchSource, WATCH_RETRY_MS, type WatchMode, } from './watch.js';
 /**
  * Connect the client that lists and fetches this consumer's vault credentials

package/dist/internal-types/claustrum/roster.d.ts

@@ -119,6 +119,37 @@ export declare function mutateVaultRoster<T>(path: string, change: (current: Vau
 export declare function declineVaultRoute(path: string, routeId: string): Promise<undefined>;
 /** Lift the user's decline for a vault account and every alias of it. */
 export declare function acceptVaultRoute(path: string, routeId: string): Promise<undefined>;
+/** Options of `reorderVaultRoster`. */
+export interface ReorderVaultRosterOptions {
+    /** Aborts the wait for the roster's write lock. */
+    signal?: AbortSignal;
+}
+export interface ReorderVaultRosterResult {
+    /** The route id order now on disk. */
+    ids: string[];
+    /** `unchanged` when the roster was already in this order; nothing was written. */
+    outcome: 'reordered' | 'unchanged';
+}
+/**
+ * Set the order vault accounts are tried in. Routing reads that order from
+ * the roster's row order (`vaultRoutingRows`), and a later discovery keeps
+ * each account at its position, so the order lasts until the next reorder.
+ * The order is this host's routing preference: the vault has no order of its
+ * own, and this never contacts it.
+ *
+ * `routeIds` must name every roster route id exactly once; anything else
+ * (an unknown, missing or repeated id) refuses with `invalid-order` and
+ * writes nothing. It runs under the roster's write lock, like every other
+ * roster write, so a quota reading or decline committed meanwhile is kept.
+ * Each row is kept as the same object, so only the positions change: every
+ * row's fields and the rest of the file stay as they were. An order equal to
+ * the current one writes nothing. A host with no roster file yet has no
+ * routes, so only the empty order is accepted.
+ *
+ * A `ClaustrumConsumer` in the same process does not see the new order until
+ * it re-reads the file: call `consumer.reorder` instead to update both.
+ */
+export declare function reorderVaultRoster(path: string, routeIds: readonly string[], options?: ReorderVaultRosterOptions): Promise<ReorderVaultRosterResult>;
 /**
  * The receipt fields a quota or profile observation must carry to say which
  * send (credential and account) it came from. Pass the

package/dist/internal-types/commands/builtins.d.ts

@@ -48,6 +48,43 @@ export interface RoutingSectionOptions {
      */
     orderedVariants?: MenuChoice[];
     formerMainId?: string;
+    /**
+     * The vault accounts' routing order, for a plugin that can run in vault
+     * mode. Called on each build; return the order while the plugin routes
+     * through vault accounts and undefined otherwise. While it returns one, the
+     * section shows and sets the vault accounts' order (by the name the menu
+     * shows for each account) instead of the pool roster's. Wire it to
+     * `ClaustrumConsumer.snapshot()` and `ClaustrumConsumer.reorder`, or to
+     * `readVaultRoster` and `reorderVaultRoster` for a plugin without a
+     * consumer.
+     */
+    vaultOrder?: () => VaultRoutingOrder | undefined | Promise<VaultRoutingOrder | undefined>;
+}
+/**
+ * The order vault accounts are tried in, as the Routing section reads and
+ * sets it in vault mode. Shaped after `/claustrum`'s roster, without
+ * importing it, so the menu does not need the vault client.
+ */
+export interface VaultRoutingOrder {
+    /**
+     * Every vault roster row, in roster (routing) order: its route id and the
+     * name the plugin shows for that account (the roster row's `label`, or its
+     * email). Route ids are long and opaque, so the section shows and accepts
+     * labels; a route id is still accepted wherever a label is.
+     */
+    rows: readonly {
+        id: string;
+        label: string;
+    }[];
+    /**
+     * Sets the order. `ids` are route ids, every one exactly once. Wire it to
+     * `ClaustrumConsumer.reorder` or `reorderVaultRoster`, which refuse any
+     * other list without writing.
+     */
+    reorder(ids: readonly string[]): Promise<{
+        ids: readonly string[];
+        outcome: 'reordered' | 'unchanged';
+    }>;
 }
 export interface LimitsSectionOptions {
     /**

package/dist/internal-types/commands/index.d.ts

@@ -1,4 +1,4 @@
-export type { AccountsSectionOptions, LimitsSectionOptions, LoginOutcome, QuotaSectionOptions, RoutingSectionOptions, } from './builtins.js';
+export type { AccountsSectionOptions, LimitsSectionOptions, LoginOutcome, QuotaSectionOptions, RoutingSectionOptions, VaultRoutingOrder, } from './builtins.js';
 export { MENU_DISABLED_REASON } from './builtins.js';
 export type { CommandMenu, CommandMenuOptions, StoreSectionSlot, } from './menu.js';
 export { createCommandMenu, parseApplyRequest } from './menu.js';

package/dist/internal-types/setup/enroll.d.ts

@@ -1,7 +1,7 @@
 import { type MenuTerminal } from '../auth-menu/terminal.js';
 import type { SetupHost, SetupIO, SetupPlugin } from './types.js';
 /** Fixed text: no version, host or account detail, so it is safe to print anywhere. */
-export declare const 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.";
+export declare const UNSUPPORTED_VAULT_MESSAGE = "This Claustrum vault is too old to connect plugins. Run ck upgrade to move to Claustrum v0.2.0 or newer (read \"Upgrading from v0.1.3\" in its release notes first), or run setup without --claustrum to use local accounts.";
 /**
  * The longest setup waits, in total, for the vault to create the enrollment
  * request and for an operator to approve it. It matches the wait setup always

package/dist/native-custody.d.ts

@@ -203,7 +203,7 @@ export interface NativeCustodyInventory {
         }[];
     };
 }
-export type NativeCustodyErrorCode = 'closed' | 'not-enrolled' | 'invalid-token' | 'unavailable' | 'identity-changed' | 'identity-unasserted' | 'insufficient-validity' | 'invalid-material' | 'not-active' | 'route-unavailable' | 'route-declined' | 'no-receipt' | 'unsafe-file' | 'invalid-state' | 'wrong-consumer' | 'roster-busy' | 'host-slot-login' | 'host-slot-placeholder' | 'placeholder-refresh';
+export type NativeCustodyErrorCode = 'closed' | 'not-enrolled' | 'invalid-token' | 'unavailable' | 'identity-changed' | 'identity-unasserted' | 'insufficient-validity' | 'invalid-material' | 'not-active' | 'route-unavailable' | 'route-declined' | 'no-receipt' | 'unsafe-file' | 'invalid-state' | 'wrong-consumer' | 'roster-busy' | 'host-slot-login' | 'host-slot-placeholder' | 'placeholder-refresh' | 'invalid-order';
 export declare class NativeCustodyError extends Error {
     readonly code: NativeCustodyErrorCode;
     constructor(code: NativeCustodyErrorCode);

package/dist/native-local-publication.d.ts

@@ -0,0 +1,8 @@
+import type { NativeAccountMetadataPatch } from './native-account-view.ts';
+/** Share one replaceable bookkeeping mailbox per destination in this process, never for credential writes. */
+export declare function acquireNativeLocalPublisher(key: string): {
+    release(): void;
+    run: <T>(write: () => Promise<T>) => Promise<T>;
+    enqueue(key: string, patch: NativeAccountMetadataPatch, write: (patch: NativeAccountMetadataPatch) => Promise<boolean>): Promise<boolean>;
+    drain(): Promise<void>;
+};

package/dist/native-quota-observations.d.ts

@@ -7,6 +7,14 @@ export type NativeQuotaObservation = {
     entry: QuotaEntry;
     generalExhausted: boolean;
     quotaErrorClearedAt?: number;
+    /**
+     * Set on a response-header reading from a host that routes on native
+     * snapshots (OpenCode 2). The snapshot overlay then applies it while its
+     * detached save is still pending, as it does for poll readings. Header
+     * readings without it stay host-owned: OpenCode 1 applies its own routing
+     * and display rules to them.
+     */
+    routeBeforeSave?: boolean;
 };
 export declare function nativePollQuotaGenerallyExhausted(quota: OAuthQuotaSnapshot): boolean;
 export declare function nativeLocalQuotaLineage(binding: NativeLocalPoolBinding & {
@@ -22,5 +30,14 @@ export declare class NativeQuotaObservations extends Map<string, NativeQuotaObse
         clearAt?: number;
     } | undefined;
     publish(accountId: string, observation: NativeQuotaObservation, write: () => Promise<boolean>): Promise<void>;
+    /**
+     * Registers a response-header reading before its detached save starts, so
+     * routing in this process sees it while the save waits on file locks. A
+     * reading older than the one already held for the same credential lineage
+     * is not registered, so an older reading never replaces a newer one.
+     */
+    hold(accountId: string, observation: NativeQuotaObservation): boolean;
+    /** Forgets a held reading whose save was refused, unless a later reading already replaced it. */
+    forget(accountId: string, observation: NativeQuotaObservation): void;
     drain(): Promise<void>;
 }

package/dist/native-runtime.d.ts

@@ -104,10 +104,10 @@ export interface NativeRuntimeWriteHooks {
 /** This writer alone uses `<leaf>.native-runtime.<UUID v4>.partial`. */
 export declare function isNativeRuntimeStagingName(path: string, name: string): boolean;
 /**
- * This file has its own update lock. Account publishers also hold the locks
- * protecting the pool and, for vault accounts, the roster. They verify those
- * locks immediately before replacement. A process paused beyond a lock expiry
- * can overlap a new owner even with normal renewal.
+ * This file has its own update lock. Advisory account publishers recheck the
+ * pool or roster binding without taking its lock immediately before replacement;
+ * readers reject metadata whose binding no longer matches. Credential writers
+ * retain their separate ownership and custody checks.
  */
 export declare function updateNativeRuntime(path: string, storageId: string, change: (current: NativeRuntimeState) => NativeRuntimeState | Promise<NativeRuntimeState>, hooks?: NativeRuntimeWriteHooks): Promise<NativeRuntimeState>;
 /**

package/dist/pool-store.d.ts

@@ -15,8 +15,9 @@ export interface NativePoolStoreOptions extends Pick<OpenPoolStoreOptions, 'now'
     onLockEvent?: (event: NativeLockEvent) => void;
 }
 /**
- * These config/state locks also fence local account metadata against concurrent
- * credential changes. Legacy sidecar writers use different files and locks.
+ * These locks serialize pool transactions, including credential changes and
+ * quota publication. Runtime bookkeeping has its own lock and binding checks.
+ * Legacy sidecar writers use different files and locks.
  */
 export declare function nativePoolStoreLocks(paths: NativePoolStorePaths): readonly [{
     readonly path: string;

package/dist/sticky-routing.d.ts

@@ -148,6 +148,8 @@ export declare class StickySessionRouter {
         inputBytes: number;
         preferredAccountId?: string;
         excludeAccountIds?: ReadonlySet<string>;
+        /** Leave the current pin intact when selection cannot offer an account. */
+        preserveOnNoCandidate?: boolean;
     }): Promise<StickyRouteResolution | null>;
     clear(sessionId: string): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/anthropic-auth-core",
-  "version": "2.2.4",
+  "version": "2.2.6",
   "type": "module",
   "repository": {
     "type": "git",
@@ -30,7 +30,7 @@
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "@cortexkit/common-auth": "0.24.0"
+    "@cortexkit/common-auth": "0.25.0"
   },
   "dependencies": {
     "@cortexkit/claustrum-client": "0.12.0",