Opencode-DCP · Tarquinen · Apr 1, 2026 · Mar 29, 2026 · Mar 29, 2026 · Mar 29, 2026
diff --git a/README.md b/README.md
@@ -9,18 +9,13 @@ Automatically reduces token usage in OpenCode by managing conversation context.
 
 ## Installation
 
-Add to your OpenCode config:
+Install from the CLI:
 
-```jsonc
-// opencode.jsonc
-{
-    "plugin": ["@tarquinen/opencode-dcp@latest"],
-}
+```bash
+opencode plugin @tarquinen/opencode-dcp@latest --global
 ```
 
-Using `@latest` ensures you always get the newest version automatically when OpenCode starts.
-
-Restart OpenCode. The plugin will automatically start optimizing your sessions.
+This installs the package and adds it to your global OpenCode config.
 
 ## How It Works
 

diff --git a/index.ts b/index.ts
@@ -13,6 +13,7 @@ import {
     createChatMessageHandler,
     createChatMessageTransformHandler,
     createCommandExecuteHandler,
+    createEventHandler,
     createSystemPromptHandler,
     createTextCompleteHandler,
 } from "./lib/hooks"
@@ -57,7 +58,6 @@ const plugin: Plugin = (async (ctx) => {
             config,
             prompts,
         ),
-
         "experimental.chat.messages.transform": createChatMessageTransformHandler(
             ctx.client,
             state,
@@ -76,6 +76,7 @@ const plugin: Plugin = (async (ctx) => {
             ctx.directory,
             hostPermissions,
         ),
+        event: createEventHandler(state, logger),
         tool: {
             ...(config.compress.permission !== "deny" && {
                 compress:

diff --git a/lib/commands/compression-targets.ts b/lib/commands/compression-targets.ts
@@ -5,6 +5,7 @@ export interface CompressionTarget {
     runId: number
     topic: string
     compressedTokens: number
+    durationMs: number
     grouped: boolean
     blocks: CompressionBlock[]
 }
@@ -26,6 +27,7 @@ function buildTarget(blocks: CompressionBlock[]): CompressionTarget {
         runId: first.runId,
         topic: grouped ? first.batchTopic || first.topic : first.topic,
         compressedTokens: ordered.reduce((total, block) => total + block.compressedTokens, 0),
+        durationMs: ordered.reduce((total, block) => Math.max(total, block.durationMs), 0),
         grouped,
         blocks: ordered,
     }

diff --git a/lib/commands/context.ts b/lib/commands/context.ts
@@ -44,9 +44,9 @@ import type { Logger } from "../logger"
 import type { SessionState, WithParts } from "../state"
 import { sendIgnoredMessage } from "../ui/notification"
 import { formatTokenCount } from "../ui/utils"
-import { isMessageCompacted } from "../shared-utils"
-import { isIgnoredUserMessage } from "../messages/utils"
-import { countTokens, getCurrentParams } from "../strategies/utils"
+import { isIgnoredUserMessage } from "../messages/query"
+import { isMessageCompacted } from "../state/utils"
+import { countTokens, extractCompletedToolOutput, getCurrentParams } from "../token-utils"
 import type { AssistantMessage, TextPart, ToolPart } from "@opencode-ai/sdk/v2"
 
 export interface ContextCommandContext {
@@ -159,11 +159,8 @@ function analyzeTokens(state: SessionState, messages: WithParts[]): TokenBreakdo
                         toolInputParts.push(inputStr)
                     }
 
-                    if (toolPart.state?.status === "completed" && toolPart.state?.output) {
-                        const outputStr =
-                            typeof toolPart.state.output === "string"
-                                ? toolPart.state.output
-                                : JSON.stringify(toolPart.state.output)
+                    const outputStr = extractCompletedToolOutput(toolPart)
+                    if (outputStr !== undefined) {
                         toolOutputParts.push(outputStr)
                     }
                 }

diff --git a/lib/commands/decompress.ts b/lib/commands/decompress.ts
@@ -2,7 +2,7 @@ import type { Logger } from "../logger"
 import type { CompressionBlock, PruneMessagesState, SessionState, WithParts } from "../state"
 import { syncCompressionBlocks } from "../messages"
 import { parseBlockRef } from "../message-ids"
-import { getCurrentParams } from "../strategies/utils"
+import { getCurrentParams } from "../token-utils"
 import { saveSessionState } from "../state/persistence"
 import { sendIgnoredMessage } from "../ui/notification"
 import { formatTokenCount } from "../ui/utils"

diff --git a/lib/commands/help.ts b/lib/commands/help.ts
@@ -6,9 +6,9 @@
 import type { Logger } from "../logger"
 import type { PluginConfig } from "../config"
 import type { SessionState, WithParts } from "../state"
-import { compressPermission } from "../shared-utils"
+import { compressPermission } from "../compress-permission"
 import { sendIgnoredMessage } from "../ui/notification"
-import { getCurrentParams } from "../strategies/utils"
+import { getCurrentParams } from "../token-utils"
 
 export interface HelpCommandContext {
     client: any

diff --git a/lib/commands/manual.ts b/lib/commands/manual.ts
@@ -11,9 +11,9 @@ import type { Logger } from "../logger"
 import type { SessionState, WithParts } from "../state"
 import type { PluginConfig } from "../config"
 import { sendIgnoredMessage } from "../ui/notification"
-import { getCurrentParams } from "../strategies/utils"
-import { buildCompressedBlockGuidance } from "../messages/inject/utils"
-import { isIgnoredUserMessage } from "../messages/utils"
+import { getCurrentParams } from "../token-utils"
+import { buildCompressedBlockGuidance } from "../prompts/extensions/nudge"
+import { isIgnoredUserMessage } from "../messages/query"
 
 const MANUAL_MODE_ON = "Manual mode is now ON. Use /dcp compress to trigger context tools manually."
 

diff --git a/lib/commands/recompress.ts b/lib/commands/recompress.ts
@@ -2,7 +2,7 @@ import type { Logger } from "../logger"
 import type { PruneMessagesState, SessionState, WithParts } from "../state"
 import { syncCompressionBlocks } from "../messages"
 import { parseBlockRef } from "../message-ids"
-import { getCurrentParams } from "../strategies/utils"
+import { getCurrentParams } from "../token-utils"
 import { saveSessionState } from "../state/persistence"
 import { sendIgnoredMessage } from "../ui/notification"
 import { formatTokenCount } from "../ui/utils"

diff --git a/lib/commands/stats.ts b/lib/commands/stats.ts
@@ -8,7 +8,8 @@ import type { SessionState, WithParts } from "../state"
 import { sendIgnoredMessage } from "../ui/notification"
 import { formatTokenCount } from "../ui/utils"
 import { loadAllSessionStats, type AggregatedStats } from "../state/persistence"
-import { getCurrentParams } from "../strategies/utils"
+import { getCurrentParams } from "../token-utils"
+import { getActiveCompressionTargets } from "./compression-targets"
 
 export interface StatsCommandContext {
     client: any
@@ -20,8 +21,10 @@ export interface StatsCommandContext {
 
 function formatStatsMessage(
     sessionTokens: number,
+    sessionSummaryTokens: number,
     sessionTools: number,
     sessionMessages: number,
+    sessionDurationMs: number,
     allTime: AggregatedStats,
 ): string {
     const lines: string[] = []
@@ -30,11 +33,15 @@ function formatStatsMessage(
     lines.push("│                    DCP Statistics                         │")
     lines.push("╰───────────────────────────────────────────────────────────╯")
     lines.push("")
-    lines.push("Session:")
+    lines.push("Compression:")
     lines.push("─".repeat(60))
-    lines.push(`  Tokens pruned:   ~${formatTokenCount(sessionTokens)}`)
-    lines.push(`  Tools pruned:     ${sessionTools}`)
-    lines.push(`  Messages pruned:  ${sessionMessages}`)
+    lines.push(
+        `  Tokens in|out:    ~${formatTokenCount(sessionTokens)} | ~${formatTokenCount(sessionSummaryTokens)}`,
+    )
+    lines.push(`  Ratio:            ${formatCompressionRatio(sessionTokens, sessionSummaryTokens)}`)
+    lines.push(`  Time:             ${formatCompressionTime(sessionDurationMs)}`)
+    lines.push(`  Messages:         ${sessionMessages}`)
+    lines.push(`  Tools:            ${sessionTools}`)
     lines.push("")
     lines.push("All-time:")
     lines.push("─".repeat(60))
@@ -46,11 +53,55 @@ function formatStatsMessage(
     return lines.join("\n")
 }
 
+function formatCompressionRatio(inputTokens: number, outputTokens: number): string {
+    if (inputTokens <= 0) {
+        return "0:1"
+    }
+
+    if (outputTokens <= 0) {
+        return "∞:1"
+    }
+
+    const ratio = Math.max(1, Math.round(inputTokens / outputTokens))
+    return `${ratio}:1`
+}
+
+function formatCompressionTime(ms: number): string {
+    const safeMs = Math.max(0, Math.round(ms))
+    if (safeMs < 1000) {
+        return `${safeMs} ms`
+    }
+
+    const totalSeconds = safeMs / 1000
+    if (totalSeconds < 60) {
+        return `${totalSeconds.toFixed(1)} s`
+    }
+
+    const wholeSeconds = Math.floor(totalSeconds)
+    const hours = Math.floor(wholeSeconds / 3600)
+    const minutes = Math.floor((wholeSeconds % 3600) / 60)
+    const seconds = wholeSeconds % 60
+
+    if (hours > 0) {
+        return `${hours}h ${minutes}m ${seconds}s`
+    }
+
+    return `${minutes}m ${seconds}s`
+}
+
 export async function handleStatsCommand(ctx: StatsCommandContext): Promise<void> {
     const { client, state, logger, sessionId, messages } = ctx
 
     // Session stats from in-memory state
     const sessionTokens = state.stats.totalPruneTokens
+    const sessionSummaryTokens = Array.from(state.prune.messages.blocksById.values()).reduce(
+        (total, block) => (block.active ? total + block.summaryTokens : total),
+        0,
+    )
+    const sessionDurationMs = getActiveCompressionTargets(state.prune.messages).reduce(
+        (total, target) => total + target.durationMs,
+        0,
+    )
 
     const prunedToolIds = new Set<string>(state.prune.tools.keys())
     for (const block of state.prune.messages.blocksById.values()) {
@@ -72,15 +123,24 @@ export async function handleStatsCommand(ctx: StatsCommandContext): Promise<void
     // All-time stats from storage files
     const allTime = await loadAllSessionStats(logger)
 
-    const message = formatStatsMessage(sessionTokens, sessionTools, sessionMessages, allTime)
+    const message = formatStatsMessage(
+        sessionTokens,
+        sessionSummaryTokens,
+        sessionTools,
+        sessionMessages,
+        sessionDurationMs,
+        allTime,
+    )
 
     const params = getCurrentParams(state, messages, logger)
     await sendIgnoredMessage(client, sessionId, message, params, logger)
 
     logger.info("Stats command executed", {
         sessionTokens,
+        sessionSummaryTokens,
         sessionTools,
         sessionMessages,
+        sessionDurationMs,
         allTimeTokens: allTime.totalTokens,
         allTimeTools: allTime.totalTools,
         allTimeMessages: allTime.totalMessages,

diff --git a/lib/commands/sweep.ts b/lib/commands/sweep.ts
@@ -12,10 +12,11 @@ import type { SessionState, WithParts, ToolParameterEntry } from "../state"
 import type { PluginConfig } from "../config"
 import { sendIgnoredMessage } from "../ui/notification"
 import { formatPrunedItemsList } from "../ui/utils"
-import { getCurrentParams, getTotalToolTokens } from "../strategies/utils"
-import { buildToolIdList, isIgnoredUserMessage } from "../messages/utils"
+import { getCurrentParams, getTotalToolTokens } from "../token-utils"
+import { isIgnoredUserMessage } from "../messages/query"
+import { buildToolIdList } from "../messages/utils"
 import { saveSessionState } from "../state/persistence"
-import { isMessageCompacted } from "../shared-utils"
+import { isMessageCompacted } from "../state/utils"
 import {
     getFilePathsFromParameters,
     isFilePathProtected,

diff --git a/lib/compress-permission.ts b/lib/compress-permission.ts
@@ -0,0 +1,25 @@
+import type { PluginConfig } from "./config"
+import { type HostPermissionSnapshot, resolveEffectiveCompressPermission } from "./host-permissions"
+import type { SessionState, WithParts } from "./state"
+import { getLastUserMessage } from "./messages/query"
+
+export const compressPermission = (
+    state: SessionState,
+    config: PluginConfig,
+): "ask" | "allow" | "deny" => {
+    return state.compressPermission ?? config.compress.permission
+}
+
+export const syncCompressPermissionState = (
+    state: SessionState,
+    config: PluginConfig,
+    hostPermissions: HostPermissionSnapshot,
+    messages: WithParts[],
+): void => {
+    const activeAgent = getLastUserMessage(messages)?.info.agent
+    state.compressPermission = resolveEffectiveCompressPermission(
+        config.compress.permission,
+        hostPermissions,
+        activeAgent,
+    )
+}