fix: use real outputTokens from assistant.message to estimate CLI session tokens

Sessions without session.shutdown events were massively undercounting
tokens because character-based estimation ignores context accumulation
in agent sessions. Investigation found:

- Real input:output ratio in completed sessions: ~100-200x
- Cache reads ≈ input tokens (prompt caching caches full context)
- A session with 387 tool calls showed 92K real output tokens but only
  13K estimated, with real total likely 10-25M

Changes:
1. assistant.message events carry real API-reported outputTokens per
   response. Capture these directly instead of estimating from text.

2. When no session.shutdown exists but we have real output tokens,
   estimate input using observed ratios from completed sessions:
   - >20 tool calls: 130x (heavy agent)
   - >5 tool calls: 50x (moderate)
   - <=5 tool calls: 10x (light/chat)
   Cache reads estimated as equal to input (empirically ~50% of total).

3. Also fix tool.result -> tool.execution_complete event type (wrong
   event name meant tool outputs were silently skipped in fallback).

4. Count tool.execution_start to drive the ratio selection.

Result: sessions without shutdown now estimate correctly in the right
order of magnitude instead of being off by 100x. Sessions WITH
session.shutdown are unaffected (still use exact API data).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: rajbos

.github/skills/copilot-log-analysis/SKILL.md

@@ -179,14 +179,18 @@ See the **Executable Scripts** section for available utilities:
 ```jsonl
 {"type": "user.message", "data": {"content": "..."}, "model": "gpt-4o"}
 {"type": "assistant.message", "data": {"content": "..."}}
-{"type": "tool.result", "data": {"output": "..."}}
+{"type": "tool.execution_start", "data": {"toolCallId": "...", "toolName": "...", "arguments": {}}}
+{"type": "tool.execution_complete", "data": {"toolCallId": "...", "success": true, "result": {"content": "...", "detailedContent": "..."}}}
+{"type": "session.shutdown", "data": {"modelMetrics": {"claude-opus-4.6": {"usage": {"inputTokens": 0, "outputTokens": 0, "cacheReadTokens": 0, "cacheWriteTokens": 0}}}}}
 ```
 
 **Key fields:**
 - Event type: `type`
 - User input: `data.content` (when `type: 'user.message'`)
 - Assistant output: `data.content` (when `type: 'assistant.message'`)
-- Tool output: `data.output` (when `type: 'tool.result'`)
+- Tool output: `data.result.content` or `data.result.detailedContent` (when `type: 'tool.execution_complete'`)
+- Tool name for counting: `data.toolName` (when `type: 'tool.execution_start'`)
+- API-accurate token counts: `data.modelMetrics[model].usage` (when `type: 'session.shutdown'`) — always prefer these over estimates when available
 - Model: `model` (optional, defaults to `gpt-4o`)
 
 ## JSONL File Structure (JetBrains IDE)

.github/skills/copilot-log-analysis/session-file-discovery.js

@@ -147,7 +147,7 @@ function getCopilotSessionFiles() {
     }
 
     // OpenCode session files (XDG data directory)
-    const xdgDataHome = (platform === 'win32')
+    const xdgDataHome = (os.platform() === 'win32')
         ? path.join(homedir, '.local', 'share')
         : (process.env.XDG_DATA_HOME || path.join(homedir, '.local', 'share'));
     const openCodeSessionDir = path.join(xdgDataHome, 'opencode', 'storage', 'session');

vscode-extension/src/usageAnalysis.ts

@@ -1499,6 +1499,9 @@ export async function getModelUsageFromSession(deps: Pick<UsageAnalysisDeps, 'wa
 			let isDeltaBased = false;
 			// For CLI (non-delta) sessions: capture exact per-model usage from session.shutdown
 			let cliShutdownModelUsage: ModelUsage | null = null;
+			// Real outputTokens from assistant.message events (used when session.shutdown is absent)
+			let cliRealOutputByModel: { [model: string]: number } | null = null;
+			let totalCliToolCalls = 0;
 
 			for (const line of lines) {
 				if (!line.trim()) { continue; }
@@ -1579,11 +1582,20 @@ export async function getModelUsageFromSession(deps: Pick<UsageAnalysisDeps, 'wa
 							}
 						} else if (event.type === 'user.message' && event.data?.content) {
 							modelUsage[model].inputTokens += estimateTokensFromText(event.data.content, model, deps.tokenEstimators);
-						} else if (event.type === 'assistant.message' && event.data?.content) {
-							modelUsage[model].outputTokens += estimateTokensFromText(event.data.content, model, deps.tokenEstimators);
-						} else if (event.type === 'tool.result' && event.data?.output) {
-							// Tool outputs are typically input context
-							modelUsage[model].inputTokens += estimateTokensFromText(event.data.output, model, deps.tokenEstimators);
+						} else if (event.type === 'assistant.message') {
+							const realOutput = typeof event.data?.outputTokens === 'number' ? event.data.outputTokens : 0;
+							if (realOutput > 0) {
+								if (!cliRealOutputByModel) { cliRealOutputByModel = {}; }
+								cliRealOutputByModel[model] = (cliRealOutputByModel[model] ?? 0) + realOutput;
+							} else if (event.data?.content) {
+								modelUsage[model].outputTokens += estimateTokensFromText(event.data.content, model, deps.tokenEstimators);
+							}
+						} else if (event.type === 'tool.execution_start') {
+							totalCliToolCalls++;
+						} else if (event.type === 'tool.execution_complete' && (event.data?.result?.content || event.data?.result?.detailedContent)) {
+							// Tool outputs are fed back as input context in the next turn
+							const toolContent = event.data.result.content || event.data.result.detailedContent;
+							modelUsage[model].inputTokens += estimateTokensFromText(String(toolContent), model, deps.tokenEstimators);
 						}
 					}
 				} catch (e) {
@@ -1596,6 +1608,24 @@ export async function getModelUsageFromSession(deps: Pick<UsageAnalysisDeps, 'wa
 				return cliShutdownModelUsage;
 			}
 
+			// No session.shutdown: assistant.message events carry real per-response outputTokens from the API.
+			// Estimate input using observed ratio from completed agent sessions (~130x output for heavy
+			// agent sessions with >20 tool calls, ~50x for moderate, ~10x for light/chat-only).
+			// Cache reads empirically equal ~input tokens (prompt caching caches the full context).
+			if (!isDeltaBased && cliRealOutputByModel) {
+				const inputOutputRatio = totalCliToolCalls > 20 ? 130 : totalCliToolCalls > 5 ? 50 : 10;
+				const estimatedUsage: ModelUsage = {};
+				for (const [m, realOutput] of Object.entries(cliRealOutputByModel)) {
+					const estimatedInput = Math.round(realOutput * inputOutputRatio);
+					estimatedUsage[m] = {
+						inputTokens: estimatedInput,
+						outputTokens: realOutput,
+						cachedReadTokens: estimatedInput,
+					};
+				}
+				return estimatedUsage;
+			}
+
 			// For delta-based formats, extract actual usage from reconstructed state
 			if (isDeltaBased && sessionState.requests && Array.isArray(sessionState.requests)) {
 				for (const request of sessionState.requests) {