@syengup/friday-channel-next 0.0.45 → 0.1.1

package/dist/src/http/server.js

@@ -15,6 +15,7 @@ import { handleSessionsDelete } from "./handlers/sessions-delete.js";
 import { handleSessionsSettings } from "./handlers/sessions-settings.js";
 import { handleModelsList } from "./handlers/models-list.js";
 import { handleStatus } from "./handlers/status.js";
+import { handleHealth } from "./handlers/health.js";
 import { applyCorsHeaders } from "./middleware/cors.js";
 import { resolveFridayNextConfig } from "../config.js";
 import { getHostOpenClawConfigSnapshot } from "../host-config.js";
@@ -67,6 +68,10 @@ async function handleFridayNextRoute(req, res) {
     if (req.method === "GET" && pathname === "/friday-next/status") {
         return await handleStatus(req, res);
     }
+    // Route: GET /friday-next/health?deviceId=...&nodeDeviceId=...&selfHeal=true
+    if (req.method === "GET" && pathname === "/friday-next/health") {
+        return await handleHealth(req, res);
+    }
     // Not found
     return false;
 }

package/dist/src/run-metadata.d.ts

@@ -5,11 +5,17 @@ type RunRoute = {
 };
 export type RunMetadata = {
     modelName?: string;
+    modelProvider?: string;
     totalTokens?: number;
     /** Tokens counted toward the model context window (prompt-side: input + cache read + cache write when present). */
     contextTokensUsed?: number;
     /** Resolved model context window limit when the runtime exposes it. */
     contextWindowMax?: number;
+    /** Detailed token breakdown captured from agent event usage (current run, not stale store read). */
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
 };
 /** Vitest / harness: clears per-run metadata and final-delivered flags (not routes). */
 export declare function resetRunMetadataForTest(): void;

package/dist/src/run-metadata.js

@@ -106,6 +106,11 @@ export function ingestAgentEventMetadata(runId, data) {
         undefined;
     if (modelName)
         next.modelName = modelName;
+    const modelProvider = (typeof data.modelProvider === "string" && data.modelProvider.trim()) ||
+        (typeof data.provider === "string" && data.provider.trim()) ||
+        undefined;
+    if (modelProvider)
+        next.modelProvider = modelProvider;
     const usage = recordValue(data.usage);
     const totalTokens = finiteNumber(data.totalTokens) ??
         finiteNumber(data.total_tokens) ??
@@ -115,6 +120,19 @@ export function ingestAgentEventMetadata(runId, data) {
     if (typeof totalTokens === "number" && totalTokens > 0) {
         next.totalTokens = Math.floor(totalTokens);
     }
+    const usageForTokens = usage ?? data;
+    const input = pickInputTokens(usageForTokens);
+    if (typeof input === "number" && input >= 0)
+        next.inputTokens = Math.floor(input);
+    const output = pickOutputTokens(usageForTokens);
+    if (typeof output === "number" && output >= 0)
+        next.outputTokens = Math.floor(output);
+    const cacheRead = pickCacheRead(usageForTokens);
+    if (typeof cacheRead === "number" && cacheRead >= 0)
+        next.cacheReadTokens = Math.floor(cacheRead);
+    const cacheWrite = pickCacheWrite(usageForTokens);
+    if (typeof cacheWrite === "number" && cacheWrite >= 0)
+        next.cacheWriteTokens = Math.floor(cacheWrite);
     const usageForContext = usage ?? data;
     const ctxUsed = contextTokensFromUsageRecord(usageForContext);
     if (typeof ctxUsed === "number" && ctxUsed > 0) {
@@ -131,9 +149,14 @@ export function ingestAgentEventMetadata(runId, data) {
         }
     }
     if (next.modelName ||
+        next.modelProvider ||
         typeof next.totalTokens === "number" ||
         typeof next.contextTokensUsed === "number" ||
-        typeof next.contextWindowMax === "number") {
+        typeof next.contextWindowMax === "number" ||
+        typeof next.inputTokens === "number" ||
+        typeof next.outputTokens === "number" ||
+        typeof next.cacheReadTokens === "number" ||
+        typeof next.cacheWriteTokens === "number") {
         setRunMetadata(runId, next);
     }
 }

package/index.ts

@@ -16,6 +16,7 @@ import {
 } from "./src/friday-session.js";
 import { setFridayAgentForwardRuntime } from "./src/agent-forward-runtime.js";
 import { getOpenClawAgentRunContext } from "./src/agent-run-context-bridge.js";
+import { accumulateRunUsage } from "./src/agent/run-usage-accumulator.js";
 
 export { fridayNextChannelPlugin } from "./src/channel.js";
 export { setFridayNextRuntime } from "./src/runtime.js";
@@ -103,6 +104,21 @@ export default defineChannelPluginEntry({
       });
     });
 
