granttap-mcp 0.8.91 → 0.8.93

package/apps/bridge/src/mesh/admin/capsule.ts

@@ -86,7 +86,7 @@ export function buildTaskCapsule(
   const capsule = {
     taskId: request.taskId,
     goal: task.goal,
-    currentStatus: session.summary ?? session.title ?? task.title,
+    currentStatus: (session.summary?.trim() || session.title?.trim() || task.title).slice(0, 1_000),
     sourceProvider: session.agent,
     sourceComputer: computerId,
     targetProvider: request.targetProvider,

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

@@ -166,8 +166,17 @@ function linkSession(input: {
   const agent = provider(session.agent);
   const cwd = session.cwd?.trim();
   if (!agent || !cwd) return session;
-  const repository = inspect(session.worktree ?? cwd);
   const knownTaskId = store.taskForExecution(computerId, agent, session.sessionId);
+  const knownProjectId = knownTaskId ? store.task(knownTaskId)?.projectId : undefined;
+  const previous = knownProjectId ? store.snapshot(knownProjectId)?.executions.find(row =>
+    row.taskId === knownTaskId && row.provider === agent && row.sessionId === session.sessionId
+      && row.computerId === computerId && row.workspace === cwd) : undefined;
+  let repository = inspect(session.worktree ?? cwd);
+  if (!repository.worktree && previous?.worktree) {
+    const retained = inspect(previous.worktree);
+    if (retained.worktree && retained.revision
+      && retained.canonicalRepositoryId === previous.repositoryId) repository = retained;
+  }
   const projectId = (knownTaskId ? store.task(knownTaskId)?.projectId : undefined)
     ?? store.projectIdForRepository(repository.canonicalRepositoryId, computerId)
     ?? projectIdentity(repository.canonicalRepositoryId);
@@ -229,13 +238,14 @@ function linkSession(input: {
     provider: agent,
     computerId,
     workspace: cwd,
-    repositoryId: repository.canonicalRepositoryId,
+    repositoryId: repository.worktree ? repository.canonicalRepositoryId
+      : previous?.repositoryId ?? repository.canonicalRepositoryId,
     activeAt: session.lastActivityAt,
     state: session.state, continuedAt: session.transfer?.continuedAt,
     branch: repository.branch ?? session.branch,
-    worktree: repository.worktree,
+    worktree: repository.worktree ?? previous?.worktree,
     uncommitted: input.inspectWorkingTree(repository.worktree ?? cwd),
     startedAt: session.startedAt,
   });
-  return { ...session, projectId, taskId, computerId, worktree: repository.worktree };
+  return { ...session, projectId, taskId, computerId, worktree: repository.worktree ?? previous?.worktree };
 }

package/apps/bridge/src/mesh/runtime/prepared-transfer/README.md

@@ -12,13 +12,20 @@ Catalog batches share a working-tree probe for chats in the same checkout.
 The next batch reads it again, including unknown results, so this never hides
 new uncommitted work behind a persistent cache.
 
-For a chat started above its repositories, `source-binding.ts` resolves an
-explicit `sourceBindingId` only within the owning endpoint's available Project
-bindings. It verifies the actual Git root and identity before capturing context.
+For a chat started above its repositories, `source-binding.ts` first uses the
+Task's own execution, current resource claim, Project repository, or sole owned
+checkout. Multiple unresolved choices require an explicit `sourceBindingId`.
+Both paths stay within the owning endpoint's available Project bindings and
+verify the actual Git root and identity before capturing context. A catalog
+refresh preserves an established checkout when the native chat still reports
+the same parent folder; missing known checkouts never select another repository.
 An exact repository binding takes precedence over a Project's parent execution
 folder. Preparing keeps the native source folder unchanged and launches no
 provider. Rejected preparations also publish their retained Project state.
 
+Capsule status is bounded independently from the complete conversation capture;
+a long native summary cannot invalidate an otherwise transferable Git Task.
+
 Tests: `tests/metadata.test.ts`, `tests/source-checkout.test.ts`,
 `tests/mesh/mesh-handoff-safety.test.ts`, and catalog
 `tests/working-tree-batch.test.ts`.

package/apps/bridge/src/mesh/runtime/prepared-transfer/source-binding.ts

@@ -1,16 +1,27 @@
 import { realpathSync } from 'node:fs';
-import type { MeshHandoffPrepare, SessionInfo } from '../../../../../../packages/protocol/schema';
+import type { MeshHandoffPrepare, MeshSnapshot, ProjectBindingSummary, SessionInfo } from '../../../../../../packages/protocol/schema';
 import { inspectRepository } from '../../catalog';
 import type { MeshStore } from '../../store';
 import { matchesLocalCheckout } from '../graph/checkout-identity';
 
-/** The controller chooses an already admitted binding, never an arbitrary path. */
+/** Resolve the Task's admitted checkout; an explicit choice can replace that default. */
 export function resolveHandoffSource(store: MeshStore, session: SessionInfo,
   request: MeshHandoffPrepare, computer: string): SessionInfo {
-  if (!request.sourceBindingId) return session;
-  const binding = store.snapshot(request.projectId)?.bindings?.find(row =>
-    row.bindingId === request.sourceBindingId && row.projectId === request.projectId
-      && row.endpointId === computer && row.available);
+  const snapshot = store.snapshot(request.projectId);
+  if (!request.sourceBindingId) {
+    const cwd = session.worktree ?? session.cwd;
+    if (cwd) {
+      const native = inspectRepository(cwd);
+      if (native.worktree && native.revision) {
+        return { ...session, worktree: native.root, branch: session.branch ?? native.branch };
+      }
+    }
+  }
+  const binding = request.sourceBindingId
+    ? snapshot?.bindings?.find(row => row.bindingId === request.sourceBindingId
+      && row.projectId === request.projectId && row.endpointId === computer && row.available)
+    : inferBinding(snapshot, session, request, computer);
+  if (!binding && !request.sourceBindingId) return session;
   if (binding?.localPathHint) {
     const facts = inspectRepository(binding.localPathHint);
     try {
@@ -22,3 +33,50 @@ export function resolveHandoffSource(store: MeshStore, session: SessionInfo,
   }
   throw new Error('The selected repository is not available on this computer. Refresh the Project and choose its checkout again.');
 }
+
+function samePath(left: string | undefined, right: string | undefined): boolean {
+  if (!left || !right) return false;
+  try { return realpathSync(left) === realpathSync(right); } catch { return false; }
+}
+
+function inferBinding(snapshot: MeshSnapshot | undefined, session: SessionInfo,
+  request: MeshHandoffPrepare, computer: string): ProjectBindingSummary | undefined {
+  const paths = new Set<string>();
+  const bindings = (snapshot?.bindings ?? []).filter(row => {
+    if (row.projectId !== request.projectId || row.endpointId !== computer
+      || !row.available || !row.revision || !row.localPathHint) return false;
+    try {
+      const path = realpathSync(row.localPathHint);
+      if (paths.has(path)) return false;
+      paths.add(path);
+      return true;
+    } catch { return false; }
+  });
+  if (!bindings.length) return undefined;
+  const execution = snapshot?.executions.find(row => row.taskId === request.taskId
+    && row.provider === session.agent && row.sessionId === session.sessionId
+    && row.computerId === computer && row.endedAt == null);
+  if (execution?.worktree) {
+    const exact = bindings.find(row => samePath(row.localPathHint, execution.worktree));
+    if (exact) return exact;
+    throw new Error('This Task\'s source checkout is unavailable. Refresh its computer before transferring.');
+  }
+  const byExecution = execution?.repositoryId
+    ? bindings.filter(row => row.repositoryId === execution.repositoryId) : [];
+  if (byExecution.length === 1) return byExecution[0];
+  const parent = snapshot?.bindings?.some(row => row.repositoryId === execution?.repositoryId
+    && row.endpointId === computer && !row.revision && samePath(row.localPathHint, session.cwd));
+  if (execution?.repositoryId && !parent) {
+    throw new Error('This Task\'s source repository is unavailable. Refresh its computer before transferring.');
+  }
+  const claims = snapshot?.claims.filter(row => row.taskId === request.taskId
+    && row.ownerSessionId === session.sessionId && row.expiresAt > Date.now()
+    && (!row.endpointId || row.endpointId === computer)) ?? [];
+  const byClaim = bindings.filter(row => claims.some(claim =>
+    claim.repositoryId === row.repositoryId && (!claim.worktree || samePath(claim.worktree, row.localPathHint))));
+  if (byClaim.length === 1) return byClaim[0];
+  const byProject = bindings.filter(row => row.repositoryId === snapshot?.project.canonicalRepositoryId);
+  if (byProject.length === 1) return byProject[0];
+  if (bindings.length === 1) return bindings[0];
+  throw new Error('Multiple Project checkouts are available. Choose the repository this Task should continue in.');
+}

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/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.91
+npm install -g granttap-mcp@0.8.93
 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.91\";\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.93\";\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.91";
+const PACKAGE = "granttap-mcp@0.8.93";
 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.91",
+  "version": "0.8.93",
   "description": "Commercial computer runtime connecting local coding agents to GrantTap on Mac, iPhone, iPad and Apple Watch.",
   "type": "module",
   "bin": {