The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.
TypeScript 3d-modelingagent-frameworkagent-harnessai-agentscadclaude-codecodexcoding-agentsdeveloper-toolsesp32game-developmentmcp-servermulti-agentopen-hardwareopencodeopenharnesspcbroboticsterminaltmux
import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
import { env } from '../config/env.js'
import { runtime as claudeRuntime } from '../engines/claude/runtimeProfile.js'
import type { RegisteredSession } from './registry.js'
import { RuntimeProfileState } from './runtimeProfileState.js'
import { RuntimeProfileManager } from './runtimeProfile.js'
import { parseRuntimeProfile } from './runtimeProfileWire.js'
import { engineNow, loadEngine, OTHER_ENGINES } from '../engines/inProcess.js'
import type { InlineRuntimeContext } from '../engines/facets/inlineRuntime.js'
import { createTerminalControl } from '../core/terminals/control.js'
// A test may say an engine's code could not be loaded.
vi.mock('../engines/inProcess.js', async (real) => {
const actual = await real<typeof import('../engines/inProcess.js')>()
return { ...actual, engineNow: vi.fn(actual.engineNow), loadEngine: vi.fn(actual.loadEngine) }
})
const fixture = (name: string): string => readFileSync(join(import.meta.dirname, '__fixtures__', name), 'utf8')
const session = (engine: RegisteredSession['engine']): RegisteredSession => ({
agentId: 'agent', sessionId: 'conversation', engine, model: 'registered-model', cliVersion: '1.0.0',
cwd: '/tmp', transcriptPath: '/tmp/profile-recording.jsonl',
} as RegisteredSession)
afterEach(() => { vi.restoreAllMocks(); vi.useRealTimers(); vi.mocked(engineNow).mockReset(); vi.mocked(loadEngine).mockReset() })
// The other engines' profile readers load as one of their sessions enters the registry (engines/inProcess.ts
// `preloadEngine`): before any pane of theirs is read, as here.
beforeAll(async () => { for (const engine of OTHER_ENGINES) await loadEngine(engine) })
describe('another engine whose code could not be loaded', () => {
it('contains a missing or throwing reader factory while core confirmation and cleanup still work', async () => {
vi.spyOn(console, 'warn').mockImplementation(() => {})
for (const createRuntimeProfileReader of [undefined, () => { throw new Error('broken facet') }]) {
vi.mocked(engineNow).mockReturnValue({ createRuntimeProfileReader } as never)
vi.mocked(loadEngine).mockResolvedValue({ createRuntimeProfileReader } as never)
const manager = new RuntimeProfileState(() => undefined), agent = session('cursor')
manager.hydrate(agent, [])
expect(manager.ingestPane(agent, 'Auto · 10%', true)).toBe(false)
expect(manager.ingestPane(agent, 'Auto · 10%', true)).toBe(false)
expect(await manager.ingestConfig(agent)).toBe(false)
manager.confirmEffort(agent.sessionId, 'high')
expect(manager.getState(agent.sessionId).effort).toBe('high')
manager.forget(agent.sessionId)
expect(manager.getState(agent.sessionId).model).toBeNull()
}
expect(console.warn).toHaveBeenCalledTimes(2)
vi.mocked(engineNow).mockReset()
vi.mocked(loadEngine).mockReset()
})
it('reads nothing of its panes, config files or catalog, and leaves its chips as they were', async () => {
const manager = new RuntimeProfileState(() => undefined)
vi.mocked(engineNow).mockReturnValue(null)
vi.mocked(loadEngine).mockResolvedValue(null as never)
try {
for (const engine of ['cursor', 'devin', 'hermes', 'commandcode', 'opencode', 'kilo', 'pi', 'grok', 'agy'] as const) {
const agent = { ...session(engine), sessionId: `${engine}-s` }
expect(manager.ingestPane(agent, 'any pane', true), engine).toBe(false)
expect(manager.getState(agent.sessionId), engine).toMatchObject({ model: null, effort: null })
}
for (const engine of ['hermes', 'muse', 'amp'] as const) {
expect(await manager.ingestConfig({ ...session(engine), sessionId: `${engine}-c` }, true), engine).toBe(false)
}
expect(await manager.opencodeCatalog()).toEqual([])
expect(await manager.kiloCatalog()).toEqual([])
} finally {
vi.mocked(engineNow).mockReset()
vi.mocked(loadEngine).mockReset()
}
})
})
describe('late optional profile observations', () => {
it.each(['binding', 'process', 'route', 'confirmation', 'forget', 'unchanged'] as const)(
'fences a pane through the promise handoff to its profile consumer: %s', async change => {
const agent = { ...session('claude'), active: true, boundAt: 1, runtimes: [{ backend: 'tmux' as const, paneId: '%1' }],
processIdentity: { pid: 7, startMarker: 'before', executable: 'claude' } }
const manager = new RuntimeProfileState(() => ({ ...claudeRuntime, pane: ({ state }, text) => { state.model = text } }), () => agent)
manager.hydrate(agent, [])
let finish!: (value: { state: 'succeeded'; value: string }) => void
const backend = { capture: vi.fn(() => new Promise<{ state: 'succeeded'; value: string }>(resolve => { finish = resolve })) }
const terminal = createTerminalControl({ resolve: () => agent, terminals: backend as never })
const pending = manager.capturePane(agent, terminal.captureTerminal, 60, true)
finish({ state: 'succeeded', value: 'captured-model' })
// Runs after captureTerminal's own guard, but before its awaiting profile consumer resumes.
queueMicrotask(() => {
if (change === 'binding') { agent.sessionId = 'new-conversation'; agent.boundAt++ }
if (change === 'process') agent.processIdentity.startMarker = 'after'
if (change === 'route') agent.runtimes[0]!.paneId = '%2'
if (change === 'confirmation') manager.confirmEffort(agent.sessionId, 'high')
if (change === 'forget') manager.forget(agent.sessionId)
})
expect(await pending).toBe(change === 'unchanged' ? 'captured-model' : null)
expect(manager.getState(agent.sessionId).model === 'captured-model').toBe(change === 'unchanged')
manager.forget('conversation'); manager.forget(agent.sessionId)
},
)
it('does not capture for an unbound or detached profile, or ingest an empty pane', async () => {
const agent = session('claude'), capture = vi.fn(async () => null)
const manager = new RuntimeProfileState(() => claudeRuntime, () => agent)
expect(await manager.capturePane({ ...agent, sessionId: '' }, capture)).toBeNull()
expect(await manager.capturePane({ ...agent, boundAt: 2 }, capture)).toBeNull()
expect(capture).not.toHaveBeenCalled()
expect(await manager.capturePane(agent, capture)).toBeNull()
expect(capture).toHaveBeenCalledOnce()
manager.forget(agent.sessionId)
})
it.each(['explicit read', 'confirmation'] as const)('does not let a queued refresh supersede a newer %s', async newer => {
const config = vi.fn(async ({ state }: InlineRuntimeContext) => { state.effort = 'low'; return true })
const module = { createRuntimeProfileReader: () => ({ engine: 'commandcode', target: () => null, config,
pane: ({ state, refreshConfig }: InlineRuntimeContext) => { state.model = 'model'; refreshConfig() },
}) }
vi.mocked(engineNow).mockReturnValue(module as never)
vi.mocked(loadEngine).mockResolvedValue(module as never)
const manager = new RuntimeProfileState(() => undefined), agent = session('commandcode')
manager.ingestPane(agent, 'model', true)
if (newer === 'explicit read') {
await manager.ingestConfig(agent, true)
expect(config).toHaveBeenCalledOnce()
expect(manager.getState(agent.sessionId).effort).toBe('low')
} else {
manager.confirmEffort(agent.sessionId, 'high')
await Promise.resolve()
expect(config).not.toHaveBeenCalled()
expect(manager.getState(agent.sessionId).effort).toBe('high')
}
manager.forget(agent.sessionId)
})
it.each(['cancel', 'finish'] as const)('does not revive a forgotten state when late control cleanup calls %s', async end => {
const cleanup = vi.fn(() => { throw new Error('optional cleanup failed') })
vi.spyOn(console, 'warn').mockImplementation(() => {})
vi.mocked(engineNow).mockReturnValue({ createRuntimeProfileReader: () => ({
engine: 'cursor', pane: () => false, forget: cleanup,
}) } as never)
const manager = new RuntimeProfileState(() => undefined), agent = session('cursor')
manager.ingestPane(agent, '')
manager.forget(agent.sessionId)
if (end === 'cancel') manager.cancelControl(agent.sessionId)
else manager.finishControl(agent)
await Promise.resolve()
expect(cleanup).toHaveBeenCalledExactlyOnceWith(agent.sessionId)
expect(console.warn).toHaveBeenCalledOnce()
manager.forget(agent.sessionId)
})
it('keeps newer control flags even when neither a value nor the control object changes', async () => {
let finish!: (effort: string) => void
const manager = new RuntimeProfileState(() => ({ ...claudeRuntime,
transcript: ({ control }, raw) => { if (raw.confirm && control) control.modelConfirmed = true },
configuredEffort: () => new Promise<string>(resolve => { finish = resolve }),
})), agent = session('claude')
manager.hydrate(agent, [])
manager.confirmEffort(agent.sessionId, 'high')
manager.beginControl(agent, { id: 'target', sessionId: agent.agentId, engine: agent.engine, model: 'new-model', effort: 'high' })
const pending = manager.ingestConfig(agent)
manager.ingest(agent, '{"confirm":true}')
finish('low')
await pending
expect(await manager.waitForProfile(agent.sessionId, 10)).toBe(true)
expect(manager.getState(agent.sessionId).effort).toBe('high')
manager.forget(agent.sessionId)
})
it.each(['cancel', 'finish'] as const)('invalidates config and hydration across a complete control %s cycle', async end => {
let finish!: (effort: string) => void
const manager = new RuntimeProfileState(() => ({ ...claudeRuntime,
configuredEffort: () => new Promise<string>(resolve => { finish = resolve }),
})), agent = session('claude')
manager.hydrate(agent, [])
manager.confirmEffort(agent.sessionId, 'high')
const before = manager.getState(agent.sessionId)
const pending = manager.ingestConfig(agent), stage = manager.beginHydrate(agent)
stage.ingest(JSON.stringify({ type: 'assistant', message: { model: 'staged-model' } }))
expect(manager.beginControl(agent, { id: 'target', sessionId: agent.agentId, engine: agent.engine,
model: 'new-model', effort: 'high' })).toBe(true)
if (end === 'cancel') manager.cancelControl(agent.sessionId)
else manager.finishControl(agent)
finish('low')
expect(await pending).toBe(false)
const install = vi.fn(() => true)
expect(stage.commitWith!(install)).toBe(false)
expect(install).not.toHaveBeenCalled()
expect(manager.getState(agent.sessionId)).toEqual(before)
manager.forget(agent.sessionId)
})
it('treats a repeated confirmation as newer authority than a pending config or transcript stage', async () => {
// One frozen millisecond: the repeated confirmation stamps observedAt again, and a clock that
// ticked in between failed the comparison below on CI (observedAt 1 ms apart, 2026-10-09).
vi.useFakeTimers({ toFake: ['Date'] })
let finish!: (effort: string) => void
const manager = new RuntimeProfileState(() => ({ ...claudeRuntime,
configuredEffort: () => new Promise<string>(resolve => { finish = resolve }),
})), agent = session('claude')
manager.hydrate(agent, [])
manager.confirmEffort(agent.sessionId, 'high')
const pending = manager.ingestConfig(agent)
manager.confirmEffort(agent.sessionId, 'high')
finish('low')
expect(await pending).toBe(false)
expect(manager.getState(agent.sessionId).effort).toBe('high')
const stage = manager.beginHydrate(agent)
const before = manager.getState(agent.sessionId)
manager.confirmEffort(agent.sessionId, 'high')
stage.commit()
expect(manager.getState(agent.sessionId)).toEqual(before)
})
it('keeps a same-value pane observation ahead of a pending config answer', async () => {
let finish!: (effort: string) => void
const manager = new RuntimeProfileState(() => ({ ...claudeRuntime,
pane: ({ state }) => { state.effort = 'high' },
configuredEffort: () => new Promise<string>(resolve => { finish = resolve }),
})), agent = session('claude')
manager.hydrate(agent, [])
manager.confirmEffort(agent.sessionId, 'high')
const pending = manager.ingestConfig(agent)
manager.ingestPane(agent, 'same evidence', true)
finish('low')
expect(await pending).toBe(false)
expect(manager.getState(agent.sessionId).effort).toBe('high')
})
it('finishes core waiters and every optional cleanup despite a throwing reader', async () => {
const later = vi.fn()
vi.spyOn(console, 'warn').mockImplementation(() => {})
vi.mocked(engineNow).mockImplementation(engine => ({ createRuntimeProfileReader: () => ({
engine, target: () => null, forget: engine === 'cursor' ? () => { throw new Error('broken cleanup') } : later,
}) }) as never)
const manager = new RuntimeProfileState(() => undefined), agent = session('cursor')
manager.ingestPane(agent, '', true)
manager.ingestPane(session('grok'), '', true)
manager.beginControl(agent, { id: 'target', sessionId: agent.sessionId, engine: agent.engine, model: 'wanted', effort: 'high' })
const waiting = manager.waitForModel(agent.sessionId, 100)
expect(() => manager.forget(agent.sessionId)).not.toThrow()
expect(await waiting).toBe(false)
expect(later).toHaveBeenCalledWith(agent.sessionId)
expect(manager.getState(agent.sessionId).model).toBeNull()
})
// Codex at its own default effort writes `reasoning_effort: null` in each turn's context (0.164, 0.165): its model was never
// reported, so its Swarm attempts were recorded with none (Scholes, 2026-10-30).
it('names a Codex agent\'s model from its first turn at Codex\'s own default effort, as auto', () => {
const manager = new RuntimeProfileManager(), agent = session('codex')
manager.hydrate(agent, [JSON.stringify({ type: 'session_meta', payload: { cli_version: '0.165.0' } }),
JSON.stringify({ type: 'turn_context', payload: { model: 'gpt-6.1-sol', collaboration_mode: { mode: 'default', settings: { model: 'gpt-6.1-sol', reasoning_effort: null } } } })])
expect(parseRuntimeProfile(manager.selectedModel(agent))).toMatchObject({ engine: 'codex', model: 'gpt-6.1-sol', effort: 'auto' })
// A later turn at a named effort says so; one back at the default reads auto again.
manager.ingest(agent, JSON.stringify({ type: 'turn_context', payload: { model: 'gpt-6.1-sol', reasoning_effort: 'xhigh' } }), true)
expect(parseRuntimeProfile(manager.selectedModel(agent))).toMatchObject({ model: 'gpt-6.1-sol', effort: 'xhigh' })
manager.ingest(agent, JSON.stringify({ type: 'turn_context', payload: { model: 'gpt-6.1-sol', reasoning_effort: null } }), true)
expect(parseRuntimeProfile(manager.selectedModel(agent))).toMatchObject({ model: 'gpt-6.1-sol', effort: 'auto' })
// A settings change that names a model and no effort changed only the model: the effort stays.
manager.ingest(agent, JSON.stringify({ type: 'turn_context', payload: { model: 'gpt-6.1-sol', reasoning_effort: 'high' } }), true)
manager.ingest(agent, JSON.stringify({ type: 'event_msg', payload: { type: 'thread_settings_applied', thread_settings: { model: 'gpt-6-astra' } } }), true)
expect(parseRuntimeProfile(manager.selectedModel(agent))).toMatchObject({ model: 'gpt-6-astra', effort: 'high' })
// A context that names no model says nothing about one.
const none = new RuntimeProfileManager(), other = session('codex')
none.hydrate(other, [JSON.stringify({ type: 'turn_context', payload: { cwd: '/repo' } })])
expect(none.selectedModel(other)).toBeNull()
})
it('cannot commit a staged transcript after forget or newer live evidence', () => {
for (const forget of [true, false]) {
const manager = new RuntimeProfileManager(), agent = session('codex')
const line = (model: string) => JSON.stringify({ type: 'turn_context', payload: { model, reasoning_effort: 'high' } })
manager.hydrate(agent, [line('first')])
const stage = manager.beginHydrate(agent)
stage.ingest(line('old-history'))
if (forget) manager.forget(agent.sessionId)
else manager.ingest(agent, line('latest'), true)
const before = manager.getState(agent.sessionId)
stage.commit()
expect(manager.getState(agent.sessionId)).toEqual(before)
}
})
it('keeps the session version and control confirmation private until a stage commits', async () => {
const manager = new RuntimeProfileState(() => ({ ...claudeRuntime,
transcript(context) {
context.session.cliVersion = 'staged-version'
context.state.model = 'staged-model'
if (context.control) context.control.modelConfirmed = true
},
})), agent = session('claude')
const target = { id: 'runtime-v1:conversation:claude:staged-model@high', sessionId: agent.sessionId,
engine: agent.engine, model: 'staged-model', effort: 'high' }
manager.beginControl(agent, target)
const stage = manager.beginHydrate(agent)
stage.ingest('{}')
expect(agent.cliVersion).toBe('1.0.0')
vi.useFakeTimers()
const waiting = manager.waitForModel(agent.sessionId, 15)
await vi.advanceTimersByTimeAsync(15)
expect(await waiting).toBe(false)
stage.commit()
expect(agent.cliVersion).toBe('staged-version')
expect(await manager.waitForModel(agent.sessionId, 15)).toBe(true)
manager.forget(agent.sessionId)
})
it('cannot recreate state when its module finishes loading after forget', async () => {
const manager = new RuntimeProfileState(() => undefined), agent = session('hermes')
let finish!: (value: Awaited<ReturnType<typeof loadEngine<'hermes'>>>) => void
const module = await loadEngine('hermes')
const read = vi.fn(async ({ state }: InlineRuntimeContext) => {
state.model = 'late-model'; state.effort = 'high'; return true
})
vi.mocked(loadEngine).mockReturnValueOnce(new Promise(resolve => { finish = resolve }) as never)
const pending = manager.ingestConfig(agent)
manager.forget(agent.sessionId)
finish({ ...module!, createRuntimeProfileReader: () => ({ engine: 'hermes', target: () => null, config: read }) })
expect(await pending).toBe(false)
expect(read).not.toHaveBeenCalled()
expect(manager.getState(agent.sessionId)).toMatchObject({ model: null, effort: null })
})
it('does not replace a confirmed effort with a config read started earlier', async () => {
let finish!: (effort: string) => void
const configuredEffort = vi.fn(() => new Promise<string>(resolve => { finish = resolve }))
const manager = new RuntimeProfileState(() => ({ ...claudeRuntime, configuredEffort })), agent = session('claude')
manager.hydrate(agent, [])
const pending = manager.ingestConfig(agent)
manager.confirmEffort(agent.sessionId, 'high')
finish('low')
expect(await pending).toBe(false)
expect(manager.getState(agent.sessionId).effort).toBe('high')
})
// A confirmed switch is the session's effort, even one equal to what the settings filled (#1966 delta review).
it.each(['effort', 'profile'] as const)('keeps a confirmed %s equal to the settings when they change', async confirmed => {
let configured = 'high'
const manager = new RuntimeProfileState(() => ({ ...claudeRuntime, configuredEffort: async () => configured })), agent = session('claude')
manager.hydrate(agent, [])
await manager.ingestConfig(agent, true)
expect(manager.getState(agent.sessionId).effort).toBe('high')
if (confirmed === 'effort') manager.confirmEffort(agent.sessionId, 'high')
else manager.confirmControlProfile({ id: 'target', sessionId: agent.sessionId, engine: agent.engine, model: 'opus', effort: 'high' })
configured = 'medium'
await manager.ingestConfig(agent, true)
expect(manager.getState(agent.sessionId).effort).toBe('high')
})
it('does not notify for a read completed after the session was forgotten', async () => {
vi.useFakeTimers()
let finish!: (effort: string) => void
const configuredEffort = () => new Promise<string>(resolve => { finish = resolve })
const manager = new RuntimeProfileState(() => ({ ...claudeRuntime, configuredEffort })), agent = session('claude')
manager.hydrate(agent, [])
manager.confirmEffort(agent.sessionId, 'high')
const changed = vi.fn(); manager.onChanged = changed
const pending = manager.ingestConfig(agent)
manager.forget(agent.sessionId)
finish('low')
expect(await pending).toBe(false)
await vi.advanceTimersByTimeAsync(120)
expect(changed).not.toHaveBeenCalled()
})
it('discards a config answer for a different native home on the same mutable row', async () => {
const module = await loadEngine('hermes')
let finish!: () => void
const config = vi.fn(async ({ state }: InlineRuntimeContext) => {
await new Promise<void>(resolve => { finish = resolve })
state.model = 'old-home-model'; state.effort = 'high'; return true
})
vi.mocked(loadEngine).mockResolvedValueOnce({ ...module!, createRuntimeProfileReader: () => ({ engine: 'hermes', target: () => null, config }) })
const manager = new RuntimeProfileState(() => undefined), agent = { ...session('hermes'), hermesHome: '/tmp/first-profile' }
const pending = manager.ingestConfig(agent)
await vi.waitFor(() => expect(config).toHaveBeenCalledOnce())
agent.hermesHome = '/tmp/replacement-profile'
finish()
expect(await pending).toBe(false)
expect(manager.getState(agent.sessionId)).toMatchObject({ model: null, effort: null })
})
})
describe('runtime profiles without the pilot implementations', () => {
it.each([
['amp', 'amp-session.jsonl'], ['amp', 'amp-session-queued.jsonl'],
['muse', 'muse-session.jsonl'], ['copilot', 'copilot-session.jsonl'], ['agy', 'agy-session.jsonl'],
] as const)('preserves the registry seed when replaying the recorded %s transcript %s', (engine, file) => {
const lines = fixture(file).trim().split('\n')
// Audit the removed fallback against recordings, not formats inferred from Claude. None of these
// native records contributed profile metadata through that reader; their own config/panes do.
expect(lines.map(line => claudeRuntime.decode(JSON.parse(line))).filter(Boolean)).toEqual([])
const manager = new RuntimeProfileState(() => undefined)
const agent = session(engine)
manager.hydrate(agent, lines)
expect(manager.getState(agent.sessionId)).toEqual({
model: 'registered-model', effort: null, mode: 'unknown', cliVersion: '1.0.0', observedAt: null,
})
})
it('keeps Pi metadata in its native footer and never treats answer text as Claude commands', () => {
const manager = new RuntimeProfileState(() => undefined)
const agent = session('pi')
// These metadata records are copied from the Pi 0.82.1 recording in pi/normalizer.spec.ts.
const lines = [
'{"type":"session","version":3,"id":"019fa2a5-a26d-700c-bf8c-97af19ae3d5f","timestamp":"2026-07-27T08:16:31.854Z","cwd":"/tmp/pi-probe"}',
'{"type":"model_change","id":"45215278","parentId":null,"model":"minimax/minimax-m3"}',
'{"type":"thinking_level_change","id":"1da16955","parentId":"45215278","level":"medium"}',
]
expect(lines.map(line => claudeRuntime.decode(JSON.parse(line)))).toEqual([null, null, null])
manager.hydrate(agent, lines)
manager.ingestPane(agent, '0.0%/500k (auto) minimax/minimax-m3 • high', true)
const before = manager.getState(agent.sessionId)
expect(parseRuntimeProfile(manager.selectedModel(agent))).toMatchObject({
engine: 'pi', model: 'minimax/minimax-m3', effort: 'high',
})
// An answer explaining another CLI uses ordinary text in Pi's recorded message envelope.
expect(manager.ingest(agent, JSON.stringify({ type: 'message', message: {
role: 'assistant', content: [{ type: 'text', text: 'Set model to Opus 5\nSet effort level to low' }],
} }), true)).toBe(false)
expect(manager.getState(agent.sessionId)).toEqual(before)
})
// Pi 1.0 prints no `model • level` in its footer: the right edge clips the model's name and a footer
// extension can replace the line. Its session file still says both (shapes from a Pi 1.0.0 session,
// 2026-10-15; the values are invented).
it('reads Pi 1.0 model and thinking level from its session, never from the clipped footer', () => {
const manager = new RuntimeProfileState(() => undefined)
const agent = session('pi')
manager.hydrate(agent, [
'{"type":"session","version":3,"id":"s1","timestamp":"2026-10-15T03:00:00.000Z","cwd":"/tmp/pi"}',
'{"type":"model_change","id":"m1","parentId":null,"timestamp":"2026-10-15T03:00:01.000Z","provider":"autonomous-ai","modelId":"DeepSeek-V4-Flash-0731"}',
'{"type":"thinking_level_change","id":"t1","parentId":"m1","timestamp":"2026-10-15T03:00:01.000Z","thinkingLevel":"off"}',
])
expect(parseRuntimeProfile(manager.selectedModel(agent))).toMatchObject({ engine: 'pi', model: 'DeepSeek-V4-Flash-0731', effort: 'off' })
expect(manager.ingestPane(agent, '↑14M ↓289k R21M CH0.0% 51.4%/256k (auto) DeepSeek-V4-Fla', true)).toBe(false)
expect(parseRuntimeProfile(manager.selectedModel(agent))?.model).toBe('DeepSeek-V4-Flash-0731')
// Every answer names the model that gave it.
expect(manager.ingest(agent, JSON.stringify({ type: 'message', message: {
role: 'assistant', provider: 'autonomous-ai', model: 'Qwen/Qwen3.8-27B', content: [{ type: 'text', text: 'ok' }],
} }), true)).toBe(true)
expect(parseRuntimeProfile(manager.selectedModel(agent))?.model).toBe('Qwen/Qwen3.8-27B')
// A person's message names none.
expect(manager.ingest(agent, JSON.stringify({ type: 'message', message: { role: 'user', model: 'other', content: [] } }), true)).toBe(false)
})
it('confirms a Pi switch from the model_change its /model writes', async () => {
const manager = new RuntimeProfileState(() => undefined)
const agent = session('pi')
manager.hydrate(agent, ['{"type":"model_change","provider":"autonomous-ai","modelId":"DeepSeek-V4-Flash-0731"}'])
manager.beginControl(agent, { id: 'target', sessionId: agent.sessionId, engine: agent.engine, model: 'Qwen/Qwen3.8-27B', effort: 'auto' })
const waiting = manager.waitForModel(agent.sessionId, 1000)
manager.ingest(agent, '{"type":"model_change","provider":"autonomous-ai","modelId":"Qwen/Qwen3.8-27B"}', true)
expect(await waiting).toBe(true)
})
it.each(['amp', 'muse', 'copilot', 'terminal'] as const)('does not interpret Claude UI quoted in a %s pane', engine => {
// Apply the same boundary in explicit inline mode. Supplying a Claude facet must not make it a
// fallback for engines whose profile source is their own config or registration.
const manager = new RuntimeProfileManager(), agent = session(engine)
manager.hydrate(agent, [])
const before = manager.getState(agent.sessionId)
expect(manager.ingestPane(agent, 'Claude Code v2.1.212\nOpus 5 with high effort · Claude Max\nplan mode on', true)).toBe(false)
expect(manager.getState(agent.sessionId)).toEqual(before)
})
it('retains the native Muse and Amp config sources without loading either pilot facet', async () => {
const root = mkdtempSync(join(tmpdir(), 'legacy-profile-'))
const defaults = { muse: env.MUSE_CONFIG_DIR, amp: env.AMP_STATE_DIR }
try {
env.MUSE_CONFIG_DIR = join(root, 'muse'); env.AMP_STATE_DIR = join(root, 'amp')
mkdirSync(env.MUSE_CONFIG_DIR); mkdirSync(env.AMP_STATE_DIR)
// Verified config shapes documented in each engine's runtimeProfile.ts.
writeFileSync(join(env.MUSE_CONFIG_DIR, 'settings.json'), JSON.stringify({
schema_version: 1, provider: 'meta', model: 'muse-spark-1.2-contributor',
}))
writeFileSync(join(env.AMP_STATE_DIR, 'session.json'), JSON.stringify({ agentMode: 'medium' }))
const manager = new RuntimeProfileState(() => undefined)
for (const [engine, model, effort] of [
['muse', 'muse-spark-1.2-contributor', 'high'], ['amp', 'medium', 'auto'],
] as const) {
const agent = { ...session(engine), sessionId: engine }
await manager.ingestConfig(agent, true)
expect(parseRuntimeProfile(manager.selectedModel(agent))).toMatchObject({ engine, model, effort })
}
} finally {
env.MUSE_CONFIG_DIR = defaults.muse; env.AMP_STATE_DIR = defaults.amp
rmSync(root, { recursive: true, force: true })
}
})
it('still reads the captured agy footer and the registry-supplied CLI version', () => {
const manager = new RuntimeProfileState(() => undefined), agent = session('agy')
manager.hydrate(agent, [])
manager.ingestPane(agent, fixture('permission-agy.txt'), true)
expect(parseRuntimeProfile(manager.selectedModel(agent))).toMatchObject({
engine: 'agy', model: 'gemini-3.7-flash-high', effort: 'high',
})
expect(manager.getState(agent.sessionId).cliVersion).toBe('1.0.0')
})
})
describe('native evidence recovery', () => {
it.each(['configured effort', 'optional config', 'pane'] as const)('rejects a deferred %s after a complete hold/recovery cycle', async operation => {
const agent = session(operation === 'optional config' ? 'commandcode' : 'claude')
let finish!: () => void
const waiting = new Promise<void>(resolve => { finish = resolve })
const config = vi.fn(async ({ state }: InlineRuntimeContext) => { await waiting; state.effort = 'high'; return true })
vi.mocked(loadEngine).mockResolvedValue({ createRuntimeProfileReader: () => ({ engine: 'commandcode', config }) } as never)
const manager = new RuntimeProfileState(engine => engine === 'claude' ? { ...claudeRuntime,
configuredEffort: async () => { await waiting; return 'high' },
pane: ({ state }, text) => { state.model = text },
} : undefined, () => agent)
manager.hydrate(agent, [])
const before = { ...manager.getState(agent.sessionId) }
const pending = operation === 'pane'
? manager.capturePane(agent, async () => { await waiting; return 'stale-model' }, 20, true)
: manager.ingestConfig(agent, true)
if (operation === 'optional config') await vi.waitFor(() => expect(config).toHaveBeenCalledOnce())
agent.identityHold = 'incomplete'; agent.evidenceRevision = 1
expect(manager.ingestPane(agent, 'held-model')).toBe(false)
delete agent.identityHold; agent.evidenceRevision = 2
finish(); await pending
expect(manager.getState(agent.sessionId)).toEqual(before)
manager.forget(agent.sessionId)
})
})