muonroi-cli 1.8.4 → 1.9.0

package/dist/src/orchestrator/compaction.js

@@ -1,7 +1,8 @@
 import { generateText } from "ai";
 import { isMetaAnalysisPrompt } from "../pil/layer6-output.js";
 import { getProviderCapabilities } from "../providers/capabilities.js";
-import { requireRuntimeProvider, resolveModelRuntime } from "../providers/runtime.js";
+import { requireRuntimeProvider, resolveModelRuntime, resolveTemperatureParam } from "../providers/runtime.js";
+import { logger } from "../utils/logger.js";
 import { COMPACT_PROPOSER_SYSTEM_PROMPT } from "./compaction-proposer-prompt.js";
 import { containsEncryptedReasoning } from "./reasoning.js";
 import { countTokens } from "./token-counter.js";
@@ -10,9 +11,9 @@ import { countTokens } from "./token-counter.js";
  * The model sees the current messages and decides whether compaction is needed at all.
  * Returns null if the proposer call fails (caller should fall back gracefully).
  */
-export async function proposeCompaction(provider, modelId, messages, signal) {
+export async function proposeCompaction(modelId, messages, signal) {
     try {
-        const runtime = resolveModelRuntime(provider, modelId);
+        const runtime = resolveModelRuntime(modelId);
         const compactCaps = getProviderCapabilities(requireRuntimeProvider(runtime));
         const serialized = serializeConversation(messages);
         const result = await generateText({
@@ -21,28 +22,35 @@ export async function proposeCompaction(provider, modelId, messages, signal) {
             prompt: `Current conversation messages:\n\n${serialized}\n\nDecide if compaction is needed and what to keep/drop/summarize. Return strict JSON.`,
             abortSignal: signal,
             maxRetries: 1,
-            temperature: 0.1,
+            ...resolveTemperatureParam(runtime, 0.1),
             ...(!compactCaps.acceptsParam("maxOutputTokens", runtime.modelInfo) ? {} : { maxOutputTokens: 2048 }),
             ...(runtime.providerOptions ? { providerOptions: runtime.providerOptions } : {}),
         });
         const text = result.text.trim();
-        // Attempt to parse top-level JSON object. The model might wrap in markdown fences — strip those.
-        const jsonStr = text.replace(/^```(?:json)?\s*|\s*```$/gi, "").trim();
-        const parsed = JSON.parse(jsonStr);
+        // Attempt to parse JSON object robustly, even if the model wraps it in conversational text or markdown fences.
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            logger.warn("orchestrator", "Failed to extract JSON from proposer output", { text });
+            return null;
+        }
+        const parsed = JSON.parse(jsonMatch[0]);
         // Validate shape
         if (typeof parsed.shouldCompact !== "boolean" || !Array.isArray(parsed.actions)) {
+            logger.warn("orchestrator", "Invalid JSON shape from proposer", { parsed });
             return null;
         }
         // Validate each action
         for (const action of parsed.actions) {
             if (typeof action.messageIndex !== "number" || !["keep", "drop", "summarize"].includes(action.action)) {
+                logger.warn("orchestrator", "Invalid action shape from proposer", { action });
                 return null;
             }
         }
         return parsed;
     }
-    catch {
+    catch (err) {
         // Proposer failure is non-fatal — caller falls back to heuristic or no-compact
+        logger.warn("orchestrator", "Proposer failure", { error: err });
         return null;
     }
 }
@@ -347,6 +355,18 @@ export function estimateConversationTokens(systemPrompt, messages, inFlightText
 export function shouldCompactContext(contextTokens, contextWindow, settings) {
     return contextTokens > contextWindow - settings.reserveTokens;
 }
+/**
+ * Cross-turn anti-thrash guard: true when a post-turn compaction should be
+ * SKIPPED because too few new tokens have accumulated since the last
+ * compaction's `tokensAfter` — i.e. the cache-reset cost would not be
+ * amortized (observed: session ff932f8568e8 re-compacted after only ~14K
+ * new tokens against a 20K floor).
+ *
+ * `lastAfter === null` means no prior compaction this session — never skip.
+ */
+export function isCompactionThrash(tokens, lastAfter, minNew) {
+    return lastAfter !== null && tokens - lastAfter < minNew;
+}
 function isValidCutPoint(message) {
     return message.role !== "tool";
 }
@@ -497,7 +517,7 @@ function readUsage(usage) {
             : 0;
     return { promptTokens: prompt, completionTokens: completion };
 }
-async function summarizeConversation(provider, modelId, messages, reserveTokens, customInstructions, previousSummary, promptOverride, signal) {
+async function summarizeConversation(modelId, messages, reserveTokens, customInstructions, previousSummary, promptOverride, signal) {
     const serialized = serializeConversation(messages);
     const promptParts = [serialized];
     // Improvement from session df2dbb878984 analysis: detect meta-analysis (self-evaluation of agent/PIL)
@@ -515,7 +535,7 @@ async function summarizeConversation(provider, modelId, messages, reserveTokens,
     if (customInstructions?.trim()) {
         promptParts.push(`Additional focus: ${customInstructions.trim()}`);
     }
-    const runtime = resolveModelRuntime(provider, modelId);
+    const runtime = resolveModelRuntime(modelId);
     const compactCaps = getProviderCapabilities(requireRuntimeProvider(runtime));
     const result = await generateText({
         model: runtime.model,
@@ -523,7 +543,7 @@ async function summarizeConversation(provider, modelId, messages, reserveTokens,
         prompt: promptParts.filter(Boolean).join("\n\n"),
         abortSignal: signal,
         maxRetries: 0,
-        temperature: 0.2,
+        ...resolveTemperatureParam(runtime, 0.2),
         ...(!compactCaps.acceptsParam("maxOutputTokens", runtime.modelInfo) ? {} : { maxOutputTokens: effectiveMax }),
         ...(runtime.providerOptions ? { providerOptions: runtime.providerOptions } : {}),
     });
@@ -538,14 +558,14 @@ function addUsage(a, b) {
         completionTokens: a.completionTokens + b.completionTokens,
     };
 }
-export async function generateCompactionSummary(provider, modelId, preparation, customInstructions, signal) {
+export async function generateCompactionSummary(modelId, preparation, customInstructions, signal) {
     const { messagesToSummarize, turnPrefixMessages, isSplitTurn, previousSummary, settings } = preparation;
     if (isSplitTurn && turnPrefixMessages.length > 0) {
         const [historyResult, prefixResult] = await Promise.all([
             messagesToSummarize.length > 0
-                ? summarizeConversation(provider, modelId, messagesToSummarize, settings.reserveTokens, customInstructions, previousSummary, undefined, signal)
+                ? summarizeConversation(modelId, messagesToSummarize, settings.reserveTokens, customInstructions, previousSummary, undefined, signal)
                 : Promise.resolve({ summary: previousSummary?.trim() || "", usage: emptyUsage() }),
-            summarizeConversation(provider, modelId, turnPrefixMessages, settings.reserveTokens, undefined, undefined, TURN_PREFIX_SUMMARIZATION_PROMPT, signal),
+            summarizeConversation(modelId, turnPrefixMessages, settings.reserveTokens, undefined, undefined, TURN_PREFIX_SUMMARIZATION_PROMPT, signal),
         ]);
         const usage = addUsage(historyResult.usage, prefixResult.usage);
         if (historyResult.summary && prefixResult.summary) {
@@ -553,6 +573,6 @@ export async function generateCompactionSummary(provider, modelId, preparation,
         }
         return { summary: (historyResult.summary || prefixResult.summary).trim(), usage };
     }
-    return summarizeConversation(provider, modelId, messagesToSummarize, settings.reserveTokens, customInstructions, previousSummary, undefined, signal);
+    return summarizeConversation(modelId, messagesToSummarize, settings.reserveTokens, customInstructions, previousSummary, undefined, signal);
 }
 //# sourceMappingURL=compaction.js.map

package/dist/src/orchestrator/council-manager.d.ts

@@ -36,6 +36,12 @@ export interface CouncilManagerDeps {
 export declare class CouncilManager {
     private deps;
     private _lastSynthesis;
+    /**
+     * 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.
+     */
+    private _lastPostDebateAction;
     private _isContinuation;
     private _questionResolvers;
     private _preflightResolvers;
@@ -49,10 +55,12 @@ export declare class CouncilManager {
     constructor(deps: CouncilManagerDeps);
     get lastSynthesis(): string | null;
     setLastSynthesis(v: string | null): void;
+    get lastPostDebateAction(): string | null;
+    setLastPostDebateAction(v: string | null): void;
     get isContinuation(): boolean;
     setContinuation(v: boolean): void;
     resetStats(startMs?: number): void;
-    respondToQuestion(questionId: string, answer: string): void;
+    respondToQuestion(questionId: string, answer: string, questionText?: string): void;
     respondToPreflight(preflightId: string, approved: boolean): void;
     createQuestionResponder(): (questionId: string) => Promise<string>;
     createPreflightResponder(): (preflightId: string) => Promise<boolean>;
@@ -84,8 +92,9 @@ export declare class CouncilManager {
     generateRoundSummary(exchangeLogs: Map<string, string[]>, topic: string, round: number, modelId: string): Promise<string>;
     /**
      * 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(): string;
     parseOutcome(synthesisText: string, _topic: string): CouncilOutcome | null;

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

@@ -11,14 +11,15 @@
 // 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";
-import { COUNCIL_COLOR_BG, COUNCIL_COLOR_RESET, COUNCIL_ROLE_COLORS, } from "./agent-options.js";
+import { COUNCIL_COLOR_BG, COUNCIL_COLOR_RESET, COUNCIL_ROLE_COLORS } from "./agent-options.js";
 import { extractUserContent, getCompactionSummaryText, isCompactionSummaryMessage } from "./compaction.js";
 /**
  * CouncilManager — extracted council subsystem.
@@ -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
@@ -128,14 +149,14 @@ export class CouncilManager {
     async generate(modelId, system, prompt, maxTokens = 2048) {
         const providerId = detectProviderForModel(modelId);
         const key = await loadKeyForProvider(providerId);
-        const provider = createCouncilProvider(providerId, key);
-        const runtime = resolveModelRuntime(provider, modelId);
+        ensureCouncilProvider(providerId, key);
+        const runtime = resolveModelRuntime(modelId);
         const { text } = await generateText({
             model: runtime.model,
             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++;
@@ -149,11 +170,12 @@ export class CouncilManager {
     async research(modelId, topic, conversationContext, signal) {
         const providerId = detectProviderForModel(modelId);
         const key = await loadKeyForProvider(providerId);
-        const provider = createCouncilProvider(providerId, key);
-        const runtime = resolveModelRuntime(provider, modelId);
+        ensureCouncilProvider(providerId, key);
+        const runtime = resolveModelRuntime(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)
@@ -463,11 +504,12 @@ export class CouncilManager {
     static COLOR_RESET = COUNCIL_COLOR_RESET;
 }
 /**
- * Internal: build a provider factory using the shared runtime factory.
+ * Internal: register a provider factory using the shared runtime factory, so a
+ * council sub-call on a provider the session never built can still resolve.
  * Mirrors `createProvider` in orchestrator.ts to keep council sub-calls
  * decoupled from Agent state.
  */
-function createCouncilProvider(providerId, apiKey, baseURL) {
-    return createProviderFactory(providerId, { apiKey, baseURL }).factory;
+function ensureCouncilProvider(providerId, apiKey, baseURL) {
+    createProviderFactory(providerId, { apiKey, baseURL });
 }
 //# sourceMappingURL=council-manager.js.map

package/dist/src/orchestrator/council-request.d.ts

@@ -0,0 +1,49 @@
+/**
+ * src/orchestrator/council-request.ts
+ *
+ * Process-global one-shot channel for an AGENT-initiated council convening.
+ *
+ * The `convene_council` tool (src/tools/registry.ts) sets a pending request when
+ * the model decides THIS request warrants a multi-model debate; the tool-engine
+ * consumes it from the OUTER restart loop after a stream drain (NOT solely via
+ * dynamicStopWhen — a phase-1 SAMR step ends on stepCountIs(1) and never
+ * evaluates the stop hook), runs `runCouncilV2({ convenePath: true })`, splices
+ * the synthesis into the convene tool's tool_result, and restarts streamText so
+ * the model reads the conclusion as the tool's result and continues the turn.
+ *
+ * Modelled on compact-request.ts. Two differences that matter for correctness:
+ *   1. It carries the `toolCallId` of the convene_council call so the tool-engine
+ *      can (a) confirm the pending request actually belongs to THIS drain's
+ *      messages before running council — guarding against a nested sub-session
+ *      whose convene call would otherwise be consumed by the parent loop — and
+ *      (b) locate the exact tool-result to replace with the synthesis.
+ *   2. `peekCouncilConveneToolCallId()` is a NON-consuming read for that guard;
+ *      the flag is only cleared by `consumeCouncilConvene()` (on run) or by the
+ *      turn-teardown `finally` (discard) so a request can never leak into the
+ *      next user turn when the convene call shared a step with a terminal
+ *      `respond_*` tool.
+ *
+ * Single-active-turn assumption (inherited from compact-request.ts): the TUI
+ * streams one turn at a time, so a process-global slot cannot cross-talk between
+ * concurrent user turns.
+ */
+export interface CouncilConveneRequestState {
+    /** Model-supplied justification for convening (the specific tradeoff/decision at stake). */
+    reason: string | null;
+    /** Tool-call id of the convene_council call, so the tool-engine can match + replace its result. */
+    toolCallId: string | null;
+}
+/** Queue a council convening to run before the model's next step. */
+export declare function requestCouncilConvene(reason?: string | null, toolCallId?: string | null): void;
+/** True when a council convening is queued (non-consuming peek). */
+export declare function hasPendingCouncilConvene(): boolean;
+/**
+ * Non-consuming read of the pending request's toolCallId. Used by the tool-engine
+ * to check whether the pending convene belongs to THIS drain's response.messages
+ * before committing to a (possibly expensive, possibly wrong-frame) debate.
+ */
+export declare function peekCouncilConveneToolCallId(): string | null;
+/** Consume the pending request exactly once (returns null when none queued). */
+export declare function consumeCouncilConvene(): CouncilConveneRequestState | null;
+/** Test hook — clear any queued request. */
+export declare function __resetCouncilConveneForTests(): void;

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

@@ -0,0 +1,62 @@
+/**
+ * src/orchestrator/council-request.ts
+ *
+ * Process-global one-shot channel for an AGENT-initiated council convening.
+ *
+ * The `convene_council` tool (src/tools/registry.ts) sets a pending request when
+ * the model decides THIS request warrants a multi-model debate; the tool-engine
+ * consumes it from the OUTER restart loop after a stream drain (NOT solely via
+ * dynamicStopWhen — a phase-1 SAMR step ends on stepCountIs(1) and never
+ * evaluates the stop hook), runs `runCouncilV2({ convenePath: true })`, splices
+ * the synthesis into the convene tool's tool_result, and restarts streamText so
+ * the model reads the conclusion as the tool's result and continues the turn.
+ *
+ * Modelled on compact-request.ts. Two differences that matter for correctness:
+ *   1. It carries the `toolCallId` of the convene_council call so the tool-engine
+ *      can (a) confirm the pending request actually belongs to THIS drain's
+ *      messages before running council — guarding against a nested sub-session
+ *      whose convene call would otherwise be consumed by the parent loop — and
+ *      (b) locate the exact tool-result to replace with the synthesis.
+ *   2. `peekCouncilConveneToolCallId()` is a NON-consuming read for that guard;
+ *      the flag is only cleared by `consumeCouncilConvene()` (on run) or by the
+ *      turn-teardown `finally` (discard) so a request can never leak into the
+ *      next user turn when the convene call shared a step with a terminal
+ *      `respond_*` tool.
+ *
+ * Single-active-turn assumption (inherited from compact-request.ts): the TUI
+ * streams one turn at a time, so a process-global slot cannot cross-talk between
+ * concurrent user turns.
+ */
+let pending = null;
+/** Queue a council convening to run before the model's next step. */
+export function requestCouncilConvene(reason, toolCallId) {
+    const trimmedReason = typeof reason === "string" ? reason.trim() : "";
+    const trimmedId = typeof toolCallId === "string" ? toolCallId.trim() : "";
+    pending = {
+        reason: trimmedReason.length > 0 ? trimmedReason : null,
+        toolCallId: trimmedId.length > 0 ? trimmedId : null,
+    };
+}
+/** True when a council convening is queued (non-consuming peek). */
+export function hasPendingCouncilConvene() {
+    return pending !== null;
+}
+/**
+ * Non-consuming read of the pending request's toolCallId. Used by the tool-engine
+ * to check whether the pending convene belongs to THIS drain's response.messages
+ * before committing to a (possibly expensive, possibly wrong-frame) debate.
+ */
+export function peekCouncilConveneToolCallId() {
+    return pending?.toolCallId ?? null;
+}
+/** Consume the pending request exactly once (returns null when none queued). */
+export function consumeCouncilConvene() {
+    const p = pending;
+    pending = null;
+    return p;
+}
+/** Test hook — clear any queued request. */
+export function __resetCouncilConveneForTests() {
+    pending = null;
+}
+//# sourceMappingURL=council-request.js.map

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;