@north-light/crouter 0.3.160 → 0.3.162

package/dist/core/runtime/launch.d.ts

@@ -3,17 +3,6 @@ import type { NodeMeta, LaunchSpec, Mode, Lifecycle } from '../canvas/index.js';
 import type { ModelProvider, ModelStrength, ScopeConfig } from '../../types.js';
 export { OPENAI_PROVIDER_ENV, configuredLadderProviders, inferPortableModelSelection } from './model-selection.js';
 export type { PortableModelSelection } from './model-selection.js';
-export interface EquivalentProviderModel {
-    fromProvider: ModelProvider;
-    toProvider: ModelProvider;
-    strength: ModelStrength;
-    model: string;
-}
-/** Map a concrete ladder model back to its provider×strength cell, then return
- *  the other configured provider's model at the same strength. `failedProviders`
- *  is per-turn state: once a provider has produced a retryable outage error, do
- *  not bounce back to it or keep reattempting the same failed provider. */
-export declare function equivalentOtherProviderModel(currentModel: string, failedProviders?: ReadonlySet<ModelProvider>): EquivalentProviderModel | null;
 /** True when an explicit model token is QUALIFIED — a `<provider>/<model-id>`
  *  or `<provider>/<tier>` raw token — the structural marker of a concrete exact
  *  pick. Deliberately provider-agnostic: a real registry provider namespace
@@ -31,6 +20,10 @@ export declare function isProviderPinnedModelToken(model: string): boolean;
  *  ladder the running build ships, so they never freeze a stale concrete
  *  model id to disk. Mirrors `normalizeModel`'s branch structure exactly. */
 export declare function isPortableModelToken(model: string): boolean;
+export declare function logicalModelIntent(model: string, ladders?: ScopeConfig['modelLadders']): {
+    family: string;
+    strength: ModelStrength;
+} | undefined;
 export declare function normalizeModel(model: string, ladders?: ScopeConfig['modelLadders']): string;
 /** The interleaved model-ladder cycle Alt+M / Alt+Shift+M walks: for each strength tier
  *  from strongest to weakest, each offered provider before descending — anthropic/ultra,
@@ -95,6 +88,11 @@ export declare function buildLaunchSpec(kind: string, mode: Mode, opts: {
      *  promote/config, where `opts.model`'s shape IS the raw token and
      *  legitimately re-decides the pin. */
     modelProviderPinned?: boolean;
