granttap-mcp 0.8.101 → 0.8.104

package/README.md

@@ -855,3 +855,17 @@ See [repository observations](apps/bridge/src/mesh/repository-details/README.md)
 The relay can retain recipient-encrypted catalogs, Mesh snapshots, capability usage and recent chat heads for reconnect without the computer. This bounded seven-day read cache is separate from the durable encrypted command queue. See [relay state publication](packages/core/retained-state/README.md). The relay never receives decryption keys or readable chat content.
 
 Tools & Skills matches recorded usage to the exact computer, provider and execution. Codex's native history projection supplies actual MCP invocation IDs, results and durations, including calls made through Code Mode. Claude Code uses observed tool-use, result and Skill records, aggregating MCP and skill calls before its recent-detail cache is trimmed. Execution summaries remain available when older call details fall outside the recent-event budget. Counts describe recorded evidence; installation and permission do not prove usage. Missing resource measurements remain unknown. See [native capability history](apps/bridge/src/sessions/native-capability-history/README.md).
+
+## Automatic runtime updates
+
+Installed GrantTap background services check for stable MCP updates automatically.
+Verified updates are staged separately and applied after active requests and pending
+decisions finish. Startup failures restore the previous version. Pairing and task
+policies are retained; source checkouts and running provider processes stay in place.
+
+In the plugin's GrantTap connection card, use **Automatic updates: On / Off**.
+The choice is saved for this computer and takes effect without restarting the
+service. Off prevents further update checks and activation; an already running
+download may finish staging, and the current runtime keeps running. Turn it on to
+resume automatic checks. `GRANTTAP_DISABLE_AUTO_UPDATE=1` on the service overrides
+the card and keeps the switch disabled.

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

@@ -1,3 +1,5 @@
+import { startRuntimeUpdates } from "../../runtime-updates";
+import { runtimeUpdateReadiness } from "../../runtime-updates/readiness";
 /** Persistent, terminal-free task sync for the GrantTap phone app on macOS. */
 import { join } from "node:path";
 import { RelayClient } from "../../../../../packages/core/relay-client";
@@ -25,6 +27,8 @@ let stopEndpointPublisher = () => {};
 let stopTaskDispatch = () => {};
 let stopTaskNetwork = () => {};
 let stopEngineRecovery = () => {};
