@herbertgao/pi-extensions 2026.8.4 → 2026.8.5

package/node_modules/pi-lens/docs/features.md

@@ -40,6 +40,21 @@ Repositories can disable all immediate and deferred auto-format mutations with
 keeping formatter detection, lint dispatch, LSP synchronization, and
 diagnostics available.
 
+Deferred formatting (the `agent_end` default) runs with **bounded
+concurrency**: at most three formatter subprocesses in flight at once, with
+results applied in admission order and cooperative yields between files, so a
+large batch of queued files can't stall the event loop or the turn-end pass.
+
+### Commit/Push Guard (Experimental)
+
+`--lens-guard` (also `guard.enabled: true` in `~/.pi-lens/config.json`) opts
+into blocking `git commit`/`git push` while unresolved pi-lens blockers exist.
+Detection covers normalized wrapper launchers, shell-escaped and
+keyword/combined-flag verb forms, and shell substitutions, while literal text
+in non-executing contexts remains allowed. Off by default; see
+[docs/agent-guide.md](agent-guide.md) and [docs/settings.md](settings.md) for
+the full behavior and honest limits.
+
 ### Review Graph - Cascade Diagnostics
 
 pi-lens builds a review graph (`file → symbol → dependency`) during session and uses it at turn end to render an impact cascade: which files were affected by a change and how diagnostics propagated through the dependency graph. Nodes track kind, language, and export status; edges track contains/imports/calls/references.
@@ -317,9 +332,9 @@ pi-lens ships an MCP (Model Context Protocol) server so Claude Code — or any M
 | Layer | MCP tools | What they expose |
 |---|---|---|
 | **Per-edit** | `pilens_analyze`, `pilens_lsp_diagnostics`, `pilens_lsp_navigation`, `pilens_ast_grep_search`, `pilens_ast_grep_replace`, `pilens_module_report`, `pilens_read_symbol` | The fast pipeline (format → autofix → LSP diagnostics → parallel runners) plus the structured read-substitute pair. `analyze` accepts `mode: warm \| fresh` — `warm` reuses the server's in-process LSP, `fresh` forks a worker that loads freshly-built code from disk so the result reflects the latest commit. |
-| **Per-turn** | `pilens_turn_end` | Drives the **real** `handleTurnEnd` (knip incremental, jscpd delta, dep-circular, cascade, tests, actionable+code-quality warnings) — not a re-implementation. Caller-supplied edited files are auto-registered into turn-state via `addModifiedRange`. |
+| **Per-turn** | `pilens_turn_end` | Drives the **real** `handleTurnEnd` (knip incremental, dep-circular, cascade, tests, actionable+code-quality warnings) — not a re-implementation. Caller-supplied edited files are auto-registered into turn-state via `addModifiedRange`. |
 | **Per-session** | `pilens_session_start` | Drives the **real** `handleSessionStart` — full jscpd/knip/madge/govulncheck/gitleaks/trivy scans + complexity baselines + LSP warm. The error-debt baseline is not currently populated by the production session-start path. |
-| **Project / observability** | `pilens_project_scan`, `pilens_diagnostics`, `pilens_health`, `pilens_latency`, `pilens_symbol_search` | Cheap project-wide scans, cached diagnostic state, latency telemetry, ranked identifier search (BM25 over the persisted word index — see [docs/word-index.md](word-index.md)). Cross-file blast radius now lives in `pilens_module_report`'s `blastRadius` option. |
+| **Project / observability** | `pilens_project_scan`, `pilens_diagnostics`, `pilens_health`, `pilens_latency`, `pilens_symbol_search` | Cheap project-wide scans, cached diagnostic state, latency telemetry, ranked identifier search (BM25 over the persisted word index — see [docs/word-index.md](word-index.md)). Cross-file blast radius now lives in `pilens_module_report`'s `blastRadius` option. `pilens_health` (and its pi-side `/lens-health` counterpart) also reports a bounded, process-local **degradation ledger** — trust refusals, mode suppressions, LSP breaker trips, formatter skips/failures, TypeScript/word-index/review-graph/project-snapshot idle evictions, WASM aborts, and diagnostics-timeout tallies — so silently degraded behavior stays visible instead of vanishing into a log. |
 | **Lifecycle / loop** | `pilens_rebuild` | Runs `npm run build:dist` so `pilens_analyze mode=fresh` reflects the latest commit. Makes the review loop self-contained: commit → `pilens_rebuild` → `pilens_analyze mode=fresh` → `pilens_latency`. |
 
 **Honest limits** (live-tested, documented in `mcp.md`):
