granttap-mcp 0.8.85 → 0.8.86

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,33 @@
+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";
+
+type Publication = { running: boolean; closed: boolean; lastPublishedAt: number };
+const publications = new WeakMap<RelayClient, Publication>();
+
+/** A slow usage fan-out never occupies the current chat catalog's publication slot. */
+export function publishMonitorCapabilities(client: RelayClient, status: SessionsStatus,
+  history: () => Promise<SessionInfo[]>): void {
+  const state = publications.get(client) ?? { running: false, closed: false, lastPublishedAt: 0 };
+  publications.set(client, state);
+  if (state.running || state.closed || Date.now() - state.lastPublishedAt < 30_000) return;
+  state.running = true;
+  const work = (async () => {
+    await setImmediate();
+    if (state.closed || !client.isConnected) return;
+    const 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 });
+    state.lastPublishedAt = Date.now();
+  })();
+  void work.catch(() => {}).finally(() => { state.running = false; });
+}
+
+export function stopMonitorCapabilities(client: RelayClient): void {
+  const state = publications.get(client);
+  if (state) state.closed = true;
+  publications.delete(client);
+}

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

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

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