+    api.on("llm_output", (event: any) => {
+      accumulateRunUsage(
+        event.runId,
+        {
+          input: event.usage?.input,
+          output: event.usage?.output,
+          cacheRead: event.usage?.cacheRead,
+          cacheWrite: event.usage?.cacheWrite,
+          total: event.usage?.total,
+        },
+        event.model,
+        event.provider,
+      );
+    });
+
     if (fridayNextToolHooksRegistered) {
       return;
     }

package/install.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { execSync } from "node:child_process";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, rmSync } from "node:fs";
 import { homedir, networkInterfaces } from "node:os";
 import { join } from "node:path";
 
@@ -102,6 +102,13 @@ try {
   if (out.trim()) console.log(out.trim());
   installed = true;
   log("Plugin registered with install record — auto-upgrade enabled.");
+
+  // Remove old manual install to avoid "duplicate plugin id" warning.
+  const legacyDir = join(USER_HOME, ".openclaw", "extensions", "friday-channel-next");
+  if (existsSync(legacyDir)) {
+    try { rmSync(legacyDir, { recursive: true, force: true }); log("Removed legacy manual install."); }
+    catch { /* non-critical */ }
+  }
 } catch (e) {
   const msg = (e.stderr || e.stdout || e.message || "").toString();
   warn("openclaw plugins install failed: " + msg.trim().split("\n").pop());
@@ -118,6 +125,11 @@ if (!installed) {
   }
   warn("Manual install complete, but auto-upgrade is NOT available.");
   warn("To enable auto-upgrade later, run: openclaw plugins install @syengup/friday-channel-next");
+  // Clean up legacy dir even in fallback to avoid duplicate warnings
+  if (existsSync(join(USER_HOME, ".openclaw", "extensions", "friday-channel-next"))) {
+    warn("Legacy install detected. Remove it to avoid duplicate warnings:");
+    warn("  rm -rf ~/.openclaw/extensions/friday-channel-next");
+  }
 }
 
 // --------------- configure OpenClaw ---------------
@@ -167,6 +179,10 @@ for (const id of ["friday-next", "canvas"]) {
   else if (!config.plugins.entries[id].enabled) { config.plugins.entries[id].enabled = true; configChanged = true; }
 }
 
+// llm_output hook requires allowConversationAccess for non-bundled plugins.
+if (!config.plugins.entries["friday-next"].hooks) { config.plugins.entries["friday-next"].hooks = {}; configChanged = true; }
+if (!config.plugins.entries["friday-next"].hooks.allowConversationAccess) { config.plugins.entries["friday-next"].hooks.allowConversationAccess = true; configChanged = true; }
+
 // Channel
 if (!config.channels) config.channels = {};
 if (!config.channels["friday-next"]) { config.channels["friday-next"] = { enabled: true, transport: "http+sse" }; configChanged = true; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syengup/friday-channel-next",
-  "version": "0.0.45",
+  "version": "0.1.1",
   "description": "OpenClaw Friday Next Apple channel plugin",
   "type": "module",
   "files": [
@@ -11,6 +11,15 @@
     "tsconfig.json",
     "openclaw.plugin.json"
   ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "pnpm build",
+    "test": "npm run test:unit && npm run test:e2e",
+    "test:unit": "vitest run",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts",
+    "test:smoke": "node scripts/e2e-smoke.mjs",
+    "test:msg-live": "node scripts/message-roundtrip-live.mjs"
+  },
   "bin": {
     "friday-channel-next": "install.js"
   },
@@ -56,13 +65,5 @@
     "typescript": "^6.0.3",
     "vitest": "^4.1.5",
     "zod": "^4.3.6"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "npm run test:unit && npm run test:e2e",
-    "test:unit": "vitest run",
-    "test:e2e": "vitest run --config vitest.e2e.config.ts",
-    "test:smoke": "node scripts/e2e-smoke.mjs",
-    "test:msg-live": "node scripts/message-roundtrip-live.mjs"
   }
