@quantiya/codevibe-antigravity-plugin 2.0.10 → 2.0.12

package/dist/server.js

@@ -32,7 +32,9 @@ var server_exports = {};
 __export(server_exports, {
   McpServer: () => McpServer,
   SessionNotFoundError: () => SessionNotFoundError,
+  TERMINAL_SHUTDOWN_SIGNALS: () => TERMINAL_SHUTDOWN_SIGNALS,
   __testing: () => __testing,
+  classifyTmuxHasSessionError: () => classifyTmuxHasSessionError,
   generateLaunchSessionId: () => generateLaunchSessionId,
   getActiveConversationFromCliLog: () => getActiveConversationFromCliLog,
   parseMaybeJson: () => parseMaybeJson
@@ -42,6 +44,8 @@ var crypto3 = __toESM(require("crypto"));
 var path5 = __toESM(require("path"));
 var fs5 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
+var import_child_process3 = require("child_process");
+var import_util3 = require("util");
 var import_codevibe_core4 = require("@quantiya/codevibe-core");
 
 // src/logger.ts
@@ -1121,13 +1125,16 @@ var TmuxPaneObserver = class _TmuxPaneObserver extends import_events2.EventEmitt
         if (kind === "question") {
           const q = extractQuestionHeader(snapshot);
           headerText = q ? q.body : null;
+        } else if (kind === "file_access") {
+          const fileAccess = extractFileAccessPrompt(snapshot);
+          headerText = fileAccess ? fileAccess.identity : null;
         } else if (kind === "approval") {
           headerText = extractHeader(snapshot);
         }
       }
-      return { active, headerText };
+      return { active, headerText, probeSucceeded: true };
     } catch {
-      return { active: false, headerText: null };
+      return { active: false, headerText: null, probeSucceeded: false };
     }
   }
   // ─── tmux pipe-pane plumbing ─────────────────────────────────────────────
