super-dsh 0.1.10 → 0.1.11

package/README.md

@@ -14,7 +14,7 @@ the foreign store.
 ## Install
 
 ```bash
-dsh plugin --profile <name> add super-dsh@0.1.0
+dsh plugin --profile <name> add super-dsh@0.1.11
 ```
 
 That single package composes the whole line (`@pgmi-builds/superd-hub` plus the
@@ -27,12 +27,28 @@ home under `<DSH_HOME>/agents/<label>/` on first boot.
 | Label | Runtime | Integration |
 |---|---|---|
 | OMP | OMP (`~/.omp`) | host `omp` binary over RPC (`omp --mode rpc`, NDJSON v1), lazy per session |
-| Codex | Codex CLI (`~/.codex`) | adapter world plugin |
+| Codex | Codex app-server (`~/.codex`) | desktop core first, CLI and bundled core fallback |
 | Claude | Claude Code (`~/.claude`) | standalone adapter, joined by the hub |
 | Pi | pi coding agent (`~/.pi`) | in-process SDK |
 | Hermes | Hermes (`~/.hermes`) | gateway child |
 | Antigravity | agy SDK | Python bridge (`bridge/agy_bridge.py`) |
 
+### Codex in 0.1.11
+
+Codex discovers the local OpenAI OAuth login as a read-only provider in the
+model selector. Selecting it explicitly overrides a third-party provider in the
+native config, while credentials and native configuration stay in the native
+home. Third-party providers remain selectable per session.
+
+The adapter prefers the installed desktop core, then the CLI, then the bundled
+0.160.0 core (`CODEX_BIN` overrides discovery). Desktop host browser and computer
+use services are separate and are not attached by this adapter.
+
+**Known limitation:** returning a session with third-party reasoning history to
+OpenAI OAuth can be rejected by the official endpoint. Use a separate official
+session for now. Compaction before switching was proven in an isolated probe;
+automatic compaction is not included in this release.
+
 ### Opt-in SDK halves
 
 Three runtimes also ship a preserved in-process SDK transport beside the primary

package/agent-agy/dist/agent.js

@@ -129,9 +129,27 @@ export class AgyAgent {
                     this.closeStep();
                 this.commitStepStart();
                 const callId = ToolCallId(ev.id || `agy-${this.dashTurn}-${this.step}`);
+                const argumentsJson = ev.args || "{}";
+                // Advertisement-before-execution (validator invariant, 2026-10-04 dev3
+                // omp/hermes repair family): agy assistant frames carry only
+                // reasoning/text — never tool-call blocks — so every tool/call needs
+                // a minimal advertisement assistant frame first; arguments are copied
+                // verbatim into both frames (validator: lifecycle arguments ≡
+                // advertised, strict string equality).
+                const advertisement = createAssistantMessage({
+                    content: [{ type: "tool-call", id: callId, name: ev.name, arguments: argumentsJson }],
+                    source: {
+                        provider: this.options.provider ?? "agy",
+                        model: this.options.model ?? "",
+                    },
+                });
+                this.session.append("assistant/message", {
+                    turn: this.dashTurn, step: this.step,
+                    message: advertisement, stream: [],
+                }, { surfaceOp: "append" });
                 this.session.append("tool/call", {
                     turn: this.dashTurn, step: this.step,
-                    callId, name: ev.name, arguments: ev.args || "{}",
+                    callId, name: ev.name, arguments: argumentsJson,
                 });
                 this.unpairedCalls.push({ callId, name: ev.name });
             }

package/agent-claude/dist/adapter.js

@@ -4,8 +4,23 @@
  * The browser model selector never touches the Claude agent directly: it is an
  * RPC round-trip through the apiproxy, which reads `ctx.llm.listProviders /
  * listModels / resolveModel` to build the catalog. This adapter answers those
- * queries from the models Claude actually reported (`models.ts`) under the
- * single provider route `claude`.
+ * queries from TWO sources, one route each (the codex twin's one-route-per-
+ * provider shape, 2026-10-04 F-A rework):
+ *
+ *   - the fixed native route `claude` serves the OBSERVED catalog only (raw
+ *     ids — what the CLI itself reports, `models.ts`); its group stays "Claude".
+ *   - one route PER configured provider (route id = provider id) serves that
+ *     provider's curated `models[]` (RAW model ids, `claude-providers.ts`).
+ *
+ * The route/model composition therefore yields selection ids identical to the
+ * old composite keys (`deepseek/deepseek-flash`, `glm/glm-5.3`), so route seeds
+ * and logged selections keep working — the route half simply moved from the
+ * hardcoded `claude` to the provider id itself.
+ *
+ * The curated half follows the codex twin's rule exactly: the store is read
+ * LIVE on every call, so a panel edit is visible to the next catalog query
+ * without re-registration. An absent `worldHome` means observed-only (the
+ * settings-UI round trip and the unit tests).
  *
  * The route id must be `claude`, NOT `claude-code`: the upstream package
  * `@deepseek-ai/dsh-subagent-claude-code` already occupies the subagent
@@ -14,47 +29,107 @@
  * `stream` is never dispatched: Claude owns generation through its own SDK
  * thread, so the adapter only serves catalog/metadata queries. It throws
  * rather than fabricating a wire route the harness would misuse.
+ *
+ * @module agent-claude/adapter
  */
 import { LlmAdapter, LlmError, ReasoningEffortId, } from "@deepseek-ai/dsh-llm";
+import { readProviderStore } from "./claude-providers.js";
 import { readModelCatalog } from "./models.js";
-/** The one provider route every observed Claude model is served under. */
+/** The fixed native route every observed Claude model is served under. */
 export const CLAUDE_PROVIDER_ID = "claude";
-/** Human-readable provider name for selectors and diagnostics. */
+/** Human-readable provider name for the fixed native route. */
 const CLAUDE_PROVIDER_NAME = "Claude";
+/** Whether a provider may be registered as a model route. */
+export function routableProvider(entry) {
+    return entry.models.length > 0;
+}
+/** The route ids a store currently contributes to `ctx.llm`: the fixed `claude`
+ *  route first, then one route per provider that has models (store order). */
+export function routeIds(store) {
+    return [CLAUDE_PROVIDER_ID, ...store.providers.filter(routableProvider).map((entry) => entry.id)];
+}
 export class ClaudeLlmAdapter extends LlmAdapter {
-    providerInfo(_provider) {
-        return { id: CLAUDE_PROVIDER_ID, name: CLAUDE_PROVIDER_NAME };
+    worldHome;
+    /**
+     * @param worldHome - the world's DSH home, holding the curated provider
+     *   store in `<worldHome>/claude-providers.json`. Read on every call (the
+     *   codex twin's rule), so a panel edit is visible to the next catalog query
+     *   without re-registration. Absent = observed-only (the fixed `claude` route).
+     */
+    constructor(worldHome) {
+        super();
+        this.worldHome = worldHome;
+    }
+    /** The curated store entry a provider route id names, or `undefined`. */
+    curatedProvider(providerId) {
+        if (this.worldHome === undefined)
+            return undefined;
+        return readProviderStore(this.worldHome).providers.find((entry) => entry.id === providerId);
+    }
+    providerInfo(provider) {
+        if (provider === CLAUDE_PROVIDER_ID)
+            return { id: CLAUDE_PROVIDER_ID, name: CLAUDE_PROVIDER_NAME };
+        // The display name is the entry's label — for a provider folded in from the
+        // user's own settings that is its endpoint URL, the only name it supplies.
+        return { id: provider, name: this.curatedProvider(provider)?.label ?? provider };
     }
-    async listModels(_provider) {
-        return readModelCatalog().models.map((model) => ({
-            provider: CLAUDE_PROVIDER_ID,
+    async listModels(provider) {
+        if (provider === CLAUDE_PROVIDER_ID) {
+            // Observed catalog only, raw ids exactly as the CLI reported them.
+            return readModelCatalog().models.map((model) => ({
+                provider: CLAUDE_PROVIDER_ID,
+                id: model.id,
+                name: model.label,
+                ...(model.description === undefined ? {} : { description: model.description }),
+            }));
+        }
+        const entry = this.curatedProvider(provider);
+        if (entry === undefined)
+            return [];
+        return entry.models.map((model) => ({
+            provider,
             id: model.id,
-            name: model.label,
-            ...(model.description === undefined ? {} : { description: model.description }),
+            name: model.displayName ?? model.id,
         }));
     }
-    async resolveModel(_provider, model) {
-        const found = readModelCatalog().models.find((candidate) => candidate.id === model);
-        if (found === undefined) {
+    async resolveModel(provider, model) {
+        if (provider === CLAUDE_PROVIDER_ID) {
+            // Observed catalog (primary; unchanged behavior for the native route).
+            const found = readModelCatalog().models.find((candidate) => candidate.id === model);
+            if (found !== undefined) {
+                return {
+                    provider: CLAUDE_PROVIDER_ID,
+                    id: found.id,
+                    name: found.label,
+                    ...(found.description === undefined ? {} : { description: found.description }),
+                    // Only a positive window is real metadata: an absent or zero window must
+                    // never become `context: { contextWindow: 0 }`.
+                    ...(found.contextWindow !== undefined && found.contextWindow > 0
+                        ? { context: { contextWindow: found.contextWindow } }
+                        : {}),
+                    // The CLI's advertised effort levels become adapter-owned reasoning
+                    // efforts (omp thinking.efforts parity); the CLI names no default, so
+                    // none is invented.
+                    ...(found.reasoningEfforts !== undefined && found.reasoningEfforts.length > 0
+                        ? { reasoning: { efforts: found.reasoningEfforts.map((effort) => ({ id: ReasoningEffortId(effort), name: effort })) } }
+                        : {}),
+                };
+            }
             throw new LlmError(`Claude provider "${CLAUDE_PROVIDER_ID}" does not serve model "${model}"`, "MODEL_NOT_FOUND");
         }
-        return {
-            provider: CLAUDE_PROVIDER_ID,
-            id: found.id,
-            name: found.label,
-            ...(found.description === undefined ? {} : { description: found.description }),
-            // Only a positive window is real metadata: an absent or zero window must
-            // never become `context: { contextWindow: 0 }`.
-            ...(found.contextWindow !== undefined && found.contextWindow > 0
-                ? { context: { contextWindow: found.contextWindow } }
-                : {}),
-            // The CLI's advertised effort levels become adapter-owned reasoning
-            // efforts (omp thinking.efforts parity); the CLI names no default, so
-            // none is invented.
-            ...(found.reasoningEfforts !== undefined && found.reasoningEfforts.length > 0
-                ? { reasoning: { efforts: found.reasoningEfforts.map((effort) => ({ id: ReasoningEffortId(effort), name: effort })) } }
-                : {}),
-        };
+        const entry = this.curatedProvider(provider);
+        const curated = entry?.models.find((candidate) => candidate.id === model);
+        if (entry !== undefined && curated !== undefined) {
+            return {
+                provider,
+                id: curated.id,
+                name: curated.displayName ?? curated.id,
+                ...(curated.contextWindow !== undefined && curated.contextWindow > 0
+                    ? { context: { contextWindow: curated.contextWindow } }
+                    : {}),
+            };
+        }
+        throw new LlmError(`Claude provider "${provider}" does not serve model "${model}"`, "MODEL_NOT_FOUND");
     }
     stream(_options) {
         throw new LlmError("the Claude adapter does not stream: Claude owns generation through its SDK thread", "UNSUPPORTED_STREAM");

package/agent-claude/dist/agent.js

@@ -39,11 +39,14 @@
  */
 import { randomUUID } from "node:crypto";
 import { agentEvents } from "@deepseek-ai/dsh-agent";
+import { canonicalHeader, headerEquals } from "@deepseek-ai/dsh-session";
 import { LlmAttemptId, ToolCallId, createAssistantMessage, createSystemMessage, createToolResultMessage, createUserMessage, } from "@deepseek-ai/dsh-llm";
 import { createScope } from "@deepseek-ai/dsh-scope";
 import { toClaudeContent } from "./content.js";
 import { Inbox } from "./inbox.js";
 import { resetProjectionState } from "./claude-events.js";
+import { NATIVE_LAUNCH } from "./claude-launch.js";
+import { resolveRoute, routeSeed } from "./claude-route.js";
 import { CLAUDE_PROVIDER_ID } from "./adapter.js";
 import { claudePermissionMode, presetFromEvents } from "./permission.js";
 import { catalogFromInit, modelEntryFromSdk, readModelCatalog, setModelCatalog } from "./models.js";
@@ -235,6 +238,9 @@ export class ClaudeAgent {
     inbox;
     ctx;
     client;
+    /** Unsubscriber for the LIVE client's wire listener — released before a swap closes the old child. */
+    clientUnsubscribe = undefined;
+    clientFactory;
     loopCtx;
     scope;
     dispatch;
@@ -262,7 +268,12 @@ export class ClaudeAgent {
     systemMessageDone = false;
     /** Last `request/context` route key (`provider/model`) — dedupes per-turn emits. */
     lastRouteKey = null;
-    /** Live v2 assistant-stream publication for the in-flight wire message. */
+    /** The route the OPEN turn runs, captured when the turn opened. */
+    turnRoute = undefined;
+    /** The route the LIVE client was last told to run (`provider/model`) — a work-saver. */
+    routeKey = null;
+    /** Whether THIS agent instance has already logged a `request/header` snapshot. */
+    requestHeaderLogged = false;
     streamBridge;
     assistantAttemptCounter = 0;
     assistantStreamRevision = 0;
@@ -295,12 +306,13 @@ export class ClaudeAgent {
     commandsSignature = "";
     /** Releases the current mirror before it is rebuilt or the agent is disposed. */
     commandsDisposer = undefined;
-    constructor(loopCtx, id, options, session, client, onIdleExit, runtimeInfo) {
+    constructor(loopCtx, id, options, session, client, onIdleExit, runtimeInfo, clientFactory) {
         this.loopCtx = loopCtx;
         this.id = id;
         this.options = options;
         this.session = withSystemHead(session, () => createSystemMessage(""));
         this.client = client;
+        this.clientFactory = clientFactory;
         this.onIdleExit = onIdleExit;
         this.runtimeInfo = runtimeInfo;
         this.dispatch = agentEvents(loopCtx, this);
@@ -318,7 +330,7 @@ export class ClaudeAgent {
             this.attachCommandRuntime(commandCtx.commands);
         });
         this.lastTurn = session.snapshotEvents().findLast((event) => event.type === "turn/start")?.data.turn ?? 0;
-        client.on((event) => this.handleEvent(event));
+        this.clientUnsubscribe = client.on((event) => this.handleEvent(event));
         // Session-start projection reset: the module-level tool-name map must never
         // leak another session's tool into this one (Task 4 review finding).
         resetProjectionState();
@@ -420,6 +432,12 @@ export class ClaudeAgent {
         }
         this.markIdle();
         this.endActivity();
+        // Release the live client's wire listener BEFORE its child closes (Task 9
+        // ledger): without this the dispose path can still receive the superseded
+        // client's stale `agent_end` — the same bug class `reattach()` guards
+        // against on the swap path.
+        this.clientUnsubscribe?.();
+        this.clientUnsubscribe = undefined;
         this.client.close();
         resetProjectionState();
         // Release the command mirror explicitly (the agent scope would also dispose
@@ -618,8 +636,14 @@ export class ClaudeAgent {
      * than hanging, then unwinds the reservation.
      */
     async startTurn(message) {
+        let route;
         try {
-            await this.client.ensureStarted();
+            // Resolve the route and put it in force BEFORE the client is touched: a
+            // provider move is a different child, and a mid-turn selection change must
+            // land on the NEXT turn's applyRoute — never kill the running turn.
+            route = this.resolveRoute();
+            await this.applyRoute(route);
+            this.turnRoute = route;
             await this.bootstrapSessionIdentity();
         }
         catch (error) {
@@ -637,9 +661,11 @@ export class ClaudeAgent {
         if (this.disposed)
             return;
         this.session.append("turn/start", { turn: this.dashTurn });
-        // Route metadata for the next request (`request/context`) lands before
-        // the turn's messages, exactly as the reference loop stamps it.
-        this.emitRequestContext();
+        // Route metadata for the next request lands before the turn's messages,
+        // exactly as the reference loop stamps it.
+        if (route !== undefined)
+            this.commitRequestHeader(route);
+        this.emitRequestContext(route);
         this.appendUserMessage(message);
         // Flush any idle-injection that was parked before this turn.
         for (const entry of this.remoteQueue.splice(0)) {
@@ -743,25 +769,132 @@ export class ClaudeAgent {
      * effective provider/model plus the model's context window when genuinely
      * known. Turn-enclosed (no step required) and deduped by route key.
      */
-    emitRequestContext() {
+    emitRequestContext(route) {
         if (!this.turnOpen)
             return;
-        const model = this.observedMessageModel || this.observedDefaultModel || this.options.model || "";
+        // A resolved route names the raw provider/model pair (the route the selector
+        // picked); a missing route falls back to the observed model (the degraded
+        // single-provider shape), preserving the pre-multi-provider metadata.
+        const model = route !== undefined
+            ? route.model
+            : (this.observedMessageModel || this.observedDefaultModel || this.options.model || "");
         if (model === "")
             return;
-        const key = `${CLAUDE_PROVIDER_ID}/${model}`;
+        const provider = route?.provider ?? CLAUDE_PROVIDER_ID;
+        const key = `${provider}/${model}`;
         if (key === this.lastRouteKey)
             return;
         this.lastRouteKey = key;
-        const entry = readModelCatalog().models.find((candidate) => candidate.id === model);
-        const contextWindow = entry?.contextWindow;
+        const contextWindow = route !== undefined
+            ? (this.runtimeInfo?.contextWindowFor?.(route.provider, route.model)
+                ?? readModelCatalog().models.find((candidate) => candidate.id === route.model)?.contextWindow)
+            : undefined;
         this.session.append("request/context", {
-            provider: CLAUDE_PROVIDER_ID,
+            provider,
             model,
             ...(contextWindow !== undefined && contextWindow > 0 ? { contextWindow } : {}),
         });
         trace(`request/context ${key}${contextWindow === undefined ? "" : ` ctx=${contextWindow}`}`);
     }
+    /**
+     * Resolve the route this session must run, mirroring the harness's own
+     * precedence (`pending ?? logged ?? preferred ?? fallback`). Each candidate is
+     * already a raw provider/model pair — the provider IS the route id and the
+     * model IS the raw wire id (the codex twin's shape). A provider id with no
+     * store entry reads as "launch native, inject nothing".
+     */
+    resolveRoute() {
+        const projections = this.loopCtx.get("sessionProjections");
+        const service = this.ctx.get("agentDefaultModel");
+        return resolveRoute({
+            pending: projections?.stateOf?.(this.session, "modelSelection")?.pending,
+            logged: this.session.requestHeader()?.config,
+            preferred: service?.currentSelection?.(),
+            fallback: routeSeed(this.options),
+        });
+    }
+    /**
+     * Put the resolved route in force on the client, swapping the child when the
+     * provider moved. Three cases, in increasing cost:
+     *  1. nothing spawned yet — pin the launch and let the first prompt spawn
+     *     (the lazy-spawn gate: choosing a model must not cost a process);
+     *  2. same provider — `setModel` rides the live query with the RAW id;
+     *  3. different provider — the child is replaced (`reattach`).
+     */
+    async applyRoute(route) {
+        const launch = route === undefined ? undefined : this.runtimeInfo?.launchFor?.(route.provider, route.model);
+        // An unknown provider id (a legacy session pinned before the multi-provider
+        // rework) maps to "no injection": the user's own settings.json decides.
+        const launchSpec = launch ?? NATIVE_LAUNCH;
+        const providerId = launch === undefined ? null : route?.provider ?? null;
+        const client = this.client;
+        const key = `${providerId ?? "native"}/${route?.model ?? ""}`;
+        if (!client.spawned) {
+            client.setLaunch(launchSpec);
+            await client.ensureStarted();
+        }
+        else if ((client.appliedProvider ?? null) !== providerId) {
+            await this.reattach(launchSpec, providerId, route);
+        }
+        else if (route !== undefined) {
+            await client.setModel(route.model).catch((error) => {
+                trace(`set_model ${key} failed: ${String(error)}`);
+            });
+        }
+        this.routeKey = key;
+    }
+    /**
+     * Replace the client at a turn boundary: close the old one and build a fresh
+     * child through the injected factory, resuming the SAME SDK session id and
+     * re-wiring the event listener and the live permission mode.
+     */
+    async reattach(launch, _providerId, _route) {
+        const old = this.client;
+        const threadId = old.threadId;
+        this.clientUnsubscribe?.();
+        old.close();
+        if (this.clientFactory === undefined) {
+            throw new Error("agent-claude: cannot reattach — no clientFactory was injected");
+        }
+        const replacement = this.clientFactory({ ...(threadId !== null ? { resumeSessionId: threadId } : {}), launch });
+        this.clientUnsubscribe = replacement.on((event) => this.handleEvent(event));
+        this.client = replacement;
+        // Re-apply the live permission mode onto the fresh child (the old client's
+        // buffered control calls died with it).
+        const mode = this.runtimeInfo?.claudeMode ?? claudePermissionMode(presetFromEvents(this.session.snapshotEvents()));
+        if (mode !== undefined)
+            void replacement.setPermissionMode(mode).catch(() => { });
+        await replacement.ensureStarted();
+    }
+    /**
+     * Log the request header the NEXT request runs under, so the harness's
+     * `modelSelection` projection retires a pending switch when it matches.
+     */
+    commitRequestHeader(route) {
+        const header = canonicalHeader({
+            config: {
+                provider: route.provider,
+                model: route.model,
+            },
+        });
+        const baseline = this.session.requestHeader();
+        if (!this.requestHeaderLogged) {
+            this.session.append("request/header", { header, reason: baseline === undefined ? "initial" : "resume" });
+            this.requestHeaderLogged = true;
+            return;
+        }
+        if (baseline === undefined || !headerEquals(baseline, header)) {
+            this.session.append("request/header", { header, reason: "change" });
+        }
+    }
+    /** Test-only thin shell over {@link applyRoute}. */
+    async applyRouteForTest(route) {
+        await this.applyRoute(route);
+    }
+    /** Test-only thin shell over {@link resolveRoute}. */
+    resolveRouteForTest() {
+        return this.resolveRoute();
+    }
     /** The open stream bridge for this message, starting one on first use. */
     ensureStreamBridge() {
         if (this.streamBridge === undefined || this.streamBridge.ended) {
@@ -836,8 +969,12 @@ export class ClaudeAgent {
      * projection carried — so the `tool_start` flush lands a same-attempt
      * sample and nothing ever stashes across turns.
      */
-    flushAssistant(usage) {
-        if (this.reasoningBuffer === "" && this.textBuffer === "") {
+    flushAssistant(usage, toolCall) {
+        // A toolCall rides the SAME frame (advertise+usage on one attempt): the
+        // token-meter fold requires every step's assistant frame to carry a usage
+        // sample, so a separate no-usage advertisement frame would turn the
+        // turn's whole usage disclosure undefined.
+        if (toolCall === undefined && this.reasoningBuffer === "" && this.textBuffer === "") {
             if (usage !== undefined)
                 trace("flush had usage but no buffered content — sample dropped (no message carries it)");
             return;
@@ -847,6 +984,9 @@ export class ClaudeAgent {
             blocks.push({ type: "reasoning", text: this.reasoningBuffer });
         if (this.textBuffer !== "")
             blocks.push({ type: "text", text: this.textBuffer });
+        if (toolCall !== undefined) {
+            blocks.push({ type: "tool-call", id: ToolCallId(toolCall.callId), name: toolCall.name, arguments: toolCall.arguments });
+        }
         this.reasoningBuffer = "";
         this.textBuffer = "";
         const effectiveUsage = usage ?? this.capturedUsage;
@@ -856,7 +996,7 @@ export class ClaudeAgent {
         const assistant = createAssistantMessage({
             content: blocks,
             // The OBSERVED model (what the CLI actually ran), not the requested one.
-            source: { provider: CLAUDE_PROVIDER_ID, model: this.observedMessageModel || this.observedDefaultModel || this.options.model || "" },
+            source: { provider: this.turnRoute?.provider ?? CLAUDE_PROVIDER_ID, model: this.observedMessageModel || this.observedDefaultModel || this.options.model || "" },
         });
         const event = this.session.append("assistant/message", {
             turn: this.dashTurn,
@@ -873,13 +1013,23 @@ export class ClaudeAgent {
         this.streamBridge = undefined;
     }
     appendToolCall(callId, name, args) {
-        this.commitStepStart();
+        // The tool-call block rides the SAME assistant/message as any pending
+        // text (native advertise+usage shape): one attempt per step with the
+        // usage sample AND the advertisement on one frame. A separate no-usage
+        // advertisement frame would satisfy the format validator but break the
+        // token-meter fold (every step's assistant frame needs a usage sample).
+        const argumentsJson = JSON.stringify(args ?? {});
+        this.flushAssistant(undefined, {
+            callId,
+            name,
+            arguments: argumentsJson,
+        });
         this.session.append("tool/call", {
             turn: this.dashTurn,
             step: this.step,
             callId: ToolCallId(callId),
             name,
-            arguments: JSON.stringify(args ?? {}),
+            arguments: argumentsJson,
         });
     }
     appendToolResult(callId, content, isError) {
@@ -905,13 +1055,17 @@ export class ClaudeAgent {
     observeModelCatalog(init) {
         if (typeof init.model === "string" && init.model !== "")
             this.observedDefaultModel = init.model;
+        // The observed catalog stays RAW: the fixed `claude` route serves exactly
+        // what the CLI reported, and curated provider models live under their own
+        // routes (2026-10-04 F-A) — no composite minting here.
         const entries = catalogFromInit(init);
         if (entries.length > 0)
             setModelCatalog(entries, this.observedDefaultModel);
         void this.client.supportedModels().then((models) => {
             const full = Array.isArray(models) ? models.flatMap((m) => modelEntryFromSdk(m)) : [];
-            if (full.length > 0)
-                setModelCatalog(full, this.observedDefaultModel);
+            if (full.length === 0)
+                return;
+            setModelCatalog(full, this.observedDefaultModel);
         }).catch((error) => {
             trace(`supportedModels() failed: ${String(error)}`);
         });
@@ -1056,7 +1210,8 @@ export class ClaudeAgent {
                 // RC-6: the mid-turn flush closes the attempt WITH the sample the
                 // message itself reported (captured above / on the assistant events).
                 this.captureProvenance(event);
-                this.flushAssistant();
+                // flushes pending text WITH the tool-call block as one assistant
+                // message (advertise+usage on one attempt — see appendToolCall).
                 this.appendToolCall(callId, name, event.arguments);
                 break;
             }
@@ -1133,7 +1288,7 @@ export class ClaudeAgent {
                     this.commitStepStart();
                     const assistant = createAssistantMessage({
                         content: blocks,
-                        source: { provider: CLAUDE_PROVIDER_ID, model: String(event.fallbackModel ?? this.options.model ?? "") },
+                        source: { provider: this.turnRoute?.provider ?? CLAUDE_PROVIDER_ID, model: String(event.fallbackModel ?? this.options.model ?? "") },
                     });
                     this.session.append("assistant/message", {
                         turn: this.dashTurn,