granttap-mcp 0.8.75 → 0.8.78

package/apps/bridge/src/bin/cli/setup.ts

@@ -11,7 +11,7 @@ import {
   type InstallResult,
 } from "../../install";
 import { createOneTimePairing, DEFAULT_RELAY, PAIRING_CODE_TTL_MINUTES } from "../../pairing";
-import { declareEngine } from "../../engine/protocol/engine-declaration";
+import { prepareEngine } from "../../engine/distribution";
 import { isMachineConfigured } from "../../../../mcp/src/status/pairing-status";
 import { removeCursorUserGrantTap } from "../../../../mcp/src/cursor-config";
 import { installHttpMcpService, waitForHttpMcpHealth } from "../../../../mcp/src/http-service";
@@ -59,15 +59,14 @@ async function main(): Promise<void> {
   // Declared before the helper is written, so the LaunchAgent picks the engine
   // up in the same run rather than needing a second one.
   const engineFlag = process.argv.indexOf("--engine");
-  const engine = declareEngine(
-    engineFlag >= 0 ? process.argv[engineFlag + 1] : undefined,
-  );
+  if (engineFlag >= 0 && !process.argv[engineFlag + 1]) throw new Error("Choose an executable after --engine");
+  const engine = await prepareEngine(engineFlag >= 0 ? process.argv[engineFlag + 1] : undefined);
   const helper = installMonitorHelper();
   let httpService: InstallResult | null = null;
   let cursorConfig: InstallResult | null = null;
   const mcpClientInstalled = before.agents.some((item) => item.installed);
   if (before.cursor.installed || mcpClientInstalled) {
-    httpService = installHttpMcpService();
+    httpService = installHttpMcpService({ forceReload: true });
     if (process.platform === "win32" && httpService.status !== "manual"
       && !await waitForHttpMcpHealth(undefined, 15_000)) {
       httpService = { status: "manual", detail: "Windows background service did not become healthy." };
@@ -112,9 +111,7 @@ async function main(): Promise<void> {
         ? "Next: keep the GrantTap plugin. Pair and change settings in the GrantTap app, not Cursor MCP settings."
         : !paired
           ? "Next: pair from the GrantTap plugin connection card or the GrantTap app."
-          : engine
-            ? "Governance is live. Restart the helper to pick it up: launchctl kickstart -k gui/$(id -u)/com.granttap.monitor"
-            : "Governance stays off until an engine is found. Point at one with: granttap setup --engine <path>",
+          : "Ready. Continue from GrantTap on your controller device.",
     "",
   ].join("\n"));
 }

package/apps/bridge/src/bin/hooks/cursor-hook.ts

@@ -112,6 +112,11 @@ async function continueApproval(
     return;
   }
 
+  if (process.env.GRANTTAP_CURSOR_ACP === "1") {
+    nativeAsk("GrantTap will show this action through the active Cursor conversation.");
+    return;
+  }
+
   const timeoutMs = Number(process.env.GRANTTAP_APPROVAL_TIMEOUT_MS ?? 60_000);
   let decision;
   try {
@@ -137,6 +142,6 @@ function cursorCwd(input: CursorHookInput): string | undefined {
 }
 
 main().catch(() => {
-  nativeAsk("GrantTap shell hook failed; use Cursor approval.");
+  deny("GrantTap could not verify this Cursor Task's execution scope.");
   process.exit(0);
 });

package/apps/bridge/src/bin/runtime/cursor-mcp-hook.ts

@@ -122,6 +122,11 @@ async function continueApproval(
     return;
   }
 
+  if (process.env.GRANTTAP_CURSOR_ACP === "1") {
+    nativeAsk("GrantTap will show this action through the active Cursor conversation.");
+    return;
+  }
+
   const timeoutMs = Number(process.env.GRANTTAP_APPROVAL_TIMEOUT_MS ?? 60_000);
   let decision;
   try {
@@ -170,6 +175,6 @@ function cursorWorkspaceRoot(input: CursorMcpHookInput): string | undefined {
 }
 
 main().catch(() => {
-  nativeAsk("GrantTap MCP hook failed; use Cursor approval.");
+  deny("GrantTap could not verify this Cursor Task's execution scope.");
   process.exit(0);
 });

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

@@ -3,8 +3,10 @@ import { join } from "node:path";
 import { RelayClient } from "../../../../../packages/core/relay-client";
 import { configDir, loadConfig, machineConfigPath } from "../../config";
 import { EngineSupervisor } from "../../engine/runtime/engine-supervisor";
+import { prepareMonitorEngine } from "../../engine/distribution";
+import { startEngineRecovery } from "../../engine/startup";
 import { meshSnapshotsAsync } from "../../mesh/runtime";
-import { publishedCatalog, recoverCatalogBindings } from "../../session-catalog";
+import { publishedCatalog } from "../../session-catalog";
 import { recoverLocalGraphBindings } from "../../mesh/runtime/graph/binding-sync";
 import { startSessionMonitor } from "../../monitor";
 import { controllerPeerGate } from "../../pairing/controllers";
@@ -22,6 +24,7 @@ let stopping = false;
 let stopEndpointPublisher = () => {};
 let stopTaskDispatch = () => {};
 let stopTaskNetwork = () => {};
+let stopEngineRecovery = () => {};
 
 try {
   const cfg = applyNetworkRoute(loadConfig(machineConfigPath()));
@@ -47,6 +50,7 @@ try {
 const stop = (): void => {
   if (stopping) return;
   stopping = true;
+  stopEngineRecovery();
   stopTaskDispatch();
   stopTaskNetwork();
   monitor.close();
@@ -58,8 +62,9 @@ const stop = (): void => {
 process.on("SIGINT", stop);
 process.on("SIGTERM", stop);
 
-void recoverCatalogBindings({
-  engineAvailable: async () => {
+stopEngineRecovery = startEngineRecovery({
+  prepare: prepareMonitorEngine,
+  available: async () => {
     const health = await engine.ensureAvailable();
     if (health.state !== "disabled" && health.state !== "healthy") {
       process.stderr.write(`[granttap-mcp] Project engine ${health.state}; legacy behavior remains active\n`);
@@ -74,9 +79,13 @@ void recoverCatalogBindings({
       throw error;
     }
   },
-  snapshots: () => {
+  recover: async () => {
     const known = publishedCatalog(client);
-    return meshSnapshotsAsync(known ? [...known.sessions, ...(known.history ?? [])] : []);
+    const snapshots = await meshSnapshotsAsync(known ? [...known.sessions, ...(known.history ?? [])] : []);
+    await recoverLocalGraphBindings(snapshots);
+    await monitor.publish();
   },
-  recover: recoverLocalGraphBindings,
-}).then(() => monitor.publish()).catch(() => undefined);
+  failed: error => {
+    process.stderr.write(`[granttap-mcp] Engine recovery will retry (${error instanceof Error ? error.name : "unknown"})\n`);
+  },
+});

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

@@ -11,4 +11,4 @@ Catalog observations and Project requests do not install a skill or native MCP
 configuration on another host. Availability requires a separate native apply
 and independently observed initialization; that rollout is still unfinished.
 
-License: this module is distributed under the Apache License 2.0 in the repository-root `LICENSE` file.
+License: this module is distributed under the GrantTap Commercial Source License in the repository-root `LICENSE` file.

package/apps/bridge/src/claude-questions/README.md

@@ -10,4 +10,4 @@ an `answers` mapping using Claude's documented PreToolUse `updatedInput` contrac
 
 Tests: `tests/`. Engineering contract: the Apple repository `AGENTS.md`.
 
-License: Apache License 2.0; see the repository LICENSE.
+License: GrantTap Commercial Source License; see the repository LICENSE.

package/apps/bridge/src/cloud-runners/README.md

@@ -45,4 +45,4 @@ The first message is the Task Capsule: goal, status, repository, branch and
 commit, the person's comment, decisions and remaining work, bounded to 12,000
 characters. The visible conversation archive is not uploaded.
 
-Tests: [`tests/`](tests/). Apache License 2.0, see [LICENSE](../../../../LICENSE).
+Tests: [`tests/`](tests/). GrantTap Commercial Source License, see [LICENSE](../../../../LICENSE).

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/codex-hook-trust/README.md

@@ -31,4 +31,4 @@ It never trusts hooks in the user's configuration.
 
 ## License
 
-This module is distributed under the Apache License 2.0. See the repository LICENSE.
+This module is distributed under the GrantTap Commercial Source License. See the repository LICENSE.

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

@@ -6,5 +6,5 @@ and device pairing serialization. `../config.ts` is its public entry point.
 Behavior is covered by `tests/config.test.ts`, `tests/capabilities.test.ts`, and
 `tests/core.test.ts`.
 
-License: this module is distributed under the Apache License 2.0
+License: this module is distributed under the GrantTap Commercial Source License
 in the repository-root `LICENSE` file.

package/apps/bridge/src/config/runtime/index.ts

@@ -1,5 +1,5 @@
 import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { isAbsolute, join, win32 } from "node:path";
 import { writePrivateFile } from "../access/write-private";
 import type {
   AgentAccess,
@@ -132,7 +132,8 @@ function parseSessionList(raw: unknown): string[] {
 
 /** Only an absolute path can be verified, so a relative one is not kept. */
 function parseEnginePath(raw: unknown): string | null {
-  return typeof raw === "string" && raw.startsWith("/") && raw.length <= 1024 ? raw : null;
+  return typeof raw === "string" && raw.length <= 1024 && !/^[/\\]{2}/.test(raw)
+    && (isAbsolute(raw) || win32.isAbsolute(raw)) ? raw : null;
 }
 
 function parseEngineChecksum(raw: unknown): string | null {

package/apps/bridge/src/configuration-delivery/README.md

@@ -7,4 +7,4 @@ computer-enforced chat level. Socket delivery alone is never an applied rule.
 The configuration and task-automation modules own durable admission and tests.
 Engineering contract: the Apple repository `AGENTS.md`.
 
-License: Apache License 2.0; see the repository LICENSE.
+License: GrantTap Commercial Source License; see the repository LICENSE.

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

@@ -12,6 +12,7 @@ type DeliveryRecord = {
   state: "processing" | "completed";
   updatedAt: number;
   processingAcknowledged?: boolean;
+  rejectedError?: string;
 };
 
 export type DeliveryStart = "started" | "processing" | "completed";
@@ -89,6 +90,19 @@ export function completeDelivery(messageId: string, now = Date.now()): void {
   save(records, now);
 }
 
+/** A late provider refusal remains terminal across reconnects and replayed boxes. */
+export function rejectCompletedDelivery(messageId: string, error: string, now = Date.now()): void {
+  const records = load();
+  records[messageId] = { state: 'completed', updatedAt: now, rejectedError: error.slice(0, 1_000) };
+  save(records, now);
+}
+
+export function completedDeliveryFailure(messageId: string): string | undefined {
+  const record = load()[messageId];
+  return record?.state === 'completed' && typeof record.rejectedError === 'string'
+    ? record.rejectedError : undefined;
+}
+
 /** Release a failed attempt so a relay retry can safely try again. */
 export function abandonDelivery(messageId: string, now = Date.now()): void {
   const records = load();

package/apps/bridge/src/device-network/README.md

@@ -12,7 +12,7 @@ forwarding or promise background iPhone delivery. Self-hosted mode has no
 managed directory announcement. Settings never contain pairing secret keys.
 
 Behavior tests live in `tests/network.test.ts`. This machine runtime module is
-covered by the repository Apache License 2.0; the separately installed relay follows
+covered by the repository GrantTap Commercial Source License; the separately installed relay follows
 its own license and customer terms.
 
-This runtime module is covered by the repository Apache License 2.0.
+This runtime module is covered by the repository GrantTap Commercial Source License.

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

@@ -2,9 +2,9 @@
 
 This module owns the versioned local IPC boundary between the public machine
 runtime and the separately distributed GrantTap Engine. `engine-client.ts`
-implements bounded length-prefixed framing and a persistent multiplexed Unix
-socket. A timed-out request is never retried automatically on the hook-critical
-path. `engine-supervisor.ts` keeps rollout opt-in, verifies the configured
+implements bounded length-prefixed framing and a persistent multiplexed local
+socket or Windows named pipe. A timed-out request is never retried automatically
+on the hook-critical path. `engine-supervisor.ts` verifies the configured
 binary by SHA-256 before launch, and reports explicit health without changing
 legacy hook behavior when the engine is disabled or unavailable.
 `engine-projects.ts` forwards only bounded local Project/binding records when
@@ -49,5 +49,18 @@ the durable journal.
 
 The proprietary engine source and Project database do not live in this package.
 
-License: this module is distributed under the Apache License 2.0
+Every CLI entry point loads the persisted Engine declaration before importing
+its runtime. The monitor, HTTP MCP and provider hooks therefore share activation
+on macOS, Linux and Windows rather than relying on a LaunchAgent environment.
+Explicit disablement and a complete explicit executable/checksum pair win over
+the saved declaration. Partial environment overrides are never mixed with a
+different file's checksum. The supervisor still verifies the executable's bytes
+before launch. Windows clients derive a local named pipe from the normalized
+configuration path; remote shares never become Engine endpoints.
+The paired monitor installs the pinned managed Engine in the background when
+needed. Catalog delivery does not await that download. Failed preparation retries
+without losing phone questions, and a restarted helper re-admits verified local
+checkouts. Explicit disablement and custom declarations are preserved.
+
+License: this module is distributed under the GrantTap Commercial Source License
 in the repository-root `LICENSE` file.

package/apps/bridge/src/engine/distribution/README.md

@@ -0,0 +1,20 @@
+# Engine distribution
+
+`index.ts` exposes installation of the commercial Engine. Release
+metadata is reviewed with the MCP source and pins the exact platform, size and
+SHA-256. Downloads use the fixed GrantTap HTTPS origin, no redirects or cookies,
+a deadline and a streaming byte limit. A download cannot choose its own hash.
+
+Verified executables live in versioned private directories. New bytes are
+written and synced to an exclusive temporary file before an atomic rename.
+Failed downloads leave the previous declared Engine untouched. Setup and the
+paired monitor save a new declaration only after verification.
+Custom executable declarations remain available through `setup --engine`.
+
+Provider hooks never download an executable. The catalog can connect and replay
+questions independently of Engine installation and repository analysis.
+The monitor prepares a missing or outdated managed Engine in the background,
+retries failed downloads and recovers verified bindings once it becomes healthy.
+Explicit disablement and custom executable declarations remain in force.
+
+License: GrantTap Commercial Source License, in the repository-root `LICENSE`.