+    /** Preserved intent from an existing launch recipe when rebuilding it. */
+    modelIntent?: {
+        family: string;
+        strength: ModelStrength;
+    };
     /** Exact-consult launch: pass the captured `provider/id:thinking` spec
      *  verbatim as `launch.model`, skipping `floorReviewModel`/`normalizeModel`
      *  entirely (avoids any tier-collision reinterpretation). `opts.model` MUST

package/dist/core/runtime/launch.js

@@ -43,26 +43,7 @@ export { OPENAI_PROVIDER_ENV, configuredLadderProviders, inferPortableModelSelec
 function ladderFor(provider, ladders = modelLadders()) {
     return ladders[provider];
 }
-// Automatic turn-time fallback ordering + strength ranking stay local to the
-// launch recipe (not needed by the pure selection primitives).
-const FALLBACK_PROVIDER_KEYS = ['anthropic', 'openai'];
 const MODEL_STRENGTH_RANK = { light: 0, medium: 1, strong: 2, ultra: 3 };
-/** Map a concrete ladder model back to its provider×strength cell, then return
- *  the other configured provider's model at the same strength. `failedProviders`
- *  is per-turn state: once a provider has produced a retryable outage error, do
- *  not bounce back to it or keep reattempting the same failed provider. */
-export function equivalentOtherProviderModel(currentModel, failedProviders = new Set()) {
-    const ladders = modelLadders();
-    const cell = findLadderCell(normalizeModel(currentModel), ladders, FALLBACK_PROVIDER_KEYS);
-    if (cell === null)
-        return null;
-    if (failedProviders.has(cell.provider))
-        return null;
-    const toProvider = cell.provider === 'anthropic' ? 'openai' : 'anthropic';
-    if (failedProviders.has(toProvider))
-        return null;
-    return { fromProvider: cell.provider, toProvider, strength: cell.strength, model: ladders[toProvider][cell.strength] };
-}
 /** Back-map a concrete model spec to the provider×strength ladder cell it came
  *  from. Two cells may legitimately name the SAME model id at different thinking
  *  levels (the openai ladder's `ultra` and `strong` are both gpt-5.6-sol, at
@@ -147,7 +128,8 @@ function floorReviewModel(kind, requestedModel, kindModel, ladders = modelLadder
  *  (`ultra`) or bare family alias (`opus`/`sonnet`/`haiku`) has no `/` and
  *  stays unpinned. */
 export function isProviderPinnedModelToken(model) {
-    return model.includes('/');
+    // Logical family/strength refs express a preference, not provider exclusivity.
+    return model.includes('/') && !isPortableModelToken(model);
 }
 /** True when `model` is a PORTABLE ladder token — a bare strength/alias
  *  (`ultra`, `normal`, `opus`, …) or a `anthropic|openai / strength` pair —
@@ -165,6 +147,16 @@ export function isPortableModelToken(model) {
     }
     return STRENGTH_ALIASES[model] !== undefined || model === 'opus' || model === 'sonnet' || model === 'haiku';
 }
+export function logicalModelIntent(model, ladders = modelLadders()) {
+    const strength = modelTokenStrength(model);
+    if (strength === null)
+        return undefined;
+    if (model.includes('/'))
+        return { family: model.slice(0, model.indexOf('/')), strength };
+    if (model === 'opus' || model === 'sonnet' || model === 'haiku')
+        return { family: 'anthropic', strength };
+    return { family: defaultProvider(ladders), strength };
+}
 export function normalizeModel(model, ladders = modelLadders()) {
     // 1. Qualified provider/rest.
     if (model.includes('/')) {
@@ -265,10 +257,12 @@ export function buildLaunchSpec(kind, mode, opts) {
     const ladders = merged.modelLadders;
     const kindModel = mode === 'orchestrator' ? kindConfig?.orchestratorModel ?? kindConfig?.model : kindConfig?.model;
     const chosenModel = opts.modelExact === true ? opts.model : floorReviewModel(kind, opts.model, kindModel, ladders);
+    const intent = opts.modelExact === true ? undefined : (opts.modelIntent ?? (chosenModel !== undefined ? logicalModelIntent(chosenModel, ladders) : undefined));
     const launch = {
         model: opts.modelExact === true
             ? chosenModel
             : (chosenModel !== undefined ? normalizeModel(chosenModel, ladders) : undefined),
+        modelIntent: intent,
         modelProviderPinned: opts.modelProviderPinned !== undefined
             ? opts.modelProviderPinned
             : opts.model !== undefined && isProviderPinnedModelToken(opts.model),
@@ -276,7 +270,7 @@ export function buildLaunchSpec(kind, mode, opts) {
         tools: kindConfig?.tools ?? [],
         extensions: mergeCanvasExtensions([...CANVAS_EXTENSIONS, ...(kindConfig?.extensions ?? [])]),
         systemPrompt: LAUNCH_SYSTEM_PROMPT,
-        env: { ...(opts.extraEnv ?? {}) },
+        env: { ...(opts.extraEnv ?? {}), ...(intent ? { CRTR_MODEL_INTENT: `${intent.family}/${intent.strength}` } : {}) },
     };
     return { launch, lifecycle: opts.lifecycle };
 }

package/dist/core/runtime/managed-provider-cooling.d.ts

@@ -4,20 +4,6 @@ import type { AssistantMessageDiagnostic } from "@earendil-works/pi-ai";
 export declare const MANAGED_PROVIDER_COOLING_DIAGNOSTIC = "crtr:managed-provider-cooling";
 /** Stable error code so a caller can recognize the typed error without message parsing. */
 export declare const MANAGED_PROVIDER_COOLING_CODE = "managed_provider_cooling";
