granttap-mcp 0.8.77 → 0.8.78

package/README.md

@@ -29,6 +29,12 @@ requesting controller, and restricted to that native execution's admitted
 checkout. Received previews remain on the device for offline inspection.
 **Agents** opens nested execution conversations within the same Task.
 
+Messages sent to a chat open in Codex Desktop continue that same conversation,
+including while a turn is running. The runtime forwards them to the existing
+desktop owner and preserves the delivery ID across retries. **Pause** reaches
+that owner too. A confirmed receipt means Codex accepted the message; its answer
+then arrives through the existing chat history.
+
 The MCP runtime, plugins, and CLI use the GrantTap Commercial Source License.
 Product use requires authorized GrantTap account access; official TestFlight
 access remains free. Earlier releases through 0.8.75 retain their Apache-2.0

package/apps/bridge/src/codex-desktop/README.md

@@ -0,0 +1,31 @@
+# Codex desktop delivery
+
+Public entry: `deliverToCodexDesktop` in `index.ts`. A paired controller's follow-up
+goes to the native owner of the existing conversation, including between turns.
+Starting a second `codex exec resume` against that owner's thread would conflict
+with its single writer. New Tasks continue to use the provider's CLI creation path.
+
+The local desktop coordination protocol is versioned and differs from the public
+app-server WebSocket transport. This adapter implements its framing independently;
+no desktop application source is bundled. The existing socket must be private,
+owned by the current user, and inside the configured Codex home. Nothing creates,
+replaces, or restarts the native router. Windows has no tested desktop socket path
+and keeps the CLI path.
+
+The native owner inherits its workspace and approval settings. Explicit per-Task
+sandbox settings and model/effort are carried with the turn. Disabled MCP settings
+that cannot be enforced through the owner are refused. Protocol errors or an
+unconfirmed submission never fall back to a second writer. Only a missing socket
+or an explicit owner-not-found response permits headless resume.
+
+The original message ID is carried into Codex. A private, cross-process receipt
+records a hash of the intent before dispatch and native turn ID after acceptance.
+An uncertain or crashed dispatch is not replayed. A native receipt produces no
+synthetic assistant reply or completed-run digest; the existing transcript carries
+the actual work. Pause sends the user's stop request to the same owner. Document
+attachments remain in private staging for up to a day after admission; the monitor
+removes expired stages. Image-only stages are removed once native admission has
+consumed them. Tests exercise native delivery, framing, socket trust, durable
+deduplication, and refusal without launching the CLI.
+
+License: GrantTap Commercial Source License in the repository-root `LICENSE`.

package/apps/bridge/src/codex-desktop/connection.ts

