muonroi-cli 1.6.3 → 1.6.5

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/orchestrator/steer-inbox.d.ts

@@ -0,0 +1,32 @@
+/**
+ * src/orchestrator/steer-inbox.ts
+ *
+ * Live-queue steering — pure decision helper.
+ *
+ * When the user types a message while a turn is streaming, the UI queue is
+ * drained at the next prepareStep boundary and the messages are injected into
+ * the running turn as `user` interjections (Claude-Code-style steering). This
+ * module holds the PURE mapping/gating decision so it is unit-testable in
+ * isolation from the orchestrator loop. The orchestrator owns the side effects
+ * (draining the queue, the pendingSteers accumulator, emitting telemetry).
+ */
+import type { ModelMessage } from "ai";
+/** Inputs to the steer-injection decision — see {@link planSteerInjection}. */
+export interface SteerInjectionState {
+    /** Raw messages drained from the UI steer queue this step. */
+    drained: {
+        text: string;
+    }[];
+    /** True on a genuine user cancel — never steer an aborted turn. */
+    aborted: boolean;
+    /** Feature flag (getSteerInjectionEnabled). */
+    enabled: boolean;
+}
+/**
+ * Decide which (if any) drained messages to inject into the running turn.
+ *
+ * Returns user-role ModelMessages in FIFO order, trimmed, with empty/whitespace
+ * entries dropped. Returns `[]` when the feature is disabled or the turn was
+ * cancelled. Pure (no side effects).
+ */
+export declare function planSteerInjection(s: SteerInjectionState): ModelMessage[];

package/dist/src/orchestrator/steer-inbox.js

@@ -0,0 +1,20 @@
+/**
+ * Decide which (if any) drained messages to inject into the running turn.
+ *
+ * Returns user-role ModelMessages in FIFO order, trimmed, with empty/whitespace
+ * entries dropped. Returns `[]` when the feature is disabled or the turn was
+ * cancelled. Pure (no side effects).
+ */
+export function planSteerInjection(s) {
+    if (!s.enabled || s.aborted)
+        return [];
+    const out = [];
+    for (const m of s.drained) {
+        const text = m.text?.trim();
+        if (!text)
+            continue;
+        out.push({ role: "user", content: text });
+    }
+    return out;
+}
+//# sourceMappingURL=steer-inbox.js.map

package/dist/src/orchestrator/steer-inbox.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/orchestrator/steer-inbox.test.js

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { planSteerInjection } from "./steer-inbox.js";
+describe("planSteerInjection", () => {
+    // A valid baseline: feature enabled, not cancelled, one queued message.
+    const base = (over = {}) => ({
+        drained: [{ text: "also add tests" }],
+        aborted: false,
+        enabled: true,
+        ...over,
+    });
+    it("maps drained text into a single user ModelMessage", () => {
+        const out = planSteerInjection(base());
+        expect(out).toEqual([{ role: "user", content: "also add tests" }]);
+    });
+    it("preserves FIFO order across multiple drained messages", () => {
+        const out = planSteerInjection(base({ drained: [{ text: "a" }, { text: "b" }] }));
+        expect(out.map((m) => m.content)).toEqual(["a", "b"]);
+    });
+    it("returns [] when the feature is disabled", () => {
+        expect(planSteerInjection(base({ enabled: false }))).toEqual([]);
+    });
+    it("returns [] over a genuine user cancel (never steer an aborted turn)", () => {
+        expect(planSteerInjection(base({ aborted: true }))).toEqual([]);
+    });
+    it("returns [] when nothing was drained", () => {
+        expect(planSteerInjection(base({ drained: [] }))).toEqual([]);
+    });
+    it("skips empty / whitespace-only messages and trims the rest", () => {
+        const out = planSteerInjection(base({ drained: [{ text: "  " }, { text: "  keep me  " }, { text: "" }] }));
+        expect(out).toEqual([{ role: "user", content: "keep me" }]);
+    });
+});
+//# sourceMappingURL=steer-inbox.test.js.map

package/dist/src/orchestrator/tool-loop-askcard.d.ts

