@cjhyy/code-shell-core 0.6.0-rc.8 → 0.7.0-beta.1

package/dist/context/compaction.js

@@ -18,6 +18,144 @@ import { estimateMessagesTokens } from "./token-counter.js";
 export function estimateTokens(messages) {
     return Math.ceil(estimateMessagesTokens(messages) * (4 / 3));
 }
+export const IMAGE_HISTORY_PLACEHOLDER_PREFIX = "[image #";
+export const IMAGE_HISTORY_PLACEHOLDER_SUFFIX = ", 已处理 / already provided earlier]";
+export function collectBase64Images(messages) {
+    const entries = [];
+    let nextImageNumber = 1;
+    const visitBlocks = (blocks) => {
+        for (const block of blocks) {
+            const placeholderNumber = imageHistoryPlaceholderNumber(block);
+            if (placeholderNumber !== undefined) {
+                nextImageNumber = Math.max(nextImageNumber, placeholderNumber + 1);
+                continue;
+            }
+            if (isBase64ImageBlock(block)) {
+                entries.push({ imageNumber: nextImageNumber++, block });
+                continue;
+            }
+            if (block.type === "tool_result" && Array.isArray(block.content)) {
+                visitBlocks(block.content);
+            }
+        }
+    };
+    for (const msg of messages) {
+        if (Array.isArray(msg.content))
+            visitBlocks(msg.content);
+    }
+    return entries;
+}
+export function findImageByNumber(messages, imageNumber) {
+    if (!Number.isSafeInteger(imageNumber) || imageNumber <= 0)
+        return undefined;
+    return collectBase64Images(messages).find((entry) => entry.imageNumber === imageNumber);
+}
+/**
+ * Replace already-consumed image payload blocks with compact text markers.
+ *
+ * The transcript may retain the full image bytes for rendering/resume, but the
+ * working message history sent to the model should not re-send base64 after the
+ * model has seen it once. This handles both our internal Anthropic-style image
+ * blocks and OpenAI-style data-url image blocks defensively, including images
+ * nested inside tool_result.content arrays (view_image / browser screenshots).
+ */
+export function downgradeImagePayloadsInHistory(messages, options = {}) {
+    let replacedCount = 0;
+    let changed = false;
+    const imageNumberQueues = new WeakMap();
+    for (const entry of collectBase64Images(messages)) {
+        const key = entry.block;
+        const existing = imageNumberQueues.get(key);
+        if (existing) {
+            existing.push(entry.imageNumber);
+        }
+        else {
+            imageNumberQueues.set(key, [entry.imageNumber]);
+        }
+    }
+    const takeImageNumber = (block) => {
+        const queue = imageNumberQueues.get(block);
+        return queue?.shift();
+    };
+    const placeholderFor = (imageNumber) => ({
+        type: "text",
+        text: `${IMAGE_HISTORY_PLACEHOLDER_PREFIX}${imageNumber}${IMAGE_HISTORY_PLACEHOLDER_SUFFIX}`,
+    });
+    const transformBlocks = (blocks, preserve) => {
+        let blocksChanged = false;
+        const out = blocks.map((block) => {
+            const placeholderNumber = imageHistoryPlaceholderNumber(block);
+            if (placeholderNumber !== undefined) {
+                return block;
+            }
+            if (isBase64ImageBlock(block)) {
+                const imageNumber = takeImageNumber(block);
+                if (imageNumber === undefined)
+                    return block;
+                if (preserve)
+                    return block;
+                replacedCount++;
+                blocksChanged = true;
+                return placeholderFor(imageNumber);
+            }
+            if (block.type === "tool_result" && Array.isArray(block.content)) {
+                const nested = transformBlocks(block.content, preserve);
+                if (nested.changed) {
+                    blocksChanged = true;
+                    return { ...block, content: nested.blocks };
+                }
+            }
+            return block;
+        });
+        return { blocks: blocksChanged ? out : blocks, changed: blocksChanged };
+    };
+    const out = messages.map((msg) => {
+        if (!Array.isArray(msg.content))
+            return msg;
+        const preserve = options.preserveMessages?.has(msg) === true;
+        const result = transformBlocks(msg.content, preserve);
+        if (!result.changed)
+            return msg;
+        changed = true;
+        return { ...msg, content: result.blocks };
+    });
+    return { messages: changed ? out : messages, replacedCount };
+}
+export function messageHasBase64ImagePayload(message) {
+    if (!Array.isArray(message.content))
+        return false;
+    return message.content.some(blockHasBase64ImagePayload);
+}
+function blockHasBase64ImagePayload(block) {
+    if (isBase64ImageBlock(block))
+        return true;
+    return (block.type === "tool_result" &&
+        Array.isArray(block.content) &&
+        block.content.some(blockHasBase64ImagePayload));
+}
+function imageHistoryPlaceholderNumber(block) {
+    if (block.type !== "text" || typeof block.text !== "string")
+        return undefined;
+    const escapedPrefix = IMAGE_HISTORY_PLACEHOLDER_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const escapedSuffix = IMAGE_HISTORY_PLACEHOLDER_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = block.text.match(new RegExp(`^${escapedPrefix}(\\d+)${escapedSuffix}$`));
+    if (!match?.[1])
+        return undefined;
+    const n = Number(match[1]);
+    return Number.isSafeInteger(n) && n > 0 ? n : undefined;
+}
+export function isBase64ImageBlock(block) {
+    if (block.type === "image" &&
+        block.source?.type === "base64" &&
+        typeof block.source.data === "string" &&
+        block.source.data.length > 0) {
+        return true;
+    }
+    const maybeOpenAI = block;
+    return (maybeOpenAI.type === "image_url" &&
+        typeof maybeOpenAI.image_url?.url === "string" &&
+        /^data:image\/[^;,]+;base64,/i.test(maybeOpenAI.image_url.url));
+}
 /**
  * Reconcile user-supplied compaction ratios into a safe ordering.
  *

package/dist/context/manager.d.ts

@@ -5,7 +5,7 @@
  * Tier 2: LLM summary (async) — generate summary of older messages via model call
  * Tier 3: window compact (sync, emergency) — aggressive truncation fallback
  */