@@ -0,0 +1,104 @@
+import { randomUUID } from 'node:crypto';
+import { connect, type Socket } from 'node:net';
+
+type Response = { type: 'response'; requestId: string; method?: string; resultType: string;
+  handledByClientId?: string; result?: any; error?: string };
+type Pending = { method: string; target?: string; resolve: (response: Response) => void;
+  reject: (error: Error) => void; timer: NodeJS.Timeout };
+const MAX_FRAME_BYTES = 8 * 1024 * 1024;
+
+/** The desktop coordination socket is length-prefixed JSON, not another app-server. */
+export class DesktopConnection {
+  private readonly socket: Socket;
+  private readonly pending = new Map<string, Pending>();
+  private buffered = Buffer.alloc(0);
+  private clientId = 'initializing-client';
+  private closed = false;
+  private readonly deadline: number;
+
+  constructor(path: string, timeoutMs: number) {
+    this.deadline = Date.now() + Math.min(5_000, timeoutMs);
+    this.socket = connect(path);
+    this.socket.on('error', () => this.close());
+    this.socket.on('close', () => this.close());
+    this.socket.on('data', chunk => {
+      try { this.receive(chunk); } catch { this.close(); }
+    });
+  }
+
+  async initialize(): Promise<void> {
+    const response = await this.call('initialize', { clientType: 'desktop' }, 0);
+    const id = response.result?.clientId;
+    if (response.resultType !== 'success' || typeof id !== 'string' || !id || id.length > 180) {
+      throw new Error('Codex desktop initialization is unavailable.');
+    }
+    this.clientId = id;
+  }
+
+  call(method: string, params: unknown, version: number, target?: string): Promise<Response> {
+    return new Promise((resolve, reject) => {
+      if (this.closed) return reject(new Error('Codex desktop disconnected.'));
+      const requestId = randomUUID();
+      const timer = setTimeout(() => {
+        this.pending.delete(requestId);
+        reject(new Error('Codex desktop has not confirmed the request.'));
+      }, Math.max(1, this.deadline - Date.now()));
+      this.pending.set(requestId, { method, target, resolve, reject, timer });
+      this.send({ type: 'request', requestId, sourceClientId: this.clientId,
+        method, params, version, ...(target ? { targetClientId: target } : {}) });
+    });
+  }
+
+  close(): void {
+    if (this.closed) return;
+    this.closed = true;
+    this.socket.destroy();
+    this.buffered = Buffer.alloc(0);
+    for (const request of this.pending.values()) {
+      clearTimeout(request.timer);
+      request.reject(new Error('Codex desktop disconnected.'));
+    }
+    this.pending.clear();
+  }
+
+  private send(value: unknown): void {
+    const body = Buffer.from(JSON.stringify(value));
+    if (body.length > MAX_FRAME_BYTES) return this.close();
+    const prefix = Buffer.alloc(4);
+    prefix.writeUInt32LE(body.length);
+    this.socket.write(Buffer.concat([prefix, body]));
+  }
+
+  private receive(chunk: Buffer): void {
+    this.buffered = Buffer.concat([this.buffered, chunk]);
+    while (this.buffered.length >= 4) {
+      const size = this.buffered.readUInt32LE();
+      if (size === 0 || size > MAX_FRAME_BYTES) throw new Error('Invalid desktop frame.');
+      if (this.buffered.length < size + 4) return;
+      const message = JSON.parse(this.buffered.subarray(4, size + 4).toString());
+      this.buffered = this.buffered.subarray(size + 4);
+      this.handle(message);
+    }
+  }
+
+  private handle(message: any): void {
+    if (!message || typeof message !== 'object' || Array.isArray(message)) return;
+    if (message.type === 'client-discovery-request') {
+      this.send({ type: 'client-discovery-response', requestId: message.requestId,
+        response: { canHandle: false } });
+    } else if (message.type === 'request') {
+      this.send({ type: 'response', requestId: message.requestId,
+        resultType: 'error', error: 'no-handler-for-request' });
+    } else if (message.type === 'response') {
+      const request = this.pending.get(message.requestId);
+      if (!request) return;
+      if (message.method !== undefined && message.method !== request.method
+          || message.resultType === 'success' && request.target && message.handledByClientId !== request.target) {
+        return this.close();
+      }
+      this.pending.delete(message.requestId);
+      clearTimeout(request.timer);
+      request.resolve(message);
+    }
+  }
+}

package/apps/bridge/src/codex-desktop/controls.ts

@@ -0,0 +1,21 @@
+import { DesktopConnection } from './connection';
+import { desktopSocketPath } from './socket-path';
+
+/** A deliberate user stop reaches the owning desktop; no provider process is killed. */
+export async function interruptCodexDesktop(sessionId: string): Promise<{ ok: boolean } | undefined> {
+  let connection: DesktopConnection | undefined;
+  try {
+    const path = desktopSocketPath();
+    if (!path) return undefined;
+    connection = new DesktopConnection(path, 2_500);
+    await connection.initialize();
+    const owner = await connection.call('thread-owner-discovery', { hostId: 'local', conversationId: sessionId }, 1);
+    if (owner.resultType === 'error' && owner.error === 'no-client-found') return undefined;
+    if (owner.resultType !== 'success' || !owner.handledByClientId) return { ok: false };
+    // Version 3 is the native explicit-user-stop form, without a stale expected turn ID.
+    const response = await connection.call('thread-follower-interrupt-turn',
+      { conversationId: sessionId, mode: 'user-stop', expectedTurnId: null }, 3, owner.handledByClientId);
+    return { ok: response.resultType === 'success' && response.result?.ok === true };
+  } catch { return { ok: false }; }
+  finally { connection?.close(); }
+}

