context-mode 1.0.166 → 1.0.168

package/build/adapters/openclaw/usage.js

@@ -0,0 +1,52 @@
+/**
+ * adapters/openclaw/usage — per-turn token + cost capture handler.
+ *
+ * openclaw emits a first-class `model.usage` diagnostic event once per turn
+ * (`DiagnosticUsageEvent`, refs/platforms/openclaw/src/infra/diagnostic-events.ts:18-47),
+ * carrying the full usage breakdown {input, output, cacheRead, cacheWrite} plus
+ * a PRE-COMPUTED `costUsd` (estimateUsageCost, agent-runner.ts:1995). Consumers
+ * subscribe via `onDiagnosticEvent(listener)` (diagnostic-events.ts:1156) — the
+ * exact bus the first-party diagnostics-otel / diagnostics-prometheus extensions
+ * read.
+ *
+ * This module is the parse→build→insert handler the plugin's diagnostic-event
+ * listener invokes. It is deliberately decoupled from the openclaw plugin SDK so
+ * it stays unit-testable: the caller passes the raw payload and an `insert`
+ * callback (the plugin hands it `db.insertEvent`-bound-to-sessionId). The handler
+ * never throws — a usage-capture failure must never break the agent turn.
+ *
+ * Capture surface: the diagnostic-event bus, NOT the tool-call hook. The native
+ * before_tool_call / after_tool_call relay carries only approval/policy data and
+ * NO token usage (matrix §4) — so usage cannot be captured from after_tool_call.
+ */
+import { parseOpenclawUsage, buildAgentUsageEvent } from "../../session/extract.js";
+/**
+ * Handle one openclaw `model.usage` diagnostic payload: parse the per-turn usage
+ * (NOT lastCallUsage), build the structured `agent_usage` event with openclaw's
+ * native `costUsd` (preferred over the pricing catalog), and insert it.
+ *
+ * Returns the inserted event (for tests / callers that want to forward) or null
+ * when the payload is not a usage event, carries no usage, or sums to zero.
+ * Best-effort: swallows any insert failure.
+ */
+export function handleOpenclawUsageEvent(payload, insert) {
+    // parseOpenclawUsage maps cacheWrite→cache_creation_tokens,
+    // cacheRead→cache_read_tokens, costUsd→native_cost_usd, and reads ONLY the
+    // per-turn `usage` total — never the lastCallUsage delta.
+    const counts = parseOpenclawUsage(payload);
+    if (!counts)
+        return null;
+    // native_cost_usd (openclaw's pre-computed costUsd) is preferred over the
+    // catalog inside buildAgentUsageEvent.
+    const event = buildAgentUsageEvent(counts);
+    if (!event)
+        return null;
+    try {
+        insert(event);
+    }
+    catch {
+        // Usage capture must never break the agent turn.
+        return null;
+    }
+    return event;
+}

package/build/adapters/opencode/plugin.d.ts

@@ -88,6 +88,22 @@ interface AfterHookOutput {
     output: string;
     metadata: any;
 }
