@indigoai-us/hq-cli 5.108.15 → 5.108.17

package/dist/lib/mesh/live/daemon/transcript-watch.js

@@ -2,7 +2,16 @@
  * Transcript-watch fallback for hookless hosts (US-018 / AMEND-001).
  *
  * Enumerates ~/.claude/projects/ (recursive *.jsonl) and ~/.codex/sessions/
- * every 15s using only readdir + stat (mtime). Never opens or reads transcript bytes.
+ * on an adaptive interval (default 30s, backoff to 120s) using only readdir +
+ * stat (mtime). Never opens or reads transcript bytes.
+ *
+ * Scans are incremental: directory mtime is cached so unchanged directories are
+ * not re-listed; only files in changed directories (plus files still inside the
+ * active mtime window) are re-statted. Every TRANSCRIPT_WATCH_REVALIDATE_MS a
+ * cached directory is force-relisted so idle appends and coarse mtimes cannot
+ * hide changes forever. A per-tick entry cap (split across Claude/Codex roots)
+ * bounds pathological trees; capped ticks skip disappearance reconciliation.
+ * Ticks never overlap (a concurrent call is skipped).
  *
  * Session identity (deterministic):
  * - Claude: ~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl
@@ -28,7 +37,21 @@ import { deriveRemoteOwnerSlug } from "../../../work-context/repo-remote.js";
 import { isHookWrittenSessionState, readSessionState, writeSessionState, } from "../../../work-context/state.js";
 import { enqueueSessionEvent } from "../enqueue.js";
 import { isValidSessionId } from "../session-identity.js";
-export const TRANSCRIPT_WATCH_INTERVAL_MS = 15_000;
+export const TRANSCRIPT_WATCH_INTERVAL_MS = 30_000;
+/** Ceiling for adaptive backoff after heavy ticks. */
+export const TRANSCRIPT_WATCH_INTERVAL_MAX_MS = 120_000;
+/** Double the interval when a tick examines more than this many entries. */
+export const TRANSCRIPT_WATCH_BACKOFF_ENTRIES = 2_000;
+/** Double the interval when a tick takes longer than this many ms. */
+export const TRANSCRIPT_WATCH_BACKOFF_DURATION_MS = 500;
+/** Hard cap on entries examined (dir stats, readdir children, file stats) per tick. */
+export const TRANSCRIPT_WATCH_ENTRY_CAP = 20_000;
+/**
+ * Even when a directory mtime matches the cache, force a full relist (readdir +
+ * re-stat) after this many ms so content appends and coarse mtime granularity
+ * cannot hide membership or mtime changes indefinitely.
+ */
+export const TRANSCRIPT_WATCH_REVALIDATE_MS = 5 * 60_000;
 export const TRANSCRIPT_TURN_QUIET_MS = 5_000;
 export const TRANSCRIPT_SESSION_END_MS = 10 * 60_000;
 export const TRANSCRIPT_HOOK_COVER_MS = 60_000;
@@ -45,6 +68,9 @@ export const defaultTranscriptFs = {
     statSync: (p) => fs.statSync(p),
     existsSync: (p) => fs.existsSync(p),
 };