@@ -0,0 +1,59 @@
+/**
+ * src/orchestrator/tool-loop-askcard.ts
+ *
+ * Pure helper that computes the tool-loop-cap askcard tier (label set + default
+ * action) from the current step number and the resolved natural ceiling for
+ * the (taskType, size) matrix.
+ *
+ * Four tiers (open intervals — boundaries belong to the higher tier):
+ *   - early       : step < 0.5 × ceiling — a transient fixation. Default Continue.
+ *   - normal      : 0.5× ≤ step ≤ 2× ceiling — used cheap budget; Default Stop.
+ *   - overBudget  : 2× < step ≤ 5× ceiling — Continue still available but the
+ *                   label carries the overage multiplier so the cost of
+ *                   continuing is visible at decision time. Default Stop.
+ *   - extreme     : step > 5× ceiling — Stop is moved FIRST in the option
+ *                   array (Enter = Stop) and Continue is labelled "expensive".
+ *                   Default Stop (now at index 0).
+ *
+ * Live miss this tier set fixes (session 1f29e238, step 77/6 = 12.8×): extreme
+ * tier put Stop first with a warning — good. But the storyflow_ui session
+ * 22661c8de9f2 ran step 29/12 = 2.4× — the OLD code had no middle warning, so
+ * the askcard showed a plain "Continue (let agent try)" with no signal that
+ * continuing costs more. User chose Continue, the model stalled 4 tool-calls
+ * later, and forced-finalize had to rescue a degraded answer.
+ *
+ * Pure — no React, no DOM, no side effects. Unit-testable in isolation.
+ */
+export type LoopCapTier = "early" | "normal" | "overBudget" | "extreme";
+export interface LoopCapAskcardOptions {
+    /** AI-SDK step number when the pattern fired. */
+    stepNumber: number;
+    /**
+     * Natural step ceiling for (taskType, size). Optional — when undefined we
+     * cannot compute multipliers, so the askcard falls back to the legacy
+     * step-threshold heuristic (step ≤ 15 = early-ish, else normal).
+     */
+    naturalCeiling?: number;
+}
+export interface LoopCapAskcardLayout {
+    tier: LoopCapTier;
+    /** Index into `optionLabels` of the option pre-selected (Enter applies). */
+    defaultIndex: 0 | 1;
+    /**
+     * Exactly two labels in render order. The first is at index 0, the second
+     * at index 1 — order matters for the askcard UI (arrow-key navigation,
+     * Enter-applies-default).
+     */
+    optionLabels: [continueOrStop: string, stopOrContinue: string];
+    /** Values parallel to optionLabels — what the resolver returns to the loop. */
+    optionValues: [string, string];
+    /**
+     * x.x string (e.g. "2.4") when the tier is overBudget or extreme, else
+     * null. Caller can also surface this in the askcard context message.
+     */
+    overageMultiplier: string | null;
+}
+/**
+ * Decide the askcard layout for a tool-loop-cap pattern hit. Pure.
+ */
+export declare function planLoopCapAskcard(opts: LoopCapAskcardOptions): LoopCapAskcardLayout;

package/dist/src/orchestrator/tool-loop-askcard.js