+/**
+ * OpenCode generic bus `event` hook — single parameter.
+ * The plugin SDK delivers every bus Event here (refs/platforms/opencode/
+ * packages/plugin/src/index.ts:224). We narrow to `message.updated`, whose
+ * `properties.info` is the full assistant Message carrying tokens/cost/modelID.
+ */
+interface EventHookInput {
+    event?: {
+        type?: string;
+        properties?: {
+            info?: {
+                sessionID?: string;
+            } & Record<string, unknown>;
+        };
+    };
+}
 /** OpenCode experimental.session.compacting — first parameter */
 interface CompactingHookInput {
     sessionID: string;
@@ -154,6 +170,7 @@ declare function createContextModePlugin(ctx: PluginContext): Promise<{
     tool: Record<string, NativeToolDefinition>;
     "tool.execute.before": (input: BeforeHookInput, output: BeforeHookOutput) => Promise<void>;
     "tool.execute.after": (input: AfterHookInput, output: AfterHookOutput) => Promise<void>;
+    event: (input: EventHookInput) => Promise<void>;
     "chat.message": (input: ChatMessageHookInput, output: ChatMessageHookOutput) => Promise<void>;
     "experimental.session.compacting": (input: CompactingHookInput, output: CompactingHookOutput) => Promise<string>;
     "experimental.chat.system.transform": (input: SystemTransformHookInput, output: SystemTransformHookOutput) => Promise<void>;

package/build/adapters/opencode/plugin.js

@@ -24,7 +24,7 @@ import { dirname, resolve, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { existsSync, readFileSync } from "node:fs";
 import { resolveSessionDbPath, SessionDB } from "../../session/db.js";
-import { extractEvents, extractUserEvents } from "../../session/extract.js";
+import { extractEvents, extractUserEvents, parseOpencodeUsage, buildAgentUsageEvent } from "../../session/extract.js";
 import { buildResumeSnapshot } from "../../session/snapshot.js";
 import { OpenCodeAdapter } from "./index.js";
 import { PLATFORM_ENV_VARS } from "../detect.js";
@@ -346,6 +346,45 @@ async function createContextModePlugin(ctx) {
                 // Silent — session capture must never break the tool call
             }
         },
+        // ── event: per-turn token + cost capture (paid-observability) ───
+        // The generic bus `event` hook (refs/platforms/opencode/packages/plugin/
+        // src/index.ts:224) delivers every Event; we filter `message.updated`
+        // (published on each assistant-message update incl. step-finish —
+        // session.ts:673) and read tokens/cost/modelID off properties.info
+        // (assistant filter via role; refs stream.transport.ts:214-216).
+        //
+        // CAVEAT (refs processor.ts:717-718): message-level `.tokens` is the LAST
+        // step's snapshot (overwritten per step-finish), while `.cost` is
+        // cumulative for the turn. parseOpencodeUsage passes `.cost` through as
+        // native_cost_usd so the billed $ stays exact despite the token snapshot
+        // being last-step only. `message.updated` fires multiple times per turn;
+        // because tokens are a terminal snapshot and cost is cumulative, the last
+        // event for a message carries the final figures — re-emitting on each
+        // update is idempotent at the cost column and merely refreshes the
+        // last-step token telemetry. db.insertEvent both persists locally AND
+        // forwards to the platform (the TS-plugin equivalent of the .mjs
+        // attributeAndInsertEvents path).
+        event: async (input) => {
+            try {
+                const ev = input?.event;
+                if (!ev || ev.type !== "message.updated")
+                    return;
+                const sessionId = ev.properties?.info?.sessionID;
+                if (!sessionId || typeof sessionId !== "string")
+                    return;
+                const counts = parseOpencodeUsage(ev);
+                if (!counts)
+                    return;
+                const usageEvent = buildAgentUsageEvent(counts);
+                if (!usageEvent)
+                    return;
+                db.ensureSession(sessionId, projectDir);
+                db.insertEvent(sessionId, usageEvent, "MessageUpdated");
+            }
+            catch {
+                // Silent — usage capture must never break the session.
+            }
+        },
         // ── chat.message: User-prompt capture (OC-2 / Z2) ───
         // SDK signature verified at refs/platforms/opencode/packages/plugin/src/
         // index.ts:233. Orchestrator reference at refs/plugin-examples/opencode/

package/build/adapters/pi/extension.js

@@ -16,7 +16,7 @@ import { homedir } from "node:os";
 import { join, resolve, dirname } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { resolveSessionDbPath, SessionDB } from "../../session/db.js";
-import { extractEvents, extractUserEvents } from "../../session/extract.js";
+import { extractEvents, extractUserEvents, parsePiUsage, buildAgentUsageEvent } from "../../session/extract.js";
 import { buildResumeSnapshot } from "../../session/snapshot.js";
 import { bootstrapMCPTools, makeBridgeDiag, isForegroundSession } from "./mcp-bridge.js";
 import { PiAdapter } from "./index.js";
@@ -705,6 +705,39 @@ export default function piExtension(pi) {
             // best effort — never break provider response
         }
     });
