Surface the model and thinking level agents actually use

[colonelpanic8]

Linked issue

Part of #2644

Type of change

• Bug fix
• New feature (with prior issue + design alignment)
• Refactor / code improvement
• Docs

What does this PR do

Paseo only ever showed the model and thinking level you had selected, never what the agent was actually running. Those can differ: Codex collaboration modes inject their own model and reasoning effort, models fall back mid-session, and a provider may refuse a configured model outright. Subagent rows showed no model at all, so with several subagents running there was no way to tell what any of them was using.

The observed-vs-configured channel already existed end to end — runtimeInfo.model, runtimeInfo.thinkingOptionId, and the daemon's runtime-preferring effectiveThinkingOptionId. It was unevenly populated and barely surfaced. No protocol changes were needed (git diff --stat -- packages/protocol is empty).

Server — populate runtimeInfo from data the runtimes already send and Paseo was discarding:

• Codex captures model and reasoningEffort from thread/start, thread/resume, and thread/turn notifications, normalized to catalog thinking ids. An omitted effort retains the last observation; an explicit null clears it and falls back to config.
• Claude captures per-turn assistant-message models, not just the SDK init model, so a mid-session fallback is visible; and run() no longer drops the raw extra.runtimeModel.
• OpenCode keeps the observed assistant providerID/modelID it was already resolving for context-window lookups.
• All three clear their observations on setModel/setThinkingOption, so a stale observation can never shadow a fresh user selection.

App — surface it, runtime-preferring, and never guess:

• Subagents track rows gain trailing Model · Thinking meta, and now prefer the human task description over the provider's agent-type label (Claude subagents were showing "general-purpose" instead of the Task description).
• Desktop tab tooltips show Claude · Opus 4.5 · High.
• The running-turn indicator and the context-window tooltip show model and thinking.
• The composer thinking chip reads out the runtime value while the dropdown keeps marking the configured one, so a mutation stays relative to config.
• The client stops discarding effectiveThinkingOptionId, preserving the load-bearing "absent (daemon never sent it)" vs "explicit null" distinction through the store and the offline replica cache.

Display never substitutes a guess for something unknown: an off-catalog runtime model or thinking id renders verbatim rather than falling back to the configured model or to the first available option. Provider-subagent rows have no model on the wire yet and render no meta.

Partial provider coverage is intentional — ACP (Copilot) and Pi/OMP already reported runtime values correctly and are untouched.

How did you verify it

Automated, all run locally on this branch:

• npm run typecheck — clean across all workspaces.
• npm run lint — 0 warnings, 0 errors.
• npm run format (Biome/oxfmt) — clean; also enforced by the pre-commit hook.
• Provider unit tests: codex-app-server-agent.test.ts (new cases for observed capture from start/resume/notifications, observed-over-configured precedence, absent-vs-null effort, and stale-observation clearing on setModel/setThinkingOption), claude/agent.test.ts (62 passed), opencode-agent.test.ts (70 passed).
• App unit tests: composer/agent-controls/utils.test.ts (32 passed), plus subagents/select, subagents/track-presentation, utils/agent-snapshots, panels/agent-panel-descriptor, runtime/replica-cache — 91 passed across the six files.
• Pre-existing unrelated failure, confirmed not mine: the full Codex test file stops at configures Codex app-server to use a custom provider base URL. I stashed only my changes and reproduced the identical failure on unmodified HEAD.

Review: the full diff went through an adversarial review pass that specifically hunted stale-observation and absent-vs-null bugs. It found three real defects, all fixed in this branch and each now pinned by a regression test: the Codex and OpenCode setModel/setThinkingOption reset described above, and a display path that could read out a thinking level the agent was not using (the runtime id fell through to thinkingOptions[0]).

Screenshots: posted in a follow-up comment — subagents track, desktop tab tooltip, context window tooltip, and the running-turn indicator, captured against a dev daemon running this branch with three real Codex agents. That setup incidentally reproduces the bug: two children configured low/medium are observed running at high, so the old UI would have misreported them.

Captured on web only (headless Chromium, desktop layout). iOS, Android, and Electron desktop are not captured — this is a headless machine. The compact layout is worth a visual check before merge (row meta truncates at maxWidth: 40%, and track actions are always-visible on native/compact); happy to get a simulator/device capture if you want it.