-/**
- * Broker-owned, live policy exposed to the jiti-loaded provider-rotation
- * extension through its UI context. A callback (rather than a boot-time value)
- * is required because an attached viewer can pin or unpin the running broker
- * with `set_model`; the very next provider attempt must observe that decision.
- */
-export declare const MANAGED_PROVIDER_ROTATION_POLICY_UI: unique symbol;
-export type ManagedProviderRotationPolicy = {
-    allowCrossProviderFallback: boolean;
-    reason?: "provider-pinned" | "model-exact";
-};
-export type ManagedProviderRotationPolicyControl = () => ManagedProviderRotationPolicy;
-/** Non-broker/test hosts retain the historical permissive fallback policy. */
-export declare function readManagedProviderRotationPolicy(ui: unknown): ManagedProviderRotationPolicy;
 /** Every managed provider pool tried this turn is cooling; `rateLimitedUntil` is
  *  the earliest future deadline (epoch ms) across those pools. */
 export declare class ManagedProviderCoolingError extends Error {

package/dist/core/runtime/managed-provider-cooling.js

@@ -16,25 +16,6 @@
 export const MANAGED_PROVIDER_COOLING_DIAGNOSTIC = "crtr:managed-provider-cooling";
 /** Stable error code so a caller can recognize the typed error without message parsing. */
 export const MANAGED_PROVIDER_COOLING_CODE = "managed_provider_cooling";
-/**
- * Broker-owned, live policy exposed to the jiti-loaded provider-rotation
- * extension through its UI context. A callback (rather than a boot-time value)
- * is required because an attached viewer can pin or unpin the running broker
- * with `set_model`; the very next provider attempt must observe that decision.
- */
-export const MANAGED_PROVIDER_ROTATION_POLICY_UI = Symbol.for("@crouton-kit/crtr:managed-provider-rotation-policy");
-/** Non-broker/test hosts retain the historical permissive fallback policy. */
-export function readManagedProviderRotationPolicy(ui) {
-    const control = ui?.[MANAGED_PROVIDER_ROTATION_POLICY_UI];
-    if (typeof control !== "function")
-        return { allowCrossProviderFallback: true };
-    try {
-        return control();
-    }
-    catch {
-        return { allowCrossProviderFallback: true };
-    }
-}
 /** Every managed provider pool tried this turn is cooling; `rateLimitedUntil` is
  *  the earliest future deadline (epoch ms) across those pools. */
 export class ManagedProviderCoolingError extends Error {

package/dist/core/runtime/model-swap.js

@@ -65,6 +65,12 @@ export function persistDormantModel(nodeId, spec, pinned) {
     const meta = getNode(nodeId);
     if (meta === null)
         return;
-    const launch = meta.launch !== undefined ? { ...meta.launch, model: spec, modelProviderPinned: pinned } : undefined;
+    const launch = meta.launch === undefined
+        ? undefined
+        : (() => {
+            const { modelIntent: _modelIntent, env, ...rest } = meta.launch;
+            const { CRTR_MODEL_INTENT: _intentEnv, ...remainingEnv } = env;
+            return { ...rest, model: spec, modelProviderPinned: pinned, env: remainingEnv };
+        })();
     updateNode(nodeId, { model_override: spec, ...(launch !== undefined ? { launch } : {}) });
 }

package/dist/core/runtime/naming.js

@@ -35,10 +35,12 @@ const PROMPT_CAP = 2000;
  *  provider's own cold start; naming is async and off the spawn path, so a slow
  *  call delays only the label, never the node. */
 const NAME_TIMEOUT_MS = 45_000;
-/** Nerd Font glyphs offered to the namer as EXAMPLES, never as a closed set —
- *  the model may pick any Nerd Font character it thinks fits better. Grouped by
- *  the kind of work they read as, so the model generalizes from the grouping
- *  instead of pattern-matching a lookup table. */
+/** Nerd Font glyphs offered to the namer as a FALLBACK set for when a task has
+ *  no concrete subject — never a closed set, and deliberately introduced to the
+ *  model as the generic tier so it reaches for a real noun first. Measured
+ *  against 20 real prompts, an unqualified example list anchors the model onto
+ *  it almost totally; the two-step rule in the system prompt is what pulls picks
+ *  back out to the actual subject. */
 const ICON_EXAMPLES = [
     'fixing/diagnosis: U+F188 bug, U+F0F1 stethoscope, U+F06D fire, U+F071 warning',
     'building/changing code: U+F0AD wrench, U+F067 plus, U+F121 code, U+F085 cogs, U+F021 refresh',
@@ -58,16 +60,21 @@ const NAME_SYSTEM_PROMPT = 'You name coding-agent work sessions. The name is a l
     'hyphens (e.g. `refactor-auth-token-flow`, `add-csv-export-endpoint`). No punctuation, ' +
     'quotes, or prose.\n' +
     '- `icon`: ONE Nerd Font glyph, written as its codepoint in `U+XXXX` form (e.g. ' +
-    '`U+F188`). ANY Nerd Font codepoint is allowed — the whole Font Awesome, Material, ' +
-    'Devicons, Octicons and Codicons ranges are available, so reach for the glyph that ' +
-    'actually depicts this work rather than settling for one of the examples below. ' +
-    'Emit a codepoint, not a name like `nf-fa-bug`, and not an emoji.\n\n' +
-    'Pick the glyph whose depicted object a person would associate with this work at a ' +
-    'glance. Prefer the concrete subject (a database, a lock, a browser, a specific ' +
-    "technology's logo) over a generic verb glyph when the task has one; fall back to the " +
-    'activity (fixing, building, testing) otherwise. Never reuse a generic gear for ' +
-    'everything.\n\n' +
-    'Examples of what reads well, by kind of work:\n' +
+    '`U+F188`). Emit a codepoint, not a name like `nf-fa-bug`, and not an emoji.\n\n' +
+    'Choosing the icon — work through it in this order:\n' +
+    '1. Name the concrete SUBJECT of the task: the thing being acted on. A font, a ' +
+    'trash can, an account, a browser tab, a clock, an invoice, a map, a robot, a specific ' +
+    "technology's logo. If a glyph depicts that thing, use it. This is almost always the " +
+    'better icon, because it is what distinguishes this session from every other one.\n' +
+    '2. Only when the task has no depictable subject, fall back to the ACTIVITY (fixing, ' +
+    'documenting, testing) using the generic set below.\n\n' +
+    'ANY Nerd Font codepoint is allowed and the set is enormous — the whole Font Awesome ' +
+    'range, Devicons and Seti technology logos, Octicons, Codicons, Weather, and the ' +
+    'thousands of Material Design nouns above U+F0001. Reach into it. The examples below ' +
+    'are the generic tier, NOT a menu: if your pick came from them and the task had a real ' +
+    'subject, you picked wrong. Never reuse a generic gear, wrench, or bug for a task that ' +
+    'is actually about something.\n\n' +
+    'Generic fallback set, by kind of work:\n' +
     ICON_EXAMPLES;
 /** Put the raw task text FIRST in a delimited block, then the instruction, so the
  *  model reads the content before being told what to do and never mistakes the

package/dist/core/runtime/promote.js

@@ -59,6 +59,7 @@ function reshapeNode(nodeId, opts = {}, beforePersist) {
         // just re-supplies the current value for resolution, not a new user
         // choice — so carry the node's existing pin verbatim instead.
         modelProviderPinned: opts.model === undefined ? node.launch?.modelProviderPinned : undefined,
+        modelIntent: opts.model === undefined ? node.launch?.modelIntent : undefined,
         // Resolve kind/ladder config against the NODE's own cwd + profile, not
         // this process's ambient scope.
         cwd: node.cwd,

package/dist/core/subscription-state.d.ts

@@ -1,11 +1,13 @@
-import type { ThinkingLevel } from "@earendil-works/pi-ai";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 export declare const ANTHROPIC_PROVIDER_ID = "anthropic";
 export declare const OPENAI_CODEX_PROVIDER_ID = "openai-codex";
 export declare const INVALID_REFRESH_TOKEN_BACKOFF_MS: number;
 export type ManagedProviderId = typeof ANTHROPIC_PROVIDER_ID | typeof OPENAI_CODEX_PROVIDER_ID;
-export type LadderProviderId = "anthropic" | "openai";
 export type ModelStrength = "ultra" | "strong" | "medium" | "light";
+export type RotationConfig = {
+    defaultFallbackStrength?: ModelStrength;
+    revertWhenAvailable?: boolean;
+};
+type RotationConfigUpdate = RotationConfig;
 export type SubscriptionCredential = {
     label: string;
     refresh: string;
@@ -17,27 +19,6 @@ export type SubscriptionCredential = {
     authFailure?: "invalid_grant";
     accountId?: string;
 };
-export type ModelRef = {
-    providerId: ManagedProviderId;
-    modelId: string;
-};
-export type RotationConfig = {
-    defaultFallbackStrength?: ModelStrength;
-    revertWhenAvailable?: boolean;
-    preferredModel?: ModelRef;
-};
-type RotationConfigUpdate = {
-    defaultFallbackStrength?: ModelStrength;
-    revertWhenAvailable?: boolean;
-    preferredModel?: ModelRef | null;
-};
-export type FallbackTarget = {
-    providerId: ManagedProviderId;
-    modelId: string;
-    label: string;
-    strength: ModelStrength;
-    thinkingLevel?: ThinkingLevel;
-};
 /** A concrete provider/model considered for either broker launch or turn-time rotation. */
 export type ProviderCandidate = {
     providerId: string;
@@ -49,6 +30,12 @@ export type ProviderCandidate = {
     coolingUntil?: number;
     /** False when this candidate may only be selected by an explicit request, never as fallback. */
     automaticFallback?: boolean;
+    /** Route provenance carried through selection diagnostics. */
+    routeId?: string;
+    credentialSource?: string;
+    family?: string;
+    strength?: ModelStrength;
+    rank?: number;
 };
 export type ProviderCandidateRejection = "unregistered" | "non-managed-fallback" | "unauthenticated" | "cooling";
 /**
@@ -72,12 +59,6 @@ export declare function resolveProviderCandidates(candidates: readonly ProviderC
     }>;
 };
 export declare function isManagedProvider(providerId: string | undefined): providerId is ManagedProviderId;
-/** The `modelLadders` CONFIG key for a runtime provider id -- `openai-codex`
- *  (the runtime/auth id) maps to the `openai` ladder key used in
- *  ~/.crouter/config.json. Callers building a repair command that a user can
- *  paste into `crtr sys config set modelLadders.<key>...` must use THIS key,
- *  not the runtime provider id. */
-export declare function getLadderProviderId(providerId: ManagedProviderId): LadderProviderId;
 export declare function getProviderLabel(providerId: ManagedProviderId): string;
 export declare function mutateSubscriptionPool(providerId: ManagedProviderId, fn: (pool: SubscriptionCredential[], assertLockHeld: () => void) => SubscriptionCredential[] | undefined | Promise<SubscriptionCredential[] | undefined>): Promise<SubscriptionCredential[]>;
 export declare function refreshSubscriptionCredential(providerId: ManagedProviderId, label: string, exchange: (refreshToken: string) => Promise<{
@@ -118,6 +99,7 @@ export declare function commitManagedLogin(providerId: ManagedProviderId, label:
     lastRateLimitedAt: number;
     autoLabel?: boolean;
 }): Promise<SubscriptionCredential[]>;
+export declare function removeAllManagedAccounts(providerId: ManagedProviderId): Promise<number>;
 export declare function removeManagedProvider(providerId: ManagedProviderId, label?: string): Promise<SubscriptionCredential[]>;
 export declare function removeSubscription(providerId: ManagedProviderId, ref: string): Promise<SubscriptionCredential[]>;
 export declare function promoteSubscription(providerId: ManagedProviderId, ref: string): Promise<SubscriptionCredential[]>;
@@ -128,11 +110,5 @@ export declare function markSubscriptionSuccess(providerId: ManagedProviderId, r
 export declare function parseRetryAfterHeader(value: string | undefined, now?: number): number | undefined;
 export declare function readRotationConfig(): RotationConfig;
 export declare function writeRotationConfig(next: RotationConfigUpdate): RotationConfig;
-export declare function clearPreferredModel(): RotationConfig;
-export declare function rememberPreferredModel(model: ModelRef): RotationConfig;
-export declare function resolveFallbackTarget(currentProviderId: ManagedProviderId, currentModelId?: string, config?: RotationConfig, currentThinkingLevel?: string): FallbackTarget | undefined;
-export declare function shouldRestorePreferredModel(config?: RotationConfig, now?: number): boolean;
-export declare function restorePreferredModelIfPossible(piApi: ExtensionAPI, ctx: Pick<ExtensionContext, "model" | "modelRegistry">): Promise<boolean>;
-export declare function switchToFallbackIfPossible(piApi: ExtensionAPI, ctx: Pick<ExtensionContext, "model" | "modelRegistry">, preferredModel?: ModelRef | undefined): Promise<FallbackTarget | undefined>;
 export declare function formatStatusLine(providerId: ManagedProviderId, now?: number): string;
 export {};

package/dist/core/subscription-state.js

@@ -1,6 +1,5 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { createHash } from "node:crypto";
-import { defaultModelLaddersConfig } from "../types.js";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { LockedJsonFile } from "./locked-file.js";
@@ -61,19 +60,14 @@ function agentDir() {
 function rotationConfigFile() {
     return join(agentDir(), "provider-rotation.json");
 }
-function crouterConfigFile() {
-    return join(homedir(), ".crouter", "config.json");
-}
 const DEFAULT_FALLBACK_STRENGTH = "strong";
 const PROVIDERS = {
     [ANTHROPIC_PROVIDER_ID]: {
         label: "Claude",
-        ladderProviderId: "anthropic",
         poolFileName: "anthropic-subscriptions.json",
     },
     [OPENAI_CODEX_PROVIDER_ID]: {
         label: "OpenAI Codex",
-        ladderProviderId: "openai",
         poolFileName: "openai-codex-subscriptions.json",
     },
 };
@@ -184,9 +178,6 @@ function traceDroppedRows(providerId, stored, normalized) {
         return;
     process.stderr.write(`[subscription-pool] ${getProviderLabel(providerId)}: dropping ${stored.length - normalized.length} stored row(s) with no label or no token pair\n`);
 }
-function getCurrentModelRef(model) {
-    return isManagedProvider(model?.provider) ? { providerId: model.provider, modelId: model.id } : undefined;
-}
 // A refreshed/modified token set is only storable when it carries BOTH halves and a usable
 // expiry. Persisting a partial one is silently destructive: `JSON.stringify` drops the missing
 // key, and `normalizeCredential` (which requires refresh AND access together) then discards the
@@ -247,14 +238,6 @@ function logCredentialSetChange(providerId, base, next) {
 export function isManagedProvider(providerId) {
     return providerId === ANTHROPIC_PROVIDER_ID || providerId === OPENAI_CODEX_PROVIDER_ID;
 }
-/** The `modelLadders` CONFIG key for a runtime provider id -- `openai-codex`
- *  (the runtime/auth id) maps to the `openai` ladder key used in
- *  ~/.crouter/config.json. Callers building a repair command that a user can
- *  paste into `crtr sys config set modelLadders.<key>...` must use THIS key,
- *  not the runtime provider id. */
-export function getLadderProviderId(providerId) {
-    return PROVIDERS[providerId].ladderProviderId;
-}
 export function getProviderLabel(providerId) {
     return PROVIDERS[providerId].label;
 }
@@ -603,14 +586,26 @@ export async function commitManagedLogin(providerId, label, credential) {
         return merged;
     });
 }
+// Remove every account for one managed provider through a single locked transform. The
+// returned count belongs to that locked snapshot, so callers do not race a concurrent login.
+export async function removeAllManagedAccounts(providerId) {
+    let removed = 0;
+    await mutateSubscriptionPool(providerId, (pool) => {
+        removed = pool.length;
+        return [];
+    });
+    return removed;
+}
 // Coordinated removal for the human UI. Removes a single account when `label` is given; the ENTIRE
-// provider (every pool account) when `label` is omitted — always through removeManagedAccount. UI
+// provider (every pool account) when `label` is omitted — always through a pool transform. UI
 // must NEVER reach for a raw auth.json delete on a managed provider: that strips a file pi no
 // longer reads for managed providers and orphans the whole pool.
 export async function removeManagedProvider(providerId, label) {
+    if (label === undefined) {
+        await removeAllManagedAccounts(providerId);
+        return [];
+    }
     return mutateSubscriptionPool(providerId, (pool) => {
-        if (label === undefined)
-            return [];
         const index = resolveCredentialIndex(pool, label);
         if (index === -1)
             throw new Error(`Unknown ${getProviderLabel(providerId)} subscription: ${label}`);
@@ -701,9 +696,6 @@ export async function markSubscriptionSuccess(providerId, ref, attemptAt = Date.
         return next;
     });
 }
-function findAvailableSubscription(providerId, now = Date.now()) {
-    return readSubscriptionPool(providerId).find((entry) => !entry.rateLimitedUntil || entry.rateLimitedUntil <= now);
-}
 export function parseRetryAfterHeader(value, now = Date.now()) {
     if (!value)
         return undefined;
@@ -716,102 +708,11 @@ export function parseRetryAfterHeader(value, now = Date.now()) {
     const parsed = Date.parse(trimmed);
     return Number.isFinite(parsed) ? Math.max(0, parsed - now) : undefined;
 }
-function thinkingLevelOfRef(ref) {
-    const match = ref.trim().match(/:(thinking|off|minimal|low|medium|high|xhigh|max)$/i);
-    if (!match)
-        return undefined;
-    const level = match[1].toLowerCase();
-    return level === "off" || level === "thinking" ? undefined : level;
-}
-function normalizeModelRef(ref) {
-    return ref
-        .trim()
-        .replace(/^[^/]+\//, "")
-        .replace(/:(?:thinking|off|minimal|low|medium|high|xhigh|max)$/i, "")
-        .toLowerCase();
-}
-function splitModelRef(ref) {
-    const trimmed = ref.trim();
-    const slash = trimmed.indexOf("/");
-    const providerId = slash === -1 ? OPENAI_CODEX_PROVIDER_ID : trimmed.slice(0, slash).trim();
-    if (!isManagedProvider(providerId)) {
-        throw new Error(`Unsupported fallback provider: ${providerId}`);
-    }
-    const rawModelId = slash === -1 ? trimmed : trimmed.slice(slash + 1).trim();
-    const thinkingMatch = rawModelId.match(/^(.*?)(?::(thinking|off|minimal|low|medium|high|xhigh|max))$/i);
-    return {
-        providerId,
-        modelId: thinkingMatch ? thinkingMatch[1] : rawModelId,
-        label: `${providerId}/${thinkingMatch ? thinkingMatch[1] : rawModelId}${thinkingMatch?.[2] ? `:${thinkingMatch[2].toLowerCase()}` : ""}`,
-        strength: DEFAULT_FALLBACK_STRENGTH,
-        thinkingLevel: thinkingMatch?.[2] && thinkingMatch[2].toLowerCase() !== "off" && thinkingMatch[2].toLowerCase() !== "thinking"
-            ? thinkingMatch[2].toLowerCase()
-            : undefined,
-    };
-}
-// Layers ~/.crouter/config.json's `modelLadders` (if any) OVER crouter's
-// builtin ladder (`defaultModelLaddersConfig()`, src/types.ts — imported
-// directly: this package's canonical home is the crouter tree, so the
-// relative import always resolves, to dist/types.js at runtime), per
-// provider/strength — mirroring crouter's own
-// `mergeModelLadders` (src/core/config.ts), which is what a node's launcher
-// actually resolves models from. Without this fallback, a config-less user
-// (the common case: fresh install, no ~/.crouter/config.json) saw an EMPTY
-// ladder here while crtr itself launched them on the builtin defaults —
-// rotation could then never resolve a strength tier or a cross-provider
-// fallback for a model it was already running. Always returns a fully
-// populated ladder for both providers; a config.json override only replaces
-// the specific strengths it sets.
-function readModelLadders() {
-    const config = readJsonFile(crouterConfigFile());
-    const overrides = config?.modelLadders;
-    const builtin = defaultModelLaddersConfig();
-    const result = {};
-    for (const provider of ["anthropic", "openai"]) {
-        const normalized = { ...builtin[provider] };
-        const override = overrides?.[provider];
-        if (override) {
-            for (const strength of ["ultra", "strong", "medium", "light"]) {
-                const value = typeof override[strength] === "string" ? override[strength]?.trim() : "";
-                if (value)
-                    normalized[strength] = value;
-            }
-        }
-        result[provider] = normalized;
-    }
-    return result;
-}
-function findStrengthForModelId(providerId, modelId, defaultStrength, ladders = readModelLadders(), currentThinkingLevel) {
-    const source = ladders?.[PROVIDERS[providerId].ladderProviderId];
-    const bareId = modelId ? normalizeModelRef(modelId) : undefined;
-    if (!source || !bareId)
-        return undefined;
-    const matches = [];
-    for (const strength of ["ultra", "strong", "medium", "light"]) {
-        const ref = source[strength];
-        if (ref && normalizeModelRef(ref) === bareId)
-            matches.push(strength);
-    }
-    if (matches.length === 0)
-        return undefined;
-    // Rungs that share a bare model id (e.g. gpt-5.6-sol:max vs gpt-5.6-sol:high) are
-    // disambiguated by the live reasoning level so an ultra run doesn't collapse to strong.
-    if (matches.length > 1 && currentThinkingLevel) {
-        const exact = matches.find((strength) => thinkingLevelOfRef(source[strength]) === currentThinkingLevel);
-        if (exact)
-            return exact;
-    }
-    return matches.includes(defaultStrength) ? defaultStrength : matches[0];
-}
 export function readRotationConfig() {
     const raw = readJsonFile(rotationConfigFile()) ?? {};
-    const preferredModel = raw.preferredModel && isManagedProvider(raw.preferredModel.providerId) && typeof raw.preferredModel.modelId === "string"
-        ? { providerId: raw.preferredModel.providerId, modelId: raw.preferredModel.modelId.trim() }
-        : undefined;
     return {
         defaultFallbackStrength: normalizeStrength(raw.defaultFallbackStrength) ?? DEFAULT_FALLBACK_STRENGTH,
         revertWhenAvailable: raw.revertWhenAvailable ?? true,
-        preferredModel,
     };
 }
 export function writeRotationConfig(next) {
@@ -819,100 +720,15 @@ export function writeRotationConfig(next) {
     const merged = {
         defaultFallbackStrength: normalizeStrength(next.defaultFallbackStrength) ?? current.defaultFallbackStrength ?? DEFAULT_FALLBACK_STRENGTH,
         revertWhenAvailable: next.revertWhenAvailable ?? current.revertWhenAvailable ?? true,
-        preferredModel: Object.prototype.hasOwnProperty.call(next, "preferredModel")
-            ? next.preferredModel || undefined
-            : current.preferredModel,
     };
     writeJsonFile(rotationConfigFile(), merged);
     return merged;
 }
-export function clearPreferredModel() {
-    return writeRotationConfig({ preferredModel: null });
-}
-export function rememberPreferredModel(model) {
-    return writeRotationConfig({ preferredModel: model });
-}
-// `readModelLadders()` always fills both providers from the builtin defaults, so this
-// only returns undefined (never throws) in the defensive case where a rung is still
-// genuinely missing; callers must treat that as a graceful "no fallback available" case
-// rather than a config error to surface mid-turn.
-export function resolveFallbackTarget(currentProviderId, currentModelId, config = readRotationConfig(), currentThinkingLevel) {
-    const ladders = readModelLadders();
-    const defaultStrength = config.defaultFallbackStrength ?? DEFAULT_FALLBACK_STRENGTH;
-    const sourceStrength = findStrengthForModelId(currentProviderId, currentModelId, defaultStrength, ladders, currentThinkingLevel);
-    const strength = sourceStrength ?? defaultStrength;
-    const targetProvider = currentProviderId === ANTHROPIC_PROVIDER_ID ? OPENAI_CODEX_PROVIDER_ID : ANTHROPIC_PROVIDER_ID;
-    const targetLadder = ladders?.[PROVIDERS[targetProvider].ladderProviderId];
-    const candidates = strength === defaultStrength ? [strength] : [strength, defaultStrength];
-    const fallbackRef = candidates.map((candidate) => targetLadder?.[candidate]).find((ref) => typeof ref === "string" && ref.trim().length > 0);
-    if (!fallbackRef) {
-        return undefined;
-    }
-    const parsed = splitModelRef(fallbackRef);
-    const resolvedStrength = candidates.find((candidate) => targetLadder?.[candidate] === fallbackRef) ?? strength;
-    return { ...parsed, strength: resolvedStrength };
-}
-export function shouldRestorePreferredModel(config = readRotationConfig(), now = Date.now()) {
-    if (!config.revertWhenAvailable || !config.preferredModel)
-        return false;
-    return Boolean(findAvailableSubscription(config.preferredModel.providerId, now));
-}
-export async function restorePreferredModelIfPossible(piApi, ctx) {
-    const config = readRotationConfig();
-    if (!shouldRestorePreferredModel(config, Date.now()))
-        return false;
-    const preferred = config.preferredModel;
-    if (!preferred)
-        return false;
-    const current = getCurrentModelRef(ctx.model);
-    if (current?.providerId === preferred.providerId && current.modelId === preferred.modelId) {
-        clearPreferredModel();
-        return true;
-    }
-    const model = ctx.modelRegistry.find(preferred.providerId, preferred.modelId);
-    if (!model)
-        return false;
-    const switched = await piApi.setModel(model);
-    if (switched)
-        clearPreferredModel();
-    return switched;
-}
-export async function switchToFallbackIfPossible(piApi, ctx, preferredModel = getCurrentModelRef(ctx.model)) {
-    if (!preferredModel)
-        return undefined;
-    rememberPreferredModel(preferredModel);
-    const currentThinkingLevel = piApi.getThinkingLevel?.();
-    const target = resolveFallbackTarget(preferredModel.providerId, preferredModel.modelId, readRotationConfig(), currentThinkingLevel);
-    if (!target)
-        return undefined;
-    const current = getCurrentModelRef(ctx.model);
-    const model = ctx.modelRegistry.find(target.providerId, target.modelId);
-    if (!model)
-        return undefined;
-    if (current?.providerId !== target.providerId || current.modelId !== target.modelId) {
-        const switched = await piApi.setModel(model);
-        if (!switched) {
-            // `setModel` returns false when its target lacks configured auth and leaves
-            // the live model unchanged. A concurrent transition can still independently
-            // make THIS exact target current while this call is in flight, so re-read
-            // the live model and accept only when it now equals the target on both provider and
-            // model id; any other current model is a genuine failed switch.
-            const afterSwitch = getCurrentModelRef(ctx.model);
-            if (afterSwitch?.providerId !== target.providerId || afterSwitch.modelId !== target.modelId)
-                return undefined;
-        }
-    }
-    if (target.thinkingLevel)
-        piApi.setThinkingLevel(target.thinkingLevel);
-    return target;
-}
 export function formatStatusLine(providerId, now = Date.now()) {
     const pool = readSubscriptionPool(providerId);
-    const ready = pool.filter((entry) => !entry.rateLimitedUntil || entry.rateLimitedUntil <= now);
+    const ready = pool.filter((entry) => entry.authFailure === undefined && (!entry.rateLimitedUntil || entry.rateLimitedUntil <= now));
     const label = getProviderLabel(providerId);
-    if (ready.length === 0) {
-        const fallback = resolveFallbackTarget(providerId, undefined, readRotationConfig());
-        return fallback ? `${label} pool exhausted -> ${fallback.label}` : `${label} pool exhausted (no fallback configured)`;
-    }
-    return `${label} ${ready[0]?.label ?? providerId} (${ready.length}/${pool.length} ready)`;
+    return ready.length === 0
+        ? `${label} pool exhausted`
+        : `${label} ${ready[0]?.label ?? providerId} (${ready.length}/${pool.length} ready)`;
 }