bargraph: v1

Author: spoons-and-mirrors

lib/strategies/utils.ts

@@ -133,3 +133,17 @@ export function countMessageTextTokens(msg: WithParts): number {
     if (texts.length === 0) return 0
     return estimateTokensBatch(texts)
 }
+
+export function countAllMessageTokens(msg: WithParts): number {
+    const parts = Array.isArray(msg.parts) ? msg.parts : []
+    const texts: string[] = []
+    for (const part of parts) {
+        if (part.type === "text") {
+            texts.push(part.text)
+        } else {
+            texts.push(...extractToolContent(part))
+        }
+    }
+    if (texts.length === 0) return 0
+    return estimateTokensBatch(texts)
+}

lib/tools/compress.ts

@@ -4,7 +4,8 @@ import type { ToolContext } from "./types"
 import { ensureSessionInitialized } from "../state"
 import { saveSessionState } from "../state/persistence"
 import { loadPrompt } from "../prompts"
-import { getCurrentParams, getTotalToolTokens, countMessageTextTokens } from "../strategies/utils"
+import { getCurrentParams, countAllMessageTokens, countTokens } from "../strategies/utils"
+import type { AssistantMessage } from "@opencode-ai/sdk/v2"
 import { findStringInMessages, collectToolIdsInRange, collectMessageIdsInRange } from "./utils"
 import { sendCompressNotification } from "../ui/notification"
 import { prune as applyPruneTransforms } from "../messages/prune"
@@ -330,26 +331,42 @@ export function createCompressTool(ctx: ToolContext): ReturnType<typeof tool> {
                     },
                 })
 
-                let textTokens = 0
+                let estimatedCompressedTokens = 0
                 for (const msgId of compressedMessageIds) {
                     const msg = messages.find((m) => m.info.id === msgId)
                     if (msg) {
-                        const tokens = countMessageTextTokens(msg)
-                        textTokens += tokens
+                        const tokens = countAllMessageTokens(msg)
+                        estimatedCompressedTokens += tokens
                         state.prune.messages.set(msgId, tokens)
                     }
                 }
-                const toolTokens = getTotalToolTokens(state, compressedToolIds)
                 for (const id of compressedToolIds) {
                     const entry = state.toolParameters.get(id)
                     state.prune.tools.set(id, entry?.tokenCount ?? 0)
                 }
