ahp-inspector 1.4.1 → 1.4.3

package/dist/index.js

@@ -2,48 +2,156 @@
 
 // src/index.ts
 import { existsSync as existsSync2, readFileSync, statSync as statSync3 } from "fs";
-import { dirname as dirname3, join as join7, resolve as resolvePath } from "path";
+import { dirname as dirname5, join as join7, resolve as resolvePath } from "path";
 import { fileURLToPath } from "url";
 
 // ../host-node/src/discovery.ts
 import { createHash } from "crypto";
-import { readdir, stat } from "fs/promises";
 import { homedir } from "os";
-import { basename, join, sep } from "path";
+import { basename as basename2, dirname as dirname2, isAbsolute, join as join2, relative, sep } from "path";
+
+// ../host-node/src/bounded-log-discovery.ts
+import { opendir, stat } from "fs/promises";
+import { basename, dirname, join } from "path";
+async function scanConfiguredRoots(options) {
+  const now = options.now ?? Date.now;
+  const maxDepthBelowLaunch = options.maxDepthBelowLaunch ?? 3;
+  const rootResults = [];
+  for (const [rootIndex, root] of options.roots.entries()) {
+    const state = {
+      stats: 0,
+      immediateEntries: 0,
+      truncated: false,
+      startedAt: now(),
+      files: []
+    };
+    const launchEntries = [];
+    let rootDirectory;
+    try {
+      rootDirectory = await opendir(root.dir);
+      while (true) {
+        if (rootScanOverBudget(state, options, now, true)) break;
+        const entry = await rootDirectory.read();
+        if (!entry) break;
+        state.immediateEntries++;
+        const absPath = join(root.dir, entry.name);
+        const entryStat = await boundedStat(absPath, state, options, now);
+        if (!entryStat) continue;
+        if (entryStat.isDirectory()) {
+          launchEntries.push({ absPath, mtimeMs: entryStat.mtimeMs });
+        } else if (entryStat.isFile() && options.matchesFilename(entry.name)) {
+          state.files.push(toScannedFile(absPath, root.dir, entryStat.mtimeMs, entryStat.size));
+        }
+      }
+    } catch {
+    } finally {
+      await rootDirectory?.close().catch(() => {
+      });
+    }
+    launchEntries.sort((left, right) => right.mtimeMs - left.mtimeMs);
+    if (launchEntries.length > options.topLaunchDirs) state.truncated = true;
+    for (const launch of launchEntries.slice(0, options.topLaunchDirs)) {
+      if (rootScanOverBudget(state, options, now, false)) break;
+      await walkLaunchDirectory(launch.absPath, launch.absPath, maxDepthBelowLaunch, state, options, now);
+    }
+    rootResults.push({
+      rootIndex,
+      files: state.files,
+      truncated: state.truncated,
+      statsAttempted: state.stats,
+      immediateEntriesExamined: state.immediateEntries
+    });
+  }
+  return { roots: rootResults, truncated: rootResults.some((root) => root.truncated) };
+}
+async function walkLaunchDirectory(absDir, launchDir, depthLeft, state, options, now) {
+  if (depthLeft < 0 || rootScanOverBudget(state, options, now, false)) return;
+  let directory;
+  try {
+    directory = await opendir(absDir);
+    while (true) {
+      if (rootScanOverBudget(state, options, now, false)) return;
+      const entry = await directory.read();
+      if (!entry) return;
+      const absPath = join(absDir, entry.name);
+      const entryStat = await boundedStat(absPath, state, options, now);
+      if (!entryStat) continue;
+      if (entryStat.isDirectory()) {
+        if (depthLeft === 0) {
+          state.truncated = true;
+        } else {
+          await walkLaunchDirectory(absPath, launchDir, depthLeft - 1, state, options, now);
+        }
+      } else if (entryStat.isFile() && options.matchesFilename(entry.name)) {
+        state.files.push(toScannedFile(absPath, launchDir, entryStat.mtimeMs, entryStat.size));
+      }
+    }
+  } catch {
+  } finally {
+    await directory?.close().catch(() => {
+    });
+  }
+}
+async function boundedStat(absPath, state, options, now) {
+  if (rootScanOverBudget(state, options, now, false)) return void 0;
+  state.stats++;
+  try {
+    return await stat(absPath);
+  } catch {
+    return void 0;
+  }
+}
+function rootScanOverBudget(state, options, now, includeImmediateEntries) {
+  const overBudget = state.stats >= options.maxStats || now() - state.startedAt >= options.timeBudgetMs || includeImmediateEntries && state.immediateEntries >= options.maxImmediateEntries;
+  if (overBudget) state.truncated = true;
+  return overBudget;
+}
+function toScannedFile(absPath, launchDir, mtimeMs, sizeBytes) {
+  return {
+    absPath,
+    name: basename(absPath),
+    parentDir: dirname(absPath),
+    launchDir,
+    mtimeMs,
+    sizeBytes
+  };
+}
+
+// ../host-node/src/discovery.ts
 var DEFAULT_TIME_BUDGET_MS = 1500;
 var DEFAULT_MAX_STATS = 5e3;
