muonroi-cli 1.3.4 → 1.4.1

package/dist/src/orchestrator/__tests__/stream-runner.test.js

@@ -4,8 +4,14 @@
 // runtime), DI surface invariants. Stream integration is covered by
 // tests/harness/cost-leak-{f1,g1,b3,b4,c3}.spec.ts — those exercise real
 // streamText with MockLanguageModelV3.
-import { describe, expect, it } from "vitest";
+import { beforeAll, describe, expect, it } from "vitest";
+import { getTestModelForProvider, getTestModels, getTestProviders } from "../../__test-helpers__/catalog-fixtures.js";
+import { loadCatalog } from "../../models/registry.js";
+import { computePromptCacheKey } from "../../providers/runtime.js";
 import { StreamRunner } from "../stream-runner.js";
+beforeAll(async () => {
+    await loadCatalog();
+});
 function makeBashStub() {
     return {
         getCwd: () => process.cwd(),
@@ -14,11 +20,13 @@ function makeBashStub() {
     };
 }
 function makeDeps(overrides = {}) {
+    const testModels = getTestModels();
+    const testProviders = getTestProviders();
     return {
         getProvider: () => (() => null),
-        resolveModelForTask: () => "deepseek-ai/DeepSeek-V4-Flash",
-        getModelId: () => "deepseek-ai/DeepSeek-V4-Flash",
-        getProviderId: () => "siliconflow",
+        resolveModelForTask: () => testModels.fast,
+        getModelId: () => testModels.fast,
+        getProviderId: () => testProviders.default,
         getBash: () => makeBashStub(),
         getMaxToolRounds: () => 50,
         getMaxTokens: () => 8192,
@@ -28,6 +36,7 @@ function makeDeps(overrides = {}) {
         recordUsage: () => { },
         setCurrentCallId: () => { },
         setLastProviderOptionsShape: () => { },
+        getSessionId: () => undefined,
         runTaskRequestBatch: async () => ({
             success: false,
             output: "batch path not exercised in this test",
@@ -64,6 +73,69 @@ describe("StreamRunner — setup short-circuit paths", () => {
         }
     });
 });
+describe("StreamRunner — cheap-model steering on sub-agent system prompt", () => {
+    // The sub-agent prompt must carry the SAME front-loaded steering stack as the
+    // top-level turn for fast-tier models (regression: previously only the
+    // playbook was injected, leaving the sub-agent without the anti-ramble
+    // workbook or the shell directive). Final prompt order: [ENV] → [CRITICAL
+    // playbook] → [CONVERGENCE workbook] → base.
+    //
+    // `explore` is used because its childMode is "ask" (no MCP load) so setup()
+    // completes synchronously without spawning anything.
+    it("front-loads [ENV] → [CRITICAL] → [CONVERGENCE] for a fast-tier explore sub-agent", async () => {
+        const runner = new StreamRunner(makeDeps());
+        const outcome = await runner.setup({ agent: "explore", description: "scan", prompt: "find auth wiring" });
+        expect(outcome.kind).toBe("prepared");
+        if (outcome.kind !== "prepared")
+            return;
+        const sys = outcome.prepared.childSystem;
+        const iEnv = sys.indexOf("[ENV]");
+        const iCritical = sys.indexOf("[CRITICAL TOOL-USE RULES");
+        const iConvergence = sys.indexOf("[CONVERGENCE");
+        expect(sys.startsWith("[ENV]")).toBe(true);
+        expect(iEnv).toBeGreaterThanOrEqual(0);
+        expect(iCritical).toBeGreaterThan(iEnv);
+        expect(iConvergence).toBeGreaterThan(iCritical);
+        // explore → analyze workbook addendum.
+        expect(sys).toMatch(/do not read the whole codebase/i);
+    });
+});
+describe("StreamRunner — F1 promptCacheKey parity on the sub-agent path", () => {
+    // The top-level turn derives a stable openai.promptCacheKey per turn via
+    // buildTurnProviderOptions({ sessionId }) so every tool round in a session
+    // routes to the same cache node (message-processor.ts). The sub-agent path
+    // previously used only resolve-time childRuntime.providerOptions, which has
+    // NO promptCacheKey — so every explore/verify OpenAI call auto-hashed its
+    // prompt and fragmented the cache, re-billing the unchanging prefix. setup()
+    // must now thread the session id so sub-agents get the SAME stable key.
+    it("threads sessionId → openai.promptCacheKey onto the sub-agent providerOptions", async () => {
+        const sessionId = "sess-fixed-for-f1-parity";
+        const openaiModel = getTestModelForProvider("openai", "fast");
+        const runner = new StreamRunner(makeDeps({
+            resolveModelForTask: () => openaiModel,
+            getSessionId: () => sessionId,
+        }));
+        const outcome = await runner.setup({ agent: "explore", description: "scan", prompt: "find auth wiring" });
+        expect(outcome.kind).toBe("prepared");
+        if (outcome.kind !== "prepared")
+            return;
+        const opts = outcome.prepared.childProviderOptions;
+        expect(opts?.openai?.promptCacheKey).toBe(computePromptCacheKey(sessionId));
+    });
+    it("omits promptCacheKey when there is no session id (headless one-shot)", async () => {
+        const openaiModel = getTestModelForProvider("openai", "fast");
+        const runner = new StreamRunner(makeDeps({
+            resolveModelForTask: () => openaiModel,
+            getSessionId: () => undefined,
+        }));
+        const outcome = await runner.setup({ agent: "explore", description: "scan", prompt: "find auth wiring" });
+        expect(outcome.kind).toBe("prepared");
+        if (outcome.kind !== "prepared")
+            return;
+        const opts = outcome.prepared.childProviderOptions;
+        expect(opts?.openai?.promptCacheKey).toBeUndefined();
+    });
+});
 describe("StreamRunner — DI surface", () => {
     it("constructs without invoking any dep callbacks", () => {
         let touched = 0;
@@ -86,6 +158,7 @@ describe("StreamRunner — DI surface", () => {
             recordUsage: trip,
             setCurrentCallId: trip,
             setLastProviderOptionsShape: trip,
+            getSessionId: trip,
             runTaskRequestBatch: trip,
         });
         expect(runner).toBeInstanceOf(StreamRunner);

package/dist/src/orchestrator/__tests__/sub-agent-model-tier.test.d.ts

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

package/dist/src/orchestrator/__tests__/sub-agent-model-tier.test.js

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import { resolveModelForTask, TASK_TIER_PREFS } from "../sub-agent-model-tier.js";
+// A fake provider catalog: "acme" has a full ladder; "premOnly" has premium only.
+function makeLookup() {
+    const table = {
+        acme: {
+            fast: { id: "acme-fast", provider: "acme" },
+            balanced: { id: "acme-balanced", provider: "acme" },
+            premium: { id: "acme-premium", provider: "acme" },
+        },
+        premOnly: {
+            premium: { id: "prem-premium", provider: "premOnly" },
+        },
+    };
+    return (tier, preferProvider) => (preferProvider ? table[preferProvider]?.[tier] : undefined);
+}
+describe("sub-agent model tier policy", () => {
+    const lookup = makeLookup();
+    it("downgrades a general sub-agent to balanced (gap #2 fix)", () => {
+        expect(resolveModelForTask("general", "acme", "acme-premium", lookup)).toBe("acme-balanced");
+    });
+    it("keeps verify on premium (rigor over cost)", () => {
+        expect(resolveModelForTask("verify", "acme", "acme-premium", lookup)).toBe("acme-premium");
+    });
+    it("explore prefers balanced", () => {
+        expect(resolveModelForTask("explore", "acme", "acme-premium", lookup)).toBe("acme-balanced");
+    });
+    it("compact/title prefer the cheapest tier", () => {
+        expect(resolveModelForTask("compact", "acme", "acme-premium", lookup)).toBe("acme-fast");
+        expect(resolveModelForTask("title", "acme", "acme-premium", lookup)).toBe("acme-fast");
+    });
+    it("falls back to the parent model when the provider has no cheaper tier", () => {
+        // premOnly has only premium → general's [balanced, premium] resolves premium.
+        expect(resolveModelForTask("general", "premOnly", "prem-premium", lookup)).toBe("prem-premium");
+    });
+    it("never crosses providers — unknown provider yields the fallback model", () => {
+        expect(resolveModelForTask("general", "unknown", "parent-model", lookup)).toBe("parent-model");
+    });
+    it("policy intent is documented in the tier map", () => {
+        // general downgrades (balanced before premium); verify does not.
+        expect(TASK_TIER_PREFS.general.indexOf("balanced")).toBeLessThan(TASK_TIER_PREFS.general.indexOf("premium"));
+        expect(TASK_TIER_PREFS.verify.indexOf("premium")).toBeLessThan(TASK_TIER_PREFS.verify.indexOf("balanced"));
+    });
+});
+//# sourceMappingURL=sub-agent-model-tier.test.js.map

package/dist/src/orchestrator/__tests__/usage-shape-threading.test.d.ts

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

package/dist/src/orchestrator/__tests__/usage-shape-threading.test.js

@@ -0,0 +1,98 @@
+/**
+ * src/orchestrator/__tests__/usage-shape-threading.test.ts
+ *
+ * Forensics-accuracy regression: the providerOptions SHAPE recorded on each
+ * usage_events row must reflect the call that produced THAT event.
+ *
+ * The old design stashed the shape in mutable `Agent._lastProviderOptionsShape`
+ * and cleared it after the first `source==="message"` event. Two failures fell
+ * out of that:
+ *   1. Multi-step turns emit one usage event PER step (onStepFinish), but the
+ *      clear nulled the shape after step 1 → steps 2+ recorded an EMPTY shape
+ *      even though the same streamText config (with promptCacheKey) drove them.
+ *   2. A `task` sub-agent running mid-turn overwrote the shared field, so the
+ *      message turn's later steps recorded the TASK's shape (interleaving race).
+ *
+ * The fix threads the shape EXPLICITLY into recordUsage per call, so neither the
+ * clear nor an interleaved task can corrupt it. These tests drive the private
+ * recordUsage directly with a faked session and a spied recordUsageEvent.
+ */
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+const recordUsageEventSpy = vi.fn();
+vi.mock("../../storage/index.js", () => ({
+    appendCompaction: vi.fn(),
+    appendMessages: vi.fn(() => []),
+    appendSystemMessage: vi.fn(() => 0),
+    buildChatEntries: vi.fn(() => []),
+    getNextMessageSequence: vi.fn(() => 0),
+    getSessionTotalTokens: vi.fn(() => 0),
+    loadTranscript: vi.fn(() => []),
+    loadTranscriptState: vi.fn(() => ({ messages: [], seqs: [] })),
+    recordUsageEvent: (...args) => recordUsageEventSpy(...args),
+    SessionStore: class {
+        getWorkspace() {
+            return null;
+        }
+        openSession() {
+            return null;
+        }
+        createSession() {
+            return null;
+        }
+        setModel() { }
+        getRequiredSession() {
+            return null;
+        }
+        setMode() { }
+        touchSession() { }
+    },
+}));
+import { loadCatalog } from "../../models/registry.js";
+import { Agent } from "../orchestrator.js";
+// recordUsageEvent(sessionId, source, model, usage, lastSeq, pilActive,
+//                  enrichmentDelta, providerOptionsShape) — shape is the LAST arg.
+const SHAPE_ARG = 7;
+function makeAgentWithSession() {
+    const agent = new Agent(undefined, undefined, undefined, undefined, { persistSession: false });
+    // Fake a live session so recordUsage's `if (this.session)` branch runs.
+    agent.session = { id: "sess-threading-test" };
+    return {
+        recordUsage: (...a) => agent.recordUsage(...a),
+        setLastShape: (s) => {
+            agent._lastProviderOptionsShape = s;
+        },
+    };
+}
+const USAGE = { inputTokens: 100, outputTokens: 50, totalTokens: 150 };
+beforeAll(async () => {
+    await loadCatalog();
+});
+describe("recordUsage threads an explicit providerOptions shape", () => {
+    beforeEach(() => recordUsageEventSpy.mockClear());
+    afterEach(() => recordUsageEventSpy.mockClear());
+    it("records the explicit shape on EVERY message event of a multi-step turn (clear bug)", () => {
+        const a = makeAgentWithSession();
+        const shape = JSON.stringify({ openai: { promptCacheKey: "string", store: "boolean" } });
+        // Two steps of the same turn — both must carry the shape (step 2 used to be
+        // null because the first event cleared the shared field).
+        a.recordUsage(USAGE, "message", "gpt-5.4-mini", shape);
+        a.recordUsage(USAGE, "message", "gpt-5.4-mini", shape);
+        expect(recordUsageEventSpy).toHaveBeenCalledTimes(2);
+        expect(recordUsageEventSpy.mock.calls[0]?.[SHAPE_ARG]).toBe(shape);
+        expect(recordUsageEventSpy.mock.calls[1]?.[SHAPE_ARG]).toBe(shape);
+    });
+    it("records the message shape even when a task call set the shared field (interleaving race)", () => {
+        const a = makeAgentWithSession();
+        // Simulate a task sub-agent having stamped the shared field mid-turn.
+        a.setLastShape(JSON.stringify({ openai: { instructions: "string" } }));
+        const msgShape = JSON.stringify({ openai: { promptCacheKey: "string" } });
+        a.recordUsage(USAGE, "message", "gpt-5.4-mini", msgShape);
+        expect(recordUsageEventSpy.mock.calls[0]?.[SHAPE_ARG]).toBe(msgShape);
+    });
+    it("falls back to null (not stale) when no explicit shape is given for a title/other call", () => {
+        const a = makeAgentWithSession();
+        a.recordUsage(USAGE, "title", "gpt-5.4-mini");
+        expect(recordUsageEventSpy.mock.calls[0]?.[SHAPE_ARG]).toBeNull();
+    });
+});
+//# sourceMappingURL=usage-shape-threading.test.js.map

package/dist/src/orchestrator/agent.test.js

@@ -1,6 +1,8 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 async function importAgentModule() {
     vi.resetModules();
+    const { loadCatalog } = await import("../models/registry.js");
+    await loadCatalog();
     vi.doMock("../storage/index", () => ({
         appendCompaction: vi.fn(),
         appendMessages: vi.fn(() => []),
@@ -34,7 +36,7 @@ async function importAgentModule() {
 afterEach(() => {
     vi.restoreAllMocks();
     vi.resetModules();
-    vi.doUnmock("../storage/index");
+    vi.doUnmock("../storage/index.js");
 });
 describe("Agent class", { timeout: 30_000 }, () => {
     it("constructs with default options", async () => {
@@ -104,34 +106,47 @@ describe("Agent class", { timeout: 30_000 }, () => {
         // chunk yields but BEFORE the council generator's await on
         // respondToQuestion(qid) registers a resolver. The buffer must catch
         // the answer so the eventual Promise resolves immediately.
-        const { Agent } = await importAgentModule();
-        const agent = new Agent(undefined, undefined, undefined, undefined, {
-            persistSession: false,
-        });
-        // Reach into the private responder factory to mirror clarifier.ts flow.
-        const make = agent._createQuestionResponder.bind(agent);
-        agent.respondToCouncilQuestion("qid-1", "buffered-answer");
-        const promise = make()("qid-1");
+        //
+        // This behavior lives on CouncilManager (extracted from Agent in Phase 12.1-02).
+        // We test it here via CouncilManager directly since _createQuestionResponder
+        // was never a method on Agent.
+        const { CouncilManager } = await import("./council-manager.js");
+        const stubDeps = {
+            getModelId: () => "stub",
+            getSessionId: () => null,
+            hasSessionStore: () => false,
+            getMessages: () => [],
+            getBash: () => ({}),
+            getMode: () => "agent",
+        };
+        const m = new CouncilManager(stubDeps);
+        m.respondToQuestion("qid-1", "buffered-answer");
+        const promise = m.createQuestionResponder()("qid-1");
         await expect(promise).resolves.toBe("buffered-answer");
         // After consumption the buffer slot is gone — a second responder waits.
-        const stalled = make()("qid-1");
+        const stalled = m.createQuestionResponder()("qid-1");
         let settled = false;
         void stalled.then(() => {
             settled = true;
         });
         await new Promise((r) => setTimeout(r, 10));
         expect(settled).toBe(false);
-        agent.respondToCouncilQuestion("qid-1", "second");
+        m.respondToQuestion("qid-1", "second");
         await expect(stalled).resolves.toBe("second");
     });
     it("buffers council preflight approvals before the resolver registers", async () => {
-        const { Agent } = await importAgentModule();
-        const agent = new Agent(undefined, undefined, undefined, undefined, {
-            persistSession: false,
-        });
-        const make = agent._createPreflightResponder.bind(agent);
-        agent.respondToCouncilPreflight("pf-1", false);
-        await expect(make()("pf-1")).resolves.toBe(false);
+        const { CouncilManager } = await import("./council-manager.js");
+        const stubDeps = {
+            getModelId: () => "stub",
+            getSessionId: () => null,
+            hasSessionStore: () => false,
+            getMessages: () => [],
+            getBash: () => ({}),
+            getMode: () => "agent",
+        };
+        const m = new CouncilManager(stubDeps);
+        m.respondToPreflight("pf-1", false);
+        await expect(m.createPreflightResponder()("pf-1")).resolves.toBe(false);
     });
     it("respects MUONROI_MAX_TOKENS env var", async () => {
         vi.stubEnv("MUONROI_MAX_TOKENS", "32768");

package/dist/src/orchestrator/batch-turn-runner.d.ts

@@ -1,6 +1,6 @@
 import type { ModelMessage, ToolSet } from "ai";
 import type { getModelInfo } from "../models/registry.js";
-import type { resolveModelRuntime } from "../providers/runtime.js";
+import { type resolveModelRuntime } from "../providers/runtime.js";
 import type { BashTool } from "../tools/bash.js";
 import type { AgentMode, StreamChunk, TaskRequest, ToolCall, ToolResult } from "../types/index.js";
 import type { BatchClientOptions, LegacyProvider, ProcessMessageObserver } from "./agent-options.js";

package/dist/src/orchestrator/batch-turn-runner.js

@@ -27,6 +27,7 @@
 // `TurnRunnerDepsBase` hoist is mechanical.
 import { buildMcpToolSet } from "../mcp/runtime.js";
 import { getProviderCapabilities } from "../providers/capabilities.js";
+import { requireRuntimeProvider } from "../providers/runtime.js";
 import { loadMcpServers } from "../utils/settings.js";
 import { accumulateUsage, buildAssistantBatchMessage, buildBatchChatCompletionRequest, buildBatchName, buildToolBatchMessage, getBatchFinishReason, getBatchUsage, hasUsage, toLocalToolCall, } from "./batch-utils.js";
 import { relaxCompactionSettings } from "./compaction.js";
@@ -87,7 +88,7 @@ export class BatchTurnRunner {
                 if (modelInfo?.contextWindow) {
                     await deps.compactForContext(provider, system, modelInfo.contextWindow, signal, settings, attemptedOverflowRecovery);
                 }
-                const batchCaps = getProviderCapabilities(runtime.modelInfo?.provider ?? "anthropic");
+                const batchCaps = getProviderCapabilities(requireRuntimeProvider(runtime));
                 if (batchCaps.usesResponsesAPI(runtime.modelInfo)) {
                     throw new Error("Batch mode currently supports chat-completions models only.");
                 }
@@ -286,7 +287,7 @@ export class BatchTurnRunner {
                     }
                 }
                 const authError = isAuthenticationError(err);
-                const friendly = humanizeApiError(err);
+                const friendly = humanizeApiError(err, { modelId: runtime.modelId, providerId: modelInfo?.provider });
                 notifyObserver(observer?.onError, {
                     message: friendly,
                     timestamp: Date.now(),

package/dist/src/orchestrator/compaction.js

@@ -1,6 +1,7 @@
 import { generateText } from "ai";
+import { isMetaAnalysisPrompt } from "../pil/layer6-output.js";
 import { getProviderCapabilities } from "../providers/capabilities.js";
-import { resolveModelRuntime } from "../providers/runtime.js";
+import { requireRuntimeProvider, resolveModelRuntime } from "../providers/runtime.js";
 import { containsEncryptedReasoning } from "./reasoning.js";
 import { countTokens } from "./token-counter.js";
 const TOOL_RESULT_MAX_CHARS = 8000;
@@ -11,91 +12,97 @@ export const POST_TURN_MIN_TOKENS = 2_000;
 export const COMPACTION_MAX_OUTPUT_TOKENS = 4_096;
 export const TOOL_RESULT_MAX_CHARS_CONFIGURABLE = 8000;
 export const COMPACTION_SUMMARY_HEADER = "[Context checkpoint summary]";
-const SUMMARIZATION_SYSTEM_PROMPT = `You are a context summarization assistant.
-
-Do not continue the conversation. Do not answer any questions from the conversation.
-Only output a structured checkpoint summary that another coding agent can use to continue the work.
-
+const SUMMARIZATION_SYSTEM_PROMPT = `You are a context summarization assistant.
+
+Do not continue the conversation. Do not answer any questions from the conversation.
+Only output a structured checkpoint summary that another coding agent can use to continue the work.
+
 CRITICAL: The agent reading this summary must NEVER redo completed work. Mark completed items clearly.`;
-const SUMMARIZATION_PROMPT = `The messages above are a conversation to summarize. Create a structured context checkpoint summary that another LLM will use to continue the work.
-
-Use this exact format:
-
-## Goal
-[What the user is trying to accomplish]
-
-## Active Plan
-- **Plan file**: [path to PLAN.md or plan document being followed, or "(none)" if no explicit plan]
-- **Plan step**: [current step number and description, e.g. "Step 3/7: implement layer6-output.ts", or "(none)"]
-- **Plan source**: [e.g. "/gsd:execute-phase", "/gsd:quick", "manual", or "(none)"]
-
-## Constraints & Preferences
-- [Requirements, preferences, or constraints]
-- [(none) if none were mentioned]
-
-## Progress
-### ✅ DONE — DO NOT REDO
-- [x] [Completed work — be specific: file changed, test passed, command ran]
-
-### 🔄 In Progress (resume here)
-- [ ] [Current work with exact state: e.g. "editing src/foo.ts — halfway through refactor"]
-
-### ❌ Blocked
-- [Any active blockers with root cause if known]
-
-## Session Notes
-- [Important observations, warnings, or gotchas discovered during the session]
-- [(none) if not applicable]
-
-## Key Decisions
-- **[Decision]**: [Rationale]
-
-## Next Steps
-1. [The very next action to take — be specific enough that the agent can act without re-reading the conversation]
-
-## Critical Context
-- [Important details needed to continue]
-- [(none) if not applicable]
-
-## Critical Data
-- **File paths mentioned**: [list all file paths exactly as they appear]
-- **Function/method names**: [list all function/method names]
-- **Error messages**: [copy verbatim any error messages]
-- **Key numbers/results**: [list important numbers, query results, or metrics]
-
+const SUMMARIZATION_PROMPT = `The messages above are a conversation to summarize. Create a structured context checkpoint summary that another LLM will use to continue the work.
+
+Use this exact format:
+
+## Goal
+[What the user is trying to accomplish]
+
+## Active Plan
+- **Plan file**: [path to PLAN.md or plan document being followed, or "(none)" if no explicit plan]
+- **Plan step**: [current step number and description, e.g. "Step 3/7: implement layer6-output.ts", or "(none)"]
+- **Plan source**: [e.g. "/gsd:execute-phase", "/gsd:quick", "manual", or "(none)"]
+
+## Constraints & Preferences
+- [Requirements, preferences, or constraints]
+- [(none) if none were mentioned]
+
+## Progress
+### ✅ DONE — DO NOT REDO
+- [x] [Completed work — be specific: file changed, test passed, command ran]
+
+### 🔄 In Progress (resume here)
+- [ ] [Current work with exact state: e.g. "editing src/foo.ts — halfway through refactor"]
+
+### ❌ Blocked
+- [Any active blockers with root cause if known]
+
+## Session Notes
+- [Important observations, warnings, or gotchas discovered during the session]
+- [(none) if not applicable]
+
+## Key Decisions
+- **[Decision]**: [Rationale]
+
+## Next Steps
+1. [The very next action to take — be specific enough that the agent can act without re-reading the conversation]
+
+## Critical Context
+- [Important details needed to continue]
+- [(none) if not applicable]
+
+## Critical Data
+- **File paths mentioned**: [list all file paths exactly as they appear]
+- **Function/method names**: [list all function/method names]
+- **Error messages**: [copy verbatim any error messages]
+- **Key numbers/results**: [list important numbers, query results, or metrics]
+
+## Kept Artifacts (high-fidelity tool outputs preserved verbatim across B3/B4 compaction per anti-mù; agent can query the ee_query tool with "tool-artifact id=..." or "full tool result id=..." for full content later)
+- toolCallId | toolName | first120chars | reason (high-value|KEEP_TOOL_IDS|recent-turn|error)
+
 Keep it concise, but preserve exact file paths, function names, and error messages.`;
-const UPDATE_SUMMARIZATION_PROMPT = `The messages above are new conversation messages to incorporate into the existing summary provided below.
-
-Update the existing structured summary with new information. Rules:
-- Preserve still-relevant information from the previous summary
-- Add new progress, decisions, and critical context
-- Move completed items from "In Progress" to "Done" (✅ DONE — DO NOT REDO) when appropriate
-- Update "Active Plan" step if the current step has advanced
-- Update "Next Steps" based on the current state
-- Append new observations to "Session Notes"
-- Preserve exact file paths, function names, and error messages
-
-## Critical Data
-- Preserve exact file paths, function names, error messages (verbatim), and key numbers/results
-
+const UPDATE_SUMMARIZATION_PROMPT = `The messages above are new conversation messages to incorporate into the existing summary provided below.
+
+Update the existing structured summary with new information. Rules:
+- Preserve still-relevant information from the previous summary
+- Add new progress, decisions, and critical context
+- Move completed items from "In Progress" to "Done" (✅ DONE — DO NOT REDO) when appropriate
+- Update "Active Plan" step if the current step has advanced
+- Update "Next Steps" based on the current state
+- Append new observations to "Session Notes"
+- Preserve exact file paths, function names, and error messages
+
+## Critical Data
+- Preserve exact file paths, function names, error messages (verbatim), and key numbers/results
+
+## Kept Artifacts
+- (carry forward or add new high-fidelity toolCallId | tool | reason from this increment)
+
 Use the exact same section structure as the existing summary format.`;
-const TURN_PREFIX_SUMMARIZATION_PROMPT = `This is the early prefix of a single turn that was too large to keep in full. The recent suffix is still available.
-
-Summarize only what is needed so another coding agent can understand the retained suffix.
-CRITICAL: List all completed steps explicitly so the agent does not redo them.
-
-Use this exact format:
-
-## Original Request
-[What the user asked for in this turn]
-
-## Early Progress — COMPLETED (DO NOT REDO)
-- [x] [Each completed step before the suffix — be specific: file edited, test ran, etc.]
-
-## Current State
-- [Exact state at the cut point: what was just done, what variable/file is mid-edit]
-
-## Context For Suffix
+const TURN_PREFIX_SUMMARIZATION_PROMPT = `This is the early prefix of a single turn that was too large to keep in full. The recent suffix is still available.
+
+Summarize only what is needed so another coding agent can understand the retained suffix.
+CRITICAL: List all completed steps explicitly so the agent does not redo them.
+
+Use this exact format:
+
+## Original Request
+[What the user asked for in this turn]
+
+## Early Progress — COMPLETED (DO NOT REDO)
+- [x] [Each completed step before the suffix — be specific: file edited, test ran, etc.]
+
+## Current State
+- [Exact state at the cut point: what was just done, what variable/file is mid-edit]
+
+## Context For Suffix
 - [Information needed to understand the kept recent messages]`;
 function isRecord(value) {
     return typeof value === "object" && value !== null;
@@ -438,6 +445,13 @@ function readUsage(usage) {
 async function summarizeConversation(provider, 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)
+    // and force tighter maxOutputTokens to prevent 14k+ char summaries (see DB compaction at seq 52, 73k tokens -> 14k chars).
+    const userText = messages.map((m) => extractUserContent(m.content)).join("\n");
+    const isMeta = isMetaAnalysisPrompt(userText);
+    const effectiveMax = isMeta
+        ? Math.min(1024, Math.max(512, Math.floor(reserveTokens * 0.5)))
+        : Math.min(COMPACTION_MAX_OUTPUT_TOKENS, Math.max(512, Math.floor(reserveTokens * 0.8)));
     if (previousSummary) {
         promptParts.push(`Existing summary:\n${previousSummary}`);
     }
@@ -447,7 +461,7 @@ async function summarizeConversation(provider, modelId, messages, reserveTokens,
         promptParts.push(`Additional focus: ${customInstructions.trim()}`);
     }
     const runtime = resolveModelRuntime(provider, modelId);
-    const compactCaps = getProviderCapabilities(runtime.modelInfo?.provider ?? "anthropic");
+    const compactCaps = getProviderCapabilities(requireRuntimeProvider(runtime));
     const result = await generateText({
         model: runtime.model,
         system: SUMMARIZATION_SYSTEM_PROMPT,
@@ -455,9 +469,7 @@ async function summarizeConversation(provider, modelId, messages, reserveTokens,
         abortSignal: signal,
         maxRetries: 0,
         temperature: 0.2,
-        ...(!compactCaps.acceptsParam("maxOutputTokens", runtime.modelInfo)
-            ? {}
-            : { maxOutputTokens: Math.min(COMPACTION_MAX_OUTPUT_TOKENS, Math.max(512, Math.floor(reserveTokens * 0.8))) }),
+        ...(!compactCaps.acceptsParam("maxOutputTokens", runtime.modelInfo) ? {} : { maxOutputTokens: effectiveMax }),
         ...(runtime.providerOptions ? { providerOptions: runtime.providerOptions } : {}),
     });
     return { summary: result.text.trim(), usage: readUsage(result.usage) };

package/dist/src/orchestrator/compaction.test.js

@@ -1,6 +1,7 @@
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import { buildEffectiveTranscript } from "../storage/transcript-view.js";
 import { COMPACTION_SUMMARY_HEADER, createCompactionSummaryMessage, findCutPoint, prepareCompaction, serializeConversation, shouldCompactContext, } from "./compaction.js";
+import { buildCheckpointReminder } from "./scope-reminder.js";
 import { __forceFallbackForTests } from "./token-counter.js";
 // Pin token counts to the chars/4 fallback so cut-point assertions remain stable.
 // The real BPE tokenizer is exercised by token-counter's own tests.
@@ -142,5 +143,21 @@ describe("compaction helpers", () => {
             ? transcript.messages[0].content
             : "").toContain(COMPACTION_SUMMARY_HEADER);
     });
+    it("creates compaction summary with EE-extractable checkpoint meta (Progress ✔ DONE shape for pilContext/layer3)", () => {
+        // This is the exact text shape persisted to EE behavioral collection on cli-compact-checkpoint
+        // (orchestrator compactForContext + extract). Layer 3 searches for it; agent uses via "task finished?".
+        const summaryMsg = createCompactionSummaryMessage("Goal: implement anti-mu\nPlan: Phase 1-3\nProgress: ✔ DONE dedup marker\n↻ In Progress: layer1 enrich");
+        const content = typeof summaryMsg.content === "string" ? summaryMsg.content : "";
+        expect(content).toContain("Context checkpoint summary");
+        expect(content).toContain("✔ DONE");
+        expect(content).toContain("Progress");
+        expect(summaryMsg.role).toBe("system");
+    });
+    it("buildCheckpointReminder now includes PRESERVE + KEEP_TOOL_IDS + tool-artifact query for anti-mù (ideas 3+4)", () => {
+        const r = buildCheckpointReminder(3, true);
+        expect(r).toContain("PRESERVE");
+        expect(r).toContain("KEEP_TOOL_IDS");
+        expect(r).toContain("tool-artifact");
+    });
 });
 //# sourceMappingURL=compaction.test.js.map

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

@@ -1,5 +1,5 @@
 import { type ModelMessage } from "ai";
-import type { ProviderId } from "../providers/types.js";
+import { type ProviderId } from "../providers/types.js";
 import type { BashTool } from "../tools/bash.js";
 import type { AgentMode, StreamChunk } from "../types/index.js";
 import { type ModelRole } from "../utils/settings.js";