+let stopRuntimeUpdates = () => {};
+let stopUpdateReadiness = () => {};
 
 try {
   const cfg = applyNetworkRoute(loadConfig(machineConfigPath()));
@@ -40,6 +44,8 @@ try {
   stopTaskNetwork = startTaskNetworkMonitor({ config: cfg, client,
     isLeader: monitor.isLeader, peerAllowed: controllerPeerGate(cfg), publish: monitor.publish });
   stopEndpointPublisher = startEndpointPublisher(cfg);
+  stopRuntimeUpdates = startRuntimeUpdates(monitor.canUpdate);
+  stopUpdateReadiness = runtimeUpdateReadiness(monitor.canUpdate);
 } catch (error) {
   process.stderr.write(
     `[granttap-mcp] monitor is not paired: ${error instanceof Error ? error.message : String(error)}\n`,
@@ -50,6 +56,8 @@ try {
 const stop = (): void => {
   if (stopping) return;
   stopping = true;
+  stopRuntimeUpdates();
+  stopUpdateReadiness();
   stopEngineRecovery();
   stopTaskDispatch();
   stopTaskNetwork();

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

@@ -121,6 +121,7 @@ export async function handleUserMessage(
   onProcessing?: () => Promise<void>,
   peerPublicKey?: string,
   native?: { messageId: string; nativeOnly: true },
+  onRefusal?: (error: string) => Promise<void>,
 ): Promise<"accepted" | "rejected"> {
   const say = (text: string, sessionId?: string, wake = false, kind: "status" | "response" = "response") => {
     const payload = agentEventForUserMessage(message, text, sessionId, kind);
@@ -129,6 +130,11 @@ export async function handleUserMessage(
       ? sendSessionPayload(client, payload, sessionId, "phone", options)
       : client.send(payload, "phone", options)).catch(() => {});
   };
+  const refuse = async (error: string, wake = false): Promise<"rejected"> => {
+    await onRefusal?.(error);
+    await say(error, message.sessionId, wake);
+    return "rejected";
+  };
   if (!message.sessionId) {
     const origin = message.taskOriginId && peerPublicKey ? {
       registry: localTaskOrigins(),
@@ -150,23 +156,16 @@ export async function handleUserMessage(
   // 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";
-  }
+  if (!target) return refuse("This task is no longer available on the computer.");
 
   const settings = loadRuntimeConfig().providerSettings;
   if (target.agent in settings
     && settings[target.agent as keyof typeof settings] === false) {
-    await say("This agent is disabled in GrantTap Settings.", message.sessionId, true);
-    return "rejected";
+    return refuse("This agent is disabled in GrantTap Settings.", true);
   }
 
   const routingError = deliveryRoutingError(target, message);
-  if (routingError) {
-    await say(routingError, target.sessionId);
-    return "rejected";
-  }
+  if (routingError) return refuse(routingError);
 
   // No "sent, waiting" line from a middleman: the delivery receipt already
   // marks the person's bubble, and the next words in the chat are the answer.

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

@@ -22,6 +22,11 @@ message again. Only the original authenticated controller, room, and session
 may read it. Older unscoped records are not exposed through this query.
 Receipts to a known controller use its device encryption directly, so a missed
 task-key grant cannot hide a provider rejection or processing acknowledgement.
+For existing chats, refusals before provider dispatch (missing task, disabled provider, or rejected
+task capability) also persist a scoped rejected receipt before the relay box is
+consumed. The original controller can recover that specific refusal after a
+restart or lost response. Missing attachment recovery retains its existing
+transport behavior; an admission refusal is never reported as agent activity.
 
 A correlated `agentActivityAt` receipt is emitted only after provider stream output
 confirms activity. It is retained under the original controller, room and session

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

@@ -1,7 +1,8 @@
 import type { Payload } from "../../../../../packages/protocol/schema";
 import type { RelayClient } from "../../../../../packages/core/relay-client";
 import { abandonDelivery, beginDelivery, completeDelivery,
-  acknowledgeProcessingDelivery, processingDeliveryAcknowledged, completedDeliveryFailure, deliveryReceiptStatus } from "../../delivery";
+  acknowledgeProcessingDelivery, processingDeliveryAcknowledged, completedDeliveryFailure, deliveryReceiptStatus,
+  rejectCompletedDelivery } from "../../delivery";
 import { sendDeliveryReceipt } from "../handlers/receipts";
 import { handleUserMessage } from "../handlers/user-message";
 
@@ -34,9 +35,15 @@ export async function handleInboundUserMessage(
       if (!payload.messageId) return;
       acknowledgeProcessingDelivery(payload.messageId);
       await sendDeliveryReceipt(client, payload.messageId, "accepted", undefined, payload.sessionId, peerPublicKey);
-    }, peerPublicKey, native);
+    }, peerPublicKey, native, async error => {
+      if (!payload.messageId) return;
+      rejectCompletedDelivery(payload.messageId, error);
+      await sendDeliveryReceipt(client, payload.messageId, 'rejected', error, payload.sessionId, peerPublicKey);
+    });
     if (payload.messageId && deliveryStarted) {
-      if (outcome === "rejected") abandonDelivery(payload.messageId);
+      if (outcome === "rejected") {
+        if (!completedDeliveryFailure(payload.messageId)) abandonDelivery(payload.messageId);
+      }
       else {
         completeDelivery(payload.messageId);
         await sendDeliveryReceipt(client, payload.messageId, "accepted", undefined, payload.sessionId, peerPublicKey);

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

@@ -1,3 +1,4 @@
+import { runtimeWorkTracker } from "../../runtime-updates/readiness";
 import { refreshCodexHooks } from "../../codex-hook-trust";
 import { computerDisplayName } from "../../../../../packages/core/computer-name";
 import { RelayClient } from "../../../../../packages/core/relay-client";
@@ -38,6 +39,7 @@ import { publishMonitorCapabilities, stopMonitorCapabilities } from "../capabili
 export type SessionMonitor = {
   publish: () => Promise<void>;
   isLeader: () => boolean;
+  canUpdate: () => boolean;
   close: () => void;
 };
 
@@ -163,29 +165,13 @@ async function publishMonitorTick(input: {
 export function startSessionMonitor(client: RelayClient): SessionMonitor {
   const subscriptions = new Set<string>();
   const leadership = monitorLeadership();
-  primeSessionKeys(client);
-  publishedCatalog(client);
+  restoreMonitorState(client);
   let historyCache: { generatedAt: number; sessions: SessionsStatus["sessions"] } | undefined;
   let historyRead: Promise<SessionsStatus["sessions"]> | undefined;
   let lastHistoryPublishedAt = 0;
   let closed = false;
-  const publishMachineLoad = createMachineLoadPublisher({
-    log: (line) => process.stderr.write(`[monitor] ${line}\n`),
-  });
-  const loadLoop = startMachineLoadLoop({
-    connected: () => client.isConnected,
-    // Only the leader reports load. Every MCP server used to run this loop
-    // too, each with the code of the day it started, and the phone flickered
-    // between their answers.
-    publish: (status, intervalMs) => (leadership.acquire()
-      ? publishMachineLoad(client, status, intervalMs)
-      : Promise.resolve(undefined)),
-    onError: (error) => {
-      process.stderr.write(
-        `[monitor] load report failed: ${error instanceof Error ? error.message : String(error)}\n`,
-      );
-    },
-  });
+  const work = runtimeWorkTracker(() => approvalsStatus().pending.length > 0);
+  const loadLoop = monitorLoadLoop(client, leadership);
 
   const history = (force = false): Promise<SessionsStatus["sessions"]> => {
     if (historyRead) return historyRead;
@@ -209,7 +195,7 @@ export function startSessionMonitor(client: RelayClient): SessionMonitor {
     lastHistoryPublishedAt = next.lastHistoryPublishedAt;
   });
 
-  const off = client.onMessage(async (payload: Payload, peerPublicKey) => {
+  const off = client.onMessage((payload: Payload, peerPublicKey) => work.run(async () => {
     if (payload.type === "hello" && payload.role === "phone") {
       confirmPendingController(client.room, peerPublicKey);
       recordControllerName(peerPublicKey, payload.deviceName);
@@ -219,8 +205,8 @@ export function startSessionMonitor(client: RelayClient): SessionMonitor {
         await replayNativeQuestions(client, peerPublicKey);
       }
     }
-    return handleMonitorMessage(client, payload, { leadership, subscriptions, publish, peerPublicKey });
-  });
+    return await handleMonitorMessage(client, payload, { leadership, subscriptions, publish, peerPublicKey });
+  }));
 
   const offConnected = client.onConnected?.(() => publish().catch(() => {}));
 
@@ -244,6 +230,7 @@ export function startSessionMonitor(client: RelayClient): SessionMonitor {
   return {
     publish: () => publish(false),
     isLeader: () => leadership.acquire(),
+    canUpdate: work.idle,
     close: () => {
       closed = true;
       offConnected?.();
@@ -279,3 +266,28 @@ async function replayNativeQuestions(client: RelayClient, peerPublicKey: string)
   const known = publishedCatalog(client);
   if (known) await publishCodexQuestions(client, known.sessions, { replay: true, peerPublicKey }).catch(() => {});
 }
+
+function restoreMonitorState(client: RelayClient): void {
+  primeSessionKeys(client);
+  publishedCatalog(client);
+}
+
+function monitorLoadLoop(client: RelayClient, leadership: ReturnType<typeof monitorLeadership>) {
+  const publishMachineLoad = createMachineLoadPublisher({
+    log: (line) => process.stderr.write(`[monitor] ${line}\n`),
+  });
+  return startMachineLoadLoop({
+    connected: () => client.isConnected,
+    // Only the leader reports load. Every MCP server used to run this loop
+    // too, each with the code of the day it started, and the phone flickered
+    // between their answers.
+    publish: (status, intervalMs) => (leadership.acquire()
+      ? publishMachineLoad(client, status, intervalMs)
+      : Promise.resolve(undefined)),
+    onError: (error) => {
+      process.stderr.write(
+        `[monitor] load report failed: ${error instanceof Error ? error.message : String(error)}\n`,
+      );
+    },
+  });
+}

package/apps/bridge/src/runtime-updates/README.md

@@ -0,0 +1,32 @@
+# Automatic GrantTap runtime updates
+
+The installed background monitor checks the official `granttap-mcp` npm stable
+release every four hours. New versions are installed in a separate private
+version directory under `~/.granttap/runtime-updates`, with lifecycle scripts
+disabled, Node engine checks enabled, and registry integrity verified. A failed
+installation leaves the running version in place.
+
+The stable launcher selects the verified version for future invocations. Owned
+background services switch only after their current requests finish and no
+approval is pending. Existing provider processes and active stdio MCP calls keep
+running. A new service that cannot start restores the previous version; that
+failed version is quarantined until a newer release appears.
+
+Pairing, account credentials, task history, capability policy, and provider
+installations are not modified by runtime updates. Offline checks retry later.
+Source checkouts and test processes do not update themselves. The plugin's
+connection card offers a persistent **Automatic updates: On / Off** switch for
+this computer. The running monitor reads it before registry checks and activation;
+the launcher checks it again before handing off an owned service. Off keeps the
+current selected runtime and rollback protection. An in-progress download may
+finish staging but cannot activate while off. Re-enabling is observed on the next
+minute tick without restarting services. Administrators may
+set `GRANTTAP_DISABLE_AUTO_UPDATE=1` on their service to retain their installed
+version. Private staging consumes space; old versions are retained for rollback.
+
+Public entry: `startRuntimeUpdates`, `runtimeUpdateReadiness`, and the launcher's
+`selection.mjs` / `supervision.mjs` boundary. Tests exercise failed downloads and
+verification, deferred activation, concurrent installation, selection, and startup
+rollback using isolated directories and owned child processes.
+
+License: [GrantTap Commercial Source License](../../../../LICENSE).

package/apps/bridge/src/runtime-updates/http-readiness.ts

@@ -0,0 +1,17 @@
+import type { Express } from 'express';
+
+/** Long-lived HTTP/SSE calls defer replacement until their normal completion. */
+export function trackHttpRuntimeWork(app:Express):()=>boolean {
+  let activeRequests=0;
+  app.use((_req,res,next)=>{
+    activeRequests++;
+    let finished=false;
+    const complete=()=>{
+      if(!finished) {finished=true;activeRequests--;}
+    };
+    res.once('finish',complete);
+    res.once('close',complete);
+    next();
+  });
+  return ()=>activeRequests===0;
+}

package/apps/bridge/src/runtime-updates/index.ts

@@ -0,0 +1,74 @@
+import { closeSync, mkdirSync, openSync, statSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { configDir } from '../config/runtime/paths';
+import { latestRelease, trustedRelease, installRelease, verifyRelease, type Release } from './registry';
+import { newerVersion, readState, runtimeVersion, saveState, validRuntime, versionRoot } from './selection.mjs';
+import { automaticUpdatesAllowed } from './preferences/storage.mjs';
+export { runtimeUpdateSettings, setRuntimeAutoUpdate } from './preferences';
+
+type Options={root:string;stateDirectory:string;now?:()=>number;latest?:()=>Promise<unknown>;
+  idle:()=>boolean;install?:(release:Release,directory:string)=>Promise<void>;
+  verify?:(root:string)=>Promise<void>;activate?:(root:string)=>void};
+
+/** Stage verified releases independently; activation waits until no request or decision is pending. */
+export async function checkForRuntimeUpdate(options:Options):Promise<string|undefined> {
+  if(!automaticUpdatesAllowed(options.stateDirectory))return;
+  mkdirSync(options.stateDirectory,{recursive:true,mode:0o700});
+  const lock=join(options.stateDirectory,'install.lock');let fd:number;
+  try {fd=openSync(lock,'wx',0o600);} catch {return undefined;}
+  try {
+    const release=await (options.latest??latestRelease)();
+    if(!automaticUpdatesAllowed(options.stateDirectory))return;
+    const state=readState(options.stateDirectory);
+    if(!trustedRelease(release) || !newerVersion(release.version,runtimeVersion(options.root))
+      || state.rejectedVersion===release.version || (state.version && !newerVersion(release.version,state.version)))return;
+    const candidate=versionRoot(options.stateDirectory,release.version);
+    if(!validRuntime(candidate,options.stateDirectory,release.version)) {
+      await (options.install??installRelease)(release,options.stateDirectory);
+    }
+    if(!automaticUpdatesAllowed(options.stateDirectory))return;
+    await (options.verify??verifyRelease)(candidate);
+    if(!validRuntime(candidate,options.stateDirectory,release.version))throw Error('Runtime verification failed');
+    if(!options.idle() || !automaticUpdatesAllowed(options.stateDirectory))return;
+    saveState(options.stateDirectory,{root:candidate,version:release.version,
+      previous:state.root?{root:state.root,version:state.version}:undefined});
+    options.activate?.(candidate);return candidate;
+  } finally {closeSync(fd);unlinkSync(lock);}
+}
+
+type LoopOptions={root:string;directory:string;idle:()=>boolean;check?:typeof checkForRuntimeUpdate;
+  now?:()=>number;schedule?:typeof setTimeout;report?:()=>void;activate?:()=>void};
+
+/** Check failure never stops sync; timers are owned and cancellation prevents another check. */
+export function runtimeUpdateLoop(options:LoopOptions):()=>void {
+  let stopped=false,timer:NodeJS.Timeout|undefined,lastCheck=0;
+  const now=options.now??Date.now,schedule=options.schedule??setTimeout;
+  const tick=async()=>{
+    if(stopped)return;
+    try {
+      if(!automaticUpdatesAllowed(options.directory)){lastCheck=0;return;}
+      const lock=join(options.directory,'install.lock');
+      try {if(now()-statSync(lock).mtimeMs>10*60_000)unlinkSync(lock);} catch { /* no stale lock */ }
+      if(now()-lastCheck>=4*60*60_000) {
+        await (options.check??checkForRuntimeUpdate)({root:options.root,stateDirectory:options.directory,idle:options.idle,
+          activate:()=>options.activate?.()});
+        lastCheck=options.idle()?now():0;
+      }
+    } catch {options.report?.();}
+    finally {if(!stopped){timer=schedule(()=>void tick(),60_000);timer.unref();}}
+  };
+  timer=schedule(()=>void tick(),60_000);timer.unref();
+  return ()=>{stopped=true;if(timer)clearTimeout(timer);};
+}
+
+/** Only the owned installed background monitor downloads updates; source checkouts stay fixed. */
+export function startRuntimeUpdates(idle:()=>boolean):()=>void {
+  if(process.env.GRANTTAP_DISABLE_AUTO_UPDATE==='1' || process.env.GRANTTAP_LOCAL==='1'
+    || process.env.NODE_TEST_CONTEXT || !process.send)return ()=>{};
+  const root=fileURLToPath(new URL('../../../../',import.meta.url));
+  if(!root.includes('node_modules'))return ()=>{};
+  return runtimeUpdateLoop({root,directory:join(configDir(),'runtime-updates'),idle,
+    activate:()=>process.send?.({type:'granttap.runtime-update-ready'},()=>{}),
+    report:()=>process.stderr.write('[granttap-mcp] Automatic runtime update deferred; current version retained.\n')});
+}

package/apps/bridge/src/runtime-updates/preferences/README.md

@@ -0,0 +1,18 @@
+# Runtime update preference
+
+The public runtime-updates entry exports `runtimeUpdateSettings` and
+`setRuntimeAutoUpdate`. The connection card stores the computer-wide choice in
+`runtime-updates/preferences.json`, separately from version selection and pairing.
+Missing settings retain the existing enabled default; unreadable settings pause
+updates. A service-level `GRANTTAP_DISABLE_AUTO_UPDATE=1` takes precedence.
+
+The monitor checks the saved preference before registry access and before
+activation. Its loop observes changes without restarting. The launcher checks it
+again before asking the owned service to drain or stopping that service. Turning
+updates off retains the selected working version and startup rollback protection.
+
+Integration tests in `../tests/preferences.test.ts` cover live off/on and an
+in-flight update. Connection-center tests cover persistence through actual MCP
+calls, pairing preservation, service overrides, and the DOM switch.
+
+License: [GrantTap Commercial Source License](../../../../../LICENSE).

package/apps/bridge/src/runtime-updates/preferences/index.ts

@@ -0,0 +1,12 @@
+import { join } from 'node:path';
+import { configDir } from '../../config';
+import { automaticUpdateSettings, saveAutomaticUpdateSetting } from './storage.mjs';
+
+export function runtimeUpdateSettings() {
+  return automaticUpdateSettings(join(configDir(), 'runtime-updates'));
+}
+
+/** A running monitor reads this preference before its next check and before activation. */
+export function setRuntimeAutoUpdate(enabled: boolean): void {
+  saveAutomaticUpdateSetting(join(configDir(), 'runtime-updates'), enabled);
+}

package/apps/bridge/src/runtime-updates/preferences/storage.d.mts

@@ -0,0 +1,4 @@
+export type AutomaticUpdateSettings = { enabled: boolean; lockedByEnvironment: boolean };
+export function automaticUpdateSettings(directory: string): AutomaticUpdateSettings;
+export function automaticUpdatesAllowed(directory: string): boolean;
+export function saveAutomaticUpdateSetting(directory: string, enabled: boolean): void;

package/apps/bridge/src/runtime-updates/preferences/storage.mjs

@@ -0,0 +1,35 @@
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/** Missing preferences preserve the installed default; unreadable settings pause updates. */
+export function automaticUpdateSettings(directory) {
+  const lockedByEnvironment = process.env.GRANTTAP_DISABLE_AUTO_UPDATE === '1';
+  let enabled;
+  try {
+    const value = JSON.parse(readFileSync(join(directory, 'preferences.json'), 'utf8'));
+    enabled = value?.automaticUpdatesEnabled === true;
+  } catch (error) { enabled = error?.code === 'ENOENT'; }
+  return { enabled: enabled && !lockedByEnvironment, lockedByEnvironment };
+}
+
+export function automaticUpdatesAllowed(directory) {
+  return automaticUpdateSettings(directory).enabled;
+}
+
+/** Separate from selected versions, pairing, credentials, and capability policy. */
+export function saveAutomaticUpdateSetting(directory, enabled) {
+  if (typeof enabled !== 'boolean') throw new TypeError('Automatic updates require a boolean setting');
+  if (enabled && process.env.GRANTTAP_DISABLE_AUTO_UPDATE === '1') {
+    throw new Error('Automatic updates are disabled by service configuration');
+  }
+  mkdirSync(directory, { recursive: true, mode: 0o700 });
+  const path = join(directory, 'preferences.json');
+  const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
+  try {
+    writeFileSync(temporary, JSON.stringify({ automaticUpdatesEnabled: enabled }) + '\n', { mode: 0o600 });
+    renameSync(temporary, path);
+  } finally {
+    try { unlinkSync(temporary); } catch (error) { if (error?.code !== 'ENOENT') throw error; }
+  }
+}

package/apps/bridge/src/runtime-updates/readiness.ts

@@ -0,0 +1,23 @@
+/** Only the launcher's private IPC channel can ask the owned service to drain for an update. */
+export function runtimeUpdateReadiness(idle:()=>boolean):()=>void {
+  const listener=(message:unknown)=>{
+    if((message as {type?:string})?.type==='granttap.runtime-update-check' && idle()) {
+      process.send?.({type:'granttap.runtime-update-ready'},()=>{});
+    }
+  };
+  process.on('message',listener);
+  process.send?.({type:'granttap.runtime-healthy'},()=>{});
+  return ()=>{process.off('message',listener);};
+}
+
+/** Count async work until completion; an update cannot interrupt a partially delivered command. */
+export function runtimeWorkTracker(blocked:()=>boolean) {
+  let count=0;
+  return {
+    idle:()=>count===0 && !blocked(),
+    run:async<T>(work:()=>Promise<T>):Promise<T>=>{
+      count++;
+      try {return await work();} finally {count--;}
+    },
+  };
+}

package/apps/bridge/src/runtime-updates/registry.ts

@@ -0,0 +1,58 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { stableVersion, validRuntime, versionRoot } from './selection.mjs';
+
+export type Release = {name:string;version:string;dist:{integrity:string;tarball:string}};
+const registry='https://registry.npmjs.org';
+export function trustedRelease(value:unknown):value is Release {
+  const r=value as Release|undefined;
+  return r?.name==='granttap-mcp' && stableVersion(r.version)
+    && typeof r.dist?.integrity==='string' && /^sha512-[A-Za-z0-9+/]{86}==$/.test(r.dist.integrity)
+    && r.dist.tarball===`${registry}/granttap-mcp/-/granttap-mcp-${r.version}.tgz`;
+}
+/** Registry metadata is bounded, timed, and never changes the installed runtime by itself. */
+export async function latestRelease():Promise<unknown> {
+  const response=await fetch(registry+'/granttap-mcp/latest',{signal:AbortSignal.timeout(10_000),redirect:'error'});
+  if(!response.ok || !response.body) throw Error('Runtime registry unavailable');
+  const reader=response.body.getReader();let size=0;const chunks:Uint8Array[]=[];
+  try { for(;;) {const {done,value}=await reader.read();if(done)break;
+    size+=value.byteLength;if(size>262_144)throw Error('Runtime metadata exceeds limit');chunks.push(value);
+  } } finally {await reader.cancel();}
+  return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+}
+export function run(command:string,args:string[],timeoutMs=180_000,env:NodeJS.ProcessEnv=process.env):Promise<void> {
+  return new Promise((resolve,reject)=>{
+    const child=spawn(command,args,{env,stdio:'ignore',windowsHide:true});let done=false;
+    const finish=(error?:Error)=>{if(done)return;done=true;clearTimeout(timer);error?reject(error):resolve();};
+    const timer=setTimeout(()=>{child.kill();finish(Error('Runtime update command timed out'));},timeoutMs);
+    child.once('error',()=>finish(Error('Runtime update command could not start')));
+    child.once('exit',code=>finish(code===0?undefined:Error('Runtime update command failed')));
+  });
+}
+function npmCli():string {
+  const bin=dirname(process.execPath);
+  for(const path of [join(bin,'npm'),join(bin,'node_modules','npm','bin','npm-cli.js'),
+    join(bin,'..','lib','node_modules','npm','bin','npm-cli.js')]) {
+    if(existsSync(path) && !path.endsWith('.cmd'))return realpathSync(path);
+  }
+  throw Error('The installed Node runtime has no npm updater');
+}
+/** npm verifies registry integrity and Node compatibility in a version-specific, isolated prefix. */
+export async function installRelease(release:Release,directory:string,runner=run):Promise<void> {
+  await runner(process.execPath,[npmCli(),'install','--prefix',join(directory,'versions',release.version),
+    '--registry',registry,'--ignore-scripts','--engine-strict','--omit=dev','--no-audit','--no-fund',
+    '--save-exact',`granttap-mcp@${release.version}`]);
+  const lock=JSON.parse(readFileSync(join(directory,'versions',release.version,'package-lock.json'),'utf8'));
+  const installed=lock.packages?.['node_modules/granttap-mcp'];
+  if(installed?.version!==release.version || installed?.integrity!==release.dist.integrity
+    || installed?.resolved!==release.dist.tarball || !validRuntime(versionRoot(directory,release.version),directory,release.version)) {
+    throw Error('Installed runtime identity or registry integrity did not match');
+  }
+}
+export async function verifyRelease(root:string):Promise<void> {
+  await run(process.execPath,[join(root,'bin','granttap-mcp.mjs'),'--help'],15_000,
+    {...process.env,GRANTTAP_DISABLE_AUTO_UPDATE:'1'});
+  // Validate the launcher without starting services or reading the live pairing.
+  await run(process.execPath,['--check',join(root,'bin','granttap-mcp.mjs')],15_000);
+}

package/apps/bridge/src/runtime-updates/selection.d.mts

@@ -0,0 +1,10 @@
+export type RuntimeState = {root?:string;version?:string;rejectedVersion?:string;previous?:RuntimeState};
+export function stableVersion(value:unknown):value is string;
+export function newerVersion(candidate:string,current:string):boolean;
+export function readState(directory:string):RuntimeState;
+export function saveState(directory:string,state:RuntimeState):void;
+export function runtimeVersion(root:string):string;
+export function versionRoot(directory:string,version:string):string;
+export function validRuntime(root:string|undefined,directory:string,version:string|undefined):boolean;
+export function selectedRuntime(bundled:string,directory:string):string;
+export function rollbackRuntime(bundled:string,directory:string,failedRoot?:string):boolean;

package/apps/bridge/src/runtime-updates/selection.mjs

@@ -0,0 +1,46 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+export const stableVersion = value => typeof value === 'string' && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(value);
+export function newerVersion(candidate, current) {
+  if (!stableVersion(candidate) || !stableVersion(current)) return false;
+  const a=candidate.split('.').map(Number), b=current.split('.').map(Number);
+  for(let i=0;i<3;i++) { if(a[i]!==b[i]) return a[i]>b[i]; }
+  return false;
+}
+export function readState(directory) {
+  try { return JSON.parse(readFileSync(join(directory,'active.json'),'utf8')); } catch { return {}; }
+}
+export function saveState(directory, state) {
+  mkdirSync(directory,{recursive:true,mode:0o700});
+  const path=join(directory,'active.json'), temporary=path+'.'+process.pid+'.tmp';
+  writeFileSync(temporary,JSON.stringify(state),{mode:0o600});renameSync(temporary,path);
+}
+export function runtimeVersion(root) {
+  const p=JSON.parse(readFileSync(join(root,'package.json'),'utf8'));
+  if(p.name!=='granttap-mcp' || !stableVersion(p.version)) throw Error('Invalid GrantTap runtime package');
+  return p.version;
+}
+export function versionRoot(directory, version) {
+  return join(directory,'versions',version,'node_modules','granttap-mcp');
+}
+export function validRuntime(root, directory, version) {
+  try { return stableVersion(version) && resolve(root)===resolve(versionRoot(directory,version))
+    && runtimeVersion(root)===version && existsSync(join(root,'bin','granttap-mcp.mjs')); } catch { return false; }
+}
+/** The stable launcher accepts only a verified, newer package inside its private version cache. */
+export function selectedRuntime(bundled, directory) {
+  const state=readState(directory);
+  return validRuntime(state.root,directory,state.version) && newerVersion(state.version,runtimeVersion(bundled))
+    ? state.root : bundled;
+}
+/** A new background service that exits during startup restores the last working selection. */
+export function rollbackRuntime(bundled, directory, failedRoot) {
+  const state=readState(directory);
+  if(!state.version || (failedRoot && state.root!==failedRoot)) return false;
+  const rejectedVersion=state.version, previous=state.previous;
+  if(previous && validRuntime(previous.root,directory,previous.version)) {
+    saveState(directory,{...previous,rejectedVersion});
+  } else saveState(directory,{rejectedVersion});
+  return true;
+}

package/apps/bridge/src/runtime-updates/supervision.mjs

@@ -0,0 +1,29 @@
+import { selectedRuntime, rollbackRuntime } from './selection.mjs';
+import { automaticUpdatesAllowed } from './preferences/storage.mjs';
+
+/** Monitor only the child started by this launcher; external providers are never stopped. */
+export function superviseRuntime(child, options) {
+  const {bundled,root,directory}=options;
+  const started=(options.now??Date.now)();let healthy=root===bundled,stopped=false;
+  const read=()=>selectedRuntime(bundled,directory);
+  const changed=()=>read()!==root;
+  const stop=()=>{if(stopped)return;stopped=true;clearInterval(timer);child.off('message',onMessage);};
+  const onMessage=message=>{
+    if(message?.type==='granttap.runtime-healthy')healthy=true;
+    if(message?.type==='granttap.runtime-update-ready' && automaticUpdatesAllowed(directory) && changed()) {stop();child.kill('SIGTERM');}
+  };
+  const tick=()=>{
+    if(stopped)return;
+    if(!healthy && (options.now??Date.now)()-started>120_000) {
+      rollbackRuntime(bundled,directory,root);stop();child.kill('SIGTERM');return;
+    }
+    if(automaticUpdatesAllowed(directory) && changed() && child.connected)child.send({type:'granttap.runtime-update-check'},()=>{});
+  };
+  const timer=(options.schedule??setInterval)(tick,10_000);timer.unref?.();child.on('message',onMessage);
+  return {stop,onExit:(code,signal)=>{
+    if(!stopped && !healthy && code!==0 && !['SIGTERM','SIGINT'].includes(signal)) {
+      rollbackRuntime(bundled,directory,root);
+    }
+    stop();
+  }};
+}

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

@@ -35,6 +35,11 @@ answers below the current request. Native completion marks the final visible
 answer. Existing entry IDs replace cached timestamps without duplicating history.
 Session continuation uses the installed Grok CLI and its existing authentication.
 
+Prepared transfer chats retain their stable Task identity and are ranked again
+after native-session aliasing, before the bounded live and history windows.
+A transferred chat therefore keeps its native activity position instead of
+being appended behind older chats and disappearing from the phone's catalog.
+
 ## License
 
 Licensed under the GrantTap Commercial Source License. See LICENSE and NOTICE.

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

@@ -56,9 +56,9 @@ async function cooperativeProviderScans(maxFiles = MAX_FILES): Promise<ProviderS
   return scans;
 }
 
-function sortedUniqueSessions(scans: ProviderScan[]): SessionInfo[] {
+function sortedUniqueSessions(sessions: SessionInfo[]): SessionInfo[] {
   const merged = new Map<string, SessionInfo>();
-  for (const session of scans.flatMap((scan) => scan.sessions)) {
+  for (const session of sessions) {
     const key = sessionKey(session);
     const previous = merged.get(key);
     if (!previous || session.lastActivityAt >= previous.lastActivityAt) {
@@ -97,8 +97,12 @@ function pickWithReserve(
 }
 
 function catalogFromScans(scans: ProviderScan[]) {
+  const native = sortedUniqueSessions(scans.flatMap((scan) => scan.sessions));
+  // Prepared transfers replace native ids; rank their native activity before
+  // the bounded live/history windows, rather than appending them after older chats.
+  const sessions = sortedUniqueSessions(localTaskTransfers().catalog(native));
   return {
-    all: localTaskTransfers().catalog(sortedUniqueSessions(scans)).map(session => ({ ...session,
+    all: sessions.map(session => ({ ...session,
       transfer: localTransferContinuations().notice(session.sessionId) })),
     tokensRecent: scans.reduce((sum, scan) => sum + scan.tokensRecent, 0),
     sourceLimited: scans.some((scan) => scan.sourceLimited === true),

package/apps/mcp/src/connection-center/README.md

@@ -32,6 +32,13 @@ the one-time URL from structured tool output when a host omits MCP metadata.
 The separate coding-app OAuth page can also use passkey to authorize that MCP
 client. The Codex-owned plugin management page is not this card.
 
+The Automatic updates switch calls `set_runtime_auto_update` with an explicit
+boolean and displays the confirmed persisted result from the server. The setting
+is computer-wide for the GrantTap runtime; marketplace plugin updates stay under
+the coding app's control. A service environment override locks it off. Failed
+saves do not optimistically change the switch. Pairing and capability policy are
+stored separately and preserved.
+
 Tests in `tests/` exercise isolated keys, a loopback encrypted phone connection,
 expiry, non-mutating status, and actual DOM button/host-message behavior.
 

package/apps/mcp/src/connection-center/bridge.js

@@ -70,11 +70,11 @@ async function call(name, args = {}) {
     const result = legacyBridge
       ? await legacyCall(name, args)
       : await request("tools/call", { name, arguments: args });
-    if (result?.isError) message("Could not complete the request. Refresh status and check the relay before retrying.");
+    if (result?.isError) message("Could not complete the request. Refresh status before retrying.");
     else { render(result); message("Status updated."); }
     return result;
   } catch {
-    message("No successful response. Refresh status before retrying; pairing may already have changed.");
+    message("No successful response. Refresh status before retrying.");
   } finally {
     setBusy(false);
   }

package/apps/mcp/src/connection-center/state.ts

@@ -7,6 +7,7 @@ import { packageVersion } from "../status/package-version";
 import { connectionRuntimeStatus } from "../mcp-tools/connect/relay";
 import { beginEnrollment, cancelEnrollment, enrollmentIsOpen } from "./enrollment";
 import { loadAccountLink } from "../../../bridge/src/account-recovery/link";
+import { runtimeUpdateSettings } from "../../../bridge/src/runtime-updates";
 
 export const connectionOutput = {
   status: z.enum(["disconnected", "paired", "pairing", "expired", "connected"]),
@@ -25,6 +26,7 @@ export const connectionOutput = {
   providers: z.array(z.object({ id: z.string(), status: z.string(), detail: z.string() })),
   roomPrefix: z.string(),
   accountLinkSaved: z.boolean(),
+  runtimeUpdates: z.object({ enabled: z.boolean(), lockedByEnvironment: z.boolean() }),
   passkeyUrl: z.string().url().optional(),
 };
 
@@ -80,6 +82,7 @@ export class ConnectionState {
         providers: inspectProviderStatusSnapshot().providers.map(({ id, status, detail }) => ({ id, status, detail })),
         roomPrefix: config?.room ? config.room.slice(0, 8) : "",
         accountLinkSaved: loadAccountLink() !== null,
+        runtimeUpdates: runtimeUpdateSettings(),
       },
       _meta: { granttap: code ? { pairingUri: code.pairingUri, qrDataUrl: code.qrDataUrl } : {} },
     };

package/apps/mcp/src/connection-center/update-controls.ts

@@ -0,0 +1,23 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { setRuntimeAutoUpdate } from '../../../bridge/src/runtime-updates';
+import { connectionOutput } from './state';
+
+export function registerRuntimeUpdateControl(
+  server: McpServer, result: () => CallToolResult, meta: Record<string, unknown>,
+): void {
+  server.registerTool('set_runtime_auto_update', {
+    title: 'GrantTap automatic updates',
+    description: 'Enable or disable automatic GrantTap runtime updates on this computer when the user requests it. Saves the preference without restarting services or changing pairing, tasks, or provider policy.',
+    inputSchema: { enabled: z.boolean().describe('Whether this computer should automatically check for and apply stable GrantTap runtime updates') },
+    outputSchema: connectionOutput,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    _meta: meta,
+  }, async ({ enabled }) => {
+    try { setRuntimeAutoUpdate(enabled); return result(); }
+    catch {
+      return { isError: true, content: [{ type: 'text', text: 'Could not save automatic update settings. Service configuration may disable updates. Refresh status to see the current setting.' }] };
+    }
+  });
+}

package/apps/mcp/src/connection-center/view.js

@@ -7,6 +7,16 @@ function message(text) { $("message").textContent = text; }
 function setBusy(value) {
   busy = value;
   document.querySelectorAll("button").forEach(button => { button.disabled = value; });
+  renderUpdateSetting();
+}
+function renderUpdateSetting() {
+  const setting = current.runtimeUpdates;
+  $("automatic-updates").textContent = "Automatic updates: " + (setting ? setting.enabled ? "On" : "Off" : "Unknown");
+  $("automatic-updates").setAttribute("aria-checked", String(setting?.enabled === true));
+  $("automatic-updates").disabled = busy || !setting || setting.lockedByEnvironment;
+  $("updates-detail").textContent = setting?.lockedByEnvironment
+    ? "Disabled by service configuration."
+    : "Checks for stable GrantTap runtime updates every 4 hours. Off keeps this computer’s current version.";
 }
 function clearCode() {
   pairingUri = "";
@@ -19,6 +29,7 @@ function render(value) {
   const state = result?.structuredContent ?? result?.structured_content;
   if (!state?.status || result.isError) return;
   current = state;
+  renderUpdateSetting();
   clearCode();
   const meta = result._meta?.granttap ?? {};
   const candidate = state.passkeyUrl || meta.passkeyUrl;
@@ -102,6 +113,7 @@ $("connect").addEventListener("click", () => {
   call("connect");
 });
 $("refresh").addEventListener("click", () => call("connection_status"));
+$("automatic-updates").addEventListener("click", () => call("set_runtime_auto_update", { enabled: !current.runtimeUpdates.enabled }));
 $("passkey").addEventListener("click", () => call("connect_with_passkey"));
 $("reconnect").addEventListener("click", () => {
   pendingMode = "reconnect";

package/apps/mcp/src/connection-center/widget.html

@@ -31,6 +31,7 @@ details{border-top:1px solid #8884;padding-top:14px}summary{cursor:pointer;font-
     <img id="qr" class="hidden" alt="GrantTap pairing QR" />
   </section>
   <p id="expiry" class="small" aria-live="polite"></p>
+  <section aria-label="Runtime updates"><div class="actions"><button id="automatic-updates" role="switch" aria-checked="false" aria-describedby="updates-detail" disabled>Automatic updates: Unknown</button></div><p id="updates-detail" class="small">Checking update settings…</p></section>
   <details><summary>Connection details &amp; help</summary>
     <dl><dt>Computer</dt><dd id="computer">—</dd><dt>MCP version</dt><dd id="version">—</dd>
     <dt>Relay observed by this MCP</dt><dd id="relay">Not checked</dd>

package/apps/mcp/src/http/http-server.ts

@@ -1,3 +1,6 @@
+import { trackHttpRuntimeWork } from "../../../bridge/src/runtime-updates/http-readiness";
+import { runtimeUpdateReadiness } from "../../../bridge/src/runtime-updates/readiness";
+import { approvalsStatus } from "../../../bridge/src/approvals/state";
 /**
  * GrantTap MCP over Streamable HTTP + loopback OAuth with website consent.
  *
@@ -63,6 +66,7 @@ export async function startHttpMcpServer(options: ServeOptions = {}): Promise<{
   const issuerUrl = new URL(`http://${host === "::1" ? "[::1]" : host}:${port}`);
   const provider = new GrantTapOAuthProvider(mcpUrl.href);
   const app = createMcpExpressApp({ host });
+  const httpIdle = trackHttpRuntimeWork(app);
   app.use(express.urlencoded({ extended: false }));
   app.use(mcpAuthRouter({
     provider,
@@ -120,11 +124,13 @@ export async function startHttpMcpServer(options: ServeOptions = {}): Promise<{
   const stopAccountRecovery = accountOrigin
     ? startAccountRecoveryPoller(accountOrigin, refreshRecoveredPairing) : () => {};
 
+  const stopUpdateReadiness=runtimeUpdateReadiness(()=>httpIdle() && approvalsStatus().pending.length===0);
   return {
     host,
     port,
     mcpUrl: mcpUrl.href,
     close: async () => {
+      stopUpdateReadiness();
       stopAccountRecovery();
       await sessions.close();
       resetConnectWatchers();

package/apps/mcp/src/mcp-tools/README.md

@@ -1,7 +1,8 @@
 # MCP tools
 
 The Personal MCP surface is an exact allowlist: `connection_status`, `connect`,
-`reconnect`, `notify`, `ask_yes_no`, and `ask`. Context compilation belongs
+`connect_with_passkey`, `reconnect`, `set_runtime_auto_update`, `notify`,
+`ask_yes_no`, `ask`, and `offload_task`. Context compilation belongs
 inside Project Mesh, not as extra tools. `relay.ts` owns one shared encrypted relay connection
 and the durable question lifecycle. Machine setup, custom relay selection, and
 pairing reset remains an explicit CLI operation. The narrower `reconnect` MCP
@@ -32,3 +33,7 @@ The connection center lives in `../connection-center`. Status requests are
 read-only. Saved pairing, a connected relay socket, and recent encrypted phone
 activity are separate observations. Only explicit connect/reconnect requests
 create codes; transfer material is carried in UI metadata and a user-facing QR.
+
+`set_runtime_auto_update` saves the user’s computer-wide runtime update choice
+from the connection card. It preserves pairing and capability policy, and cannot
+override a service-level disable. Status exposes the confirmed setting.

package/apps/mcp/src/mcp-tools/connect/index.ts

@@ -8,6 +8,7 @@ import { ConnectionState, connectionOutput } from "../../connection-center/state
 import { CONNECTION_WIDGET_URI } from "./widget";
 import { resetRelay, relay } from "./relay";
 import { startPasskeyAccountLink } from "../../connection-center/passkey";
+import { registerRuntimeUpdateControl } from "../../connection-center/update-controls";
 
 const widgetMeta = {
   ui: { resourceUri: CONNECTION_WIDGET_URI, visibility: ["model", "app"] },
@@ -26,6 +27,7 @@ const changes = {
 
 export function registerConnectTool(server: McpServer): void {
   const state = new ConnectionState();
+  registerRuntimeUpdateControl(server, () => connectionResult(state), widgetMeta);
   let pendingCall: Promise<CallToolResult> | null = null;
   const perform = (options: { issue?: boolean; replace?: boolean; addController?: boolean } = {}) => {
     if (pendingCall) return pendingCall;
@@ -126,7 +128,7 @@ async function connect(
 
 function connectionResult(state: ConnectionState): CallToolResult {
   const snapshot = state.snapshot();
-  const { status, computer, relay, version, relayStatus } = snapshot.structuredContent;
+  const { status, computer, relay, version, relayStatus, runtimeUpdates } = snapshot.structuredContent;
   const instructions = status === "pairing"
     ? "Use the GrantTap card: tap Add a device if needed, then scan the QR on the card."
     : status === "disconnected" ? "Use the GrantTap card and tap Add a device. The QR stays on the card."
@@ -135,7 +137,7 @@ function connectionResult(state: ConnectionState): CallToolResult {
   return {
     ...snapshot,
     content: [{ type: "text", text:
-      `GrantTap: ${status}. Computer: ${computer}. MCP ${version}. Relay: ${relay || "not configured"} (${relayStatus}).\n${instructions}`,
+      `GrantTap: ${status}. Computer: ${computer}. MCP ${version}. Relay: ${relay || "not configured"} (${relayStatus}). Automatic runtime updates: ${runtimeUpdates.enabled ? "on" : "off"}.\n${instructions}`,
     }],
   };
 }

package/apps/mcp/src/mcp-tools/connect/widget.ts

@@ -1,6 +1,6 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
-export const CONNECTION_WIDGET_URI = "ui://granttap/connection/v4.html";
+export const CONNECTION_WIDGET_URI = "ui://granttap/connection/v5.html";
 
 import { readFileSync } from "node:fs";
 

package/bin/granttap-mcp.mjs

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { selectedRuntime, runtimeVersion, rollbackRuntime } from "../apps/bridge/src/runtime-updates/selection.mjs";
+import { superviseRuntime } from "../apps/bridge/src/runtime-updates/supervision.mjs";
 import { createRequire } from "node:module";
 import { delimiter, dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -12,7 +15,12 @@ if (!isSupportedNode(process.versions.node)) {
   process.exit(1);
 }
 
-const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const bundledRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+const updateDirectory = join(process.env.GRANTTAP_CONFIG_DIR ?? process.env.NODVOX_CONFIG_DIR
+  ?? join(homedir(), ".granttap"), "runtime-updates");
+const managed = bundledRoot.includes("node_modules") && process.env.GRANTTAP_LOCAL !== "1"
+  && process.env.GRANTTAP_DISABLE_AUTO_UPDATE !== "1" && !process.env.NODE_TEST_CONTEXT;
+const root = managed ? selectedRuntime(bundledRoot, updateDirectory) : bundledRoot;
 const [command = "mcp", ...commandArgs] = process.argv.slice(2);
 const argument = commandArgs[0];
 
@@ -85,7 +93,7 @@ if (command === "mcp") {
 
 // Cursor (and LaunchAgents) often spawn with cwd=$HOME. Bare `--import tsx` then
 // resolves from home and dies with ERR_MODULE_NOT_FOUND. Pin absolute loaders + cwd.
-const requireFromBin = createRequire(import.meta.url);
+const requireFromBin = createRequire(join(root,"package.json"));
 let preflight;
 let loader;
 try {
@@ -105,6 +113,7 @@ try {
   }
 }
 if (!preflight || !loader) {
+  if (root !== bundledRoot) rollbackRuntime(bundledRoot, updateDirectory, root);
   process.stderr.write(
     "[granttap-mcp] unable to resolve the installed tsx runtime — reinstall granttap-mcp\n",
   );
@@ -114,22 +123,27 @@ if (!preflight || !loader) {
 const forwardedArgs = ["connect", "status", "reset", "mesh", "setup", "restrictions", "phone"].includes(command)
   ? (command === "mesh" || command === "restrictions" ? commandArgs.slice(1) : commandArgs)
   : [];
+const background = command === "internal" && ["monitor", "serve"].includes(argument);
 const child = spawn(
   process.execPath,
   ["--require", preflight, "--import", pathToFileURL(loader).href,
     "--import", pathToFileURL(join(root, "apps", "bridge", "src", "engine", "startup", "activation-entry.ts")).href,
     entry, ...forwardedArgs],
   {
-    stdio: "inherit",
+    stdio: background ? ["inherit", "inherit", "inherit", "ipc"] : "inherit",
     cwd: root,
     env: {
       ...process.env,
+      GRANTTAP_PACKAGE_VERSION: runtimeVersion(root),
       NODE_PATH: [join(root, "node_modules"), process.env.NODE_PATH].filter(Boolean).join(delimiter),
     },
   },
 );
 
+const supervision = background && managed ? superviseRuntime(child, {bundled:bundledRoot, root, directory:updateDirectory}) : undefined;
+
 function stopChild() {
+  supervision?.stop();
   try {
     if (process.platform === "win32") child.kill();
     else child.kill("SIGTERM");
@@ -148,6 +162,7 @@ child.on("error", (error) => {
 });
 
 child.on("exit", (code, signal) => {
+  supervision?.onExit(code, signal);
   if (signal && process.platform !== "win32") {
     try { process.kill(process.pid, signal); } catch { process.exit(code ?? 1); }
   } else process.exit(code ?? 1);

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.101
+npm install -g granttap-mcp@0.8.104
 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.101\";\nconst dryRun = process.env.GRANTTAP_BOOTSTRAP_DRY_RUN === \"1\";\nconst platform = dryRun && process.env.GRANTTAP_BOOTSTRAP_PLATFORM\n  ? process.env.GRANTTAP_BOOTSTRAP_PLATFORM : process.platform;\nconst nodeRoot = dryRun && process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT\n  ? process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT : dirname(process.execPath);\nconst pathRoots = (process.env.PATH || \"\").split(delimiter).filter(Boolean);\nconst appData = process.env.APPDATA;\nconst roots = [nodeRoot, ...pathRoots, ...(appData ? [join(appData, \"npm\")] : [])];\nconst first = (paths) => paths.find((path) => existsSync(path));\n\nfunction launch() {\n  if (platform !== \"win32\") {\n    const installed = first(roots.map((root) => join(root, \"granttap-mcp\")));\n    if (installed) return { command: installed, args: [] };\n    const npx = first(roots.map((root) => join(root, \"npx\"))) || \"npx\";\n    return { command: npx, args: [\"-y\", PACKAGE] };\n  }\n  const installed = first(roots.map((root) =>\n    join(root, \"node_modules\", \"granttap-mcp\", \"bin\", \"granttap-mcp.mjs\")));\n  if (installed) return { command: process.execPath, args: [installed] };\n  const npx = first(roots.map((root) =>\n    join(root, \"node_modules\", \"npm\", \"bin\", \"npx-cli.js\")));\n  if (npx) return { command: process.execPath, args: [npx, \"-y\", PACKAGE] };\n  throw new Error(\"Node.js/npm 22.13.0+ is required on this Windows device. Install npm and retry GrantTap.\");\n}\n\nlet target;\ntry { target = launch(); }\ncatch (error) {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n}\n\nif (dryRun) {\n  process.stdout.write(JSON.stringify(target));\n  process.exit(0);\n}\n\nconst child = spawn(target.command, target.args, { stdio: \"inherit\", windowsHide: true });\nchild.on(\"error\", (error) => {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n});\nchild.on(\"exit\", (code, signal) => {\n  if (signal && platform !== \"win32\") {\n    try { process.kill(process.pid, signal); } catch { process.exit(code ?? 1); }\n    return;\n  }\n  process.exit(code ?? 1);\n});\n"
+        "\"use strict\";\n\n// Cursor may start this MCP from any cwd. Execute JavaScript entry points with\n// Node itself: Windows batch shims require shell quoting that differs by host.\nconst { spawn } = require(\"node:child_process\");\nconst { existsSync } = require(\"node:fs\");\nconst { delimiter, dirname, join } = require(\"node:path\");\n\nconst PACKAGE = \"granttap-mcp@0.8.104\";\nconst dryRun = process.env.GRANTTAP_BOOTSTRAP_DRY_RUN === \"1\";\nconst platform = dryRun && process.env.GRANTTAP_BOOTSTRAP_PLATFORM\n  ? process.env.GRANTTAP_BOOTSTRAP_PLATFORM : process.platform;\nconst nodeRoot = dryRun && process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT\n  ? process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT : dirname(process.execPath);\nconst pathRoots = (process.env.PATH || \"\").split(delimiter).filter(Boolean);\nconst appData = process.env.APPDATA;\nconst roots = [nodeRoot, ...pathRoots, ...(appData ? [join(appData, \"npm\")] : [])];\nconst first = (paths) => paths.find((path) => existsSync(path));\n\nfunction launch() {\n  if (platform !== \"win32\") {\n    const installed = first(roots.map((root) => join(root, \"granttap-mcp\")));\n    if (installed) return { command: installed, args: [] };\n    const npx = first(roots.map((root) => join(root, \"npx\"))) || \"npx\";\n    return { command: npx, args: [\"-y\", PACKAGE] };\n  }\n  const installed = first(roots.map((root) =>\n    join(root, \"node_modules\", \"granttap-mcp\", \"bin\", \"granttap-mcp.mjs\")));\n  if (installed) return { command: process.execPath, args: [installed] };\n  const npx = first(roots.map((root) =>\n    join(root, \"node_modules\", \"npm\", \"bin\", \"npx-cli.js\")));\n  if (npx) return { command: process.execPath, args: [npx, \"-y\", PACKAGE] };\n  throw new Error(\"Node.js/npm 22.13.0+ is required on this Windows device. Install npm and retry GrantTap.\");\n}\n\nlet target;\ntry { target = launch(); }\ncatch (error) {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n}\n\nif (dryRun) {\n  process.stdout.write(JSON.stringify(target));\n  process.exit(0);\n}\n\nconst child = spawn(target.command, target.args, { stdio: \"inherit\", windowsHide: true });\nchild.on(\"error\", (error) => {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n});\nchild.on(\"exit\", (code, signal) => {\n  if (signal && platform !== \"win32\") {\n    try { process.kill(process.pid, signal); } catch { process.exit(code ?? 1); }\n    return;\n  }\n  process.exit(code ?? 1);\n});\n"
       ]
     }
   }

package/cursor-plugin/stdio-bootstrap.cjs

@@ -7,7 +7,7 @@ const { spawn } = require("node:child_process");
 const { existsSync } = require("node:fs");
 const { delimiter, dirname, join } = require("node:path");
 
-const PACKAGE = "granttap-mcp@0.8.101";
+const PACKAGE = "granttap-mcp@0.8.104";
 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.101",
+  "version": "0.8.104",
   "description": "Commercial computer runtime connecting local coding agents to GrantTap on Mac, iPhone, iPad and Apple Watch.",
   "type": "module",
   "bin": {