@@ -342,4 +357,18 @@ claude mcp add --scope user pi-lens \
   -- node <repo>/dist/mcp/server.js
 ```
 
+**Hooks** (`settings.json`) close the loop: PostToolUse = per-edit, Stop = per-turn.
+
+```json
+{ "hooks": {
+  "PostToolUse": [
+    { "matcher": "Edit|Write",
+      "hooks": [ { "type": "command", "command": "pi-lens-analyze --hook" } ] } ],
+  "Stop": [
+    { "hooks": [ { "type": "command", "command": "pi-lens-analyze --turn-end", "timeout": 60 } ] } ]
+} }
+```
+
+The per-edit hook falls back to a cold local analysis when no server is up; the `Stop` hook is **warm-server-only** because only the server process owns the session state and pending turn work. It skips with a single stderr line when unavailable. Workspace IPC requests are ordered, so a timed-out PostToolUse client cannot let `Stop` overtake analysis still running in the server. `SubagentStop` is deliberately not registered because subagent edits already reach turn-state through PostToolUse.
+
 The full design + tier-by-tier progress (and known limits) lives in [`docs/mcp.md`](docs/mcp.md). Status: **experimental** — the foundation is solid (transport, warm LSP, lifecycle handlers wired), but the surface is still maturing. Use the pi extension for production agent work; reach for the MCP server for debugging, dogfooding, and direct Claude Code access.

package/node_modules/pi-lens/docs/globalconfig.md

@@ -24,6 +24,7 @@ Each runtime toggle is settable from the CLI *and* from `config.json`. The two a
 | `--lens-actionable-warning-actions` | `actionableWarnings.includeLspCodeActions` | `false` |
 | `--lens-actionable-warning-autofix` | `actionableWarnings.autoFix.enabled` | `false` |
 | `--lens-actionable-warning-all` | `actionableWarnings.deltaOnly` (`false`) | `true` |
+| `--lens-compact-tool-line` | `ui.compactToolLine` | `false` |
 
 Keys are positive (`"enabled": true` means the feature runs), so a `--no-*` flag corresponds to setting its key `false`. A `no-*` flag on the command line is a one-way switch: it can disable, never re-enable, so `--no-lsp` wins over `lsp.enabled: true` but nothing on the CLI overrides `lsp.enabled: false`. Set the key back to `true` to re-enable.
 
@@ -167,10 +168,52 @@ Note: `maxProjectFiles` (below) is discovered differently — via an upward walk
 
 ### `rules`
 
-Per-rule threshold overrides. Currently honored:
+Per-rule threshold overrides and policy filters. Currently honored:
 
 - `high-complexity.threshold` — cyclomatic complexity (default `15`)
 - `high-fan-out.threshold` — distinct function calls (default `20`)
+- `<id>.disable` — disable diagnostics for the listed rule ids (output-only
+  filter). Same rule-id normalization as `pi-lens-ignore`: a user lists
+  `no-eval` once and the filter covers `no-eval`, `ast-grep:no-eval`, and
+  `no-eval-js`. Side effect: a rule whose real name genuinely ends in `-js`
+  (e.g. `prefer-js`) is conflated with its stem (`prefer`) — disabling or
+  selecting one also disables or selects the other.
+- `<id>.select` — allowlist of rule ids; only the listed rule ids survive
+  filtering. Disable wins over select project-wide, even when the two lists
+  are configured under different keys.
+
+The `<id>` key is a grouping label only — it does not scope which rules the
+`disable`/`select` list underneath it can match. Matching is **project-wide**:
+every `disable` list across every key is unioned into one drop list, and
+every `select` list across every key is unioned into one allowlist. So
+`"security": { "disable": ["no-eval"] }` disables `no-eval` regardless of
+`security` being the rule's own id, and two keys can each contribute to the
+same select union.
+
+```json
+{
+  "rules": {
+    "high-complexity": { "threshold": 25 },
+    "high-fan-out": { "threshold": 30 },
+    "no-eval": { "disable": ["no-eval", "no-eval-js", "ast-grep:no-eval"] },
+    "my-rule-set": { "select": ["rule-a", "rule-b"] }
+  }
+}
+```
+
+**Warning:** because select is project-wide, a non-empty `select` list
+*anywhere* in `rules` silences every rule not in that list, across the whole
+project — including tsc/eslint findings, not just the rule types you're
+thinking about when you write it. It's a big hammer; reach for `disable`
+instead unless you actually want an allowlist over everything. Findings that
+carry no rule id at all (an eslint parse error, for example) are exempt from
+select, so an allowlist can never hide them.
+
+Disable and select are output-only filters applied AFTER inline suppression,
+disposition, and dedup — the project-level policy never widens the trusted
+surface area (widget state, baseline, dedup cache stay authoritative). The
+baseline still records the full unfiltered set so a project-config edit does
+not corrupt delta baselines.
 
 ### `maxProjectFiles`
 
@@ -197,5 +240,6 @@ Explicit override for the review graph's own file budget (#775), for monorepos t
 - A malformed JSON file is logged once and treated as "no config" — your diagnostics never get blocked by a syntax error in your own config.
 - Rule thresholds must be positive finite numbers; invalid, zero, or negative values are logged once and ignored.
 - Mutation-control `enabled` values must be booleans; invalid values are logged once and ignored.
+- `rules.<id>.disable` and `rules.<id>.select` must each be a non-empty array of non-empty strings; a non-array value, an empty array, or an all-whitespace array is logged once and the entry is dropped. A policy-only entry (no `threshold`) is honored. A policy entry with an invalid value still keeps any valid `threshold` alongside it.
 - The depth sub-threshold of `high-complexity` (default `6`) is intentionally not exposed; only the cyclomatic-complexity knob ships today to keep the schema tight.
 - The file is mtime-cached, so editing it takes effect on the next scan without restarting the agent.

package/node_modules/pi-lens/docs/language-coverage.md

@@ -20,8 +20,8 @@ Dispatch is diagnostics-oriented: automatic formatting and safe autofix happen i
 | HTML                  | ✓   | lsp, htmlhint                                                                                                  | prettier                |
 | YAML                  | ✓   | lsp, yamllint, actionlint (GitHub workflows)                                                                   | prettier                |
 | JSON                  | ✓   | lsp                                                                                                            | biome, prettier         |
-| Svelte                | ✓   | lsp                                                                                                            | —                       |
-| Vue                   | ✓   | lsp                                                                                                            | —                       |
+| Svelte                | ✓   | lsp                                                                                                            | oxfmt (needs `svelte` pkg installed + config `svelte: true`) |
+| Vue                   | ✓   | lsp                                                                                                            | prettier, oxfmt         |
 | SQL                   | —   | sqlfluff                                                                                                       | sqlfluff                |
 | Markdown              | —   | spellcheck, markdownlint, vale                                                                                 | prettier                |
 | Docker                | ✓   | lsp, hadolint                                                                                                  | —                       |
@@ -42,7 +42,8 @@ Dispatch is diagnostics-oriented: automatic formatting and safe autofix happen i
 | Gleam                 | ✓   | lsp, gleam-check                                                                                               | gleam format            |
 | OCaml                 | ✓   | lsp                                                                                                            | ocamlformat             |
 | Clojure               | ✓   | lsp                                                                                                            | cljfmt                  |
-| Terraform             | ✓   | lsp, tflint                                                                                                    | terraform fmt           |
+| Terraform             | ✓   | lsp, tflint, trivy-config (opt-in)                                                                             | terraform fmt           |
+| Terragrunt            | —   | terragrunt                                                                                                     | terragrunt hcl fmt      |
 | Nix                   | ✓   | lsp                                                                                                            | nixfmt                  |
 | TOML                  | ✓   | lsp, taplo                                                                                                     | taplo                   |
 | CMake                 | ✓ (cmake-language-server) | lsp                                                                                           | cmake-format            |

package/node_modules/pi-lens/docs/lsp-capability-matrix.md

@@ -18,7 +18,7 @@ regenerated docs — so this file self-populates from CI without manual copy-pas
 
 `probe-clean-signal.mjs` also runs a **drift check** (#529): it compares each
 probed server's observed `clean-behavior` against the hand-set `silentOnClean`
-marker in `clients/lsp/server-strategies.ts` and writes any mismatch to the
+marker in `clients/lsp/wait-policy/strategies.ts` and writes any mismatch to the
 `## silentOnClean drift` section below. This is telemetry only — never a CI
 gate — because the probe is a timing-based negative observation; a mismatch
 just tells a human the marker may need updating. `unknown` observations are
