@syengup/friday-channel-next 0.0.46 → 0.1.2

package/dist/src/http/handlers/health.js

@@ -0,0 +1,225 @@
+import { listDevicePairing, approveDevicePairing } from "openclaw/plugin-sdk/device-bootstrap";
+import { extractBearerToken } from "../middleware/auth.js";
+import { loadNodePairingModule } from "../../agent/node-pairing-bridge.js";
+import { createFridayNextLogger } from "../../logging.js";
+const REQUIRED_NODE_CAPS = ["location", "canvas"];
+const REQUIRED_NODE_COMMANDS = [
+    "location.get",
+    "canvas.present",
+    "canvas.hide",
+    "canvas.navigate",
+    "canvas.eval",
+    "canvas.snapshot",
+    "canvas.a2ui.push",
+    "canvas.a2ui.pushJSONL",
+    "canvas.a2ui.reset",
+];
+export async function handleHealth(req, res) {
+    if (req.method !== "GET") {
+        res.statusCode = 405;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Method Not Allowed" }));
+        return true;
+    }
+    const token = extractBearerToken(req);
+    if (!token) {
+        res.statusCode = 401;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Unauthorized: bearer token mismatch" }));
+        return true;
+    }
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const deviceId = (url.searchParams.get("deviceId") ?? "").trim();
+    const nodeDeviceId = (url.searchParams.get("nodeDeviceId") ?? "").trim();
+    const selfHeal = (url.searchParams.get("selfHeal") ?? "").toLowerCase() === "true";
+    const result = {
+        ok: true,
+        timestamp: Date.now(),
+        deviceId,
+        nodeDeviceId,
+    };
+    const log = createFridayNextLogger("health");
+    if (deviceId) {
+        result.devicePairing = await checkDevicePairing(deviceId, selfHeal, result, log);
+    }
+    if (nodeDeviceId) {
+        result.nodePairing = await checkNodePairing(nodeDeviceId, selfHeal, result, log);
+    }
+    const statuses = [
+        result.devicePairing?.status,
+        result.nodePairing?.status,
+    ].filter(Boolean);
+    result.ok = statuses.length === 0 || statuses.every((s) => s === "ok" || s === "pending");
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(result));
+    return true;
+}
+async function checkDevicePairing(deviceId, selfHeal, result, log) {
+    const normalizedDeviceId = deviceId.trim().toUpperCase();
+    let pairing;
+    try {
+        pairing = await listDevicePairing();
+    }
+    catch (err) {
+        log.error(`listDevicePairing failed: ${err instanceof Error ? err.message : String(err)}`);
+        return {
+            status: "failed",
+            detail: `listDevicePairing failed: ${err instanceof Error ? err.message : String(err)}`,
+            devicePaired: false,
+        };
+    }
+    const pairedDevice = (pairing?.paired ?? []).find((entry) => entry.deviceId?.trim().toUpperCase() === normalizedDeviceId);
+    if (pairedDevice) {
+        const approvedScopes = pairedDevice.approvedScopes ?? [];
+        const tokens = pairedDevice.tokens ?? {};
+        const hasValidToken = Object.values(tokens).some((t) => !t.revokedAtMs);
+        if (approvedScopes.length === 0 || !hasValidToken) {
+            const issues = [];
+            if (approvedScopes.length === 0)
+                issues.push("no approved scopes");
+            if (!hasValidToken)
+                issues.push("all tokens revoked");
+            return {
+                status: "degraded",
+                detail: `Device paired but degraded: ${issues.join(", ")}`,
+                devicePaired: true,
+                approvedScopesEmpty: approvedScopes.length === 0,
+                tokensRevoked: !hasValidToken,
+            };
+        }
+        return { status: "ok", detail: "Device paired and healthy", devicePaired: true };
+    }
+    const pendingDevice = (pairing?.pending ?? []).find((entry) => entry.deviceId?.trim().toUpperCase() === normalizedDeviceId);
+    if (pendingDevice && selfHeal) {
+        try {
+            const approved = await approveDevicePairing(pendingDevice.requestId);
+            const succeeded = approved && approved.status === "approved";
+            (result.repairActions ??= []).push({
+                component: "devicePairing",
+                action: "approveDevicePairing",
+                result: succeeded ? "ok" : "failed",
+                detail: succeeded
+                    ? `Auto-approved device ${normalizedDeviceId}`
+                    : `approveDevicePairing returned status=${approved?.status ?? "null"}`,
+            });
+            if (succeeded) {
+                log.info(`Auto-approved device ${normalizedDeviceId}`);
+                return { status: "ok", detail: "Device was pending, auto-approved", devicePaired: true };
+            }
+        }
+        catch (err) {
+            log.error(`approveDevicePairing failed: ${err instanceof Error ? err.message : String(err)}`);
+            (result.repairActions ??= []).push({
+                component: "devicePairing",
+                action: "approveDevicePairing",
+                result: "failed",
+                detail: err instanceof Error ? err.message : String(err),
+            });
+        }
+        return {
+            status: "degraded",
+            detail: "Device pending but auto-approve failed",
+            devicePaired: false,
+        };
+    }
+    if (pendingDevice) {
+        return { status: "pending", detail: "Device is pending approval", devicePaired: false };
+    }
+    return { status: "not_found", detail: `Device ${normalizedDeviceId} not registered`, devicePaired: false };
+}
+async function checkNodePairing(nodeDeviceId, selfHeal, result, log) {
+    const normalizedNodeId = nodeDeviceId.trim().toUpperCase();
+    let listData, listNodePairing, approveNodePairing;
+    try {
+        ({ listNodePairing, approveNodePairing } = await loadNodePairingModule());
+    }
+    catch (err) {
+        log.error(`loadNodePairingModule failed: ${err instanceof Error ? err.message : String(err)}`);
+        return {
+            status: "failed",
+            detail: `loadNodePairingModule failed: ${err instanceof Error ? err.message : String(err)}`,
+            nodePaired: false,
+        };
+    }
+    try {
+        listData = await listNodePairing();
+    }
+    catch (err) {
+        log.error(`listNodePairing failed: ${err instanceof Error ? err.message : String(err)}`);
+        return {
+            status: "failed",
+            detail: `listNodePairing failed: ${err instanceof Error ? err.message : String(err)}`,
+            nodePaired: false,
+        };
+    }
+    const pairedNodes = listData?.paired ?? [];
+    const pairedMatch = pairedNodes.find((entry) => entry.nodeId?.trim().toUpperCase() === normalizedNodeId);
+    if (pairedMatch) {
+        const caps = pairedMatch.caps ?? [];
+        const commands = pairedMatch.commands ?? [];
+        const hasRequiredCaps = REQUIRED_NODE_CAPS.every((c) => caps.includes(c));
+        const hasRequiredCommands = REQUIRED_NODE_COMMANDS.every((c) => commands.includes(c));
+        const capsValid = caps.length > 0 && hasRequiredCaps;
+        const commandsValid = commands.length > 0 && hasRequiredCommands;
+        if (capsValid && commandsValid) {
+            return {
+                status: "ok",
+                detail: `Node paired with ${caps.length} caps, ${commands.length} commands`,
+                nodePaired: true,
+                capsCount: caps.length,
+                commandsCount: commands.length,
+                capsValid: true,
+                commandsValid: true,
+            };
+        }
+        return {
+            status: "degraded",
+            detail: `Node paired but caps/commands incomplete: caps=${caps.length} (valid=${capsValid}), commands=${commands.length} (valid=${commandsValid})`,
+            nodePaired: true,
+            capsCount: caps.length,
+            commandsCount: commands.length,
+            capsValid,
+            commandsValid,
+        };
+    }
+    const pendingNodes = listData?.pending ?? [];
+    const pendingMatch = pendingNodes.find((entry) => entry.nodeId?.trim().toUpperCase() === normalizedNodeId);
+    if (pendingMatch && selfHeal) {
+        try {
+            const callerScopes = ["operator.admin", "operator.pairing", "operator.read", "operator.write"];
+            const approved = await approveNodePairing(pendingMatch.requestId, { callerScopes });
+            const succeeded = approved != null && !("status" in approved && approved.status === "forbidden") && "requestId" in approved;
+            (result.repairActions ??= []).push({
+                component: "nodePairing",
+                action: "approveNodePairing",
+                result: succeeded ? "ok" : "failed",
+                detail: succeeded
+                    ? `Auto-approved node ${normalizedNodeId}`
+                    : `approveNodePairing returned status=${approved?.status ?? "null"}`,
+            });
+            if (succeeded) {
+                log.info(`Auto-approved node ${normalizedNodeId}`);
+                return { status: "ok", detail: "Node was pending, auto-approved", nodePaired: true };
+            }
+        }
+        catch (err) {
+            log.error(`approveNodePairing failed: ${err instanceof Error ? err.message : String(err)}`);
+            (result.repairActions ??= []).push({
+                component: "nodePairing",
+                action: "approveNodePairing",
+                result: "failed",
+                detail: err instanceof Error ? err.message : String(err),
+            });
+        }
+        return {
+            status: "degraded",
+            detail: "Node pending but auto-approve failed",
+            nodePaired: false,
+        };
+    }
+    if (pendingMatch) {
+        return { status: "pending", detail: "Node is pending approval", nodePaired: false };
+    }
+    return { status: "not_found", detail: `Node ${normalizedNodeId} not registered`, nodePaired: false };
+}

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

@@ -179,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,7 +1,8 @@
 {
   "name": "@syengup/friday-channel-next",
-  "version": "0.0.46",
+  "version": "0.1.2",
   "description": "OpenClaw Friday Next Apple channel plugin",
+  "license": "MIT",
   "type": "module",
   "files": [
     "dist/",
@@ -11,6 +12,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 +66,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);
   });
 });