-import type { Message } from "../types.js";
+import type { Message, ContextUsageAnchor, PromptTokenConfidence, PromptTokenSource } from "../types.js";
 export interface ContextManagerConfig {
     maxTokens: number;
     compactAtRatio: number;
@@ -41,11 +41,18 @@ export declare class ContextManager {
     private config;
     private summarizeFn;
     private consecutiveSummaryFailures;
+    /** Prevents repeated spin-band LLM calls after a summary generated no shrink. */
+    private suppressNoOpMicroSummaryUntilCompact;
     private lastSummary;
     /** Last known actual token count from API usage data. */
     private lastActualTokens;
     /** Message count at the time lastActualTokens was recorded. */
     private lastActualAtMessageCount;
+    /** Heuristic token estimate for the same messages as lastActualTokens. */
+    private lastActualAnchorEstimate;
+    private lastActualRecordedAt;
+    private lastActualProvider;
+    private lastActualModel;
     /** Path to session transcript — passed to summary compaction for on-demand access. */
     private transcriptPath;
     /** Notified whenever any compaction tier fires, including microcompact. */
@@ -63,16 +70,24 @@ export declare class ContextManager {
      * Record actual token usage from API response.
      * Used for hybrid estimation: actual + estimate for new messages.
      */
-    recordActualUsage(inputTokens: number, messageCount: number): void;
+    recordActualUsage(inputTokens: number, messageCount: number, messages?: Message[]): ContextUsageAnchor | undefined;
+    /**
+     * Seed actual prompt-token usage from persisted session state.
+     * Returns the normalized anchor when accepted; invalid legacy/tampered data is ignored.
+     */
+    seedActualUsage(anchor: ContextUsageAnchor | undefined): ContextUsageAnchor | undefined;
+    getActualUsageAnchor(): ContextUsageAnchor | undefined;
     /**
      * Best-effort token estimate: uses actual API usage as base if available,
      * plus estimation for messages added since the last API call.
      */
+    private estimateTokensHybridInfo;
     private estimateTokensHybrid;
     /**
      * Set the summarize function (injected by Engine).
      */
     setSummarizeFn(fn: SummarizeFn): void;
+    private trySummaryCompact;
     /**
      * Set the transcript path so compaction can reference it. The
      * tool-results directory lives alongside the transcript file:
@@ -97,6 +112,21 @@ export declare class ContextManager {
      * Call this when you have access to the LLM (between turns).
      */
     manageAsync(messages: Message[]): Promise<Message[]>;
+    /**
+     * Force maximum compaction, ignoring the ratio gates. This is what a manual
+     * `/compact` invokes: the user explicitly asked to shrink NOW, so we don't
+     * wait for the prompt to reach compactAtRatio.
+     *
+     * Order: tier-0 cleanups (persist/truncate/dedupe/mask) + microcompact, then
+     * an unconditional LLM summary of the older messages. If no summarizeFn is
+     * wired (or it fails / yields nothing), fall back to snip → window so the
+     * call still shrinks the conversation rather than no-opping.
+     *
+     * Unlike manage()/manageAsync(), there is NO `ratio >= compactAtRatio` gate:
+     * a long-but-under-threshold text-only conversation (the /compact bug) still
+     * gets summarized here.
+     */
+    forceSummarize(messages: Message[]): Promise<Message[]>;
     /**
      * Persist large tool_result blocks to disk and replace them with a
      * preview + filepath. No-op when transcript path hasn't been set
@@ -121,5 +151,7 @@ export declare class ContextManager {
         ratio: number;
         needsCompact: boolean;
         needsEmergency: boolean;
+        promptTokensSource: PromptTokenSource;
+        promptTokensConfidence: PromptTokenConfidence;
     };
 }

package/dist/context/manager.js

@@ -37,15 +37,25 @@ const DEFAULT_CONFIG = {
 function defaultKeepRecent(maxTokens) {
     return Math.max(5, Math.floor(maxTokens / 100_000));
 }
+function positiveFinite(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
 export class ContextManager {
     config;
     summarizeFn;
     consecutiveSummaryFailures = 0;
+    /** Prevents repeated spin-band LLM calls after a summary generated no shrink. */
+    suppressNoOpMicroSummaryUntilCompact = false;
     lastSummary;
     /** Last known actual token count from API usage data. */
     lastActualTokens;
     /** Message count at the time lastActualTokens was recorded. */
     lastActualAtMessageCount;
+    /** Heuristic token estimate for the same messages as lastActualTokens. */
+    lastActualAnchorEstimate;
+    lastActualRecordedAt;
+    lastActualProvider;
+    lastActualModel;
     /** Path to session transcript — passed to summary compaction for on-demand access. */
     transcriptPath;
     /** Notified whenever any compaction tier fires, including microcompact. */
@@ -67,23 +77,84 @@ export class ContextManager {
      * Record actual token usage from API response.
      * Used for hybrid estimation: actual + estimate for new messages.
      */
-    recordActualUsage(inputTokens, messageCount) {
-        this.lastActualTokens = inputTokens;
-        this.lastActualAtMessageCount = messageCount;
+    recordActualUsage(inputTokens, messageCount, messages) {
+        const estimateAtAnchor = messages ? estimateTokens(messages) : undefined;
+        return this.seedActualUsage({
+            promptTokens: inputTokens,
+            messageCount,
+            ...(estimateAtAnchor !== undefined ? { estimateAtAnchor } : {}),
+            recordedAt: Date.now(),
+        });
+    }
+    /**
+     * Seed actual prompt-token usage from persisted session state.
+     * Returns the normalized anchor when accepted; invalid legacy/tampered data is ignored.
+     */
+    seedActualUsage(anchor) {
+        if (!anchor)
+            return undefined;
+        if (!positiveFinite(anchor.promptTokens))
+            return undefined;
+        if (!Number.isSafeInteger(anchor.messageCount) || anchor.messageCount <= 0) {
+            return undefined;
+        }
+        if (anchor.estimateAtAnchor !== undefined && !positiveFinite(anchor.estimateAtAnchor)) {
+            return undefined;
+        }
+        this.lastActualTokens = anchor.promptTokens;
+        this.lastActualAtMessageCount = anchor.messageCount;
+        this.lastActualAnchorEstimate = anchor.estimateAtAnchor;
+        this.lastActualRecordedAt = positiveFinite(anchor.recordedAt) ? anchor.recordedAt : Date.now();
+        this.lastActualProvider = anchor.provider;
+        this.lastActualModel = anchor.model;
+        return this.getActualUsageAnchor();
+    }
+    getActualUsageAnchor() {
+        if (this.lastActualTokens === undefined ||
+            this.lastActualAtMessageCount === undefined ||
+            this.lastActualRecordedAt === undefined) {
+            return undefined;
+        }
+        return {
+            promptTokens: this.lastActualTokens,
+            messageCount: this.lastActualAtMessageCount,
+            ...(this.lastActualAnchorEstimate !== undefined
+                ? { estimateAtAnchor: this.lastActualAnchorEstimate }
+                : {}),
+            recordedAt: this.lastActualRecordedAt,
+            ...(this.lastActualProvider ? { provider: this.lastActualProvider } : {}),
+            ...(this.lastActualModel ? { model: this.lastActualModel } : {}),
+        };
     }
     /**
      * Best-effort token estimate: uses actual API usage as base if available,
      * plus estimation for messages added since the last API call.
      */
-    estimateTokensHybrid(messages) {
+    estimateTokensHybridInfo(messages) {
+        const currentEstimate = estimateTokens(messages);
         if (this.lastActualTokens !== undefined &&
-            this.lastActualAtMessageCount !== undefined &&
-            this.lastActualAtMessageCount < messages.length) {
-            const newMessages = messages.slice(this.lastActualAtMessageCount);
-            const newTokens = estimateTokens(newMessages);
-            return this.lastActualTokens + newTokens;
+            this.lastActualAtMessageCount !== undefined) {
+            if (this.lastActualAtMessageCount < messages.length) {
+                const newMessages = messages.slice(this.lastActualAtMessageCount);
+                const newTokens = estimateTokens(newMessages);
+                return {
+                    tokens: this.lastActualTokens + newTokens,
+                    source: "anchor_delta",
+                    confidence: "medium",
+                };
+            }
+            if (this.lastActualAnchorEstimate !== undefined && this.lastActualAnchorEstimate > 0) {
+                return {
+                    tokens: Math.round(this.lastActualTokens * (currentEstimate / this.lastActualAnchorEstimate)),
+                    source: "anchor_rescale",
+                    confidence: "medium",
+                };
+            }
         }
-        return estimateTokens(messages);
+        return { tokens: currentEstimate, source: "heuristic_estimate", confidence: "low" };
+    }
+    estimateTokensHybrid(messages) {
+        return this.estimateTokensHybridInfo(messages).tokens;
     }
     /**
      * Set the summarize function (injected by Engine).
@@ -91,6 +162,64 @@ export class ContextManager {
     setSummarizeFn(fn) {
         this.summarizeFn = fn;
     }
+    async trySummaryCompact(messages, before, logEvent) {
+        if (!this.summarizeFn || this.consecutiveSummaryFailures >= 3) {
+            return { messages, tokens: before, compacted: false, noProgress: false };
+        }
+        try {
+            const keepRecentN = Math.max(8, Math.floor(messages.length * 0.3));
+            const messagesToSummarize = messages.slice(1, -keepRecentN); // skip first (userContext) and recent
+            if (messagesToSummarize.length <= 3) {
+                return { messages, tokens: before, compacted: false, noProgress: false };
+            }
+            // Rolling summary: if a prior summary is already anchored in the
+            // messages (from an earlier compaction in this session or in a resumed
+            // session), feed it back so the LLM merges-updates rather than
+            // re-summarizes from scratch.
+            const priorSummary = extractAnchoredSummary(messages) ?? this.lastSummary;
+            const prompt = buildSummarizationPrompt(messagesToSummarize, priorSummary);
+            const summary = await this.summarizeFn(prompt);
+            if (!summary || summary.length <= 50) {
+                this.consecutiveSummaryFailures++;
+                logger.warn("context.summary_failed", {
+                    failures: this.consecutiveSummaryFailures,
+                    error: "summary was empty or too short",
+                });
+                return { messages, tokens: before, compacted: false, noProgress: true };
+            }
+            const compacted = applySummaryCompaction(messages, summary, keepRecentN, this.transcriptPath);
+            const after = this.estimateTokensHybrid(compacted);
+            if (after >= before) {
+                this.consecutiveSummaryFailures++;
+                logger.warn("context.summary_no_progress", {
+                    failures: this.consecutiveSummaryFailures,
+                    before,
+                    after,
+                    summaryLen: summary.length,
+                    rolling: priorSummary !== undefined,
+                });
+                return { messages, tokens: before, compacted: false, noProgress: true };
+            }
+            this.consecutiveSummaryFailures = 0;
+            this.lastSummary = summary;
+            logger.info(logEvent, {
+                before,
+                after,
+                summaryLen: summary.length,
+                rolling: priorSummary !== undefined,
+            });
+            this.onCompact?.({ strategy: "summary", before, after });
+            return { messages: compacted, tokens: after, compacted: true, noProgress: false };
+        }
+        catch (err) {
+            this.consecutiveSummaryFailures++;
+            logger.warn("context.summary_failed", {
+                failures: this.consecutiveSummaryFailures,
+                error: err.message,
+            });
+            return { messages, tokens: before, compacted: false, noProgress: false };
+        }
+    }
     /**
      * Set the transcript path so compaction can reference it. The
      * tool-results directory lives alongside the transcript file:
@@ -238,9 +367,22 @@ export class ContextManager {
         result = this.truncateToolResults(result);
         // Tier 0c: Aggregate tool result budget (per-message)
         result = applyToolResultBudget(result);
+        // Tier 0d: same always-on waste-removal passes as manage().
+        const dedup = dedupeFileReads(result);
+        if (dedup.clearedCount > 0) {
+            result = dedup.messages;
+            logger.info("context.dedupe_file_reads", { cleared: dedup.clearedCount });
+        }
+        const masked = maskOldObservations(result);
+        if (masked.maskedCount > 0) {
+            result = masked.messages;
+            logger.info("context.mask_browser_snapshots", { masked: masked.maskedCount });
+        }
         // Tier 1: microcompact — see manage() for the rationale on the floor.
         const preTier1Tokens = this.estimateTokensHybrid(result);
-        if (preTier1Tokens > this.config.maxTokens * this.config.microcompactFloorRatio) {
+        const microFloorGate = this.config.maxTokens * this.config.microcompactFloorRatio;
+        let microNoOpAtFloor = false;
+        if (preTier1Tokens > microFloorGate) {
             const keepRecentN = this.config.microcompactKeepRecent ?? defaultKeepRecent(this.config.maxTokens);
             // See manage(): onClear fires synchronously before microcompact returns,
             // so defer the token re-estimate until result is reassigned.
@@ -251,67 +393,63 @@ export class ContextManager {
                     clearedInfo = info;
                 },
             });
+            const postTier1Tokens = this.estimateTokensHybrid(result);
+            microNoOpAtFloor = postTier1Tokens === preTier1Tokens;
+            if (postTier1Tokens < preTier1Tokens) {
+                this.suppressNoOpMicroSummaryUntilCompact = false;
+            }
             if (clearedInfo) {
-                const after = this.estimateTokensHybrid(result);
                 logger.info("context.microcompact", {
                     before: preTier1Tokens,
-                    after,
+                    after: postTier1Tokens,
                     keepRecentN,
                     clearedRounds: clearedInfo.clearedRounds,
                     toolNames: clearedInfo.toolNames,
                 });
-                this.onCompact?.({ strategy: "micro", before: preTier1Tokens, after });
+                this.onCompact?.({
+                    strategy: "micro",
+                    before: preTier1Tokens,
+                    after: postTier1Tokens,
+                });
             }
         }
-        const tokens = this.estimateTokensHybrid(result);
+        let tokens = this.estimateTokensHybrid(result);
         const ratio = tokens / this.config.maxTokens;
-        // Tier 2: LLM summary if approaching limit
-        if (ratio >= this.config.compactAtRatio &&
-            this.summarizeFn &&
-            this.consecutiveSummaryFailures < 3) {
-            try {
-                const keepRecentN = Math.max(8, Math.floor(result.length * 0.3));
-                const messagesToSummarize = result.slice(1, -keepRecentN); // skip first (userContext) and recent
-                if (messagesToSummarize.length > 3) {
-                    // Rolling summary: if a prior summary is already anchored in the
-                    // messages (from an earlier compaction in this session or in a
-                    // resumed session), feed it back so the LLM merges-updates rather
-                    // than re-summarizes from scratch — preserves info that would
-                    // otherwise erode across successive compactions.
-                    const priorSummary = extractAnchoredSummary(result) ?? this.lastSummary;
-                    const prompt = buildSummarizationPrompt(messagesToSummarize, priorSummary);
-                    const summary = await this.summarizeFn(prompt);
-                    if (summary && summary.length > 50) {
-                        result = applySummaryCompaction(result, summary, keepRecentN, this.transcriptPath);
-                        this.consecutiveSummaryFailures = 0;
-                        this.lastSummary = summary;
-                        const after = estimateTokens(result);
-                        logger.info("context.summary_compact", {
-                            before: tokens,
-                            after,
-                            summaryLen: summary.length,
-                            rolling: priorSummary !== undefined,
-                        });
-                        this.onCompact?.({ strategy: "summary", before: tokens, after });
-                        return result;
-                    }
-                }
+        if (ratio < this.config.microcompactFloorRatio) {
+            this.suppressNoOpMicroSummaryUntilCompact = false;
+        }
+        const noOpMicroSpinBand = microNoOpAtFloor &&
+            ratio >= this.config.microcompactFloorRatio &&
+            ratio < this.config.compactAtRatio;
+        const shouldEscalateNoOpMicro = noOpMicroSpinBand && !this.suppressNoOpMicroSummaryUntilCompact;
+        const snipGate = this.config.maxTokens * this.config.compactAtRatio;
+        const windowGate = this.config.maxTokens * (this.config.compactAtRatio + 0.05);
+        const emergencyGate = this.config.maxTokens * this.config.summarizeAtRatio;
+        // Tier 2: LLM summary if approaching limit, or if micro was the only tier
+        // available in the 0.70-0.85 band and it freed nothing.
+        if (ratio >= this.config.compactAtRatio || shouldEscalateNoOpMicro) {
+            const summarized = await this.trySummaryCompact(result, tokens, "context.summary_compact");
+            result = summarized.messages;
+            tokens = summarized.tokens;
+            if (summarized.compacted) {
+                this.suppressNoOpMicroSummaryUntilCompact = false;
+                if (tokens <= snipGate)
+                    return result;
             }
-            catch (err) {
-                this.consecutiveSummaryFailures++;
-                logger.warn("context.summary_failed", {
-                    failures: this.consecutiveSummaryFailures,
-                    error: err.message,
+            if (shouldEscalateNoOpMicro && summarized.noProgress) {
+                this.suppressNoOpMicroSummaryUntilCompact = true;
+                logger.info("context.micro_noop_summary_suppressed", {
+                    tokens,
+                    ratio,
+                    compactAtRatio: this.config.compactAtRatio,
+                    microcompactFloorRatio: this.config.microcompactFloorRatio,
                 });
             }
         }
-        // Reuse the `tokens` we already computed above. We only get here if the
-        // LLM summary path didn't fire (no summarizeFn, too many failures, or it
-        // threw) — fall back to the same severity ladder as manage().
+        // Reuse the `tokens` we already computed above. We get here if no summary
+        // compacted the prompt, or if summary helped but the hybrid estimate is
+        // still above the fallback gate.
         let live = tokens;
-        const snipGate = this.config.maxTokens * this.config.compactAtRatio;
-        const windowGate = this.config.maxTokens * (this.config.compactAtRatio + 0.05);
-        const emergencyGate = this.config.maxTokens * this.config.summarizeAtRatio;
         // Tier 2 fallback: snip first (cheapest sync option)
         if (live > snipGate) {
             const before = live;
@@ -336,6 +474,61 @@ export class ContextManager {
         }
         return result;
     }
+    /**
+     * Force maximum compaction, ignoring the ratio gates. This is what a manual
+     * `/compact` invokes: the user explicitly asked to shrink NOW, so we don't
+     * wait for the prompt to reach compactAtRatio.
+     *
+     * Order: tier-0 cleanups (persist/truncate/dedupe/mask) + microcompact, then
+     * an unconditional LLM summary of the older messages. If no summarizeFn is
+     * wired (or it fails / yields nothing), fall back to snip → window so the
+     * call still shrinks the conversation rather than no-opping.
+     *
+     * Unlike manage()/manageAsync(), there is NO `ratio >= compactAtRatio` gate:
+     * a long-but-under-threshold text-only conversation (the /compact bug) still
+     * gets summarized here.
+     */
+    async forceSummarize(messages) {
+        let result = messages;
+        // Tier 0: same waste-removal + micro as the automatic path.
+        result = this.persistLargeToolResults(result);
+        result = this.truncateToolResults(result);
+        result = applyToolResultBudget(result);
+        const dedup = dedupeFileReads(result);
+        if (dedup.clearedCount > 0)
+            result = dedup.messages;
+        const masked = maskOldObservations(result);
+        if (masked.maskedCount > 0)
+            result = masked.messages;
+        const keepRecentN = this.config.microcompactKeepRecent ?? defaultKeepRecent(this.config.maxTokens);
+        result = microcompact(result, { keepRecentN });
+        let tokens = this.estimateTokensHybrid(result);
+        // Unconditional LLM summary (no ratio gate).
+        {
+            const summarized = await this.trySummaryCompact(result, tokens, "context.force_summary_compact");
+            result = summarized.messages;
+            tokens = summarized.tokens;
+            if (summarized.compacted)
+                return result;
+        }
+        // Fallback: no summary available — snip, then window, so /compact still
+        // shrinks the conversation instead of no-opping.
+        {
+            const before = tokens;
+            result = snipCompact(result, 3, 8);
+            tokens = this.estimateTokensHybrid(result);
+            if (tokens < before)
+                this.onCompact?.({ strategy: "snip", before, after: tokens });
+        }
+        if (this.estimateTokensHybrid(result) >= this.estimateTokensHybrid(messages)) {
+            const before = tokens;
+            const keepN = Math.max(10, Math.floor(result.length * 0.4));
+            result = windowCompact(result, keepN);
+            tokens = this.estimateTokensHybrid(result);
+            this.onCompact?.({ strategy: "window", before, after: tokens });
+        }
+        return result;
+    }
     /**
      * Persist large tool_result blocks to disk and replace them with a
      * preview + filepath. No-op when transcript path hasn't been set
@@ -395,13 +588,16 @@ export class ContextManager {
      * Check if context is approaching limits.
      */
     checkLimits(messages) {
-        const tokens = this.estimateTokensHybrid(messages);
+        const estimate = this.estimateTokensHybridInfo(messages);
+        const tokens = estimate.tokens;
         const ratio = tokens / this.config.maxTokens;
         return {
             tokens,
             ratio,
             needsCompact: ratio >= this.config.compactAtRatio,
             needsEmergency: ratio >= this.config.summarizeAtRatio,
+            promptTokensSource: estimate.source,
+            promptTokensConfidence: estimate.confidence,
         };
     }
 }

package/dist/context/token-counter.js

@@ -69,11 +69,24 @@ function estimateBlockTokens(block) {
     if (block.content && typeof block.content === "string") {
         tokens += estimateStringTokens(block.content);
     }
+    else if (Array.isArray(block.content)) {
+        for (const nested of block.content) {
+            tokens += estimateBlockTokens(nested);
+        }
+    }
     if (block.input) {
         tokens += estimateStringTokens(JSON.stringify(block.input));
     }
     if (block.name)
         tokens += estimateStringTokens(block.name);
+    if (block.source?.data) {
+        tokens += estimateStringTokens(block.source.media_type);
+        tokens += estimateStringTokens(block.source.data);
+    }
+    const maybeOpenAI = block;
+    if (typeof maybeOpenAI.image_url?.url === "string") {
+        tokens += estimateStringTokens(maybeOpenAI.image_url.url);
+    }
     return tokens;
 }
 export function calculateContextUsage(messages, systemPrompt, maxTokens) {