+var DEFAULT_MAX_IMMEDIATE_ENTRIES = 5e3;
 var DEFAULT_TOP_LAUNCH_DIRS = 10;
-var MAX_LAUNCH_LIST = 50;
 var MAX_RESULTS = 200;
 var MAX_DEPTH_BELOW_LAUNCH = 3;
 function defaultRoots() {
   const home = homedir();
   const platform = process.platform;
   const ossDevRoots = [
-    { origin: "vscode-oss-dev", dir: join(home, ".vscode-oss-dev", "logs") },
-    { origin: "vscode-oss-dev", dir: join(home, ".vscode-oss-agents-dev", "logs") }
+    { origin: "vscode-oss-dev", dir: join2(home, ".vscode-oss-dev", "logs") },
+    { origin: "vscode-oss-dev", dir: join2(home, ".vscode-oss-agents-dev", "logs") }
   ];
   if (platform === "darwin") {
     return [
-      { origin: "vscode", dir: join(home, "Library", "Application Support", "Code", "logs") },
+      { origin: "vscode", dir: join2(home, "Library", "Application Support", "Code", "logs") },
       {
         origin: "vscode-insiders",
-        dir: join(home, "Library", "Application Support", "Code - Insiders", "logs")
+        dir: join2(home, "Library", "Application Support", "Code - Insiders", "logs")
       },
       ...ossDevRoots
     ];
   }
   if (platform === "win32") {
-    const appData = process.env.APPDATA ?? join(home, "AppData", "Roaming");
+    const appData = process.env.APPDATA ?? join2(home, "AppData", "Roaming");
     return [
-      { origin: "vscode", dir: join(appData, "Code", "logs") },
-      { origin: "vscode-insiders", dir: join(appData, "Code - Insiders", "logs") },
+      { origin: "vscode", dir: join2(appData, "Code", "logs") },
+      { origin: "vscode-insiders", dir: join2(appData, "Code - Insiders", "logs") },
       ...ossDevRoots
     ];
   }
   return [
-    { origin: "vscode", dir: join(home, ".config", "Code", "logs") },
-    { origin: "vscode-insiders", dir: join(home, ".config", "Code - Insiders", "logs") },
+    { origin: "vscode", dir: join2(home, ".config", "Code", "logs") },
+    { origin: "vscode-insiders", dir: join2(home, ".config", "Code - Insiders", "logs") },
     ...ossDevRoots
   ];
 }
@@ -70,132 +178,97 @@ function makeId(absPath) {
   return createHash("sha256").update(absPath).digest("hex").slice(0, 32);
 }
 function makeContextLabel(absPath, launchDir) {
-  const idx = absPath.indexOf(launchDir);
-  if (idx < 0) return "";
-  const tail = absPath.slice(idx).split(sep).filter(Boolean);
-  tail.pop();
-  return tail.join(" / ");
+  const relativeParent = relative(launchDir, dirname2(absPath));
+  if (relativeParent === "" || relativeParent === ".") return "";
+  if (isAbsolute(relativeParent) || relativeParent === ".." || relativeParent.startsWith(`..${sep}`)) return "";
+  return [basename2(launchDir), ...relativeParent.split(sep).filter(Boolean)].join(" / ");
 }
 var idToPath = /* @__PURE__ */ new Map();