-}
+}

package/src/agent/run-usage-accumulator.ts

@@ -0,0 +1,70 @@
+import type { FridaySessionUsagePayload } from "../session-usage-snapshot.js";
+
+type UsageFields = {
+  input?: number;
+  output?: number;
+  cacheRead?: number;
+  cacheWrite?: number;
+  total?: number;
+};
+
+type AccumulatedUsage = {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  total: number;
+  model?: string;
+  provider?: string;
+};
+
+const usageByRunId = new Map<string, AccumulatedUsage>();
+
+function ensure(runId: string): AccumulatedUsage {
+  let entry = usageByRunId.get(runId);
+  if (!entry) {
+    entry = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+    usageByRunId.set(runId, entry);
+  }
+  return entry;
+}
+
+export function accumulateRunUsage(
+  runId: string,
+  usage: UsageFields,
+  model?: string,
+  provider?: string,
+): void {
+  if (!runId.trim()) return;
+  const entry = ensure(runId);
+  if (typeof usage.input === "number" && usage.input > 0) entry.input += usage.input;
+  if (typeof usage.output === "number" && usage.output > 0) entry.output += usage.output;
+  if (typeof usage.cacheRead === "number" && usage.cacheRead > 0) entry.cacheRead += usage.cacheRead;
+  if (typeof usage.cacheWrite === "number" && usage.cacheWrite > 0) entry.cacheWrite += usage.cacheWrite;
+  if (typeof usage.total === "number" && usage.total > 0) entry.total += usage.total;
+  if (model && model.trim()) entry.model = model.trim();
+  if (provider && provider.trim()) entry.provider = provider.trim();
+}
+
+export function consumeRunUsage(runId: string): FridaySessionUsagePayload | undefined {
+  const entry = usageByRunId.get(runId);
+  if (!entry) return undefined;
+  usageByRunId.delete(runId);
+  const tokens: NonNullable<FridaySessionUsagePayload["tokens"]> = {};
+  if (entry.input > 0) tokens.input = entry.input;
+  if (entry.output > 0) tokens.output = entry.output;
+  if (entry.cacheRead > 0) tokens.cacheRead = entry.cacheRead;
+  if (entry.cacheWrite > 0) tokens.cacheWrite = entry.cacheWrite;
+  if (entry.total > 0) tokens.total = entry.total;
+  tokens.totalFresh = true;
+  if (Object.keys(tokens).length === 1) return undefined; // only totalFresh, no actual tokens
+  const payload: FridaySessionUsagePayload = { tokens };
+  if (entry.model) payload.modelId = entry.model;
+  if (entry.provider) payload.modelProvider = entry.provider;
+  return payload;
+}
+
+/** Vitest-only. */
+export function resetRunUsageAccumulatorForTest(): void {
+  usageByRunId.clear();
+}

package/src/friday-session.forward-agent.test.ts

@@ -10,6 +10,7 @@ import {
   resetThinkingStreamAccumStateForTest,
 } from "./friday-session.js";
 import { resetRunMetadataForTest } from "./run-metadata.js";
+import { accumulateRunUsage, resetRunUsageAccumulatorForTest } from "./agent/run-usage-accumulator.js";
 import { sseEmitter } from "./sse/emitter.js";
 import { toSessionStoreKey } from "./session/session-manager.js";
 
@@ -24,6 +25,7 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     resetOpenClawRunDeviceMappingForTest();
     resetFridayAgentForwardRuntimeForTest();
     resetRunMetadataForTest();
+    resetRunUsageAccumulatorForTest();
     registerFridaySessionDeviceMapping(sessionKey, deviceId);
     vi.spyOn(sseEmitter, "broadcastToRun").mockImplementation(() => {});
   });
@@ -198,38 +200,107 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     expect("reasoningPrefixChars" in (payload.data as object)).toBe(false);
   });
 
