granttap-mcp 0.8.116 → 0.8.118

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

@@ -18,3 +18,7 @@ do not borrow an implementation's description or icon. These are display data,
 not instructions or evidence that a capability was used.
 
 License: this module is distributed under the GrantTap Commercial Source License in the repository-root `LICENSE` file.
+
+Catalog publication warms native Codex MCP configuration asynchronously through
+`refreshCodexMcpDescriptors`, preserving its existing retry window and last known
+rows while allowing request-delivery callbacks to run during a slow native query.

package/apps/bridge/src/capabilities/descriptors.ts

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { execFileSync } from "node:child_process";
+import { execFile, execFileSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
@@ -65,6 +65,28 @@ function codexMcpDescriptors(): McpDescriptor[] {
     .sort((a, b) => a.name.localeCompare(b.name));
 }
 
+let codexRefresh: Promise<void> | undefined;
+
+/** Warm native configuration asynchronously before a catalog consumes the synchronous projection. */
+export function refreshCodexMcpDescriptors(): Promise<void> {
+  if (codexCache && Date.now() - codexCache.at < CACHE_MS) return Promise.resolve();
+  if (codexRefresh) return codexRefresh;
+  codexRefresh = new Promise<void>(resolve => {
+    const finish = (error: Error | null, output = '') => {
+      let rows = codexCache?.rows ?? [];
+      if (!error) {
+        try { const parsed = JSON.parse(output); if (Array.isArray(parsed)) rows = parsed; } catch { /* Keep last known rows. */ }
+      }
+      codexCache = { at: Date.now(), rows };
+      resolve();
+    };
+    try { execFile(resolveCodexBinary(), ['mcp', 'list', '--json'],
+      { encoding: 'utf8', timeout: 15_000, maxBuffer: 4 * 1024 * 1024 }, finish); }
+    catch { finish(new Error('Native configuration is unavailable.')); }
+  }).finally(() => { codexRefresh = undefined; });
+  return codexRefresh;
+}
+
 function codexMcpRows(): CodexMcpRow[] {
   if (codexCache && Date.now() - codexCache.at < CACHE_MS) return codexCache.rows;
   try {

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

@@ -41,3 +41,5 @@ function mcpServersFromDescriptors(
     return metadata ? { ...base, ...metadata } : base;
   });
 }
+
+export { refreshCodexMcpDescriptors } from "./descriptors";

package/apps/bridge/src/codex-questions/README.md

@@ -32,3 +32,9 @@ answer, image and file payload together; ordinary encrypted attachment transport
 Task policy, native-owner admission and stable question idempotency still apply.
 Legacy text-only replies keep their existing contract. Files remain available
 for the admitted native turn; another phone cannot start a second answer.
+
+Notification refresh can name one request through `sessions.refresh.notificationRequestId`.
+Recovery checks the private request's owning room, restores a discovered source only
+inside the native Codex sessions root, and sends that exact question or its terminal
+state through the priority device channel. It does not require an admitted catalog,
+start a provider turn, send another wake notification, or schedule a full scan.

package/apps/bridge/src/codex-questions/index.ts

@@ -1,6 +1,6 @@
 import type { RelayClient } from '../../../../packages/core/relay-client';
 import type { SessionInfo, UserMessage } from '../../../../packages/protocol/schema';
-import { nativeTranscriptSource } from '../sessions';
+import { nativeTranscriptSource, restoreNativeTranscriptSource } from '../sessions';
 import { handleInboundUserMessage } from '../monitor/message-delivery';
 import { sendDeliveryReceipt } from '../monitor/handlers/receipts';
 import { nativeAnswerEnvelope } from './observations';
@@ -12,7 +12,7 @@ const RETENTION_MS = 24 * 60 * 60_000;
 
 /** Phone questions travel as device-encrypted control events, independently of task-key grants. */
 export async function publishCodexQuestions(client: RelayClient, sessions: SessionInfo[],
-  options: { replay?: boolean; peerPublicKey?: string } = {}): Promise<void> {
+  options: { replay?: boolean; peerPublicKey?: string; requestId?: string } = {}): Promise<void> {
   for (const session of sessions.filter(s => s.agent === 'codex')) {
     const path = nativeTranscriptSource(session);
     if (!path) continue;
@@ -22,9 +22,11 @@ export async function publishCodexQuestions(client: RelayClient, sessions: Sessi
     for (const question of observed.questions) {
       if (Date.now() - question.createdAt > RETENTION_MS) continue;
       const existing = readQuestion(question.requestId);
-      if (!existing) saveQuestion({ ...question, room: client.room });
+      if (!existing) saveQuestion({ ...question, room: client.room, sourcePath: path });
+      else if (existing.room === client.room && existing.sourcePath !== path) saveQuestion({ ...existing, sourcePath: path });
     }
-    const records = storedQuestions().filter(q => q.room === client.room && q.sessionId === session.sessionId)
+    const records = storedQuestions().filter(q => q.room === client.room && q.sessionId === session.sessionId
+      && (!options.requestId || q.requestId === options.requestId))
       .sort((a, b) => a.createdAt - b.createdAt || a.index - b.index);
     for (const record of records) {
       const expired = Date.now() - record.createdAt > RETENTION_MS;
@@ -44,7 +46,7 @@ export async function publishCodexQuestions(client: RelayClient, sessions: Sessi
           sessionId: session.sessionId, agent: 'codex', projectId: session.projectId,
           taskId: session.taskId, computerId: session.computerId, text, createdAt: record.createdAt },
         'phone', { ttlMs: Math.max(1, record.createdAt + RETENTION_MS - Date.now()),
-          wake: !record.announced, peerPublicKey: options.peerPublicKey,
+          wake: !record.announced, urgent: true, peerPublicKey: options.peerPublicKey,
           deliveryId: 'native-question-' + record.requestId });
         saveQuestion({ ...record, announced: true });
       }
@@ -52,6 +54,20 @@ export async function publishCodexQuestions(client: RelayClient, sessions: Sessi
   }
 }
 
+/** Restore one notification from private owned records; catalog discovery is not a prerequisite. */
+export async function replayCodexQuestion(client: RelayClient, requestId: string, peerPublicKey?: string): Promise<boolean> {
+  if (!peerPublicKey) return false;
+  const record = readQuestion(requestId);
+  if (!record || record.room !== client.room) return false;
+  const identity = { sessionId: record.sessionId, agent: 'codex' as const };
+  if (!nativeTranscriptSource(identity)
+    && (!record.sourcePath || !restoreNativeTranscriptSource(identity, record.sourcePath))) return false;
+  const session: SessionInfo = { ...identity, state: 'idle', startedAt: record.createdAt,
+    lastActivityAt: record.createdAt, tokensSession: 0, tokensLastTurn: 0 };
+  await publishCodexQuestions(client, [session], { replay: true, peerPublicKey, requestId });
+  return true;
+}
+
 /** Reuse ordinary scoped delivery, policy and receipts; only the human's explicit answer is wrapped. */
 export async function handleCodexQuestionReply(client: RelayClient, message: UserMessage,
   publish: () => Promise<void>, peerPublicKey?: string,

package/apps/bridge/src/codex-questions/records.ts

@@ -7,6 +7,7 @@ import { questionId } from './observations';
 const Record = z.object({ requestId: z.string(), sessionId: z.string(), callId: z.string(),
   index: z.number().int().min(0).max(3), question: z.string().max(2_000),
   options: z.array(z.string().max(512)).max(8), createdAt: z.number(), room: z.string(),
+  sourcePath: z.string().min(1).max(4096).optional(),
   announced: z.boolean().optional(), answered: z.boolean().optional(), resolvedSent: z.boolean().optional() });
 export type QuestionRecord = z.infer<typeof Record>;
 const directory = () => join(configDir(), 'codex-question-records');

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

@@ -20,7 +20,10 @@ import type { MeshStore } from "../store";
 import { queueProjectBindingSync } from "../../engine/runtime/engine-projects";
 import { isCursorTaskCloneId } from "../../sessions/cursor/catalog";
 import { localTaskTransfers } from '../../task-transfer';
-export { inspectRepositoryAsync } from "./repository-inspection";
+export { inspectRepositoryAsync, inspectWorkingTreeAsync } from "./repository-inspection";
+export { prepareMonitorInspection } from "./monitor-inspection";
+import type { CatalogInspection } from "./monitor-inspection";
+export type { CatalogInspection } from "./monitor-inspection";
 
 export type RepositoryFacts = {
   root: string;
@@ -120,7 +123,7 @@ export function linkSessionsToProjects(
   store: MeshStore,
   sessions: SessionInfo[],
   computerId: string,
-  inspect: (cwd: string) => RepositoryFacts = inspectRepository,
+  inspect: ((cwd: string) => RepositoryFacts) | CatalogInspection = inspectRepository,
   formerNames: string[] = formerComputerNames(),
 ): SessionInfo[] {
   localTaskTransfers().reconcileCatalogOwnership(store, computerId);
@@ -143,13 +146,14 @@ export function linkSessionsToProjects(
   const repositories = new Map<string, RepositoryFacts>();
   const workingTrees = new Map<string, boolean | undefined>();
   const inspectWorkingTree = (cwd: string): boolean | undefined => {
-    if (!workingTrees.has(cwd)) workingTrees.set(cwd, hasUncommittedWork(cwd));
+    if (!workingTrees.has(cwd)) workingTrees.set(cwd, typeof inspect === "function"
+      ? hasUncommittedWork(cwd) : inspect.workingTree(cwd));
     return workingTrees.get(cwd);
   };
   const inspectOnce = (cwd: string): RepositoryFacts => {
     let facts = repositories.get(cwd);
     if (!facts) {
-      facts = inspect(cwd);
+      facts = typeof inspect === "function" ? inspect(cwd) : inspect.repository(cwd);
       repositories.set(cwd, facts);
     }
     return facts;

package/apps/bridge/src/mesh/catalog/monitor-inspection/README.md

@@ -0,0 +1,14 @@
+# Monitor repository inspection
+
+Public entry: `prepareMonitorInspection` through the catalog entry point. The
+monitor prepares Git observations asynchronously with the existing two-command
+pool. Each catalog reads uncommitted work afresh. Only stable repository metadata
+is reused for at most 30 seconds; missing repositories retry after five seconds.
+An explicit refresh bypasses reuse. Retired directories are removed, older
+in-flight results cannot replace a forced refresh, and cache size is bounded.
+
+These are catalog observations. Explicit Git and Task transfer operations retain
+their fresh native inspection and never use this observation cache as authority.
+Tests cover fresh unsaved work, forced refresh, expiry, retirement and ordering.
+
+License: GrantTap Commercial Source License in the repository LICENSE.

package/apps/bridge/src/mesh/catalog/monitor-inspection/index.ts

@@ -0,0 +1,48 @@
+import { inspectRepositoryAsync, inspectWorkingTreeAsync } from '../repository-inspection';
+import { inspectRepository, hasUncommittedWork, type RepositoryFacts } from '..';
+
+type Readers = { repository: (cwd: string) => Promise<RepositoryFacts>;
+  workingTree: (cwd: string) => Promise<boolean | undefined>; now: () => number };
+export type CatalogInspection = { repository: (cwd: string) => RepositoryFacts;
+  workingTree: (cwd: string) => boolean | undefined };
+type Observation = { facts: RepositoryFacts; observedAt: number; expiresAt: number };
+
+/** Observation only. Explicit Git and transfer operations continue to inspect native state freshly. */
+export function createMonitorInspection(readers: Readers = {
+  repository: inspectRepositoryAsync, workingTree: inspectWorkingTreeAsync, now: Date.now,
+}) {
+  const metadata = new Map<string, Observation>();
+  const pending = new Map<string, Promise<RepositoryFacts>>();
+  let admitted = new Set<string>();
+  const repository = (cwd: string, force: boolean): Promise<RepositoryFacts> => {
+    const cached = metadata.get(cwd);
+    if (!force && cached && readers.now() >= cached.observedAt && readers.now() < cached.expiresAt) return Promise.resolve(cached.facts);
+    const active = pending.get(cwd);
+    if (!force && active) return active;
+    const next = readers.repository(cwd).then(facts => {
+      const observed = Object.freeze({ ...facts }), now = readers.now();
+      if (pending.get(cwd) === next && admitted.has(cwd) && (metadata.has(cwd) || metadata.size < 512)) {
+        metadata.set(cwd, { facts: observed, observedAt: now, expiresAt: now + (facts.worktree ? 30_000 : 5_000) });
+      }
+      return observed;
+    }).finally(() => { if (pending.get(cwd) === next) pending.delete(cwd); });
+    pending.set(cwd, next);
+    return next;
+  };
+  return async (directories: string[], force = false): Promise<CatalogInspection> => {
+    admitted = new Set(directories);
+    for (const cwd of metadata.keys()) if (!admitted.has(cwd)) metadata.delete(cwd);
+    const facts = new Map(await Promise.all([...admitted].map(async cwd => [cwd, await repository(cwd, force)] as const)));
+    const roots = new Set([...facts.values()].flatMap(value => value.worktree ? [value.worktree] : []));
+    const workingTrees = new Map(await Promise.all([...roots].map(async root => [root, await readers.workingTree(root)] as const)));
+    const values = new Map([...facts].map(([cwd, value]) => [cwd, { repository: value,
+      workingTree: value.worktree ? workingTrees.get(value.worktree) : undefined }] as const));
+    for (const value of [...values.values()]) {
+      if (value.repository.worktree && !values.has(value.repository.worktree)) values.set(value.repository.worktree, value);
+    }
+    return { repository: cwd => values.get(cwd)?.repository ?? inspectRepository(cwd),
+      workingTree: cwd => values.has(cwd) ? values.get(cwd)!.workingTree : hasUncommittedWork(cwd) };
+  };
+}
+
+export const prepareMonitorInspection = createMonitorInspection();

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

@@ -7,18 +7,18 @@ 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> {
+function git(cwd: string, args: string[], status = false): 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);
+        resolve(error ? undefined : status ? stdout : stdout.trim() || undefined);
       };
       try {
         execFile("git", ["-C", cwd, ...args], {
-          encoding: "utf8", timeout: 2_000, maxBuffer: 1024 * 1024, windowsHide: true,
+          encoding: "utf8", timeout: status ? 5_000 : 2_000, maxBuffer: (status ? 4 : 1) * 1024 * 1024, windowsHide: true,
         }, done);
       } catch { done(new Error("Repository command could not start")); }
     };
@@ -47,3 +47,9 @@ export function inspectRepositoryAsync(cwd: string): Promise<RepositoryFacts> {
   pending.set(cwd, next);
   return next;
 }
+
+/** A fresh working-tree observation shares the bounded, nonblocking Git command pool. */
+export async function inspectWorkingTreeAsync(cwd: string): Promise<boolean | undefined> {
+  const output = await git(cwd, ['status', '--porcelain=v1', '--untracked-files=normal', '-z'], true);
+  return output === undefined ? undefined : output.length > 0;
+}

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

@@ -21,7 +21,7 @@ import {
 } from "../../reply";
 import { isProviderEnabled } from "../../config/runtime";
 import { sendMeshPayload } from "../../host/session-keys";
-import { linkSessionsToProjects } from "../catalog";
+import { linkSessionsToProjects, type CatalogInspection } from "../catalog";
 import { catalogFromEndpoint } from "../catalog/models";
 import { saveProjectCapabilityRequest } from "../catalog/project/requests";
 import { computerId } from "../identity/computer";
@@ -84,8 +84,8 @@ const defaultDependencies: MeshRuntimeDependencies = {
 export function createMeshRuntime(deps: MeshRuntimeDependencies) {
   const flow = createHandoffFlow(deps);
   const { capsulePrompt, acceptHandoff, answerAgentQuestion } = flow;
-  const catalog = (sessions: SessionInfo[]) =>
-    linkSessionsToProjects(deps.store(), sessions, deps.computer());
+  const catalog = (sessions: SessionInfo[], inspection?: CatalogInspection) =>
+    linkSessionsToProjects(deps.store(), sessions, deps.computer(), inspection);
 
 
   return {
@@ -165,8 +165,8 @@ export function createLocalMeshRuntime(overrides: Partial<MeshRuntimeDependencie
 
 const defaultRuntime = createLocalMeshRuntime();
 
-export function meshCatalog(sessions: SessionInfo[]): SessionInfo[] {
-  return defaultRuntime.catalog(sessions);
+export function meshCatalog(sessions: SessionInfo[], inspection?: CatalogInspection): SessionInfo[] {
+  return defaultRuntime.catalog(sessions, inspection);
 }
 
 export function meshSnapshots(): MeshSnapshot[] {

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

@@ -47,7 +47,7 @@ import { handleControllerPairRequest, handleInboundKnowledgeWrite } from "../con
 import { acceptPhoneAccountLink } from "../../account-recovery/phone-link";
 import { approvalsStatus } from '../../approvals/state';
 import { handleDeliveryReceiptQuery } from '../message-delivery/status-query';
-import { handleCodexQuestionReply, publishCodexQuestions } from '../../codex-questions';
+import { handleCodexQuestionReply, publishCodexQuestions, replayCodexQuestion } from '../../codex-questions';
 import { publishedCatalog } from '../../session-catalog';
 
 export async function handleMonitorMessage(
@@ -205,6 +205,10 @@ async function handleInboundRefresh(
   // Notification actions must not wait behind provider scans or graph analysis.
   await client.send(approvalsStatus(), 'phone', { peerPublicKey, reliable: false, ttlMs: 90_000 })
     .catch(() => {});
+  if (payload.notificationRequestId) {
+    await replayCodexQuestion(client, payload.notificationRequestId, peerPublicKey).catch(() => false);
+    return true;
+  }
   const known = publishedCatalog(client);
   if (known) await publishCodexQuestions(client, [...known.sessions, ...(known.history ?? [])],
     { replay: true, peerPublicKey }).catch(() => {});

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

@@ -7,7 +7,8 @@ import { RelayClient } from "../../../../../packages/core/relay-client";
 import type { Payload, SessionInfo, SessionsStatus } from "../../../../../packages/protocol/schema";
 import { loadRuntimeConfig, autoAcceptLevelFor } from "../../config";
 import { monitorLeadership } from "./leadership";
-import { mcpServersForSession, workspaceSkills } from "../../capabilities";
+import { mcpServersForSession, workspaceSkills, refreshCodexMcpDescriptors } from "../../capabilities";
+import { prepareMonitorInspection, type CatalogInspection } from "../../mesh/catalog";
 import { inspectAgentIntegrations } from "../../install";
 import { withCloudRunners } from "../../cloud-runners";
 import { currentConfigRevision } from "../../config/commands";
@@ -48,12 +49,13 @@ export type SessionMonitor = {
 function decorateSessions(
   sessions: SessionsStatus["sessions"],
   subscriptions: Set<string>,
+  inspection?: CatalogInspection,
 ): SessionsStatus["sessions"] {
   const runtime = loadRuntimeConfig();
   const visible = sessions.filter((session) =>
     runtime.providerSettings[session.agent as keyof typeof runtime.providerSettings] !== false
   );
-  const coordinated = runtime.meshEnabled ? meshCatalog(visible) : visible;
+  const coordinated = runtime.meshEnabled ? meshCatalog(visible, inspection) : visible;
   return coordinated.map((session) => {
     const base: SessionInfo = {
       ...session,
@@ -88,13 +90,17 @@ async function monitorSnapshot(input: {
   if (loadRuntimeConfig().meshEnabled) localMeshStore().flush();
   const { sessions, tokensRecent } = await scanSessionsCooperatively();
   const runtime = loadRuntimeConfig();
+  const historical = includeHistory ? boundedCatalogHistory(await history(forceHistory), subscriptions) : undefined;
+  const all = [...sessions, ...(historical ?? [])].filter(session =>
+    runtime.providerSettings[session.agent as keyof typeof runtime.providerSettings] !== false);
+  if (all.some(session => session.agent === 'codex')) await refreshCodexMcpDescriptors();
+  const directories = all.flatMap(session => [session.worktree, session.cwd].filter((path): path is string => !!path));
+  const inspection = runtime.meshEnabled ? await prepareMonitorInspection(directories, forceHistory) : undefined;
   return {
     type: "sessions.status",
     machine: computerDisplayName(),
-    sessions: decorateSessions(sessions, subscriptions),
-    history: includeHistory
-      ? decorateSessions(boundedCatalogHistory(await history(forceHistory), subscriptions), subscriptions)
-      : undefined,
+    sessions: decorateSessions(sessions, subscriptions, inspection),
+    history: historical ? decorateSessions(historical, subscriptions, inspection) : undefined,
     tokensRecent,
     tokenWindowHours: TOKEN_WINDOW_HOURS,
     tokensAllTime: tokensRecent,

package/apps/bridge/src/sessions/native-source.ts

@@ -17,7 +17,7 @@ export function nativeTranscriptSource(session: Pick<SessionInfo, 'agent' | 'ses
 }
 
 /** Restore an owned native source without walking every provider's logs. */
-export function restoreNativeTranscriptSource(session: SessionInfo, path: string): boolean {
+export function restoreNativeTranscriptSource(session: Pick<SessionInfo, 'agent' | 'sessionId'>, path: string): boolean {
   if (!["claude", "codex"].includes(session.agent)
     || !/^[a-zA-Z0-9-]{1,128}$/.test(session.sessionId)) return false;
   const name = basename(path);

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

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

@@ -161,5 +161,6 @@ export const SessionsRefresh = z.object({
   createdAt: z.number(),
   graphProjectId: z.string().min(1).max(128).optional(),
   graphAnalysisRequestId: z.string().min(1).max(128).optional(),
+  notificationRequestId: z.string().min(1).max(256).optional(),
 });
 export type SessionsRefresh = z.infer<typeof SessionsRefresh>;