muonroi-cli 1.6.2 → 1.6.4

package/dist/src/generated/version.d.ts

@@ -1,2 +1,2 @@
-export declare const PACKAGE_VERSION = "1.6.2";
+export declare const PACKAGE_VERSION = "1.6.4";
 export declare const PACKAGE_DESCRIPTION = "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.";

package/dist/src/generated/version.js

@@ -1,5 +1,5 @@
 // AUTO-GENERATED by scripts/sync-version.cjs. DO NOT EDIT BY HAND.
 // Sourced from package.json at build time so it survives bun --compile bundling.
-export const PACKAGE_VERSION = "1.6.2";
+export const PACKAGE_VERSION = "1.6.4";
 export const PACKAGE_DESCRIPTION = "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.";
 //# sourceMappingURL=version.js.map

package/dist/src/mcp/__tests__/client-pool.spec.js

@@ -109,6 +109,27 @@ describe("acquireMcpTools — cross-turn client pool", () => {
         expect(results.every((r) => r === "pong")).toBe(true);
         expect(connectOneServer).toHaveBeenCalledTimes(2); // 14 failures → exactly ONE shared reconnect
     });
+    it("waits for a criticalServerId past the normal deadline so it lands THIS turn (session 584ba476c07a)", async () => {
+        // Normal deadline is 500ms (mock). docs connects at ~700ms — past the normal
+        // deadline but within the critical window → must be included when critical.
+        connectOneServer.mockImplementation((s) => new Promise((res) => {
+            if (s.id === "docs")
+                setTimeout(() => res(connected(s.id)), 700);
+            else
+                res(connected(s.id));
+        }));
+        const b = await acquireMcpTools([srv("docs")], { criticalServerIds: ["docs"], criticalDeadlineMs: 3000 });
+        expect(Object.keys(b.tools)).toContain("mcp_docs__ping");
+        expect(b.errors).toHaveLength(0);
+    });
+    it("without criticalServerIds, a slow server is reported still-connecting (available next turn)", async () => {
+        connectOneServer.mockImplementation((s) => new Promise((res) => {
+            setTimeout(() => res(connected(s.id)), 700);
+        }));
+        const b = await acquireMcpTools([srv("docs")]);
+        expect(Object.keys(b.tools)).not.toContain("mcp_docs__ping");
+        expect(b.errors.some((e) => /still connecting/.test(e))).toBe(true);
+    });
     it("keys by cwd/config — a different command reconnects rather than reusing", async () => {
         connectOneServer.mockImplementation(async (s) => connected(s.id));
         await acquireMcpTools([

package/dist/src/mcp/client-pool.js

@@ -179,6 +179,28 @@ export async function acquireMcpTools(servers, opts) {
     await Promise.race([Promise.allSettled(attempts), deadline]);
     if (deadlineTimer)
         clearTimeout(deadlineTimer);
+    // Critical-server extended wait: a turn that MUST have a specific server (e.g.
+    // muonroi-docs on an ecosystem question) waits for just that server's connect
+    // beyond the normal deadline, so a cold first-connect is included THIS turn
+    // rather than reported "still connecting → next turn". Only the named servers
+    // are awaited; everything already settled is untouched (no added latency for
+    // normal turns, which pass no criticalServerIds).
+    const critical = new Set((opts?.criticalServerIds ?? []).filter(Boolean));
+    if (critical.size > 0) {
+        const pendingIdx = enabled.map((s, i) => ({ s, i })).filter(({ s, i }) => critical.has(s.id) && !slots[i].done);
+        if (pendingIdx.length > 0) {
+            const criticalDeadlineMs = Math.max(deadlineMs, opts?.criticalDeadlineMs ?? 8000);
+            const extraMs = Math.max(0, criticalDeadlineMs - deadlineMs);
+            let extraTimer;
+            const extraDeadline = new Promise((resolve) => {
+                extraTimer = setTimeout(resolve, extraMs);
+                extraTimer.unref?.();
+            });
+            await Promise.race([Promise.allSettled(pendingIdx.map(({ i }) => attempts[i])), extraDeadline]);
+            if (extraTimer)
+                clearTimeout(extraTimer);
+        }
+    }
     for (let i = 0; i < slots.length; i++) {
         const slot = slots[i];
         if (slot.done) {

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

@@ -8,6 +8,17 @@ export interface McpToolBundle {
 }
 export interface McpBuildOptions {
     onOAuthRequired?: (serverId: string, url: URL) => void;
+    /**
+     * Server ids the CURRENT turn critically needs (e.g. muonroi-docs on an
+     * ecosystem question). acquireMcpTools waits for these specifically beyond the
+     * normal build deadline — up to `criticalDeadlineMs` — so a cold first-connect
+     * is included THIS turn instead of "ready next turn" (session 584ba476c07a:
+     * first ecosystem question missed muonroi-docs while it was still warming).
+     * Other servers are unaffected — only the named ones get the extended wait.
+     */
+    criticalServerIds?: string[];
+    /** Extended ceiling (ms) for criticalServerIds. Default 8000. */
+    criticalDeadlineMs?: number;
 }
 /**
  * Total wall-clock budget for building the MCP tool set. Servers connect in

package/dist/src/orchestrator/message-processor.js

@@ -60,6 +60,7 @@ import * as phaseTracker from "../ee/phase-tracker.js";
 import { buildScope as buildScopeForVeto } from "../ee/scope.js";
 import { fireTrajectoryEvent } from "../ee/session-trajectory.js";
 import { getTenantId as getTenantIdForVeto } from "../ee/tenant.js";
+import { mentionsEcosystemScope } from "../gsd/directives.js";
 import { acquireMcpTools } from "../mcp/client-pool.js";
 import { dropRedundantFsMcpTools, filterMcpServersByMessage } from "../mcp/smart-filter.js";
 import { getModelInfo } from "../models/registry.js";
@@ -88,7 +89,7 @@ import { statusBarStore } from "../ui/status-bar/store.js";
 import { appendDecisionLog } from "../usage/decision-log.js";
 import { openUrl } from "../utils/open-url.js";
 import { appendAudit, toolNeedsApproval } from "../utils/permission-mode.js";
-import { getAutoCouncilConfidence, getAutoCouncilMinRoles, getProviderStallTimeoutMs, getRoleModels, getTopLevelCompactKeepLast, getTopLevelCompactThresholdChars, getTopLevelToolBudgetChars, isAutoCouncilEnabled, isProviderDisabled, loadMcpServers, loadValidSubAgents, } from "../utils/settings.js";
+import { getAutoCouncilConfidence, getAutoCouncilMinRoles, getProviderStallRetries, getProviderStallTimeoutMs, getRoleModels, getTopLevelCompactKeepLast, getTopLevelCompactThresholdChars, getTopLevelToolBudgetChars, isAutoCouncilEnabled, isProviderDisabled, loadMcpServers, loadValidSubAgents, } from "../utils/settings.js";
 import { resolveShell } from "../utils/shell.js";
 import { relaxCompactionSettings } from "./compaction.js";
 import { wrapToolSetWithDedup } from "./cross-turn-dedup.js";
@@ -107,7 +108,7 @@ import { forcedFinalize, getSessionLastTask, incSessionStep, parseBudgetOverride
 import { attachReminderToMessages, buildCheckpointReminder, buildScopeReminder, cadenceForSize, shouldInjectCeilingCrossing, shouldInjectReminder, shouldInjectSoftWarn, shouldPreWarnCompaction, } from "./scope-reminder.js";
 import { formatElisionManifest, getSessionExperienceCounts, recordCompaction, recordElision, } from "./session-experience.js";
 import { attemptStallRescue, pushStallToolResult } from "./stall-rescue.js";
-import { createStallWatchdog, STALL_ERROR_MESSAGE } from "./stall-watchdog.js";
+import { createStallWatchdog, STALL_ERROR_MESSAGE, shouldRepromptStall, stallRepromptBackoffMs, } from "./stall-watchdog.js";
 import { wrapToolSetWithCap } from "./sub-agent-cap.js";
 import { compactSubAgentMessages, cumulativeMessageChars } from "./subagent-compactor.js";
 import { detectTextEmittedToolCall, parseDsmlToolCalls } from "./text-tool-call-detector.js";
@@ -812,6 +813,16 @@ export class MessageProcessor {
         // clear toast and SKIP the transient-retry (a stalled provider just stalls
         // again, wasting another full timeout of silence).
         let stallTriggered = false;
+        // Time-to-first-byte stall RE-PROMPT: some providers (observed:
+        // xai/grok-build-0.1) accept the request then never send the first byte —
+        // a single wedged socket, not a down backend, so a fresh request usually
+        // goes through. When the watchdog fires with ZERO chunks received this
+        // attempt, we re-issue the SAME request up to `maxStallRetries` times
+        // (loop-persistent counter). Gated on zero-chunks so it can NEVER restart a
+        // turn that already ran tools or emitted text — those go to the partial-
+        // answer rescue path instead. maxStallRetries = 0 restores legacy behaviour.
+        let stallRetryCount = 0;
+        const maxStallRetries = getProviderStallRetries();
         // Auto-council: route to multi-model debate when EITHER
         //   (a) PIL classified taskType=plan|analyze with high confidence AND the
         //       prompt is complex enough to justify the debate cost, OR
@@ -927,7 +938,7 @@ export class MessageProcessor {
             return;
         }
         try {
-            while (true) {
+            streamAttempt: while (true) {
                 // SAMR Phase 2: switch to fast model for tool-execution steps
                 if (stepRouterPhase === "phase2" && phase2Runtime) {
                     runtime = phase2Runtime;
@@ -935,6 +946,65 @@ export class MessageProcessor {
                 }
                 deps.setCompactedThisTurn(false);
                 let assistantText = "";
+                // Count of stream parts received in THIS attempt. Stays 0 only when the
+                // provider never sent a first byte → the safe-to-re-prompt stall case.
+                let chunksThisAttempt = 0;
+                // Decide whether a fired stall watchdog should re-prompt (re-issue the
+                // same request) instead of falling through to rescue/error. Returns the
+                // backoff ms to wait before re-issuing, or null to NOT re-prompt. Reads
+                // the live per-attempt locals; safe to call only when stallTriggered.
+                const planStallReprompt = () => {
+                    if (!shouldRepromptStall({
+                        stallTriggered,
+                        stallRetryCount,
+                        maxStallRetries,
+                        chunksThisAttempt,
+                        assistantTextEmpty: assistantText.trim() === "",
+                        aborted: signal.aborted,
+                    })) {
+                        return null;
+                    }
+                    stallRetryCount++;
+                    const backoffMs = stallRepromptBackoffMs(stallRetryCount);
+                    try {
+                        const _ar = globalThis.__muonroiAgentRuntime;
+                        _ar?.emitEvent({
+                            t: "event",
+                            kind: "stream-retry",
+                            attempt: stallRetryCount,
+                            maxAttempts: maxStallRetries + 1,
+                            errorName: "TimeoutError",
+                            errorMessage: "provider-stall (no first byte) — re-prompting",
+                            nextDelayMs: backoffMs,
+                        });
+                        _ar?.emitEvent({
+                            t: "event",
+                            kind: "toast",
+                            level: "warning",
+                            text: `Model stalled — re-prompting (attempt ${stallRetryCount}/${maxStallRetries})…`,
+                        });
+                    }
+                    catch (emitErr) {
+                        console.error(`[message-processor] stall-reprompt telemetry failed: ${emitErr?.message}`);
+                    }
+                    try {
+                        if (deps.session) {
+                            logInteraction(deps.session.id, "stream_retry", {
+                                data: {
+                                    attempt: stallRetryCount,
+                                    maxAttempts: maxStallRetries + 1,
+                                    errorName: "provider-stall",
+                                    errorMessage: "no first byte within stall timeout — re-prompted",
+                                    nextDelayMs: backoffMs,
+                                },
+                            });
+                        }
+                    }
+                    catch (logErr) {
+                        console.error(`[message-processor] stall-reprompt log failed: ${logErr?.message}`);
+                    }
+                    return backoffMs;
+                };
                 // Tracks where `assistantText` was at the previous step boundary so
                 // `onStepFinish` can compute the text emitted within the just-finished
                 // step (input to the self-repetition detector).
@@ -1022,6 +1092,16 @@ export class MessageProcessor {
                         const filteredServers = filterMcpServersByMessage(loadMcpServers(), userMessage, {
                             disabled: process.env.MUONROI_DISABLE_SMART_MCP === "1",
                         });
+                        // Ecosystem question → muonroi-docs is the authoritative source the
+                        // agent is nudged to consult FIRST. Wait for it specifically beyond the
+                        // normal deadline so a cold first-connect lands THIS turn instead of
+                        // "ready next turn" (session 584ba476c07a: first ecosystem question
+                        // missed docs while warming → agent guessed from local files).
+                        const criticalServerIds = mentionsEcosystemScope(userMessage)
+                            ? filteredServers
+                                .filter((s) => /(^|[-_])docs([-_]|$)/.test(s.id) && /muonroi/i.test(s.id))
+                                .map((s) => s.id)
+                            : undefined;
                         // MCP non-blocking: acquireMcpTools self-bounds — it connects servers
                         // in parallel and returns PARTIAL results at its internal deadline
                         // (fast/cached servers included; slow first-connects reported in
@@ -1038,6 +1118,7 @@ export class MessageProcessor {
                                     // command-injection vector the old exec() opener had.
                                     openUrl(url);
                                 },
+                                ...(criticalServerIds && criticalServerIds.length > 0 ? { criticalServerIds } : {}),
                             });
                         }
                         catch (err) {
@@ -1718,6 +1799,11 @@ export class MessageProcessor {
                     const _wireProviderIdTop = runtime.modelInfo?.provider ?? "unknown";
                     for await (const part of result.fullStream) {
                         stall.pet(); // chunk arrived — reset the stall watchdog
+                        // Count only real content parts. The watchdog abort itself surfaces
+                        // as an "abort" part — counting it would defeat the TTFB-stall gate
+                        // (a frozen-before-first-byte stall yields ONLY the abort part).
+                        if (part.type !== "abort")
+                            chunksThisAttempt++;
                         if (signal.aborted) {
                             yield { type: "content", content: "\n\n[Cancelled]" };
                             break;
@@ -2271,6 +2357,19 @@ export class MessageProcessor {
                                 // instead of a benign "[Cancelled]" so a hung provider no longer
                                 // looks like a silent freeze.
                                 if (stallTriggered) {
+                                    // Time-to-first-byte stall (no real chunk this attempt): the
+                                    // socket wedged before any output — re-issue the SAME request
+                                    // rather than giving up. Bounded by maxStallRetries; never
+                                    // fires once tools ran or text flowed (planStallReprompt gate).
+                                    const _stallBackoff = planStallReprompt();
+                                    if (_stallBackoff != null) {
+                                        stall.dispose();
+                                        await new Promise((r) => setTimeout(r, _stallBackoff));
+                                        if (!signal.aborted) {
+                                            stallTriggered = false;
+                                            continue streamAttempt;
+                                        }
+                                    }
                                     stall.dispose();
                                     // A response tool already produced the terminal structured
                                     // answer (buffered from its call args) before the provider
@@ -2901,6 +3000,20 @@ export class MessageProcessor {
                         attemptedOverflowRecovery = true;
                         continue;
                     }
+                    // Stall surfaced as a throw (rather than an "abort" stream part):
+                    // apply the SAME time-to-first-byte re-prompt as the abort-part path.
+                    // The watchdog already fired (stallTriggered) so its timer is spent —
+                    // no dispose needed; the next attempt arms a fresh watchdog.
+                    if (stallTriggered) {
+                        const _stallBackoff = planStallReprompt();
+                        if (_stallBackoff != null) {
+                            await new Promise((r) => setTimeout(r, _stallBackoff));
+                            if (!signal.aborted) {
+                                stallTriggered = false;
+                                continue;
+                            }
+                        }
+                    }
                     // Transient network/server error retry — up to MAX_STREAM_RETRIES extra attempts.
                     // Only retry when no content has flowed yet (assistantText empty) to avoid
                     // partial-output corruption. Honour the abort signal between retries.

package/dist/src/orchestrator/stall-watchdog.d.ts

@@ -31,4 +31,35 @@ export interface StallWatchdog {
 export declare const STALL_ABORT_REASON = "provider-stall";
 /** User-facing message surfaced when the stall watchdog fires. */
 export declare const STALL_ERROR_MESSAGE: string;
+/** Inputs to the stall re-prompt decision — see {@link shouldRepromptStall}. */
+export interface StallRepromptState {
+    /** The watchdog fired for this attempt. */
+    stallTriggered: boolean;
+    /** How many stall re-prompts have already happened this turn. */
+    stallRetryCount: number;
+    /** Configured cap (getProviderStallRetries); 0 disables re-prompt. */
+    maxStallRetries: number;
+    /** Real content parts received this attempt (the abort part is NOT counted). */
+    chunksThisAttempt: number;
+    /** True when no assistant text has flowed this attempt. */
+    assistantTextEmpty: boolean;
+    /** True on genuine user cancel (never re-prompt over a cancel). */
+    aborted: boolean;
+}
+/**
+ * Decide whether a fired stall watchdog should trigger a re-prompt (re-issue
+ * the same request) instead of surfacing the stall.
+ *
+ * ONLY a time-to-first-byte stall qualifies: zero real chunks AND no assistant
+ * text this attempt, under the retry cap, and not a user cancel. Re-issuing
+ * after tools ran or text flowed would corrupt/duplicate output — those cases
+ * fall through to the partial-answer rescue path instead. Pure (no side
+ * effects) so it is unit-testable in isolation from the orchestrator loop.
+ */
+export declare function shouldRepromptStall(s: StallRepromptState): boolean;
+/**
+ * Exponential backoff (ms, capped at 4s) before the Nth stall re-prompt
+ * (1-based): 500 → 1000 → 2000 → 4000 → 4000.
+ */
+export declare function stallRepromptBackoffMs(attempt: number): number;
 export declare function createStallWatchdog(timeoutMs: number, onFire?: () => void): StallWatchdog;

package/dist/src/orchestrator/stall-watchdog.js

@@ -23,6 +23,30 @@ export const STALL_ABORT_REASON = "provider-stall";
 export const STALL_ERROR_MESSAGE = "Model not responding — no output received within the stall timeout. " +
     "The provider may be out of balance, rate-limited, or unreachable. " +
     "Tune MUONROI_PROVIDER_STALL_TIMEOUT_MS (0 disables) or switch model/provider.";
+/**
+ * Decide whether a fired stall watchdog should trigger a re-prompt (re-issue
+ * the same request) instead of surfacing the stall.
+ *
+ * ONLY a time-to-first-byte stall qualifies: zero real chunks AND no assistant
+ * text this attempt, under the retry cap, and not a user cancel. Re-issuing
+ * after tools ran or text flowed would corrupt/duplicate output — those cases
+ * fall through to the partial-answer rescue path instead. Pure (no side
+ * effects) so it is unit-testable in isolation from the orchestrator loop.
+ */
+export function shouldRepromptStall(s) {
+    return (s.stallTriggered &&
+        s.stallRetryCount < s.maxStallRetries &&
+        s.chunksThisAttempt === 0 &&
+        s.assistantTextEmpty &&
+        !s.aborted);
+}
+/**
+ * Exponential backoff (ms, capped at 4s) before the Nth stall re-prompt
+ * (1-based): 500 → 1000 → 2000 → 4000 → 4000.
+ */
+export function stallRepromptBackoffMs(attempt) {
+    return Math.min(500 * 2 ** (Math.max(1, attempt) - 1), 4_000);
+}
 export function createStallWatchdog(timeoutMs, onFire) {
     const controller = new AbortController();
     let firedFlag = false;

package/dist/src/orchestrator/stall-watchdog.test.js

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { createStallWatchdog, STALL_ABORT_REASON } from "./stall-watchdog.js";
+import { createStallWatchdog, STALL_ABORT_REASON, shouldRepromptStall, stallRepromptBackoffMs, } from "./stall-watchdog.js";
 describe("createStallWatchdog", () => {
     beforeEach(() => vi.useFakeTimers());
     afterEach(() => vi.useRealTimers());
@@ -70,4 +70,49 @@ describe("createStallWatchdog", () => {
         expect(wd.signal.aborted).toBe(true);
     });
 });
+describe("shouldRepromptStall", () => {
+    // A clean time-to-first-byte stall: watchdog fired, zero chunks, no text,
+    // under the cap, not cancelled — the ONLY case that re-prompts.
+    const ttfb = (over = {}) => ({
+        stallTriggered: true,
+        stallRetryCount: 0,
+        maxStallRetries: 1,
+        chunksThisAttempt: 0,
+        assistantTextEmpty: true,
+        aborted: false,
+        ...over,
+    });
+    it("re-prompts a time-to-first-byte stall under the cap", () => {
+        expect(shouldRepromptStall(ttfb())).toBe(true);
+    });
+    it("does NOT re-prompt when the watchdog never fired", () => {
+        expect(shouldRepromptStall(ttfb({ stallTriggered: false }))).toBe(false);
+    });
+    it("does NOT re-prompt once the retry cap is reached", () => {
+        expect(shouldRepromptStall(ttfb({ stallRetryCount: 1, maxStallRetries: 1 }))).toBe(false);
+        // maxStallRetries=0 means the feature is disabled — never re-prompt.
+        expect(shouldRepromptStall(ttfb({ stallRetryCount: 0, maxStallRetries: 0 }))).toBe(false);
+    });
+    it("does NOT re-prompt once a real chunk has arrived (mid-stream stall → rescue)", () => {
+        expect(shouldRepromptStall(ttfb({ chunksThisAttempt: 1 }))).toBe(false);
+    });
+    it("does NOT re-prompt once assistant text has flowed (output would corrupt)", () => {
+        expect(shouldRepromptStall(ttfb({ assistantTextEmpty: false }))).toBe(false);
+    });
+    it("does NOT re-prompt over a genuine user cancel", () => {
+        expect(shouldRepromptStall(ttfb({ aborted: true }))).toBe(false);
+    });
+});
+describe("stallRepromptBackoffMs", () => {
+    it("grows exponentially and caps at 4s", () => {
+        expect(stallRepromptBackoffMs(1)).toBe(500);
+        expect(stallRepromptBackoffMs(2)).toBe(1000);
+        expect(stallRepromptBackoffMs(3)).toBe(2000);
+        expect(stallRepromptBackoffMs(4)).toBe(4000);
+        expect(stallRepromptBackoffMs(5)).toBe(4000);
+    });
+    it("treats attempt < 1 as the first attempt", () => {
+        expect(stallRepromptBackoffMs(0)).toBe(500);
+    });
+});
 //# sourceMappingURL=stall-watchdog.test.js.map

package/dist/src/pil/__tests__/layer4-gsd.test.js

@@ -104,6 +104,16 @@ describe("layer4Gsd (gsd-native)", () => {
         const result = await layer4Gsd(makeCtx({ raw, enriched: raw, taskType: "analyze", intentKind: "task", deliverableKind: "answer" }));
         expect(result.enriched).toContain("QUESTION / explanatory");
     });
+    it("deliverableKind='report' is informational (no council/discuss scaffold) — session 666630479c1a", async () => {
+        // "Đọc và tóm tắt kiến trúc…" classifies as deliverableKind 'report'. A
+        // report is human-facing with NO code change, so it must route to the
+        // QUESTION directive, not the heavy implement/discuss/council scaffold that
+        // over-asked with askcards on a read/summarize task.
+        const raw = "đọc và tóm tắt kiến trúc src/orchestrator, src/pil, src/mcp kèm file:line";
+        const result = await layer4Gsd(makeCtx({ raw, enriched: raw, taskType: "analyze", intentKind: "task", deliverableKind: "report" }));
+        expect(result.enriched).toContain("QUESTION / explanatory");
+        expect(result.enriched).not.toContain("MANDATORY");
+    });
     it("Phase 2b: deliverableKind='code' is NOT informational even for a question-shaped prompt", async () => {
         // The raw text reads as a question — the legacy regex would mark it
         // informational. The model's deliverableKind='code' must override that so

package/dist/src/pil/layer4-gsd.js

@@ -84,15 +84,20 @@ export async function layer4Gsd(ctx) {
     // into the human-facing reply as a "2-3 line plan" + process narration
     // (session 829a83888dd2). Route them to the human-facing question directive.
     //
-    // Phase 2b: when the model classified the deliverable, CONSUME it — an
-    // "answer" deliverable IS informational. Only when the model didn't emit one
-    // (deliverableKind null → legacy cascade, or the model omitted the word) do
-    // we fall back to the legacy regex predicates:
+    // Phase 2b: when the model classified the deliverable, CONSUME it. Both an
+    // "answer" AND a "report" deliverable are HUMAN-FACING with no code change, so
+    // both are informational — only "code" routes through the implement/verify (and
+    // heavy discuss/council) scaffold. Treating "report" as non-informational sent
+    // read/summarize/architecture tasks (deliverableKind "report") down the heavy
+    // council + AskUserQuestion path, over-asking on a task that just wanted a
+    // written summary (session 666630479c1a: "Đọc và tóm tắt kiến trúc…" raised 2
+    // askcards + a council loop). Only when the model emitted no deliverable
+    // (deliverableKind null → legacy cascade) do we fall back to regex predicates:
     //   1. isMetaAnalysisPrompt — self/CLI evaluation, prior-turn reflection.
     //   2. taskType "general" classified as a real task by L1.
     //   3. question-shaped prompt that is NOT an implementation request.
     const informational = ctx.deliverableKind
-        ? ctx.deliverableKind === "answer"
+        ? ctx.deliverableKind !== "code"
         : isMetaAnalysisPrompt(ctx.raw) ||
             (ctx.taskType === "general" && ctx.intentKind === "task") ||
             (isQuestionLike(ctx.raw) && !isImplementationIntent(ctx.raw));

package/dist/src/ui/app.js

@@ -2525,7 +2525,7 @@ export function App({ agent, startupConfig, initialMessage, onExit }) {
                         applyLocalAssistantDelta(`\n⚠ [Experience] ${eeChunk.experienceWarning?.message ?? eeChunk.content ?? ""}\nWhy: ${eeChunk.experienceWarning?.why ?? ""}\n`);
                     }
                     else if (eeChunk.type === "experience_injected") {
-                        applyLocalAssistantDelta(`\n💡 [Experience Injected] ${eeChunk.experienceInjected?.pointCount ?? 0} point(s) loaded (score ≥ ${eeChunk.experienceInjected?.scoreFloor ?? 0})\n`);
+                        applyLocalAssistantDelta(formatExperienceInjectedBlock(eeChunk.experienceInjected ?? {}));
                     }
                 });
                 for await (const chunk of agent.processMessage(text.trim(), undefined, images)) {
@@ -3472,10 +3472,7 @@ export function App({ agent, startupConfig, initialMessage, onExit }) {
                                             },
                                         ];
                                     }
-                                    return [
-                                        ...prev,
-                                        buildAssistantEntry(`💡 [Experience Injected] ${chunk.experienceInjected.pointCount} point(s)`),
-                                    ];
+                                    return [...prev, buildAssistantEntry(formatExperienceInjectedBlock(chunk.experienceInjected))];
                                 });
                             }
                             if (chunk.type === "halt" && chunk.haltChunk) {
@@ -3694,10 +3691,7 @@ export function App({ agent, startupConfig, initialMessage, onExit }) {
                                             },
                                         ];
                                     }
-                                    return [
-                                        ...prev,
-                                        buildAssistantEntry(`💡 [Experience Injected] ${chunk.experienceInjected.pointCount} point(s)`),
-                                    ];
+                                    return [...prev, buildAssistantEntry(formatExperienceInjectedBlock(chunk.experienceInjected))];
                                 });
                             }
                             if (chunk.type === "done")

package/dist/src/utils/settings.d.ts

@@ -317,6 +317,19 @@ export declare function getSubAgentBudgetChars(): number;
  * Default 120_000 (2 min). Env override: MUONROI_PROVIDER_STALL_TIMEOUT_MS.
  */
 export declare function getProviderStallTimeoutMs(): number;
+/**
+ * Number of times to AUTOMATICALLY re-issue a streaming model call after the
+ * stall watchdog fires WITHOUT any chunk having arrived (a time-to-first-byte
+ * "frozen" stall). Some providers (observed: xai/grok-build-0.1) accept a
+ * request then never send the first byte, yet a fresh request goes through —
+ * a single dead socket, not a down backend. Re-prompting is gated on
+ * zero-chunks-this-attempt so it can NEVER restart a turn that already ran
+ * tools or emitted text (that would corrupt/duplicate output — the partial-
+ * answer rescue path handles those). Each re-prompt waits a short backoff.
+ * Range 0–5; 0 restores the legacy "surface the stall, never retry" behaviour.
+ * Default 1. Env override: MUONROI_PROVIDER_STALL_RETRIES.
+ */
+export declare function getProviderStallRetries(): number;
 /**
  * Phase B3 — threshold (in chars of cumulative message content) above which
  * the sub-agent `prepareStep` compactor rewrites older tool_result parts

package/dist/src/utils/settings.js

@@ -693,6 +693,27 @@ export function getProviderStallTimeoutMs() {
     }
     return 120_000;
 }
+/**
+ * Number of times to AUTOMATICALLY re-issue a streaming model call after the
+ * stall watchdog fires WITHOUT any chunk having arrived (a time-to-first-byte
+ * "frozen" stall). Some providers (observed: xai/grok-build-0.1) accept a
+ * request then never send the first byte, yet a fresh request goes through —
+ * a single dead socket, not a down backend. Re-prompting is gated on
+ * zero-chunks-this-attempt so it can NEVER restart a turn that already ran
+ * tools or emitted text (that would corrupt/duplicate output — the partial-
+ * answer rescue path handles those). Each re-prompt waits a short backoff.
+ * Range 0–5; 0 restores the legacy "surface the stall, never retry" behaviour.
+ * Default 1. Env override: MUONROI_PROVIDER_STALL_RETRIES.
+ */
+export function getProviderStallRetries() {
+    const envRaw = process.env.MUONROI_PROVIDER_STALL_RETRIES;
+    if (envRaw !== undefined && envRaw !== "") {
+        const n = Number(envRaw);
+        if (Number.isFinite(n) && n >= 0 && n <= 5)
+            return Math.floor(n);
+    }
+    return 1;
+}
 /**
  * Phase B3 — threshold (in chars of cumulative message content) above which
  * the sub-agent `prepareStep` compactor rewrites older tool_result parts

package/dist/src/utils/settings.test.js

@@ -157,4 +157,35 @@ describe("resolveTelegramAudioInputSettings", () => {
         expect(result.language).toBe("vi");
     });
 });
+describe("getProviderStallRetries", () => {
+    it("defaults to 1 when the env var is unset or blank", async () => {
+        vi.unstubAllEnvs();
+        const { getProviderStallRetries } = await import("./settings.js");
+        expect(getProviderStallRetries()).toBe(1);
+        vi.stubEnv("MUONROI_PROVIDER_STALL_RETRIES", "");
+        expect(getProviderStallRetries()).toBe(1);
+    });
+    it("honours an in-range override (0 disables, up to 5)", async () => {
+        const { getProviderStallRetries } = await import("./settings.js");
+        vi.stubEnv("MUONROI_PROVIDER_STALL_RETRIES", "0");
+        expect(getProviderStallRetries()).toBe(0);
+        vi.stubEnv("MUONROI_PROVIDER_STALL_RETRIES", "3");
+        expect(getProviderStallRetries()).toBe(3);
+        vi.stubEnv("MUONROI_PROVIDER_STALL_RETRIES", "5");
+        expect(getProviderStallRetries()).toBe(5);
+    });
+    it("falls back to the default for out-of-range or non-numeric values", async () => {
+        const { getProviderStallRetries } = await import("./settings.js");
+        for (const bad of ["6", "-1", "abc", "2.5"]) {
+            vi.stubEnv("MUONROI_PROVIDER_STALL_RETRIES", bad);
+            // "2.5" floors to 2 (in range) — only the others fall back.
+            if (bad === "2.5") {
+                expect(getProviderStallRetries()).toBe(2);
+            }
+            else {
+                expect(getProviderStallRetries()).toBe(1);
+            }
+        }
+    });
+});
 //# sourceMappingURL=settings.test.js.map

package/package.json

@@ -3,7 +3,7 @@
   "workspaces": [
     "packages/*"
   ],
-  "version": "1.6.2",
+  "version": "1.6.4",
   "description": "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.",
   "repository": {
     "type": "git",