@herbertgao/pi-extensions 2026.8.14 → 2026.8.15

package/node_modules/pi-lens/config/dependency-cruiser-eager-allowlist.json

@@ -0,0 +1,79 @@
+[
+  "./clients/agent-nudge.js",
+  "./clients/ast-grep-client.js",
+  "./clients/bootstrap.js",
+  "./clients/bounded-telemetry.js",
+  "./clients/build-identity.js",
+  "./clients/bus-events-logger.js",
+  "./clients/bus-publish.js",
+  "./clients/cache-manager.js",
+  "./clients/cache-observability.js",
+  "./clients/cascade-format.js",
+  "./clients/console-guard-install.js",
+  "./clients/debug-handles.js",
+  "./clients/debug-heap.js",
+  "./clients/degradation-ledger.js",
+  "./clients/diagnostic-tracker.js",
+  "./clients/diagnostics-publish.js",
+  "./clients/dispatch/lazy.js",
+  "./clients/dispatch/runner-context.js",
+  "./clients/disposition-publish.js",
+  "./clients/event-loop-monitor.js",
+  "./clients/extension-log.js",
+  "./clients/extension-mode.js",
+  "./clients/file-utils.js",
+  "./clients/format-events-publish.js",
+  "./clients/format-service.js",
+  "./clients/formatters-lazy.js",
+  "./clients/git-guard.js",
+  "./clients/host-ports.js",
+  "./clients/installer/index.js",
+  "./clients/instance-reaper.js",
+  "./clients/instance-registry.js",
+  "./clients/latency-logger.js",
+  "./clients/lens-config.js",
+  "./clients/lens-events.js",
+  "./clients/lens-flag-registry.js",
+  "./clients/lsp-budget.js",
+  "./clients/lsp-lazy.js",
+  "./clients/lsp-status.js",
+  "./clients/lsp/cascade-tier.js",
+  "./clients/lsp/config.js",
+  "./clients/lsp/index.js",
+  "./clients/memory-sampler.js",
+  "./clients/message-end-attribution.js",
+  "./clients/package-root.js",
+  "./clients/path-attribution-telemetry.js",
+  "./clients/path-utils.js",
+  "./clients/project-lens-config.js",
+  "./clients/project-trust.js",
+  "./clients/quiet-window.js",
+  "./clients/read-bridge.js",
+  // index.ts:56 is type-only, but dependency-cruiser parses it as an edge.
+  "./clients/read-guard.js",
+  "./clients/recent-touches.js",
+  "./clients/runtime-agent-end.js",
+  "./clients/runtime-context.js",
+  "./clients/runtime-coordinator.js",
+  "./clients/runtime-session.js",
+  "./clients/runtime-tool-call.js",
+  "./clients/runtime-tool-result.js",
+  "./clients/runtime-turn.js",
+  "./clients/safe-spawn.js",
+  "./clients/session-event-guard.js",
+  "./clients/session-lifecycle.js",
+  "./clients/session-start-observability.js",
+  "./clients/session-state-store.js",
+  "./clients/sessionstart-logger.js",
+  "./clients/smells-rollup.js",
+  "./clients/startup-timing.js",
+  "./clients/tool-definition.js",
+  "./clients/tool-render.js",
+  "./clients/tool-set-policy.js",
+  "./clients/turn-summary-render.js",
+  "./clients/turn-summary.js",
+  "./clients/user-notify.js",
+  "./clients/vanished-instance-marker.js",
+  "./clients/warm-attach.js",
+  "./clients/widget-state.js"
+]

package/node_modules/pi-lens/dist/clients/actionable-warnings-logger.js

@@ -2,6 +2,7 @@ import * as path from "node:path";
 import { isTestMode } from "./env-utils.js";
 import { getGlobalPiLensDir } from "./file-utils.js";
 import { createNdjsonLogger } from "./ndjson-logger.js";
+import { normalizeFilePath } from "./path-utils.js";
 const AW_LOG_DIR = getGlobalPiLensDir();
 const AW_LOG_FILE = path.join(AW_LOG_DIR, "actionable-warnings.log");
 const AW_LOG_BACKUP_FILE = path.join(AW_LOG_DIR, "actionable-warnings.log.1");