+    // ── 4c. turn_end — per-turn token + native-USD cost capture ───
+    //
+    // Pi delivers per-turn usage on TurnEndEvent.message (an AssistantMessage):
+    // usage.{input,output,cacheRead,cacheWrite} + native usage.cost.total in USD,
+    // with model on .model. Usage is per-turn incremental, so each turn_end maps
+    // to exactly one structured `agent_usage` (category "cost") event — the same
+    // shape the Claude Code Stop path emits via buildAgentUsageEvent. We pass
+    // Pi's native cost as native_cost_usd so the builder trusts the source over
+    // the local price table (cost_confidence: HIGH — no price-table maintenance).
+    //
+    // Refs: adapter-matrix/pi.md @320261f — shared-events.ts:204-209 (TurnEndEvent),
+    // ai/src/types.ts:510/521 (model/usage), catalog/src/types.ts:100-145 (Usage).
+    // Best-effort: parse is null-safe and the handler never throws (a telemetry
+    // forwarder must never break the agent turn).
+    pi.on("turn_end", (event) => {
+        try {
+            if (!_sessionId)
+                return;
+            const counts = parsePiUsage(event);
+            if (!counts)
+                return; // non-assistant turn or all-zero usage
+            const ev = buildAgentUsageEvent(counts);
+            if (!ev)
+                return;
+            // db.insertEvent is the extension-side analog of the .mjs hooks'
+            // attributeAndInsertEvents (insert + project attribution). The MCP
+            // server forwards persisted agent_usage events to the platform.
+            db.insertEvent(_sessionId, ev, "Stop", _attribution);
+        }
+        catch {
+            // best effort — never break the agent turn
+        }
+    });
     // ── 5. session_before_compact — Build resume snapshot ──
     pi.on("session_before_compact", () => {
         try {

package/build/adapters/qwen-code/index.js

@@ -101,6 +101,19 @@ export class QwenCodeAdapter extends ClaudeCodeBaseAdapter {
                     ],
                 },
             ],
+            // Stop fires at end-of-turn. The qwen-specific stop hook records a
+            // turn_end marker AND captures per-turn token cost by tailing the session
+            // chats JSONL (~/.qwen/tmp/<hash>/chats/<sessionId>.jsonl) — usage is not
+            // reachable through hook stdin (usage.ts matrix §4). Points at the
+            // qwen-code/ hook dir (not the shared root) so it sets the qwen platform.
+            Stop: [
+                {
+                    matcher: "",
+                    hooks: [
+                        { type: "command", command: buildHookRuntimeCommand(`${pluginRoot}/hooks/qwen-code/stop.mjs`) },
+                    ],
+                },
+            ],
         };
     }
     // ── Settings read/write ────────────────────────────────
