granttap-mcp 0.8.72 → 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

@@ -16,6 +16,8 @@ import { noteDeliveredRun } from "../../mesh/delivery/run-digest";
 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";
@@ -25,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";
@@ -59,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,
@@ -67,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);
@@ -84,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);
@@ -93,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) {
@@ -104,7 +136,11 @@ export async function handleUserMessage(
   }
   const attachments = resolved.attachments;
 
-  const target = scanSessions().sessions.find((session) => session.sessionId === message.sessionId);
+  // The catalog this monitor last published already names the chat. A full
+  // provider scan blocks the event loop for seconds on a large transcript set,
+  // so it runs only for a chat newer than that catalog.
+  const target = publishedSession(client, message.sessionId)
+    ?? scanSessions().sessions.find((session) => session.sessionId === message.sessionId);
   if (!target) {
     await say("This task is no longer available on the computer.", message.sessionId);
     return "rejected";

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

@@ -10,8 +10,12 @@
  * its answer — or the reason it stopped — reaches the chat when it ends.
  */
 
-/** Long enough for a provider CLI to refuse at once, short enough not to keep the phone waiting. */
-export const ACCEPTANCE_WINDOW_MS = 15_000;
+/**
+ * Long enough for a provider CLI to refuse at once (missing chat, bad flag,
+ * not signed in), short enough that the message leaves the phone's queue
+ * while the person is still looking at it.
+ */
+export const ACCEPTANCE_WINDOW_MS = 3_000;
 
 /** A safety bound for an unattended turn; the person stops a run with Stop, not with a deadline. */
 export const PHONE_RUN_LIMIT_MS = 6 * 60 * 60_000;

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/sessions/cursor/README.md

@@ -7,3 +7,7 @@ public entry point. Characterization coverage lives in `tests/sessions.test.ts`,
 
 License: this module is distributed under the Apache License 2.0
 in the repository-root `LICENSE` file.
+
+`attention/` supplements JSONL messages with the native composer's visible
+question cards and warnings. Missing hooks or a text-only transcript must not
+hide the prompt or choices. Native storage is read-only and bounded.

package/apps/bridge/src/sessions/cursor/activity.ts

@@ -2,10 +2,11 @@ import { readFileSync } from "node:fs";
 import type { ActivityEntry, ChildThreadInfo, SessionInfo } from "../../../../../packages/protocol/schema";
 import { classifyTool, estimateTokens, pushEntry, toolSummary } from "../support/activity-helpers";
 import { childEntryFields } from "../support/child-threads";
-import { safeParse, stateFor } from "../support/common";
+import { safeParse, stateFor, ts } from "../support/common";
 import type { CapabilityObservation } from "../telemetry";
 import { cursorFiles, cursorUsage, scanCursor } from "./scan";
 import { textBlocks } from "./transcripts";
+import { cursorNativeAttention, cursorQuestionText, cursorNoticeText } from "./attention";
 
 function appendFileActivity(input: {
   out: ActivityEntry[];
@@ -31,8 +32,14 @@ function appendFileActivity(input: {
   lines.forEach((line, index) => {
     const item = safeParse(line);
     if (!item) return;
-    const createdAt = (typeof item.timestamp === "number" ? item.timestamp : 0)
+    const createdAt = ts(item.timestamp ?? item.message?.timestamp)
       || baseTime + (indexOffset + index) * 1_000;
+    const notices = [item, ...(Array.isArray(item.message?.content) ? item.message.content : [])];
+    notices.forEach((row, ordinal) => {
+      const notice = cursorNoticeText(row);
+      if (notice) pushEntry({ fullText, out, seen, sessionId, kind: "status", text: notice,
+        createdAt, ordinal: (indexOffset + index) * 100 + ordinal, extras: childFields });
+    });
     if (item.role === "user") {
       const text = textBlocks(item.message?.content).join("\n").trim();
       if (!text) return;
@@ -53,7 +60,7 @@ function appendFileActivity(input: {
       if (block?.type === "text" && typeof block.text === "string" && block.text.trim()) {
         pushEntry({ fullText, out: out, seen: seen, sessionId: sessionId, kind: "message", text: block.text, createdAt: createdAt, ordinal: sequence, extras: childFields, idOverride: entryId(createdAt, sequence) });
       } else if (block?.type === "tool_use") {
-        pushEntry({ fullText, out: out, seen: seen, sessionId: sessionId, kind: "tool", text: toolSummary(block.name, block.input), createdAt: createdAt, ordinal: sequence, extras: {
+        pushEntry({ fullText, out: out, seen: seen, sessionId: sessionId, kind: cursorQuestionText(block.name, block.input) ? "message" : "tool", text: cursorQuestionText(block.name, block.input) ?? toolSummary(block.name, block.input), createdAt: createdAt, ordinal: sequence, extras: {
             ...childFields,
             ...classifyTool(block.name, block.input),
             estimatedContextTokens: estimateTokens(block.input),
@@ -85,6 +92,9 @@ export function cursorActivity(session: SessionInfo, fullText = false): Activity
       baseTime: base, indexOffset: index * 10_000, child,
     });
   });
+  for (const entry of cursorNativeAttention(session)) {
+    if (!out.some(existing => existing.text === entry.text)) out.push(entry);
+  }
   return out.sort((a, b) => a.createdAt - b.createdAt);
 }
 

package/apps/bridge/src/sessions/cursor/attention/README.md

@@ -0,0 +1,12 @@
+# Cursor attention
+
+Public entries: `cursorQuestionText`, `cursorNoticeText`, and `cursorNativeAttention`.
+They project user-visible Cursor questions, their choices, and warnings into the
+existing chat transcript. Cursor sometimes keeps question cards in its local
+composer database without writing them to the JSONL transcript. The native reader
+uses read-only indexed lookups of the exact composer's most recent 128 bubbles,
+with a one-second timeout and bounded results. It never reads thought blocks,
+changes native answers, or represents a displayed question as answered.
+
+Tests exercise the public projection and an isolated SQLite database. Distributed
+under the repository Apache License 2.0.

package/apps/bridge/src/sessions/cursor/attention/index.ts

@@ -0,0 +1,3 @@
+/** Public projection of Cursor's user-visible questions and warnings. */
+export { cursorQuestionText, cursorNoticeText } from './presentation';
+export { cursorNativeAttention } from './native';

package/apps/bridge/src/sessions/cursor/attention/native.ts

@@ -0,0 +1,48 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import type { ActivityEntry, SessionInfo } from '../../../../../../packages/protocol/schema';
+import { cursorQuestionText, cursorNoticeText } from './presentation';
+
+type NativeRow = { id: string; at?: string | number; name?: string; params?: unknown; warning?: unknown };
+const sql = (value: string) => "'" + value.replaceAll("'", "''") + "'";
+
+function decoded(value: unknown): unknown {
+  if (typeof value !== 'string') return value;
+  try { return JSON.parse(value); } catch { return undefined; }
+}
+
+/** Exact indexed composer/bubble reads. No database scan and no writes to Cursor's state. */
+export function cursorNativeAttention(session: SessionInfo, db = process.env.GRANTTAP_CURSOR_STATE_DB
+  ?? join(homedir(), 'Library/Application Support/Cursor/User/globalStorage/state.vscdb')): ActivityEntry[] {
+  if (!existsSync(db) || !session.sessionId || session.sessionId.length > 256) return [];
+  try {
+    const query = `WITH composer AS (SELECT value FROM cursorDiskKV WHERE key=${sql('composerData:' + session.sessionId)}),
+      headers AS (SELECT json_extract(j.value,'$.bubbleId') AS id, json_extract(j.value,'$.createdAt') AS at
+        FROM composer, json_each(composer.value,'$.fullConversationHeadersOnly') j
+        ORDER BY CAST(j.key AS INTEGER) DESC LIMIT 128)
+      SELECT h.id, coalesce(json_extract(b.value,'$.createdAt'),h.at) AS at,
+        json_extract(b.value,'$.toolFormerData.name') AS name,
+        CASE WHEN lower(json_extract(b.value,'$.toolFormerData.name')) IN ('ask_question','askquestion','askuserquestion')
+          THEN json_extract(b.value,'$.toolFormerData.params') END AS params,
+        coalesce(json_extract(b.value,'$.errorDetails.error.details.detail'),
+          json_extract(b.value,'$.errorDetails.error.details.title'),
+          json_extract(b.value,'$.errorDetails.message'),json_extract(b.value,'$.warning.message')) AS warning
+      FROM headers h JOIN cursorDiskKV b ON b.key=${sql('bubbleId:' + session.sessionId + ':')} || h.id;`;
+    const raw = execFileSync('sqlite3', ['-readonly', '-json', db, query], {
+      encoding: 'utf8', timeout: 1_000, maxBuffer: 2 * 1_024 * 1_024, stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    const rows: NativeRow[] = raw.trim() ? JSON.parse(raw) : [];
+    return rows.flatMap(row => {
+      const question = cursorQuestionText(row.name, decoded(row.params));
+      const notice = cursorNoticeText({ type: 'warning', message: row.warning });
+      const text = question ?? notice;
+      if (!text || typeof row.id !== 'string' || row.id.length > 256) return [];
+      const at = typeof row.at === 'number' ? row.at : Date.parse(row.at ?? '');
+      return [{ id: `cursor-attention:${session.sessionId}:${row.id}`,
+        kind: question ? 'message' as const : 'status' as const, text,
+        createdAt: Number.isFinite(at) ? at : session.lastActivityAt }];
+    }).sort((a, b) => a.createdAt - b.createdAt);
+  } catch { return []; }
+}

package/apps/bridge/src/sessions/cursor/attention/presentation.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+
+const text = z.string().trim().min(1).max(2_000);
+const option = z.union([z.string().trim().min(1).max(512), z.object({ label: z.string().trim().min(1).max(512) })]);
+const questions = z.object({ title: z.string().max(160).optional(), questions: z.array(z.object({
+  prompt: text.optional(), question: text.optional(), options: z.array(option).max(8).optional(),
+})).min(1).max(4) });
+
+/** Only the visible question and options; native reasoning and raw tool inputs stay private. */
+export function cursorQuestionText(name: unknown, input: unknown): string | undefined {
+  if (typeof name !== 'string' || !['askquestion', 'ask_question', 'askuserquestion'].includes(name.toLowerCase())) return;
+  const parsed = questions.safeParse(input);
+  if (!parsed.success || parsed.data.questions.some(q => !q.prompt && !q.question)) return;
+  const parts = parsed.data.questions.map(q => [q.prompt ?? q.question!,
+    ...(q.options ?? []).map(o => '• ' + (typeof o === 'string' ? o : o.label))].join('\n'));
+  return [parsed.data.title, ...parts].filter(Boolean).join('\n\n').slice(0, 16_384);
+}
+
+/** Explicit user-visible notices only, never an arbitrary diagnostic or thought block. */
+export function cursorNoticeText(item: unknown): string | undefined {
+  if (!item || typeof item !== 'object') return;
+  const row = item as Record<string, unknown>;
+  if (row.type === 'tool_result' && row.is_error === true) {
+    const content = typeof row.content === 'string' ? row.content : Array.isArray(row.content)
+      ? row.content.filter(b => b?.type === 'text' && typeof b.text === 'string').map(b => b.text).join('\n') : undefined;
+    return typeof content === 'string' && content.trim() ? content.trim().slice(0, 4_000) : undefined;
+  }
+  if (!['warning', 'error'].includes(String(row.type))) return;
+  const message = typeof row.message === 'string' ? row.message
+    : row.message && typeof row.message === 'object' ? (row.message as Record<string, unknown>).content : row.text;
+  return typeof message === 'string' && message.trim() ? message.trim().slice(0, 4_000) : undefined;
+}

package/apps/bridge/src/sessions/cursor/catalog.ts

@@ -258,6 +258,7 @@ export function composerActivityAt(composer: ComposerRow): number {
 
 export function composerState(status: string | undefined, lastActivityAt: number): SessionState {
   const value = (status ?? "").toLowerCase();
+  if (["waiting", "waiting_for_user", "awaiting_user_response"].includes(value)) return "waiting";
   if (["generating", "continuing", "applying", "running", "in_progress", "active"].includes(value)) {
     return "working";
   }

package/apps/bridge/src/sessions/scan/claude/parse.ts

@@ -31,9 +31,21 @@ type ClaudeParseState = {
   tokensLastTurn: number;
   contextTokensUsed?: number;
   repositoryPaths: string[];
+  turnEnded: boolean;
 };
 
+/** Stop reasons after which Claude Code waits for the person's next prompt. */
+const FINISHED_TURN = new Set(["end_turn", "stop_sequence", "max_tokens"]);
+
+/** Metadata, progress and subagent lines do not start or end the chat's own turn. */
+function noteTurnBoundary(d: any, state: ClaudeParseState): void {
+  if (d.isSidechain === true) return;
+  if (d.type === "user" || d.type === "queue-operation") state.turnEnded = false;
+  else if (d.type === "assistant") state.turnEnded = FINISHED_TURN.has(d.message?.stop_reason);
+}
+
 function applyClaudeLine(d: any, state: ClaudeParseState): void {
+  noteTurnBoundary(d, state);
   state.repositoryPaths.push(...claudeRepositoryPaths(d));
   state.repositoryPaths = state.repositoryPaths.slice(-64);
   if (d.sessionId && !state.sessionId) state.sessionId = String(d.sessionId);
@@ -119,7 +131,7 @@ export function parseClaudeFile(file: string): {
       state:
         cached.session.childThreads?.some((child) => stateFor(child.lastActivityAt) === "working")
           ? "working" as const
-          : stateFor(cached.session.lastActivityAt),
+          : cached.turnEnded ? "idle" as const : stateFor(cached.session.lastActivityAt),
       childThreads: cached.session.childThreads?.map((child) => ({
         ...child,
         state: stateFor(child.lastActivityAt),
@@ -136,7 +148,7 @@ export function parseClaudeFile(file: string): {
   const lines = text.split("\n");
   const state: ClaudeParseState = {
     sessionId: "", startedAt: 0, lastActivityAt: 0, lastMessageAt: 0,
-    tokensSession: 0, tokensLastTurn: 0, repositoryPaths: [],
+    tokensSession: 0, tokensLastTurn: 0, repositoryPaths: [], turnEnded: false,
   };
   for (const line of lines) {
     if (!line) continue;
@@ -153,7 +165,7 @@ export function parseClaudeFile(file: string): {
     branch: state.branch,
     model: state.model,
     summary: state.summary,
-    state: stateFor(state.lastActivityAt),
+    state: state.turnEnded ? "idle" : stateFor(state.lastActivityAt),
     startedAt: state.startedAt || state.lastActivityAt,
     lastActivityAt: state.lastActivityAt,
     ...(state.lastMessageAt ? { lastMessageAt: state.lastMessageAt } : {}),
@@ -182,6 +194,7 @@ export function parseClaudeFile(file: string): {
     session,
     tokensSession: session.tokensSession,
     observations,
+    turnEnded: state.turnEnded,
   });
   return { session, tokensSession: session.tokensSession, childPaths: actualChildPaths };
 }

package/apps/bridge/src/sessions/scan/claude/shared.ts

@@ -51,6 +51,8 @@ export type CachedClaudeSummary = {
   session: SessionInfo;
   tokensSession: number;
   observations: CapabilityObservation[];
+  /** The chat's own last turn ended; recent writes no longer mean it is working. */
+  turnEnded?: boolean;
 };
 
 export const claudeSummaryCache = new Map<string, CachedClaudeSummary>();

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

@@ -9,7 +9,8 @@ import { TaskDispatchInbox } from '../index';
 import { TaskDispatchWorker } from './index';
 import { relayTaskJobRemote } from './remote';
 import { NativeTaskQueueSender } from '../sender';
-import { taskDispatchReady } from './readiness';
+import { queuedCatalogRefreshDue, taskDispatchReady } from './readiness';
+import { localTaskOrigins, resolveTaskOriginJob } from '../../task-origins';
 
 /** Only the persistent monitor advertises durable submission capability. */
 export function startTaskDispatchMonitor(input: {
@@ -17,7 +18,10 @@ export function startTaskDispatchMonitor(input: {
   peerAllowed: (peer: string) => boolean; publish: () => Promise<void>;
 }): () => void {
   const inbox = new TaskDispatchInbox(join(configDir(), 'task-dispatch'), input.config.room);
-  let stopped = false, reportedAt = 0, maintainedAt = 0;
+  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);
   const worker = new TaskDispatchWorker({ inbox, remote: relayTaskJobRemote(input.config),
@@ -25,17 +29,35 @@ 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);
-      return taskDispatchReady(job, { session, generatedAt: catalog?.generatedAt,
+      const observation = { session, generatedAt: catalog?.generatedAt,
         inFlight: isDeliveryInFlight(job.sessionId ?? `__new_${job.operation.agent ?? 'codex'}_task__`),
-        paused: !!job.sessionId && isSessionPaused(job.sessionId) });
+        paused: !!job.sessionId && isSessionPaused(job.sessionId) };
+      const ready = taskDispatchReady(job, observation);
+      if (!ready && queuedCatalogRefreshDue(job, observation, refreshedAt)) {
+        refreshedAt = Date.now();
+        void input.publish().catch(() => {});
+      }
+      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-dispatch/worker/readiness.ts

@@ -12,3 +12,15 @@ export function taskDispatchReady(job: TaskDispatch, observation: {
   // which returns a definite rejection rather than keeping a lost task forever.
   return !observation.session || observation.session.state === 'idle';
 }
+
+/** The catalog loop runs every 30 s; a waiting queued message should not. */
+export const QUEUED_CATALOG_REFRESH_MS = 10_000;
+
+/** One rate-limited catalog refresh lets a queued job see its chat go idle sooner. */
+export function queuedCatalogRefreshDue(job: TaskDispatch, observation: {
+  generatedAt?: number; inFlight: boolean; paused: boolean;
+}, lastRefreshAt: number, now = Date.now()): boolean {
+  if (!job.sessionId || job.deliveryMode === 'immediate' || observation.inFlight || observation.paused) return false;
+  return now - (observation.generatedAt ?? 0) >= QUEUED_CATALOG_REFRESH_MS
+    && now - lastRefreshAt >= QUEUED_CATALOG_REFRESH_MS;
+}

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.72
+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.72\";\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.72";
+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.72",
+  "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']);
   }