granttap-mcp 0.8.74 → 0.8.75

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

@@ -67,7 +67,7 @@ export async function handleMonitorMessage(
       return handleInboundKnowledgeWrite(client, payload, input.peerPublicKey, publish);
     }
     if (payload.type === "user.message") {
-      return handleInboundUserMessage(client, payload, publish);
+      return handleInboundUserMessage(client, payload, publish, 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/user-message.ts

@@ -17,6 +17,7 @@ import { evaluateCreateTask } from "../../mesh/tasks/create-task";
 import { sendSessionPayload } from "../../host/session-keys";
 import { scanSessions } from "../../sessions";
 import { publishedSession } from "../../session-catalog";
+import { localTaskOrigins, type TaskOriginRegistry, type TaskOriginScope } from '../../task-origins';
 import { agentEventForUserMessage, sendDeliveryReceipt } from "./receipts";
 import { resolveMessageAttachments } from "./receipts";
 import { acceptWhenStarted, PHONE_RUN_LIMIT_MS } from "../message-delivery/acceptance";
@@ -26,6 +27,7 @@ async function startNewAgentTask(input: {
   message: UserMessage;
   say: (text: string, sessionId?: string, wake?: boolean, kind?: "status" | "response") => Promise<unknown>;
   onProcessing?: () => Promise<void>;
+  origin?: { registry: TaskOriginRegistry; scope: TaskOriginScope };
 }): Promise<"accepted" | "rejected"> {
   const { client, message, say } = input;
   const agent = message.agent ?? "codex";
@@ -60,7 +62,19 @@ async function startNewAgentTask(input: {
     }
     return "rejected";
   }
-  await input.onProcessing?.();
+  const admission = input.origin?.registry.begin(input.origin.scope,
+    { ...message, attachments: resolved.attachments, attachmentRefs: undefined });
+  if (admission && admission.state !== 'started') {
+    await say(admission.state === 'ready' ? 'This task has already been created.'
+      : 'The original task is being created or needs confirmation before it can be retried.',
+      admission.sessionId, false, 'status');
+    return ['ready', 'waiting'].includes(admission.state) ? 'accepted' : 'rejected';
+  }
+  try { await input.onProcessing?.(); }
+  catch (error) {
+    if (input.origin) input.origin.registry.abandonBeforeStart(input.origin.scope);
+    throw error;
+  }
   await say(`Creating a new ${displayName} task…`, undefined, false, "status");
   const create = {
     claude: createClaudeSession,
@@ -68,13 +82,25 @@ async function startNewAgentTask(input: {
     cursor: createCursorSession,
     grok: createGrokSession,
   }[agent];
-  const run = create(
-    message.text, requestedCwd, PHONE_RUN_LIMIT_MS, resolved.attachments, message.model, undefined, message.effort,
-  );
-  const settle = (result: ReplyResult, late: boolean) => result.ok
-    ? say(result.text, result.sessionId, true)
-    : say(late ? `The ${displayName} task stopped: ${result.error}`
-      : `Could not create a ${displayName} task: ${result.error}`, undefined, true);
+  let run: Promise<ReplyResult>;
+  try {
+    run = create(message.text, requestedCwd, PHONE_RUN_LIMIT_MS, resolved.attachments,
+      message.model, undefined, message.effort).catch(() => {
+      input.origin?.registry.complete(input.origin.scope, { ok: true });
+      return { ok: false, error: 'The provider task stopped unexpectedly.' } as ReplyResult;
+    });
+  } catch {
+    input.origin?.registry.complete(input.origin.scope, { ok: false });
+    await say(`Could not create a ${displayName} task on this computer.`, undefined, true);
+    return 'rejected';
+  }
+  const settle = (result: ReplyResult, late: boolean) => {
+    input.origin?.registry.complete(input.origin.scope,
+      { ok: result.ok, sessionId: result.ok ? result.sessionId : undefined });
+    return result.ok ? say(result.text, result.sessionId, true)
+      : say(late ? `The ${displayName} task stopped: ${result.error}`
+        : `Could not create a ${displayName} task: ${result.error}`, undefined, true);
+  };
   const early = await acceptWhenStarted(run, (result) => settle(result, true));
   if (early === "started") return "accepted";
   await settle(early, false);
@@ -85,6 +111,7 @@ export async function handleUserMessage(
   client: RelayClient,
   message: UserMessage,
   onProcessing?: () => Promise<void>,
+  peerPublicKey?: string,
 ): Promise<"accepted" | "rejected"> {
   const say = (text: string, sessionId?: string, wake = false, kind: "status" | "response" = "response") => {
     const payload = agentEventForUserMessage(message, text, sessionId, kind);
@@ -94,7 +121,11 @@ export async function handleUserMessage(
       : client.send(payload, "phone", options)).catch(() => {});
   };
   if (!message.sessionId) {
-    return startNewAgentTask({ client, message, say, onProcessing });
+    const origin = message.taskOriginId && peerPublicKey ? {
+      registry: localTaskOrigins(),
+      scope: { room: client.room, peerPublicKey, originMessageId: message.taskOriginId },
+    } : undefined;
+    return startNewAgentTask({ client, message, say, onProcessing, origin });
   }
   const resolved = resolveMessageAttachments(message, (attachmentId) => takeAttachment(attachmentId, client.room));
   if (!resolved.ok) {

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

@@ -9,6 +9,7 @@ import { handleUserMessage } from "../handlers/user-message";
 export async function handleInboundUserMessage(
   client: RelayClient, payload: Extract<Payload, { type: "user.message" }>,
   publish: (forceHistory?: boolean) => Promise<void>,
+  peerPublicKey?: string,
 ): Promise<boolean> {
   if (payload.requestId) return false;
   let deliveryStarted = false;
@@ -27,7 +28,7 @@ export async function handleInboundUserMessage(
       if (!payload.messageId) return;
       acknowledgeProcessingDelivery(payload.messageId);
       await sendDeliveryReceipt(client, payload.messageId, "accepted", undefined, payload.sessionId);
-    });
+    }, peerPublicKey);
     if (payload.messageId && deliveryStarted) {
       if (outcome === "rejected") abandonDelivery(payload.messageId);
       else {

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

@@ -27,6 +27,7 @@ import { scanCapabilityUsage, scanSessionHistory, scanSessions, scopeCapabilityU
 import { boundedCatalogHistory, INTERVAL_MS, publishSessionEvents } from "../handlers/catalog";
 import { sweepAttachments } from "../handlers/receipts";
 import { handleMonitorMessage } from "../handlers/inbound";
+import { decorateTaskOriginCatalog } from '../../task-origins';
 
 const HISTORY_INTERVAL_MS = 60_000;
 const resumedHeads = new WeakSet<RelayClient>();
@@ -124,7 +125,8 @@ async function publishMonitorTick(input: {
   if (!leadership.acquire()) return { lastHistoryPublishedAt, lastCapabilityPublishedAt };
   const initial = lastHistoryPublishedAt === 0;
   const includeHistory = forceHistory || (!initial && Date.now() - lastHistoryPublishedAt >= HISTORY_INTERVAL_MS);
-  const status = monitorSnapshot({ includeHistory, forceHistory, subscriptions, history });
+  const status = decorateTaskOriginCatalog(
+    monitorSnapshot({ includeHistory, forceHistory, subscriptions, history }), client.room);
   rememberPublishedCatalog(client, status);
   await client.send(status, "phone", { ttlMs: INTERVAL_MS * 24, reliable: false });
   if (initial && !resumedHeads.has(client)) {

package/apps/bridge/src/task-dispatch/worker/index.ts

@@ -12,8 +12,10 @@ export type WorkerOptions = {
   onTerminal?: (job: TaskDispatch) => void;
   onError?: () => void;
   connected: () => boolean; authorized: (peer: string) => boolean;
-  ready: (job: TaskDispatch) => boolean;
-  deliver: (job: TaskDispatch, beforeStart: () => Promise<void>) => Promise<'accepted' | 'rejected'>;
+  conversationKey?: (job: TaskDispatch, peer: string) => string;
+  validationCode?: (job: TaskDispatch, peer: string) => string | undefined;
+  ready: (job: TaskDispatch, peer: string) => boolean;
+  deliver: (job: TaskDispatch, beforeStart: () => Promise<void>, peer: string) => Promise<'accepted' | 'rejected'>;
 };
 class DeferredLaunch extends Error {}
 
@@ -31,7 +33,8 @@ export class TaskDispatchWorker {
         || a.job.createdAt - b.job.createdAt);
     for (const record of records) {
       if (['completed', 'cancelled'].includes(record.phase) || this.active.has(record.job.jobId)) continue;
-      const key = record.job.sessionId ?? `new:${record.job.operation.agent ?? 'codex'}`;
+      const key = this.options.conversationKey?.(record.job, record.peerPublicKey)
+        ?? record.job.sessionId ?? `new:${record.job.operation.agent ?? 'codex'}`;
       if (this.conversations.has(key)) continue;
       this.conversations.add(key);
       const work = this.process(record).catch(() => { this.options.onError?.(); }).finally(() => {
@@ -71,8 +74,11 @@ export class TaskDispatchWorker {
       inbox.transition(job.jobId, 'failed', { code: 'already_finished' });
       inbox.transition(job.jobId, 'completed'); inbox.retire(job.jobId); return;
     }
-    if (job.notBefore > Date.now() || !this.options.ready(job)) return;
+    if (job.notBefore > Date.now()) return;
     if (!this.options.authorized(record.peerPublicKey)) return this.reject(record, 'policy_denied');
+    const validation = this.options.validationCode?.(job, record.peerPublicKey);
+    if (validation) return this.reject(record, validation);
+    if (!this.options.ready(job, record.peerPublicKey)) return;
     let started = false;
     try {
       const outcome = await this.options.deliver(job, async () => {
@@ -85,7 +91,7 @@ export class TaskDispatchWorker {
           throw new DeferredLaunch();
         }
         started = true;
-      });
+      }, record.peerPublicKey);
       if (!started) { if (outcome === 'rejected') await this.reject(record, 'policy_denied'); return; }
       inbox.transition(job.jobId, outcome === 'accepted' ? 'delivered' : 'failed',
         outcome === 'rejected' ? { code: 'delivery_failed' } : {});

package/apps/bridge/src/task-dispatch/worker/monitor.ts

@@ -10,6 +10,7 @@ import { TaskDispatchWorker } from './index';
 import { relayTaskJobRemote } from './remote';
 import { NativeTaskQueueSender } from '../sender';
 import { queuedCatalogRefreshDue, taskDispatchReady } from './readiness';
+import { localTaskOrigins, resolveTaskOriginJob } from '../../task-origins';
 
 /** Only the persistent monitor advertises durable submission capability. */
 export function startTaskDispatchMonitor(input: {
@@ -17,6 +18,9 @@ export function startTaskDispatchMonitor(input: {
   peerAllowed: (peer: string) => boolean; publish: () => Promise<void>;
 }): () => void {
   const inbox = new TaskDispatchInbox(join(configDir(), 'task-dispatch'), input.config.room);
+  const origins = localTaskOrigins();
+  const resolve = (job: Parameters<typeof resolveTaskOriginJob>[1], peer: string) =>
+    resolveTaskOriginJob(origins, job, input.config.room, peer);
   let stopped = false, reportedAt = 0, maintainedAt = 0, refreshedAt = 0;
   const sender = new NativeTaskQueueSender({ root: join(configDir(), 'native-task-queue'), config: input.config });
   const peerAllowed = (peer: string) => peer === input.config.myPublicKey || input.peerAllowed(peer);
@@ -25,7 +29,17 @@ export function startTaskDispatchMonitor(input: {
     authorized: peerAllowed,
     onTerminal: job => sender.confirmReceiverOutcome(job),
     onError: () => reportFailure(),
-    ready: job => {
+    conversationKey: (job, peer) => resolve(job, peer).job?.sessionId
+      ?? (job.operation.type === 'user.message.continue'
+        ? JSON.stringify([peer, job.operation.originMessageId]) : `new:${job.operation.agent ?? 'codex'}`),
+    validationCode: (job, peer) => {
+      const state = resolve(job, peer).state;
+      return state === 'uncertain' ? 'confirmation_required'
+        : state === 'failed' ? 'delivery_failed' : state === 'conflict' ? 'policy_denied' : undefined;
+    },
+    ready: (original, peer) => {
+      const job = resolve(original, peer).job;
+      if (!job) return false;
       const catalog = publishedCatalog(input.client);
       const session = [...(catalog?.sessions ?? []), ...(catalog?.history ?? [])]
         .find(item => item.sessionId === job.sessionId);
@@ -39,9 +53,11 @@ export function startTaskDispatchMonitor(input: {
       }
       return ready;
     },
-    deliver: async (job, beforeStart) => {
+    deliver: async (original, beforeStart, peer) => {
+      const job = resolve(original, peer).job;
+      if (!job || job.operation.type === 'user.message.continue') return 'rejected';
       const outcome = job.operation.type === 'user.message'
-        ? await handleUserMessage(input.client, job.operation, beforeStart)
+        ? await handleUserMessage(input.client, job.operation, beforeStart, peer)
         : (await handleTaskCreate(input.client, job.operation, beforeStart)).status;
       void input.publish().catch(() => {});
       return outcome;

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

@@ -0,0 +1,22 @@
+# Native task origins
+
+Public entry: `index.ts`. The receiver records the authenticated controller,
+room and original message before starting a native task. A completed native
+creation supplies the session ID. A continuation never supplies or invents it.
+
+Private records contain a request digest and routing metadata, never prompt
+text or attachments. Atomic, flushed writes and a process lock preserve the
+mapping across restarts. An interrupted owner, corrupt record, changed request
+or missing native ID cannot authorize another new task.
+
+Tests live in `tests/`. Origin lookup does not bypass normal provider, pause,
+Project or controller authorization.
+
+Only clients that opt into origin registration change creation behavior.
+Transport timestamps and retries keep one origin. A definite failure can be
+retried with a new explicit controller retry generation; an interrupted or
+unknown native attempt requires confirmation instead of automatic replay.
+
+## License
+
+Licensed under the Apache License, Version 2.0 (Apache-2.0). See LICENSE and NOTICE.

package/apps/bridge/src/task-origins/continuation.ts

@@ -0,0 +1,14 @@
+import type { TaskDispatch } from '../../../../packages/protocol/schema';
+import type { TaskOriginRegistry } from './index';
+
+export function resolveTaskOriginJob(registry: TaskOriginRegistry, job: TaskDispatch,
+  room: string, peerPublicKey: string): { state: string; job?: TaskDispatch } {
+  if (job.operation.type !== 'user.message.continue') return { state: 'ready', job };
+  const origin = registry.lookup({ room, peerPublicKey, originMessageId: job.operation.originMessageId },
+    job.operation.agent, job.operation.projectId);
+  if (origin.state !== 'ready') return { state: origin.state };
+  const { originMessageId: _origin, type: _type, ...message } = job.operation;
+  return { state: 'ready', job: { ...job, sessionId: origin.sessionId,
+    operation: { ...message, type: 'user.message', sessionId: origin.sessionId,
+      projectId: origin.projectId } } };
+}

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

@@ -0,0 +1,139 @@
+import { mkdirSync, unlinkSync, readdirSync, statSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { z } from 'zod';
+import type { UserMessage } from '../../../../packages/protocol/schema';
+import { withStoreLock } from '../../../../packages/core/store-file-lock';
+import { fingerprint, readOrigin, syncDirectory, writeOrigin } from './storage';
+import { configDir } from '../config';
+export { resolveTaskOriginJob } from './continuation';
+export { decorateTaskOriginCatalog } from './projection';
+
+const Scope = z.object({ room: z.string().min(1).max(180), peerPublicKey: z.string().min(1).max(180),
+  originMessageId: z.string().min(1).max(180) }).strict();
+export type TaskOriginScope = z.infer<typeof Scope>;
+const Record = z.object({ scope: Scope, digest: z.string().length(64),
+  agent: z.enum(['codex', 'claude', 'cursor', 'grok']), projectId: z.string().optional(),
+  phase: z.enum(['creating', 'ready', 'failed', 'uncertain']),
+  owner: z.number().int().positive(), createdAt: z.number().finite(), expiresAt: z.number().finite(),
+  lastRetryId: z.string().optional(),
+  sessionId: z.string().min(1).max(180).optional() }).strict();
+type OriginRecord = z.infer<typeof Record>;
+export type OriginResolution = { state: 'started' | 'waiting' | 'ready' | 'failed' | 'uncertain' | 'conflict';
+  sessionId?: string; projectId?: string };
+
+/** Only a native creation result can resolve this controller's original message to a chat. */
+export class TaskOriginRegistry {
+  private readonly catalogCache = new Map<string, { version: string; record: OriginRecord }>();
+  private readonly now: () => number;
+  private readonly ownerAlive: (pid: number) => boolean;
+  constructor(private readonly root: string, options: {
+    now?: () => number; ownerAlive?: (pid: number) => boolean;
+  } = {}) {
+    this.now = options.now ?? Date.now;
+    this.ownerAlive = options.ownerAlive ?? (pid => {
+      try { process.kill(pid, 0); return true; }
+      catch (error) { return (error as NodeJS.ErrnoException).code !== 'ESRCH'; }
+    });
+  }
+
+  begin(scope: TaskOriginScope, message: UserMessage): OriginResolution {
+    mkdirSync(this.root, { recursive: true, mode: 0o700 });
+    syncDirectory(dirname(this.root));
+    const { createdAt: _time, retryId: _retry, ...intent } = message;
+    const path = this.path(scope), digest = fingerprint(intent);
+    return withStoreLock(path, () => {
+      const existing = this.read(scope);
+      if (existing) {
+        if (existing.digest !== digest) return { state: 'conflict' };
+        if (existing.phase !== 'failed' || !message.retryId || message.retryId === existing.lastRetryId) {
+          return this.resolve(existing, message.agent ?? 'codex', message.projectId);
+        }
+      }
+      const record = Record.parse({ scope, digest, agent: message.agent ?? 'codex',
+        projectId: message.projectId, phase: 'creating', owner: process.pid,
+        lastRetryId: message.retryId,
+        createdAt: this.now(),
+        expiresAt: this.now() + 37 * 86_400_000 });
+      writeOrigin(path, record);
+      return { state: 'started' };
+    });
+  }
+
+  complete(scope: TaskOriginScope, result: { ok: boolean; sessionId?: string }): void {
+    const path = this.path(scope);
+    withStoreLock(path, () => {
+      const record = this.read(scope);
+      if (!record || record.owner !== process.pid) throw new Error('Task origin owner mismatch');
+      if (record.phase !== 'creating') return;
+      const candidate = result.sessionId?.trim();
+      const sessionId = candidate && candidate.length <= 180 ? candidate : undefined;
+      const phase = !result.ok ? 'failed' : sessionId ? 'ready' : 'uncertain';
+      writeOrigin(path, Record.parse({ ...record, phase, sessionId }));
+    });
+  }
+
+  /** Only a creation that never reached its native invocation may release its reservation. */
+  abandonBeforeStart(scope: TaskOriginScope): void {
+    const path = this.path(scope);
+    withStoreLock(path, () => {
+      const record = this.read(scope);
+      if (record?.owner !== process.pid || record.phase !== 'creating') return;
+      unlinkSync(path);
+      syncDirectory(this.root);
+    });
+  }
+
+  lookup(scope: TaskOriginScope, agent: string, projectId?: string): OriginResolution {
+    const record = this.read(scope);
+    return record ? this.resolve(record, agent, projectId) : { state: 'waiting' };
+  }
+
+  readyInRoom(room: string) {
+    return readdirSync(this.root).filter(name => /^[a-f0-9]{64}\.json$/.test(name)).sort().flatMap(name => {
+      try {
+        const path = join(this.root, name), stat = statSync(path);
+        const version = `${stat.ino}:${stat.size}:${stat.mtimeMs}`;
+        const cached = this.catalogCache.get(path);
+        const record = cached?.version === version ? cached.record : Record.parse(readOrigin(path));
+        if (this.path(record.scope) !== path) return [];
+        this.catalogCache.set(path, { version, record });
+        if (record.scope.room !== room || record.phase !== 'ready' || !record.sessionId
+            || record.expiresAt <= this.now()) return [];
+        return [{ sessionId: record.sessionId, agent: record.agent, projectId: record.projectId,
+          originId: record.scope.originMessageId, controllerPublicKey: record.scope.peerPublicKey }];
+      } catch { return []; }
+    });
+  }
+
+  private resolve(record: OriginRecord, agent: string, projectId?: string): OriginResolution {
+    if (record.agent !== agent || (projectId !== undefined && projectId !== record.projectId)) {
+      return { state: 'conflict' };
+    }
+    if (record.expiresAt <= this.now()) return { state: 'uncertain' };
+    if (record.phase === 'creating') {
+      const withinRunLimit = this.now() - record.createdAt <= 6 * 3_600_000 + 60_000;
+      return { state: withinRunLimit && this.ownerAlive(record.owner) ? 'waiting' : 'uncertain' };
+    }
+    if (record.phase !== 'ready' || !record.sessionId) return { state: record.phase === 'failed' ? 'failed' : 'uncertain' };
+    return { state: 'ready', sessionId: record.sessionId, projectId: record.projectId };
+  }
+
+  private read(scope: TaskOriginScope): OriginRecord | undefined {
+    const value = readOrigin(this.path(scope));
+    if (value === undefined) return undefined;
+    const record = Record.parse(value);
+    if (fingerprint(record.scope) !== fingerprint(scope)) throw new Error('Task origin scope mismatch');
+    return record;
+  }
+
+  private path(scope: TaskOriginScope): string {
+    return join(this.root, fingerprint(Scope.parse(scope)) + '.json');
+  }
+}
+
+let cachedLocal: { root: string; registry: TaskOriginRegistry } | undefined;
+export function localTaskOrigins(): TaskOriginRegistry {
+  const root = join(configDir(), 'task-origins');
+  if (cachedLocal?.root !== root) cachedLocal = { root, registry: new TaskOriginRegistry(root) };
+  return cachedLocal.registry;
+}

package/apps/bridge/src/task-origins/projection.ts

@@ -0,0 +1,20 @@
+import type { SessionInfo, SessionsStatus } from '../../../../packages/protocol/schema';
+import { localTaskOrigins, type TaskOriginRegistry } from './index';
+
+/** A fresh catalog heals a controller that was offline when the creation response was sent. */
+export function decorateTaskOriginCatalog(status: SessionsStatus, room: string,
+  registry?: TaskOriginRegistry): SessionsStatus {
+  let origins: ReturnType<TaskOriginRegistry['readyInRoom']>;
+  try { origins = (registry ?? localTaskOrigins()).readyInRoom(room); }
+  catch { return status; }
+  const decorate = (session: SessionInfo): SessionInfo => {
+    const matching = origins.filter(origin => origin.sessionId === session.sessionId && origin.agent === session.agent
+      && (!origin.projectId || !session.projectId || origin.projectId === session.projectId));
+    if (!matching.length && !session.creationOrigins) return session;
+    const { creationOrigins: _previous, ...native } = session;
+    return matching.length ? { ...native, creationOrigins: matching.slice(0, 32).map(origin => ({
+      originId: origin.originId, controllerPublicKey: origin.controllerPublicKey,
+    })) } : native;
+  };
+  return { ...status, sessions: status.sessions.map(decorate), history: status.history?.map(decorate) };
+}

package/apps/bridge/src/task-origins/storage.ts

@@ -0,0 +1,42 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { closeSync, fsyncSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+export function fingerprint(value: unknown): string {
+  return createHash('sha256').update(JSON.stringify(value, (_key, item) => {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) return item;
+    return Object.fromEntries(Object.keys(item).sort().map(key => [key, item[key]]));
+  })).digest('hex');
+}
+
+export function readOrigin(path: string): unknown {
+  try {
+    const record = JSON.parse(readFileSync(path, 'utf8'));
+    if (record.digest !== fingerprint(record.value)) throw new Error('Unreadable task origin');
+    return record.value;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return undefined;
+    throw error;
+  }
+}
+
+export function writeOrigin(path: string, value: unknown): void {
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  const fd = openSync(temporary, 'wx', 0o600);
+  try {
+    try { writeFileSync(fd, JSON.stringify({ value, digest: fingerprint(value) })); fsyncSync(fd); }
+    finally { closeSync(fd); }
+    renameSync(temporary, path);
+    syncDirectory(dirname(path));
+  } finally {
+    try { unlinkSync(temporary); } catch { /* Rename normally consumed it. */ }
+  }
+}
+
+export function syncDirectory(path: string): void {
+  let fd: number | undefined;
+  try { fd = openSync(path, 'r'); fsyncSync(fd); }
+  catch (error) {
+    if (!['EINVAL', 'ENOTSUP', 'EPERM', 'EISDIR'].includes((error as NodeJS.ErrnoException).code ?? '')) throw error;
+  } finally { if (fd !== undefined) closeSync(fd); }
+}

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.74
+npm install -g granttap-mcp@0.8.75
 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.74\";\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 20+ 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.75\";\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 20+ 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.74";
+const PACKAGE = "granttap-mcp@0.8.75";
 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.74",
+  "version": "0.8.75",
   "description": "Apache-2.0 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

@@ -41,6 +41,10 @@ export const ATTACHMENT_MISSING_ERROR = "attachment-missing";
 export const UserMessage = z.object({
   type: z.literal("user.message"),
   messageId: z.string().min(1).max(180).optional(),
+  /** Opt-in origin registration for follow-ups sent before a native chat ID exists. */
+  taskOriginId: z.string().min(1).max(180).optional(),
+  /** Changes only after an explicit controller Retry, never a transport retry. */
+  retryId: z.string().min(1).max(180).optional(),
   text: z.string(),
   agent: CodingAgent.optional(),
   cwd: z.string().max(4_096).optional(),

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

@@ -65,6 +65,8 @@ export const SessionSealed = z.object({
 export type SessionSealed = z.infer<typeof SessionSealed>;
 
 export const SessionInfo = z.object({
+  creationOrigins: z.array(z.object({ originId: z.string().min(1).max(180),
+    controllerPublicKey: z.string().min(1).max(180) }).strict()).max(32).optional(),
   transfer: TaskTransferNotice.optional(),
   sessionId: z.string(),
   agent: AgentId,

package/packages/protocol/task-dispatch/README.md

@@ -15,3 +15,10 @@ Tests live in `tests/wire.test.ts`.
 ## License
 
 Licensed under the Apache License, Version 2.0 (Apache-2.0). See LICENSE and NOTICE.
+
+## Pending native chats
+
+`user.message.continue` names an original creation ID and has no native session
+ID or workspace override. MCP 0.8.75 resolves it using the authenticated sender
+and room before normal provider and Project validation. Older receivers reject
+the unknown operation; it can never be interpreted as a new task.

package/packages/protocol/task-dispatch/continuation.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { UserMessage } from '../messages/interaction';
+import { CodingAgent } from '../messages/primitives';
+
+/** A separate operation fails closed on receivers that do not support origin routing. */
+export const TaskContinuation = UserMessage.omit({ type: true, sessionId: true, requestId: true, cwd: true,
+  taskOriginId: true, retryId: true })
+  .extend({ type: z.literal('user.message.continue'), agent: CodingAgent,
+    messageId: z.string().min(1).max(180), originMessageId: z.string().min(1).max(180) }).strict();

package/packages/protocol/task-dispatch/index.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { TaskCreate, UserMessage } from '../messages/interaction';
+import { TaskContinuation } from './continuation';
 
 /** Signed scheduling and acceptance proof live inside authenticated ciphertext. */
 export const TaskDispatch = z.object({
@@ -12,7 +13,7 @@ export const TaskDispatch = z.object({
   notBefore: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
   expiresAt: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
   createdAt: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
-  operation: z.union([UserMessage, TaskCreate]),
+  operation: z.union([UserMessage, TaskCreate, TaskContinuation]),
 }).strict().superRefine((job, context) => {
   const reject = (message: string, path: string[]) => context.addIssue({
     code: z.ZodIssueCode.custom, message, path,
@@ -31,6 +32,10 @@ export const TaskDispatch = z.object({
   } else if (job.sessionId !== undefined) {
     reject('New tasks cannot borrow an existing conversation encryption scope', ['sessionId']);
   }
+  if (job.operation.type === 'user.message.continue'
+    && job.operation.originMessageId === job.operation.messageId) {
+    reject('A continuation cannot depend on itself', ['operation', 'originMessageId']);
+  }
   if (job.operation.attachmentRefs?.length) {
     reject('Durable tasks must carry their attachments inline', ['operation', 'attachmentRefs']);
   }