@@ -150,7 +150,7 @@ the rest fill in as the nightly reaches them.
 ## silentOnClean drift (nightly-generated)
 
 Telemetry only — never a CI gate. Compares each probed server's observed
-`clean-behavior` against `clients/lsp/server-strategies.ts`'s `silentOnClean`
+`clean-behavior` against `clients/lsp/wait-policy/strategies.ts`'s `silentOnClean`
 marker; a mismatch means the marker may need a human update (#529). `unknown`
 observations are never compared (a slow/absent server is not evidence either way).
 

package/node_modules/pi-lens/docs/mcp.md

@@ -378,13 +378,18 @@ be exercised + debugged directly through Claude Code without running pi.
   Wire it in Claude Code `settings.json`:
 
   ```json
-  { "hooks": { "PostToolUse": [
-    { "matcher": "Edit|Write",
-      "hooks": [ { "type": "command", "command": "pi-lens-analyze --hook" } ] } ] } }
+  { "hooks": {
+    "PostToolUse": [
+      { "matcher": "Edit|Write",
+        "hooks": [ { "type": "command", "command": "pi-lens-analyze --hook" } ] } ],
+    "Stop": [
+      { "hooks": [ { "type": "command", "command": "pi-lens-analyze --turn-end", "timeout": 60 } ] } ]
+  } }
   ```
 
   (the cold-LSP fix means the type-check is honestly reported as skipped, not a
-  false clean; the agent pulls `pilens_analyze` warm when it wants types.)
+  false clean; the agent pulls `pilens_analyze` warm when it wants types. The
+  `Stop` half is the per-turn pass — see the bullet below.)
 
 - [ ] **booboo** full-codebase review tool (`/lens-booboo` → handleBooboo:
   complexity, AI-slop, TODOs, dead-code, dupes, type-coverage).
