@cortexkit/anthropic-auth-core 2.2.2 → 2.2.4

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

@@ -1,4 +1,9 @@
 import { type ClaustrumClientOptions as ClaustrumEnrollmentClientOptions, type EnrollmentPollOutcome, type EnrollmentTokenFile, writeEnrollmentTokenFile } from '@cortexkit/claustrum-client';
+/**
+ * The code a vault without the enrollment ceremony answers a proposal with.
+ * Setup reports it as "this vault cannot connect plugins" instead of waiting.
+ */
+export declare const UNSUPPORTED_ENROLLMENT_CODE = "unknown_method";
 /**
  * Codes the vault's closed enrollment-refusal vocabulary marks permanent. The
  * client labels some module error frames transient/retry regardless, so the

package/dist/internal-types/fs/private-files.d.ts

@@ -5,6 +5,8 @@ type Backend = typeof import('@cortexkit/private-files');
 type Kind = 'file' | 'directory';
 /** Tests inject a backend here; production always imports the private-files package. */
 export declare function setPrivateFilesBackendForTest(api?: Backend): void;
+/** The fixed `reason` of a refusal because the Windows native addon did not load. */
+export declare const PRIVATE_FILES_UNAVAILABLE_REASON = "native-addon-unavailable";
 export declare class PrivateFileError extends Error {
     readonly path: string;
     readonly stage: string;

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

@@ -0,0 +1,34 @@
+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.";
+/**
+ * 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
+ * had (300 one-second polls), but is now measured on the clock: a vault that
+ * answers each request slowly can no longer stretch it.
+ */
+export declare const ENROLLMENT_WAIT_MS = 300000;
+/** Why a host's enrollment ended without a token. */
+export type HostNotEnrolledReason = 'connection-failed' | 'unsupported-vault' | 'request-not-created' | 'approval-pending' | 'refused' | 'invalid-request' | 'incomplete';
+/**
+ * Thrown when the enrollment ended without writing the host's token: the vault
+ * could not be reached, it cannot enroll plugins, it refused the request, it
+ * never created one, approval never came before setup stopped waiting, or
+ * the enrollment failed in some other way (`incomplete`).
+ * Setup can then report the host as not connected without reading its files.
+ * The message is fixed text built only from vetted values, never from what
+ * the vault or client threw. `lastErrorCode` is the last enrollment error code
+ * setup saw, from the vault or from the client's transport (for example
+ * `transport_error`), for diagnostics; it carries no secret.
+ */
+export declare class HostNotEnrolledError extends Error {
+    readonly reason: HostNotEnrolledReason;
+    readonly lastErrorCode?: string;
+    constructor(message: string, details: {
+        reason: HostNotEnrolledReason;
+        lastErrorCode?: string;
+    });
+}
+/** Enroll an independently revocable host; plugin callbacks choose its credential store and account permissions. */
+export declare function connectSetupHost(plugin: SetupPlugin, host: SetupHost, io: SetupIO, terminal: MenuTerminal, fence: () => Promise<void>): Promise<void>;

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

@@ -1,6 +1,7 @@
 export { AMBIGUOUS_OPENCODE_MESSAGE, runSetup } from './command.js';
 export { SetupCommandError, setupEnrollment } from './command-error.js';
 export { detectHosts, detectOpenCodeGeneration, findExecutableOnPath, openCodeDesktopMarkers, } from './detect.js';
+export { ENROLLMENT_WAIT_MS, HostNotEnrolledError, type HostNotEnrolledReason, UNSUPPORTED_VAULT_MESSAGE, } from './enroll.js';
 export { assertHostsStopped, createProcessFence, listSetupProcesses, ProcessFenceViolationError, ProcessInspectionError, type ProcessInspectionStep, } from './process-fence.js';
 export { type PlannedWrite, planOpenCodeRegistration, registerOpenCode, registerPi, updatePluginConfig, } from './register.js';
 export type { CommandResult, CommandRunner, HostDetection, OpenCodeGeneration, ProcessFence, SetupCallbackContext, SetupDetection, SetupEnrollmentOutcome, SetupEnvironment, SetupFileSystem, SetupHost, SetupHostEnrollment, SetupIO, SetupPlugin, SetupResult, } from './types.js';

package/dist/internal-types/setup/process-fence.d.ts

@@ -39,6 +39,13 @@ export declare function listSetupProcesses(runner?: CommandRunner, options?: {
      * a container this process can hold any small PID a fixture uses.
      */
     selfPid?: number;
+    /**
+     * Windows only: answer with one CIM query for the images a fence cares
+     * about (host programs, Node and Bun), returning image name, PID and
+     * command line together, instead of `tasklist` followed by a second CIM
+     * query. The result lists only those processes.
+     */
+    hostImagesOnly?: boolean;
 }): Promise<Array<{
     pid: number;
     command: string;

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

@@ -125,6 +125,11 @@ export interface SetupIO {
         handshakeTimeoutMs: number;
     }) => Promise<ClaustrumEnrollmentConnection>;
     wait?: (ms: number) => Promise<void>;
+    /**
+     * Monotonic milliseconds that bound the enrollment wait. Defaults to
+     * `performance.now`; tests pair it with `wait` to run a fake clock.
+     */
+    now?: () => number;
 }
 export interface HostDetection {
     installed: boolean;

package/dist/mid-conversation-output-config.d.ts

@@ -1,9 +1,10 @@
+import { PER_TURN_CONTROL_BETA } from './model-capabilities.ts';
 /**
- * Per-turn control beta that Claude Code sends on Opus 5.5, Sonnet 5.5,
- * Fable 5.1 and Haiku 5.5. It enables effort changes carried by empty
+ * Per-turn control beta that Claude Code sends on the models whose
+ * capability rows list it. It enables effort changes carried by empty
  * `role: "system"` messages on the eligible models below.
  */
-export declare const PER_TURN_CONTROL_BETA = "per-turn-control-2026-07-01";
+export { PER_TURN_CONTROL_BETA };
 export type AdaptiveEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
 export type MidConversationEffortTransition = {
     /** Number of assistant messages preceding the user boundary for this effort. */
@@ -12,30 +13,33 @@ export type MidConversationEffortTransition = {
 };
 export declare function normalizeAdaptiveEffort(value: unknown): AdaptiveEffort | undefined;
 /**
- * Models that require adaptive thinking for per-message effort: Opus 5.5
- * and Sonnet 5.5, including dated and `[1m]` context-window ids. Header
- * eligibility is separate; `sendsPerTurnControlBeta` follows Claude Code.
+ * Models that require adaptive thinking for per-message effort (capability
+ * `effortMarkers: "with-adaptive-thinking"`: Opus 5.5 and Sonnet 5.5),
+ * including dated and `[1m]` context-window ids. Header eligibility is
+ * separate; `sendsPerTurnControlBeta` follows Claude Code.
  */
 export declare function usesPerTurnControl(model: unknown): boolean;
 /**
- * Models whose OAuth requests carry `PER_TURN_CONTROL_BETA`: Opus 5.5 and
- * Sonnet 5.5, plus Fable 5.1 and Haiku 5.5, which Claude Code 2.1.302 also
- * sends it on. Sending the beta does not by itself make a model eligible for
- * effort markers; `supportsPerMessageEffort` decides that.
+ * Models whose OAuth requests carry `PER_TURN_CONTROL_BETA`: those whose
+ * Claude Code main beta list includes it (Opus 5.5, Sonnet 5.5, Fable 5.1 and
+ * Haiku 5.5 in Claude Code 2.1.302). Sending the beta does not by itself make
+ * a model eligible for effort markers; `supportsPerMessageEffort` decides that.
  */
 export declare function sendsPerTurnControlBeta(model: unknown): boolean;
 /**
  * Whether a request may move effort changes into empty system messages.
  *
- * Fable 5.1 is always eligible, whatever its thinking field says. Opus 5.5
- * and Sonnet 5.5 qualify only with adaptive thinking: Anthropic rejects a
- * differing per-message effort with HTTP 400 on Sonnet 5.5 `between_tools`,
- * and asks callers to use adaptive thinking to vary effort.
+ * Models with `effortMarkers: "always"` (Fable 5.1) are always eligible,
+ * whatever the thinking field says. Models with `"with-adaptive-thinking"`
+ * (Opus 5.5, Sonnet 5.5) qualify only with adaptive thinking: Anthropic
+ * rejects a differing per-message effort with HTTP 400 on Sonnet 5.5
+ * `between_tools`, and asks callers to use adaptive thinking to vary effort.
  */
 export declare function supportsPerMessageEffort(body: Record<string, unknown>): boolean;
 /**
  * The effort Anthropic applies when a request sets no `output_config.effort`:
- * `medium` on Opus 5.5 and Haiku 5.5, `high` on the other models.
+ * the capability row's default (`medium` on Opus 5.5 and Haiku 5.5), and
+ * `high` on models without a row.
  * A history entry without a recognized effort level uses this value.
  */
 export declare function defaultAdaptiveEffort(model: unknown): AdaptiveEffort;

package/dist/model-capabilities.d.ts

@@ -0,0 +1,136 @@
+import type { AdaptiveEffort } from './mid-conversation-output-config.ts';
+/**
+ * One row per Claude model that this plugin treats differently from an
+ * unknown model. Every per-model decision in Core (family checks, effort
+ * handling, Claude Code betas, turn-end notes, thinking-binding controls) and
+ * the per-model facts OpenCode and Pi read (catalogue entries, fallback
+ * eligibility) come from this table, so adding a model is one new row.
+ *
+ * Ids stay exact. A request model resolves to a row only when it equals the
+ * row's id (after removing OpenCode's `[1m]` context-window qualifier) or
+ * extends it as the row's `idSuffixes` allows; when several rows match, the
+ * longest id wins. A model that matches no row gets the defaults described on
+ * each field.
+ */
+/** Per-turn control beta Claude Code sends on the models whose rows list it. */
+export declare const PER_TURN_CONTROL_BETA = "per-turn-control-2026-07-01";
+/** Beta that allows turn-scoped system messages (`clear_at`). */
+export declare const TURN_END_NOTE_BETA = "mid-conversation-system-clear-at-2026-08-21";
+export declare const CLAUDE_CODE_FULL_AGENT_BETAS: readonly ["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', "mid-conversation-system-clear-at-2026-08-21", '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'];
+/**
+ * Claude Code's `anthropic-beta` list for each request class, before the
+ * body-dependent additions (turn-end note, structured outputs, fast mode and
+ * caller-supplied betas). `main` is a conversation turn; `title` is any other
+ * auxiliary request; `quota` is a one-token auxiliary probe.
+ */
+export type ClaudeCodeBetaLists = {
+    main: readonly string[];
+    title: readonly string[];
+    quota: readonly string[];
+};
+/** The lists for a model without its own row. */
+export declare const CLAUDE_CODE_DEFAULT_BETAS: ClaudeCodeBetaLists;
+export type ClaudeModelFamily = 'fable' | 'mythos' | 'opus' | 'sonnet' | 'haiku';
+/** Per-million-token USD prices. */
+export type ClaudeModelPricing = {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite5m: number;
+    cacheWrite1h: number;
+};
+/**
+ * Catalogue facts for a model the plugin registers itself in OpenCode and Pi,
+ * rather than taking from the host's own model list.
+ */
+export type ClaudeModelCatalogue = {
+    releaseDate: string;
+    contextWindow: number;
+    maxOutputTokens: number;
+    pricing: ClaudeModelPricing;
+    /** Higher prices for every token of a request above `inputTokensAbove` input tokens. */
+    longContext?: {
+        inputTokensAbove: number;
+        pricing: ClaudeModelPricing;
+    };
+};
+/** Source-model keys for content-filter recovery to Opus 4.8 in OpenCode. */
+export type ClaudeRefusalRecoveryFamily = 'fable-5' | 'fable-5-1' | 'opus-5' | 'opus-5-5';
+export type ClaudeModelCapabilities = {
+    /** Exact Anthropic model id. */
+    id: string;
+    /** Display name in host model pickers. */
+    name: string;
+    family: ClaudeModelFamily;
+    /**
+     * Longer ids that also resolve to this row: `any` accepts the id followed by
+     * `-` and anything (a date, `-fast`); `dated` accepts only `-YYYYMMDD`.
+     */
+    idSuffixes: 'any' | 'dated';
+    /** Shown as limited availability. */
+    limited?: true;
+    /** Absent when the model comes from the host's own catalogue. */
+    catalogue?: ClaudeModelCatalogue;
+    /**
+     * Thinking settings the API accepts. OpenCode's transform.ts and Pi's
+     * convert.ts still normalize thinking with per-family code; a test checks
+     * that OpenCode's result agrees with this list.
+     */
+    thinkingModes: readonly ('adaptive' | 'disabled' | 'between_tools')[];
+    /** The API rejects `tool_choice` of type `any` or `tool`, so it is removed. */
+    rejectsForcedToolChoice: boolean;
+    efforts: {
+        /**
+         * Efforts offered as host model variants with adaptive thinking. Absent:
+         * the host's own variants are left alone. Unknown models: absent.
+         */
+        variants?: readonly AdaptiveEffort[];
+        /** Anthropic's effort when a request sets none. Unknown models: `high`. */
+        default: AdaptiveEffort;
+    };
+    /**
+     * When effort changes may be sent as empty `role: "system"` messages:
+     * `always` (and top-level effort is then pinned on every request),
+     * `with-adaptive-thinking` (only when the request's thinking is adaptive),
+     * or `none`. Unknown models: `none`.
+     */
+    effortMarkers: 'none' | 'with-adaptive-thinking' | 'always';
+    /** Turn-end notes may be inserted. Unknown models: no. */
+    turnEndNote: boolean;
+    /** `thinking.block_binding` may be set. Unknown models: no. */
+    thinkingBindingControls: boolean;
+    /** Unknown models: `CLAUDE_CODE_DEFAULT_BETAS`. */
+    claudeCodeBetas: ClaudeCodeBetaLists;
+    /** OpenCode may ask Anthropic for its server-side safety fallback. */
+    serverSideFallback: boolean;
+    /** OpenCode recovers from a content-filter refusal on Opus 4.8 under this key. */
+    refusalRecoveryFamily?: ClaudeRefusalRecoveryFamily;
+    /**
+     * Model-scoped weekly quota this model draws from. Quota matching in
+     * accounts.ts and native-quota-codec.ts still matches the substrings
+     * `fable`/`mythos`; a test checks that they agree with this field.
+     */
+    scopedQuota?: 'fable' | 'mythos';
+    /**
+     * Fast mode (`speed: "fast"`) is offered. `isFastModeSupportedModel` also
+     * keeps its older prefix rule for ids outside this table.
+     */
+    fastMode: boolean;
+};
+export declare const CLAUDE_MODEL_CAPABILITIES: readonly ClaudeModelCapabilities[];
+/** Remove OpenCode's context-window qualifier before model-family checks. */
+export declare function normalizeAnthropicModelId(model: string): string;
+/**
+ * The row for a request model, or `undefined` for a model this plugin does
+ * not special-case. See the table's description for how ids match.
+ */
+export declare function resolveClaudeModelCapabilities(model: unknown): ClaudeModelCapabilities | undefined;
+/** The row for an exact model id; throws when the table has no such row. */
+export declare function getClaudeModelCapabilities(id: string): ClaudeModelCapabilities;
+/** Catalogue facts for an exact model id; throws when the row has none. */
+export declare function getClaudeModelCatalogue(id: string): ClaudeModelCatalogue;
+/**
+ * Whether effort is pinned in top-level `output_config` on every request,
+ * even one without an effort change.
+ */
+export declare function pinsEffortOnEveryRequest(model: unknown): boolean;

package/dist/models.d.ts

@@ -1,3 +1,5 @@
+import { normalizeAnthropicModelId } from './model-capabilities.ts';
+export { normalizeAnthropicModelId };
 export declare const CLAUDE_FABLE_5_MODEL_ID = "claude-fable-5";
 export declare const CLAUDE_MYTHOS_5_MODEL_ID = "claude-mythos-5";
 export declare const CLAUDE_FABLE_5_1_MODEL_ID = "claude-fable-5-1";
@@ -9,8 +11,6 @@ export declare const CLAUDE_MYTHOS_5_1_MODEL_ID = "claude-mythos-5-1";
  * above so per-million-token cost estimation does not conflate families.
  */
 export declare const CLAUDE_HAIKU_4_5_MODEL_ID = "claude-haiku-4-5";
-/** Remove OpenCode's context-window qualifier before model-family checks. */
-export declare function normalizeAnthropicModelId(model: string): string;
 /**
  * Per-million-token USD pricing for Haiku 4.5. Used to project the cumulative
  * cost of prime requests from persisted usage counters — never persisted on
@@ -27,24 +27,13 @@ export declare const CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING: {
     readonly type: 'adaptive';
     readonly display: 'summarized';
 };
-export declare const CLAUDE_FABLE_MYTHOS_5_PRICING: {
-    readonly input: 10;
-    readonly output: 50;
-    readonly cacheRead: 1;
-    readonly cacheWrite5m: 12.5;
-    readonly cacheWrite1h: 20;
-};
-export declare const CLAUDE_FABLE_MYTHOS_5_1_PRICING: {
-    readonly input: 10;
-    readonly output: 50;
-    readonly cacheRead: 0.25;
-    readonly cacheWrite5m: 12.5;
-    readonly cacheWrite1h: 20;
-};
-export declare const CLAUDE_FABLE_MYTHOS_5_CONTEXT_WINDOW = 1000000;
-export declare const CLAUDE_FABLE_MYTHOS_5_MAX_OUTPUT_TOKENS = 128000;
-export declare const CLAUDE_FABLE_MYTHOS_5_RELEASE_DATE = "2026-06-09";
-export declare const CLAUDE_FABLE_MYTHOS_5_1_RELEASE_DATE = "2026-09-01";
+export declare const CLAUDE_FABLE_MYTHOS_5_PRICING: import("./model-capabilities.ts").ClaudeModelPricing;
+export declare const CLAUDE_FABLE_MYTHOS_5_1_PRICING: import("./model-capabilities.ts").ClaudeModelPricing;
+export declare const CLAUDE_FABLE_MYTHOS_5_CONTEXT_WINDOW: number;
+export declare const CLAUDE_FABLE_MYTHOS_5_MAX_OUTPUT_TOKENS: number;
+export declare const CLAUDE_FABLE_MYTHOS_5_RELEASE_DATE: string;
+export declare const CLAUDE_FABLE_MYTHOS_5_1_RELEASE_DATE: string;
+/** Name and availability of each Fable and Mythos id, from the capability table. */
 export declare const CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS: Record<ClaudeFableMythos5ModelId, {
     id: ClaudeFableMythos5ModelId;
     name: string;
@@ -62,10 +51,14 @@ export declare const CLAUDE_FABLE_MYTHOS_5_1_MODEL_SPECS: {
         limited?: boolean;
     };
 };
+/**
+ * Any Fable or Mythos row. An unknown id that extends a known Fable or Mythos
+ * id with `-` (for example `claude-fable-5-5`) resolves to the shorter row.
+ */
 export declare function isClaudeFableOrMythos5Model(model: unknown): boolean;
 export declare function isClaudeFableOrMythos51Model(model: unknown): boolean;
 export declare function isClaudeFable51Model(model: unknown): boolean;
-export declare function getClaudeFableMythos5ReleaseDate(model: unknown): "2026-06-09" | "2026-09-01";
+export declare function getClaudeFableMythos5ReleaseDate(model: unknown): string;
 export declare const CLAUDE_SONNET_5_MODEL_ID = "claude-sonnet-5";
 /**
  * Sonnet 5 enables adaptive thinking by default but ships `display: "omitted"`,
@@ -79,41 +72,23 @@ export declare const CLAUDE_SONNET_5_ADAPTIVE_THINKING: {
 };
 export declare function isClaudeSonnet5Model(model: unknown): boolean;
 export declare const CLAUDE_SONNET_5_5_MODEL_ID = "claude-sonnet-5-5";
-export declare const CLAUDE_SONNET_5_5_RELEASE_DATE = "2026-09-28";
-export declare const CLAUDE_SONNET_5_5_CONTEXT_WINDOW = 1000000;
-export declare const CLAUDE_SONNET_5_5_MAX_OUTPUT_TOKENS = 128000;
-export declare const CLAUDE_SONNET_5_5_PRICING: {
-    readonly input: 2;
-    readonly output: 10;
-    readonly cacheRead: 0.2;
-    readonly cacheWrite5m: 2.5;
-    readonly cacheWrite1h: 4;
-};
+export declare const CLAUDE_SONNET_5_5_RELEASE_DATE: string;
+export declare const CLAUDE_SONNET_5_5_CONTEXT_WINDOW: number;
+export declare const CLAUDE_SONNET_5_5_MAX_OUTPUT_TOKENS: number;
+export declare const CLAUDE_SONNET_5_5_PRICING: import("./model-capabilities.ts").ClaudeModelPricing;
 export declare const CLAUDE_SONNET_5_5_ADAPTIVE_THINKING: {
     readonly type: 'adaptive';
     readonly display: 'summarized';
 };
 export declare function isClaudeSonnet55Model(model: unknown): boolean;
 export declare const CLAUDE_HAIKU_5_5_MODEL_ID = "claude-haiku-5-5";
-export declare const CLAUDE_HAIKU_5_5_RELEASE_DATE = "2026-10-07";
-export declare const CLAUDE_HAIKU_5_5_CONTEXT_WINDOW = 1000000;
-export declare const CLAUDE_HAIKU_5_5_MAX_OUTPUT_TOKENS = 128000;
-export declare const CLAUDE_HAIKU_5_5_LONG_CONTEXT_THRESHOLD = 100000;
-export declare const CLAUDE_HAIKU_5_5_PRICING: {
-    readonly input: 0.1;
-    readonly output: 0.5;
-    readonly cacheRead: 0.01;
-    readonly cacheWrite5m: 0.125;
-    readonly cacheWrite1h: 0.2;
-};
+export declare const CLAUDE_HAIKU_5_5_RELEASE_DATE: string;
+export declare const CLAUDE_HAIKU_5_5_CONTEXT_WINDOW: number;
+export declare const CLAUDE_HAIKU_5_5_MAX_OUTPUT_TOKENS: number;
+export declare const CLAUDE_HAIKU_5_5_LONG_CONTEXT_THRESHOLD: number;
+export declare const CLAUDE_HAIKU_5_5_PRICING: import("./model-capabilities.ts").ClaudeModelPricing;
 /** Haiku 5.5's higher rates apply to every token in requests with more than 100K input tokens, including cached input. */
-export declare const CLAUDE_HAIKU_5_5_LONG_CONTEXT_PRICING: {
-    readonly input: 0.5;
-    readonly output: 2.5;
-    readonly cacheRead: 0.05;
-    readonly cacheWrite5m: 0.625;
-    readonly cacheWrite1h: 1;
-};
+export declare const CLAUDE_HAIKU_5_5_LONG_CONTEXT_PRICING: import("./model-capabilities.ts").ClaudeModelPricing;
 export declare const CLAUDE_HAIKU_5_5_ADAPTIVE_THINKING: {
     readonly type: 'adaptive';
     readonly display: 'summarized';
@@ -134,16 +109,10 @@ export declare const CLAUDE_OPUS_5_ADAPTIVE_THINKING: {
 };
 export declare function isClaudeOpus5Model(model: unknown): boolean;
 export declare const CLAUDE_OPUS_5_5_MODEL_ID = "claude-opus-5-5";
-export declare const CLAUDE_OPUS_5_5_RELEASE_DATE = "2026-09-18";
-export declare const CLAUDE_OPUS_5_5_CONTEXT_WINDOW = 1000000;
-export declare const CLAUDE_OPUS_5_5_MAX_OUTPUT_TOKENS = 128000;
-export declare const CLAUDE_OPUS_5_5_PRICING: {
-    readonly input: 4;
-    readonly output: 20;
-    readonly cacheRead: 0.2;
-    readonly cacheWrite5m: 5;
-    readonly cacheWrite1h: 8;
-};
+export declare const CLAUDE_OPUS_5_5_RELEASE_DATE: string;
+export declare const CLAUDE_OPUS_5_5_CONTEXT_WINDOW: number;
+export declare const CLAUDE_OPUS_5_5_MAX_OUTPUT_TOKENS: number;
+export declare const CLAUDE_OPUS_5_5_PRICING: import("./model-capabilities.ts").ClaudeModelPricing;
 export declare const CLAUDE_OPUS_5_5_ADAPTIVE_THINKING: {
     readonly type: 'adaptive';
     readonly display: 'summarized';

package/dist/native-enrollment-authority.d.ts

@@ -1,4 +1,23 @@
 import { enrollmentAuthority, readClaustrumEnrollmentStatus } from "./internal-types/claustrum/index.js";
+import { NativeCustodyError } from './native-custody.ts';
+/**
+ * Shown instead of `Native custody refused: invalid-token` when the
+ * enrollment files could not be read because the private-files backend did
+ * not load. Older common-auth passes on the backend's
+ * `unsupported-filesystem`, which is what every private-file check returns on
+ * Windows when the @cortexkit/private-files native addon did not load; newer
+ * common-auth refuses with `ERR_PRIVATE_FILES_UNAVAILABLE`. Either way the
+ * enrollment itself may be fine.
+ */
+export declare const 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.";
+/**
+ * The enrollment refusal for a private-files backend that did not load. It
+ * keeps the `invalid-token` code, so every caller that branches on the code
+ * treats it exactly as before; only the message names the cause and remedy.
+ */
+export declare class NativePrivateFilesUnavailableError extends NativeCustodyError {
+    constructor();
+}
 /** Enrollment files, not account settings, choose the host's credential source. */
 export declare function readNativeEnrollmentMode(host: 'opencode' | 'pi', env?: NodeJS.ProcessEnv, dependencies?: {
     enrollmentAuthority: typeof enrollmentAuthority;

package/dist/native-ui.d.ts

@@ -1,4 +1,4 @@
-import { type CommandInvocation, type CommandMenu } from "./internal-types/commands/index.js";
+import { type CommandApplyResult, type CommandInvocation, type CommandMenu } from "./internal-types/commands/index.js";
 export type { CommandApplyRequest, CommandApplyResult, CommandDialogPayload, CommandInvocation, CommandMenu, CommandMenuModel, KnobValue, KnobValues, MenuAction, MenuItem, MenuKnob, MenuSection, NotifyKind, SectionSlot, } from "./internal-types/commands/index.js";
 export { parseApplyRequest, runPiCommandMenu, } from "./internal-types/commands/index.js";
 import { type NativeMenuDispatch, type NativeVaultDisconnect } from './native-menu-executor.ts';
@@ -36,6 +36,15 @@ export interface NativeUiOptions {
     /** The host sets this flag; RPC callers cannot declare themselves interactive. */
     readonly interactive: boolean;
 }
+/**
+ * A menu result as Core returns it. After a successful OAuth start,
+ * `authorizationUrl` carries the one checked sign-in link from `text` as its
+ * own field, so a host can show it in a dialog of its own instead of finding
+ * it in the message text. Every other result leaves it out.
+ */
+export type NativeCommandApplyResult = CommandApplyResult & {
+    readonly authorizationUrl?: string;
+};
 /**
  * Builds the Claude menu from the supported commands for OpenCode or Pi.
  * Shared renderers display it, but each submitted action still goes through

package/dist/pool-authority.d.ts

@@ -142,6 +142,16 @@ export declare function readNativeMigrationJournal(paths: NativePoolPaths, owner
  * that admits requests from the journal uses this one predicate.
  */
 export declare function nativeMigrationAuthorityPhase(journal: NativeMigrationJournal | undefined): 'committed' | 'retired' | undefined;
+/**
+ * Whether a finished legacy import may be replaced by a fresh import of a
+ * later OpenCode login. A first OpenCode 1 setup with no login finishes a
+ * legacy import of nothing instead of recording empty-init (only OpenCode 2
+ * setup records empty-init). Such a journal stands in for empty-init only when
+ * it is retired with no requested or completed vault switch; callers must still
+ * prove the pool holds no account data, so a pool with accounts is never
+ * re-imported.
+ */
+export declare function nativeJournalMayAdoptLaterHostLogin(journal: NativeMigrationJournal | undefined, host: 'opencode' | 'pi'): journal is NativeLegacyMigrationJournal;
 /** An empty or readable store is not proof that the offline authority flip completed. */
 export declare function requireNativePoolAuthority(paths: NativePoolPaths): Promise<NativeMigrationJournal>;
 interface JournalHooks {
@@ -154,7 +164,12 @@ interface JournalHooks {
     onWriteStep?: (step: 'before-write' | 'after-write', journal: NativeMigrationJournal) => Promise<void>;
 }
 /** Migration resume retains the original digests and resolved paths so a retry cannot adopt changed inputs or redirect writes. */
-export declare function beginNativeMigration(paths: NativePoolPaths, input: NativeMigrationInput, hooks?: JournalHooks): Promise<NativeLegacyMigrationJournal>;
+export declare function beginNativeMigration(paths: NativePoolPaths, input: NativeMigrationInput, hooks?: JournalHooks, 
+/**
+ * The retired journal a fresh v5 import replaces, as read by the caller.
+ * The write refuses unless the journal on disk still equals it exactly.
+ */
+replaces?: NativeLegacyMigrationJournal): Promise<NativeLegacyMigrationJournal>;
 /** Save the expected host-auth entry and routing digests together before changing files, so recovery can recognize completed writes. */
 export declare function recordNativeMigrationExpectations(paths: NativePoolPaths, expectations: NativeMigrationExpectations, hooks?: JournalHooks): Promise<NativeLegacyMigrationJournal>;
 /**

package/dist/turn-end-note.d.ts

@@ -1,9 +1,10 @@
-export declare const TURN_END_NOTE_BETA = "mid-conversation-system-clear-at-2026-08-21";
+import { TURN_END_NOTE_BETA } from './model-capabilities.ts';
+export { TURN_END_NOTE_BETA };
 export declare const TURN_END_NOTE_MIN_VISIBLE_CHARACTERS = 350;
 export declare const 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.";
 /**
- * Model families that get turn-end notes. The note is a turn-scoped system
- * message (`clear_at: "next_user_message"`), which needs the
+ * Models that get turn-end notes (capability `turnEndNote`). The note is a
+ * turn-scoped system message (`clear_at: "next_user_message"`), which needs the
  * mid-conversation-system-clear-at beta that Claude Code sends for these models.
  */
 export declare function supportsTurnEndNote(model: unknown): boolean;

package/package.json

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