granttap-mcp 0.8.86 → 0.8.88

package/README.md

@@ -155,7 +155,8 @@ device pairing without a passkey account.
 
 - Claude Code and Codex: primary local control and continuation paths.
 - Cursor (Beta): Task visibility and supported local controls, with narrower coverage.
-- Grok Build: observable work where the installed runtime exposes it.
+- Grok Build: local history and headless follow-ups through an installed,
+  authenticated CLI; provider hook and scoped Mesh coverage remain narrower.
 
 GrantTap reports the depth each provider actually exposes. Visibility does not
 imply deterministic remote blocking or full mobile continuation.
@@ -477,6 +478,13 @@ grok plugin marketplace add sergii-ziborov/granttap-mcp
 grok plugin install granttap --trust
 ```
 
+In Grok, open `/mcps` and authenticate the GrantTap server, then run
+`/granttap-connect`. GrantTap's phone pairing and Grok's permission to use that
+MCP server are separate. An existing pairing does not authorize a new MCP client.
+If a Grok session does not start responding within one minute, GrantTap asks you
+to inspect the original task before retrying. A turn that has started can keep
+running; its later failure does not mean that the message was never delivered.
+
 For Cursor, use the reviewed **GrantTap** Marketplace listing when it is visible
 to your account. Reload Cursor. On this computer, run `granttap setup`. Pair
 and change settings on [granttap.com/connect](https://granttap.com/connect)
@@ -843,3 +851,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/monitor/capability-publication/index.ts

@@ -1,7 +1,7 @@
 import { setImmediate } from "node:timers/promises";
 import type { RelayClient } from "../../../../../packages/core/relay-client";
 import type { SessionInfo, SessionsStatus } from "../../../../../packages/protocol/schema";
-import { scanCapabilityUsage, scopeCapabilityUsageToRoom } from "../../sessions";
+import { scanRecordedCapabilityUsage, scopeCapabilityUsageToRoom } from "../../sessions";
 
 type Publication = { running: boolean; closed: boolean; lastPublishedAt: number };
 const publications = new WeakMap<RelayClient, Publication>();
@@ -16,11 +16,16 @@ export function publishMonitorCapabilities(client: RelayClient, status: Sessions
   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;
-    const usage = scanCapabilityUsage([...status.sessions, ...older]);
-    await client.send(scopeCapabilityUsageToRoom(usage, client.room), "phone",
-      { ttlMs: 90_000, reliable: false });
+    if (older.length) await publish([...status.sessions, ...older]);
     state.lastPublishedAt = Date.now();
   })();
   void work.catch(() => {}).finally(() => { state.running = false; });

package/apps/bridge/src/monitor/handlers/user-message.ts

@@ -98,20 +98,20 @@ async function startNewAgentTask(input: {
   }
   const settle = async (result: ReplyResult, late: boolean) => {
     input.origin?.registry.complete(input.origin.scope,
-      { ok: result.ok, sessionId: result.ok ? result.sessionId : undefined });
-    if (!result.ok && message.messageId) {
+      { ok: result.ok || result.delivery === 'native', sessionId: result.ok ? result.sessionId : undefined });
+    if (!result.ok && message.messageId && result.delivery !== 'native') {
       if (late) rejectCompletedDelivery(message.messageId, result.error);
       await sendDeliveryReceipt(client, message.messageId, 'rejected', result.error,
         undefined, input.peerPublicKey);
     }
     return result.ok ? say(result.text, result.sessionId, true)
-      : say(late ? `The ${displayName} task stopped: ${result.error}`
+      : say(late || result.delivery === 'native' ? `The ${displayName} task stopped: ${result.error}`
         : `Could not create a ${displayName} task: ${result.error}`, undefined, true);
   };
   const early = await acceptWhenStarted(run, (result) => settle(result, true));
   if (early === "started") return "accepted";
   await settle(early, false);
-  return early.ok ? "accepted" : "rejected";
+  return early.ok || early.delivery === 'native' ? "accepted" : "rejected";
 }
 
 export async function handleUserMessage(
@@ -196,15 +196,18 @@ export async function handleUserMessage(
     }
     if (result.ok) await say(result.text, result.sessionId ?? target.sessionId, true);
     else {
-      if (late && message.messageId) rejectCompletedDelivery(message.messageId, result.error);
-      if (message.messageId) await sendDeliveryReceipt(client, message.messageId, 'rejected',
-        result.error, target.sessionId, peerPublicKey);
-      await say(late ? `The run stopped: ${result.error}` : `Could not deliver the message: ${result.error}`,
+      if (result.delivery !== 'native') {
+        if (late && message.messageId) rejectCompletedDelivery(message.messageId, result.error);
+        if (message.messageId) await sendDeliveryReceipt(client, message.messageId, 'rejected',
+          result.error, target.sessionId, peerPublicKey);
+      }
+      await say(late || result.delivery === 'native' ? `The run stopped: ${result.error}`
+        : `Could not deliver the message: ${result.error}`,
         target.sessionId, true);
     }
   };
   const early = await acceptWhenStarted(run, (result) => settle(result, true));
   if (early === "started") return "accepted";
   await settle(early, false);
-  return early.ok ? "accepted" : "rejected";
+  return early.ok || early.delivery === 'native' ? "accepted" : "rejected";
 }

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

@@ -128,17 +128,20 @@ async function publishMonitorTick(input: {
   if (!leadership.acquire()) return { lastHistoryPublishedAt };
   await client.send(approvalsStatus(), "phone", { ttlMs: INTERVAL_MS * 3, reliable: false });
   const initial = lastHistoryPublishedAt === 0;
+  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 });
-  if (initial && !resumedHeads.has(client)) {
-    resumedHeads.add(client);
-    void resumePublishedChats(client,
-      (session, saved) => publishSessionEvents(client, session.sessionId, saved)).catch(() => {});
-  }
   // Provider review is independent of task visibility; a hung hook RPC must
   // never hold the current catalog behind its discovery timeout.
   void refreshCodexHooks().catch(() => {});

package/apps/bridge/src/reply/grok-response/README.md

@@ -0,0 +1,20 @@
+# Grok response admission
+
+[`index.ts`](index.ts) reads Grok Build's `streaming-json` response contract.
+Actual text, thinking, or a started tool call confirms that the prompt reached
+execution. Startup metadata alone does not establish admission. Native error
+messages remain failures and metadata is never returned as answer text.
+
+Opening a session has a 60-second response-activity deadline, separate from the
+long execution budget. A stalled opening stops only the process group GrantTap
+started and asks the person to inspect the native task before retrying. Once
+response activity is witnessed, a later timeout or run failure cannot rewrite
+the accepted message as a rejected delivery. Execution failure still reaches
+the chat. This does not grant tools, authenticate MCP, or alter Grok policy.
+
+Behavior tests live in `../tests/grok-response.test.ts` and
+`../tests/admission-deadline.test.ts`; durable receipt tests live in
+`../../monitor/message-delivery/tests/run-outcome.test.ts`.
+
+License: this module is distributed under the GrantTap Commercial Source License
+in the repository-root `LICENSE` file.

package/apps/bridge/src/reply/grok-response/index.ts

@@ -0,0 +1,48 @@
+import type { ReplyResult } from '../payload/types';
+import type { ProviderAdmission } from '../process';
+
+function events(stdout: string): Record<string, unknown>[] {
+  return stdout.split('\n').flatMap(line => {
+    try {
+      const value: unknown = JSON.parse(line);
+      return value && typeof value === 'object' && !Array.isArray(value)
+        ? [value as Record<string, unknown>] : [];
+    } catch { return []; }
+  });
+}
+
+/** Response activity proves admission; startup lists and diagnostic text do not. */
+export function grokAccepted(stdout: string): boolean {
+  return events(stdout).some(event => {
+    if (['text', 'thought'].includes(String(event.type))) {
+      return typeof event.data === 'string' && !!event.data.trim();
+    }
+    if (event.type === 'result') return typeof event.result === 'string' && !!event.result.trim();
+    return event.type === 'tool_call' && event.status === 'in_progress'
+      && typeof event.toolCallId === 'string' && !!event.toolCallId;
+  });
+}
+
+/** Opening a native session has a separate limit from executing its long turn. */
+export const grokAdmission: ProviderAdmission = {
+  confirmed: grokAccepted,
+  withinMs: 60_000,
+  timeoutMessage: 'Grok did not confirm receipt within 60s. Open the task before retrying.',
+};
+
+export function parseGrok(stdout: string, fallback: string): ReplyResult {
+  let text = '';
+  let sessionId = fallback;
+  for (const event of events(stdout)) {
+    if (event.type === 'text' && typeof event.data === 'string') text += event.data;
+    if (event.type === 'result' && typeof event.result === 'string') text = event.result;
+    if (typeof event.sessionId === 'string') sessionId = event.sessionId;
+    if (typeof event.session_id === 'string') sessionId = event.session_id;
+    const error = typeof event.message === 'string' ? event.message : event.error;
+    if (event.type === 'error' && typeof error === 'string') {
+      return { ok: false, error: error.slice(0, 500) };
+    }
+  }
+  return text.trim() ? { ok: true, text: text.trim().slice(0, 4_000), sessionId }
+    : { ok: false, error: 'Grok Build returned an empty response.' };
+}

package/apps/bridge/src/reply/process/index.ts

@@ -72,6 +72,12 @@ export function runningProcessCount(key: string): number {
   return running.get(key)?.size ?? 0;
 }
 
+export type ProviderAdmission = {
+  confirmed: (stdout: string) => boolean;
+  withinMs: number;
+  timeoutMessage: string;
+};
+
 export function runProcess(
   command: string,
   args: string[],
@@ -80,6 +86,7 @@ export function runProcess(
   parse: (stdout: string) => ReplyResult,
   stdin?: string,
   key?: string,
+  admission?: ProviderAdmission,
 ): Promise<ReplyResult> {
   return new Promise((resolve) => {
     let child: ChildProcess;
@@ -104,14 +111,20 @@ export function runProcess(
       if (done) return;
       done = true;
       clearTimeout(timer);
+      clearTimeout(startupTimer);
       untrack();
-      resolve(result);
+      resolve(!result.ok && admission?.confirmed(stdout) ? { ...result, delivery: 'native' } : result);
     };
     const timer = setTimeout(() => {
       if (done) return;
       signalOwnedProcess(child, "SIGKILL");
       finish({ ok: false, error: `${command} did not respond within ${Math.round(timeoutMs / 1000)}s.` });
     }, timeoutMs);
+    const startupTimer = admission ? setTimeout(() => {
+      if (done || admission.confirmed(stdout)) return;
+      signalOwnedProcess(child, "SIGKILL");
+      finish({ ok: false, error: admission.timeoutMessage });
+    }, admission.withinMs) : undefined;
     child.stdout?.on("data", (chunk) => { stdout += chunk; });
     child.stderr?.on("data", (chunk) => { stderr += chunk; });
     child.on("error", (error) => {

package/apps/bridge/src/reply/process/provider-headless.ts

@@ -1,3 +1,4 @@
+import { grokAdmission, parseGrok } from "../grok-response";
 import { randomUUID } from "node:crypto";
 import type { SessionInfo } from "../../../../../packages/protocol/schema";
 import { runProcess } from ".";
@@ -11,33 +12,6 @@ function grokBin(): string {
   return resolveGrokBinary();
 }
 
-function parseGrok(stdout: string, fallback: string): ReplyResult {
-  let text = "";
-  let sessionId = fallback;
-  for (const line of stdout.split("\n")) {
-    if (!line.trim()) continue;
-    try {
-      const value = JSON.parse(line) as {
-        type?: string; data?: unknown; sessionId?: unknown; session_id?: unknown;
-        result?: unknown; error?: unknown;
-      };
-      if (value.type === "text" && typeof value.data === "string") text += value.data;
-      if (value.type === "result" && typeof value.result === "string") text = value.result;
-      if (typeof value.sessionId === "string") sessionId = value.sessionId;
-      if (typeof value.session_id === "string") sessionId = value.session_id;
-      if (value.type === "error" && typeof value.error === "string") {
-        return { ok: false, error: value.error.slice(0, 500) };
-      }
-    } catch {
-      // Ignore diagnostic lines outside Grok's streaming JSON contract.
-    }
-  }
-  const visible = text.trim() || stdout.trim();
-  return visible
-    ? { ok: true, text: visible.slice(0, 4_000), sessionId }
-    : { ok: false, error: "Grok Build returned an empty response." };
-}
-
 export function runCursorNew(
   text: string, cwd: string, timeoutMs: number, model?: string, operationKey?: string, effort?: string,
 ): Promise<ReplyResult> {
@@ -62,7 +36,7 @@ export function runGrokNew(
     "-p", text, "--output-format", "streaming-json",
   ];
   return runProcess(grokBin(), args, cwd, timeoutMs, (stdout) => parseGrok(stdout, sessionId),
-    undefined, operationKey);
+    undefined, operationKey, grokAdmission);
 }
 
 export function runGrokResume(
@@ -79,6 +53,6 @@ export function runGrokResume(
   return runProcess(
     grokBin(), args, session.cwd, timeoutMs,
     (stdout) => parseGrok(stdout, session.sessionId),
-    undefined, session.sessionId,
+    undefined, session.sessionId, grokAdmission,
   );
 }

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()); });
+  });
+}