@@ -12,11 +13,25 @@ const writer = createNdjsonLogger({
     maxBytes: MAX_LOG_BYTES,
     backupPath: AW_LOG_BACKUP_FILE,
 });
+/**
+ * #2219 (the #2141 class): `filePath` reaches here from
+ * `actionable-warnings.ts`'s raw `path.resolve(cwd, file)` — the file
+ * imports `normalizeMapKey` and uses it for map lookups on this same value,
+ * but never normalizes what gets logged. `filePath` is optional (several
+ * events, e.g. `report_started`/`report_complete`, carry none), so only
+ * normalize when present.
+ */
 export function logActionableWarningsEvent(entry) {
     if (isTestMode()) {
         return;
     }
-    writer.log({ ts: new Date().toISOString(), ...entry });
+    writer.log({
+        ts: new Date().toISOString(),
+        ...entry,
+        ...(entry.filePath !== undefined
+            ? { filePath: normalizeFilePath(entry.filePath) }
+            : {}),
+    });
 }
 export function getActionableWarningsLogPath() {
     return AW_LOG_FILE;

package/node_modules/pi-lens/dist/clients/ast-grep-client.js

@@ -13,6 +13,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { AstGrepRuleManager } from "./ast-grep-rule-manager.js";
 import { resolvePackagePath } from "./package-root.js";
+import { truncatedByOutputCap } from "./spawn-output-cap.js";
 import { SgRunner, } from "./sg-runner.js";
 // --- Client ---
 function extractDebugAst(raw) {
@@ -263,6 +264,18 @@ export class AstGrepClient {
             const result = await this.runner.execRaw(args, 10_000, options);
             const stderr = result.stderr.trim();
             const stdout = result.stdout.trim();
+            // FIRST (#2100): hitting `execRaw`'s cap SIGTERMs ast-grep, so a
+            // truncated run also carries the kill's error message. Read after the
+            // two checks below, this guard could only ever describe a run that
+            // exited before the signal reached it. `execRaw` re-spells `failure`
+            // in its own vocabulary but keeps the timeout/aborted spellings, so
+            // those runs still fall through to the error branch below.
+            if (truncatedByOutputCap(result)) {
+                return {
+                    valid: false,
+                    error: "ast-grep validation output was truncated",
+                };
+            }
             if (result.error)
                 return { valid: false, error: result.error };
             if (result.status !== 0 && !(result.status === 1 && !stderr)) {
@@ -272,12 +285,6 @@ export class AstGrepClient {
                         `ast-grep validation failed with exit code ${result.status}`,
                 };
             }
-            if (result.outputTruncated) {
-                return {
-                    valid: false,
-                    error: "ast-grep validation output was truncated",
-                };
-            }
             if (stderrHasError(stderr))
                 return { valid: false, error: stderr };
             const warning = stderr || stdout || undefined;

package/node_modules/pi-lens/dist/clients/availability-probe-flight.js

@@ -0,0 +1,12 @@
+import { createSingleFlight } from "./single-flight.js";
+/** Create a flight registry whose lifetime belongs to the caller. */
+export function createAvailabilityProbeFlight(options = {}) {
+    const flights = createSingleFlight(options);
+    return {
+        run(key, probe) {
+            const joined = flights.has(key);
+            return { promise: flights.run(key, probe), joined };
+        },
+        clear: () => flights.clear(),
+    };
+}

package/node_modules/pi-lens/dist/clients/biome-client.js

@@ -179,6 +179,7 @@ export class BiomeClient {
                 latched: true,
                 hostStallMs,
                 budgetMs: PROBE_TIMEOUT_MS,
+                classifiedBy: "probe",
             });
             return { outcome: "success", value: true };
         }
@@ -225,6 +226,12 @@ export class BiomeClient {
                     latched: true,
                     hostStallMs: this.lastProbeHostStallMs,
                     budgetMs: PROBE_TIMEOUT_MS,
+                    classifiedBy: "caller",
+                    evidence: {
+                        install: "succeeded",
+                        binary: "biome",
+                        source: "managed-dir",
+                    },
                 });
             }
             return true;

