Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
52a6c9020This file is pinned to the selected release. Download the original to open it in your design tool.
import { readFile } from 'fs/promises'
import { dirname, join } from 'path'
import { execFile } from 'child_process'
import { promisify } from 'util'
import { env } from '../config/env.js'
import { parseMuseSettings } from '../engines/muse/runtimeProfile.js'
import { parseAmpSession } from '../engines/amp/runtimeProfile.js'
import type { AgentEngine } from '../engines/types.js'
import type { RegisteredSession } from './registry.js'
import {
DEVIN_EFFORTS,
devinFooterModel,
parseDevinModelsOutput,
type DevinModelTarget,
} from '../engines/devin/runtimeProfile.js'
import {
HERMES_EFFORTS,
hermesStatusModel,
parseHermesConfig,
parseHermesModelsCache,
type HermesModelTarget,
} from '../engines/hermes/runtimeProfile.js'
import {
COMMANDCODE_EFFORTS,
commandcodeBannerModel,
COMMANDCODE_EFFORT_LEVELS,
parseCommandcodeModelsOutput,
type CommandcodeModelTarget,
} from '../engines/commandcode/runtimeProfile.js'
import {
opencodeFooterModelId,
parseOpencodeFooter,
parseOpencodeModelsOutput,
type OpencodeModelTarget,
} from '../engines/opencode/runtimeProfile.js'
import {
kiloFooterModelId,
parseKiloModelsOutput,
type KiloModelTarget,
} from '../engines/kilo/runtimeProfile.js'
import {
PI_EFFORTS,
PI_THINKING_LEVELS,
parsePiFooterProfile,
parsePiModelsOutput,
} from '../engines/pi/runtimeProfile.js'
import { parseGrokFooterProfile } from '../engines/grok/runtimeProfile.js'
import { parseAgyFooterProfile } from '../engines/agy/runtimeProfile.js'
export interface RuntimeProfile {
id: string
sessionId: string
engine: AgentEngine
model: string
effort: string
}
export interface RuntimeModelOption {
id: string
displayName: string
}
export interface RuntimeState {
model: string | null
effort: string | null
mode: 'default' | 'plan' | 'unknown'
cliVersion: string | null
observedAt: number | null
}
export interface CursorModelTarget {
rawId: string
modelKey: string
familyLabel: string
context: string | null
reasoning: string | null
fast: boolean | null
thinking: boolean | null
/** Effort text rendered in the idle footer; null means Cursor omits its native default. */
footerEffort?: string | null
}
interface CursorCatalogEntry {
target: CursorModelTarget
effort: string
modelLabel: string
}
interface RuntimeControl {
target: RuntimeProfile
before: string | null
modelConfirmed: boolean
effortConfirmed: boolean
}
interface StateWaiter {
check: () => boolean
resolve: (matched: boolean) => void
timer: NodeJS.Timeout
}
interface CodexCacheModel {
slug?: unknown
display_name?: unknown
visibility?: unknown
supported_reasoning_levels?: Array<{ effort?: unknown }>
}
interface CodexCache {
models?: CodexCacheModel[]
}
const PROFILE_RE = /^runtime-v1:([^:]+):(claude|codex|cursor|commandcode|pi|devin|opencode|hermes|muse|amp|kilo|grok|agy|copilot):([^@]+)@([a-z0-9_-]+)$/i
const CODEX_EFFORTS = new Set(['auto', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'])
const CLAUDE_EFFORTS = new Set(['auto', 'low', 'medium', 'high', 'xhigh', 'max', 'ultracode'])
const CURSOR_EFFORTS = new Set(['auto', 'none', 'low', 'medium', 'high', 'xhigh', 'max'])
const EFFORTS = new Set([
...CODEX_EFFORTS, ...CLAUDE_EFFORTS, ...CURSOR_EFFORTS, ...PI_EFFORTS, ...DEVIN_EFFORTS,
...COMMANDCODE_EFFORTS, ...HERMES_EFFORTS,
])
/**
* Versions whose model UI was driven by hand before wiring it up. Open-ended upward: a newer CLI is
* assumed compatible (the alternative — refusing to switch after every auto-update — is worse), but a
* KNOWN-older one is refused rather than driven blind.
*/
const DEVIN_CONTROL_MIN_VERSION: [number, number, number] = [3000, 3, 22]
const PI_CONTROL_MIN_VERSION: [number, number, number] = [0, 82, 0]
const OPENCODE_CONTROL_MIN_VERSION: [number, number, number] = [1, 18, 7]
/**
* 1.6.0 is the first Command Code that can be driven at all: it added `--list-models` (a catalog on
* stdout) and made `/model <id>` and `/effort <level>` take arguments. On 1.5 and older the only route was
* arrow-driving a 49-row picker, which is exactly what got the first attempt reverted — so older builds
* are refused rather than driven.
*/
const COMMANDCODE_CONTROL_MIN_VERSION: [number, number, number] = [1, 6, 0]
/**
* Hermes ships no version its hook payload exposes, and its `/model` picker has been the same two-level
* arrow list throughout — so it is gated on the picker being recognisable rather than on a number. The
* driver refuses to move if it cannot read the cursor (see setHermes), which is the real safety net.
*/
const HERMES_CONTROL_UNVERSIONED = true
/**
* Cap on how many rows an engine's catalog may contribute. Devin publishes 166 across 72 families, and a
* 49-row picker was enough to stall the device's the device UI task into a watchdog reset (see the Command Code
* revert, 2026-07-30). The device already truncates at CATALOG_MAX/PICK_MAX, but truncation there is
* arbitrary — bounding here keeps the rows we DO send meaningful (see devinModels).
*/
const CATALOG_LIMIT = 96
const BASIC_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max'] as const
const CLAUDE_ALIASES = ['default', 'opus', 'fable', 'sonnet', 'haiku'] as const
const CHANGE_DEBOUNCE_MS = 120
const CLAUDE_ULTRACODE_MIN_VERSION: [number, number, number] = [2, 1, 209]
const CURSOR_CONTROLLED_BUILD = '2026.07.20-8cc9c0b'
const CURSOR_CATALOG_TTL_MS = 5 * 60_000
/** Shared TTL for the stdout catalogs (devin, pi) — same rationale as the cursor one. */
const CATALOG_TTL_MS = 5 * 60_000
import { opencodeBin } from './engineBin.js'
const execFileAsync = promisify(execFile)
function decode(value: string): string | null {
try {
const out = decodeURIComponent(value)
return out ? out : null
} catch {
return null
}
}
export function encodeRuntimeProfile(profile: Omit<RuntimeProfile, 'id'>): string {
return `runtime-v1:${encodeURIComponent(profile.sessionId)}:${profile.engine}:${encodeURIComponent(profile.model)}@${profile.effort}`
}
export function parseRuntimeProfile(value: unknown): RuntimeProfile | null {
if (typeof value !== 'string') return null
const match = PROFILE_RE.exec(value)
if (!match) return null
const sessionId = decode(match[1])
const model = decode(match[3])
const effort = match[4].toLowerCase()
if (!sessionId || !model || !EFFORTS.has(effort)) return null
return {
id: value,
sessionId,
engine: match[2].toLowerCase() as AgentEngine,
model,
effort,
}
}
function record(value: unknown): Record<string, unknown> | null {
return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : null
}
function text(value: unknown): string {
return typeof value === 'string' ? value : ''
}
function stripAnsi(value: string): string {
return value.replace(/\u001b\[[0-9;:]*[A-Za-z]/g, '')
}
function flattenContent(value: unknown): string {
if (typeof value === 'string') return value
if (!Array.isArray(value)) return ''
return value.map((item) => {
if (typeof item === 'string') return item
const obj = record(item)
return text(obj?.text) || text(obj?.content)
}).filter(Boolean).join('\n')
}
function confirmsClaudeAutoEffort(content: string): boolean {
return [
/\b(?:set|reset)\b.{0,40}\b(?:effort level|effort)\b.{0,40}\b(?:auto|model default)\b/i,
/\b(?:effort level|effort)\b.{0,40}\b(?:set|reset)\b.{0,40}\b(?:auto|model default)\b/i,
/\busing\b.{0,40}\bauto\b.{0,40}\beffort\b/i,
].some((pattern) => pattern.test(content))
}
function parseVersion(value: string | null): [number, number, number] | null {
const match = /(?:^|\D)(\d+)\.(\d+)\.(\d+)(?:\D|$)/.exec(value ?? '')
return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null
}
function versionAtLeast(value: string | null, wanted: [number, number, number]): boolean {
const parsed = parseVersion(value)
if (!parsed) return false
for (let i = 0; i < wanted.length; i++) {
if (parsed[i] !== wanted[i]) return parsed[i] > wanted[i]
}
return true
}
export function supportsNativeRuntimeControl(session: RegisteredSession): boolean {
// A gateway agent (`ori claude`, `ori codex`) is DISPLAY-ONLY (owner, 2026-08-17). Its CLI runs with
// gateway model discovery, so the picker holds the user's OpenRouter catalog rather than the native
// aliases this controller knows how to type — and a `/model opus` typed into that pane would be a
// guess. The chip still names what it is running; nothing offers to change it.
if (session.gateway) return false
// Switching is Claude and Codex only (owner, 2026-07-31); everything else is view-only, so it never gets
// here with anything to apply. This is the second gate rather than the only one — modelsForSession
// already returns an empty catalogue for those engines — because a stale profile id from an older device
// would otherwise still drive a CLI the owner took off the switchable list.
if (session.engine === 'claude') return versionAtLeast(session.cliVersion, [2, 1, 153])
if (session.engine !== 'codex') return false
if (session.engine !== 'codex') return false
const version = parseVersion(session.cliVersion)
return !!version && version[0] === 0 && (version[1] === 144 || version[1] === 145)
}
export function codexEffortAllowed(model: string, effort: string): boolean {
if (!CODEX_EFFORTS.has(effort)) return false
if (effort !== 'max' && effort !== 'ultra') return true
return /^gpt-5\.6(?:-|$)/i.test(model) || model.toLowerCase() === 'codex-auto-review'
}
function titlePart(value: string): string {
if (/^gpt$/i.test(value)) return 'GPT'
if (/^xhigh$/i.test(value)) return 'XHigh'
return value.charAt(0).toUpperCase() + value.slice(1)
}
export function runtimeModelLabel(model: string): string {
const alias = /^(default|best|fable|opus|sonnet|haiku)(\[1m\])?$/i.exec(model)
if (alias) return `${titlePart(alias[1].toLowerCase())}${alias[2] ?? ''}`
return model.split(/[-_]/).filter(Boolean).map(titlePart).join(' ')
}
function effortLabel(effort: string): string {
return effort === 'xhigh' ? 'XHigh' : titlePart(effort)
}
function cursorEffortFromId(rawId: string): { effort: string | null; modelKey: string } {
const parts = rawId.split('-')
let index = -1
let width = 1
for (let i = 2; i < parts.length; i++) {
if (parts[i] === 'extra' && parts[i + 1] === 'high') {
index = i
width = 2
i++
} else if (['none', 'low', 'medium', 'high', 'xhigh', 'max'].includes(parts[i])) {
index = i
width = 1
}
}
if (index < 0) return { effort: null, modelKey: rawId }
const rawEffort = parts.slice(index, index + width).join('-')
parts.splice(index, width)
return {
effort: rawEffort === 'extra-high' ? 'xhigh' : rawEffort,
modelKey: parts.join('-'),
}
}
function cursorEffortFromDisplay(value: string): string | null {
const match = /\b(Extra High|None|Low|Medium|High|Max)\b/i.exec(value)
if (!match) return null
return match[1].toLowerCase().replace(/\s+/g, '') === 'extrahigh'
? 'xhigh'
: match[1].toLowerCase()
}
function cursorDisplayParts(displayName: string): {
familyLabel: string
context: string | null
fast: boolean
thinking: boolean
} {
let value = displayName
.replace(/\s+\((?:current|default)(?:,\s*(?:current|default))?\)\s*$/i, '')
.replace(/\s+\(NO ZDR\)\s*$/i, '')
.replace(/\s*[·│]\s*\d+(?:\.\d+)?%.*$/i, '')
.trim()
const contextMatch = /\b(\d+(?:\.\d+)?[KM])\b/i.exec(value)
const context = contextMatch?.[1].toLowerCase() ?? null
const fast = /\bFast\b/i.test(value)
const thinking = !/\bNo\s+Thinking\b/i.test(value) && /\bThinking\b/i.test(value)
value = value
.replace(/\b\d+(?:\.\d+)?[KM]\b/gi, '')
.replace(/\bExtra High\b/gi, '')
.replace(/\b(?:None|Low|Medium|High|Max)\b/gi, '')
.replace(/\bNo\s+Thinking\b/gi, '')
.replace(/\b(?:Fast|Thinking)\b/gi, '')
.replace(/\s+/g, ' ')
.trim()
return { familyLabel: value, context, fast, thinking }
}
/** Strictly parse `agent models`; headings, tips and malformed rows are ignored. */
export function parseCursorModelsOutput(output: string): CursorCatalogEntry[] {
const candidates: Array<CursorCatalogEntry & { explicitEffort: boolean }> = []
for (const rawLine of output.split('\n')) {
const match = /^([a-z0-9][a-z0-9._-]*) - (.+?)\s*$/i.exec(rawLine)
if (!match) continue
const rawId = match[1]
const displayName = match[2].trim()
const display = cursorDisplayParts(displayName)
if (!display.familyLabel) continue
if (rawId === 'auto') {
candidates.push({
target: {
rawId,
modelKey: rawId,
familyLabel: 'Auto',
context: null,
reasoning: null,
fast: null,
thinking: null,
footerEffort: 'auto',
},
effort: 'auto',
modelLabel: 'Auto',
explicitEffort: true,
})
continue
}
const parsed = cursorEffortFromId(rawId)
const effort = parsed.effort
const footerEffort = cursorEffortFromDisplay(displayName)
candidates.push({
target: {
rawId,
modelKey: parsed.modelKey,
familyLabel: display.familyLabel,
context: display.context,
reasoning: effort,
fast: display.fast,
thinking: display.thinking,
footerEffort,
},
effort: effort ?? 'auto',
modelLabel: [
display.familyLabel,
display.context ? `(${display.context.toUpperCase()})` : '',
display.thinking ? 'Thinking' : '',
display.fast ? 'Fast' : '',
].filter(Boolean).join(' '),
explicitEffort: effort !== null,
})
}
// Some medium/default rows omit the effort segment (for example `gpt-5.3-codex`).
// Infer medium only when explicit siblings prove that the same exact model group has efforts.
const effortfulGroups = new Set(candidates.filter((item) => item.explicitEffort).map((item) => item.target.modelKey))
for (const item of candidates) {
if (item.target.rawId === 'auto' || item.effort !== 'auto' || !effortfulGroups.has(item.target.modelKey)) continue
item.effort = 'medium'
item.target.reasoning = 'medium'
}
return candidates.map(({ explicitEffort: _explicitEffort, ...item }) => item)
}
function parseCursorFooter(value: string): {
familyLabel: string
context: string | null
effort: string | null
fast: boolean
thinking: boolean
} | null {
const line = stripAnsi(value).trim()
if (/^Auto(?:\s*$|\s*[·│])/i.test(line)) {
return { familyLabel: 'Auto', context: null, effort: 'auto', fast: false, thinking: false }
}
const effort = cursorEffortFromDisplay(line)
const hasUsage = /[·│]\s*\d+(?:\.\d+)?%/i.test(line)
const hasThinkingMode = /\b(?:No\s+Thinking|Thinking)\b/i.test(line)
if (!effort && !hasUsage && !hasThinkingMode) return null
const parts = cursorDisplayParts(line)
if (!parts.familyLabel || !/\d/.test(parts.familyLabel)) return null
return {
...parts,
effort,
}
}
function cursorSyntheticTarget(
parsed: NonNullable<ReturnType<typeof parseCursorFooter>>,
effort: string,
): CursorModelTarget {
if (parsed.familyLabel.toLowerCase() === 'auto' && parsed.effort === 'auto') {
return {
rawId: 'auto',
modelKey: 'auto',
familyLabel: 'Auto',
context: null,
reasoning: null,
fast: null,
thinking: null,
footerEffort: 'auto',
}
}
const family = parsed.familyLabel.toLowerCase().replace(/[^a-z0-9.]+/g, '-').replace(/^-|-$/g, '') || 'model'
// Keep the public runtime-v1 model key compatible with every client formatter. The Cursor routing
// details remain on CursorModelTarget (and rawId) for selection/confirmation; they do not belong in
// the user-facing profile key as a percent-encoded "[fast=...,thinking=...]" implementation detail.
const modelKey = [
family,
parsed.context?.toLowerCase() ?? '',
parsed.thinking ? 'thinking' : '',
parsed.fast ? 'fast' : '',
].filter(Boolean).join('-')
const parameters = [
parsed.context ? `context=${parsed.context}` : '',
`fast=${parsed.fast}`,
`thinking=${parsed.thinking}`,
].filter(Boolean).join(',')
return {
rawId: `cursor-${family}[${parameters},effort=${effort}]`,
modelKey,
familyLabel: parsed.familyLabel,
context: parsed.context,
reasoning: effort === 'auto' ? null : effort,
fast: parsed.fast,
thinking: parsed.thinking,
footerEffort: parsed.effort,
}
}
function normalizeClaudeDisplay(value: string): string | null {
const cleaned = value
.replace(/\u001b\[[0-9;]*m/g, '')
.replace(/\s+\(default\).*$/i, '')
.replace(/\s+and saved.*$/i, '')
.replace(/\s+for (?:the )?current session.*$/i, '')
.trim()
if (!cleaned) return null
const alias = /^(default|best|fable|opus|sonnet|haiku)(\[1m\])?$/i.exec(cleaned)
if (alias) return `${alias[1].toLowerCase()}${alias[2]?.toLowerCase() ?? ''}`
const family = /^(Fable|Opus|Sonnet|Haiku)\s+(\d+(?:\.\d+)*)(?:\s+\(1M context\))?/i.exec(cleaned)
if (family) return `claude-${family[1].toLowerCase()}-${family[2].replace(/\./g, '-')}${/1M context/i.test(cleaned) ? '[1m]' : ''}`
if (/^claude-[a-z0-9._:-]+(?:\[1m\])?$/i.test(cleaned)) return cleaned.toLowerCase()
return null
}
function claudeAliasForModel(model: string): string | null {
const normalized = model.toLowerCase()
if ((CLAUDE_ALIASES as readonly string[]).includes(normalized)) return normalized
return /^claude-(opus|fable|sonnet|haiku)(?:-|$)/.exec(normalized)?.[1] ?? null
}
function claudeEfforts(model: string, cliVersion: string | null = null): string[] {
// `[1m]` marks the 1M-context variant, not a different model — strip it so `claude-opus-5[1m]` gets
// the same efforts as `claude-opus-5` (otherwise a 1M model looked effort-less and a /model switch
// reset the observed effort to `auto`). The version match is open-ended (4.7/4.8, then 5+) so a new
// release like Opus 5 works without a code change.
const normalized = model.toLowerCase().replace(/\[1m\]$/, '')
let efforts: string[] = []
if (/^claude-(?:opus|fable|sonnet)-(?:4-[78]|[5-9]|\d{2,})(?:-|$)/.test(normalized)) efforts = [...BASIC_EFFORTS]
else if (/^claude-(?:opus|sonnet)-4-6(?:-|$)/.test(normalized)) efforts = ['low', 'medium', 'high', 'max']
else if (/^(?:fable|opus|sonnet)$/.test(normalized)) efforts = [...BASIC_EFFORTS]
if (efforts.length > 0 && versionAtLeast(cliVersion, CLAUDE_ULTRACODE_MIN_VERSION)) efforts.push('ultracode')
return efforts
}
function availableModelMatches(model: string, allowed: string[]): boolean {
if (model === 'default') return true
if (allowed.length === 0) return true
const lower = model.toLowerCase()
const family = lower.replace(/\[1m\]$/, '')
const wantsLongContext = lower.endsWith('[1m]')
return allowed.some((item) => {
const candidate = item.toLowerCase()
const sameFamily = candidate.includes(`-${family}-`) || candidate.endsWith(`-${family}`)
const contextMatches = wantsLongContext === /(?:\[1m\]|1m.context)/i.test(candidate)
return lower === candidate || lower.startsWith(`${candidate}-`) || lower.startsWith(`${candidate}[`) || (sameFamily && contextMatches)
})
}
function currentPaneUi(paneText: string): string {
const lines = paneText.split('\n')
const promptIndex = lines.findLastIndex((line) => {
const marker = line.search(/[›❯→]/u)
return marker >= 0 && !/^\s*\d+\.\s/.test(line.slice(marker + 1))
})
return (promptIndex >= 0 ? lines.slice(promptIndex) : lines).join('\n')
}
async function readJson(file: string): Promise<Record<string, unknown> | null> {
try { return record(JSON.parse(await readFile(file, 'utf8'))) } catch { return null }
}
/** Raw file text, or '' when it cannot be read — hermes' config is YAML, not JSON. */
async function readText(file: string): Promise<string> {
try { return await readFile(file, 'utf8') } catch { return '' }
}
function claudeSettingsFiles(session: RegisteredSession): string[] {
const root = dirname(env.CLAUDE_PROJECTS_DIR)
const files = [join(root, 'settings.json')]
if (session.cwd) {
files.push(join(session.cwd, '.claude', 'settings.json'))
files.push(join(session.cwd, '.claude', 'settings.local.json'))
}
return files
}
async function claudeAvailableModels(session: RegisteredSession): Promise<string[]> {
const merged: string[] = []
for (const file of claudeSettingsFiles(session)) {
const config = await readJson(file)
const values = config?.availableModels
if (!Array.isArray(values)) continue
for (const value of values) if (typeof value === 'string' && !merged.includes(value)) merged.push(value)
}
return merged
}
/** Command Code ids are "vendor/name"; everything we store and show uses the name alone. */
function shortCommandcodeModel(id: string): string {
return id.slice(id.lastIndexOf('/') + 1)
}
/**
* Command Code keeps the reasoning level in its GLOBAL config, keyed by the FULL gateway id:
* { "model": "deepseek/deepseek-v4-flash", "reasoningEffort": { "deepseek/deepseek-v4-flash": "high" } }
* Nothing in the transcript, the pane footer or the session header carries it, so this file is the only
* source. It is per MACHINE rather than per session: two agents on the same model necessarily read the same
* level. Matching is done on the short name because that is what the running model is stored as.
*/
/** The configured level for `model`, or 'auto' when the model has none set. */
async function commandcodeConfiguredEffort(model: string | null): Promise<{ effort: string; defaultModel: string }> {
const config = await readJson(join(env.COMMANDCODE_HOME, 'config.json'))
const defaultModel = shortCommandcodeModel(text(config?.model))
const efforts = record(config?.reasoningEffort)
const wanted = model || defaultModel
if (!efforts || !wanted) return { effort: 'auto', defaultModel }
for (const [id, level] of Object.entries(efforts)) {
if (shortCommandcodeModel(id) !== wanted) continue
const normalized = text(level).toLowerCase()
if (normalized && normalized !== 'default' && EFFORTS.has(normalized)) return { effort: normalized, defaultModel }
}
return { effort: 'auto', defaultModel }
}
async function claudeConfiguredEffort(session: RegisteredSession): Promise<string> {
let configured: string | null = null
for (const file of claudeSettingsFiles(session)) {
const config = await readJson(file)
const raw = text(config?.effortLevel) || text(config?.effort)
const normalized = raw.toLowerCase() === 'default' ? 'auto' : raw.toLowerCase()
if (CLAUDE_EFFORTS.has(normalized)) configured = normalized
}
return configured ?? 'auto'
}
function addOption(
output: RuntimeModelOption[],
seen: Set<string>,
session: RegisteredSession,
model: string,
effort: string,
modelLabel = runtimeModelLabel(model),
): void {
// The id inside a `runtime-v1:` string is what the web/device echoes back on a pick, so it is the
// AGENT id — the public one — not the engine session that happens to be bound right now.
const id = encodeRuntimeProfile({ sessionId: session.agentId, engine: session.engine, model, effort })
if (seen.has(id)) return
seen.add(id)
output.push({ id, displayName: `${modelLabel} / ${effortLabel(effort)}` })
}
export class RuntimeProfileManager {
private readonly states = new Map<string, RuntimeState>()
private readonly controls = new Map<string, RuntimeControl>()
private readonly waiters = new Map<string, Set<StateWaiter>>()
private readonly changeTimers = new Map<string, NodeJS.Timeout>()
private readonly cursorTargets = new Map<string, Map<string, CursorModelTarget>>()
/** profile id → the exact `/model` argument, per session (devin ids are not derivable from the key). */
private readonly devinTargets = new Map<string, Map<string, DevinModelTarget>>()
private devinCatalogCache: { key: string; expiresAt: number; entries: DevinModelTarget[] } | null = null
private piCatalogCache: { key: string; expiresAt: number; entries: ReturnType<typeof parsePiModelsOutput> } | null = null
private opencodeCatalogCache: { key: string; expiresAt: number; entries: OpencodeModelTarget[] } | null = null
private kiloCatalogCache: { key: string; expiresAt: number; entries: KiloModelTarget[] } | null = null
private commandcodeCatalogCache: { key: string; expiresAt: number; entries: CommandcodeModelTarget[] } | null = null
/** profile id → the full `/model` argument (the profile carries the SHORT name the device labels by). */
private readonly commandcodeTargets = new Map<string, Map<string, CommandcodeModelTarget>>()
/** Per HOME, not one slot: a desk with a default-home agent and a profile agent would otherwise
* evict each other's catalog on every menu open (`hermes -p <name>` has its own providers). */
private hermesCatalogCache = new Map<string, { expiresAt: number; entries: HermesModelTarget[] }>()
/** profile id → the picker page + row a hermes model sits on. */
private readonly hermesTargets = new Map<string, Map<string, HermesModelTarget>>()
private cursorCatalogCache: { key: string; expiresAt: number; entries: CursorCatalogEntry[] } | null = null
private suppressNotifications = 0
onChanged: ((sessionId: string) => void) | null = null
hydrate(session: RegisteredSession, rawLines: string[]): void {
if (this.unbound(session.sessionId)) return
this.states.set(session.sessionId, {
// Registries written by older builds can hold a non-string model; treat it as unknown instead of
// letting it reach claudeAliasForModel and abort startup.
model: typeof session.model === 'string' ? session.model : null,
effort: null,
mode: 'unknown',
cliVersion: session.cliVersion,
observedAt: null,
})
for (const line of rawLines) this.ingest(session, line, true)
}
ingest(session: RegisteredSession, rawLine: string, silent = false): boolean {
let raw: Record<string, unknown> | null
try { raw = record(JSON.parse(rawLine)) } catch { return false }
if (!raw) return false
const before = this.selectedModel(session)
if (session.engine === 'codex') this.ingestCodex(session, raw)
else if (session.engine === 'cursor') this.ingestCursor(session, raw)
else if (session.engine === 'commandcode') {
const model = this.states.get(session.sessionId)?.model ?? null
this.ingestCommandcode(session, raw)
// The reasoning level is stored PER MODEL, so a model change makes the level we are holding wrong.
// Re-read it now instead of showing the previous model's level until the next poll.
if ((this.states.get(session.sessionId)?.model ?? null) !== model) {
void this.ingestConfig(session, silent).catch(() => undefined)
}
}
else if (session.engine === 'grok') this.ingestGrok(session, raw)
else this.ingestClaude(session, raw)
const after = this.selectedModel(session)
this.wake(session.sessionId)
if (!silent && this.suppressNotifications === 0 && before !== after && !this.controls.has(session.sessionId)) this.scheduleChanged(session.sessionId)
return before !== after
}
async ingestConfig(session: RegisteredSession, silent = false): Promise<boolean> {
if (session.engine === 'hermes') {
// Both axes are scalars in config.yaml and neither is announced, so this poll is the only reader.
const before = this.selectedModel(session)
const state = this.state(session.sessionId)
// This agent's OWN home: `hermes -p <name>` keeps its model and effort in the profile's
// config.yaml, and reading the default one reported the wrong model on every profile agent.
const parsed = parseHermesConfig(await readText(join(session.hermesHome || env.HERMES_HOME, 'config.yaml')))
if (parsed.model) state.model = parsed.model.slice(parsed.model.lastIndexOf('/') + 1)
state.effort = parsed.effort ?? 'auto'
state.observedAt = Date.now()
const after = this.selectedModel(session)
this.wake(session.sessionId)
if (!silent && this.suppressNotifications === 0 && before !== after && !this.controls.has(session.sessionId)) {
this.scheduleChanged(session.sessionId)
}
return before !== after
}
if (session.engine === 'muse') {
// Both axes are plain scalars in ~/.config/muse/settings.json (`model`, `reasoning_effort`) and
// neither is announced anywhere, so reading the file IS the only way the chip is ever populated.
// `reasoning_effort` is muse's own vocabulary (none|minimal|low|medium|high|xhigh|ultra); the
// absence of the key means the CLI default, which its own --help documents as `high`.
const before = this.selectedModel(session)
const state = this.state(session.sessionId)
const parsed = parseMuseSettings(await readText(join(env.MUSE_CONFIG_DIR, 'settings.json')))
if (parsed.model) state.model = parsed.model
state.effort = parsed.effort ?? 'auto'
state.observedAt = Date.now()
const after = this.selectedModel(session)
this.wake(session.sessionId)
if (!silent && this.suppressNotifications === 0 && before !== after && !this.controls.has(session.sessionId)) {
this.scheduleChanged(session.sessionId)
}
return before !== after
}
if (session.engine === 'amp') {
// Amp has no models — only agent MODES — so the mode is reported as the model and there is no
// second axis to report. `~/.local/share/amp/session.json` is the only local place it is written.
const before = this.selectedModel(session)
const state = this.state(session.sessionId)
const parsed = parseAmpSession(await readText(join(env.AMP_STATE_DIR, 'session.json')))
if (parsed.mode) state.model = parsed.mode
state.effort = 'auto'
state.observedAt = Date.now()
const after = this.selectedModel(session)
this.wake(session.sessionId)
if (!silent && this.suppressNotifications === 0 && before !== after && !this.controls.has(session.sessionId)) {
this.scheduleChanged(session.sessionId)
}
return before !== after
}
if (session.engine === 'opencode') {
// The footer only resolves against the catalog, so warm it here — `ingestPane` is synchronous and
// cannot fetch, and without this the chip stays blank until the web happens to ask for models.
await this.opencodeCatalog()
return false
}
if (session.engine === 'kilo') {
// Same reason as opencode: kilo names its model only in the composer footer, which resolves only
// against the catalog, and `ingestPane` is synchronous.
await this.kiloCatalog()
return false
}
if (session.engine === 'devin') {
// Same shape: devin's model exists only as a DISPLAY name in its pane footer, and only the catalog
// maps that back to a model key + effort. Warm it on attach so the first pane read resolves.
await this.devinCatalog()
return false
}
if (session.engine !== 'claude' && session.engine !== 'commandcode') return false
const before = this.selectedModel(session)
const state = this.state(session.sessionId)
if (session.engine === 'commandcode') {
const config = await commandcodeConfiguredEffort(state.model)
state.effort = config.effort
// Before the agent has answered once there is no transcript line to read the model from; the config's
// own model is what a fresh session starts on, so the chip names it instead of falling back to Auto.
if (!state.model && config.defaultModel) state.model = config.defaultModel
} else {
state.effort = await claudeConfiguredEffort(session)
}
state.observedAt = Date.now()
const after = this.selectedModel(session)
this.wake(session.sessionId)
if (!silent && this.suppressNotifications === 0 && before !== after && !this.controls.has(session.sessionId)) {
this.scheduleChanged(session.sessionId)
}
return before !== after
}
ingestPane(session: RegisteredSession, paneText: string, silent = false): boolean {
const before = this.selectedModel(session)
const state = this.state(session.sessionId)
paneText = stripAnsi(paneText)
const currentUi = currentPaneUi(paneText)
if (session.engine === 'codex') {
const matches = [...paneText.matchAll(/\b(gpt-[a-z0-9][a-z0-9._-]*)\s+(low|medium|high|xhigh|max|ultra|default)\s*[·│]/gi)]
const latest = matches[matches.length - 1]
if (latest) {
state.model = latest[1].toLowerCase()
state.effort = latest[2].toLowerCase() === 'default' ? 'auto' : latest[2].toLowerCase()
state.observedAt = Date.now()
}
if (/\bplan mode\b/i.test(currentUi)) state.mode = 'plan'
else if (/\b(?:default|work) mode\b/i.test(currentUi)) state.mode = 'default'
} else if (session.engine === 'cursor') {
if (/Available models|Models matching|— Edit Parameters|Type to filter.*Tab to edit|Esc to go back/i.test(currentUi)) return false
const footerLines = currentUi.split('\n')
.filter((line) => stripAnsi(line).trim())
.slice(-12)
.reverse()
const parsed = footerLines.map(parseCursorFooter).find((item) => item !== null)
if (parsed) {
const targets = this.cursorTargets.get(session.sessionId) ?? new Map<string, CursorModelTarget>()
let target = [...targets.values()].find((candidate) =>
candidate.familyLabel.toLowerCase() === parsed.familyLabel.toLowerCase()
&& (parsed.effort
? (candidate.reasoning ?? 'auto') === parsed.effort
: candidate.footerEffort === null)
&& (candidate.fast ?? false) === parsed.fast
&& (candidate.thinking ?? false) === parsed.thinking
&& (!candidate.context || candidate.context === parsed.context))
const effort = parsed.effort ?? target?.reasoning ?? 'auto'
if (!target) {
target = cursorSyntheticTarget(parsed, effort)
const id = encodeRuntimeProfile({
sessionId: session.agentId,
engine: 'cursor',
model: target.modelKey,
effort,
})
targets.set(id, target)
this.cursorTargets.set(session.sessionId, targets)
}
state.model = target.modelKey
state.effort = effort
state.observedAt = Date.now()
const control = this.controls.get(session.sessionId)
if (control && target?.modelKey === control.target.model && effort === control.target.effort) {
control.modelConfirmed = true
control.effortConfirmed = true
}
}
if (/\bPlan\b/i.test(currentUi)) state.mode = 'plan'
else if (/Plan, search, build anything/i.test(currentUi)) state.mode = 'default'
} else if (session.engine === 'devin') {
// Devin writes no transcript unless the user passes `--export`, so the footer's bottom-left cell is
// the only per-session record of the running model. It is a DISPLAY name (`SWE-1.6 Slow`); the
// catalog resolves it back to a model key so the chip and the picker agree.
const label = devinFooterModel(paneText)
const model = label ? this.devinModelKeyForLabel(session.sessionId, label) : null
if (model) {
state.model = model.modelKey
state.effort = model.effort
state.observedAt = Date.now()
this.confirmObserved(session.sessionId, model.modelKey, model.effort)
}
} else if (session.engine === 'hermes') {
// `⚕ minimax-m3 │ ctx --` — the status line is how a switch is seen immediately; config.yaml is
// rewritten too, but the poll that reads it runs on its own schedule.
const model = hermesStatusModel(paneText)
if (model && model !== state.model) {
state.model = model
state.observedAt = Date.now()
}
} else if (session.engine === 'commandcode') {
// `/model` reprints the session banner (`# models: kimi-k2.6 · taste-1`) with the new model. The
// transcript would say the same thing, but only after the NEXT turn runs — too late to confirm a
// switch, and long enough for the chip to look stuck.
const model = commandcodeBannerModel(paneText)
if (model && model !== state.model) {
state.model = model
state.observedAt = Date.now()
// Effort is stored per model in the CLI's global config, so the level we hold belongs to the old
// one. Re-read rather than carry it across.
void this.ingestConfig(session, true).catch(() => undefined)
}
} else if (session.engine === 'opencode') {
// OpenCode names what is running in its composer footer
// (`Build · MiniMax M3 (vibe) Vibe Gateway · high`). Prefer the catalog entry it resolves to,
// because that id is also what a SWITCH is addressed to — the cached entries rather than a
// fresh (async) fetch, since this runs on the pane poll.
//
// Fall back to the footer's own words when the catalog does not list it. That is not a corner
// case: with no provider connected OpenCode runs a built-in free model that `opencode models`
// never prints, so insisting on a catalog match left the chips blank on a freshly opened agent
// — showing nothing about a model the terminal was naming two lines below.
const footer = parseOpencodeFooter(paneText)
const id = opencodeFooterModelId(paneText, this.opencodeCatalogCache?.entries ?? [])
const model = id ?? footer?.target ?? null
if (model) {
// 'auto' remains the default: early builds had no reasoning axis at all, and inventing a
// level for them would put a wrong value on the chip instead of an empty one.
const effort = footer?.effort ?? 'auto'
state.model = model
state.effort = effort
state.observedAt = Date.now()
this.confirmObserved(session.sessionId, model, effort)
}
} else if (session.engine === 'kilo') {
// Kilo names the model in its composer footer too, but the line is shaped differently enough that
// its resolver had to be rewritten rather than renamed — see engines/kilo/runtimeProfile.ts.
const id = kiloFooterModelId(paneText, this.kiloCatalogCache?.entries ?? [])
if (id) {
state.model = id
state.effort = 'auto'
state.observedAt = Date.now()
this.confirmObserved(session.sessionId, id, 'auto')
}
} else if (session.engine === 'pi') {
// Pi puts both axes in one footer cell: `minimax/minimax-m3 • high`.
const footer = parsePiFooterProfile(paneText)
if (footer) {
state.model = footer.model
state.effort = footer.effort
state.observedAt = Date.now()
this.confirmObserved(session.sessionId, footer.model, footer.effort)
}
} else if (session.engine === 'grok') {
const footer = parseGrokFooterProfile(paneText)
if (footer) {
state.model = footer.model
state.effort = footer.effort
state.observedAt = Date.now()
}
} else if (session.engine === 'agy') {
// agy's transcript never names the model, so the pane footer is the only continuous source; the
// hook payload's `modelName` seeds it at session start.
const footer = parseAgyFooterProfile(paneText)
if (footer) {
state.model = footer.model
state.effort = footer.effort
state.observedAt = Date.now()
}
} else {
const header = /(Fable|Opus|Sonnet|Haiku)\s+(\d+(?:\.\d+)*)(\s+\(1M context\))?\s+with\s+(low|medium|high|xhigh|max|ultracode)\s+effort/gi
const matches = [...paneText.matchAll(header)]
const latest = matches[matches.length - 1]
if (latest) {
state.model = `claude-${latest[1].toLowerCase()}-${latest[2].replace(/\./g, '-')}${latest[3] ? '[1m]' : ''}`
state.effort = latest[4].toLowerCase()
state.observedAt = Date.now()
}
const footer = paneText.split('\n').slice(-8).join('\n')
if (/─+\s*ultracode\s*─+/i.test(footer)) {
state.effort = 'ultracode'
state.observedAt = Date.now()
}
if (/\bplan mode on\b/i.test(currentUi)) state.mode = 'plan'
else if (/\b(?:auto|default) mode on\b/i.test(currentUi)) state.mode = 'default'
}
const after = this.selectedModel(session)
this.wake(session.sessionId)
if (!silent && this.suppressNotifications === 0 && before !== after && !this.controls.has(session.sessionId)) this.scheduleChanged(session.sessionId)
return before !== after
}
getState(sessionId: string): RuntimeState {
return { ...this.state(sessionId) }
}
async withoutChangeEvents<T>(operation: () => Promise<T>): Promise<T> {
this.suppressNotifications++
try { return await operation() } finally { this.suppressNotifications-- }
}
selectedModel(session: RegisteredSession): string | null {
if (this.unbound(session.sessionId)) return null
const state = this.states.get(session.sessionId)
if (!state?.model) return null
const model = session.engine === 'claude' ? claudeAliasForModel(state.model) ?? state.model : state.model
const effort = state.effort ?? (session.engine === 'claude' && claudeEfforts(model).length === 0 ? 'auto' : null)
if (!effort) return null
return encodeRuntimeProfile({
sessionId: session.agentId,
engine: session.engine,
model,
effort,
})
}
beginControl(session: RegisteredSession, target: RuntimeProfile): boolean {
if (this.controls.has(session.sessionId)) return false
const before = this.selectedModel(session)
const current = parseRuntimeProfile(before)
this.controls.set(session.sessionId, {
target,
before,
modelConfirmed: current?.model === target.model,
effortConfirmed: current?.effort === target.effort,
})
return true
}
cancelControl(sessionId: string): void {
const control = this.controls.get(sessionId)
this.controls.delete(sessionId)
this.wake(sessionId)
if (control) this.scheduleChanged(sessionId)
}
finishControl(session: RegisteredSession): void {
const control = this.controls.get(session.sessionId)
this.controls.delete(session.sessionId)
this.wake(session.sessionId)
this.scheduleChanged(session.sessionId)
}
confirmEffort(sessionId: string, effort: string): void {
if (!EFFORTS.has(effort)) return
const state = this.state(sessionId)
state.effort = effort
state.observedAt = Date.now()
const control = this.controls.get(sessionId)
if (control) control.effortConfirmed = control.target.effort === effort
this.wake(sessionId)
}
confirmControlProfile(target: RuntimeProfile): void {
const state = this.state(target.sessionId)
state.model = target.model
state.effort = target.effort
state.observedAt = Date.now()
const control = this.controls.get(target.sessionId)
if (control?.target.id === target.id) {
control.modelConfirmed = true
control.effortConfirmed = true
}
this.wake(target.sessionId)
}
waitForModel(sessionId: string, timeoutMs: number): Promise<boolean> {
return this.waitFor(sessionId, () => this.controls.get(sessionId)?.modelConfirmed === true, timeoutMs)
}
waitForProfile(sessionId: string, timeoutMs: number): Promise<boolean> {
return this.waitFor(sessionId, () => {
const control = this.controls.get(sessionId)
return control?.modelConfirmed === true && control.effortConfirmed === true
}, timeoutMs)
}
forget(sessionId: string): void {
this.states.delete(sessionId)
this.controls.delete(sessionId)
const timer = this.changeTimers.get(sessionId)
if (timer) clearTimeout(timer)
this.changeTimers.delete(sessionId)
this.cursorTargets.delete(sessionId)
for (const waiter of this.waiters.get(sessionId) ?? []) {
clearTimeout(waiter.timer)
waiter.resolve(false)
}
this.waiters.delete(sessionId)
}
async modelsForSessions(sessions: RegisteredSession[]): Promise<RuntimeModelOption[]> {
const groups = await Promise.all(sessions.map((session) => this.modelsForSession(session)))
return groups.flat()
}
/**
* Only Claude and Codex can be SWITCHED from the device (owner, 2026-07-31). Every other engine is
* view-only: its chip still names the model and effort it is running — that comes from the ingest paths,
* not from here — but it offers nothing to pick.
*
* An empty catalogue is the whole mechanism: the device's picker returns to the projects screen when the
* list comes back empty, so this policy lives in one place and needs no firmware change to revise.
* The per-engine builders (cursor/opencode/pi/hermes/commandcode/devin) are kept, unused by this path,
* because the catalogues they fetch are what the ingest paths resolve pane footers against.
*/
async modelsForSession(session: RegisteredSession): Promise<RuntimeModelOption[]> {
// Display-only through a gateway: the empty catalogue IS the mechanism (see the note above), so web
// renders a static chip and the device picker closes instead of offering a list we cannot enumerate.
if (session.gateway) return []
if (session.engine === 'codex') return this.codexModels(session)
if (session.engine === 'claude') return this.claudeModels(session)
return []
}
cursorTarget(sessionId: string, profileId: string): CursorModelTarget | null {
return this.cursorTargets.get(sessionId)?.get(profileId) ?? null
}
/** The `/model` argument for a devin profile id — devin's ids do not follow from the model key. */
devinTarget(sessionId: string, profileId: string): DevinModelTarget | null {
return this.devinTargets.get(sessionId)?.get(profileId) ?? null
}
/** Mark an in-flight control confirmed once the pane shows the profile it asked for. */
private confirmObserved(sessionId: string, model: string, effort: string): void {
const control = this.controls.get(sessionId)
if (!control || control.target.model !== model || control.target.effort !== effort) return
control.modelConfirmed = true
control.effortConfirmed = true
}
/** Resolve devin's footer display name (`SWE-1.6 Slow`) back to the catalog row it names. */
private devinModelKeyForLabel(sessionId: string, label: string): DevinModelTarget | null {
// Resolve against the CATALOG, not the per-session id map. That map is only built when something opens
// the model picker, so a session nobody had picked on could not read its own footer and the chip stayed
// blank. The catalog is the same data minus the per-session ids, and ingestConfig warms it on attach.
// The session map stays first: its rows are the ones the picker will offer.
const targets = this.devinTargets.get(sessionId)
const pool: Iterable<DevinModelTarget> = targets?.size
? targets.values()
: this.devinCatalogCache?.entries ?? []
const wanted = label.trim().toLowerCase()
for (const target of pool) {
// A row whose id carries no effort keeps the effort word in its label ("GLM-5.2 High"), so an exact
// label match is what identifies it; anything looser would tie the footer to the wrong sibling.
if (target.label.toLowerCase() === wanted) return target
if (target.effort !== 'auto' && `${target.label} ${effortLabel(target.effort)}`.toLowerCase() === wanted) {
return target
}
}
return null
}
/**
* An agent that has not bound an engine session yet. Its `sessionId` is the EMPTY STRING, which is
* not an identity — every unbound agent would share one entry in a map keyed on it, across engines.
*
* That is not hypothetical. A claude agent ten seconds old was retargeted onto a grid, and the
* "what model was it on?" read that the retarget keeps — so a later move home can restore it —
* answered `opencode/big-pickle`: an OpenCode agent sitting at `''` had written its footer there
* first. The claude pane came home with `ANTHROPIC_MODEL=opencode/big-pickle` and Claude Code
* answered "There's an issue with the selected model (opencode/big-pickle). It may not exist".
*
* So `''` gets no entry. Reads answer "nothing observed", which is TRUE — an agent with no engine
* session has no model to report — and writes land in a throwaway rather than in a bucket the next
* agent will read. Everything real is re-read once the session binds, moments later.
*/
private unbound(sessionId: string): boolean {
return !sessionId
}
private state(sessionId: string): RuntimeState {
const blank = (): RuntimeState => ({ model: null, effort: null, mode: 'unknown', cliVersion: null, observedAt: null })
if (this.unbound(sessionId)) return blank()
let state = this.states.get(sessionId)
if (!state) {
state = blank()
this.states.set(sessionId, state)
}
return state
}
private ingestCodex(session: RegisteredSession, raw: Record<string, unknown>): void {
const state = this.state(session.sessionId)
const payload = record(raw.payload)
const cliVersion = raw.type === 'session_meta' ? text(payload?.cli_version) : ''
if (parseVersion(cliVersion)) {
session.cliVersion = cliVersion
state.cliVersion = cliVersion
}
let source: Record<string, unknown> | null = null
if (raw.type === 'event_msg' && payload?.type === 'thread_settings_applied') source = record(payload.thread_settings)
else if (raw.type === 'turn_context') source = payload
if (!source) return
const model = text(source.model)
const effort = text(source.reasoning_effort) || text(source.effort)
const collaboration = record(source.collaboration_mode)
const mode = text(collaboration?.mode)
if (model) state.model = model
if (CODEX_EFFORTS.has(effort.toLowerCase())) state.effort = effort.toLowerCase()
if (mode === 'plan' || mode === 'default') state.mode = mode
if (model || effort || mode) state.observedAt = Date.now()
const control = this.controls.get(session.sessionId)
if (control && state.model === control.target.model) {
control.modelConfirmed = true
if (control.target.effort === 'auto' || state.effort === control.target.effort) control.effortConfirmed = true
}
}
private ingestCursor(session: RegisteredSession, raw: Record<string, unknown>): void {
const state = this.state(session.sessionId)
const version = text(raw.version) || text(raw.cursor_version)
if (version) {
session.cliVersion = version
state.cliVersion = version
}
const model = text(raw.model)
if (model) {
state.model = model
// Default the effort to 'auto' when we do not have one yet. selectedModel() returns null unless BOTH
// axes are known, so without this a Cursor session whose model we DO know shows nothing at all on
// the device — the model is thrown away because the effort is missing.
//
// Cursor reports its model in the transcript but its reasoning level only in the pane footer, so
// the effort arrives later (ingestPane) or not at all for a model that has no reasoning levels.
// 'auto' is not a guess about Cursor's behaviour: it is exactly how the device renders "not
// specified", and the pane path overwrites it with the real value the moment one is read.
state.effort ??= 'auto'
state.observedAt = Date.now()
}
}
private ingestClaude(session: RegisteredSession, raw: Record<string, unknown>): void {
const state = this.state(session.sessionId)
const cliVersion = text(raw.version)
if (parseVersion(cliVersion)) {
session.cliVersion = cliVersion
state.cliVersion = cliVersion
}
const message = record(raw.message)
const assistantModel = raw.type === 'assistant' ? text(message?.model) : ''
if (assistantModel) {
state.model = assistantModel
state.observedAt = Date.now()
}
const content = `${flattenContent(message?.content)}\n${flattenContent(raw.content)}`
const control = this.controls.get(session.sessionId)
const modelMatch = /Set model to\s+(.+?)(?:\n|$)/i.exec(content)
if (modelMatch) {
const nextModel = control?.target.model ?? normalizeClaudeDisplay(modelMatch[1]) ?? state.model
state.model = nextModel
if (!control && nextModel && state.effort && !claudeEfforts(nextModel, session.cliVersion).includes(state.effort)) {
state.effort = 'auto'
}
state.observedAt = Date.now()
if (control) control.modelConfirmed = true
}
const effortMatch = /Set effort level to\s+(low|medium|high|xhigh|max|ultracode)/i.exec(content)
const effortAuto = confirmsClaudeAutoEffort(content)
if (effortMatch || effortAuto) {
state.effort = effortMatch?.[1].toLowerCase() ?? 'auto'
state.observedAt = Date.now()
if (control) control.effortConfirmed = control.target.effort === 'auto' || state.effort === control.target.effort
}
}
private ingestGrok(session: RegisteredSession, raw: Record<string, unknown>): void {
const params = record(raw.params)
const update = record(params?.update)
const meta = record(update?._meta)
const model = text(meta?.modelId)
if (!model) return
const state = this.state(session.sessionId)
state.model = model
state.observedAt = Date.now()
}
private async claudeModels(session: RegisteredSession): Promise<RuntimeModelOption[]> {
const output: RuntimeModelOption[] = []
const seen = new Set<string>()
const allowed = await claudeAvailableModels(session)
for (const model of CLAUDE_ALIASES) {
if (model === 'fable' && !versionAtLeast(session.cliVersion, [2, 1, 170])) continue
if (!availableModelMatches(model, allowed)) continue
addOption(output, seen, session, model, 'auto')
for (const effort of claudeEfforts(model, session.cliVersion)) addOption(output, seen, session, model, effort)
}
const state = this.states.get(session.sessionId)
if (state?.model) {
const model = claudeAliasForModel(state.model) ?? state.model
addOption(output, seen, session, model, 'auto')
for (const effort of claudeEfforts(model, session.cliVersion)) addOption(output, seen, session, model, effort)
if (state.effort) addOption(output, seen, session, model, state.effort)
}
return output
}
private async codexModels(session: RegisteredSession): Promise<RuntimeModelOption[]> {
const output: RuntimeModelOption[] = []
const seen = new Set<string>()
let cache: CodexCache = {}
// This agent's own CODEX_HOME profile, when it has one other than the default (see
// RegisteredSession.codexHome) — otherwise the picker would show the default profile's cached
// models for an agent that is not actually running on it.
try { cache = JSON.parse(await readFile(join(session.codexHome || env.CODEX_HOME, 'models_cache.json'), 'utf8')) as CodexCache } catch { /* current state fallback below */ }
for (const item of Array.isArray(cache.models) ? cache.models : []) {
const model = text(item.slug)
if (!model || item.visibility === 'hide') continue
const label = text(item.display_name) || runtimeModelLabel(model)
addOption(output, seen, session, model, 'auto', label)
for (const level of Array.isArray(item.supported_reasoning_levels) ? item.supported_reasoning_levels : []) {
const effort = text(level.effort).toLowerCase()
if (CODEX_EFFORTS.has(effort) && effort !== 'auto' && codexEffortAllowed(model, effort)) {
addOption(output, seen, session, model, effort, label)
}
}
}
const state = this.states.get(session.sessionId)
if (state?.model) {
addOption(output, seen, session, state.model, 'auto')
if (state.effort && codexEffortAllowed(state.model, state.effort)) {
addOption(output, seen, session, state.model, state.effort)
}
}
return output
}
/** Command Code stamps the model on every assistant line as the full gateway id
* ("deepseek/deepseek-v4-flash"). Store the short name so it matches the catalogue and the chip label.
* `raw.version` here is the transcript SCHEMA version (3), not a CLI version — never read it as one. */
private ingestCommandcode(session: RegisteredSession, raw: Record<string, unknown>): void {
const model = text(raw.model)
if (!model) return
const state = this.state(session.sessionId)
state.model = shortCommandcodeModel(model)
// Effort is NOT touched here: it comes from the CLI config (ingestConfig), and stamping 'auto' on every
// assistant line would wipe a configured level a second after it was read.
state.observedAt = Date.now()
}
private async cursorModels(session: RegisteredSession): Promise<RuntimeModelOption[]> {
const key = `${session.cliVersion ?? 'unknown'}\0${process.env.HOME ?? ''}`
let entries = this.cursorCatalogCache?.key === key && this.cursorCatalogCache.expiresAt > Date.now()
? this.cursorCatalogCache.entries
: null
if (!entries) {
try {
const result = await execFileAsync('agent', ['models'], {
env: process.env,
timeout: 5_000,
maxBuffer: 1024 * 1024,
})
entries = parseCursorModelsOutput(result.stdout)
this.cursorCatalogCache = { key, entries, expiresAt: Date.now() + CURSOR_CATALOG_TTL_MS }
} catch (err) {
console.warn('[runtime-profile] Cursor model catalog failed:', err instanceof Error ? err.message : err)
entries = []
}
}
const output: RuntimeModelOption[] = []
const previousTargets = this.cursorTargets.get(session.sessionId) ?? new Map<string, CursorModelTarget>()
const targets = new Map<string, CursorModelTarget>()
const seen = new Set<string>()
for (const entry of entries) {
if (!CURSOR_EFFORTS.has(entry.effort)) continue
const id = encodeRuntimeProfile({
sessionId: session.agentId,
engine: 'cursor',
model: entry.target.modelKey,
effort: entry.effort,
})
if (seen.has(id)) continue
seen.add(id)
targets.set(id, entry.target)
output.push({ id, displayName: `${entry.modelLabel} / ${effortLabel(entry.effort)}` })
}
const state = this.states.get(session.sessionId)
const current = state?.model && state.effort
? encodeRuntimeProfile({
sessionId: session.agentId,
engine: 'cursor',
model: state.model,
effort: state.effort,
})
: null
const observed = current ? previousTargets.get(current) : null
if (observed) {
const familyEfforts = [...new Set(entries
.filter((entry) => entry.target.familyLabel.toLowerCase() === observed.familyLabel.toLowerCase())
.map((entry) => entry.effort)
.filter((effort) => effort !== 'auto'))]
const efforts = familyEfforts.length ? familyEfforts : [state!.effort!]
for (const effort of efforts) {
const id = encodeRuntimeProfile({
sessionId: session.agentId,
engine: 'cursor',
model: observed.modelKey,
effort,
})
if (seen.has(id)) continue
seen.add(id)
targets.set(id, { ...observed, reasoning: effort, footerEffort: effort })
const label = [
observed.familyLabel,
observed.context ? `(${observed.context.toUpperCase()})` : '',
observed.thinking ? 'Thinking' : '',
observed.fast ? 'Fast' : '',
].filter(Boolean).join(' ')
output.push({ id, displayName: `${label} / ${effortLabel(effort)}` })
}
}
this.cursorTargets.set(session.sessionId, targets)
return output
}
/**
* Devin's catalog comes from `devin models list` on stdout — no picker to scrape. It is big (166 rows
* across 72 models on this account), so it is trimmed to CATALOG_LIMIT, and the model the session is
* ACTUALLY running is pinned to the front so trimming can never hide it.
*/
private async devinModels(session: RegisteredSession): Promise<RuntimeModelOption[]> {
const entries = await this.devinCatalog()
const targets = new Map<string, DevinModelTarget>()
const state = this.states.get(session.sessionId)
// Keep every row of the running model together with it, so its effort list stays complete.
const ordered = state?.model
? [...entries].sort((a, b) => Number(b.modelKey === state.model) - Number(a.modelKey === state.model))
: entries
const output: RuntimeModelOption[] = []
const seen = new Set<string>()
for (const entry of ordered) {
if (output.length >= CATALOG_LIMIT) break
if (!DEVIN_EFFORTS.has(entry.effort)) continue
const id = encodeRuntimeProfile({
sessionId: session.agentId,
engine: 'devin',
model: entry.modelKey,
effort: entry.effort,
})
if (seen.has(id)) continue
seen.add(id)
targets.set(id, entry)
output.push({ id, displayName: `${entry.label} / ${effortLabel(entry.effort)}` })
}
this.devinTargets.set(session.sessionId, targets)
return output
}
private async devinCatalog(): Promise<DevinModelTarget[]> {
const key = env.DEVIN_HOME
if (this.devinCatalogCache?.key === key && this.devinCatalogCache.expiresAt > Date.now()) {
return this.devinCatalogCache.entries
}
let entries: DevinModelTarget[] = []
try {
const result = await execFileAsync('devin', ['models', 'list'], {
env: process.env,
timeout: 10_000,
maxBuffer: 1024 * 1024,
})
entries = parseDevinModelsOutput(result.stdout)
} catch (err) {
console.warn('[runtime-profile] Devin model catalog failed:', err instanceof Error ? err.message : err)
}
this.devinCatalogCache = { key, entries, expiresAt: Date.now() + CATALOG_TTL_MS }
return entries
}
/**
* Pi lists models on stdout too, and its `thinking` column says which of them accept a reasoning depth —
* so effort rows are attached per model instead of assumed. A model that is configured but absent from
* the table (the state fallback) still gets its own row so the chip never goes blank.
*/
private async piModels(session: RegisteredSession): Promise<RuntimeModelOption[]> {
const entries = await this.piCatalog()
const output: RuntimeModelOption[] = []
const seen = new Set<string>()
for (const entry of entries) {
addOption(output, seen, session, entry.model, 'auto', entry.model)
if (!entry.thinking) continue
for (const level of PI_THINKING_LEVELS) addOption(output, seen, session, entry.model, level, entry.model)
}
const state = this.states.get(session.sessionId)
if (entries.length && state?.model) {
addOption(output, seen, session, state.model, 'auto', state.model)
if (state.effort && PI_EFFORTS.has(state.effort)) {
addOption(output, seen, session, state.model, state.effort, state.model)
}
}
return output
}
/** The picker page + row a hermes profile id points at. */
hermesTarget(sessionId: string, profileId: string): HermesModelTarget | null {
return this.hermesTargets.get(sessionId)?.get(profileId) ?? null
}
/**
* Hermes offers MODELS only. Its reasoning effort lives in `agent.reasoning_effort` in config.yaml with
* no in-session command to change it (`/config` only prints), and a running session does not re-read the
* file — so an effort row would be a control that silently does nothing. The level is still OBSERVED, so
* the chip names it truthfully; it just cannot be picked.
*/
private async hermesModels(session: RegisteredSession): Promise<RuntimeModelOption[]> {
const entries = await this.hermesCatalog(session.hermesHome || env.HERMES_HOME)
const state = this.states.get(session.sessionId)
const targets = new Map<string, HermesModelTarget>()
const output: RuntimeModelOption[] = []
const seen = new Set<string>()
const effort = state?.effort && HERMES_EFFORTS.has(state.effort) ? state.effort : 'auto'
const add = (entry: HermesModelTarget): void => {
const short = entry.id.slice(entry.id.lastIndexOf('/') + 1)
const id = encodeRuntimeProfile({
sessionId: session.agentId, engine: 'hermes', model: short, effort,
})
if (seen.has(id)) return
seen.add(id)
targets.set(id, entry)
output.push({ id, displayName: runtimeModelLabel(short) })
}
for (const entry of entries) add(entry)
// The provider in use is often absent from the picker cache (a `custom` gateway is its own one-model
// page), so the configured model is always offered — otherwise the running model is missing from its
// own list.
if (state?.model && !seen.size) add({ id: state.model, provider: '' })
else if (state?.model && ![...targets.values()].some((t) => t.id.endsWith(state.model!))) {
add({ id: state.model, provider: '' })
}
this.hermesTargets.set(session.sessionId, targets)
return output
}
private async hermesCatalog(home = env.HERMES_HOME): Promise<HermesModelTarget[]> {
// Keyed by home, and now actually asked per home: a profile has its own providers, so the cache
// key was already right and only the path it read was not.
const cached = this.hermesCatalogCache.get(home)
if (cached && cached.expiresAt > Date.now()) return cached.entries
const cache = await readJson(join(home, 'provider_models_cache.json'))
const entries = parseHermesModelsCache(cache)
this.hermesCatalogCache.set(home, { entries, expiresAt: Date.now() + CATALOG_TTL_MS })
return entries
}
/** The full `/model` argument for a Command Code profile id — the profile itself holds the short name. */
commandcodeTarget(sessionId: string, profileId: string): CommandcodeModelTarget | null {
return this.commandcodeTargets.get(sessionId)?.get(profileId) ?? null
}
/**
* Command Code's catalog comes from `--list-models`. Effort rows are attached to every model because the
* CLI does not publish which models take one; an unsupported pick is refused in words at apply time
* (see COMMANDCODE_EFFORT_LEVELS).
*/
private async commandcodeModels(session: RegisteredSession): Promise<RuntimeModelOption[]> {
const entries = await this.commandcodeCatalog()
const targets = new Map<string, CommandcodeModelTarget>()
const output: RuntimeModelOption[] = []
const seen = new Set<string>()
const add = (entry: CommandcodeModelTarget, effort: string): void => {
const id = encodeRuntimeProfile({
sessionId: session.agentId, engine: 'commandcode', model: entry.shortId, effort,
})
if (seen.has(id)) return
seen.add(id)
targets.set(id, entry)
output.push({ id, displayName: `${runtimeModelLabel(entry.shortId)} / ${effortLabel(effort)}` })
}
for (const entry of entries) {
add(entry, 'auto')
for (const level of COMMANDCODE_EFFORT_LEVELS) add(entry, level)
}
const state = this.states.get(session.sessionId)
// `entries.length` guards the fallback: a model row is worth adding when the catalogue is readable but
// does not list what the session runs (a pinned build, a just-removed model). When the catalogue could
// not be read at all, one lone row is a picker that cannot pick anything — better to offer none.
if (entries.length && state?.model && !entries.some((entry) => entry.shortId === state.model)) {
const own: CommandcodeModelTarget = { id: state.model, shortId: state.model, section: '', isDefault: false }
add(own, 'auto')
if (state.effort && COMMANDCODE_EFFORTS.has(state.effort)) add(own, state.effort)
}
this.commandcodeTargets.set(session.sessionId, targets)
return output
}
private async commandcodeCatalog(): Promise<CommandcodeModelTarget[]> {
const key = env.COMMANDCODE_HOME
if (this.commandcodeCatalogCache?.key === key && this.commandcodeCatalogCache.expiresAt > Date.now()) {
return this.commandcodeCatalogCache.entries
}
let entries: CommandcodeModelTarget[] = []
try {
const result = await execFileAsync('commandcode', ['--list-models'], {
env: process.env, timeout: 15_000, maxBuffer: 1024 * 1024,
})
entries = parseCommandcodeModelsOutput(result.stdout)
} catch (err) {
console.warn('[runtime-profile] Command Code model catalog failed:', err instanceof Error ? err.message : err)
}
this.commandcodeCatalogCache = { key, entries, expiresAt: Date.now() + CATALOG_TTL_MS }
return entries
}
/** OpenCode has no effort axis, so every model is one `auto` row and the label carries no effort. */
private async opencodeModels(session: RegisteredSession): Promise<RuntimeModelOption[]> {
const entries = await this.opencodeCatalog()
const output: RuntimeModelOption[] = []
const seen = new Set<string>()
for (const entry of entries) {
const id = encodeRuntimeProfile({
sessionId: session.agentId, engine: 'opencode', model: entry.id, effort: 'auto',
})
if (seen.has(id)) continue
seen.add(id)
output.push({ id, displayName: entry.id })
}
const state = this.states.get(session.sessionId)
// See commandcodeModels: only worth a row when the catalogue itself came back.
if (entries.length && state?.model && !entries.some((entry) => entry.id === state.model)) {
const id = encodeRuntimeProfile({
sessionId: session.agentId, engine: 'opencode', model: state.model, effort: 'auto',
})
if (!seen.has(id)) output.push({ id, displayName: state.model })
}
return output
}
async opencodeCatalog(): Promise<OpencodeModelTarget[]> {
const key = env.OPENCODE_DATA_DIR
if (this.opencodeCatalogCache?.key === key && this.opencodeCatalogCache.expiresAt > Date.now()) {
return this.opencodeCatalogCache.entries
}
let entries: OpencodeModelTarget[] = []
try {
const result = await execFileAsync(opencodeBin(), ['models'], {
env: process.env, timeout: 10_000, maxBuffer: 1024 * 1024,
})
entries = parseOpencodeModelsOutput(result.stdout)
} catch (err) {
console.warn('[runtime-profile] OpenCode model catalog failed:', err instanceof Error ? err.message : err)
}
this.opencodeCatalogCache = { key, entries, expiresAt: Date.now() + CATALOG_TTL_MS }
return entries
}
/** Kilo has no effort axis either, so every model is one `auto` row. */
private async kiloModels(session: RegisteredSession): Promise<RuntimeModelOption[]> {
const entries = await this.kiloCatalog()
const output: RuntimeModelOption[] = []
const seen = new Set<string>()
for (const entry of entries) {
const id = encodeRuntimeProfile({
sessionId: session.agentId, engine: 'kilo', model: entry.id, effort: 'auto',
})
if (seen.has(id)) continue
seen.add(id)
output.push({ id, displayName: entry.id })
}
return output
}
async kiloCatalog(): Promise<KiloModelTarget[]> {
const key = env.KILO_DATA_DIR
if (this.kiloCatalogCache?.key === key && this.kiloCatalogCache.expiresAt > Date.now()) {
return this.kiloCatalogCache.entries
}
let entries: KiloModelTarget[] = []
try {
// Measured: `kilo models` answers WITHOUT the user being logged in (unlike `kilo profile`), and
// prints 299 ids on this machine — so an empty catalog here means the binary is missing, not that
// the account is signed out.
const result = await execFileAsync(env.KILO_PATH || 'kilo', ['models'], {
env: process.env, timeout: 10_000, maxBuffer: 1024 * 1024,
})
entries = parseKiloModelsOutput(result.stdout)
} catch (err) {
console.warn('[runtime-profile] Kilo model catalog failed:', err instanceof Error ? err.message : err)
}
this.kiloCatalogCache = { key, entries, expiresAt: Date.now() + CATALOG_TTL_MS }
return entries
}
private async piCatalog(): Promise<ReturnType<typeof parsePiModelsOutput>> {
const key = env.PI_HOME
if (this.piCatalogCache?.key === key && this.piCatalogCache.expiresAt > Date.now()) {
return this.piCatalogCache.entries
}
let entries: ReturnType<typeof parsePiModelsOutput> = []
try {
const result = await execFileAsync('pi', ['--list-models'], {
env: process.env,
timeout: 10_000,
maxBuffer: 1024 * 1024,
})
entries = parsePiModelsOutput(result.stdout)
} catch (err) {
console.warn('[runtime-profile] Pi model catalog failed:', err instanceof Error ? err.message : err)
}
this.piCatalogCache = { key, entries, expiresAt: Date.now() + CATALOG_TTL_MS }
return entries
}
private scheduleChanged(sessionId: string): void {
const previous = this.changeTimers.get(sessionId)
if (previous) clearTimeout(previous)
this.changeTimers.set(sessionId, setTimeout(() => {
this.changeTimers.delete(sessionId)
if (!this.controls.has(sessionId)) this.onChanged?.(sessionId)
}, CHANGE_DEBOUNCE_MS))
}
private waitFor(sessionId: string, check: () => boolean, timeoutMs: number): Promise<boolean> {
if (check()) return Promise.resolve(true)
return new Promise((resolve) => {
const waiter: StateWaiter = {
check,
resolve,
timer: setTimeout(() => {
this.waiters.get(sessionId)?.delete(waiter)
resolve(false)
}, timeoutMs),
}
const set = this.waiters.get(sessionId) ?? new Set<StateWaiter>()
set.add(waiter)
this.waiters.set(sessionId, set)
})
}
private wake(sessionId: string): void {
const set = this.waiters.get(sessionId)
if (!set) return
for (const waiter of [...set]) {
if (!waiter.check()) continue
clearTimeout(waiter.timer)
set.delete(waiter)
waiter.resolve(true)
}
if (set.size === 0) this.waiters.delete(sessionId)
}
}