@herbertgao/pi-extensions 2026.8.5 → 2026.8.7

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

@@ -67,6 +67,27 @@ const x = risky();
 This is the same convention every runner/profile honors, so a suppression is
 portable, git-tracked, and visible in review — not private pi-lens metadata.
 
+## Dual-scanner secrets need two marks
+
+gitleaks and trivy scan for secrets independently. When both flag the same
+credential on the same line, each finding gets its own anchor (`tool` +
+`rule` differ: `gitleaks:<ruleId>` vs `trivy-secret:<ruleId>`), so one
+`lens_diagnostic_mark` call clears only one of the two copies. The 🔴 STOP
+blocker stays up, citing the still-unmarked copy, until both are marked
+false-positive.
+
+This is deliberate defense-in-depth, not a bug: a real credential that one
+scanner misses still blocks. It is also strictly better than before #1691,
+when the trivy copy of a corroborated finding had no anchor at all and could
+never be cleared. Expect to call `lens_diagnostic_mark` twice — once per
+`tool` — when `lens_diagnostics` shows the same line flagged under both
+`gitleaks` and `trivy`.
+
+The 🔴 STOP line's own bracket names which scanners still hold the finding —
+`[gitleaks + trivy]` before either mark, narrowing to `[trivy]` after the
+gitleaks copy clears — so a shrinking bracket, not a vanished blocker, is the
+signal that one copy remains.
+
 ## Telemetry
 
 Every mark (including in-memory `defer`) is appended as NDJSON to

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

@@ -2,7 +2,7 @@
 
 ### LSP Support
 
