granttap-mcp 0.8.85 → 0.8.87

package/README.md

@@ -843,3 +843,7 @@ sustained structured work in a different checkout without interpreting chat
 titles. Task identity and its original coordination/access scope survive.
 
 See [repository observations](apps/bridge/src/mesh/repository-details/README.md).
+
+The relay can retain recipient-encrypted catalogs, Mesh snapshots, capability usage and recent chat heads for reconnect without the computer. This bounded seven-day read cache is separate from the durable encrypted command queue. See [relay state publication](packages/core/retained-state/README.md). The relay never receives decryption keys or readable chat content.
+
+Tools & Skills matches recorded usage to the exact computer, provider and execution. Codex's native history projection supplies actual MCP invocation IDs, results and durations, including calls made through Code Mode. Claude Code uses observed tool-use, result and Skill records, aggregating MCP and skill calls before its recent-detail cache is trimmed. Execution summaries remain available when older call details fall outside the recent-event budget. Counts describe recorded evidence; installation and permission do not prove usage. Missing resource measurements remain unknown. See [native capability history](apps/bridge/src/sessions/native-capability-history/README.md).

package/apps/bridge/src/host/session-keys.ts

@@ -1,3 +1,4 @@
+import { retainedPayloadOptions } from "../../../../packages/core/retained-state";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { loadSessionKeys, persistedSessionKey } from "./session-key-store";
@@ -70,6 +71,9 @@ async function sendScopedPayload(input: {
   options: SendOptions;
 }): Promise<void> {
   const { client, payload, sessionId, purpose, to, options } = input;
+  const retained = retainedPayloadOptions(payload);
+  const grantOptions = retained.stateKey ? {}
+    : { stateKey: undefined, stateRevision: undefined, statePriority: undefined, stateGroup: undefined };
   const key = sessionKey(sessionId);
   client.setSessionKey(sessionId, key);
   await client.send({
@@ -78,6 +82,6 @@ async function sendScopedPayload(input: {
     key,
     purpose,
     createdAt: Date.now(),
-  }, to, { ttlMs: options.ttlMs, peerPublicKey: options.peerPublicKey });
+  }, to, { ttlMs: options.ttlMs, peerPublicKey: options.peerPublicKey, ...grantOptions });
   await client.sendSession(payload, sessionId, to, options);
 }

package/apps/bridge/src/mesh/catalog/README.md

@@ -17,6 +17,16 @@ negative probes nor old repository identities persist across refreshes.
 Behavior tests: `tests/agentic/codex-workspace-binding.test.ts` and
 `tests/project/project-mesh-core.test.ts`.
 
+## Background Graph admission
+
+`inspectRepositoryAsync` provides the same repository facts without blocking
+relay callbacks. Native Git subprocesses are limited to two across the process.
+Concurrent inspections of the same path share their in-flight result; a later
+inspection verifies the checkout again. Missing Git facts remain unknown.
+
+Tests for asynchronous inspection live in `tests/`; Graph admission also has
+`runtime/graph/tests/responsiveness/checkout-inspection.test.ts`.
+
 ## License
 
 GrantTap Commercial Source License. See [LICENSE](../../../../../LICENSE).

package/apps/bridge/src/mesh/catalog/index.ts

@@ -19,6 +19,7 @@ import { readIntegrationMap } from "../observed/integration-map";
 import type { MeshStore } from "../store";
 import { queueProjectBindingSync } from "../../engine/runtime/engine-projects";
 import { isCursorTaskCloneId } from "../../sessions/cursor/catalog";
