@quantiya/codevibe-antigravity-plugin 2.0.60 → 2.0.62

package/dist/server.js

@@ -49,7 +49,7 @@ var fs5 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
 var import_child_process3 = require("child_process");
 var import_util3 = require("util");
-var import_codevibe_core5 = require("@quantiya/codevibe-core");
+var import_codevibe_core6 = require("@quantiya/codevibe-core");
 
 // src/logger.ts
 var import_os = __toESM(require("os"));
@@ -95,14 +95,14 @@ var HttpApi = class {
     if (this.server) return this.assignedPort;
     this.server = http.createServer((req, res) => this.dispatch(req, res));
     try {
-      await new Promise((resolve3, reject) => {
+      await new Promise((resolve2, reject) => {
         const onError = (err) => {
           this.server?.off("listening", onListening);
           reject(err);
         };
         const onListening = () => {
           this.server?.off("error", onError);
-          resolve3();
+          resolve2();
         };
         this.server.once("error", onError);
         this.server.once("listening", onListening);
@@ -135,7 +135,7 @@ var HttpApi = class {
     const srv = this.server;
     if (!srv) return;
     this.server = null;
-    await new Promise((resolve3) => srv.close(() => resolve3()));
+    await new Promise((resolve2) => srv.close(() => resolve2()));
     if (this.portFilePath) {
       try {
         await fs.promises.unlink(this.portFilePath);
@@ -205,23 +205,20 @@ var HttpApi = class {
       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)) {
+    if (!isHttpEventPayload(payload)) {
       this.sendJson(res, 400, {
         success: false,
-        error: "invalid type or source enum value"
+        error: "invalid ordinary desktop event payload"
       });
       return;
     }
     try {
-      const { eventId } = await this.handlers.pushEvent(payload);
-      this.sendJson(res, 200, { success: true, data: { eventId } });
+      const result = await this.handlers.pushEvent(payload);
+      if (result.status === "DROPPED") {
+        this.sendJson(res, 503, { success: false, error: "event was not admitted", data: result });
+      } else {
+        this.sendJson(res, result.status === "PENDING" ? 202 : 200, { success: true, data: result });
+      }
     } catch (err) {
       logger.error("pushEvent failed in /event handler", { error: String(err) });
       const code = err?.code;
@@ -229,6 +226,10 @@ var HttpApi = class {
         this.sendJson(res, 404, { success: false, error: "session not found" });
         return;
       }
+      if (code === "INVALID_SYNC_INPUT") {
+        this.sendJson(res, 400, { success: false, error: "unsupported event payload; use its dedicated producer" });
+        return;
+      }
       this.sendJson(res, 500, { success: false, error: "event push failed" });
     }
   }
@@ -263,12 +264,13 @@ 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);
+function isHttpEventPayload(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const row = value;
+  return !Object.keys(row).some((key) => !["sessionId", "type", "source", "content", "metadata"].includes(key)) && typeof row.sessionId === "string" && /^[A-Za-z0-9_-]{1,256}$/.test(row.sessionId) && isValidEventType(row.type) && row.source === import_codevibe_core2.EventSource.DESKTOP && typeof row.content === "string";
 }
 async function readBody(req, maxBytes) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve2, reject) => {
     let received = 0;
     const chunks = [];
     req.on("data", (chunk) => {
@@ -280,7 +282,7 @@ async function readBody(req, maxBytes) {
       }
       chunks.push(chunk);
     });
-    req.on("end", () => resolve3(Buffer.concat(chunks).toString("utf8")));
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf8")));
     req.on("error", reject);
   });
 }
@@ -306,8 +308,8 @@ async function boundedStep(work, ms, onTimeout) {
         return Promise.reject(err);
       }
     })();
-    const timeout = new Promise((resolve3) => {
-      timer = setTimeout(() => resolve3("timeout"), ms);
+    const timeout = new Promise((resolve2) => {
+      timer = setTimeout(() => resolve2("timeout"), ms);
       if (timer.unref) timer.unref();
     });
     const outcome = await Promise.race([
@@ -346,6 +348,29 @@ function armShutdownWatchdog(exit, onFire, ms = SHUTDOWN_WATCHDOG_MS, durableObl
   return () => clearTimeout(timer);
 }
 
+// src/durable-transcript-reader.ts
+var import_codevibe_core3 = require("@quantiya/codevibe-core");
+function readAdmittedTranscript(options) {
+  const stream = (value) => Object.freeze({ ...value, conversationId: options.conversationId });
+  return (0, import_codevibe_core3.readDesktopSyncFile)({
+    ...options,
+    parse: (line) => {
+      const parsed = JSON.parse(line);
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) && Number.isFinite(parsed.step_index) && typeof parsed.type === "string" ? parsed : null;
+    },
+    admission: {
+      restore: (source, initial) => options.admission.restore(stream(source), initial),
+      skip: (gap, source) => options.admission.skip(gap, stream(source)),
+      admit: (event, source) => options.admission.admit({
+        conversationId: options.conversationId,
+        filePath: source.filePath,
+        byteOffset: source.startOffset,
+        event
+      }, stream(source))
+    }
+  });
+}
+
 // src/transcript-tailer.ts
 var OFFSET_FLUSH_INTERVAL_MS = 3e4;
 var ERROR_LOG_MIN_INTERVAL_MS = 1e4;
@@ -355,6 +380,30 @@ var CONVERSATION_DIR_REGEX = /^[0-9a-fA-F-]{36}$/;
 var SYSTEM_GENERATED_DIR = ".system_generated";
 var LOGS_DIR = "logs";
 var TRANSCRIPT_BASENAME = "transcript.jsonl";
+var DISCOVERY_TICK_MS = 250;
+var RESUME_SWEEP_EVERY_TICKS = 4;
+var TRANSCRIPT_POLL_INTERVAL_MS = 100;
+var MAX_FOLLOWED_TRANSCRIPTS = 4;
+var FOLLOW_CATCH_UP_READ_DELAY_MS = 250;
+var CHOKIDAR_ENV_OVERRIDES = ["CHOKIDAR_USEPOLLING", "CHOKIDAR_INTERVAL"];
+function watchOneFilePolled(target, options) {
+  const saved = CHOKIDAR_ENV_OVERRIDES.map((name) => [name, process.env[name]]);
+  for (const [name] of saved) delete process.env[name];
+  let watcher;
+  try {
+    watcher = (0, import_chokidar.watch)(target, { ...options, usePolling: true });
+  } finally {
+    for (const [name, value] of saved) {
+      if (value === void 0) delete process.env[name];
+      else process.env[name] = value;
+    }
+  }
+  if (watcher.options?.usePolling !== true) {
+    void watcher.close().catch(() => void 0);
+    throw new Error("chokidar did not honour usePolling; refusing a native fs.watch");
+  }
+  return watcher;
+}
 function defaultPaths() {
   const home = os2.homedir();
   return {
@@ -365,9 +414,41 @@ function defaultPaths() {
 var TranscriptTailer = class extends import_events.EventEmitter {
   constructor(options = {}) {
     super();
-    this.watcher = null;
     this.isWatching = false;
     this.isShuttingDown = false;
+    this.ownedReads = /* @__PURE__ */ new Set();
+    this.retryTimers = /* @__PURE__ */ new Map();
+    /** Transcripts currently followed (stat-polled), keyed by conversation. */
+    this.followed = /* @__PURE__ */ new Map();
+    /** Conversations released by the follow cap during this lifetime. Their
+     *  offsets stay protected from LRU eviction (as activeConversations are), so
+     *  a later re-follow resumes exactly where it left off instead of replaying
+     *  history. Cleared when its transcript goes away (unlink, confirmed
+     *  absence, directory removal), when the sweep resets a never-read cursor
+     *  for a replaced file, and on start(). A replacement found by the read
+     *  chain keeps it: that read consumes the new file (Stage 2 R1-F6). */
+    this.releasedConversations = /* @__PURE__ */ new Set();
+    /** Last inode seen per transcript path by readNewLines: a different inode
+     *  is a replacement (delete-then-recreate or atomic rename) and resets the
+     *  cursor, as the former tree watch's `unlink` did. */
+    this.fileInodes = /* @__PURE__ */ new Map();
+    /** Per-path count of cursor resets (replacement, deletion, directory
+     *  removal, unlink). A read in flight that sees the count change discards
+     *  its stale cursor instead of writing it back, and re-queues itself so the
+     *  new file is read from byte 0 (Stage 1 r7 S1-F14 / NB-K). */
+    this.cursorResets = /* @__PURE__ */ new Map();
+    /** Conversation directories seen in the brain root (snapshot at start, then
+     *  maintained by the discovery tick). */
+    this.knownConversationDirs = /* @__PURE__ */ new Set();
+    /** Conversations created after start whose transcript does not exist yet;
+     *  checked on every discovery tick. */
+    this.pendingTranscripts = /* @__PURE__ */ new Map();
+    /** Last swept stat of each unfollowed conversation's transcript (null when
+     *  absent), for the resume sweep. */
+    this.transcriptSnapshots = /* @__PURE__ */ new Map();
+    this.rootMtimeMs = 0;
+    this.discoveryTimer = null;
+    this.discoveryTickCount = 0;
     /** Error-log rate limiting (incident 2026-09-22 — a wedged watcher wrote
      *  356,298 identical EMFILE errors / 96 MB before the daemon was killed). */
     this.lastErrorSignature = null;
@@ -394,11 +475,13 @@ var TranscriptTailer = class extends import_events.EventEmitter {
     const defaults = defaultPaths();
     this.brainRoot = options.brainRoot ?? defaults.brainRoot;
     this.offsetFilePath = options.offsetFilePath ?? defaults.offsetFilePath;
-    this.usePolling = options.usePolling ?? false;
+    this.admission = options.admission;
+    if (this.admission && (typeof this.admission.restore !== "function" || typeof this.admission.admit !== "function" || typeof this.admission.skip !== "function")) throw new TypeError("Durable transcript admission requires restore, admit and skip");
   }
   /**
-   * Start watching the brain root. Loads persisted offsets, prunes orphans,
-   * then chokidar watches for new / changed transcript files.
+   * Start following transcripts. Loads persisted offsets, prunes orphans,
+   * snapshots the brain, then runs the discovery tick. Opens no directory
+   * watch (see the file header).
    */
   start() {
     if (this.isWatching) {
@@ -407,6 +490,8 @@ var TranscriptTailer = class extends import_events.EventEmitter {
     }
     this.startTime = Date.now();
     this.readGeneration++;
+    for (const timer of this.retryTimers.values()) clearTimeout(timer);
+    this.retryTimers.clear();
     this.loadPersistedOffsets();
     this.pruneOrphanedOffsets();
     if (!fs2.existsSync(this.brainRoot)) {
@@ -420,97 +505,35 @@ var TranscriptTailer = class extends import_events.EventEmitter {
         });
       }
     }
+    this.knownConversationDirs.clear();
+    this.pendingTranscripts.clear();
+    this.transcriptSnapshots.clear();
+    this.releasedConversations.clear();
+    this.discoveryTickCount = 0;
+    this.rootMtimeMs = this.statMtimeMs(this.brainRoot) ?? 0;
+    for (const conversationId of this.listConversationDirs() ?? []) {
+      this.knownConversationDirs.add(conversationId);
+      this.transcriptSnapshots.set(
+        conversationId,
+        this.snapshotTranscript(this.transcriptPathFor(conversationId))
+      );
+    }
     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,
-      // R24 — admit ONLY the exact path shape that can lead to a transcript.
-      //
-      // THE DEFECT THIS REPLACES: the previous predicate returned `false` for
-      // EVERY directory ("allow directories so chokidar can descend into
-      // them"), so chokidar descended into the whole brain. Measured on a real
-      // machine 2026-09-22: **40,345 directories across 234 conversations**
-      // (7.8 GB), on chokidar's kqueue backend which needs roughly one file
-      // descriptor per watched directory. The watcher exhausted its descriptors
-      // and threw EMFILE continuously — 77,359 errors in a single 28-minute
-      // daemon start, 89% of the whole log file across the day.
-      //
-      // That was not merely wasteful, it was a CORRECTNESS failure, and the
-      // exact shape matters because it is worse than a slow start:
-      //
-      //   1. The initial scan storms for tens of minutes.
-      //   2. When it finally completes, `ready` fires and
-      //      backfillActiveTranscripts() does a ONE-SHOT catch-up read. That
-      //      uses its own readdirSync, NOT the watcher, so it succeeds — mobile
-      //      shows a sudden burst of backlog.
-      //   3. But the per-file WATCH was never established, because the
-      //      descriptors were spent on old conversations during the scan. So no
-      //      `change` event ever arrives again and the tailer STALLS PERMANENTLY
-      //      at whatever offset the backfill reached.
-      //
-      // Measured live on the owner's machine while this fix was being written,
-      // and RETAINED — every figure here comes from that capture, not from
-      // recollection:
-      //   .hard-gate/r24-watch-scope/evidence/prefix-descriptor-accounting.log
-      // The daemon held file descriptors for 231 OLD conversations and **zero**
-      // for the active one, while its offset sat frozen at 987,484 bytes
-      // against a transcript of 1,656,028 on disk — 668 KB behind and not
-      // advancing, with the EMFILE rate back to 0/sec and the daemon otherwise
-      // idle at 0.3% CPU. The gap WIDENED between two samplings twenty minutes
-      // apart (231 KB, then 668 KB), which is what distinguishes a permanent
-      // stall from slow catch-up.
-      //
-      // User-visible result: a burst of backlog, then silence. Interactive
-      // prompts degrade to "Prompt candidate fired but no active conversation
-      // known {observedConvCount:0}", which renders on mobile as "a prompt is
-      // waiting in your desktop terminal" with NO selectable options — the user
-      // can see that a prompt exists but cannot answer it, which is the entire
-      // purpose of the mobile companion.
-      //
-      // NOTE this description was corrected twice. It was first written as
-      // "permanent", then weakened to "a bounded dead window" after observing a
-      // recovery, then corrected again once the descriptor accounting above was
-      // actually measured. The recovery was the one-shot backfill of step 2, not
-      // the watcher healing. Stage 1 NB-4 predicted this sub-case before it was
-      // measured.
-      //
-      // THE FIX: the transcript lives at exactly one shape, four levels deep:
-      //   brain/<uuid>/.system_generated/logs/transcript.jsonl
-      // so decide purely LEXICALLY on that shape and refuse everything else.
-      // Same machine, after: **699** directories (1 root + 234 conversations +
-      // 232 .system_generated + 232 logs) — a 57x reduction that also excludes
-      // the actual bulk: scratch/ (230 dirs), .user_uploaded/ (232) and the
-      // thousands of .system_generated/tasks/ dirs, none of which can ever hold
-      // a transcript.
-      //
-      // Deciding lexically also removes the per-path `fs.statSync` the old
-      // predicate ran during traversal, which was its own CPU cost on a tree
-      // this size.
-      ignored: (filePath) => this.isOutsideTranscriptPath(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) => {
-      this.emitError(error, "Chokidar error");
-    });
-    this.watcher.on("ready", () => {
-      logger.info("Transcript tailer ready (chokidar initial scan complete)");
-      this.backfillActiveTranscripts();
+      loadedOffsets: this.offsets.size,
+      knownConversations: this.knownConversationDirs.size
     });
+    this.discoveryTimer = setInterval(() => this.discoveryTick(), DISCOVERY_TICK_MS);
+    if (this.discoveryTimer.unref) this.discoveryTimer.unref();
     this.flushTimer = setInterval(() => this.flushOffsets(), OFFSET_FLUSH_INTERVAL_MS);
     if (this.flushTimer.unref) this.flushTimer.unref();
     this.isWatching = true;
+    const generation = this.readGeneration;
+    setImmediate(() => {
+      if (!this.isWatching || this.isShuttingDown || generation !== this.readGeneration) return;
+      this.backfillActiveTranscripts();
+    });
   }
   /**
    * (#638 G4) SAFE 'error' emission. `EventEmitter.emit('error', …)` with NO
@@ -550,6 +573,8 @@ var TranscriptTailer = class extends import_events.EventEmitter {
     if (!this.isWatching) return;
     this.isShuttingDown = true;
     this.readGeneration++;
+    for (const timer of this.retryTimers.values()) clearTimeout(timer);
+    this.retryTimers.clear();
     if (this.flushTimer) {
       clearInterval(this.flushTimer);
       this.flushTimer = null;
@@ -559,10 +584,18 @@ var TranscriptTailer = class extends import_events.EventEmitter {
     } catch (error) {
       logger.warn("Final offset flush failed", { error });
     }
-    if (this.watcher) {
-      const watcher = this.watcher;
+    if (this.discoveryTimer) {
+      clearInterval(this.discoveryTimer);
+      this.discoveryTimer = null;
+    }
+    const watchers = Array.from(this.followed.values(), (f) => f.watcher);
+    this.followed.clear();
+    this.pendingTranscripts.clear();
+    this.knownConversationDirs.clear();
+    this.transcriptSnapshots.clear();
+    if (watchers.length > 0) {
       const outcome = await boundedStep(
-        () => watcher.close(),
+        () => Promise.all(watchers.map((w) => w.close())),
         WATCHER_CLOSE_TIMEOUT_MS,
         () => logger.warn("chokidar watcher.close() timed out \u2014 abandoning it", {
           timeoutMs: WATCHER_CLOSE_TIMEOUT_MS
@@ -571,10 +604,10 @@ var TranscriptTailer = class extends import_events.EventEmitter {
       if (outcome === "timeout") {
         logger.warn("Transcript tailer watcher abandoned; relying on shutdown watchdog");
       }
-      this.watcher = null;
     }
     this.activeReads.clear();
     this.pendingReads.clear();
+    this.cursorResets.clear();
     this.isWatching = false;
     this.isShuttingDown = false;
     logger.info(
@@ -584,6 +617,10 @@ var TranscriptTailer = class extends import_events.EventEmitter {
     this.lastErrorSignature = null;
     this.suppressedErrorCount = 0;
   }
+  /** Server shutdown joins reads it admitted before retiring the session. */
+  async waitForReads() {
+    await Promise.allSettled([...this.ownedReads]);
+  }
   /**
    * Best-effort sync flush. Safe to call from a process EXIT trap.
    * (The async stop() above is preferred when a regular shutdown is feasible.)
@@ -603,7 +640,7 @@ var TranscriptTailer = class extends import_events.EventEmitter {
   getActiveConversations() {
     return Array.from(this.activeConversations);
   }
-  // ─── chokidar event handlers ─────────────────────────────────────────────
+  // ─── follower event handlers ─────────────────────────────────────────────
   onFileAdded(filePath) {
     if (this.isShuttingDown) return;
     const conversationId = this.extractConversationId(filePath);
@@ -625,57 +662,292 @@ var TranscriptTailer = class extends import_events.EventEmitter {
     this.emit("transcript-add", filePath, conversationId);
     void this.scheduleReadNewLines(filePath, conversationId);
   }
+  // ─── Discovery (no directory watch) ─────────────────────────────────────
   /**
-   * R24 traversal filter: true = chokidar must NOT descend into / watch this.
-   *
-   * Purely lexical — no filesystem call — so it is cheap enough to run on every
-   * traversed path and cannot be fooled by a stat race. The only paths admitted
-   * are the ones that can lead to a transcript:
-   *
-   *   <brainRoot>                                                 depth 0
-   *   <brainRoot>/<uuid>                                          depth 1
-   *   <brainRoot>/<uuid>/.system_generated                        depth 2
-   *   <brainRoot>/<uuid>/.system_generated/logs                   depth 3
-   *   <brainRoot>/<uuid>/.system_generated/logs/transcript.jsonl  depth 4
-   *
-   * Anything else — scratch/, evidence/, .user_uploaded/, the task logs, and
-   * every file that is not the transcript — is refused, which stops chokidar
-   * descending into it at all.
-   *
-   * NOTE the depth-1 UUID check is what keeps this bounded as the brain grows:
-   * a non-conversation entry at the top level can never be a conversation, so
-   * it is never traversed. `depth: 4` on the watcher remains as a second,
-   * independent bound.
+   * One discovery tick. Never throws: a throw from a timer callback is an
+   * uncaughtException, which the daemon's process guard may treat as fatal.
    */
-  isOutsideTranscriptPath(filePath) {
-    const rel = path2.relative(this.brainRoot, path2.resolve(filePath));
-    if (rel === "") return false;
-    if (rel === ".." || rel.startsWith(".." + path2.sep)) return true;
-    const seg = rel.split(path2.sep);
-    if (!CONVERSATION_DIR_REGEX.test(seg[0])) return true;
-    switch (seg.length) {
-      case 1:
-        return false;
-      // a well-formed conversation directory
-      case 2:
-        return seg[1] !== SYSTEM_GENERATED_DIR;
-      case 3:
-        return seg[2] !== LOGS_DIR;
-      case 4:
-        return seg[3] !== TRANSCRIPT_BASENAME;
-      default:
-        return true;
+  discoveryTick() {
+    if (!this.isWatching || this.isShuttingDown) return;
+    try {
+      this.discoveryTickCount++;
+      const rootMtimeMs = this.statMtimeMs(this.brainRoot);
+      if (rootMtimeMs !== null && rootMtimeMs !== this.rootMtimeMs) {
+        this.rootMtimeMs = rootMtimeMs;
+        this.reconcileConversationDirs();
+      }
+      for (const [conversationId, transcriptPath] of Array.from(this.pendingTranscripts)) {
+        if (fs2.existsSync(transcriptPath)) {
+          this.pendingTranscripts.delete(conversationId);
+          this.followTranscript(conversationId, transcriptPath, "added");
+        }
+      }
+      if (this.discoveryTickCount % RESUME_SWEEP_EVERY_TICKS === 0) {
+        this.reconcileConversationDirs();
+        this.sweepForResumedTranscripts();
+      }
+    } catch (error) {
+      this.emitError(error, "Transcript discovery tick failed (non-fatal)");
+    }
+  }
+  /** Bring knownConversationDirs in line with the brain root's listing. */
+  reconcileConversationDirs() {
+    const present = this.listConversationDirs();
+    if (present === null) return;
+    const presentSet = new Set(present);
+    for (const conversationId of present) {
+      if (this.knownConversationDirs.has(conversationId)) continue;
+      this.knownConversationDirs.add(conversationId);
+      this.onConversationDirAdded(conversationId);
+    }
+    const tracked = /* @__PURE__ */ new Set([
+      ...this.knownConversationDirs,
+      ...this.pendingTranscripts.keys(),
+      ...this.followed.keys()
+    ]);
+    for (const conversationId of tracked) {
+      if (presentSet.has(conversationId)) continue;
+      this.knownConversationDirs.delete(conversationId);
+      this.pendingTranscripts.delete(conversationId);
+      this.transcriptSnapshots.delete(conversationId);
+      this.unfollow(conversationId, "conversation directory removed");
+      this.resetCursorForReplacement(
+        this.transcriptPathFor(conversationId),
+        conversationId,
+        "conversation directory removed"
+      );
+      this.activeConversations.delete(conversationId);
     }
   }
-  onDirAdded(dirPath) {
+  onConversationDirAdded(conversationId) {
     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 });
+    logger.info("New brain directory discovered (pre-prompt)", {
+      dirPath: path2.join(this.brainRoot, conversationId),
+      conversationId
+    });
     this.emit("conversation-discovered", conversationId);
+    const transcriptPath = this.transcriptPathFor(conversationId);
+    this.transcriptSnapshots.set(conversationId, null);
+    if (fs2.existsSync(transcriptPath)) {
+      this.followTranscript(conversationId, transcriptPath, "added");
+    } else {
+      this.pendingTranscripts.set(conversationId, transcriptPath);
+    }
+  }
+  sweepForResumedTranscripts() {
+    for (const conversationId of this.knownConversationDirs) {
+      if (this.followed.has(conversationId)) continue;
+      if (this.pendingTranscripts.has(conversationId)) continue;
+      const transcriptPath = this.transcriptPathFor(conversationId);
+      const current = this.snapshotTranscript(transcriptPath);
+      const previous = this.transcriptSnapshots.get(conversationId) ?? null;
+      if (current === null) {
+        if (previous !== null && this.isAbsent(transcriptPath)) {
+          this.transcriptSnapshots.set(conversationId, null);
+          this.resetCursorForReplacement(transcriptPath, conversationId, "deleted while unfollowed");
+        }
+        continue;
+      }
+      this.transcriptSnapshots.set(conversationId, current);
+      if (previous !== null && current.ino !== previous.ino && !this.fileInodes.has(transcriptPath)) {
+        this.resetCursorForReplacement(transcriptPath, conversationId, "inode changed while unfollowed");
+        this.emit("transcript-rotated", transcriptPath, conversationId);
+      }
+      if (previous === null || current.size !== previous.size || current.mtimeMs !== previous.mtimeMs || current.ino !== previous.ino || this.hasUnreadTail(conversationId, transcriptPath, current.size)) {
+        this.followTranscript(conversationId, transcriptPath, "resumed");
+      }
+    }
+  }
+  /**
+   * A conversation released by the follow cap in this lifetime whose file
+   * holds bytes past its cursor: its eviction drain did not finish (e.g. a
+   * transient stat/open error), so the final message would otherwise wait for
+   * the next write (Stage 2 R1-F8). Limited to released conversations — the
+   * offsets file also holds other daemons' cursors (F2), and following those
+   * on stale offsets would pull another session's history in.
+   */
+  hasUnreadTail(conversationId, transcriptPath, size) {
+    if (!this.releasedConversations.has(conversationId)) return false;
+    if (this.activeReads.has(transcriptPath)) return false;
+    const entry = this.offsets.get(transcriptPath);
+    if (!entry) return false;
+    return size > entry.byteOffset + Buffer.byteLength(entry.carryover, "utf-8");
+  }
+  /**
+   * Start following one transcript by stat-polling that file (no `fs.watch`
+   * handle), then route it through the same handler a filesystem event would
+   * have: `add` for a transcript created after start, `change` for an existing
+   * one (first sight of it is treated as a resume).
+   */
+  followTranscript(conversationId, transcriptPath, how) {
+    if (this.isShuttingDown || !this.isWatching) return;
+    if (this.followed.has(conversationId)) return;
+    let watcher;
+    try {
+      watcher = watchOneFilePolled(transcriptPath, {
+        persistent: true,
+        ignoreInitial: true,
+        usePolling: true,
+        interval: TRANSCRIPT_POLL_INTERVAL_MS,
+        awaitWriteFinish: false
+        // partial-line carryover handles partial writes
+      });
+    } catch (error) {
+      this.emitError(error, "Could not follow transcript by polling");
+      return;
+    }
+    while (this.followed.size >= MAX_FOLLOWED_TRANSCRIPTS) {
+      let oldestId = null;
+      let oldestMs = Number.POSITIVE_INFINITY;
+      for (const [id, f] of this.followed) {
+        if (f.lastActivityMs < oldestMs) {
+          oldestMs = f.lastActivityMs;
+          oldestId = id;
+        }
+      }
+      if (oldestId === null) break;
+      this.unfollow(oldestId, "follow cap reached", { drainTail: true });
+    }
+    const followed = {
+      watcher,
+      transcriptPath,
+      lastActivityMs: Date.now()
+    };
+    this.followed.set(conversationId, followed);
+    const touch = () => {
+      followed.lastActivityMs = Date.now();
+    };
+    watcher.on("add", (filePath) => {
+      touch();
+      this.onFileAdded(filePath);
+    });
+    watcher.on("change", (filePath) => {
+      touch();
+      this.onFileChanged(filePath);
+    });
+    watcher.on("unlink", (filePath) => this.onFileUnlinked(filePath));
+    watcher.on("error", (error) => {
+      this.emitError(error, "Chokidar error");
+    });
+    watcher.on("ready", () => {
+      const timer = setTimeout(() => {
+        if (this.followed.get(conversationId)?.watcher !== watcher) return;
+        if (!this.activeConversations.has(conversationId)) return;
+        void this.scheduleReadNewLines(transcriptPath, conversationId);
+      }, FOLLOW_CATCH_UP_READ_DELAY_MS);
+      if (timer.unref) timer.unref();
+    });
+    logger.info("Following transcript", {
+      conversationId,
+      how,
+      followedCount: this.followed.size,
+      pollIntervalMs: TRANSCRIPT_POLL_INTERVAL_MS
+    });
+    if (how === "added") this.onFileAdded(transcriptPath);
+    else this.onFileChanged(transcriptPath);
+  }
+  /**
+   * Stop following one transcript. Its offset is kept, its swept stat is
+   * refreshed so the resume sweep only re-follows it on a NEW write, and it
+   * leaves activeConversations so a re-follow is a resume.
+   *
+   * drainTail (eviction): read whatever is past the offset now. Otherwise a
+   * write that landed within the last poll interval would sit under the
+   * refreshed snapshot, unread until that conversation writes again — for a
+   * final message, indefinitely. An evicted conversation also joins
+   * releasedConversations, which protects its offset from LRU eviction so a
+   * re-follow never replays history. Without drainTail (its directory was
+   * removed) the offset is LRU-evictable.
+   */
+  unfollow(conversationId, reason, opts = {}) {
+    const followed = this.followed.get(conversationId);
+    if (!followed) return;
+    if (this.knownConversationDirs.has(conversationId)) {
+      this.transcriptSnapshots.set(conversationId, this.snapshotTranscript(followed.transcriptPath));
+    }
+    if (opts.drainTail) {
+      this.releasedConversations.add(conversationId);
+      void this.scheduleReadNewLines(followed.transcriptPath, conversationId);
+    } else {
+      this.releasedConversations.delete(conversationId);
+    }
+    this.followed.delete(conversationId);
+    this.activeConversations.delete(conversationId);
+    followed.watcher.close().catch((error) => {
+      this.emitError(error, "Transcript follower close failed (non-fatal)");
+    });
+    logger.info("Stopped following transcript", { conversationId, reason });
+  }
+  /**
+   * The file at this path is no longer the one the cursor describes (deleted,
+   * its directory removed, or replaced by a different inode). Restart it from
+   * byte 0, as the former tree watch's `unlink` → onFileUnlinked did. The
+   * released-follower offset protection ends with the file it protected —
+   * except when the reset is made by the read that is about to consume the
+   * new file (`keepProtection`): that read advances the cursor over content it
+   * delivers, so the cursor must stay protected or a later re-follow would
+   * replay it (Stage 2 R1-F6).
+   */
+  resetCursorForReplacement(filePath, conversationId, reason, opts = {}) {
+    const entry = this.offsets.get(filePath);
+    if (entry) {
+      logger.warn("Transcript replaced or removed; resetting offset", {
+        filePath,
+        conversationId,
+        reason,
+        previousOffset: entry.byteOffset
+      });
+      entry.byteOffset = 0;
+      entry.carryover = "";
+      entry.lastKnownSize = 0;
+      entry.lastModifiedMs = Date.now();
+    }
+    this.fileInodes.delete(filePath);
+    if (!opts.keepProtection) this.releasedConversations.delete(conversationId);
+    this.bumpCursorResets(filePath);
+  }
+  /** Only a read chain in flight can hold a stale cursor, so only then is the
+   *  count kept; the chain's end prunes it (Stage 2 R1-F7). Outside resets
+   *  land at an `await`, by which time the chain is registered in activeReads. */
+  bumpCursorResets(filePath) {
+    if (!this.activeReads.has(filePath)) return;
+    this.cursorResets.set(filePath, (this.cursorResets.get(filePath) ?? 0) + 1);
+  }
+  transcriptPathFor(conversationId) {
+    return path2.join(this.brainRoot, conversationId, SYSTEM_GENERATED_DIR, LOGS_DIR, TRANSCRIPT_BASENAME);
+  }
+  /** UUID-named directories directly under the brain root; null on failure. */
+  listConversationDirs() {
+    try {
+      return fs2.readdirSync(this.brainRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && CONVERSATION_DIR_REGEX.test(entry.name)).map((entry) => entry.name);
+    } catch {
+      return null;
+    }
+  }
+  snapshotTranscript(transcriptPath) {
+    try {
+      const stat = fs2.statSync(transcriptPath);
+      return stat.isFile() ? { size: stat.size, mtimeMs: stat.mtimeMs, ino: stat.ino } : null;
+    } catch {
+      return null;
+    }
+  }
+  /** True only when the path is confirmed absent (ENOENT / ENOTDIR). */
+  isAbsent(filePath) {
+    try {
+      fs2.statSync(filePath);
+      return false;
+    } catch (error) {
+      const code = error.code;
+      return code === "ENOENT" || code === "ENOTDIR";
+    }
+  }
+  statMtimeMs(dirPath) {
+    try {
+      return fs2.statSync(dirPath).mtimeMs;
+    } catch {
+      return null;
+    }
   }
   /**
    * Fires when chokidar reports a transcript.jsonl was deleted or moved
@@ -709,6 +981,9 @@ var TranscriptTailer = class extends import_events.EventEmitter {
     entry.carryover = "";
     entry.lastKnownSize = 0;
     entry.lastModifiedMs = Date.now();
+    this.fileInodes.delete(filePath);
+    this.releasedConversations.delete(conversationId);
+    this.bumpCursorResets(filePath);
     this.activeConversations.delete(conversationId);
   }
   onFileChanged(filePath) {
@@ -728,7 +1003,7 @@ var TranscriptTailer = class extends import_events.EventEmitter {
   }
   // ─── Backfill at startup ────────────────────────────────────────────────
   /**
-   * Walk the brain root once at startup and emit resume events for any
+   * Walk the brain root once at startup and follow (as a resume) any
    * transcript.jsonl that already exists and shows recent activity. This
    * covers the case where agy is already running when codevibe-agy starts.
    */
@@ -740,6 +1015,13 @@ var TranscriptTailer = class extends import_events.EventEmitter {
         if (!dir.isDirectory()) continue;
         const conversationId = dir.name;
         if (!/^[0-9a-fA-F-]{36}$/.test(conversationId)) continue;
+        if (!this.knownConversationDirs.has(conversationId)) {
+          this.knownConversationDirs.add(conversationId);
+          this.transcriptSnapshots.set(
+            conversationId,
+            this.snapshotTranscript(this.transcriptPathFor(conversationId))
+          );
+        }
         const dirPath = path2.join(this.brainRoot, conversationId);
         const transcriptPath = path2.join(
           dirPath,
@@ -777,16 +1059,16 @@ var TranscriptTailer = class extends import_events.EventEmitter {
             transcriptPath,
             conversationId
           });
-          this.activeConversations.add(conversationId);
-          this.ensureOffset(transcriptPath);
-          this.emit("transcript-resume", transcriptPath, conversationId);
-          void this.scheduleReadNewLines(transcriptPath, conversationId);
+          this.followTranscript(conversationId, transcriptPath, "resumed");
         } else {
           logger.info("Backfilling recent transcriptless directory at startup", {
             dirPath,
             conversationId
           });
           this.emit("conversation-discovered", conversationId);
+          if (!this.followed.has(conversationId)) {
+            this.pendingTranscripts.set(conversationId, transcriptPath);
+          }
         }
       }
     } catch (error) {
@@ -807,12 +1089,23 @@ var TranscriptTailer = class extends import_events.EventEmitter {
         conversationId,
         error: String(error)
       });
+      if (this.admission && this.isWatching && generation === this.readGeneration && !this.retryTimers.has(filePath)) {
+        const timer = setTimeout(() => {
+          this.retryTimers.delete(filePath);
+          if (this.isWatching && generation === this.readGeneration) void this.scheduleReadNewLines(filePath, conversationId);
+        }, 5e3);
+        timer.unref();
+        this.retryTimers.set(filePath, timer);
+      }
     });
     this.activeReads.set(filePath, read);
+    this.ownedReads.add(read);
     void read.finally(() => {
+      this.ownedReads.delete(read);
       if (this.activeReads.get(filePath) === read) {
         this.activeReads.delete(filePath);
         this.pendingReads.delete(filePath);
+        this.cursorResets.delete(filePath);
       }
     });
     return read;
@@ -830,6 +1123,23 @@ var TranscriptTailer = class extends import_events.EventEmitter {
       logger.warn("No offset entry \u2014 skipping read", { filePath });
       return;
     }
+    if (this.admission) {
+      const result = await readAdmittedTranscript({
+        filePath,
+        conversationId,
+        initialOffset: entry.byteOffset,
+        admission: this.admission,
+        isCurrent: () => generation === this.readGeneration && !this.isShuttingDown
+      });
+      if (result) {
+        if (generation !== this.readGeneration) return;
+        entry.byteOffset = result.position.byteOffset;
+        entry.carryover = "";
+        entry.lastKnownSize = result.size;
+        entry.lastModifiedMs = result.mtimeMs;
+        return;
+      }
+    }
     let stat;
     try {
       stat = fs2.statSync(filePath);
@@ -837,6 +1147,12 @@ var TranscriptTailer = class extends import_events.EventEmitter {
       logger.warn("stat failed; file may have been deleted", { filePath, error });
       return;
     }
+    const lastInode = this.fileInodes.get(filePath);
+    if (lastInode !== void 0 && lastInode !== stat.ino) {
+      this.resetCursorForReplacement(filePath, conversationId, "inode changed", { keepProtection: true });
+      this.emit("transcript-rotated", filePath, conversationId);
+    }
+    this.fileInodes.set(filePath, stat.ino);
     if (stat.size < entry.lastKnownSize) {
       logger.warn("Transcript file rotated (size shrunk); resetting offset", {
         filePath,
@@ -849,6 +1165,12 @@ var TranscriptTailer = class extends import_events.EventEmitter {
       entry.lastKnownSize = stat.size;
       this.emit("transcript-rotated", filePath, conversationId);
     }
+    const resetsAtStart = this.cursorResets.get(filePath) ?? 0;
+    const staleRead = () => {
+      if ((this.cursorResets.get(filePath) ?? 0) === resetsAtStart) return false;
+      this.pendingReads.add(filePath);
+      return true;
+    };
     const carryoverBytes = Buffer.byteLength(entry.carryover, "utf-8");
     const readStart = entry.byteOffset + carryoverBytes;
     if (stat.size <= readStart) {
@@ -871,14 +1193,14 @@ var TranscriptTailer = class extends import_events.EventEmitter {
     let lineStartOffset = entry.byteOffset;
     try {
       for await (const chunk of stream) {
-        if (generation !== this.readGeneration) {
+        if (generation !== this.readGeneration || staleRead()) {
           stream.destroy();
           return;
         }
         buffered += chunk;
         let newlineIndex = buffered.indexOf("\n");
         while (newlineIndex !== -1) {
-          if (generation !== this.readGeneration) {
+          if (generation !== this.readGeneration || staleRead()) {
             stream.destroy();
             return;
           }
@@ -900,7 +1222,7 @@ var TranscriptTailer = class extends import_events.EventEmitter {
       this.emitError(error);
       return;
     }
-    if (generation !== this.readGeneration) return;
+    if (generation !== this.readGeneration || staleRead()) return;
     entry.byteOffset = lineStartOffset;
     entry.carryover = buffered;
     entry.lastKnownSize = stat.size;
@@ -964,7 +1286,7 @@ var TranscriptTailer = class extends import_events.EventEmitter {
     let oldestMtime = Number.POSITIVE_INFINITY;
     for (const [p, entry] of this.offsets.entries()) {
       const cid = this.extractConversationId(p);
-      if (cid && this.activeConversations.has(cid)) {
+      if (cid && (this.activeConversations.has(cid) || this.releasedConversations.has(cid))) {
         continue;
       }
       if (entry.lastModifiedMs < oldestMtime) {
@@ -1962,8 +2284,8 @@ function escapeShellArg(value) {
   return value.replace(/'/g, `'\\''`);
 }
 function sleep(ms) {
-  return new Promise((resolve3) => {
-    const t = setTimeout(resolve3, ms);
+  return new Promise((resolve2) => {
+    const t = setTimeout(resolve2, ms);
     if (t.unref) t.unref();
   });
 }
@@ -2894,7 +3216,7 @@ var PromptResponder = class {
       };
     }
   }
-  async sendFreeFormWhenNoApprovalActive(text) {
+  async sendFreeFormWhenNoApprovalActive(text, beforeType) {
     const target = this.resolveTmuxTarget();
     if (!target) return { ok: false, reason: "no-tmux-target" };
     if (!this.paneObserver) {
@@ -2914,9 +3236,20 @@ var PromptResponder = class {
       }
       return null;
     };
+    let preparationFailed = false;
     try {
       const beforeText = await chooserIsAbsent();
       if (beforeText) return beforeText;
+      if (beforeType) {
+        try {
+          await beforeType();
+        } catch (error) {
+          preparationFailed = true;
+          throw error;
+        }
+        const afterPreparation = await chooserIsAbsent();
+        if (afterPreparation) return afterPreparation;
+      }
       await this.typeLiteral(target, text);
       await delay(ENTER_DELAY_MS);
       const beforeEnter = await chooserIsAbsent();
@@ -2924,6 +3257,7 @@ var PromptResponder = class {
       await this.sendKey(target, "Enter");
       return { ok: true };
     } catch (error) {
+      if (preparationFailed) throw error;
       return {
         ok: false,
         reason: "tmux-failed",
@@ -3056,6 +3390,16 @@ var MobilePromptDeduper = class {
     this.replaceEntries(sessionId, entries);
     return match;
   }
+  /** Inspect without spending the token before durable native admission. */
+  peekIfDuplicate(sessionId, echo) {
+    const normalized = this.normalize(echo);
+    if (!normalized) return null;
+    for (const entry of this.validEntries(sessionId)) {
+      const matchType = this.matchType(entry.normalized, normalized);
+      if (matchType) return { matchType, originalLength: entry.normalized.length, echoLength: normalized.length };
+    }
+    return null;
+  }
   // ─── Internals ──────────────────────────────────────────────────────────
   sweep() {
     const cutoff = this.now() - this.expiryMs;
@@ -3135,14 +3479,14 @@ function sanitizeErrorMessage(msg) {
   return out.trim().substring(0, 100);
 }
 function fireDaemonBeacon(name, params) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve2) => {
     let req;
     let settled = false;
     const settle = () => {
       if (settled) return;
       settled = true;
       clearTimeout(overall);
-      resolve3();
+      resolve2();
     };
     const overall = setTimeout(() => {
       try {
@@ -3212,7 +3556,7 @@ function fireDaemonBeacon(name, params) {
 
 // src/event-mapper.ts
 var import_uuid2 = require("uuid");
-var import_codevibe_core3 = require("@quantiya/codevibe-core");
+var import_codevibe_core4 = require("@quantiya/codevibe-core");
 var CONTENT_MAX = 150 * 1024;
 var TOOL_OUTPUT_MAX = 50 * 1024;
 var TOOL_DIFF_MAX = 100 * 1024;
@@ -3220,10 +3564,10 @@ function mapTranscriptEvent(emit, sessionId, notBeforeMs) {
   const { event } = emit;
   const base = {
     sessionId,
-    source: import_codevibe_core3.EventSource.DESKTOP
+    source: import_codevibe_core4.EventSource.DESKTOP
   };
   const orderingKey = `${sessionId}:${emit.conversationId}`;
-  const nextTimestamp = () => (0, import_codevibe_core3.prepareEventTimestamp)({ orderingKey, agentClock: event.created_at, notBeforeMs });
+  const nextTimestamp = () => (0, import_codevibe_core4.prepareEventTimestamp)({ orderingKey, agentClock: event.created_at, notBeforeMs });
   const baseMetadata = {
     step_index: event.step_index,
     agy_source: event.source,
@@ -3263,7 +3607,7 @@ function mapTranscriptEvent(emit, sessionId, notBeforeMs) {
         {
           ...base,
           timestamp: nextTimestamp(),
-          type: import_codevibe_core3.EventType.USER_PROMPT,
+          type: import_codevibe_core4.EventType.USER_PROMPT,
           content: truncate(cleaned, CONTENT_MAX),
           metadata: { ...baseMetadata }
         }
@@ -3278,7 +3622,7 @@ function mapTranscriptEvent(emit, sessionId, notBeforeMs) {
       events.push({
         ...base,
         timestamp: nextTimestamp(),
-        type: import_codevibe_core3.EventType.REASONING,
+        type: import_codevibe_core4.EventType.REASONING,
         content: truncate(event.thinking, CONTENT_MAX),
         metadata: { ...baseMetadata }
       });
@@ -3287,7 +3631,7 @@ function mapTranscriptEvent(emit, sessionId, notBeforeMs) {
       events.push({
         ...base,
         timestamp: nextTimestamp(),
-        type: import_codevibe_core3.EventType.ASSISTANT_RESPONSE,
+        type: import_codevibe_core4.EventType.ASSISTANT_RESPONSE,
         content: truncate(event.content, CONTENT_MAX),
         metadata: { ...baseMetadata }
       });
@@ -3324,7 +3668,7 @@ function mapTranscriptEvent(emit, sessionId, notBeforeMs) {
         {
           ...base,
           timestamp: nextTimestamp(),
-          type: import_codevibe_core3.EventType.NOTIFICATION,
+          type: import_codevibe_core4.EventType.NOTIFICATION,
           content: truncate(content, CONTENT_MAX),
           metadata: {
             ...baseMetadata,
@@ -3344,7 +3688,7 @@ function mapTranscriptEvent(emit, sessionId, notBeforeMs) {
       {
         ...base,
         timestamp: nextTimestamp(),
-        type: import_codevibe_core3.EventType.TOOL_USE,
+        type: import_codevibe_core4.EventType.TOOL_USE,
         content: formatToolResultContent(event.type, toolName, truncatedContent, isErrorStatus),
         metadata: {
           ...baseMetadata,
@@ -3502,7 +3846,7 @@ function truncate(s, maxBytes) {
 }
 
 // src/tool-activity-integration.ts
-var import_codevibe_core4 = require("@quantiya/codevibe-core");
+var import_codevibe_core5 = require("@quantiya/codevibe-core");
 var TOOL_ACTIVITY_CONTENT = "tool_activity";
 var DEFAULT_WINDOW_MS = 1e4;
 var DEFAULT_MAX_OCCURRENCES = 50;
@@ -3569,9 +3913,9 @@ function agyOccurrenceId(emit, matchedCall) {
     createdAt: emit.event.created_at,
     stepIndex: emit.event.step_index,
     type: emit.event.type,
-    contentDigest: (0, import_codevibe_core4.digestOf)(emit.event.content ?? "")
+    contentDigest: (0, import_codevibe_core5.digestOf)(emit.event.content ?? "")
   };
-  return `agy:${(0, import_codevibe_core4.digestOf)(identity).slice("sha256:".length)}`;
+  return `agy:${(0, import_codevibe_core5.digestOf)(identity).slice("sha256:".length)}`;
 }
 var AgyToolActivityIntegration = class {
   constructor(deps) {
@@ -3580,31 +3924,34 @@ var AgyToolActivityIntegration = class {
     this.sessionsToRehome = /* @__PURE__ */ new Set();
     this.deps = deps;
   }
-  isActive() {
-    return this.consolidator !== null;
+  isActive(sessionId) {
+    return this.consolidator !== null && (sessionId === void 0 || this.backendSessionId === sessionId);
   }
   async start(sessionId) {
     if (this.consolidator && this.backendSessionId === sessionId) return;
     if (this.consolidator) await this.stop();
-    const outbox = new import_codevibe_core4.ToolActivityOutbox({
+    const outbox = new import_codevibe_core5.ToolActivityOutbox({
       agent: "agy",
       logger: this.deps.logger,
       root: this.deps.root
     });
-    await this.rehomePendingWindows(outbox, sessionId);
-    const ledger = new import_codevibe_core4.ToolActivityLedger({
+    const ledger = new import_codevibe_core5.ToolActivityLedger({
       agent: "agy",
       sessionId,
       logger: this.deps.logger,
       root: this.deps.root
     });
-    const consolidator = new import_codevibe_core4.ToolActivityConsolidator({
+    await this.deps.recoverPending?.(sessionId, outbox, ledger);
+    const legacyTransport = this.buildTransport();
+    const transport = this.deps.selectTransport ? await this.deps.selectTransport(sessionId, legacyTransport) : legacyTransport;
+    if (transport.protocol !== "SYNC_V2") await this.rehomePendingWindows(outbox, sessionId);
+    const consolidator = new import_codevibe_core5.ToolActivityConsolidator({
       agent: "agy",
       sessionId,
       logger: this.deps.logger,
       outbox,
       ledger,
-      transport: this.buildTransport(),
+      transport,
       windowMs: this.deps.windowMs ?? DEFAULT_WINDOW_MS,
       maxOccurrences: DEFAULT_MAX_OCCURRENCES
     });
@@ -3636,7 +3983,7 @@ var AgyToolActivityIntegration = class {
       ...target ? { normalizedTarget: target } : {},
       ts: emit.event.created_at,
       byteOffset: emit.byteOffset,
-      ...inputIdentity ? { digest: (0, import_codevibe_core4.digestOf)(inputIdentity) } : {}
+      ...inputIdentity ? { digest: (0, import_codevibe_core5.digestOf)(inputIdentity) } : {}
     });
   }
   async flush() {
@@ -3686,7 +4033,8 @@ var AgyToolActivityIntegration = class {
         }
       }
       if (!eligible) continue;
-      for (const envelope of pending.valid) {
+      const legacyWindows = pending.valid.filter((envelope) => envelope.syncSessionGenerationId === void 0);
+      for (const envelope of legacyWindows) {
         const rehomed = { ...envelope, backendSessionId: replacementSessionId };
         await outbox.persist(replacementSessionId, rehomed);
         await outbox.prune(oldSessionId, envelope.clientEventId);
@@ -3695,7 +4043,7 @@ var AgyToolActivityIntegration = class {
       this.deps.logger.info("[tool-activity] Rehomed durable Agy windows", {
         oldSessionId,
         replacementSessionId,
-        count: pending.valid.length
+        count: legacyWindows.length
       });
     }
   }
@@ -3705,7 +4053,7 @@ var AgyToolActivityIntegration = class {
       if (!session || session.sessionId !== sessionId) {
         throw terminalSessionError(sessionId);
       }
-      const encrypted = (0, import_codevibe_core4.encryptForEmit)(
+      const encrypted = (0, import_codevibe_core5.encryptForEmit)(
         override?.sessionKey ?? session.sessionKey ?? null,
         session.sessionIsEncrypted ?? false,
         TOOL_ACTIVITY_CONTENT,
@@ -3717,8 +4065,8 @@ var AgyToolActivityIntegration = class {
       const sessionKeyGen = override?.sessionKeyGen ?? session.sessionKeyGen;
       const input = {
         sessionId,
-        type: import_codevibe_core4.EventType.TOOL_ACTIVITY,
-        source: import_codevibe_core4.EventSource.DESKTOP,
+        type: import_codevibe_core5.EventType.TOOL_ACTIVITY,
+        source: import_codevibe_core5.EventSource.DESKTOP,
         content: encrypted.content,
         metadata: encrypted.metadata,
         timestamp: envelope.windowStart,
@@ -3733,10 +4081,10 @@ var AgyToolActivityIntegration = class {
         try {
           await sendOnce(sessionId, envelope);
         } catch (error) {
-          if ((0, import_codevibe_core4.isTerminalSessionError)(error)) {
+          if ((0, import_codevibe_core5.isTerminalSessionError)(error)) {
             throw new Error(`[tool-activity] Agy session ${sessionId} retired; awaiting replacement`);
           }
-          if ((0, import_codevibe_core4.isSessionKeyStaleError)(error) && this.deps.refreshSessionKey) {
+          if ((0, import_codevibe_core5.isSessionKeyStaleError)(error) && this.deps.refreshSessionKey) {
             const refreshed = await this.deps.refreshSessionKey(sessionId);
             if (refreshed) {
               await sendOnce(sessionId, envelope, refreshed);
@@ -3798,8 +4146,12 @@ var McpServer = class _McpServer {
      *  under this single sessionId. /resume does NOT create a new
      *  session — same row. */
     this.session = null;
-    this.promptPublications = new import_codevibe_core5.PromptPublicationTracker();
+    this.promptPublications = new import_codevibe_core6.PromptPublicationTracker();
     this.transcriptHandlers = /* @__PURE__ */ new Set();
+    this.nativeSourceSelection = null;
+    this.nativeSources = /* @__PURE__ */ new Map();
+    this.nativeToolStart = null;
+    this.nativeAdmissionChain = Promise.resolve();
     this.toolActivityKeyRefresh = null;
     // E1 (§4/§6a-4) — per-promptId durable raise entries for the agy producer.
     // Keyed by the E1 promptId (= derive(ownerToken)); each holds the SECRET
@@ -3952,9 +4304,23 @@ var McpServer = class _McpServer {
     this.wrapperPid = options.wrapperPid ?? null;
     this.cliLogPath = options.cliLogPath ?? null;
     this.launchSettleTimeoutMs = options.launchSettleTimeoutMs ?? LAUNCH_SETTLE_TIMEOUT_MS;
-    this.appSyncClient = options.appSyncClient ?? new import_codevibe_core5.AppSyncClient();
+    this.appSyncClient = options.appSyncClient ?? new import_codevibe_core6.AppSyncClient();
     this.toolActivity = options.toolActivityIntegration === void 0 ? new AgyToolActivityIntegration({
       logger,
+      selectTransport: async (sessionId, legacyTransport) => {
+        const session = this.session;
+        if (!session || session.sessionId !== sessionId) throw Error("SYNC_SOURCE_OWNER_CHANGED");
+        const selection = await this.selectNativeSource(session);
+        if (this.session !== session || !this.started) throw Error("SYNC_SOURCE_OWNER_CHANGED");
+        return selection.protocol === "LEGACY" ? legacyTransport : this.appSyncClient.toolActivitySyncTransport({
+          sessionScope: selection.sessionScope,
+          getEncryptionContext: selection.getEncryptionContext
+        });
+      },
+      recoverPending: async (sessionId, outbox, ledger) => {
+        await this.appSyncClient.recoverCompanionSyncSources({ sessionId });
+        await this.appSyncClient.recoverToolActivityWindows({ sessionId, outbox, ledger });
+      },
       createEvent: (input) => this.appSyncClient.createEvent(input),
       getSession: () => this.session,
       refreshSessionKey: (sessionId) => this.refreshToolActivitySessionKey(sessionId),
@@ -3970,7 +4336,11 @@ var McpServer = class _McpServer {
     this.workingDirectory = process.cwd();
     this.approvalDetector = options.approvalDetector ?? new ApprovalDetector(options.detectorOptions);
     this.paneObserver = options.paneObserver ?? new TmuxPaneObserver();
-    this.transcriptTailer = options.transcriptTailer ?? new TranscriptTailer();
+    this.transcriptTailer = options.transcriptTailer ?? new TranscriptTailer({ admission: {
+      restore: (source, initial) => this.restoreNativeSource(source, initial),
+      admit: (emit, source) => this.admitNativeSource(emit, source),
+      skip: (gap, source) => this.skipNativeSource(gap, source)
+    } });
     this.mobileDeduper = options.mobileDeduper ?? new MobilePromptDeduper();
     this.promptResponder = options.promptResponder ?? new PromptResponder({
       tmuxTarget: this.tmuxTarget ?? void 0,
@@ -4005,7 +4375,7 @@ var McpServer = class _McpServer {
     const authed = await this.appSyncClient.authenticateWithStoredTokens();
     if (!authed) {
       const kind = this.appSyncClient.getLastAuthFailureKind();
-      const failure = (0, import_codevibe_core5.describeStoredAuthFailure)(
+      const failure = (0, import_codevibe_core6.describeStoredAuthFailure)(
         kind,
         this.appSyncClient.getLastAuthFailureDetail()
       );
@@ -4024,9 +4394,32 @@ var McpServer = class _McpServer {
     this.stopRequestedDuringCreate = false;
     this.registerSignalHandlers();
     this.startTmuxLifecycleMonitor();
-    await (0, import_codevibe_core5.registerDeviceEncryptionKey)(this.appSyncClient, logger);
+    try {
+      const statusUserId = this.appSyncClient.getCurrentUserId();
+      const signal = AbortSignal.timeout(5e3);
+      const timeout = new Promise((_, reject) => signal.addEventListener(
+        "abort",
+        () => reject(new Error("status read timed out")),
+        { once: true }
+      ));
+      const subscription = await Promise.race([this.appSyncClient.getSubscriptionStatus(signal), timeout]);
+      if (this.appSyncClient.getCurrentUserId() !== statusUserId) throw new Error("account changed during read");
+      const sync = await Promise.race([this.appSyncClient.getCompanionSyncState(signal), timeout]);
+      if (this.appSyncClient.getCurrentUserId() !== statusUserId) throw new Error("account changed during read");
+      if (subscription.tier !== sync.tier) throw new Error("tier changed during read");
+      logger.info("Standalone Companion sync status", {
+        tier: sync.tier,
+        protocol: sync.protocol,
+        syncState: sync.usage?.syncState ?? null,
+        resetAtEpochMs: sync.resetAtEpochMs
+      });
+    } catch {
+      logger.warn("Standalone Companion sync status unavailable; cloud admission remains authoritative");
+    }
     if (!this.started) return { httpPort: 0 };
-    (0, import_codevibe_core5.startDeviceKeyWatcher)(this.appSyncClient, logger);
+    await (0, import_codevibe_core6.registerDeviceEncryptionKey)(this.appSyncClient, logger);
+    if (!this.started) return { httpPort: 0 };
+    (0, import_codevibe_core6.startDeviceKeyWatcher)(this.appSyncClient, logger);
     try {
       const swept = await this.appSyncClient.sweepOrphanSessions({
         agentType: "ANTIGRAVITY",
@@ -4126,8 +4519,8 @@ var McpServer = class _McpServer {
     let hostedRetirementError = null;
     if (launchSettlement) {
       let timer;
-      const timeout = new Promise((resolve3) => {
-        timer = setTimeout(resolve3, this.launchSettleTimeoutMs);
+      const timeout = new Promise((resolve2) => {
+        timer = setTimeout(resolve2, this.launchSettleTimeoutMs);
         timer.unref?.();
       });
       try {
@@ -4166,6 +4559,9 @@ var McpServer = class _McpServer {
     }
     this.listenerHandles = [];
     await Promise.allSettled([...this.transcriptHandlers]);
+    await this.transcriptTailer.waitForReads();
+    await this.nativeAdmissionChain;
+    await this.stopNativeSources();
     if (this.session) {
       try {
         this.appSyncClient.stopHeartbeat(this.session.sessionId);
@@ -4176,7 +4572,7 @@ var McpServer = class _McpServer {
       } catch (err) {
         logger.warn("[tool-activity] Agy shutdown drain failed", { error: String(err) });
       }
-      const retired = await this.deactivateLaunchRow(this.session.sessionId);
+      const retired = await this.deactivateLaunchRow(this.session.sessionId, this.session);
       if (retired) this.durableObligationOpen = false;
       if (!retired) {
         hostedRetirementError = new Error(
@@ -4258,7 +4654,7 @@ var McpServer = class _McpServer {
    * their settlement marker/obligation alive on `false` instead of treating the
    * attempt as completion. The log stays inside so no failure is ever silent.
    */
-  async deactivateLaunchRow(sessionId) {
+  async deactivateLaunchRow(sessionId, quiescentSession) {
     try {
       this.appSyncClient.stopHeartbeat(sessionId);
     } catch (error) {
@@ -4269,7 +4665,14 @@ var McpServer = class _McpServer {
     }
     for (let attempt = 1; attempt <= SESSION_RETIRE_MAX_ATTEMPTS; attempt += 1) {
       try {
-        await this.appSyncClient.updateSession({ sessionId, status: "INACTIVE" });
+        const retired = await this.appSyncClient.updateSession({ sessionId, status: "INACTIVE" });
+        if (quiescentSession && retired?.sessionGenerationId) {
+          await this.appSyncClient.completeDesktopSyncRetirement({ sessionId }, retired, async () => {
+            await Promise.allSettled([...this.transcriptHandlers]);
+            await this.nativeAdmissionChain;
+            await this.stopNativeSources(quiescentSession);
+          });
+        }
         logger.info("Marked superseded/interrupted launch session INACTIVE", { sessionId });
         return true;
       } catch (err) {
@@ -4280,7 +4683,7 @@ var McpServer = class _McpServer {
           error: String(err)
         });
         if (attempt < SESSION_RETIRE_MAX_ATTEMPTS) {
-          await new Promise((resolve3) => setTimeout(resolve3, SESSION_RETIRE_RETRY_MS * attempt));
+          await new Promise((resolve2) => setTimeout(resolve2, SESSION_RETIRE_RETRY_MS * attempt));
         }
       }
     }
@@ -4313,7 +4716,7 @@ var McpServer = class _McpServer {
     let sessionKey = null;
     let sessionKeyGen = null;
     try {
-      const result = await (0, import_codevibe_core5.resumeOrCreateSession)(
+      const result = await (0, import_codevibe_core6.resumeOrCreateSession)(
         {
           sessionId,
           userId,
@@ -4399,8 +4802,9 @@ var McpServer = class _McpServer {
       const stop = this.appSyncClient.subscribeToEvents(
         sessionId,
         (evt) => {
-          void this.handleMobileEvent(evt).catch((err) => {
+          return this.handleMobileEvent(evt).catch((err) => {
             logger.error("handleMobileEvent failed", { error: String(err) });
+            if ((0, import_codevibe_core6.requiresSyncInputDeliveryReceipt)(evt)) throw err;
           });
         },
         (err) => logger.warn("AppSync subscription error", { error: String(err) }),
@@ -4482,7 +4886,7 @@ var McpServer = class _McpServer {
     return activeId === conversationId;
   }
   // ─── Transcript flow ────────────────────────────────────────────────────
-  async handleTranscriptEmit(emit) {
+  async handleTranscriptEmit(emit, admission) {
     if (!this.started) return;
     const { conversationId, byteOffset, event } = emit;
     if (this.sessionDisabled) {
@@ -4508,14 +4912,18 @@ var McpServer = class _McpServer {
       }
     }
     const mapped = mapTranscriptEvent(emit, session.sessionId, notBeforeMs);
+    if (admission && (mapped.events.length > 2 || mapped.events.some((input) => !["USER_PROMPT", "ASSISTANT_RESPONSE", "REASONING", "TOOL_USE", "NOTIFICATION"].includes(input.type)))) {
+      throw Error("SYNC_NATIVE_SPECIALIZED_PRODUCER_REQUIRED");
+    }
     for (const reg of mapped.pendingCallRegistrations) {
       this.approvalDetector.registerPendingCall(reg);
     }
-    for (const input of mapped.events) {
-      if (input.type === import_codevibe_core5.EventType.USER_PROMPT || input.type === import_codevibe_core5.EventType.ASSISTANT_RESPONSE || input.type === import_codevibe_core5.EventType.NOTIFICATION) {
-        await this.flushToolActivityAtBoundary(input.type);
+    for (const [index, input] of mapped.events.entries()) {
+      if (input.type === import_codevibe_core6.EventType.USER_PROMPT || input.type === import_codevibe_core6.EventType.ASSISTANT_RESPONSE || input.type === import_codevibe_core6.EventType.NOTIFICATION) {
+        if (admission) await this.toolActivity.flush();
+        else await this.flushToolActivityAtBoundary(input.type);
       }
-      if (input.type === import_codevibe_core5.EventType.TOOL_USE && typeof input.metadata === "object" && input.metadata) {
+      if (input.type === import_codevibe_core6.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;
@@ -4532,6 +4940,7 @@ var McpServer = class _McpServer {
               continue;
             }
           } catch (error) {
+            if (admission) throw error;
             logger.warn("[tool-activity] Agy result observation failed; emitting raw TOOL_USE fallback", {
               sessionId: session.sessionId,
               conversationId,
@@ -4541,11 +4950,12 @@ var McpServer = class _McpServer {
           }
         }
       }
-      if (input.type === import_codevibe_core5.EventType.USER_PROMPT && input.source === import_codevibe_core5.EventSource.DESKTOP) {
+      if (input.type === import_codevibe_core6.EventType.USER_PROMPT && input.source === import_codevibe_core6.EventSource.DESKTOP) {
         const clearedPromptIds = this.approvalDetector.onPanePromptCleared();
         await this.resolveAcceptedInputPrompts(session, clearedPromptIds);
-        const dedupe = this.mobileDeduper.consumeIfDuplicate(session.sessionId, input.content);
+        const dedupe = admission ? null : this.mobileDeduper.consumeIfDuplicate(session.sessionId, input.content);
         if (dedupe) {
+          if (admission) admission.echoContent = input.content;
           logger.info("Suppressed desktop echo of mobile prompt", {
             sessionId: session.sessionId,
             matchType: dedupe.matchType
@@ -4553,6 +4963,10 @@ var McpServer = class _McpServer {
           continue;
         }
       }
+      if (admission) {
+        admission.outputs[index] = input;
+        continue;
+      }
       try {
         if (!await this.createEncryptedEvent(session, input)) continue;
       } catch (err) {
@@ -4564,6 +4978,161 @@ var McpServer = class _McpServer {
       }
     }
   }
+  selectNativeSource(session) {
+    if (!this.started || this.session !== session) return Promise.reject(Error("SYNC_SOURCE_OWNER_CHANGED"));
+    if (this.nativeSourceSelection?.session === session) return this.nativeSourceSelection.pending;
+    const pending = this.appSyncClient.selectCompanionSourceTransport({ sessionId: session.sessionId });
+    const selected = { session, pending };
+    this.nativeSourceSelection = selected;
+    void pending.catch(() => {
+      if (this.nativeSourceSelection === selected) this.nativeSourceSelection = null;
+    });
+    return pending;
+  }
+  assertNativeOwner(owner) {
+    if (!this.started || this.sessionDisabled || this.session !== owner.session || owner.controller.signal.aborted) {
+      throw Error("SYNC_SOURCE_OWNER_CHANGED");
+    }
+  }
+  async nativeOwner(source) {
+    if (!this.started || this.sessionDisabled) throw Error("SYNC_SOURCE_STOPPED");
+    await this.ensureLaunchSession();
+    const session = this.session;
+    if (!session || !this.isMainConversation(source.conversationId)) throw Error("SYNC_SOURCE_OWNERSHIP_UNAVAILABLE");
+    const selection = await this.selectNativeSource(session);
+    if (!this.started || this.session !== session) throw Error("SYNC_SOURCE_OWNER_CHANGED");
+    if (selection.protocol === "LEGACY") return null;
+    if (!this.toolActivity?.isActive(session.sessionId)) {
+      if (this.nativeToolStart && this.nativeToolStart.session !== session) throw Error("SYNC_SOURCE_OWNER_CHANGED");
+      if (!this.nativeToolStart) {
+        const start = this.toolActivity ? this.toolActivity.start(session.sessionId) : Promise.reject(Error("SYNC_SOURCE_OWNERSHIP_UNAVAILABLE"));
+        const attempt = { session, pending: start };
+        this.nativeToolStart = attempt;
+        void start.finally(() => {
+          if (this.nativeToolStart === attempt) this.nativeToolStart = null;
+        }).catch(() => void 0);
+      }
+      await this.nativeToolStart.pending;
+    }
+    if (!this.toolActivity?.isActive(session.sessionId) || this.session !== session || !this.started) throw Error("SYNC_SOURCE_OWNERSHIP_UNAVAILABLE");
+    const streamSha256 = crypto3.createHash("sha256").update(JSON.stringify([source.filePath, source.conversationId])).digest("hex");
+    const key = `${selection.sessionScope.sessionId}:${selection.sessionScope.sessionGenerationId}:${streamSha256}`;
+    const existing = this.nativeSources.get(key);
+    if (existing) {
+      this.assertNativeOwner(existing);
+      return existing;
+    }
+    const owner = {
+      session,
+      selection,
+      streamSha256,
+      cursor: selection.writer.sourcePair({ provider: "agy", streamSha256 }),
+      controller: new AbortController(),
+      drain: null,
+      drainRequested: false,
+      timer: null,
+      retryMs: 5e3
+    };
+    this.nativeSources.set(key, owner);
+    return owner;
+  }
+  async restoreNativeSource(source, initial) {
+    const owner = await this.nativeOwner(source);
+    if (!owner) return null;
+    const position = await owner.cursor.open(initial);
+    this.assertNativeOwner(owner);
+    await owner.selection.writer.mobileEchoes("agy").reconcile(owner.streamSha256, position.byteOffset);
+    this.drainNativeSource(owner);
+    return position;
+  }
+  async skipNativeSource(gap, source) {
+    const owner = await this.nativeOwner(source);
+    if (!owner) throw Error("SYNC_SOURCE_PROTOCOL_CHANGED");
+    await owner.cursor.skip(gap);
+    this.assertNativeOwner(owner);
+  }
+  async admitNativeSource(emit, source) {
+    const owner = await this.nativeOwner(source);
+    if (!owner) throw Error("SYNC_SOURCE_PROTOCOL_CHANGED");
+    const run = this.nativeAdmissionChain.then(async () => {
+      this.assertNativeOwner(owner);
+      if ((await owner.cursor.open(0)).byteOffset >= source.endOffset) return;
+      const admission = { outputs: [null, null] };
+      await this.handleTranscriptEmit(emit, admission);
+      this.assertNativeOwner(owner);
+      const echoFrame = {
+        streamSha256: owner.streamSha256,
+        occurrence: `${source.startOffset}:${source.endOffset}`,
+        sourceSha256: source.sha256,
+        startOffset: source.startOffset,
+        endOffset: source.endOffset
+      };
+      const echoes = owner.selection.writer.mobileEchoes("agy");
+      for (let index = 0; index < admission.outputs.length; index++) {
+        const input = admission.outputs[index];
+        if (input?.type === import_codevibe_core6.EventType.USER_PROMPT && await echoes.claim(echoFrame, input.content, emit.event.created_at)) admission.outputs[index] = null;
+      }
+      const factory = (index) => {
+        const input = admission.outputs[index];
+        return input ? (id) => owner.selection.prepareEvent(input, id) : null;
+      };
+      await owner.cursor.admit({
+        provider: "agy",
+        streamSha256: owner.streamSha256,
+        occurrence: `${source.startOffset}:${source.endOffset}`,
+        sourceSha256: source.sha256,
+        startOffset: source.startOffset,
+        endOffset: source.endOffset,
+        anchor: source.anchor
+      }, [factory(0), factory(1)]);
+      this.assertNativeOwner(owner);
+      await echoes.reconcile(owner.streamSha256, source.endOffset);
+      this.drainNativeSource(owner);
+    });
+    this.nativeAdmissionChain = run.catch((error) => {
+      logger.warn("[sync-source] Agy admission retained", { error: String(error) });
+    });
+    await run;
+  }
+  drainNativeSource(owner) {
+    if (!this.started || this.session !== owner.session || owner.controller.signal.aborted) return;
+    owner.drainRequested = true;
+    if (owner.drain || owner.timer) return;
+    owner.drainRequested = false;
+    const run = (async () => {
+      let failed = false;
+      try {
+        if (await owner.cursor.drain(64, owner.controller.signal) >= 64) owner.drainRequested = true;
+        owner.retryMs = 5e3;
+      } catch (error) {
+        failed = true;
+        owner.retryMs = Math.min(owner.retryMs * 2, 6e4);
+        if (!owner.controller.signal.aborted) logger.warn("[sync-source] Agy delivery retained", { error: String(error) });
+      }
+      owner.drain = null;
+      if (!this.started || this.session !== owner.session || owner.controller.signal.aborted) return;
+      if (failed) {
+        owner.timer = setTimeout(() => {
+          owner.timer = null;
+          this.drainNativeSource(owner);
+        }, owner.retryMs);
+        owner.timer.unref();
+      } else if (owner.drainRequested) this.drainNativeSource(owner);
+    })();
+    owner.drain = run;
+    void run.catch((error) => logger.error("[sync-source] unexpected Agy drain failure", { error: String(error) }));
+  }
+  async stopNativeSources(session) {
+    const owned = [...this.nativeSources].filter(([, owner]) => !session || owner.session === session);
+    for (const [, owner] of owned) {
+      if (owner.timer) clearTimeout(owner.timer);
+      owner.timer = null;
+      owner.controller.abort(Error("SYNC_SOURCE_STOPPED"));
+    }
+    await Promise.all(owned.map(([, owner]) => owner.drain?.catch(() => void 0)));
+    for (const [key] of owned) this.nativeSources.delete(key);
+    if (!session || this.nativeSourceSelection?.session === session) this.nativeSourceSelection = null;
+  }
   async flushToolActivityAtBoundary(boundary) {
     try {
       await this.toolActivity?.flush();
@@ -4593,18 +5162,18 @@ var McpServer = class _McpServer {
     const expectedSession = this.session;
     try {
       const session = await this.appSyncClient.getSession(sessionId);
-      if (session?.status === import_codevibe_core5.SessionStatus.INACTIVE) {
+      if (session?.status === import_codevibe_core6.SessionStatus.INACTIVE) {
         const terminal = new Error(`Antigravity session is no longer active: ${sessionId}`);
         terminal.errorType = "SessionTerminal";
         throw terminal;
       }
-      if (!session || session.status !== import_codevibe_core5.SessionStatus.ACTIVE || !session.isEncrypted) {
+      if (!session || session.status !== import_codevibe_core6.SessionStatus.ACTIVE || !session.isEncrypted) {
         return null;
       }
       const sessionKeyGen = session.sessionKeyGen ?? null;
       const encryptedKeys = session.encryptedKeys ?? [];
       if (encryptedKeys.length === 0) return null;
-      const sessionKey = await import_codevibe_core5.keychainManager.getSessionKey(
+      const sessionKey = await import_codevibe_core6.keychainManager.getSessionKey(
         sessionId,
         encryptedKeys,
         sessionKeyGen
@@ -4617,7 +5186,7 @@ var McpServer = class _McpServer {
       liveSession.sessionIsEncrypted = true;
       return { sessionKey, sessionKeyGen };
     } catch (error) {
-      if ((0, import_codevibe_core5.isTerminalSessionError)(error)) throw error;
+      if ((0, import_codevibe_core6.isTerminalSessionError)(error)) throw error;
       logger.warn("[tool-activity] Agy session-key refresh failed; window remains retryable", {
         sessionId,
         error: String(error)
@@ -4637,7 +5206,7 @@ var McpServer = class _McpServer {
    * an encrypted keyless one (drop).
    */
   encryptOutbound(session, input) {
-    const enc = (0, import_codevibe_core5.encryptForEmit)(
+    const enc = (0, import_codevibe_core6.encryptForEmit)(
       session.sessionKey ?? null,
       session.sessionIsEncrypted ?? false,
       input.content,
@@ -4667,7 +5236,7 @@ var McpServer = class _McpServer {
     const promptId = input.producerKind === "PLUGIN_APPROVAL" ? input.promptId : void 0;
     const promptEntry = promptId ? this.e1PromptRaises.get(promptId) : void 0;
     const sendOnce = async () => {
-      if (promptId && !(0, import_codevibe_core5.isOpenPromptRaise)(
+      if (promptId && !(0, import_codevibe_core6.isOpenPromptRaise)(
         promptEntry,
         this.e1PromptRaises.get(promptId),
         this.e1NeedsResolution.has(promptId)
@@ -4680,7 +5249,7 @@ var McpServer = class _McpServer {
     try {
       return await sendOnce();
     } catch (error) {
-      if (!(0, import_codevibe_core5.isSessionKeyStaleError)(error)) throw error;
+      if (!(0, import_codevibe_core6.isSessionKeyStaleError)(error)) throw error;
       const refreshed = await this.refreshToolActivitySessionKey(session.sessionId);
       if (!refreshed) throw error;
       return sendOnce();
@@ -4701,7 +5270,7 @@ var McpServer = class _McpServer {
    * NOTIFICATION carrier, no fabricated options).
    */
   newE1Raise(sessionId, mobileActionable, title) {
-    const { record } = (0, import_codevibe_core5.newPromptRaise)({
+    const { record } = (0, import_codevibe_core6.newPromptRaise)({
       sessionId,
       producerKind: "PLUGIN_APPROVAL",
       mobileActionable,
@@ -4737,14 +5306,12 @@ var McpServer = class _McpServer {
     const operation = (async () => {
       try {
         if (this.promptPublications.isPublishing(promptId)) await this.promptPublications.waitFor(promptId);
-        const ack = await this.appSyncClient.createEvent({
+        const acknowledged = await this.appSyncClient.resolveCompanionPrompt({
           sessionId: entry.record.sessionId || sessionId,
-          type: import_codevibe_core5.EventType.NOTIFICATION,
-          source: import_codevibe_core5.EventSource.DESKTOP,
-          resolvedPromptId: promptId,
+          promptId,
           ownerToken: entry.record.ownerToken
         });
-        if (ack?.promptId !== promptId) return false;
+        if (!acknowledged) return false;
         this.e1NeedsResolution.delete(promptId);
         this.e1NeedsReRaise.delete(promptId);
         this.e1PromptRaises.delete(promptId);
@@ -4797,27 +5364,43 @@ var McpServer = class _McpServer {
    * Content is E2E-encrypted; the raise identity rides plaintext top-level.
    * Fail-closed on a missing session key — never cleartext.
    */
-  async emitSuppressedPromptCarrier(session, record, customBannerText) {
+  async emitSuppressedPromptCarrier(session, record, reRaiseToken, customBannerText) {
     const bannerText = customBannerText || "\u26A0\uFE0F A prompt is waiting in your desktop terminal, but its options could not be shown here. Please answer it on your desktop.";
     const input = {
       sessionId: session.sessionId,
-      type: import_codevibe_core5.EventType.NOTIFICATION,
-      source: import_codevibe_core5.EventSource.DESKTOP,
+      type: import_codevibe_core6.EventType.NOTIFICATION,
+      source: import_codevibe_core6.EventSource.DESKTOP,
       content: bannerText,
       metadata: {
         e1SuppressedPrompt: true
       },
-      ...(0, import_codevibe_core5.raiseFieldsFromRecord)(record),
+      ...(0, import_codevibe_core6.raiseFieldsFromRecord)(record),
       notificationText: bannerText,
-      timestamp: (0, import_codevibe_core5.prepareEventTimestamp)({ orderingKey: session.sessionId })
+      timestamp: (0, import_codevibe_core6.prepareEventTimestamp)({ orderingKey: session.sessionId })
     };
-    await this.flushToolActivityAtBoundary(import_codevibe_core5.EventType.NOTIFICATION);
-    if (!await this.createEncryptedEvent(session, input)) return false;
-    logger.info("E1: emitted suppressed-prompt badge carrier (mobileActionable=false)", {
-      sessionId: session.sessionId,
-      promptId: record.promptId
-    });
-    return true;
+    await this.flushToolActivityAtBoundary(import_codevibe_core6.EventType.NOTIFICATION);
+    return this.publishE1Prompt(session, input, reRaiseToken);
+  }
+  async publishE1Prompt(session, input, reRaiseToken) {
+    const promptId = input.promptId, entry = promptId ? this.e1PromptRaises.get(promptId) : void 0;
+    if (!promptId || !(0, import_codevibe_core6.isOpenPromptRaise)(entry, this.e1PromptRaises.get(promptId), this.e1NeedsResolution.has(promptId))) return "CLOSED";
+    if (!this.started || this.session !== session || input.sessionId !== session.sessionId) return "RETRY";
+    const { notificationText: _legacyHint, ...plain } = input;
+    const settle = (disposition) => {
+      if ((0, import_codevibe_core6.isOpenPromptRaise)(entry, this.e1PromptRaises.get(promptId), this.e1NeedsResolution.has(promptId))) {
+        if (disposition === "RETRY") this.e1NeedsReRaise.add(promptId);
+        else if (disposition === "RERAISED" || disposition === "OMITTED") this.e1NeedsReRaise.delete(promptId);
+      }
+      return disposition;
+    };
+    return this.promptPublications.run(promptId, () => this.appSyncClient.publishCompanionPrompt(
+      plain,
+      async () => !!await this.createEncryptedEvent(session, input),
+      { reRaiseToken }
+    ).then(settle, (error) => {
+      settle("RETRY");
+      throw error;
+    }));
   }
   /**
    * E1 (§6a-2b) — badge-only raise for a SUPPRESSED prompt, applying the content-key
@@ -4842,7 +5425,7 @@ var McpServer = class _McpServer {
         entry.contentPlain = customBannerText;
       }
     }
-    this.emitSuppressedPromptCarrier(session, record, customBannerText).catch((e) => {
+    this.emitSuppressedPromptCarrier(session, record, void 0, customBannerText).catch((e) => {
       logger.error("E1: failed to emit suppressed-prompt badge carrier", {
         sessionId: session.sessionId,
         promptId: record.promptId,
@@ -4879,8 +5462,8 @@ var McpServer = class _McpServer {
         ...snap.metadataPlain !== void 0 && { metadataPlain: snap.metadataPlain }
       };
       this.e1PromptRaises.set(entry.record.promptId, entry);
-      const acked = await this.reRaiseOneE1(replacementSession, entry, opts);
-      if (!acked && !entry.resolutionStarted) unacked.push(snap);
+      const disposition = await this.reRaiseOneE1(replacementSession, entry, opts);
+      if (disposition !== "RERAISED" && disposition !== "OMITTED" && !entry.resolutionStarted) unacked.push(snap);
     }
     if (!this.e1TtlRefreshTimer) this.startE1TtlRefresh();
     return unacked;
@@ -4940,7 +5523,7 @@ var McpServer = class _McpServer {
       if (this.reRaiseSuperseded(gen)) return;
       const slice = Math.min(50, deadline - Date.now());
       if (slice <= 0) return;
-      await new Promise((resolve3) => setTimeout(resolve3, slice));
+      await new Promise((resolve2) => setTimeout(resolve2, slice));
     }
   }
   /**
@@ -4968,57 +5551,65 @@ var McpServer = class _McpServer {
    */
   async reRaiseOneE1(session, entry, opts) {
     const rec = entry.record;
-    if (this.e1NeedsResolution.has(rec.promptId)) return false;
-    if (!(0, import_codevibe_core5.canRecoverPromptRaise)(entry, this.promptPublications.isPublishing(rec.promptId))) {
-      return false;
+    if (this.e1NeedsResolution.has(rec.promptId)) return "CLOSED";
+    if (!(0, import_codevibe_core6.canRecoverPromptRaise)(entry, this.promptPublications.isPublishing(rec.promptId))) {
+      return "RETRY";
     }
     const actionable = rec.mobileActionable && entry.contentPlain !== void 0;
     const retryUntilAck = opts?.retryUntilAck === true;
     const gen = opts?.gen;
     const MAX_ATTEMPTS = 4;
     for (let attempt = 1; ; attempt++) {
-      if (!(0, import_codevibe_core5.isOpenPromptRaise)(
+      if (!(0, import_codevibe_core6.isOpenPromptRaise)(
         entry,
         this.e1PromptRaises.get(rec.promptId),
         this.e1NeedsResolution.has(rec.promptId)
-      )) return false;
+      )) return "CLOSED";
       if (retryUntilAck && this.reRaiseSuperseded(gen)) {
         this.e1NeedsReRaise.add(rec.promptId);
         logger.warn("E1: block-until-ack re-raise aborted (lifecycle superseded/stopping) \u2014 flagged for retry-until-ack (entry retained)", {
           sessionId: session.sessionId,
           promptId: rec.promptId
         });
-        return false;
+        return "RETRY";
       }
       try {
+        let disposition;
         if (actionable) {
           const input = {
             sessionId: session.sessionId,
-            type: import_codevibe_core5.EventType.INTERACTIVE_PROMPT,
-            source: import_codevibe_core5.EventSource.DESKTOP,
+            type: import_codevibe_core6.EventType.INTERACTIVE_PROMPT,
+            source: import_codevibe_core6.EventSource.DESKTOP,
             content: entry.contentPlain,
             metadata: entry.metadataPlain ?? {},
-            ...(0, import_codevibe_core5.raiseFieldsFromRecord)(rec),
-            timestamp: (0, import_codevibe_core5.prepareEventTimestamp)({ orderingKey: session.sessionId })
+            ...(0, import_codevibe_core6.raiseFieldsFromRecord)(rec),
+            timestamp: (0, import_codevibe_core6.prepareEventTimestamp)({ orderingKey: session.sessionId })
           };
-          await this.flushToolActivityAtBoundary(import_codevibe_core5.EventType.INTERACTIVE_PROMPT);
-          if (!(0, import_codevibe_core5.isOpenPromptRaise)(
+          await this.flushToolActivityAtBoundary(import_codevibe_core6.EventType.INTERACTIVE_PROMPT);
+          if (!(0, import_codevibe_core6.isOpenPromptRaise)(
             entry,
             this.e1PromptRaises.get(rec.promptId),
             this.e1NeedsResolution.has(rec.promptId)
-          )) return false;
-          if (!await this.createEncryptedEvent(session, input)) return false;
+          )) return "CLOSED";
+          disposition = await this.publishE1Prompt(session, input, opts?.reRaiseToken);
         } else {
           rec.mobileActionable = false;
-          if (!await this.emitSuppressedPromptCarrier(session, rec, entry.contentPlain)) return false;
+          disposition = await this.emitSuppressedPromptCarrier(
+            session,
+            rec,
+            opts?.reRaiseToken,
+            entry.contentPlain
+          );
         }
+        if (disposition === "CLOSED" || disposition === "RETRY") return disposition;
         this.e1NeedsReRaise.delete(rec.promptId);
-        logger.info("E1: re-raised prompt onto replacement session", {
+        logger.info("E1: prompt publication settled", {
           sessionId: session.sessionId,
           promptId: rec.promptId,
-          actionable
+          actionable,
+          disposition
         });
-        return true;
+        return disposition;
       } catch (e) {
         if (!retryUntilAck && attempt >= MAX_ATTEMPTS) {
           this.e1NeedsReRaise.add(rec.promptId);
@@ -5027,7 +5618,7 @@ var McpServer = class _McpServer {
             promptId: rec.promptId,
             error: e instanceof Error ? e.message : String(e)
           });
-          return false;
+          return "RETRY";
         }
         if (retryUntilAck) {
           const delay2 = Math.min(
@@ -5036,7 +5627,7 @@ var McpServer = class _McpServer {
           );
           await this.interruptibleBackoff(delay2, gen);
         } else {
-          await new Promise((resolve3) => setTimeout(resolve3, 250 * attempt));
+          await new Promise((resolve2) => setTimeout(resolve2, 250 * attempt));
         }
       }
     }
@@ -5075,16 +5666,14 @@ var McpServer = class _McpServer {
     const session = this.session;
     if (!session) return;
     const sid = session.sessionId;
-    const promptIds = [...this.e1PromptRaises.values()].filter((e) => e.record.sessionId === sid && !this.e1NeedsResolution.has(e.record.promptId) && (0, import_codevibe_core5.canRecoverPromptRaise)(e, this.promptPublications.isPublishing(e.record.promptId))).map((e) => e.record.promptId);
+    const promptIds = [...this.e1PromptRaises.values()].filter((e) => e.record.sessionId === sid && !this.e1NeedsResolution.has(e.record.promptId) && (0, import_codevibe_core6.canRecoverPromptRaise)(e, this.promptPublications.isPublishing(e.record.promptId))).map((e) => e.record.promptId);
     if (promptIds.length === 0) return;
     try {
-      const agedOut = await this.appSyncClient.refreshOpenPromptTtl(promptIds);
-      for (const promptId of agedOut) {
+      await this.appSyncClient.refreshSessionOpenPromptTtl({ sessionId: sid, promptIds }, async (promptId, reRaiseToken) => {
         const entry = this.e1PromptRaises.get(promptId);
-        if (entry && this.session && entry.record.sessionId === this.session.sessionId) {
-          await this.reRaiseOneE1(this.session, entry);
-        }
-      }
+        if (!entry || this.session !== session || entry.record.sessionId !== sid || this.e1NeedsResolution.has(promptId)) return "CLOSED";
+        return this.reRaiseOneE1(session, entry, { reRaiseToken });
+      });
     } catch (e) {
       logger.warn("E1: TTL-refresh tick failed (non-fatal, retries next tick)", {
         error: e instanceof Error ? e.message : String(e)
@@ -5145,6 +5734,7 @@ var McpServer = class _McpServer {
         }
         this.subscription = null;
       }
+      await this.stopNativeSources(old);
       try {
         await this.toolActivity?.prepareForReplacement();
       } catch (error) {
@@ -5187,10 +5777,10 @@ var McpServer = class _McpServer {
     }
     const result = { ...evt };
     try {
-      result.content = import_codevibe_core5.cryptoService.decryptContent(evt.content, session.sessionKey);
+      result.content = import_codevibe_core6.cryptoService.decryptContent(evt.content, session.sessionKey);
       const rawMeta = parseMaybeJson(evt.metadata);
       if (rawMeta && typeof rawMeta === "object" && typeof rawMeta.encrypted === "string") {
-        const decryptedMeta = import_codevibe_core5.cryptoService.decryptMetadata(
+        const decryptedMeta = import_codevibe_core6.cryptoService.decryptMetadata(
           rawMeta.encrypted,
           session.sessionKey
         );
@@ -5314,35 +5904,35 @@ var McpServer = class _McpServer {
     const content = state.paneDisplayHeader || state.matchedPaneHeader || state.pendingCall?.command || state.pendingCall?.filePath || "approval requested";
     const input = {
       sessionId: session.sessionId,
-      type: import_codevibe_core5.EventType.INTERACTIVE_PROMPT,
-      source: import_codevibe_core5.EventSource.DESKTOP,
+      type: import_codevibe_core6.EventType.INTERACTIVE_PROMPT,
+      source: import_codevibe_core6.EventSource.DESKTOP,
       content,
       metadata: optionsForMobile,
       // E1 (§4) — raise identity top-level: promptId + ownerToken/producerKind/
       // mobileActionable (the backend's classifyRaise upserts the open-prompt row).
-      ...(0, import_codevibe_core5.raiseFieldsFromRecord)(e1rec),
+      ...(0, import_codevibe_core6.raiseFieldsFromRecord)(e1rec),
       // Per-conversation monotonic timestamp (event-timestamp-ordering fix
       // v5.4, 2026-05-24). orderingKey scopes the counter to this conv so
       // INTERACTIVE_PROMPT can't be forced to lastMs+1 by a newer event
       // from a sibling conversation under v9's multi-conv-per-session
       // model.
-      timestamp: (0, import_codevibe_core5.prepareEventTimestamp)({
+      timestamp: (0, import_codevibe_core6.prepareEventTimestamp)({
         orderingKey: `${session.sessionId}:${state.conversationId}`
       })
     };
     try {
       this.stashE1RaiseContent(e1rec.promptId, content, optionsForMobile);
-      await this.flushToolActivityAtBoundary(import_codevibe_core5.EventType.INTERACTIVE_PROMPT);
+      await this.flushToolActivityAtBoundary(import_codevibe_core6.EventType.INTERACTIVE_PROMPT);
       if (this.e1NeedsResolution.has(e1rec.promptId) || this.e1PromptRaises.get(e1rec.promptId)?.record !== e1rec) return;
-      if (!await this.createEncryptedEvent(session, input)) return;
+      await this.publishE1Prompt(session, input);
     } catch (err) {
       logger.error("createEvent INTERACTIVE_PROMPT failed", {
         promptId: state.promptId,
         error: String(err)
       });
-      this.approvalDetector.rollbackPrompt(state.promptId);
-      if (state.paneHash) this.paneObserver.resetPromptHash(state.paneHash);
-      this.e1PromptRaises.delete(state.promptId);
+      if (this.e1PromptRaises.get(e1rec.promptId)?.record === e1rec && !this.e1NeedsResolution.has(e1rec.promptId)) {
+        this.e1NeedsReRaise.add(e1rec.promptId);
+      }
     }
   }
   // ─── Mobile → desktop flow ──────────────────────────────────────────────
@@ -5380,7 +5970,7 @@ var McpServer = class _McpServer {
       if (shouldDecrypt && sessionKey) {
         try {
           logger.info("Decrypting attachment", { id: attachment.id });
-          buffer = import_codevibe_core5.cryptoService.decryptData(buffer, sessionKey);
+          buffer = import_codevibe_core6.cryptoService.decryptData(buffer, sessionKey);
           logger.info("Attachment decrypted successfully", {
             id: attachment.id,
             decryptedSize: buffer.length
@@ -5435,7 +6025,7 @@ var McpServer = class _McpServer {
     await this.ensureLaunchSession();
     if (!this.session) return;
     const session = this.session;
-    if (evt.source !== import_codevibe_core5.EventSource.MOBILE) return;
+    if (evt.source !== import_codevibe_core6.EventSource.MOBILE) return;
     if (evt.sessionId !== session.sessionId) {
       logger.warn("Dropping mobile event with mismatched sessionId", {
         expected: session.sessionId,
@@ -5446,19 +6036,20 @@ var McpServer = class _McpServer {
     let decrypted;
     try {
       decrypted = this.decryptInbound(session, evt);
-    } catch {
+    } catch (error) {
+      if ((0, import_codevibe_core6.requiresSyncInputDeliveryReceipt)(evt)) throw error;
       return;
     }
     evt = decrypted;
-    await this.markDelivered(evt);
-    if (evt.type === import_codevibe_core5.EventType.USER_PROMPT || evt.type === import_codevibe_core5.EventType.PROMPT_RESPONSE) {
+    if (!await this.markDelivered(evt)) return;
+    if (evt.type === import_codevibe_core6.EventType.USER_PROMPT || evt.type === import_codevibe_core6.EventType.PROMPT_RESPONSE) {
       const mobileFloorMs = Date.parse(evt.timestamp);
       this.mobilePromptFloorBySession.set(session.sessionId, {
         floorMs: Number.isNaN(mobileFloorMs) ? Date.now() : mobileFloorMs,
         setAtWallMs: Date.now()
       });
     }
-    if (evt.type === import_codevibe_core5.EventType.USER_PROMPT || evt.type === import_codevibe_core5.EventType.PROMPT_RESPONSE) {
+    if (evt.type === import_codevibe_core6.EventType.USER_PROMPT || evt.type === import_codevibe_core6.EventType.PROMPT_RESPONSE) {
       let promptContent = evt.content;
       const attachments = evt.attachments ?? [];
       if (attachments.length > 0) {
@@ -5497,16 +6088,16 @@ var McpServer = class _McpServer {
       const rawMeta = parseMaybeJson(evt.metadata);
       const meta = rawMeta && typeof rawMeta === "object" ? rawMeta : {};
       const evtAny = evt;
-      const responsePromptId = evt.type === import_codevibe_core5.EventType.PROMPT_RESPONSE ? 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 : null;
+      const responsePromptId = evt.type === import_codevibe_core6.EventType.PROMPT_RESPONSE ? 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 : null;
       const advertisedOptionNumbers = Array.from(new Set(
         pendingPrompts.flatMap((prompt) => Object.keys(prompt.submitMap))
       ));
-      const intent = (0, import_codevibe_core5.classifyMobilePromptInput)(
+      const intent = (0, import_codevibe_core6.classifyMobilePromptInput)(
         promptContent,
         advertisedOptionNumbers
       );
       if (intent.kind === "option") {
-        const activePrompt = evt.type === import_codevibe_core5.EventType.PROMPT_RESPONSE ? pendingPrompts.find((prompt) => prompt.promptId === responsePromptId) ?? null : pendingPrompts.length === 1 ? pendingPrompts[0] : null;
+        const activePrompt = evt.type === import_codevibe_core6.EventType.PROMPT_RESPONSE ? pendingPrompts.find((prompt) => prompt.promptId === responsePromptId) ?? null : pendingPrompts.length === 1 ? pendingPrompts[0] : null;
         if (!activePrompt || !Object.prototype.hasOwnProperty.call(activePrompt.submitMap, intent.option)) {
           logger.warn("Numeric input does not identify one current advertised prompt; dropping", {
             sessionId: session.sessionId,
@@ -5516,7 +6107,7 @@ var McpServer = class _McpServer {
           });
           return;
         }
-        if (evt.type === import_codevibe_core5.EventType.PROMPT_RESPONSE) {
+        if (evt.type === import_codevibe_core6.EventType.PROMPT_RESPONSE) {
           if (responsePromptId !== activePrompt.promptId) {
             logger.warn("PROMPT_RESPONSE does not identify the current advertised prompt; dropping", {
               sessionId: session.sessionId,
@@ -5526,13 +6117,13 @@ var McpServer = class _McpServer {
             return;
           }
         }
-        this.mobileDeduper.track(session.sessionId, intent.option);
+        await this.trackDurableMobileEcho(session, evt, intent.option, "primary");
         const optionResult = await this.promptResponder.sendApprovalReply(
           activePrompt.promptId,
           intent.option
         );
         if (!optionResult.ok) {
-          this.mobileDeduper.forget(session.sessionId, intent.option);
+          if (!(0, import_codevibe_core6.requiresSyncInputDeliveryReceipt)(evt)) this.mobileDeduper.forget(session.sessionId, intent.option);
           return;
         }
         await this.resolveE1PluginApproval(session.sessionId, activePrompt.promptId);
@@ -5541,7 +6132,7 @@ var McpServer = class _McpServer {
           return;
         }
         promptContent = intent.followUpText;
-        await new Promise((resolve3) => setTimeout(resolve3, 250));
+        await new Promise((resolve2) => setTimeout(resolve2, 250));
       } else {
         const dismissal = await this.promptResponder.dismissActivePrompt();
         if (!dismissal.ok) {
@@ -5554,10 +6145,12 @@ var McpServer = class _McpServer {
         const clearedPromptIds = this.approvalDetector.onPanePromptCleared();
         await this.resolveAcceptedInputPrompts(session, clearedPromptIds);
       }
-      this.mobileDeduper.track(session.sessionId, promptContent);
-      const result = await this.promptResponder.sendFreeFormWhenNoApprovalActive(promptContent);
+      const result = await this.promptResponder.sendFreeFormWhenNoApprovalActive(
+        promptContent,
+        () => this.trackDurableMobileEcho(session, evt, promptContent, "free_form")
+      );
       if (!result.ok) {
-        this.mobileDeduper.forget(session.sessionId, promptContent);
+        if (!(0, import_codevibe_core6.requiresSyncInputDeliveryReceipt)(evt)) this.mobileDeduper.forget(session.sessionId, promptContent);
         logger.warn("sendFreeForm failed", { reason: result.reason, details: result.details });
         return;
       }
@@ -5565,18 +6158,37 @@ var McpServer = class _McpServer {
       return;
     }
   }
+  async trackDurableMobileEcho(session, event, content, lane) {
+    if (!(0, import_codevibe_core6.requiresSyncInputDeliveryReceipt)(event)) {
+      this.mobileDeduper.track(session.sessionId, content);
+      return;
+    }
+    const selected = await this.selectNativeSource(session);
+    if (selected.protocol !== "SYNC_V2" || !this.started || this.sessionDisabled || this.session !== session || event.sessionId !== selected.sessionScope.sessionId || event.sessionGenerationId !== selected.sessionScope.sessionGenerationId) throw Error("SYNC_ECHO_OWNER_CHANGED");
+    if (content.trim()) await selected.writer.mobileEchoes("agy").arm(
+      { eventId: event.eventId, timestamp: event.timestamp, type: event.type, lane },
+      content,
+      { nowMs: Date.now(), windowMs: 15e3, clockPrecisionMs: 1e3, allowSuffix: true, normalization: "whitespace" }
+    );
+    if (!this.started || this.sessionDisabled || this.session !== session) throw Error("SYNC_ECHO_OWNER_CHANGED");
+  }
   async emitPromptSafetyNotification(session, content) {
     const input = {
       sessionId: session.sessionId,
-      type: import_codevibe_core5.EventType.NOTIFICATION,
-      source: import_codevibe_core5.EventSource.DESKTOP,
+      type: import_codevibe_core6.EventType.NOTIFICATION,
+      source: import_codevibe_core6.EventSource.DESKTOP,
       content,
       metadata: { promptSafetyBlocked: true },
-      timestamp: (0, import_codevibe_core5.prepareEventTimestamp)({ orderingKey: session.sessionId })
+      timestamp: (0, import_codevibe_core6.prepareEventTimestamp)({ orderingKey: session.sessionId })
     };
-    await this.flushToolActivityAtBoundary(import_codevibe_core5.EventType.NOTIFICATION);
+    await this.flushToolActivityAtBoundary(import_codevibe_core6.EventType.NOTIFICATION);
     try {
-      await this.createEncryptedEvent(session, input);
+      if (!this.started || this.sessionDisabled || this.session !== session) return;
+      const result = await this.appSyncClient.publishCompanionNotice(
+        input,
+        async () => !!await this.createEncryptedEvent(session, input)
+      );
+      logger.debug("Prompt-safety notification publication outcome", { sessionId: session.sessionId, result });
     } catch (error) {
       logger.warn("Failed to emit prompt-safety notification", { error: String(error) });
     }
@@ -5586,23 +6198,20 @@ var McpServer = class _McpServer {
    * 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.
+   * that it has acted on it yet. Legacy checkmarks remain best-effort;
+   * R2 requires exact cloud authority before terminal routing.
    */
   async markDelivered(evt) {
     try {
-      await this.appSyncClient.updateEventStatus({
-        eventId: evt.eventId,
-        sessionId: evt.sessionId,
-        timestamp: evt.timestamp,
-        deliveryStatus: import_codevibe_core5.DeliveryStatus.DELIVERED
-      });
+      return await (0, import_codevibe_core6.acknowledgeMobileInputDelivery)(this.appSyncClient.updateEventStatus.bind(this.appSyncClient), evt);
     } catch (err) {
       logger.warn("updateEventStatus(DELIVERED) failed", {
         eventId: evt.eventId,
         sessionId: evt.sessionId,
         error: String(err)
       });
+      if ((0, import_codevibe_core6.requiresSyncInputDeliveryReceipt)(evt)) throw err;
+      return true;
     }
   }
   /**
@@ -5615,12 +6224,7 @@ var McpServer = class _McpServer {
    */
   async markExecuted(evt) {
     try {
-      await this.appSyncClient.updateEventStatus({
-        eventId: evt.eventId,
-        sessionId: evt.sessionId,
-        timestamp: evt.timestamp,
-        deliveryStatus: import_codevibe_core5.DeliveryStatus.EXECUTED
-      });
+      await (0, import_codevibe_core6.acknowledgeMobileInputExecution)(this.appSyncClient.updateEventStatus.bind(this.appSyncClient), evt);
     } catch (err) {
       logger.warn("updateEventStatus(EXECUTED) failed", {
         eventId: evt.eventId,
@@ -5631,10 +6235,14 @@ var McpServer = class _McpServer {
   }
   // ─── HTTP API push hook (internal/programmatic) ────────────────────────
   async handleHttpPushEvent(payload) {
+    if (!isHttpEventPayload(payload)) throw Object.assign(Error("invalid HTTP event payload"), { code: "INVALID_SYNC_INPUT" });
     const session = this.findSessionByBackendId(payload.sessionId);
-    if (!session) {
+    if (!session || !this.started || this.sessionDisabled) {
       throw new SessionNotFoundError(payload.sessionId);
     }
+    const assertOwner = () => {
+      if (!this.started || this.sessionDisabled || this.session !== session) throw new SessionNotFoundError(payload.sessionId);
+    };
     const normalizedMeta = parseMaybeJson(payload.metadata);
     const metadata = normalizedMeta && typeof normalizedMeta === "object" ? normalizedMeta : {};
     const input = {
@@ -5647,15 +6255,12 @@ var McpServer = class _McpServer {
       // orderingKey is session-scoped. Slightly coarser than the
       // per-conv key used by transcript emits, but acceptable because
       // hook-script pushes are off the hot transcript path.
-      timestamp: (0, import_codevibe_core5.prepareEventTimestamp)({ orderingKey: payload.sessionId })
+      timestamp: (0, import_codevibe_core6.prepareEventTimestamp)({ orderingKey: payload.sessionId })
     };
-    const created = await this.createEncryptedEvent(session, input);
-    if (!created) {
-      throw new Error(
-        `fail-closed: encrypted session ${payload.sessionId} has no session key \u2014 event dropped (#638)`
-      );
-    }
-    return { eventId: created.eventId };
+    return this.appSyncClient.publishCompanionEvent(input, async () => {
+      assertOwner();
+      return this.createEncryptedEvent(session, input);
+    }, { assertOwner });
   }
   findSessionByBackendId(backendSessionId) {
     if (!this.session) return null;
@@ -6024,7 +6629,7 @@ async function main() {
     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
   });
-  (0, import_codevibe_core5.installDaemonProcessGuards)(logger, {
+  (0, import_codevibe_core6.installDaemonProcessGuards)(logger, {
     onFatal: () => {
       void server.stop().finally(() => process.exit(1));
     }