@toddzheng024/dscode-bundle 0.7.6 → 0.7.7

package/vendor/compaction-basic/types/config.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Load-time validation and routed-model policy resolution for compaction-basic.
+ *
+ * @module @deepseek-ai/dsh-compaction-basic/config
+ */
+import type { LlmCallConfig } from '@deepseek-ai/dsh-llm';
+import type { BasicCompactionConfig, ResolvedCompactSpec, ResolvedConfig, ResolvedTargetPolicy } from './types.ts';
+/** Target-specific pressure configuration failure eligible for warning suppression. */
+export declare class TargetPressureConfigError extends Error {
+    readonly targetKey: string;
+    /**
+     * @param targetKey - exact provider/model route used as the warning key.
+     * @param message - actionable configuration failure detail.
+     */
+    constructor(targetKey: string, message: string);
+}
+/**
+ * Resolve and validate service defaults plus exact-target partial overrides.
+ * @param config - untrusted plugin configuration after Loader normalization.
+ * @returns detached immutable defaults and validated exact-target overrides.
+ */
+export declare function resolveConfig(config?: BasicCompactionConfig): ResolvedConfig;
+/**
+ * Merge the exact provider/model override over the validated default policy.
+ * @param config - validated service defaults and override table.
+ * @param target - exact durable provider/model route to match.
+ * @returns detached immutable policy before model-capacity scaling.
+ */
+export declare function resolveTargetPolicy(config: ResolvedConfig, target: Pick<LlmCallConfig, 'provider' | 'model'>): ResolvedTargetPolicy;
+/**
+ * Scale one routed policy into concrete token budgets for its model capacity.
+ * @param policy - merged policy for the exact routed target.
+ * @param contextWindow - positive adapter-owned capacity for that target.
+ * @returns detached immutable pressure and retention budgets.
+ */
+export declare function resolveCompactSpec(policy: ResolvedTargetPolicy, contextWindow: number): ResolvedCompactSpec;
+//# sourceMappingURL=config.d.ts.map

