test(desktop): exercise the injected preload failure behind the usage overview

The review of 7a51a1c observed that the failure-path coverage for the
main-only usage read stopped at the overview model: nothing pinned the
preload wiring that feeds it. Extract the blended+main double query into
`preload/usage-summary.ts` with the invoke surface injectable, keep
`preload.ts` on the real `invokeWhenReady`, and pin the injected failure:
a failed main-only IPC call marks `mainSummaryUnavailable` on the blended
summary (and the narrow read asks for exactly `callKinds: ['main']`),
while both-succeed attaches `mainSummary`.

Generated-by: GLM-5.3-Flash (ZCode)

Author: ggbdpq

apps/desktop/src/main/__tests__/session-inspector-usage-stats.test.ts

@@ -26,6 +26,11 @@ import {
   usageRingArcs,
 } from '../../renderer/features/workbar/testing.js';
 import type { UsageSummaryV2 } from '@maka/core/usage-stats/types';
+import type { DesktopSessionUsageSummary } from '../../preload/bridge-contract.js';
+import {
+  loadSessionUsageSummaryVia,
+  type UsageSummaryInvoke,
+} from '../../preload/usage-summary.js';
 
 function usageSummary(overrides: Partial<UsageSummaryV2> = {}): UsageSummaryV2 {
   return {
@@ -49,6 +54,22 @@ function usageSummary(overrides: Partial<UsageSummaryV2> = {}): UsageSummaryV2 {
   };
 }
 
+function fullCoverageProvenance(): DesktopSessionUsageSummary['provenance'] {
+  return {
+    coverage: {
+      attempts: 3,
+      pricedAttempts: 3,
+      unpricedAttempts: 0,
+      usageReportedAttempts: 3,
+      usagePartialAttempts: 0,
+      usageMissingAttempts: 0,
+    },
+    legacyRecords: 0,
+    unreadableRecords: 0,
+    pendingRepairs: 0,
+  };
+}
+
 test('splits the session metered tokens the way a bill reads', () => {
   const { tokenUsage } = deriveInspectorOverviewModel(
     undefined,
@@ -405,3 +426,55 @@ test('shows no cache rate when the main-only read failed rather than blending',
 
   assert.equal(cacheHitRate, undefined);
 });
+
+test('marks the overview when the injected preload IPC read of the main loop fails', async () => {
+  // The model-level test above pins the hiding rule; this one pins the
+  // preload wiring that feeds it. A failed main-only IPC call — the injected
+  // preload failure path — must mark the blended summary rather than drop
+  // the overview or present the blend as the main loop's (#5691 review).
+  const blended: DesktopSessionUsageSummary = {
+    ...usageSummary(),
+    provenance: fullCoverageProvenance(),
+  };
+  const calls: Array<Record<string, unknown>> = [];
+  const invoke: UsageSummaryInvoke = async (_channel, _scope, args) => {
+    calls.push(args);
+    return (args as { callKinds?: readonly string[] }).callKinds
+      ? { ok: false, error: { code: 'persistence_failed', message: 'usage read failed' } }
+      : { ok: true, data: blended };
+  };
+
+  const outcome = await loadSessionUsageSummaryVia(invoke, {
+    scope: { profileId: 'profile-1' },
+    sessionId: 'session-1',
+  });
+
+  assert.equal(outcome.ok, true);
+  if (!outcome.ok) return;
+  assert.equal(outcome.data.mainSummary, undefined);
+  assert.equal(outcome.data.mainSummaryUnavailable, true);
+  // The second read asked for exactly the agent loop's own calls.
+  assert.deepEqual(
+    calls.map((args) => (args as { callKinds?: readonly string[] }).callKinds ?? null),
+    [null, ['main']],
+  );
+});
+
+test('attaches the main summary when both injected preload reads succeed', async () => {
+  const invoke: UsageSummaryInvoke = async (_channel, _scope, args) => ({
+    ok: true,
+    data: (args as { callKinds?: readonly string[] }).callKinds
+      ? { ...usageSummary(), provenance: fullCoverageProvenance(), cacheHitRequests: 2 }
+      : { ...usageSummary({ cacheHitRequests: 3 }), provenance: fullCoverageProvenance() },
+  });
+
+  const outcome = await loadSessionUsageSummaryVia(invoke, {
+    scope: { profileId: 'profile-1' },
+    sessionId: 'session-1',
+  });
+
+  assert.equal(outcome.ok, true);
+  if (!outcome.ok) return;
+  assert.equal(outcome.data.mainSummaryUnavailable, undefined);
+  assert.equal(outcome.data.mainSummary?.cacheHitRequests, 2);
+});

apps/desktop/src/preload/preload.ts

@@ -91,6 +91,7 @@ import type {
   AppIconSelectResult,
 } from './bridge-contract.js';
 import type { ExternalSessionImportIpcResult } from './external-session-import-result.js';
+import { loadSessionUsageSummaryVia } from './usage-summary.js';
 import type { RuntimeHostObservationIpcResult } from '../shared/runtime-host-observation-ipc.js';
 import {
   projectDesktopExternalSessionCatalogItem,
@@ -1315,25 +1316,7 @@ async function loadSessionTracePage(
 async function loadSessionUsageSummary(
   sessionId: string,
 ): Promise<Result<DesktopSessionUsageSummary>> {
-  const session = await runtimeHostSessionRef(sessionId);
-  const summaryQuery = { range: 'all' as const, sessionId: session.sessionId };
-  // The overview reads the Session's whole metered spend and, separately, the
-  // agent loop's own calls: auxiliary prompts do not share the main loop's
-  // cached prefix, so a blended rate under-reports it (#5691).
-  const [summary, main] = (await Promise.all([
-    invokeWhenReady('usage:summary', session.scope, summaryQuery),
-    invokeWhenReady('usage:summary', session.scope, {
-      ...summaryQuery,
-      callKinds: ['main'],
-    }),
-  ])) as [Result<DesktopSessionUsageSummary>, Result<DesktopSessionUsageSummary>];
-  if (!summary.ok) return summary;
-  // The main-only read refines the cache rate; losing it must not lose the
-  // overview — but it must also not pass the blended rate off as the main
-  // loop's, so the failure is marked and the rate hides itself (#5691).
-  return main.ok
-    ? { ...summary, data: { ...summary.data, mainSummary: main.data } }
-    : { ...summary, data: { ...summary.data, mainSummaryUnavailable: true } };
+  return loadSessionUsageSummaryVia(invokeWhenReady, await runtimeHostSessionRef(sessionId));
 }
 
 async function updateDailyReviewConfig(

apps/desktop/src/preload/usage-summary.ts

@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import type { Result } from '@maka/core/result';
+import type { DesktopSessionUsageSummary } from './bridge-contract.js';
+
+/** The narrow invoke surface the usage overview needs; injectable for tests. */
+export type UsageSummaryInvoke = (
+  channel: 'usage:summary',
+  scope: unknown,
+  args: Record<string, unknown>,
+) => Promise<Result<DesktopSessionUsageSummary>>;
+
+/**
+ * The overview reads the Session's whole metered spend and, separately, the
+ * agent loop's own calls: auxiliary prompts do not share the main loop's
+ * cached prefix, so a blended rate under-reports it (#5691).
+ *
+ * The main-only read refines the cache rate; losing it must not lose the
+ * overview — but it must also not pass the blended rate off as the main
+ * loop's, so the failure is marked and the rate hides itself (#5691).
+ */
+export async function loadSessionUsageSummaryVia(
+  invoke: UsageSummaryInvoke,
+  session: { readonly scope: unknown; readonly sessionId: string },
+): Promise<Result<DesktopSessionUsageSummary>> {
+  const summaryQuery = { range: 'all' as const, sessionId: session.sessionId };
+  const [summary, main] = (await Promise.all([
+    invoke('usage:summary', session.scope, summaryQuery),
+    invoke('usage:summary', session.scope, { ...summaryQuery, callKinds: ['main'] }),
+  ])) as [Result<DesktopSessionUsageSummary>, Result<DesktopSessionUsageSummary>];
+  if (!summary.ok) return summary;
+  return main.ok
+    ? { ...summary, data: { ...summary.data, mainSummary: main.data } }
+    : { ...summary, data: { ...summary.data, mainSummaryUnavailable: true } };
+}