granttap-mcp 0.8.96 → 0.8.98

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

@@ -12,10 +12,14 @@ type DeliveryRecord = {
   state: "processing" | "completed";
   updatedAt: number;
   processingAcknowledged?: boolean;
+  agentActivityAt?: number;
   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,38 +66,56 @@ 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);
 }
 
+/** Provider output, rather than process creation, confirms the original operation started. */
+export function acknowledgeAgentActivity(messageId: string, at = Date.now(), scope?: DeliveryScope): number | undefined {
+  const records = load();
+  const record = records[messageId] ?? (scope
+    ? { state: 'completed' as const, updatedAt: at, processingAcknowledged: true, scope } : undefined);
+  if (!record || record.rejectedError || !Number.isFinite(at) || at <= 0
+    || records[messageId] && scope && !record.scope
+    || scope && record.scope && (scope.room !== record.scope.room
+      || scope.peerPublicKey !== record.scope.peerPublicKey || scope.sessionId !== record.scope.sessionId)) return undefined;
+  if (record.agentActivityAt == null) {
+    records[messageId] = { ...record, agentActivityAt: at };
+    save(records, Date.now());
+  }
+  return records[messageId]?.agentActivityAt;
+}
+
 export function processingDeliveryAcknowledged(messageId: string): boolean {
   const record = load()[messageId];
   return record?.state === "processing" && record.processingAcknowledged === true;
 }
 
 /** 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 +125,16 @@ 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, agentActivityAt: record.agentActivityAt };
+}
+
 /** 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

@@ -12,6 +12,7 @@ export async function sendDeliveryReceipt(
   error?: string,
   sessionId?: string,
   peerPublicKey?: string,
+  agentActivityAt?: number,
 ): Promise<void> {
   const payload = {
     type: "delivery.receipt" as const,
@@ -20,9 +21,12 @@ export async function sendDeliveryReceipt(
     status,
     error,
     receivedAt: Date.now(),
+    ...(agentActivityAt ? { agentActivityAt } : {}),
   };
   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

@@ -21,6 +21,7 @@ import { publishedSession } from "../../session-catalog";
 import { localTaskOrigins, type TaskOriginRegistry, type TaskOriginScope } from '../../task-origins';
 import { agentEventForUserMessage, sendDeliveryReceipt } from "./receipts";
 import { resolveMessageAttachments } from "./receipts";
+import { reportMessageAgentActivity } from '../message-delivery/activity';
 import { acceptWhenStarted, PHONE_RUN_LIMIT_MS } from "../message-delivery/acceptance";
 
 async function startNewAgentTask(input: {
@@ -137,7 +138,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";
   }
@@ -172,6 +173,7 @@ export async function handleUserMessage(
   const startedAt = Date.now();
   const run = deliverToSession(target, message.text, PHONE_RUN_LIMIT_MS, attachments, {
     messageId: message.messageId,
+    onAgentActivity: () => reportMessageAgentActivity(client, message, peerPublicKey),
     preferredMcp: message.preferredMcp,
     skill: message.skill,
     model: message.model,

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

@@ -16,3 +16,13 @@ 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.
+
+A correlated `agentActivityAt` receipt is emitted only after provider stream output
+confirms activity. It is retained under the original controller, room and session
+scope, survives receipt refresh, and does not claim a final response.

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

@@ -0,0 +1,14 @@
+import type { RelayClient } from '../../../../../packages/core/relay-client';
+import type { UserMessage } from '../../../../../packages/protocol/schema';
+import { acknowledgeAgentActivity } from '../../delivery';
+import { sendDeliveryReceipt } from '../handlers/receipts';
+
+/** The provider stream confirms activity for one authenticated original operation. */
+export function reportMessageAgentActivity(client: RelayClient, message: UserMessage, peerPublicKey?: string): void {
+  if (!message.messageId || !message.sessionId || !peerPublicKey) return;
+  const at = acknowledgeAgentActivity(message.messageId, Date.now(), {
+    room: client.room, sessionId: message.sessionId, peerPublicKey,
+  });
+  if (at) void sendDeliveryReceipt(client, message.messageId, 'accepted', undefined,
+    message.sessionId, peerPublicKey, at);
+}

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

