muonroi-cli 1.6.4 → 1.6.5

package/dist/packages/agent-harness-core/src/event-filter.js

@@ -28,6 +28,7 @@ export const LIFECYCLE_PRESET = new Set([
     "sprint-stage",
     "sprint-halt",
     "route-decision",
+    "steer-inject",
     "usage",
 ]);
 /**

package/dist/packages/agent-harness-core/src/event-redact.js

@@ -85,7 +85,12 @@ const ALLOWED_FIELDS = {
         forceCouncil: "pass",
         runId: "pass",
     },
-    "toast": {
+    "steer-inject": {
+        count: "pass",
+        atStep: "pass",
+        runId: "pass",
+    },
+    toast: {
         level: "pass",
         text: 500, // cap to 500 chars, then scrub
         ttlMs: "pass",
@@ -94,7 +99,7 @@ const ALLOWED_FIELDS = {
         target: "pass",
         text: 500, // cap to 500 chars
     },
-    "usage": {
+    usage: {
         source: "pass",
         model: "pass",
         inputTokens: "pass",

package/dist/packages/agent-harness-core/src/protocol.d.ts

@@ -177,6 +177,14 @@ export type LiveEvent = {
     /** Total number of unverified claims in this turn. */
     count: number;
     ts: number;
+} | {
+    t: "event";
+    kind: "steer-inject";
+    /** How many queued messages were injected at this boundary. */
+    count: number;
+    /** The prepareStep step number at which injection occurred (>= 1). */
+    atStep: number;
+    runId: string;
 } | {
     t: "idle";
 };

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

@@ -1,2 +1,2 @@
-export declare const PACKAGE_VERSION = "1.6.4";
+export declare const PACKAGE_VERSION = "1.6.5";
 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.4";
+export const PACKAGE_VERSION = "1.6.5";
 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/gsd/__tests__/directives.test.js

@@ -98,5 +98,42 @@ describe("buildDirective", () => {
             expect(out.text).toMatch(/\[recommended\]/);
         }
     });
+    // Language nudge — re-anchors the "reply in user's language" rule INSIDE the
+    // directive so layered brevity / FIX-FIRST directives can't drown it (live
+    // miss: storyflow_ui session 22661c8de9f2).
+    describe("language nudge", () => {
+        it("appends the nudge when replyLanguage is set", () => {
+            const out = buildDirective({
+                complexity: scoreComplexity("fix CI fail"),
+                phase: "debug",
+                grayAreas: [],
+                replyLanguage: "Vietnamese",
+            });
+            expect(out.text).toMatch(/LANGUAGE — the user wrote in Vietnamese/);
+            expect(out.text).toMatch(/Reply in Vietnamese/);
+            expect(out.text).toMatch(/OVERRIDES any brevity/);
+        });
+        it("omits the nudge when replyLanguage is undefined", () => {
+            const out = buildDirective({
+                complexity: scoreComplexity("fix CI fail"),
+                phase: "debug",
+                grayAreas: [],
+            });
+            expect(out.text).not.toMatch(/LANGUAGE —/);
+        });
+        it("stacks with the ecosystem nudge when both apply", () => {
+            const out = buildDirective({
+                complexity: scoreComplexity("how does the muonroi ecosystem work"),
+                phase: null,
+                grayAreas: [],
+                ecosystem: true,
+                replyLanguage: "Vietnamese",
+            });
+            expect(out.text).toMatch(/ECOSYSTEM SCOPE/);
+            expect(out.text).toMatch(/LANGUAGE —/);
+            // ecosystem nudge precedes language nudge (deterministic order)
+            expect(out.text.indexOf("ECOSYSTEM SCOPE")).toBeLessThan(out.text.indexOf("LANGUAGE —"));
+        });
+    });
 });
 //# sourceMappingURL=directives.test.js.map

package/dist/src/gsd/directives.d.ts

