@royalcat/opencode-dcp-rc 4.0.0 → 4.0.1

package/dist/index.js

@@ -2250,6 +2250,102 @@ import { existsSync as existsSync4 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join4 } from "path";
 
+// lib/compress/usage.ts
+function emptyCompressionUsage() {
+  return {
+    calls: 0,
+    providerCalls: 0,
+    estimatedCalls: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    reasoningTokens: 0
+  };
+}
+function toCount(value, fallback = 0) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return fallback;
+  }
+  return Math.round(value);
+}
+function normalizeProviderUsage(raw) {
+  if (!raw || typeof raw !== "object") {
+    return void 0;
+  }
+  const value = raw;
+  const input = value.inputTokens && typeof value.inputTokens === "object" ? value.inputTokens : {};
+  const output2 = value.outputTokens && typeof value.outputTokens === "object" ? value.outputTokens : {};
+  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(output2.reasoning);
+  const outputTotal = Math.max(toCount(output2.total, toCount(output2.text) + reasoning), reasoning);
+  if (inputTotal === 0 && outputTotal === 0 && cacheRead === 0 && cacheWrite === 0 && reasoning === 0) {
+    return void 0;
+  }
+  return {
+    inputTokens: inputTotal,
+    outputTokens: outputTotal,
+    cacheReadTokens: cacheRead,
+    cacheWriteTokens: cacheWrite,
+    reasoningTokens: reasoning,
+    source: "provider"
+  };
+}
+function estimatedCompressionUsage(inputTokens, outputTokens) {
+  return {
+    inputTokens: toCount(inputTokens),
+    outputTokens: toCount(outputTokens),
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    reasoningTokens: 0,
+    source: "estimated"
+  };
+}
+function addCompressionUsage(totals, usage) {
+  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
+  };
+}
+function addCompressionUsageTotals(totals, other) {
+  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
+  };
+}
+function normalizeCompressionUsageTotals(value) {
+  if (!value || typeof value !== "object") {
+    return emptyCompressionUsage();
+  }
+  const raw = value;
+  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)
+  };
+}
+
 // lib/messages/shape.ts
 function isMessageWithInfo(message) {
   if (!message || typeof message !== "object") {
@@ -2824,7 +2920,8 @@ function emptyPersistedState(manualMode) {
     },
     stats: {
       pruneTokenCounter: 0,
-      totalPruneTokens: 0
+      totalPruneTokens: 0,
+      compressionUsage: emptyCompressionUsage()
     },
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -2845,7 +2942,8 @@ async function loadAllSessionStats(logger) {
     totalTokens: 0,
     totalTools: 0,
     totalMessages: 0,
-    sessionCount: 0
+    sessionCount: 0,
+    compressionUsage: emptyCompressionUsage()
   };
   try {
     if (!existsSync4(STORAGE_DIR)) {
@@ -2858,10 +2956,16 @@ async function loadAllSessionStats(logger) {
         const filePath = join4(STORAGE_DIR, file);
         const content = await fs.readFile(filePath, "utf-8");
         const state = JSON.parse(content);
-        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 {
@@ -3302,7 +3406,8 @@ function createSessionState(idFormat = "xml") {
     },
     stats: {
       pruneTokenCounter: 0,
-      totalPruneTokens: 0
+      totalPruneTokens: 0,
+      compressionUsage: emptyCompressionUsage()
     },
     compressionTiming: {
       startsByCallId: /* @__PURE__ */ new Map(),
@@ -3339,7 +3444,8 @@ function resetSessionState(state) {
   };
   state.stats = {
     pruneTokenCounter: 0,
-    totalPruneTokens: 0
+    totalPruneTokens: 0,
+    compressionUsage: emptyCompressionUsage()
   };
   state.toolParameters.clear();
   state.subAgentResultCache.clear();
@@ -3385,7 +3491,8 @@ async function ensureSessionInitialized(client, state, sessionId, logger, messag
   );
   state.stats = {
     pruneTokenCounter: persisted.stats?.pruneTokenCounter || 0,
-    totalPruneTokens: persisted.stats?.totalPruneTokens || 0
+    totalPruneTokens: persisted.stats?.totalPruneTokens || 0,
+    compressionUsage: normalizeCompressionUsageTotals(persisted.stats?.compressionUsage)
   };
   const applied = applyPendingCompressionDurations(state);
   if (applied > 0) {
@@ -4562,6 +4669,22 @@ ${output2}`);
 
 // lib/compress/summary.ts
 var RC_SUMMARY_MARKER = "[[DCP-RC-SUMMARY]]";
+var RC_SUMMARY_MARKER_PREFIX = "[[DCP-RC-SUMMARY";
+function sanitizeCallId(callId) {
+  return callId.replace(/[^A-Za-z0-9_-]/g, "-");
+}
+function buildSummaryMarker(callId) {
+  if (!callId) {
+    return RC_SUMMARY_MARKER;
+  }
+  return `${RC_SUMMARY_MARKER_PREFIX}:${sanitizeCallId(callId)}]]`;
+}
+function hasSummaryMarker(text) {
+  return text.includes(RC_SUMMARY_MARKER_PREFIX);
+}
+function extractSummaryCallId(text) {
+  return text.match(/\[\[DCP-RC-SUMMARY:([A-Za-z0-9_-]+)\]\]/)?.[1];
+}
 function stringify(value) {
   if (typeof value === "string") {
     return value;
@@ -4641,7 +4764,7 @@ var SUMMARY_RULES = `RULES
 - Preserve every high-signal detail: user intent (quote short user messages exactly), decisions, constraints, file paths, function and symbol names, commands run, key findings, errors, verification results, and any subagent task IDs with their scope and completion state.
 - Drop noise: failed attempts that led nowhere, repeated tool output, exploration that produced no durable result.
 - Be dense and precise. Prefer terse technical wording over narrative.`;
-function buildSummaryPrompt(selectors, idFormat = "xml") {
+function buildSummaryPrompt(selectors, idFormat = "xml", callId) {
   const selectorList = selectors.map((segment) => segment.selector);
   const example = selectorList[0] ?? (idFormat === "compact" ? "" : "m0004");
   const body = selectors.map((segment) => {
@@ -4652,7 +4775,7 @@ ${prior.body.trim()}`
     ).join("\n\n");
     return [messageBody, priorBody].filter((part) => part.length > 0).join("\n\n");
   }).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.
 
@@ -4759,6 +4882,11 @@ function parseSummarySections(text, expected, idFormat = "xml") {
 }
 
 // lib/compress/rc.ts
+var summaryCallCounter = 0;
+function nextSummaryCallId() {
+  summaryCallCounter += 1;
+  return `c${summaryCallCounter.toString(36)}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
 function validateArgs(args) {
   if (!args || typeof args !== "object") {
     throw new Error("compress requires an object argument with an `ids` array");
@@ -4905,7 +5033,12 @@ function createRcCompressTool(ctx) {
           messages: plan.messages,
           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),
@@ -4944,8 +5077,19 @@ function createRcCompressTool(ctx) {
   });
 }
 async function generateSummaries(ctx, sessionID, segments) {
-  const prompt = buildSummaryPrompt(segments, ctx.state.idFormat);
-  let text = await ctx.generate({ sessionID, prompt });
+  let usage = emptyCompressionUsage();
+  const summarize = async (promptSegments) => {
+    const callId = nextSummaryCallId();
+    const prompt = buildSummaryPrompt(promptSegments, ctx.state.idFormat, callId);
+    const result = await ctx.generate({ sessionID, prompt, callId });
+    const text2 = result.text ?? "";
+    usage = addCompressionUsage(
+      usage,
+      result.usage ?? estimatedCompressionUsage(countTokens2(prompt), countTokens2(text2))
+    );
+    return text2;
+  };
+  let text = await summarize(segments);
   for (let retry = 0; retry < 2; retry++) {
     const parsed = parseSummarySections(
       text,
@@ -4962,14 +5106,13 @@ async function generateSummaries(ctx, sessionID, segments) {
     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(ctx, selectors, text) {
   const parsed = parseSummarySections(text, selectors, ctx.state.idFormat);
@@ -5081,6 +5224,318 @@ async function resetManualMode(ctx, sessionID) {
   await saveSessionState(ctx.state, ctx.logger);
 }
 
+// lib/v2/usage.ts
+function createCompressionUsageTracker() {
+  const pending = /* @__PURE__ */ new Map();
+  const entry = (callId) => {
+    let current = pending.get(callId);
+    if (!current) {
+      current = {};
+      pending.set(callId, current);
+    }
+    return current;
+  };
+  return {
+    recordProvider(callId, usage) {
+      entry(callId).provider = usage;
+    },
+    recordEstimatedInput(callId, inputTokens) {
+      if (Number.isFinite(inputTokens) && inputTokens > 0) {
+        entry(callId).estimatedInput = Math.round(inputTokens);
+      }
+    },
+    resolve(callId, outputText) {
+      const current = pending.get(callId);
+      if (!current) {
+        return void 0;
+      }
+      if (current.provider) {
+        return current.provider;
+      }
+      if (current.estimatedInput === void 0) {
+        return void 0;
+      }
+      return estimatedCompressionUsage(current.estimatedInput, countTokens2(outputText));
+    },
+    discard(callId) {
+      pending.delete(callId);
+    }
+  };
+}
+function findSummaryCallId(options) {
+  const texts = [];
+  collectTexts(options?.prompt, texts);
+  for (const text of texts) {
+    const callId = extractSummaryCallId(text);
+    if (callId) {
+      return callId;
+    }
+  }
+  return void 0;
+}
+function collectTexts(value, out, depth = 0) {
+  if (depth > 8 || out.length > 200) {
+    return;
+  }
+  if (typeof value === "string") {
+    out.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectTexts(item, out, depth + 1);
+    }
+    return;
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    if (typeof record.text === "string") {
+      out.push(record.text);
+    }
+    if (typeof record.content === "string") {
+      out.push(record.content);
+    } else if (Array.isArray(record.content)) {
+      collectTexts(record.content, out, depth + 1);
+    }
+  }
+}
+function wrapLanguageModel(model, tracker, logger) {
+  return new Proxy(model, {
+    get(target, property, receiver) {
+      if (property === "doStream") {
+        return (options) => trackedStream(target, options, tracker, logger);
+      }
+      if (property === "doGenerate") {
+        return (options) => trackedGenerate(target, options, tracker, logger);
+      }
+      return Reflect.get(target, property, receiver);
+    }
+  });
+}
+async function trackedStream(target, options, tracker, logger) {
+  const result = await target.doStream(options);
+  const callId = findSummaryCallId(options);
+  logger.debug("Compression usage stream call", { callId: callId ?? null });
+  const TransformStreamImpl = globalThis.TransformStream;
+  if (!callId || typeof result?.stream?.pipeThrough !== "function") {
+    return result;
+  }
+  if (typeof TransformStreamImpl !== "function") {
+    return result;
+  }
+  let recorded = false;
+  const transform = new TransformStreamImpl({
+    transform(part, controller) {
+      try {
+        if (!recorded && part?.type === "finish" && part.usage) {
+          const usage = normalizeProviderUsage(part.usage);
+          if (usage) {
+            recorded = true;
+            tracker.recordProvider(callId, usage);
+          }
+        }
+      } catch {
+      }
+      controller.enqueue(part);
+    }
+  });
+  return { ...result, stream: result.stream.pipeThrough(transform) };
+}
+async function trackedGenerate(target, options, tracker, logger) {
+  const result = await target.doGenerate(options);
+  const callId = findSummaryCallId(options);
+  logger.debug("Compression usage generate call", { callId: callId ?? null });
+  if (!callId) {
+    return result;
+  }
+  const usage = normalizeProviderUsage(result?.usage);
+  if (usage) {
+    tracker.recordProvider(callId, usage);
+  }
+  return result;
+}
+async function installCompressionUsageHook(ctx, tracker, logger) {
+  const aisdk = ctx?.aisdk;
+  if (!aisdk || typeof aisdk.hook !== "function") {
+    logger.debug("aisdk hook unavailable; compression usage will be estimated");
+    return;
+  }
+  try {
+    await aisdk.hook("language", (event) => {
+      try {
+        const isModel = (candidate) => !!candidate && typeof candidate.doStream === "function";
+        logger.debug("Compression usage hook event", {
+          modelID: event?.model?.modelID ?? event?.model?.id ?? null,
+          hasLanguage: isModel(event?.language),
+          hasFactory: typeof event?.sdk?.languageModel === "function"
+        });
+        let model = isModel(event?.language) ? event.language : void 0;
+        if (!model && typeof event?.sdk?.languageModel === "function") {
+          model = event.sdk.languageModel(
+            event?.model?.modelID ?? event?.model?.id
+          );
+        }
+        if (!isModel(model)) {
+          return;
+        }
+        event.language = wrapLanguageModel(model, tracker, logger);
+      } catch (error) {
+        logger.debug("Compression usage hook could not wrap language model", {
+          error: error?.message
+        });
+      }
+    });
+    logger.debug("Compression usage hook installed");
+  } catch (error) {
+    logger.warn("Compression usage hook registration failed", {
+      error: error?.message
+    });
+  }
+}
+function emptyUsageAccumulator() {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    reasoning: 0,
+    exclusiveInput: false
+  };
+}
+function usageField(key) {
+  switch (key) {
+    case "input_tokens":
+    case "prompt_tokens":
+    case "promptTokenCount":
+      return "input";
+    case "output_tokens":
+    case "completion_tokens":
+    case "candidatesTokenCount":
+      return "output";
+    case "cache_read_input_tokens":
+    case "cache_creation_input_tokens":
+    case "cached_tokens":
+    case "cachedContentTokenCount":
+      return key === "cache_creation_input_tokens" ? "cacheWrite" : "cacheRead";
+    case "reasoning_tokens":
+    case "thoughtsTokenCount":
+      return "reasoning";
+    default:
+      return void 0;
+  }
+}
+function scanUsage(value, acc, depth) {
+  if (depth > 8 || !value || typeof value !== "object") {
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      scanUsage(item, acc, depth + 1);
+    }
+    return;
+  }
+  for (const [key, raw] of Object.entries(value)) {
+    const field = usageField(key);
+    if (field && typeof raw === "number" && Number.isFinite(raw)) {
+      acc[field] = Math.max(acc[field], raw);
+      if (key === "cache_read_input_tokens" || key === "cache_creation_input_tokens") {
+        acc.exclusiveInput = true;
+      }
+      continue;
+    }
+    if (raw && typeof raw === "object") {
+      scanUsage(raw, acc, depth + 1);
+    }
+  }
+}
+function usageFromAccumulator(acc) {
+  const input = acc.exclusiveInput ? acc.input + acc.cacheRead + acc.cacheWrite : acc.input;
+  const usage = {
+    inputTokens: Math.max(0, Math.round(input)),
+    outputTokens: Math.max(0, Math.round(acc.output)),
+    cacheReadTokens: Math.max(0, Math.round(acc.cacheRead)),
+    cacheWriteTokens: Math.max(0, Math.round(acc.cacheWrite)),
+    reasoningTokens: Math.max(0, Math.round(acc.reasoning)),
+    source: "provider"
+  };
+  const total = usage.inputTokens + usage.outputTokens + usage.cacheReadTokens + usage.cacheWriteTokens + usage.reasoningTokens;
+  return total > 0 ? usage : void 0;
+}
+function parseProviderUsageFromBody(body) {
+  const acc = emptyUsageAccumulator();
+  const trimmed = body.trim();
+  let parsedJson = false;
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      scanUsage(JSON.parse(trimmed), acc, 0);
+      parsedJson = true;
+    } catch {
+    }
+  }
+  if (!parsedJson) {
+    for (const line of body.split(/\r?\n/)) {
+      const match = /^\s*data:\s*(.*)$/.exec(line);
+      if (!match) {
+        continue;
+      }
+      const payload = match[1].trim();
+      if (!payload || payload === "[DONE]") {
+        continue;
+      }
+      try {
+        scanUsage(JSON.parse(payload), acc, 0);
+      } catch {
+      }
+    }
+  }
+  return usageFromAccumulator(acc);
+}
+async function installHttpUsageHook(ctx, tracker, logger) {
+  const session2 = ctx?.session;
+  if (!session2 || typeof session2.hook !== "function") {
+    return;
+  }
+  try {
+    await session2.hook("http.response", async (event) => {
+      if (event?.kind !== "generate") {
+        return;
+      }
+      try {
+        const request = event.request;
+        const response = event.response;
+        if (!request || typeof request.clone !== "function") {
+          return;
+        }
+        const callId = extractSummaryCallId(await request.clone().text());
+        if (!callId) {
+          return;
+        }
+        if (!response || typeof response.clone !== "function") {
+          return;
+        }
+        const usage = parseProviderUsageFromBody(await response.clone().text());
+        if (usage) {
+          tracker.recordProvider(callId, usage);
+          logger.debug("Compression usage captured from http response", {
+            callId,
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens
+          });
+        }
+      } catch (error) {
+        logger.debug("Compression usage http capture failed", {
+          error: error?.message
+        });
+      }
+    });
+    logger.debug("Compression usage http hook installed");
+  } catch (error) {
+    logger.warn("Compression usage http hook registration failed", {
+      error: error?.message
+    });
+  }
+}
+
 // lib/prompts/index.ts
 function renderSystemPrompt(prompts, protectedToolsExtension, manual, subagent) {
   const extensions = [];
@@ -6592,7 +7047,7 @@ async function handleRecompressCommand(ctx) {
 }
 
 // lib/commands/stats.ts
-function formatStatsMessage(sessionTokens, sessionSummaryTokens, sessionTools, sessionMessages, sessionDurationMs, allTime) {
+function formatStatsMessage(sessionTokens, sessionSummaryTokens, sessionTools, sessionMessages, sessionDurationMs, sessionUsage, allTime) {
   const lines = [];
   lines.push("\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E");
   lines.push("\u2502                    DCP Statistics                         \u2502");
@@ -6607,6 +7062,16 @@ function formatStatsMessage(sessionTokens, sessionSummaryTokens, sessionTools, s
   lines.push(`  Time:             ${formatCompressionTime(sessionDurationMs)}`);
   lines.push(`  Messages:         ${sessionMessages}`);
   lines.push(`  Tools:            ${sessionTools}`);
+  lines.push(
+    `  Summary requests: ${sessionUsage.calls} (${sessionUsage.providerCalls} provider, ${sessionUsage.estimatedCalls} estimated)`
+  );
+  lines.push(
+    `  Request in|out:   ~${formatTokenCount(sessionUsage.inputTokens)} | ~${formatTokenCount(sessionUsage.outputTokens)}`
+  );
+  lines.push(
+    `  Request cache:    ~${formatTokenCount(sessionUsage.cacheReadTokens)} read | ~${formatTokenCount(sessionUsage.cacheWriteTokens)} write`
+  );
+  lines.push(`  Request reason:   ~${formatTokenCount(sessionUsage.reasoningTokens)}`);
   lines.push("");
   lines.push("All-time:");
   lines.push("\u2500".repeat(60));
@@ -6614,6 +7079,9 @@ function formatStatsMessage(sessionTokens, sessionSummaryTokens, sessionTools, s
   lines.push(`  Tools pruned:     ${allTime.totalTools}`);
   lines.push(`  Messages pruned:  ${allTime.totalMessages}`);
   lines.push(`  Sessions:         ${allTime.sessionCount}`);
+  lines.push(
+    `  Summary requests: ${allTime.compressionUsage.calls} (~${formatTokenCount(allTime.compressionUsage.inputTokens)} in | ~${formatTokenCount(allTime.compressionUsage.outputTokens)} out)`
+  );
   return lines.join("\n");
 }
 function formatCompressionRatio(inputTokens, outputTokens) {
@@ -6653,6 +7121,7 @@ async function handleStatsCommand(ctx) {
     report2.sessionTools,
     report2.sessionMessages,
     report2.sessionDurationMs,
+    report2.sessionCompressionUsage,
     report2.allTime
   );
   const params = getCurrentParams(state, messages, logger);
@@ -6663,9 +7132,11 @@ async function handleStatsCommand(ctx) {
     sessionTools: report2.sessionTools,
     sessionMessages: report2.sessionMessages,
     sessionDurationMs: report2.sessionDurationMs,
+    sessionCompressionUsage: report2.sessionCompressionUsage,
     allTimeTokens: report2.allTime.totalTokens,
     allTimeTools: report2.allTime.totalTools,
-    allTimeMessages: report2.allTime.totalMessages
+    allTimeMessages: report2.allTime.totalMessages,
+    allTimeCompressionUsage: report2.allTime.compressionUsage
   });
 }
 async function buildStatsReport(state, logger) {
@@ -6687,6 +7158,7 @@ async function buildStatsReport(state, logger) {
     }
   }
   const sessionTools = prunedToolIds.size;
+  const sessionCompressionUsage = normalizeCompressionUsageTotals(state.stats.compressionUsage);
   let sessionMessages = 0;
   for (const entry of state.prune.messages.byMessageId.values()) {
     if (entry.activeBlockIds.length > 0) {
@@ -6700,6 +7172,7 @@ async function buildStatsReport(state, logger) {
     sessionTools,
     sessionMessages,
     sessionDurationMs,
+    sessionCompressionUsage,
     allTime
   };
 }
@@ -7235,17 +7708,29 @@ function project(native, entries, session2) {
 import { tool as tool2 } from "@opencode-ai/plugin";
 var z = tool2.schema;
 var session = z.object({ sessionID: z.string() });
+var compressionUsage = z.object({
+  calls: z.number(),
+  providerCalls: z.number(),
+  estimatedCalls: z.number(),
+  inputTokens: z.number(),
+  outputTokens: z.number(),
+  cacheReadTokens: z.number(),
+  cacheWriteTokens: z.number(),
+  reasoningTokens: z.number()
+});
 var stats = z.object({
   sessionTokens: z.number(),
   sessionSummaryTokens: z.number(),
   sessionDurationMs: z.number(),
   sessionTools: z.number(),
   sessionMessages: z.number(),
+  sessionCompressionUsage: compressionUsage,
   allTime: z.object({
     totalTokens: z.number(),
     totalTools: z.number(),
     totalMessages: z.number(),
-    sessionCount: z.number()
+    sessionCount: z.number(),
+    compressionUsage
   })
 });
 var context = z.object({
@@ -7300,6 +7785,9 @@ async function setup(ctx) {
     return;
   }
   const logger = new Logger(config.debug);
+  const usageTracker = createCompressionUsageTracker();
+  await installCompressionUsageHook(ctx, usageTracker, logger);
+  await installHttpUsageHook(ctx, usageTracker, logger);
   const prompts = new PromptStore(
     logger,
     ctx.location.directory,
@@ -7465,7 +7953,7 @@ async function setup(ctx) {
   await ctx.session.hook("generate", (event) => {
     const own = event.messages.filter(
       (message) => Array.isArray(message.content) && message.content.some(
-        (part) => part?.type === "text" && typeof part.text === "string" && part.text.includes(RC_SUMMARY_MARKER)
+        (part) => part?.type === "text" && typeof part.text === "string" && hasSummaryMarker(part.text)
       )
     );
     if (own.length === 0) {
@@ -7475,6 +7963,25 @@ async function setup(ctx) {
     for (const name of Object.keys(event.tools ?? {})) {
       delete event.tools[name];
     }
+    const callId = own.flatMap(
+      (message) => Array.isArray(message.content) ? message.content : []
+    ).filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => extractSummaryCallId(part.text)).find((id) => !!id);
+    if (callId) {
+      const texts = [];
+      for (const part of event.system ?? []) {
+        if (typeof part?.text === "string") {
+          texts.push(part.text);
+        }
+      }
+      for (const message of own) {
+        for (const part of message.content ?? []) {
+          if (part?.type === "text" && typeof part.text === "string") {
+            texts.push(part.text);
+          }
+        }
+      }
+      usageTracker.recordEstimatedInput(callId, countTokens2(texts.join("\n")));
+    }
   });
   if (config.compress.permission !== "deny") {
     const define = (state) => {
@@ -7485,8 +7992,19 @@ async function setup(ctx) {
         config,
         prompts,
         generate: async (input) => {
-          const result = await ctx.session.generate(input);
-          return result?.text ?? "";
+          try {
+            const result = await ctx.session.generate({
+              sessionID: input.sessionID,
+              prompt: input.prompt
+            });
+            const text = result?.text ?? "";
+            const usage = input.callId ? usageTracker.resolve(input.callId, text) : void 0;
+            return { text, usage };
+          } finally {
+            if (input.callId) {
+              usageTracker.discard(input.callId);
+            }
+          }
         }
       };
       return createRcCompressTool(context2);