@@ -410,6 +415,34 @@ be exercised + debugged directly through Claude Code without running pi.
   project. 5 IPC unit tests (path stability, named-pipe round-trip, no-server +
   error → undefined fallback); live-proven (server "warm analyze" log fired,
   bin returned the diagnostic). Removes the one real weakness of the push half.
+- [x] **Stop hook → per-turn pass** (#538) — the `pi-lens-analyze` bin gains a
+  turn-end mode (`--turn-end`, or a Claude Code `Stop` payload on stdin), the
+  analogue of pi's `agent_end`: incremental knip/madge, dep-circular,
+  cascade-to-dependents, tests, actionable-warnings aggregation. PostToolUse has
+  already accumulated the edited files into turn-state by the time `Stop` fires,
+  so the hook passes no files and clears any inherited pi `sessionId` — turn-
+  end's stale-session eviction leaves the registered worklist alone. The request is a
+  tagged route (`{route:"turn-end"}`, own schema version) on the **workspace**
+  socket, not the PID-scoped one: a Stop hook knows its cwd, never the server's
+  pid. It rides in ahead of the parse, so it inherits the #535 build-staleness
+  gate for free, and an untagged analyze request on the same socket is byte-for-
+  byte unchanged. All workspace IPC requests share one server-side queue, so a
+  timed-out PostToolUse client cannot let `Stop` overtake analysis still running
+  in the server, and concurrent turn-ends cannot race the turn-state clear.
+  **Warm-only, no cold fallback**: only the server process owns the session state
+  and pending turn work, so a local pass would report a false clean — no warm
+  server means one stderr line, silent stdout, exit 0.
+  The client waits 55s so it gives up inside Claude Code's 60s hook timeout.
+  `SubagentStop` is deliberately NOT registered: subagent edits already fire
+  PostToolUse into the shared turn-state, the consume bridges are one-shot (a
+  subagent pass would eat the main agent's findings into a transcript nobody
+  reads), and the fan-out would multiply the heavy pass. Visibility, honestly:
+  Stop-hook stdout is user-visible in transcript mode (Ctrl-R), NOT model
+  context — blockers still gate commits through the retained lens-guard record,
+  and a `decision:"block"` render is a follow-up. Tests run fire-and-forget
+  inside turn-end, so the `Tests:` section you see is the *previous* turn's
+  failures. Unit, bin, and live-route smoke tests cover transport, ordering,
+  rendering, and spawned-server behavior.
 
 ## Transport decision — RESOLVED: hand-roll (zero new deps)
 

package/node_modules/pi-lens/docs/servercapabilities.md

@@ -6,7 +6,7 @@ server's `initialize` handshake. Generated by `node scripts/server-capabilities.
 absent on the generating host are listed under *Unavailable* — run in a
 provisioned environment (the nightly) to capture those rows.
 
-_Last generated: 2026-08-01 on linux; 29 servers captured, 14 unavailable._
+_Last generated: 2026-08-14 on linux; 29 servers captured, 14 unavailable._
 
 ## Diagnostic mode + navigation/edit operations
 
@@ -19,7 +19,7 @@ Legend: ✓ advertised, · not. **mode** = document diagnostics (`pull` = `textD
 | clojure | push-only | · | ✓ | · | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | 62 |
 | csharp | pull | ✓ | ✓ | ✓ | · | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | 0 |
 | css | pull | · | ✓ | · | · | ✓ | ✓ | · | ✓ | · | ✓ | ✓ | · | · | 0 |
-| dart | push-only | · | ✓ | ✓ | · | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | 16 |
+| dart | push-only | · | ✓ | ✓ | · | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | 18 |
 | deno | pull | · | ✓ | ✓ | · | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | 2 |
 | docker | push-only | · | ✓ | · | · | · | ✓ | ✓ | ✓ | · | · | ✓ | · | · | 0 |
 | expert | push-only | · | ✓ | · | · | ✓ | ✓ | · | ✓ | ✓ | ✓ | · | · | · | 2 |
@@ -89,7 +89,7 @@ surface, including providers pi-lens does not yet consume.
 
 - **ast-grep** (1): ast-grep.applyAllFixes
 - **clojure** (62): add-import-to-namespace, add-missing-import, add-missing-libspec, add-require-suggestion, as-to-refer, backward, backward-barf, backward-select, backward-slurp, change-coll, clean-ns, cond->if-refactor, create-function, create-test, cursor-info, cycle-coll, cycle-keyword-auto-resolve, cycle-privacy, demote-fn, destructure-keys, drag-backward, drag-forward, drag-param-backward, drag-param-forward, expand-let, extract-function, extract-to-def, forward, forward-barf, forward-select, forward-slurp, get-in-all, get-in-less, get-in-more, get-in-none, if->cond-refactor, inline-function, inline-symbol, introduce-let, kill-sexp, …
-- **dart** (16): dart.edit.codeAction.apply, dart.edit.sortMembers, dart.edit.organizeImports, dart.edit.fixAll, dart.edit.fixAllInWorkspace.preview, dart.edit.fixAllInWorkspace, dart.edit.sendWorkspaceEdit, refactor.perform, refactor.validate, dart.logAction, dart.refactor.add_constructor_name, dart.refactor.convert_all_formal_parameters_to_named, dart.refactor.convert_selected_formal_parameters_to_named, dart.refactor.move_selected_formal_parameters_left, dart.refactor.move_top_level_to_file, dart.refactor.remove_constructor_name
+- **dart** (18): dart.edit.codeAction.apply, dart.edit.sortMembers, dart.edit.organizeImports, dart.edit.fixAll, dart.edit.fixAllInWorkspace.preview, dart.edit.fixAllInWorkspace, dart.edit.sendWorkspaceEdit, refactor.perform, refactor.validate, dart.logAction, dart.refactor.add_constructor_name, dart.refactor_add.import_prefix, dart.refactor.convert_all_formal_parameters_to_named, dart.refactor.convert_selected_formal_parameters_to_named, dart.refactor.move_selected_formal_parameters_left, dart.refactor.move_top_level_to_file, dart.refactor.remove_constructor_name, dart.refactor.remove_import_prefix
 - **deno** (2): deno.cache, deno.reloadImportRegistries
 - **expert** (2): Reindex, connectionDetails
 - **go** (47): gopls.add_dependency, gopls.add_import, gopls.add_telemetry_counters, gopls.add_test, gopls.apply_fix, gopls.assembly, gopls.change_signature, gopls.check_upgrades, gopls.client_open_url, gopls.diagnose_files, gopls.doc, gopls.edit_go_directive, gopls.extract_to_new_file, gopls.fetch_vulncheck_result, gopls.free_symbols, gopls.gc_details, gopls.generate, gopls.go_get_package, gopls.implement_interface, gopls.list_imports, gopls.list_known_packages, gopls.lsp, gopls.maybe_prompt_for_telemetry, gopls.mem_stats, gopls.modify_tags, gopls.modules, gopls.move_type, gopls.package_symbols, gopls.packages, gopls.regenerate_cgo, gopls.remove_dependency, gopls.reset_go_mod_diagnostics, gopls.run_go_work_command, gopls.run_govulncheck, gopls.run_tests, gopls.scan_imports, gopls.split_package, gopls.start_debugging, gopls.start_profile, gopls.stop_profile, …

package/node_modules/pi-lens/docs/settings.md

@@ -60,6 +60,7 @@ column is the effective behavior when nothing is set.
 | `--no-tests` | `tests.enabled` | global | test runner **on** |
 | `--no-delta` | `delta.enabled` | global | delta mode **on** (new diagnostics only) |
 | `--lens-guard` | `guard.enabled` | global | **off** |
+
 | `--no-opengrep` | `opengrep.enabled` | global | Opengrep scanner **on** |
 | `--no-read-guard` | `readGuard.enabled` | global | read-before-edit monitor **on** |
 | `--no-lens-context` | `contextInjection.enabled` | global | context injection **on** |
@@ -68,6 +69,13 @@ column is the effective behavior when nothing is set.
 | `--lens-actionable-warning-actions` | `actionableWarnings.includeLspCodeActions` | global | **off** |
 | `--lens-actionable-warning-autofix` | `actionableWarnings.autoFix.enabled` | project | **off** |
 | `--lens-actionable-warning-all` | `actionableWarnings.deltaOnly` (`false`) | global | `deltaOnly` **on** (report this turn only) |
+| `--lens-compact-tool-line` | `ui.compactToolLine` | global | **off** (two-row tool rendering) |
+
+`--lens-guard` is **EXPERIMENTAL and strictly opt-in**. When enabled, actual
+`git commit`/`git push` commands are blocked only for current, structured
+blocking findings (including blocking test failures); advisory/no-action-required
+findings do not block. Stale, malformed, or ambiguous persisted state blocks
+conservatively until checks run again.
 
 `--immediate-format` and `--lens-actionable-warning-all` are not `--no-*` flags,
 so they set a value rather than flipping a boolean off.
@@ -87,6 +95,8 @@ field docs.
 | `actionableWarnings.autoFix.maxFixes` | global | `5` | Cap on quickfixes applied per turn (`0` = report only) |
 | `rules.high-complexity.threshold` | project | `15` | Cyclomatic-complexity threshold |
 | `rules.high-fan-out.threshold` | project | `20` | Distinct-function-call threshold |
+| `rules.<id>.disable` | project | absent | Disable diagnostics for a rule (output-only filter, project-wide; same normalization as `pi-lens-ignore`) |
+| `rules.<id>.select` | project | absent | Allowlist of rule ids (output-only filter, project-wide across every key; disable wins over select) |
 | `maxProjectFiles` | project | `2000` | Base scale knob; derives five subsystem size budgets |
 | `reviewGraph.maxFiles` | project | derived (clamped `100`–`20000`) | Explicit review-graph file budget |
 | `trivy.enabled` / `trivy.minSeverity` | project | off | Opt-in Trivy vulnerability scanning |
@@ -140,7 +150,8 @@ tolerated without warning; anything else is logged once as a likely typo.
   "ignore": ["**/*.test.ts", "vendor/**"],
   "rules": {
     "high-complexity": { "threshold": 25 },
-    "high-fan-out": { "threshold": 30 }
+    "high-fan-out": { "threshold": 30 },
+    "no-eval": { "disable": ["no-eval", "ast-grep:no-eval", "no-eval-js"] }
   },
   "maxProjectFiles": 5000,
   "format": { "enabled": false }

package/node_modules/pi-lens/docs/tools.md

@@ -5,7 +5,10 @@ pi-lens registers the following slash commands with the pi host:
 - `/lens-toggle` — toggle pi-lens on/off for the current session without restarting
 - `/lens-context-toggle` — toggle automatic context injection on/off for the session (tools/LSP/read-guard/formatting stay active)
 - `/lens-widget-toggle` — show/hide the pi-lens diagnostics widget below the editor
-- `/lens-health` — runtime health, latency, and diagnostic telemetry
+- `/lens-health` — runtime health, latency, and diagnostic telemetry, including
+  bounded per-session degradation counts (trust refusals, LSP breakers,
+  formatter skips/failures, idle evictions, WASM aborts, timeout tallies, and
+  more)
 - `/lens-perf` — independent top-five p50 and p99 rankings for the current process session and machine-wide active latency-log window
 - `/lens-allow-edit <path>` — override the read-before-edit guard for a single edit
 - `/lens-tools` — tool installation status: globally installed, auto-installed, or npx fallback

package/node_modules/pi-lens/docs/usage.md

@@ -91,6 +91,7 @@ pi --lens-guard          # Block git commit/push when unresolved blockers exist
 pi --no-opengrep         # Disable the Opengrep security scanner (default-on auxiliary LSP)
 pi --no-read-guard       # Disable the read-before-edit behavior monitor
 pi --lens-turn-summary   # Persist a per-turn summary of diagnostics, autofixes, and autoformats
+pi --lens-compact-tool-line   # Render tool results as one compact, theme-aware line (closes #1327)
 
 # Actionable warnings (all default off)
 pi --lens-actionable-warnings          # Report fixable warnings at turn end
@@ -141,6 +142,23 @@ second host adapter that calls the same `clients/lens-engine.ts` seam as the pi
 extension. Use `npm run build:dist` after MCP/engine changes so the user-scoped
 server loads fresh compiled code.
 
+Two Claude Code hooks give the MCP mirror the same automatic cadence the pi
+extension has. PostToolUse runs the per-edit pass, `Stop` runs the per-turn one:
+
+```json
+{ "hooks": {
+  "PostToolUse": [
+    { "matcher": "Edit|Write",
+      "hooks": [ { "type": "command", "command": "pi-lens-analyze --hook" } ] } ],
+  "Stop": [
+    { "hooks": [ { "type": "command", "command": "pi-lens-analyze --turn-end", "timeout": 60 } ] } ]
+} }
+```
+
+The `Stop` hook only works against a running MCP server because only that
+process owns the session state and pending turn work. With no warm server the
+turn-end is skipped, not faked: one line on stderr and nothing on stdout.
+
 ## Troubleshooting
 
 - Run `npm run build` before tests after editing TypeScript; tests import

package/node_modules/pi-lens/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-lens",
-  "version": "3.8.74",
+  "version": "4.0.0",
   "type": "module",
   "description": "Real-time code feedback for pi — LSP, linters, formatters, type-checking, structural analysis & booboo",
   "repository": {
@@ -20,9 +20,9 @@
     "prepare": "npm run build:dist && node scripts/download-grammars.js --core --dest grammars",
     "lint": "tsc --project tsconfig.json",
     "watch": "tsc --watch",
-    "test": "vitest run",
-    "test:unit": "vitest run --ignore tests/index-integration.test.ts --ignore tests/clients/lsp/integration.test.ts",
-    "test:integration": "vitest run tests/index-integration.test.ts tests/clients/lsp/integration.test.ts",
+    "test": "node scripts/with-test-lock.mjs -- vitest run",
+    "test:unit": "node scripts/with-test-lock.mjs -- vitest run",
+    "test:integration": "node scripts/with-test-lock.mjs -- vitest run tests/index-integration.test.ts tests/clients/lsp/integration.test.ts",
     "test:watch": "vitest",
     "check": "node scripts/check-extensions.mjs",
     "selftest:install": "node scripts/install-selftest.mjs",
@@ -34,7 +34,7 @@
     "audit:astgrep-rule-pairs": "node scripts/audit-astgrep-rule-pairs.mjs",
     "audit:playground": "node scripts/playground-verify-rule.mjs",
     "logs:smells": "node scripts/analyze-pi-lens-logs.mjs",
-    "changelog:check": "node scripts/changelog-release.mjs --check",
+    "changelog:check": "node scripts/rollup-changelog.mjs --check",
     "changelog:release": "node scripts/changelog-release.mjs",
     "changelog:extract": "node scripts/changelog-extract.mjs",
     "release:backfill-notes": "node scripts/backfill-github-releases.mjs",
@@ -85,9 +85,9 @@
   "dependencies": {
     "@ast-grep/cli": "^0.45.0",
     "@ast-grep/napi": "^0.45.0",
-    "@earendil-works/pi-tui": "^0.82.1",
+    "@earendil-works/pi-tui": "^0.84.1",
     "js-yaml": "^5.2.2",
-    "minimatch": "^10.2.5",
+    "minimatch": "^10.2.6",
     "pidusage": "^4.0.1",
     "typebox": "^1.0.0",
     "vscode-jsonrpc": "^9.0.0"
@@ -105,7 +105,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.10",
-    "@earendil-works/pi-coding-agent": "^0.82.1",
+    "@earendil-works/pi-coding-agent": "^0.84.1",
     "@types/node": "^26.0.0",
     "@types/pidusage": "^2.0.5",
     "@vitest/coverage-v8": "^4.1.5",
@@ -134,8 +134,8 @@
     ]
   },
   "allowScripts": {
-    "@ast-grep/cli@0.44.1": true,
+    "@ast-grep/cli@0.45.1": true,
     "@google/genai@1.52.0": true,
-    "protobufjs@7.6.4": true
+    "protobufjs@7.6.5": true
   }
 }

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-bare-except-test.yml

@@ -15,6 +15,55 @@ valid:
         doThing()
     except Exception as e:
         handle(e)
+  - |
+    # dotted/qualified name (#1031)
+    try:
+        doThing()
+    except asyncio.TimeoutError:
+        handle()
+  - |
+    # parenthesized single name (mirrors #1026's tree-sitter spec set)
+    try:
+        doThing()
+    except (ValueError):
+        handle()
+  - |
+    # subscripted generic (#1244)
+    try:
+        doThing()
+    except dict[str, int]:
+        handle()
+  - |
+    # subscripted PEP 654 exception group (#1244)
+    try:
+        doThing()
+    except BaseExceptionGroup[TypeError, ValueError]:
+        handle()
+  - |
+    try:
+        doThing()
+    except ValueError | TypeError:
+        handle()
+  - |
+    try:
+        doThing()
+    except cache[key]:
+        handle()
+  - |
+    try:
+        doThing()
+    except (ValueError,):
+        handle()
+  - |
+    try:
+        doThing()
+    except (mod.E1, E2) as error:
+        handle(error)
+  - |
+    try:
+        doThing()
+    except* ValueError:
+        handle()
 invalid:
   - |
     try:

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-bare-host-path-in-win32-branch-test.yml

@@ -0,0 +1,87 @@
+id: no-bare-host-path-in-win32-branch
+valid:
+  # DOCUMENTED LIMITATION (#1339 review): the exact pre-fix #1150 shape --
+  # bare dirname in an unguarded helper CALLED FROM the guarded branch.
+  # ast-grep has no cross-function reach, so this is deliberately a
+  # negative fixture; it exists so a future strengthening flips it to a
+  # positive consciously, not accidentally. Review-enforced meanwhile
+  # (AGENTS.md defect-shape 2).
+  - |
+    import * as path from "node:path";
+    import { isWindowsPath } from "./path-utils.js";
+    function resolveNonExisting(filePath: string) {
+      return path.dirname(filePath);
+    }
+    function normalize(filePath: string) {
+      if (isWindowsPath(filePath)) {
+        return resolveNonExisting(filePath);
+      }
+    }
+  - |
+    import * as path from "node:path";
+    import { isWindowsPath } from "./path-utils.js";
+    function f(filePath: string) {
+      if (isWindowsPath(filePath)) {
+        return path.win32.dirname(filePath);
+      }
+      return path.dirname(filePath);
+    }
+  - |
+    import * as path from "node:path";
+    import { isWindowsPath } from "./path-utils.js";
+    function f(filePath: string) {
+      return isWindowsPath(filePath)
+        ? path.win32.basename(filePath)
+        : path.basename(filePath);
+    }
+  - |
+    import { dirname } from "node:path";
+    function f(filePath: string) {
+      if (someOtherPredicate(filePath)) {
+        return dirname(filePath);
+      }
+    }
+invalid:
+  # Fresh probes from the #1339 review, encoded so they stay covered.
+  - |
+    import * as path from "node:path";
+    import { isWindowsPath } from "./path-utils.js";
+    function f(filePath: string) {
+      if (isWindowsPath(filePath)) {
+        for (const part of parts) {
+          const nested = path.join(filePath, part);
+        }
+      }
+    }
+  - |
+    import * as path from "node:path";
+    import { isWindowsPath } from "./path-utils.js";
+    function f(filePath: string) {
+      if (isWindowsPath(filePath)) {
+        return filePath.split(path.sep);
+      }
+    }
+  - |
+    import * as path from "node:path";
+    import { isFullyQualifiedWin32 } from "./path-utils.js";
+    function f(filePath: string, other: boolean) {
+      if (isFullyQualifiedWin32(filePath) && other) {
+        return path.basename(filePath);
+      }
+    }
+  - |
+    import * as path from "node:path";
+    import { isWindowsPath } from "./path-utils.js";
+    function f(filePath: string) {
+      if (isWindowsPath(filePath)) {
+        return path.dirname(filePath);
+      }
+    }
+  - |
+    import { join, sep } from "node:path";
+    import { isFullyQualifiedWin32 } from "./path-utils.js";
+    function f(filePath: string) {
+      if (isFullyQualifiedWin32(filePath)) {
+        return join(filePath, sep);
+      }
+    }

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-nested-links-test.yml

@@ -2,7 +2,17 @@ id: no-nested-links
 valid:
   - '<a href="/x">link</a>'
   - '<a href="/x"><span>nested</span></a>'
+  - '<div><a href="/x">link</a></div>'
+  - '<div><a href="/x">first</a><a href="/y">second</a></div>'
 invalid:
   - '<a href="/x">outer <a href="/y">inner</a></a>'
   - '<a><a>double</a></a>'
-  - '<div><a href="/x">link</a></div>'
+  - '<a href="/x"><span><a href="/y">inner</a></span></a>'
+  - |
+      <a href="/outer">
+        <span>
+          <a href="/middle">
+            <em><a href="/inner">deep</a></em>
+          </a>
+        </span>
+      </a>

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-raw-json-store-write-test.yml

@@ -0,0 +1,17 @@
+id: no-raw-json-store-write
+valid:
+  - "writeFileAtomic(file, JSON.stringify(data))"
+  - "writeFileSync(file, text)"
+invalid:
+  # #1349 review: encoding/replacer/indent variants are the same raw write.
+  - "writeFileSync(file, JSON.stringify(data), 'utf8')"
+  - "writeFileSync(file, JSON.stringify(data, null, 2))"
+  - "fs.writeFileSync(file, JSON.stringify(data, replacer), { encoding: 'utf8' })"
+  - "writeFileSync(file, JSON.stringify(data))"
+  - "fs.writeFileSync(file, JSON.stringify(data))"
+  - |
+    const payload = JSON.stringify(data)
+    writeFileSync(file, payload)
+  - |
+    const payload = JSON.stringify(data)
+    fs.writeFileSync(file, payload)

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-win32-isabsolute-for-qualification-test.yml

@@ -0,0 +1,16 @@
+id: no-win32-isabsolute-for-qualification
+valid:
+  # DOCUMENTED LIMITATION (#1349 review): the aliased parser -- the shape
+  # the actual pre-#1330 defect used -- is beyond ast-grep's reach and is
+  # deliberately a negative; flipping it to invalid requires an engine
+  # capability decision. Review-enforced meanwhile (AGENTS.md shape 2).
+  - |
+    const w = path.win32;
+    if (w.isAbsolute(filePath)) {
+      return true;
+    }
+  - "isFullyQualified(filePath)"
+  - "path.posix.isAbsolute(filePath)"
+invalid:
+  - "path.win32.isAbsolute(filePath)"
+  - "win32.isAbsolute(filePath)"

package/node_modules/pi-lens/rules/ast-grep-rules/rules/no-bare-except.yml

@@ -12,20 +12,8 @@ note: |
   identifier, making it fire only for empty bodies or `pass`/`raise`
   (where there are no function-call identifiers).
 
-  The fixed rule checks the except_clause's direct children for ANY of
-  the three exception-spec shapes (bare identifier `except E`, tuple
-  `except (E, F)`, or `as` pattern `except E as e`). The original missed
-  the tuple and `as_pattern` forms — a tuple like `(ValueError, KeyError)`
-  has no direct `identifier` child (the identifiers are inside the
-  tuple), and `except Exception as e` has `e` as an identifier child
-  even though the type is specified.
+  The rule now matches the grammar's bare `except:` syntax directly, so
+  newly introduced exception-spec node kinds cannot become false positives.
 rule:
   kind: except_clause
-  not:
-    any:
-      - has:
-          kind: identifier
-      - has:
-          kind: tuple
-      - has:
-          kind: as_pattern
+  pattern: "except:"