Checklist

• One focused change. Unrelated cleanups split out.
• npm run typecheck passes
• npm run lint passes
• npm run format ran (Biome)
• UI changes include screenshots — web/desktop layout only; iOS, Android, and Electron not captured (headless machine), called out above
• Tests added or updated where it made sense

---

Disclosure: written with AI assistance (Claude Code). The design decisions, the review pass, and every verification claim above are things I ran and read myself; the one thing I could not stand up is called out rather than papered over.

[greptile-apps]

Greptile Summary

This PR records the model and thinking level actually observed from supported agent runtimes and surfaces that attribution throughout the app.

• Captures runtime model and reasoning observations from Claude, Codex, and OpenCode while clearing stale observations after configuration changes.
• Preserves runtime attribution through protocol projections, session state, timeline history, and offline replica caching.
• Displays observed model and thinking metadata in turn footers, composer controls, context-window details, desktop tabs, and subagent rows.
• Adds regression coverage for runtime capture, off-catalog identifiers, timeline attribution, state propagation, and display resolution.

Confidence Score: 5/5

The PR appears safe to merge.

No blocking failure remains; the previously reported off-catalog Claude model issues are fixed across current runtime state, live timeline attribution, coalesced messages, and restored history.

Important Files Changed

Filename	Overview
packages/server/src/server/agent/providers/claude/agent.ts	Captures Claude runtime model and effort observations across live, coalesced, and restored timeline paths, including raw off-catalog identifiers.
packages/server/src/server/agent/providers/codex-app-server-agent.ts	Captures Codex runtime model and reasoning effort from thread lifecycle messages and clears stale observations after configuration changes.
packages/server/src/server/agent/providers/opencode-agent.ts	Retains OpenCode’s observed provider/model identity and resets it when model or thinking configuration changes.
packages/app/src/hooks/use-agent-model-display.ts	Centralizes runtime-preferred model and thinking display resolution for app surfaces.
packages/app/src/agent-stream/turn-attribution.ts	Resolves completed-turn attribution from the final attributed assistant message without crossing turn boundaries.
packages/app/src/runtime/replica-cache/index.ts	Preserves effective thinking attribution, including the distinction between an absent field and explicit null, in cached replicas.
packages/protocol/src/agent-types.ts	Extends shared agent and timeline types to carry runtime and per-turn attribution through existing protocol channels.

Sequence Diagram

sequenceDiagram
  participant Provider as Agent provider
  participant Server as Paseo daemon
  participant Store as Client session store
  participant UI as App surfaces
  Provider->>Server: Runtime model and thinking observations
  Server->>Server: Normalize known values or preserve raw identifiers
  Server->>Store: runtimeInfo and attributed timeline items
  Store->>UI: Runtime-preferred model and thinking metadata

Loading

_{Reviews (9): Last reviewed commit: "fix: keep AgentControls under the comple..." | Re-trigger Greptile}

[colonelpanic8]

Screenshots (web, desktop layout)

Captured against a dev daemon running this branch's server code, with three real Codex agents (a parent plus two children created with a paseo.parent-agent-id label). Platform coverage is stated at the bottom.

The setup happens to demonstrate the exact bug this PR fixes. All three agents were created with a configured thinking level, and Codex reports something different at runtime:

Agent	Configured	Observed (runtimeInfo)
Investigate runtime model reporting	gpt-5.6-sol / high	gpt-5.6-sol / high
Map the Codex capture sites	gpt-5.6-luna / low	gpt-5.6-luna / high
Audit absent-vs-null semantics	gpt-5.6-terra / medium	gpt-5.6-terra / high

Before this PR the UI would have shown "Low" and "Medium" for those children. It now shows what Codex is actually doing.

Subagents track — trailing Model · Thinking, plus the composer chips

Rows read GPT-5.6-Luna · High and GPT-5.6-Terra · High. Titles come from the description-first label change (these are Paseo subagents; provider subagents have no model on the wire yet and render no meta).

Desktop tab tooltip

Codex · GPT-5.6-Sol · High — replaces the old Codex agent.

Context window tooltip