-  it("merges sessionUsage from session store on lifecycle end after persist (deferred)", async () => {
+  it("builds sessionUsage from llm_output accumulated usage on lifecycle end", () => {
+    // Simulate llm_output hook accumulating usage across API calls.
+    accumulateRunUsage(runId, { input: 100, output: 50, cacheRead: 10, total: 150 }, "my-model", "openai");
+    accumulateRunUsage(runId, { input: 30, output: 10, cacheRead: 0, total: 40 }, "my-model", "openai");
+
+    forwardAgentEventRaw({
+      runId,
+      seq: 1,
+      stream: "lifecycle",
+      sessionKey,
+      data: { phase: "end" },
+    });
+
+    // Lifecycle events are synchronous now (no file I/O wait).
+    expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(1);
+    const forwarded = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[0][1].data;
+    expect(forwarded.stream).toBe("lifecycle");
+    const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<string, unknown>;
+    expect(sessionUsage).toBeDefined();
+    expect(sessionUsage.modelId).toBe("my-model");
+    expect(sessionUsage.modelProvider).toBe("openai");
+    // Accumulated totals across both API calls.
+    expect((sessionUsage.tokens as Record<string, unknown>).input).toBe(130);
+    expect((sessionUsage.tokens as Record<string, unknown>).output).toBe(60);
+    expect((sessionUsage.tokens as Record<string, unknown>).cacheRead).toBe(10);
+    expect((sessionUsage.tokens as Record<string, unknown>).total).toBe(190);
+    expect((sessionUsage.tokens as Record<string, unknown>).totalFresh).toBe(true);
+  });
+
+  it("merges llm_output usage with RunMetadata for sessionUsage on lifecycle end", () => {
+    // Simulate llm_output hook.
+    accumulateRunUsage(runId, { input: 500, output: 100, cacheRead: 200, cacheWrite: 0, total: 800 }, "llm-model", "llm-provider");
+
+    // Send an agent event that populates RunMetadata (model, context window).
+    forwardAgentEventRaw({
+      runId,
+      seq: 1,
+      stream: "assistant",
+      sessionKey,
+      data: {
+        model: "agent-model",
+        provider: "agent-provider",
+        usage: { input: 999, total: 999 },
+        contextWindow: 100000,
+      },
+    });
+
+    forwardAgentEventRaw({
+      runId,
+      seq: 2,
+      stream: "lifecycle",
+      sessionKey,
+      data: { phase: "end" },
+    });
+
+    // Assistant (1st) + lifecycle.end (2nd, synchronous).
+    expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(2);
+    const lifecycleCall = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[1];
+    const lifecycleData = (lifecycleCall[1] as { data: { data: Record<string, unknown> } }).data.data;
+    const sessionUsage = lifecycleData.sessionUsage as Record<string, unknown> | undefined;
+    expect(sessionUsage).toBeDefined();
+    // llm_output tokens win (authoritative per-API-call data).
+    expect(sessionUsage!.modelId).toBe("llm-model");
+    expect(sessionUsage!.modelProvider).toBe("llm-provider");
+    expect((sessionUsage!.tokens as Record<string, unknown>).input).toBe(500);
+    expect((sessionUsage!.tokens as Record<string, unknown>).output).toBe(100);
+    expect((sessionUsage!.tokens as Record<string, unknown>).cacheRead).toBe(200);
+    expect((sessionUsage!.tokens as Record<string, unknown>).total).toBe(800);
+    // Context from RunMetadata (not available from llm_output).
+    expect((sessionUsage!.context as Record<string, unknown>).windowMax).toBe(100000);
+  });
+
+  it("falls back to store read when llm_output has no data (deferred)", async () => {
     const storeKey = toSessionStoreKey(sessionKey);
     const store: Record<string, Record<string, unknown>> = {
       [storeKey]: {
-        model: "my-model",
-        modelProvider: "openai",
-        inputTokens: 100,
-        outputTokens: 50,
-        totalTokens: 9999,
+        model: "store-model",
+        modelProvider: "store-provider",
+        inputTokens: 200,
+        outputTokens: 80,
+        totalTokens: 5000,
         totalTokensFresh: true,
-        contextTokens: 128000,
-        estimatedCostUsd: 0.01,
-        cacheRead: 10,
+        contextTokens: 64000,
+        estimatedCostUsd: 0.05,
+        cacheRead: 20,
         cacheWrite: 0,
       },
     };
-    const loadSessionStore = vi.fn(() => store);
-    const mockApi = {
+    setFridayAgentForwardRuntime({
       runtime: {
-        config: {
-          current: () => ({ session: {} }),
-        },
+        config: { current: () => ({ session: {} }) },
         agent: {
           session: {
             resolveStorePath: () => "/tmp/sessions.json",
-            loadSessionStore,
+            loadSessionStore: vi.fn(() => store),
           },
         },
       },
-    };
-    setFridayAgentForwardRuntime(mockApi as never);
+    } as never);
 
+    // No llm_output data accumulated — store is the only token source.
     forwardAgentEventRaw({
       runId,
       seq: 1,
@@ -237,28 +308,24 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
       sessionKey,
       data: { phase: "end" },
     });
+    // Deferred: not broadcast yet (setTimeout 100ms hasn't fired).
     expect(sseEmitter.broadcastToRun).not.toHaveBeenCalled();
 
-    await new Promise<void>((resolve) => setImmediate(resolve));
+    await new Promise<void>((resolve) => setTimeout(resolve, 150));
 
     expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(1);
     const forwarded = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[0][1].data;
     expect(forwarded.stream).toBe("lifecycle");
-    expect((forwarded.data as Record<string, unknown>).sessionUsage).toEqual({
-      modelId: "my-model",
-      modelProvider: "openai",
-      tokens: {
-        input: 100,
-        output: 50,
-        cacheRead: 10,
-        cacheWrite: 0,
-        total: 9999,
-        totalFresh: true,
-      },
-      context: { windowMax: 128000, used: 9999 },
-      estimatedCostUsd: 0.01,
-    });
-    expect(loadSessionStore).toHaveBeenCalledWith("/tmp/sessions.json", { skipCache: true });
+    const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<string, unknown>;
+    expect(sessionUsage).toBeDefined();
+    expect(sessionUsage.modelId).toBe("store-model");
+    expect(sessionUsage.modelProvider).toBe("store-provider");
+    expect((sessionUsage.tokens as Record<string, unknown>).input).toBe(200);
+    expect((sessionUsage.tokens as Record<string, unknown>).output).toBe(80);
+    expect((sessionUsage.tokens as Record<string, unknown>).total).toBe(5000);
+    expect((sessionUsage.tokens as Record<string, unknown>).totalFresh).toBe(true);
+    expect((sessionUsage.context as Record<string, unknown>).windowMax).toBe(64000);
+    expect(sessionUsage.estimatedCostUsd).toBe(0.05);
   });
 });
 

