granttap-mcp 0.8.90 → 0.8.92

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

@@ -8,6 +8,7 @@ import type {
   MeshEvent,
   MeshSnapshot,
   MeshInvocationPage,
+  ProjectKnowledgePage,
   Payload,
   ProjectPolicyPayload,
   Role,
@@ -53,7 +54,7 @@ export async function sendMeshPayload(
 
 export async function sendProjectPayload(
   client: RelayClient,
-  payload: ProjectPolicyPayload | MeshClaimReleaseResult | MeshInvocationPage,
+  payload: ProjectPolicyPayload | MeshClaimReleaseResult | MeshInvocationPage | ProjectKnowledgePage,
   to: Role | "all" = "phone",
   options: SendOptions = {},
 ): Promise<void> {

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

@@ -12,3 +12,11 @@ Engine validates its scope. The phone may replay the same ID after a lost reply.
 This is not a migration of old chats into verified knowledge.
 
 GrantTap Commercial Source License.
+
+`read.ts` is the bounded Project evidence read: Memory and the invocation journal
+run in parallel with independent deadlines. Calls may belong to older Tasks
+outside the current phone snapshot. A failed source leaves the other source
+available. Whole records are omitted to fit the encrypted frame budget; record
+content is never shortened. `runtime-read.ts` exposes this read over local Mac
+IPC and an authenticated, requester-scoped Project relay response. It does not
+rescan provider chats or rebuild architecture.

package/apps/bridge/src/mesh/knowledge/read.ts

@@ -0,0 +1,65 @@
+import type { MeshSnapshot, ProjectKnowledgeRecord } from "../../../../../packages/protocol/schema";
+import { ProjectKnowledgePage, ProjectKnowledgeQuery } from "../../../../../packages/protocol/messages/mesh/knowledge/refresh";
+import type { InvocationHistoryPage } from "../../engine/protocol/engine-invocation-protocol";
+import { activeProjectKnowledge, supersededProjectKnowledgeIds } from "./active";
+
+export type KnowledgeReadDependencies = {
+  snapshot: (projectId: string) => MeshSnapshot | undefined;
+  memory: (projectId: string) => Promise<ProjectKnowledgeRecord[] | undefined>;
+  history: (projectId: string) => Promise<InvocationHistoryPage | undefined>;
+  endpointId: string;
+  now: () => number;
+  timeoutMs?: number;
+};
+
+export async function readProjectKnowledge(
+  query: ProjectKnowledgeQuery, dependencies: KnowledgeReadDependencies,
+): Promise<ProjectKnowledgePage | undefined> {
+  if (!ProjectKnowledgeQuery.safeParse(query).success) return undefined;
+  const snapshot = dependencies.snapshot(query.projectId);
+  if (!snapshot || snapshot.projectId !== query.projectId) return undefined;
+  const timeout = dependencies.timeoutMs ?? 2_000;
+  let [memory, history] = await Promise.all([
+    boundedSource(() => dependencies.memory(query.projectId), timeout),
+    boundedSource(() => dependencies.history(query.projectId), timeout),
+  ]);
+  if (memory?.some(record => record.projectId !== query.projectId || record.visibility !== "project")) {
+    memory = undefined;
+  }
+  if (history?.events.some(row => row.event.project_id !== query.projectId)) history = undefined;
+  const records = memory ?? [];
+  const knowledge = activeProjectKnowledge(query.projectId, records)
+    .sort((a, b) => b.recordedAt - a.recordedAt).slice(0, 32);
+  const invocations = (history?.events ?? []).slice(-32);
+  const page: ProjectKnowledgePage = {
+    type: "mesh.knowledge.page", sessionId: query.projectId, projectId: query.projectId,
+    requestId: query.requestId, sourceEndpointId: dependencies.endpointId,
+    memoryAvailability: memory ? "ready" : "unavailable",
+    invocationAvailability: history ? "ready" : "unavailable",
+    knowledge, invocations,
+    supersededKnowledgeRecordIds: supersededProjectKnowledgeIds(query.projectId, records),
+    incomplete: records.length > knowledge.length || history?.has_older === true
+      || history?.has_more === true,
+    generatedAt: dependencies.now(),
+  };
+  // Keep encrypted frames below the transport limit without shortening a fact.
+  while (Buffer.byteLength(JSON.stringify(page)) > 128 * 1_024
+    && (knowledge.length > 0 || invocations.length > 0)) {
+    const oldestRecord = knowledge.at(-1)?.recordedAt ?? Infinity;
+    const oldestCall = invocations[0]?.event.occurred_at ?? Infinity;
+    if (oldestRecord <= oldestCall) knowledge.pop();
+    else invocations.shift();
+    page.incomplete = true;
+  }
+  return ProjectKnowledgePage.parse(page);
+}
+
+async function boundedSource<T>(read: () => Promise<T>, timeoutMs: number): Promise<T | undefined> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([Promise.resolve().then(read), new Promise<undefined>(resolve => {
+      timer = setTimeout(() => resolve(undefined), timeoutMs);
+    })]);
+  } catch { return undefined; }
+  finally { if (timer) clearTimeout(timer); }
+}

package/apps/bridge/src/mesh/knowledge/runtime-read.ts

@@ -0,0 +1,49 @@
+import { join } from "node:path";
+import type { RelayClient } from "../../../../../packages/core/relay-client";
+import { ProjectKnowledgeQuery } from "../../../../../packages/protocol/messages/mesh/knowledge/refresh";
+import { configDir } from "../../config/runtime/paths";
+import { EngineClient } from "../../engine/runtime/engine-client";
+import { engineFeatureEnabled } from "../../engine/runtime/engine-supervisor";
+import { projectKnowledge } from "../../engine/runtime/engine-memory";
+import { sendProjectPayload } from "../../host/session-keys";
+import { computerId } from "../identity/computer";
+import { localMeshStore } from "../local-remote/local";
+import { readProjectKnowledge } from "./read";
+
+const engine = new EngineClient({ socketPath: join(configDir(), "engine.sock") });
+
+export async function currentProjectKnowledge(query: ProjectKnowledgeQuery) {
+  return readProjectKnowledge(query, {
+    snapshot: projectId => localMeshStore().snapshot(projectId),
+    endpointId: computerId(), now: Date.now,
+    memory: projectId => projectKnowledge(projectId),
+    history: async projectId => {
+      if (!engineFeatureEnabled()) return undefined;
+      const result = await engine.request({ operation: "invocation.history",
+        input: { project_id: projectId, tail: true, limit: 32 } }, { timeoutMs: 1_000 });
+      return result.operation === "invocation.history" ? result.page : undefined;
+    },
+  });
+}
+
+export async function handleProjectKnowledgeQuery(
+  client: RelayClient, query: ProjectKnowledgeQuery, peerPublicKey?: string,
+): Promise<boolean> {
+  if (!peerPublicKey) return false;
+  const page = await currentProjectKnowledge(query);
+  if (!page) return false;
+  if (page.memoryAvailability === "ready") {
+    localMeshStore().cacheKnowledge(page.projectId, page.knowledge);
+  }
+  await sendProjectPayload(client, page, "phone", {
+    peerPublicKey, ttlMs: 15_000, reliable: false,
+  }).catch(() => {});
+  return true;
+}
+
+export async function desktopProjectKnowledge(input: unknown) {
+  const value = input as { project_id?: unknown; request_id?: unknown } | undefined;
+  const query = ProjectKnowledgeQuery.safeParse({ type: "mesh.knowledge.query",
+    projectId: value?.project_id, sessionId: value?.project_id, requestId: value?.request_id });
+  return query.success ? currentProjectKnowledge(query.data) : undefined;
+}

package/apps/bridge/src/monitor/handlers/inbound.ts

@@ -18,6 +18,7 @@ import {
 } from "../../mesh/runtime";
 import { releaseClaimByPerson, releaseResult } from "../../mesh/admin";
 import { handleInvocationQuery } from "../../engine/invocation/query";
+import { handleProjectKnowledgeQuery } from "../../mesh/knowledge/runtime-read";
 import { applyPairingJoin } from "../../pairing";
 import { recordPhoneSeen } from "../../pairing/presence";
 import { handleProjectPolicySet } from "../../project-policy/runtime";
@@ -123,6 +124,8 @@ export async function handleMonitorMessage(
       const accepted = requestProjectCapability(payload);
       if (accepted) void publish().catch(() => {});
       return accepted;
+    } else if (payload.type === "mesh.knowledge.query" && loadRuntimeConfig().meshEnabled) {
+      return handleProjectKnowledgeQuery(client, payload, input.peerPublicKey);
     } else if (payload.type === "mesh.invocation.query" && loadRuntimeConfig().meshEnabled) {
       return handleInvocationQuery(client, payload);
     } else if ((payload.type === "mesh.event" || payload.type === "mesh.snapshot")

package/apps/bridge/src/policy/governed-projects.ts

@@ -17,7 +17,7 @@ const MAX_PROJECTS = 256;
 
 const GovernedFile = z.object({
   version: z.literal(1),
-  projects: z.record(z.object({
+  projects: z.record(z.string(), z.object({
     revision: z.number().int().nonnegative(),
     at: z.number().nonnegative(),
   })),

package/apps/bridge/src/provider-account-status/README.md

@@ -9,10 +9,27 @@ expire after five minutes and changing the native auth file clears the cache.
 Only visible picker metadata and reported usage percentages, window durations,
 reset times and observation times cross the existing encrypted Mesh channel.
 Identity, credentials, credits, instructions and raw provider responses stay out.
-Missing windows remain unknown. Claude CLI aliases remain available. The GrantTap status-line wrapper observes
+Missing windows remain unknown. `native-usage/reader.ts` independently reads the
+already signed-in Claude, Cursor and Grok account interfaces, with an eight-second
+request bound, a 64 KiB response bound and no redirects. Requests coalesce and
+refresh at most once every two minutes. Expired windows disappear without
+inventing a reset allowance. `native-usage/credentials.ts` reads existing native files
+or the native macOS keychain entries; it never starts login, refreshes credentials
+or changes provider settings. A relocated profile cannot use another account's
+keychain. Temporary HOME directories never read the OS user's keychain.
+
+Claude CLI aliases remain available. The GrantTap status-line wrapper observes
 Claude's documented `rate_limits` after a native response, preserves the prior
 status command/options, and stores only independently present 5h/7d windows.
-Cursor and Grok subscription limits remain unavailable when their installed
-interfaces do not report them; their session tokens and tools are still counted.
+Its newest real observation takes precedence over an older direct read. Expired
+Claude credentials require a native Claude refresh; they are not a full allowance.
+
+Cursor reports its weekly account usage, with the native billing-period pool as
+a fallback for older plans. Grok reports its current subscription period and
+credit usage percentage through its CLI billing interface. Unified subscriptions
+may share a pool across Cursor and Grok: these are provider views, not additive
+allowances. Grok's reported percentage can be rounded by the provider. A missing
+or unauthenticated account report stays unknown. Session tokens, context size and
+tool activity do not stand in for subscription limits.
 
-Tests: `tests/status.test.ts`. GrantTap Commercial Source License, see root LICENSE.
+Tests live in `tests/`. GrantTap Commercial Source License, see root LICENSE.

package/apps/bridge/src/provider-account-status/index.ts

@@ -6,6 +6,7 @@ import { codexHookRpc, type HookRpc } from "../codex-hook-trust";
 import { projectAccountModels, projectAccountUsage } from "./projection";
 
 export { projectAccountModels, projectAccountUsage } from "./projection";
+export { cachedNativeAccountUsage } from "./native-usage";
 
 /** A bounded read of an already signed-in provider; no threads, turns or login. */
 export function createProviderAccountReader(rpc: HookRpc, clock = Date.now) {

package/apps/bridge/src/provider-account-status/native-usage/README.md

@@ -0,0 +1,12 @@
+# Native account allowances
+
+Public entry: `index.ts`, exported by the parent Provider Account Status module.
+Reads the existing Claude, Cursor and Grok account interfaces without creating
+sessions or changing credentials. `projection.ts` retains only usage windows;
+`credentials.ts` bounds local native credential reads; `reader.ts` coalesces,
+throttles and expires the independent requests. Native status-line observations
+keep their actual timestamps and can supersede direct Claude observations.
+
+Tests live in `tests/`; the parent README documents data sources and boundaries.
+
+GrantTap Commercial Source License. See the repository root LICENSE.

package/apps/bridge/src/provider-account-status/native-usage/credentials.ts

@@ -0,0 +1,69 @@
+import { execFile } from "node:child_process";
+import { readFile, stat } from "node:fs/promises";
+import { homedir, userInfo } from "node:os";
+import { join } from "node:path";
+import type { NativeUsageProvider } from "./projection";
+
+type Options = {
+  home?: string;
+  env?: NodeJS.ProcessEnv;
+  platform?: NodeJS.Platform;
+  keychain?: (service: string, account?: string) => Promise<string | undefined>;
+  now?: number;
+};
+
+/** The same existing native entries used by Claude Code and Cursor. Never refresh or write credentials. */
+export function readNativeKeychain(service: string, account?: string, run = execFile): Promise<string | undefined> {
+  return new Promise(resolve => run("/usr/bin/security",
+    ["find-generic-password", "-s", service, ...(account ? ["-a", account] : []), "-w"],
+    { timeout: 3_000, maxBuffer: 65_536, windowsHide: true },
+    (error, stdout) => resolve(error ? undefined : stdout.trim() || undefined)));
+}
+
+async function jsonFile(path: string): Promise<any> {
+  try {
+    if ((await stat(path)).size > 65_536) return undefined;
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch { return undefined; }
+}
+
+function token(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 && value.length <= 32_768
+    && !/[\r\n]/.test(value) ? value : undefined;
+}
+
+function claudeToken(value: any, now: number): string | undefined {
+  const row = value?.claudeAiOauth;
+  return typeof row?.expiresAt === "number" && row.expiresAt <= now ? undefined : token(row?.accessToken);
+}
+
+export async function readNativeCredential(provider: NativeUsageProvider, options: Options = {}): Promise<string | undefined> {
+  const home = options.home ?? homedir();
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const keychain = options.keychain ?? readNativeKeychain;
+  const keychainAllowed = options.keychain !== undefined || home === userInfo().homedir;
+  if (provider === "grok") {
+    const root = env.GRANTTAP_GROK_DIR ?? join(home, ".grok");
+    const auth = await jsonFile(join(root, "auth.json"));
+    return auth && Object.entries(auth).flatMap(([id, row]: [string, any]) =>
+      id.startsWith("https://auth.x.ai::") && row?.auth_mode === "oidc" ? [token(row.key)] : [])
+      .find(Boolean);
+  }
+  if (provider === "claude") {
+    const override = env.GRANTTAP_CLAUDE_DIR ?? env.NODVOX_CLAUDE_DIR ?? env.CLAUDE_CONFIG_DIR;
+    const saved = claudeToken(await jsonFile(join(override ?? join(home, ".claude"), ".credentials.json")), options.now ?? Date.now());
+    if (saved || platform !== "darwin" || override || !keychainAllowed) return saved;
+    if (!await jsonFile(join(home, ".claude", "settings.json"))) return undefined;
+    try {
+      const raw = await keychain("Claude Code-credentials");
+      return raw ? claudeToken(JSON.parse(raw), options.now ?? Date.now()) : undefined;
+    } catch { return undefined; }
+  }
+  const root = platform === "win32" ? join(env.APPDATA ?? join(home, "AppData", "Roaming"), "Cursor")
+    : platform === "darwin" ? join(home, ".cursor") : join(env.XDG_CONFIG_HOME ?? join(home, ".config"), "cursor");
+  const saved = token((await jsonFile(join(root, "auth.json")))?.accessToken);
+  if (saved || platform !== "darwin" || !keychainAllowed || !await jsonFile(join(root, "cli-config.json"))) return saved;
+  try { return token(await keychain("cursor-access-token", "cursor-user")); }
+  catch { return undefined; }
+}

package/apps/bridge/src/provider-account-status/native-usage/index.ts

@@ -0,0 +1,30 @@
+import { homedir } from "node:os";
+import type { ProviderAccountUsage } from "../../../../../packages/protocol/schema";
+import { readClaudeUsage } from "../claude-statusline";
+import { readNativeCredential } from "./credentials";
+import { createNativeAccountUsageReader } from "./reader";
+
+let scope = "";
+let reader = createNativeAccountUsageReader({ credential: readNativeCredential });
+
+export function mergeNativeUsage(direct: ProviderAccountUsage[], statusLine: ProviderAccountUsage[],
+  now = Date.now()): ProviderAccountUsage[] {
+  const newest = new Map<string, ProviderAccountUsage>();
+  for (const report of [...direct, ...statusLine]) {
+    const key = `${report.provider}\u001f${report.limitId}`;
+    const windows = report.windows.filter(window => window.resetsAt > now);
+    if (!windows.length || now - report.observedAt > 300_000 || report.observedAt > now + 60_000) continue;
+    if ((newest.get(key)?.observedAt ?? -Infinity) <= report.observedAt) newest.set(key, { ...report, windows });
+  }
+  return [...newest.values()];
+}
+
+/** Account reads are scheduled beside the catalog; provider credentials never enter its result. */
+export function cachedNativeAccountUsage(): ProviderAccountUsage[] {
+  const env = process.env;
+  const current = [homedir(), env.GRANTTAP_CLAUDE_DIR, env.NODVOX_CLAUDE_DIR, env.CLAUDE_CONFIG_DIR,
+    env.GRANTTAP_GROK_DIR, env.XDG_CONFIG_HOME, env.APPDATA].join("\u001f");
+  if (scope !== current) { scope = current; reader = createNativeAccountUsageReader({ credential: readNativeCredential }); }
+  void reader.refresh();
+  return mergeNativeUsage(reader.current(), readClaudeUsage());
+}

package/apps/bridge/src/provider-account-status/native-usage/projection.ts

@@ -0,0 +1,52 @@
+import type { ProviderAccountUsage } from "../../../../../packages/protocol/schema";
+
+type ProviderUsageWindow = ProviderAccountUsage["windows"][number];
+
+export type NativeUsageProvider = "claude" | "cursor" | "grok";
+
+function percent(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 100;
+}
+
+function timestamp(value: unknown): number {
+  return typeof value === "string" ? Date.parse(value) : NaN;
+}
+
+/** Only allowance windows cross the wire; identity, money and top-up settings never do. */
+export function projectNativeAccountUsage(provider: NativeUsageProvider, input: any,
+  now = Date.now()): ProviderAccountUsage | undefined {
+  let windows: ProviderUsageWindow[] = [];
+  if (provider === "claude") {
+    windows = ([["five_hour", "primary", 300], ["seven_day", "secondary", 10_080]] as const)
+      .flatMap(([key, id, windowMinutes]) => {
+        const row = input?.[key];
+        const resetsAt = timestamp(row?.resets_at);
+        return percent(row?.utilization) && resetsAt > now
+          ? [{ id, usedPercent: row.utilization, windowMinutes, resetsAt }] : [];
+      });
+  } else {
+    const start = timestamp(provider === "cursor" ? input?.currentPeriodStart : input?.config?.currentPeriod?.start);
+    const resetsAt = timestamp(provider === "cursor" ? input?.nextResetTimestampUtc : input?.config?.currentPeriod?.end);
+    const usedPercent = provider === "cursor" ? input?.usagePercent : input?.config?.creditUsagePercent;
+    if (percent(usedPercent) && Number.isFinite(start) && start <= now && resetsAt > now && resetsAt > start) {
+      const windowMinutes = Math.ceil((resetsAt - start) / 60_000);
+      if (Number.isSafeInteger(windowMinutes) && windowMinutes > 0) {
+        windows = [{ id: "primary", usedPercent, windowMinutes, resetsAt }];
+      }
+    }
+  }
+  return windows.length ? { provider, limitId: provider, observedAt: now, windows } : undefined;
+}
+
+/** Older Cursor plans report a billing-period pool rather than a weekly pool. */
+export function projectCursorPeriodUsage(input: any, now = Date.now()): ProviderAccountUsage | undefined {
+  const start = Number(input?.billingCycleStart), end = Number(input?.billingCycleEnd);
+  const plan = input?.planUsage;
+  const usedPercent = percent(plan?.totalPercentUsed) ? plan.totalPercentUsed
+    : Number.isFinite(plan?.totalSpend) && plan.totalSpend >= 0 && Number.isFinite(plan?.limit) && plan.limit > 0
+      ? plan.totalSpend / plan.limit * 100 : undefined;
+  if (!Number.isFinite(start) || !Number.isFinite(end) || start <= 0 || end <= start
+    || start > 8.64e15 || end > 8.64e15) return undefined;
+  return projectNativeAccountUsage("cursor", { usagePercent: usedPercent,
+    currentPeriodStart: new Date(start).toISOString(), nextResetTimestampUtc: new Date(end).toISOString() }, now);
+}

package/apps/bridge/src/provider-account-status/native-usage/reader.ts

@@ -0,0 +1,85 @@
+import type { ProviderAccountUsage } from "../../../../../packages/protocol/schema";
+import { projectCursorPeriodUsage, projectNativeAccountUsage, type NativeUsageProvider } from "./projection";
+
+type Options = {
+  credential: (provider: NativeUsageProvider) => Promise<string | undefined>;
+  fetcher?: (url: string, init: RequestInit) => Promise<Response>;
+  clock?: () => number;
+};
+
+const requests = {
+  claude: { url: "https://api.anthropic.com/api/oauth/usage", method: "GET" },
+  cursor: { url: "https://api2.cursor.sh/aiserver.v1.DashboardService/GetSandUsageStatus", method: "POST" },
+  grok: { url: "https://cli-chat-proxy.grok.com/v1/billing?format=credits", method: "GET" },
+} as const;
+
+async function boundedResponse(response: Response): Promise<unknown> {
+  if (!response.ok || !response.body) return undefined;
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let length = 0;
+  try {
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      length += chunk.value.byteLength;
+      if (length > 65_536) return undefined;
+      chunks.push(chunk.value);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } finally { await reader.cancel(); }
+}
+
+/** Independent, bounded account reads. A catalog never waits for a native login or a turn. */
+export function createNativeAccountUsageReader(options: Options) {
+  const clock = options.clock ?? Date.now;
+  const fetcher = options.fetcher ?? fetch;
+  const reports = new Map<NativeUsageProvider, ProviderAccountUsage>();
+  let pending: Promise<void> | undefined;
+  let attemptedAt = -Infinity;
+
+  async function update(provider: NativeUsageProvider): Promise<void> {
+    try {
+      const token = await options.credential(provider);
+      if (!token) { reports.delete(provider); return; }
+      const request = requests[provider];
+      const response = await fetcher(request.url, {
+        method: request.method, redirect: "error", signal: AbortSignal.timeout(8_000),
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json",
+          ...(provider === "claude" ? { "anthropic-beta": "oauth-2025-04-20" } : {}),
+          ...(provider === "cursor" ? { "Connect-Protocol-Version": "1" } : {}),
+        },
+        ...(request.method === "POST" ? { body: "{}" } : {}),
+      });
+      const value = await boundedResponse(response);
+      let report = projectNativeAccountUsage(provider, value, clock());
+      if (provider === "cursor" && !report && value !== undefined) {
+        const legacy = await fetcher("https://api2.cursor.sh/aiserver.v1.DashboardService/GetCurrentPeriodUsage", {
+          method: "POST", redirect: "error", signal: AbortSignal.timeout(8_000), body: "{}",
+          headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", "Connect-Protocol-Version": "1" },
+        });
+        report = projectCursorPeriodUsage(await boundedResponse(legacy), clock());
+      }
+      if (report) reports.set(provider, report);
+      else reports.delete(provider);
+    } catch { reports.delete(provider); }
+  }
+
+  return {
+    current(): ProviderAccountUsage[] {
+      const now = clock();
+      return [...reports.values()].flatMap(report => {
+        const windows = report.windows.filter(window => window.resetsAt > now);
+        return now - report.observedAt <= 300_000 && windows.length ? [{ ...report, windows }] : [];
+      });
+    },
+    refresh(): Promise<void> {
+      if (pending) return pending;
+      if (clock() - attemptedAt < 120_000) return Promise.resolve();
+      attemptedAt = clock();
+      pending = Promise.allSettled((Object.keys(requests) as NativeUsageProvider[]).map(update))
+        .then(() => undefined).finally(() => { pending = undefined; });
+      return pending;
+    },
+  };
+}

package/apps/bridge/src/provider-model-catalog/index.ts

@@ -3,9 +3,8 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import type { AdvertisedModel, EndpointModelCatalog } from "../../../../packages/protocol/schema";
 
-import { readClaudeUsage } from "../provider-account-status/claude-statusline";
 import { cachedCLIModels } from "./cli-models";
-import { cachedProviderAccount } from "../provider-account-status";
+import { cachedNativeAccountUsage, cachedProviderAccount } from "../provider-account-status";
 
 const MAX_BYTES = 2_000_000;
 const MAX_AGE = 24 * 60 * 60_000;
@@ -82,6 +81,6 @@ export function readProviderModelCatalog(endpointId: string): EndpointModelCatal
   const codex = readCodexModelCatalog(endpointId);
   const cli = cachedCLIModels(endpointId);
   return { ...codex, observedAt: Math.max(codex.observedAt, ...cli.map(row => row.observedAt)),
-    accountUsage: [...(codex.accountUsage ?? []), ...readClaudeUsage()],
+    accountUsage: [...(codex.accountUsage ?? []), ...cachedNativeAccountUsage()],
     stale: codex.stale === true && cli.length === 0, models: [...codex.models, ...cli].slice(0, 256) };
 }

package/apps/bridge/src/task-routing/admission/index.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { TaskRoutingNeeds } from '../../../../../packages/protocol/task-resources';
 import { loadConfig, loadRuntimeConfig, machineConfigPath } from '../../config';
 import { applyNetworkRoute } from '../../device-network/settings';
 import { scanSessions } from '../../sessions';
@@ -14,7 +15,7 @@ import { observedRoutingSession } from '../observed-turn';
 
 export const OffloadInput = z.object({ action: z.enum(['request', 'cancel', 'status']).optional(),
   operationId: z.string().trim().min(1).max(128).optional(),
-  requirements: RoutingRequirementsInput.partial().extend({ reason: RoutingRequirementsInput.shape.reason }).optional() }).strict();
+  requirements: TaskRoutingNeeds.partial().extend({ reason: RoutingRequirementsInput.shape.reason }).optional() }).strict();
 export type OffloadArguments = z.infer<typeof OffloadInput>;
 type Proof = { sessionId: string; provider: RoutingRequestSource['provider'] };
 type Ports = { store: RoutingRequests; enabled: () => boolean;

package/apps/mcp/src/desktop/engine-bridge.ts

@@ -21,6 +21,7 @@ export const DESKTOP_OPERATIONS = new Set([
   "desktop.machine_load", "desktop.capability_usage", "desktop.task_image", "desktop.task_workspace",
   "desktop.installed_skills", "desktop.policy_status", "desktop.policy_set", "desktop.project_auto_accept",
   "desktop.mesh_snapshots",
+  "desktop.project_knowledge",
   "desktop.task_send", "desktop.task_queue", "desktop.transfer_continue", "desktop.task_control", "desktop.task_preferences",
   "desktop.task_handoff",
   "desktop.project_transport",

package/apps/mcp/src/desktop/operations/index.ts

@@ -20,6 +20,7 @@ import { desktopTaskHandoff } from "../delivery/task-handoff";
 import { desktopTaskCreate } from "../delivery/task-create";
 import { desktopMeshCreate } from "../delivery/mesh-create";
 import { desktopInvocationHistory } from "../invocation";
+import { desktopProjectKnowledge } from "../../../../bridge/src/mesh/knowledge/runtime-read";
 import { desktopUsage } from "../projection/usage";
 import { desktopInstalledSkills } from "../projection/installed-skills";
 import type { DesktopControllerEnrollment } from "../pairing";
@@ -74,6 +75,7 @@ export function desktopReadOperation(input: {
   if (operation === "desktop.invocation_history") {
     return desktopInvocationHistory(queryInput, engine, storePath);
   }
+  if (operation === "desktop.project_knowledge") return desktopProjectKnowledge(queryInput);
   if (operation === "desktop.project") {
     return Promise.resolve(desktopMeshProject(queryInput, storePath));
   }

package/cursor-plugin/README.md

@@ -10,7 +10,7 @@ keeps each phone response tied to the exact originating chat and prompt.
 Install the supported CLI on this computer, then run:
 
 ```bash
-npm install -g granttap-mcp@0.8.90
+npm install -g granttap-mcp@0.8.92
 granttap setup
 granttap status
 ```

package/cursor-plugin/mcp.json

@@ -4,7 +4,7 @@
       "command": "node",
       "args": [
         "-e",
-        "\"use strict\";\n\n// Cursor may start this MCP from any cwd. Execute JavaScript entry points with\n// Node itself: Windows batch shims require shell quoting that differs by host.\nconst { spawn } = require(\"node:child_process\");\nconst { existsSync } = require(\"node:fs\");\nconst { delimiter, dirname, join } = require(\"node:path\");\n\nconst PACKAGE = \"granttap-mcp@0.8.90\";\nconst dryRun = process.env.GRANTTAP_BOOTSTRAP_DRY_RUN === \"1\";\nconst platform = dryRun && process.env.GRANTTAP_BOOTSTRAP_PLATFORM\n  ? process.env.GRANTTAP_BOOTSTRAP_PLATFORM : process.platform;\nconst nodeRoot = dryRun && process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT\n  ? process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT : dirname(process.execPath);\nconst pathRoots = (process.env.PATH || \"\").split(delimiter).filter(Boolean);\nconst appData = process.env.APPDATA;\nconst roots = [nodeRoot, ...pathRoots, ...(appData ? [join(appData, \"npm\")] : [])];\nconst first = (paths) => paths.find((path) => existsSync(path));\n\nfunction launch() {\n  if (platform !== \"win32\") {\n    const installed = first(roots.map((root) => join(root, \"granttap-mcp\")));\n    if (installed) return { command: installed, args: [] };\n    const npx = first(roots.map((root) => join(root, \"npx\"))) || \"npx\";\n    return { command: npx, args: [\"-y\", PACKAGE] };\n  }\n  const installed = first(roots.map((root) =>\n    join(root, \"node_modules\", \"granttap-mcp\", \"bin\", \"granttap-mcp.mjs\")));\n  if (installed) return { command: process.execPath, args: [installed] };\n  const npx = first(roots.map((root) =>\n    join(root, \"node_modules\", \"npm\", \"bin\", \"npx-cli.js\")));\n  if (npx) return { command: process.execPath, args: [npx, \"-y\", PACKAGE] };\n  throw new Error(\"Node.js/npm 22.13.0+ is required on this Windows device. Install npm and retry GrantTap.\");\n}\n\nlet target;\ntry { target = launch(); }\ncatch (error) {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n}\n\nif (dryRun) {\n  process.stdout.write(JSON.stringify(target));\n  process.exit(0);\n}\n\nconst child = spawn(target.command, target.args, { stdio: \"inherit\", windowsHide: true });\nchild.on(\"error\", (error) => {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n});\nchild.on(\"exit\", (code, signal) => {\n  if (signal && platform !== \"win32\") {\n    try { process.kill(process.pid, signal); } catch { process.exit(code ?? 1); }\n    return;\n  }\n  process.exit(code ?? 1);\n});\n"
+        "\"use strict\";\n\n// Cursor may start this MCP from any cwd. Execute JavaScript entry points with\n// Node itself: Windows batch shims require shell quoting that differs by host.\nconst { spawn } = require(\"node:child_process\");\nconst { existsSync } = require(\"node:fs\");\nconst { delimiter, dirname, join } = require(\"node:path\");\n\nconst PACKAGE = \"granttap-mcp@0.8.92\";\nconst dryRun = process.env.GRANTTAP_BOOTSTRAP_DRY_RUN === \"1\";\nconst platform = dryRun && process.env.GRANTTAP_BOOTSTRAP_PLATFORM\n  ? process.env.GRANTTAP_BOOTSTRAP_PLATFORM : process.platform;\nconst nodeRoot = dryRun && process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT\n  ? process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT : dirname(process.execPath);\nconst pathRoots = (process.env.PATH || \"\").split(delimiter).filter(Boolean);\nconst appData = process.env.APPDATA;\nconst roots = [nodeRoot, ...pathRoots, ...(appData ? [join(appData, \"npm\")] : [])];\nconst first = (paths) => paths.find((path) => existsSync(path));\n\nfunction launch() {\n  if (platform !== \"win32\") {\n    const installed = first(roots.map((root) => join(root, \"granttap-mcp\")));\n    if (installed) return { command: installed, args: [] };\n    const npx = first(roots.map((root) => join(root, \"npx\"))) || \"npx\";\n    return { command: npx, args: [\"-y\", PACKAGE] };\n  }\n  const installed = first(roots.map((root) =>\n    join(root, \"node_modules\", \"granttap-mcp\", \"bin\", \"granttap-mcp.mjs\")));\n  if (installed) return { command: process.execPath, args: [installed] };\n  const npx = first(roots.map((root) =>\n    join(root, \"node_modules\", \"npm\", \"bin\", \"npx-cli.js\")));\n  if (npx) return { command: process.execPath, args: [npx, \"-y\", PACKAGE] };\n  throw new Error(\"Node.js/npm 22.13.0+ is required on this Windows device. Install npm and retry GrantTap.\");\n}\n\nlet target;\ntry { target = launch(); }\ncatch (error) {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n}\n\nif (dryRun) {\n  process.stdout.write(JSON.stringify(target));\n  process.exit(0);\n}\n\nconst child = spawn(target.command, target.args, { stdio: \"inherit\", windowsHide: true });\nchild.on(\"error\", (error) => {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n});\nchild.on(\"exit\", (code, signal) => {\n  if (signal && platform !== \"win32\") {\n    try { process.kill(process.pid, signal); } catch { process.exit(code ?? 1); }\n    return;\n  }\n  process.exit(code ?? 1);\n});\n"
       ]
     }
   }

package/cursor-plugin/stdio-bootstrap.cjs

@@ -7,7 +7,7 @@ const { spawn } = require("node:child_process");
 const { existsSync } = require("node:fs");
 const { delimiter, dirname, join } = require("node:path");
 
-const PACKAGE = "granttap-mcp@0.8.90";
+const PACKAGE = "granttap-mcp@0.8.92";
 const dryRun = process.env.GRANTTAP_BOOTSTRAP_DRY_RUN === "1";
 const platform = dryRun && process.env.GRANTTAP_BOOTSTRAP_PLATFORM
   ? process.env.GRANTTAP_BOOTSTRAP_PLATFORM : process.platform;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "granttap-mcp",
-  "version": "0.8.90",
+  "version": "0.8.92",
   "description": "Commercial computer runtime connecting local coding agents to GrantTap on Mac, iPhone, iPad and Apple Watch.",
   "type": "module",
   "bin": {
@@ -42,7 +42,7 @@
     "tsx": "^4.23.4",
     "tweetnacl": "^1.0.3",
     "ws": "^8.18.0",
-    "zod": "^3.24.1"
+    "zod": "4.6.7"
   },
   "devDependencies": {
     "@types/express": "^5.0.3",

package/packages/protocol/messages/approval-questions/index.ts

@@ -15,7 +15,7 @@ export function questionAnswers(questions: z.infer<typeof ApprovalQuestions> | u
   note: string | null | undefined): Record<string, string> | undefined {
   if (!questions || !note || note.length > 20_000) return undefined;
   try {
-    const answers = z.record(z.string().trim().min(1).max(4_000)).parse(JSON.parse(note));
+    const answers = z.record(z.string(), z.string().trim().min(1).max(4_000)).parse(JSON.parse(note));
     if (Object.keys(answers).length !== questions.length
       || questions.some(item => !Object.hasOwn(answers, item.question))) return undefined;
     return answers;

package/packages/protocol/messages/mesh/knowledge/refresh.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { Identifier } from "../endpoint";
+import { MeshInvocationEvent } from "../invocations";
+import { ProjectKnowledgeRecord } from "./index";
+
+const Sequence = z.number().int().nonnegative().safe();
+export const ProjectKnowledgeQuery = z.object({
+  type: z.literal("mesh.knowledge.query"),
+  sessionId: Identifier, projectId: Identifier, requestId: Identifier,
+}).strict().refine(value => value.sessionId === value.projectId, "Project scope mismatch");
+export type ProjectKnowledgeQuery = z.infer<typeof ProjectKnowledgeQuery>;
+
+/** One bounded Project read; no architecture rebuild or per-Task fan-out. */
+export const ProjectKnowledgePage = z.object({
+  type: z.literal("mesh.knowledge.page"),
+  sessionId: Identifier, projectId: Identifier, requestId: Identifier,
+  sourceEndpointId: Identifier,
+  memoryAvailability: z.enum(["ready", "unavailable"]),
+  invocationAvailability: z.enum(["ready", "unavailable"]),
+  knowledge: z.array(ProjectKnowledgeRecord).max(32),
+  supersededKnowledgeRecordIds: z.array(Identifier).max(128),
+  invocations: z.array(z.object({ sequence: Sequence, event: MeshInvocationEvent }).strict()).max(32),
+  incomplete: z.boolean(), generatedAt: Sequence,
+}).strict().superRefine((value, ctx) => {
+  let previous = 0;
+  const seenCalls = new Set<string>();
+  const orderedCalls = value.invocations.every(row => {
+    const valid = row.sequence > previous && !seenCalls.has(row.event.event_id);
+    previous = row.sequence;
+    seenCalls.add(row.event.event_id);
+    return valid;
+  });
+  if (!orderedCalls
+    || new Set(value.knowledge.map(row => row.recordId)).size !== value.knowledge.length
+    || new Set(value.supersededKnowledgeRecordIds).size !== value.supersededKnowledgeRecordIds.length
+    || value.sessionId !== value.projectId
+    || value.knowledge.some(record => record.projectId !== value.projectId || record.visibility !== "project")
+    || value.invocations.some(row => row.event.project_id !== value.projectId)
+    || value.memoryAvailability === "unavailable" && value.knowledge.length > 0
+    || value.invocationAvailability === "unavailable" && value.invocations.length > 0) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: "Knowledge source or Project scope mismatch" });
+  }
+});
+export type ProjectKnowledgePage = z.infer<typeof ProjectKnowledgePage>;

package/packages/protocol/messages/sessions/index.ts

@@ -149,8 +149,8 @@ export const SessionsStatus = z.object({
   gatingEnabled: z.boolean().optional(),
   excludedSessions: z.array(z.string()).optional(),
   autoAcceptDefault: AutoAcceptLevel.optional(),
-  autoAcceptBySession: z.record(AutoAcceptLevel).optional(),
-  autoAcceptByProject: z.record(AutoAcceptLevel).optional(),
+  autoAcceptBySession: z.record(z.string(), AutoAcceptLevel).optional(),
+  autoAcceptByProject: z.record(z.string(), AutoAcceptLevel).optional(),
   autoAcceptPaused: z.boolean().optional(),
   providerSettings: ProviderRuntimeSettings.optional(),
   meshEnabled: z.boolean().optional(),

package/packages/protocol/schema.ts

@@ -45,6 +45,7 @@ import { PairingJoin } from "./messages/pairing-join";
 import { ControllerPairOffer, ControllerPairRequest } from "./messages/device/controller-pairing";
 import { AccountMachineLink } from "./messages/device/account-machine-link";
 import { KnowledgeWrite, KnowledgeWriteResult } from "./messages/mesh/knowledge/write";
+import { ProjectKnowledgeQuery, ProjectKnowledgePage } from "./messages/mesh/knowledge/refresh";
 import { MeshInvocationPage, MeshInvocationQuery } from "./messages/mesh/invocations";
 import {
   ProjectPolicyAck,
@@ -82,6 +83,7 @@ export * from "./messages/pairing-join";
 export * from "./messages/device/controller-pairing";
 export * from "./messages/device/account-machine-link";
 export * from "./messages/mesh/knowledge/write";
+export * from "./messages/mesh/knowledge/refresh";
 export * from "./messages/mesh";
 export * from "./messages/mesh/invocations";
 export * from "./messages/primitives";
@@ -165,6 +167,8 @@ export const Payload = z.union([
   ProjectCapabilityRequestSet,
   MeshInvocationQuery,
   MeshInvocationPage,
+  ProjectKnowledgeQuery,
+  ProjectKnowledgePage,
   MeshEndpointPolicy,
   ProjectPolicySet,
   ProjectPolicyStatus,