@@ -0,0 +1,86 @@
+/**
+ * src/orchestrator/tool-loop-askcard.ts
+ *
+ * Pure helper that computes the tool-loop-cap askcard tier (label set + default
+ * action) from the current step number and the resolved natural ceiling for
+ * the (taskType, size) matrix.
+ *
+ * Four tiers (open intervals — boundaries belong to the higher tier):
+ *   - early       : step < 0.5 × ceiling — a transient fixation. Default Continue.
+ *   - normal      : 0.5× ≤ step ≤ 2× ceiling — used cheap budget; Default Stop.
+ *   - overBudget  : 2× < step ≤ 5× ceiling — Continue still available but the
+ *                   label carries the overage multiplier so the cost of
+ *                   continuing is visible at decision time. Default Stop.
+ *   - extreme     : step > 5× ceiling — Stop is moved FIRST in the option
+ *                   array (Enter = Stop) and Continue is labelled "expensive".
+ *                   Default Stop (now at index 0).
+ *
+ * Live miss this tier set fixes (session 1f29e238, step 77/6 = 12.8×): extreme
+ * tier put Stop first with a warning — good. But the storyflow_ui session
+ * 22661c8de9f2 ran step 29/12 = 2.4× — the OLD code had no middle warning, so
+ * the askcard showed a plain "Continue (let agent try)" with no signal that
+ * continuing costs more. User chose Continue, the model stalled 4 tool-calls
+ * later, and forced-finalize had to rescue a degraded answer.
+ *
+ * Pure — no React, no DOM, no side effects. Unit-testable in isolation.
+ */
+const NORMAL_LABELS = ["Continue (let agent try)", "Stop and answer"];
+const NORMAL_VALUES = ["continue", "stop"];
+/**
+ * Decide the askcard layout for a tool-loop-cap pattern hit. Pure.
+ */
+export function planLoopCapAskcard(opts) {
+    const { stepNumber, naturalCeiling } = opts;
+    // No ceiling → cannot compute multipliers. Fall back to a static threshold:
+    // step ≤ 15 looks "early" enough to default Continue, else default Stop.
+    if (!naturalCeiling || naturalCeiling <= 0) {
+        const tier = stepNumber > 0 && stepNumber <= 15 ? "early" : "normal";
+        return {
+            tier,
+            defaultIndex: tier === "early" ? 0 : 1,
+            optionLabels: NORMAL_LABELS,
+            optionValues: NORMAL_VALUES,
+            overageMultiplier: null,
+        };
+    }
+    const ratio = stepNumber / naturalCeiling;
+    const multiplier = ratio.toFixed(1);
+    if (ratio > 5) {
+        return {
+            tier: "extreme",
+            defaultIndex: 0,
+            optionLabels: ["Stop and answer (recommended)", `Continue anyway (⚠ ${multiplier}× over budget — expensive)`],
+            optionValues: ["stop", "continue"],
+            overageMultiplier: multiplier,
+        };
+    }
+    if (ratio > 2) {
+        return {
+            tier: "overBudget",
+            defaultIndex: 1,
+            optionLabels: [
+                `Continue (⚠ ${multiplier}× past natural budget — quality may degrade)`,
+                "Stop and answer (recommended)",
+            ],
+            optionValues: NORMAL_VALUES,
+            overageMultiplier: multiplier,
+        };
+    }
+    if (ratio < 0.5) {
+        return {
+            tier: "early",
+            defaultIndex: 0,
+            optionLabels: NORMAL_LABELS,
+            optionValues: NORMAL_VALUES,
+            overageMultiplier: null,
+        };
+    }
+    return {
+        tier: "normal",
+        defaultIndex: 1,
+        optionLabels: NORMAL_LABELS,
+        optionValues: NORMAL_VALUES,
+        overageMultiplier: null,
+    };
+}
+//# sourceMappingURL=tool-loop-askcard.js.map

package/dist/src/orchestrator/tool-loop-askcard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/orchestrator/tool-loop-askcard.test.js

