@adhdev/daemon-core 0.9.82-rc.443 → 0.9.82-rc.445

package/dist/index.mjs

@@ -404,10 +404,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "21c6fe269d621db0b4841be14c111d4d656d6996" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "21c6fe26" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.443" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-01T10:41:15.424Z" : void 0);
+  const commit = readInjected(true ? "92b0714a88a4e1e253a40fa5a8c49602d087a5b3" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "92b0714a" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.445" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-01T12:57:54.212Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -3711,6 +3711,7 @@ var init_coordinator_prompt = __esm({
 | \`mesh_read_debug\` | Collect a daemon-side chat/parser debug bundle for a session |
 | \`mesh_task_history\` | Read the task ledger \u2014 dispatches, completions, failures. Use to understand what has been done before deciding next steps |
 | \`mesh_record_note\` | Record a durable, provider-neutral operating note (provider quirk / pattern to avoid / recovery lesson). Future coordinators see it under "## Operating Notes" at launch |
+| \`mesh_forget_note\` | Retract a stale/wrong operating note by note_id or exact text so it stops riding into future coordinators' prompts (append-only tombstone; history preserved) |
 | \`mesh_git_status\` | Check git status on a specific node |
 | \`mesh_read_node_logs\` | Fetch a remote node's daemon log tail directly over P2P (grep/since/byte-bounded, secrets redacted) \u2014 no session/PowerShell needed to debug a node's daemon |
 | \`mesh_fast_forward_node\` | Safely dry-run or explicitly execute an obvious clean fast-forward without launching an agent session |
@@ -4096,6 +4097,10 @@ var init_load_better_sqlite3 = __esm({
 var mesh_ledger_exports = {};
 __export(mesh_ledger_exports, {
   MAX_LEDGER_SLICE_LIMIT: () => MAX_LEDGER_SLICE_LIMIT,
+  OPERATING_NOTE_DEDUPE_WINDOW: () => OPERATING_NOTE_DEDUPE_WINDOW,
+  OPERATING_NOTE_KEEP_LATEST: () => OPERATING_NOTE_KEEP_LATEST,
+  OPERATING_NOTE_KIND: () => OPERATING_NOTE_KIND,
+  OPERATING_NOTE_TOMBSTONE_KIND: () => OPERATING_NOTE_TOMBSTONE_KIND,
   __clearMeshLedgerForTests: () => __clearMeshLedgerForTests,
   appendLedgerEntry: () => appendLedgerEntry,
   appendRemoteLedgerEntries: () => appendRemoteLedgerEntries,
@@ -4106,11 +4111,15 @@ __export(mesh_ledger_exports, {
   getLedgerSummary: () => getLedgerSummary,
   getSessionRecoveryContext: () => getSessionRecoveryContext,
   isIntentionalCleanupStopEntry: () => isIntentionalCleanupStopEntry,
+  isOperatingNoteTombstoned: () => isOperatingNoteTombstoned,
   meshLedgerEvents: () => meshLedgerEvents,
   normalizeMeshWorkerResult: () => normalizeMeshWorkerResult,
+  pruneOperatingNotes: () => pruneOperatingNotes,
   readLedgerEntries: () => readLedgerEntries,
   readLedgerSlice: () => readLedgerSlice,
-  readLedgerSliceFromStore: () => readLedgerSliceFromStore
+  readLedgerSliceFromStore: () => readLedgerSliceFromStore,
+  readOperatingNotes: () => readOperatingNotes,
+  tombstoneOperatingNote: () => tombstoneOperatingNote
 });
 import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync5, statSync as statSync4, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
 import { join as join8 } from "path";
@@ -4384,6 +4393,17 @@ function buildTaskCompletionEvidence(opts) {
   };
 }
 function appendLedgerEntry(meshId, partial) {
+  if (partial.kind === OPERATING_NOTE_KIND) {
+    const text = operatingNoteText(partial.payload);
+    if (text) {
+      const recentNotes = readLedgerEntries(meshId, {
+        kind: [OPERATING_NOTE_KIND],
+        tail: OPERATING_NOTE_DEDUPE_WINDOW
+      });
+      const existing = recentNotes.find((e) => operatingNoteText(e.payload) === text);
+      if (existing) return existing;
+    }
+  }
   const entry = {
     id: randomUUID4(),
     meshId,
@@ -4421,11 +4441,101 @@ function appendLedgerEntry(meshId, partial) {
     appendFileSync(filePath, line, { encoding: "utf-8", mode: 384 });
     invalidateLedgerCache(meshId);
     meshLedgerEvents.emit("append", meshId, entry);
+    if (entry.kind === OPERATING_NOTE_KIND || entry.kind === OPERATING_NOTE_TOMBSTONE_KIND) {
+      try {
+        pruneOperatingNotes(meshId);
+      } catch {
+      }
+    }
     return entry;
   } catch (e) {
     throw new Error(`Failed to append to ledger for mesh ${meshId}: ${e.message}`);
   }
 }
+function operatingNoteText(payload) {
+  const text = payload && typeof payload.text === "string" ? payload.text.trim() : "";
+  return text || void 0;
+}
+function collectOperatingNoteTombstones(entries) {
+  const ids = /* @__PURE__ */ new Set();
+  const fingerprints = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    if (e.kind !== OPERATING_NOTE_TOMBSTONE_KIND) continue;
+    const p = e.payload || {};
+    const targetId = typeof p.targetNoteId === "string" ? p.targetNoteId.trim() : "";
+    const targetFp = typeof p.targetFingerprint === "string" ? p.targetFingerprint.trim() : "";
+    if (targetId) ids.add(targetId);
+    if (targetFp) fingerprints.add(targetFp);
+  }
+  return { ids, fingerprints };
+}
+function isOperatingNoteTombstoned(entry, tombstones) {
+  if (tombstones.ids.has(entry.id)) return true;
+  const text = operatingNoteText(entry.payload);
+  return text ? tombstones.fingerprints.has(text) : false;
+}
+function tombstoneOperatingNote(meshId, target) {
+  const noteId = typeof target.noteId === "string" ? target.noteId.trim() : "";
+  const fingerprint = typeof target.text === "string" ? target.text.trim() : "";
+  if (!noteId && !fingerprint) {
+    throw new Error("tombstoneOperatingNote requires a noteId or text target");
+  }
+  const notes = readOperatingNotes(meshId);
+  const matched = notes.filter(
+    (n) => noteId && n.id === noteId || fingerprint && operatingNoteText(n.payload) === fingerprint
+  ).length;
+  const tombstone = appendLedgerEntry(meshId, {
+    kind: OPERATING_NOTE_TOMBSTONE_KIND,
+    payload: {
+      ...noteId ? { targetNoteId: noteId } : {},
+      ...fingerprint ? { targetFingerprint: fingerprint } : {},
+      ...target.reason && target.reason.trim() ? { reason: target.reason.trim() } : {},
+      forgottenAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  });
+  return { tombstone, matched };
+}
+function readOperatingNotes(meshId, opts) {
+  const raw = getCachedRawEntries(meshId);
+  const tombstones = collectOperatingNoteTombstones(raw);
+  let notes = raw.filter((e) => e.kind === OPERATING_NOTE_KIND && !isOperatingNoteTombstoned(e, tombstones));
+  if (opts?.tail && opts.tail > 0 && notes.length > opts.tail) {
+    notes = notes.slice(-opts.tail);
+  }
+  return notes;
+}
+function pruneOperatingNotes(meshId, keepLatest = OPERATING_NOTE_KEEP_LATEST) {
+  const raw = getCachedRawEntries(meshId);
+  const tombstones = collectOperatingNoteTombstones(raw);
+  const removeIds = [];
+  const liveNotes = [];
+  for (const e of raw) {
+    if (e.kind !== OPERATING_NOTE_KIND) continue;
+    if (isOperatingNoteTombstoned(e, tombstones)) {
+      removeIds.push(e.id);
+    } else {
+      liveNotes.push(e);
+    }
+  }
+  const bound = Math.max(0, Math.floor(keepLatest));
+  if (liveNotes.length > bound) {
+    for (const e of liveNotes.slice(0, liveNotes.length - bound)) removeIds.push(e.id);
+  }
+  if (removeIds.length === 0) return 0;
+  try {
+    MeshRuntimeStore.getInstance().deleteLedgerEntries(meshId, removeIds);
+  } catch {
+  }
+  try {
+    const remaining = readLedgerFile(meshId).filter((e) => !removeIds.includes(e.id));
+    const filePath = getLedgerPath(meshId);
+    const lines = remaining.length ? remaining.map((e) => JSON.stringify(e)).join("\n") + "\n" : "";
+    writeFileSync3(filePath, lines, { encoding: "utf-8", mode: 384 });
+  } catch {
+  }
+  invalidateLedgerCache(meshId);
+  return removeIds.length;
+}
 function clampLedgerSliceLimit(limit) {
   if (typeof limit !== "number" || !Number.isFinite(limit)) return DEFAULT_LEDGER_SLICE_LIMIT;
   return Math.max(1, Math.min(MAX_LEDGER_SLICE_LIMIT, Math.floor(limit)));
@@ -4765,7 +4875,7 @@ function rotateLedgerFile(meshId, currentPath) {
 `);
   }
 }
