muonroi-cli 1.8.5 → 1.9.0

package/dist/src/providers/runtime.d.ts

@@ -6,14 +6,7 @@ export type ProviderFactory = ((modelId: string) => any) & {
     defaultProviderOptions?: Record<string, unknown>;
     /** AI SDK top-level call params to strip (backend doesn't accept them). */
     unsupportedParams?: ReadonlyArray<"maxOutputTokens" | "temperature" | "topP">;
-    /**
-     * The provider this factory talks to. Stamped by createProviderFactory so a
-     * caller that blindly reuses one provider's factory with a model from a
-     * DIFFERENT provider can be detected and auto-corrected in resolveModelRuntime
-     * (see the factory registry below) — otherwise the request would hit the wrong
-     * endpoint (e.g. a gateway-routed model POSTed straight to a native API,
-     * bypassing the configured gateway).
-     */
+    /** The provider this factory talks to. Stamped by createProviderFactory. */
     providerId?: ProviderId;
 };
 export interface ProviderFactoryResult {
@@ -30,6 +23,15 @@ export interface ResolvedModelRuntime {
 }
 /** Test seam: clear the registry between cases so entries never leak across specs. */
 export declare function __resetProviderFactoryRegistry(): void;
+/**
+ * Whether a factory for `id` was already built this session.
+ *
+ * Used by the boot warm-up to avoid CLOBBERING a factory that was built with
+ * session-specific options (custom baseURL, OAuth headers) with a plainer one.
+ */
+export declare function hasProviderFactory(id: ProviderId): boolean;
+/** The providers that have a factory this session. */
+export declare function registeredProviderIds(): ProviderId[];
 /**
  * Phase 12.2-G4: thin dispatcher delegating to the provider strategy registry.
  * Each provider's SDK wiring + `factory.responses` + `defaultProviderOptions`
@@ -52,7 +54,20 @@ export declare function createProviderFactoryAsync(id: ProviderId, opts: {
     apiKey?: string;
     baseURL?: string;
 }): Promise<ProviderFactoryResult>;
-export declare function resolveModelRuntime(factory: ProviderFactory, modelId: string): ResolvedModelRuntime;
+/**
+ * The factory for `modelId`'s OWN provider.
+ *
+ * Deriving the factory from the model is what makes a cross-wire structurally
+ * impossible: callers pass only a model id, so there is no second, independent
+ * value that can disagree with it. Previously the factory and the model id
+ * travelled separately and every sub-task path (compaction, classify,
+ * sub-agents) silently borrowed whatever factory its parent held — measured
+ * live 2026-07-16 (session 0c6728ba1a25): model `gpt-5.4` (openai) went out
+ * through an `xai` factory, and api.x.ai answered "The model gpt-5.4 does not
+ * exist", sending the user hunting a model-name problem that did not exist.
+ */
+export declare function factoryForModel(modelId: string): ProviderFactory;
+export declare function resolveModelRuntime(modelId: string): ResolvedModelRuntime;
 /**
  * F1: derive a stable OpenAI prompt-cache key from the session id.
  *

package/dist/src/providers/runtime.js

@@ -1,24 +1,36 @@
 import { createHash } from "node:crypto";
 import { getModelInfo } from "../models/registry.js";
-import { logger } from "../utils/logger.js";
 import { getReasoningEffortForModel } from "../utils/settings.js";
 import { getProviderCapabilities } from "./capabilities.js";
 import { getProviderStrategy } from "./strategies/registry.js";
 /**
  * Session-scoped registry of the most-recently-built factory per provider.
- * resolveModelRuntime consults this to auto-correct a factory/model provider
- * mismatch: when a caller reuses provider A's factory to run a model that
- * belongs to provider B (a real hazard in sub-task paths like compaction that
- * inherit the parent session's factory), we substitute B's real factory if one
- * was built this session. Single-orchestrator invariant (v1, see CQ-16a) makes
- * a module-level map safe. Last-built wins, so a /model key change that rebuilds
- * a provider's factory transparently refreshes the entry.
+ * It is the ONLY way a model reaches a factory: `factoryForModel` derives the
+ * factory from the model's own provider, so provider A's factory can never be
+ * paired with provider B's model (a real hazard in sub-task paths like
+ * compaction that used to inherit the parent session's factory). Boot warms an
+ * entry for every credentialed provider (see ./warm.ts). Single-orchestrator
+ * invariant (v1, see CQ-16a) makes a module-level map safe. Last-built wins, so
+ * a /model key change that rebuilds a provider's factory refreshes the entry.
  */
 const providerFactoryRegistry = new Map();
 /** Test seam: clear the registry between cases so entries never leak across specs. */
 export function __resetProviderFactoryRegistry() {
     providerFactoryRegistry.clear();
 }
+/**
+ * Whether a factory for `id` was already built this session.
+ *
+ * Used by the boot warm-up to avoid CLOBBERING a factory that was built with
+ * session-specific options (custom baseURL, OAuth headers) with a plainer one.
+ */
+export function hasProviderFactory(id) {
+    return providerFactoryRegistry.has(id);
+}
+/** The providers that have a factory this session. */
+export function registeredProviderIds() {
+    return [...providerFactoryRegistry.keys()];
+}
 /**
  * Phase 12.2-G4: thin dispatcher delegating to the provider strategy registry.
  * Each provider's SDK wiring + `factory.responses` + `defaultProviderOptions`
@@ -82,7 +94,31 @@ export async function createProviderFactoryAsync(id, opts) {
     }
     return createProviderFactory(id, opts);
 }
-export function resolveModelRuntime(factory, modelId) {
+/**
+ * The factory for `modelId`'s OWN provider.
+ *
+ * Deriving the factory from the model is what makes a cross-wire structurally
+ * impossible: callers pass only a model id, so there is no second, independent
+ * value that can disagree with it. Previously the factory and the model id
+ * travelled separately and every sub-task path (compaction, classify,
+ * sub-agents) silently borrowed whatever factory its parent held — measured
+ * live 2026-07-16 (session 0c6728ba1a25): model `gpt-5.4` (openai) went out
+ * through an `xai` factory, and api.x.ai answered "The model gpt-5.4 does not
+ * exist", sending the user hunting a model-name problem that did not exist.
+ */
+export function factoryForModel(modelId) {
+    const providerId = getModelInfo(modelId)?.provider;
+    if (!providerId) {
+        throw new Error(`Model "${modelId}" not found in catalog — cannot determine provider.`);
+    }
+    const factory = providerFactoryRegistry.get(providerId);
+    if (!factory) {
+        throw new Error(`No provider factory for "${providerId}" (model "${modelId}") — that provider is not authenticated this session. ` +
+            `Run /login for it, or pick a model from an authenticated provider.`);
+    }
+    return factory;
+}
+export function resolveModelRuntime(modelId) {
     // Resolve aliases (e.g. "deepseek-v4-flash") to the provider-native id
     // (e.g. "deepseek-v4-flash") BEFORE invoking the factory.
     // Without this, DeepSeek / xAI reject the request because
@@ -94,32 +130,6 @@ export function resolveModelRuntime(factory, modelId) {
     if (!providerId && !mockGlobals.__muonroiMockModel) {
         throw new Error(`Model "${modelId}" not found in catalog — cannot determine provider.`);
     }
-    // Factory/model provider guard (Layer 2). A caller that reuses one provider's
-    // factory to run a model from another provider (e.g. compaction inheriting the
-    // parent session's native factory for a gateway-routed model) would otherwise
-    // POST to the wrong endpoint. If the passed factory is stamped for a different
-    // provider AND we built the correct one this session, substitute it so the
-    // request lands on the right backend; otherwise keep going (Part 3's wire-id
-    // normalization keeps it valid) but log the mismatch so it is never silent.
-    let effectiveFactory = factory;
-    if (providerId && factory.providerId && factory.providerId !== providerId) {
-        const correct = providerFactoryRegistry.get(providerId);
-        if (correct) {
-            effectiveFactory = correct;
-            logger.debug("orchestrator", "Redirected model to its own provider factory", {
-                modelId: canonicalId,
-                modelProvider: providerId,
-                factoryProvider: factory.providerId,
-            });
-        }
-        else {
-            logger.warn("orchestrator", "Factory/model provider mismatch; no factory for model's provider", {
-                modelId: canonicalId,
-                modelProvider: providerId,
-                factoryProvider: factory.providerId,
-            });
-        }
-    }
     const userEffort = getReasoningEffortForModel(modelId);
     const mockModel = mockGlobals.__muonroiMockModel;
     // Determine the language model + unsupportedParams + provider-level defaults.
@@ -147,14 +157,15 @@ export function resolveModelRuntime(factory, modelId) {
         providerLevelDefaults = mockGlobals.__muonroiMockDefaultProviderOptions;
     }
     else {
+        const factory = factoryForModel(canonicalId);
         const strategy = getProviderStrategy(providerId);
         resolved = strategy.resolve({
-            factory: effectiveFactory,
+            factory,
             modelId: canonicalId,
             modelInfo,
             reasoningEffort: userEffort,
         });
-        providerLevelDefaults = effectiveFactory.defaultProviderOptions;
+        providerLevelDefaults = factory.defaultProviderOptions;
     }
     // Merge provider-level defaults from the factory (e.g. OAuth backends inject
     // `instructions` + `store: false` for the ChatGPT Codex API). This keeps

package/dist/src/providers/strategies/thinking-mode.js

@@ -242,7 +242,15 @@ export function sanitizeToolCallArguments(messages) {
                 }
                 else {
                     try {
-                        JSON.parse(trimmed);
+                        const parsed = JSON.parse(trimmed);
+                        // Tool arguments MUST be a JSON object. grok-composer (and some other
+                        // models) occasionally emit a bare string / number / array / null —
+                        // valid JSON but the wrong shape — which xAI rejects with 400
+                        // "expected JSON object for tool arguments" (a non-transient error
+                        // that wedges the retry loop). Normalize any non-object to {}.
+                        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+                            repaired = "{}";
+                        }
                     }
                     catch {
                         repaired = "{}";

package/dist/src/providers/strategies/xai.strategy.js

@@ -7,6 +7,7 @@ import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { getProviderCapabilities } from "../capabilities.js";
 import { OPENAI_COMPATIBLE_BASE_URLS } from "../endpoints.js";
 import { BaseProviderStrategy } from "./base.strategy.js";
+import { sanitizeToolCallArguments, splitParallelToolCalls } from "./thinking-mode.js";
 export class XAIStrategy extends BaseProviderStrategy {
     id = "xai";
     capabilities = getProviderCapabilities("xai");
@@ -22,6 +23,32 @@ export class XAIStrategy extends BaseProviderStrategy {
             baseURL: opts.baseURL ?? OPENAI_COMPATIBLE_BASE_URLS.xai,
             apiKey: opts.apiKey ?? (opts.headers ? "oauth" : undefined),
             ...(opts.headers ? { headers: opts.headers } : {}),
+            // grok-composer (Cursor Composer via xAI) emits BATCHES of parallel
+            // tool_calls per assistant turn, and some carry empty/truncated
+            // `arguments` strings. On the next multi-step request xAI rejects the
+            // replayed history with 400 `invalid-argument: expected JSON object for
+            // tool arguments` — a NON-transient error, so the bounded stream-retry
+            // re-sends the same malformed history and the turn wedges (observed live
+            // 2026-07-14, run mrkoeezk9a29: /ideal sprint impl made one tool-call
+            // response then never progressed, 0 files, across every path). Mirror the
+            // opencode-go/zai fix: split multi-tool-call assistant turns into
+            // sequential single-call turns and repair empty/truncated tool arguments
+            // to `{}` before they reach the upstream. Both helpers are no-ops unless
+            // the failing pattern is present, so healthy requests are untouched.
+            transformRequestBody: (body) => {
+                const out = { ...body };
+                if (Array.isArray(out.messages)) {
+                    out.messages = splitParallelToolCalls(out.messages);
+                    out.messages = sanitizeToolCallArguments(out.messages);
+                }
+                if ("response_format" in out) {
+                    const rf = out.response_format;
+                    if (rf == null || (typeof rf === "object" && Object.keys(rf).length === 0)) {
+                        delete out.response_format;
+                    }
+                }
+                return out;
+            },
         });
         return (modelId) => p(modelId);
     }

package/dist/src/providers/warm.d.ts

@@ -0,0 +1,65 @@
+/**
+ * src/providers/warm.ts
+ *
+ * Boot-time warm-up of the provider factory registry.
+ *
+ * Root cause it addresses (measured live, 2026-07-16, session 0c6728ba1a25):
+ * an xai session POSTed model `gpt-5.4` to api.x.ai and got 404 "The model
+ * gpt-5.4 does not exist" — an openai model sent to the xai endpoint. The
+ * factory/model guard in `runtime.ts` DID spot the mismatch and tried to
+ * redirect the request to openai's own factory, but the registry had no openai
+ * entry: a session only ever built the factory for ITS OWN provider, so any
+ * sub-task that resolved a model from another provider had nothing to redirect
+ * to and fell through to the wrong endpoint.
+ *
+ * That is the actual hole. Model ids and provider factories travel as two
+ * independent values, so "borrow the session's factory" is the silent default
+ * for every sub-task (compaction, classify, sub-agents, mode switches) and only
+ * some paths remember to re-derive the provider. Warming the registry for every
+ * credentialed provider closes it at the source: the factory for a model's own
+ * provider is then always present, so `resolveModelRuntime` can derive it from
+ * the model itself instead of trusting whatever factory a caller passed.
+ *
+ * Best-effort by construction: a provider that fails to warm is simply absent
+ * (the same state as today), never a boot failure.
+ */
+import { type ProviderId } from "./types.js";
+/** Outcome of {@link warmProviderFactories}, for logging and tests. */
+export interface WarmResult {
+    /** Providers whose factory is now registered. */
+    warmed: ProviderId[];
+    /** Providers left out, with the reason (no credentials, disabled, or an error). */
+    skipped: Array<{
+        id: ProviderId;
+        reason: string;
+    }>;
+}
+/**
+ * Build and register a factory for every provider the user has credentials for.
+ *
+ * Runs providers concurrently — each is an independent credential read, and a
+ * serial loop would add every provider's latency to boot.
+ *
+ * Skips providers that already have a factory: the session builds its own with
+ * session-specific options (custom baseURL, OAuth headers), and rebuilding it
+ * from bare defaults here would silently downgrade the live session's wiring.
+ */
+/**
+ * Rebuild ONE provider's factory after its credentials changed mid-session.
+ *
+ * `createProviderFactoryAsync` reads OAuth tokens at CONSTRUCTION and bakes the
+ * resulting auth headers into the factory (runtime.ts: `loadTokensWithRefresh()`
+ * then `authHeaders(tokens)`). Boot warms openai/xai even with no tokens —
+ * `getOAuthProviderConfig` only reports that a provider SUPPORTS OAuth — so the
+ * entry built at boot is an API-key-path factory. Signing in later saved tokens
+ * that nothing re-read: the stale factory stayed registered and the provider
+ * kept failing until the next process start. That is the "OAuth only works
+ * after I restart the session" report; the same held for a key set via `K` on a
+ * provider skipped at boot for "no credentials".
+ *
+ * warmProviderFactories() cannot be reused for this: it deliberately SKIPS a
+ * provider that already has a factory. The registry is last-built-wins, so
+ * building again is what replaces the stale entry.
+ */
+export declare function rewarmProviderFactory(id: ProviderId): Promise<boolean>;
+export declare function warmProviderFactories(): Promise<WarmResult>;

package/dist/src/providers/warm.js

@@ -0,0 +1,145 @@
+/**
+ * src/providers/warm.ts
+ *
+ * Boot-time warm-up of the provider factory registry.
+ *
+ * Root cause it addresses (measured live, 2026-07-16, session 0c6728ba1a25):
+ * an xai session POSTed model `gpt-5.4` to api.x.ai and got 404 "The model
+ * gpt-5.4 does not exist" — an openai model sent to the xai endpoint. The
+ * factory/model guard in `runtime.ts` DID spot the mismatch and tried to
+ * redirect the request to openai's own factory, but the registry had no openai
+ * entry: a session only ever built the factory for ITS OWN provider, so any
+ * sub-task that resolved a model from another provider had nothing to redirect
+ * to and fell through to the wrong endpoint.
+ *
+ * That is the actual hole. Model ids and provider factories travel as two
+ * independent values, so "borrow the session's factory" is the silent default
+ * for every sub-task (compaction, classify, sub-agents, mode switches) and only
+ * some paths remember to re-derive the provider. Warming the registry for every
+ * credentialed provider closes it at the source: the factory for a model's own
+ * provider is then always present, so `resolveModelRuntime` can derive it from
+ * the model itself instead of trusting whatever factory a caller passed.
+ *
+ * Best-effort by construction: a provider that fails to warm is simply absent
+ * (the same state as today), never a boot failure.
+ */
+import { logger } from "../utils/logger.js";
+import { createProviderFactoryAsync, hasProviderFactory } from "./runtime.js";
+import { ALL_PROVIDER_IDS } from "./types.js";
+/**
+ * Build and register a factory for every provider the user has credentials for.
+ *
+ * Runs providers concurrently — each is an independent credential read, and a
+ * serial loop would add every provider's latency to boot.
+ *
+ * Skips providers that already have a factory: the session builds its own with
+ * session-specific options (custom baseURL, OAuth headers), and rebuilding it
+ * from bare defaults here would silently downgrade the live session's wiring.
+ */
+/**
+ * Rebuild ONE provider's factory after its credentials changed mid-session.
+ *
+ * `createProviderFactoryAsync` reads OAuth tokens at CONSTRUCTION and bakes the
+ * resulting auth headers into the factory (runtime.ts: `loadTokensWithRefresh()`
+ * then `authHeaders(tokens)`). Boot warms openai/xai even with no tokens —
+ * `getOAuthProviderConfig` only reports that a provider SUPPORTS OAuth — so the
+ * entry built at boot is an API-key-path factory. Signing in later saved tokens
+ * that nothing re-read: the stale factory stayed registered and the provider
+ * kept failing until the next process start. That is the "OAuth only works
+ * after I restart the session" report; the same held for a key set via `K` on a
+ * provider skipped at boot for "no credentials".
+ *
+ * warmProviderFactories() cannot be reused for this: it deliberately SKIPS a
+ * provider that already has a factory. The registry is last-built-wins, so
+ * building again is what replaces the stale entry.
+ */
+export async function rewarmProviderFactory(id) {
+    try {
+        const { loadUserSettings } = await import("../utils/settings.js");
+        const baseURL = loadUserSettings()?.providers?.[id]?.baseURL;
+        let apiKey;
+        try {
+            const { loadKeyForProvider } = await import("./keychain.js");
+            apiKey = (await loadKeyForProvider(id)) || undefined;
+        }
+        catch (err) {
+            // No stored key is the normal OAuth case, so this is not an error —
+            // but log it: a keychain fault here silently downgrades auth.
+            logger.debug("cli", `[provider-warm] key read failed for ${id}: ${err?.message}`, { error: err });
+            apiKey = undefined;
+        }
+        await createProviderFactoryAsync(id, { ...(apiKey ? { apiKey } : {}), ...(baseURL ? { baseURL } : {}) });
+        logger.info("cli", `[provider-warm] rebuilt ${id} factory after a credential change`, { providerId: id });
+        return true;
+    }
+    catch (err) {
+        logger.warn("cli", `[provider-warm] failed to rebuild factory for ${id}: ${err?.message}`, {
+            error: err,
+            providerId: id,
+        });
+        return false;
+    }
+}
+export async function warmProviderFactories() {
+    const warmed = [];
+    const skipped = [];
+    const { isProviderDisabled } = await import("../utils/settings.js");
+    const { loadUserSettings } = await import("../utils/settings.js");
+    const userSettings = loadUserSettings();
+    await Promise.all(ALL_PROVIDER_IDS.map(async (id) => {
+        try {
+            if (hasProviderFactory(id)) {
+                skipped.push({ id, reason: "already built" });
+                return;
+            }
+            if (isProviderDisabled(id)) {
+                skipped.push({ id, reason: "disabled" });
+                return;
+            }
+            let apiKey;
+            try {
+                const { loadKeyForProvider } = await import("./keychain.js");
+                apiKey = (await loadKeyForProvider(id)) || undefined;
+            }
+            catch {
+                // No stored key for this provider — normal; OAuth may still cover it.
+                apiKey = undefined;
+            }
+            let hasOAuth = false;
+            try {
+                const { getOAuthProviderConfig } = await import("./auth/registry.js");
+                hasOAuth = !!(await getOAuthProviderConfig(id));
+            }
+            catch (err) {
+                logger.debug("cli", `[provider-warm] OAuth probe failed for ${id}: ${err?.message}`, {
+                    error: err,
+                });
+            }
+            if (!apiKey && !hasOAuth) {
+                skipped.push({ id, reason: "no credentials" });
+                return;
+            }
+            // Honour a user-configured endpoint; otherwise each strategy falls back
+            // to its own provider's apiBase, which is what a non-session provider
+            // should use.
+            const baseURL = userSettings?.providers?.[id]?.baseURL;
+            await createProviderFactoryAsync(id, { ...(apiKey ? { apiKey } : {}), ...(baseURL ? { baseURL } : {}) });
+            warmed.push(id);
+        }
+        catch (err) {
+            // Never let one provider's credential problem break boot: absent from
+            // the registry is exactly the pre-warm status quo.
+            logger.warn("cli", `[provider-warm] failed to build factory for ${id}: ${err?.message}`, {
+                error: err,
+                providerId: id,
+            });
+            skipped.push({ id, reason: `error: ${err?.message ?? "unknown"}` });
+        }
+    }));
+    logger.info("cli", `[provider-warm] registry warmed: ${warmed.join(", ") || "(none)"}`, {
+        warmed,
+        skipped,
+    });
+    return { warmed, skipped };
+}
+//# sourceMappingURL=warm.js.map

package/dist/src/self-qa/agentic-loop.js

@@ -141,8 +141,9 @@ export async function createLLMBrain(opts) {
     const apiKey = await loadKeyForProvider(provider);
     if (!apiKey)
         throw new Error(`No API key found for provider '${provider}'`);
-    const { factory } = createProviderFactory(provider, { apiKey });
-    const runtime = resolveModelRuntime(factory, opts.modelId);
+    // Registers the factory so resolveModelRuntime can derive it from the model.
+    createProviderFactory(provider, { apiKey });
+    const runtime = resolveModelRuntime(opts.modelId);
     const systemPrompt = opts.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
     const maxTokens = opts.maxTokens ?? 1024;
     const retryOnEmpty = opts.retryOnEmpty !== false;

package/dist/src/storage/transcript.js

@@ -604,13 +604,19 @@ export function buildChatEntries(sessionId) {
     catch (err) {
         logger.error("storage", "Failed to load session metadata for chain in buildChatEntries", { error: err });
     }
+    // One read per session in the chain — the prompt/answer reconciliation below
+    // and the render walk both need every session's records.
+    const recordsBySession = new Map();
+    for (const sid of chain) {
+        recordsBySession.set(sid, buildEffectiveMessageRecords(sid));
+    }
     // Map each child sub-session's initial user prompt to its creation timestamp
     const childPrompts = new Map();
     for (let i = 1; i < chain.length; i++) {
         const sid = chain[i];
         const meta = sessionMeta.get(sid);
         if (meta && meta.parent_session_id) {
-            const records = buildEffectiveMessageRecords(sid);
+            const records = recordsBySession.get(sid) ?? [];
             const firstUser = records.find((r) => r.message.role === "user");
             if (firstUser) {
                 const content = renderUserContent(firstUser.message.content);
@@ -620,14 +626,38 @@ export function buildChatEntries(sessionId) {
             }
         }
     }
+    // When a sub-session finishes, the orchestrator absorbs its LAST assistant
+    // message into the PARENT (salvageSubSessionOutput + appendCompletedTurn,
+    // orchestrator.ts) so the parent keeps context continuity. That content is
+    // therefore persisted in BOTH sessions, and the chain walk below would render
+    // the final answer twice. Keep the parent's copy — it sits in the timeline
+    // where the user actually asked — and drop the child's, mirroring how the
+    // child's duplicated user prompt is handled above.
+    const absorbedByChild = new Map();
+    for (let i = 1; i < chain.length; i++) {
+        const sid = chain[i];
+        const parentId = sessionMeta.get(sid)?.parent_session_id;
+        if (!parentId)
+            continue;
+        const parentRecords = recordsBySession.get(parentId);
+        if (!parentRecords)
+            continue;
+        const text = lastAssistantText(recordsBySession.get(sid) ?? []);
+        if (text && parentRecords.some((r) => r.message.role === "assistant" && assistantText(r.message) === text)) {
+            absorbedByChild.set(sid, text);
+        }
+    }
     const callMap = new Map();
     const entries = [];
     const renderedResponseCallIds = new Set();
     let lastTimestamp;
     for (let i = 0; i < chain.length; i++) {
         const sid = chain[i];
-        const records = buildEffectiveMessageRecords(sid);
+        const records = recordsBySession.get(sid) ?? [];
         const isChildSession = i > 0;
+        // Only the single message the parent absorbed is dropped, so a child that
+        // legitimately repeats itself still renders its other turns.
+        let absorbedPending = absorbedByChild.get(sid);
         for (let j = 0; j < records.length; j++) {
             const { message, timestamp } = records[j];
             lastTimestamp = timestamp;
@@ -658,8 +688,15 @@ export function buildChatEntries(sessionId) {
                 continue;
             }
             if (message.role === "assistant") {
+                // Call first regardless: it registers this message's tool-calls in
+                // callMap, which the tool-result branch below needs even when the
+                // message itself is skipped as an absorbed duplicate.
                 const text = renderAssistantContent(message.content, callMap);
                 if (text) {
+                    if (absorbedPending !== undefined && text === absorbedPending) {
+                        absorbedPending = undefined;
+                        continue;
+                    }
                     entries.push({ type: "assistant", content: text, timestamp });
                 }
                 continue;
@@ -744,6 +781,23 @@ export function buildChatEntries(sessionId) {
     logger.debug("storage", "Built chat entries successfully", { sessionId, count: entries.length });
     return entries;
 }
+/** Rendered text of an assistant message, with no callMap side effect. */
+function assistantText(message) {
+    return renderAssistantContent(message.content, new Map());
+}
+/**
+ * Text of the session's LAST assistant message — the one the sub-session
+ * absorption path hands to the parent. Empty when that message carried only
+ * tool-calls (nothing renders, so nothing can duplicate).
+ */
+function lastAssistantText(records) {
+    for (let i = records.length - 1; i >= 0; i--) {
+        const message = records[i].message;
+        if (message.role === "assistant")
+            return assistantText(message);
+    }
+    return "";
+}
 function getNextSequence(db, sessionId) {
     const row = db
         .prepare(`

package/dist/src/tools/git-safety.d.ts

@@ -90,6 +90,25 @@ export interface StagingBlockResult {
  *   2. Setting MUONROI_ALLOW_BROAD_STAGE=1 (escape hatch, logged to decision-log).
  */
 export declare function checkSensitiveStaging(cwd: string): StagingBlockResult;
+export type DestructiveKind = "checkout-discard" | "restore" | "reset-hard" | "clean" | "stash-drop" | "rm-tracked";
+export interface DestructiveShape {
+    kind: DestructiveKind | null;
+    /** true when the risk is untracked files (clean) rather than tracked mods. */
+    untrackedRisk: boolean;
+}
+export declare function analyzeDestructiveGit(command: string): DestructiveShape;
+export interface DestructiveBlockResult {
+    blocked: boolean;
+    kind: DestructiveKind | null;
+    message: string;
+}
+/**
+ * Pre-execution guard: block a working-tree-destroying command when it would
+ * actually discard uncommitted work. Returns blocked=false (no message) when
+ * the command is non-destructive, when nothing is at risk, or when the user set
+ * the escape hatch. Deterministic + cheap (a couple of git plumbing calls).
+ */
+export declare function checkDestructiveOp(command: string, cwd: string): DestructiveBlockResult;
 /**
  * @deprecated Use checkSensitiveStaging() for hard-blocking.
  * Kept for call sites that emit a trailing warning (non-broad-stage contexts).