+export { inspectRepositoryAsync } from "./repository-inspection";
 
 export type RepositoryFacts = {
   root: string;

package/apps/bridge/src/mesh/catalog/repository-inspection.ts

@@ -0,0 +1,49 @@
+import { execFile } from "node:child_process";
+import { canonicalRepositoryIdentity, sanitizedRepositoryRemote } from "../identity";
+import type { RepositoryFacts } from ".";
+
+let running = 0;
+const waiting: Array<() => void> = [];
+const pending = new Map<string, Promise<RepositoryFacts>>();
+
+/** Native read-only Git work stays bounded without blocking relay callbacks. */
+function git(cwd: string, args: string[]): Promise<string | undefined> {
+  return new Promise(resolve => {
+    const run = () => {
+      running++;
+      const done = (error: Error | null, stdout = "") => {
+        running--;
+        waiting.shift()?.();
+        resolve(error ? undefined : stdout.trim() || undefined);
+      };
+      try {
+        execFile("git", ["-C", cwd, ...args], {
+          encoding: "utf8", timeout: 2_000, maxBuffer: 1024 * 1024, windowsHide: true,
+        }, done);
+      } catch { done(new Error("Repository command could not start")); }
+    };
+    if (running < 2) run(); else waiting.push(run);
+  });
+}
+
+async function inspect(cwd: string): Promise<RepositoryFacts> {
+  const worktree = await git(cwd, ["rev-parse", "--show-toplevel"]);
+  const root = worktree ?? cwd;
+  const [rawRemote, revision, branch] = await Promise.all([
+    git(root, ["remote", "get-url", "origin"]),
+    git(root, ["rev-parse", "HEAD"]),
+    git(root, ["symbolic-ref", "--quiet", "--short", "HEAD"]),
+  ]);
+  return { root, worktree, revision, branch,
+    baseRemote: rawRemote ? sanitizedRepositoryRemote(rawRemote) : undefined,
+    canonicalRepositoryId: canonicalRepositoryIdentity(rawRemote, root) };
+}
+
+/** Share only in-flight observations; a later refresh verifies the checkout again. */
+export function inspectRepositoryAsync(cwd: string): Promise<RepositoryFacts> {
+  const active = pending.get(cwd);
+  if (active) return active;
+  const next = inspect(cwd).finally(() => { pending.delete(cwd); });
+  pending.set(cwd, next);
+  return next;
+}

package/apps/bridge/src/mesh/runtime/graph/binding-sync.ts

@@ -1,7 +1,7 @@
 import { realpathSync } from "node:fs";
 import type { MeshSnapshot, ProjectRepositoryGraph } from "../../../../../../packages/protocol/schema";
 import { queueProjectBindingSync } from "../../../engine/runtime/engine-projects";
-import { inspectRepository } from "../../catalog";
+import { inspectRepositoryAsync, type RepositoryFacts } from "../../catalog";
 import { computerId } from "../../identity/computer";
 import { matchesLocalCheckout } from "./checkout-identity";
 
@@ -18,18 +18,18 @@ export async function refreshLocalGraphBindings(
   snapshot: MeshSnapshot,
   dependencies: {
     endpoint: () => string;
-    inspect: typeof inspectRepository;
+    inspect: (cwd: string) => RepositoryFacts | Promise<RepositoryFacts>;
     sync: typeof queueProjectBindingSync;
-  } = { endpoint: computerId, inspect: inspectRepository, sync: queueProjectBindingSync },
+  } = { endpoint: computerId, inspect: inspectRepositoryAsync, sync: queueProjectBindingSync },
 ): Promise<ProjectRepositoryGraph[]> {
   const localEndpoint = dependencies.endpoint();
   const candidates = (snapshot.bindings ?? []).filter((binding) =>
     binding.endpointId === localEndpoint && binding.available && binding.localPathHint);
   const failures: ProjectRepositoryGraph[] = [];
-  const checkouts = candidates.flatMap((binding) => {
-    const facts = readCheckout(dependencies.inspect, binding.localPathHint!);
+  const checkouts = (await Promise.all(candidates.map(async binding => {
+    const facts = await readCheckout(dependencies.inspect, binding.localPathHint!);
     return facts ? [{ binding, facts, real: realpathSync(facts.root) }] : [];
-  });
+  }))).flat();
   await Promise.all(checkouts.map(async ({ binding, facts, real }) => {
     const pathIdentity = matchesLocalCheckout(binding.repositoryId, facts.root);
     if (facts.canonicalRepositoryId !== binding.repositoryId && !pathIdentity) {
@@ -58,9 +58,9 @@ export async function refreshLocalGraphBindings(
 }
 
 /** A Git checkout rooted exactly at the bound path, or nothing a Graph can be built from. */
-function readCheckout(inspect: typeof inspectRepository, path: string) {
+async function readCheckout(inspect: (cwd: string) => RepositoryFacts | Promise<RepositoryFacts>, path: string) {
   try {
-    const facts = inspect(path);
+    const facts = await inspect(path);
     if (!facts.worktree || realpathSync(facts.root) !== realpathSync(path)) return undefined;
     return facts;
   } catch {

package/apps/bridge/src/monitor/capability-publication/README.md

@@ -0,0 +1,13 @@
+# Usage publication
+
+Public entry: `index.ts`. Complete capability totals are computed from the live
+catalog and full discovered history. This work has one independent in-flight
+publication per relay client. A slow history read or encrypted fan-out does not
+hold the current chat catalog. Successful reports retain their existing cadence;
+failures retry on a later catalog publication. Closing the monitor prevents
+further queued reads and sends. Counts and unknown usage semantics are unchanged.
+Concurrent catalog and Usage requests share one in-flight history read. The
+history cache's lifetime begins when that read completes.
+
+Behavior tests live in `tests/`.
+Licensed under the GrantTap Commercial Source License in the repository root.

package/apps/bridge/src/monitor/capability-publication/index.ts

@@ -0,0 +1,38 @@
+import { setImmediate } from "node:timers/promises";
+import type { RelayClient } from "../../../../../packages/core/relay-client";
+import type { SessionInfo, SessionsStatus } from "../../../../../packages/protocol/schema";
+import { scanRecordedCapabilityUsage, scopeCapabilityUsageToRoom } from "../../sessions";
+
+type Publication = { running: boolean; closed: boolean; lastPublishedAt: number };
+const publications = new WeakMap<RelayClient, Publication>();
+
+/** A slow usage fan-out never occupies the current chat catalog's publication slot. */
+export function publishMonitorCapabilities(client: RelayClient, status: SessionsStatus,
+  history: () => Promise<SessionInfo[]>): void {
+  const state = publications.get(client) ?? { running: false, closed: false, lastPublishedAt: 0 };
+  publications.set(client, state);
+  if (state.running || state.closed || Date.now() - state.lastPublishedAt < 30_000) return;
+  state.running = true;
+  const work = (async () => {
+    await setImmediate();
+    if (state.closed || !client.isConnected) return;
+    const publish = async (sessions: SessionInfo[]) => {
+      const usage = await scanRecordedCapabilityUsage(sessions);
+      if (state.closed || !client.isConnected) return;
+      await client.send(scopeCapabilityUsageToRoom(usage, client.room), "phone",
+        { ttlMs: 90_000, reliable: false });
+    };
+    await publish(status.sessions);
+    const older = await history();
+    if (state.closed || !client.isConnected) return;
+    if (older.length) await publish([...status.sessions, ...older]);
+    state.lastPublishedAt = Date.now();
+  })();
+  void work.catch(() => {}).finally(() => { state.running = false; });
+}
+
+export function stopMonitorCapabilities(client: RelayClient): void {
+  const state = publications.get(client);
+  if (state) state.closed = true;
+  publications.delete(client);
+}

package/apps/bridge/src/monitor/support/runtime.ts

@@ -23,7 +23,7 @@ import { publishedCatalog, rememberPublishedCatalog, resumePublishedChats,
   publishCatalogHeads, stopCatalogHeads } from "../../session-catalog";
 import { createMachineLoadPublisher } from "../../machine-load";
 import { startMachineLoadLoop } from "../../machine-load/host/loop";
-import { scanCapabilityUsage, scanSessionHistoryCooperatively, scanSessionsCooperatively, scopeCapabilityUsageToRoom, TOKEN_WINDOW_HOURS } from "../../sessions";
+import { scanSessionHistoryCooperatively, scanSessionsCooperatively, TOKEN_WINDOW_HOURS } from "../../sessions";
 import { boundedCatalogHistory, INTERVAL_MS, publishSessionEvents } from "../handlers/catalog";
 import { sweepAttachments } from "../handlers/receipts";
 import { handleMonitorMessage } from "../handlers/inbound";
@@ -32,6 +32,7 @@ import { decorateTaskOriginCatalog } from '../../task-origins';
 const HISTORY_INTERVAL_MS = 60_000;
 const resumedHeads = new WeakSet<RelayClient>();
 import { publishMonitorMeshes, stopMonitorMeshes } from "../mesh-publication";
+import { publishMonitorCapabilities, stopMonitorCapabilities } from "../capability-publication";
 
 export type SessionMonitor = {
   publish: () => Promise<void>;
@@ -114,30 +115,33 @@ async function publishMonitorTick(input: {
   leadership: ReturnType<typeof monitorLeadership>;
   subscriptions: Set<string>;
   history: (force?: boolean) => Promise<SessionsStatus["sessions"]>;
-  clocks: { lastHistoryPublishedAt: number; lastCapabilityPublishedAt: number };
+  clocks: { lastHistoryPublishedAt: number };
   loadLoop: { updateStatus: (status: SessionsStatus) => void };
   forceHistory: boolean;
   active: () => boolean;
-}): Promise<{ lastHistoryPublishedAt: number; lastCapabilityPublishedAt: number }> {
+}): Promise<{ lastHistoryPublishedAt: number }> {
   const { client, leadership, subscriptions, history, clocks, loadLoop, forceHistory } = input;
-  let { lastHistoryPublishedAt, lastCapabilityPublishedAt } = clocks;
-  if (!client.isConnected) return { lastHistoryPublishedAt, lastCapabilityPublishedAt };
+  let { lastHistoryPublishedAt } = clocks;
+  if (!client.isConnected) return { lastHistoryPublishedAt };
   await publishHeartbeat(client).catch(() => {});
-  if (!input.active()) return { lastHistoryPublishedAt, lastCapabilityPublishedAt };
-  if (!leadership.acquire()) return { lastHistoryPublishedAt, lastCapabilityPublishedAt };
+  if (!input.active()) return { lastHistoryPublishedAt };
+  if (!leadership.acquire()) return { lastHistoryPublishedAt };
   await client.send(approvalsStatus(), "phone", { ttlMs: INTERVAL_MS * 3, reliable: false });
   const initial = lastHistoryPublishedAt === 0;
-  const includeHistory = forceHistory || (!initial && Date.now() - lastHistoryPublishedAt >= HISTORY_INTERVAL_MS);
-  const snapshot = await monitorSnapshot({ includeHistory, forceHistory, subscriptions, history });
-  if (!input.active()) return { lastHistoryPublishedAt, lastCapabilityPublishedAt };
-  const status = decorateTaskOriginCatalog(snapshot, client.room);
-  rememberPublishedCatalog(client, status);
-  await client.send(status, "phone", { ttlMs: INTERVAL_MS * 24, reliable: false });
   if (initial && !resumedHeads.has(client)) {
+    const saved = publishedCatalog(client);
+    if (saved) await client.send(saved, "phone", { ttlMs: INTERVAL_MS * 24, reliable: false });
+    if (!input.active()) return { lastHistoryPublishedAt };
     resumedHeads.add(client);
     void resumePublishedChats(client,
       (session, saved) => publishSessionEvents(client, session.sessionId, saved)).catch(() => {});
   }
+  const includeHistory = forceHistory || (!initial && Date.now() - lastHistoryPublishedAt >= HISTORY_INTERVAL_MS);
+  const snapshot = await monitorSnapshot({ includeHistory, forceHistory, subscriptions, history });
+  if (!input.active()) return { lastHistoryPublishedAt };
+  const status = decorateTaskOriginCatalog(snapshot, client.room);
+  rememberPublishedCatalog(client, status);
+  await client.send(status, "phone", { ttlMs: INTERVAL_MS * 24, reliable: false });
   // Provider review is independent of task visibility; a hung hook RPC must
   // never hold the current catalog behind its discovery timeout.
   void refreshCodexHooks().catch(() => {});
@@ -146,15 +150,8 @@ async function publishMonitorTick(input: {
   void refreshMcpLoad(status.sessions).catch(() => {});
   publishCatalogHeads(client, status, subscriptions, publishSessionEvents);
   if (loadRuntimeConfig().meshEnabled) publishMonitorMeshes(client, status);
-  if (Date.now() - lastCapabilityPublishedAt >= 30_000) {
-    const usage = scanCapabilityUsage([
-      ...status.sessions,
-      ...await history(false),
-    ]);
-    await client.send(scopeCapabilityUsageToRoom(usage, client.room), "phone", { ttlMs: 90_000, reliable: false });
-    lastCapabilityPublishedAt = Date.now();
-  }
-  return { lastHistoryPublishedAt, lastCapabilityPublishedAt };
+  publishMonitorCapabilities(client, status, () => history(false));
+  return { lastHistoryPublishedAt };
 }
 
 /**
@@ -168,8 +165,8 @@ export function startSessionMonitor(client: RelayClient): SessionMonitor {
   primeSessionKeys(client);
   publishedCatalog(client);
   let historyCache: { generatedAt: number; sessions: SessionsStatus["sessions"] } | undefined;
+  let historyRead: Promise<SessionsStatus["sessions"]> | undefined;
   let lastHistoryPublishedAt = 0;
-  let lastCapabilityPublishedAt = 0;
   let closed = false;
   const publishMachineLoad = createMachineLoadPublisher({
     log: (line) => process.stderr.write(`[monitor] ${line}\n`),
@@ -189,11 +186,16 @@ export function startSessionMonitor(client: RelayClient): SessionMonitor {
     },
   });
 
-  const history = async (force = false): Promise<SessionsStatus["sessions"]> => {
-    if (force || !historyCache || Date.now() - historyCache.generatedAt > 60_000) {
-      historyCache = { generatedAt: Date.now(), sessions: await scanSessionHistoryCooperatively() };
+  const history = (force = false): Promise<SessionsStatus["sessions"]> => {
+    if (historyRead) return historyRead;
+    if (!force && historyCache && Date.now() - historyCache.generatedAt <= 60_000) {
+      return Promise.resolve(historyCache.sessions);
     }
-    return historyCache.sessions;
+    historyRead = scanSessionHistoryCooperatively().then(sessions => {
+      historyCache = { generatedAt: Date.now(), sessions };
+      return sessions;
+    }).finally(() => { historyRead = undefined; });
+    return historyRead;
   };
 
   const publish = singleFlightPublisher(async (forceHistory: boolean): Promise<void> => {
@@ -201,10 +203,9 @@ export function startSessionMonitor(client: RelayClient): SessionMonitor {
     const next = await publishMonitorTick({
       client, leadership, subscriptions, history, loadLoop, forceHistory,
       active: () => !closed,
-      clocks: { lastHistoryPublishedAt, lastCapabilityPublishedAt },
+      clocks: { lastHistoryPublishedAt },
     });
     lastHistoryPublishedAt = next.lastHistoryPublishedAt;
-    lastCapabilityPublishedAt = next.lastCapabilityPublishedAt;
   });
 
   const off = client.onMessage(async (payload: Payload, peerPublicKey) => {
@@ -245,6 +246,7 @@ export function startSessionMonitor(client: RelayClient): SessionMonitor {
       offConnected?.();
       stopCatalog();
       stopCatalogHeads(client);
+      stopMonitorCapabilities(client);
       stopMonitorMeshes(client);
       stopHeartbeat();
       loadLoop.stop();

package/apps/bridge/src/session-catalog/README.md

@@ -9,10 +9,11 @@ unreadable merely because hundreds of newer logs appeared.
 The private `session-catalog-cache.json` contains metadata and validated native
 source locations. It excludes messages, capability descriptions, and credentials.
 The room and provider roots bind its scope. On restart the primary monitor sends
-a fresh live catalog first, then resumes the saved Now chats' native heads under
-their independent task keys in the background. Closed-history discovery runs
-separately from that first live publication. It does not republish an old catalog
-as fresh. The phone continues its durable historical backfill independently.
+the saved catalog with its original timestamp before starting fresh discovery,
+and resumes the saved Now chats' native heads under their independent task keys
+in the background. Fresh discovery replaces that saved state. Closed-history
+discovery runs separately from the first live publication. The phone continues
+its durable historical backfill independently.
 
 Tests live in `tests/`. This runtime module uses the repository GrantTap Commercial Source License.
 

package/apps/bridge/src/session-catalog/publish-heads.ts

@@ -1,19 +1,25 @@
 import type { RelayClient } from "../../../../packages/core/relay-client";
 import type { SessionsStatus } from "../../../../packages/protocol/schema";
 
-type HeadRun = { running: boolean; closed: boolean };
+type HeadRun = { running: boolean; closed: boolean; cursor: number };
 const runs = new WeakMap<RelayClient, HeadRun>();
 
 /** Transcript transfers must never occupy the fresh catalog's publication slot. */
 export function publishCatalogHeads(client: RelayClient, status: SessionsStatus,
   subscriptions: ReadonlySet<string>,
   publish: (client: RelayClient, sessionId: string, status: SessionsStatus) => Promise<unknown>): void {
-  const state = runs.get(client) ?? { running: false, closed: false };
+  const state = runs.get(client) ?? { running: false, closed: false, cursor: 0 };
   runs.set(client, state);
-  if (state.running || state.closed || subscriptions.size === 0) return;
+  if (state.running || state.closed) return;
+  const candidates = [...new Set([...subscriptions,
+    ...(client.supportsRetainedState ? status.sessions.map(session => session.sessionId) : [])])];
+  if (!candidates.length) return;
+  const count = Math.min(32, candidates.length);
+  const selected = Array.from({ length: count }, (_, offset) => candidates[(state.cursor + offset) % candidates.length]!);
+  state.cursor = (state.cursor + count) % candidates.length;
   state.running = true;
   void (async () => {
-    for (const sessionId of [...subscriptions]) {
+    for (const sessionId of selected) {
       await new Promise<void>(resolve => setImmediate(resolve));
       if (state.closed || !client.isConnected) break;
       await publish(client, sessionId, status).catch(() => {});

package/apps/bridge/src/sessions/README.md

@@ -18,6 +18,14 @@ the child snapshot. Root chat pagination remains in `TranscriptHistory`.
 Feature tests live in `tests/`; the reusable multi-provider conversation harness
 lives in the repository `tests/thread/` directory.
 
+## Grok Build history
+
+Grok discovery reads the local session summaries and visible conversation history.
+Both role-based records and current typed user/assistant records are supported.
+Typed user records must have a valid prompt index. Environment preambles, synthetic
+reminders, system messages, and hidden reasoning are excluded from the timeline.
+Session continuation uses the installed Grok CLI and its existing authentication.
+
 ## License
 
 Licensed under the GrantTap Commercial Source License. See LICENSE and NOTICE.

package/apps/bridge/src/sessions/index.ts

@@ -38,6 +38,9 @@ import {
   toRemoteCapabilityUsageEvent,
 } from "./telemetry";
 import { createCapabilityTotals } from "./support/capability-totals";
+import { createExecutionSummaries, budgetExecutionSummaries } from './telemetry/execution-summaries';
+import { readCodexCapabilityHistory, type NativeCapabilityEvidence } from './native-capability-history';
+import { recordedClaudeUsage } from './scan/claude';
 
 export { MAX_ACTIVITY_ENTRIES, MAX_ACTIVITY_TEXT, TOKEN_WINDOW_HOURS };
 export { nativeTranscriptRoots, nativeTranscriptSource, restoreNativeTranscriptSource } from "./native-source";
@@ -115,11 +118,13 @@ export function scanSessionActivity(session: SessionInfo): SessionActivity {
  */
 export function scanCapabilityUsage(
   sessions: SessionInfo[] = [...scanSessions().sessions, ...scanSessionHistory()],
+  native?: NativeCapabilityEvidence,
 ): CapabilityUsageStatus {
   const candidates: RemoteCapabilityUsageEvent[] = [];
   // Totals count every observation as it streams past; the candidate list is
   // trimmed to a byte budget and can never answer for a whole period.
   const totals = createCapabilityTotals();
+  const summaries = createExecutionSummaries();
   const seenSessions = new Set<string>();
   for (const session of sessions) {
     const nativeScope = `${session.agent}\0${session.sessionId}`;
@@ -131,19 +136,35 @@ export function scanCapabilityUsage(
           : session.agent === "cursor" ? cursorCapabilityUsage(session)
             : session.agent === "grok" ? grokCapabilityUsage(session)
             : [];
-    for (const observation of observations) {
-      const converted = toRemoteCapabilityUsageEvent(observation);
-      if (!converted) continue;
+    const recorded = session.agent === 'codex' && native?.scopes.includes(session.sessionId);
+    const claudeRecorded = session.agent === 'claude' ? recordedClaudeUsage(observations) : undefined;
+    const events = observations.map(toRemoteCapabilityUsageEvent).filter(
+      (event): event is RemoteCapabilityUsageEvent => event != null
+        && !(recorded && event.kind === 'mcp'));
+    if (recorded) events.push(...native!.events.filter(event => event.sessionId === session.sessionId));
+    for (const converted of events) {
       const event = { ...converted, agent: session.agent };
-      totals.add(event);
+      if (!claudeRecorded || event.kind === 'cli') {
+        totals.add(event);
+        summaries.add(event, recorded && event.kind === 'mcp' ? 'native-history' : 'transcript');
+      }
       rememberCapabilityUsageCandidate(candidates, event);
     }
+    for (const summary of claudeRecorded?.summaries ?? []) summaries.merge(summary);
+    for (const total of claudeRecorded?.totals ?? []) totals.merge(total);
   }
-  const envelope = { type: "capability.usage.status" as const,
+  const metadata = { type: "capability.usage.status" as const,
     totals: totals.rows(), generatedAt: Date.now() };
+  const executionSummaries = budgetExecutionSummaries(summaries.rows(), metadata);
+  const envelope = { ...metadata, ...(executionSummaries.length ? { executionSummaries } : {}) };
   return { ...envelope, events: limitCapabilityUsageEvents(candidates, envelope) };
 }
 
+/** Native metadata enrichment runs off the relay event loop. */
+export async function scanRecordedCapabilityUsage(sessions: SessionInfo[]): Promise<CapabilityUsageStatus> {
+  return scanCapabilityUsage(sessions, await readCodexCapabilityHistory(sessions));
+}
+
 /** Bind every local observation to the authenticated relay room before publish. */
 export function scopeCapabilityUsageToRoom(
   status: CapabilityUsageStatus,

package/apps/bridge/src/sessions/native-capability-history/README.md

@@ -0,0 +1,20 @@
+# Native capability history
+
+`index.ts` reads Codex's local history projection through a bounded worker.
+Native MCP execution records provide call identity, outcome, and duration even
+when the call happened through Code Mode and the transcript preview omits it.
+The database is opened read only. Native projection watermarks and the provider's
+updated-page index restrict warm reads to changed calls; a completion replaces
+its original call rather than adding another one. Queries run in a worker with
+a bounded deadline and never occupy the relay event loop. Missing or incompatible projections remain
+unknown; the existing transcript reader remains a compatibility fallback.
+
+Only requested executions and their recorded children are queried. The worker
+returns metadata, never prompts, arguments, or tool results. Its thirty-day,
+20,000-record bound and per-result size bound make summaries observed evidence,
+not a claim of complete lifetime usage. The recent-call list and execution
+summaries are bounded independently. File paths follow the configured Codex
+root and contain no machine-specific fallback.
+
+Tests use a real SQLite history projection and reopen it after the writer closes.
+This module uses the repository GrantTap Commercial Source License.

package/apps/bridge/src/sessions/native-capability-history/completed-item.ts

@@ -0,0 +1,31 @@
+import type { SessionInfo } from '../../../../../packages/protocol/schema';
+import type { CapabilityObservation } from '../telemetry';
+import { ts } from '../support/common';
+
+/** Only host-authored execution records establish inner Code Mode calls. */
+export function completedCodexMcp(row: any, session: SessionInfo): CapabilityObservation | undefined {
+  const payload = row?.payload;
+  if (row?.type !== 'event_msg' || payload?.type !== 'item_completed'
+    || (payload.thread_id != null && payload.thread_id !== session.sessionId)) return;
+  const item = payload.item;
+  if (!['McpToolCall', 'mcpToolCall'].includes(item?.type)) return;
+  if (![item.id, item.server, item.tool].every(x => typeof x === 'string' && x.trim() && x.length <= 240)) return;
+  const start = payload.started_at_ms ?? ts(row.timestamp) ?? session.lastActivityAt;
+  const elapsed = item.durationMs ?? (item.duration && Number.isFinite(item.duration.secs)
+    && Number.isFinite(item.duration.nanos) ? item.duration.secs * 1000 + item.duration.nanos / 1e6
+      : payload.completed_at_ms != null ? payload.completed_at_ms - start : undefined);
+  const outcome = item.status === 'failed' || item.result?.isError === true || item.result?.is_error === true
+    ? 'error' : ['cancelled', 'canceled'].includes(item.status) ? 'cancelled'
+      : item.status === 'completed' ? 'success' : 'unknown';
+  return { sourceId: `${session.sessionId}:${item.id}`, sessionId: session.sessionId,
+    toolName: `mcp__${item.server}__${item.tool}`, mcpServer: item.server, createdAt: start,
+    outcome, ...(Number.isFinite(elapsed) && elapsed >= 0
+      ? { durationMs: Math.min(3600000, Math.round(elapsed)) } : {}) };
+}
+
+export function recordedCodexToolName(payload: any): string {
+  const name = String(payload.name ?? payload.type);
+  const namespace = payload.namespace;
+  return typeof namespace === 'string' && /^mcp__[A-Za-z0-9_-]+$/.test(namespace)
+    ? `${namespace}__${name}` : name;
+}

package/apps/bridge/src/sessions/native-capability-history/index.ts

@@ -0,0 +1,67 @@
+import type { CapabilityExecutionSummary, RemoteCapabilityUsageEvent, SessionInfo } from '../../../../../packages/protocol/schema';
+import { Worker } from 'node:worker_threads';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { codexSessionsRoot } from '../support/common';
+export { completedCodexMcp, recordedCodexToolName } from './completed-item';
+export type NativeCapabilityEvidence = {
+  scopes: string[];
+  events: RemoteCapabilityUsageEvent[];
+  summaries: CapabilityExecutionSummary[];
+};
+
+const empty = (): NativeCapabilityEvidence => ({ scopes: [], events: [], summaries: [] });
+const cache = new Map<string, { at: number; value: Promise<NativeCapabilityEvidence> }>();
+type Cursor = { threadId: string; watermark: number; events: RemoteCapabilityUsageEvent[] };
+const cursors = new Map<string, Cursor[]>();
+
+/** Query only bounded call metadata in a worker; native conversation contents stay local. */
+export function readCodexCapabilityHistory(
+  sessions: SessionInfo[], root = process.env.GRANTTAP_CODEX_DIR ?? process.env.NODVOX_CODEX_DIR
+    ?? process.env.CODEX_HOME ?? dirname(codexSessionsRoot()),
+): Promise<NativeCapabilityEvidence> {
+  const database = join(root, 'thread_history_1.sqlite');
+  const owners = new Map<string, string>();
+  for (const session of sessions.filter(s => s.agent === 'codex')) {
+    owners.set(session.sessionId, session.sessionId);
+    for (const child of session.childThreads ?? []) {
+      if (!owners.has(child.threadId)) owners.set(child.threadId, session.sessionId);
+    }
+  }
+  const bindings = [...owners].slice(0, 512);
+  if (!bindings.length || !existsSync(database)) return Promise.resolve(empty());
+  const key = JSON.stringify([database, bindings]);
+  const previous = cache.get(key);
+  if (previous && Date.now() - previous.at < 30_000) return previous.value;
+  const value = readWorker(database, bindings);
+  cache.set(key, { at: Date.now(), value });
+  while (cache.size > 4) cache.delete(cache.keys().next().value!);
+  return value;
+}
+
+function readWorker(database: string, bindings: [string, string][]): Promise<NativeCapabilityEvidence> {
+  return new Promise(resolve => {
+    const requested = new Set(bindings.map(([thread]) => thread));
+    const worker = new Worker(new URL('./reader.js', import.meta.url), { execArgv: [],
+      workerData: { database, bindings, now: Date.now(),
+        previous: (cursors.get(database) ?? []).filter(cursor => requested.has(cursor.threadId)) },
+      resourceLimits: { maxOldGenerationSizeMb: 64 } });
+    let evidence = empty();
+    const timer = setTimeout(() => { void worker.terminate(); }, 45_000);
+    worker.once('message', (result: NativeCapabilityEvidence & { cursors?: Cursor[] }) => {
+      const { cursors: next, ...publicEvidence } = result;
+      if (next) {
+        const merged = [...next, ...(cursors.get(database) ?? []).filter(cursor => !requested.has(cursor.threadId))];
+        let count = 0;
+        cursors.set(database, merged.filter(cursor => {
+          count += cursor.events.length;
+          return count <= 20000;
+        }).slice(0, 512));
+        while (cursors.size > 4) cursors.delete(cursors.keys().next().value!);
+      }
+      evidence = publicEvidence;
+    });
+    worker.once('error', () => { evidence = empty(); });
+    worker.once('exit', code => { clearTimeout(timer); resolve(code === 0 ? evidence : empty()); });
+  });
+}