@herbertgao/pi-extensions 2026.9.1 → 2026.9.2

package/node_modules/pi-lens/dist/clients/metrics-history.js

@@ -93,7 +93,7 @@ export function loadHistory() {
 /**
  * Save history to disk
  */
-export function saveHistory(history) {
+function saveHistory(history) {
     const historyDir = getProjectDataDir(process.cwd());
     if (!fs.existsSync(historyDir)) {
         fs.mkdirSync(historyDir, { recursive: true });
@@ -161,10 +161,35 @@ export function captureSnapshot(filePath, metrics) {
     }, SAVE_DEBOUNCE_MS);
     saveTimer.unref?.();
 }
+// --- Trend Analysis ---
 /**
- * Capture snapshots for multiple files (explicit, immediate save)
- * Used by /lens-metrics for batch capture
+ * Compute trend direction from history snapshots
+ * Uses last 3 snapshots for stability (or 2 if only 2 available)
  */
+function computeTrend(history) {
+    if (history.length < 2)
+        return "stable";
+    const recent = history.slice(-3);
+    const first = recent[0];
+    const last = recent[recent.length - 1];
+    // Use MI as primary indicator, cognitive as secondary
+    const miDelta = last.mi - first.mi;
+    const cogDelta = last.cognitive - first.cognitive;
+    // Thresholds (MI changes < 2 are noise)
+    if (miDelta > 2)
+        return "improving";
+    if (miDelta < -2)
+        return "regressing";
+    // If MI is stable, check cognitive
+    if (cogDelta < -10)
+        return "improving";
+    if (cogDelta > 10)
+        return "regressing";
+    return "stable";
+}
+// --- Technical Debt Index (TDI) ---
+// Test-reached through a child-process `require` string
+/** @public — reached through a child-process `require` string in tests/clients/metrics-history-stderr.test.ts; knip cannot see it. */
 export function captureSnapshots(files) {
     const history = loadHistory();
     for (const file of files) {
@@ -200,110 +225,6 @@ export function captureSnapshots(files) {
     saveHistory(history);
     return history;
 }
-// --- Trend Analysis ---
-/**
- * Compute trend direction from history snapshots
- * Uses last 3 snapshots for stability (or 2 if only 2 available)
- */
-export function computeTrend(history) {
-    if (history.length < 2)
-        return "stable";
-    const recent = history.slice(-3);
-    const first = recent[0];
-    const last = recent[recent.length - 1];
-    // Use MI as primary indicator, cognitive as secondary
-    const miDelta = last.mi - first.mi;
-    const cogDelta = last.cognitive - first.cognitive;
-    // Thresholds (MI changes < 2 are noise)
-    if (miDelta > 2)
-        return "improving";
-    if (miDelta < -2)
-        return "regressing";
-    // If MI is stable, check cognitive
-    if (cogDelta < -10)
-        return "improving";
-    if (cogDelta > 10)
-        return "regressing";
-    return "stable";
-}
-/**
- * Get delta between current snapshot and previous
- */
-export function getDelta(history) {
-    if (!history || history.history.length < 2)
-        return null;
-    const current = history.history[history.history.length - 1];
-    const previous = history.history[history.history.length - 2];
-    return {
-        mi: Math.round((current.mi - previous.mi) * 10) / 10,
-        cognitive: current.cognitive - previous.cognitive,
-        trend: history.trend,
-    };
-}
-/**
- * Get trend emoji for display
- */
-export function getTrendEmoji(trend) {
-    switch (trend) {
-        case "improving":
-            return "📈";
-        case "regressing":
-            return "📉";
-        default:
-            return "➡️";
-    }
-}
-/**
- * Get trend summary across all files
- */
-export function getTrendSummary(history) {
-    let improving = 0;
-    let regressing = 0;
-    let stable = 0;
-    const regressions = [];
-    for (const [file, fileHistory] of Object.entries(history.files)) {
-        switch (fileHistory.trend) {
-            case "improving":
-                improving++;
-                break;
-            case "regressing": {
-                regressing++;
-                const delta = getDelta(fileHistory);
-                if (delta) {
-                    regressions.push({ file, miDelta: delta.mi });
-                }
-                break;
-            }
-            default:
-                stable++;
-        }
-    }
-    // Sort regressions by MI delta (worst first)
-    regressions.sort((a, b) => a.miDelta - b.miDelta);
-    return {
-        improving,
-        regressing,
-        stable,
-        worstRegressions: regressions.slice(0, 5),
-    };
-}
-/**
- * Format trend for metrics table
- */
-export function formatTrendCell(filePath, history) {
-    const relativePath = path.relative(process.cwd(), filePath);
-    const fileHistory = history.files[relativePath];
-    if (!fileHistory || fileHistory.history.length < 2) {
-        return "—"; // No history
-    }
-    const delta = getDelta(fileHistory);
-    if (!delta)
-        return "—";
-    const emoji = getTrendEmoji(delta.trend);
-    const miSign = delta.mi > 0 ? "+" : "";
-    const miColor = delta.mi > 0 ? "🟢" : delta.mi < 0 ? "🔴" : "⚪";
-    return `${emoji} ${miColor}${miSign}${delta.mi}`;
-}
 /**
  * Calculate Technical Debt Index for the project.
  * Score: 0 = perfect, 100 = maximum debt.

package/node_modules/pi-lens/dist/clients/middle-man-analysis.js

@@ -159,7 +159,7 @@ function isAccessorLine(rawLine) {
  * extracted data — no re-parsing, no file I/O beyond the lines already read
  * by the caller.
  */
-export function analyzeMiddleMan(classEntry, lines, languageId) {
+function analyzeMiddleMan(classEntry, lines, languageId) {
     if (!languageId)
         return undefined;
     const selfSpec = SELF_TOKEN[languageId];

package/node_modules/pi-lens/dist/clients/module-report.js

@@ -48,7 +48,7 @@ import { symbolExtractionGrammar, TreeSitterSymbolExtractor, } from "./tree-sitt
 // lsp.ts) to be re-homed in #236, where LSP writes provenance-tagged edges INTO
 // the review graph (computed once, persisted) so this path just reads them.
 /** Hard payload bound for the per-symbol who-uses-this section. */
-export const MAX_MODULE_REPORT_REFS = 100;
+const MAX_MODULE_REPORT_REFS = 100;
 function normalizeMaxRefsPerSymbol(value) {
     if (value === undefined || !Number.isFinite(value))
         return 10;

package/node_modules/pi-lens/dist/clients/mutating-tool.js

@@ -113,7 +113,7 @@ function asRecord(value) {
  * field list the seam classifies with — a second spelling list would arm on
  * inputs the seam cannot resolve, and miss ones it can.
  */
-export function resolveMutationPath(input) {
+function resolveMutationPath(input) {
     for (const key of ["path", "filePath", "file_path"]) {
         const value = input[key];
         if (typeof value === "string" && value.length > 0)
@@ -141,7 +141,7 @@ export function readMutationPathField(event) {
  * base62 anchor — handled by `clients/hashline-anchor.ts`. Do not reach for
  * this function there.
  */
-export function parseHashlineAnchor(anchor) {
+function parseHashlineAnchor(anchor) {
     if (typeof anchor !== "string")
         return undefined;
     const trimmed = anchor.trim();
@@ -153,7 +153,7 @@ export function parseHashlineAnchor(anchor) {
     return Number.isInteger(line) && line > 0 ? line : undefined;
 }
 /** Bounding box plus per-range detail for a multi-range edit. */
-export function combineRanges(ranges) {
+function combineRanges(ranges) {
     const starts = ranges.map(([start]) => start);
     const ends = ranges.map(([, end]) => end);
     return {

package/node_modules/pi-lens/dist/clients/mutation-attribution.js

@@ -45,7 +45,7 @@ import { BoundedFifoMap } from "./bounded-cache.js";
 import { getProjectDataDir } from "./file-utils.js";
 import { getProcessSingleton } from "./process-singletons.js";
 /** Persisted-file schema version. A file of any other version is ignored. */
-export const MUTATION_ATTRIBUTION_FILE_VERSION = 1;
+const MUTATION_ATTRIBUTION_FILE_VERSION = 1;
 /** File under `getProjectDataDir(cwd)` holding the learned attributions. */
 export const MUTATION_ATTRIBUTION_FILE = "observed-mutating-tools.json";
 /**
@@ -55,7 +55,7 @@ export const MUTATION_ATTRIBUTION_FILE = "observed-mutating-tools.json";
  * co-occurrence — an unrelated tool call that happened to overlap a background
  * write — cannot durably mislabel a tool for every future session.
  */
-export const PERSIST_AFTER_OBSERVATIONS = 2;
+const PERSIST_AFTER_OBSERVATIONS = 2;
 /**
  * Consecutive clean observations after which an UNATTRIBUTED tool stops being
  * armed for the session. Two, not one: a mutating tool whose FIRST call
@@ -88,7 +88,7 @@ export const CLEAN_OBSERVATION_ARM_LIMIT = 2;
  */
 export const DEATTRIBUTE_AFTER_CLEAN_OBSERVATIONS = 3;
 /** Bound on distinct tool names remembered, in-memory and on disk. */
-export const MUTATION_ATTRIBUTION_MAX_TOOLS = 64;
+const MUTATION_ATTRIBUTION_MAX_TOOLS = 64;
 const ATTRIBUTION_FAMILY = "mutation-attribution";
 /**
  * Bumped to 2 (#2449 review round 5, F3): `session` changed shape from a

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

@@ -127,10 +127,6 @@ export function _exitFlushersForTest() {
 export function getRegisteredLogFiles() {
     return registeredLogFiles;
 }
-/** Test-only reset — each test file gets a clean registry (see ndjson-logger.test.ts). */
-export function _resetRegisteredLogFilesForTest() {
-    registeredLogFiles.clear();
-}
 /**
  * Snapshot of unrecovered write losses, one entry per sink that has any
  * (#1970). Pure in-memory read — no I/O, so a caller (`degradation-ledger.ts`)

package/node_modules/pi-lens/dist/clients/observed-mutation.js

@@ -119,7 +119,7 @@ import { lineContentHash } from "./read-guard.js";
  * must not turn every first observation into a timeout, which is the least
  * useful possible outcome.
  */
-export const OBSERVED_CAPTURE_BUDGET_MS = 200;
+const OBSERVED_CAPTURE_BUDGET_MS = 200;
 /**
  * Cumulative ceiling for every ARMED capture in one turn. A turn that calls
  * twenty unclassified tools pays this once, not twenty times. The SETTLE does
@@ -141,7 +141,7 @@ export const OBSERVED_TURN_BUDGET_MS = 600;
  * holds regardless of the clock. What it CAN cut is a directory target's tail,
  * and that is reported as `stoppedEarly` rather than scored as clean.
  */
-export const OBSERVED_SETTLE_DEADLINE_MS = 50;
+const OBSERVED_SETTLE_DEADLINE_MS = 50;
 /**
  * Entries taken from a DIRECTORY-shaped target path, non-recursively.
  *
@@ -175,7 +175,7 @@ export const OBSERVED_TRACKED_MAX_FILES = 400;
  * closes it as soon as anything moves the size or the tick, and the armed
  * observation (which hashes the target unconditionally) never depended on it.
  */
-export const OBSERVED_LEDGER_SETTLE_MS = 150;
+const OBSERVED_LEDGER_SETTLE_MS = 150;
 /**
  * Path keys the "pi-lens already recorded this" set may hold.
  *
@@ -198,19 +198,19 @@ export const OBSERVED_HANDLED_MAX = 1000;
  */
 export const OBSERVED_SWEEP_STAT_WINDOW = 128;
 /** Cumulative content-hash budget for ONE capture. */
-export const OBSERVED_HASH_BUDGET_BYTES = 2 * 1024 * 1024;
+const OBSERVED_HASH_BUDGET_BYTES = 2 * 1024 * 1024;
 /** Cumulative bytes ONE settled sweep may read to seed or verify a hash. */
 export const OBSERVED_SWEEP_HASH_BUDGET_BYTES = 2 * 1024 * 1024;
 /** Cumulative bytes ONE settled sweep may read to derive edit RANGES. */
-export const OBSERVED_SWEEP_RANGE_BUDGET_BYTES = 1024 * 1024;
+const OBSERVED_SWEEP_RANGE_BUDGET_BYTES = 1024 * 1024;
 /** Largest file whose per-line hashes are captured for range derivation. */
-export const OBSERVED_LINE_HASH_MAX_BYTES = 512 * 1024;
+const OBSERVED_LINE_HASH_MAX_BYTES = 512 * 1024;
 /** Ranges reported per file before they collapse to one bounding box. */
-export const OBSERVED_MAX_EDIT_RANGES = 32;
+const OBSERVED_MAX_EDIT_RANGES = 32;
 /** Pending baselines held between `tool_call` and `tool_result`. */
-export const OBSERVED_PENDING_MAX = 32;
+const OBSERVED_PENDING_MAX = 32;
 /** Files remembered by the settled-sweep content ledger. */
-export const OBSERVED_LEDGER_MAX = 1000;
+const OBSERVED_LEDGER_MAX = 1000;
 const OBSERVED_FAMILY = "observed-mutation-net";
 const OBSERVED_VERSION = 3;
 function state() {

package/node_modules/pi-lens/dist/clients/opaque-mutation-scan.js

@@ -43,11 +43,11 @@ import { freshnessFromMtime } from "./freshness.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
 import { truncatedByOutputCap } from "./spawn-output-cap.js";
 /** Stop hashing once this many cumulative bytes were read (per capture). */
-export const OPAQUE_HASH_BUDGET_BYTES = 8 * 1024 * 1024;
+const OPAQUE_HASH_BUDGET_BYTES = 8 * 1024 * 1024;
 /** Hard cap on scanned files — beyond it the verdict is coverage-unknown. */
 export const OPAQUE_SCAN_MAX_FILES = 2000;
 /** How far before recorded start an earlier write may still be attributed. */
-export const OPAQUE_MTIME_TOLERANCE_MS = 150;
+const OPAQUE_MTIME_TOLERANCE_MS = 150;
 // `--untracked-files=all` lists untracked files individually instead of
 // collapsing them per directory (it does NOT add ignored paths — that needs
 // `--ignored`), so the worst realistic case is a working tree with a large
@@ -220,10 +220,6 @@ export async function isGitWorktree(root) {
     gitRepoMemo.set(key, isRepo === true);
     return isRepo === true;
 }
-export function _resetGitWorktreeMemoForTests() {
-    gitRepoMemo.clear();
-    gitToplevelMemo.clear();
-}
 const gitToplevelMemo = new Map();
 /**
  * The root of the working tree `root` belongs to, or `undefined` when it is

package/node_modules/pi-lens/dist/clients/opengrep-config.js

@@ -3,7 +3,7 @@ import { findLocalToolConfig } from "./path-utils.js";
 // Opengrep is a fork of Semgrep and natively consumes the same rule format, so
 // we discover both `.opengrep.*` (preferred) and the de-facto `.semgrep.*` rule
 // files an existing repo may already carry.
-export const LOCAL_OPENGREP_CONFIG_NAMES = [
+const LOCAL_OPENGREP_CONFIG_NAMES = [
     ".opengrep.yml",
     ".opengrep.yaml",
     "opengrep.yml",

package/node_modules/pi-lens/dist/clients/path-utils.js

@@ -10,7 +10,7 @@
  * - On non-Windows: return path as-is (case-sensitive filesystem)
  * - Always convert backslashes to forward slashes for Map key consistency
  */
-import { existsSync, realpathSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync, statSync, } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { win32 } from "node:path";
@@ -413,6 +413,25 @@ export function findLocalToolConfig(startDir, names, options = {}) {
     }
     return undefined;
 }
+/**
+ * Accept only a real Git repository marker: a directory with HEAD, or a
+ * worktree/submodule marker file whose first line starts with `gitdir:`.
+ */
+export function isRealGitMarker(markerPath) {
+    try {
+        const marker = statSync(markerPath);
+        if (marker.isDirectory())
+            return existsSync(path.join(markerPath, "HEAD"));
+        if (!marker.isFile())
+            return false;
+        return readFileSync(markerPath, "utf8")
+            .split(/\r?\n/, 1)[0]
+            .startsWith("gitdir:");
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Walk up from `startDir` looking for a directory containing any of
  * `markers`, the same containment-aware climb `knip-client.ts` and
@@ -438,11 +457,13 @@ export function findLocalToolConfig(startDir, names, options = {}) {
 export function findNearestMarkerRoot(startDir, markers, options = {}) {
     const boundaries = options.boundaries ?? [];
     const homeDir = path.resolve(options.homeDir ?? os.homedir());
+    const markerPredicate = options.markerPredicate ?? (() => true);
     let current = path.resolve(startDir);
     for (let depth = 0; depth < 64; depth++) {
         if (isAtOrAboveHomeDir(current, homeDir))
             return null;
-        if (markers.some((m) => existsSync(path.join(current, m))))
+        if (markers.some((m) => existsSync(path.join(current, m)) &&
+            markerPredicate(path.join(current, m))))
             return current;
         if (boundaries.some((m) => existsSync(path.join(current, m))))
             return null;

package/node_modules/pi-lens/dist/clients/performance-report.js

@@ -2,8 +2,8 @@ import * as fs from "node:fs";
 import * as readline from "node:readline";
 import { flushLatencyLog, getLatencyLogPath, } from "./latency-logger.js";
 import { getMaxLogSizeMB } from "./log-cleanup.js";
-export const DEFAULT_PERF_TOP_N = 5;
-export const MAX_PERF_TOP_N = 50;
+const DEFAULT_PERF_TOP_N = 5;
+const MAX_PERF_TOP_N = 50;
 export const MAX_PERF_PHASE_SAMPLES = 20_000;
 const PARSE_YIELD_EVERY = 500;
 // The window follows the same threshold that rotates the log out from under it.

package/node_modules/pi-lens/dist/clients/php-cs-fixer-config.js

@@ -98,7 +98,7 @@ import { findLocalToolConfig } from "./path-utils.js";
  * before `.php-cs-fixer.dist.php` — so a same-directory precedence check can
  * just take the first existing name.
  */
-export const PHP_CS_FIXER_CONFIG_NAMES = [
+const PHP_CS_FIXER_CONFIG_NAMES = [
     ".php-cs-fixer.php",
     ".php-cs-fixer.dist.php",
 ];

package/node_modules/pi-lens/dist/clients/pipeline.js

@@ -179,7 +179,7 @@ function createPhaseTracker(toolName, filePath) {
     };
 }
 // --- ESLint autofix helpers ---
-export { hasEslintConfig, hasRubocopConfig, hasSqlfluffConfig, hasStylelintConfig, };
+export { hasEslintConfig, hasSqlfluffConfig, hasStylelintConfig };
 /**
  * eslint autofix availability, per cwd + PATH. The verdict is owned by the
  * shared availability latch (#1494): a `missing` / `non-installable` outcome
@@ -338,7 +338,7 @@ async function tryDetektFix(filePath, cwd) {
     const absPath = path.resolve(cwd, filePath);
     return detectFileChangedAfterCommand(filePath, cmd, ["--auto-correct", "--input", absPath, "--config", configPath], cwd, [1, 2]);
 }
-export async function tryMarkdownlintFix(filePath, cwd) {
+async function tryMarkdownlintFix(filePath, cwd) {
     const cmd = await resolveToolCommandWithInstallFallback(cwd, "markdownlint");
     if (!cmd)
         return 0;

package/node_modules/pi-lens/dist/clients/project-changes.js

@@ -54,7 +54,7 @@ export function readProjectChanges(cwd) {
  * version — a missing/corrupt log is the normal cold-start case, not a
  * caller-visible error.
  */
-export async function readProjectChangesAsync(cwd) {
+async function readProjectChangesAsync(cwd) {
     const logPath = getProjectChangeLogPath(cwd);
     try {
         const content = await fs.promises.readFile(logPath, "utf-8");

package/node_modules/pi-lens/dist/clients/project-diagnostics/extractors.js

@@ -15,7 +15,7 @@ const WARM_TRIGGER = {
     "dead-code": "runs at session-start (Python projects only)",
     "test-runner": "fires per-edit at turn_end (only after a source file with a discoverable test companion is edited)",
 };
-export function warmTriggerFor(analyzerId) {
+function warmTriggerFor(analyzerId) {
     return WARM_TRIGGER[analyzerId] ?? "runs at session-start";
 }
 /**

package/node_modules/pi-lens/dist/clients/project-diagnostics/runner-adapters/jscpd.js

@@ -8,7 +8,7 @@ function resolveClonePath(cwd, file) {
  * BOTH ends so the duplication surfaces on whichever file the agent is looking
  * at, each one naming the other end.
  */
-export function jscpdCloneToProjectDiagnostics(cwd, clone) {
+function jscpdCloneToProjectDiagnostics(cwd, clone) {
     const a = resolveClonePath(cwd, clone.fileA);
     const b = resolveClonePath(cwd, clone.fileB);
     const make = (filePath, line, otherFile, otherLine) => ({

package/node_modules/pi-lens/dist/clients/project-diagnostics/runner-adapters/knip.js

@@ -27,7 +27,7 @@ function knipIssueMessage(issue) {
     }
     return `${issue.type}: ${issue.name}`;
 }
-export function knipIssueToProjectDiagnostic(cwd, issue) {
+function knipIssueToProjectDiagnostic(cwd, issue) {
     const blocking = issue.type === "unlisted" || issue.type === "bin";
     return {
         filePath: knipIssueFile(cwd, issue),

package/node_modules/pi-lens/dist/clients/project-diagnostics/runner-adapters/madge.js

@@ -12,7 +12,7 @@ function cycleMembers(dep) {
  * single-point knip finding. Emit a diagnostic on EACH file in the cycle so it
  * surfaces wherever the agent is looking, each one rendering the whole cycle.
  */
-export function circularDepToProjectDiagnostics(cwd, dep) {
+function circularDepToProjectDiagnostics(cwd, dep) {
     const members = cycleMembers(dep);
     const rendered = `${members.map((f) => path.basename(f)).join(" → ")} → ${path.basename(members[0] ?? "")}`;
     return members.map((file) => ({

package/node_modules/pi-lens/dist/clients/project-diagnostics/runner-adapters/opengrep.js

@@ -15,7 +15,7 @@ function severityFor(raw) {
             return { severity: "warning", blocking: false };
     }
 }
-export function opengrepFindingToProjectDiagnostic(cwd, finding) {
+function opengrepFindingToProjectDiagnostic(cwd, finding) {
     const { severity, blocking } = severityFor(finding.severity);
     const cweSuffix = finding.cwe?.length ? ` (${finding.cwe[0]})` : "";
     return {

package/node_modules/pi-lens/dist/clients/project-diagnostics/runner-adapters/runner-findings.js

@@ -43,7 +43,7 @@ function parseLocation(location) {
  * caller deserves the same "this may already be superseded" honesty the
  * per-edit path already gives.
  */
-export function testResultToProjectDiagnostics(result, stale = false) {
+function testResultToProjectDiagnostics(result, stale = false) {
     if (result.failed === 0 && !result.error)
         return [];
     const stalePrefix = stale ? "[stale — from a prior turn] " : "";

package/node_modules/pi-lens/dist/clients/project-lens-config.js

@@ -162,8 +162,15 @@ export function loadPiLensProjectConfig(startDir, preloadedInfo) {
     // a pi-lens-owned file were then produced by nobody at all. The pi-lens
     // loader now enumerates those documents itself, for records only: nothing
     // here is merged, and which file supplies a VALUE is unchanged.
-    reportPiLensConfigRecords(entry.legacyRecords);
     const configInfo = preloadedInfo ?? freshInfoFor(entry);
+    // The selected legacy document is resolved below and its bounded migration
+    // records are cached with that projection. Reporting the discovery copy as
+    // well would produce two suppression records with different totals, because
+    // the discovery walk and the single-document resolution see different
+    // record populations. Keep discovery-only documents here; the selected file
+    // is reported by `loadCachedConfigFile`.
+    const selectedLegacyPath = configInfo?.path;
+    reportPiLensConfigRecords(entry.legacyRecords.filter((record) => record.file !== selectedLegacyPath));
     if (!configInfo)
         return EMPTY_PROJECT_CONFIG;
     return loadCachedConfigFile(configInfo);
@@ -634,6 +641,43 @@ function parseConfigFile(configPath) {
             }
         }
     }
+    let startup;
+    if (obj.startup !== undefined) {
+        if (!obj.startup ||
+            typeof obj.startup !== "object" ||
+            Array.isArray(obj.startup)) {
+            note("startup must be an object");
+        }
+        else {
+            const section = obj.startup;
+            if (section.mode === "quick" ||
+                section.mode === "full" ||
+                section.mode === "minimal") {
+                startup = { mode: section.mode };
+            }
+            else if ("mode" in section) {
+                note('startup.mode must be "quick", "full", or "minimal"');
+            }
+            if (section.scans !== undefined) {
+                if (!section.scans ||
+                    typeof section.scans !== "object" ||
+                    Array.isArray(section.scans)) {
+                    note("startup.scans must be an object");
+                }
+                else if (typeof section.scans.enabled ===
+                    "boolean") {
+                    startup ??= {};
+                    startup.scans = {
+                        enabled: section.scans
+                            .enabled,
+                    };
+                }
+                else if ("enabled" in section.scans) {
+                    note("startup.scans.enabled must be a boolean");
+                }
+            }
+        }
+    }
     // #533 hygiene: mirror the global loader's unknown-key warn so a typo in a
     // shared `.pi-lens.json` (e.g. `maxProjectFile`, `lps`) produces a signal
     // instead of silently doing nothing. The recognized set is single-sourced
@@ -694,6 +738,7 @@ function parseConfigFile(configPath) {
     }
     return {
         config: {
+            ...(startup === undefined ? {} : { startup }),
             ignore,
             rules,
             ...mutations,

package/node_modules/pi-lens/dist/clients/project-scan-policy.js

@@ -1,55 +1,7 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getProjectIgnoreMatcher, isExcludedDirName, } from "./file-utils.js";
-import { isGeneratedArtifactDirectoryName, isGeneratedOrArtifact, } from "./generated-artifacts.js";
-import { collectSourceFiles, collectSourceFilesAsync, collectSourceFilesWithBudgetAsync, } from "./source-filter.js";
-export function shouldSkipProjectPath(filePath, options) {
-    const isDirectory = options.isDirectory === true;
-    const matcher = options.ignoreMatcher ?? getProjectIgnoreMatcher(options.rootDir);
-    if (matcher.isIgnored(filePath, isDirectory))
-        return true;
-    const name = path.basename(filePath);
-    if (isDirectory) {
-        if (isExcludedDirName(name))
-            return true;
-        return (options.includeGenerated !== true &&
-            isGeneratedArtifactDirectoryName(name));
-    }
-    return (options.includeGenerated !== true &&
-        isGeneratedOrArtifact(filePath, {
-            readContentHeader: options.inspectGeneratedHeaders !== false,
-            includeDeclarations: options.includeDeclarationFiles !== true,
-        }));
-}
-export function shouldScanProjectSourceFile(filePath, options) {
-    try {
-        if (!fs.statSync(filePath).isFile())
-            return false;
-    }
-    catch {
-        return false;
-    }
-    return !shouldSkipProjectPath(filePath, {
-        ...options,
-        isDirectory: false,
-    });
-}
-export function collectProjectSourceFiles(rootDir, options) {
-    return collectSourceFiles(rootDir, options);
-}
-/**
- * Async, chunked-yield twin of {@link collectProjectSourceFiles}. Produces the
- * exact same file list (it shares `classifyEntry` with the sync collector) but
- * yields to the event loop every N entries so a large-tree walk on a hot hook
- * tick (e.g. the per-edit cascade graph rebuild) never holds the loop in one
- * synchronous burst. Prefer this on the per-edit / per-cascade path.
- */
-export function collectProjectSourceFilesAsync(rootDir, options) {
-    return collectSourceFilesAsync(rootDir, options);
-}
+import { collectSourceFilesWithBudgetAsync, } from "./source-filter.js";
 /**
- * Budget-aware twin of {@link collectProjectSourceFilesAsync} (#760): same
- * walk, but returns `{ files, entryBudgetExceeded }` so a caller on a hot
+ * Budget-aware source walk (#760): the same walk as
+ * `collectProjectSourceFiles`, but returns `{ files, entryBudgetExceeded }` so a caller on a hot
  * path (e.g. the per-edit cascade graph rebuild) can observe that the walk
  * stopped at its `maxScanEntries` entry budget and got a truncated
  * best-effort list rather than a complete enumeration.

package/node_modules/pi-lens/dist/clients/python-provenance.js

@@ -455,7 +455,7 @@ class Summary {
         return false;
     }
 }
-export function getPythonProvenanceSummary(root) {
+function getPythonProvenanceSummary(root) {
     const cached = SUMMARY_BY_ROOT.get(root);
     if (cached)
         return cached;

package/node_modules/pi-lens/dist/clients/read-guard-logger.js

@@ -18,7 +18,7 @@ const VERBOSE_READ_GUARD_LOG = process.env.PI_LENS_READ_GUARD_VERBOSE === "1" ||
 const LOG_ALLOWED_EDITS = process.env.PI_LENS_READ_GUARD_LOG_ALLOWS === "1";
 const SNAPSHOT_LOG_SETTING = (process.env.PI_LENS_READ_GUARD_LOG_SNAPSHOTS ?? "1").toLowerCase();
 const LOG_SNAPSHOT_VALIDATION = !["0", "false", "off"].includes(SNAPSHOT_LOG_SETTING);
-export const MAX_EDIT_BATCH_ITEMS = 100;
+const MAX_EDIT_BATCH_ITEMS = 100;
 let generatedCorrelationCounter = 0;
 export function sanitizeCorrelationId(value) {
     if (typeof value !== "string" && typeof value !== "number")

package/node_modules/pi-lens/dist/clients/read-guard.js

@@ -1396,8 +1396,11 @@ export class ReadGuard {
             return filePath.endsWith(suffix);
         }
         if (pattern.includes("*")) {
-            // Convert glob to regex
-            const regex = new RegExp(`^${pattern.replace(/\\/g, "\\\\").replace(/\./g, "\\.").replace(/\*/g, ".*")}$`);
+            // Adjacent stars are equivalent to one star in this dialect. Collapse
+            // them before compiling so a non-match cannot backtrack over every
+            // nullable `.*` group (#2622).
+            const collapsedPattern = pattern.replace(/\*+/g, "*");
+            const regex = new RegExp(`^${collapsedPattern.replace(/\\/g, "\\\\").replace(/\./g, "\\.").replace(/\*/g, ".*")}$`);
             return regex.test(filePath);
         }
         return filePath === pattern;