package/apps/bridge/src/codex-desktop/index.ts

@@ -0,0 +1,78 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import type { SessionInfo } from '../../../../packages/protocol/schema';
+import { loadRuntimeConfig } from '../config';
+import type { DeliveryOptions, ReplyResult } from '../reply';
+import { DesktopConnection } from './connection';
+import { DesktopReceipt } from './receipts';
+import { desktopSocketPath } from './socket-path';
+export { interruptCodexDesktop } from './controls';
+
+const UNAVAILABLE = 'Codex desktop is not ready to receive this message. Keep the original chat open and try again.';
+const UNCERTAIN = 'Codex has not confirmed this message. Check the original chat before sending it again.';
+
+/** Undefined means no desktop owner exists; only then may the caller resume a CLI. */
+export async function deliverToCodexDesktop(input: {
+  session: SessionInfo; text: string; images: string[]; options: DeliveryOptions; timeoutMs: number;
+}): Promise<ReplyResult | undefined> {
+  let connection: DesktopConnection | undefined;
+  let dispatched = false;
+  const { session, text, images, options } = input;
+  const accepted: ReplyResult = { ok: true, text: '', sessionId: session.sessionId, delivery: 'native' };
+  try {
+    const policy = loadRuntimeConfig();
+    const request = turnRequest(input, policy.sessionAccess[session.sessionId]);
+    const intent = options.intentDigest ?? { text,
+      images: images.map(path => createHash('sha256').update(readFileSync(path)).digest('hex')), options };
+    const receipt = new DesktopReceipt(session.sessionId, request.clientUserMessageId, intent);
+    const prior = receipt.lookup();
+    if (prior === 'accepted') return accepted;
+    if (prior) return refusal(prior);
+    const path = desktopSocketPath();
+    if (!path) return undefined;
+    connection = new DesktopConnection(path, input.timeoutMs);
+    await connection.initialize();
+    const owner = await connection.call('thread-owner-discovery',
+      { hostId: 'local', conversationId: session.sessionId }, 1);
+    if (owner.resultType === 'error' && owner.error === 'no-client-found') return undefined;
+    if (owner.resultType !== 'success' || !owner.handledByClientId) return { ok: false, error: UNAVAILABLE };
+    if (policy.sessionMcpDisabled[session.sessionId]?.length) {
+      return { ok: false, error: 'Apply this Task’s disabled MCP settings in Codex before continuing its open desktop chat.' };
+    }
+    const state = receipt.begin();
+    if (state === 'accepted') return accepted;
+    if (state !== 'new') return refusal(state);
+    dispatched = true;
+    const response = await connection.call('thread-follower-start-turn', {
+      conversationId: session.sessionId,
+      turnStart: { request, context: { inheritThreadSettings: true } },
+    }, 2, owner.handledByClientId);
+    const turnId = response.result?.result?.turn?.id;
+    if (response.resultType !== 'success' || typeof turnId !== 'string' || !turnId || turnId.length > 180) {
+      return { ok: false, error: UNCERTAIN, delivery: 'native' };
+    }
+    receipt.accept(turnId);
+    return accepted;
+  } catch {
+    return { ok: false, error: dispatched ? UNCERTAIN : UNAVAILABLE,
+      ...(dispatched ? { delivery: 'native' as const } : {}) };
+  } finally { connection?.close(); }
+}
+
+function refusal(state: string): ReplyResult {
+  return state === 'conflict' ? { ok: false, error: 'This message ID belongs to a different Codex delivery.' }
+    : { ok: false, error: UNCERTAIN, delivery: 'native' };
+}
+
+function turnRequest(input: { session: SessionInfo; text: string; images: string[]; options: DeliveryOptions }, access?: string) {
+  const { session, text, images, options } = input;
+  const effort = ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(options.effort ?? '') ? options.effort : undefined;
+  const sandboxPolicy = access === 'read-only' ? { type: 'readOnly', networkAccess: false }
+    : access === 'workspace' ? { type: 'workspaceWrite', writableRoots: session.cwd ? [session.cwd] : [],
+      networkAccess: false, excludeTmpdirEnvVar: false, excludeSlashTmp: false }
+    : access === 'full' ? { type: 'dangerFullAccess' } : undefined;
+  return { threadId: session.sessionId, clientUserMessageId: options.messageId ?? randomUUID(),
+    input: [{ type: 'text', text, text_elements: [] }, ...images.map(path => ({ type: 'localImage', path }))],
+    ...(options.model ? { model: options.model } : {}), ...(effort ? { effort } : {}),
+    ...(sandboxPolicy ? { sandboxPolicy } : {}) };
+}

