@quantiya/codevibe-antigravity-plugin 2.0.60 → 2.0.61

package/README.md

@@ -51,7 +51,7 @@ install the unified `codevibe --agent` interface yet.
 
 ## How it works
 
-Antigravity CLI writes session transcripts to `~/.gemini/antigravity-cli/brain/<uuid>/.system_generated/logs/transcript.jsonl`. CodeVibe watches those files with chokidar, parses every line of the JSONL stream, and pushes events through E2E-encrypted AWS AppSync to your phone.
+Antigravity CLI writes session transcripts to `~/.gemini/antigravity-cli/brain/<uuid>/.system_generated/logs/transcript.jsonl`. CodeVibe follows the active conversation's transcript file, parses every line of the JSONL stream, and pushes events through E2E-encrypted AWS AppSync to your phone.
 
 Approval prompts and multi-choice questions aren't in the transcript at the moment they appear — agy renders them directly into the terminal. CodeVibe observes the live tmux pane to detect both UI variants, parses the option labels, and surfaces them to mobile. Your mobile reply is delivered back via `tmux send-keys`.
 

package/dist/server.js

@@ -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);
@@ -268,7 +268,7 @@ function isValidEventSource(value) {
   return Object.values(import_codevibe_core2.EventSource).includes(value);
 }
 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 +280,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 +306,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([
@@ -355,6 +355,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 +389,39 @@ function defaultPaths() {
 var TranscriptTailer = class extends import_events.EventEmitter {
   constructor(options = {}) {
     super();
-    this.watcher = null;
     this.isWatching = false;
     this.isShuttingDown = false;
+    /** 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 +448,11 @@ 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;
   }
   /**
-   * 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) {
@@ -420,97 +474,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
@@ -559,10 +551,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 +571,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(
@@ -603,7 +603,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 +625,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 +944,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 +966,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 +978,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 +1022,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) {
@@ -813,6 +1058,7 @@ var TranscriptTailer = class extends import_events.EventEmitter {
       if (this.activeReads.get(filePath) === read) {
         this.activeReads.delete(filePath);
         this.pendingReads.delete(filePath);
+        this.cursorResets.delete(filePath);
       }
     });
     return read;
@@ -837,6 +1083,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 +1101,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 +1129,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 +1158,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 +1222,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 +2220,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();
   });
 }
@@ -3135,14 +3393,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 {
@@ -4126,8 +4384,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 {
@@ -4280,7 +4538,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));
         }
       }
     }
@@ -4940,7 +5198,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));
     }
   }
   /**
@@ -5036,7 +5294,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));
         }
       }
     }
@@ -5541,7 +5799,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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-antigravity-plugin",
-  "version": "2.0.60",
+  "version": "2.0.61",
   "description": "Control Antigravity CLI from your iPhone and Android — real-time sync, approve file edits, send prompts by voice. Part of CodeVibe.",
   "main": "dist/server.js",
   "codevibe": {