-                const estimatedCompressedTokens = textTokens + toolTokens
+
+                // Use API-reported tokens from last assistant message (matches OpenCode UI)
+                let totalSessionTokens = 0
+                for (let i = messages.length - 1; i >= 0; i--) {
+                    if (messages[i].info.role === "assistant") {
+                        const info = messages[i].info as AssistantMessage
+                        if (info.tokens?.output > 0) {
+                            totalSessionTokens =
+                                (info.tokens?.input || 0) +
+                                (info.tokens?.output || 0) +
+                                (info.tokens?.reasoning || 0) +
+                                (info.tokens?.cache?.read || 0) +
+                                (info.tokens?.cache?.write || 0)
+                            break
+                        }
+                    }
+                }
 
                 clog.info(C.COMPRESS, `Token Accounting`, {
-                    text: textTokens,
-                    tools: toolTokens,
-                    total: estimatedCompressedTokens,
+                    totalSessionTokens,
+                    estimatedCompressedTokens,
+                    compressedMessages: compressedMessageIds.length,
+                    compressedTools: compressedToolIds.length,
                     pruneState: {
                         tools: state.prune.tools.size,
                         messages: state.prune.messages.size,
@@ -369,6 +386,21 @@ export function createCompressTool(ctx: ToolContext): ReturnType<typeof tool> {
                 }
 
                 const currentParams = getCurrentParams(state, messages, logger)
+                const summaryTokens = countTokens(args.content.summary)
+
+                clog.info(C.COMPRESS, `Notification Values`, {
+                    totalSessionTokens,
+                    estimatedCompressedTokens,
+                    summaryTokens,
+                    reductionPercent:
+                        totalSessionTokens > 0
+                            ? `-${Math.round((estimatedCompressedTokens / totalSessionTokens) * 100)}%`
+                            : "N/A",
+                    messageCount: messages.length,
+                    compressedMessageIds: compressedMessageIds.length,
+                    compressedToolIds: compressedToolIds.length,
+                })
+
                 await sendCompressNotification(
                     client,
                     logger,
@@ -379,6 +411,9 @@ export function createCompressTool(ctx: ToolContext): ReturnType<typeof tool> {
                     compressedMessageIds,
                     topic,
                     summary,
+                    summaryTokens,
+                    totalSessionTokens,
+                    estimatedCompressedTokens,
                     rawStartResult,
                     rawEndResult,
                     messages.length,
@@ -398,7 +433,7 @@ export function createCompressTool(ctx: ToolContext): ReturnType<typeof tool> {
                     clog.error(C.STATE, `✗ State Persistence Failed`, { error: err.message })
                 })
 
-                const result = `Compressed ${compressedMessageIds.length} messages (${compressedToolIds.length} tool calls) into summary. The content will be replaced with your summary.`
+                const result = `Compressed ${compressedMessageIds.length} messages (${compressedToolIds.length} tool calls) into summary (${summaryTokens} tokens). The content will be replaced with your summary.`
                 clog.info(
                     C.COMPRESS,
                     `${separator}\n✓ COMPRESS INVOCATION SUCCESS\nID: ${invocationId}\n\n${result}\n${separator}`,

lib/ui/notification.ts

@@ -4,10 +4,11 @@ import {
     formatPrunedItemsList,
     formatStatsHeader,
     formatTokenCount,
-    formatProgressBar,
+    formatCompressBar,
 } from "./utils"
 import { ToolParameterEntry } from "../state"
 import { PluginConfig } from "../config"
+import { clog, C } from "../compress-logger"
 
 export type PruneReason = "completion" | "noise" | "extraction"
 export const PRUNE_REASON_LABELS: Record<PruneReason, string> = {
@@ -137,6 +138,9 @@ export async function sendCompressNotification(
     messageIds: string[],
     topic: string,
     summary: string,
+    summaryTokens: number,
+    totalSessionTokens: number,
+    compressedTokens: number,
     startResult: any,
     endResult: any,
     totalMessages: number,
@@ -147,20 +151,27 @@ export async function sendCompressNotification(
     }
 
     let message: string
+    const summaryTokensStr = formatTokenCount(summaryTokens)
 
     if (config.pruneNotification === "minimal") {
         message = formatStatsHeader(state.stats.totalPruneTokens, state.stats.pruneTokenCounter)
     } else {
         message = formatStatsHeader(state.stats.totalPruneTokens, state.stats.pruneTokenCounter)
 
-        const pruneTokenCounterStr = `~${formatTokenCount(state.stats.pruneTokenCounter)}`
-        const progressBar = formatProgressBar(
-            totalMessages,
-            startResult.messageIndex,
-            endResult.messageIndex,
-            25,
-        )
-        message += `\n\n▣ Compressing (${pruneTokenCounterStr}) ${progressBar}`
+        const pruneTokenCounterStr = `~${formatTokenCount(compressedTokens)}`
+
+        clog.info(C.COMPRESS, `sendCompressNotification inputs`, {
+            totalSessionTokens,
+            compressedTokens,
+            summaryTokens,
+            ratio:
+                totalSessionTokens > 0 ? (compressedTokens / totalSessionTokens).toFixed(4) : "N/A",
+        })
+
+        const progressBar = formatCompressBar(totalSessionTokens, compressedTokens, 25)
+        const reduction =
+            totalSessionTokens > 0 ? Math.round((compressedTokens / totalSessionTokens) * 100) : 0
+        message += `\n\n▣ Compressing (${pruneTokenCounterStr} removed, ${reduction}% reduction) ${progressBar}`
         message += `\n→ Topic: ${topic}`
         message += `\n→ Items: ${messageIds.length} messages`
         if (toolIds.length > 0) {
@@ -169,7 +180,7 @@ export async function sendCompressNotification(
             message += ` condensed`
         }
         if (config.tools.compress.showCompression) {
-            message += `\n→ Compression: ${summary}`
+            message += `\n→ Compression (~${summaryTokensStr}): ${summary}`
         }
     }
 
@@ -179,8 +190,8 @@ export async function sendCompressNotification(
             const truncatedSummary = truncateToastSummary(summary)
             if (truncatedSummary !== summary) {
                 toastMessage = toastMessage.replace(
-                    `\n→ Compression: ${summary}`,
-                    `\n→ Compression: ${truncatedSummary}`,
+                    `\n→ Compression (~${summaryTokensStr}): ${summary}`,
+                    `\n→ Compression (~${summaryTokensStr}): ${truncatedSummary}`,
                 )
             }
         }

lib/ui/utils.ts

@@ -1,6 +1,7 @@
 import { ToolParameterEntry } from "../state"
 import { extractParameterKey } from "../messages/utils"
 import { countTokens } from "../strategies/utils"
+import { clog, C } from "../compress-logger"
 
 export function countDistillationTokens(distillation?: string[]): number {
     if (!distillation || distillation.length === 0) return 0
@@ -58,6 +59,34 @@ export function formatProgressBar(
     return `│${bar}│`
 }
 
+export function formatCompressBar(
+    sessionContext: number,
+    compressedAmount: number,
+    width: number = 20,
+): string {
+    if (sessionContext <= 0) return `│${"░".repeat(width)}│ 0%`
+
+    // sessionContext already includes compressedAmount (it's the full session total)
+    const remainingRatio = (sessionContext - compressedAmount) / sessionContext
+    const remainingWidth = Math.round(remainingRatio * width)
+    const compressedWidth = width - remainingWidth
+    const reductionPercent = -Math.round((compressedAmount / sessionContext) * 100)
+
+    clog.info(C.COMPRESS, `formatCompressBar`, {
+        sessionContext,
+        compressedAmount,
+        remainingRatio: remainingRatio.toFixed(4),
+        remainingWidth,
+        compressedWidth,
+        reductionPercent,
+    })
+
+    const remainingBar = "█".repeat(Math.max(0, remainingWidth))
+    const compressedBar = "░".repeat(Math.max(0, compressedWidth))
+
+    return `│${remainingBar}${compressedBar}│`
+}
+
 export function shortenPath(input: string, workingDirectory?: string): string {
     const inPathMatch = input.match(/^(.+) in (.+)$/)
     if (inPathMatch) {