muonroi-cli 1.2.2 → 1.3.1

package/src/orchestrator/compaction.ts

@@ -1,7 +1,9 @@
 import { generateText, type ModelMessage } from "ai";
+import { getProviderCapabilities } from "../providers/capabilities.js";
 import type { ProviderFactory as LegacyProvider } from "../providers/runtime.js";
 import { resolveModelRuntime } from "../providers/runtime.js";
 import { containsEncryptedReasoning } from "./reasoning";
+import { countTokens } from "./token-counter.js";
 
 export interface CompactionSettings {
   reserveTokens: number;
@@ -25,18 +27,22 @@ export interface PreparedCompaction {
   settings: CompactionSettings;
 }
 
-const TOOL_RESULT_MAX_CHARS = 2000;
+const TOOL_RESULT_MAX_CHARS = 8000;
 const MIN_KEPT_TOKENS_ON_RETRY = 4000;
 
 export const DEFAULT_RESERVE_TOKENS = 16_384;
 export const DEFAULT_KEEP_RECENT_TOKENS = 20_000;
 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.`;
+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.
 
@@ -45,30 +51,45 @@ 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
-- [x] [Completed work]
+### ✅ DONE — DO NOT REDO
+- [x] [Completed work — be specific: file changed, test passed, command ran]
 
-### In Progress
-- [ ] [Current work]
+### 🔄 In Progress (resume here)
+- [ ] [Current work with exact state: e.g. "editing src/foo.ts — halfway through refactor"]
 
-### Blocked
-- [Any active blockers]
+### ❌ 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 next action to take]
+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]
+
 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.
@@ -76,23 +97,32 @@ const UPDATE_SUMMARIZATION_PROMPT = `The messages above are new conversation mes
 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" when appropriate
+- 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
+
 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
-- [Key work done before the kept suffix]
+## 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]`;
@@ -138,10 +168,56 @@ function stringifyForSummary(value: unknown): string {
 
 function truncateForSummary(text: string, maxChars = TOOL_RESULT_MAX_CHARS): string {
   if (text.length <= maxChars) return text;
-  return `${text.slice(0, maxChars)}\n\n[... ${text.length - maxChars} more characters truncated]`;
+  // Keep head + tail. Errors, exit codes, and summaries usually live at the end of long
+  // tool outputs; head-only truncation routinely drops the most diagnostic lines.
+  const headChars = Math.floor(maxChars * 0.6);
+  const tailChars = maxChars - headChars;
+  const omitted = text.length - maxChars;
+  return `${text.slice(0, headChars)}\n\n[... ${omitted} more characters truncated ...]\n\n${text.slice(-tailChars)}`;
+}
+
+function hashString(s: string): string {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) {
+    h = ((h << 5) - h + s.charCodeAt(i)) | 0;
+  }
+  return h.toString(36);
+}
+
+const DEDUP_MIN_CHARS = 500;
+
+/**
+ * Dedup identical tool-result payloads inside a slice destined for summarization.
+ * Repeated reads of an unchanged file inflate the summarize prompt with
+ * (truncated) duplicates that cost tokens and add zero new context.
+ */
+function dedupToolResultsWithState(messages: ModelMessage[], seenHashes: Set<string>): ModelMessage[] {
+  return messages.map((msg) => {
+    if (msg.role !== "tool" || !Array.isArray(msg.content)) return msg;
+    const parts = msg.content as unknown[];
+    const newContent = parts.map((part) => {
+      if (!isRecord(part) || part.type !== "tool-result") return part;
+      const serialized = stringifyForSummary((part as Record<string, unknown>).output);
+      if (serialized.length < DEDUP_MIN_CHARS) return part;
+      const hash = hashString(serialized);
+      if (seenHashes.has(hash)) {
+        const toolName =
+          typeof (part as Record<string, unknown>).toolName === "string"
+            ? ((part as Record<string, unknown>).toolName as string)
+            : "tool";
+        return {
+          ...(part as Record<string, unknown>),
+          output: `[Identical to earlier ${toolName} result; ${serialized.length} chars elided]`,
+        };
+      }
+      seenHashes.add(hash);
+      return part;
+    });
+    return { ...msg, content: newContent as typeof msg.content };
+  });
 }
 
-function extractUserContent(content: unknown): string {
+export function extractUserContent(content: unknown): string {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
 
@@ -215,34 +291,30 @@ export function getCompactionSummaryText(message: ModelMessage | undefined): str
   return message.content.slice(COMPACTION_SUMMARY_HEADER.length).trim();
 }
 
-export function estimateMessageTokens(message: ModelMessage): number {
-  let chars = 0;
-
+function messageToString(message: ModelMessage): string {
   switch (message.role) {
     case "user":
-      chars += extractUserContent(message.content).length;
-      break;
-    case "assistant":
-      chars += extractAssistantText(message.content).length;
-      chars += extractToolCallText(message.content).join("; ").length;
-      break;
+      return extractUserContent(message.content);
+    case "assistant": {
+      const text = extractAssistantText(message.content);
+      const toolCalls = extractToolCallText(message.content).join("; ");
+      return toolCalls ? `${text}\n${toolCalls}` : text;
+    }
     case "tool":
-      chars += extractToolResultText(message.content).join("\n").length;
-      break;
+      return extractToolResultText(message.content).join("\n");
     case "system":
-      chars +=
-        typeof message.content === "string" ? message.content.length : getTextParts(message.content).join("\n").length;
-      break;
+      return typeof message.content === "string" ? message.content : getTextParts(message.content).join("\n");
     default:
-      chars += stringifyForSummary((message as { content?: unknown }).content).length;
-      break;
+      return stringifyForSummary((message as { content?: unknown }).content);
   }
+}
 
-  return Math.ceil(chars / 4);
+export function estimateMessageTokens(message: ModelMessage): number {
+  return countTokens(messageToString(message));
 }
 
 export function estimateConversationTokens(systemPrompt: string, messages: ModelMessage[], inFlightText = ""): number {
-  const systemTokens = Math.ceil((systemPrompt.length + inFlightText.length) / 4);
+  const systemTokens = countTokens(systemPrompt) + (inFlightText ? countTokens(inFlightText) : 0);
   return systemTokens + messages.reduce((sum, message) => sum + estimateMessageTokens(message), 0);
 }
 
@@ -314,10 +386,14 @@ export function prepareCompaction(
 
   const cutPoint = findCutPoint(messages, boundaryStart, settings.keepRecentTokens);
   const historyEnd = cutPoint.isSplitTurn ? cutPoint.turnStartIndex : cutPoint.firstKeptIndex;
-  const messagesToSummarize = messages.slice(boundaryStart, Math.max(boundaryStart, historyEnd));
-  const turnPrefixMessages = cutPoint.isSplitTurn
-    ? messages.slice(cutPoint.turnStartIndex, cutPoint.firstKeptIndex)
-    : [];
+  const rawHistory = messages.slice(boundaryStart, Math.max(boundaryStart, historyEnd));
+  const rawTurnPrefix = cutPoint.isSplitTurn ? messages.slice(cutPoint.turnStartIndex, cutPoint.firstKeptIndex) : [];
+  // Shared dedup state — second occurrence of a duplicate tool-result gets stubbed
+  // even when the first occurrence is in the history slice and the second in the prefix.
+  const dedupState = new Set<string>();
+  const messagesToSummarize = dedupToolResultsWithState(rawHistory, dedupState);
+  const turnPrefixMessages = dedupToolResultsWithState(rawTurnPrefix, dedupState);
+  // keptMessages stay verbatim — they live in the active conversation, not the summarize prompt.
   const keptMessages = messages.slice(cutPoint.firstKeptIndex);
   const tokensBefore = estimateConversationTokens(systemPrompt, messages);
 
@@ -369,15 +445,25 @@ export function serializeConversation(messages: ModelMessage[]): string {
     if (message.role === "assistant") {
       const text = extractAssistantText(message.content).trim();
       const toolCalls = extractToolCallText(message.content);
-      if (text) parts.push(`[Assistant]: ${text}`);
-      if (toolCalls.length > 0) parts.push(`[Assistant tool calls]: ${toolCalls.join("; ")}`);
+      if (text) parts.push(`[Assistant response]: ${text}`);
+      if (toolCalls.length > 0) parts.push(`[Tool call]: ${toolCalls.join("; ")}`);
       continue;
     }
 
     if (message.role === "tool") {
-      const results = extractToolResultText(message.content);
-      for (const result of results) {
-        if (result.trim()) parts.push(`[Tool result]: ${result}`);
+      if (Array.isArray(message.content)) {
+        for (const part of message.content) {
+          if (!isRecord(part)) continue;
+          const r = part as Record<string, unknown>;
+          if (r.type !== "tool-result") continue;
+          const toolName = typeof r.toolName === "string" ? r.toolName : "unknown";
+          const result = truncateForSummary(stringifyForSummary(r.output));
+          if (result.trim()) parts.push(`[Tool result from ${toolName}]: ${result}`);
+        }
+      } else {
+        // Fallback for string content
+        const text = String(message.content).trim();
+        if (text) parts.push(`[Tool result]: ${text}`);
       }
       continue;
     }
@@ -392,6 +478,33 @@ export function serializeConversation(messages: ModelMessage[]): string {
   return parts.join("\n\n");
 }
 
+export interface CompactionUsage {
+  promptTokens: number;
+  completionTokens: number;
+}
+
+export interface CompactionSummaryResult {
+  summary: string;
+  usage: CompactionUsage;
+}
+
+function readUsage(usage: unknown): CompactionUsage {
+  if (!isRecord(usage)) return { promptTokens: 0, completionTokens: 0 };
+  const prompt =
+    typeof usage.inputTokens === "number"
+      ? usage.inputTokens
+      : typeof (usage as Record<string, unknown>).promptTokens === "number"
+        ? (usage as { promptTokens: number }).promptTokens
+        : 0;
+  const completion =
+    typeof usage.outputTokens === "number"
+      ? usage.outputTokens
+      : typeof (usage as Record<string, unknown>).completionTokens === "number"
+        ? (usage as { completionTokens: number }).completionTokens
+        : 0;
+  return { promptTokens: prompt, completionTokens: completion };
+}
+
 async function summarizeConversation(
   provider: LegacyProvider,
   modelId: string,
@@ -401,7 +514,7 @@ async function summarizeConversation(
   previousSummary?: string,
   promptOverride?: string,
   signal?: AbortSignal,
-): Promise<string> {
+): Promise<CompactionSummaryResult> {
   const serialized = serializeConversation(messages);
   const promptParts = [serialized];
 
@@ -417,20 +530,32 @@ async function summarizeConversation(
   }
 
   const runtime = resolveModelRuntime(provider, modelId);
-  const { text } = await generateText({
+  const compactCaps = getProviderCapabilities(runtime.modelInfo?.provider ?? "anthropic");
+  const result = await generateText({
     model: runtime.model,
     system: SUMMARIZATION_SYSTEM_PROMPT,
     prompt: promptParts.filter(Boolean).join("\n\n"),
     abortSignal: signal,
     maxRetries: 0,
     temperature: 0.2,
-    ...(runtime.modelInfo?.supportsMaxOutputTokens === false
+    ...(!compactCaps.acceptsParam("maxOutputTokens", runtime.modelInfo)
       ? {}
-      : { maxOutputTokens: Math.max(512, Math.floor(reserveTokens * 0.8)) }),
+      : { maxOutputTokens: Math.min(COMPACTION_MAX_OUTPUT_TOKENS, Math.max(512, Math.floor(reserveTokens * 0.8))) }),
     ...(runtime.providerOptions ? { providerOptions: runtime.providerOptions } : {}),
   });
 
-  return text.trim();
+  return { summary: result.text.trim(), usage: readUsage(result.usage) };
+}
+
+function emptyUsage(): CompactionUsage {
+  return { promptTokens: 0, completionTokens: 0 };
+}
+
+function addUsage(a: CompactionUsage, b: CompactionUsage): CompactionUsage {
+  return {
+    promptTokens: a.promptTokens + b.promptTokens,
+    completionTokens: a.completionTokens + b.completionTokens,
+  };
 }
 
 export async function generateCompactionSummary(
@@ -439,11 +564,11 @@ export async function generateCompactionSummary(
   preparation: PreparedCompaction,
   customInstructions?: string,
   signal?: AbortSignal,
-): Promise<string> {
+): Promise<CompactionSummaryResult> {
   const { messagesToSummarize, turnPrefixMessages, isSplitTurn, previousSummary, settings } = preparation;
 
   if (isSplitTurn && turnPrefixMessages.length > 0) {
-    const [historySummary, prefixSummary] = await Promise.all([
+    const [historyResult, prefixResult] = await Promise.all([
       messagesToSummarize.length > 0
         ? summarizeConversation(
             provider,
@@ -455,7 +580,7 @@ export async function generateCompactionSummary(
             undefined,
             signal,
           )
-        : Promise.resolve(previousSummary?.trim() || ""),
+        : Promise.resolve<CompactionSummaryResult>({ summary: previousSummary?.trim() || "", usage: emptyUsage() }),
       summarizeConversation(
         provider,
         modelId,
@@ -468,10 +593,11 @@ export async function generateCompactionSummary(
       ),
     ]);
 
-    if (historySummary && prefixSummary) {
-      return `${historySummary}\n\n---\n\n${prefixSummary}`;
+    const usage = addUsage(historyResult.usage, prefixResult.usage);
+    if (historyResult.summary && prefixResult.summary) {
+      return { summary: `${historyResult.summary}\n\n---\n\n${prefixResult.summary}`, usage };
     }
-    return (historySummary || prefixSummary).trim();
+    return { summary: (historyResult.summary || prefixResult.summary).trim(), usage };
   }
 
   return summarizeConversation(