@quantiya/codevibe-antigravity-plugin 2.0.51 → 2.0.53

package/dist/server.js

@@ -350,6 +350,10 @@ var OFFSET_FLUSH_INTERVAL_MS = 3e4;
 var ERROR_LOG_MIN_INTERVAL_MS = 1e4;
 var LRU_CAP = 50;
 var TRANSCRIPT_FILE_REGEX = /\/brain\/([0-9a-fA-F-]{36})\/\.system_generated\/logs\/transcript\.jsonl$/;
+var CONVERSATION_DIR_REGEX = /^[0-9a-fA-F-]{36}$/;
+var SYSTEM_GENERATED_DIR = ".system_generated";
+var LOGS_DIR = "logs";
+var TRANSCRIPT_BASENAME = "transcript.jsonl";
 function defaultPaths() {
   const home = os2.homedir();
   return {
@@ -428,17 +432,69 @@ var TranscriptTailer = class extends import_events.EventEmitter {
       // partial-line carryover handles partial writes
       usePolling: this.usePolling,
       interval: this.usePolling ? 50 : void 0,
-      ignored: (filePath) => {
-        const isDir = (() => {
-          try {
-            return fs2.statSync(filePath).isDirectory();
-          } catch {
-            return false;
-          }
-        })();
-        if (isDir) return false;
-        return !TRANSCRIPT_FILE_REGEX.test(filePath);
-      }
+      // 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));
@@ -568,6 +624,48 @@ var TranscriptTailer = class extends import_events.EventEmitter {
     this.emit("transcript-add", filePath, conversationId);
     void this.scheduleReadNewLines(filePath, conversationId);
   }
+  /**
+   * 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.
+   */
+  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;
+    }
+  }
   onDirAdded(dirPath) {
     if (this.isShuttingDown) return;
     const base = path2.basename(dirPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-antigravity-plugin",
-  "version": "2.0.51",
+  "version": "2.0.53",
   "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": {
@@ -46,7 +46,7 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@quantiya/codevibe-core": "^2.0.48",
+    "@quantiya/codevibe-core": "^2.0.49",
     "chokidar": "^5.0.0",
     "dotenv": "^16.6.1",
     "express": "^5.1.0",