@code-yeongyu/senpi-ai 2026.10.20-1 → 2026.10.21-2

package/dist/api/anthropic-messages.js

@@ -75,7 +75,7 @@ function getCacheControl(model, cacheRetention, env) {
 // The bundled Claude Code version and the floor of the advertised `claude-cli/<version>`
 // (see utils/claude-code-version.ts). Keep this exact declaration: a downstream installer
 // (oh-my-openagent) rewrites it byte-for-byte in the installed dist and bundle.
-const claudeCodeVersion = "2.1.296";
+const claudeCodeVersion = "2.1.306";
 // Claude Code 2.x tool names (canonical casing)
 // Source: https://cchistory.mariozechner.at/data/prompts-2.1.11.md
 // To update: https://github.com/badlogic/cchistory

package/dist/api/azure-openai-responses.js

@@ -8,7 +8,7 @@ import { getProviderEnvValue } from "../utils/provider-env.js";
 import { retryProviderRequest } from "../utils/provider-retry.js";
 import { getDeclaredTools, resolveTranscript, resolveTranscriptTools } from "../utils/transcript.js";
 import { createGrammarToolInputProperties } from "./constrained-sampling.js";
-import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
+import { deriveOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
 import { buildBaseOptions } from "./simple-options.js";
 const DEFAULT_AZURE_API_VERSION = "v1";
@@ -233,7 +233,7 @@ function buildParams(model, context, options, deploymentName, grammarToolInputPr
         stream: true,
         ...((options?.cacheRetention ?? model.cacheRetention) === "none"
             ? {}
-            : { prompt_cache_key: clampOpenAIPromptCacheKey(options?.sessionId) }),
+            : { prompt_cache_key: deriveOpenAIPromptCacheKey(model.id, context) }),
         store: false,
     };
     if (options?.maxTokens) {

package/dist/api/cursor-agent.js

@@ -20,6 +20,7 @@ import * as http2 from "node:http2";
 import { create, fromBinary, fromJson, toBinary, toJson } from "@bufbuild/protobuf";
 import { ValueSchema } from "@bufbuild/protobuf/wkt";
 import { CURSOR_COMPOSER_PROMPT, isCursorComposerModel } from "../cursor/composer-prompt.js";
+import { cursorDiscoveredInput } from "../cursor/model-input.js";
 import { calculateCost } from "../models.js";
 import { registerSessionResourceCleanup } from "../session-resources.js";
 import { clearStreamingPartialJson, kCursorExecResolved, kStreamingBlockIndex, kStreamingBlockKind, kStreamingEnvelopeId, kStreamingLastParseLen, kStreamingPartialJson, } from "../utils/block-symbols.js";
@@ -3788,11 +3789,6 @@ const CURSOR_DEFAULT_MAX_TOKENS = 64_000;
 const CURSOR_1M_CONTEXT_WINDOW = 1_000_000;
 const CURSOR_1M_NAME_PATTERN = /\b1m\b/i;
 const CURSOR_MAX_MODE_1M_ID_PATTERN = /claude|gemini/;
-/**
- * Model-id families whose native catalogs are multimodal. Cursor-only or
- * text-only families (`composer-*`, `grok-code-*`) stay outside this pattern.
- */
-const CURSOR_MULTIMODAL_ID_PATTERN = /claude|gemini|gpt-|codex/;
 /**
  * Fetches Cursor models through `GetUsableModels` (unary protobuf over
  * HTTP/2; the ALB rejects HTTP/1.1 with 464) and normalizes them.
@@ -3882,7 +3878,7 @@ export async function fetchCursorUsableModels(options) {
                 id,
                 name,
                 reasoning: Boolean(model.thinkingDetails),
-                input: CURSOR_MULTIMODAL_ID_PATTERN.test(id.toLowerCase()) ? ["text", "image"] : ["text"],
+                input: cursorDiscoveredInput(id),
                 contextWindow,
                 maxTokens: CURSOR_DEFAULT_MAX_TOKENS,
                 cursorMaxMode: maxMode,

package/dist/api/google-generative-ai.js

@@ -4,6 +4,7 @@ import { formatProviderError, normalizeProviderError } from "../utils/error-body
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { providerHeadersToRecord } from "../utils/headers.js";
 import { getPiUserAgent } from "../utils/pi-user-agent.js";
+import { reportedCount } from "../utils/reported-count.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { getSystemMessageText } from "../utils/text.js";
 import { collapseSystemMessages, getCurrentTools, getInitialSystemMessage } from "../utils/transcript.js";
@@ -191,12 +192,13 @@ export const stream = (model, context, options) => {
                     }
                 }
                 if (chunk.usageMetadata) {
+                    const reasoning = reportedCount(chunk.usageMetadata.thoughtsTokenCount);
                     output.usage = {
                         input: (chunk.usageMetadata.promptTokenCount || 0) - (chunk.usageMetadata.cachedContentTokenCount || 0),
                         output: (chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0),
                         cacheRead: chunk.usageMetadata.cachedContentTokenCount || 0,
                         cacheWrite: 0,
-                        reasoning: chunk.usageMetadata.thoughtsTokenCount || 0,
+                        ...(reasoning === undefined ? {} : { reasoning }),
                         totalTokens: chunk.usageMetadata.totalTokenCount || 0,
                         cost: {
                             input: 0,

package/dist/api/google-vertex.js

@@ -5,6 +5,7 @@ import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { providerHeadersToRecord } from "../utils/headers.js";
 import { getPiUserAgent } from "../utils/pi-user-agent.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
+import { reportedCount } from "../utils/reported-count.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { getSystemMessageText } from "../utils/text.js";
 import { collapseSystemMessages, getCurrentTools, getInitialSystemMessage } from "../utils/transcript.js";
@@ -195,12 +196,13 @@ export const stream = (model, context, options) => {
                     }
                 }
                 if (chunk.usageMetadata) {
+                    const reasoning = reportedCount(chunk.usageMetadata.thoughtsTokenCount);
                     output.usage = {
                         input: (chunk.usageMetadata.promptTokenCount || 0) - (chunk.usageMetadata.cachedContentTokenCount || 0),
                         output: (chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0),
                         cacheRead: chunk.usageMetadata.cachedContentTokenCount || 0,
                         cacheWrite: 0,
-                        reasoning: chunk.usageMetadata.thoughtsTokenCount || 0,
+                        ...(reasoning === undefined ? {} : { reasoning }),
                         totalTokens: chunk.usageMetadata.totalTokenCount || 0,
                         cost: {
                             input: 0,

package/dist/api/openai-codex-responses.js

@@ -28,7 +28,7 @@ import { createGrammarToolInputProperties } from "./constrained-sampling.js";
 import { clearWebSocketFallbackState, getOrCreateWebSocketDebugStats, getWebSocketDebugStats, isWebSocketSseFallbackActive, recordWebSocketFailure, recordWebSocketSseFallback, recordWebSocketSuccess, } from "./openai-codex-responses/fallback-state.js";
 import { codexEventProviderDiagnostic, codexHttpProviderDiagnostic, } from "./openai-codex-responses/provider-diagnostic.js";
 import { buildCodexReasoning } from "./openai-codex-responses/reasoning.js";
-import { applyChatGptSubscriptionCacheAffinityHeaders, clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
+import { applyChatGptSubscriptionCacheAffinityHeaders, clampOpenAIPromptCacheKey, deriveOpenAIPromptCacheKey, } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream, resolveResponsesDeferredToolsMode, resolveResponsesToolPlacement, } from "./openai-responses-shared.js";
 import { applyExtraBody, buildBaseOptions, clampMaxForOpenAI, OPENAI_RESPONSES_RESERVED_BODY_KEYS, } from "./simple-options.js";
 import { startWebSocketLiveness } from "./websocket-liveness.js";
@@ -171,7 +171,7 @@ export const stream = (model, context, options) => {
             const grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(normalizedContext.messages), model.compat?.supportsOpenAIGrammarTools ?? false);
             const cacheSessionId = options?.cacheRetention === "none" ? undefined : options?.sessionId;
             const codexSessionId = clampOpenAIPromptCacheKey(cacheSessionId);
-            let body = buildRequestBody(model, normalizedContext, options, codexSessionId, grammarToolInputProperties);
+            let body = buildRequestBody(model, normalizedContext, options, grammarToolInputProperties);
             const nextBody = await options?.onPayload?.(body, model);
             if (nextBody !== undefined) {
                 body = nextBody;
@@ -402,7 +402,7 @@ export const streamSimple = (model, context, options) => {
 // ============================================================================
 // Request Building
 // ============================================================================
-function buildRequestBody(model, context, options, cacheSessionId, grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(context.messages), model.compat?.supportsOpenAIGrammarTools ?? false)) {
+function buildRequestBody(model, context, options, grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(context.messages), model.compat?.supportsOpenAIGrammarTools ?? false)) {
     const requestedReasoningEffort = options?.reasoningEffort;
     const mappedReasoningEffort = requestedReasoningEffort === undefined
         ? undefined
@@ -436,7 +436,7 @@ function buildRequestBody(model, context, options, cacheSessionId, grammarToolIn
         input: messages,
         text: { verbosity: options?.textVerbosity || "low" },
         include: ["reasoning.encrypted_content"],
-        prompt_cache_key: cacheSessionId,
+        prompt_cache_key: options?.cacheRetention === "none" ? undefined : deriveOpenAIPromptCacheKey(model.id, context),
         tool_choice: options?.toolChoice ?? "auto",
         parallel_tool_calls: true,
     };

package/dist/api/openai-completions.js

@@ -12,6 +12,7 @@ import { getOpenAICompletionsCompat as getCompat, } from "../utils/prompt-cache-
 import { awaitProviderTransport, iterateProviderTransport, openAICompatibleProviderDiagnosticFromError, } from "../utils/provider-diagnostic-sources.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { retryProviderStreamRequest } from "../utils/provider-retry.js";
+import { reportedCount } from "../utils/reported-count.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { getSystemMessageText, renderSystemMessageUpdate } from "../utils/text.js";
 import { primeStreamUntilContent, sendWithForcedToolChoiceFallback } from "../utils/tool-choice-fallback.js";
@@ -1569,12 +1570,13 @@ function parseChunkUsage(rawUsage, model) {
     const input = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
     // OpenAI completion_tokens already includes reasoning_tokens.
     const outputTokens = rawUsage.completion_tokens || 0;
+    const reasoning = reportedCount(rawUsage.completion_tokens_details?.reasoning_tokens);
     const usage = {
         input,
         output: outputTokens,
         cacheRead: cacheReadTokens,
         cacheWrite: cacheWriteTokens,
-        reasoning: rawUsage.completion_tokens_details?.reasoning_tokens || 0,
+        ...(reasoning === undefined ? {} : { reasoning }),
         totalTokens: input + outputTokens + cacheReadTokens + cacheWriteTokens,
         cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
     };

package/dist/api/openai-prompt-cache.d.ts

@@ -1,4 +1,7 @@
+import type { TranscriptContext } from "../types.ts";
 export declare const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+/** Cache affinity belongs to the reusable leading prefix, never to a conversation UUID. */
+export declare function deriveOpenAIPromptCacheKey(modelId: string, context: TranscriptContext): string | undefined;
 export declare function clampOpenAIPromptCacheKey(key: string | undefined): string | undefined;
 export declare function applyChatGptSubscriptionCacheAffinityHeaders(headers: Headers, sessionId: string | undefined): void;
 //# sourceMappingURL=openai-prompt-cache.d.ts.map

package/dist/api/openai-prompt-cache.js

@@ -1,4 +1,26 @@
+import { shortHash } from "../utils/hash.js";
+import { getSystemMessageText } from "../utils/text.js";
+import { getInitialSystemMessage } from "../utils/transcript.js";
 export const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+const PREFIX_VERSION = "senpi-responses-prefix-v1";
+/** Cache affinity belongs to the reusable leading prefix, never to a conversation UUID. */
+export function deriveOpenAIPromptCacheKey(modelId, context) {
+    const initial = getInitialSystemMessage(context.messages);
+    const tools = [...(initial?.toolsAdded ?? [])].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    const prefix = JSON.stringify([
+        PREFIX_VERSION,
+        modelId,
+        initial === undefined ? "" : getSystemMessageText(initial),
+        tools.map(({ name, description, parameters, freeform, constrainedSampling }) => ({
+            name,
+            description,
+            parameters,
+            freeform,
+            constrainedSampling,
+        })),
+    ]);
+    return clampOpenAIPromptCacheKey(`${PREFIX_VERSION}-${shortHash(prefix)}`);
+}
 export function clampOpenAIPromptCacheKey(key) {
     if (key === undefined)
         return undefined;

package/dist/api/openai-responses-shared.js

@@ -3,6 +3,7 @@ import { calculateCost, supportsConfigurationUpdate } from "../models.js";
 import { splitDeferredTools } from "../utils/deferred-tools.js";
 import { shortHash } from "../utils/hash.js";
 import { parseStreamingJson } from "../utils/json-parse.js";
+import { reportedCount } from "../utils/reported-count.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { getSystemMessageText, renderSystemMessageUpdate } from "../utils/text.js";
 import { getCurrentTools, getDeclaredTools, resolveTranscript, resolveTranscriptTools } from "../utils/transcript.js";
@@ -480,7 +481,8 @@ export function convertResponsesTools(tools, options) {
     const defaultStrict = options?.strict === undefined ? false : options.strict;
     const supportsStrictMode = options?.supportsStrictMode ?? true;
     const supportsOpenAIGrammarTools = options?.supportsOpenAIGrammarTools ?? false;
-    return tools.map((tool) => {
+    const sortedTools = [...tools].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    return sortedTools.map((tool) => {
         const grammar = resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools);
         if (grammar) {
             return {
@@ -772,13 +774,14 @@ export async function processResponsesStream(openaiStream, output, stream, model
             const cachedTokens = inputDetails?.cached_tokens || 0;
             // OpenAI platform reports cache_write_tokens; some compatible gateways use cache_creation_tokens.
             const cacheWriteTokens = inputDetails?.cache_write_tokens ?? inputDetails?.cache_creation_tokens ?? 0;
+            const reasoning = reportedCount(response.usage.output_tokens_details?.reasoning_tokens);
             output.usage = {
                 // OpenAI includes cached and cache-write tokens in input_tokens, so subtract both.
                 input: Math.max(0, (response.usage.input_tokens || 0) - cachedTokens - cacheWriteTokens),
                 output: response.usage.output_tokens || 0,
                 cacheRead: cachedTokens,
                 cacheWrite: cacheWriteTokens,
-                reasoning: response.usage.output_tokens_details?.reasoning_tokens || 0,
+                ...(reasoning === undefined ? {} : { reasoning }),
                 totalTokens: response.usage.total_tokens || 0,
                 cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
             };

package/dist/api/openai-responses.js

@@ -17,7 +17,7 @@ import { createGrammarToolInputProperties } from "./constrained-sampling.js";
 import { withGitHubCopilotFailureNote } from "./github-copilot-errors.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { resolveOpenAIClientAuth } from "./openai-client-auth.js";
-import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
+import { deriveOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { applyAllowedToolsChoice, hasRefusedAllowedToolsChoice, isAllowedToolsChoiceRefusal, rememberAllowedToolsChoiceRefusal, restrictToAllowedTools, } from "./openai-responses-allowed-tools.js";
 import { findPromptCacheComparisonResponseId, withPromptCacheComparison, } from "./openai-responses-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream, resolveResponsesDeferredToolsMode, resolveResponsesToolPlacement, } from "./openai-responses-shared.js";
@@ -195,7 +195,7 @@ export const stream = (model, context, options) => {
             params = applyAllowedToolsChoice(params, normalizedContext, context.activeToolNames, compat);
             if (hasRefusedAllowedToolsChoice(model))
                 params = restrictToAllowedTools(params);
-            const limitedTools = limitGitHubCopilotTools(model.provider, params.tools, params.tool_choice);
+            const limitedTools = limitGitHubCopilotTools(model.provider, params.tools, params.tool_choice, getDeclaredTools(normalizedContext.messages).map((tool) => tool.name));
             if (limitedTools.omittedCount > 0) {
                 params = { ...params, tools: limitedTools.tools };
                 recordGitHubCopilotToolLimit(output, limitedTools.omittedCount);
@@ -348,7 +348,7 @@ export async function warmOpenAIResponsesPromptCache(model, context, options) {
     if (nextParams !== undefined)
         params = nextParams;
     params = sanitizeUnsupportedNativeTools(params, compat);
-    const limitedTools = limitGitHubCopilotTools(model.provider, params.tools, params.tool_choice);
+    const limitedTools = limitGitHubCopilotTools(model.provider, params.tools, params.tool_choice, getDeclaredTools(prefix.messages).map((tool) => tool.name));
     if (limitedTools.omittedCount > 0)
         params = { ...params, tools: limitedTools.tools };
     const body = {
@@ -443,10 +443,7 @@ function buildParams(model, context, options, compat = getCompat(model, options?
         model: model.id,
         input: messages,
         stream: true,
-        prompt_cache_key: cacheRetention === "none" ||
-            (isNativeEndpoint && (compat.supportsExplicitPromptCacheMode || model.cost.cacheWrite > 0))
-            ? undefined
-            : clampOpenAIPromptCacheKey(options?.sessionId),
+        prompt_cache_key: cacheRetention === "none" ? undefined : deriveOpenAIPromptCacheKey(model.id, context),
         prompt_cache_retention: getPromptCacheRetention(compat, cacheRetention),
         prompt_cache_options: withPromptCacheComparison(getPromptCacheOptions(compat, cacheRetention), comparisonResponseId),
         store: false,

package/dist/auth/pool/kinds.d.ts

@@ -0,0 +1,17 @@
+import type { Credential } from "../types.ts";
+import { type CredentialSlot, type PooledCredential } from "./slots.ts";
+export type CredentialKind = Credential["type"];
+/**
+ * A slot's kind from its own material: OAuth tokens make an OAuth login, a key alone makes an API
+ * key. A slot with neither is not classified, so a caller never drops or reports it by guess.
+ */
+export declare function slotKind(slot: Pick<CredentialSlot, "access" | "refresh" | "key">): CredentialKind | undefined;
+/**
+ * Kinds held by a credential's slots that its top-level type cannot use: slots are projected
+ * through that type, so a slot of the other kind is never used (senpi#3448). Builds before the
+ * fix appended a login of the other kind this way.
+ */
+export declare function unusedSlotKinds(credential: PooledCredential | undefined): ReadonlyArray<CredentialKind>;
+/** The slots a credential can actually use: a slot of the other kind never projects (senpi#3486). */
+export declare function slotsOfOwnKind(credential: PooledCredential): CredentialSlot[];
+//# sourceMappingURL=kinds.d.ts.map

package/dist/auth/pool/kinds.js

@@ -0,0 +1,32 @@
+import { listSlots } from "./slots.js";
+/**
+ * A slot's kind from its own material: OAuth tokens make an OAuth login, a key alone makes an API
+ * key. A slot with neither is not classified, so a caller never drops or reports it by guess.
+ */
+export function slotKind(slot) {
+    if (slot.access !== undefined || slot.refresh !== undefined)
+        return "oauth";
+    return slot.key !== undefined ? "api_key" : undefined;
+}
+/**
+ * Kinds held by a credential's slots that its top-level type cannot use: slots are projected
+ * through that type, so a slot of the other kind is never used (senpi#3448). Builds before the
+ * fix appended a login of the other kind this way.
+ */
+export function unusedSlotKinds(credential) {
+    if (!credential || !Array.isArray(credential.accounts))
+        return [];
+    const kinds = new Set();
+    for (const slot of listSlots(credential)) {
+        const kind = slotKind(slot);
+        if (kind !== undefined && kind !== credential.type)
+            kinds.add(kind);
+    }
+    return [...kinds];
+}
+/** The slots a credential can actually use: a slot of the other kind never projects (senpi#3486). */
+export function slotsOfOwnKind(credential) {
+    return listSlots(credential).filter((slot) => slotKind(slot) !== otherKind(credential.type));
+}
+const otherKind = (kind) => (kind === "oauth" ? "api_key" : "oauth");
+//# sourceMappingURL=kinds.js.map

package/dist/auth/pool/slots.d.ts

@@ -89,7 +89,7 @@ export declare function projectSlot(credential: PooledCredential | undefined, na
  * `onAllocated` reports the account this login committed, so a caller can name
  * it in a receipt without re-reading storage.
  */
-export declare function appendLoginSlot(current: PooledCredential | undefined, flat: Credential, onAllocated?: (name: string, origin: "generated" | "provider") => void): Credential;
+export declare function appendLoginSlot(stored: PooledCredential | undefined, flat: Credential, onAllocated?: (name: string, origin: "generated" | "provider") => void): Credential;
 /**
  * Material a provider writes into the flat credential when the real token lives
  * outside auth.json (an SDK subprocess or a vendor CLI owns it): the literal

package/dist/auth/pool/slots.js

@@ -306,7 +306,10 @@ function hasNewerMaterial(candidate, stored) {
  * `onAllocated` reports the account this login committed, so a caller can name
  * it in a receipt without re-reading storage.
  */
-export function appendLoginSlot(current, flat, onAllocated) {
+export function appendLoginSlot(stored, flat, onAllocated) {
+    // A pool holds one kind: a login of the other kind replaces the credential instead of joining it
+    // as a slot nothing can project (senpi#3448). The caller backs up what it replaces.
+    const current = stored?.type === flat.type ? stored : undefined;
     const provided = providedSlots(flat);
     if (provided) {
         // Provider-owned envelopes identify an addition by immutable ID, never by

package/dist/cursor/capability-table.d.ts

@@ -0,0 +1,10 @@
+import type { CursorModelCapability } from "./model-capabilities.ts";
+/**
+ * Static cursor capability table. Values come from the live
+ * aiserver.v1 AvailableModels capture of 2026-08-18 (evidence:
+ * local-ignore/qa-evidence/20260818-cursor-reasoning-levels/available-models-catalog.json).
+ * `GetUsableModels` carries no window or parameter field, so this table is the
+ * authoritative source; see .omo/plans/cursor-reasoning-levels.md §3.1/§6.
+ */
+export declare const CURSOR_MODEL_CAPABILITIES: Record<string, CursorModelCapability>;
+//# sourceMappingURL=capability-table.d.ts.map

package/dist/cursor/capability-table.js

@@ -0,0 +1,183 @@
+const P = "parameters";
+const V = "variant-id";
+function ladder(values, encoding = P) {
+    const out = {};
+    for (const value of values)
+        out[value === "none" ? "off" : value] = { value, encoding };
+    return out;
+}
+const CLAUDE_ORDER = ["thinking", "context", "effort"];
+const GPT_ORDER = ["context", "reasoning", "fast"];
+function claude(window, maxWindow, levels, defaultContext) {
+    return {
+        evidence: "available-models",
+        window,
+        maxWindow,
+        parameterOrder: CLAUDE_ORDER,
+        defaultContext,
+        requestContext: window >= 1_000_000 ? "1m" : defaultContext,
+        levels: ladder(levels),
+    };
+}
+function gpt(levels, order = GPT_ORDER, window = 400000, maxWindow = 400000) {
+    return {
+        evidence: "available-models",
+        window,
+        maxWindow,
+        parameterOrder: order,
+        defaultContext: "272k",
+        requestContext: order.includes("context") && window >= 1_000_000 ? "1m" : undefined,
+        levels: ladder(levels),
+    };
+}
+const LEVELS_LOW_MAX = ["low", "medium", "high", "xhigh", "max"];
+const CONTEXT_TOKEN = { 300000: "300k", 256000: "256k" };
+/** A family whose window is the default context option the server reported serving. */
+function served(window, maxWindow, order, levels) {
+    const context = order.includes("context") ? CONTEXT_TOKEN[window] : undefined;
+    return {
+        evidence: "served-checkpoint",
+        window,
+        ...(maxWindow !== undefined ? { maxWindow } : {}),
+        parameterOrder: order,
+        ...(context !== undefined ? { defaultContext: context, requestContext: context } : {}),
+        levels: ladder(levels),
+    };
+}
+/**
+ * Static cursor capability table. Values come from the live
+ * aiserver.v1 AvailableModels capture of 2026-08-18 (evidence:
+ * local-ignore/qa-evidence/20260818-cursor-reasoning-levels/available-models-catalog.json).
+ * `GetUsableModels` carries no window or parameter field, so this table is the
+ * authoritative source; see .omo/plans/cursor-reasoning-levels.md §3.1/§6.
+ */
+export const CURSOR_MODEL_CAPABILITIES = {
+    "claude-fable-5": claude(1000000, 1000000, ["low", "medium", "high", "xhigh", "max"], "300k"),
+    "claude-sonnet-5": claude(1000000, 1000000, ["low", "medium", "high", "xhigh", "max"], "300k"),
+    "claude-opus-4-7": claude(1000000, 1000000, ["low", "medium", "high", "xhigh", "max"], "300k"),
+    "claude-opus-4-8": claude(1000000, 1000000, ["low", "medium", "high", "xhigh", "max"], "300k"),
+    "claude-opus-5": claude(1000000, 1000000, ["low", "medium", "high", "xhigh", "max"], "300k"),
+    "claude-4.6-opus": claude(1000000, 1000000, ["high", "max"], "200k"),
+    "claude-4.6-sonnet": claude(1000000, 1000000, ["medium"], "200k"),
+    "claude-4.5-opus": {
+        evidence: "available-models",
+        window: 200000,
+        parameterOrder: ["thinking"],
+        levels: { high: { value: "high", encoding: V } },
+    },
+    "gpt-5.6-sol": gpt(["none", "low", "medium", "high", "xhigh", "max"], GPT_ORDER, 1000000, 1000000),
+    "gpt-5.6-luna": gpt(["none", "low", "medium", "high", "xhigh", "max"], GPT_ORDER, 1000000, 1000000),
+    "gpt-5.6-terra": gpt(["none", "low", "medium", "high", "xhigh", "max"], GPT_ORDER, 272000, 272000),
+    "gpt-5.5": {
+        ...gpt(["none", "low", "medium", "high"], GPT_ORDER, 1000000, 1000000),
+        levels: { ...ladder(["none", "low", "medium", "high"]), xhigh: { value: "extra-high", encoding: P } },
+    },
+    "gpt-5.3-codex": {
+        ...gpt([], ["reasoning", "fast"]),
+        maxWindow: undefined,
+        defaultContext: undefined,
+        levels: { ...ladder(["low", "medium", "high"]), xhigh: { value: "extra-high", encoding: P } },
+    },
+    "gpt-5.1": {
+        ...gpt([], ["reasoning"]),
+        maxWindow: undefined,
+        defaultContext: undefined,
+        levels: ladder(["low", "high"]),
+    },
+    "gpt-5.2": {
+        ...gpt([], ["reasoning"]),
+        maxWindow: undefined,
+        defaultContext: undefined,
+        levels: { ...ladder(["low", "high"]), xhigh: { value: "xhigh", encoding: V } },
+    },
+    "gpt-5.4": {
+        ...gpt([], ["reasoning"]),
+        maxWindow: undefined,
+        defaultContext: undefined,
+        levels: { ...ladder(["low", "medium", "high"]), xhigh: { value: "xhigh", encoding: V } },
+    },
+    "gpt-5.4-mini": {
+        evidence: "available-models",
+        window: 400_000,
+        parameterOrder: [],
+        levels: ladder(["none", "low", "medium", "high", "xhigh"], V),
+    },
+    "gpt-5.4-nano": {
+        ...gpt([], ["reasoning"]),
+        maxWindow: undefined,
+        defaultContext: undefined,
+        levels: ladder(["none", "low", "medium", "high", "xhigh"]),
+    },
+    "gemini-3.7-flash": {
+        evidence: "cli-live",
+        window: 1_048_576,
+        parameterOrder: ["effort"],
+        levels: ladder(["low", "medium", "high"]),
+    },
+    "gemini-3.6-flash": {
+        evidence: "suffix-only",
+        window: 1_048_576,
+        parameterOrder: [],
+        levels: ladder(["minimal", "low", "medium", "high"], V),
+    },
+    "cursor-grok-4.6": {
+        evidence: "available-models",
+        window: 500_000,
+        parameterOrder: ["effort", "fast"],
+        levels: ladder(["low", "medium", "high", "xhigh"]),
+    },
+    "cursor-grok-4.5": {
+        evidence: "suffix-only",
+        window: 500_000,
+        parameterOrder: [],
+        levels: ladder(["low", "medium", "high"], V),
+    },
+    "glm-5.2": {
+        evidence: "available-models",
+        window: 1000000,
+        parameterOrder: ["reasoning"],
+        levels: ladder(["high", "max"]),
+    },
+    "kimi-k3": {
+        evidence: "available-models",
+        window: 1048576,
+        parameterOrder: ["reasoning"],
+        levels: ladder(["low", "high", "max"]),
+    },
+    "composer-2.5": { evidence: "available-models", window: 200000, parameterOrder: ["fast"], levels: {} },
+    "claude-haiku-4-5": { evidence: "available-models", window: 200000, parameterOrder: ["thinking"], levels: {} },
+    "claude-4-sonnet": {
+        evidence: "available-models",
+        window: 200000,
+        parameterOrder: ["thinking", "context"],
+        defaultContext: "200k",
+        levels: {},
+    },
+    "claude-4.5-sonnet": {
+        evidence: "available-models",
+        window: 200_000,
+        parameterOrder: ["thinking", "context"],
+        defaultContext: "200k",
+        levels: {},
+    },
+    "kimi-k2.7-code": { evidence: "available-models", window: 262_144, parameterOrder: [], levels: {} },
+    "gemini-3-flash": { evidence: "available-models", window: 1000000, parameterOrder: [], levels: {} },
+    "gemini-3.1-pro": { evidence: "available-models", window: 1000000, parameterOrder: [], levels: {} },
+    "gemini-3.5-flash": { evidence: "available-models", window: 1_048_576, parameterOrder: [], levels: {} },
+    "gpt-5-mini": { evidence: "available-models", window: 400_000, parameterOrder: [], levels: {} },
+    // Families published after the 2026-08-18 capture (senpi#3620). Windows are the
+    // ceilings the server reported on the first checkpoint on 2026-10-18 for the
+    // suffix variant senpi sends (no context parameter, so Cursor's default option);
+    // maxWindow is the largest context option AvailableModels offers.
+    "claude-opus-5-5": served(300_000, 1_000_000, ["context", "effort", "fast"], LEVELS_LOW_MAX),
+    "claude-fable-5-1": served(300_000, 1_000_000, ["thinking", "context", "effort"], LEVELS_LOW_MAX),
+    "claude-sonnet-5-5": served(300_000, 1_000_000, ["context", "reasoning_effort"], LEVELS_LOW_MAX),
+    "claude-haiku-5-5": served(300_000, 1_000_000, ["thinking", "context", "reasoning_effort"], LEVELS_LOW_MAX),
+    "muse-wonder-1.0": served(300_000, 1_000_000, ["context", "reasoning_effort"], ["minimal", ...LEVELS_LOW_MAX]),
+    "muse-spark-1.3": served(300_000, 1_000_000, ["context", "effort"], ["minimal", ...LEVELS_LOW_MAX]),
+    "grok-4.7": served(256_000, 500_000, ["context", "reasoning_effort", "fast"], ["low", "medium", "high", "xhigh"]),
+    "gemini-4-argon": served(200_000, undefined, ["reasoning_effort"], ["low", "medium", "high"]),
+    "gemini-3.8-flash": served(200_000, undefined, ["reasoning_effort"], ["low", "medium", "high"]),
+    default: served(256_000, undefined, [], []),
+};
+//# sourceMappingURL=capability-table.js.map

package/dist/cursor/catalog-grouping.js

@@ -1,32 +1,10 @@
 import aliasData from "./cursor-variant-aliases.json" with { type: "json" };
+import { cleanCursorGroupName, dropUnservedSizeToken, sanitizeCursorDisplayName } from "./display-name.js";
 import { CURSOR_MODEL_CAPABILITIES, getCursorVariantAlias, parseCursorVariantId, } from "./model-capabilities.js";
 export { parseCursorVariantId } from "./model-capabilities.js";
 const ALL_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
 const FALLBACK_WINDOW = 200000;
 const STATIC_TARGETS = new Set(Object.values(aliasData.aliases).map((alias) => alias.targetId));
-function isClaude(baseId) {
-    return baseId.startsWith("claude-");
-}
-function cleanName(members, baseId, thinkingMode) {
-    const levelWords = /(Minimal|Low|Medium|High|Extra High|XHigh|Max|None)/g;
-    const representative = members.find((member) => member.level === "high") ??
-        members.find((member) => member.level === "medium") ??
-        members.find((member) => member.level === "low") ??
-        members[0];
-    let name = representative.raw.name;
-    name = name.replace(/\s*\(NO ZDR\)\s*/g, " \u0001").trim();
-    name = name.replace(new RegExp(`\\s+${levelWords.source}\\b`, "g"), "");
-    name = name.replace(/\s+Fast\b/g, "");
-    if (thinkingMode !== true)
-        name = name.replace(/\s+Thinking\b/g, "");
-    name = name
-        .replace(/\u0001/g, "(NO ZDR)")
-        .replace(/\s+/g, " ")
-        .trim();
-    if (name.length === 0)
-        name = baseId;
-    return name;
-}
 function buildLevelMap(members, capability) {
     const observed = new Set(members.map((member) => member.level).filter((level) => level !== undefined));
     const map = {};
@@ -196,10 +174,10 @@ export function normalizeCursorCatalog(rawEntries) {
         const isGrouped = members.length > 1 || first.alias.targetId !== first.raw.id;
         const efforts = members.filter((member) => member.level !== undefined && member.level !== "none");
         if (isGrouped && efforts.length > 0 && !first.fast) {
-            const thinkingMode = isClaude(baseId) ? first.thinking === true : undefined;
+            const thinkingMode = baseId.startsWith("claude-") ? first.thinking === true : undefined;
             out.push({
                 id: first.alias.targetId,
-                name: cleanName(members, baseId, thinkingMode),
+                name: dropUnservedSizeToken(cleanCursorGroupName(members, baseId, thinkingMode), capability),
                 reasoning: true,
                 thinkingLevelMap: derivedGroup ? buildDerivedLevelMap(members) : buildLevelMap(members, capability),
                 window: capability?.window ?? FALLBACK_WINDOW,
@@ -219,7 +197,7 @@ export function normalizeCursorCatalog(rawEntries) {
             const memberCapability = CURSOR_MODEL_CAPABILITIES[memberBase];
             out.push({
                 id: member.raw.id,
-                name: member.raw.name,
+                name: dropUnservedSizeToken(sanitizeCursorDisplayName(member.raw.name), memberCapability),
                 reasoning: false,
                 window: memberCapability?.window ?? FALLBACK_WINDOW,
                 ...(memberCapability?.maxWindow !== undefined ? { maxWindow: memberCapability.maxWindow } : {}),

package/dist/cursor/display-name.d.ts

@@ -0,0 +1,31 @@
+/** Cursor display-name cleanup for catalog identities (senpi#3620). */
+export interface CursorNamedMember {
+    readonly raw: {
+        readonly name: string;
+    };
+    readonly level: string | undefined;
+}
+/** Drops zero-width characters and collapses whitespace in a raw Cursor label. */
+export declare function sanitizeCursorDisplayName(name: string): string;
+/**
+ * Names a grouped identity after its representative variant, without the level, fast and
+ * thinking words that the identity's level map and thinking flag now carry. Cursor labels
+ * the Haiku 5.5 split the other way round ("No Thinking" on the plain variants, nothing on
+ * the thinking ones), so the plain group drops "No Thinking" whole and a thinking group
+ * whose label never said so gains "Thinking".
+ */
+export declare function cleanCursorGroupName(members: readonly CursorNamedMember[], baseId: string, thinkingMode: boolean | undefined): string;
+/** A window the server was measured serving; `window` is what senpi sends. */
+export interface CursorSizedCapability {
+    readonly evidence?: string;
+    readonly window: number;
+}
+/**
+ * A size token may stay in a display name only while the served window backs it. Cursor
+ * labels the 2026-10 generation "1M" for the extended-context tier; the checkpoint the
+ * catalog measures reports 300k for the default option senpi requests, so the token
+ * misleads (senpi#3620 review LOW-1). Entries whose window is only advertised
+ * (`available-models`) keep Cursor's label; their mismatch is senpi#3621's call.
+ */
+export declare function dropUnservedSizeToken(name: string, capability: CursorSizedCapability | undefined): string;
+//# sourceMappingURL=display-name.d.ts.map