-pi-lens includes **42 language server definitions** (including four cross-cutting *auxiliary* scanners that attach alongside the file's language server — Opengrep, ast-grep, zizmor, and typos — see below). LSP is **enabled by default**; use `--no-lsp` to disable it for a session. Servers are auto-discovered from PATH, project `node_modules`, and managed installs. When a server is not installed, pi-lens offers an interactive install prompt.
+pi-lens includes **45 language server definitions** (including four cross-cutting *auxiliary* scanners that attach alongside the file's language server — Opengrep, ast-grep, zizmor, and typos — see below). LSP is **enabled by default**; use `--no-lsp` to disable it for a session. Servers are auto-discovered from PATH, project `node_modules`, and managed installs. When a server is not installed, pi-lens offers an interactive install prompt.
 
 **LSP Idle Management:** LSP servers shut down after 240 seconds of inactivity (no files modified) to free resources. The timer resets when you resume editing, preventing cold-start penalties during active development.
 
@@ -19,13 +19,13 @@ pi-lens includes **42 language server definitions** (including four cross-cuttin
 - **`capabilities`** — shows which operations are supported by the active LSP server(s) for a file, read directly from the cached `initialize` response (no round-trip).
 - **Symbol column resolution** — passing `symbol: "myFunc"` instead of an exact `character` position resolves the correct column automatically. Use `symbol: "foo#2"` for the second occurrence of `foo` on the line.
 
-LSP servers for: TypeScript, Deno, Python (pyright/basedpyright + jedi), Go, Rust, Ruby (ruby-lsp + solargraph), PHP, C# (omnisharp), F#, Java (JDT LS, with Lombok javaagent support when a Lombok jar is available), Kotlin, Swift, Dart, Lua, C/C++, Zig, Haskell, Elixir, Gleam, OCaml, Clojure, Terraform, Nix, Bash, Docker, YAML, JSON, HTML, TOML, Prisma, Vue, Svelte, CSS.
+LSP servers for: TypeScript, Deno, Python (pyright/basedpyright + jedi), Go, Rust, Ruby (ruby-lsp + solargraph), PHP, C# (omnisharp), F#, Java (JDT LS, with Lombok javaagent support when a Lombok jar is available), Kotlin, Swift, Dart, Lua, C/C++, Zig, Haskell, Elixir, Gleam, OCaml, Clojure, CUE (syntax and parse diagnostics; evaluation errors via the cue-vet auxiliary runner), Terraform, Nix, Bash, Docker, YAML, JSON, HTML, TOML, Prisma, Vue, Svelte, CSS.
 
 ### Formatters
 
-pi-lens auto-detects and runs **32 formatters** based on project config:
+pi-lens auto-detects and runs **34 formatters** based on project config:
 
-biome, prettier, oxfmt, ruff, black, sqlfluff, gofmt, rustfmt, zig fmt, dart format, shfmt, nixfmt, mix format, ocamlformat, clang-format, ktlint, rubocop, standardrb, gleam format, terraform fmt, php-cs-fixer, csharpier, fantomas, swiftformat, stylua, ormolu, taplo, fish_indent, google-java-format, cljfmt, cmake-format, psscriptanalyzer-format
+biome, prettier, oxfmt, ruff, black, sqlfluff, gofmt, rustfmt, zig fmt, dart format, shfmt, nixfmt, mix format, ocamlformat, clang-format, ktlint, rubocop, standardrb, gleam format, terraform fmt, php-cs-fixer, csharpier, fantomas, swiftformat, stylua, ormolu, taplo, fish_indent, google-java-format, cljfmt, cmake-format, cue fmt, psscriptanalyzer-format
 
 Detection rules:
 
@@ -40,6 +40,19 @@ Repositories can disable all immediate and deferred auto-format mutations with
 keeping formatter detection, lint dispatch, LSP synchronization, and
 diagnostics available.
 
+**Auto-fix timing depends on the tool.** A `write` (new file, full overwrite,
+or a bash-authored write like `sed -i`/a redirect) still gets pipeline autofix
+immediately, in the same tool result; when it changes the file, the result
+carries the full authoritative post-fix content (capped at 2 MiB per file, one
+shared budget across a multi-file bash write — past that it degrades to a
+re-read warning). An `edit` defers autofix to `agent_end`, where it joins the
+same per-file deferred-mutation queue as deferred formatting — one coalesced
+record per file (`kinds: {autofix, format}`), autofix draining before format
+so the final state is formatter-stable. A `write` immediately followed by an
+`edit` on the same file in the same turn demotes the write's autofix to
+deferred too. See `clients/pipeline.ts`, `clients/runtime-tool-result.ts`, and
+`clients/runtime-agent-end.ts`.
+
 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
@@ -155,7 +168,7 @@ When `actionableWarnings.autoFix.enabled` is set in global or project config (or
 
 ### Bus Events — `pilens:files:touched` (#482)
 
-pi-lens writes files **outside the agent's own tool calls**: dispatch autofix (biome/ruff/eslint/stylelint/sqlfluff/rubocop/ktlint/rust-clippy/dart-fix/golangci-lint/detekt/ktfmt/markdownlint/oxlint --fix) and formatter runs (immediate or deferred-at-`agent_end`) both mutate files after the fact, and the conservative actionable-warnings autofix above applies LSP quickfixes the same way. Other extensions in the same session that track file mutations are otherwise blind to those writes.
+pi-lens writes files **outside the agent's own tool calls**: dispatch autofix (biome/ruff/eslint/stylelint/sqlfluff/rubocop/ktlint/ktfmt/rust-clippy/dart-fix/golangci-lint/detekt/markdownlint/oxlint --fix) mutates the file immediately for a `write` and at `agent_end` for a deferred `edit` (see "Formatters" above); formatter runs (immediate or deferred-at-`agent_end`) do the same; and the conservative actionable-warnings autofix above applies LSP quickfixes at `agent_end` the same way. Other extensions in the same session that track file mutations are otherwise blind to those writes — this event, published either way, is how they find out.
 
 pi-lens broadcasts them on pi's shared in-process event bus (`pi.events`, exposed to every extension via the `ExtensionAPI`) as a single named event:
 
@@ -319,7 +332,21 @@ Trivy requires an **explicit** opt-in (rather than just a manifest being present
 }
 ```
 
-**IaC misconfiguration (per-edit, not a session scan).** When `trivy.enabled` is set, pi-lens also runs `trivy config` as an on-write dispatch runner (alongside hadolint/tflint) over **Dockerfiles** and **Kubernetes manifests** (YAML with an `apiVersion:` + `kind:` signature) — Trivy's security-policy engine (runs-as-root, no `HEALTHCHECK`, `privileged: true`, missing resource limits, …), a different class from hadolint's lint. On Dockerfiles, trivy-config findings that hadolint already reports at the same line are suppressed, so it only adds the security checks hadolint lacks. Terraform/Helm/Compose/CloudFormation are tracked as follow-ups.
+**IaC misconfiguration (per-edit, not a session scan).** When `trivy.enabled` is set, pi-lens also runs `trivy config` as an on-write dispatch runner (alongside hadolint/tflint) over **Dockerfiles** and **Kubernetes manifests** (YAML with an `apiVersion:` + `kind:` signature) — Trivy's security-policy engine (runs-as-root, no `HEALTHCHECK`, `privileged: true`, missing resource limits, …), a different class from hadolint's lint. On Dockerfiles, trivy-config findings that hadolint already reports at the same line are suppressed, so it only adds the security checks hadolint lacks. Compose/CloudFormation are tracked as follow-ups; Terraform is covered by the same runner, and Helm charts are covered by rendered-manifest validation below.
+
+**Rendered-manifest validation for Helm charts (opt-in).** `helm lint` checks a chart's source; it cannot see what the chart produces. When a project sets
+
+```json
+{ "helm": { "renderValidation": { "enabled": true } } }
+```
+
+pi-lens also renders the nearest chart with `helm template` into a scratch directory under the system temp dir and validates the output:
+
+- a **failed render** (a missing values key, a nil pointer in a template expression, a dependency declared in `Chart.yaml` but absent from `charts/`) is reported as a blocking finding on the template that failed — charts that pass `helm lint` and still cannot be installed;
+- every rendered document must declare `apiVersion` and `kind`, so a conditional that renders a headless fragment is flagged instead of installing as a silent no-op;
+- when `trivy.enabled` is also set, `trivy config` runs over the rendered manifests, which is the only way Trivy's Kubernetes policy checks can see a chart's real output.
+
+It is **off by default** because rendering executes chart-authored template code, and the switch alone is not enough: the render also requires **host project trust**, since `.pi-lens.json` is a tracked file a cloned repository could ship pre-enabled. The switch is read from the chart's own project root, not the current directory. In untrusted mode the refusal is reported rather than silently skipped. Nothing is written to the chart directory, `--dependency-update` is never passed, and the scratch directory is removed on every exit path. Findings map back to the source template through helm's own `# Source:` annotations; rendered line numbers travel in the message, since they do not correspond to template lines. Full OpenAPI schema validation (kubeconform) is not included.
 
 ### MCP Server (Experimental)
 

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

@@ -25,6 +25,18 @@ Each runtime toggle is settable from the CLI *and* from `config.json`. The two a
 | `--lens-actionable-warning-autofix` | `actionableWarnings.autoFix.enabled` | `false` |
 | `--lens-actionable-warning-all` | `actionableWarnings.deltaOnly` (`false`) | `true` |
 | `--lens-compact-tool-line` | `ui.compactToolLine` | `false` |
+| `--no-lazy-tools` | `tools.lazy` | `true` |
+| `--lens-turn-end-madge` | `turnEnd.madge.enabled` | `false` |
+
+By default pi-lens registers six situational tools (the `ast_grep_*` family,
+`lsp_navigation`, `lens_diagnostic_mark`) inactive and exposes a small loader,
+`pi_lens_activate_tools`, that the model calls to activate the ones it needs.
+`--no-lazy-tools` turns that off: every pi-lens tool is active from the first
+turn and pi-lens never changes the tool list. Use it if you would rather spend
+the tokens of a longer tool list than have the list change mid-session. The
+loader tool is still registered and still describes itself as activating
+inactive tools; under this flag those tools are already active, so calling it
+does nothing.
 
 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.
 
@@ -79,6 +91,8 @@ Hide the diagnostics widget by default, run formatting immediately after write/e
 
 `actionableWarnings.enabled` gates the turn_end report. `includeLspCodeActions` fetches LSP code actions for each warning (requires an active language server). `deltaOnly` (default `true`) limits the report to lines touched in the current turn. `autoFix.enabled` applies conservative LSP quickfixes at `agent_end`; `autoFix.maxFixes` caps the number applied per turn (default `5`, must be a non-negative whole number). `maxFixes: 0` keeps the report and applies nothing, which is a useful halfway step before enabling `autoFix` for real. Unlike the toggles in the table above there is no CLI counterpart, since it takes a number rather than being on or off.
 
+`turnEnd.madge.enabled` (default `false`) runs the per-turn-end madge circular-dependency check on import-changed files. It is off by default because that pass only writes debug output — user-facing madge diagnostics come from the session-start scan cache and the `lens_diagnostics` extractor — and its subprocess spawns dominated the turn-end latency tail (#766). Enable it with `--lens-turn-end-madge` or `turnEnd.madge.enabled: true` if you want the per-edit circular-dependency note.
+
 `ignore` is an array of gitignore-style glob patterns excluded from pi-lens scans across **every** project — the global counterpart to the per-project `.pi-lens.json` `ignore` below. Precedence is lowest: a project `.gitignore` or `.pi-lens.json` (including a `!negation`) overrides it, so you can globally hide e.g. `scratch/**` and still re-include it in one repo.
 
 Turn subsystems off globally instead of retyping flags every session:

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

@@ -9,7 +9,7 @@ Dispatch is diagnostics-oriented: automatic formatting and safe autofix happen i
 | Language              | LSP | Dispatch Runners                                                                                               | Formatter               |
 | --------------------- | --- | -------------------------------------------------------------------------------------------------------------- | ----------------------- |
 | JavaScript/TypeScript | ✓   | lsp, ts-lsp, biome-check-json, tree-sitter, ast-grep-napi, type-safety, similarity, fact-rules, eslint, oxlint | biome, prettier         |
-| Python                | ✓   | lsp, pyright, ruff-lint, tree-sitter                                                                           | ruff, black             |
+| Python                | ✓   | lsp, pyright, mypy (config-first), ruff-lint, tree-sitter                                                      | ruff, black             |
 | Go                    | ✓   | lsp, go-vet, golangci-lint, tree-sitter                                                                        | gofmt                   |
 | Rust                  | ✓   | lsp, rust-clippy, tree-sitter                                                                                  | rustfmt                 |
 | Ruby                  | ✓   | lsp, rubocop, tree-sitter                                                                                      | rubocop, standardrb     |
@@ -18,13 +18,13 @@ Dispatch is diagnostics-oriented: automatic formatting and safe autofix happen i
 | Fish                  | ✓ (fish-lsp) | lsp, fish-indent                                                                                      | fish_indent             |
 | CSS/SCSS/Less         | ✓   | lsp, stylelint                                                                                                 | biome, prettier         |
 | HTML                  | ✓   | lsp, htmlhint                                                                                                  | prettier                |
-| YAML                  | ✓   | lsp, yamllint, actionlint (GitHub workflows)                                                                   | prettier                |
-| JSON                  | ✓   | lsp                                                                                                            | biome, prettier         |
+| YAML                  | ✓   | lsp, yamllint, actionlint (GitHub workflows), trivy-config (opt-in; Kubernetes manifests, CloudFormation)      | prettier                |
+| JSON                  | ✓   | lsp, trivy-config (opt-in; CloudFormation templates only)                                                      | biome, prettier         |
 | 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                                                                                                  | —                       |
+| Docker                | ✓   | lsp, hadolint, trivy-config (opt-in)                                                                           | —                       |
 | PHP                   | ✓   | lsp, php-lint, phpstan                                                                                         | php-cs-fixer            |
 | PowerShell            | ✓   | lsp, psscriptanalyzer                                                                                          | psscriptanalyzer-format |
 | Prisma                | ✓   | lsp, prisma-validate                                                                                           | —                       |
@@ -46,4 +46,70 @@ Dispatch is diagnostics-oriented: automatic formatting and safe autofix happen i
 | Terragrunt            | —   | terragrunt                                                                                                     | terragrunt hcl fmt      |
 | Nix                   | ✓   | lsp                                                                                                            | nixfmt                  |
 | TOML                  | ✓   | lsp, taplo                                                                                                     | taplo                   |
-| CMake                 | ✓ (cmake-language-server) | lsp                                                                                           | cmake-format            |
+| CMake                 | ✓ (cmake-language-server) | lsp                                                                                      | cmake-format            |
+| CUE                   | ✓ (syntax via cue lsp, evaluation via cue vet) | lsp, cue-vet                                                              | cue fmt                 |
+
+`cue lsp` reports load and parse errors as you type but leaves conflicting
+values and failed constraints to `cue vet` — the `cue-vet` auxiliary runner
+(#1522) covers that gap, so together they give full coverage: syntax/parse
+diagnostics, hover, definition, completion, code actions, and formatting from
+the language server, plus evaluation-error validation from `cue vet` on every
+edit (vetted at the PACKAGE level — the touched file's directory — with the
+result filtered back to that file, since CUE packages are directory-scoped).
+`.cue` files parse under tree-sitter with symbol (`#Definition`s, fields,
+`let` bindings) and import queries (#1522), giving CUE the same structural
+symbol search and import extraction as any other language, with two known
+rough edges inherited from the young `tree-sitter-cue` grammar itself (not
+this repo's queries):
+
+- **Multi-hash raw strings** (`` ##"..."## ``, two or more `#` delimiters)
+  mis-parse regardless of content — the field's value becomes a bare
+  `identifier` node instead of a `string`, and the parser emits stray
+  top-level nodes outside the field entirely. Because the broken value node
+  can carry `#`-prefixed text, this can surface as a spurious symbol
+  reference in the extracted refs. Single-hash raw strings (`` #"..."# ``)
+  are unaffected.
+- **Aliased field labels** (`X=name: value`) emit the alias identifier (`X`)
+  as its own spurious `property` symbol alongside the real field's correct
+  symbol, because the grammar exposes both identifiers as untagged siblings
+  under the same `label` node with no way to tell them apart structurally.
+
+Both are upstream grammar limitations (tracked among
+[eonpatapon/tree-sitter-cue](https://github.com/eonpatapon/tree-sitter-cue)'s
+open issues), not something a query change here can fix.
+
+## Considered and skipped (2026-08-20 survey, closed out by #1757)
+
+Recorded so these are not re-litigated. The 2026-08-20 survey's first pass
+rejected `bandit` and `checkov` as duplicates of existing lanes; #1752's
+review disproved both "already covered" claims against the actual code, and
+#1757 closed the resulting gaps:
+
+- **bandit** (Python SAST) — RESOLVED. ruff's `S` ruleset implements Bandit's
+  checks; `config/ruff/core.toml` now selects `S`, with `S101` (assert),
+  `S311` (non-cryptographic random), `S603`/`S607` (subprocess without
+  `shell=True` / partial executable path) excluded as over-firing on real
+  code (measured against the `requests` and `pip` packages — see the config
+  file's comments for the exclusion reasoning and hit counts). `C90`
+  (mccabe complexity) was evaluated and NOT enabled: it is a maintainability
+  metric, not a Bandit-equivalent security check, and its hit volume on a
+  large pre-existing codebase (379 in `pandas`) would drown the security
+  signal `S` adds. As always, a project-local ruff config overrides the
+  bundled one outright.
+- **checkov** (IaC security) — the `trivy config` lane pi-lens's own dispatch
+  registry already carries (`clients/dispatch/runners/trivy-config.ts`,
+  opt-in via `trivy.enabled`) makes checkov a duplicate, not a gap: no
+  second full-scan tool is needed. That lane covers Kubernetes manifests,
+  Dockerfiles, and Terraform; #1757 added CloudFormation (yaml and json
+  templates, detected via `AWSTemplateFormatVersion` / SAM `Transform` /
+  `Type: AWS::*` heuristics) and fixed a real bug found while verifying
+  against the installed binary: the runner passed `--no-progress` to `trivy
+  config`, a flag that subcommand rejects (only `trivy fs` accepts it) —
+  every real invocation exited 1 and, because trivy prints its usage text to
+  stdout on a rejected flag, was misreported as a clean `succeeded` scan
+  rather than an errored one. Dropping the flag was the fix.
+- **radon / lizard** (complexity) — still not enabled; see the C90 note
+  above. Unchanged conclusion, now backed by measurement rather than
+  assumption.
+
+Known coverage holes with no tool currently clearing the adoption bar: Rust and Java dead-code detection, Ruby type checking (sorbet judged too heavy and idiosyncratic for a default lane).

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

@@ -243,8 +243,8 @@ Initial assumption ("knip/jscpd are booboo-only") was **wrong**. Verified:
 | layer | handler | runs |
 |-------|---------|------|
 | per-edit | `dispatchLintWithResult` | LSP, tree-sitter, ast-grep, fact-rules, biome/ruff/eslint/oxlint |
-| per-turn | `handleTurnEnd` (`runtime-turn.ts`) | **knip** (`:298`), **jscpd** (incremental, `getFilesForJscpd`), **madge/dep circular** (`:426`), **cascade merge** (`:175`), **tests** (`:461`), actionable/code-quality warnings aggregation, project-diagnostics delta |
-| per-session | `handleSessionStart` (`runtime-session.ts`) | **jscpd full scan** (`:505`), knip, type-coverage, dep, govulncheck, gitleaks, todo, complexity baselines, dominant-language **LSP warm** (#203). The production path does not currently populate the error-debt baseline. |
+| per-turn | `handleTurnEnd` (`runtime-turn.ts`) | **knip**, **jscpd** (incremental, `getFilesForJscpd`), **madge/dep circular** (opt-in via `--lens-turn-end-madge`), **cascade merge**, **tests**, actionable/code-quality warnings aggregation, project-diagnostics delta |
+| per-session | `handleSessionStart` (`runtime-session.ts`) | **jscpd full scan**, knip, type-coverage, dep, govulncheck, gitleaks, todo, complexity baselines, dominant-language **LSP warm** (#203). The production path does not currently populate the error-debt baseline. |
 
 The initial MCP implementation invoked **none** of the lifecycle handlers —
 only the per-edit layer. The shipped server now exposes `pilens_session_start`

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-14 on linux; 29 servers captured, 14 unavailable._
+_Last generated: 2026-08-20 on linux; 30 servers captured, 14 unavailable._
 
 ## Diagnostic mode + navigation/edit operations
 
@@ -19,6 +19,7 @@ Legend: ✓ advertised, · not. **mode** = document diagnostics (`pull` = `textD
 | clojure | push-only | · | ✓ | · | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | 62 |
 | csharp | pull | ✓ | ✓ | ✓ | · | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | 0 |
 | css | pull | · | ✓ | · | · | ✓ | ✓ | · | ✓ | · | ✓ | ✓ | · | · | 0 |
+| cue | push-only | · | ✓ | · | · | ✓ | ✓ | · | ✓ | · | ✓ | ✓ | · | · | 1 |
 | dart | push-only | · | ✓ | ✓ | · | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | 18 |
 | deno | pull | · | ✓ | ✓ | · | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | 2 |
 | docker | push-only | · | ✓ | · | · | · | ✓ | ✓ | ✓ | · | · | ✓ | · | · | 0 |
@@ -54,6 +55,7 @@ Legend: ✓ advertised, · not. **mode** = document diagnostics (`pull` = `textD
 - **clojure**: callHierarchyProvider, codeActionProvider, codeLensProvider, completionProvider, declarationProvider, definitionProvider, documentFormattingProvider, documentHighlightProvider, documentRangeFormattingProvider, documentSymbolProvider, executeCommandProvider, experimental, foldingRangeProvider, hoverProvider, implementationProvider, linkedEditingRangeProvider, referencesProvider, renameProvider, selectionRangeProvider, semanticTokensProvider, signatureHelpProvider, textDocumentSync, workspace, workspaceSymbolProvider
 - **csharp**: callHierarchyProvider, codeActionProvider, codeLensProvider, completionProvider, definitionProvider, diagnosticProvider, documentFormattingProvider, documentHighlightProvider, documentOnTypeFormattingProvider, documentRangeFormattingProvider, documentSymbolProvider, foldingRangeProvider, hoverProvider, implementationProvider, inlayHintProvider, referencesProvider, renameProvider, semanticTokensProvider, signatureHelpProvider, textDocumentSync, typeDefinitionProvider, typeHierarchyProvider, workspace, workspaceSymbolProvider
 - **css**: codeActionProvider, colorProvider, definitionProvider, diagnosticProvider, documentFormattingProvider, documentHighlightProvider, documentLinkProvider, documentRangeFormattingProvider, documentSymbolProvider, foldingRangeProvider, hoverProvider, referencesProvider, renameProvider, selectionRangeProvider, textDocumentSync
+- **cue**: codeActionProvider, codeLensProvider, completionProvider, definitionProvider, documentFormattingProvider, documentSymbolProvider, executeCommandProvider, hoverProvider, referencesProvider, renameProvider, textDocumentSync, workspace
 - **dart**: callHierarchyProvider, codeActionProvider, codeLensProvider, colorProvider, completionProvider, definitionProvider, documentFormattingProvider, documentHighlightProvider, documentLinkProvider, documentOnTypeFormattingProvider, documentRangeFormattingProvider, documentSymbolProvider, executeCommandProvider, experimental, foldingRangeProvider, hoverProvider, implementationProvider, inlayHintProvider, inlineValueProvider, referencesProvider, renameProvider, selectionRangeProvider, semanticTokensProvider, signatureHelpProvider, textDocumentSync, typeDefinitionProvider, typeHierarchyProvider, workspace, workspaceSymbolProvider
 - **deno**: callHierarchyProvider, codeActionProvider, codeLensProvider, completionProvider, definitionProvider, diagnosticProvider, documentFormattingProvider, documentHighlightProvider, documentSymbolProvider, executeCommandProvider, experimental, foldingRangeProvider, hoverProvider, implementationProvider, inlayHintProvider, notebookDocumentSync, referencesProvider, renameProvider, selectionRangeProvider, semanticTokensProvider, signatureHelpProvider, textDocumentSync, typeDefinitionProvider, workspace, workspaceSymbolProvider
 - **docker**: codeActionProvider, completionProvider, definitionProvider, documentFormattingProvider, documentHighlightProvider, documentLinkProvider, documentOnTypeFormattingProvider, documentRangeFormattingProvider, documentSymbolProvider, foldingRangeProvider, hoverProvider, renameProvider, signatureHelpProvider, textDocumentSync
@@ -89,6 +91,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, …
+- **cue** (1): cuelsp.externalvalidate
 - **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

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

@@ -70,6 +70,13 @@ column is the effective behavior when nothing is set.
 | `--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) |
+| `--no-lazy-tools` | `tools.lazy` | global | lazy tools **on** (six situational tools start inactive) |
+| `--lens-turn-end-madge` | `turnEnd.madge.enabled` | global | **off** (madge runs at session start, not per turn) |
+
+`--no-lazy-tools` keeps every pi-lens tool active for the whole session, so the
+advertised tool list never changes. The `pi_lens_activate_tools` loader stays
+registered and keeps its usual description; under this flag the tools it names
+are already active, so calling it is a no-op.
 
 `--lens-guard` is **EXPERIMENTAL and strictly opt-in**. When enabled, actual
 `git commit`/`git push` commands are blocked only for current, structured
@@ -100,6 +107,7 @@ field docs.
 | `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 |
+| `helm.renderValidation.enabled` | project | off | Opt-in `helm template` rendering plus rendered-manifest validation. Rendering executes chart templates, so it **also requires host project trust** and is read from the chart's own project root — see below |
 
 ## Global vs project config
 
@@ -135,7 +143,23 @@ A project file honors **only**:
 
 - the three mutation controls — `format.enabled`, `autofix.enabled`,
   `actionableWarnings.autoFix.enabled`;
-- `ignore`, `rules`, `maxProjectFiles`, `reviewGraph`, and `trivy`.
+- `ignore`, `rules`, `maxProjectFiles`, `reviewGraph`, `trivy`, and `helm`.
+
+### `helm.renderValidation.enabled` needs trust as well as consent
+
+Rendering a Helm chart runs the chart's own Go templates, so this switch is not
+sufficient on its own. Two independent conditions must both hold:
+
+1. **The project consents.** `helm.renderValidation.enabled` must be `true`,
+   read from the `.pi-lens.json` that governs the **chart's own project root** —
+   not the current working directory. An opt-in in an unrelated directory does
+   not authorize rendering another project's chart.
+2. **The host trusts the project.** `.pi-lens.json` is a tracked file, so a
+   cloned repository can arrive with the switch already on and would otherwise
+   authorize execution of its own templates. In untrusted mode pi-lens refuses
+   to render and reports the refusal, naming trust as the reason, rather than
+   skipping silently. This is the same trust gate that governs LSP server spawns
+   and tool auto-installs.
 
 Most toggles are **global-only**. Putting a global-only key such as
 `"lsp": { "enabled": false }` in a `.pi-lens.json` is **not** honored at project

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

@@ -18,17 +18,34 @@ pi-lens hooks into the pi agent lifecycle:
 
 ## On-write pipeline
 
-For each write/edit, pi-lens runs a language-aware pipeline:
-
-1. Format queue / immediate formatting when configured.
-2. Safe autofix from tools with deterministic fix support.
+For each write/edit, pi-lens runs a language-aware pipeline. Format and safe
+autofix (steps 1–2) run on different schedules depending on the tool:
+
+- **`write`** (new file, full overwrite, bash-authored write): autofix runs
+  immediately, in the same tool result, carrying the fixed file's full content
+  back to the agent when it fits under the per-file cap.
+- **`edit`**: autofix defers to `agent_end`, joining the same per-file queue as
+  deferred formatting; autofix drains before format so the final state is
+  formatter-stable. A `write` followed by an `edit` on the same file in the
+  same turn demotes the write's autofix to deferred too.
+
+1. Format queue / immediate formatting when configured (deferred to
+   `agent_end` for an `edit` even under `--immediate-format`, so it lands
+   after autofix reformats the file).
+2. Safe autofix from tools with deterministic fix support — immediate for
+   `write`, deferred to `agent_end` for `edit` (see above).
 3. LSP file sync and diagnostic wait.
 4. Parallel dispatch runners: LSP, ast-grep, tree-sitter, fact rules, and
-   language-specific linters/security scanners.
+   language-specific linters/security scanners. For a deferred `edit`, these
+   run against the not-yet-autofixed disk state, so a lint finding autofix
+   would have cleared may appear here and resolve itself at `agent_end`.
 5. Cascade diagnostics for likely affected neighbors.
 6. Deduplication and routing to blockers, actionable warnings, or code-quality
    history.
 
+See [`docs/agent-guide.md`](agent-guide.md#6-auto-format--auto-fix-timing--dont-be-surprised)
+for the consumer-facing version of this routing.
+
 ## Agent tools
 
 pi-lens exposes these high-value tools to agents:
@@ -92,6 +109,8 @@ pi --no-opengrep         # Disable the Opengrep security scanner (default-on aux
 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)
+pi --no-lazy-tools       # Keep every pi-lens tool active instead of activating the situational ones on demand
+pi --lens-turn-end-madge # Run the madge circular-dependency check at every turn end, not just at session start
 
 # Actionable warnings (all default off)
 pi --lens-actionable-warnings          # Report fixable warnings at turn end

package/node_modules/pi-lens/docs/word-index.md

@@ -42,6 +42,41 @@ HTTPServer    → httpserver, http, server
 each through `splitIdentifier`; queries are tokenized the same way so
 `"authenticate user"` matches `authenticateUser`, `auth_user`, etc.
 
+## Query prefix filters (#1450)
+
+The query string can mix plain terms with composable `key:value` filters,
+parsed by `parseWordIndexQuery` (`clients/word-index.ts`) before tokenization:
+
+- `lang:<kind>` — restrict to a file kind's extensions, drawn from
+  `KIND_EXTENSIONS` (`clients/file-kinds.ts`) — the single source of truth
+  (#894 invariant), so there is no second, hand-maintained language list here.
+- `file:<substr>` — path substring match against the index's own stored path,
+  normalized through `wordIndexKey` (case-folded on win32 only, matching how
+  the index's own path-keyed maps already fold win32 paths, #1025).
+- `ext:<ext>` — literal extension match (`ext:ts` and `ext:.ts` are
+  equivalent).
+- Any filter may be negated with a leading `-` (`-file:test`).
+
+Example: `lang:jsts file:clients/ -file:test rank`. Multiple positive filters
+of the SAME key OR together; different keys AND; negations always subtract.
+Filters are applied as a `fileFilter` predicate BEFORE BM25/priors/centrality
+scoring (same seam as the pre-existing `paths`/`lang` structured options,
+#771), so a surviving file's score is unaffected by filtering. An unrecognized
+`key:` token passes through as an ordinary search term (colon-bearing terms
+like `std::vector`, URLs, and Windows paths search normally). Only a
+recognized key with a bad value — an unrecognized `lang:` kind — throws
+`WordIndexQueryError`
+naming the supported list — never silently falls through as a literal search
+term. Both the pi `symbol_search` tool and the MCP `pilens_symbol_search`
+mirror inherit the syntax for free since both pass their `query` argument
+straight through to `searchWordIndex` (the entry point where parsing happens).
+
+DF-normalization: BM25's per-token `idf` is computed from the FULL,
+unfiltered posting for that token before `fileFilter` is applied per
+candidate file — a filtered query reuses the global, corpus-wide document
+frequency rather than recomputing it over the filtered subset. Documented as
+an acceptable approximation (see the doc comment on `searchWordIndex`).
+
 ## Lifecycle
 
 The index is built/refreshed in **every** startup mode: load the persisted

package/node_modules/pi-lens/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-lens",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "type": "module",
   "description": "Real-time code feedback for pi — LSP, linters, formatters, type-checking, structural analysis & booboo",
   "repository": {
@@ -32,7 +32,10 @@
     "audit:tree-sitter": "node scripts/audit-tree-sitter-rules.mjs",
     "audit:rule-catalog": "node scripts/validate-rule-catalog.mjs",
     "audit:astgrep-rule-pairs": "node scripts/audit-astgrep-rule-pairs.mjs",
+    "astgrep:self-scan": "node scripts/run-astgrep-pi-lens.mjs",
+    "astgrep:self-scan:update-baseline": "node scripts/run-astgrep-pi-lens.mjs --update-baseline",
     "audit:playground": "node scripts/playground-verify-rule.mjs",
+    "bench:cascade-budget": "node scripts/bench-cascade-budget.mjs",
     "logs:smells": "node scripts/analyze-pi-lens-logs.mjs",
     "changelog:check": "node scripts/rollup-changelog.mjs --check",
     "changelog:release": "node scripts/changelog-release.mjs",
@@ -42,11 +45,11 @@
     "docs:rule-catalogs": "node scripts/gen-rule-catalogs.mjs",
     "banner": "npx -y sharp-cli --input banner.svg --output banner.png resize 2200 620",
     "download-grammars": "node scripts/download-grammars.js",
-    "harness:poc": "node scripts/run-harness.mjs cases/ts/pipeline-dispatch-poc --pi-bin \"C:\\Users\\R3LiC\\AppData\\Roaming\\npm\\pi.cmd\"",
-    "harness:python-poc": "node scripts/run-harness.mjs cases/python/pipeline-dispatch-poc --pi-bin \"C:\\Users\\R3LiC\\AppData\\Roaming\\npm\\pi.cmd\"",
-    "harness:ts-format-poc": "node scripts/run-harness.mjs cases/ts/format-default-poc --pi-bin \"C:\\Users\\R3LiC\\AppData\\Roaming\\npm\\pi.cmd\"",
-    "harness:python-autofix-poc": "node scripts/run-harness.mjs cases/python/autofix-default-poc --pi-bin \"C:\\Users\\R3LiC\\AppData\\Roaming\\npm\\pi.cmd\"",
-    "harness:go-poc": "node scripts/run-harness.mjs cases/go/pipeline-dispatch-poc --pi-bin \"C:\\Users\\R3LiC\\AppData\\Roaming\\npm\\pi.cmd\""
+    "harness:poc": "node scripts/run-harness.mjs cases/ts/pipeline-dispatch-poc",
+    "harness:python-poc": "node scripts/run-harness.mjs cases/python/pipeline-dispatch-poc",
+    "harness:ts-format-poc": "node scripts/run-harness.mjs cases/ts/format-default-poc",
+    "harness:python-autofix-poc": "node scripts/run-harness.mjs cases/python/autofix-default-poc",
+    "harness:go-poc": "node scripts/run-harness.mjs cases/go/pipeline-dispatch-poc"
   },
   "keywords": [
     "pi",
@@ -69,6 +72,7 @@
     "dist/",
     "docs/",
     "grammars/",
+    "vendor/grammars/",
     "config/",
     "rules/",
     "skills/",

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/__snapshots__/no-reflect-get-js-snapshot.yml

@@ -0,0 +1,23 @@
+id: no-reflect-get-js
+snapshots:
+  Reflect.get(obj, "key"):
+    fixed: obj["key"]
+    labels:
+    - source: Reflect.get(obj, "key")
+      style: primary
+      start: 0
+      end: 23
+  const ordinary = { get(target, prop, receiver) { return Reflect.get(target, prop, receiver); } };:
+    fixed: const ordinary = { get(target, prop, receiver) { return Reflect.get(target, prop, receiver); } };
+    labels:
+    - source: Reflect.get(target, prop, receiver)
+      style: primary
+      start: 56
+      end: 91
+  const v = Reflect.get(target, prop);:
+    fixed: const v = target[prop];
+    labels:
+    - source: Reflect.get(target, prop)
+      style: primary
+      start: 10
+      end: 35

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/__snapshots__/no-reflect-get-snapshot.yml

@@ -0,0 +1,23 @@
+id: no-reflect-get
+snapshots:
+  Reflect.get(obj, "key"):
+    fixed: obj["key"]
+    labels:
+    - source: Reflect.get(obj, "key")
+      style: primary
+      start: 0
+      end: 23
+  const ordinary = { get(target, prop, receiver) { return Reflect.get(target, prop, receiver); } };:
+    fixed: const ordinary = { get(target, prop, receiver) { return Reflect.get(target, prop, receiver); } };
+    labels:
+    - source: Reflect.get(target, prop, receiver)
+      style: primary
+      start: 56
+      end: 91
+  const v = Reflect.get(target, prop);:
+    fixed: const v = target[prop];
+    labels:
+    - source: Reflect.get(target, prop)
+      style: primary
+      start: 10
+      end: 35

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/__snapshots__/ts-void-zero-snapshot.yml

@@ -0,0 +1,23 @@
+id: ts-void-zero
+snapshots:
+  const x = void 0:
+    fixed: const x = undefined
+    labels:
+    - source: void 0
+      style: primary
+      start: 10
+      end: 16
+  return void 0:
+    fixed: return undefined
+    labels:
+    - source: void 0
+      style: primary
+      start: 7
+      end: 13
+  void 0:
+    fixed: undefined
+    labels:
+    - source: void 0
+      style: primary
+      start: 0
+      end: 6

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

@@ -0,0 +1,16 @@
+id: no-bare-object-param
+valid:
+  - "function f(x: string) {}"
+  - "function f(x: Record<string, unknown>) {}"
+  - "function f(x: { a: string }) {}"
+  - "function f(x: Object) {}"
+  - "function f(x: object | null) {}"
+  - "function f(...rest: object[]) {}"
+  - "type H = (entry: Record<string, unknown>) => void;"
+invalid:
+  - "function f(x: object) {}"
+  - "const g = (x: object) => {};"
+  - "class C { m(x: object) {} }"
+  - "interface I { m(x: object): void; }"
+  - "type H = (entry: object) => void;"
+  - "function f(x?: object) {}"

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-chained-type-assertions-test.yml

@@ -0,0 +1,22 @@
+id: no-chained-type-assertions
+valid:
+  - 'const v = x as A'
+  - 'const w = x as A as const'
+  # 2026-08-20 (#1727/#1777): the `as unknown as` shape is delegated wholly to
+  # require-safety-comment-for-as-unknown-as.yml. This rule owns the concrete
+  # chain only, so BOTH the commented and the uncommented `unknown` forms are
+  # valid here. Deleting the `not: { pattern: $X as unknown as $B }` guard reds
+  # all three.
+  - |
+    // SAFETY: checked above
+    const u = x as unknown as Foo;
+  - 'const u = /* SAFETY: inline */ x as unknown as Foo;'
+  - 'const u = x as unknown as Foo;'
+invalid:
+  - 'const v = x as A as B'
+  - 'const v = foo.bar() as A as B;'
+  # A concrete chain has no escape valve: a SAFETY comment does NOT excuse it.
+  # Re-adding a comment-based exemption to this rule reds this case.
+  - |
+    // SAFETY: I promise
+    const v = x as A as B;