-var LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, COMPACT_THRESHOLD_BYTES, ARCHIVE_TERMINAL_OLDER_THAN_MS, RECENT_FAILURE_WINDOW_MS, ARCHIVABLE_KINDS, DEFAULT_LEDGER_SLICE_LIMIT, MAX_LEDGER_SLICE_LIMIT, meshLedgerEvents, ledgerReadCache, LEDGER_CACHE_TTL_MS, ledgerImportStoreRef, ledgerImportDone;
+var LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, COMPACT_THRESHOLD_BYTES, ARCHIVE_TERMINAL_OLDER_THAN_MS, RECENT_FAILURE_WINDOW_MS, ARCHIVABLE_KINDS, DEFAULT_LEDGER_SLICE_LIMIT, MAX_LEDGER_SLICE_LIMIT, OPERATING_NOTE_KIND, OPERATING_NOTE_TOMBSTONE_KIND, OPERATING_NOTE_DEDUPE_WINDOW, OPERATING_NOTE_KEEP_LATEST, meshLedgerEvents, ledgerReadCache, LEDGER_CACHE_TTL_MS, ledgerImportStoreRef, ledgerImportDone;
 var init_mesh_ledger = __esm({
   "src/mesh/mesh-ledger.ts"() {
     "use strict";
@@ -4784,6 +4894,10 @@ var init_mesh_ledger = __esm({
     ]);
     DEFAULT_LEDGER_SLICE_LIMIT = 100;
     MAX_LEDGER_SLICE_LIMIT = 500;
+    OPERATING_NOTE_KIND = "coordinator_operating_note";
+    OPERATING_NOTE_TOMBSTONE_KIND = "coordinator_operating_note_tombstone";
+    OPERATING_NOTE_DEDUPE_WINDOW = 40;
+    OPERATING_NOTE_KEEP_LATEST = 100;
     meshLedgerEvents = new EventEmitter();
     ledgerReadCache = /* @__PURE__ */ new Map();
     LEDGER_CACHE_TTL_MS = 100;
@@ -41154,8 +41268,7 @@ var CliProviderInstance = class _CliProviderInstance {
    * to the genuine-modal classification.
    */
   isTransientToolConsent(now = Date.now()) {
-    const isAutonomousMeshSession = this.isMeshWorkerSession() || !!this.settings.meshCoordinatorFor;
-    return isAutonomousMeshSession && this.hasAdapterPendingResponse() && !this.manualAttendance.isAttended(now);
+    return this.isAutonomousMeshSession() && this.hasAdapterPendingResponse() && !this.manualAttendance.isAttended(now);
   }
   /** True when this session is parked on a modal awaiting a human answer. */
   isModalParked() {
@@ -41638,6 +41751,19 @@ var CliProviderInstance = class _CliProviderInstance {
   isMeshWorkerSession() {
     return !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.meshNodeId || this.settings.launchedByCoordinator);
   }
+  // FALSE-IDLE (self-coordinator settle): an autonomously-progressing mesh session
+  // is either a delegated worker (isMeshWorkerSession) OR the coordinator's OWN
+  // claude-cli session (meshCoordinatorFor). Both run auto-approved tool turns whose
+  // inter-approval valley (busy→idle blip→generating re-entry ~0.5s later) must be
+  // absorbed by the completedDebounce settle window, not flushed on the first idle
+  // sample. The worker branch already gets NATIVE_HISTORY_MESH_IDLE_SETTLE_MS; the
+  // self-coordinator session (worker markers absent, meshCoordinatorFor present) was
+  // taking flushDelay=0 — no settle window — so its busyEpoch/lastOutputAt continuity
+  // guard had no window to observe the valley and fired mid-turn "next-step" previews
+  // as a finalSummary. Mirrors the isAutonomousMeshSession notion in isTransientToolConsent.
+  isAutonomousMeshSession() {
+    return this.isMeshWorkerSession() || !!this.settings.meshCoordinatorFor;
+  }
   /**
    * ARCH-REFACTOR R1: the taskId to attribute the CURRENTLY-completing turn to.
    * Prefers the per-turn binding (engine.currentTurnTaskId, set when the turn was
@@ -42131,9 +42257,9 @@ var CliProviderInstance = class _CliProviderInstance {
             ...typeof adapterStatus?.lastOutputAt === "number" && Number.isFinite(adapterStatus.lastOutputAt) ? { lastOutputAtArm: adapterStatus.lastOutputAt } : {}
           };
           const ownsExternalHistory = !!this.adapter?.chatMessagesOwnedExternally;
-          const meshWorkerSession = this.isMeshWorkerSession();
-          const flushDelay = ownsExternalHistory ? meshWorkerSession ? NATIVE_HISTORY_MESH_IDLE_SETTLE_MS : 0 : 3e3;
-          LOG.debug("CLI", `[${this.type}] set completedDebouncePending duration=${duration}s ownsExternalHistory=${ownsExternalHistory} meshWorker=${meshWorkerSession} flushDelay=${flushDelay}ms generatingStartedAt=${this.generatingStartedAt}`);
+          const meshSettleSession = this.isAutonomousMeshSession();
+          const flushDelay = ownsExternalHistory ? meshSettleSession ? NATIVE_HISTORY_MESH_IDLE_SETTLE_MS : 0 : 3e3;
+          LOG.debug("CLI", `[${this.type}] set completedDebouncePending duration=${duration}s ownsExternalHistory=${ownsExternalHistory} meshSettle=${meshSettleSession} flushDelay=${flushDelay}ms generatingStartedAt=${this.generatingStartedAt}`);
           this.scheduleCompletedDebounceFlush(flushDelay);
         }
       } else if (newStatus === "idle" && this.lastStatus === "starting") {
@@ -46193,6 +46319,8 @@ function readSession2(sessionPath) {
 }
 
 // src/providers/native-history/antigravity-cli-transcript.ts
+init_load_better_sqlite3();
+init_logger();
 import * as fs22 from "fs";
 import * as path31 from "path";
 import * as os22 from "os";
@@ -46369,6 +46497,159 @@ function parsePbFile(filePath, sessionId) {
     }
   ];
 }
+var AGY_STEP_TYPE_USER = 14;
+var AGY_STEP_TYPE_MODEL = 15;
+function readVarint(buf, offset) {
+  let result = 0;
+  let shift = 0;
+  let i = offset;
+  while (i < buf.length) {
+    const byte = buf[i];
+    i += 1;
+    result += (byte & 127) * Math.pow(2, shift);
+    if ((byte & 128) === 0) return [result, i];
+    shift += 7;
+    if (shift > 63) break;
+  }
+  return [result, i];
+}
+function decodeProtoFields(buf) {
+  const fields = [];
+  let i = 0;
+  while (i < buf.length) {
+    const [key2, afterKey] = readVarint(buf, i);
+    if (afterKey === i) break;
+    i = afterKey;
+    const field = Math.floor(key2 / 8);
+    const wireType = key2 & 7;
+    if (field <= 0) break;
+    if (wireType === 0) {
+      const [value, next] = readVarint(buf, i);
+      if (next === i) break;
+      i = next;
+      fields.push({ field, wireType, varint: value });
+    } else if (wireType === 2) {
+      const [len, afterLen] = readVarint(buf, i);
+      i = afterLen;
+      if (len < 0 || i + len > buf.length) break;
+      fields.push({ field, wireType, bytes: buf.subarray(i, i + len) });
+      i += len;
+    } else if (wireType === 5) {
+      i += 4;
+    } else if (wireType === 1) {
+      i += 8;
+    } else {
+      break;
+    }
+  }
+  return fields;
+}
+function firstLenField(buf, field) {
+  for (const f of decodeProtoFields(buf)) {
+    if (f.field === field && f.wireType === 2 && f.bytes) return f.bytes;
+  }
+  return null;
+}
+function looksLikeText(buf) {
+  if (buf.length === 0) return false;
+  let printable = 0;
+  for (let i = 0; i < buf.length; i++) {
+    const b = buf[i];
+    if (b >= 32 && b <= 126 || b === 9 || b === 10 || b === 13 || b >= 128) printable += 1;
+  }
+  return printable / buf.length >= 0.9;
+}
+function stripAnswerMarker(text) {
+  return text.replace(/^\s*MARKER_V1\s*/, "");
+}
+function extractModelAnswer(payload) {
+  const inner = firstLenField(payload, 20);
+  if (!inner) return "";
+  const answer = firstLenField(inner, 1) ?? firstLenField(inner, 8);
+  if (!answer || !looksLikeText(answer)) return "";
+  return stripAnswerMarker(answer.toString("utf-8")).trim();
+}
+function extractUserPrompt(payload) {
+  const inner = firstLenField(payload, 19);
+  if (!inner) return "";
+  const raw = firstLenField(inner, 2) ?? firstLenField(inner, 3);
+  if (!raw || !looksLikeText(raw)) return "";
+  const text = raw.toString("utf-8").trim();
+  if (!text) return "";
+  return extractUserRequestContent(text);
+}
+function parseConversationDb(filePath, sessionId, workspace) {
+  let db;
+  try {
+    const Database = loadBetterSqlite3();
+    db = new Database(filePath, { readonly: true, fileMustExist: true });
+  } catch (err) {
+    LOG.warn(
+      "NativeHistory",
+      `antigravity .db reader could not open ${path31.basename(filePath)}: ${err instanceof Error ? err.message : String(err)} (better-sqlite3 load/open failed \u2014 assistant answers in this .db will not surface)`
+    );
+    return null;
+  }
+  let rows;
+  try {
+    rows = db.prepare(
+      `SELECT idx, step_type, step_payload
+           FROM steps
+          WHERE step_type IN (${AGY_STEP_TYPE_USER}, ${AGY_STEP_TYPE_MODEL})
+          ORDER BY idx ASC`
+    ).all();
+  } catch (err) {
+    LOG.debug(
+      "NativeHistory",
+      `antigravity .db ${path31.basename(filePath)} has no readable steps table: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  } finally {
+    try {
+      db.close();
+    } catch {
+    }
+  }
+  if (!Array.isArray(rows) || rows.length === 0) return null;
+  const normalizedWorkspace = typeof workspace === "string" ? workspace.trim() : "";
+  const baseTs = statMtimeMs3(filePath) || Date.now();
+  const messages = [];
+  for (const row of rows) {
+    const payload = row.step_payload;
+    if (!payload || !Buffer.isBuffer(payload) || payload.length === 0) continue;
+    const receivedAt = baseTs + messages.length;
+    if (row.step_type === AGY_STEP_TYPE_USER) {
+      const content = extractUserPrompt(payload);
+      if (!content) continue;
+      const msg = {
+        ts: new Date(receivedAt).toISOString(),
+        receivedAt,
+        role: "user",
+        content,
+        kind: "standard",
+        agent: "antigravity-cli",
+        historySessionId: sessionId
+      };
+      if (normalizedWorkspace) msg.workspace = normalizedWorkspace;
+      messages.push(msg);
+    } else if (row.step_type === AGY_STEP_TYPE_MODEL) {
+      const content = extractModelAnswer(payload);
+      if (!content) continue;
+      const msg = {
+        ts: new Date(receivedAt).toISOString(),
+        receivedAt,
+        role: "assistant",
+        content,
+        kind: "standard",
+        agent: "antigravity-cli",
+        historySessionId: sessionId
+      };
+      if (normalizedWorkspace) msg.workspace = normalizedWorkspace;
+      messages.push(msg);
+    }
+  }
+  return messages.length > 0 ? messages : null;
+}
 function readSession3(sessionPath, sessionId, workspace) {
   if (!sessionPath || !path31.isAbsolute(sessionPath)) return null;
   if (!fs22.existsSync(sessionPath)) return null;
@@ -46391,6 +46672,21 @@ function readSession3(sessionPath, sessionId, workspace) {
       workspace
     };
   }
+  if (sessionPath.endsWith(".db")) {
+    const dbSessionId = sessionId || path31.basename(sessionPath, ".db");
+    if (!isUuidLike(dbSessionId)) return null;
+    const messages = parseConversationDb(sessionPath, dbSessionId, workspace);
+    if (!messages || messages.length === 0) return null;
+    return {
+      messages,
+      providerSessionId: dbSessionId,
+      source: "provider-native",
+      sourcePath: sessionPath,
+      sourceMtimeMs,
+      nativeHistoryCoverage: "full",
+      workspace
+    };
+  }
   if (sessionPath.endsWith(".pb")) {
     const pbSessionId = sessionId || path31.basename(sessionPath, ".pb");
     if (!isUuidLike(pbSessionId)) return null;
@@ -46619,7 +46915,7 @@ function resolveSourcePath(reader, workspace, sessionId, sessionStartedAtMs) {
     case "codex-cli":
       return resolveCodexPath(workspace, sessionId, sessionStartedAtMs);
     case "antigravity-cli":
-      return resolveAntigravityPath(workspace);
+      return resolveAntigravityPath(workspace, sessionId);
     case "hermes-cli":
       return resolveHermesPath(workspace, sessionId);
   }
@@ -46734,16 +47030,25 @@ function resolveRealPath(value) {
     return value;
   }
 }
-function resolveAntigravityPath(workspace) {
+function resolveAntigravityPath(workspace, sessionId) {
   void workspace;
-  const brainRoot2 = path33.join(os24.homedir(), ".gemini", "antigravity-cli", "brain");
-  if (!fs24.existsSync(brainRoot2)) return null;
-  const cutoff = Date.now() - RECENT_WINDOW_MS;
-  const entries = fs24.readdirSync(brainRoot2, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => ({ p: path33.join(brainRoot2, e.name), mtime: safeMtime(path33.join(brainRoot2, e.name)) })).filter((e) => e.mtime >= cutoff).sort((a, b) => b.mtime - a.mtime);
-  for (const e of entries) {
-    const t = path33.join(e.p, ".system_generated", "logs", "transcript.jsonl");
-    if (fs24.existsSync(t)) return t;
+  const agyRoot = path33.join(os24.homedir(), ".gemini", "antigravity-cli");
+  if (sessionId && isUuidLikeSessionId2(sessionId)) {
+    const dbPath = path33.join(agyRoot, "conversations", `${sessionId}.db`);
+    if (fs24.existsSync(dbPath)) return dbPath;
   }
+  const brainRoot2 = path33.join(agyRoot, "brain");
+  if (fs24.existsSync(brainRoot2)) {
+    const cutoff = Date.now() - RECENT_WINDOW_MS;
+    const entries = fs24.readdirSync(brainRoot2, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => ({ p: path33.join(brainRoot2, e.name), mtime: safeMtime(path33.join(brainRoot2, e.name)) })).filter((e) => e.mtime >= cutoff).sort((a, b) => b.mtime - a.mtime);
+    for (const e of entries) {
+      const t = path33.join(e.p, ".system_generated", "logs", "transcript.jsonl");
+      if (fs24.existsSync(t) && safeSize(t) > 0) return t;
+    }
+  }
+  const convRoot = path33.join(agyRoot, "conversations");
+  const newestDb = newestRecentFile2(convRoot, /^[0-9a-f-]+\.db$/i);
+  if (newestDb) return newestDb;
   return null;
 }
 function resolveHermesPath(workspace, sessionId) {
@@ -46802,6 +47107,13 @@ function safeMtime(p) {
     return 0;
   }
 }
+function safeSize(p) {
+  try {
+    return fs24.statSync(p).size;
+  } catch {
+    return 0;
+  }
+}
 function normalizeRole2(r) {
   const s2 = String(r ?? "").toLowerCase();
   if (s2 === "user" || s2 === "human") return "user";
@@ -51015,8 +51327,8 @@ var meshCoordinatorLaunchHandlers = {
       };
       const buildOperatingNotesBestEffort = async (id) => {
         try {
-          const { readLedgerEntries: readLedgerEntries2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
-          const noteEntries = readLedgerEntries2(id, { kind: ["coordinator_operating_note"], tail: 20 });
+          const { readOperatingNotes: readOperatingNotes2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+          const noteEntries = readOperatingNotes2(id, { tail: 20 });
           const notes = noteEntries.map((e) => {
             const p = e.payload || {};
             const text = typeof p.text === "string" ? p.text.trim() : "";
@@ -65717,6 +66029,10 @@ export {
   MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
   MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
   NodePtyTransportFactory,
+  OPERATING_NOTE_DEDUPE_WINDOW,
+  OPERATING_NOTE_KEEP_LATEST,
+  OPERATING_NOTE_KIND,
+  OPERATING_NOTE_TOMBSTONE_KIND,
   P2pRelayFailureError,
   PRUNABLE_ORPHAN_STALE_REASONS,
   ProviderCliAdapter,
@@ -65886,6 +66202,7 @@ export {
   isManagedStatusWaiting,
   isManagedStatusWorking,
   isMeshHostOwner,
+  isOperatingNoteTombstoned,
   isP2pRelayTransportFailure,
   isPathInside,
   isSessionHostLiveRuntime,
@@ -65954,6 +66271,7 @@ export {
   prepareSessionChatTailUpdate,
   prepareSessionModalUpdate,
   probeCdpPort,
+  pruneOperatingNotes,
   pruneStaleDirectDispatches,
   queuePendingMeshCoordinatorEvent,
   readSession3 as readAntigravityCliSession,
@@ -65966,6 +66284,7 @@ export {
   readLedgerSlice,
   readLedgerSliceFromStore,
   readMeshCompletionSummary,
+  readOperatingNotes,
   reconcileDirectDispatchCompletionFromTranscript,
   recordCompletionConflict,
   recordDebugTrace,
@@ -66023,6 +66342,7 @@ export {
   summarizeMeshMagiActivity,
   summarizeMeshMission,
   summarizeMissionTasks,
+  tombstoneOperatingNote,
   triggerMeshQueue,
   unregisterMeshCoordinator,
   updateConfig,