@quantiya/codevibe-antigravity-plugin 1.0.0

package/dist/server.js

@@ -0,0 +1,3558 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  McpServer: () => McpServer,
+  SessionNotFoundError: () => SessionNotFoundError,
+  __testing: () => __testing,
+  generateLaunchSessionId: () => generateLaunchSessionId,
+  getActiveConversationFromCliLog: () => getActiveConversationFromCliLog,
+  parseMaybeJson: () => parseMaybeJson
+});
+module.exports = __toCommonJS(server_exports);
+var crypto3 = __toESM(require("crypto"));
+var path5 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
+var os5 = __toESM(require("os"));
+var import_codevibe_core4 = require("@quantiya/codevibe-core");
+
+// src/logger.ts
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_codevibe_core = require("@quantiya/codevibe-core");
+var logger = (0, import_codevibe_core.createLogger)({
+  name: "codevibe-agy",
+  logFile: import_path.default.join(import_os.default.tmpdir(), "codevibe-agy-mcp.log"),
+  level: "info"
+});
+
+// src/http-api.ts
+var fs = __toESM(require("fs"));
+var crypto = __toESM(require("crypto"));
+var http = __toESM(require("http"));
+var import_codevibe_core2 = require("@quantiya/codevibe-core");
+var HttpApi = class {
+  constructor(options) {
+    this.server = null;
+    this.handlers = null;
+    this.assignedPort = 0;
+    if (!options.bearerToken || options.bearerToken.length < 16) {
+      throw new Error("HttpApi requires a non-trivial bearerToken");
+    }
+    this.bearerToken = options.bearerToken;
+    this.host = options.host ?? "127.0.0.1";
+    if (this.host !== "127.0.0.1" && this.host !== "::1" && this.host !== "localhost") {
+      throw new Error(
+        `HttpApi refusing to bind ${this.host}: only loopback addresses are permitted`
+      );
+    }
+    this.preferredPort = options.preferredPort ?? 0;
+    this.portFilePath = options.portFilePath ?? null;
+  }
+  setHandlers(handlers) {
+    this.handlers = handlers;
+  }
+  /** Returns the bound port (0 if not started). */
+  getPort() {
+    return this.assignedPort;
+  }
+  async start() {
+    if (this.server) return this.assignedPort;
+    this.server = http.createServer((req, res) => this.dispatch(req, res));
+    try {
+      await new Promise((resolve3, reject) => {
+        const onError = (err) => {
+          this.server?.off("listening", onListening);
+          reject(err);
+        };
+        const onListening = () => {
+          this.server?.off("error", onError);
+          resolve3();
+        };
+        this.server.once("error", onError);
+        this.server.once("listening", onListening);
+        this.server.listen(this.preferredPort, this.host);
+      });
+    } catch (err) {
+      try {
+        this.server?.close();
+      } catch {
+      }
+      this.server = null;
+      throw err;
+    }
+    const address = this.server.address();
+    this.assignedPort = address.port;
+    logger.info("HTTP API listening", { host: this.host, port: this.assignedPort });
+    if (this.portFilePath) {
+      try {
+        await this.writePortFile();
+      } catch (err) {
+        logger.warn("Failed to write port file (continuing without)", {
+          path: this.portFilePath,
+          error: String(err)
+        });
+      }
+    }
+    return this.assignedPort;
+  }
+  async stop() {
+    const srv = this.server;
+    if (!srv) return;
+    this.server = null;
+    await new Promise((resolve3) => srv.close(() => resolve3()));
+    if (this.portFilePath) {
+      try {
+        await fs.promises.unlink(this.portFilePath);
+      } catch {
+      }
+    }
+    this.assignedPort = 0;
+    logger.info("HTTP API stopped");
+  }
+  // ─── Request handling ───────────────────────────────────────────────────
+  dispatch(req, res) {
+    const pathOnly = (req.url ?? "").split("?")[0];
+    if (req.method === "GET" && (pathOnly === "/health" || pathOnly === "/healthz")) {
+      this.handleHealth(req, res);
+      return;
+    }
+    if (!this.checkBearer(req)) {
+      this.sendJson(res, 401, { success: false, error: "unauthorized" });
+      return;
+    }
+    if (req.method === "POST" && pathOnly === "/event") {
+      void this.handlePostEvent(req, res);
+      return;
+    }
+    this.sendJson(res, 404, { success: false, error: "not found" });
+  }
+  checkBearer(req) {
+    const auth = req.headers["authorization"];
+    if (typeof auth !== "string") return false;
+    const m = auth.match(/^Bearer\s+(.+)$/i);
+    if (!m) return false;
+    const provided = m[1].trim();
+    try {
+      const providedHash = crypto.createHash("sha256").update(provided, "utf8").digest();
+      const expectedHash = crypto.createHash("sha256").update(this.bearerToken, "utf8").digest();
+      return crypto.timingSafeEqual(providedHash, expectedHash);
+    } catch {
+      return false;
+    }
+  }
+  handleHealth(_req, res) {
+    const session = this.handlers?.getActiveSession() ?? null;
+    this.sendJson(res, 200, {
+      success: true,
+      data: {
+        ok: true,
+        hasActiveSession: session !== null
+      }
+    });
+  }
+  async handlePostEvent(req, res) {
+    if (!this.handlers) {
+      this.sendJson(res, 503, { success: false, error: "server not ready" });
+      return;
+    }
+    let body;
+    try {
+      body = await readBody(req, 256 * 1024);
+    } catch (err) {
+      this.sendJson(res, 413, { success: false, error: "body too large or read failed" });
+      return;
+    }
+    let payload;
+    try {
+      payload = JSON.parse(body);
+    } catch {
+      this.sendJson(res, 400, { success: false, error: "invalid JSON" });
+      return;
+    }
+    if (!payload.sessionId || !payload.type || !payload.source || typeof payload.content !== "string") {
+      this.sendJson(res, 400, {
+        success: false,
+        error: "missing required fields: sessionId, type, source, content"
+      });
+      return;
+    }
+    if (!isValidEventType(payload.type) || !isValidEventSource(payload.source)) {
+      this.sendJson(res, 400, {
+        success: false,
+        error: "invalid type or source enum value"
+      });
+      return;
+    }
+    try {
+      const { eventId } = await this.handlers.pushEvent(payload);
+      this.sendJson(res, 200, { success: true, data: { eventId } });
+    } catch (err) {
+      logger.error("pushEvent failed in /event handler", { error: String(err) });
+      const code = err?.code;
+      if (code === "session-not-found") {
+        this.sendJson(res, 404, { success: false, error: "session not found" });
+        return;
+      }
+      this.sendJson(res, 500, { success: false, error: "event push failed" });
+    }
+  }
+  // ─── Helpers ────────────────────────────────────────────────────────────
+  async writePortFile() {
+    if (!this.portFilePath) return;
+    const content = JSON.stringify({
+      port: this.assignedPort,
+      token: this.bearerToken,
+      writtenAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const tmpPath = `${this.portFilePath}.tmp.${process.pid}`;
+    try {
+      await fs.promises.writeFile(tmpPath, content, { mode: 384 });
+      await fs.promises.chmod(tmpPath, 384);
+      await fs.promises.rename(tmpPath, this.portFilePath);
+    } catch (err) {
+      try {
+        await fs.promises.unlink(tmpPath);
+      } catch {
+      }
+      throw err;
+    }
+  }
+  sendJson(res, status, body) {
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(body));
+  }
+};
+function isValidEventType(value) {
+  if (typeof value !== "string") return false;
+  return Object.values(import_codevibe_core2.EventType).includes(value);
+}
+function isValidEventSource(value) {
+  if (typeof value !== "string") return false;
+  return Object.values(import_codevibe_core2.EventSource).includes(value);
+}
+async function readBody(req, maxBytes) {
+  return new Promise((resolve3, reject) => {
+    let received = 0;
+    const chunks = [];
+    req.on("data", (chunk) => {
+      received += chunk.length;
+      if (received > maxBytes) {
+        req.destroy();
+        reject(new Error("body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve3(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+
+// src/transcript-tailer.ts
+var import_events = require("events");
+var fs2 = __toESM(require("fs"));
+var os2 = __toESM(require("os"));
+var path2 = __toESM(require("path"));
+var import_chokidar = require("chokidar");
+var OFFSET_FLUSH_INTERVAL_MS = 3e4;
+var LRU_CAP = 50;
+var TRANSCRIPT_FILE_REGEX = /\/brain\/([0-9a-fA-F-]{36})\/\.system_generated\/logs\/transcript\.jsonl$/;
+function defaultPaths() {
+  const home = os2.homedir();
+  return {
+    brainRoot: path2.join(home, ".gemini", "antigravity-cli", "brain"),
+    offsetFilePath: path2.join(home, ".codevibe", "codevibe-agy", "transcript-offsets.json")
+  };
+}
+var TranscriptTailer = class extends import_events.EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.watcher = null;
+    this.isWatching = false;
+    this.isShuttingDown = false;
+    /** Per-file offset state (in-memory mirror of the persisted store). */
+    this.offsets = /* @__PURE__ */ new Map();
+    /** Conversation UUIDs we're actively tailing. v1.0 pins to single-active
+     *  per design §3.5; if a second conversation UUID is observed, we WARN
+     *  and skip (collision guard). */
+    this.activeConversations = /* @__PURE__ */ new Set();
+    /** Periodic offset flush timer. */
+    this.flushTimer = null;
+    /** Per-file read serialization (prevents concurrent reads of same file
+     *  when `change` events fire in rapid succession). */
+    this.activeReads = /* @__PURE__ */ new Map();
+    this.pendingReads = /* @__PURE__ */ new Set();
+    /** Monotonic counter — used to short-circuit stale read loops after stop(). */
+    this.readGeneration = 0;
+    /** ms-epoch when start() was called. Files modified before this minus 5s
+     *  are considered pre-existing and ignored unless they're being actively
+     *  written to (mtime > startTime - 5s). */
+    this.startTime = 0;
+    const defaults = defaultPaths();
+    this.brainRoot = options.brainRoot ?? defaults.brainRoot;
+    this.offsetFilePath = options.offsetFilePath ?? defaults.offsetFilePath;
+    this.usePolling = options.usePolling ?? false;
+  }
+  /**
+   * Start watching the brain root. Loads persisted offsets, prunes orphans,
+   * then chokidar watches for new / changed transcript files.
+   */
+  start() {
+    if (this.isWatching) {
+      logger.warn("TranscriptTailer.start called while already watching");
+      return;
+    }
+    this.startTime = Date.now();
+    this.readGeneration++;
+    this.loadPersistedOffsets();
+    this.pruneOrphanedOffsets();
+    if (!fs2.existsSync(this.brainRoot)) {
+      try {
+        fs2.mkdirSync(this.brainRoot, { recursive: true });
+        logger.info("Created brain root", { brainRoot: this.brainRoot });
+      } catch (error) {
+        logger.warn("Could not create brain root (will retry implicitly)", {
+          brainRoot: this.brainRoot,
+          error
+        });
+      }
+    }
+    logger.info("Starting transcript tailer", {
+      brainRoot: this.brainRoot,
+      offsetFile: this.offsetFilePath,
+      loadedOffsets: this.offsets.size
+    });
+    this.watcher = (0, import_chokidar.watch)(this.brainRoot, {
+      persistent: true,
+      ignoreInitial: true,
+      depth: 4,
+      awaitWriteFinish: false,
+      // partial-line carryover handles partial writes
+      usePolling: this.usePolling,
+      interval: this.usePolling ? 50 : void 0,
+      ignored: (filePath) => {
+        const isDir = (() => {
+          try {
+            return fs2.statSync(filePath).isDirectory();
+          } catch {
+            return false;
+          }
+        })();
+        if (isDir) return false;
+        return !TRANSCRIPT_FILE_REGEX.test(filePath);
+      }
+    });
+    this.watcher.on("add", (filePath) => this.onFileAdded(filePath));
+    this.watcher.on("addDir", (dirPath) => this.onDirAdded(dirPath));
+    this.watcher.on("change", (filePath) => this.onFileChanged(filePath));
+    this.watcher.on("unlink", (filePath) => this.onFileUnlinked(filePath));
+    this.watcher.on("error", (error) => {
+      logger.error("Chokidar error", { error });
+      this.emit("error", error instanceof Error ? error : new Error(String(error)));
+    });
+    this.watcher.on("ready", () => {
+      logger.info("Transcript tailer ready (chokidar initial scan complete)");
+      this.backfillActiveTranscripts();
+    });
+    this.flushTimer = setInterval(() => this.flushOffsets(), OFFSET_FLUSH_INTERVAL_MS);
+    if (this.flushTimer.unref) this.flushTimer.unref();
+    this.isWatching = true;
+  }
+  /**
+   * Stop watching. Flushes offsets one last time before closing chokidar.
+   * Idempotent.
+   */
+  async stop() {
+    if (!this.isWatching) return;
+    this.isShuttingDown = true;
+    this.readGeneration++;
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    try {
+      this.flushOffsets();
+    } catch (error) {
+      logger.warn("Final offset flush failed", { error });
+    }
+    if (this.watcher) {
+      try {
+        await this.watcher.close();
+      } catch (error) {
+        logger.warn("Error closing chokidar watcher", { error });
+      }
+      this.watcher = null;
+    }
+    this.activeReads.clear();
+    this.pendingReads.clear();
+    this.isWatching = false;
+    this.isShuttingDown = false;
+    logger.info("Transcript tailer stopped");
+  }
+  /**
+   * Best-effort sync flush. Safe to call from a process EXIT trap.
+   * (The async stop() above is preferred when a regular shutdown is feasible.)
+   */
+  syncFlush() {
+    try {
+      this.flushOffsets();
+    } catch (error) {
+      logger.warn("syncFlush failed", { error });
+    }
+  }
+  /** True if any conversation is currently being tailed. */
+  isActive() {
+    return this.activeConversations.size > 0;
+  }
+  /** Returns the set of currently-tailed conversation UUIDs (copy). */
+  getActiveConversations() {
+    return Array.from(this.activeConversations);
+  }
+  // ─── chokidar event handlers ─────────────────────────────────────────────
+  onFileAdded(filePath) {
+    if (this.isShuttingDown) return;
+    const conversationId = this.extractConversationId(filePath);
+    if (!conversationId) return;
+    if (this.isPreExisting(filePath)) {
+      logger.debug("Ignoring pre-existing transcript on `add`", { filePath });
+      return;
+    }
+    if (this.activeConversations.has(conversationId)) {
+      logger.debug("Conversation already active \u2014 ignoring duplicate add", {
+        conversationId,
+        filePath
+      });
+      return;
+    }
+    logger.info("New transcript file detected", { filePath, conversationId });
+    this.activeConversations.add(conversationId);
+    this.ensureOffset(filePath);
+    this.emit("transcript-add", filePath, conversationId);
+    void this.scheduleReadNewLines(filePath, conversationId);
+  }
+  onDirAdded(dirPath) {
+    if (this.isShuttingDown) return;
+    const base = path2.basename(dirPath);
+    if (!/^[0-9a-fA-F-]{36}$/.test(base)) return;
+    const conversationId = base;
+    const expectedParent = path2.dirname(dirPath);
+    if (path2.resolve(expectedParent) !== path2.resolve(this.brainRoot)) return;
+    logger.info("New brain directory discovered (pre-prompt)", { dirPath, conversationId });
+    this.emit("conversation-discovered", conversationId);
+  }
+  /**
+   * Fires when chokidar reports a transcript.jsonl was deleted or moved
+   * out from under us. Two scenarios (Codex HIGH-1 fix):
+   *
+   *   (a) agy ended the conversation + cleaned up — the file is gone for
+   *       good. We keep the offset entry in case the same conversation UUID
+   *       gets recreated later (rare but possible), but log it.
+   *
+   *   (b) Move-then-recreate (e.g. agy rotates the file) — chokidar will
+   *       fire `add` shortly after for the new file at the same path. We
+   *       proactively RESET the offset entry to byteOffset=0 + carryover=''
+   *       so the next read picks up from the start of the new file. Without
+   *       this, the next read would skip bytes 0..oldOffset of the new file.
+   */
+  onFileUnlinked(filePath) {
+    const conversationId = this.extractConversationId(filePath);
+    if (!conversationId) return;
+    const entry = this.offsets.get(filePath);
+    if (!entry) {
+      logger.debug("Unlink for unwatched path; ignoring", { filePath });
+      return;
+    }
+    logger.warn("Transcript file unlinked", {
+      filePath,
+      conversationId,
+      previousOffset: entry.byteOffset,
+      previousKnownSize: entry.lastKnownSize
+    });
+    entry.byteOffset = 0;
+    entry.carryover = "";
+    entry.lastKnownSize = 0;
+    entry.lastModifiedMs = Date.now();
+    this.activeConversations.delete(conversationId);
+  }
+  onFileChanged(filePath) {
+    if (this.isShuttingDown) return;
+    const conversationId = this.extractConversationId(filePath);
+    if (!conversationId) return;
+    if (!this.activeConversations.has(conversationId)) {
+      logger.info("Resuming transcript file via change event", {
+        filePath,
+        conversationId
+      });
+      this.activeConversations.add(conversationId);
+      this.ensureOffset(filePath);
+      this.emit("transcript-resume", filePath, conversationId);
+    }
+    void this.scheduleReadNewLines(filePath, conversationId);
+  }
+  // ─── Backfill at startup ────────────────────────────────────────────────
+  /**
+   * Walk the brain root once at startup and emit resume events for any
+   * transcript.jsonl that already exists and shows recent activity. This
+   * covers the case where agy is already running when codevibe-agy starts.
+   */
+  backfillActiveTranscripts() {
+    if (!fs2.existsSync(this.brainRoot)) return;
+    try {
+      const brainDirs = fs2.readdirSync(this.brainRoot, { withFileTypes: true });
+      for (const dir of brainDirs) {
+        if (!dir.isDirectory()) continue;
+        const conversationId = dir.name;
+        if (!/^[0-9a-fA-F-]{36}$/.test(conversationId)) continue;
+        const dirPath = path2.join(this.brainRoot, conversationId);
+        const transcriptPath = path2.join(
+          dirPath,
+          ".system_generated",
+          "logs",
+          "transcript.jsonl"
+        );
+        const hasTranscript = fs2.existsSync(transcriptPath);
+        try {
+          if (hasTranscript) {
+            const stat = fs2.statSync(transcriptPath);
+            if (stat.mtimeMs < this.startTime - 5 * 60 * 1e3) {
+              logger.debug("Skipping stale transcript at startup", {
+                transcriptPath,
+                ageMinutes: ((this.startTime - stat.mtimeMs) / 6e4).toFixed(1)
+              });
+              continue;
+            }
+          } else {
+            const stat = fs2.statSync(dirPath);
+            if (stat.mtimeMs < this.startTime - 5 * 60 * 1e3) {
+              logger.debug("Skipping stale transcriptless directory at startup", {
+                dirPath,
+                ageMinutes: ((this.startTime - stat.mtimeMs) / 6e4).toFixed(1)
+              });
+              continue;
+            }
+          }
+        } catch {
+          continue;
+        }
+        if (hasTranscript) {
+          if (this.activeConversations.has(conversationId)) continue;
+          logger.info("Backfilling resumed transcript at startup", {
+            transcriptPath,
+            conversationId
+          });
+          this.activeConversations.add(conversationId);
+          this.ensureOffset(transcriptPath);
+          this.emit("transcript-resume", transcriptPath, conversationId);
+          void this.scheduleReadNewLines(transcriptPath, conversationId);
+        } else {
+          logger.info("Backfilling recent transcriptless directory at startup", {
+            dirPath,
+            conversationId
+          });
+          this.emit("conversation-discovered", conversationId);
+        }
+      }
+    } catch (error) {
+      logger.warn("Backfill scan failed", { error });
+    }
+  }
+  // ─── Read serialization ─────────────────────────────────────────────────
+  scheduleReadNewLines(filePath, conversationId) {
+    const inflight = this.activeReads.get(filePath);
+    if (inflight) {
+      this.pendingReads.add(filePath);
+      return inflight;
+    }
+    const generation = this.readGeneration;
+    const read = this.drainReadQueue(filePath, conversationId, generation);
+    this.activeReads.set(filePath, read);
+    void read.finally(() => {
+      if (this.activeReads.get(filePath) === read) {
+        this.activeReads.delete(filePath);
+        this.pendingReads.delete(filePath);
+      }
+    });
+    return read;
+  }
+  async drainReadQueue(filePath, conversationId, generation) {
+    do {
+      this.pendingReads.delete(filePath);
+      await this.readNewLines(filePath, conversationId, generation);
+    } while (generation === this.readGeneration && this.pendingReads.has(filePath));
+  }
+  async readNewLines(filePath, conversationId, generation) {
+    if (generation !== this.readGeneration) return;
+    const entry = this.offsets.get(filePath);
+    if (!entry) {
+      logger.warn("No offset entry \u2014 skipping read", { filePath });
+      return;
+    }
+    let stat;
+    try {
+      stat = fs2.statSync(filePath);
+    } catch (error) {
+      logger.warn("stat failed; file may have been deleted", { filePath, error });
+      return;
+    }
+    if (stat.size < entry.lastKnownSize) {
+      logger.warn("Transcript file rotated (size shrunk); resetting offset", {
+        filePath,
+        previousOffset: entry.byteOffset,
+        previousKnownSize: entry.lastKnownSize,
+        currentSize: stat.size
+      });
+      entry.byteOffset = 0;
+      entry.carryover = "";
+      entry.lastKnownSize = stat.size;
+      this.emit("transcript-rotated", filePath, conversationId);
+    }
+    const carryoverBytes = Buffer.byteLength(entry.carryover, "utf-8");
+    const readStart = entry.byteOffset + carryoverBytes;
+    if (stat.size <= readStart) {
+      entry.lastKnownSize = stat.size;
+      entry.lastModifiedMs = stat.mtimeMs;
+      return;
+    }
+    let stream;
+    try {
+      stream = fs2.createReadStream(filePath, {
+        start: readStart,
+        encoding: "utf-8"
+      });
+    } catch (error) {
+      logger.error("createReadStream failed", { filePath, error });
+      this.emit("error", error instanceof Error ? error : new Error(String(error)));
+      return;
+    }
+    let buffered = entry.carryover;
+    let lineStartOffset = entry.byteOffset;
+    try {
+      for await (const chunk of stream) {
+        if (generation !== this.readGeneration) {
+          stream.destroy();
+          return;
+        }
+        buffered += chunk;
+        let newlineIndex = buffered.indexOf("\n");
+        while (newlineIndex !== -1) {
+          if (generation !== this.readGeneration) {
+            stream.destroy();
+            return;
+          }
+          const rawLine = buffered.slice(0, newlineIndex);
+          const completeRecord = buffered.slice(0, newlineIndex + 1);
+          const recordBytes = Buffer.byteLength(completeRecord, "utf-8");
+          const lineByteOffset = lineStartOffset;
+          buffered = buffered.slice(newlineIndex + 1);
+          lineStartOffset += recordBytes;
+          const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+          if (line.trim()) {
+            this.parseAndEmitLine(line, filePath, conversationId, lineByteOffset);
+          }
+          newlineIndex = buffered.indexOf("\n");
+        }
+      }
+    } catch (error) {
+      logger.error("Error reading transcript stream", { filePath, error });
+      this.emit("error", error instanceof Error ? error : new Error(String(error)));
+      return;
+    }
+    if (generation !== this.readGeneration) return;
+    entry.byteOffset = lineStartOffset;
+    entry.carryover = buffered;
+    entry.lastKnownSize = stat.size;
+    entry.lastModifiedMs = stat.mtimeMs;
+  }
+  parseAndEmitLine(line, filePath, conversationId, byteOffset) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch (error) {
+      logger.warn("Failed to parse transcript line as JSON", {
+        filePath,
+        linePreview: line.substring(0, 120),
+        error
+      });
+      return;
+    }
+    if (typeof event.step_index !== "number" || typeof event.type !== "string") {
+      logger.warn("Transcript line missing required fields", {
+        filePath,
+        linePreview: line.substring(0, 120),
+        hasStepIndex: typeof event.step_index,
+        hasType: typeof event.type
+      });
+      return;
+    }
+    const emit = { conversationId, filePath, event, byteOffset };
+    this.emit("event", emit);
+  }
+  // ─── Offset persistence ─────────────────────────────────────────────────
+  ensureOffset(filePath) {
+    if (this.offsets.has(filePath)) return;
+    if (this.offsets.size >= LRU_CAP) {
+      this.evictOldestOffset();
+    }
+    let stat = null;
+    try {
+      stat = fs2.statSync(filePath);
+    } catch {
+    }
+    this.offsets.set(filePath, {
+      byteOffset: 0,
+      carryover: "",
+      lastKnownSize: stat?.size ?? 0,
+      lastModifiedMs: stat?.mtimeMs ?? Date.now()
+    });
+  }
+  /**
+   * Pick the oldest-mtime offset entry that is NOT for a currently-active
+   * conversation, and evict it. Active conversations are PROTECTED — losing
+   * their offset would mean re-reading the whole file from byte 0 and
+   * duplicating events to AppSync. (Codex MED-4 fix.)
+   *
+   * If ALL entries are active (very unusual — would require 51 concurrent
+   * agy sessions in the same wrapper, which the §3.5 collision guard
+   * prevents), log a warning and skip eviction. The cap is then a soft
+   * cap for the duration of the wrapper.
+   */
+  evictOldestOffset() {
+    let oldestPath = null;
+    let oldestMtime = Number.POSITIVE_INFINITY;
+    for (const [p, entry] of this.offsets.entries()) {
+      const cid = this.extractConversationId(p);
+      if (cid && this.activeConversations.has(cid)) {
+        continue;
+      }
+      if (entry.lastModifiedMs < oldestMtime) {
+        oldestMtime = entry.lastModifiedMs;
+        oldestPath = p;
+      }
+    }
+    if (oldestPath) {
+      logger.info("LRU evicting transcript offset (inactive)", {
+        evictedPath: oldestPath,
+        cap: LRU_CAP
+      });
+      this.offsets.delete(oldestPath);
+    } else {
+      logger.warn("LRU cap reached but ALL entries are active; cap is soft", {
+        cap: LRU_CAP,
+        size: this.offsets.size,
+        activeConversations: this.activeConversations.size
+      });
+    }
+  }
+  loadPersistedOffsets() {
+    if (!fs2.existsSync(this.offsetFilePath)) return;
+    try {
+      const raw = fs2.readFileSync(this.offsetFilePath, "utf-8");
+      const store = JSON.parse(raw);
+      if (store.version !== 1 || !store.entries) {
+        logger.warn("Unrecognized offset file version; ignoring", {
+          version: store.version
+        });
+        return;
+      }
+      for (const [filePath, entry] of Object.entries(store.entries)) {
+        this.offsets.set(filePath, {
+          byteOffset: entry.byteOffset ?? 0,
+          carryover: "",
+          lastKnownSize: entry.lastKnownSize ?? 0,
+          lastModifiedMs: entry.lastModifiedMs ?? 0
+        });
+      }
+      logger.info("Loaded persisted offsets", { count: this.offsets.size });
+    } catch (error) {
+      logger.warn("Failed to load persisted offsets \u2014 starting fresh", { error });
+    }
+  }
+  pruneOrphanedOffsets() {
+    let pruned = 0;
+    for (const filePath of Array.from(this.offsets.keys())) {
+      if (!fs2.existsSync(filePath)) {
+        this.offsets.delete(filePath);
+        pruned++;
+      }
+    }
+    if (pruned > 0) {
+      logger.info("Pruned orphan offsets at startup", { pruned });
+    }
+  }
+  flushOffsets() {
+    if (this.offsets.size === 0) {
+      return;
+    }
+    try {
+      const offsetDir = path2.dirname(this.offsetFilePath);
+      if (!fs2.existsSync(offsetDir)) {
+        fs2.mkdirSync(offsetDir, { recursive: true, mode: 448 });
+      }
+      const store = {
+        version: 1,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        entries: {}
+      };
+      for (const [filePath, entry] of this.offsets.entries()) {
+        store.entries[filePath] = {
+          byteOffset: entry.byteOffset,
+          carryover: "",
+          // never persist carryover; see loadPersistedOffsets
+          lastKnownSize: entry.lastKnownSize,
+          lastModifiedMs: entry.lastModifiedMs
+        };
+      }
+      const tmpPath = this.offsetFilePath + ".tmp";
+      fs2.writeFileSync(tmpPath, JSON.stringify(store, null, 2), { mode: 384 });
+      fs2.renameSync(tmpPath, this.offsetFilePath);
+    } catch (error) {
+      logger.warn("Failed to flush transcript offsets", { error });
+    }
+  }
+  // ─── Helpers ────────────────────────────────────────────────────────────
+  extractConversationId(filePath) {
+    const m = TRANSCRIPT_FILE_REGEX.exec(filePath);
+    return m ? m[1] : null;
+  }
+  isPreExisting(filePath) {
+    try {
+      const stat = fs2.statSync(filePath);
+      const ageMs = this.startTime - stat.mtimeMs;
+      return ageMs > 5e3 && stat.mtimeMs < this.startTime - 5e3 && (stat.birthtimeMs ?? stat.ctimeMs) < this.startTime - 5e3;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/tmux-pane-observer.ts
+var fs3 = __toESM(require("fs"));
+var os3 = __toESM(require("os"));
+var path3 = __toESM(require("path"));
+var import_crypto = require("crypto");
+var import_child_process = require("child_process");
+var import_events2 = require("events");
+var import_util = require("util");
+var execAsync = (0, import_util.promisify)(import_child_process.exec);
+var TmuxPaneObserver = class _TmuxPaneObserver extends import_events2.EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.sessionName = null;
+    this.started = false;
+    this.filePosition = 0;
+    this.watcher = null;
+    this.processing = false;
+    this.pendingRead = false;
+    /** Monotonic counter — incremented on each start() so in-flight async
+     *  operations from a prior session/start cycle can detect they're stale
+     *  and abort before emitting. (Codex tmux-observer MED-2.) */
+    this.generation = 0;
+    /** sha256 of the last emitted prompt-candidate snapshot. Prevents
+     *  re-emitting when pane content is unchanged (e.g. when noise
+     *  somewhere else in the pane triggers fs.watch). */
+    this.lastPromptHash = null;
+    /** True if the previous tick saw an approval UI active in the pane.
+     *  Used to fire 'prompt-cleared' when the UI vanishes between ticks. */
+    this.approvalUIActive = false;
+    /** Cached header text from the last detected approval (used by the
+     *  prompt-responder's active-prompt-identity guard). */
+    this.currentApprovalHeader = null;
+    this.pendingEmitCandidate = null;
+    this.debounceTimer = null;
+    /** ms-epoch when the CURRENT debounce window opened (first prompt-bearing
+     *  snapshot since the last flush). Used to enforce DEBOUNCE_MAX_WAIT_MS. */
+    this.debounceWindowOpenedAt = null;
+    /** Monotonic cycle counter — incremented on every call to
+     *  `scheduleDebouncedEmit` (a new burst window) and on every
+     *  `cancelDebounce`. Each `flushDebouncedEmit` captures this value
+     *  at its scheduling moment; on every await boundary, it compares
+     *  the captured value against the current cycle id and bails if
+     *  they differ. Required to close the race where an OLDER flush
+     *  is mid-await while a NEWER cycle has been scheduled AND already
+     *  cleared `debounceTimer` (so a `debounceTimer !== null` check
+     *  fails to detect the newer cycle). `generation` only tracks
+     *  start()/stop() lifecycle and doesn't distinguish debounce
+     *  cycles. (Stage 2 iter-4 R1 HIGH finding 2026-05-21.) */
+    this.debounceCycleId = 0;
+    this.pipeFilePath = options.pipeFilePath ?? path3.join(os3.tmpdir(), `codevibe-agy-pane-${process.pid}.log`);
+    this.skipTmuxCommands = options.skipTmuxCommands ?? false;
+    this.captureFn = options.captureFn ?? null;
+  }
+  static {
+    // ─── Debounce state (collapses repaint bursts into one emit) ────────────
+    //
+    // agy redraws the approval UI multiple times in rapid succession after
+    // the prompt first appears (spinner ticks, layout finalization, footer
+    // re-emit). Each redraw produces a different pane snapshot — different
+    // sha256 — and would otherwise fire a fresh `prompt-candidate`. We
+    // debounce here so that consecutive prompt-bearing snapshots within
+    // DEBOUNCE_QUIET_MS of each other collapse into a single emit of the
+    // LATEST snapshot. DEBOUNCE_MAX_WAIT_MS is a safety cap so that if
+    // agy never goes idle (e.g. an animated spinner inside the approval
+    // UI), we still emit eventually rather than starving the user.
+    // Correctness >> latency for approval prompts: agy users wait many
+    // seconds for the model to plan the action; an extra ~200ms before
+    // the prompt reaches mobile is invisible to the user.
+    this.DEBOUNCE_QUIET_MS = 200;
+  }
+  static {
+    this.DEBOUNCE_MAX_WAIT_MS = 600;
+  }
+  static {
+    /** Extra settle delay applied to Question UI snapshots inside
+     *  flushDebouncedEmit. agy renders question option lists
+     *  progressively (verified empirically when a 6-option prompt
+     *  emitted to mobile with only 5 options). Re-capturing once after
+     *  this delay catches options painted after the initial settle.
+     *  Approvals don't need this — their option count is fixed at 4
+     *  and they paint atomically. */
+    this.QUESTION_SETTLE_DELAY_MS = 100;
+  }
+  /**
+   * Start observing the tmux pane targeted by `sessionName`. If sessionName
+   * is omitted, read $CODEVIBE_AGY_TMUX_TARGET from env (set by the
+   * wrapper). Calling twice SEQUENTIALLY with the same session is a no-op;
+   * with a different session is a transparent restart.
+   *
+   * **Contract assumption** (Codex tmux-observer-r4 LOW): concurrent
+   * (overlapping in time) `start()` calls with the SAME session name are
+   * NOT supported. If start A is canceled by start B with the same target,
+   * A's generation-mismatch cleanup may disable B's just-enabled pipe.
+   * In our `codevibe-agy` wrapper, this is contract-impossible: the
+   * wrapper exec's agy ONCE per process with a unique PID-bound target,
+   * so observer.start() is called exactly once.
+   *
+   * Concurrent calls with DIFFERENT session names ARE supported via the
+   * existing stop()-then-start() restart path.
+   */
+  async start(sessionName) {
+    const targetSession = sessionName ?? process.env.CODEVIBE_AGY_TMUX_TARGET;
+    if (!targetSession) {
+      throw new Error(
+        "TmuxPaneObserver.start: no session name given and CODEVIBE_AGY_TMUX_TARGET not set"
+      );
+    }
+    if (this.started && this.sessionName === targetSession) {
+      logger.debug("Tmux pane observer already started", { sessionName: targetSession });
+      return;
+    }
+    if (this.started) {
+      await this.stop();
+    }
+    this.generation += 1;
+    const myGeneration = this.generation;
+    this.sessionName = targetSession;
+    this.filePosition = 0;
+    this.lastPromptHash = null;
+    this.approvalUIActive = false;
+    this.currentApprovalHeader = null;
+    try {
+      fs3.mkdirSync(path3.dirname(this.pipeFilePath), { recursive: true });
+      fs3.writeFileSync(this.pipeFilePath, "");
+      if (!this.skipTmuxCommands) {
+        await this.enablePipePane();
+      }
+      if (this.generation !== myGeneration) {
+        if (!this.skipTmuxCommands) {
+          try {
+            const escapedSession = escapeShellArg(targetSession);
+            await execAsync(`tmux pipe-pane -t '${escapedSession}'`);
+          } catch (cleanupError) {
+            logger.debug("Failed to disable tmux pipe-pane during canceled start (best-effort)", {
+              error: cleanupError
+            });
+          }
+        }
+        if (this.sessionName === targetSession) {
+          this.sessionName = null;
+        }
+        return;
+      }
+      this.startFileWatcher();
+      this.started = true;
+    } catch (error) {
+      this.sessionName = null;
+      this.started = false;
+      if (this.watcher) {
+        this.watcher.close();
+        this.watcher = null;
+      }
+      throw error;
+    }
+    logger.info("Tmux pane observer started", {
+      sessionName: targetSession,
+      pipeFilePath: this.pipeFilePath
+    });
+  }
+  async stop() {
+    this.generation += 1;
+    if (!this.started) return;
+    this.started = false;
+    this.cancelDebounce();
+    if (!this.skipTmuxCommands) {
+      try {
+        await this.disablePipePane();
+      } catch (error) {
+        logger.debug("Failed to disable tmux pipe-pane cleanly", { error });
+      }
+    }
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    try {
+      fs3.unlinkSync(this.pipeFilePath);
+    } catch {
+    }
+    logger.info("Tmux pane observer stopped", { sessionName: this.sessionName });
+    this.sessionName = null;
+    this.filePosition = 0;
+    this.processing = false;
+    this.pendingRead = false;
+    this.lastPromptHash = null;
+    this.approvalUIActive = false;
+    this.currentApprovalHeader = null;
+  }
+  /**
+   * Returns the current pane snapshot (best-effort). Used by approval-detector
+   * for the active-prompt-identity guard right before prompt-responder sends
+   * keys (DESIGN.md §3.4: "re-check active-prompt-identity immediately before
+   * send; if no active prompt or different identity, drop").
+   */
+  async captureSnapshot(lines = 120) {
+    if (!this.sessionName) {
+      throw new Error("Tmux pane observer is not started");
+    }
+    if (this.captureFn) {
+      return this.captureFn(this.sessionName, lines);
+    }
+    const safeLines = Math.max(1, Math.floor(lines));
+    const escapedSession = escapeShellArg(this.sessionName);
+    const cmd = `tmux capture-pane -p -e -S -${safeLines} -t '${escapedSession}'`;
+    try {
+      const { stdout } = await execAsync(cmd);
+      return stdout;
+    } catch (error) {
+      logger.error("Failed to capture tmux pane snapshot", {
+        sessionName: this.sessionName,
+        error
+      });
+      this.emit("observer-error", error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    }
+  }
+  /**
+   * Snapshot of "is an approval UI currently visible in the pane?". Cheap —
+   * returns cached state from the last fs.watch tick. For freshness-critical
+   * uses (e.g. just-before-send-keys), call probeApprovalUIActive() instead
+   * which does a fresh capture.
+   */
+  isApprovalUIActive() {
+    return this.approvalUIActive;
+  }
+  /**
+   * Fresh check via tmux capture-pane. More expensive than isApprovalUIActive()
+   * but reflects state as of NOW. Returns { active, headerText } so the caller
+   * can verify the active prompt's identity matches the expected one.
+   */
+  async probeApprovalUIActive() {
+    try {
+      const snapshot = await this.captureSnapshot();
+      const active = looksLikePromptSnapshot(snapshot);
+      let headerText = null;
+      if (active) {
+        const kind = detectActivePromptKind(snapshot);
+        if (kind === "question") {
+          const q = extractQuestionHeader(snapshot);
+          headerText = q ? q.body : null;
+        } else if (kind === "approval") {
+          headerText = extractHeader(snapshot);
+        }
+      }
+      return { active, headerText };
+    } catch {
+      return { active: false, headerText: null };
+    }
+  }
+  // ─── tmux pipe-pane plumbing ─────────────────────────────────────────────
+  async enablePipePane() {
+    if (!this.sessionName) {
+      throw new Error("Tmux pane observer is not initialized");
+    }
+    const escapedSession = escapeShellArg(this.sessionName);
+    const escapedFile = escapeShellArg(this.pipeFilePath);
+    const cmd = `tmux pipe-pane -O -t '${escapedSession}' "cat >> '${escapedFile}'"`;
+    await execAsync(cmd);
+    logger.debug("Enabled tmux pipe-pane mirroring", {
+      sessionName: this.sessionName,
+      pipeFilePath: this.pipeFilePath
+    });
+  }
+  async disablePipePane() {
+    if (!this.sessionName) return;
+    const escapedSession = escapeShellArg(this.sessionName);
+    const cmd = `tmux pipe-pane -t '${escapedSession}'`;
+    await execAsync(cmd);
+  }
+  startFileWatcher() {
+    this.watcher = fs3.watch(this.pipeFilePath, (eventType) => {
+      if (eventType !== "change") return;
+      void this.processFileChanges();
+    });
+  }
+  /**
+   * Coalesce a prompt-bearing snapshot into the pending debounce window.
+   * Each new candidate within the quiet-window replaces the prior one
+   * (we always emit the LATEST snapshot — that's the settled state agy
+   * is showing). A MAX_WAIT cap ensures we still emit even if agy never
+   * goes idle (e.g. an animated spinner inside the approval UI).
+   */
+  scheduleDebouncedEmit(candidate) {
+    const now = Date.now();
+    this.pendingEmitCandidate = candidate;
+    if (this.debounceWindowOpenedAt === null) {
+      this.debounceWindowOpenedAt = now;
+    }
+    const elapsed = now - this.debounceWindowOpenedAt;
+    const cappedRemaining = Math.max(0, _TmuxPaneObserver.DEBOUNCE_MAX_WAIT_MS - elapsed);
+    const waitMs = Math.min(_TmuxPaneObserver.DEBOUNCE_QUIET_MS, cappedRemaining);
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.debounceCycleId += 1;
+    const myGeneration = this.generation;
+    const myCycleId = this.debounceCycleId;
+    this.debounceTimer = setTimeout(() => {
+      void this.flushDebouncedEmit(myGeneration, myCycleId);
+    }, waitMs);
+    if (this.debounceTimer.unref) this.debounceTimer.unref();
+  }
+  /**
+   * Fire the deferred `prompt-candidate` emit if (a) we're still in the
+   * same generation as when the timer was scheduled and (b) the
+   * observer is still started.
+   *
+   * Re-captures the pane snapshot here, BEFORE emitting. The staged
+   * candidate's snapshot was taken inside the most recent
+   * `processFileChanges` tick during the burst — which may have been
+   * mid-paint if agy was still rendering options or footer content.
+   * By flush time the pane has been quiet for ≥ DEBOUNCE_QUIET_MS, so
+   * a fresh capture reflects the SETTLED state. (Empirical
+   * 2026-05-21: a Question UI with 6 options on desktop was emitted
+   * to mobile with only 5 because the staged snapshot was captured
+   * before agy painted the last option.)
+   *
+   * Re-applies the lastPromptHash dedup against the FRESH hash so a
+   * snapshot that ends up identical to the previous emission doesn't
+   * fire a redundant candidate.
+   */
+  async flushDebouncedEmit(scheduledGeneration, scheduledCycleId) {
+    if (this.generation !== scheduledGeneration || !this.started) return;
+    if (this.debounceCycleId !== scheduledCycleId) return;
+    const staged = this.pendingEmitCandidate;
+    this.pendingEmitCandidate = null;
+    this.debounceTimer = null;
+    this.debounceWindowOpenedAt = null;
+    if (!staged) return;
+    let candidate = staged;
+    try {
+      const freshSnapshot = await this.captureSnapshot();
+      if (freshSnapshot && looksLikePromptSnapshot(freshSnapshot)) {
+        candidate = {
+          rawDelta: staged.rawDelta,
+          snapshot: freshSnapshot,
+          detectedAt: Date.now(),
+          snapshotHash: hashPromptSnapshot(freshSnapshot)
+        };
+      }
+      if (isQuestionUISnapshot(candidate.snapshot)) {
+        const firstHeader = extractQuestionHeader(candidate.snapshot);
+        await sleep(_TmuxPaneObserver.QUESTION_SETTLE_DELAY_MS);
+        if (this.generation !== scheduledGeneration || !this.started) return;
+        if (this.debounceCycleId !== scheduledCycleId) return;
+        try {
+          const settled = await this.captureSnapshot();
+          if (this.generation !== scheduledGeneration || !this.started) return;
+          if (this.debounceCycleId !== scheduledCycleId) return;
+          const settledHeader = settled ? extractQuestionHeader(settled) : null;
+          const sameBody = !!firstHeader && !!settledHeader && firstHeader.body === settledHeader.body;
+          if (settled && looksLikePromptSnapshot(settled) && detectActivePromptKind(settled) === "question" && sameBody) {
+            candidate = {
+              rawDelta: staged.rawDelta,
+              snapshot: settled,
+              detectedAt: Date.now(),
+              snapshotHash: hashPromptSnapshot(settled)
+            };
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    if (this.generation !== scheduledGeneration || !this.started) return;
+    if (this.debounceCycleId !== scheduledCycleId) return;
+    if (candidate.snapshotHash === this.lastPromptHash) return;
+    this.lastPromptHash = candidate.snapshotHash;
+    this.approvalUIActive = true;
+    this.currentApprovalHeader = extractHeader(candidate.snapshot);
+    this.emit("prompt-candidate", candidate);
+  }
+  /** Cancel any in-flight debounce timer + drop the pending candidate.
+   *  Called from stop() so a wrapper exit / restart doesn't fire a
+   *  prompt for a torn-down observer. Also bumps debounceCycleId so
+   *  any in-flight flushDebouncedEmit currently awaiting a capture
+   *  sees a cycle-id mismatch at its next guard and bails — without
+   *  this bump, a flush mid-sleep at stop() time could resume and
+   *  emit because the generation guard alone is delayed by a
+   *  separate start()/stop() cycle (which is what `generation`
+   *  tracks). */
+  cancelDebounce() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    this.pendingEmitCandidate = null;
+    this.debounceWindowOpenedAt = null;
+    this.debounceCycleId += 1;
+  }
+  /**
+   * Public hook for tests / drivers: trigger a read+process cycle as if
+   * fs.watch had fired. Not invoked in production except via the
+   * watcher.
+   *
+   * In production, processFileChanges schedules a debounced emit via
+   * setTimeout(DEBOUNCE_QUIET_MS); the timer fires after the pane
+   * goes quiet, at which point flushDebouncedEmit re-captures and
+   * emits. Tests using tick() expect the emit to be observable
+   * synchronously after await — so we drain any pending debounce
+   * here, end-to-end, so tests don't have to coordinate with the
+   * real timeout.
+   */
+  async tick() {
+    await this.processFileChanges();
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+      await this.flushDebouncedEmit(this.generation, this.debounceCycleId);
+    }
+  }
+  async processFileChanges() {
+    if (this.processing) {
+      this.pendingRead = true;
+      return;
+    }
+    if (!this.started) return;
+    this.processing = true;
+    const myGeneration = this.generation;
+    try {
+      do {
+        if (this.generation !== myGeneration || !this.started) return;
+        this.pendingRead = false;
+        const chunk = this.readAppendedChunk();
+        if (!chunk) continue;
+        if (!looksLikePromptDelta(chunk)) {
+          if (this.approvalUIActive) {
+            await this.checkPromptCleared(myGeneration);
+          }
+          continue;
+        }
+        const snapshot = await this.captureSnapshot();
+        if (this.generation !== myGeneration || !this.started) return;
+        if (!snapshot || !looksLikePromptSnapshot(snapshot)) {
+          if (this.approvalUIActive) {
+            await this.checkPromptCleared(myGeneration);
+          }
+          continue;
+        }
+        const snapshotHash = hashPromptSnapshot(snapshot);
+        if (snapshotHash === this.lastPromptHash) {
+          continue;
+        }
+        if (this.generation !== myGeneration || !this.started) return;
+        this.scheduleDebouncedEmit({
+          rawDelta: chunk,
+          snapshot,
+          detectedAt: Date.now(),
+          snapshotHash
+        });
+      } while (this.pendingRead);
+    } catch (error) {
+      if (this.generation !== myGeneration || !this.started) return;
+      logger.error("Failed to process tmux pane changes", { error });
+      this.emit("observer-error", error instanceof Error ? error : new Error(String(error)));
+    } finally {
+      if (this.generation === myGeneration) {
+        this.processing = false;
+      }
+    }
+  }
+  /** Called when we suspect the approval UI may have vanished. Does a
+   *  fresh capture; if the pane no longer shows approval UI, fires
+   *  'prompt-cleared'. Generation-checked to suppress emit after stop(). */
+  async checkPromptCleared(myGeneration) {
+    try {
+      const snapshot = await this.captureSnapshot();
+      if (this.generation !== myGeneration || !this.started) return;
+      if (!looksLikePromptSnapshot(snapshot)) {
+        this.approvalUIActive = false;
+        this.lastPromptHash = null;
+        this.currentApprovalHeader = null;
+        this.emit("prompt-cleared");
+      }
+    } catch {
+    }
+  }
+  readAppendedChunk() {
+    const stat = fs3.statSync(this.pipeFilePath);
+    if (stat.size <= this.filePosition) return "";
+    const fd = fs3.openSync(this.pipeFilePath, "r");
+    try {
+      const length = stat.size - this.filePosition;
+      const buffer = Buffer.alloc(length);
+      fs3.readSync(fd, buffer, 0, length, this.filePosition);
+      this.filePosition = stat.size;
+      return buffer.toString("utf-8");
+    } finally {
+      fs3.closeSync(fd);
+    }
+  }
+};
+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)
+  );
+}
+function looksLikePromptSnapshot(snapshot) {
+  const stripped = snapshot.replace(ANSI_ESCAPE_REGEX, "");
+  const recent = stripped.split("\n").slice(-30).join("\n");
+  const hasApprovalHeader = /Requesting permission for:/i.test(recent) || /Do you want to proceed\?/i.test(recent);
+  const hasApprovalOptions = /^\s*[1-9]\. (?:Yes|No)\b/im.test(recent);
+  const hasApprovalFooter = /\besc to cancel\b/i.test(recent);
+  const isApproval = hasApprovalHeader && hasApprovalOptions && hasApprovalFooter;
+  const hasQuestionHeader = /Question \d+\/\d+:/i.test(recent);
+  const hasQuestionOptions = /^[>\s]+[1-9]\. \S/im.test(recent);
+  const hasQuestionFooter = /\benter Select\b/i.test(recent);
+  const isQuestion = hasQuestionHeader && hasQuestionOptions && hasQuestionFooter;
+  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;
+}
+function extractHeader(snapshot) {
+  const stripped = snapshot.replace(ANSI_ESCAPE_REGEX, "");
+  const matches = Array.from(stripped.matchAll(/Requesting permission for:\s*([^\n]+)/gi));
+  if (matches.length === 0) return null;
+  return matches[matches.length - 1][1].trim();
+}
+function extractFullHeaderLine(snapshot) {
+  const stripped = snapshot.replace(ANSI_ESCAPE_REGEX, "");
+  const matches = Array.from(stripped.matchAll(/Requesting permission for:\s*([^\n]+)/gi));
+  if (matches.length === 0) return null;
+  return matches[matches.length - 1][0].trim();
+}
+function detectActivePromptKind(snapshot) {
+  const stripped = snapshot.replace(ANSI_ESCAPE_REGEX, "");
+  const lines = stripped.split("\n");
+  const approvalRe = /Requesting permission for:/i;
+  const questionRe = /Question \d+\/\d+:/i;
+  let lastApprovalLineIdx = -1;
+  let lastQuestionLineIdx = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lastApprovalLineIdx < 0 && approvalRe.test(lines[i])) {
+      lastApprovalLineIdx = i;
+    }
+    if (lastQuestionLineIdx < 0 && questionRe.test(lines[i])) {
+      lastQuestionLineIdx = i;
+    }
+    if (lastApprovalLineIdx >= 0 && lastQuestionLineIdx >= 0) break;
+  }
+  if (lastApprovalLineIdx < 0 && lastQuestionLineIdx < 0) return null;
+  if (lastQuestionLineIdx > lastApprovalLineIdx) return "question";
+  return "approval";
+}
+function extractQuestionHeader(snapshot) {
+  const stripped = snapshot.replace(ANSI_ESCAPE_REGEX, "");
+  const matches = Array.from(stripped.matchAll(/Question \d+\/\d+:\s*([^\n]+)/gi));
+  if (matches.length === 0) return null;
+  const last = matches[matches.length - 1];
+  return { fullLine: last[0].trim(), body: last[1].trim() };
+}
+function hashPromptSnapshot(snapshot) {
+  const normalized = snapshot.replace(ANSI_ESCAPE_REGEX, "").replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/[ \t]+\n/g, "\n").trim();
+  return (0, import_crypto.createHash)("sha256").update(normalized).digest("hex");
+}
+var ANSI_ESCAPE_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+function escapeShellArg(value) {
+  return value.replace(/'/g, `'\\''`);
+}
+function sleep(ms) {
+  return new Promise((resolve3) => {
+    const t = setTimeout(resolve3, ms);
+    if (t.unref) t.unref();
+  });
+}
+function isQuestionUISnapshot(snapshot) {
+  const stripped = snapshot.replace(ANSI_ESCAPE_REGEX, "");
+  return /Question \d+\/\d+:/i.test(stripped);
+}
+
+// src/approval-detector.ts
+var import_events3 = require("events");
+var import_uuid = require("uuid");
+
+// src/prompt-parser.ts
+function parseApprovalSnapshot(snapshot) {
+  if (!snapshot) return null;
+  const stripped = stripAnsi(snapshot);
+  const kind = detectActivePromptKind(stripped);
+  if (kind === "question") {
+    const questionHeader = extractQuestionHeader(stripped);
+    if (questionHeader) {
+      return parseQuestionSnapshot(stripped, snapshot, questionHeader);
+    }
+  }
+  return parseApprovalUISnapshot(stripped, snapshot);
+}
+function parseApprovalUISnapshot(stripped, originalSnapshot) {
+  const headerText = extractHeader(stripped);
+  if (!headerText) return null;
+  const fullHeaderLine = extractFullHeaderLine(stripped) ?? headerText;
+  const lines = stripped.split("\n");
+  let headerIdx = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lines[i].includes("Requesting permission for:")) {
+      headerIdx = i;
+      break;
+    }
+  }
+  const belowHeader = headerIdx >= 0 ? lines.slice(headerIdx + 1).join("\n") : stripped;
+  const options = parseOptions(belowHeader);
+  if (options.length < 2) return null;
+  const submitMap = buildApprovalSubmitMap(options);
+  const { command, filePath } = extractIdentity(headerText);
+  return {
+    kind: "approval",
+    headerText,
+    fullHeaderLine,
+    command,
+    filePath,
+    options,
+    submitMap,
+    paneHash: hashPromptSnapshot(originalSnapshot)
+  };
+}
+function parseQuestionSnapshot(stripped, originalSnapshot, header) {
+  const lines = stripped.split("\n");
+  let headerIdx = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (/Question \d+\/\d+:/i.test(lines[i])) {
+      headerIdx = i;
+      break;
+    }
+  }
+  const belowHeader = headerIdx >= 0 ? lines.slice(headerIdx + 1).join("\n") : stripped;
+  const options = parseOptions(belowHeader);
+  if (options.length < 2) return null;
+  const submitMap = buildQuestionSubmitMap(options);
+  return {
+    kind: "question",
+    headerText: header.body,
+    fullHeaderLine: header.fullLine,
+    command: void 0,
+    filePath: void 0,
+    options,
+    submitMap,
+    paneHash: hashPromptSnapshot(originalSnapshot)
+  };
+}
+function parseOptions(snapshot) {
+  const recent = snapshot.split("\n").slice(-30);
+  const optionRegex = /^[>\s]*([1-9])\. (.+?)\s*$/;
+  const found = /* @__PURE__ */ new Map();
+  for (const line of recent) {
+    const m = line.match(optionRegex);
+    if (!m) continue;
+    const num = m[1];
+    found.set(num, m[2].trim());
+  }
+  return Array.from(found.entries()).sort(([a], [b]) => Number(a) - Number(b)).map(([number, text]) => ({ number, text }));
+}
+function buildApprovalSubmitMap(options) {
+  const map = {};
+  for (const opt of options) {
+    map[opt.number] = [opt.number];
+  }
+  return map;
+}
+function buildQuestionSubmitMap(options) {
+  const map = {};
+  for (const opt of options) {
+    map[opt.number] = [opt.number, "Enter"];
+  }
+  return map;
+}
+function extractIdentity(headerText) {
+  if (!headerText) return {};
+  const trimmed = headerText.trim();
+  if (trimmed.startsWith("/") || trimmed.startsWith("~/") || trimmed.startsWith("./") || /^[A-Za-z]:[\\/]/.test(trimmed)) {
+    if (!/\s/.test(trimmed)) {
+      return { filePath: trimmed };
+    }
+  }
+  const firstWord = trimmed.split(/\s+/, 1)[0].toLowerCase();
+  const KNOWN_COMMANDS = /* @__PURE__ */ new Set([
+    // Shell builtins / coreutils
+    "rm",
+    "mv",
+    "cp",
+    "cat",
+    "ls",
+    "mkdir",
+    "rmdir",
+    "touch",
+    "echo",
+    "pwd",
+    "chmod",
+    "chown",
+    "find",
+    "grep",
+    "sed",
+    "awk",
+    "tar",
+    "curl",
+    "wget",
+    "tee",
+    "head",
+    "tail",
+    "cut",
+    "sort",
+    "uniq",
+    "wc",
+    "diff",
+    "patch",
+    // Common dev tools
+    "git",
+    "npm",
+    "pnpm",
+    "yarn",
+    "bun",
+    "node",
+    "python",
+    "python3",
+    "pip",
+    "cargo",
+    "rustc",
+    "go",
+    "gradle",
+    "mvn",
+    "bash",
+    "sh",
+    "zsh",
+    "make",
+    "docker",
+    "podman",
+    "kubectl",
+    "helm",
+    "terraform",
+    "aws",
+    "gcloud",
+    // Editors (rarely intercepted but possible)
+    "vim",
+    "nvim",
+    "nano",
+    "code"
+  ]);
+  if (KNOWN_COMMANDS.has(firstWord)) {
+    return { command: trimmed };
+  }
+  if (/\./.test(firstWord) && !/\s/.test(trimmed)) {
+    return { filePath: trimmed };
+  }
+  return { command: trimmed };
+}
+function guessToolTypeFromIdentity(c) {
+  if (c.command) return "RUN_COMMAND";
+  if (c.filePath) return "CODE_ACTION";
+  return "GENERIC";
+}
+var ANSI_ESCAPE_REGEX2 = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+function stripAnsi(s) {
+  return s.replace(ANSI_ESCAPE_REGEX2, "");
+}
+
+// src/approval-detector.ts
+var DEFAULT_PROMPT_TTL_MS = 6e4;
+var PENDING_CALL_TTL_MS = 5 * 6e4;
+var SWEEP_INTERVAL_MS = 3e4;
+var PASS3_MIN_IDENTITY_LEN = 4;
+var PENDING_CANDIDATE_BUFFER_MS = 5e3;
+var ApprovalDetector = class extends import_events3.EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.pendingCalls = /* @__PURE__ */ new Map();
+    this.pendingPrompts = /* @__PURE__ */ new Map();
+    /** Track recently-resolved promptIds so a duplicate candidate-emit
+     *  doesn't re-fire INTERACTIVE_PROMPT. Maps promptId → ms-epoch when
+     *  resolved. Pruned by sweep. */
+    this.resolvedPrompts = /* @__PURE__ */ new Map();
+    /** Pre-transcript candidate buffer keyed by `${conversationId}|${paneHash}`
+     *  (composite key prevents collision when two conversations on the same
+     *  tmux pane produce identical paneHashes — agy R2 Stage 2 round-3 MED).
+     *  When a candidate arrives with no matching pending call, we park it
+     *  here for pendingCandidateBufferMs and re-try the match each time
+     *  registerPendingCall fires. */
+    this.pendingCandidates = /* @__PURE__ */ new Map();
+    this.sweepTimer = null;
+    // ─── Pane-only prompt emission (v9.1 — bypasses pending-call match) ─────
+    /** Set of pane-snapshot hashes we've already emitted INTERACTIVE_PROMPT
+     *  for. Belt-and-suspenders dedupe against the case where paneObserver
+     *  somehow re-fires `prompt-candidate` with the same snapshot bytes
+     *  for the same prompt. The primary dedupe for cosmetic redraws of a
+     *  single approval (spinner ticks, cursor blink, partial repaints)
+     *  lives in tmux-pane-observer's debounce window — by the time a
+     *  candidate reaches this layer, the pane has settled. */
+    this.paneOnlyEmittedHashes = /* @__PURE__ */ new Set();
+    this.promptTtlMs = options.promptTtlMs ?? DEFAULT_PROMPT_TTL_MS;
+    this.pendingCallTtlMs = options.pendingCallTtlMs ?? PENDING_CALL_TTL_MS;
+    this.sweepIntervalMs = options.sweepIntervalMs ?? SWEEP_INTERVAL_MS;
+    this.pendingCandidateBufferMs = options.pendingCandidateBufferMs ?? PENDING_CANDIDATE_BUFFER_MS;
+  }
+  start() {
+    if (this.sweepTimer) return;
+    this.sweepTimer = setInterval(() => this.sweep(), this.sweepIntervalMs);
+    if (this.sweepTimer.unref) this.sweepTimer.unref();
+    logger.info("Approval detector started", {
+      promptTtlMs: this.promptTtlMs,
+      pendingCallTtlMs: this.pendingCallTtlMs
+    });
+  }
+  async stop() {
+    if (this.sweepTimer) {
+      clearInterval(this.sweepTimer);
+      this.sweepTimer = null;
+    }
+    this.pendingCalls.clear();
+    this.pendingPrompts.clear();
+    this.resolvedPrompts.clear();
+    this.pendingCandidates.clear();
+    this.paneOnlyEmittedHashes.clear();
+    logger.info("Approval detector stopped");
+  }
+  /**
+   * Emit INTERACTIVE_PROMPT directly from a pane snapshot, WITHOUT
+   * requiring a matching PendingToolCall from a transcript PLANNER_RESPONSE.
+   *
+   * Background (v9.1, 2026-05-21): agy does NOT write tool_call entries
+   * to the transcript BEFORE rendering the approval UI for shell
+   * commands. It only writes them AFTER the user approves. So the
+   * transcript-based pending-call matching path deadlocks for shell
+   * commands: paneObserver sees the UI, but no pending call exists →
+   * candidate buffered → user can't approve from mobile (no prompt
+   * shown) → no transcript write → buffer expires.
+   *
+   * Solution: pane is authoritative for "approval UI is showing right
+   * now." Skip the pending-call requirement and emit directly. The
+   * parsed candidate has everything needed (command, options, submitMap).
+   *
+   * Synthesizes a minimal PendingToolCall from the candidate so the
+   * existing handlePendingPrompt code path doesn't need to branch on
+   * `pendingCall: null`.
+   *
+   * Returns the emitted state, or null if dedupe (already emitted for
+   * this paneHash) or disabled.
+   */
+  emitPaneOnlyPrompt(candidate, conversationId) {
+    if (this.paneOnlyEmittedHashes.has(candidate.paneHash)) {
+      logger.debug("Skipping pane-only re-emit for duplicate paneHash", {
+        paneHash: candidate.paneHash.substring(0, 16)
+      });
+      return null;
+    }
+    const promptId = (0, import_uuid.v4)();
+    const syntheticCall = {
+      conversationId,
+      intentStepIndex: -1,
+      // sentinel: "no transcript origin"
+      toolCallIndex: 0,
+      intentByteOffset: 0,
+      // Best-effort tool-type inference from the candidate. For shell
+      // commands → RUN_COMMAND. For edit-style headers with a file
+      // path → CODE_ACTION. Default: GENERIC.
+      toolType: guessToolTypeFromIdentity(candidate),
+      command: candidate.command,
+      filePath: candidate.filePath,
+      rawToolName: candidate.command ?? candidate.filePath ?? "unknown",
+      promptId,
+      startedAt: Date.now(),
+      intentCreatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const state = {
+      promptId,
+      conversationId,
+      pendingCall: syntheticCall,
+      submitMap: candidate.submitMap,
+      matchedPaneHeader: candidate.headerText,
+      paneDisplayHeader: candidate.fullHeaderLine,
+      emittedAt: Date.now(),
+      ttlMs: this.promptTtlMs,
+      paneOptions: candidate.options
+    };
+    this.pendingPrompts.set(promptId, state);
+    this.paneOnlyEmittedHashes.add(candidate.paneHash);
+    logger.info("Emitting pane-only INTERACTIVE_PROMPT", {
+      promptId,
+      command: candidate.command,
+      filePath: candidate.filePath,
+      optionsCount: candidate.options.length
+    });
+    this.emit("pending-prompt", state);
+    return state;
+  }
+  // ─── Pending-call registration (called from event-mapper hook) ──────────
+  /**
+   * Register a tool-call intent from a PLANNER_RESPONSE.tool_calls[].
+   * Indexed by composite key so agy rollback (which can replay
+   * step_index values) doesn't cause collisions.
+   */
+  registerPendingCall(call) {
+    const key = this.callKey(call);
+    if (this.pendingCalls.has(key)) {
+      logger.debug("Pending call already registered, skipping", {
+        key,
+        intentStepIndex: call.intentStepIndex,
+        toolType: call.toolType
+      });
+      return;
+    }
+    this.pendingCalls.set(key, call);
+    logger.debug("Pending tool call registered", {
+      key,
+      toolType: call.toolType,
+      command: call.command,
+      filePath: call.filePath
+    });
+    this.drainBufferedCandidates(call.conversationId);
+  }
+  drainBufferedCandidates(conversationId) {
+    if (this.pendingCandidates.size === 0) return;
+    const now = Date.now();
+    for (const [key, buffered] of this.pendingCandidates.entries()) {
+      if (buffered.conversationId !== conversationId) continue;
+      if (now - buffered.queuedAt > this.pendingCandidateBufferMs) {
+        this.pendingCandidates.delete(key);
+        continue;
+      }
+      const state = this.matchCandidateInternal(buffered.candidate, buffered.conversationId);
+      if (state) {
+        this.pendingCandidates.delete(key);
+        logger.info("Drained buffered candidate after pending-call arrived", {
+          key,
+          ageMs: now - buffered.queuedAt
+        });
+      }
+    }
+  }
+  /** Composite key for the pre-transcript buffer. Scoping by
+   *  conversationId prevents the collision case where two simultaneous
+   *  conversations on the same tmux pane (contract-discouraged but not
+   *  contract-impossible) produce identical paneHashes — without
+   *  conversation scoping, conv-B's candidate would be silently dropped
+   *  at the same-key dedupe check. (agy R2 Stage 2 round-3 MED finding
+   *  2026-05-20.) */
+  candidateKey(conversationId, paneHash) {
+    return `${conversationId}|${paneHash}`;
+  }
+  /**
+   * Clear a pending call when its matching RESULT event arrives in the
+   * transcript. event-mapper.ts calls this from its tool-result handlers.
+   *
+   * The result event's step_index = intentStepIndex + toolCallIndex + 1
+   * per agy R2 v2 (the deterministic correlation formula). We try to
+   * match by (conversationId, expected step_index, toolType) — when one
+   * matches, clear it. If multiple pending calls match (rollback edge),
+   * clear the earliest by intentStepIndex.
+   */
+  clearOnResultEvent(args) {
+    let matched = null;
+    let matchedKey = null;
+    for (const [key, call] of this.pendingCalls.entries()) {
+      if (call.conversationId !== args.conversationId) continue;
+      if (call.toolType !== args.toolType) continue;
+      const expected = call.intentStepIndex + call.toolCallIndex + 1;
+      if (expected !== args.resultStepIndex) continue;
+      if (typeof args.resultByteOffset === "number") {
+        if (call.intentByteOffset >= args.resultByteOffset) continue;
+        if (!matched || call.intentByteOffset > matched.intentByteOffset) {
+          matched = call;
+          matchedKey = key;
+        }
+      } else if (!matched || call.intentStepIndex < matched.intentStepIndex) {
+        matched = call;
+        matchedKey = key;
+      }
+    }
+    if (matched && matchedKey) {
+      matched.resultStepIndex = args.resultStepIndex;
+      this.pendingCalls.delete(matchedKey);
+      if (matched.promptId) {
+        this.resolvedPrompts.set(matched.promptId, Date.now());
+        this.pendingPrompts.delete(matched.promptId);
+      }
+      logger.debug("Pending tool call cleared on result event", {
+        intentStepIndex: matched.intentStepIndex,
+        toolCallIndex: matched.toolCallIndex,
+        resultStepIndex: args.resultStepIndex,
+        toolType: args.toolType
+      });
+    }
+    return matched;
+  }
+  // ─── Candidate matching (called from tmux-pane-observer's prompt-candidate) ─
+  /**
+   * Cross-reference a parsed ApprovalCandidate against the pending-call
+   * list. Returns the matched PendingPromptState (which the MCP server
+   * uses to create the INTERACTIVE_PROMPT event), or null if no match
+   * (stale scrollback).
+   *
+   * Match algorithm:
+   *   1. Filter pendingCalls by candidate.command (if set) — exact match
+   *      against PendingToolCall.command.
+   *   2. Fallback: filter by candidate.filePath (if set) — exact match
+   *      against PendingToolCall.filePath.
+   *   3. If multiple candidates match (rare), prefer the earliest
+   *      intentStepIndex.
+   *   4. If a match exists AND it already has a promptId AND that
+   *      promptId is in resolvedPrompts → null (don't re-emit).
+   *   5. If a match exists AND has a promptId BUT NOT resolved → return
+   *      the existing PendingPromptState (idempotent re-emit on the same
+   *      promptId for a duplicate candidate hash).
+   *   6. Otherwise: create a fresh promptId + PendingPromptState, attach
+   *      to the matched call, store in pendingPrompts, return it.
+   */
+  matchCandidate(candidate, conversationId) {
+    const state = this.matchCandidateInternal(candidate, conversationId);
+    if (state) return state;
+    const existing = this.pendingCandidates.get(this.candidateKey(conversationId, candidate.paneHash));
+    if (existing) {
+      logger.debug("Candidate already buffered (same paneHash)", { paneHash: this.candidateKey(conversationId, candidate.paneHash) });
+    } else {
+      this.pendingCandidates.set(this.candidateKey(conversationId, candidate.paneHash), {
+        candidate,
+        conversationId,
+        queuedAt: Date.now()
+      });
+      logger.debug("No pending tool-call matched \u2014 buffering candidate for pre-transcript window", {
+        candidateCommand: candidate.command,
+        candidateFilePath: candidate.filePath,
+        pendingCount: this.pendingCalls.size,
+        bufferSize: this.pendingCandidates.size
+      });
+    }
+    return null;
+  }
+  /** Internal match logic — does NOT buffer on miss. Used both by the
+   *  public matchCandidate (which buffers on miss) and by
+   *  drainBufferedCandidates (which doesn't re-buffer; misses just stay
+   *  in the buffer until their TTL expires). */
+  matchCandidateInternal(candidate, conversationId) {
+    const matched = this.findMatchingPendingCall(candidate, conversationId);
+    if (!matched) {
+      return null;
+    }
+    if (matched.promptId && this.resolvedPrompts.has(matched.promptId)) {
+      logger.debug("Skipping re-emit for already-resolved prompt", {
+        promptId: matched.promptId
+      });
+      return null;
+    }
+    if (matched.promptId && this.pendingPrompts.has(matched.promptId)) {
+      return this.pendingPrompts.get(matched.promptId) ?? null;
+    }
+    const promptId = (0, import_uuid.v4)();
+    matched.promptId = promptId;
+    const state = {
+      promptId,
+      conversationId,
+      pendingCall: matched,
+      submitMap: candidate.submitMap,
+      matchedPaneHeader: candidate.headerText,
+      paneDisplayHeader: candidate.fullHeaderLine,
+      emittedAt: Date.now(),
+      ttlMs: this.promptTtlMs
+    };
+    this.pendingPrompts.set(promptId, state);
+    logger.info("Emitting INTERACTIVE_PROMPT for matched candidate", {
+      promptId,
+      command: matched.command,
+      filePath: matched.filePath,
+      intentStepIndex: matched.intentStepIndex,
+      toolCallIndex: matched.toolCallIndex
+    });
+    this.emit("pending-prompt", state);
+    return state;
+  }
+  /** Resolve a pending prompt — called from MCP server when mobile sends
+   *  the option-number reply with metadata.promptId. */
+  /**
+   * Called from the MCP server when paneObserver emits 'prompt-cleared'
+   * — i.e. the approval UI disappeared from the pane (desktop user
+   * picked an option, agy timed out the prompt, or the dispatcher
+   * answered). Resolves ALL outstanding pane-only pending prompts and
+   * releases the paneOnly dedup hashes so a subsequent approval can
+   * fresh-emit. Without this, mobile prompt state dangles until TTL
+   * AND the next identical approval is forever-suppressed by stale
+   * dedup. (Stage 2 R1 MED finding 2026-05-21.)
+   */
+  onPanePromptCleared() {
+    if (this.pendingPrompts.size === 0 && this.paneOnlyEmittedHashes.size === 0) {
+      return;
+    }
+    const now = Date.now();
+    const cleared = [];
+    for (const [promptId] of this.pendingPrompts.entries()) {
+      this.resolvedPrompts.set(promptId, now);
+      cleared.push(promptId);
+    }
+    this.pendingPrompts.clear();
+    this.paneOnlyEmittedHashes.clear();
+    if (cleared.length > 0) {
+      logger.info("Pane prompt cleared \u2014 resolved pending prompts", {
+        count: cleared.length
+      });
+    }
+  }
+  resolvePrompt(promptId) {
+    const state = this.pendingPrompts.get(promptId);
+    if (!state) return null;
+    this.resolvedPrompts.set(promptId, Date.now());
+    this.pendingPrompts.delete(promptId);
+    this.paneOnlyEmittedHashes.clear();
+    return state;
+  }
+  /**
+   * Roll back a pending prompt WITHOUT marking it as resolved. Used by
+   * the MCP server when the INTERACTIVE_PROMPT createEvent fails — the
+   * prompt was never delivered to mobile, so a future tmux pane
+   * candidate for the same pending tool-call should be eligible to
+   * re-emit. `resolvePrompt` is the WRONG call there because it adds
+   * the promptId to `resolvedPrompts`, which the stale-scrollback guard
+   * uses to suppress re-emit forever. This method instead detaches the
+   * promptId from the pending call + removes from pendingPrompts +
+   * leaves resolvedPrompts UNTOUCHED so the fresh-emit path runs on
+   * the next match. (agy R2 Stage 2 round-2 MED finding 2026-05-20.)
+   */
+  rollbackPrompt(promptId) {
+    const state = this.pendingPrompts.get(promptId);
+    if (!state) return null;
+    this.pendingPrompts.delete(promptId);
+    if (state.pendingCall.promptId === promptId) {
+      state.pendingCall.promptId = void 0;
+    }
+    this.paneOnlyEmittedHashes.clear();
+    return state;
+  }
+  /** Returns the current pending-prompt state by id, or null if expired /
+   *  unknown. Used by prompt-responder for the active-prompt-identity
+   *  guard right before send-keys. */
+  getPendingPrompt(promptId) {
+    return this.pendingPrompts.get(promptId) ?? null;
+  }
+  // ─── Read-only accessors ────────────────────────────────────────────────
+  getPendingCalls() {
+    return Array.from(this.pendingCalls.values());
+  }
+  getActivePromptCount() {
+    return this.pendingPrompts.size;
+  }
+  // ─── Internals ──────────────────────────────────────────────────────────
+  callKey(call) {
+    return `${call.conversationId}|${call.intentStepIndex}|${call.toolCallIndex}|${call.intentByteOffset}`;
+  }
+  findMatchingPendingCall(candidate, conversationId) {
+    if (candidate.command) {
+      const matches = Array.from(this.pendingCalls.values()).filter((c) => c.conversationId === conversationId).filter((c) => c.command && c.command === candidate.command).sort((a, b) => a.intentStepIndex - b.intentStepIndex);
+      if (matches.length > 0) return matches[0];
+    }
+    if (candidate.filePath) {
+      const matches = Array.from(this.pendingCalls.values()).filter((c) => c.conversationId === conversationId).filter((c) => c.filePath && c.filePath === candidate.filePath).sort((a, b) => a.intentStepIndex - b.intentStepIndex);
+      if (matches.length > 0) return matches[0];
+    }
+    const allFields = (candidate.command ?? "") + " " + (candidate.filePath ?? "");
+    if (allFields.trim()) {
+      const matches = Array.from(this.pendingCalls.values()).filter((c) => c.conversationId === conversationId).filter((c) => {
+        const cmd = (c.command ?? "").trim();
+        const fp = (c.filePath ?? "").trim();
+        if (!cmd && !fp) return false;
+        const cmdOk = cmd.length >= PASS3_MIN_IDENTITY_LEN && containsAsWord(allFields, cmd);
+        const fpOk = fp.length >= PASS3_MIN_IDENTITY_LEN && containsAsWord(allFields, fp);
+        return cmdOk || fpOk;
+      }).sort((a, b) => a.intentStepIndex - b.intentStepIndex);
+      if (matches.length > 0) return matches[0];
+    }
+    return null;
+  }
+  sweep() {
+    const now = Date.now();
+    for (const [key, call] of this.pendingCalls.entries()) {
+      if (now - call.startedAt > this.pendingCallTtlMs) {
+        this.pendingCalls.delete(key);
+        if (call.promptId) {
+          this.pendingPrompts.delete(call.promptId);
+          this.resolvedPrompts.set(call.promptId, now);
+        }
+        logger.warn("Pending tool call expired (no matching result event)", {
+          intentStepIndex: call.intentStepIndex,
+          toolCallIndex: call.toolCallIndex,
+          command: call.command,
+          filePath: call.filePath,
+          ageMs: now - call.startedAt
+        });
+        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);
+      }
+    }
+    for (const [key, buffered] of this.pendingCandidates.entries()) {
+      if (now - buffered.queuedAt > this.pendingCandidateBufferMs) {
+        this.pendingCandidates.delete(key);
+        logger.debug("Buffered candidate expired without ever matching a pending call", {
+          key,
+          candidateCommand: buffered.candidate.command,
+          ageMs: now - buffered.queuedAt
+        });
+      }
+    }
+  }
+};
+function containsAsWord(haystack, needle) {
+  const escaped = needle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(^|[\\s"'\`])${escaped}([\\s"'\`]|$)`).test(haystack);
+}
+
+// src/prompt-responder.ts
+var import_child_process2 = require("child_process");
+var import_util2 = require("util");
+var execAsync2 = (0, import_util2.promisify)(import_child_process2.exec);
+var ENTER_DELAY_MS = 100;
+var CODEVIBE_AGY_ESCAPE_INPUT = "__CODEVIBE_AGY_KEY_ESCAPE__";
+var PromptResponder = class {
+  constructor(options = {}) {
+    this.tmuxTargetOverride = options.tmuxTarget;
+    this.execFn = options.execFn ?? (async (cmd) => execAsync2(cmd));
+    this.paneObserver = options.paneObserver ?? null;
+    this.detector = options.detector ?? null;
+    if (this.detector && !this.paneObserver) {
+      throw new Error(
+        "PromptResponder misconfigured: detector wired without paneObserver. Approval-reply identity guard requires the observer to re-probe the pane before send. Either wire both, or wire neither."
+      );
+    }
+  }
+  /**
+   * Send free-form text to the agy session. The text is typed (via
+   * `send-keys -l`) then Enter is sent after a short delay so agy's
+   * input handler has time to process the buffer.
+   */
+  async sendFreeForm(text) {
+    const target = this.resolveTmuxTarget();
+    if (!target) {
+      return { ok: false, reason: "no-tmux-target" };
+    }
+    try {
+      if (text === CODEVIBE_AGY_ESCAPE_INPUT) {
+        await this.sendKey(target, "Escape");
+      } else {
+        await this.typeLiteral(target, text);
+        await delay(ENTER_DELAY_MS);
+        await this.sendKey(target, "Enter");
+      }
+      logger.info("Sent free-form input to agy", {
+        target,
+        textLength: text.length
+      });
+      return { ok: true };
+    } catch (error) {
+      logger.error("tmux send-keys failed for free-form input", { target, error });
+      return {
+        ok: false,
+        reason: "tmux-failed",
+        details: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Resolve a pending approval prompt with the mobile-user's chosen
+   * option number. Uses the submitMap from the PendingPromptState to
+   * translate option-number → terminal keystrokes (digit alone for agy's
+   * 4-numbered UI; future Y/N prompts would use 'y'/'n'/'Escape').
+   *
+   * Active-prompt-identity guard (DESIGN.md §3.4):
+   *   1. Detector check: is `promptId` still in pendingPrompts? If not
+   *      (expired or already-resolved), drop with `prompt-expired`.
+   *   2. Pane-observer check: probeApprovalUIActive() — does the pane
+   *      STILL show an approval UI whose header matches our pending
+   *      call's identity? If active-UI is gone OR header differs,
+   *      drop with `prompt-superseded`.
+   *   3. submitMap lookup: is `optionNumber` a valid key? If not (e.g.
+   *      mobile sent "5" for a 4-option prompt), drop with
+   *      `invalid-option`.
+   *   4. Send the keystrokes via tmux send-keys.
+   */
+  async sendApprovalReply(promptId, optionNumber) {
+    const target = this.resolveTmuxTarget();
+    if (!target) {
+      return { ok: false, reason: "no-tmux-target" };
+    }
+    if (this.detector) {
+      const state = this.detector.getPendingPrompt(promptId);
+      if (!state) {
+        logger.warn("Mobile reply for unknown / expired promptId", { promptId, optionNumber });
+        return {
+          ok: false,
+          reason: "prompt-expired",
+          details: `promptId ${promptId} is not in pendingPrompts`
+        };
+      }
+      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);
+          return {
+            ok: false,
+            reason: "prompt-superseded",
+            details: `pane shows '${probe.headerText}' but matched-against header was '${expectedHeader}'`
+          };
+        }
+      }
+      const keys = state.submitMap[optionNumber];
+      if (!keys || keys.length === 0) {
+        return {
+          ok: false,
+          reason: "invalid-option",
+          details: `option '${optionNumber}' not in submitMap (valid: ${Object.keys(state.submitMap).join(",")})`
+        };
+      }
+      try {
+        for (const key of keys) {
+          if (isNamedKey(key)) {
+            await this.sendKey(target, key);
+          } else {
+            await this.typeLiteral(target, key);
+          }
+        }
+        this.detector.resolvePrompt(promptId);
+        logger.info("Sent approval reply via tmux", {
+          promptId,
+          optionNumber,
+          keysSent: keys
+        });
+        return { ok: true };
+      } catch (error) {
+        return {
+          ok: false,
+          reason: "tmux-failed",
+          details: error instanceof Error ? error.message : String(error)
+        };
+      }
+    }
+    try {
+      await this.typeLiteral(target, optionNumber);
+      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, "\\`");
+    const safeTarget = escapeShellArg2(target);
+    const cmd = `tmux send-keys -t '${safeTarget}' -l "${escaped}"`;
+    await this.execFn(cmd);
+  }
+  async sendKey(target, key) {
+    const safeTarget = escapeShellArg2(target);
+    const cmd = `tmux send-keys -t '${safeTarget}' ${key}`;
+    await this.execFn(cmd);
+  }
+  resolveTmuxTarget() {
+    return this.tmuxTargetOverride ?? process.env.CODEVIBE_AGY_TMUX_TARGET ?? null;
+  }
+};
+function escapeShellArg2(value) {
+  return value.replace(/'/g, `'\\''`);
+}
+function isNamedKey(key) {
+  return /^[A-Z][A-Za-z0-9]+$/.test(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;
+var DEFAULT_MIN_FUZZY_ECHO_LENGTH = 16;
+var DEFAULT_MIN_FUZZY_ECHO_RATIO = 0.35;
+var MobilePromptDeduper = class {
+  constructor(options = {}) {
+    this.pendingBySession = /* @__PURE__ */ new Map();
+    this.expiryMs = options.expiryMs ?? DEFAULT_EXPIRY_MS;
+    this.minFuzzyEchoLength = options.minFuzzyEchoLength ?? DEFAULT_MIN_FUZZY_ECHO_LENGTH;
+    this.minFuzzyEchoRatio = options.minFuzzyEchoRatio ?? DEFAULT_MIN_FUZZY_ECHO_RATIO;
+    this.now = options.now ?? Date.now;
+  }
+  /** Called by the MCP server immediately BEFORE prompt-responder
+   *  performs the tmux send-keys. Records the normalized text + timestamp
+   *  for future echo-suppression. */
+  track(sessionId, prompt) {
+    this.sweep();
+    const normalized = this.normalize(prompt);
+    if (!normalized) return;
+    const entries = this.validEntries(sessionId);
+    entries.push({ normalized, timestamp: this.now() });
+    this.pendingBySession.set(sessionId, entries);
+  }
+  /** Symmetric helper for callers that want to retract a tracked entry
+   *  WITHOUT consuming it via dedupe (e.g. responder bailed before send). */
+  forget(sessionId, prompt) {
+    this.sweep();
+    const normalized = this.normalize(prompt);
+    if (!normalized) return;
+    let removed = false;
+    const entries = this.validEntries(sessionId).filter((entry) => {
+      if (!removed && entry.normalized === normalized) {
+        removed = true;
+        return false;
+      }
+      return true;
+    });
+    this.replaceEntries(sessionId, entries);
+  }
+  /**
+   * Called by event-mapper / MCP server immediately BEFORE forwarding a
+   * USER_PROMPT to AppSync. If the echo matches a recently-tracked mobile
+   * prompt, returns the match metadata + CONSUMES the tracked entry (so a
+   * second similar echo doesn't suppress an actual second mobile prompt).
+   * Returns null when no match → caller proceeds with the AppSync emit.
+   */
+  consumeIfDuplicate(sessionId, echo) {
+    this.sweep();
+    const normalizedEcho = this.normalize(echo);
+    if (!normalizedEcho) return null;
+    let match = null;
+    const entries = this.validEntries(sessionId).filter((entry) => {
+      if (!match) {
+        const matchType = this.matchType(entry.normalized, normalizedEcho);
+        if (matchType) {
+          match = {
+            matchType,
+            originalLength: entry.normalized.length,
+            echoLength: normalizedEcho.length
+          };
+          return false;
+        }
+      }
+      return true;
+    });
+    this.replaceEntries(sessionId, entries);
+    return match;
+  }
+  // ─── Internals ──────────────────────────────────────────────────────────
+  sweep() {
+    const cutoff = this.now() - this.expiryMs;
+    for (const [sessId, entries] of this.pendingBySession.entries()) {
+      const valid = entries.filter((entry) => entry.timestamp >= cutoff);
+      if (valid.length > 0) {
+        this.pendingBySession.set(sessId, valid);
+      } else {
+        this.pendingBySession.delete(sessId);
+      }
+    }
+  }
+  validEntries(sessionId) {
+    const cutoff = this.now() - this.expiryMs;
+    return (this.pendingBySession.get(sessionId) || []).filter((entry) => entry.timestamp >= cutoff);
+  }
+  replaceEntries(sessionId, entries) {
+    if (entries.length > 0) {
+      this.pendingBySession.set(sessionId, entries);
+    } else {
+      this.pendingBySession.delete(sessionId);
+    }
+  }
+  matchType(original, echo) {
+    if (original === echo) {
+      return "exact";
+    }
+    const longEnough = echo.length >= this.minFuzzyEchoLength;
+    const enoughOfOriginal = echo.length / original.length >= this.minFuzzyEchoRatio;
+    if (longEnough && enoughOfOriginal && original.endsWith(echo)) {
+      return "suffix";
+    }
+    return null;
+  }
+  normalize(text) {
+    return text.replace(/\s+/g, " ").trim();
+  }
+};
+
+// src/daemon-telemetry.ts
+var crypto2 = __toESM(require("crypto"));
+var fs4 = __toESM(require("fs"));
+var https = __toESM(require("https"));
+var os4 = __toESM(require("os"));
+var path4 = __toESM(require("path"));
+var MEASUREMENT_ID = "G-GS74YEQTB8";
+var API_SECRET = "lAfOF6OxRzSQ-NsLBRjhAg";
+var GA4_HOSTNAME = "www.google-analytics.com";
+var GA4_PATH = `/mp/collect?measurement_id=${MEASUREMENT_ID}&api_secret=${API_SECRET}`;
+var BEACON_TOTAL_TIMEOUT_MS = 800;
+function readPluginVersion() {
+  try {
+    const pkgPath = path4.resolve(__dirname, "..", "package.json");
+    const raw = fs4.readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    if (typeof pkg.version === "string" && pkg.version.length > 0 && pkg.version.length < 30) {
+      return pkg.version;
+    }
+  } catch {
+  }
+  return "unknown";
+}
+var PLUGIN_VERSION = readPluginVersion();
+function getClientId() {
+  const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+  return crypto2.createHash("sha256").update(`${os4.hostname()}-${uid}`).digest("hex").substring(0, 36);
+}
+function sanitizeErrorMessage(msg) {
+  if (!msg) return "";
+  const homedir4 = os4.homedir();
+  let out = msg.replace(/[\n\r\t]/g, " ");
+  if (homedir4 && homedir4.length > 0) {
+    const safeHome = homedir4.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    out = out.replace(new RegExp(safeHome, "g"), "~");
+  }
+  out = out.replace(/\/Users\/[^/\s"'`]+/g, "/Users/<user>").replace(/\/home\/[^/\s"'`]+/g, "/home/<user>").replace(/[A-Za-z]:\\Users\\[^\\\s"'`]+/gi, "C:\\Users\\<user>").replace(/[^\x20-\x7E]/g, "");
+  return out.trim().substring(0, 100);
+}
+function fireDaemonBeacon(name, params) {
+  return new Promise((resolve3) => {
+    let req;
+    let settled = false;
+    const settle = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(overall);
+      resolve3();
+    };
+    const overall = setTimeout(() => {
+      try {
+        req?.destroy();
+      } catch {
+      }
+      settle();
+    }, BEACON_TOTAL_TIMEOUT_MS);
+    if (typeof overall.unref === "function") {
+      overall.unref();
+    }
+    try {
+      const sanitizedParams = {};
+      for (const [key, value] of Object.entries(params)) {
+        if (typeof value === "string") {
+          sanitizedParams[key] = sanitizeErrorMessage(value);
+        } else {
+          sanitizedParams[key] = value;
+        }
+      }
+      const payload = JSON.stringify({
+        client_id: getClientId(),
+        events: [
+          {
+            name,
+            params: {
+              agent: "antigravity",
+              plugin_version: PLUGIN_VERSION,
+              platform: process.platform,
+              source: process.env.CODEVIBE_TELEMETRY_SOURCE || "production",
+              ...sanitizedParams
+            }
+          }
+        ]
+      });
+      req = https.request(
+        {
+          hostname: GA4_HOSTNAME,
+          path: GA4_PATH,
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          timeout: BEACON_TOTAL_TIMEOUT_MS
+        },
+        (res) => {
+          res.resume();
+          res.on("end", settle);
+          res.on("close", settle);
+          res.on("error", settle);
+        }
+      );
+      req.on("error", settle);
+      req.on("timeout", () => {
+        try {
+          req?.destroy();
+        } catch {
+        }
+        settle();
+      });
+      req.on("close", settle);
+      req.write(payload);
+      req.end();
+    } catch {
+      settle();
+    }
+  });
+}
+
+// src/event-mapper.ts
+var import_uuid2 = require("uuid");
+var import_codevibe_core3 = require("@quantiya/codevibe-core");
+var CONTENT_MAX = 150 * 1024;
+var TOOL_OUTPUT_MAX = 50 * 1024;
+var TOOL_DIFF_MAX = 100 * 1024;
+function mapTranscriptEvent(emit, sessionId) {
+  const { event } = emit;
+  const base = {
+    sessionId,
+    source: import_codevibe_core3.EventSource.DESKTOP
+  };
+  const nextTimestamp = () => bumpTimestampForConv(event.created_at, emit.conversationId);
+  const baseMetadata = {
+    step_index: event.step_index,
+    agy_source: event.source,
+    agy_status: event.status,
+    agy_created_at: event.created_at,
+    agy_type: event.type,
+    agy_conversation_id: emit.conversationId
+  };
+  if (event.source === "SYSTEM") {
+    if (event.type === "CONVERSATION_HISTORY" || event.type === "SYSTEM_MESSAGE") {
+      logger.debug("Dropping internal transcript event", {
+        type: event.type,
+        stepIndex: event.step_index
+      });
+      return { events: [], pendingCallRegistrations: [] };
+    }
+    if (event.type !== "ERROR_MESSAGE") {
+      logger.warn("Dropping unknown SYSTEM-source transcript event (safety)", {
+        type: event.type,
+        stepIndex: event.step_index
+      });
+      return { events: [], pendingCallRegistrations: [] };
+    }
+  }
+  if (event.type === "CONVERSATION_HISTORY" || event.type === "SYSTEM_MESSAGE") {
+    logger.debug("Dropping internal transcript event (non-SYSTEM source)", {
+      type: event.type,
+      source: event.source,
+      stepIndex: event.step_index
+    });
+    return { events: [], pendingCallRegistrations: [] };
+  }
+  if (event.type === "USER_INPUT") {
+    const cleaned = stripUserRequestWrapper(event.content || "");
+    return {
+      events: [
+        {
+          ...base,
+          timestamp: nextTimestamp(),
+          type: import_codevibe_core3.EventType.USER_PROMPT,
+          content: truncate(cleaned, CONTENT_MAX),
+          metadata: { ...baseMetadata }
+        }
+      ],
+      pendingCallRegistrations: []
+    };
+  }
+  if (event.type === "PLANNER_RESPONSE") {
+    const events = [];
+    const pendingCallRegistrations = [];
+    if (typeof event.thinking === "string" && event.thinking.trim().length > 0) {
+      events.push({
+        ...base,
+        timestamp: nextTimestamp(),
+        type: import_codevibe_core3.EventType.REASONING,
+        content: truncate(event.thinking, CONTENT_MAX),
+        metadata: { ...baseMetadata }
+      });
+    }
+    if (typeof event.content === "string" && event.content.trim().length > 0) {
+      events.push({
+        ...base,
+        timestamp: nextTimestamp(),
+        type: import_codevibe_core3.EventType.ASSISTANT_RESPONSE,
+        content: truncate(event.content, CONTENT_MAX),
+        metadata: { ...baseMetadata }
+      });
+    }
+    const toolCalls = event.tool_calls;
+    if (Array.isArray(toolCalls)) {
+      for (let i = 0; i < toolCalls.length; i++) {
+        const tc = toolCalls[i];
+        if (!tc || typeof tc !== "object") continue;
+        const name = tc.name;
+        if (typeof name !== "string") continue;
+        const args = tc.args;
+        pendingCallRegistrations.push({
+          intentStepIndex: event.step_index,
+          toolCallIndex: i,
+          intentByteOffset: emit.byteOffset,
+          toolType: hookToolNameToTranscriptType(name),
+          conversationId: emit.conversationId,
+          command: extractCommandFromArgs(name, args),
+          filePath: extractFilePathFromArgs(name, args),
+          cwd: extractCwdFromArgs(args),
+          rawToolName: name,
+          startedAt: Date.now(),
+          intentCreatedAt: event.created_at
+        });
+      }
+    }
+    return { events, pendingCallRegistrations };
+  }
+  if (event.type === "ERROR_MESSAGE") {
+    const content = stripTimestampPrefix(event.content || "Agy error");
+    return {
+      events: [
+        {
+          ...base,
+          timestamp: nextTimestamp(),
+          type: import_codevibe_core3.EventType.NOTIFICATION,
+          content: truncate(content, CONTENT_MAX),
+          metadata: {
+            ...baseMetadata,
+            severity: "error"
+          }
+        }
+      ],
+      pendingCallRegistrations: []
+    };
+  }
+  const toolName = transcriptTypeToFriendlyToolName(event.type);
+  const isErrorStatus = event.status === "ERROR";
+  const rawContent = stripTimestampPrefix(event.content || "");
+  const truncatedContent = truncate(rawContent, TOOL_OUTPUT_MAX);
+  return {
+    events: [
+      {
+        ...base,
+        timestamp: nextTimestamp(),
+        type: import_codevibe_core3.EventType.TOOL_USE,
+        content: formatToolResultContent(event.type, toolName, truncatedContent, isErrorStatus),
+        metadata: {
+          ...baseMetadata,
+          tool_name: toolName,
+          tool_output: truncatedContent,
+          success: !isErrorStatus
+        }
+      }
+    ],
+    pendingCallRegistrations: []
+  };
+}
+var lastEmittedSecondPerConv = /* @__PURE__ */ new Map();
+function bumpTimestampForConv(createdAt, conversationId) {
+  const parsed = new Date(createdAt);
+  const agySec = Math.floor(parsed.getTime() / 1e3);
+  const lastSec = lastEmittedSecondPerConv.get(conversationId) ?? 0;
+  const effectiveSec = Math.max(agySec, lastSec + 1);
+  lastEmittedSecondPerConv.set(conversationId, effectiveSec);
+  return new Date(effectiveSec * 1e3).toISOString();
+}
+function stripUserRequestWrapper(content) {
+  const match = content.match(/<USER_REQUEST>([\s\S]*?)<\/USER_REQUEST>/);
+  if (match && match[1] !== void 0) {
+    return match[1].trim();
+  }
+  return content.trim();
+}
+function stripTimestampPrefix(content) {
+  return content.replace(
+    /^Created At:[^\n]*\nCompleted At:[^\n]*\n+(?:\s*\n)?/,
+    ""
+  ).trim();
+}
+function transcriptTypeToFriendlyToolName(type) {
+  switch (type) {
+    case "RUN_COMMAND":
+      return "Bash";
+    case "LIST_DIRECTORY":
+      return "LS";
+    case "GREP_SEARCH":
+      return "Grep";
+    case "VIEW_FILE":
+      return "Read";
+    case "CODE_ACTION":
+      return "Edit";
+    case "SEARCH_WEB":
+      return "WebSearch";
+    case "GENERIC":
+      return "Other";
+    default:
+      return "Other";
+  }
+}
+function hookToolNameToTranscriptType(hookName) {
+  const upper = hookName.toUpperCase();
+  switch (upper) {
+    case "LIST_DIR":
+      return "LIST_DIRECTORY";
+    case "REPLACE_FILE_CONTENT":
+    case "MULTI_REPLACE_FILE_CONTENT":
+    case "WRITE_TO_FILE":
+      return "CODE_ACTION";
+    case "GENERATE_IMAGE":
+    case "READ_URL_CONTENT":
+    case "INVOKE_SUBAGENT":
+    case "DEFINE_SUBAGENT":
+    case "MANAGE_SUBAGENTS":
+    case "SEND_MESSAGE":
+    case "LIST_PERMISSIONS":
+    case "MANAGE_TASK":
+    case "SCHEDULE":
+    case "ASK_PERMISSION":
+    case "ASK_QUESTION":
+      return "GENERIC";
+    default:
+      return upper;
+  }
+}
+function extractCommandFromArgs(toolName, args) {
+  if (!args || typeof args !== "object") return void 0;
+  const a = args;
+  for (const key of ["CommandLine", "Command", "command", "cmd", "exec"]) {
+    const v = a[key];
+    if (typeof v === "string" && v.trim().length > 0) {
+      return stripWrappingQuotes(v.trim());
+    }
+  }
+  return void 0;
+}
+function extractFilePathFromArgs(toolName, args) {
+  if (!args || typeof args !== "object") return void 0;
+  const a = args;
+  for (const key of [
+    "TargetFile",
+    "FilePath",
+    "file_path",
+    "filePath",
+    "path",
+    "DirectoryPath",
+    "directory",
+    "Directory"
+  ]) {
+    const v = a[key];
+    if (typeof v === "string" && v.trim().length > 0) {
+      return stripWrappingQuotes(v.trim());
+    }
+  }
+  return void 0;
+}
+function extractCwdFromArgs(args) {
+  if (!args || typeof args !== "object") return void 0;
+  const a = args;
+  for (const key of ["Cwd", "cwd", "workingDirectory", "WorkingDirectory"]) {
+    const v = a[key];
+    if (typeof v === "string" && v.trim().length > 0) {
+      return stripWrappingQuotes(v.trim());
+    }
+  }
+  return void 0;
+}
+function stripWrappingQuotes(s) {
+  if (s.length >= 2 && s.startsWith('"') && s.endsWith('"')) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function formatToolResultContent(agyType, toolName, output, isError) {
+  const prefix = isError ? "\u26A0 " : "";
+  const firstLine = output.split("\n", 1)[0]?.trim();
+  switch (agyType) {
+    case "RUN_COMMAND":
+      return `${prefix}Bash: ${firstLine || "command executed"}`;
+    case "LIST_DIRECTORY":
+      return `${prefix}LS: ${firstLine || "directory listed"}`;
+    case "GREP_SEARCH":
+      return `${prefix}Grep: ${firstLine || "search executed"}`;
+    case "VIEW_FILE":
+      return `${prefix}Read: ${firstLine || "file read"}`;
+    case "CODE_ACTION":
+      return `${prefix}Edit: ${firstLine || "file edited"}`;
+    case "SEARCH_WEB":
+      return `${prefix}WebSearch: ${firstLine || "search executed"}`;
+    case "GENERIC":
+      return `${prefix}${toolName}: ${firstLine || "tool executed"}`;
+    default:
+      return `${prefix}${toolName} (${agyType}): ${firstLine || "unknown event"}`;
+  }
+}
+function truncate(s, maxBytes) {
+  if (!s) return "";
+  if (Buffer.byteLength(s, "utf-8") <= maxBytes) return s;
+  let lo = 0;
+  let hi = s.length;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >>> 1;
+    if (Buffer.byteLength(s.slice(0, mid), "utf-8") <= maxBytes - 32) {
+      lo = mid;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return s.slice(0, lo) + ` [...truncated ${s.length - lo} chars]`;
+}
+
+// src/server.ts
+var McpServer = class {
+  constructor(options) {
+    /** v9 launch-session: ONE backend session per wrapper lifetime.
+     *  Created at start() before any tailer event can fire. All agy
+     *  conv UUIDs observed during this wrapper's lifetime emit events
+     *  under this single sessionId. /resume does NOT create a new
+     *  session — same row. */
+    this.session = null;
+    /** Single subscription for the launch session (v9 — was per-conv Map). */
+    this.subscription = null;
+    /** Wrapper-level disable flag (free-tier limit / collision). v9
+     *  collapses v8's per-conv disabledConversations Set because there's
+     *  only ONE backend session per wrapper. */
+    this.sessionDisabled = false;
+    /** Registry of agy conv UUIDs the wrapper has observed this lifecycle.
+     *  Populated from handleConversationDiscovered + handleTranscriptEmit
+     *  (after isMainConversation passes). Used by:
+     *   (a) handlePromptCandidate — approvalDetector keys candidates by
+     *       agy conv UUID, not backend session ID;
+     *   (b) getSessionByConversation — defensive membership check before
+     *       returning the launch session.
+     *  Stale UUIDs from /resume cycles remain until lifecycle stop;
+     *  causes harmless extra candidate-buffer entries in approvalDetector
+     *  bounded by TTL. (Codex Stage 2 R1 v12 HIGH.) */
+    this.observedMainConversationIds = /* @__PURE__ */ new Set();
+    this.started = false;
+    /** Monotonically-increasing counter incremented on every start(). Captured
+     *  by async callbacks at entry; mismatch after an await means stop()→start()
+     *  ran during the await, so the captured work is from a previous lifecycle
+     *  and must bail before touching this lifecycle's state. NOT reset on
+     *  stop() — preserving the monotonic invariant lets stale callbacks
+     *  reliably detect they're stale. (Codex Stage 2 R1 v5 MED 2026-05-20.) */
+    this.lifecycleGen = 0;
+    /** In-flight stop() promise so a re-entrant call (e.g. double SIGINT)
+     *  awaits the same shutdown instead of bypassing it and calling
+     *  process.exit before the original stop's cleanup completes.
+     *  (Stage 1 MED finding 2026-05-20.) */
+    this.stopPromise = null;
+    /** Listener references kept so doStop() can detach them. Without this,
+     *  a server restart (test mode or future hot-reload) accumulates
+     *  listeners on the shared module instances. (Stage 2 HIGH finding
+     *  2026-05-20.) */
+    this.listenerHandles = [];
+    this.signalsRegistered = false;
+    this.boundSigintHandler = null;
+    this.boundSigtermHandler = null;
+    if (!options.bearerToken || options.bearerToken.length < 16) {
+      throw new Error("McpServer requires a non-trivial bearerToken");
+    }
+    this.bearerToken = options.bearerToken;
+    this.preferredPort = options.preferredPort ?? 0;
+    this.runtimeDir = options.runtimeDir ?? null;
+    this.tmuxTarget = options.tmuxTarget ?? process.env.CODEVIBE_AGY_TMUX_TARGET ?? null;
+    this.wrapperPid = options.wrapperPid ?? null;
+    this.cliLogPath = options.cliLogPath ?? null;
+    this.appSyncClient = options.appSyncClient ?? new import_codevibe_core4.AppSyncClient();
+    this.approvalDetector = options.approvalDetector ?? new ApprovalDetector(options.detectorOptions);
+    this.paneObserver = options.paneObserver ?? new TmuxPaneObserver();
+    this.transcriptTailer = options.transcriptTailer ?? new TranscriptTailer();
+    this.mobileDeduper = options.mobileDeduper ?? new MobilePromptDeduper();
+    this.promptResponder = options.promptResponder ?? new PromptResponder({
+      tmuxTarget: this.tmuxTarget ?? void 0,
+      paneObserver: this.paneObserver,
+      detector: this.approvalDetector
+    });
+    const portFilePath = this.runtimeDir ? path5.join(this.runtimeDir, "conn.json") : void 0;
+    this.httpApi = options.httpApi ?? new HttpApi({
+      bearerToken: this.bearerToken,
+      preferredPort: this.preferredPort,
+      portFilePath
+    });
+    this.httpApi.setHandlers({
+      pushEvent: (p) => this.handleHttpPushEvent(p),
+      getActiveSession: () => this.getAnySession()
+    });
+  }
+  // ─── Lifecycle ──────────────────────────────────────────────────────────
+  async start() {
+    if (this.started) throw new Error("McpServer.start() called twice");
+    this.stopPromise = null;
+    await fireDaemonBeacon("daemon_init_start", {
+      step: "init",
+      outcome: "ok",
+      has_tmux_target: this.tmuxTarget ? "yes" : "no"
+    });
+    const authed = await this.appSyncClient.authenticateWithStoredTokens();
+    if (!authed) {
+      await fireDaemonBeacon("daemon_init_step", {
+        step: "auth",
+        outcome: "fail",
+        error_message: "no stored OAuth tokens"
+      });
+      throw new Error(
+        "codevibe-antigravity-plugin: no OAuth tokens \u2014 run `codevibe-agy login` first"
+      );
+    }
+    this.started = true;
+    this.lifecycleGen++;
+    this.approvalDetector.start();
+    this.addListener(this.approvalDetector, "pending-prompt", (state) => {
+      void this.handlePendingPrompt(state).catch((err) => {
+        logger.error("handlePendingPrompt failed", { error: String(err) });
+      });
+    });
+    await this.createLaunchSession();
+    this.addListener(this.transcriptTailer, "event", (emit) => {
+      void this.handleTranscriptEmit(emit).catch((err) => {
+        logger.error("handleTranscriptEmit failed", { error: String(err) });
+      });
+    });
+    this.addListener(this.transcriptTailer, "conversation-discovered", (conversationId) => {
+      void this.handleConversationDiscovered(conversationId).catch((err) => {
+        logger.error("handleConversationDiscovered failed", { error: String(err) });
+      });
+    });
+    await this.transcriptTailer.start();
+    if (this.tmuxTarget) {
+      this.addListener(this.paneObserver, "prompt-candidate", (cand) => {
+        void this.handlePromptCandidate(cand).catch((err) => {
+          logger.error("handlePromptCandidate failed", { error: String(err) });
+        });
+      });
+      this.addListener(this.paneObserver, "prompt-cleared", () => {
+        this.approvalDetector.onPanePromptCleared();
+      });
+      await this.paneObserver.start(this.tmuxTarget);
+    } else {
+      logger.warn("No tmux target \u2014 pane observer disabled (mobile-only mode)");
+    }
+    const httpPort = await this.httpApi.start();
+    this.registerSignalHandlers();
+    await fireDaemonBeacon("daemon_init_step", {
+      step: "ready",
+      outcome: "ok",
+      http_port: httpPort
+    });
+    return { httpPort };
+  }
+  async stop() {
+    if (this.stopPromise) return this.stopPromise;
+    if (!this.started) return;
+    this.stopPromise = this.doStop();
+    try {
+      await this.stopPromise;
+    } finally {
+    }
+  }
+  addListener(emitter, event, handler) {
+    emitter.on(event, handler);
+    this.listenerHandles.push({ emitter, event, handler });
+  }
+  async doStop() {
+    this.started = false;
+    try {
+      await this.transcriptTailer.stop();
+    } catch (err) {
+      logger.warn("transcriptTailer.stop failed", { error: String(err) });
+    }
+    try {
+      await this.paneObserver.stop();
+    } catch (err) {
+      logger.warn("paneObserver.stop failed", { error: String(err) });
+    }
+    if (this.subscription) {
+      try {
+        this.subscription();
+      } catch {
+      }
+      this.subscription = null;
+    }
+    for (const { emitter, event, handler } of this.listenerHandles) {
+      try {
+        emitter.off(event, handler);
+      } catch {
+      }
+    }
+    this.listenerHandles = [];
+    this.unregisterSignalHandlers();
+    if (this.session) {
+      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)
+        });
+      }
+      try {
+        this.appSyncClient.stopHeartbeat(this.session.sessionId);
+      } catch {
+      }
+    }
+    try {
+      await this.approvalDetector.stop();
+    } catch (err) {
+      logger.warn("approvalDetector.stop failed", { error: String(err) });
+    }
+    try {
+      await this.httpApi.stop();
+    } catch (err) {
+      logger.warn("httpApi.stop failed", { error: String(err) });
+    }
+    try {
+      this.appSyncClient.cleanupSubscriptions();
+    } catch (err) {
+      logger.warn("appSyncClient.cleanupSubscriptions failed", { error: String(err) });
+    }
+    this.session = null;
+    this.sessionDisabled = false;
+    this.observedMainConversationIds.clear();
+    await fireDaemonBeacon("daemon_init_step", {
+      step: "shutdown",
+      outcome: "ok"
+    });
+  }
+  async handleConversationDiscovered(conversationId) {
+    if (!this.started) return;
+    if (this.sessionDisabled) return;
+    if (!this.session) return;
+    if (!this.isMainConversation(conversationId)) {
+      logger.debug("Ignoring discovery for non-main conversation (subagent)", { conversationId });
+      return;
+    }
+    this.observedMainConversationIds.add(conversationId);
+    logger.info("agy conversation observed under launch session", {
+      conversationId,
+      launchSessionId: this.session.sessionId
+    });
+  }
+  /**
+   * v9 launch-session: create the wrapper-lifetime backend session at
+   * start(). All agy conv UUIDs observed during this lifetime emit
+   * events under this single sessionId. /resume does NOT create a new
+   * row. (Codex Stage 2 R1 v5/v6/v7 switch machinery is now dead code,
+   * removed.)
+   */
+  async createLaunchSession() {
+    const gen = this.lifecycleGen;
+    const sessionId = generateLaunchSessionId(this.wrapperPid ?? process.pid);
+    const userId = this.appSyncClient.getCurrentUserId();
+    const projectPath = process.cwd();
+    let sessionKey = null;
+    try {
+      const result = await (0, import_codevibe_core4.resumeOrCreateSession)(
+        {
+          sessionId,
+          userId,
+          agentType: import_codevibe_core4.AgentType.ANTIGRAVITY,
+          projectPath,
+          metadata: { wrapperPid: this.wrapperPid ?? void 0, launch: true }
+        },
+        this.appSyncClient,
+        logger
+      );
+      sessionKey = result.sessionKey ?? null;
+    } catch (err) {
+      const msg = String(err);
+      if (msg.includes("session-limit-exceeded")) {
+        logger.warn("Free-tier session limit reached \u2014 mobile sync disabled for this wrapper", { sessionId });
+        if (gen !== this.lifecycleGen || !this.started) return;
+        this.sessionDisabled = true;
+        return;
+      }
+      logger.error("createLaunchSession failed (non-fatal)", { sessionId, error: msg });
+      return;
+    }
+    if (gen !== this.lifecycleGen || !this.started) return;
+    this.session = {
+      sessionId,
+      conversationId: "",
+      // No agy conv UUID yet at launch
+      userId,
+      projectPath,
+      cwd: projectPath,
+      createdAt: /* @__PURE__ */ new Date(),
+      subscriptionActive: false,
+      metadata: { wrapperPid: this.wrapperPid ?? void 0, launch: true },
+      sessionKey
+    };
+    try {
+      const stop = this.appSyncClient.subscribeToEvents(
+        sessionId,
+        (evt) => {
+          void this.handleMobileEvent(evt).catch((err) => {
+            logger.error("handleMobileEvent failed", { error: String(err) });
+          });
+        },
+        (err) => logger.warn("AppSync subscription error", { error: String(err) })
+      );
+      if (gen !== this.lifecycleGen || !this.started) {
+        try {
+          stop();
+        } catch {
+        }
+        return;
+      }
+      this.subscription = stop;
+      this.session.subscriptionActive = true;
+    } catch (err) {
+      logger.error("subscribeToEvents failed (non-fatal)", { sessionId, error: String(err) });
+    }
+    try {
+      this.appSyncClient.startHeartbeat(sessionId);
+    } catch (err) {
+      logger.warn("startHeartbeat failed", { sessionId, error: String(err) });
+    }
+    void fireDaemonBeacon("daemon_init_step", {
+      step: "session_ready",
+      outcome: "ok",
+      path: "launch_session"
+    });
+    logger.info("Launch session created", { sessionId, userId });
+  }
+  isMainConversation(conversationId) {
+    if (process.env.JEST_WORKER_ID && !this.cliLogPath) {
+      return true;
+    }
+    const cliLogPath = this.cliLogPath ?? path5.join(os5.homedir(), ".gemini", "antigravity-cli", "cli.log");
+    const activeId = getActiveConversationFromCliLog(cliLogPath);
+    if (!activeId) {
+      return true;
+    }
+    return activeId === conversationId;
+  }
+  // ─── Transcript flow ────────────────────────────────────────────────────
+  async handleTranscriptEmit(emit) {
+    if (!this.started) return;
+    const { conversationId, byteOffset, event } = emit;
+    if (this.sessionDisabled) {
+      return;
+    }
+    if (!this.session) {
+      return;
+    }
+    if (!this.isMainConversation(conversationId)) {
+      logger.debug("Ignoring transcript emit for non-main conversation (subagent)", { conversationId });
+      return;
+    }
+    this.observedMainConversationIds.add(conversationId);
+    const session = this.session;
+    const mapped = mapTranscriptEvent(emit, session.sessionId);
+    for (const reg of mapped.pendingCallRegistrations) {
+      this.approvalDetector.registerPendingCall(reg);
+    }
+    for (const input of mapped.events) {
+      if (input.type === import_codevibe_core4.EventType.TOOL_USE && typeof input.metadata === "object" && input.metadata) {
+        const meta = input.metadata;
+        const resultStep = typeof meta.step_index === "number" ? meta.step_index : void 0;
+        const agyType = typeof meta.agy_type === "string" ? meta.agy_type : void 0;
+        if (resultStep !== void 0 && agyType) {
+          this.approvalDetector.clearOnResultEvent({
+            conversationId,
+            resultStepIndex: resultStep,
+            toolType: agyType,
+            resultByteOffset: byteOffset
+          });
+        }
+      }
+      if (input.type === import_codevibe_core4.EventType.USER_PROMPT && input.source === import_codevibe_core4.EventSource.DESKTOP) {
+        const dedupe = this.mobileDeduper.consumeIfDuplicate(session.sessionId, input.content);
+        if (dedupe) {
+          logger.info("Suppressed desktop echo of mobile prompt", {
+            sessionId: session.sessionId,
+            matchType: dedupe.matchType
+          });
+          continue;
+        }
+      }
+      try {
+        await this.appSyncClient.createEvent(this.encryptOutbound(session, input));
+      } catch (err) {
+        logger.error("createEvent failed", {
+          sessionId: session.sessionId,
+          type: input.type,
+          error: String(err)
+        });
+      }
+    }
+  }
+  /**
+   * If the session has an E2E sessionKey, encrypt the event's content +
+   * metadata and stamp isEncrypted=true. Returns a new CreateEventInput;
+   * never mutates the input. When no key is set, returns input unchanged.
+   * (Codex Stage 2 HIGH finding 2026-05-20.)
+   */
+  encryptOutbound(session, input) {
+    if (!session.sessionKey) return input;
+    try {
+      const encryptedContent = import_codevibe_core4.cryptoService.encryptContent(input.content, session.sessionKey);
+      let encryptedMetadata = input.metadata;
+      if (input.metadata) {
+        const encryptedMetaStr = import_codevibe_core4.cryptoService.encryptMetadata(
+          input.metadata,
+          session.sessionKey
+        );
+        encryptedMetadata = { encrypted: encryptedMetaStr };
+      }
+      return {
+        ...input,
+        content: encryptedContent,
+        metadata: encryptedMetadata,
+        isEncrypted: true
+      };
+    } catch (err) {
+      logger.error("Outbound encryption failed \u2014 DROPPING event to avoid plaintext leak", {
+        sessionId: session.sessionId,
+        type: input.type,
+        error: String(err)
+      });
+      throw err;
+    }
+  }
+  /**
+   * If the inbound mobile event is marked isEncrypted, decrypt content +
+   * metadata in place. Returns a new shallow-copied Event; never mutates
+   * the input. When the session has no key OR the event isn't encrypted,
+   * returns input unchanged. (Codex Stage 2 HIGH finding 2026-05-20.)
+   */
+  decryptInbound(session, evt) {
+    const isEnc = evt.isEncrypted;
+    if (!isEnc) return evt;
+    if (!session.sessionKey) {
+      logger.warn("Encrypted mobile event arrived but no sessionKey \u2014 dropping", {
+        sessionId: session.sessionId,
+        eventId: evt.eventId
+      });
+      throw new Error("encrypted-event-no-session-key");
+    }
+    const result = { ...evt };
+    try {
+      result.content = import_codevibe_core4.cryptoService.decryptContent(evt.content, session.sessionKey);
+      const rawMeta = parseMaybeJson(evt.metadata);
+      if (rawMeta && typeof rawMeta === "object" && typeof rawMeta.encrypted === "string") {
+        const decryptedMeta = import_codevibe_core4.cryptoService.decryptMetadata(
+          rawMeta.encrypted,
+          session.sessionKey
+        );
+        result.metadata = decryptedMeta;
+      } else if (rawMeta && typeof rawMeta === "object") {
+        result.metadata = rawMeta;
+      }
+    } catch (err) {
+      logger.error("Decryption failed \u2014 dropping event", {
+        sessionId: session.sessionId,
+        eventId: evt.eventId,
+        error: String(err)
+      });
+      throw err;
+    }
+    return result;
+  }
+  // ─── Tmux pane flow ─────────────────────────────────────────────────────
+  async handlePromptCandidate(cand) {
+    if (!this.started) return;
+    if (this.sessionDisabled) return;
+    if (!this.session) return;
+    const parsed = parseApprovalSnapshot(cand.snapshot);
+    if (!parsed) return;
+    const activeConvId = this.pickActiveConversationForPrompt();
+    if (!activeConvId) {
+      logger.warn("Prompt candidate fired but no active conversation known", {
+        observedConvCount: this.observedMainConversationIds.size
+      });
+      return;
+    }
+    this.approvalDetector.emitPaneOnlyPrompt(parsed, activeConvId);
+  }
+  /**
+   * Pick the agy conversation UUID that owns the current approval UI.
+   * Priority:
+   *   1. cli.log says it's a specific conv → return that one if observed.
+   *   2. Otherwise, return the most recently observed main conv UUID.
+   *   3. Otherwise null (no active conv).
+   */
+  pickActiveConversationForPrompt() {
+    if (this.observedMainConversationIds.size === 0) return null;
+    const cliLogPath = this.cliLogPath ?? path5.join(os5.homedir(), ".gemini", "antigravity-cli", "cli.log");
+    const cliActive = getActiveConversationFromCliLog(cliLogPath);
+    if (cliActive && this.observedMainConversationIds.has(cliActive)) {
+      return cliActive;
+    }
+    let last = null;
+    for (const id of this.observedMainConversationIds) last = id;
+    return last;
+  }
+  async handlePendingPrompt(state) {
+    if (!this.started) return;
+    const session = this.getSessionByConversation(state.conversationId);
+    if (!session) {
+      logger.warn("pending-prompt fired but no session known", {
+        promptId: state.promptId,
+        conversationId: state.conversationId
+      });
+      return;
+    }
+    const optionsArr = state.paneOptions ? state.paneOptions.map((o) => ({ number: o.number, text: o.text })) : Object.keys(state.submitMap).map((n) => ({ number: n }));
+    const optionsForMobile = state.pendingCall ? {
+      promptId: state.promptId,
+      tool_name: state.pendingCall.toolType,
+      command: state.pendingCall.command,
+      file_path: state.pendingCall.filePath,
+      options: optionsArr
+    } : { promptId: state.promptId };
+    const content = state.paneDisplayHeader || state.matchedPaneHeader || state.pendingCall?.command || state.pendingCall?.filePath || "approval requested";
+    const input = {
+      sessionId: session.sessionId,
+      type: import_codevibe_core4.EventType.INTERACTIVE_PROMPT,
+      source: import_codevibe_core4.EventSource.DESKTOP,
+      content,
+      metadata: optionsForMobile,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      await this.appSyncClient.createEvent(this.encryptOutbound(session, input));
+    } catch (err) {
+      logger.error("createEvent INTERACTIVE_PROMPT failed", {
+        promptId: state.promptId,
+        error: String(err)
+      });
+      this.approvalDetector.rollbackPrompt(state.promptId);
+    }
+  }
+  // ─── Mobile → desktop flow ──────────────────────────────────────────────
+  async handleMobileEvent(evt) {
+    if (!this.started) return;
+    if (this.sessionDisabled) return;
+    if (!this.session) return;
+    const session = this.session;
+    if (evt.source !== import_codevibe_core4.EventSource.MOBILE) return;
+    if (evt.sessionId !== session.sessionId) {
+      logger.warn("Dropping mobile event with mismatched sessionId", {
+        expected: session.sessionId,
+        got: evt.sessionId
+      });
+      return;
+    }
+    let decrypted;
+    try {
+      decrypted = this.decryptInbound(session, evt);
+    } catch {
+      return;
+    }
+    evt = decrypted;
+    await this.markDelivered(evt);
+    if (evt.type === import_codevibe_core4.EventType.USER_PROMPT) {
+      this.mobileDeduper.track(session.sessionId, evt.content);
+      const result = await this.promptResponder.sendFreeForm(evt.content);
+      if (!result.ok) {
+        this.mobileDeduper.forget(session.sessionId, evt.content);
+        logger.warn("sendFreeForm failed", { reason: result.reason, details: result.details });
+        return;
+      }
+      await this.markExecuted(evt);
+      return;
+    }
+    if (evt.type === import_codevibe_core4.EventType.PROMPT_RESPONSE) {
+      const rawMeta = parseMaybeJson(evt.metadata);
+      const meta = rawMeta && typeof rawMeta === "object" ? rawMeta : {};
+      const evtAny = evt;
+      const promptId = typeof meta.promptId === "string" && meta.promptId || typeof meta.prompt_id === "string" && meta.prompt_id || typeof evtAny.promptId === "string" && evtAny.promptId || typeof evtAny.prompt_id === "string" && evtAny.prompt_id || null;
+      if (!promptId) {
+        logger.warn("PROMPT_RESPONSE missing promptId metadata; dropping", {
+          sessionId: session.sessionId
+        });
+        return;
+      }
+      const optionNumber = (evt.content || "").trim();
+      this.mobileDeduper.track(session.sessionId, optionNumber);
+      const result = await this.promptResponder.sendApprovalReply(promptId, optionNumber);
+      if (!result.ok) {
+        this.mobileDeduper.forget(session.sessionId, optionNumber);
+        logger.warn("sendApprovalReply failed", {
+          promptId,
+          reason: result.reason,
+          details: result.details
+        });
+        return;
+      }
+      await this.markExecuted(evt);
+    }
+  }
+  /**
+   * Transition a mobile event's deliveryStatus to DELIVERED. Called as
+   * soon as the plugin receives + decrypts the event and BEFORE the
+   * tmux send is attempted, mirroring codex/claude plugin semantics:
+   * "delivered" means the desktop daemon has the message in hand, not
+   * that it has acted on it yet. Errors are swallowed (logged) since
+   * a status-write failure must not block the actual prompt routing.
+   */
+  async markDelivered(evt) {
+    try {
+      await this.appSyncClient.updateEventStatus({
+        eventId: evt.eventId,
+        sessionId: evt.sessionId,
+        timestamp: evt.timestamp,
+        deliveryStatus: import_codevibe_core4.DeliveryStatus.DELIVERED
+      });
+    } catch (err) {
+      logger.warn("updateEventStatus(DELIVERED) failed", {
+        eventId: evt.eventId,
+        sessionId: evt.sessionId,
+        error: String(err)
+      });
+    }
+  }
+  /**
+   * Transition a mobile event's deliveryStatus to EXECUTED. Called
+   * after the tmux send-keys for this mobile event succeeded — at
+   * which point the desktop pane has actually consumed the input
+   * (free-form text or approval digit). Errors are swallowed so a
+   * transient AppSync failure doesn't surface as a user-visible
+   * error after the desktop has already acted on the message.
+   */
+  async markExecuted(evt) {
+    try {
+      await this.appSyncClient.updateEventStatus({
+        eventId: evt.eventId,
+        sessionId: evt.sessionId,
+        timestamp: evt.timestamp,
+        deliveryStatus: import_codevibe_core4.DeliveryStatus.EXECUTED
+      });
+    } catch (err) {
+      logger.warn("updateEventStatus(EXECUTED) failed", {
+        eventId: evt.eventId,
+        sessionId: evt.sessionId,
+        error: String(err)
+      });
+    }
+  }
+  // ─── HTTP API push hook (internal/programmatic) ────────────────────────
+  async handleHttpPushEvent(payload) {
+    const session = this.findSessionByBackendId(payload.sessionId);
+    if (!session) {
+      throw new SessionNotFoundError(payload.sessionId);
+    }
+    const normalizedMeta = parseMaybeJson(payload.metadata);
+    const metadata = normalizedMeta && typeof normalizedMeta === "object" ? normalizedMeta : {};
+    const input = {
+      sessionId: payload.sessionId,
+      type: payload.type,
+      source: payload.source,
+      content: payload.content,
+      metadata,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const finalInput = this.encryptOutbound(session, input);
+    const created = await this.appSyncClient.createEvent(finalInput);
+    return { eventId: created.eventId };
+  }
+  findSessionByBackendId(backendSessionId) {
+    if (!this.session) return null;
+    return this.session.sessionId === backendSessionId ? this.session : null;
+  }
+  // ─── Signal handling ────────────────────────────────────────────────────
+  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.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);
+  }
+  unregisterSignalHandlers() {
+    if (!this.signalsRegistered) return;
+    if (this.boundSigintHandler) process.off("SIGINT", this.boundSigintHandler);
+    if (this.boundSigtermHandler) process.off("SIGTERM", this.boundSigtermHandler);
+    this.boundSigintHandler = null;
+    this.boundSigtermHandler = null;
+    this.signalsRegistered = false;
+  }
+  // ─── Lookups (test surface) ────────────────────────────────────────────
+  getSessionByConversation(conversationId) {
+    if (!this.session) return null;
+    if (!this.observedMainConversationIds.has(conversationId)) return null;
+    return this.session;
+  }
+  getAnySession() {
+    return this.session;
+  }
+  isDisabled() {
+    return this.sessionDisabled;
+  }
+};
+function parseMaybeJson(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "object") return value;
+  if (typeof value === "string") {
+    if (value.length === 0) return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+var SessionNotFoundError = class extends Error {
+  constructor(sessionId) {
+    super(`session not found: ${sessionId}`);
+    this.sessionId = sessionId;
+    this.code = "session-not-found";
+    this.name = "SessionNotFoundError";
+  }
+};
+function generateLaunchSessionId(wrapperPid) {
+  const nonce = crypto3.randomBytes(8).toString("hex");
+  return `agy-${wrapperPid}-${nonce}`;
+}
+function getActiveConversationFromCliLog(cliLogPath) {
+  try {
+    if (!fs5.existsSync(cliLogPath)) return null;
+    const content = fs5.readFileSync(cliLogPath, "utf8");
+    const regex = /(?:Created conversation|Streaming conversation|Starting conversation update stream for)\s+([0-9a-fA-F-]{36})/g;
+    const matches = Array.from(content.matchAll(regex));
+    if (matches.length === 0) return null;
+    return matches[matches.length - 1][1];
+  } catch (err) {
+    return null;
+  }
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const bearerToken = process.env.CODEVIBE_AGY_MCP_TOKEN || args.token;
+  if (!bearerToken) {
+    console.error("codevibe-antigravity-plugin: bearer token required via $CODEVIBE_AGY_MCP_TOKEN or --token");
+    process.exit(1);
+  }
+  const server = new McpServer({
+    bearerToken,
+    preferredPort: args.port,
+    runtimeDir: args.runtimeDir,
+    tmuxTarget: process.env.CODEVIBE_AGY_TMUX_TARGET ?? void 0,
+    wrapperPid: process.env.CODEVIBE_AGY_WRAPPER_PID ? parseInt(process.env.CODEVIBE_AGY_WRAPPER_PID, 10) : void 0
+  });
+  try {
+    const { httpPort } = await server.start();
+    logger.info("codevibe-antigravity-plugin ready", { httpPort });
+  } catch (err) {
+    console.error("startup failed:", err);
+    process.exit(1);
+  }
+}
+function parseArgs(argv) {
+  let token = "";
+  let port = 0;
+  let runtimeDir;
+  for (let i = 0; i < argv.length; i++) {
+    const flag = argv[i];
+    if (flag === "--token") {
+      token = argv[++i] ?? "";
+    } else if (flag === "--port") {
+      port = parseInt(argv[++i] ?? "0", 10);
+    } else if (flag === "--runtime-dir") {
+      runtimeDir = argv[++i];
+    }
+  }
+  return { token, port, runtimeDir };
+}
+if (require.main === module) {
+  void main();
+}
+var __testing = {
+  generateLaunchSessionId,
+  parseArgs,
+  parseMaybeJson,
+  getActiveConversationFromCliLog
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  McpServer,
+  SessionNotFoundError,
+  __testing,
+  generateLaunchSessionId,
+  getActiveConversationFromCliLog,
+  parseMaybeJson
+});