@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import { planLoopCapAskcard } from "./tool-loop-askcard.js";
+describe("planLoopCapAskcard", () => {
+    it("early tier (< 0.5× ceiling): default Continue, no warning", () => {
+        const r = planLoopCapAskcard({ stepNumber: 5, naturalCeiling: 12 });
+        expect(r.tier).toBe("early");
+        expect(r.defaultIndex).toBe(0);
+        expect(r.optionLabels[0]).toMatch(/Continue/);
+        expect(r.optionValues[0]).toBe("continue");
+        expect(r.overageMultiplier).toBeNull();
+        // no warning emoji on the Continue label
+        expect(r.optionLabels[0]).not.toMatch(/⚠/);
+    });
+    it("normal tier (0.5×–2× ceiling): default Stop, no warning, Continue first", () => {
+        const r = planLoopCapAskcard({ stepNumber: 18, naturalCeiling: 12 });
+        expect(r.tier).toBe("normal");
+        expect(r.defaultIndex).toBe(1);
+        expect(r.optionLabels[0]).toBe("Continue (let agent try)");
+        expect(r.optionLabels[1]).toBe("Stop and answer");
+        expect(r.overageMultiplier).toBeNull();
+    });
+    it("overBudget tier (2×–5× ceiling): Continue carries the overage multiplier, default Stop", () => {
+        // The storyflow_ui case: step 29 / ceiling 12 = 2.4×
+        const r = planLoopCapAskcard({ stepNumber: 29, naturalCeiling: 12 });
+        expect(r.tier).toBe("overBudget");
+        expect(r.defaultIndex).toBe(1);
+        expect(r.optionLabels[0]).toMatch(/⚠ 2\.4× past natural budget/);
+        expect(r.optionLabels[1]).toMatch(/Stop and answer \(recommended\)/);
+        expect(r.overageMultiplier).toBe("2.4");
+        // order preserved: Continue at 0, Stop at 1
+        expect(r.optionValues).toEqual(["continue", "stop"]);
+    });
+    it("extreme tier (> 5× ceiling): Stop FIRST in the array, Continue labelled expensive", () => {
+        // session 1f29e238 — step 77 / ceiling 6 = 12.8×
+        const r = planLoopCapAskcard({ stepNumber: 77, naturalCeiling: 6 });
+        expect(r.tier).toBe("extreme");
+        expect(r.defaultIndex).toBe(0);
+        expect(r.optionLabels[0]).toMatch(/Stop and answer \(recommended\)/);
+        expect(r.optionLabels[1]).toMatch(/⚠ 12\.8× over budget — expensive/);
+        expect(r.optionValues).toEqual(["stop", "continue"]); // ORDER REVERSED at extreme
+        expect(r.overageMultiplier).toBe("12.8");
+    });
+    it("tier boundaries are open-on-the-lower-side (ratio==2 → normal; ratio==5 → overBudget; ratio==0.5 → normal)", () => {
+        // ratio === 2.0 exactly → still normal (the > 2 gate excludes 2.0)
+        expect(planLoopCapAskcard({ stepNumber: 24, naturalCeiling: 12 }).tier).toBe("normal");
+        // ratio === 5.0 exactly → still overBudget (the > 5 gate excludes 5.0)
+        expect(planLoopCapAskcard({ stepNumber: 60, naturalCeiling: 12 }).tier).toBe("overBudget");
+        // ratio === 0.5 exactly → normal (the < 0.5 gate excludes 0.5)
+        expect(planLoopCapAskcard({ stepNumber: 6, naturalCeiling: 12 }).tier).toBe("normal");
+    });
+    it("falls back to step-threshold heuristic when naturalCeiling is missing", () => {
+        const early = planLoopCapAskcard({ stepNumber: 8 });
+        expect(early.tier).toBe("early");
+        expect(early.defaultIndex).toBe(0);
+        const normal = planLoopCapAskcard({ stepNumber: 22 });
+        expect(normal.tier).toBe("normal");
+        expect(normal.defaultIndex).toBe(1);
+        // boundary: step === 15 → still early
+        expect(planLoopCapAskcard({ stepNumber: 15 }).tier).toBe("early");
+        // step === 16 → normal
+        expect(planLoopCapAskcard({ stepNumber: 16 }).tier).toBe("normal");
+        // step === 0 → normal (no early credit for nothing)
+        expect(planLoopCapAskcard({ stepNumber: 0 }).tier).toBe("normal");
+    });
+    it("treats naturalCeiling=0 the same as undefined (no multiplier possible)", () => {
+        const r = planLoopCapAskcard({ stepNumber: 30, naturalCeiling: 0 });
+        expect(r.overageMultiplier).toBeNull();
+        expect(r.tier).toBe("normal");
+    });
+});
+//# sourceMappingURL=tool-loop-askcard.test.js.map

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