package/vendor/compaction-basic/types/index.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Basic replay-aware compaction backend.
+ *
+ * @module @deepseek-ai/dsh-compaction-basic
+ */
+import { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { CompactionEngine } from '@deepseek-ai/dsh-compaction';
+import type { CompactionResult, CompactionTrigger } from '@deepseek-ai/dsh-compaction';
+import type { SessionSeq } from '@deepseek-ai/dsh-session';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { CommandId } from '@deepseek-ai/dsh-commands/brand';
+import type { SummarizationInput, SummaryResult } from './summarizer.ts';
+import type { BasicCompactionConfig, ResolvedConfig } from './types.ts';
+export type { BasicCompactionConfig, CompactionPolicyConfig, ModelCompactPolicyConfig, ResolvedCompactSpec, ResolvedConfig, ResolvedRetention, ResolvedTargetPolicy, } from './types.ts';
+/**
+ * Dependency-light compaction backend using `ctx.tokenMeter` for pressure,
+ * retention, cited source events, and summary-convergence pricing.
+ *
+ * `summarize()` is the sole subclass customization hook; the replay and durable
+ * mutation strategy stays fixed so every pricing decision uses the singleton
+ * token meter.
+ */
+export declare class BasicCompactionEngine extends CompactionEngine {
+    static inject: string[];
+    static Config: z<BasicCompactionConfig>;
+    /** Resolved and validated compaction configuration. */
+    readonly config: ResolvedConfig;
+    private readonly warnedPressureConfigTargets;
+    private readonly overflowRetries;
+    private readonly overflowAgents;
+    constructor(ctx: Context, config?: BasicCompactionConfig);
+    /**
+     * Register automatic between-step pressure and model-request overflow
+     * recovery. `compactIfNeeded` stays dynamically dispatched so subclass
+     * overrides are honored at event time.
+     */
+    private _registerAutomaticCompaction;
+    /**
+     * Summarize the replayed conversation region through a direct one-shot
+     * `ctx.llm.stream()` call whose prefix reuses the conversation's own system
+     * prompt, tools, and messages so the provider's KV cache is not invalidated.
+     * Override this sole hook for a template or remote summarizer.
+     * @param input - replayed conversation prefix (system, tools, and leading messages) to condense.
+     * @param agent - supplies routed-model history, fallback model, and session id.
+     * @param signal - optional cancellation forwarded to the adapter.
+     * @returns safe text summary blocks and the exact auxiliary call envelope and output.
+     */
+    protected summarize(input: SummarizationInput, agent: Agent, signal?: AbortSignal): Promise<SummaryResult>;
+    /**
+     * Compact for replayed step-boundary pressure or one provider-confirmed context
+     * overflow. Both triggers price the latest durable routed request envelope;
+     * overflow bypasses the normal threshold and retained-tail policy so it can
+     * force one useful balanced reduction.
+     * @param agent - agent whose latest durable routed request is measured.
+     * @param trigger - normal step-boundary pressure or context-overflow recovery.
+     * @param signal - live turn cancellation signal forwarded to summarization.
+     * @returns the latest summary compaction result, or `null` when no summary ran.
+     */
+    compactIfNeeded(agent: Agent, trigger: CompactionTrigger, signal: AbortSignal): Promise<CompactionResult | null>;
+    /**
+     * Compact one inclusive positional range from the agent-owned surface using
+     * the effective token meter for all retention and shrink pricing.
+     * @param start - inclusive first surface-node seq.
+     * @param end - inclusive last surface-node seq.
+     * @param agent - owner of the target session, used by the summarizer.
+     * @param signal - optional summarization cancellation signal.
+     * @returns the successful durable compaction result.
+     */
+    compactRegion(start: SessionSeq, end: SessionSeq, agent: Agent, signal?: AbortSignal): Promise<CompactionResult>;
+    /**
+     * Force one useful idle-session compaction below the pressure threshold, and
+     * resolve only after its standalone marker pair is durably checkpointed.
+     * @param agent - idle agent whose next-turn admission this call reserves.
+     * @param signal - cancellation scoped to this compaction request.
+     * @param sourceCommandId - initiating command identity for presentation correlation.
+     * @returns the committed result, or `null` when no safe useful range exists.
+     */
+    compactNow(agent: Agent, signal: AbortSignal, sourceCommandId?: CommandId): Promise<CompactionResult | null>;
+    /** Bind the effective token meter and dynamically dispatched summarizer hook. */
+    private regionDependencies;
+}
+export default BasicCompactionEngine;
+//# sourceMappingURL=index.d.ts.map

package/vendor/compaction-basic/types/region.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Surface retention selection and the shared log-recorded compaction
+ * transaction for automatic open-turn and manual idle-session compaction.
+ *
+ * @module @deepseek-ai/dsh-compaction-basic/region
+ */
+import type { CompactionResult } from '@deepseek-ai/dsh-compaction';
+import type { CommandId } from '@deepseek-ai/dsh-commands/brand';
+import type { TokenMeasurement, TokenMeter } from '@deepseek-ai/dsh-token-meter';
+import { SessionSeq, type Session } from '@deepseek-ai/dsh-session';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { SummarizationInput, SummaryResult } from './summarizer.ts';
+interface RegionDependencies {
+    readonly meter: TokenMeter;
+    summarize(input: SummarizationInput, agent: Agent, signal?: AbortSignal): Promise<SummaryResult>;
+}
+interface CompactionTransactionOptions {
+    /** `current-turn` derives a numbered owner; `null` writes a standalone bracket. */
+    readonly owner: 'current-turn' | null;
+    /** Surface relationship that must survive asynchronous summarization. */
+    readonly stability: 'whole-surface' | 'selected-span';
+    /** Optional durability checkpoint after a successfully closed bracket. */
+    readonly flush?: () => Promise<void>;
+    /** Manual command that initiated this transaction, when present. */
+    readonly sourceCommandId?: CommandId;
+}
+/**
+ * Resolve the next range starting at the first non-system surface node while
+ * retaining a priced recent tail and never splitting an assistant
+ * tool-call/result pair. A `system/message` at surface node 0 is never inside
+ * the range; without one the range starts at node 0.
+ * @param session - session supplying authoritative current surface positions.
+ * @param measurement - unified pressure and surface measurement from the conversation meter.
+ * @param retainTokens - minimum recent tail budget retained verbatim.
+ * @returns the inclusive positional seq range to compact, or `null`.
+ */
+export declare function selectCompactableRange(session: Session, measurement: TokenMeasurement, retainTokens: number): {
+    start: SessionSeq;
+    end: SessionSeq;
+} | null;
+/**
+ * Run the single compaction transaction over one selected positional span.
+ * Selection and validation are read-only. Idle/log validation and
+ * `compaction/start` are synchronously adjacent, so the durable opening marker is
+ * the compaction lock before summarization yields. Every later failure makes
+ * exactly one `compaction/end` attempt; a failed close deliberately leaves the
+ * unmatched start detectable.
+ * @param dependencies - conversation meter and dynamically dispatched summarizer hook.
+ * @param session - session whose surface is mutated.
+ * @param start - inclusive first surface-node seq.
+ * @param end - inclusive last surface-node seq.
+ * @param agent - agent used by the summarizer.
+ * @param options - bracket owner, stability rule, and optional durability checkpoint.
+ * @param signal - optional summarization cancellation signal.
+ * @returns the successful durable compaction result.
+ */
+export declare function compactSurfaceRegion(dependencies: RegionDependencies, session: Session, start: SessionSeq, end: SessionSeq, agent: Agent, options: CompactionTransactionOptions, signal?: AbortSignal): Promise<CompactionResult>;
+/**
+ * Recheck the durable compaction lock after an asynchronous policy decision.
+ * @param session - session whose latest marker state is inspected.
+ * @param stage - operation label included in the busy diagnostic.
+ */
+export declare function assertNoActiveCompaction(session: Session, stage: string): void;
+export {};
+//# sourceMappingURL=region.d.ts.map

package/vendor/compaction-basic/types/summarizer.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Default one-shot summarization and durable checkpoint framing.
+ *
+ * @module @deepseek-ai/dsh-compaction-basic/summarizer
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ContentBlock, Message, TokenUsage, ToolSchema } from '@deepseek-ai/dsh-llm';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+interface SummaryConfig {
+    readonly summarizationProvider: string;
+    readonly summarizationModel: string;
+    readonly maxTokens: number;
+}
+/**
+ * The replayed conversation surface the summarizer condenses. Reproducing the
+ * last routed request's system prompt, tools, and leading messages verbatim
+ * lets the auxiliary call reuse the provider's warm prefix cache; the trailing
+ * compaction instruction is then the only novel input.
+ */
+export interface SummarizationInput {
+    /** The conversation's tool schemas, reused for prefix-cache alignment; absent when the request carried none. */
+    readonly tools?: readonly ToolSchema[];
+    /** The derived system head, when present, followed by the shadowed region in surface order. */
+    readonly messages: readonly Message[];
+}
+/** Safe summary content plus the exact auxiliary call envelope recorded with it. */
+export type SummaryResult = {
+    summary: ContentBlock[];
+    provider: string;
+    model: string;
+    maxTokens?: number;
+    /** Provider-reported usage for this summarization request. */
+    usage?: TokenUsage;
+} & ({
+    /** Complete provider output before the text-only summary projection. */
+    rawOutput: ContentBlock[];
+    /** Identifies exactly one call through this context's `ctx.llm.stream()`. */
+    llmStreamCall: true;
+} | {
+    /** Optional complete output from an unmarked template, remote, or other summarizer. */
+    rawOutput?: ContentBlock[];
+    /** An unmarked result does not identify a call through this context's LLM seam. */
+    llmStreamCall?: never;
+});
+/**
+ * Run the default cache-reusing `ctx.llm.stream()` summarization call: replay
+ * the conversation prefix, then append the compaction instruction as the final
+ * user message so the provider's warm prefix cache is reused.
+ * @param ctx - context providing the LLM service.
+ * @param config - resolved backend configuration.
+ * @param input - replayed conversation prefix (system, tools, and leading messages) to condense.
+ * @param agent - supplies routed-model history, fallback model, and session id.
+ * @param signal - optional cancellation forwarded to the adapter.
+ * @returns safe text-only summary blocks and the exact call envelope and output.
+ */
+export declare function summarizeWithLlm(ctx: Context, config: SummaryConfig, input: SummarizationInput, agent: Agent, signal?: AbortSignal): Promise<SummaryResult>;
+/**
+ * Wrap raw summary blocks in the durable checkpoint framing.
+ * @param summary - safe text-only model output.
+ * @returns content for the synthesized replacement user message.
+ */
+export declare function frameSummary(summary: readonly ContentBlock[]): ContentBlock[];
+export {};
+//# sourceMappingURL=summarizer.d.ts.map

