@royalcat/opencode-dcp-rc 4.0.0 → 4.0.2

package/lib/compress/rc.ts

@@ -21,6 +21,13 @@ import { countTokens } from "../token-utils"
 import { saveSessionState } from "../state/persistence"
 import { rcFormat } from "../prompts/extensions/tool"
 import { appendProtectedPromptInfo, appendProtectedTools } from "./protected-content"
+import {
+    addCompressionUsage,
+    addCompressionUsageTotals,
+    emptyCompressionUsage,
+    estimatedCompressionUsage,
+    type CompressionUsageTotals,
+} from "./usage"
 import {
     buildSummaryPrompt,
     parseSummarySections,
@@ -34,6 +41,16 @@ export interface RcCompressToolArgs {
     ids: string[]
 }
 
+let summaryCallCounter = 0
+
+/** Unique per hidden summary request so provider usage can be attributed. */
+function nextSummaryCallId(): string {
+    summaryCallCounter += 1
+    return `c${summaryCallCounter.toString(36)}-${Date.now().toString(36)}-${Math.random()
+        .toString(36)
+        .slice(2, 8)}`
+}
+
 /**
  * Compress selections with a hidden, synchronous summary request.
  *
@@ -244,7 +261,12 @@ export function createRcCompressTool(ctx: ToolContext): ReturnType<typeof tool>
                     priorSummaries: plan.priorSummaries,
                 }))
 
-                const text = await generateSummaries(ctx, sessionID, segments)
+                const { text, usage } = await generateSummaries(ctx, sessionID, segments)
+                ctx.state.stats.compressionUsage = addCompressionUsageTotals(
+                    ctx.state.stats.compressionUsage,
+                    usage,
+                )
+                await saveSessionState(ctx.state, ctx.logger)
                 const accepted = await resolveAcceptedSections(
                     ctx,
                     plans.map((plan) => plan.selector.selector),
@@ -290,9 +312,24 @@ async function generateSummaries(
     ctx: ToolContext,
     sessionID: string,
     segments: SummarySegment[],
-): Promise<string> {
-    const prompt = buildSummaryPrompt(segments, ctx.state.idFormat)
-    let text = await ctx.generate({ sessionID, prompt })
+): Promise<{ text: string; usage: CompressionUsageTotals }> {
+    let usage = emptyCompressionUsage()
+
+    const summarize = async (promptSegments: SummarySegment[]): Promise<string> => {
+        const callId = nextSummaryCallId()
+        const prompt = buildSummaryPrompt(promptSegments, ctx.state.idFormat, callId)
+        const result = await ctx.generate({ sessionID, prompt, callId })
+        const text = result.text ?? ""
+        // Provider usage is authoritative; fall back to a local estimate when
+        // the plugin could not observe the underlying model call.
+        usage = addCompressionUsage(
+            usage,
+            result.usage ?? estimatedCompressionUsage(countTokens(prompt), countTokens(text)),
+        )
+        return text
+    }
+
+    let text = await summarize(segments)
 
     // One retry for sections the model failed to emit.
     for (let retry = 0; retry < 2; retry++) {
@@ -311,14 +348,13 @@ async function generateSummaries(
         if (retrySegments.length === 0) {
             break
         }
-        const retryPrompt = buildSummaryPrompt(retrySegments, ctx.state.idFormat)
         try {
-            text += "\n\n" + (await ctx.generate({ sessionID, prompt: retryPrompt }))
+            text += "\n\n" + (await summarize(retrySegments))
         } catch {
             break
         }
     }
-    return text
+    return { text, usage }
 }
 
 async function resolveAcceptedSections(

package/lib/compress/summary.ts

@@ -4,8 +4,34 @@ import { formatBlockRef, formatMessageRef, parseBoundaryId, type IdFormat } from
 /**
  * Marker embedded in the hidden summary prompt so the plugin can recognize its
  * own transient (`session.generate`) request and strip everything else from it.
+ * Requests carry a per-call suffix (`[[DCP-RC-SUMMARY:<callId>]]`) so captured
+ * provider usage can be attributed to a specific request.
  */
 export const RC_SUMMARY_MARKER = "[[DCP-RC-SUMMARY]]"
+/** Prefix shared by the static marker and its per-call variant. */
+export const RC_SUMMARY_MARKER_PREFIX = "[[DCP-RC-SUMMARY"
+
+function sanitizeCallId(callId: string): string {
+    return callId.replace(/[^A-Za-z0-9_-]/g, "-")
+}
+
+/** Marker line for a hidden summary request, optionally tagged with a call id. */
+export function buildSummaryMarker(callId?: string): string {
+    if (!callId) {
+        return RC_SUMMARY_MARKER
+    }
+    return `${RC_SUMMARY_MARKER_PREFIX}:${sanitizeCallId(callId)}]]`
+}
+
+/** True when the text contains a hidden summary marker, with or without a call id. */
+export function hasSummaryMarker(text: string): boolean {
+    return text.includes(RC_SUMMARY_MARKER_PREFIX)
+}
+
+/** Extract the call id from a hidden summary marker, when present. */
+export function extractSummaryCallId(text: string): string | undefined {
+    return text.match(/\[\[DCP-RC-SUMMARY:([A-Za-z0-9_-]+)\]\]/)?.[1]
+}
 
 export interface PriorSummary {
     /** Canonical block reference, e.g. `b2` or `@b2@`. */
@@ -134,6 +160,7 @@ const SUMMARY_RULES = `RULES
 export function buildSummaryPrompt(
     selectors: SummarySegment[],
     idFormat: IdFormat = "xml",
+    callId?: string,
 ): string {
     const selectorList = selectors.map((segment) => segment.selector)
     const example = selectorList[0] ?? (idFormat === "compact" ? "" : "m0004")
@@ -152,7 +179,7 @@ export function buildSummaryPrompt(
         })
         .join("\n\n")
 
-    return `${RC_SUMMARY_MARKER}
+    return `${buildSummaryMarker(callId)}
 
 You generate compressed-context entries for a coding session. Summarize ONLY the conversation segments listed below. Do not summarize anything else and do not ask questions.
 

package/lib/compress/types.ts

@@ -2,6 +2,14 @@ import type { PluginConfig } from "../config"
 import type { Logger } from "../logger"
 import type { PromptStore } from "../prompts/store"
 import type { CompressionBlock, CompressionMode, SessionState, WithParts } from "../state"
+import type { CompressionUsage } from "./usage"
+
+/** Result of the hidden transient model call (OpenCode V2 `session.generate`). */
+export interface GenerateSummaryResult {
+    text: string
+    /** Provider usage when captured, otherwise a local estimate. */
+    usage?: CompressionUsage
+}
 
 export interface ToolContext {
     client: any
@@ -10,7 +18,12 @@ export interface ToolContext {
     config: PluginConfig
     prompts: PromptStore
     /** Hidden transient model call (OpenCode V2 `session.generate`). */
-    generate: (input: { sessionID: string; prompt: string }) => Promise<string>
+    generate: (input: {
+        sessionID: string
+        prompt: string
+        /** Per-request id embedded in the prompt marker for usage attribution. */
+        callId?: string
+    }) => Promise<GenerateSummaryResult>
 }
 
 export interface BoundaryReference {

package/lib/compress/usage.ts

@@ -0,0 +1,168 @@
+/**
+ * Usage accounting for the hidden compression (summary) request.
+ *
+ * Provider-reported usage is preferred: OpenCode V2 generates the summary
+ * through `session.generate`, which does not surface token usage to the
+ * caller, so the numbers are captured by wrapping the resolved language
+ * model (`ctx.aisdk.hook("language")`) and reading the `finish` usage.
+ * When that path is unavailable, local tokenizer estimates are recorded
+ * instead so the plugin can still report an approximate cost.
+ */
+
+export type CompressionUsageSource = "provider" | "estimated"
+
+/** Usage of a single hidden compression request. */
+export interface CompressionUsage {
+    inputTokens: number
+    outputTokens: number
+    cacheReadTokens: number
+    cacheWriteTokens: number
+    reasoningTokens: number
+    source: CompressionUsageSource
+}
+
+/** Aggregated usage of all hidden compression requests in a session. */
+export interface CompressionUsageTotals {
+    calls: number
+    providerCalls: number
+    estimatedCalls: number
+    inputTokens: number
+    outputTokens: number
+    cacheReadTokens: number
+    cacheWriteTokens: number
+    reasoningTokens: number
+}
+
+export function emptyCompressionUsage(): CompressionUsageTotals {
+    return {
+        calls: 0,
+        providerCalls: 0,
+        estimatedCalls: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        reasoningTokens: 0,
+    }
+}
+
+function toCount(value: unknown, fallback = 0): number {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        return fallback
+    }
+    return Math.round(value)
+}
+
+/**
+ * Normalize AI SDK v3 usage (`{ inputTokens: { total, noCache, cacheRead,
+ * cacheWrite }, outputTokens: { total, text, reasoning } }`) into the plugin
+ * shape. Returns undefined when there is nothing usable to record.
+ */
+export function normalizeProviderUsage(raw: unknown): CompressionUsage | undefined {
+    if (!raw || typeof raw !== "object") {
+        return undefined
+    }
+
+    const value = raw as { inputTokens?: unknown; outputTokens?: unknown }
+    const input =
+        value.inputTokens && typeof value.inputTokens === "object"
+            ? (value.inputTokens as Record<string, unknown>)
+            : {}
+    const output =
+        value.outputTokens && typeof value.outputTokens === "object"
+            ? (value.outputTokens as Record<string, unknown>)
+            : {}
+
+    const cacheRead = toCount(input.cacheRead)
+    const cacheWrite = toCount(input.cacheWrite)
+    const uncached = toCount(input.noCache)
+    const inputFromParts = uncached + cacheRead + cacheWrite
+    const inputTotal = Math.max(toCount(input.total, inputFromParts), inputFromParts)
+
+    const reasoning = toCount(output.reasoning)
+    const outputTotal = Math.max(toCount(output.total, toCount(output.text) + reasoning), reasoning)
+
+    if (
+        inputTotal === 0 &&
+        outputTotal === 0 &&
+        cacheRead === 0 &&
+        cacheWrite === 0 &&
+        reasoning === 0
+    ) {
+        return undefined
+    }
+
+    return {
+        inputTokens: inputTotal,
+        outputTokens: outputTotal,
+        cacheReadTokens: cacheRead,
+        cacheWriteTokens: cacheWrite,
+        reasoningTokens: reasoning,
+        source: "provider",
+    }
+}
+
+/** Local fallback when the provider did not report usage. */
+export function estimatedCompressionUsage(
+    inputTokens: number,
+    outputTokens: number,
+): CompressionUsage {
+    return {
+        inputTokens: toCount(inputTokens),
+        outputTokens: toCount(outputTokens),
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        reasoningTokens: 0,
+        source: "estimated",
+    }
+}
+
+export function addCompressionUsage(
+    totals: CompressionUsageTotals,
+    usage: CompressionUsage,
+): CompressionUsageTotals {
+    return {
+        calls: totals.calls + 1,
+        providerCalls: totals.providerCalls + (usage.source === "provider" ? 1 : 0),
+        estimatedCalls: totals.estimatedCalls + (usage.source === "estimated" ? 1 : 0),
+        inputTokens: totals.inputTokens + usage.inputTokens,
+        outputTokens: totals.outputTokens + usage.outputTokens,
+        cacheReadTokens: totals.cacheReadTokens + usage.cacheReadTokens,
+        cacheWriteTokens: totals.cacheWriteTokens + usage.cacheWriteTokens,
+        reasoningTokens: totals.reasoningTokens + usage.reasoningTokens,
+    }
+}
+
+export function addCompressionUsageTotals(
+    totals: CompressionUsageTotals,
+    other: CompressionUsageTotals,
+): CompressionUsageTotals {
+    return {
+        calls: totals.calls + other.calls,
+        providerCalls: totals.providerCalls + other.providerCalls,
+        estimatedCalls: totals.estimatedCalls + other.estimatedCalls,
+        inputTokens: totals.inputTokens + other.inputTokens,
+        outputTokens: totals.outputTokens + other.outputTokens,
+        cacheReadTokens: totals.cacheReadTokens + other.cacheReadTokens,
+        cacheWriteTokens: totals.cacheWriteTokens + other.cacheWriteTokens,
+        reasoningTokens: totals.reasoningTokens + other.reasoningTokens,
+    }
+}
+
+/** Backward-compatible load of persisted totals. */
+export function normalizeCompressionUsageTotals(value: unknown): CompressionUsageTotals {
+    if (!value || typeof value !== "object") {
+        return emptyCompressionUsage()
+    }
+    const raw = value as Record<string, unknown>
+    return {
+        calls: toCount(raw.calls),
+        providerCalls: toCount(raw.providerCalls),
+        estimatedCalls: toCount(raw.estimatedCalls),
+        inputTokens: toCount(raw.inputTokens),
+        outputTokens: toCount(raw.outputTokens),
+        cacheReadTokens: toCount(raw.cacheReadTokens),
+        cacheWriteTokens: toCount(raw.cacheWriteTokens),
+        reasoningTokens: toCount(raw.reasoningTokens),
+    }
+}

package/lib/config.ts

@@ -35,6 +35,8 @@ export interface CompressConfig {
     protectedTools: string[]
     protectTags: boolean
     protectUserMessages: boolean
+    scrubModelOutput: boolean
+    scrubMessageIds: boolean
 }
 
 export interface Commands {
@@ -131,6 +133,8 @@ export const VALID_CONFIG_KEYS = new Set([
     "compress.protectedTools",
     "compress.protectTags",
     "compress.protectUserMessages",
+    "compress.scrubModelOutput",
+    "compress.scrubMessageIds",
     "strategies",
     "strategies.deduplication",
     "strategies.deduplication.enabled",
@@ -432,6 +436,28 @@ export function validateConfigTypes(config: Record<string, any>): ValidationErro
                 })
             }
 
+            if (
+                compress.scrubModelOutput !== undefined &&
+                typeof compress.scrubModelOutput !== "boolean"
+            ) {
+                errors.push({
+                    key: "compress.scrubModelOutput",
+                    expected: "boolean",
+                    actual: typeof compress.scrubModelOutput,
+                })
+            }
+
+            if (
+                compress.scrubMessageIds !== undefined &&
+                typeof compress.scrubMessageIds !== "boolean"
+            ) {
+                errors.push({
+                    key: "compress.scrubMessageIds",
+                    expected: "boolean",
+                    actual: typeof compress.scrubMessageIds,
+                })
+            }
+
             if (
                 typeof compress.iterationNudgeThreshold === "number" &&
                 compress.iterationNudgeThreshold < 1
@@ -676,6 +702,8 @@ const defaultConfig: PluginConfig = {
         protectedTools: [...COMPRESS_DEFAULT_PROTECTED_TOOLS],
         protectTags: false,
         protectUserMessages: false,
+        scrubModelOutput: true,
+        scrubMessageIds: true,
     },
     strategies: {
         deduplication: {
@@ -844,6 +872,8 @@ function mergeCompress(
         protectedTools: [...new Set([...base.protectedTools, ...(override.protectedTools ?? [])])],
         protectTags: override.protectTags ?? base.protectTags,
         protectUserMessages: override.protectUserMessages ?? base.protectUserMessages,
+        scrubModelOutput: override.scrubModelOutput ?? base.scrubModelOutput,
+        scrubMessageIds: override.scrubMessageIds ?? base.scrubMessageIds,
     }
 }
 

package/lib/prompts/context-limit-nudge.ts

@@ -14,5 +14,7 @@ Avoid the newest active working messages unless it is clearly closed.
 SUMMARY REQUIREMENTS
 Your summary MUST cover all essential details from the selected messages so work can continue.
 If the compressed range includes user messages, preserve user intent exactly. Prefer direct quotes for short user messages to avoid semantic drift.
+
+Never repeat or quote this reminder in your reply.
 </dcp-system-reminder>
 `

package/lib/prompts/extensions/system.ts

@@ -6,6 +6,8 @@ Only use the compress tool after seeing \`<compress triggered manually>\` in the
 Issue exactly ONE compress tool per manual trigger. Do NOT launch multiple compress tools in parallel. Each trigger grants a single compression; after it completes, wait for the next trigger.
 
 After completing a manually triggered context-management action, STOP IMMEDIATELY. Do NOT continue with any task execution. End your response right after the tool use completes and wait for the next user input.
+
+Never repeat this notice in your reply.
 </dcp-system-reminder>
 `
 
@@ -15,6 +17,8 @@ You are operating in a subagent environment.
 The initial subagent instruction is imperative and must be followed exactly.
 It is the only user message intentionally not assigned a message ID, and therefore is not eligible for compression.
 All subsequent messages in the session will have IDs.
+
+Never repeat this notice in your reply.
 </dcp-system-reminder>
 `
 

package/lib/prompts/iteration-nudge.ts

@@ -2,5 +2,7 @@ export const ITERATION_NUDGE = `<dcp-system-reminder>
 You've been iterating for a while after the last user message.
 
 If there is a closed portion that is unlikely to be referenced immediately (for example, finished research before implementation), use the compress tool on it now.
+
+Never repeat or quote this reminder in your reply.
 </dcp-system-reminder>
 `

package/lib/prompts/system.ts

@@ -8,7 +8,7 @@ You operate in a context-constrained environment. Manage context continuously to
 
 The ONLY tool you have for context management is \`compress\`. It replaces older conversation content with compact technical summaries.
 
-${markers} and \`<dcp-system-reminder>\` tags are environment-injected metadata. Do not output them.
+${markers} and \`<dcp-system-reminder>\` tags are environment-injected metadata. Do not output, quote, or mention them in your replies or reasoning.
 
 THE PHILOSOPHY OF COMPRESS
 \`compress\` transforms conversation content into dense, high-fidelity summaries. This is not cleanup - it is crystallization. Your summary becomes the authoritative record of what transpired.

package/lib/prompts/turn-nudge.ts

@@ -6,5 +6,7 @@ If direction has shifted, compress earlier ranges that are now less relevant.
 
 The goal is to filter noise and distill key information so context accumulation stays under control.
 Keep active context uncompressed.
+
+Never repeat or quote this reminder in your reply.
 </dcp-system-reminder>
 `

package/lib/state/persistence.ts

@@ -10,6 +10,12 @@ import { homedir } from "os"
 import { join } from "path"
 import type { CompressionBlock, PrunedMessageEntry, SessionState, SessionStats } from "./types"
 import type { Logger } from "../logger"
+import {
+    addCompressionUsageTotals,
+    emptyCompressionUsage,
+    normalizeCompressionUsageTotals,
+    type CompressionUsageTotals,
+} from "../compress/usage"
 import { serializePruneMessagesState } from "./utils"
 
 /** Prune state as stored on disk */
@@ -227,6 +233,7 @@ function emptyPersistedState(manualMode: boolean): PersistedSessionState {
         stats: {
             pruneTokenCounter: 0,
             totalPruneTokens: 0,
+            compressionUsage: emptyCompressionUsage(),
         },
         lastUpdated: new Date().toISOString(),
     }
@@ -257,6 +264,7 @@ export interface AggregatedStats {
     totalTools: number
     totalMessages: number
     sessionCount: number
+    compressionUsage: CompressionUsageTotals
 }
 
 export async function loadAllSessionStats(logger: Logger): Promise<AggregatedStats> {
@@ -265,6 +273,7 @@ export async function loadAllSessionStats(logger: Logger): Promise<AggregatedSta
         totalTools: 0,
         totalMessages: 0,
         sessionCount: 0,
+        compressionUsage: emptyCompressionUsage(),
     }
 
     try {
@@ -281,14 +290,21 @@ export async function loadAllSessionStats(logger: Logger): Promise<AggregatedSta
                 const content = await fs.readFile(filePath, "utf-8")
                 const state = JSON.parse(content) as PersistedSessionState
 
-                if (state?.stats?.totalPruneTokens && state?.prune) {
-                    result.totalTokens += state.stats.totalPruneTokens
+                const usage = normalizeCompressionUsageTotals(state?.stats?.compressionUsage)
+                const hasUsage = usage.calls > 0
+
+                if (state?.prune && (state?.stats?.totalPruneTokens || hasUsage)) {
+                    result.totalTokens += state.stats?.totalPruneTokens || 0
                     result.totalTools += state.prune.tools
                         ? Object.keys(state.prune.tools).length
                         : 0
                     result.totalMessages += state.prune.messages?.byMessageId
                         ? Object.keys(state.prune.messages.byMessageId).length
                         : 0
+                    result.compressionUsage = addCompressionUsageTotals(
+                        result.compressionUsage,
+                        usage,
+                    )
                     result.sessionCount++
                 }
             } catch {

package/lib/state/state.ts

@@ -1,5 +1,6 @@
 import type { SessionState, ToolParameterEntry, WithParts } from "./types"
 import type { Logger } from "../logger"
+import { emptyCompressionUsage, normalizeCompressionUsageTotals } from "../compress/usage"
 import { applyPendingCompressionDurations } from "../compress/timing"
 import { loadManualModeSetting, loadSessionState, saveSessionState } from "./persistence"
 import {
@@ -84,6 +85,7 @@ export function createSessionState(idFormat: IdFormat = "xml"): SessionState {
         stats: {
             pruneTokenCounter: 0,
             totalPruneTokens: 0,
+            compressionUsage: emptyCompressionUsage(),
         },
         compressionTiming: {
             startsByCallId: new Map<string, number>(),
@@ -122,6 +124,7 @@ export function resetSessionState(state: SessionState): void {
     state.stats = {
         pruneTokenCounter: 0,
         totalPruneTokens: 0,
+        compressionUsage: emptyCompressionUsage(),
     }
     state.toolParameters.clear()
     state.subAgentResultCache.clear()
@@ -186,6 +189,7 @@ export async function ensureSessionInitialized(
     state.stats = {
         pruneTokenCounter: persisted.stats?.pruneTokenCounter || 0,
         totalPruneTokens: persisted.stats?.totalPruneTokens || 0,
+        compressionUsage: normalizeCompressionUsageTotals(persisted.stats?.compressionUsage),
     }
 
     const applied = applyPendingCompressionDurations(state)

package/lib/state/types.ts

@@ -1,4 +1,5 @@
 import type { CompressionTimingState } from "../compress/timing"
+import type { CompressionUsageTotals } from "../compress/usage"
 import type { IdFormat } from "../message-ids"
 import { Message, Part } from "@opencode-ai/sdk/v2"
 
@@ -22,6 +23,8 @@ export interface ToolParameterEntry {
 export interface SessionStats {
     pruneTokenCounter: number
     totalPruneTokens: number
+    /** Token usage of the hidden compression (summary) requests. */
+    compressionUsage: CompressionUsageTotals
 }
 
 export interface PrunedMessageEntry {

package/lib/tui/dialogs.tsx

@@ -121,6 +121,24 @@ export function StatsDialog(props: { api: ViewApi; report: StatsReport; onBack:
                     label="Messages pruned"
                     value={`${props.report.sessionMessages}`}
                 />
+                <Metric
+                    theme={theme}
+                    label="Summary requests"
+                    value={`${props.report.sessionCompressionUsage.calls}`}
+                    hint={`${props.report.sessionCompressionUsage.providerCalls} provider · ${props.report.sessionCompressionUsage.estimatedCalls} estimated`}
+                />
+                <Metric
+                    theme={theme}
+                    label="Request in|out"
+                    value={`~${formatTokenCount(props.report.sessionCompressionUsage.inputTokens)} | ~${formatTokenCount(props.report.sessionCompressionUsage.outputTokens)}`}
+                    hint="tokens"
+                />
+                <Metric
+                    theme={theme}
+                    label="Request cache r|w"
+                    value={`~${formatTokenCount(props.report.sessionCompressionUsage.cacheReadTokens)} | ~${formatTokenCount(props.report.sessionCompressionUsage.cacheWriteTokens)}`}
+                    hint={`reasoning ~${formatTokenCount(props.report.sessionCompressionUsage.reasoningTokens)}`}
+                />
             </Card>
             <Card theme={theme} title="All time">
                 <Metric
@@ -144,6 +162,12 @@ export function StatsDialog(props: { api: ViewApi; report: StatsReport; onBack:
                     label="Sessions with DCP history"
                     value={`${props.report.allTime.sessionCount}`}
                 />
+                <Metric
+                    theme={theme}
+                    label="Summary requests"
+                    value={`${props.report.allTime.compressionUsage.calls}`}
+                    hint={`~${formatTokenCount(props.report.allTime.compressionUsage.inputTokens)} in · ~${formatTokenCount(props.report.allTime.compressionUsage.outputTokens)} out`}
+                />
             </Card>
         </DcpFrame>
     )