package/node_modules/pi-lens/dist/clients/blocker-freshness.js

@@ -43,12 +43,32 @@
  * runtime condition — that edge is invisible to this gate, so a blocker whose only
  * stale dependency arrives that way survives a replay. This is an honest boundary,
  * not a silently-closed one.
+ *
+ * Delivery cap (#1950). A demoted-but-confirmable entry (`alreadyStale` above)
+ * is deliberately NOT retired after its past-EOF sibling's one-delivery rule
+ * (#1944, `blocker-past-eof.ts`) — its coordinates are still in bounds, so a
+ * fresh dispatch can genuinely confirm or clear it, and retiring on delivery
+ * one would discard a recoverable finding. But nothing capped how many times
+ * the SAME demoted record re-serves: incident data (#1944's lane sweep) showed
+ * 18 `alreadyStale` re-serves in one window, with repeat deliveries carrying
+ * near-zero information after the first. `runtime-turn.ts` counts each
+ * delivery (`InlineBlockerRecord.staleDeliveryCount`) and retires the record
+ * via `RuntimeCoordinator.retireDemotedDependencyDriftBlocker` once it reaches
+ * `DEPENDENCY_DRIFT_MAX_DELIVERIES` — a count, not a TTL or a session
+ * boundary, because "how many times has the agent already been told" is the
+ * quantity that actually went to zero information, not "how much time has
+ * passed". The ledger reason says "capped, re-run can still confirm" so it
+ * reads distinctly from #1944's "retired, unrecoverable" — a capped record
+ * COULD still resolve a fresh dispatch; it just stopped being handed one for
+ * free.
  */
 import * as fs from "node:fs";
 import { normalizeEphemeralMapKey } from "./path-utils.js";
 import { resolveImportToFiles } from "./review-graph/import-resolvers.js";
 import { getSharedTreeSitterClient, resolveTreeSitterLanguage, } from "./tree-sitter-shared.js";
 import { TreeSitterSymbolExtractor } from "./tree-sitter-symbol-extractor.js";
+/** See the module doc's "Delivery cap (#1950)" section above. */
+export const DEPENDENCY_DRIFT_MAX_DELIVERIES = 3;
 /**
  * Upper bound on the number of forward imports stat-checked for a single blocker.
  * Blocking entries are rare, but one file can import many modules; the sweep must

package/node_modules/pi-lens/dist/clients/bounded-telemetry.js

@@ -24,10 +24,9 @@
  *    that must re-arm at `session_start` and will eventually be forgotten
  *    (the #1266–#1625 defect class).
  * 2. **A per-turn cap names its turn.** `capPerTurn` carries the caller's
- *    `turnIndex` in the same object as the limit, so there is no separate
- *    reset to wire and forget: the counters clear when the observed turn
- *    changes. This is the same lazy clear-on-transition shape as
- *    `noteImportResolutionMemoTurn` (`clients/blocker-freshness.ts`).
+ *    `turnIndex` in the same object as the limit. A bounded 64-turn window
+ *    keeps overlapping async turns independent; results older than that window
+ *    fail closed. Session start clears the window when numbering restarts.
  * 3. **Identity always survives.** Every emitted record carries the
  *    discriminating identity in `filePath` and in `metadata.identity`, so
  *    aggregation can still answer "which file, which method, which record is
@@ -85,6 +84,14 @@ export const BOUNDED_TELEMETRY_PHASES = [
      * exact count.
      */
     "lsp_warm_client_missing",
+    /** #2052: a file's nearest LSP root is outside the session ceiling. */
+    "lsp_capability_skip",
+    /**
+     * #2044: failed-first test state was retired after a confirmed missing path,
+     * retained because the filesystem verdict was indeterminate, or evicted at
+     * the state cap. Selection checks and detailed rows are both capped per turn.
+     */
+    "test_runner_failed_target_state",
     /**
      * #1723: an event-loop block at or above the floor. Not a degradation, so
      * no ledger kind; bounded by call cadence (one `turn_end` runs it once per
@@ -97,6 +104,17 @@ export const BOUNDED_TELEMETRY_PHASES = [
      * queue of them, so it is rising-edge per event name.
      */
     "session_event_stale_ctx_skip",
+    /**
+     * #2007: a worktree-mutating git command declined because another live
+     * session shares this dirty checkout. Rising edge per checkout root; the
+     * ledger keeps the exact repeat count.
+     */
+    "shared_checkout_switch_blocked",
+    /**
+     * #2007: `git status` could not report the working-tree state, so the same
+     * command was declined on an UNKNOWN rather than assumed clean.
+     */
+    "shared_checkout_probe_failed",
 ];
 const REGISTERED_PHASES = new Set(BOUNDED_TELEMETRY_PHASES);
 /** Report whether a phase name is in the registry (used by the sweep). */
@@ -104,14 +122,15 @@ export function isBoundedTelemetryPhase(phase) {
     return REGISTERED_PHASES.has(phase);
 }
 /**
- * Per-turn admission counters, keyed by phase. Cleared lazily when a call
- * observes a turn index different from the one the counters were built for,
- * and eagerly by `resetBoundedTelemetry` at `session_start` (a new session
- * restarts turn numbering at 0, so the lazy check alone could carry a stale
- * count across a session boundary that happened to land on the same index).
+ * Per-turn admission counters, keyed by turn and phase. Multiple turns remain
+ * live because async work can finish T1 after T2 has already emitted. The map
+ * retains a bounded recent window; work older than that window fails closed
+ * rather than reopening an exhausted budget. Session start clears all state.
  */
+const MAX_TRACKED_TURN_CAPS = 64;
 let turnCounts = new Map();
-let countedTurnIndex;
+let latestCountedTurnIndex;
+let retiredThroughTurnIndex = Number.NEGATIVE_INFINITY;
 /**
  * Decide whether this occurrence earns a detailed record, and count it in the
  * ledger either way. Returns `true` when the caller should write the record.
@@ -180,14 +199,25 @@ export function emitBounded(phase, identity, payload, options = {}) {
 function admitAgainstTurnCap(phase, cap) {
     if (cap === undefined)
         return true;
-    if (countedTurnIndex !== cap.turnIndex) {
-        turnCounts = new Map();
-        countedTurnIndex = cap.turnIndex;
+    if (cap.turnIndex <= retiredThroughTurnIndex)
+        return false;
+    let counts = turnCounts.get(cap.turnIndex);
+    if (!counts) {
+        if (turnCounts.size >= MAX_TRACKED_TURN_CAPS) {
+            const oldestTrackedTurn = Math.min(...turnCounts.keys());
+            if (cap.turnIndex < oldestTrackedTurn)
+                return false;
+            turnCounts.delete(oldestTrackedTurn);
+            retiredThroughTurnIndex = Math.max(retiredThroughTurnIndex, oldestTrackedTurn);
+        }
+        counts = new Map();
+        turnCounts.set(cap.turnIndex, counts);
     }
-    const used = turnCounts.get(phase) ?? 0;
+    latestCountedTurnIndex = Math.max(latestCountedTurnIndex ?? cap.turnIndex, cap.turnIndex);
+    const used = counts.get(phase) ?? 0;
     if (used >= cap.limit)
         return false;
-    turnCounts.set(phase, used + 1);
+    counts.set(phase, used + 1);
     return true;
 }
 /**
@@ -198,9 +228,16 @@ function admitAgainstTurnCap(phase, cap) {
  */
 export function resetBoundedTelemetry() {
     turnCounts = new Map();
-    countedTurnIndex = undefined;
+    latestCountedTurnIndex = undefined;
+    retiredThroughTurnIndex = Number.NEGATIVE_INFINITY;
+}
+/** Test-only: one turn's live admission count for a phase. */
+export function _boundedTurnCountForTest(phase, turnIndex = latestCountedTurnIndex) {
+    if (turnIndex === undefined)
+        return 0;
+    return turnCounts.get(turnIndex)?.get(phase) ?? 0;
 }
-/** Test-only: the live per-turn admission count for a phase. */
-export function _boundedTurnCountForTest(phase) {
-    return turnCounts.get(phase) ?? 0;
+/** Test-only: number of turn buckets retained by the bounded counter. */
+export function _boundedTrackedTurnsForTest() {
+    return turnCounts.size;
 }

package/node_modules/pi-lens/dist/clients/build-identity.js

@@ -0,0 +1,95 @@
+/**
+ * #1775: `sessionstart.log` recorded no build identity — no commit hash, no
+ * build timestamp. Dogfood forensics ("does this session include PR #1727?")
+ * had to reconstruct that by hand: run `git merge-base --is-ancestor` in the
+ * serving checkout and compare `dist/` mtimes against the session-start time.
+ *
+ * The running extension can be a different checkout than the repo an
+ * investigator is looking at, so identity is derived from the RUNNING
+ * build's own files — `getPackageRoot` (already used by grammar-source.ts to
+ * find pi-lens's own assets under both the unbundled dev layout and a
+ * packaged install) plus the mtime of the very entry file that is executing
+ * right now — never from `process.cwd()` and never assumed to be a git
+ * checkout.
+ *
+ * Commit resolution reuses `review-graph/git-identity.ts`'s
+ * `resolveGitIdentity` — a PURE filesystem read, no `git` subprocess. This
+ * runs inside the `session_start` handler, ahead of the #473
+ * concurrent-secondary classification, so every in-process subagent pays
+ * whatever this costs; a synchronous `git rev-parse`/`git status` spawn pair
+ * (fix round 1's approach, reverted here) measured 150-300ms typical and up
+ * to ~10s worst case on two 5s timeouts. `resolveGitIdentity` is a handful of
+ * `fs.readFileSync` calls, LRU-cached per process, so this path never spawns.
+ *
+ * The dirty working-tree flag genuinely needs `git status`, which has no
+ * spawn-free equivalent — so it is dropped from this record rather than
+ * reintroducing a spawn on the session-start hot path (refs #1775 followup
+ * comment: dirty flag deferred, commit + entryMtime + version shipped).
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { isTestMode } from "./env-utils.js";
+import { getPackageRoot } from "./package-root.js";
+import { normalizeFilePath } from "./path-utils.js";
+import { resolveGitIdentity } from "./review-graph/git-identity.js";
+/**
+ * A `.git` found by walking up from `root` only counts as owning `root` when
+ * its resolved worktree top-level IS `root` — not merely an ancestor of it.
+ * Without this check, a packaged install nested anywhere under an unrelated
+ * repo (a dotfiles checkout in $HOME is the common case) would confidently
+ * report that repo's HEAD as the running build's identity.
+ */
+function resolveOwnedCommit(root) {
+    const identity = resolveGitIdentity(root);
+    if (!identity)
+        return "unknown";
+    const normalizedRoot = normalizeFilePath(path.resolve(root));
+    if (identity.worktreeRoot !== normalizedRoot)
+        return "unknown";
+    return identity.headCommit.slice(0, 8);
+}
+function readPackageVersion(root) {
+    try {
+        const raw = fs.readFileSync(path.join(root, "package.json"), "utf-8");
+        const pkg = JSON.parse(raw);
+        return pkg.version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+function statEntryMtime(entryImportMetaUrl) {
+    try {
+        return fs.statSync(fileURLToPath(entryImportMetaUrl)).mtime.toISOString();
+    }
+    catch {
+        // Entry path unresolvable (e.g. a non-file:// URL) — "unknown" rather
+        // than throw out of a session-start observability line.
+        return "unknown";
+    }
+}
+/**
+ * Resolve the identity of the build currently running — pure filesystem
+ * reads, no subprocess. `entryImportMetaUrl` must be the ENTRY module's own
+ * `import.meta.url` (index.ts) — passing a different module's URL would
+ * report that module's mtime instead of the running build's.
+ *
+ * Returns `undefined` inside the test runner: nothing computed, nothing
+ * logged (`sessionstart-logger`'s writer is a no-op there too), so a caller
+ * on the session-start hot path never pays this cost during tests.
+ */
+export function getBuildIdentity(entryImportMetaUrl) {
+    if (isTestMode())
+        return undefined;
+    const root = getPackageRoot(entryImportMetaUrl);
+    return {
+        commit: resolveOwnedCommit(root),
+        entryMtime: statEntryMtime(entryImportMetaUrl),
+        version: readPackageVersion(root),
+    };
+}
+/** One bounded, human-readable line for sessionstart.log's free-text writer. */
+export function formatBuildIdentity(identity) {
+    return `session_start: build identity — commit=${identity.commit} entryMtime=${identity.entryMtime} version=${identity.version}`;
+}

package/node_modules/pi-lens/dist/clients/bus-publish.js

@@ -23,6 +23,7 @@ import { appendRecentTouches } from "./recent-touches.js";
 import { createLiveBusEmitter, recordStaleBusFailure, resolveLiveBusEmitter, } from "./live-bus-emitter.js";
 export const BUS_FILES_TOUCHED_EVENT = "pilens:files:touched";
 export const BUS_FILES_TOUCHED_VERSION = 1;
+const BUS_LOG_PATH_CAP = 64;
 const liveEmitter = createLiveBusEmitter();
 let hasLoggedFailure = false;
 // Log-once-per-process guards for the two structural-no-op outcomes below
@@ -148,6 +149,8 @@ export function publishFilesTouched(args) {
             cwd: payload.cwd,
             reason: args.reason,
             fileCount: payload.paths.length,
+            writer: "pi-lens",
+            paths: payload.paths.slice(0, BUS_LOG_PATH_CAP),
         });
     }
     catch (err) {

package/node_modules/pi-lens/dist/clients/cache/rule-cache.js

@@ -11,6 +11,7 @@ import { getProjectDataDir } from "../file-utils.js";
 import { readJsonCache } from "../json-cache-read.js";
 import { resolvePackagePath } from "../package-root.js";
 import { writeFileAtomic } from "../atomic-write.js";
+import { compareOrdinal } from "../string-utils.js";
 // v4: cache skip_test_files + fix_action — v3 entries silently dropped them,
 // and ruleHash (rule-file mtimes) never invalidates on a code-only fix.
 // v5 (#675): rule SELECTION changed in code — javascript no longer inherits the
@@ -69,7 +70,7 @@ export class RuleCache {
     }
     computeRuleHash(ruleFiles) {
         const hash = crypto.createHash("sha256");
-        for (const file of ruleFiles.sort((a, b) => a.localeCompare(b))) {
+        for (const file of ruleFiles.sort(compareOrdinal)) {
             const resolved = path.resolve(file);
             if (!fs.existsSync(resolved))
                 continue;

package/node_modules/pi-lens/dist/clients/cache-observability.js

@@ -50,6 +50,7 @@
 import { createHash } from "node:crypto";
 import { lazyEnvNumber } from "./env-utils.js";
 import { logLatency } from "./latency-logger.js";
+import { compareOrdinal } from "./string-utils.js";
 /** RuntimeCoordinator's counter is process-global when sessions share a host. */
 const PROCESS_TURN_SCOPE = "process-global-runtime";
 const SECONDARY_TURN_SCOPE = "unavailable-concurrent-secondary";
@@ -490,7 +491,7 @@ function boundedHashArray(value, depth, seen, state) {
     return `array:${value.length}:[${items.join(",")}]`;
 }
 function boundedHashObject(value, depth, seen, state) {
-    const keys = Object.keys(value).sort((left, right) => left.localeCompare(right));
+    const keys = Object.keys(value).sort((left, right) => compareOrdinal(left, right));
     if (keys.length > 24)
         state.contentTruncated = true;
     const fields = keys

package/node_modules/pi-lens/dist/clients/cascade-logger.js

@@ -3,17 +3,31 @@ import { isTestMode } from "./env-utils.js";
 import { getGlobalPiLensDir } from "./file-utils.js";
 import { createNdjsonLogger } from "./ndjson-logger.js";
 import { getMaxLogSizeMB } from "./log-cleanup.js";
+import { normalizeLoggedPath } from "./path-utils.js";
 const CASCADE_LOG_DIR = getGlobalPiLensDir();
 const CASCADE_LOG_FILE = path.join(CASCADE_LOG_DIR, "cascade.log");
 const writer = createNdjsonLogger({
     filePath: CASCADE_LOG_FILE,
     maxBytes: getMaxLogSizeMB() * 1024 * 1024,
 });
+/**
+ * #2219 (the #2141 class): call sites across `dispatch/integration.ts`,
+ * `runtime-turn.ts`, and `runtime-coordinator.ts` feed a mix of raw
+ * `filePath`/`cwd` params and (for `lsp/cascade-tier.ts`) the
+ * `"<quiet-window>"` sentinel. Normalize once here, the single emit seam —
+ * same pattern as `review-graph-logger.ts`'s `logReviewGraph`, guarded via
+ * `normalizeLoggedPath` so the non-path sentinel passes through unchanged
+ * instead of being resolved against the process cwd.
+ */
 export function logCascade(entry) {
     if (isTestMode()) {
         return;
     }
-    writer.log({ ts: new Date().toISOString(), ...entry });
+    writer.log({
+        ts: new Date().toISOString(),
+        ...entry,
+        filePath: normalizeLoggedPath(entry.filePath),
+    });
 }
 export function getCascadeLogPath() {
     return CASCADE_LOG_FILE;

package/node_modules/pi-lens/dist/clients/dead-code-client.js

@@ -101,9 +101,9 @@ export function parseVultureOutput(output, root) {
  *
  * vulture finds unused functions, classes, methods, imports, variables and
  * attributes by static analysis of the whole tree. It has no JSON reporter, so
- * we parse its stable one-line-per-finding text output. It exits 1 when it
- * FINDS dead code (linter convention), so a non-zero exit with parseable
- * output is success, not failure.
+ * we parse its stable one-line-per-finding text output. A clean run exits 0;
+ * found dead code exits 3 with findings on stdout. A non-zero exit with
+ * parseable output is success, not failure (see runAnalyze for the table).
  */
 export class PythonDeadCodeClient {
     id = "python";
@@ -245,6 +245,7 @@ export class PythonDeadCodeClient {
                     latched: true,
                     hostStallMs,
                     budgetMs: 5000,
+                    classifiedBy: "probe",
                 });
                 return true;
             }
@@ -370,14 +371,16 @@ export class PythonDeadCodeClient {
                 durationMs,
             };
         }
-        // vulture writes parse/usage errors to stderr and exits 1 with no
-        // stdout findings; distinguish that from "found dead code" (exit 1 WITH
-        // findings on stdout). #1736 sweep: the ORIGINAL guard here required
-        // non-empty stderr to call it an error, so a nonzero exit with BOTH
-        // empty stdout and empty stderr (a silent crash) still fell through to
-        // "No dead code found" -- the same empty-distinguishes-clean-from-errored
-        // gap the knip fix closes. A nonzero exit with no findings on stdout is
-        // never clean now, regardless of whether stderr said anything.
+        // Verified exit-code table (vulture 2.16, probed live during the #1758
+        // review): a clean run exits 0 with empty stdout; dead code found exits
+        // 3 with findings on stdout; invalid input or a parse error exits 1
+        // with empty stdout and the error on stderr. #1736 sweep: the ORIGINAL
+        // guard here required non-empty stderr to call it an error, so a
+        // nonzero exit with BOTH empty stdout and empty stderr (a silent crash)
+        // still fell through to "No dead code found" -- the same
+        // empty-distinguishes-clean-from-errored gap the knip fix closes. A
+        // nonzero exit with no findings on stdout is never clean now,
+        // regardless of whether stderr said anything.
         const output = result.stdout || "";
         if (!output.trim()) {
             const stderr = (result.stderr || "").trim();