granttap-mcp 0.8.95 → 0.8.97

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

@@ -13,9 +13,12 @@ type DeliveryRecord = {
   updatedAt: number;
   processingAcknowledged?: boolean;
   rejectedError?: string;
+  scope?: DeliveryScope;
 };
 
-export type DeliveryStart = "started" | "processing" | "completed";
+export type DeliveryScope = { room: string; peerPublicKey: string; sessionId: string };
+
+export type DeliveryStart = "started" | "processing" | "completed" | "foreign";
 
 export function deliveryLedgerPath(): string {
   return join(configDir(), "delivery-ledger.json");
@@ -62,7 +65,7 @@ function save(records: Record<string, DeliveryRecord>, now: number): void {
 export function acknowledgeProcessingDelivery(messageId: string, now = Date.now()): void {
   const records = load();
   if (records[messageId]?.state !== "processing") return;
-  records[messageId] = { state: "processing", updatedAt: now, processingAcknowledged: true };
+  records[messageId] = { ...records[messageId], state: "processing", updatedAt: now, processingAcknowledged: true };
   save(records, now);
 }
 
@@ -72,28 +75,30 @@ export function processingDeliveryAcknowledged(messageId: string): boolean {
 }
 
 /** Acquire a durable processing lease before invoking an agent. */
-export function beginDelivery(messageId: string, now = Date.now()): DeliveryStart {
+export function beginDelivery(messageId: string, now = Date.now(), scope?: DeliveryScope): DeliveryStart {
   const records = load();
   const current = records[messageId];
+  if (current?.scope && (!scope || current.scope.room !== scope.room
+    || current.scope.peerPublicKey !== scope.peerPublicKey || current.scope.sessionId !== scope.sessionId)) return 'foreign';
   if (current?.state === "completed" && current.updatedAt >= now - MAX_AGE_MS) return "completed";
   if (current?.state === "processing" && current.updatedAt >= now - PROCESSING_LEASE_MS) {
     return "processing";
   }
-  records[messageId] = { state: "processing", updatedAt: now };
+  records[messageId] = { state: "processing", updatedAt: now, scope };
   save(records, now);
   return "started";
 }
 
 export function completeDelivery(messageId: string, now = Date.now()): void {
   const records = load();
-  records[messageId] = { state: "completed", updatedAt: now };
+  records[messageId] = { ...records[messageId], state: "completed", updatedAt: now };
   save(records, now);
 }
 
 /** A late provider refusal remains terminal across reconnects and replayed boxes. */
 export function rejectCompletedDelivery(messageId: string, error: string, now = Date.now()): void {
   const records = load();
-  records[messageId] = { state: 'completed', updatedAt: now, rejectedError: error.slice(0, 1_000) };
+  records[messageId] = { ...records[messageId], state: 'completed', updatedAt: now, rejectedError: error.slice(0, 500) };
   save(records, now);
 }
 
@@ -103,6 +108,15 @@ export function completedDeliveryFailure(messageId: string): string | undefined
     ? record.rejectedError : undefined;
 }
 
+/** Receipt replay is scoped to the original authenticated controller and route. */
+export function deliveryReceiptStatus(messageId: string, scope: DeliveryScope, now = Date.now()) {
+  const record = load()[messageId], saved = record?.scope;
+  if (!saved || saved.room !== scope.room || saved.peerPublicKey !== scope.peerPublicKey
+    || saved.sessionId !== scope.sessionId || record.updatedAt < now - MAX_AGE_MS
+    || record.updatedAt > now || record.state === 'processing' && !record.processingAcknowledged) return undefined;
+  return { status: record.rejectedError ? 'rejected' as const : 'accepted' as const, error: record.rejectedError };
+}
+
 /** Release a failed attempt so a relay retry can safely try again. */
 export function abandonDelivery(messageId: string, now = Date.now()): void {
   const records = load();

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

@@ -25,6 +25,13 @@ reports are retained in a bounded private computer cache across restarts, served
 while a new observation runs, and refreshed after the observation expires. Git
 admission revision (`sourceRevision`) remains separate from Weavatrix's content
 fingerprint (`revision`). Failed analyses cannot erase the durable last report.
+Explicit Graph builds also invoke the Engine's `graph.analyze_project` for two
+to eight admitted local repositories. The projection labels these shared static
+contracts and keeps their runtime destination unverified. They do not become
+verified Backbone dependencies or merge Project grants. The Apple Silicon
+artifact pins Engine 0.1.3 with Weavatrix 2.17.5; unsupported Engine operations
+leave this analysis unavailable. See `runtime/project-relationships/README.md`.
+
 Claude, Codex, and Cursor hooks can evaluate the engine's local Project
 Governance policy only when both `GRANTTAP_ENGINE_ENABLED` and
 `GRANTTAP_PROJECT_POLICY_ENABLED` are enabled. Project `DENY` and `ASK` precede

package/apps/bridge/src/engine/distribution/artifacts.ts

@@ -8,8 +8,8 @@ export type EngineArtifact = {
 
 /** Release hashes are part of the reviewed MCP, never supplied by a remote manifest. */
 export const ENGINE_ARTIFACTS: readonly EngineArtifact[] = [
-  { version: "0.1.2", platform: "darwin", arch: "arm64",
-    sha256: "fa23668f2f2cbb716a0ba66c5a6e027a25ed4e7e2dedf0c870edb32199045b97", bytes: 12101408 },
+  { version: "0.1.3", platform: "darwin", arch: "arm64",
+    sha256: "d948b6cfc572fa062af602c72d7b0e14bedcc5b48ecb8fb8d7af5b6fc33e9920", bytes: 12185568 },
   { version: "0.1.2", platform: "darwin", arch: "x64",
     sha256: "b3235a15936a77ec323d5ecbc54a0bc19994fe6e5a36044da964b68524b4c1dd", bytes: 13944984 },
   { version: "0.1.2", platform: "linux", arch: "x64",

package/apps/bridge/src/engine/protocol/project-relationships/README.md

@@ -0,0 +1,12 @@
+# Project relationship wire contract
+
+`index.ts` validates the Engine's bounded static contract report. Repository IDs
+must belong to its selected set; locations are relative paths in the source
+repository, and the relation remains `contract_match`. Source excerpts,
+absolute paths, foreign identities and unexpected fields fail closed.
+
+The public framed-client and parser tests live with the consuming feature in
+`../../runtime/project-relationships/tests/`. Runtime projection is documented
+in that feature's README.
+
+License: GrantTap Commercial Source License. See the repository-root `LICENSE`.

package/apps/bridge/src/engine/protocol/project-relationships/index.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { EngineProtocolError } from "../transport/protocol-base";
+
+const text = z.string().min(1).max(512).refine(value => !/[\x00-\x1f\x7f]/.test(value));
+const location = z.object({
+  repository_id: text,
+  path: text.refine(value => !/^(?:[A-Za-z]:|[\\/])/.test(value)
+    && !value.split(/[\\/]/).includes("..")),
+  line: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+}).strict();
+const schema = z.object({
+  project_id: text.max(128),
+  weavatrix_version: text.max(64),
+  analysis_status: z.enum(["COMPLETE", "INCOMPLETE"]),
+  repositories: z.array(z.object({ repository_id: text, revision: text }).strict()).min(2).max(8),
+  matches: z.array(z.object({
+    source: text,
+    target: text,
+    transport: z.enum(["http", "graphql", "grpc", "event"]),
+    relation: z.literal("contract_match"),
+    evidence_count: z.number().int().positive().max(1_000_000),
+    evidence: z.array(location).min(1).max(16),
+  }).strict()).max(128),
+  truncated: z.boolean(),
+}).strict().superRefine((value, context) => {
+  const ids = new Set(value.repositories.map(item => item.repository_id));
+  if (ids.size !== value.repositories.length || value.matches.some(edge =>
+    edge.source === edge.target || !ids.has(edge.source) || !ids.has(edge.target)
+    || edge.evidence_count < edge.evidence.length
+    || edge.evidence.some(item => item.repository_id !== edge.source))) {
+    context.addIssue({ code: "custom", message: "relationship scope is invalid" });
+  }
+});
+
+export type EngineProjectRelationships = z.infer<typeof schema>;
+
+export function parseProjectRelationships(value: unknown): void {
+  if (Buffer.byteLength(JSON.stringify(value), "utf8") > 65_536 || !schema.safeParse(value).success) {
+    throw new EngineProtocolError("Project relationship evidence is invalid");
+  }
+}

package/apps/bridge/src/engine/protocol/transport/protocol-types.ts

@@ -1,3 +1,4 @@
+import type { EngineProjectRelationships } from "../project-relationships";
 import type {
   EnginePolicyOperation,
   EnginePolicyResult,
@@ -105,6 +106,7 @@ export type EngineOperation = EnginePolicyOperation | InvocationEngineOperation
   | { operation: "project.get"; input: { project_id: string } }
   | { operation: "project.list"; input: { after_project_id?: string; limit: number } }
   | { operation: "project.list_bindings"; input: { project_id: string } }
+  | { operation: "graph.analyze_project"; input: {project_id:string;repository_ids:string[]} }
   | { operation: "graph.get_backbone"; input: { project_id: string } }
   | { operation: "graph.analyze_repository"; input: {
     project_id: string; repository_id: string;
@@ -136,6 +138,7 @@ export type EngineResult = EnginePolicyResult | InvocationEngineResult | MemoryE
     projects: EngineProject[]; next_after_project_id: string | null;
   } }
   | { operation: "project.bindings"; bindings: EngineProjectBinding[] }
+  | { operation: "graph.project_relationships"; graph:EngineProjectRelationships }
   | { operation: "graph.backbone"; backbone: EngineProjectBackbone }
   | { operation: "graph.repository"; graph: EngineRepositoryGraph }
   | { operation: "context.compiled"; compilation: EngineContextCompilation }

package/apps/bridge/src/engine/protocol/transport/result-parser.ts

@@ -1,3 +1,4 @@
+import { parseProjectRelationships } from "../project-relationships";
 import { parseInvocationResult } from "../engine-invocation-protocol";
 import { parseMemoryResult } from "../engine-memory-protocol";
 import { parsePolicyResult } from "../engine-policy-protocol";
@@ -47,6 +48,7 @@ function parseResult(value: unknown): EngineResult {
   else if (operation === "project.listed") parseProjectCatalog(result.page);
   else if (operation === "project.bindings") parseBindings(result.bindings);
   else if (operation === "project.binding_upserted") parseBinding(result.binding);
+  else if (operation === "graph.project_relationships") parseProjectRelationships(result.graph);
   else if (operation === "graph.backbone") parseBackbone(result.backbone);
   else if (operation === "graph.repository") parseRepositoryGraph(result.graph);
   else if (operation === "context.compiled") {

package/apps/bridge/src/engine/runtime/engine-client.ts

@@ -201,6 +201,7 @@ function expectedResultOperation(
   if (operation === "graph.get_backbone") return "graph.backbone";
   if (operation === "graph.get_heads") return "graph.heads";
   if (operation === "graph.compute_impact") return "graph.impact";
+  if (operation === "graph.analyze_project") return "graph.project_relationships";
   if (operation === "graph.analyze_repository") return "graph.repository";
   if (operation === "context.compile_project") return "context.compiled";
   if (operation === "invocation.observe") return "invocation.observed";

package/apps/bridge/src/engine/runtime/project-relationships/README.md

@@ -0,0 +1,19 @@
+# Project relationship projection
+
+`projectRelationshipPeers` connects the Engine's `graph.analyze_project` to the
+existing Graph refresh. Only distinct repository IDs from admitted local
+Project bindings are selected, with a limit of eight. A separate Engine socket
+keeps expensive analysis off the policy channel.
+
+Explicit Graph builds refresh static contract matches. Background snapshots
+read the bounded retained result for the same binding/revision key; they do not
+start additional cross-repository scans. Stale or unavailable results do not
+establish a missing dependency.
+
+The existing compatibility graph shows these edges as shared contracts, with
+an explicit static/runtime-unverified explanation. They never enter the
+verified Backbone and never merge independent Project groups or change grants.
+Full relative source evidence stays in the typed Engine response. No source
+excerpts or absolute machine roots are published to the phone.
+
+License: GrantTap Commercial Source License. See the repository-root `LICENSE`.

package/apps/bridge/src/engine/runtime/project-relationships/index.ts

@@ -0,0 +1,71 @@
+import { join } from "node:path";
+import type { IntegrationPeer, ProjectBindingSummary } from "../../../../../../packages/protocol/schema";
+import type { EngineProjectRelationships } from "../../protocol/project-relationships";
+import { configDir } from "../../../config/runtime/paths";
+import { EngineClient } from "../engine-client";
+import { engineFeatureEnabled, type EngineClientLike } from "../engine-supervisor";
+import { RepositoryGraphJobs } from "../repository-graph-jobs";
+
+type Analysis = { graph: EngineProjectRelationships; observedAt: number };
+const jobs = new RepositoryGraphJobs<Analysis>(Date.now, 120_000, 300_000, 8);
+const STATIC_CONTRACT_PREFIX = "Weavatrix: static ";
+
+/** Static compatibility is shown as shared contracts, never a proven dependency. */
+export async function projectRelationshipPeers(
+  projectId: string,
+  bindings: ProjectBindingSummary[],
+  options: { env?: NodeJS.ProcessEnv; client?: EngineClientLike; background?: boolean } = {},
+): Promise<IntegrationPeer[]> {
+  if (!engineFeatureEnabled(options.env ?? process.env)) return [];
+  const ids = [...new Set(bindings.map(binding => binding.repositoryId))].sort();
+  if (ids.length < 2 || ids.length > 8) return [];
+  const key = JSON.stringify([
+    projectId, ids, bindings.map(item => [item.bindingId, item.revision]).sort(),
+  ]);
+  // Background snapshots read retained results; explicit Graph builds start analysis.
+  const result = options.background
+    ? jobs.cached(key)
+    : await jobs.refresh(key, () => analyze(projectId, ids, options.client));
+  if (!result) return [];
+  return result.graph.matches.flatMap(edge => {
+    if (edge.target.length > 160) return [];
+    return [{
+      projectId,
+      repositoryId: edge.source,
+      peer: edge.target,
+      via: edge.transport === "event" ? "kafka" as const : "api" as const,
+      relation: "shares" as const,
+      through: `${STATIC_CONTRACT_PREFIX}${edge.transport.toUpperCase()} contract; runtime target unverified`,
+      updatedAt: result.observedAt,
+    }];
+  }).slice(0, 64);
+}
+
+async function analyze(
+  projectId: string, ids: string[], supplied?: EngineClientLike,
+): Promise<Analysis | undefined> {
+  const client = supplied ?? new EngineClient({
+    socketPath: join(configDir(), "engine.sock"), connectTimeoutMs: 10_000,
+  });
+  try {
+    const result = await client.request({
+      operation: "graph.analyze_project",
+      input: { project_id: projectId, repository_ids: ids },
+    }, { timeoutMs: 120_000 });
+    if (result.operation !== "graph.project_relationships" || result.graph.project_id !== projectId
+      || JSON.stringify(result.graph.repositories.map(item => item.repository_id).sort()) !== JSON.stringify(ids)) {
+      return undefined;
+    }
+    return { graph: result.graph, observedAt: Date.now() };
+  } catch { return undefined; }
+  finally { if (!supplied) client.close(); }
+}
+
+export function mergeRelationshipPeers(
+  current: IntegrationPeer[] | undefined, analyzed: IntegrationPeer[],
+): IntegrationPeer[] {
+  return [
+    ...(current ?? []).filter(peer => !peer.through?.startsWith(STATIC_CONTRACT_PREFIX)),
+    ...analyzed,
+  ].slice(0, 64);
+}

package/apps/bridge/src/engine/runtime/repository-graph-jobs.ts

@@ -56,6 +56,12 @@ export class RepositoryGraphJobs<T> {
     return new Promise(resolve => entry.listeners.push(resolve));
   }
 
+  /** Read a fresh in-memory result without starting or queueing an analysis. */
+  cached(key: string): T | undefined {
+    const entry = this.entries.get(key);
+    return entry && this.now() < entry.retryAt ? entry.value : undefined;
+  }
+
   private admit(priority: number): boolean {
     if (this.queue.length < this.capacity) return true;
     const last = this.queue[this.queue.length - 1];

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

@@ -50,11 +50,14 @@ function taskOrderKey(task: TaskValue): string {
 export function preferExecution(
   current: ExecutionValue,
   incoming: ExecutionValue,
+  preparedOwner = false,
 ): ExecutionValue {
   if ((current.endedAt != null) !== (incoming.endedAt != null)) {
     const ended = current.endedAt != null ? current : incoming;
     const live = current.endedAt != null ? incoming : current;
     if (live.continuedAt != null && live.continuedAt > ended.endedAt!) return live;
+    if (preparedOwner && /^transfer-[a-f0-9]{48}$/.test(live.sessionId)
+      && (live.updatedAt ?? live.startedAt) > ended.endedAt!) return live;
     return { ...live, endedAt: ended.endedAt };
   }
   const currentAt = current.updatedAt ?? current.startedAt;
@@ -78,7 +81,10 @@ export function mayOwnTask(
   sessionId: string,
   executions: readonly ExecutionValue[],
 ): boolean {
-  if (task.ownerSessionId == null || task.ownerSessionId === sessionId) return true;
+  if (task.ownerSessionId === sessionId) return true;
+  const candidate = executions.find(item => item.taskId === task.taskId && item.sessionId === sessionId);
+  if (candidate?.endedAt != null) return false;
+  if (task.ownerSessionId == null) return true;
   const owner = executions.find((item) =>
     item.taskId === task.taskId && item.sessionId === task.ownerSessionId);
   return owner == null || owner.endedAt != null;

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";
+import { localTaskTransfers } from '../../task-transfer';
 export { inspectRepositoryAsync } from "./repository-inspection";
 
 export type RepositoryFacts = {
@@ -122,6 +123,7 @@ export function linkSessionsToProjects(
   inspect: (cwd: string) => RepositoryFacts = inspectRepository,
   formerNames: string[] = formerComputerNames(),
 ): SessionInfo[] {
+  localTaskTransfers().reconcileCatalogOwnership(store, computerId);
   // Records kept under a name this computer used to go by are this computer's
   // leftovers, not a second machine: their executions are over and their
   // bindings unavailable.

package/apps/bridge/src/mesh/runtime/execution-sweep.ts

@@ -27,6 +27,8 @@ export function closeVanished(
     if (execution.computerId !== computerId || execution.endedAt != null) continue;
     // A provider cloud run is never a local chat, so its absence here says nothing.
     if (execution.external) continue;
+    // Prepared aliases are owned by the durable transfer catalog, not a native CLI scan.
+    if (/^transfer-[a-f0-9]{48}$/.test(execution.sessionId)) continue;
     if (!scannedProviders.has(execution.provider)) continue;
     if (liveSessionIds.has(execution.sessionId)) continue;
     execution.endedAt = endedAt;

package/apps/bridge/src/mesh/runtime/graph/README.md

@@ -18,6 +18,13 @@ computer analyzes only its own endpoint bindings. Failed bindings remain visible
 projection and phone refresh use this rule. The graph contains actual Engine
 analysis; unavailable analysis is never synthesized as a successful graph.
 
+After repository analysis, explicit builds request bounded cross-repository
+contract matches from the same admitted bindings. These are projected as shared
+static contracts with an unverified runtime target. Background snapshots reuse
+fresh in-memory results; they do not queue additional multi-repository scans.
+A verified Backbone remains authoritative. Project identities and grants are
+preserved.
+
 Behavior tests: `tests/`, root `tests/graph/graph-binding-sync.test.ts`, and
 `apps/mcp/src/desktop/projection/tests/graph-refresh.test.ts`. The optional
 `engine-selection-live.test.ts` uses `GRANTTAP_ENGINE_TEST_BINARY` to verify the

package/apps/bridge/src/mesh/runtime/graph/analysis.ts

@@ -1,3 +1,4 @@
+import { projectRelationshipPeers, mergeRelationshipPeers } from "../../../engine/runtime/project-relationships";
 import type { RelayClient } from "../../../../../../packages/core/relay-client";
 import type { MeshSnapshot } from "../../../../../../packages/protocol/schema";
 import { projectBackbone, projectRepositoryGraphs, waitForProjectBindingSync } from "../../../engine/runtime/engine-projects";
@@ -17,6 +18,7 @@ type GraphAnalysisDependencies = {
   sync?: typeof refreshLocalGraphBindings;
   backbone: typeof projectBackbone;
   graphs: typeof projectRepositoryGraphs;
+  relationships?: typeof projectRelationshipPeers;
   send: (client: RelayClient, snapshot: MeshSnapshot) => Promise<void>;
   endpoint?: () => string;
   details?: (snapshot: MeshSnapshot) => ReturnType<typeof repositoryDetails>;
@@ -28,6 +30,7 @@ const graphAnalysisDependencies: GraphAnalysisDependencies = {
   sync: refreshLocalGraphBindings,
   backbone: projectBackbone,
   graphs: projectRepositoryGraphs,
+  relationships: projectRelationshipPeers,
   endpoint: computerId,
   details: snapshot => repositoryDetails(snapshot, computerId()),
   send: (client, snapshot) => sendMeshPayload(client, snapshot, "phone", {
@@ -61,6 +64,9 @@ export async function analyzeProjectGraphNow(
     dependencies.graphs(projectId, bindings, { background: false }),
     dependencies.details?.(current),
   ]);
+  const relationships = await dependencies.relationships?.(projectId, bindings, { background: false });
+  const peers = relationships === undefined ? current.peers
+    : mergeRelationshipPeers(current.peers, relationships);
   const observed = [...repositoryGraphs, ...failures];
   const reports = observed.length > 0 ? observed : [{
     projectId, repositoryId: current.project.canonicalRepositoryId,
@@ -71,7 +77,7 @@ export async function analyzeProjectGraphNow(
   const receipts = requestIds?.size ? requestIds : new Set<string | undefined>([undefined]);
   for (const id of receipts) {
     await dependencies.send(client, {
-      ...current, backbone, repositoryGraphs: reports, generatedAt: Date.now(),
+      ...current, backbone, peers, repositoryGraphs: reports, generatedAt: Date.now(),
       ...(details ? { repositoryDetails: details } : {}),
       ...(id ? { graphAnalysisRequestId: id } : {}),
     });

package/apps/bridge/src/mesh/runtime/snapshot/enriched.ts

@@ -1,3 +1,4 @@
+import { projectRelationshipPeers, mergeRelationshipPeers } from "../../../engine/runtime/project-relationships";
 import { refreshLocalGraphBindings } from "../graph/binding-sync";
 import { graphAnalysisBindings } from "../graph/checkout-identity";
 import type { MeshSnapshot } from "../../../../../../packages/protocol/schema";
@@ -33,6 +34,10 @@ export async function enrichMeshSnapshot(
     projectKnowledge(snapshot.projectId),
     repositoryDetails(snapshot, computerId()),
   ]);
+  const relationships = await projectRelationshipPeers(snapshot.projectId, bindings, {
+    background: options.refreshGraph !== true,
+  });
+  const peers = mergeRelationshipPeers(snapshot.peers, relationships);
   const sharedKnowledge = knowledge?.filter((item) => item.visibility === "project");
   if (sharedKnowledge) localMeshStore().cacheKnowledge(snapshot.projectId, sharedKnowledge);
   const memoryRows = new Map((snapshot.knowledge ?? []).map((item) => [item.recordId, item]));
@@ -42,7 +47,7 @@ export async function enrichMeshSnapshot(
     ...(snapshot.supersededKnowledgeRecordIds ?? []),
     ...supersededProjectKnowledgeIds(snapshot.projectId, allMemory),
   ])].sort().slice(-128);
-  const enriched = { ...snapshot, backbone, ...(repositoryGraphs.length || identityFailures.length
+  const enriched = { ...snapshot, backbone, peers, ...(repositoryGraphs.length || identityFailures.length
       ? { repositoryGraphs: [...repositoryGraphs, ...identityFailures] } : {}),
     repositoryDetails: details,
     knowledge: activeProjectKnowledge(snapshot.projectId, allMemory)

package/apps/bridge/src/mesh/snapshot/merge.ts

@@ -4,6 +4,7 @@ import { upsertBinding } from "../catalog/binding-state";
 import { integrationPeerKey } from "../handoff/other-side";
 import { mergeBy, mergeWith } from "../store/support";
 import { MAX_STORE_PEERS, type StoreState } from "../store/state";
+import { preferScopedExecution } from '../store/receipts/execution-merge';
 
 export function mergeSnapshotState(state: StoreState, input: SnapshotValue): void {
   const snapshot = MeshSnapshot.parse(input);
@@ -25,11 +26,12 @@ export function mergeSnapshotState(state: StoreState, input: SnapshotValue): voi
   candidate.peers = mergeBy(candidate.peers, snapshot.peers ?? [], integrationPeerKey)
     .slice(-MAX_STORE_PEERS);
   candidate.tasks = mergeWith(candidate.tasks, snapshot.tasks, (item) => item.taskId, preferTask);
+  candidate.events = mergeBy(candidate.events, snapshot.events, (item) => item.eventId).slice(-512);
   candidate.executions = mergeWith(
     candidate.executions,
     snapshot.executions,
     (item) => `${item.computerId}\0${item.provider}\0${item.sessionId}`,
-    preferExecution,
+    (current, incoming) => preferScopedExecution(candidate, current, incoming),
   );
   candidate.claims = mergeBy(candidate.claims, snapshot.claims, (item) => item.claimId);
   candidate.dependencies = mergeBy(
@@ -37,7 +39,6 @@ export function mergeSnapshotState(state: StoreState, input: SnapshotValue): voi
     snapshot.dependencies,
     (item) => `${item.taskId}\0${item.dependsOnTaskId}`,
   );
-  candidate.events = mergeBy(candidate.events, snapshot.events, (item) => item.eventId).slice(-512);
   for (const incoming of snapshot.knowledge ?? []) {
     const known = candidate.knowledge.find((item) => item.projectId === incoming.projectId
       && item.recordId === incoming.recordId);

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

@@ -28,14 +28,14 @@ import { projectSharedSkills } from "../../capabilities/skills";
 import { loadExecutionPolicy } from "../runtime/execution-policy";
 import { loadEnvironment, redactEnvironment } from "../context/env";
 import { loadRestrictions } from "../restrictions";
-import { MeshStoreBase } from "./base";
+import { MeshPreparedStore } from "./receipts/prepared-availability";
 import { activeProjectKnowledge, supersededProjectKnowledgeIds } from "../knowledge/active";
 import { restoreHandoffResult, validStoredReceipt } from './receipts';
 import {
   projectCapabilityRequests,
 } from "../catalog/project/requests";
 
-export class MeshStore extends MeshStoreBase {
+export class MeshStore extends MeshPreparedStore {
   recordReceipt(input: ReceiptValue): void {
     this.sync();
     const receipt = HandoffReceipt.parse(input);

package/apps/bridge/src/mesh/store/receipts/execution-merge.ts

@@ -0,0 +1,10 @@
+import type { ExecutionSessionLink } from '../../../../../../packages/protocol/schema';
+import { isTerminalTaskState, preferExecution } from '../../admin/convergence';
+import type { StoreState } from '../state';
+
+/** Ownership has already converged before availability; an ended former owner never qualifies. */
+export function preferScopedExecution(state: StoreState, current: ExecutionSessionLink, incoming: ExecutionSessionLink) {
+  const task = state.tasks.find(row => row.taskId === incoming.taskId);
+  const preparedOwner = !!task && !isTerminalTaskState(task.state) && task.ownerSessionId === incoming.sessionId;
+  return preferExecution(current, incoming, preparedOwner);
+}

package/apps/bridge/src/mesh/store/receipts/prepared-availability.ts

@@ -0,0 +1,55 @@
+import type { PreparedTransfer } from '../../../task-transfer';
+import { isTerminalTaskState, nextTaskRevision } from '../../admin/convergence';
+import { MeshStoreBase } from '../base';
+import { validStoredReceipt } from './index';
+import { capsuleHash } from '../../handoff';
+import type { StoreState } from '../state';
+
+/** Repairs only an unstarted, durably accepted local preparation. */
+export class MeshPreparedStore extends MeshStoreBase {
+  reconcilePreparedTransfers(rows: PreparedTransfer[], verify: (row: PreparedTransfer) => boolean): number {
+    this.sync();
+    if (!rows.some(row => repairable(this.state, row))) return 0;
+    const result = this.transact(() => {
+      let repaired = 0;
+      for (const row of rows) {
+        const facts = repairable(this.state, row);
+        if (!facts || !verify(row)) continue;
+        const at = Math.max(this.now(), (facts.destination.endedAt ?? 0) + 1, facts.task.updatedAt);
+        facts.destination.endedAt = undefined;
+        facts.destination.updatedAt = at;
+        facts.task.ownerSessionId = row.sessionId;
+        facts.task.state = 'planned';
+        facts.task.updatedAt = at;
+        facts.task.revision = nextTaskRevision(facts.task);
+        repaired += 1;
+      }
+      return repaired;
+    });
+    return result.applied ? result.value : 0;
+  }
+}
+
+function repairable(state: StoreState, row: PreparedTransfer) {
+  if (row.phase !== 'prepared' || row.nativeSessionId) return undefined;
+  const task = state.tasks.find(item => item.taskId === row.capsule.taskId && item.projectId === row.projectId);
+  if (!task || isTerminalTaskState(task.state)
+    || ![row.sourceSessionId, row.sessionId].includes(task.ownerSessionId ?? '')) return undefined;
+  const destination = state.executions.find(item => item.taskId === task.taskId && item.sessionId === row.sessionId
+    && item.provider === row.capsule.targetProvider && item.computerId === row.capsule.targetComputer
+    && item.workspace === row.workspace && item.startedAt === row.acceptedAt);
+  if (!destination || destination.endedAt == null && task.ownerSessionId === row.sessionId) return undefined;
+  const request = state.events.find(item => item.eventId === row.eventId && item.eventType === 'HANDOFF_REQUEST'
+    && item.taskId === task.taskId && item.projectId === row.projectId && item.sourceSessionId === row.sourceSessionId);
+  if (!request || state.events.some(item => item.taskId === task.taskId && item.eventType === 'HANDOFF_REQUEST'
+    && item.eventId !== row.eventId && item.createdAt >= request.createdAt)) return undefined;
+  const accepted = state.events.find(item => item.eventType === 'HANDOFF_ACCEPTED' && item.taskId === task.taskId
+    && item.projectId === row.projectId && item.sourceSessionId === row.sessionId
+    && item.payload.receipt?.prepared === true && item.payload.receipt.targetSessionId === row.sessionId
+    && item.payload.receipt.sourceSessionId === row.sourceSessionId && item.payload.receipt.acceptedAt >= row.acceptedAt
+    && item.payload.receipt.capsuleHash === capsuleHash(row.capsule));
+  const source = state.executions.find(item => item.taskId === task.taskId && item.sessionId === row.sourceSessionId);
+  if (!accepted || !validStoredReceipt(state, accepted) || !source?.endedAt
+    || source.continuedAt != null && source.continuedAt >= row.acceptedAt) return undefined;
+  return { task, destination };
+}

package/apps/bridge/src/mesh/store/sync.ts

@@ -19,6 +19,7 @@ import type {
   MeshTask as TaskValue,
 } from "../../../../../packages/protocol/schema";
 import { preferExecution, preferTask } from "../admin/convergence";
+import { preferScopedExecution } from './receipts/execution-merge';
 import { integrationPeerKey } from "../handoff/other-side";
 import {
   MAX_RELEASED_CLAIMS, MAX_STORE_MIGRATIONS, MAX_STORE_PEERS, type StoreState,
@@ -115,7 +116,7 @@ export function applyStoreDelta(disk: StoreState, delta: StoreDelta): StoreState
       const key = rowKey(name, item);
       const theirs = rows.get(key);
       const untouched = theirs == null || JSON.stringify(theirs) === before;
-      rows.set(key, untouched ? item : settle(name, theirs, item));
+      rows.set(key, untouched ? item : settle(name, theirs, item, merged as StoreState));
     }
     let items = [...rows.values()];
     const bound = BOUNDS[name];
@@ -125,9 +126,9 @@ export function applyStoreDelta(disk: StoreState, delta: StoreDelta): StoreState
   return merged as StoreState;
 }
 
-function settle(name: Collection, theirs: unknown, ours: unknown): unknown {
+function settle(name: Collection, theirs: unknown, ours: unknown, state: StoreState): unknown {
   if (name === "tasks") return preferTask(theirs as TaskValue, ours as TaskValue);
-  if (name === "executions") return preferExecution(theirs as ExecutionValue, ours as ExecutionValue);
+  if (name === "executions") return preferScopedExecution(state, theirs as ExecutionValue, ours as ExecutionValue);
   if (name === "knowledge") return theirs;
   return ours;
 }

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

@@ -44,6 +44,7 @@ import { requestProjectGraphRefresh } from "../graph-refresh";
 import { handleControllerPairRequest, handleInboundKnowledgeWrite } from "../controller-knowledge";
 import { acceptPhoneAccountLink } from "../../account-recovery/phone-link";
 import { approvalsStatus } from '../../approvals/state';
+import { handleDeliveryReceiptQuery } from '../message-delivery/status-query';
 
 export async function handleMonitorMessage(
   client: RelayClient,
@@ -70,6 +71,8 @@ export async function handleMonitorMessage(
     }
     if (payload.type === "user.message") {
       return handleInboundUserMessage(client, payload, publish, input.peerPublicKey);
+    } else if (payload.type === 'delivery.receipt.query') {
+      return handleDeliveryReceiptQuery(client, payload, input.peerPublicKey);
     } else if (payload.type === "user.attachment") {
       // Ahead of its message, so the message itself travels light.
       return storeAttachment(payload, client.room);

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

@@ -22,7 +22,9 @@ export async function sendDeliveryReceipt(
     receivedAt: Date.now(),
   };
   const options = { ttlMs: 24 * 60 * 60_000, peerPublicKey };
-  await (sessionId
+  // A controller receipt is control-plane state. It remains device-encrypted,
+  // and must not depend on a separately retained task-key grant arriving first.
+  await (sessionId && !peerPublicKey
     ? sendSessionPayload(client, payload, sessionId, "phone", options)
     : client.send(payload, "phone", options)).catch(() => {});
 }

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

@@ -137,7 +137,7 @@ export async function handleUserMessage(
   const resolved = resolveMessageAttachments(message, (attachmentId) => takeAttachment(attachmentId, client.room));
   if (!resolved.ok) {
     if (message.messageId) {
-      await sendDeliveryReceipt(client, message.messageId, "rejected", ATTACHMENT_MISSING_ERROR, message.sessionId);
+      await sendDeliveryReceipt(client, message.messageId, "rejected", ATTACHMENT_MISSING_ERROR, message.sessionId, peerPublicKey);
     }
     return "rejected";
   }

package/apps/bridge/src/monitor/message-delivery/README.md

@@ -16,3 +16,9 @@ This module uses the repository GrantTap Commercial Source License.
 Replies and receipts target the requesting controller. A provider refusal after
 the processing acknowledgement emits a rejected receipt and retains that final
 outcome across ciphertext retries; it never silently turns back into accepted.
+
+`delivery.receipt.query` reads the original durable result without sending a
+message again. Only the original authenticated controller, room, and session
+may read it. Older unscoped records are not exposed through this query.
+Receipts to a known controller use its device encryption directly, so a missed
+task-key grant cannot hide a provider rejection or processing acknowledgement.

package/apps/bridge/src/monitor/message-delivery/index.ts

@@ -14,7 +14,8 @@ export async function handleInboundUserMessage(
   if (payload.requestId) return false;
   let deliveryStarted = false;
   if (payload.messageId) {
-    const state = beginDelivery(payload.messageId);
+    const state = beginDelivery(payload.messageId, Date.now(), payload.sessionId && peerPublicKey
+      ? { room: client.room, sessionId: payload.sessionId, peerPublicKey } : undefined);
     if (state !== "started") {
       if (state === "completed" || processingDeliveryAcknowledged(payload.messageId)) {
         const failure = completedDeliveryFailure(payload.messageId);

package/apps/bridge/src/monitor/message-delivery/status-query.ts

@@ -0,0 +1,12 @@
+import type { RelayClient } from '../../../../../packages/core/relay-client';
+import type { DeliveryReceiptQuery } from '../../../../../packages/protocol/schema';
+import { deliveryReceiptStatus } from '../../delivery';
+import { sendDeliveryReceipt } from '../handlers/receipts';
+
+export async function handleDeliveryReceiptQuery(client: RelayClient, query: DeliveryReceiptQuery,
+  peerPublicKey?: string): Promise<boolean> {
+  if (!peerPublicKey) return true;
+  const receipt = deliveryReceiptStatus(query.messageId, { room: client.room, peerPublicKey, sessionId: query.sessionId });
+  if (receipt) await sendDeliveryReceipt(client, query.messageId, receipt.status, receipt.error, query.sessionId, peerPublicKey);
+  return true;
+}

package/apps/bridge/src/providers/grok-activity/README.md

@@ -0,0 +1,13 @@
+# Native Grok activity
+
+`grokNativeActivity` reads at most 64 KiB of the native structured event log.
+It confirms the active registry PID and OS process start time before treating a
+turn as running. Summary writes alone cannot prove that Grok is idle during a
+long turn. Permission phases remain waiting; completed turns are idle.
+
+The session catalog consumes these observations, and the resume adapter checks
+them again before launching a headless process. A queued phone message waits
+for the current native turn instead of loading the same running session twice.
+No prompt, reasoning, or native event contents are published by this reader.
+
+Licensed under the GrantTap Commercial Source License. See LICENSE and NOTICE.

package/apps/bridge/src/providers/grok-activity/index.ts

@@ -0,0 +1,64 @@
+import { closeSync, openSync, readFileSync, readSync, statSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+type LiveActivity = { state: 'working' | 'waiting' | 'idle'; updatedAt: number };
+
+export function grokResumeActivity(session: { sessionId: string; cwd?: string }): LiveActivity | undefined {
+  if (!session.cwd || !/^[a-zA-Z0-9_-]{1,256}$/.test(session.sessionId)) return undefined;
+  const root = process.env.GRANTTAP_GROK_SESSIONS_DIR
+    ?? join(process.env.GROK_HOME ?? join(homedir(), '.grok'), 'sessions');
+  return grokNativeActivity(session.sessionId, join(root, encodeURIComponent(session.cwd), session.sessionId));
+}
+
+/** Native events, unlike summary.json, advance during a long running turn. */
+export function grokNativeActivity(sessionId: string, directory: string, now = Date.now()): LiveActivity | undefined {
+  const root = process.env.GRANTTAP_GROK_DIR ?? process.env.GROK_HOME ?? join(homedir(), '.grok');
+  const owned = ownedSession(root, sessionId);
+  const lines = tail(join(directory, 'events.jsonl'));
+  for (const line of lines.reverse()) {
+    let row: Record<string, unknown>;
+    try { row = JSON.parse(line); } catch { continue; }
+    const updatedAt = typeof row.ts === 'string' ? Date.parse(row.ts) : NaN;
+    if (!Number.isFinite(updatedAt) || updatedAt > now + 5_000) continue;
+    if (row.type === 'turn_ended') return { state: 'idle', updatedAt };
+    if (row.type === 'turn_started') return owned ? { state: 'working', updatedAt } : undefined;
+    if (row.type !== 'phase_changed') continue;
+    if (row.phase === 'permission_prompt') return owned ? { state: 'waiting', updatedAt } : undefined;
+    if (['waiting_for_model', 'streaming_reasoning', 'streaming_text', 'tool_execution'].includes(String(row.phase))) {
+      return owned ? { state: 'working', updatedAt } : undefined;
+    }
+  }
+  return undefined;
+}
+
+function ownedSession(root: string, sessionId: string): boolean {
+  try {
+    const path = join(root, 'active_sessions.json');
+    if (statSync(path).size > 512_000) return false;
+    const rows = JSON.parse(readFileSync(path, 'utf8'));
+    if (!Array.isArray(rows) || rows.length > 256) return false;
+    const row = rows.find(item => item?.session_id === sessionId);
+    if (!row || !Number.isSafeInteger(row.pid) || row.pid <= 0 || !Number.isFinite(row.pid_start)) return false;
+    process.kill(row.pid, 0);
+    // Grok records microseconds. Match the OS start time so a reused PID cannot hold a Task.
+    const started = Date.parse(execFileSync('ps', ['-p', String(row.pid), '-o', 'lstart='], {
+      encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 500,
+      env: { ...process.env, LC_ALL: 'C' }, maxBuffer: 1_024,
+    }).trim());
+    return Math.abs(started - row.pid_start / 1_000) < 1_000;
+  } catch { return false; }
+}
+
+function tail(path: string): string[] {
+  let fd: number | undefined;
+  try {
+    const size = statSync(path).size, length = Math.min(size, 64 * 1_024);
+    fd = openSync(path, 'r'); const buffer = Buffer.alloc(length);
+    const read = readSync(fd, buffer, 0, length, size - length);
+    const lines = buffer.subarray(0, read).toString('utf8').split('\n');
+    return size > length ? lines.slice(1) : lines;
+  } catch { return []; }
+  finally { if (fd != null) closeSync(fd); }
+}

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

@@ -7,6 +7,7 @@ import type { ReplyResult } from "../payload/types";
 import type { DeliveryOptions } from "../payload/types";
 import { resolveGrokBinary } from "../../providers/grok-bin";
 import { runCursorConversation } from "../cursor-conversation";
+import { grokResumeActivity } from '../../providers/grok-activity';
 
 function grokBin(): string {
   return resolveGrokBinary();
@@ -42,6 +43,10 @@ export function runGrokNew(
 export function runGrokResume(
   session: SessionInfo, text: string, timeoutMs: number, options: DeliveryOptions = {},
 ): Promise<ReplyResult> {
+  const live = grokResumeActivity(session);
+  if (live?.state === 'working' || live?.state === 'waiting') return Promise.resolve({ ok: false,
+    error: live.state === 'working' ? 'Grok is still running a turn in this task. Wait for it to finish, then retry this message.'
+      : 'Grok is waiting for permission in its open task. Resolve that request, then retry this message.' });
   const permission = options.permissionMode === "manual" ? "default" : options.permissionMode;
   const args = [
     "--no-auto-update", ...(session.cwd ? ["--cwd", session.cwd] : []),

package/apps/bridge/src/sessions/scan/grok.ts

@@ -18,6 +18,7 @@ import {
   type Scan,
 } from "../support/common";
 import type { CapabilityObservation } from "../telemetry";
+import { grokNativeActivity } from '../../providers/grok-activity';
 
 type Summary = {
   info?: { id?: unknown; cwd?: unknown };
@@ -170,10 +171,11 @@ export function scanGrok(maxFiles = MAX_FILES): Scan {
     const title = [summary.generated_title, summary.session_summary, parsed.firstUser]
       .find((value): value is string => typeof value === "string" && value.trim().length > 0);
     const cwd = typeof summary.info?.cwd === "string" ? summary.info.cwd : undefined;
+    const live = grokNativeActivity(sessionId, directory);
     sessions.push({
       sessionId, agent: "grok", title: title?.trim().slice(0, 120), cwd,
       model: typeof summary.current_model_id === "string" ? summary.current_model_id : undefined,
-      state: stateFor(updatedAt), startedAt, lastActivityAt: updatedAt,
+      state: live?.state ?? stateFor(updatedAt), startedAt, lastActivityAt: Math.max(updatedAt, live?.updatedAt ?? 0),
       ...(parsed.lastMessageAt ? { lastMessageAt: parsed.lastMessageAt } : {}),
       tokensSession: parsed.tokens, tokensLastTurn: parsed.lastTurn,
       contextTokensUsed: parsed.tokens,

package/apps/bridge/src/task-transfer/README.md

@@ -10,6 +10,13 @@ oversized context refuses preparation instead of silently dropping history.
 A launch is recorded before invoking the provider. An interrupted first launch
 requires inspection and cannot automatically create a second native execution.
 
+Native catalog sweeps never close a prepared alias. The catalog can repair an
+older false closure from the retained accepted receipt and checksummed, unstarted
+preparation. It does not supersede a later transfer, reopen completed work, or
+invent consent to resume the source. Existing Task ownership, the accepted
+receipt, and a newer live observation keep availability through delayed snapshot
+merges without changing the persisted execution format.
+
 Tests: `tests/prepared.test.ts` covers preparation, restart, model/effort forwarding,
 context persistence, stable catalog identity and ambiguous first submissions.
 

package/apps/bridge/src/task-transfer/index.ts

@@ -2,6 +2,7 @@ import type { CodingAgent, SessionInfo, UserAttachment } from '../../../../packa
 import type { DeliveryOptions, ReplyResult } from '../reply';
 import { TransferPersistence } from './persistence';
 import type { PreparedTransfer } from './records';
+import type { MeshStore } from '../mesh/store';
 export type { PreparedTransfer, TransferPreparation } from './records';
 
 type TransferProvider = {
@@ -14,6 +15,12 @@ const interrupted = (): ReplyResult => ({ ok: false,
 
 /** Prepared executions are visible immediately and start only with a person's first message. */
 export class PreparedTaskTransfers extends TransferPersistence {
+  reconcileCatalogOwnership(store: MeshStore, computerId: string): number {
+    return store.reconcilePreparedTransfers(this.records().filter(row => row.capsule.targetComputer === computerId), row => {
+      try { this.readContext(row); return true; } catch { return false; }
+    });
+  }
+
   catalog(native: SessionInfo[]): SessionInfo[] {
     const rows = this.records().map(row => {
       if (row.phase !== 'starting' || ownerAlive(row.ownerPid)) return row;

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.95
+npm install -g granttap-mcp@0.8.97
 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.95\";\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.97\";\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.95";
+const PACKAGE = "granttap-mcp@0.8.97";
 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.95",
+  "version": "0.8.97",
   "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

@@ -110,6 +110,13 @@ export const DeliveryReceipt = z.object({
 });
 export type DeliveryReceipt = z.infer<typeof DeliveryReceipt>;
 
+/** Reads the original operation; it cannot submit or resume a provider turn. */
+export const DeliveryReceiptQuery = z.object({
+  type: z.literal('delivery.receipt.query'), messageId: z.string().min(1).max(180),
+  sessionId: z.string().min(1).max(256), createdAt: z.number().finite(),
+}).strict();
+export type DeliveryReceiptQuery = z.infer<typeof DeliveryReceiptQuery>;
+
 export const AgentEvent = z.object({
   type: z.literal("agent.event"),
   text: z.string(),

package/packages/protocol/schema.ts

@@ -21,6 +21,7 @@ import { CapabilityUsageStatus } from "./messages/capabilities";
 import {
   AgentEvent,
   DeliveryReceipt,
+  DeliveryReceiptQuery,
   MAX_ATTACHMENT_BASE64_CHARS,
   SessionEventsRequest,
   SessionsRefresh,
@@ -130,6 +131,7 @@ export const Payload = z.union([
   HostGrant,
   UserAttachmentUpload,
   DeliveryReceipt,
+  DeliveryReceiptQuery,
   AgentEvent,
   SessionSubscription,
   SessionEventsRequest,