muonroi-cli 1.8.4 → 1.8.5

package/dist/src/orchestrator/council-manager.js

@@ -11,10 +11,11 @@
 // original orchestrator.ts (see commit history), only `this.xxx` → `this.deps.xxx()`
 // transposition where the field/method originally lived on Agent.
 import { generateText, stepCountIs } from "ai";
-import { getModelByTier, getModelsForProvider } from "../models/registry.js";
+import { getModelsForProvider } from "../models/registry.js";
 import { loadKeyForProvider } from "../providers/keychain.js";
-import { createProviderFactory, detectProviderForModel, resolveModelRuntime, shouldDropParam, } from "../providers/runtime.js";
+import { createProviderFactory, detectProviderForModel, resolveModelRuntime, resolveTemperatureParam, shouldDropParam, } from "../providers/runtime.js";
 import { ALL_PROVIDER_IDS } from "../providers/types.js";
+import { getRoutedModelByTier } from "../router/peak-hour.js";
 import { appendSystemMessage } from "../storage/index.js";
 import { createBuiltinTools } from "../tools/registry.js";
 import { isProviderDisabled } from "../utils/settings.js";
@@ -35,6 +36,12 @@ export class CouncilManager {
     deps;
     // ---- Mutable state (was Agent private fields) ----
     _lastSynthesis = null;
+    /**
+     * Post-debate action the user chose on the last runCouncilV2 (e.g.
+     * "continue_session", "save_exit"). Relayed to the auto-council caller
+     * (tool-engine) so it can honor the choice instead of always continuing.
+     */
+    _lastPostDebateAction = null;
     _isContinuation = false;
     _questionResolvers = new Map();
     _preflightResolvers = new Map();
@@ -52,6 +59,12 @@ export class CouncilManager {
     setLastSynthesis(v) {
         this._lastSynthesis = v;
     }
+    get lastPostDebateAction() {
+        return this._lastPostDebateAction;
+    }
+    setLastPostDebateAction(v) {
+        this._lastPostDebateAction = v;
+    }
     get isContinuation() {
         return this._isContinuation;
     }
@@ -62,7 +75,7 @@ export class CouncilManager {
         this.stats = { calls: 0, startMs: startMs ?? 0 };
     }
     // ---- Public responder API (delegated from Agent.respondToCouncilQuestion etc) ----
-    respondToQuestion(questionId, answer) {
+    respondToQuestion(questionId, answer, questionText) {
         if (process.env.MUONROI_DEBUG_LEADER === "1") {
             process.stderr.write(`[responder] respondToCouncilQuestion: ${JSON.stringify({
                 questionId,
@@ -75,6 +88,14 @@ export class CouncilManager {
         if (resolver) {
             resolver(answer);
             this._questionResolvers.delete(questionId);
+            if (questionText) {
+                import("../gsd/phase-sync.js")
+                    .then(({ appendClarificationToContext }) => {
+                    const cwd = this.deps.getBash().getCwd();
+                    appendClarificationToContext(cwd, questionText, answer);
+                })
+                    .catch(() => { });
+            }
         }
         else {
             // Headless auto-answer: response arrived before the generator registered
@@ -135,7 +156,7 @@ export class CouncilManager {
             system,
             prompt,
             ...(shouldDropParam(runtime, "maxOutputTokens") ? {} : { maxOutputTokens: maxTokens }),
-            ...(shouldDropParam(runtime, "temperature") ? {} : { temperature: 0.7 }),
+            ...resolveTemperatureParam(runtime, 0.7),
             ...(runtime.providerOptions ? { providerOptions: runtime.providerOptions } : {}),
         });
         this.stats.calls++;
@@ -153,7 +174,8 @@ export class CouncilManager {
         const runtime = resolveModelRuntime(provider, modelId);
         // Build tool set with bash, grep, read_file for codebase research
         const researchTools = createBuiltinTools(this.deps.getBash(), this.deps.getMode(), {
-        // research phase intentionally has no runTask/runDelegation handlers
+            // research phase intentionally has no runTask/runDelegation handlers
+            sessionId: this.deps.getSessionId() ?? undefined,
         });
         const systemPrompt = `You are a research specialist. Your job is to gather FACTS about the topic below.\n\n` +
             `## Instructions\n` +
@@ -182,7 +204,7 @@ export class CouncilManager {
                 tools: researchTools,
                 stopWhen: stepCountIs(10),
                 ...(shouldDropParam(runtime, "maxOutputTokens") ? {} : { maxOutputTokens: 4096 }),
-                ...(shouldDropParam(runtime, "temperature") ? {} : { temperature: 0.3 }),
+                ...resolveTemperatureParam(runtime, 0.3),
                 ...(runtime.providerOptions ? { providerOptions: runtime.providerOptions } : {}),
                 ...(signal ? { abortSignal: signal } : {}),
             });
@@ -251,8 +273,9 @@ export class CouncilManager {
     }
     /**
      * Build conversation context for council discussion from current session messages.
-     * Extracts: compaction summary, recent user messages, key decisions.
-     * Limited to ~3000 tokens to avoid excessive cost.
+     * Extracts: compaction summary, recent conversation (user + analytical assistant),
+     * key decisions/outcomes/plans.
+     * Limited to ~8000 tokens (~32K chars) to balance depth vs cost.
      */
     buildContext() {
         const messages = this.deps.getMessages();
@@ -267,34 +290,52 @@ export class CouncilManager {
                 }
             }
         }
-        // 2. Recent user messages (last 3-5 user turns)
-        const userMessages = [];
-        for (let i = messages.length - 1; i >= 0 && userMessages.length < 5; i--) {
+        // 2. Recent conversation turns — user + analytical assistant messages.
+        //    Previously only captured user messages, losing assistant analysis,
+        //    code changes, and decisions made during the session.
+        const conversationTurns = [];
+        for (let i = messages.length - 1; i >= 0 && conversationTurns.length < 8; i--) {
             const msg = messages[i];
             if (msg.role === "user") {
                 const text = typeof msg.content === "string" ? msg.content : extractUserContent(msg.content);
                 if (text.trim()) {
-                    userMessages.unshift(`- ${text.slice(0, 2000).trim()}`);
+                    conversationTurns.unshift(`[User] ${text.slice(0, 3000).trim()}`);
+                }
+            }
+            else if (msg.role === "assistant") {
+                const text = typeof msg.content === "string" ? msg.content : extractUserContent(msg.content);
+                // Only include analytical assistant turns (≥80 chars of text — excludes pure tool-call results)
+                if (text.trim().length >= 80) {
+                    conversationTurns.unshift(`[Assistant] ${text.slice(0, 1500).trim()}`);
                 }
             }
         }
-        if (userMessages.length > 0) {
-            parts.push(`## Recent User Messages\n${userMessages.join("\n")}`);
+        if (conversationTurns.length > 0) {
+            parts.push(`## Recent Conversation\n${conversationTurns.join("\n\n")}`);
         }
-        // 3. Key decisions from council memory if available
-        const councilMemories = [];
+        // 3. Key decisions from system messages (task outcomes, council results, plans, etc.)
+        const decisionMsgs = [];
         for (const msg of messages) {
-            if (msg.role === "system" && typeof msg.content === "string" && msg.content.includes("[Council Memory]")) {
-                councilMemories.push(msg.content);
+            if (msg.role !== "system" || typeof msg.content !== "string")
+                continue;
+            const c = msg.content;
+            if (c.includes("[Council Memory]") ||
+                c.includes("[Council Decision]") ||
+                c.includes("[Council Action Items]") ||
+                c.includes("[Council Plan Update]") ||
+                c.includes("[Decision]") ||
+                c.includes("[Task Completed]") ||
+                c.includes("[NEEDS HUMAN REVIEW]")) {
+                decisionMsgs.push(c);
             }
         }
-        if (councilMemories.length > 0) {
-            parts.push(`## Previous Council Outcomes\n${councilMemories.slice(-2).join("\n\n")}`);
+        if (decisionMsgs.length > 0) {
+            parts.push(`## Key Decisions\n${decisionMsgs.slice(-4).join("\n\n")}`);
         }
         const combined = parts.join("\n\n---\n\n");
-        // Rough token estimate: char/4
-        if (combined.length > 12000) {
-            return `${combined.slice(0, 12000)}\n\n[... context truncated to fit token budget]`;
+        // ~8K token budget (char/4 ≈ token count; cap raised from original 12K chars)
+        if (combined.length > 32000) {
+            return `${combined.slice(0, 32000)}\n\n[... context truncated to fit token budget]`;
         }
         return combined;
     }
@@ -414,7 +455,7 @@ export class CouncilManager {
             if (!isProviderDisabled(p)) {
                 const key = await loadKeyForProvider(p).catch(() => null);
                 if (key) {
-                    const m = getModelByTier("balanced", p);
+                    const m = getRoutedModelByTier("balanced", p);
                     // Guard: getModelByTier may return a model from a different provider
                     // when the preferred provider has no model for the requested tier.
                     if (m && m.provider === p)

package/dist/src/orchestrator/cross-turn-dedup.d.ts

@@ -32,6 +32,12 @@ export interface CrossTurnDedupEntry {
     firstSeenTurn: number;
     /** Tool name that originally produced the content (for the stub). */
     firstSeenToolName: string;
+    /**
+     * Number of SAME-TURN repeat calls seen for this content (0 until the first
+     * in-turn re-call). Used to re-serve content once before hard-stopping a
+     * loop — see the same-turn branch of maybeDedup.
+     */
+    sameTurnRepeats: number;
 }
 export interface CrossTurnDedupStats {
     /** Total dedup hits across the lifetime of this instance. */

package/dist/src/orchestrator/cross-turn-dedup.js

@@ -75,10 +75,30 @@ export class CrossTurnDedup {
         const hash = shortHash(raw);
         const existing = this.cache.get(hash);
         if (existing) {
-            this.hits += 1;
             // Refresh LRU position so frequently-reused outputs survive eviction.
             this.cache.delete(hash);
             this.cache.set(hash, existing);
+            const thisTurn = this.currentTurn || 1;
+            const sameTurnLoop = existing.firstSeenTurn === thisTurn;
+            if (sameTurnLoop) {
+                // O1/O2 fix — a re-call of identical content WITHIN the same turn is a
+                // model loop, not genuine cross-turn reuse. A cheap model (kimi /
+                // deepseek) that re-issues the same read usually did so because it did
+                // NOT retain the earlier result; a bare "reuse" stub then triggers a
+                // WORSE fallback — it re-reads each file singly, inflating fresh input
+                // (measured: batch read → stub → stub → 4 single reads). Re-serve the
+                // content ONCE (passthrough) to satisfy the loop, then hard-stop on any
+                // further in-turn repeat so an infinite loop stays bounded.
+                existing.sameTurnRepeats += 1;
+                if (existing.sameTurnRepeats === 1)
+                    return null;
+                this.hits += 1;
+                return `[${existing.firstSeenToolName} already returned this EXACT result ${existing.sameTurnRepeats + 1}× this turn — it is unchanged and already in the context above. STOP re-calling it; answer from the result you already have.]`;
+            }
+            // Genuine cross-turn reuse (C3): the user prompted again and the agent
+            // re-ran an identical read. The model is not looping, so the short stub
+            // is the right, token-saving behavior.
+            this.hits += 1;
             // G3 — short marker. Old format was ~110 chars; this is ~45.
             return `[dup of ${existing.firstSeenToolName} from turn ${existing.firstSeenTurn} — reuse]`;
         }
@@ -87,6 +107,7 @@ export class CrossTurnDedup {
             content: raw,
             firstSeenTurn: this.currentTurn || 1,
             firstSeenToolName: toolName,
+            sameTurnRepeats: 0,
         });
         this.inserts += 1;
         while (this.cache.size > this.maxEntries) {

package/dist/src/orchestrator/error-utils.d.ts

@@ -27,6 +27,35 @@ export interface ApiErrorForensics {
     urlHost: string | undefined;
     responseBodyTrunc: string | undefined;
     requestParamKeys: string[] | undefined;
+    /** Field-key signature per distinct assistant message shape (PII-safe).
+     * Diagnoses Z.ai 1210 / SiliconFlow 20015 "invalid parameter" rejections
+     * where the culprit is a missing/extra field on assistant turns in a
+     * multi-step tool loop (e.g. reasoning_content present on some turns but
+     * absent on tool-only turns). */
+    assistantFieldKeys: string[] | undefined;
+    /** Per-assistant-message char counts (PII-safe — lengths only, no text).
+     * Distinguishes the "uniform shape but still rejected" failure mode:
+     * H1 cumulative reasoning budget exceeded vs H2 empty reasoning_content
+     * string vs H3 oversized text/tool payload. Set when messages are present. */
+    assistantReasoningLens: number[] | undefined;
+    /** Total reasoning_content chars across assistant messages. */
+    totalReasoningChars: number | undefined;
+    /** Values of scalar SDK-config params (reasoning_effort, verbosity,
+     * tool_choice, response_format, max_tokens, temperature, top_p,
+     * frequency_penalty, presence_penalty, seed, stop, parallel_tool_calls).
+     * PII-safe (generation config, not prompt content) — pinpoints WHICH
+     * param value a provider rejects when the error is generic (Z.ai 1210,
+     * SiliconFlow 20015). */
+    configParamValues: Record<string, unknown> | undefined;
+    /** Per-assistant tool_calls counts (from assistant messages in the request
+     * that failed). Captures H3 for Z.ai 1210: a single assistant response
+     * emitting many parallel tool_calls (e.g. 8 or 12) → the follow-up request
+     * carrying that many role:tool results gets rejected by the coding endpoint
+     * with generic 1210. */
+    assistantToolCallCounts: number[] | undefined;
+    /** Count of role:"tool" messages in the failing request body. Complements
+     * assistantToolCallCounts to show the round-trip payload size for H3. */
+    toolMessageCount: number | undefined;
     isRetryable: boolean | undefined;
 }
 export declare function summarizeApiErrorForLog(error: unknown): ApiErrorForensics | null;

package/dist/src/orchestrator/error-utils.js

@@ -1,16 +1,16 @@
 import { APICallError } from "@ai-sdk/provider";
 const STATUS_MESSAGES = {
-    400: "The request was invalid. This may be caused by an unsupported parameter or model.",
-    401: "Authentication failed. Your API key may be invalid or expired.",
-    403: "Access denied. Your API key does not have permission for this request.",
-    404: "The requested model or endpoint was not found. Check your model name and base URL.",
-    408: "The request timed out. Please try again.",
-    422: "The request could not be processed. Check your message format or parameters.",
-    429: "Rate limit exceeded. Please wait a moment and try again.",
-    500: "The API server encountered an internal error. Please try again later.",
-    502: "The API server is temporarily unavailable. Please try again later.",
-    503: "The API service is temporarily overloaded. Please try again later.",
-    529: "The API service is overloaded. Please try again later.",
+    400: "The provider rejected this request as invalid — usually a parameter or model it doesn't support. Try switching models with `-m <model>`, or simplify the request and retry.",
+    401: "The provider didn't accept your API key — it may be missing, invalid, or expired. Run `keys login <provider>` to set a fresh key, then try again.",
+    403: "Your API key works, but it isn't allowed to make this request. Check your plan or key permissions on the provider's dashboard, or switch models with `-m <model>`.",
+    404: "The provider couldn't find that model or endpoint. Double-check the model name (see `models list`) and your base URL, then try again.",
+    408: "The request took too long and timed out. This is usually temporary — just try again.",
+    422: "The provider understood the request but couldn't process it. Check your message format and parameters, then retry — switching models with `-m <model>` can also help.",
+    429: "You're sending requests faster than the provider allows right now. Wait a moment and try again, or switch to another model with `-m <model>`.",
+    500: "Something went wrong on the provider's servers — not on your end. Give it a moment and try again later.",
+    502: "The provider's servers are temporarily unreachable. This usually clears up on its own — try again in a minute.",
+    503: "The provider is overloaded right now. Give it a minute and retry, or switch models with `-m <model>` in the meantime.",
+    529: "The provider is overloaded right now. Give it a minute and retry, or switch models with `-m <model>` in the meantime.",
 };
 export function isContextLimitError(error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -48,14 +48,45 @@ function routingSuffix(error, ctx) {
     if (status === undefined && /insufficient balance|out of (balance|credit)/i.test(message)) {
         status = 402;
     }
-    if (status === undefined || !ROUTING_STATUSES.has(status))
+    const rawMsg = (error instanceof Error ? error.message : String(error)).toLowerCase();
+    const isConsoleGo = rawMsg.includes("console go") || ctx?.providerId === "opencode-go";
+    const isRateLimitMsg = /rate limit|rate-limited|429|too many requests/i.test(rawMsg);
+    // If we have model context and it's a routing error (by status or by message content)
+    if (!ctx?.modelId)
+        return "";
+    if (!(status !== undefined && ROUTING_STATUSES.has(status)) && !isRateLimitMsg && !isConsoleGo)
         return "";
     const where = `routed to model "${ctx.modelId}"${ctx.providerId ? ` via provider "${ctx.providerId}"` : ""}`;
-    const hint = status === 402
-        ? "out of balance/credit — top up the provider account, or switch model with `-m <model>`."
-        : status === 401 || status === 403
-            ? "not authenticated for this provider — run `keys login <provider>` (or set its API key), or switch model with `-m <model>`."
-            : "rate-limited — wait and retry, or switch model with `-m <model>`.";
+    // A generic "invalid request" rejection — NOT a rate limit. Console Go can
+    // silently re-route (e.g. deepseek-v4-flash → a kimi coding backend) and then
+    // reject a long tool-loop payload with a bare 400 invalid_request. Retrying
+    // as-is never helps (isRetryable:false), so the hint must NOT say "wait and
+    // retry" — it must point at the real levers (switch model / shorten payload).
+    const isInvalidRequest = status === 400 || status === 422;
+    let hint;
+    if (isConsoleGo && (isRateLimitMsg || status === 429)) {
+        hint =
+            "the Console Go proxy hit its own burst rate limit — this is separate from your web 'Rolling Usage' %, so the dashboard can look fine while the proxy still throttles. Wait a moment, use native DeepSeek with `-m deepseek-v4-flash`, or switch provider.";
+    }
+    else if (status === 402) {
+        hint =
+            "this provider account is out of balance or credit. Top it up on the provider's site, or switch to another model with `-m <model>`.";
+    }
+    else if (status === 401 || status === 403) {
+        hint =
+            "you're not authenticated for this provider. Run `keys login <provider>` (or set its API key), or switch to another model with `-m <model>`.";
+    }
+    else if (isInvalidRequest) {
+        hint =
+            "the provider rejected this request as invalid — often a param or backend model it doesn't support, or a tool-loop payload the routed model can't accept (some gateways re-route to a different backend than the one you picked). Switch models with `-m <model>` or shorten/simplify the request; retrying it unchanged won't help.";
+    }
+    else if (isRateLimitMsg || status === 429) {
+        hint = "the provider is rate-limiting you. Wait a moment and retry, or switch to another model with `-m <model>`.";
+    }
+    else {
+        hint =
+            "the routed model or provider couldn't complete this request. Switch to another model with `-m <model>`, or try again.";
+    }
     return ` [${where}] — ${hint}`;
 }
 export function humanizeApiError(error, ctx) {
@@ -63,7 +94,7 @@ export function humanizeApiError(error, ctx) {
 }
 function humanizeApiErrorBase(error) {
     if (isMalformedFunctionNameError(error)) {
-        return "Model emitted a malformed tool call (function.name missing). Skipping this turn — please retry or rephrase.";
+        return "The model produced a malformed tool call (its function name was missing), so this turn was skipped. Just send your request again — rephrasing slightly often helps.";
     }
     if (APICallError.isInstance(error)) {
         const detail = extractResponseDetail(error.responseBody);
@@ -75,7 +106,8 @@ function humanizeApiErrorBase(error) {
         // For 5xx prefer the canned "retry later" message + the status code; keep a
         // body detail only when it actually adds information.
         if (status && status >= 500) {
-            const canned = STATUS_MESSAGES[status] ?? "The API server returned an error. Please try again later.";
+            const canned = STATUS_MESSAGES[status] ??
+                "The provider's servers returned an error — not something you did. Wait a bit and try again.";
             if (!detail || isOpaqueDetail(detail))
                 return `${canned} (HTTP ${status})`;
             return `${detail} (HTTP ${status})`;
@@ -93,9 +125,9 @@ function humanizeApiErrorBase(error) {
         const toolMatch = raw.match(/Tool\s+"?(\w+)"?\s+(?:is\s+)?not\s+found/i) ?? raw.match(/tool\s+(\w+)/i);
         const toolName = toolMatch?.[1] ?? "that tool";
         if (toolName === "search_web") {
-            return `"search_web" is not available. Use bash with curl for web requests, or delegate to an explore agent for research.`;
+            return `"search_web" isn't available here. For web requests, use bash with curl instead, or hand the research off to an explore agent.`;
         }
-        return `Tool "${toolName}" is not available. Check the TOOLS list in the system prompt for supported tools.`;
+        return `Tool "${toolName}" isn't available in this session. Check the TOOLS list in the system prompt to see which tools you can use.`;
     }
     return stripped;
 }
@@ -135,9 +167,50 @@ export function summarizeApiErrorForLog(error) {
     catch {
         urlHost = undefined;
     }
-    let requestParamKeys;
-    if (error.requestBodyValues && typeof error.requestBodyValues === "object") {
-        requestParamKeys = Object.keys(error.requestBodyValues).sort();
+    const bodyValues = error.requestBodyValues && typeof error.requestBodyValues === "object"
+        ? error.requestBodyValues
+        : undefined;
+    const requestParamKeys = bodyValues ? Object.keys(bodyValues).sort() : undefined;
+    // Collect the distinct field-key signature across assistant wire messages.
+    // Only key NAMES are persisted — values may contain secrets/PII.
+    let assistantFieldKeys;
+    let assistantReasoningLens;
+    let assistantToolCallCounts;
+    let totalReasoningChars = 0;
+    let toolMessageCount = 0;
+    if (bodyValues && Array.isArray(bodyValues.messages)) {
+        const signatures = new Set();
+        const rcLens = [];
+        const tcLens = [];
+        for (const m of bodyValues.messages) {
+            const msg = m;
+            if (msg?.role === "tool") {
+                toolMessageCount++;
+                continue;
+            }
+            if (msg?.role !== "assistant")
+                continue;
+            const sig = Object.keys(msg ?? {})
+                .sort()
+                .join(",");
+            signatures.add(sig);
+            const rc = msg?.reasoning_content;
+            if (typeof rc === "string") {
+                rcLens.push(rc.length);
+                totalReasoningChars += rc.length;
+            }
+            else {
+                rcLens.push(-1); // marker: reasoning_content missing/non-string on this turn
+            }
+            const tcs = Array.isArray(msg?.tool_calls) ? msg.tool_calls.length : 0;
+            tcLens.push(tcs);
+        }
+        if (signatures.size > 0)
+            assistantFieldKeys = [...signatures].sort();
+        if (rcLens.length > 0)
+            assistantReasoningLens = rcLens;
+        if (tcLens.length > 0)
+            assistantToolCallCounts = tcLens;
     }
     const body = typeof error.responseBody === "string" ? error.responseBody : undefined;
     const responseBodyTrunc = body && body.length > RESPONSE_BODY_CAP ? `${body.slice(0, RESPONSE_BODY_CAP)}…[truncated]` : body;
@@ -146,8 +219,43 @@ export function summarizeApiErrorForLog(error) {
         urlHost,
         responseBodyTrunc,
         requestParamKeys,
+        assistantFieldKeys,
+        assistantReasoningLens,
+        totalReasoningChars: assistantReasoningLens ? totalReasoningChars : undefined,
+        configParamValues: bodyValues ? extractConfigParamValues(bodyValues) : undefined,
+        assistantToolCallCounts,
+        toolMessageCount: bodyValues && Array.isArray(bodyValues.messages) ? toolMessageCount : undefined,
         isRetryable: error.isRetryable,
     };
 }
+/**
+ * Scalar SDK-config params whose VALUES are PII-safe (generation config, not
+ * user prompt content). See `ApiErrorForensics.configParamValues`.
+ * Includes parallel_tool_calls because Z.ai GLM coding endpoint rejects
+ * high-parallelism tool call batches (observed 8-12 in one assistant turn)
+ * with generic 1210; capturing the value helps confirm if SDK overrode it.
+ */
+const CONFIG_PARAM_KEYS = [
+    "reasoning_effort",
+    "verbosity",
+    "tool_choice",
+    "response_format",
+    "max_tokens",
+    "temperature",
+    "top_p",
+    "frequency_penalty",
+    "presence_penalty",
+    "seed",
+    "stop",
+    "parallel_tool_calls",
+];
+function extractConfigParamValues(body) {
+    const out = {};
+    for (const k of CONFIG_PARAM_KEYS) {
+        if (k in body)
+            out[k] = body[k] ?? null;
+    }
+    return out;
+}
 export { extractResponseDetail, STATUS_MESSAGES };
 //# sourceMappingURL=error-utils.js.map

package/dist/src/orchestrator/grounding-check.js

@@ -41,6 +41,30 @@ const COUNT_RE = new RegExp(`\\b(\\d{1,3}(?:,\\d{3})+|\\d{2,})\\b(?:\\s+(?:\\w+\
 const NOUN_SEP_NUM_RE = new RegExp(`\\b(?:${COUNT_NOUN})\\b[^.\\n:=]{0,40}?[:=]\\s*(\\d{1,3}(?:,\\d{3})+|\\d{2,})\\b`, "gi");
 // filename.ext:line — basename only (the char class excludes "/").
 const FILELINE_RE = /\b([\w.-]+\.[a-z]{1,5}):(\d+)\b/gi;
+// read_file emits a header `[<path>: lines A-B of TOTAL]` (src/tools/file.ts:75).
+// TOTAL is always the FULL file length (not the slice end B), so it is the
+// ground truth for "does line N exist in this file". Path may use "/" or "\";
+// the basename char class excludes both, so it captures just "planner.ts".
+const READ_HEADER_RE = /([\w.-]+\.[a-z]{1,5}):\s*lines\s+\d+-\d+\s+of\s+(\d+)/gi;
+/**
+ * Map basename → largest known full-file line count, parsed from read_file
+ * headers in the corpus. Used to catch a file:line that names a REAL (read)
+ * file but a FABRICATED line number beyond the file's length — the failure the
+ * basename-only check misses.
+ */
+function parseReadLineCounts(corpus) {
+    const totals = new Map();
+    for (const m of corpus.matchAll(READ_HEADER_RE)) {
+        const base = m[1].toLowerCase();
+        const total = Number.parseInt(m[2], 10);
+        if (!Number.isFinite(total))
+            continue;
+        const prev = totals.get(base);
+        if (prev === undefined || total > prev)
+            totals.set(base, total);
+    }
+    return totals;
+}
 // Hedge markers immediately before a number mean it is an estimate, not a fact.
 const HEDGE_RE = /(~|≈|\babout\b|\bapprox(?:imately)?\b|\broughly\b|\baround\b|\bnearly\b|\best\.?\b)\s*$/i;
 function stripCommas(s) {
@@ -56,6 +80,7 @@ export function findUnverifiedClaims(finalText, corpus) {
         return [];
     const corpusNorm = stripCommas(corpus).toLowerCase();
     const corpusLower = corpus.toLowerCase();
+    const readTotals = parseReadLineCounts(corpus);
     const out = [];
     const seen = new Set();
     const push = (claim) => {
@@ -103,8 +128,21 @@ export function findUnverifiedClaims(finalText, corpus) {
         if (idx > 0 && finalText[idx - 1] === "/")
             continue;
         const basename = m[1];
+        const lineNo = Number.parseInt(m[2], 10);
+        const knownTotal = readTotals.get(basename.toLowerCase());
+        // Provably-fabricated line: the file WAS read this turn (header parsed), but
+        // the cited line exceeds its real length. Deterministic — flag even though
+        // the basename appears in the corpus (the basename check below would pass).
+        if (knownTotal !== undefined && Number.isFinite(lineNo) && lineNo > knownTotal) {
+            push({
+                kind: "fileline",
+                value: `${basename}:${m[2]}`,
+                text: `${basename}:${m[2]} (file has ${knownTotal} lines)`,
+            });
+            continue;
+        }
         if (corpusLower.includes(basename.toLowerCase()))
-            continue; // file was read/grepped → verified
+            continue; // file was read/grepped & in-bounds → verified
         push({ kind: "fileline", value: `${basename}:${m[2]}`, text: `${basename}:${m[2]}` });
     }
     return out.slice(0, MAX_CLAIMS);