+export function createTranscriptDiscoverCache() {
+    return { dirs: new Map() };
+}
 const UUID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
 /**
  * Claude Code encodes an absolute cwd as a directory name by replacing every
@@ -89,155 +115,315 @@ export function sessionIdFromCodexTranscriptPath(filePath) {
         return null;
     return id;
 }
-function listJsonlFiles(root, tfs) {
-    if (!tfs.existsSync(root))
-        return [];
-    const out = [];
+function emptyScanMeta() {
+    return {
+        entriesExamined: 0,
+        dirsListed: 0,
+        dirsSkipped: 0,
+        filesStatted: 0,
+        capped: false,
+        cacheOverflowCleared: false,
+    };
+}
+function countCachedFiles(cache) {
+    let n = 0;
+    for (const entry of cache.dirs.values())
+        n += entry.files.length;
+    return n;
+}
+function bumpExamined(meta, entryCap) {
+    if (meta.entriesExamined >= entryCap) {
+        meta.capped = true;
+        return false;
+    }
+    meta.entriesExamined += 1;
+    return true;
+}
+function entryIsDirFile(entry, full, tfs, meta, entryCap) {
+    if (typeof entry !== "string" && typeof entry.isDirectory === "function") {
+        return { isDir: entry.isDirectory(), isFile: entry.isFile() };
+    }
+    if (!bumpExamined(meta, entryCap))
+        return null;
+    try {
+        const st = tfs.statSync(full);
+        return { isDir: st.isDirectory(), isFile: st.isFile() };
+    }
+    catch {
+        return null;
+    }
+}
+function isCodexSessionCandidate(filePath) {
+    const base = path.basename(filePath);
+    return filePath.endsWith(".jsonl") || base.startsWith("rollout-");
+}
+function pruneCacheTree(cache, root) {
     const stack = [root];
     while (stack.length > 0) {
         const dir = stack.pop();
-        let entries;
+        const entry = cache.dirs.get(dir);
+        cache.dirs.delete(dir);
+        if (!entry)
+            continue;
+        for (const sub of entry.subdirs)
+            stack.push(sub);
+    }
+}
+function buildClaudeDiscovery(filePath, mtimeMs) {
+    const sessionId = sessionIdFromClaudeTranscriptPath(filePath);
+    if (!sessionId)
+        return null;
+    const projectDir = path.basename(path.dirname(filePath));
+    const cwd = decodeClaudeProjectDirName(projectDir);
+    return {
+        path: filePath,
+        sessionId,
+        kind: "claude",
+        cwd,
+        mtimeMs,
+        harness: "claude-desktop",
+    };
+}
+function buildCodexDiscovery(filePath, mtimeMs) {
+    if (!isCodexSessionCandidate(filePath))
+        return null;
+    const sessionId = sessionIdFromCodexTranscriptPath(filePath);
+    if (!sessionId)
+        return null;
+    return {
+        path: filePath,
+        sessionId,
+        kind: "codex",
+        mtimeMs,
+        harness: "codex",
+    };
+}
+function acceptFileName(kind, name) {
+    if (kind === "claude")
+        return name.endsWith(".jsonl");
+    // Codex: keep parity with prior walk (all files; filtered when building).
+    return true;
+}
+/**
+ * Walk one transcript root with optional per-directory mtime cache.
+ * Unchanged directories skip readdir until TRANSCRIPT_WATCH_REVALIDATE_MS elapses;
+ * active-window files are still re-statted on the skip path.
+ */
+function walkTranscriptRoot(opts) {
+    const { root, kind, tfs, cache, nowMs, activeWindowMs, revalidateMs, entryCap, meta, out, visited, } = opts;
+    if (!tfs.existsSync(root)) {
+        if (cache)
+            pruneCacheTree(cache, root);
+        return;
+    }
+    const stack = [root];
+    while (stack.length > 0) {
+        if (meta.capped)
+            return;
+        const dir = stack.pop();
+        if (!bumpExamined(meta, entryCap))
+            return;
+        let dirMtime;
         try {
-            entries = tfs.readdirSync(dir, { withFileTypes: true });
+            const st = tfs.statSync(dir);
+            if (!st.isDirectory())
+                continue;
+            dirMtime = st.mtimeMs;
         }
         catch {
+            if (cache)
+                pruneCacheTree(cache, dir);
             continue;
         }
-        for (const entry of entries) {
-            const name = typeof entry === "string" ? entry : entry.name;
-            const full = path.join(dir, name);
-            let isDir;
-            let isFile;
-            if (typeof entry !== "string" && typeof entry.isDirectory === "function") {
-                isDir = entry.isDirectory();
-                isFile = entry.isFile();
-            }
-            else {
-                try {
-                    const st = tfs.statSync(full);
-                    isDir = st.isDirectory();
-                    isFile = st.isFile();
+        visited?.add(dir);
+        const cached = cache?.dirs.get(dir);
+        const cacheFresh = cached !== undefined &&
+            nowMs - cached.lastFullStatAtMs < revalidateMs;
+        if (cache && cached && cached.mtimeMs === dirMtime && cacheFresh) {
+            meta.dirsSkipped += 1;
+            for (const f of cached.files) {
+                if (meta.capped)
+                    return;
+                if (nowMs - f.mtimeMs <= activeWindowMs) {
+                    if (!bumpExamined(meta, entryCap))
+                        return;
+                    meta.filesStatted += 1;
+                    try {
+                        const st = tfs.statSync(f.path);
+                        if (!st.isFile())
+                            continue;
+                        f.mtimeMs = st.mtimeMs;
+                        out.push({ ...f });
+                    }
+                    catch {
+                        /* file gone; parent mtime should refresh on next listing */
+                    }
                 }
-                catch {
-                    continue;
+                else {
+                    out.push({ ...f });
                 }
             }
-            if (isDir) {
-                stack.push(full);
-            }
-            else if (isFile && name.endsWith(".jsonl")) {
-                out.push(full);
-            }
+            for (const sub of cached.subdirs)
+                stack.push(sub);
+            continue;
         }
-    }
-    return out;
-}
-function listCodexSessionFiles(root, tfs) {
-    if (!tfs.existsSync(root))
-        return [];
-    const out = [];
-    const stack = [root];
-    while (stack.length > 0) {
-        const dir = stack.pop();
+        meta.dirsListed += 1;
         let entries;
         try {
             entries = tfs.readdirSync(dir, { withFileTypes: true });
         }
         catch {
+            if (cache)
+                pruneCacheTree(cache, dir);
             continue;
         }
+        const files = [];
+        const subdirs = [];
+        let listingComplete = true;
         for (const entry of entries) {
+            if (!bumpExamined(meta, entryCap)) {
+                listingComplete = false;
+                break;
+            }
             const name = typeof entry === "string" ? entry : entry.name;
             const full = path.join(dir, name);
-            let isDir;
-            let isFile;
-            if (typeof entry !== "string" && typeof entry.isDirectory === "function") {
-                isDir = entry.isDirectory();
-                isFile = entry.isFile();
+            const kindFlags = entryIsDirFile(entry, full, tfs, meta, entryCap);
+            if (!kindFlags) {
+                listingComplete = false;
+                break;
             }
-            else {
-                try {
-                    const st = tfs.statSync(full);
-                    isDir = st.isDirectory();
-                    isFile = st.isFile();
-                }
-                catch {
+            if (kindFlags.isDir) {
+                subdirs.push(full);
+                stack.push(full);
+                continue;
+            }
+            if (!kindFlags.isFile || !acceptFileName(kind, name))
+                continue;
+            if (!bumpExamined(meta, entryCap)) {
+                listingComplete = false;
+                break;
+            }
+            meta.filesStatted += 1;
+            let mtimeMs;
+            try {
+                const st = tfs.statSync(full);
+                if (!st.isFile())
                     continue;
-                }
+                mtimeMs = st.mtimeMs;
             }
-            if (isDir) {
-                stack.push(full);
+            catch {
+                continue;
             }
-            else if (isFile) {
-                // Codex stores rollout-*.jsonl (and occasionally other session files).
-                out.push(full);
+            const discovered = kind === "claude"
+                ? buildClaudeDiscovery(full, mtimeMs)
+                : buildCodexDiscovery(full, mtimeMs);
+            if (!discovered)
+                continue;
+            files.push(discovered);
+            out.push({ ...discovered });
+        }
+        // Only replace the cache after a complete listing. A mid-listing cap must
+        // not overwrite a prior complete entry with a partial files/subdirs set.
+        if (cache && listingComplete) {
+            const prev = cache.dirs.get(dir);
+            if (prev) {
+                const keep = new Set(subdirs);
+                for (const sub of prev.subdirs) {
+                    if (!keep.has(sub))
+                        pruneCacheTree(cache, sub);
+                }
             }
+            cache.dirs.set(dir, {
+                mtimeMs: dirMtime,
+                files,
+                subdirs,
+                lastFullStatAtMs: nowMs,
+            });
         }
     }
-    return out;
 }
 /**
  * Enumerate transcript files with mtime only (no content read).
+ * Pass `cache` to skip readdir on directories whose mtime is unchanged
+ * (until TRANSCRIPT_WATCH_REVALIDATE_MS forces a relist).
+ *
+ * Each root gets half of `entryCap`; unused budget from the first root is
+ * available to the second so a huge Claude tree cannot starve Codex.
  */
-export function discoverTranscripts(opts) {
+export function discoverTranscriptsWithMeta(opts = {}) {
     const home = opts.home ?? os.homedir();
     const tfs = opts.fs ?? defaultTranscriptFs;
     const claudeRoot = opts.claudeProjectsDir ?? path.join(home, ".claude", "projects");
     const codexRoot = opts.codexSessionsDir ?? path.join(home, ".codex", "sessions");
-    const found = [];
-    for (const filePath of listJsonlFiles(claudeRoot, tfs)) {
-        const sessionId = sessionIdFromClaudeTranscriptPath(filePath);
-        if (!sessionId)
-            continue;
-        let mtimeMs;
-        try {
-            const st = tfs.statSync(filePath);
-            if (!st.isFile())
-                continue;
-            mtimeMs = st.mtimeMs;
-        }
-        catch {
-            continue;
-        }
-        const projectDir = path.basename(path.dirname(filePath));
-        const cwd = decodeClaudeProjectDirName(projectDir);
-        found.push({
-            path: filePath,
-            sessionId,
-            kind: "claude",
-            cwd,
-            mtimeMs,
-            harness: "claude-desktop",
-        });
+    const cache = opts.cache ?? null;
+    const nowMs = opts.nowMs ?? Date.now();
+    const entryCap = opts.entryCap ?? TRANSCRIPT_WATCH_ENTRY_CAP;
+    const activeWindowMs = opts.activeWindowMs ?? TRANSCRIPT_FRESH_MS;
+    const revalidateMs = TRANSCRIPT_WATCH_REVALIDATE_MS;
+    const meta = emptyScanMeta();
+    const transcripts = [];
+    const visited = cache ? new Set() : null;
+    // Per-root budgets: first root limited to half; remainder rolls to second.
+    const firstRootBudget = Math.floor(entryCap / 2);
+    walkTranscriptRoot({
+        root: claudeRoot,
+        kind: "claude",
+        tfs,
+        cache,
+        nowMs,
+        activeWindowMs,
+        revalidateMs,
+        entryCap: firstRootBudget,
+        meta,
+        out: transcripts,
+        visited,
+    });
+    const firstRootIncomplete = meta.capped;
+    // Allow the second root to consume leftover budget up to the global cap.
+    if (meta.capped && meta.entriesExamined < entryCap) {
+        meta.capped = false;
     }
-    for (const filePath of listCodexSessionFiles(codexRoot, tfs)) {
-        if (!filePath.endsWith(".jsonl") && !path.basename(filePath).startsWith("rollout-")) {
-            // Prefer jsonl; still accept rollout-* without extension edge cases via id parse.
-            if (!path.basename(filePath).startsWith("rollout-"))
-                continue;
-        }
-        const sessionId = sessionIdFromCodexTranscriptPath(filePath);
-        if (!sessionId)
-            continue;
-        let mtimeMs;
-        try {
-            const st = tfs.statSync(filePath);
-            if (!st.isFile())
-                continue;
-            mtimeMs = st.mtimeMs;
-        }
-        catch {
-            continue;
+    walkTranscriptRoot({
+        root: codexRoot,
+        kind: "codex",
+        tfs,
+        cache,
+        nowMs,
+        activeWindowMs,
+        revalidateMs,
+        entryCap,
+        meta,
+        out: transcripts,
+        visited,
+    });
+    meta.capped = meta.capped || firstRootIncomplete;
+    if (cache && !meta.capped && visited) {
+        for (const key of [...cache.dirs.keys()]) {
+            if (!visited.has(key))
+                cache.dirs.delete(key);
         }
-        found.push({
-            path: filePath,
-            sessionId,
-            kind: "codex",
-            mtimeMs,
-            harness: "codex",
-        });
     }
-    return found;
+    // Bound by the production constant (not a test-reduced entryCap) so a low
+    // scan budget cannot wipe a still-valid cache.
+    if (cache && countCachedFiles(cache) > TRANSCRIPT_WATCH_ENTRY_CAP) {
+        cache.dirs.clear();
+        meta.cacheOverflowCleared = true;
+    }
+    return { transcripts, meta };
+}
+/**
+ * Enumerate transcript files with mtime only (no content read).
+ * Without a cache this is a full walk; with `cache` it is incremental.
+ */
+export function discoverTranscripts(opts = {}) {
+    return discoverTranscriptsWithMeta(opts).transcripts;
+}
+/** Sort key for comparing discovery results independent of walk order. */
+export function discoveryFingerprint(d) {
+    return `${d.path}\0${d.sessionId}\0${d.kind}\0${d.mtimeMs}\0${d.cwd ?? ""}\0${d.harness}`;
+}
+export function sortDiscoveries(items) {
+    return [...items].sort((a, b) => a.path.localeCompare(b.path));
 }
 /**
  * Whether hooks already cover this session: durable hook-written state, or a
@@ -350,6 +536,11 @@ export class TranscriptWatcher {
     readState;
     writeState;
     reconcileFn;
+    discoverCache = createTranscriptDiscoverCache();
+    intervalMs = TRANSCRIPT_WATCH_INTERVAL_MS;
+    tickInFlight = false;
+    /** Tracks contiguous capped ticks so we log once per cap episode. */
+    inCapEpisode = false;
     constructor(deps) {
         this.deps = deps;
         this.tfs = deps.fs ?? defaultTranscriptFs;
@@ -358,6 +549,14 @@ export class TranscriptWatcher {
         this.writeState = deps.writeState ?? writeSessionState;
         this.reconcileFn = deps.reconcile ?? reconcileObservation;
     }
+    /** Current adaptive poll interval (after the last tick's backoff). */
+    getIntervalMs() {
+        return this.intervalMs;
+    }
+    /** Expose discovery cache for tests. */
+    getDiscoverCache() {
+        return this.discoverCache;
+    }
     /** Record that a hook path emitted an event for sessionId (daemon flush). */
     noteHookEvent(sessionId, atMs) {
         const map = this.deps.lastHookEventAt;
@@ -366,97 +565,158 @@ export class TranscriptWatcher {
         map.set(sessionId, atMs ?? (this.deps.now?.() ?? Date.now()));
     }
     async tick() {
-        const nowMs = this.deps.now?.() ?? Date.now();
-        const home = this.deps.home ?? os.homedir();
-        const result = {
+        const previousIntervalMs = this.intervalMs;
+        const idle = () => ({
             discovered: 0,
             started: 0,
             turns: 0,
             ended: 0,
             skippedHookCovered: 0,
             skippedStale: 0,
-        };
-        const discovered = discoverTranscripts({
-            home,
-            fs: this.tfs,
-            claudeProjectsDir: this.deps.claudeProjectsDir,
-            codexSessionsDir: this.deps.codexSessionsDir,
+            entriesExamined: 0,
+            durationMs: 0,
+            capped: false,
+            capEpisodeStart: false,
+            cacheOverflowCleared: false,
+            intervalMs: this.intervalMs,
+            previousIntervalMs,
+            intervalChanged: false,
+            skippedConcurrent: true,
         });
-        result.discovered = discovered.length;
-        const seenPaths = new Set();
-        for (const d of discovered) {
-            seenPaths.add(d.path);
-            if (isTranscriptHookCovered(d.sessionId, {
-                workContextRoot: this.deps.workContextRoot,
+        if (this.tickInFlight)
+            return idle();
+        this.tickInFlight = true;
+        // Wall clock for backoff — independent of injectable session `now`.
+        const wallStartedAt = Date.now();
+        try {
+            const nowMs = this.deps.now?.() ?? Date.now();
+            const home = this.deps.home ?? os.homedir();
+            const result = {
+                discovered: 0,
+                started: 0,
+                turns: 0,
+                ended: 0,
+                skippedHookCovered: 0,
+                skippedStale: 0,
+                entriesExamined: 0,
+                durationMs: 0,
+                capped: false,
+                capEpisodeStart: false,
+                cacheOverflowCleared: false,
+                intervalMs: this.intervalMs,
+                previousIntervalMs,
+                intervalChanged: false,
+                skippedConcurrent: false,
+            };
+            const { transcripts: discovered, meta } = discoverTranscriptsWithMeta({
+                home,
+                fs: this.tfs,
+                claudeProjectsDir: this.deps.claudeProjectsDir,
+                codexSessionsDir: this.deps.codexSessionsDir,
+                cache: this.discoverCache,
                 nowMs,
-                lastHookEventAt: this.deps.lastHookEventAt,
-                readState: this.readState,
-            })) {
-                result.skippedHookCovered += 1;
-                this.tracked.delete(d.path);
-                continue;
-            }
-            let track = this.tracked.get(d.path);
-            if (!track) {
-                // First sight: only adopt fresh or actively-written transcripts.
-                if (nowMs - d.mtimeMs > TRANSCRIPT_FRESH_MS) {
-                    result.skippedStale += 1;
+                entryCap: this.deps.entryCap,
+            });
+            result.discovered = discovered.length;
+            result.entriesExamined = meta.entriesExamined;
+            result.capped = meta.capped;
+            result.capEpisodeStart = meta.capped && !this.inCapEpisode;
+            this.inCapEpisode = meta.capped;
+            result.cacheOverflowCleared = meta.cacheOverflowCleared;
+            const seenPaths = new Set();
+            for (const d of discovered) {
+                seenPaths.add(d.path);
+                if (isTranscriptHookCovered(d.sessionId, {
+                    workContextRoot: this.deps.workContextRoot,
+                    nowMs,
+                    lastHookEventAt: this.deps.lastHookEventAt,
+                    readState: this.readState,
+                })) {
+                    result.skippedHookCovered += 1;
+                    this.tracked.delete(d.path);
                     continue;
                 }
-                track = {
-                    path: d.path,
-                    sessionId: d.sessionId,
-                    kind: d.kind,
-                    cwd: d.cwd,
-                    harness: d.harness,
-                    lastMtimeMs: d.mtimeMs,
-                    lastChangeAtMs: d.mtimeMs,
-                    started: false,
-                    ended: false,
-                    pendingTurn: false,
-                    seq: 0,
-                };
-                this.tracked.set(d.path, track);
-                const started = await this.emitStart(track, nowMs);
-                if (started)
-                    result.started += 1;
-                continue;
-            }
-            if (track.ended)
-                continue;
-            if (d.mtimeMs > track.lastMtimeMs) {
-                track.lastMtimeMs = d.mtimeMs;
-                track.lastChangeAtMs = nowMs;
-                if (track.started) {
-                    track.pendingTurn = true;
+                let track = this.tracked.get(d.path);
+                if (!track) {
+                    // First sight: only adopt fresh or actively-written transcripts.
+                    if (nowMs - d.mtimeMs > TRANSCRIPT_FRESH_MS) {
+                        result.skippedStale += 1;
+                        continue;
+                    }
+                    track = {
+                        path: d.path,
+                        sessionId: d.sessionId,
+                        kind: d.kind,
+                        cwd: d.cwd,
+                        harness: d.harness,
+                        lastMtimeMs: d.mtimeMs,
+                        lastChangeAtMs: d.mtimeMs,
+                        started: false,
+                        ended: false,
+                        pendingTurn: false,
+                        seq: 0,
+                    };
+                    this.tracked.set(d.path, track);
+                    const started = await this.emitStart(track, nowMs);
+                    if (started)
+                        result.started += 1;
+                    continue;
+                }
+                if (track.ended)
+                    continue;
+                if (d.mtimeMs > track.lastMtimeMs) {
+                    track.lastMtimeMs = d.mtimeMs;
+                    track.lastChangeAtMs = nowMs;
+                    if (track.started) {
+                        track.pendingTurn = true;
+                    }
+                }
+                if (track.pendingTurn &&
+                    nowMs - track.lastChangeAtMs >= TRANSCRIPT_TURN_QUIET_MS) {
+                    this.emitKind(track, "turn_end", nowMs);
+                    track.pendingTurn = false;
+                    result.turns += 1;
+                }
+                if (track.started &&
+                    !track.ended &&
+                    nowMs - track.lastChangeAtMs >= TRANSCRIPT_SESSION_END_MS) {
+                    this.emitKind(track, "session_end", nowMs);
+                    track.ended = true;
+                    result.ended += 1;
                 }
             }
-            if (track.pendingTurn &&
-                nowMs - track.lastChangeAtMs >= TRANSCRIPT_TURN_QUIET_MS) {
-                this.emitKind(track, "turn_end", nowMs);
-                track.pendingTurn = false;
-                result.turns += 1;
-            }
-            if (track.started &&
-                !track.ended &&
-                nowMs - track.lastChangeAtMs >= TRANSCRIPT_SESSION_END_MS) {
-                this.emitKind(track, "session_end", nowMs);
-                track.ended = true;
-                result.ended += 1;
+            // Sessions that disappeared from disk: end if still open. Skip when the
+            // walk was capped — missing paths may simply be unvisited, not gone.
+            if (!meta.capped) {
+                for (const [p, track] of [...this.tracked.entries()]) {
+                    if (seenPaths.has(p))
+                        continue;
+                    if (track.started && !track.ended) {
+                        this.emitKind(track, "session_end", nowMs);
+                        track.ended = true;
+                        result.ended += 1;
+                    }
+                    this.tracked.delete(p);
+                }
             }
+            result.durationMs = Math.max(0, Date.now() - wallStartedAt);
+            this.applyIntervalBackoff(result.entriesExamined, result.durationMs);
+            result.intervalMs = this.intervalMs;
+            result.intervalChanged = this.intervalMs !== previousIntervalMs;
+            return result;
         }
-        // Sessions that disappeared from disk: end if still open.
-        for (const [p, track] of [...this.tracked.entries()]) {
-            if (seenPaths.has(p))
-                continue;
-            if (track.started && !track.ended) {
-                this.emitKind(track, "session_end", nowMs);
-                track.ended = true;
-                result.ended += 1;
-            }
-            this.tracked.delete(p);
+        finally {
+            this.tickInFlight = false;
         }
-        return result;
+    }
+    /**
+     * Heavy ticks double the poll interval up to MAX; a quiet tick resets to base.
+     */
+    applyIntervalBackoff(entriesExamined, durationMs) {
+        this.intervalMs = nextTranscriptWatchIntervalMs(this.intervalMs, {
+            entriesExamined,
+            durationMs,
+        });
     }
     /**
      * Register via reconcileObservation (membership-validated slug→uid), then
@@ -517,4 +777,15 @@ export class TranscriptWatcher {
         this.enqueueFn(opts);
     }
 }
+/**
+ * Adaptive interval: busy ticks double up to MAX; quiet ticks return to base.
+ */
+export function nextTranscriptWatchIntervalMs(currentMs, opts) {
+    const busy = opts.entriesExamined > TRANSCRIPT_WATCH_BACKOFF_ENTRIES ||
+        opts.durationMs > TRANSCRIPT_WATCH_BACKOFF_DURATION_MS;
+    if (busy) {
+        return Math.min(currentMs * 2, TRANSCRIPT_WATCH_INTERVAL_MAX_MS);
+    }
+    return TRANSCRIPT_WATCH_INTERVAL_MS;
+}
 //# sourceMappingURL=transcript-watch.js.map