@@ -102,7 +102,11 @@ export async function layer4Gsd(ctx) {
             (ctx.taskType === "general" && ctx.intentKind === "task") ||
             (isQuestionLike(ctx.raw) && !isImplementationIntent(ctx.raw));
     const ecosystem = mentionsEcosystemScope(ctx.raw);
-    const directive = buildDirective({ complexity, phase, grayAreas, informational, ecosystem });
+    // Heuristic: VN diacritics → user wrote Vietnamese → re-anchor language rule
+    // inside the directive (storyflow_ui session 22661c8de9f2 — base rule
+    // crowded out by brevity/FIX-FIRST directives).
+    const replyLanguage = /[à-ỹÀ-Ỹ]/.test(ctx.raw) ? "Vietnamese" : undefined;
+    const directive = buildDirective({ complexity, phase, grayAreas, informational, ecosystem, replyLanguage });
     const budgetChars = Math.floor(ctx.tokenBudget * DIRECTIVE_BUDGET_FRACTION);
     const trimmed = truncateToBudget(directive.text, budgetChars);
     return {

package/dist/src/ui/app.js

@@ -13,6 +13,7 @@ import { POPULAR_MCP_CATALOG } from "../mcp/catalog.js";
 import { parseEnvLines, parseHeaderLines } from "../mcp/parse-headers.js";
 import { toMcpServerId, validateMcpServerConfig } from "../mcp/validate.js";
 import { Agent } from "../orchestrator/orchestrator.js";
+import { planLoopCapAskcard } from "../orchestrator/tool-loop-askcard.js";
 import { getConfiguredProviders, setKeyForProvider } from "../providers/keychain.js";
 import { buildIdealContinuationPrompt } from "../scaffold/continuation-prompt.js";
 import { continueAsCouncil } from "../scaffold/continue-as-council.js";
@@ -24,7 +25,7 @@ import { processAtMentions } from "../utils/at-mentions.js";
 import { readClipboardImage } from "../utils/clipboard-image.js";
 import { FileIndex } from "../utils/file-index.js";
 import { copyTextToHostClipboard, readTextFromHostClipboard } from "../utils/host-clipboard.js";
-import { getApiKey, getCurrentModel, getTelegramBotToken, isModelDisabled, isReservedSubagentName, loadMcpServers, loadPaymentSettings, loadUserSettings, loadValidSubAgents, saveApprovedTelegramUserId, saveMcpServers, savePaymentSettings, saveProjectSettings, saveUserSettings, setDefaultProvider, setModelDisabled, setProviderDisabled, } from "../utils/settings.js";
+import { getApiKey, getCurrentModel, getSteerInjectionEnabled, getTelegramBotToken, isModelDisabled, isReservedSubagentName, loadMcpServers, loadPaymentSettings, loadUserSettings, loadValidSubAgents, saveApprovedTelegramUserId, saveMcpServers, savePaymentSettings, saveProjectSettings, saveUserSettings, setDefaultProvider, setModelDisabled, setProviderDisabled, } from "../utils/settings.js";
 import { discoverSkills, formatSkillsForChat } from "../utils/skills.js";
 import { formatSubagentName } from "../utils/subagent-display.js";
 import { checkForUpdate, runUpdate } from "../utils/update-checker.js";
@@ -483,6 +484,11 @@ export function App({ agent, startupConfig, initialMessage, onExit }) {
                 pushToast(lvl, text);
             return;
         }
+        if (e.kind === "steer-inject") {
+            const count = typeof e.count === "number" ? e.count : 1;
+            pushToast("info", `↳ steering applied (${count} message${count === 1 ? "" : "s"})`);
+            return;
+        }
         if (e.kind === "ee-timeout" || e.kind === "ee-error") {
             const source = typeof e.source === "string" ? e.source : "unknown";
             const kind = e.kind === "ee-timeout" ? "timeout" : "error";
@@ -539,6 +545,23 @@ export function App({ agent, startupConfig, initialMessage, onExit }) {
         }
         return undefined;
     }, [handleHarnessEvent]);
+    // Live-queue steering: expose the mid-turn queue to the running turn so
+    // prepareStep can inject typed-while-busy messages at the next step boundary
+    // instead of deferring them to a new turn. Disabled → callback not wired, so
+    // finishTurnProcessing drains the queue post-turn exactly as before.
+    useEffect(() => {
+        if (!getSteerInjectionEnabled())
+            return;
+        agent.setSteerDrain(() => {
+            if (queuedMessagesRef.current.length === 0)
+                return [];
+            const drained = queuedMessagesRef.current.map((m) => ({ text: m.text }));
+            queuedMessagesRef.current = [];
+            setQueuedMessages([]);
+            return drained;
+        });
+        return () => agent.setSteerDrain(null);
+    }, [agent]);
     const dismissToast = useCallback(() => setActiveToast(null), []);
     // ─── /Phase 21 toast subscriber ────────────────────────────────────────────
     const { model, setModel, showModelPicker, setShowModelPicker, modelPickerIndex, setModelPickerIndex, modelSearchQuery, setModelSearchQuery, configuredProviders, setConfiguredProviders, disabledProviders, setDisabledProvidersState, defaultProvider, setDefaultProviderState, disabledModels, setDisabledModelsState, modelPickerFocus, setModelPickerFocus, providerChipIndex, setProviderChipIndex, reasoningEffortByModel, setReasoningEffortByModel, } = useModelPicker(agent.getModel());
@@ -1779,50 +1802,43 @@ export function App({ agent, startupConfig, initialMessage, onExit }) {
                 const isPattern = info.kind === "pattern";
                 const qid = isPattern ? `tool-pattern-loop-${Date.now()}` : `tool-loop-cap-${info.stepNumber}-${Date.now()}`;
                 toolLoopCapResolversRef.current.set(qid, resolve);
-                // Phase 5 BUG-H — context-aware default:
-                //   - Early in the run (step < natural ceiling × 0.5) loops are
-                //     usually a temporary fixation on a single file/cmd; "continue"
-                //     is the right default.
-                //   - Past the soft-warn line (≥ 50% of natural ceiling) we've used
-                //     up the cheap budget — "stop" becomes the safer default.
-                // Falls back to a static stepNumber heuristic (≤ 15) when caller
-                // didn't supply a naturalCeiling.
+                // Tier-aware askcard layout (planLoopCapAskcard) — 4 tiers:
+                //   early (< 0.5× ceiling)       → Default Continue, no warning
+                //   normal (0.5×–2× ceiling)     → Default Stop, no warning
+                //   overBudget (2×–5× ceiling)   → Default Stop, Continue label carries
+                //                                   the overage multiplier so cost is
+                //                                   visible (storyflow_ui 22661c8de9f2:
+                //                                   2.4× hit had no warning before)
+                //   extreme (> 5× ceiling)        → Stop FIRST in the array (Enter=Stop),
+                //                                   Continue labelled "expensive"
+                //                                   (session 1f29e238: 12.8× past ceiling)
                 const patternStep = isPattern ? info.stepNumber : 0;
                 const patternCeiling = isPattern ? info.naturalCeiling : undefined;
-                const patternEarly = patternCeiling !== undefined
-                    ? patternStep < Math.floor(patternCeiling * 0.5)
-                    : patternStep > 0 && patternStep <= 15;
-                // Extreme-overage trip: stepNumber > 5× naturalCeiling. Evidence
-                // (session 1f29e238): at step 77/6 = 12.8× ceiling the askcard still
-                // showed Continue as a first-class option and user chose Continue
-                // within 4s. At extreme overage we put Stop FIRST (Enter = Stop) and
-                // label Continue with the explicit overage multiplier so the cost is
-                // visible at decision time.
-                const patternExtreme = patternCeiling !== undefined && patternCeiling > 0 && patternStep > patternCeiling * 5;
-                const overageMultiplier = patternExtreme && patternCeiling ? (patternStep / patternCeiling).toFixed(1) : null;
-                const patternDefaultIdx = patternEarly ? 0 : patternExtreme ? 0 : 1;
-                const patternOptions = patternExtreme
+                const layout = isPattern
+                    ? planLoopCapAskcard({ stepNumber: patternStep, naturalCeiling: patternCeiling })
+                    : null;
+                const patternEarly = layout?.tier === "early";
+                const patternOverBudget = layout?.tier === "overBudget";
+                const patternExtreme = layout?.tier === "extreme";
+                const overageMultiplier = layout?.overageMultiplier ?? null;
+                const patternDefaultIdx = layout?.defaultIndex ?? 0;
+                const patternOptions = layout
                     ? [
-                        { label: "Stop and answer (recommended)", value: "stop", kind: "choice" },
-                        {
-                            label: `Continue anyway (⚠ ${overageMultiplier}× over budget — expensive)`,
-                            value: "continue",
-                            kind: "choice",
-                        },
+                        { label: layout.optionLabels[0], value: layout.optionValues[0], kind: "choice" },
+                        { label: layout.optionLabels[1], value: layout.optionValues[1], kind: "choice" },
                     ]
-                    : [
-                        { label: "Continue (let agent try)", value: "continue", kind: "choice" },
-                        { label: "Stop and answer", value: "stop", kind: "choice" },
-                    ];
+                    : [];
                 const question = isPattern
                     ? {
                         questionId: qid,
                         question: `Tool \`${info.toolName}\` đã chạy ${info.count}/${info.windowSize} lần với args gần giống (step ${info.stepNumber}${patternCeiling ? `/${patternCeiling}` : ""}) — có thể đang loop. Tiếp tục?`,
                         context: patternExtreme
                             ? `EXTREME OVERAGE — ${overageMultiplier}× past natural budget. Continuing has historically not converged in this regime (see session 1f29e238: 8× over budget, still failed). Stop returns the agent's best answer with current context.`
-                            : patternEarly
-                                ? "Continue lets the agent keep trying — likely the right call this early in the run. Stop returns the agent's best answer with current context."
-                                : "You're past the natural budget for this task type. Stop usually recovers a clean answer; Continue keeps spending tokens.",
+                            : patternOverBudget
+                                ? `Past natural budget — ${overageMultiplier}× the typical step count for this task type. Continuing may still converge but quality often degrades (longer compaction, stale tool results, forced-finalize on stall). Stop returns the agent's best answer with current context.`
+                                : patternEarly
+                                    ? "Continue lets the agent keep trying — likely the right call this early in the run. Stop returns the agent's best answer with current context."
+                                    : "You're past the natural budget for this task type. Stop usually recovers a clean answer; Continue keeps spending tokens.",
                         isRequired: true,
                         phase: "tool-loop-cap",
                         options: patternOptions,

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

@@ -317,6 +317,29 @@ 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;
+/**
+ * Live-queue steering: when true, a message typed while a turn is streaming is
+ * injected into the running turn at the next prepareStep boundary (as a `user`
+ * interjection) instead of waiting for the turn to finish and running as a new
+ * turn. When false, the legacy deferred-queue behaviour is preserved (the
+ * message runs only after the current turn completes). House convention for a
+ * default-true boolean knob: only an explicit "0" disables; unset/blank/any
+ * other value = enabled. Env override: MUONROI_STEER_INJECTION.
+ */
+export declare function getSteerInjectionEnabled(): boolean;
 /**
  * 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,39 @@ 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;
+}
+/**
+ * Live-queue steering: when true, a message typed while a turn is streaming is
+ * injected into the running turn at the next prepareStep boundary (as a `user`
+ * interjection) instead of waiting for the turn to finish and running as a new
+ * turn. When false, the legacy deferred-queue behaviour is preserved (the
+ * message runs only after the current turn completes). House convention for a
+ * default-true boolean knob: only an explicit "0" disables; unset/blank/any
+ * other value = enabled. Env override: MUONROI_STEER_INJECTION.
+ */
+export function getSteerInjectionEnabled() {
+    return process.env.MUONROI_STEER_INJECTION !== "0";
+}
 /**
  * Phase B3 — threshold (in chars of cumulative message content) above which
  * the sub-agent `prepareStep` compactor rewrites older tool_result parts