@@ -46,6 +46,15 @@ export interface DirectiveInput {
      * the shipped authoritative source.
      */
     ecosystem?: boolean;
+    /**
+     * User's reply language (heuristic — Vietnamese|undefined). When set, the
+     * directive appends an explicit language nudge so the rule survives the
+     * personality/GSD instructions stacking on top of it (storyflow_ui session
+     * 22661c8de9f2: user wrote Vietnamese, layered directives + a stalled
+     * forced-finalize drowned out the base "reply in user's language" rule and
+     * the agent answered in English).
+     */
+    replyLanguage?: string;
 }
 export interface DirectiveOutput {
     text: string;
@@ -60,4 +69,13 @@ export declare function mentionsEcosystemScope(message: string): boolean;
  * configured — the model simply finds no such tool and falls back to local files.
  */
 export declare const ECOSYSTEM_DOCS_NUDGE: string;
+/**
+ * Appended to any directive when the user's reply language is non-English.
+ * The base system prompt's "reply in user's language" rule normally suffices,
+ * but `concise` / `FIX-FIRST` / GSD-debug directive bodies stack on top of it
+ * with strong "be terse / code over prose" language that crowds the rule out
+ * — observed live (storyflow_ui 22661c8de9f2). This NUDGE re-anchors the rule
+ * inside the directive itself so brevity preferences cannot override it.
+ */
+export declare function buildLanguageNudge(lang: string): string;
 export declare function buildDirective(input: DirectiveInput): DirectiveOutput;

package/dist/src/gsd/directives.js

@@ -36,6 +36,20 @@ export const ECOSYSTEM_DOCS_NUDGE = [
     `${HEADER} ECOSYSTEM SCOPE — this turn concerns the Muonroi ecosystem (platform overview, BB/.NET packages, building-block, open-core boundary, setup).`,
     "If the muonroi-docs MCP is available, it is the AUTHORITATIVE source — call it FIRST (docs_search / setup_guide / bb_recipe_list / bb_package_describe), THEN ground with local files. Do NOT characterize the ecosystem from local repo files alone.",
 ].join("\n");
+/**
+ * Appended to any directive when the user's reply language is non-English.
+ * The base system prompt's "reply in user's language" rule normally suffices,
+ * but `concise` / `FIX-FIRST` / GSD-debug directive bodies stack on top of it
+ * with strong "be terse / code over prose" language that crowds the rule out
+ * — observed live (storyflow_ui 22661c8de9f2). This NUDGE re-anchors the rule
+ * inside the directive itself so brevity preferences cannot override it.
+ */
+export function buildLanguageNudge(lang) {
+    return [
+        `${HEADER} LANGUAGE — the user wrote in ${lang}. Reply in ${lang}.`,
+        "This rule OVERRIDES any brevity / concise / code-over-prose directive: terseness is fine, but the response language stays the user's.",
+    ].join("\n");
+}
 function renderGrayAreas(qs) {
     if (qs.length === 0)
         return "  (no gray areas detected — confirm the request is fully specified before proceeding)";
@@ -125,9 +139,16 @@ export function buildDirective(input) {
     // Ecosystem-scoped turns get a docs-first nudge regardless of tier (question
     // OR task): muonroi-docs is the authoritative source and must not be skipped
     // in favour of guessing from local files (session 41ccfeb2ceee turn 1).
+    let text = base.text;
     if (input.ecosystem) {
-        return { ...base, text: `${base.text}\n${ECOSYSTEM_DOCS_NUDGE}` };
+        text = `${text}\n${ECOSYSTEM_DOCS_NUDGE}`;
+    }
+    // Language nudge: re-anchor the "reply in user's language" rule INSIDE the
+    // directive when the user wrote in a non-English language, so layered
+    // brevity/concise directives can't drown it (storyflow_ui 22661c8de9f2).
+    if (input.replyLanguage) {
+        text = `${text}\n${buildLanguageNudge(input.replyLanguage)}`;
     }
-    return base;
+    return { ...base, text };
 }
 //# sourceMappingURL=directives.js.map

package/dist/src/orchestrator/message-processor.d.ts

@@ -100,6 +100,14 @@ export interface MessageProcessorDeps extends TurnRunnerDepsBase {
      * — preserves backward compat for batch / headless paths that have no UI to
      * surface the askcard.
      */
+    /**
+     * Live-queue steering drain (UI-provided). Returns and CLEARS any messages
+     * the user typed while this turn is streaming, so prepareStep can inject them
+     * mid-turn. Undefined / returns [] → no steering (legacy deferred queue).
+     */
+    drainSteerMessages?: () => {
+        text: string;
+    }[];
     askToolLoopContinue?: ToolLoopCapAsk;
     runCouncilV2(userMessage: string, opts: {
         skipClarification: boolean;

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

@@ -89,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, getProviderStallRetries, getProviderStallTimeoutMs, getRoleModels, getTopLevelCompactKeepLast, getTopLevelCompactThresholdChars, getTopLevelToolBudgetChars, isAutoCouncilEnabled, isProviderDisabled, loadMcpServers, loadValidSubAgents, } from "../utils/settings.js";
+import { getAutoCouncilConfidence, getAutoCouncilMinRoles, getProviderStallRetries, getProviderStallTimeoutMs, getRoleModels, getSteerInjectionEnabled, 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";
@@ -109,6 +109,7 @@ import { attachReminderToMessages, buildCheckpointReminder, buildScopeReminder,
 import { formatElisionManifest, getSessionExperienceCounts, recordCompaction, recordElision, } from "./session-experience.js";
 import { attemptStallRescue, pushStallToolResult } from "./stall-rescue.js";
 import { createStallWatchdog, STALL_ERROR_MESSAGE, shouldRepromptStall, stallRepromptBackoffMs, } from "./stall-watchdog.js";
+import { planSteerInjection } from "./steer-inbox.js";
 import { wrapToolSetWithCap } from "./sub-agent-cap.js";
 import { compactSubAgentMessages, cumulativeMessageChars } from "./subagent-compactor.js";
 import { detectTextEmittedToolCall, parseDsmlToolCalls } from "./text-tool-call-detector.js";
@@ -823,6 +824,14 @@ export class MessageProcessor {
         // answer rescue path instead. maxStallRetries = 0 restores legacy behaviour.
         let stallRetryCount = 0;
         const maxStallRetries = getProviderStallRetries();
+        // Live-queue steering: messages the user typed mid-turn are drained at a
+        // prepareStep boundary and accumulated here, then re-appended (deduped) to
+        // the messages returned for each subsequent step. Loop-persistent so they
+        // survive a stall-reprompt restart of streamText. NOT pushed into
+        // deps.messages in v1 — model-context only; the assistant response captures
+        // the steering effect and is persisted via appendCompletedTurn.
+        const pendingSteers = [];
+        const steerEnabled = getSteerInjectionEnabled();
         // 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
@@ -1538,6 +1547,46 @@ export class MessageProcessor {
                         prepareStep: ({ stepNumber: sn, messages: stepMessages }) => {
                             if (sn < 1)
                                 return {};
+                            // --- Live-queue steering injection ---------------------------
+                            // Drain the UI steer queue ONCE per prepareStep call (sn >= 1),
+                            // accumulate into pendingSteers, and graft pendingSteers onto the
+                            // messages this step returns. Dedup-by-content makes re-appending
+                            // idempotent even if a stall-reprompt restart re-reads history.
+                            const withSteers = (r) => {
+                                // Guard the drain on !signal.aborted too: planSteerInjection
+                                // already refuses to inject on abort, but draining still CLEARS
+                                // the UI queue — so on a (programmatic) abort we must not drain,
+                                // or a queued-but-uninjected message is lost (spec §143).
+                                const _drained = steerEnabled && !signal.aborted ? (deps.drainSteerMessages?.() ?? []) : [];
+                                const _newSteers = planSteerInjection({
+                                    drained: _drained,
+                                    aborted: signal.aborted,
+                                    enabled: steerEnabled,
+                                });
+                                if (_newSteers.length > 0) {
+                                    pendingSteers.push(..._newSteers);
+                                    try {
+                                        const _ar = globalThis.__muonroiAgentRuntime;
+                                        _ar?.emitEvent({
+                                            t: "event",
+                                            kind: "steer-inject",
+                                            count: _newSteers.length,
+                                            atStep: sn,
+                                            runId: deps.getActiveRunId() ?? "",
+                                        });
+                                    }
+                                    catch (emitErr) {
+                                        console.error(`[message-processor] steer-inject telemetry failed: ${emitErr?.message}`);
+                                    }
+                                }
+                                if (pendingSteers.length === 0)
+                                    return r;
+                                const _base = r.messages ?? stepMessages;
+                                const _steerContents = new Set(pendingSteers.map((s) => (typeof s.content === "string" ? s.content : JSON.stringify(s.content))));
+                                const _deduped = _base.filter((m) => !(m.role === "user" &&
+                                    _steerContents.has(typeof m.content === "string" ? m.content : JSON.stringify(m.content))));
+                                return { ...r, messages: [..._deduped, ...pendingSteers] };
+                            };
                             const stripped = turnCaps.sanitizeHistory(stepMessages);
                             // Agent-controlled veto (PRESERVE) or lighter selective keep (KEEP_TOOL_IDS) for this turn's B4 compaction.
                             // PRESERVE_FULL_CONTEXT skips the compactor entirely (full history).
@@ -1568,7 +1617,7 @@ export class MessageProcessor {
                                 return false;
                             });
                             if (hasPreserve) {
-                                return { messages: stripped };
+                                return withSteers({ messages: stripped });
                             }
                             // F2 — envelope = system prompt + JSON-Schema of every tool
                             // re-sent on every step. Without this the threshold check
@@ -1642,7 +1691,7 @@ export class MessageProcessor {
                             if (compacted === stripped && shouldPreWarnCompaction(_preWarnChars, topLevelCompactThreshold)) {
                                 const _cp = buildCheckpointReminder(sn, true);
                                 const _pre = `[pre-compaction warning at step ${sn} — next step(s) will likely rewrite older tool results to stubs (threshold ${topLevelCompactThreshold}, keepLast=${topLevelCompactKeepLast}). ${_cp} Summarize or finish if possible.]`;
-                                return { messages: attachReminderToMessages(stripped, _pre) };
+                                return withSteers({ messages: attachReminderToMessages(stripped, _pre) });
                             }
                             // Phase 4A — scope reminder injection (REQ-005).
                             // Cadence K = 3/5/8 for small/medium/large. Soft-warn fires
@@ -1704,10 +1753,10 @@ export class MessageProcessor {
                                         : buildRepetitionReminder(_ceilingSessionId)
                                     : _scopePart;
                                 const withReminder = attachReminderToMessages(compacted, _reminder);
-                                return { messages: withReminder };
+                                return withSteers({ messages: withReminder });
                             }
                             if (compacted === stripped && stripped === stepMessages)
-                                return {};
+                                return withSteers({});
                             // Self-awareness note: tell the model compaction happened so it
                             // knows earlier context was elided and can adjust its behavior.
                             // Enhanced per EE anti-mù plan (docs/ee-anti-mu-compaction-plan.md Phase 2): include proactive
@@ -1725,9 +1774,9 @@ export class MessageProcessor {
                                 })()
                                 : null;
                             if (_compactNote) {
-                                return { messages: attachReminderToMessages(compacted, _compactNote) };
+                                return withSteers({ messages: attachReminderToMessages(compacted, _compactNote) });
                             }
-                            return { messages: compacted };
+                            return withSteers({ messages: compacted });
                         },
                         ...(dropParam("temperature") ? {} : { temperature: 0.7 }),
                         ...(dropParam("maxOutputTokens") ? {} : { maxOutputTokens: taskTypeToMaxTokens(pilCtx.taskType) }),

package/dist/src/orchestrator/orchestrator.d.ts

@@ -20,6 +20,8 @@ export declare class Agent {
     private messages;
     private messageSeqs;
     private abortController;
+    /** UI-registered live-queue steer drain; see Agent.setSteerDrain. */
+    private steerDrain;
     private maxToolRounds;
     private mode;
     private modelId;
@@ -97,6 +99,14 @@ export declare class Agent {
      */
     private _initFlow;
     getModel(): string;
+    /**
+     * Register (or clear with null) the UI callback that drains messages typed
+     * while a turn is streaming, for mid-turn steering injection. Called from the
+     * TUI when MUONROI_STEER_INJECTION is enabled.
+     */
+    setSteerDrain(fn: (() => {
+        text: string;
+    }[]) | null): void;
     getActiveRunId(): string | null;
     setModel(model: string): void;
     getMode(): AgentMode;

package/dist/src/orchestrator/orchestrator.js

@@ -130,6 +130,8 @@ export class Agent {
     messages = [];
     messageSeqs = [];
     abortController = null;
+    /** UI-registered live-queue steer drain; see Agent.setSteerDrain. */
+    steerDrain = null;
     maxToolRounds;
     mode = "agent";
     modelId;
@@ -309,6 +311,14 @@ export class Agent {
     getModel() {
         return this.modelId;
     }
+    /**
+     * Register (or clear with null) the UI callback that drains messages typed
+     * while a turn is streaming, for mid-turn steering injection. Called from the
+     * TUI when MUONROI_STEER_INJECTION is enabled.
+     */
+    setSteerDrain(fn) {
+        this.steerDrain = fn;
+    }
     getActiveRunId() {
         return this._activeRunId;
     }
@@ -2123,6 +2133,7 @@ export class Agent {
             runDelegation: (request, signal) => self.runDelegation(request, signal),
             readDelegation: (id) => self.readDelegation(id),
             listDelegations: () => self.listDelegations(),
+            drainSteerMessages: () => self.steerDrain?.() ?? [],
             appendCompletedTurn: (user, asst) => self.appendCompletedTurn(user, asst),
             discardAbortedTurn: (user) => self.discardAbortedTurn(user),
             recordUsage: (usage, source, model, shape) => self.recordUsage(usage, source, model, shape),

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

@@ -31,6 +31,7 @@ export interface StallToolResult {
 export declare const STALL_RESCUE_MAX_RESULTS = 8;
 /** Max chars kept per tool output in the digest. */
 export declare const STALL_RESCUE_MAX_CHARS_PER_RESULT = 1500;
+export declare function detectReplyLanguageHint(userText: string): string | null;
 /**
  * Capture a tool result into a capped ring buffer (mutates `buffer`). Keeps the
  * buffer bounded in BOTH count and per-entry size so a long turn can't blow

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

@@ -26,6 +26,22 @@
 export const STALL_RESCUE_MAX_RESULTS = 8;
 /** Max chars kept per tool output in the digest. */
 export const STALL_RESCUE_MAX_CHARS_PER_RESULT = 1500;
+/**
+ * Heuristic: detect the user's reply language from the original request so the
+ * synthesis prompt can carry an EXPLICIT language directive. The base system
+ * prompt's "reply in user's language" rule is normally enough, but after a
+ * stall the rescue path issues a NEW synthesis call whose extra directives
+ * ("use ONLY tool outputs", "no more tools") can crowd out the language rule
+ * — observed live (storyflow_ui session 22661c8de9f2): user wrote Vietnamese,
+ * the rescued answer came back in English. Returns a language name or null
+ * (skip the hint = treat as English-default).
+ */
+const VI_DIACRITIC_RE = /[à-ỹÀ-Ỹ]/;
+export function detectReplyLanguageHint(userText) {
+    if (VI_DIACRITIC_RE.test(userText))
+        return "Vietnamese";
+    return null;
+}
 /**
  * Capture a tool result into a capped ring buffer (mutates `buffer`). Keeps the
  * buffer bounded in BOTH count and per-entry size so a long turn can't blow
@@ -44,7 +60,10 @@ export function pushStallToolResult(buffer, tool, rawText) {
  */
 export function buildStallSynthesisMessages(baseMessages, userText, toolResults) {
     const digest = toolResults.map((r, i) => `[${i + 1}] ${r.tool}:\n${r.text}`).join("\n\n");
-    const content = "The connection to the model stalled before it could finish its answer. " +
+    const lang = detectReplyLanguageHint(userText);
+    const langLine = lang ? `Reply in ${lang} (the user wrote in ${lang}).\n\n` : "";
+    const content = langLine +
+        "The connection to the model stalled before it could finish its answer. " +
         "You already ran the tools below this turn — use ONLY their outputs to give " +
         "your best final answer now. Do NOT call any more tools.\n\n" +
         `Original request:\n${userText}\n\n` +

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { attemptStallRescue, buildStallSynthesisMessages, pushStallToolResult, STALL_RESCUE_MAX_CHARS_PER_RESULT, STALL_RESCUE_MAX_RESULTS, } from "./stall-rescue.js";
+import { attemptStallRescue, buildStallSynthesisMessages, detectReplyLanguageHint, pushStallToolResult, STALL_RESCUE_MAX_CHARS_PER_RESULT, STALL_RESCUE_MAX_RESULTS, } from "./stall-rescue.js";
 describe("pushStallToolResult", () => {
     it("caps the buffer count, keeping the most recent results", () => {
         const buf = [];
@@ -34,6 +34,35 @@ describe("buildStallSynthesisMessages", () => {
         // does not mutate the base array
         expect(base.length).toBe(1);
     });
+    it("prepends a Vietnamese reply directive when user wrote in Vietnamese", () => {
+        const out = buildStallSynthesisMessages([], "sửa thêm popup reload không xoá login", [
+            { tool: "grep", text: "found" },
+        ]);
+        const last = out[out.length - 1];
+        expect(last.content).toMatch(/^Reply in Vietnamese/);
+        expect(last.content).toContain("the user wrote in Vietnamese");
+    });
+    it("omits the language directive for plain English input", () => {
+        const out = buildStallSynthesisMessages([], "find a bug please", [{ tool: "grep", text: "found" }]);
+        const last = out[out.length - 1];
+        expect(last.content).not.toMatch(/^Reply in /);
+    });
+});
+describe("detectReplyLanguageHint", () => {
+    it("detects Vietnamese from any diacritic", () => {
+        expect(detectReplyLanguageHint("tìm")).toBe("Vietnamese");
+        expect(detectReplyLanguageHint("sửa thêm cho tôi")).toBe("Vietnamese");
+        expect(detectReplyLanguageHint("Cập nhật")).toBe("Vietnamese");
+    });
+    it("returns null for ASCII / English text", () => {
+        expect(detectReplyLanguageHint("commit and push please")).toBeNull();
+        expect(detectReplyLanguageHint("")).toBeNull();
+    });
+    it("returns null for a VN-only word with NO diacritics (the heuristic is conservative)", () => {
+        // 'commit push de auto ci/cd len prod nhe' — VN sans diacritics is indistinguishable
+        // from English under this heuristic. Acceptable: false negative, never false positive.
+        expect(detectReplyLanguageHint("commit push de auto ci/cd len prod nhe")).toBeNull();
+    });
 });
 describe("attemptStallRescue", () => {
     it("returns null when there are no tool results (nothing to synthesize)", async () => {

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

@@ -330,6 +330,16 @@ export declare function getProviderStallTimeoutMs(): number;
  * 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

@@ -714,6 +714,18 @@ export function getProviderStallRetries() {
     }
     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

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

@@ -188,4 +188,25 @@ describe("getProviderStallRetries", () => {
         }
     });
 });
+describe("getSteerInjectionEnabled", () => {
+    it("defaults to true when the env var is unset or blank", async () => {
+        vi.unstubAllEnvs();
+        const { getSteerInjectionEnabled } = await import("./settings.js");
+        expect(getSteerInjectionEnabled()).toBe(true);
+        vi.stubEnv("MUONROI_STEER_INJECTION", "");
+        expect(getSteerInjectionEnabled()).toBe(true);
+    });
+    it("returns false only for an explicit '0'", async () => {
+        const { getSteerInjectionEnabled } = await import("./settings.js");
+        vi.stubEnv("MUONROI_STEER_INJECTION", "0");
+        expect(getSteerInjectionEnabled()).toBe(false);
+    });
+    it("returns true for '1' and any other non-'0' value", async () => {
+        const { getSteerInjectionEnabled } = await import("./settings.js");
+        for (const v of ["1", "true", "yes", "on", "xyz"]) {
+            vi.stubEnv("MUONROI_STEER_INJECTION", v);
+            expect(getSteerInjectionEnabled()).toBe(true);
+        }
+    });
+});
 //# sourceMappingURL=settings.test.js.map

package/package.json

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