@@ -126,7 +139,7 @@ export class QwenCodeAdapter extends ClaudeCodeBaseAdapter {
         const results = [];
         const settings = this.readSettings();
         const hooks = (settings?.hooks ?? {});
-        for (const hookName of ["PreToolUse", "PostToolUse", "SessionStart", "PreCompact", "UserPromptSubmit"]) {
+        for (const hookName of ["PreToolUse", "PostToolUse", "SessionStart", "PreCompact", "UserPromptSubmit", "Stop"]) {
             const configured = Array.isArray(hooks[hookName]) && hooks[hookName].length > 0;
             results.push({
                 check: `${hookName} hook`,
@@ -275,6 +288,15 @@ export class QwenCodeAdapter extends ClaudeCodeBaseAdapter {
                 script: "userpromptsubmit.mjs",
                 matcher: "",
             },
+            {
+                // Stop captures per-turn token cost by tailing the session chats JSONL
+                // (usage is unreachable through hook stdin). Routes to the qwen-code/
+                // hook dir so it sets the qwen platform — keep in sync with
+                // generateHookConfig above.
+                name: "Stop",
+                script: "qwen-code/stop.mjs",
+                matcher: "",
+            },
         ];
         for (const { name, script, matcher } of hookTypes) {
             const entry = {

package/build/adapters/qwen-code/usage.d.ts

@@ -0,0 +1,90 @@
+/**
+ * adapters/qwen-code/usage — per-turn token capture from the session JSONL.
+ *
+ * Qwen Code is a Gemini-CLI fork and normalizes EVERY backend (Gemini-native,
+ * OpenAI-compat/DashScope, Anthropic) to the same canonical token shape:
+ * `GenerateContentResponseUsageMetadata` { promptTokenCount, candidatesTokenCount,
+ * cachedContentTokenCount, thoughtsTokenCount, totalTokenCount }
+ * (matrix §1: turn.ts:96,417 + converter.ts:1145-1148). That metadata is
+ * persisted, per API call, into the session record file as a `ChatRecord`
+ * carrying `.usageMetadata` + `.model`
+ * (refs: packages/core/src/services/chatRecordingService.ts:259,261,919 file at
+ * ~/.qwen/tmp/<project_id>/chats/<sessionId>.jsonl — :451 location comment,
+ * :600,628-629 path build).
+ *
+ * CRITICAL (matrix §4): qwen-code's hook payloads carry tool I/O ONLY — token
+ * usage is unreachable through the hook stream (grep of hookEventHandler.ts /
+ * hookSystem.ts / toolHookTriggers.ts for token|usageMetadata|usage → zero
+ * matches). The ONLY live capture path is a tail of the session JSONL. This
+ * module is therefore the JSONL-tail counterpart to claude-code's
+ * `extractTranscriptUsageSince` (src/session/extract.ts) — same cursor-gated,
+ * char-algorithmic, NO-regex parse, same `buildAgentUsageEvent` emission path.
+ *
+ * Per matrix §3 each ChatRecord.usageMetadata is INCREMENTAL per API call
+ * (cumulative session totals are derived downstream via += in
+ * uiTelemetry.ts:237-241), so summing the NEW records since the cursor yields
+ * the exact billed delta with no double-count.
+ *
+ * No native USD — cost_usd is derived from the pricing catalog inside
+ * buildAgentUsageEvent (native_cost_usd omitted). Pure, null-safe, NO regex.
+ */
+import { type AgentUsageCounts, type SessionEvent } from "../../session/extract.js";
+/**
+ * Parse ONE qwen `ChatRecord` into the `buildAgentUsageEvent` input shape, or
+ * null when the record carries no usage / sums to zero.
+ *
+ * Mapping → builder shape (AgentUsageCounts):
+ *   promptTokenCount        → input_tokens
+ *   candidatesTokenCount    → output_tokens
+ *   thoughtsTokenCount      → ADDED into output_tokens (Gemini-lineage bills
+ *                             reasoning/thoughts as output — same fold as
+ *                             parseGeminiUsage in src/session/extract.ts)
+ *   cachedContentTokenCount → cache_read_tokens (when present)
+ *   model_id                → ChatRecord.model
+ *
+ * No native cost — native_cost_usd omitted (catalog-derived). NO regex.
+ */
+export declare function parseQwenUsage(record: unknown): AgentUsageCounts | null;
+/**
+ * Cursor-aware tail of the qwen session JSONL. Emits one priced `agent_usage`
+ * event PER distinct model across the records NEW since `cursor`, so re-reading
+ * the (append-only, ever-growing) JSONL each Stop never double-counts.
+ *
+ *   - cursor null/empty            → process ALL records.
+ *   - cursor found                 → process records STRICTLY AFTER it.
+ *   - cursor set but NOT found     → compaction/rotation dropped it: bounded
+ *     fallback processes ONLY THE LAST record (never re-emit full history).
+ *
+ * `cursor` returns the id of the LAST id-bearing record seen (whether or not it
+ * carried usage), so the next call resumes exactly past it. When no record
+ * carries an id, the input cursor is returned unchanged.
+ *
+ * One linear walk, JSON.parse per line, NO regex — mirrors
+ * extractTranscriptUsageSince's structure exactly.
+ */
+export declare function extractQwenUsageSince(jsonlText: string, cursor: string | null): {
+    events: SessionEvent[];
+    cursor: string | null;
+};
+/**
+ * Hash a project root into qwen-code's `<project_id>` directory segment.
+ *
+ * EXACT port of qwen's `getProjectHash`
+ * (refs/platforms/qwen-code/packages/core/src/utils/paths.ts:262 —
+ * `crypto.createHash('sha256').update(normalizedPath).digest('hex')`). On
+ * Windows qwen lowercases the path first (case-insensitive FS); we mirror that
+ * so a hook running on win32 resolves the same tmp dir qwen itself wrote.
+ * Pure, deterministic, NO regex.
+ */
+export declare function qwenProjectHash(projectRoot: string): string;
+/**
+ * Build the canonical session JSONL path qwen-code writes its ChatRecords to:
+ *   <qwenHome>/tmp/<sha256(projectRoot)>/chats/<sessionId>.jsonl
+ * (refs chatRecordingService.ts:451 location + storage.ts:316-320
+ * getProjectTempDir → getGlobalTempDir(<qwenHome>/tmp) + getProjectHash).
+ *
+ * `qwenHome` is normally `<homedir>/.qwen`. Pure path join — does NOT touch the
+ * FS, so it is fully unit-testable; existence probing + the glob fallback live
+ * in the Stop hook (which cannot import this TS at runtime). NO regex.
+ */
+export declare function qwenChatJsonlPath(qwenHome: string, projectRoot: string, sessionId: string): string;

package/build/adapters/qwen-code/usage.js

@@ -0,0 +1,222 @@
+/**
+ * adapters/qwen-code/usage — per-turn token capture from the session JSONL.
+ *
+ * Qwen Code is a Gemini-CLI fork and normalizes EVERY backend (Gemini-native,
+ * OpenAI-compat/DashScope, Anthropic) to the same canonical token shape:
+ * `GenerateContentResponseUsageMetadata` { promptTokenCount, candidatesTokenCount,
+ * cachedContentTokenCount, thoughtsTokenCount, totalTokenCount }
+ * (matrix §1: turn.ts:96,417 + converter.ts:1145-1148). That metadata is
+ * persisted, per API call, into the session record file as a `ChatRecord`
+ * carrying `.usageMetadata` + `.model`
+ * (refs: packages/core/src/services/chatRecordingService.ts:259,261,919 file at
+ * ~/.qwen/tmp/<project_id>/chats/<sessionId>.jsonl — :451 location comment,
+ * :600,628-629 path build).
+ *
+ * CRITICAL (matrix §4): qwen-code's hook payloads carry tool I/O ONLY — token
+ * usage is unreachable through the hook stream (grep of hookEventHandler.ts /
+ * hookSystem.ts / toolHookTriggers.ts for token|usageMetadata|usage → zero
+ * matches). The ONLY live capture path is a tail of the session JSONL. This
+ * module is therefore the JSONL-tail counterpart to claude-code's
+ * `extractTranscriptUsageSince` (src/session/extract.ts) — same cursor-gated,
+ * char-algorithmic, NO-regex parse, same `buildAgentUsageEvent` emission path.
+ *
+ * Per matrix §3 each ChatRecord.usageMetadata is INCREMENTAL per API call
+ * (cumulative session totals are derived downstream via += in
+ * uiTelemetry.ts:237-241), so summing the NEW records since the cursor yields
+ * the exact billed delta with no double-count.
+ *
+ * No native USD — cost_usd is derived from the pricing catalog inside
+ * buildAgentUsageEvent (native_cost_usd omitted). Pure, null-safe, NO regex.
+ */
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { platform } from "node:os";
+import { buildAgentUsageEvent } from "../../session/extract.js";
+/** Floor-and-clamp a token field to a non-negative integer (mirrors omp/usage). */
+function tokenNum(v) {
+    if (typeof v !== "number" || !Number.isFinite(v))
+        return 0;
+    const n = Math.floor(v);
+    return n > 0 ? n : 0;
+}
+/**
+ * Parse ONE qwen `ChatRecord` into the `buildAgentUsageEvent` input shape, or
+ * null when the record carries no usage / sums to zero.
+ *
+ * Mapping → builder shape (AgentUsageCounts):
+ *   promptTokenCount        → input_tokens
+ *   candidatesTokenCount    → output_tokens
+ *   thoughtsTokenCount      → ADDED into output_tokens (Gemini-lineage bills
+ *                             reasoning/thoughts as output — same fold as
+ *                             parseGeminiUsage in src/session/extract.ts)
+ *   cachedContentTokenCount → cache_read_tokens (when present)
+ *   model_id                → ChatRecord.model
+ *
+ * No native cost — native_cost_usd omitted (catalog-derived). NO regex.
+ */
+export function parseQwenUsage(record) {
+    if (!record || typeof record !== "object" || Array.isArray(record))
+        return null;
+    const rec = record;
+    const um = rec.usageMetadata;
+    if (!um || typeof um !== "object")
+        return null;
+    const usage = um;
+    const input = tokenNum(usage.promptTokenCount);
+    const candidates = tokenNum(usage.candidatesTokenCount);
+    const thoughts = tokenNum(usage.thoughtsTokenCount);
+    const cached = tokenNum(usage.cachedContentTokenCount);
+    // Gemini-lineage bills reasoning (thoughts) as output tokens — fold into output.
+    const output = candidates + thoughts;
+    // All token fields zero → not a billable record. buildAgentUsageEvent would
+    // also reject this, but short-circuit keeps the contract explicit.
+    if (input <= 0 && output <= 0 && cached <= 0)
+        return null;
+    const model_id = typeof rec.model === "string" ? rec.model : "";
+    return {
+        model_id,
+        input_tokens: input,
+        output_tokens: output,
+        cache_creation_tokens: 0, // qwen exposes no cache-creation field
+        cache_read_tokens: cached,
+        native_cost_usd: null, // catalog-derived (no native cost on qwen records)
+    };
+}
+/** Stable cursor identity for a ChatRecord: prefer `id`, fall back to `messageId`. */
+function recordId(rec) {
+    if (typeof rec.id === "string" && rec.id.length > 0)
+        return rec.id;
+    if (typeof rec.messageId === "string" && rec.messageId.length > 0)
+        return rec.messageId;
+    return null;
+}
+/**
+ * Cursor-aware tail of the qwen session JSONL. Emits one priced `agent_usage`
+ * event PER distinct model across the records NEW since `cursor`, so re-reading
+ * the (append-only, ever-growing) JSONL each Stop never double-counts.
+ *
+ *   - cursor null/empty            → process ALL records.
+ *   - cursor found                 → process records STRICTLY AFTER it.
+ *   - cursor set but NOT found     → compaction/rotation dropped it: bounded
+ *     fallback processes ONLY THE LAST record (never re-emit full history).
+ *
+ * `cursor` returns the id of the LAST id-bearing record seen (whether or not it
+ * carried usage), so the next call resumes exactly past it. When no record
+ * carries an id, the input cursor is returned unchanged.
+ *
+ * One linear walk, JSON.parse per line, NO regex — mirrors
+ * extractTranscriptUsageSince's structure exactly.
+ */
+export function extractQwenUsageSince(jsonlText, cursor) {
+    const inputCursor = typeof cursor === "string" && cursor.length > 0 ? cursor : null;
+    if (typeof jsonlText !== "string" || jsonlText.length === 0) {
+        return { events: [], cursor: inputCursor };
+    }
+    const rows = [];
+    let start = 0;
+    for (let i = 0; i <= jsonlText.length; i++) {
+        if (i !== jsonlText.length && jsonlText.charCodeAt(i) !== 10 /* \n */)
+            continue;
+        const line = jsonlText.slice(start, i).trim();
+        start = i + 1;
+        if (line.length === 0)
+            continue;
+        let obj;
+        try {
+            const p = JSON.parse(line);
+            if (!p || typeof p !== "object" || Array.isArray(p))
+                continue;
+            obj = p;
+        }
+        catch {
+            continue;
+        }
+        rows.push({ id: recordId(obj), counts: parseQwenUsage(obj) });
+    }
+    if (rows.length === 0)
+        return { events: [], cursor: inputCursor };
+    // Cursor always advances to the last id-bearing record's id (or stays as the
+    // input cursor when no record carries an id).
+    let lastId = inputCursor;
+    for (let i = rows.length - 1; i >= 0; i--) {
+        if (rows[i].id !== null) {
+            lastId = rows[i].id;
+            break;
+        }
+    }
+    // Select the slice to sum.
+    let slice;
+    if (inputCursor === null) {
+        slice = rows; // all records
+    }
+    else {
+        let foundAt = -1;
+        for (let i = 0; i < rows.length; i++) {
+            if (rows[i].id === inputCursor) {
+                foundAt = i;
+                break;
+            }
+        }
+        if (foundAt >= 0) {
+            slice = rows.slice(foundAt + 1); // strictly after the cursor
+        }
+        else {
+            // Compaction/rotation: cursor fell off the front. Bounded fallback — last
+            // record only. Never re-emit the whole history.
+            slice = rows.slice(rows.length - 1);
+        }
+    }
+    // Sum the selected records per model, then emit via the shared builder.
+    const sums = new Map();
+    for (const row of slice) {
+        const c = row.counts;
+        if (!c)
+            continue;
+        const cur = sums.get(c.model_id) ?? { input: 0, output: 0, cacheCreate: 0, cacheRead: 0 };
+        cur.input += c.input_tokens;
+        cur.output += c.output_tokens;
+        cur.cacheCreate += c.cache_creation_tokens;
+        cur.cacheRead += c.cache_read_tokens;
+        sums.set(c.model_id, cur);
+    }
+    const events = [];
+    for (const [model_id, s] of sums) {
+        const ev = buildAgentUsageEvent({
+            model_id,
+            input_tokens: s.input,
+            output_tokens: s.output,
+            cache_creation_tokens: s.cacheCreate,
+            cache_read_tokens: s.cacheRead,
+        });
+        if (ev)
+            events.push(ev);
+    }
+    return { events, cursor: lastId };
+}
+/**
+ * Hash a project root into qwen-code's `<project_id>` directory segment.
+ *
+ * EXACT port of qwen's `getProjectHash`
+ * (refs/platforms/qwen-code/packages/core/src/utils/paths.ts:262 —
+ * `crypto.createHash('sha256').update(normalizedPath).digest('hex')`). On
+ * Windows qwen lowercases the path first (case-insensitive FS); we mirror that
+ * so a hook running on win32 resolves the same tmp dir qwen itself wrote.
+ * Pure, deterministic, NO regex.
+ */
+export function qwenProjectHash(projectRoot) {
+    const normalized = platform() === "win32" ? projectRoot.toLowerCase() : projectRoot;
+    return createHash("sha256").update(normalized).digest("hex");
+}
+/**
+ * Build the canonical session JSONL path qwen-code writes its ChatRecords to:
+ *   <qwenHome>/tmp/<sha256(projectRoot)>/chats/<sessionId>.jsonl
+ * (refs chatRecordingService.ts:451 location + storage.ts:316-320
+ * getProjectTempDir → getGlobalTempDir(<qwenHome>/tmp) + getProjectHash).
+ *
+ * `qwenHome` is normally `<homedir>/.qwen`. Pure path join — does NOT touch the
+ * FS, so it is fully unit-testable; existence probing + the glob fallback live
+ * in the Stop hook (which cannot import this TS at runtime). NO regex.
+ */
+export function qwenChatJsonlPath(qwenHome, projectRoot, sessionId) {
+    return join(qwenHome, "tmp", qwenProjectHash(projectRoot), "chats", `${sessionId}.jsonl`);
+}

package/build/session/analytics.js

@@ -900,6 +900,18 @@ export function getRealBytesStats(opts) {
                             snapshotBytes += Number(snap.bytes);
                     }
                     catch { /* old schema */ }
+                    try {
+                        // "With context-mode" = the bytes the model paid to ACCESS the
+                        // kept-out content: ctx_search (query the index) + ctx_fetch_and_index
+                        // (fetch + index a URL). Sandbox compute (ctx_execute/batch/file) is
+                        // work-output the model would see regardless — NOT redirect savings —
+                        // so it is excluded; folding it crushed the bar to a false ~43%.
+                        const tc = sdb.prepare(`SELECT COALESCE(SUM(bytes_returned), 0) AS bytes FROM tool_calls
+               WHERE session_id = ? AND tool IN ('ctx_search', 'ctx_fetch_and_index')`).get(opts.sessionId);
+                        if (tc?.bytes)
+                            bytesReturned += Number(tc.bytes);
+                    }
+                    catch { /* old schema: no tool_calls table */ }
                 }
                 else if (opts.projectDir) {
                     // Bug E+F: META-scoped aggregation. Take every session_id whose
@@ -930,6 +942,17 @@ export function getRealBytesStats(opts) {
                             snapshotBytes += Number(snap.bytes);
                     }
                     catch { /* old schema */ }
+                    try {
+                        const tc = sdb.prepare(`SELECT COALESCE(SUM(bytes_returned), 0) AS bytes
+               FROM tool_calls
+               WHERE session_id IN (
+                 SELECT session_id FROM session_meta WHERE project_dir = ?
+               )
+               AND tool IN ('ctx_search', 'ctx_fetch_and_index')`).get(opts.projectDir);
+                        if (tc?.bytes)
+                            bytesReturned += Number(tc.bytes);
+                    }
+                    catch { /* old schema: no tool_calls table */ }
                 }
                 else {
                     const row = sdb.prepare(`SELECT
@@ -948,6 +971,13 @@ export function getRealBytesStats(opts) {
                             snapshotBytes += Number(snap.bytes);
                     }
                     catch { /* old schema */ }
+                    try {
+                        const tc = sdb.prepare(`SELECT COALESCE(SUM(bytes_returned), 0) AS bytes FROM tool_calls
+               WHERE tool IN ('ctx_search', 'ctx_fetch_and_index')`).get();
+                        if (tc?.bytes)
+                            bytesReturned += Number(tc.bytes);
+                    }
+                    catch { /* old schema: no tool_calls table */ }
                 }
             }
             finally {

package/build/session/db.d.ts

@@ -380,6 +380,17 @@ export declare class SessionDB extends SQLiteBase {
      * Increment the compact_count for a session (tracks snapshot rebuilds).
      */
     incrementCompactCount(sessionId: string): void;
+    /**
+     * Read the per-session usage high-water cursor — the uuid of the last
+     * assistant turn already emitted by the Stop hook's main-turn capture.
+     * Returns null when unset (first Stop) or the session row is absent.
+     */
+    getUsageCursor(sessionId: string): string | null;
+    /**
+     * Advance the per-session usage high-water cursor to `uuid`. No-op when the
+     * session_meta row does not exist yet (callers ensureSession first).
+     */
+    setUsageCursor(sessionId: string, uuid: string): void;
     /**
      * Upsert a resume snapshot for a session. Resets consumed flag on update.
      */