package/apps/bridge/src/codex-desktop/receipts.ts

@@ -0,0 +1,55 @@
+import { createHash } from 'node:crypto';
+import { closeSync, existsSync, fsyncSync, openSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { z } from 'zod';
+import { withStoreLock } from '../../../../packages/core/store-file-lock';
+import { configDir, writePrivateFile } from '../config';
+
+const Receipt = z.object({ digest: z.string().length(64), phase: z.enum(['sending', 'accepted']),
+  turnId: z.string().min(1).max(180).optional() }).strict();
+type Record = z.infer<typeof Receipt>;
+const hash = (value: string) => createHash('sha256').update(value).digest('hex');
+
+/** A crashed or disconnected submission is never replayed as a new native turn. */
+export class DesktopReceipt {
+  private readonly path: string;
+  private readonly digest: string;
+
+  constructor(threadId: string, messageId: string, intent: unknown) {
+    this.path = join(configDir(), 'codex-desktop-deliveries', hash(`${threadId}:${messageId}`) + '.json');
+    this.digest = hash(JSON.stringify(intent));
+  }
+
+  begin(): 'new' | 'accepted' | 'uncertain' | 'conflict' {
+    return withStoreLock(this.path, () => {
+      const prior = this.lookup();
+      if (prior) return prior;
+      this.save({ digest: this.digest, phase: 'sending' });
+      return 'new';
+    });
+  }
+
+  lookup(): 'accepted' | 'uncertain' | 'conflict' | undefined {
+    if (!existsSync(this.path)) return undefined;
+    const prior = this.read();
+    if (prior.digest !== this.digest) return 'conflict';
+    return prior.phase === 'accepted' ? 'accepted' : 'uncertain';
+  }
+
+  accept(turnId: string): void {
+    withStoreLock(this.path, () => {
+      const prior = this.read();
+      if (prior.digest !== this.digest) throw new Error('Codex delivery identity changed.');
+      this.save({ ...prior, phase: 'accepted', turnId });
+    });
+  }
+
+  private read(): Record { return Receipt.parse(JSON.parse(readFileSync(this.path, 'utf8'))); }
+  private save(record: Record): void {
+    writePrivateFile(this.path, JSON.stringify(record) + '\n');
+    for (const path of [this.path, ...(process.platform === 'win32' ? [] : [dirname(this.path)])]) {
+      const fd = openSync(path, 'r');
+      try { fsyncSync(fd); } finally { closeSync(fd); }
+    }
+  }
+}

package/apps/bridge/src/codex-desktop/socket-path.ts

@@ -0,0 +1,25 @@
+import { lstatSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+/** Only the user's existing desktop router may receive a paired controller's input. */
+export function desktopSocketPath(): string | undefined {
+  if (process.platform === 'win32') return undefined;
+  const root = process.env.GRANTTAP_CODEX_DIR ?? process.env.NODVOX_CODEX_DIR
+    ?? process.env.CODEX_HOME ?? join(homedir(), '.codex');
+  const directory = join(root, 'ipc');
+  const socket = join(directory, 'ipc.sock');
+  for (const [path, isSocket] of [[root, false], [directory, false], [socket, true]] as const) {
+    try {
+      const stat = lstatSync(path);
+      if (stat.uid !== process.getuid?.() || (stat.mode & 0o022) !== 0
+          || (isSocket ? !stat.isSocket() || (stat.mode & 0o077) !== 0 : !stat.isDirectory())) {
+        throw new Error('The Codex desktop connection is not private.');
+      }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') return undefined;
+      throw error;
+    }
+  }
+  return socket;
+}

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

@@ -3,6 +3,7 @@ import { MAX_USER_ATTACHMENTS } from "../../../../../packages/protocol/schema";
 import type { RelayClient } from "../../../../../packages/core/relay-client";
 import { pruneAttachments, takeAttachment } from "../../delivery/attachment-store";
 import { sendSessionPayload } from "../../host/session-keys";
+import { prunePreparedAttachments } from '../../reply';
 
 export async function sendDeliveryReceipt(
   client: RelayClient,
@@ -54,7 +55,7 @@ let attachmentsSweptAt = 0;
 export function sweepAttachments(now = Date.now()): number {
   if (now - attachmentsSweptAt < ATTACHMENT_SWEEP_MS) return 0;
   attachmentsSweptAt = now;
-  return pruneAttachments(now);
+  return pruneAttachments(now) + prunePreparedAttachments(now);
 }
 
 /**

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

@@ -171,6 +171,7 @@ export async function handleUserMessage(
   await onProcessing?.();
   const startedAt = Date.now();
   const run = deliverToSession(target, message.text, PHONE_RUN_LIMIT_MS, attachments, {
+    messageId: message.messageId,
     preferredMcp: message.preferredMcp,
     skill: message.skill,
     model: message.model,
@@ -178,6 +179,7 @@ export async function handleUserMessage(
     effort: message.effort,
   });
   const settle = async (result: ReplyResult, late: boolean) => {
+    if (result.ok && result.delivery === 'native') return;
     // The run's turns are in the transcript, but a session holding this chat
     // open never sees them; the journal is how it finds out on its next prompt,
     // and the Task carries the same digest as progress.

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

@@ -30,3 +30,9 @@ Explicit Cursor task turns pass `--trust` for the selected workspace so an
 updated CLI cannot wait for an invisible desktop trust prompt. Resumes without
 a reported workspace are refused. Tool approvals and global action bans remain
 active; `--force`, `--yolo` and automatic MCP approval are never added.
+
+An existing Codex desktop conversation receives follow-ups through its native
+owner, without a competing `exec resume` writer. The `codex-desktop` feature owns
+that versioned local connection and durable admission receipt. Headless resume is
+used only when no native owner exists. Native admission carries the controller's
+message ID and returns promptly; the provider transcript supplies the answer.

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

@@ -13,6 +13,7 @@ import { withAttachments } from "./payload/attachments";
 import { abortProcesses, runProcess } from "./process";
 import { routingPrompt } from "./payload/routing";
 import type { DeliveryOptions, ReplyResult } from "./payload/types";
+import { deliveryIntent } from './payload/identity';
 import {
   runCursorNew,
   runCursorResume,
@@ -20,6 +21,7 @@ import {
   runGrokResume,
 } from "./process/provider-headless";
 export type { DeliveryOptions, ReplyResult } from "./payload/types";
+export { prunePreparedAttachments } from './payload/attachments';
 
 export const GENERAL_WORKSPACE = "granttap:general";
 
@@ -59,6 +61,7 @@ export function deliverToSession(
   if (!options.ignorePause && isSessionPaused(session.sessionId)) {
     return Promise.resolve({ ok: false, error: PAUSED_SESSION_REASON });
   }
+  if (session.agent === 'codex') options = { ...options, intentDigest: deliveryIntent(text, attachments, options) };
   if (/^transfer-[a-f0-9]{48}$/.test(session.sessionId)) {
     return queued(session.sessionId, async () => (await localTaskTransfers().deliver(
       session.sessionId, text, attachments, options, {

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

@@ -1,8 +1,9 @@
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { existsSync, lstatSync, readdirSync, rmSync } from 'node:fs';
 import { basename, join } from "node:path";
 import { MAX_USER_ATTACHMENTS, type UserAttachment } from "../../../../../packages/protocol/schema";
 import type { ReplyResult } from "./types";
+import { configDir } from '../../config';
 
 type PreparedAttachments = { prompt: string; claudePrompt: string; images: string[] };
 
@@ -12,24 +13,47 @@ export async function withAttachments(
   run: (prepared: PreparedAttachments) => Promise<ReplyResult>,
 ): Promise<ReplyResult> {
   if (attachments.length === 0) return run({ prompt: text, claudePrompt: text, images: [] });
-  const directory = await mkdtemp(join(tmpdir(), "granttap-attachments-"));
+  const root = join(configDir(), 'message-attachments');
+  await mkdir(root, { recursive: true, mode: 0o700 });
+  const directory = await mkdtemp(join(root, "granttap-attachments-"));
+  let retained = false;
   try {
     const files = await writeAttachments(directory, attachments);
     const documents = files.filter((file) => !file.image);
     const documentNote = documents.length === 0 ? "" : `\n\nAttached files available locally:\n${documents.map(fileLine).join("\n")}`;
     const claudeNote = `\n\nAttached files available locally (inspect them as part of this request):\n${files.map(fileLine).join("\n")}`;
-    return await run({
+    const result = await run({
       prompt: `${text || "Please inspect the attached content."}${documentNote}`,
       claudePrompt: `${text || "Please inspect the attached content."}${claudeNote}`,
       images: files.filter((file) => file.image).map((file) => file.path),
     });
+    retained = result.delivery === 'native' && documents.length > 0;
+    return result;
   } catch (error) {
     return { ok: false, error: `Could not prepare attachment: ${(error as Error).message}` };
   } finally {
-    await rm(directory, { recursive: true, force: true });
+    if (!retained) await rm(directory, { recursive: true, force: true });
   }
 }
 
+/** Native admission returns before the agent reads documents. Retain those for one day. */
+export function prunePreparedAttachments(now = Date.now()): number {
+  const root = join(configDir(), 'message-attachments');
+  if (!existsSync(root)) return 0;
+  let count = 0;
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !/^granttap-attachments-[a-zA-Z0-9]+$/.test(entry.name)) continue;
+    try {
+      const path = join(root, entry.name);
+      const stat = lstatSync(path);
+      if (!stat.isDirectory() || stat.uid !== process.getuid?.() || stat.mtimeMs > now - 86_400_000) continue;
+      rmSync(path, { recursive: true, force: true });
+      count++;
+    } catch { /* A concurrent delivery may already have removed its own stage. */ }
+  }
+  return count;
+}
+
 type StagedFile = { path: string; image: boolean; name: string };
 
 async function writeAttachments(directory: string, attachments: UserAttachment[]): Promise<StagedFile[]> {

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

@@ -0,0 +1,13 @@
+import { createHash } from 'node:crypto';
+import type { UserAttachment } from '../../../../../packages/protocol/schema';
+import type { DeliveryOptions } from './types';
+
+/** Restaging an attachment changes its local path, not the controller's intent. */
+export function deliveryIntent(text: string, attachments: UserAttachment[], options: DeliveryOptions): string {
+  return createHash('sha256').update(JSON.stringify({ text,
+    attachments: attachments.map(file => ({ name: file.name, mimeType: file.mimeType,
+      digest: createHash('sha256').update(Buffer.from(file.data, 'base64')).digest('hex') })),
+    model: options.model, effort: options.effort, preferredMcp: options.preferredMcp,
+    skill: options.skill, permissionMode: options.permissionMode,
+  })).digest('hex');
+}

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

@@ -1,8 +1,12 @@
 export type ReplyResult =
-  | { ok: true; text: string; sessionId?: string }
-  | { ok: false; error: string };
+  | { ok: true; text: string; sessionId?: string; delivery?: 'native' }
+  | { ok: false; error: string; delivery?: 'native' };
 
 export type DeliveryOptions = {
+  /** Stable controller delivery ID, also used by the provider's native admission. */
+  messageId?: string;
+  /** Computer-generated identity before temporary attachment paths are inserted. */
+  intentDigest?: string;
   preferredMcp?: string;
   skill?: string;
   model?: string;

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

@@ -4,6 +4,7 @@ import { resolveCodexBinary } from "../../providers/codex-bin";
 import { runProcess } from ".";
 import { providerEffortArgs } from "./provider-effort";
 import type { DeliveryOptions, ReplyResult } from "../payload/types";
+import { deliverToCodexDesktop } from '../../codex-desktop';
 
 function parseCodexJsonl(stdout: string, fallbackSessionId?: string): ReplyResult {
   let lastMessage = "";
@@ -44,13 +45,15 @@ function parseCodexJsonl(stdout: string, fallbackSessionId?: string): ReplyResul
     : { ok: false, error: "Codex returned an empty response." };
 }
 
-export function runCodex(
+export async function runCodex(
   session: SessionInfo,
   text: string,
   timeoutMs: number,
   images: string[] = [],
   options: DeliveryOptions = {},
 ): Promise<ReplyResult> {
+  const native = await deliverToCodexDesktop({ session, text, images, options, timeoutMs });
+  if (native) return native;
   const configured = loadRuntimeConfig().sessionAccess[session.sessionId];
   const disabledMcp = loadRuntimeConfig().sessionMcpDisabled[session.sessionId] ?? [];
   const sandbox = configured === "read-only"
@@ -71,7 +74,7 @@ export function runCodex(
     "exec", "resume", ...accessArgs, ...mcpArgs, ...modelArgs, ...providerEffortArgs("codex", options.effort), ...imageArgs,
     session.sessionId, "--json", "-",
   ];
-  return runProcess(
+  const result = await runProcess(
     resolveCodexBinary(),
     args,
     session.cwd,
@@ -80,6 +83,9 @@ export function runCodex(
     text,
     session.sessionId,
   );
+  return !result.ok && /thread-store conflict|already has an active writer/i.test(result.error)
+    ? { ok: false, error: 'Codex already owns this chat. Keep its window open and retry the message in GrantTap.' }
+    : result;
 }
 
 function tomlKey(value: string): string {

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

@@ -3,6 +3,7 @@ import { setSessionPaused } from "../config";
 import { compactCodexSession } from "../providers/codex-control";
 import { deliverToSession, stopDeliveries } from "../reply";
 import { scanSessionHistory, scanSessions } from "../sessions";
+import { interruptCodexDesktop } from '../codex-desktop';
 
 const DELIVERY_TIMEOUT_MS = 240_000;
 
@@ -31,6 +32,9 @@ export async function controlTaskSession(
   }
   if (message.action === "pause") {
     const stopped = stopDeliveries(sessionId);
+    const desktop = await interruptCodexDesktop(sessionId);
+    if (desktop?.ok) return reply(true,
+      'Paused. Codex acknowledged the stop request. Every new tool call from this chat is refused until you resume.');
     return reply(true, stopped > 0
       ? `Paused. Stop requested for ${stopped} running turn${stopped === 1 ? "" : "s"}; process exit is not yet confirmed. Every new tool call from this chat is refused until you resume.`
       : "Paused: every tool call from this chat is refused until you resume.");

package/apps/mcp/src/desktop/delivery/task-send.ts

@@ -47,7 +47,7 @@ export function desktopTaskSend(input: unknown,
   if (prior) return prior;
   const attachments = readDesktopAttachments(query.attachments_json);
   if (!attachments || !text.trim() && attachments.length === 0) return Promise.resolve(undefined);
-  const operation = deliver(session, text.trim(), 240_000, attachments, options).then((result) => ({
+  const operation = deliver(session, text.trim(), 240_000, attachments, { ...options, messageId: deliveryId }).then((result) => ({
     operation: "desktop.task_send", accepted: result.ok,
     error: result.ok ? null : result.error.slice(0, 500),
   }), () => ({ operation: "desktop.task_send", accepted: false,

package/cursor-plugin/.cursor-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "granttap",
   "displayName": "GrantTap",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "description": "GrantTap pairs this computer with iPhone. The connection card shows a one-time QR when Cursor supports interactive MCP Apps; an interactive terminal command is available if it does not. The website approves the coding app.",
   "author": {
     "name": "GrantTap",

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.77
+npm install -g granttap-mcp@0.8.78
 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.77\";\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.78\";\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.77";
+const PACKAGE = "granttap-mcp@0.8.78";
 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.77",
+  "version": "0.8.78",
   "description": "Commercial computer runtime connecting local coding agents to GrantTap on Mac, iPhone, iPad and Apple Watch.",
   "type": "module",
   "bin": {