@@ -1388,7 +1395,7 @@ var TmuxPaneObserver = class _TmuxPaneObserver extends import_events2.EventEmitt
 function looksLikePromptDelta(chunk) {
   return (
     // Approval UI signatures
-    /Requesting permission for:/i.test(chunk) || /Do you want to proceed\?/i.test(chunk) || /\besc to cancel\b/i.test(chunk) || /^\s*[1-9]\. (?:Yes|No)\b/im.test(chunk) || /\[(?:y\/n|Y\/n|y\/N)\]/.test(chunk) || /Question \d+\/\d+:/i.test(chunk) || /\benter Select\b/i.test(chunk)
+    /Requesting permission for:/i.test(chunk) || /Do you want to proceed\?/i.test(chunk) || /\besc to cancel\b/i.test(chunk) || /^\s*[1-9]\. (?:Yes|No)\b/im.test(chunk) || /\[(?:y\/n|Y\/n|y\/N)\]/.test(chunk) || /Question \d+\/\d+:/i.test(chunk) || /\benter Select\b/i.test(chunk) || /^File access\s*$/im.test(chunk) || /Allow access to this file\?/i.test(chunk) || /No, deny access/i.test(chunk)
   );
 }
 function looksLikePromptSnapshot(snapshot) {
@@ -1402,8 +1409,31 @@ function looksLikePromptSnapshot(snapshot) {
   const hasQuestionOptions = /^[>\s]+[1-9]\. \S/im.test(recent);
   const hasQuestionFooter = /\benter Select\b/i.test(recent);
   const isQuestion = hasQuestionHeader && hasQuestionOptions && hasQuestionFooter;
+  const hasFileAccessHeader = /^File access\s*$/im.test(recent);
+  const hasFileAccessQuestion = /Allow access to this file\?/i.test(recent);
+  const isFileAccess = hasFileAccessHeader && hasFileAccessQuestion && hasApprovalOptions && hasApprovalFooter;
   const legacyYN = /\[(?:y\/n|Y\/n|y\/N)\]/.test(recent) && /\b(?:apply|approve|allow|continue|proceed|run|execute|confirm)\b/i.test(recent);
-  return legacyYN || isApproval || isQuestion;
+  return legacyYN || isApproval || isQuestion || isFileAccess;
+}
+function extractFileAccessPrompt(snapshot) {
+  const stripped = snapshot.replace(ANSI_ESCAPE_REGEX, "");
+  const lines = stripped.split("\n");
+  let headingIndex = -1;
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    if (/^\s*File access\s*$/i.test(lines[index])) {
+      headingIndex = index;
+      break;
+    }
+  }
+  if (headingIndex < 0) return null;
+  const block = lines.slice(headingIndex, headingIndex + 20);
+  const questionIndex = block.findIndex((line) => /Allow access to this file\?/i.test(line));
+  if (questionIndex < 0) return null;
+  const readLine = block.slice(0, questionIndex + 1).find((line) => /^\s*Read:\s*\S/i.test(line));
+  const identity = readLine?.replace(/^\s*Read:\s*/i, "").trim() || "non-workspace file access";
+  const fullLine = block[questionIndex].trim();
+  const body = block.slice(1, questionIndex).join("\n").trim();
+  return { identity, fullLine, body };
 }
 function extractHeader(snapshot) {
   const stripped = snapshot.replace(ANSI_ESCAPE_REGEX, "");
@@ -1422,8 +1452,10 @@ function detectActivePromptKind(snapshot) {
   const lines = stripped.split("\n");
   const approvalRe = /Requesting permission for:/i;
   const questionRe = /Question \d+\/\d+:/i;
+  const fileAccessRe = /^\s*File access\s*$/i;
   let lastApprovalLineIdx = -1;
   let lastQuestionLineIdx = -1;
+  let lastFileAccessLineIdx = -1;
   for (let i = lines.length - 1; i >= 0; i--) {
     if (lastApprovalLineIdx < 0 && approvalRe.test(lines[i])) {
       lastApprovalLineIdx = i;
@@ -1431,10 +1463,15 @@ function detectActivePromptKind(snapshot) {
     if (lastQuestionLineIdx < 0 && questionRe.test(lines[i])) {
       lastQuestionLineIdx = i;
     }
-    if (lastApprovalLineIdx >= 0 && lastQuestionLineIdx >= 0) break;
+    if (lastFileAccessLineIdx < 0 && fileAccessRe.test(lines[i])) {
+      lastFileAccessLineIdx = i;
+    }
+    if (lastApprovalLineIdx >= 0 && lastQuestionLineIdx >= 0 && lastFileAccessLineIdx >= 0) break;
   }
-  if (lastApprovalLineIdx < 0 && lastQuestionLineIdx < 0) return null;
-  if (lastQuestionLineIdx > lastApprovalLineIdx) return "question";
+  const latest = Math.max(lastApprovalLineIdx, lastQuestionLineIdx, lastFileAccessLineIdx);
+  if (latest < 0) return null;
+  if (latest === lastFileAccessLineIdx) return "file_access";
+  if (latest === lastQuestionLineIdx) return "question";
   return "approval";
 }
 function extractQuestionHeader(snapshot) {
@@ -1468,10 +1505,17 @@ var import_events3 = require("events");
 var import_uuid = require("uuid");
 
 // src/prompt-parser.ts
+var import_crypto2 = require("crypto");
 function parseApprovalSnapshot(snapshot) {
   if (!snapshot) return null;
   const stripped = stripAnsi(snapshot);
   const kind = detectActivePromptKind(stripped);
+  if (kind === "file_access") {
+    const fileAccess = extractFileAccessPrompt(stripped);
+    if (fileAccess) {
+      return parseFileAccessSnapshot(stripped, snapshot, fileAccess);
+    }
+  }
   if (kind === "question") {
     const questionHeader = extractQuestionHeader(stripped);
     if (questionHeader) {
@@ -1480,6 +1524,49 @@ function parseApprovalSnapshot(snapshot) {
   }
   return parseApprovalUISnapshot(stripped, snapshot);
 }
+function buildApprovalSemanticKey(candidate) {
+  const normalize = (value) => value.replace(/\s+/g, " ").trim();
+  const payload = {
+    kind: candidate.kind,
+    headerText: normalize(candidate.headerText),
+    body: normalize(candidate.body),
+    options: candidate.options.map((option) => ({
+      number: option.number,
+      text: normalize(option.text)
+    })),
+    submitMap: Object.fromEntries(
+      Object.entries(candidate.submitMap).sort(([left], [right]) => Number(left) - Number(right)).map(([number, keys]) => [number, [...keys]])
+    )
+  };
+  return (0, import_crypto2.createHash)("sha256").update(JSON.stringify(payload)).digest("hex");
+}
+function hasNegativeApprovalOption(options) {
+  return options.some((option) => /^(?:no|deny|reject|cancel)\b/i.test(option.text.trim()));
+}
+function parseFileAccessSnapshot(stripped, originalSnapshot, prompt) {
+  const lines = stripped.split("\n");
+  let questionIndex = -1;
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    if (/Allow access to this file\?/i.test(lines[index])) {
+      questionIndex = index;
+      break;
+    }
+  }
+  const belowQuestion = questionIndex >= 0 ? lines.slice(questionIndex + 1).join("\n") : stripped;
+  const options = parseOptions(belowQuestion);
+  if (options.length < 2 || !hasNegativeApprovalOption(options)) return null;
+  return {
+    kind: "approval",
+    headerText: prompt.identity,
+    fullHeaderLine: prompt.fullLine,
+    command: void 0,
+    filePath: prompt.identity === "non-workspace file access" ? void 0 : prompt.identity,
+    options,
+    submitMap: buildApprovalSubmitMap(options),
+    body: prompt.body,
+    paneHash: hashPromptSnapshot(originalSnapshot)
+  };
+}
 function parseApprovalUISnapshot(stripped, originalSnapshot) {
   const headerText = extractHeader(stripped);
   if (!headerText) return null;
@@ -1494,7 +1581,7 @@ function parseApprovalUISnapshot(stripped, originalSnapshot) {
   }
   const belowHeader = headerIdx >= 0 ? lines.slice(headerIdx + 1).join("\n") : stripped;
   const options = parseOptions(belowHeader);
-  if (options.length < 2) return null;
+  if (options.length < 2 || !hasNegativeApprovalOption(options)) return null;
   const submitMap = buildApprovalSubmitMap(options);
   const { command, filePath } = extractIdentity(headerText);
   const body = extractBodyBetweenHeaderAndFirstOption(belowHeader);
@@ -1785,9 +1872,10 @@ var ApprovalDetector = class extends import_events3.EventEmitter {
       matchedPaneHeader: candidate.headerText,
       paneDisplayHeader: candidate.fullHeaderLine,
       body: candidate.body,
+      paneOptions: candidate.options,
+      paneSemanticKey: buildApprovalSemanticKey(candidate),
       emittedAt: Date.now(),
       ttlMs: this.promptTtlMs,
-      paneOptions: candidate.options,
       // E1 (§6a-2b / F5) — carry the consumed pane hash so an emit-failure
       // rollback can reset the observer's lastPromptHash and let the unchanged
       // live pane re-emit.
@@ -1974,6 +2062,8 @@ var ApprovalDetector = class extends import_events3.EventEmitter {
       matchedPaneHeader: candidate.headerText,
       paneDisplayHeader: candidate.fullHeaderLine,
       body: candidate.body,
+      paneOptions: candidate.options,
+      paneSemanticKey: buildApprovalSemanticKey(candidate),
       emittedAt: Date.now(),
       ttlMs: this.promptTtlMs
     };
@@ -2054,6 +2144,10 @@ var ApprovalDetector = class extends import_events3.EventEmitter {
   getPendingPrompt(promptId) {
     return this.pendingPrompts.get(promptId) ?? null;
   }
+  getPendingPromptsForConversation(conversationId) {
+    const pending = Array.from(this.pendingPrompts.values());
+    return conversationId ? pending.filter((state) => state.conversationId === conversationId) : pending;
+  }
   // ─── Read-only accessors ────────────────────────────────────────────────
   getPendingCalls() {
     return Array.from(this.pendingCalls.values());
@@ -2107,21 +2201,6 @@ var ApprovalDetector = class extends import_events3.EventEmitter {
         this.emit("pending-call-expired", call);
       }
     }
-    let anyExpired = false;
-    for (const [promptId, state] of this.pendingPrompts.entries()) {
-      if (now - state.emittedAt > state.ttlMs) {
-        this.pendingPrompts.delete(promptId);
-        this.resolvedPrompts.set(promptId, now);
-        anyExpired = true;
-        logger.debug("Pending prompt expired (TTL)", {
-          promptId,
-          ageMs: now - state.emittedAt
-        });
-      }
-    }
-    if (anyExpired) {
-      this.paneOnlyEmittedHashes.clear();
-    }
     for (const [promptId, resolvedAt] of this.resolvedPrompts.entries()) {
       if (now - resolvedAt > 5 * 6e4) {
         this.resolvedPrompts.delete(promptId);
@@ -2228,22 +2307,11 @@ var PromptResponder = class {
         };
       }
       if (this.paneObserver) {
-        const probe = await this.paneObserver.probeApprovalUIActive();
-        if (!probe.active) {
-          this.detector.resolvePrompt(promptId);
-          return {
-            ok: false,
-            reason: "prompt-superseded",
-            details: "approval UI vanished from pane (likely user approved on desktop)"
-          };
-        }
-        const expectedHeader = state.matchedPaneHeader;
-        if (expectedHeader && probe.headerText && !sameIdentity(probe.headerText, expectedHeader)) {
-          this.detector.resolvePrompt(promptId);
+        if (!state.paneSemanticKey) {
           return {
             ok: false,
-            reason: "prompt-superseded",
-            details: `pane shows '${probe.headerText}' but matched-against header was '${expectedHeader}'`
+            reason: "prompt-probe-failed",
+            details: "pending prompt has no exact semantic identity"
           };
         }
       }
@@ -2257,6 +2325,51 @@ var PromptResponder = class {
       }
       try {
         for (const key of keys) {
+          if (!this.detector || !this.paneObserver) {
+            return {
+              ok: false,
+              reason: "prompt-probe-failed",
+              details: "approval responder is missing its detector or pane observer"
+            };
+          }
+          if (this.detector.getPendingPrompt(promptId) !== state) {
+            return { ok: false, reason: "prompt-expired" };
+          }
+          let liveSemanticKey = null;
+          try {
+            const snapshot = await this.paneObserver.captureSnapshot();
+            const live = parseApprovalSnapshot(snapshot);
+            if (!live) {
+              if (detectActivePromptKind(snapshot) === null) {
+                this.detector.resolvePrompt(promptId);
+                return {
+                  ok: false,
+                  reason: "prompt-superseded",
+                  details: "the approval chooser is no longer active"
+                };
+              }
+              return {
+                ok: false,
+                reason: "prompt-probe-failed",
+                details: "the active chooser could not be parsed exactly"
+              };
+            }
+            liveSemanticKey = live ? buildApprovalSemanticKey(live) : null;
+          } catch (error) {
+            return {
+              ok: false,
+              reason: "prompt-probe-failed",
+              details: error instanceof Error ? error.message : String(error)
+            };
+          }
+          if (liveSemanticKey !== state.paneSemanticKey) {
+            this.detector.resolvePrompt(promptId);
+            return {
+              ok: false,
+              reason: "prompt-superseded",
+              details: "active chooser semantics differ from the mobile prompt"
+            };
+          }
           if (isNamedKey(key)) {
             await this.sendKey(target, key);
           } else {
@@ -2289,6 +2402,43 @@ var PromptResponder = class {
       };
     }
   }
+  async sendFreeFormWhenNoApprovalActive(text) {
+    const target = this.resolveTmuxTarget();
+    if (!target) return { ok: false, reason: "no-tmux-target" };
+    if (!this.paneObserver) {
+      return {
+        ok: false,
+        reason: "prompt-probe-failed",
+        details: "pane observer is required for safe free-form input"
+      };
+    }
+    const chooserIsAbsent = async () => {
+      const probe = await this.paneObserver.probeApprovalUIActive();
+      if (!probe.probeSucceeded) {
+        return { ok: false, reason: "prompt-probe-failed" };
+      }
+      if (probe.active) {
+        return { ok: false, reason: "prompt-superseded" };
+      }
+      return null;
+    };
+    try {
+      const beforeText = await chooserIsAbsent();
+      if (beforeText) return beforeText;
+      await this.typeLiteral(target, text);
+      await delay(ENTER_DELAY_MS);
+      const beforeEnter = await chooserIsAbsent();
+      if (beforeEnter) return beforeEnter;
+      await this.sendKey(target, "Enter");
+      return { ok: true };
+    } catch (error) {
+      return {
+        ok: false,
+        reason: "tmux-failed",
+        details: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
   // ─── Tmux primitives ────────────────────────────────────────────────────
   async typeLiteral(target, text) {
     const escaped = text.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\$/g, "\\$").replace(/`/g, "\\`");
@@ -2314,9 +2464,6 @@ function isNamedKey(key) {
 function delay(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
-function sameIdentity(headerFromPane, expected) {
-  return headerFromPane.trim() === expected.trim();
-}
 
 // src/mobile-prompt-dedupe.ts
 var DEFAULT_EXPIRY_MS = 15e3;
@@ -2834,6 +2981,27 @@ function truncate(s, maxBytes) {
 // src/server.ts
 var MOBILE_PROMPT_FLOOR_RECENCY_MS = 12e4;
 var LAUNCH_SETTLE_TIMEOUT_MS = 3e3;
+var TMUX_LIFECYCLE_POLL_MS = 1e3;
+var TMUX_LIFECYCLE_INIT_GRACE_MS = 1e4;
+var SESSION_RETIRE_MAX_ATTEMPTS = 3;
+var SESSION_RETIRE_RETRY_MS = 100;
+var execFileAsync = (0, import_util3.promisify)(import_child_process3.execFile);
+var TERMINAL_SHUTDOWN_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+function commandErrorText(error, field) {
+  const value = error?.[field];
+  if (typeof value === "string") return value;
+  if (Buffer.isBuffer(value)) return value.toString("utf8");
+  return "";
+}
+function classifyTmuxHasSessionError(error) {
+  if (typeof error?.code !== "number") return "unknown";
+  const output = `${commandErrorText(error, "stderr")}
+${commandErrorText(error, "stdout")}`;
+  if (/^can't find session:/m.test(output) || /^no server running on /m.test(output) || /^error connecting to .* \((?:No such file or directory|Connection refused)\)$/m.test(output)) {
+    return "absent";
+  }
+  return "unknown";
+}
 var McpServer = class _McpServer {
   constructor(options) {
     /** Per-session causal floor for transcript-event timestamps emitted right
@@ -2974,6 +3142,11 @@ var McpServer = class _McpServer {
     this.signalsRegistered = false;
     this.boundSigintHandler = null;
     this.boundSigtermHandler = null;
+    this.boundSighupHandler = null;
+    this.tmuxLifecycleTimer = null;
+    this.tmuxLifecycleCheckInFlight = false;
+    this.tmuxLifecycleObservedAlive = false;
+    this.tmuxLifecycleInitDeadlineMs = Number.POSITIVE_INFINITY;
     if (!options.bearerToken || options.bearerToken.length < 16) {
       throw new Error("McpServer requires a non-trivial bearerToken");
     }
@@ -3013,6 +3186,8 @@ var McpServer = class _McpServer {
   async start() {
     if (this.started) throw new Error("McpServer.start() called twice");
     this.stopPromise = null;
+    this.stopTmuxLifecycleMonitor();
+    this.tmuxLifecycleObservedAlive = false;
     await fireDaemonBeacon("daemon_init_start", {
       step: "init",
       outcome: "ok",
@@ -3033,6 +3208,7 @@ var McpServer = class _McpServer {
     this.lifecycleGen++;
     this.stopRequestedDuringCreate = false;
     this.registerSignalHandlers();
+    this.startTmuxLifecycleMonitor();
     await (0, import_codevibe_core4.registerDeviceEncryptionKey)(this.appSyncClient, logger);
     if (!this.started) return { httpPort: 0 };
     (0, import_codevibe_core4.startDeviceKeyWatcher)(this.appSyncClient, logger);
@@ -3116,15 +3292,18 @@ var McpServer = class _McpServer {
   }
   async doStop() {
     this.started = false;
-    if (this.launchSessionPromise) {
-      const settled = this.launchSessionPromise.catch(() => void 0);
+    this.stopTmuxLifecycleMonitor();
+    const launchSettlement = this.launchSessionPromise?.catch(() => void 0) ?? null;
+    let mustAwaitLaunchSettlement = false;
+    let hostedRetirementError = null;
+    if (launchSettlement) {
       let timer;
       const timeout = new Promise((resolve3) => {
         timer = setTimeout(resolve3, this.launchSettleTimeoutMs);
         timer.unref?.();
       });
       try {
-        await Promise.race([settled, timeout]);
+        await Promise.race([launchSettlement, timeout]);
       } finally {
         if (timer) clearTimeout(timer);
       }
@@ -3136,8 +3315,9 @@ var McpServer = class _McpServer {
       if (deactivated) {
         if (this.pendingLaunchSessionId === pendingId) this.pendingLaunchSessionId = null;
       } else {
+        mustAwaitLaunchSettlement = launchSettlement !== null;
         logger.error(
-          "doStop: INACTIVE write for the pending launch row FAILED (row may not exist yet \u2014 create still in flight). Keeping the settlement obligation: if the create resolves in-process its tail deactivates the row; if the process exits first, an ACTIVE row may leak (SIGKILL-class residual) (#638 H4)",
+          "doStop: INACTIVE write for the pending launch row FAILED (row may not exist yet \u2014 create still in flight). Keeping the settlement obligation: if the create resolves in-process its tail deactivates the row; the process remains alive so the delayed create tail can settle it (#638 H4)",
           { sessionId: pendingId }
         );
       }
@@ -3161,16 +3341,11 @@ var McpServer = class _McpServer {
         this.appSyncClient.stopHeartbeat(this.session.sessionId);
       } catch {
       }
-      try {
-        await this.appSyncClient.updateSession({
-          sessionId: this.session.sessionId,
-          status: "INACTIVE"
-        });
-      } catch (err) {
-        logger.warn("updateSession INACTIVE failed during shutdown", {
-          sessionId: this.session.sessionId,
-          error: String(err)
-        });
+      const retired = await this.deactivateLaunchRow(this.session.sessionId);
+      if (!retired) {
+        hostedRetirementError = new Error(
+          `Failed to retire hosted Antigravity session ${this.session.sessionId}`
+        );
       }
     }
     this.unregisterSignalHandlers();
@@ -3206,10 +3381,25 @@ var McpServer = class _McpServer {
     this.launchKeyUnavailable = false;
     this.ensureLaunchInFlight = null;
     this.observedMainConversationIds.clear();
+    if (mustAwaitLaunchSettlement && launchSettlement) {
+      await launchSettlement;
+      if (this.pendingLaunchSessionId) {
+        const pendingId = this.pendingLaunchSessionId;
+        const retired = await this.deactivateLaunchRow(pendingId);
+        if (retired) {
+          if (this.pendingLaunchSessionId === pendingId) this.pendingLaunchSessionId = null;
+        } else {
+          hostedRetirementError = new Error(
+            `Failed to settle delayed Antigravity launch session ${pendingId}`
+          );
+        }
+      }
+    }
     await fireDaemonBeacon("daemon_init_step", {
       step: "shutdown",
-      outcome: "ok"
+      outcome: hostedRetirementError ? "fail" : "ok"
     });
+    if (hostedRetirementError) throw hostedRetirementError;
   }
   async handleConversationDiscovered(conversationId) {
     if (!this.started) return;
@@ -3244,16 +3434,30 @@ var McpServer = class _McpServer {
   async deactivateLaunchRow(sessionId) {
     try {
       this.appSyncClient.stopHeartbeat(sessionId);
-      await this.appSyncClient.updateSession({ sessionId, status: "INACTIVE" });
-      logger.info("Marked superseded/interrupted launch session INACTIVE", { sessionId });
-      return true;
-    } catch (err) {
-      logger.warn("Failed to mark superseded/interrupted launch session INACTIVE", {
+    } catch (error) {
+      logger.warn("Failed to stop heartbeat while retiring Antigravity session", {
         sessionId,
-        error: String(err)
+        error: error instanceof Error ? error.message : String(error)
       });
-      return false;
     }
+    for (let attempt = 1; attempt <= SESSION_RETIRE_MAX_ATTEMPTS; attempt += 1) {
+      try {
+        await this.appSyncClient.updateSession({ sessionId, status: "INACTIVE" });
+        logger.info("Marked superseded/interrupted launch session INACTIVE", { sessionId });
+        return true;
+      } catch (err) {
+        logger.warn("Failed to mark superseded/interrupted launch session INACTIVE", {
+          sessionId,
+          attempt,
+          maxAttempts: SESSION_RETIRE_MAX_ATTEMPTS,
+          error: String(err)
+        });
+        if (attempt < SESSION_RETIRE_MAX_ATTEMPTS) {
+          await new Promise((resolve3) => setTimeout(resolve3, SESSION_RETIRE_RETRY_MS * attempt));
+        }
+      }
+    }
+    return false;
   }
   /**
    * v9 launch-session: create the wrapper-lifetime backend session at
@@ -4242,8 +4446,63 @@ var McpServer = class _McpServer {
           });
         }
       }
+      const pendingPrompts = this.approvalDetector.getPendingPromptsForConversation(
+        session.conversationId
+      );
+      if (pendingPrompts.length === 0) {
+        const probe = await this.paneObserver.probeApprovalUIActive();
+        if (!probe.probeSucceeded) {
+          await this.emitPromptSafetyNotification(
+            session,
+            "Your message was not sent because the desktop approval state could not be verified. Try again or resolve the prompt on the desktop."
+          );
+          return;
+        }
+        if (probe.active) {
+          await this.emitPromptSafetyNotification(
+            session,
+            "Your message was not sent because a desktop approval is active but its options are not yet available on mobile. Resolve it on the desktop and send the message again."
+          );
+          return;
+        }
+      }
+      if (pendingPrompts.length > 0) {
+        if (pendingPrompts.length !== 1) {
+          await this.emitPromptSafetyNotification(
+            session,
+            "Your message was not sent because more than one desktop approval is pending. Resolve the approvals and send it again."
+          );
+          return;
+        }
+        const activePrompt = pendingPrompts[0];
+        const rejectOption = activePrompt.paneOptions?.find(
+          (option) => /^(?:no|deny|reject|cancel)\b/i.test(option.text.trim()) && (activePrompt.submitMap[option.number]?.length ?? 0) > 0
+        );
+        if (!rejectOption) {
+          await this.emitPromptSafetyNotification(
+            session,
+            "Your message was not sent because the active desktop approval has no verified reject option. Resolve it on the desktop and send the message again."
+          );
+          return;
+        }
+        this.mobileDeduper.track(session.sessionId, rejectOption.number);
+        const rejectResult = await this.promptResponder.sendApprovalReply(
+          activePrompt.promptId,
+          rejectOption.number
+        );
+        if (!rejectResult.ok) {
+          this.mobileDeduper.forget(session.sessionId, rejectOption.number);
+          logger.warn("Reject-before-free-form failed", {
+            promptId: activePrompt.promptId,
+            reason: rejectResult.reason,
+            details: rejectResult.details
+          });
+          return;
+        }
+        await new Promise((resolve3) => setTimeout(resolve3, 250));
+      }
       this.mobileDeduper.track(session.sessionId, promptContent);
-      const result = await this.promptResponder.sendFreeForm(promptContent);
+      const result = await this.promptResponder.sendFreeFormWhenNoApprovalActive(promptContent);
       if (!result.ok) {
         this.mobileDeduper.forget(session.sessionId, promptContent);
         logger.warn("sendFreeForm failed", { reason: result.reason, details: result.details });
@@ -4278,6 +4537,23 @@ var McpServer = class _McpServer {
       await this.markExecuted(evt);
     }
   }
+  async emitPromptSafetyNotification(session, content) {
+    const input = {
+      sessionId: session.sessionId,
+      type: import_codevibe_core4.EventType.NOTIFICATION,
+      source: import_codevibe_core4.EventSource.DESKTOP,
+      content,
+      metadata: { promptSafetyBlocked: true },
+      timestamp: (0, import_codevibe_core4.prepareEventTimestamp)({ orderingKey: session.sessionId })
+    };
+    const outbound = this.encryptOutbound(session, input);
+    if (!outbound) return;
+    try {
+      await this.appSyncClient.createEvent(outbound);
+    } catch (error) {
+      logger.warn("Failed to emit prompt-safety notification", { error: String(error) });
+    }
+  }
   /**
    * Transition a mobile event's deliveryStatus to DELIVERED. Called as
    * soon as the plugin receives + decrypts the event and BEFORE the
@@ -4360,27 +4636,117 @@ var McpServer = class _McpServer {
     return this.session.sessionId === backendSessionId ? this.session : null;
   }
   // ─── Signal handling ────────────────────────────────────────────────────
+  /** Preserve a supported detach, but retire the daemon when its observed tmux owner ends. */
+  startTmuxLifecycleMonitor() {
+    if (this.tmuxLifecycleTimer || !this.tmuxTarget) return;
+    const tmuxTarget = this.tmuxTarget;
+    this.tmuxLifecycleTimer = setInterval(() => {
+      void this.checkTmuxLifecycle(tmuxTarget);
+    }, TMUX_LIFECYCLE_POLL_MS);
+    this.tmuxLifecycleInitDeadlineMs = Date.now() + TMUX_LIFECYCLE_INIT_GRACE_MS;
+    this.tmuxLifecycleTimer.unref?.();
+    void this.checkTmuxLifecycle(tmuxTarget);
+  }
+  async tmuxSessionState(tmuxTarget) {
+    try {
+      await execFileAsync("tmux", ["has-session", "-t", tmuxTarget]);
+      return "alive";
+    } catch (error) {
+      const state = classifyTmuxHasSessionError(error);
+      if (state === "absent") return state;
+      logger.warn("Could not inspect native Antigravity tmux session; preserving daemon", {
+        tmuxTarget,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return "unknown";
+    }
+  }
+  async checkTmuxLifecycle(tmuxTarget) {
+    if (!this.started || this.tmuxLifecycleCheckInFlight) return;
+    this.tmuxLifecycleCheckInFlight = true;
+    try {
+      const state = await this.tmuxSessionState(tmuxTarget);
+      if (state === "alive") {
+        this.tmuxLifecycleObservedAlive = true;
+        return;
+      }
+      const ownershipEstablished = this.tmuxLifecycleObservedAlive || Date.now() >= this.tmuxLifecycleInitDeadlineMs;
+      if (state === "unknown" || !ownershipEstablished || !this.started) return;
+      this.stopTmuxLifecycleMonitor();
+      logger.info("Native Antigravity tmux session ended; stopping companion daemon", {
+        tmuxTarget
+      });
+      void this.stop().then(
+        () => process.exit(0),
+        (error) => {
+          logger.error("Failed to stop companion daemon after native session end", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+          process.exit(1);
+        }
+      );
+    } finally {
+      this.tmuxLifecycleCheckInFlight = false;
+    }
+  }
+  stopTmuxLifecycleMonitor() {
+    if (this.tmuxLifecycleTimer) {
+      clearInterval(this.tmuxLifecycleTimer);
+      this.tmuxLifecycleTimer = null;
+    }
+  }
   registerSignalHandlers() {
     if (this.signalsRegistered) return;
     this.signalsRegistered = true;
     const onSignal = (sig) => {
-      logger.info(`${sig} received \u2014 shutting down`);
-      void this.stop().then(() => process.exit(0)).catch((err) => {
+      logger.info(`${sig} received \u2014 evaluating terminal shutdown`);
+      void this.stopForTerminalSignal(sig).then((stopped) => {
+        if (stopped) process.exit(0);
+      }).catch((err) => {
         logger.error("shutdown error", { error: String(err) });
         process.exit(1);
       });
     };
     this.boundSigintHandler = () => onSignal("SIGINT");
     this.boundSigtermHandler = () => onSignal("SIGTERM");
-    process.on("SIGINT", this.boundSigintHandler);
-    process.on("SIGTERM", this.boundSigtermHandler);
+    this.boundSighupHandler = () => onSignal("SIGHUP");
+    const handlers = {
+      SIGINT: this.boundSigintHandler,
+      SIGTERM: this.boundSigtermHandler,
+      SIGHUP: this.boundSighupHandler
+    };
+    for (const signal of TERMINAL_SHUTDOWN_SIGNALS) {
+      process.on(signal, handlers[signal]);
+    }
+  }
+  /**
+   * A tmux client detach can hang up the wrapper PTY while Antigravity remains
+   * alive in the bound tmux session. Only treat SIGHUP as terminal when tmux
+   * authoritatively reports that target absent; an unknown result preserves the
+   * daemon until the lifecycle monitor retries.
+   */
+  async stopForTerminalSignal(signal) {
+    if (signal === "SIGHUP" && this.tmuxTarget) {
+      const state = await this.tmuxSessionState(this.tmuxTarget);
+      if (state !== "absent") {
+        logger.info("Ignoring SIGHUP while native Antigravity tmux session remains available", {
+          tmuxTarget: this.tmuxTarget,
+          state
+        });
+        return false;
+      }
+    }
+    await this.stop();
+    return true;
   }
   unregisterSignalHandlers() {
     if (!this.signalsRegistered) return;
     if (this.boundSigintHandler) process.off("SIGINT", this.boundSigintHandler);
     if (this.boundSigtermHandler) process.off("SIGTERM", this.boundSigtermHandler);
+    if (this.boundSighupHandler) process.off("SIGHUP", this.boundSighupHandler);
     this.boundSigintHandler = null;
     this.boundSigtermHandler = null;
+    this.boundSighupHandler = null;
     this.signalsRegistered = false;
   }
   // ─── Lookups (test surface) ────────────────────────────────────────────
@@ -4620,7 +4986,9 @@ var __testing = {
 0 && (module.exports = {
   McpServer,
   SessionNotFoundError,
+  TERMINAL_SHUTDOWN_SIGNALS,
   __testing,
+  classifyTmuxHasSessionError,
   generateLaunchSessionId,
   getActiveConversationFromCliLog,
   parseMaybeJson

package/libexec/companion-launcher

@@ -201,6 +201,27 @@ log() {
     echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" >> "$LOG_FILE"
 }
 
+tmux_session_state() {
+    local target="$1"
+    local output
+    local rc
+    output="$(tmux has-session -t "$target" 2>&1)"
+    rc=$?
+    if [ "$rc" -eq 0 ]; then
+        printf '%s\n' "alive"
+        return
+    fi
+    case "$output" in
+        "can't find session:"*|"no server running on "*|"error connecting to "*" (No such file or directory)"|"error connecting to "*" (Connection refused)")
+            printf '%s\n' "absent"
+            ;;
+        *)
+            log "WARN: tmux inspection failed for $target; preserving daemon: $output"
+            printf '%s\n' "unknown"
+            ;;
+    esac
+}
+
 # ─── Reject unsupported invocations ───────────────────────────────────
 # `--print` / `-p` mode bypasses the interactive TUI we depend on. Bail
 # out with a clear message rather than silently producing no mobile sync.
@@ -326,6 +347,22 @@ cleanup() {
     local wrapper_exit_code=$?
     log "Cleanup triggered"
 
+    # Closing or detaching the outer terminal must not disconnect an agy
+    # process that is still alive inside tmux. The daemon monitors this exact
+    # tmux target and owns full cleanup after the native session disappears.
+    if [ "${_CV_TMUX_STARTED:-false}" = "true" ]; then
+        local tmux_state
+        tmux_state="$(tmux_session_state "$SESSION_NAME")"
+        if [ "$tmux_state" = "alive" ]; then
+            log "Tmux client detached while Antigravity remains active; leaving daemon running"
+            return
+        fi
+        if [ "$tmux_state" = "unknown" ]; then
+            log "Tmux state is ambiguous; preserving daemon and native session"
+            return
+        fi
+    fi
+
     # Fire wrapper_exited telemetry BEFORE killing the server so MCP
     # logs are intact. cv_failed sets _CV_EXITED on pre-flight failures,
     # so this block won't double-fire.
@@ -358,21 +395,12 @@ cleanup() {
         cv_telem "wrapper_exited" "\"exit_code\":$wrapper_exit_code,\"lifetime_seconds\":$lifetime,\"agy_exit_code\":\"$agy_exit\",\"agy_lifetime_seconds\":$agy_lifetime,\"tmux_session_started\":$_CV_TMUX_STARTED,\"agent_invoked\":$_CV_AGENT_INVOKED,\"terminal_outcome\":\"$outcome\""
     fi
 
-    # Stop the MCP server — graceful first, then SIGKILL fallback.
-    # The server's SIGTERM handler marks the session INACTIVE.
+    # Stop the MCP server gracefully and wait for product-owned cleanup. Never
+    # force-kill here: stop() must finish its hosted INACTIVE obligation before
+    # the process exits, even when that takes longer than the old 3s bound.
     if [ -n "$MCP_PID" ] && kill -0 "$MCP_PID" 2>/dev/null; then
         log "Stopping MCP server (PID: $MCP_PID)"
         kill -TERM "$MCP_PID" 2>/dev/null || true
-        # Wait up to 3s for graceful shutdown.
-        local i=0
-        while [ $i -lt 30 ] && kill -0 "$MCP_PID" 2>/dev/null; do
-            sleep 0.1
-            i=$((i + 1))
-        done
-        if kill -0 "$MCP_PID" 2>/dev/null; then
-            log "MCP server did not exit cleanly; sending SIGKILL"
-            kill -KILL "$MCP_PID" 2>/dev/null || true
-        fi
         wait "$MCP_PID" 2>/dev/null || true
     fi
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-antigravity-plugin",
-  "version": "2.0.10",
+  "version": "2.0.12",
   "description": "Control Antigravity CLI from your iPhone and Android — real-time sync, approve file edits, send prompts by voice. Part of CodeVibe.",
   "main": "dist/server.js",
   "codevibe": {
@@ -48,7 +48,7 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@quantiya/codevibe-core": "2.0.9",
+    "@quantiya/codevibe-core": "2.0.10",
     "chokidar": "^5.0.0",
     "dotenv": "^16.6.1",
     "express": "^5.1.0",