+var discoveryGeneration = 0;
 function resolveCandidateId(id) {
   return idToPath.get(id) ?? null;
 }
 async function discoverVsCodeLogs(opts = {}) {
   const roots = opts.roots ?? defaultRoots();
-  const timeBudget = opts.timeBudgetMs ?? DEFAULT_TIME_BUDGET_MS;
-  const maxStats = opts.maxStats ?? DEFAULT_MAX_STATS;
-  const topLaunch = opts.topLaunchDirs ?? DEFAULT_TOP_LAUNCH_DIRS;
-  const now = opts.now ?? Date.now;
-  const startedAt = now();
-  let stats = 0;
-  let truncated = false;
-  const collected = [];
+  const generation = ++discoveryGeneration;
   idToPath.clear();
-  const overBudget = () => stats >= maxStats || now() - startedAt >= timeBudget;
-  for (const root of roots) {
-    if (overBudget()) {
-      truncated = true;
-      break;
-    }
-    const launchEntries = [];
-    try {
-      const names = await readdir(root.dir);
-      const limited = names.slice(0, MAX_LAUNCH_LIST);
-      for (const name of limited) {
-        if (overBudget()) {
-          truncated = true;
-          break;
-        }
-        try {
-          const st = await stat(join(root.dir, name));
-          stats++;
-          if (st.isDirectory()) launchEntries.push({ name, mtimeMs: st.mtimeMs });
-        } catch {
-        }
-      }
-    } catch {
-      continue;
-    }
-    launchEntries.sort((a, b) => b.mtimeMs - a.mtimeMs);
-    const topEntries = launchEntries.slice(0, topLaunch);
-    for (const launch of topEntries) {
-      if (overBudget()) {
-        truncated = true;
-        break;
-      }
-      const launchDir = join(root.dir, launch.name);
-      await walkBounded(
-        launchDir,
-        launchDir,
-        MAX_DEPTH_BELOW_LAUNCH,
-        root.origin,
-        collected,
-        () => {
-          stats++;
-          return overBudget();
-        }
-      );
-    }
-  }
-  const out = collected.map((c) => c).sort((a, b) => {
-    const order = { high: 0, medium: 1, low: 2 };
-    const av = order[a.confidence];
-    const bv = order[b.confidence];
-    if (av !== bv) return av - bv;
-    return b.mtimeMs - a.mtimeMs;
-  }).slice(0, MAX_RESULTS);
-  return { candidates: out, truncated };
-  async function walkBounded(absDir, launchDir, depthLeft, origin, sink, tickAndCheck) {
-    if (depthLeft < 0) return;
-    let names;
-    try {
-      names = await readdir(absDir);
-    } catch {
-      return;
-    }
-    for (const name of names) {
-      if (tickAndCheck()) {
-        truncated = true;
-        return;
-      }
-      const abs = join(absDir, name);
-      let st;
-      try {
-        st = await stat(abs);
-      } catch {
-        continue;
-      }
-      if (st.isDirectory()) {
-        await walkBounded(abs, launchDir, depthLeft - 1, origin, sink, tickAndCheck);
-        continue;
-      }
-      if (!st.isFile()) continue;
-      const ok = FILENAME_RE_AHP_JSONL.test(name) || FILENAME_RE_AHP_NAMED_JSONL.test(name);
-      if (!ok) continue;
-      const sc = score(name, st.mtimeMs, st.size, absDir);
-      const id = makeId(abs);
-      idToPath.set(id, abs);
-      const confidence = tier(sc);
-      sink.push({
-        id,
-        label: basename(abs),
-        mtimeMs: st.mtimeMs,
-        sizeBytes: st.size,
-        origin,
-        confidence,
-        contextLabel: makeContextLabel(abs, launchDir)
-      });
-      if (sink.length >= MAX_RESULTS * 4) {
-        truncated = true;
-        return;
-      }
+  const scan = await scanConfiguredRoots({
+    roots,
+    matchesFilename: matchesAhpFilename,
+    timeBudgetMs: opts.timeBudgetMs ?? DEFAULT_TIME_BUDGET_MS,
+    maxStats: opts.maxStats ?? DEFAULT_MAX_STATS,
+    maxImmediateEntries: opts.maxImmediateEntries ?? DEFAULT_MAX_IMMEDIATE_ENTRIES,
+    topLaunchDirs: opts.topLaunchDirs ?? DEFAULT_TOP_LAUNCH_DIRS,
+    maxDepthBelowLaunch: MAX_DEPTH_BELOW_LAUNCH,
+    now: opts.now ?? Date.now
+  });
+  const populatedRoots = scan.roots.map((scannedRoot) => {
+    const root = roots[scannedRoot.rootIndex];
+    if (!root) return [];
+    return scannedRoot.files.map((file) => toPickerCandidate(file, root.origin)).sort(comparePickerCandidates);
+  }).filter((candidates) => candidates.length > 0);
+  const effectiveResultCap = Math.max(MAX_RESULTS, populatedRoots.length);
+  const retained = [];
+  const retainedPaths = /* @__PURE__ */ new Set();
+  for (const candidates of populatedRoots) {
+    const candidate = candidates[0];
+    if (!candidate || retainedPaths.has(candidate.absPath)) continue;
+    retained.push(candidate);
+    retainedPaths.add(candidate.absPath);
+  }
+  const remainingCapacity = effectiveResultCap - retained.length;
+  const extraQuota = populatedRoots.length > 0 ? Math.floor(remainingCapacity / populatedRoots.length) : 0;
+  for (const candidates of populatedRoots) {
+    for (const candidate of candidates.slice(1, 1 + extraQuota)) {
+      if (retainedPaths.has(candidate.absPath)) continue;
+      retained.push(candidate);
+      retainedPaths.add(candidate.absPath);
+    }
+  }
+  const fillCandidates = populatedRoots.flat().filter((candidate) => !retainedPaths.has(candidate.absPath)).sort(comparePickerCandidates);
+  for (const candidate of fillCandidates) {
+    if (retained.length >= effectiveResultCap) break;
+    if (retainedPaths.has(candidate.absPath)) continue;
+    retained.push(candidate);
+    retainedPaths.add(candidate.absPath);
+  }
+  retained.sort(comparePickerCandidates);
+  if (generation === discoveryGeneration) {
+    idToPath.clear();
+    for (const candidate of retained) idToPath.set(candidate.safe.id, candidate.absPath);
+  }
+  const totalCandidateCount = new Set(populatedRoots.flat().map((candidate) => candidate.absPath)).size;
+  return {
+    candidates: retained.map((candidate) => candidate.safe),
+    truncated: scan.truncated || retained.length < totalCandidateCount
+  };
+}
+function toPickerCandidate(file, origin) {
+  const confidence = tier(score(file.name, file.mtimeMs, file.sizeBytes, file.parentDir));
+  return {
+    absPath: file.absPath,
+    safe: {
+      id: makeId(file.absPath),
+      label: file.name,
+      mtimeMs: file.mtimeMs,
+      sizeBytes: file.sizeBytes,
+      origin,
+      confidence,
+      contextLabel: makeContextLabel(file.absPath, file.launchDir)
     }
-  }
+  };
+}
+function comparePickerCandidates(left, right) {
+  const order = { high: 0, medium: 1, low: 2 };
+  const confidenceDifference = order[left.safe.confidence] - order[right.safe.confidence];
+  return confidenceDifference || right.safe.mtimeMs - left.safe.mtimeMs;
+}
+function matchesAhpFilename(name) {
+  return FILENAME_RE_AHP_JSONL.test(name) || FILENAME_RE_AHP_NAMED_JSONL.test(name);
 }
 
 // ../host-node/src/find-latest-ahp-log.ts
-import { open as fsOpen, readdir as readdir2, stat as stat2 } from "fs/promises";
-import { join as join2 } from "path";
+import { open as fsOpen } from "fs/promises";
 
 // ../parser/src/jsonl.ts
 var MAX_BUF_BYTES = 16 * 1024 * 1024;
@@ -391,6 +464,13 @@ function objectChild(parent, key) {
   return typeof child === "object" && child !== null ? child : null;
 }
 function candidateObjects(p) {
+  if (Array.isArray(p)) {
+    const items = [];
+    for (const item of p) {
+      if (typeof item === "object" && item !== null) items.push(item);
+    }
+    return items;
+  }
   const out = [p];
   const action = objectChild(p, "action");
   if (action) out.push(action);
@@ -405,7 +485,25 @@ function sessionFromObject(p) {
     const uri = session.uri;
     if (typeof uri === "string") return uri;
   }
-  return asString(p.sessionId);
+  const sessionId = asString(p.sessionId);
+  if (sessionId) return sessionId;
+  const channel = asString(p.channel);
+  if (channel) return channel;
+  const terminal = asString(p.terminal);
+  if (terminal) return terminal;
+  const resource = asString(p.resource);
+  if (resource) return resource;
+  const external = asString(p.external);
+  if (external) return external;
+  const scheme = asString(p.scheme);
+  const path = asString(p.path);
+  if (scheme && path) return `${scheme}:${path}`;
+  const summary = p.summary;
+  if (typeof summary === "object" && summary !== null) {
+    const summaryResource = asString(summary.resource);
+    if (summaryResource) return summaryResource;
+  }
+  return null;
 }
 function turnFromObject(p) {
   const fromTop = asString(p.turnId);
@@ -550,55 +648,29 @@ function extractWireMeta(raw2) {
 // ../host-node/src/find-latest-ahp-log.ts
 var DEFAULT_TIME_BUDGET_MS2 = 1500;
 var DEFAULT_MAX_STATS2 = 5e3;
-var MAX_DEPTH_BELOW_ROOT = 5;
-var MAX_PROBE_CANDIDATES = 10;
+var DEFAULT_MAX_IMMEDIATE_ENTRIES2 = 5e3;
+var DEFAULT_TOP_LAUNCH_DIRS2 = 10;
+var MAX_DEPTH_BELOW_LAUNCH2 = 4;
 var PROBE_READ_BYTES = 64 * 1024;
 async function findLatestAhpLog(opts = {}) {
   const roots = opts.rootsOverride ?? defaultRoots();
-  const startedAt = Date.now();
-  let stats = 0;
-  const overBudget = () => stats >= DEFAULT_MAX_STATS2 || Date.now() - startedAt >= DEFAULT_TIME_BUDGET_MS2;
-  const collected = [];
-  for (const root of roots) {
-    if (overBudget()) break;
-    await walk(root.dir, MAX_DEPTH_BELOW_ROOT, collected, () => {
-      stats++;
-      return overBudget();
-    });
-  }
-  const ranked = collected.filter((c) => c.sizeBytes > 0).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, MAX_PROBE_CANDIDATES);
-  for (const c of ranked) {
-    if (await probeAhpShape(c.absPath)) return c.absPath;
+  const scan = await scanConfiguredRoots({
+    roots,
+    matchesFilename: matchesAhpFilename2,
+    timeBudgetMs: DEFAULT_TIME_BUDGET_MS2,
+    maxStats: DEFAULT_MAX_STATS2,
+    maxImmediateEntries: DEFAULT_MAX_IMMEDIATE_ENTRIES2,
+    topLaunchDirs: DEFAULT_TOP_LAUNCH_DIRS2,
+    maxDepthBelowLaunch: MAX_DEPTH_BELOW_LAUNCH2
+  });
+  const ranked = scan.roots.flatMap((root) => root.files).filter((candidate) => candidate.sizeBytes > 0).sort((left, right) => right.mtimeMs - left.mtimeMs);
+  for (const candidate of ranked) {
+    if (await probeAhpShape(candidate.absPath)) return candidate.absPath;
   }
   return null;
 }
-async function walk(absDir, depthLeft, sink, tickAndCheck) {
-  if (depthLeft < 0) return;
-  let names;
-  try {
-    names = await readdir2(absDir);
-  } catch {
-    return;
-  }
-  for (const name of names) {
-    if (tickAndCheck()) return;
-    const abs = join2(absDir, name);
-    let st;
-    try {
-      st = await stat2(abs);
-    } catch {
-      continue;
-    }
-    if (st.isDirectory()) {
-      await walk(abs, depthLeft - 1, sink, tickAndCheck);
-      continue;
-    }
-    if (!st.isFile()) continue;
-    if (!(FILENAME_RE_AHP_JSONL.test(name) || FILENAME_RE_AHP_NAMED_JSONL.test(name))) {
-      continue;
-    }
-    sink.push({ absPath: abs, mtimeMs: st.mtimeMs, sizeBytes: st.size });
-  }
+function matchesAhpFilename2(name) {
+  return FILENAME_RE_AHP_JSONL.test(name) || FILENAME_RE_AHP_NAMED_JSONL.test(name);
 }
 async function probeAhpShape(absPath) {
   let fh;
@@ -637,7 +709,7 @@ async function probeAhpShape(absPath) {
 
 // ../host-node/src/host-adapter.ts
 import { accessSync, constants, statSync } from "fs";
-import { basename as basename4, resolve as pathResolve } from "path";
+import { basename as basename5, resolve as pathResolve } from "path";
 
 // ../host-node/src/tail-reader.ts
 import { createReadStream } from "fs";
@@ -646,11 +718,11 @@ import { stat as fsStat } from "fs/promises";
 // ../../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
 import { EventEmitter } from "events";
 import { stat as statcb, Stats } from "fs";
-import { readdir as readdir4, stat as stat5 } from "fs/promises";
+import { readdir as readdir2, stat as stat4 } from "fs/promises";
 import * as sp2 from "path";
 
 // ../../node_modules/.pnpm/readdirp@5.0.0/node_modules/readdirp/index.js
-import { lstat, readdir as readdir3, realpath, stat as stat3 } from "fs/promises";
+import { lstat, readdir, realpath, stat as stat2 } from "fs/promises";
 import { join as pjoin, relative as prelative, resolve as presolve, sep as psep } from "path";
 import { Readable } from "stream";
 var EntryTypes = {
@@ -731,7 +803,7 @@ var ReaddirpStream = class extends Readable {
     const { root, type } = opts;
     this._fileFilter = normalizeFilter(opts.fileFilter);
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
-    const statMethod = opts.lstat ? lstat : stat3;
+    const statMethod = opts.lstat ? lstat : stat2;
     if (wantBigintFsStats) {
       this._stat = (path) => statMethod(path, { bigint: true });
     } else {
@@ -802,7 +874,7 @@ var ReaddirpStream = class extends Readable {
   async _exploreDir(path, depth) {
     let files;
     try {
-      files = await readdir3(path, this._rdOptions);
+      files = await readdir(path, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
@@ -810,10 +882,10 @@ var ReaddirpStream = class extends Readable {
   }
   async _formatEntry(dirent, path) {
     let entry;
-    const basename6 = this._isDirent ? dirent.name : dirent;
+    const basename7 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path, basename6));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename6 };
+      const fullPath = presolve(pjoin(path, basename7));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename7 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -884,7 +956,7 @@ function readdirp(root, options = {}) {
 
 // ../../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/handler.js
 import { watch as fs_watch, unwatchFile, watchFile } from "fs";
-import { realpath as fsrealpath, lstat as lstat2, open, stat as stat4 } from "fs/promises";
+import { realpath as fsrealpath, lstat as lstat2, open, stat as stat3 } from "fs/promises";
 import { type as osType } from "os";
 import * as sp from "path";
 var STR_DATA = "data";
@@ -911,7 +983,7 @@ var EVENTS = {
 };
 var EV = EVENTS;
 var THROTTLE_MODE_WATCH = "watch";
-var statMethods = { lstat: lstat2, stat: stat4 };
+var statMethods = { lstat: lstat2, stat: stat3 };
 var KEY_LISTENERS = "listeners";
 var KEY_ERR = "errHandlers";
 var KEY_RAW = "rawEmitters";
@@ -1354,9 +1426,9 @@ var NodeFsHandler = class {
   _watchWithNodeFs(path, listener) {
     const opts = this.fsw.options;
     const directory = sp.dirname(path);
-    const basename6 = sp.basename(path);
+    const basename7 = sp.basename(path);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename6);
+    parent.add(basename7);
     const absolutePath = sp.resolve(path);
     const options = {
       persistent: opts.persistent
@@ -1366,7 +1438,7 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename6) ? opts.binaryInterval : opts.interval;
+      options.interval = enableBin && isBinaryPath(basename7) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -1388,18 +1460,18 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname4 = sp.dirname(file);
-    const basename6 = sp.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname4);
+    const dirname6 = sp.dirname(file);
+    const basename7 = sp.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname6);
     let prevStats = stats;
-    if (parent.has(basename6))
+    if (parent.has(basename7))
       return;
     const listener = async (path, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
         try {
-          const newStats2 = await stat4(file);
+          const newStats2 = await stat3(file);
           if (this.fsw.closed)
             return;
           const at = newStats2.atimeMs;
@@ -1417,9 +1489,9 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname4, basename6);
+          this.fsw._remove(dirname6, basename7);
         }
-      } else if (parent.has(basename6)) {
+      } else if (parent.has(basename7)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -1667,11 +1739,11 @@ function createPattern(matcher) {
       if (matcher.path === string)
         return true;
       if (matcher.recursive) {
-        const relative3 = sp2.relative(matcher.path, string);
-        if (!relative3) {
+        const relative4 = sp2.relative(matcher.path, string);
+        if (!relative4) {
           return false;
         }
-        return !relative3.startsWith("..") && !sp2.isAbsolute(relative3);
+        return !relative4.startsWith("..") && !sp2.isAbsolute(relative4);
       }
       return false;
     };
@@ -1773,7 +1845,7 @@ var DirEntry = class {
       return;
     const dir = this.path;
     try {
-      await readdir4(dir);
+      await readdir2(dir);
     } catch (err) {
       if (this._removeWatcher) {
         this._removeWatcher(sp2.dirname(dir), sp2.basename(dir));
@@ -2123,7 +2195,7 @@ var FSWatcher = class extends EventEmitter {
       const fullPath = opts.cwd ? sp2.join(opts.cwd, path) : path;
       let stats2;
       try {
-        stats2 = await stat5(fullPath);
+        stats2 = await stat4(fullPath);
       } catch (err) {
       }
       if (!stats2 || this.closed)
@@ -2250,8 +2322,8 @@ var FSWatcher = class extends EventEmitter {
     }
     return this._userIgnored(path, stats);
   }
-  _isntIgnored(path, stat6) {
-    return !this._isIgnored(path, stat6);
+  _isntIgnored(path, stat5) {
+    return !this._isIgnored(path, stat5);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
@@ -2549,21 +2621,21 @@ var NodeHostAdapter = class {
   }
   async openLog(path) {
     const resolved = pathResolve(process.cwd(), path);
-    let stat6;
+    let stat5;
     try {
-      stat6 = statSync(resolved);
+      stat5 = statSync(resolved);
     } catch {
-      throw new Error(`openLog: cannot stat '${basename4(resolved)}'`);
+      throw new Error(`openLog: cannot stat '${basename5(resolved)}'`);
     }
-    if (!stat6.isFile()) {
-      throw new Error(`openLog: '${basename4(resolved)}' is not a regular file`);
+    if (!stat5.isFile()) {
+      throw new Error(`openLog: '${basename5(resolved)}' is not a regular file`);
     }
     try {
       accessSync(resolved, constants.R_OK);
     } catch {
-      throw new Error(`openLog: '${basename4(resolved)}' is not readable`);
+      throw new Error(`openLog: '${basename5(resolved)}' is not readable`);
     }
-    return { id: resolved, path: resolved, size: stat6.size };
+    return { id: resolved, path: resolved, size: stat5.size };
   }
   watchLog(handle, sinkOrChunk) {
     const node = handle;
@@ -2589,7 +2661,7 @@ var NodeHostAdapter = class {
 
 // ../server/src/app-state.ts
 import { Buffer as Buffer2 } from "buffer";
-import { basename as basename5 } from "path";
+import { basename as basename6 } from "path";
 
 // ../core/src/correlator.ts
 var Correlator = class {
@@ -4606,6 +4678,8 @@ function formatTs(ms) {
   )}`;
 }
 function formatSessionShort(sessionId) {
+  const watched = formatResourceWatchChannel(sessionId);
+  if (watched) return watched;
   const parts = sessionId.split(/[/:]+/).filter(Boolean);
   let label = parts.at(-1) ?? sessionId;
   label = label.replace(/^session[-_:]?/i, "");
@@ -4616,6 +4690,24 @@ function formatSessionShort(sessionId) {
   if (label.length <= 18) return label;
   return `${label.slice(0, 17)}\u2026`;
 }
+function formatResourceWatchChannel(sessionId) {
+  const match2 = sessionId.match(/^ahp-resource-watch:\/\/[^/]*\/(.+)$/u);
+  if (!match2) return null;
+  const encoded = match2[1];
+  if (!encoded) return null;
+  try {
+    const normalized = encoded.replace(/-/g, "+").replace(/_/g, "/");
+    const json = atob(normalized);
+    const parsed = JSON.parse(json);
+    const root = parsed.root ?? parsed.uri ?? parsed.resource;
+    if (typeof root !== "string") return null;
+    const tail = root.split(/[/\\]/u).filter(Boolean).at(-1) ?? root;
+    const name = decodeURIComponent(tail);
+    return `watch:${name.length <= 24 ? name : `${name.slice(0, 23)}\u2026`}`;
+  } catch {
+    return null;
+  }
+}
 function payloadPreviewOf(raw2) {
   if (raw2 === void 0 || raw2 === null) return "";
   let src = raw2;
@@ -4828,7 +4920,7 @@ async function createAppState(opts) {
   const handlePath = handle.path ?? handle.id;
   const initialMtimeMs = opts.initialMtimeMs ?? Date.now();
   const meta = {
-    filename: basename5(handlePath),
+    filename: basename6(handlePath),
     sizeBytes: handle.size ?? 0,
     startedAt: Date.now(),
     logKey: opts.logKey ?? computeLogKey(handlePath, initialMtimeMs)
@@ -8830,7 +8922,7 @@ function classifyDirection(raw2) {
 
 // src/index.ts
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = dirname3(__filename2);
+var __dirname2 = dirname5(__filename2);
 function loadVersion() {
   const candidates = [join7(__dirname2, "..", "package.json"), join7(__dirname2, "package.json")];
   for (const p of candidates) {
@@ -8902,9 +8994,9 @@ var program = new Command().name("ahp-inspector").version(VERSION).argument(
     let absPath;
     if (file) {
       absPath = resolvePath(file);
-      let stat6;
+      let stat5;
       try {
-        stat6 = statSync3(absPath);
+        stat5 = statSync3(absPath);
       } catch (err) {
         const e = err;
         if (e.code === "ENOENT") {
@@ -8914,7 +9006,7 @@ Usage: ahp-inspector [path-to-log.jsonl]`);
         fail(`Error: cannot read ${absPath}: ${e.message}
 Check file permissions.`);
       }
-      if (!stat6.isFile()) {
+      if (!stat5.isFile()) {
         fail(`Error: log file not found: ${absPath}
 Usage: ahp-inspector [path-to-log.jsonl]`);
       }