granttap-mcp 0.8.96 → 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/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/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.96
+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.96\";\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.96";
+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.96",
+  "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,