package/src/friday-session.ts

@@ -4,7 +4,9 @@ import { toSessionStoreKey } from "./session/session-manager.js";
 import { getOpenClawAgentRunContext } from "./agent-run-context-bridge.js";
 import { observeAgentEventForActiveRuns } from "./agent/active-runs.js";
 import { getRunMetadata, ingestAgentEventMetadata } from "./run-metadata.js";
+import { consumeRunUsage } from "./agent/run-usage-accumulator.js";
 import { buildSessionUsageSnapshot } from "./session-usage-snapshot.js";
+import type { FridaySessionUsagePayload } from "./session-usage-snapshot.js";
 import {
   lookupByRunId,
   registerSessionKeyForRun,
@@ -178,7 +180,7 @@ function mergeRunMetadataIntoLifecycleEnd(
   return { ...base, ...extra };
 }
 
-function tryReadSessionUsageFromStore(sessionKeyForStore: string): ReturnType<typeof buildSessionUsageSnapshot> {
+function tryReadSessionUsageFromStore(sessionKeyForStore: string): FridaySessionUsagePayload | undefined {
   const access = getFridayAgentForwardRuntime();
   if (!access) return undefined;
   try {
@@ -195,6 +197,51 @@ function tryReadSessionUsageFromStore(sessionKeyForStore: string): ReturnType<ty
   }
 }
 
+function buildSessionUsageFromRunMetadata(runId: string): FridaySessionUsagePayload | undefined {
+  const meta = getRunMetadata(runId);
+  if (!meta) return undefined;
+  const payload: FridaySessionUsagePayload = {};
+  if (typeof meta.modelName === "string" && meta.modelName.trim()) {
+    payload.modelId = meta.modelName.trim();
+  }
+  if (typeof meta.modelProvider === "string" && meta.modelProvider.trim()) {
+    payload.modelProvider = meta.modelProvider.trim();
+  }
+  const tokens: NonNullable<typeof payload.tokens> = {};
+  if (typeof meta.inputTokens === "number") tokens.input = meta.inputTokens;
+  if (typeof meta.outputTokens === "number") tokens.output = meta.outputTokens;
+  if (typeof meta.cacheReadTokens === "number") tokens.cacheRead = meta.cacheReadTokens;
+  if (typeof meta.cacheWriteTokens === "number") tokens.cacheWrite = meta.cacheWriteTokens;
+  if (typeof meta.totalTokens === "number") tokens.total = meta.totalTokens;
+  if (Object.keys(tokens).length > 0) payload.tokens = tokens;
+  const context: NonNullable<typeof payload.context> = {};
+  if (typeof meta.contextWindowMax === "number") context.windowMax = meta.contextWindowMax;
+  if (typeof meta.totalTokens === "number") context.used = meta.totalTokens;
+  if (Object.keys(context).length > 0) payload.context = context;
+  if (!payload.modelId && !payload.modelProvider && !payload.tokens && !payload.context) {
+    return undefined;
+  }
+  return payload;
+}
+
+function mergeUsage(
+  llmUsage: FridaySessionUsagePayload | undefined,
+  memUsage: FridaySessionUsagePayload | undefined,
+): FridaySessionUsagePayload | undefined {
+  if (!llmUsage && !memUsage) return undefined;
+  if (!llmUsage) return memUsage;
+  if (!memUsage) return llmUsage;
+  // llm_output tokens are authoritative (per API call, no race);
+  // RunMetadata fills context window gaps.
+  return {
+    modelId: llmUsage.modelId ?? memUsage.modelId,
+    modelProvider: llmUsage.modelProvider ?? memUsage.modelProvider,
+    tokens: llmUsage.tokens,
+    context: memUsage.context ?? llmUsage.context,
+    estimatedCostUsd: llmUsage.estimatedCostUsd ?? memUsage.estimatedCostUsd,
+  };
+}
+
 function completeAgentEventForward(params: {
   evt: ForwardAgentEventArgs;
   sk: string;
@@ -436,23 +483,38 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
     }
   }
 
-  if (isTerminalLifecycle && getFridayAgentForwardRuntime()) {
-    setImmediate(() => {
-      let data = outgoingData;
-      const usage = tryReadSessionUsageFromStore(sk);
+  // Build sessionUsage: llm_output hook (primary, no race) → store read (fallback).
+  if (isTerminalLifecycle) {
+    const llmUsage = consumeRunUsage(evt.runId);
+    const memUsage = buildSessionUsageFromRunMetadata(evt.runId);
+    const hasRealTokens = llmUsage?.tokens && Object.keys(llmUsage.tokens).length > 1;
+
+    if (hasRealTokens) {
+      const usage = mergeUsage(llmUsage, memUsage);
       if (usage) {
-        data = { ...outgoingData, sessionUsage: usage };
+        outgoingData = { ...outgoingData, sessionUsage: usage };
       }
-      completeAgentEventForward({
-        evt,
-        sk,
-        deviceIdRaw,
-        outgoingData: data,
-        isTerminalLifecycle: true,
-        subagentMeta,
-      });
-    });
-    return;
+    } else if (getFridayAgentForwardRuntime()) {
+      // llm_output hook fires async ~20ms after lifecycle.end.
+      // Wait 100ms then re-check before falling back to store read.
+      setTimeout(() => {
+        let data = outgoingData;
+        const retryLlm = consumeRunUsage(evt.runId);
+        const usage = mergeUsage(retryLlm, memUsage) ?? tryReadSessionUsageFromStore(sk);
+        if (usage) {
+          data = { ...outgoingData, sessionUsage: usage };
+        }
+        completeAgentEventForward({
+          evt,
+          sk,
+          deviceIdRaw,
+          outgoingData: data,
+          isTerminalLifecycle: true,
+          subagentMeta,
+        });
+      }, 100);
+      return;
+    }
   }
 
   completeAgentEventForward({