package/vendor/compaction-basic/types/types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Configuration vocabulary for the replay-aware basic compaction backend.
+ *
+ * @module @deepseek-ai/dsh-compaction-basic/types
+ */
+import type { LlmCallConfig } from '@deepseek-ai/dsh-llm';
+/** Policy fields shared by the default policy and exact model overrides. */
+export interface CompactionPolicyConfig {
+    /** Compact at this fraction of the model's context window. Defaults to `0.8`. */
+    thresholdRatio?: number;
+    /** Recent context retained as a fraction of the model's window. Defaults to `0.16`. */
+    retainRatio?: number;
+    /** Absolute recent-context budget; mutually exclusive with `retainRatio`. */
+    retainTokens?: number;
+    /** Summary provider; set together with `summarizationModel`, or inherit the conversation target. */
+    summarizationProvider?: string;
+    /** Summary model; set together with `summarizationProvider`, or inherit the conversation target. */
+    summarizationModel?: string;
+    /** Provider generation cap for summarization. Defaults to `8192`. */
+    maxTokens?: number;
+    /** Extra attempts after the first compaction when pressure remains above threshold. Defaults to `1`. */
+    compactionRetries?: number;
+    /** Maximum retries after canonical context overflow; `0` disables recovery. Defaults to `1`. */
+    maxOverflowRetries?: number;
+}
+/** Exact provider/model override merged over the default compaction policy. */
+export interface ModelCompactPolicyConfig extends CompactionPolicyConfig {
+    /** Registered provider route to match. */
+    provider: string;
+    /** Exact routed model id to match within `provider`. */
+    model: string;
+}
+/** Basic compaction configuration with an optional exact-target policy table. */
+export interface BasicCompactionConfig extends CompactionPolicyConfig {
+    /** Exact provider/model overrides; duplicate targets fail plugin load. */
+    modelPolicies?: ModelCompactPolicyConfig[];
+    /** Enable automatic step-boundary pressure and overflow-recovery listeners. Defaults to `true`. */
+    auto?: boolean;
+}
+/** Exactly one validated retention form. */
+export type ResolvedRetention = {
+    readonly retainRatio: number;
+    readonly retainTokens?: never;
+} | {
+    readonly retainRatio?: never;
+    readonly retainTokens: number;
+};
+/** Validated policy fields shared before and after exact-target matching. */
+interface ResolvedPolicyFields {
+    readonly thresholdRatio: number;
+    readonly summarizationProvider: string;
+    readonly summarizationModel: string;
+    readonly maxTokens: number;
+    readonly compactionRetries: number;
+    readonly maxOverflowRetries: number;
+}
+/** Validated immutable config whose target-specific defaults remain unresolved. */
+export type ResolvedConfig = ResolvedPolicyFields & ResolvedRetention & {
+    readonly modelPolicies: readonly Readonly<ModelCompactPolicyConfig>[];
+    readonly auto: boolean;
+};
+/** Fully merged policy for one routed conversation target, before capacity scaling. */
+export type ResolvedTargetPolicy = ResolvedPolicyFields & ResolvedRetention & {
+    readonly target: Pick<LlmCallConfig, 'provider' | 'model'>;
+};
+/** One routed model's concrete pressure and retention budget. */
+export type ResolvedCompactSpec = Omit<ResolvedTargetPolicy, 'retainRatio' | 'retainTokens'> & {
+    readonly contextWindow: number;
+    readonly thresholdTokens: number;
+    readonly retainTokens: number;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/vendor/tui/dscode-providers/catalog.mjs

@@ -1,83 +1,42 @@
 // Model providers `/provider` switches between. DeepSeek's official API is the
-// native `llm-deepseek` route; OpenRouter serves the DeepSeek models and the rest
-// of pi-ai's OpenRouter catalog through pi-ai's catalog route, which the base
-// composition mounts dormant until a `llm-pi-ai:` settings section declares it.
+// native `llm-deepseek` route; OpenRouter is DSCODE's own adapter
+// (plugins/openrouter), which serves OpenRouter's live model listing and is always
+// registered. This module ships beside the TUI too, so it imports nothing.
 
 export const PROVIDERS = Object.freeze([
   { id: 'deepseek-official', name: 'DeepSeek', aliases: ['deepseek', 'deepseek-official', 'official'], credentialRef: 'DEEPSEEK_API_KEY', defaultModel: 'deepseek-flash' },
-  { id: 'openrouter', name: 'OpenRouter', aliases: ['openrouter', 'open-router'], credentialRef: 'OPENROUTER_API_KEY', defaultModel: 'deepseek/deepseek-v4-flash' },
+  // The optional management key reads account data only; it cannot call models.
+  { id: 'openrouter', name: 'OpenRouter', aliases: ['openrouter', 'open-router'], credentialRef: 'OPENROUTER_API_KEY', managementRef: 'OPENROUTER_MANAGEMENT_KEY', defaultModel: 'deepseek/deepseek-v4-flash' },
 ]);
 
+// The pi-ai adapter served OpenRouter until 0.7.6, from this settings section.
 const PI_AI_NS = 'llm-pi-ai';
 
 // OpenRouter serves DeepSeek V4 thinking as none/high/xhigh. DeepSeek itself
 // answers `low` as high and `max` as xhigh, so the route offers the official
 // low/high/max detents (and Ultra on top of max) with the wire spelling OpenRouter
 // accepts; session cards and delegated children that ask for `low` keep working.
-const OPENROUTER_EFFORTS = Object.freeze({ off: 'none', low: 'high', high: 'high', max: 'xhigh' });
+export const OPENROUTER_EFFORTS = Object.freeze({ off: 'none', low: 'high', high: 'high', max: 'xhigh' });
 
-/** The DeepSeek models the OpenRouter route declares, with their official-route counterparts. */
+/** The DeepSeek models the OpenRouter route serves, with their official-route counterparts. */
 export const OPENROUTER_MODELS = Object.freeze([
   { id: 'deepseek/deepseek-v4-flash', name: 'DeepSeek V4 Flash', official: ['deepseek-flash', 'deepseek-v4-flash'] },
   { id: 'deepseek/deepseek-v4-pro', name: 'DeepSeek V4 Pro', official: ['deepseek-v4-pro'] },
   { id: 'deepseek/deepseek-v4-flash-vision-exp', name: 'DeepSeek V4 Flash Vision Exp', official: ['deepseek-v4-flash-vision-exp'] },
 ]);
 
-/** The `llm-pi-ai` profile `/provider openrouter` writes: pi-ai's whole OpenRouter catalog. */
-export function openRouterProfile() {
-  return {
-    displayName: 'OpenRouter',
-    apiKeyEnv: 'OPENROUTER_API_KEY',
-    // Like the official route, requests default to high; a model without high uses its own default.
-    reasoning: 'high',
-    // No models list, so the route serves every catalog model; the overrides give the
-    // DeepSeek models the official detents (and /effort its detent bar).
-    modelOverrides: Object.fromEntries(OPENROUTER_MODELS.map(({ id, name }) => [id, { name, reasoningEfforts: { ...OPENROUTER_EFFORTS } }])),
-  };
-}
-
-/** The profile 0.7.3 to 0.7.5 wrote: the catalog narrowed to the three DeepSeek models. */
-export function narrowOpenRouterProfile() {
-  return {
-    displayName: 'OpenRouter',
-    apiKeyEnv: 'OPENROUTER_API_KEY',
-    reasoning: 'high',
-    models: OPENROUTER_MODELS.map(({ id, name }) => ({ id, name, reasoningEfforts: { ...OPENROUTER_EFFORTS } })),
-  };
-}
-
-// Fields a user sets to point the route elsewhere or shape its requests. The settings
-// service describes a profile with its resolved defaults, which fill these with empty
-// values (`input: []`, `compat: { chatTemplateKwargs: {}, ... }`), so empty counts as unset.
-const USER_FIELDS = ['api', 'baseURL', 'modelOverrides', 'headers', 'compat', 'thinkingBudgets', 'cacheRetention', 'transport'];
-const empty = value => value === undefined || (Array.isArray(value) ? value.length === 0
-  : value !== null && typeof value === 'object' && Object.values(value).every(empty));
-const sameEfforts = (left, right) => left !== null && typeof left === 'object'
-  && Object.keys(left).length === Object.keys(right).length && Object.entries(right).every(([level, wire]) => left[level] === wire);
-
-/** Whether a stored profile is exactly the narrow one DSCODE wrote, so replacing it discards nothing the user chose. */
-export function isNarrowOpenRouterProfile(profile) {
-  if (profile === null || typeof profile !== 'object' || !Array.isArray(profile.models)) return false;
-  const narrow = narrowOpenRouterProfile();
-  return profile.displayName === narrow.displayName && profile.apiKeyEnv === narrow.apiKeyEnv && profile.reasoning === narrow.reasoning
-    && USER_FIELDS.every(field => empty(profile[field]))
-    && profile.models.length === narrow.models.length
-    && narrow.models.every((expected, index) => {
-      const { id, name, reasoningEfforts, ...rest } = profile.models[index] ?? {};
-      return id === expected.id && name === expected.name && sameEfforts(reasoningEfforts, expected.reasoningEfforts) && Object.values(rest).every(empty);
-    });
-}
-
 /**
- * Replace the narrow profile earlier builds wrote with the whole-catalog one.
- * Never declares a route and never throws: /model must open regardless.
+ * Remove the `openrouter` profile earlier builds wrote into the pi-ai section. The
+ * pi-ai adapter is no longer mounted, so the profile is inert, and it would claim the
+ * route a second time if that adapter were ever mounted again.
+ * Never throws: /model and /provider must open regardless.
  * @returns whether the settings changed.
  */
 export async function migrateOpenRouterProfile(settings) {
   try {
     const descriptor = settings?.describe?.({ redactSecrets: true }).find(entry => entry.ns === PI_AI_NS);
-    if (!descriptor || settings.writable !== true || !isNarrowOpenRouterProfile(descriptor.value?.providers?.openrouter)) return false;
-    await settings.mutate(PI_AI_NS, [{ op: 'set', path: ['providers', 'openrouter'], value: openRouterProfile() }], descriptor.revision);
+    if (!descriptor || settings.writable !== true || descriptor.value?.providers?.openrouter === undefined) return false;
+    await settings.mutate(PI_AI_NS, [{ op: 'unset', path: ['providers', 'openrouter'] }], descriptor.revision);
     return true;
   } catch {
     return false;
@@ -156,25 +115,16 @@ export function credentialState(row) {
 }
 
 /**
- * Declare a provider's route before it is used. Only OpenRouter needs one; a
- * profile the user already has (their own models or endpoint) is left alone,
- * while the narrow profile earlier builds wrote is replaced.
+ * Prepare a provider before a switch. Both routes are always registered; switching
+ * to OpenRouter only clears the inert pi-ai profile earlier builds wrote.
  * @param settings - the host settings service.
  * @returns whether the settings changed.
  */
 export async function ensureProviderRoute(settings, provider) {
-  if (provider !== 'openrouter') return false;
-  if (typeof settings?.describe !== 'function' || typeof settings.mutate !== 'function') throw new Error('settings are unavailable; OpenRouter cannot be configured in this profile');
-  const descriptor = settings.describe({ redactSecrets: true }).find(entry => entry.ns === PI_AI_NS);
-  if (!descriptor) throw new Error('the OpenRouter adapter (llm-pi-ai) is not mounted in this profile');
-  const existing = descriptor.value?.providers?.openrouter;
-  if (existing !== undefined) return migrateOpenRouterProfile(settings);
-  if (settings.writable !== true) throw new Error('settings are read-only; OpenRouter cannot be configured here');
-  await settings.mutate(PI_AI_NS, [{ op: 'set', path: ['providers', 'openrouter'], value: openRouterProfile() }], descriptor.revision);
-  return true;
+  return provider === 'openrouter' ? migrateOpenRouterProfile(settings) : false;
 }
 
-/** Wait for a freshly declared route to reach the model directory. */
+/** Wait for a route's models to reach the model directory. */
 export async function waitForModels(loadModels, provider, { attempts = 30, delayMs = 100 } = {}) {
   let directory;
   for (let attempt = 0; attempt < attempts; attempt++) {

package/vendor/tui/dscode-providers/openrouter-account.mjs

@@ -0,0 +1,171 @@
+// OpenRouter account facts for /openrouter and the footer balance. The inference key
+// reads the account credits and its own limit and usage; an optional management key,
+// which cannot call models, adds every key's usage and the last 30 days of spend.
+// This directory also ships beside the TUI, so the module imports nothing.
+export const OPENROUTER_API = 'https://openrouter.ai/api/v1';
+export const MANAGEMENT_REF = 'OPENROUTER_MANAGEMENT_KEY';
+
+const finite = value => {
+  const number = Number(value);
+  return value !== null && value !== undefined && value !== '' && Number.isFinite(number) ? number : undefined;
+};
+
+export class OpenRouterAccountError extends Error {
+  constructor(message, status) {
+    super(message);
+    this.name = 'OpenRouterAccountError';
+    this.status = status;
+  }
+}
+
+async function get(path, key, { fetch: fetchImpl = globalThis.fetch, signal } = {}) {
+  let response;
+  try {
+    response = await fetchImpl(`${OPENROUTER_API}${path}`, { headers: { authorization: `Bearer ${key}`, accept: 'application/json' }, signal });
+  } catch (error) {
+    throw new OpenRouterAccountError(`OpenRouter is unreachable: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  let body;
+  try { body = await response.json(); } catch { body = undefined; }
+  if (!response.ok) throw new OpenRouterAccountError(typeof body?.error?.message === 'string' ? body.error.message : `HTTP ${response.status}`, response.status);
+  return body;
+}
+
+/** Account credits from a `/credits` body, or undefined when it carries none. */
+export function creditsOf(body) {
+  const total = finite(body?.data?.total_credits), used = finite(body?.data?.total_usage);
+  if (total === undefined || used === undefined || total < 0 || used < 0) return undefined;
+  return { total, used, remaining: Math.max(0, total - used) };
+}
+
+/** Remaining USD account credits from a `/credits` body: purchased minus used. */
+export function parseOpenRouterCredits(body) {
+  return creditsOf(body)?.remaining ?? null;
+}
+
+/** Remaining USD credit limit from a `/key` body; null when the key has no limit. */
+export function parseOpenRouterKeyRemaining(body) {
+  const remaining = body?.data?.limit_remaining;
+  if (remaining == null) return null;
+  const value = Number(remaining);
+  return Number.isFinite(value) ? Math.max(0, value) : null;
+}
+
+function keyOf(raw) {
+  return {
+    label: typeof raw?.label === 'string' ? raw.label : undefined,
+    name: typeof raw?.name === 'string' && raw.name.length > 0 ? raw.name : undefined,
+    disabled: raw?.disabled === true,
+    limit: finite(raw?.limit),
+    limitRemaining: finite(raw?.limit_remaining),
+    usage: finite(raw?.usage),
+    usageDaily: finite(raw?.usage_daily),
+    usageWeekly: finite(raw?.usage_weekly),
+    usageMonthly: finite(raw?.usage_monthly),
+  };
+}
+
+/**
+ * Verify a management key before it is stored. Account activity is the reading OpenRouter
+ * refuses an inference key; `/credits`, though documented as management-only, serves both.
+ * @throws OpenRouterAccountError with a message fit for the key prompt.
+ */
+export async function verifyManagementKey(key, options) {
+  try {
+    await get('/activity', key, options);
+  } catch (error) {
+    if (error instanceof OpenRouterAccountError && (error.status === 401 || error.status === 403)) {
+      throw new OpenRouterAccountError('This is not a management key: OpenRouter refused it for account data. Create one under Settings → Management keys.', error.status);
+    }
+    throw error;
+  }
+}
+
+/** The `/activity` rows (last 30 completed UTC days) as totals and the top models with the providers that served them. */
+export function summarizeActivity(rows, top = 5) {
+  const models = new Map(), days = new Set();
+  let usage = 0, requests = 0;
+  for (const row of Array.isArray(rows) ? rows : []) {
+    if (typeof row?.model !== 'string') continue;
+    const cost = finite(row.usage) ?? 0, count = finite(row.requests) ?? 0;
+    usage += cost;
+    requests += count;
+    if (typeof row.date === 'string') days.add(row.date);
+    const entry = models.get(row.model) ?? { model: row.model, usage: 0, requests: 0, providers: new Map() };
+    entry.usage += cost;
+    entry.requests += count;
+    const name = typeof row.provider_name === 'string' && row.provider_name.length > 0 ? row.provider_name : 'unknown';
+    const served = entry.providers.get(name) ?? { name, usage: 0, requests: 0 };
+    served.usage += cost;
+    served.requests += count;
+    entry.providers.set(name, served);
+    models.set(row.model, entry);
+  }
+  const ranked = [...models.values()].sort((left, right) => right.usage - left.usage || right.requests - left.requests).slice(0, top)
+    .map(entry => ({ ...entry, providers: [...entry.providers.values()].sort((left, right) => right.usage - left.usage) }));
+  return { usage, requests, days: days.size, modelCount: models.size, models: ranked };
+}
+
+/**
+ * Everything /openrouter shows. Each section settles on its own: `{ value }`, `{ error }`,
+ * or undefined when the key it needs is missing.
+ */
+export async function loadOpenRouterAccount({ apiKey, managementKey, fetch, signal } = {}) {
+  const options = { fetch, signal };
+  const section = (key, run) => key ? run().then(value => ({ value }), error => ({ error: error instanceof Error ? error.message : String(error) })) : Promise.resolve(undefined);
+  const [key, credits, keys, activity] = await Promise.all([
+    section(apiKey, async () => keyOf((await get('/key', apiKey, options))?.data)),
+    section(managementKey ?? apiKey, async () => {
+      const credits = creditsOf(await get('/credits', managementKey ?? apiKey, options));
+      if (!credits) throw new Error('OpenRouter returned no account credits');
+      return credits;
+    }),
+    section(managementKey, async () => {
+      const body = await get('/keys', managementKey, options);
+      return (Array.isArray(body?.data) ? body.data : []).map(keyOf);
+    }),
+    section(managementKey, async () => summarizeActivity((await get('/activity', managementKey, options))?.data)),
+  ]);
+  return { hasApiKey: Boolean(apiKey), hasManagementKey: Boolean(managementKey), key, credits, keys, activity };
+}
+
+const money = value => Number.isFinite(value) ? `$${value.toFixed(2)}` : '$--';
+const limitText = key => key.limit === undefined ? 'no limit' : `limit ${money(key.limit)}, ${money(key.limitRemaining)} left`;
+
+/**
+ * The panel's lines for a loaded account.
+ * @returns `{ text, tone }` rows; tone is `title`, `value`, `dim` or `error`.
+ */
+export function openRouterAccountLines(account, { maxKeys = 5 } = {}) {
+  const lines = [];
+  const push = (text, tone = 'value') => lines.push({ text, tone });
+  if (!account.hasApiKey) push('No OpenRouter API key: run /login openrouter.', 'error');
+  if (account.credits?.value) {
+    const { remaining, total, used } = account.credits.value;
+    push(`Account balance  ${money(remaining)} · credits ${money(total)} · used ${money(used)}`, 'title');
+  } else if (account.credits?.error) push(`Account balance unavailable: ${account.credits.error}`, 'error');
+  else push('Account balance  $--', 'dim');
+  if (account.key?.value) {
+    const key = account.key.value;
+    push(`This key  ${key.label ?? 'unnamed'} · ${limitText(key)}`, 'title');
+    push(`  today ${money(key.usageDaily)} · week ${money(key.usageWeekly)} · month ${money(key.usageMonthly)}`, 'dim');
+  } else if (account.key?.error) push(`This key unavailable: ${account.key.error}`, 'error');
+  if (!account.hasManagementKey) push('API keys and 30-day spend  press m to add a management key', 'dim');
+  if (account.keys?.value) {
+    const keys = [...account.keys.value].sort((left, right) => (right.usageMonthly ?? 0) - (left.usageMonthly ?? 0));
+    push(`API keys (${keys.length})`, 'title');
+    for (const key of keys.slice(0, maxKeys)) {
+      const current = account.key?.value?.label !== undefined && key.label === account.key.value.label;
+      push(`  ${key.name ?? key.label ?? 'unnamed'}${current ? ' (this key)' : ''}${key.disabled ? ' · disabled' : ''} · today ${money(key.usageDaily)} · month ${money(key.usageMonthly)} · ${limitText(key)}`, key.disabled ? 'dim' : 'value');
+    }
+    if (keys.length > maxKeys) push(`  +${keys.length - maxKeys} more`, 'dim');
+  } else if (account.keys?.error) push(`API keys unavailable: ${account.keys.error}`, 'error');
+  if (account.activity?.value) {
+    const activity = account.activity.value;
+    push(`Last 30 days  ${money(activity.usage)} · ${activity.requests} requests · ${activity.modelCount} models`, 'title');
+    for (const model of activity.models) {
+      push(`  ${model.model} · ${money(model.usage)} · ${model.requests} req · ${model.providers.map(provider => `${provider.name} ${money(provider.usage)}`).join(', ')}`);
+    }
+  } else if (account.activity?.error) push(`Activity unavailable: ${account.activity.error}`, 'error');
+  return lines;
+}