(Cropped to omit my provider plan usage, which the tooltip also renders.)

Running-turn indicator

Captured mid-turn: 2s · GPT-5.6-Sol · High.

Also verified by hand

• Expanding/collapsing the track, and the density rule: at a narrower pane the thinking chip drops its label to just the brain glyph (existing layout.ts behavior, unchanged).
• agent update --thinking against the live daemon, confirming the stale-observation fix — after changing the configured level, getRuntimeInfo() follows config immediately instead of replaying the earlier observation.

Platform coverage — read this before trusting the above

Captured: web only (headless Chromium, 1600x1000, desktop layout). Not captured: iOS, Android, or Electron desktop. This machine is a headless server, so native and Electron captures need a display I do not have here; I tried a narrow-viewport web capture to stand in for the compact layout and the mobile navigation didn't cooperate, so I am not claiming it. The compact path does matter for this change — the subagent row meta has maxWidth: 40% and truncates before the title, and the track's action buttons are always visible on native/compact — so if you want that verified visually before merging, say so and I will get a real device or simulator capture rather than guess.

[colonelpanic8]

Added: per-turn model attribution

Scope grew by request — the thread now records which model produced each assistant turn, not just what the agent is running right now. Same feature, so it's in this PR rather than a follow-up.

What it looks like

Completed turn footers gain the model and thinking level that produced them:

In a thread, every turn carries its own attribution:

Together with the subagent rows from the earlier comment:

How it works

assistant_message timeline items gained optional model / thinkingOptionId. Old clients ignore them, old daemons omit them, absence renders nothing — no capability gate needed. Providers stamp only what they actually observed, never the configured value.

History: Claude and OpenCode backfill from their persisted transcripts, so existing conversations gain attribution retroactively. Codex is forward-only — its transcript exposes no per-message model.

Two things found by testing this against a live agent, not by reading the diff

1. Codex turns were silently unattributed. Attribution was keyed on per-turn observations, but the real app-server reports model/effort on the thread response and usually omits them from turn notifications — so in practice nothing was ever stamped. Fixed by falling back to the thread-level observation (still something Codex reported), with a turn's own value preferred when present. The unit tests passed throughout, because they fed turn notifications that carried the fields; only a live agent showed the gap.

2. A rejected fix that rewrote history. I first tried also falling back to the model Paseo requested for the turn, so attribution would survive a model switch. It looked right and passed tests — then in the live app I watched an earlier Sol turn silently repaint itself as Luna after I switched models, because that fallback reflects current config and any replay reapplies it. Reverted. Recording a turn wrong is worse than recording nothing.

Known limitation

A turn taken immediately after a model switch may be unattributed until the runtime reports again — Codex clears its observation on setModel and doesn't necessarily re-report on the next turn. Verified behavior: past turns keep their recorded values; only the new turn is blank. I'd rather ship that than guess.

Verification

• npm run typecheck, npm run lint, npm run format — all clean (also enforced by the pre-commit hook).
• 341 tests across the touched app and server files, including new coverage for turn attribution, absent-vs-null, child-message isolation, and the mid-turn-change rule.
• Screenshots above are a live Codex agent against a dev daemon running this branch.

Platform coverage is unchanged from the earlier comment: web only, no iOS/Android/Electron captures.

[colonelpanic8]

Pushed 9915e10, a follow-up found by dogfooding the branch: the observed model was invisible for most of an agent's life.

• The manager only refreshed runtimeInfo on thread_started / turn_completed, and Claude pre-assigns its session id so thread_started never fires for it — a running Claude agent (exactly what the subagents track shows) reported no model until its turn completed. Claude now dispatches model_changed on capture, the same push path ACP uses.
• turn_failed / turn_canceled now refresh runtime info like turn_completed does.
• The <synthetic> placeholder is no longer treated as an observation (one had reached a real agent record as its display model); all four attribution sites now go through resolveObservedClaudeModelId.
• Loading a persisted transcript re-seeds the observation from the last real assistant entry, so a daemon restart no longer blanks the model until the next turn.

Verified with new regression tests in claude/agent.test.ts (70 pass), agent-manager.test.ts (143 pass), plus 139 across the related Claude provider/subagent files; typecheck and lint clean.