@@ -1,7 +1,7 @@
 import type { Payload } from "../../../../../packages/protocol/schema";
 import type { RelayClient } from "../../../../../packages/core/relay-client";
 import { abandonDelivery, beginDelivery, completeDelivery,
-  acknowledgeProcessingDelivery, processingDeliveryAcknowledged, completedDeliveryFailure } from "../../delivery";
+  acknowledgeProcessingDelivery, processingDeliveryAcknowledged, completedDeliveryFailure, deliveryReceiptStatus } from "../../delivery";
 import { sendDeliveryReceipt } from "../handlers/receipts";
 import { handleUserMessage } from "../handlers/user-message";
 
@@ -14,12 +14,15 @@ 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);
         await sendDeliveryReceipt(client, payload.messageId, failure ? 'rejected' : 'accepted',
-          failure, payload.sessionId, peerPublicKey);
+          failure, payload.sessionId, peerPublicKey, peerPublicKey && payload.sessionId
+            ? deliveryReceiptStatus(payload.messageId, { room: client.room, peerPublicKey,
+              sessionId: payload.sessionId })?.agentActivityAt : undefined);
       }
       return true;
     }

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, receipt.agentActivityAt);
+  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/index.ts

@@ -65,9 +65,15 @@ export function deliverToSession(
   if (/^transfer-[a-f0-9]{48}$/.test(session.sessionId)) {
     return queued(session.sessionId, async () => (await localTaskTransfers().deliver(
       session.sessionId, text, attachments, options, {
-        start: request => ({ claude: createClaudeSession, codex: createCodexSession,
-          cursor: createCursorSession, grok: createGrokSession }[request.provider])(
-          request.text, request.cwd, timeoutMs, request.attachments, request.model, request.operationKey, request.effort),
+        start: request => request.provider === "grok"
+          ? createGrokSession(request.text, request.cwd, timeoutMs, request.attachments,
+            request.model, request.operationKey, request.effort, nativeId => {
+              request.onNativeSession(nativeId);
+              options.onAgentActivity?.(nativeId);
+            })
+          : ({ claude: createClaudeSession, codex: createCodexSession,
+            cursor: createCursorSession }[request.provider])(request.text, request.cwd,
+            timeoutMs, request.attachments, request.model, request.operationKey, request.effort),
         resume: (native, body, images, settings) => withAttachments(images, body, prepared => runDelivery(native,
           native.agent === "codex" ? prepared.prompt : prepared.claudePrompt, timeoutMs, prepared.images, settings)),
       },
@@ -139,10 +145,11 @@ export function createGrokSession(
   model?: string,
   operationKey?: string,
   effort?: string,
+  onNativeSession?: (sessionId: string) => void,
 ): Promise<ReplyResult> {
   const workspace = resolveAgentWorkspace(cwd, "grok");
   return queued("__new_grok_task__", () => withAttachments(attachments, text, (prepared) =>
-    runGrokNew(prepared.claudePrompt, workspace, timeoutMs, model, operationKey, effort),
+    runGrokNew(prepared.claudePrompt, workspace, timeoutMs, model, operationKey, effort, onNativeSession),
   ));
 }
 

package/apps/bridge/src/reply/payload/types.ts

@@ -3,6 +3,8 @@ export type ReplyResult =
   | { ok: false; error: string; delivery?: 'native' };
 
 export type DeliveryOptions = {
+  /** Called only after provider output confirms this operation has started. */
+  onAgentActivity?: (nativeSessionId: string) => void;
   /** Stable controller delivery ID, also used by the provider's native admission. */
   messageId?: string;
   /** Computer-generated identity before temporary attachment paths are inserted. */

package/apps/bridge/src/reply/process/index.ts

@@ -74,6 +74,7 @@ export function runningProcessCount(key: string): number {
 
 export type ProviderAdmission = {
   confirmed: (stdout: string) => boolean;
+  onConfirmed?: () => void;
   withinMs: number;
   timeoutMessage: string;
 };
@@ -107,6 +108,7 @@ export function runProcess(
     let stdout = "";
     let stderr = "";
     let done = false;
+    let admissionReported = false;
     const finish = (result: ReplyResult): void => {
       if (done) return;
       done = true;
@@ -125,7 +127,17 @@ export function runProcess(
       signalOwnedProcess(child, "SIGKILL");
       finish({ ok: false, error: admission.timeoutMessage });
     }, admission.withinMs) : undefined;
-    child.stdout?.on("data", (chunk) => { stdout += chunk; });
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+      if (done || admissionReported || !admission?.confirmed(stdout)) return;
+      admissionReported = true;
+      clearTimeout(startupTimer);
+      try { admission.onConfirmed?.(); }
+      catch {
+        signalOwnedProcess(child, "SIGTERM");
+        finish({ ok: false, error: "Provider activity could not be recorded safely.", delivery: "native" });
+      }
+    });
     child.stderr?.on("data", (chunk) => { stderr += chunk; });
     child.on("error", (error) => {
       finish({ ok: false, error: `${command}: ${error.message}` });

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();
@@ -28,6 +29,7 @@ export async function runCursorResume(
 
 export function runGrokNew(
   text: string, cwd: string, timeoutMs: number, model?: string, operationKey?: string, effort?: string,
+  onNativeSession?: (sessionId: string) => void,
 ): Promise<ReplyResult> {
   const sessionId = randomUUID();
   const args = [
@@ -36,12 +38,16 @@ export function runGrokNew(
     "-p", text, "--output-format", "streaming-json",
   ];
   return runProcess(grokBin(), args, cwd, timeoutMs, (stdout) => parseGrok(stdout, sessionId),
-    undefined, operationKey, grokAdmission);
+    undefined, operationKey, { ...grokAdmission, onConfirmed: () => onNativeSession?.(sessionId) });
 }
 
 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] : []),
@@ -53,6 +59,7 @@ export function runGrokResume(
   return runProcess(
     grokBin(), args, session.cwd, timeoutMs,
     (stdout) => parseGrok(stdout, session.sessionId),
-    undefined, session.sessionId, grokAdmission,
+    undefined, session.sessionId, { ...grokAdmission,
+      onConfirmed: () => options.onAgentActivity?.(session.sessionId) },
   );
 }

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,7 +10,18 @@ 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.
 
 Licensed under the GrantTap Commercial Source License. See LICENSE and NOTICE.
+
+The first Grok turn binds its confirmed native session before the final answer,
+so the transferred Task can publish live native history while the turn runs.
+The durable launch remains in progress and cannot start another execution.

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

@@ -2,11 +2,12 @@ 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 = {
   start: (request: { provider: CodingAgent; text: string; cwd: string; attachments: UserAttachment[];
-    model?: string; effort?: string; operationKey: string }) => Promise<ReplyResult>;
+    model?: string; effort?: string; operationKey: string; onNativeSession: (sessionId: string) => void }) => Promise<ReplyResult>;
   resume: (session: SessionInfo, text: string, attachments: UserAttachment[], options: DeliveryOptions) => Promise<ReplyResult>;
 };
 const interrupted = (): ReplyResult => ({ ok: false,
@@ -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;
@@ -61,7 +68,17 @@ export class PreparedTaskTransfers extends TransferPersistence {
       ownsLaunch = true;
       const result = await provider.start({ provider: row.capsule.targetProvider as CodingAgent,
         text: this.prompt(row, context, text), cwd: row.workspace, attachments,
-        model: options.model ?? row.capsule.targetModel, effort: options.effort, operationKey: id });
+        model: options.model ?? row.capsule.targetModel, effort: options.effort, operationKey: id,
+        onNativeSession: nativeId => {
+          if (!/^[a-zA-Z0-9_-]{1,256}$/.test(nativeId)) throw new Error('Invalid native session identity');
+          this.update(id, current => {
+            if (current.phase !== 'starting' || current.ownerPid !== process.pid
+              || current.nativeSessionId && current.nativeSessionId !== nativeId) {
+              throw new Error('The transfer no longer owns this provider launch');
+            }
+            return { ...current, nativeSessionId: nativeId, updatedAt: Date.now() };
+          });
+        } });
       if (!result.ok || !result.sessionId) {
         this.update(id, current => ({ ...current, phase: 'uncertain', updatedAt: Date.now() }));
         return result.ok ? interrupted() : result;

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.98
 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.98\";\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.98";
 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.98",
   "description": "Commercial computer runtime connecting local coding agents to GrantTap on Mac, iPhone, iPad and Apple Watch.",
   "type": "module",
   "bin": {

package/packages/core/outbound-scheduler/index.ts

@@ -71,9 +71,9 @@ export class OutboundFrameQueue {
   }
 }
 
-const control = (type: Payload["type"]) => type === "hello" || type.startsWith("approval.")
+export const priorityControlPayload = (type: Payload["type"]) => type === "hello" || type.startsWith("approval.")
   || type.startsWith("config.") || type.startsWith("pairing.") || type === "session.key.grant"
-  || type === "sessions.status" || type === "machine.heartbeat" || type === "approvals.status";
+  || type === "delivery.receipt" || type === "sessions.status" || type === "machine.heartbeat" || type === "approvals.status";
 
 export async function sendEncryptedPayload(queue: OutboundFrameQueue, config: PeerConfig,
   allowed: (key: string) => boolean,
@@ -83,6 +83,6 @@ export async function sendEncryptedPayload(queue: OutboundFrameQueue, config: Pe
   if (!peers.length) throw new Error("no authorized pairing peers");
   for (const peerPublicKey of peers) {
     await queue.send(sealEnvelope({ ...config, peerPublicKey }, payload, to,
-      peers.length === 1 ? options : { ...options, deliveryId: undefined }), control(payload.type) || options.wake === true);
+      peers.length === 1 ? options : { ...options, deliveryId: undefined }), priorityControlPayload(payload.type) || options.wake === true);
   }
 }

package/packages/core/relay-client.ts

@@ -2,7 +2,7 @@ import { retainedPayloadOptions } from "./retained-state";
 /** Shared authenticated relay transport. See README.md for delivery and encryption boundaries. */
 import WebSocket from "ws";
 import { ManagedRelayLease, RelaySocketHealth, RelayReconnectBackoff, RelayConnectionNotifications, relayUpgradeHeaders } from "./socket-lifecycle";
-import { OutboundFrameQueue, sendEncryptedPayload } from "./outbound-scheduler";
+import { OutboundFrameQueue, sendEncryptedPayload, priorityControlPayload } from "./outbound-scheduler";
 import { openRelayMessage, parseRelayControl, waitForRelayPayload } from "./relay-inbound";
 import { consumeTaskJobOffer, type TaskDispatchListener } from "./task-dispatch";
 import { Payload, type Role } from "../protocol/schema";
@@ -213,7 +213,8 @@ export class RelayClient {
     if (!peerPublicKeys(this.cfg.peerPublicKey, this.cfg.extraPeerPublicKeys).includes(peerPublicKey)
       || !this.peerIsAllowed(peerPublicKey)) throw new Error("controller peer is not authorized");
     if (!this.frames) throw new Error("relay not connected");
-    await this.frames.send(sealEnvelope({ ...this.cfg, peerPublicKey }, payload, this.otherRole(), { ...retainedPayloadOptions(payload), ...options, retainedState: this.retainedState, recipientRouting: this.recipientRouting }), true);
+    await this.frames.send(sealEnvelope({ ...this.cfg, peerPublicKey }, payload, this.otherRole(), { ...retainedPayloadOptions(payload), ...options, retainedState: this.retainedState, recipientRouting: this.recipientRouting }),
+      priorityControlPayload(payload.type) || options.wake === true);
   }
 
   setSessionKey(sessionId: string, key: string): void {

package/packages/core/socket-lifecycle/README.md

@@ -21,3 +21,7 @@ Consumers can immediately replace stale snapshots; notification failures cannot
 interrupt the transport, and unsubscribing prevents later callbacks.
 
 Licensed under the GrantTap Commercial Source License in the repository root.
+
+Controller-addressed history uses the snapshot queue. Delivery receipts and
+heartbeats use the control queue, so a history download cannot put them behind
+its pending frames. An in-flight WebSocket frame is allowed to finish.

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

@@ -107,9 +107,17 @@ export const DeliveryReceipt = z.object({
   status: z.enum(["accepted", "rejected"]),
   error: z.string().max(500).optional(),
   receivedAt: z.number(),
+  agentActivityAt: z.number().finite().positive().optional(),
 });
 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,