agent-lsp: baixar versions anteriors

### Fixed
• **`safe_apply_edit` could still apply an unverified edit with gopls**：the 0.23.1 refusal of timed-out previews never fired, because the diagnostics wait reported a timeout as success. When gopls had not yet published diagnostics for the edit, the preview compared the pre-edit diagnostics with themselves, reported `net_delta: 0` with `confidence: high`, and the edit was applied. The wait also discarded the first publication for a document that had none cached, mistaking it for a cached replay. The preview now waits for diagnostics that cover the edited document version (servers report it in `publishDiagnostics`) and reports `timeout: true` with `confidence: partial` when they do not arrive, which `safe_apply_edit` refuses. A publication for an older version never counts. Servers that publish nothing when an edit leaves the diagnostics unchanged (typescript-language-server, rust-analyzer, Dart, and clangd for text it already analysed) keep the previous behavior, since for them silence is the normal result of a clean edit; gopls publishes for every version, so silence from it means the edit was not checked.

### Fixed
• **`.tsx` and `.jsx` files were opened as plain TypeScript/JavaScript** ([#73](https://github.com/blackwell-systems/agent-lsp/pull/73))：`didOpen` sent the language family (`typescript`, `javascript`) instead of the LSP identifiers `typescriptreact` and `javascriptreact`, so typescript-language-server parsed a `.tsx` file opened before its project loaded it as plain TypeScript and reported every JSX element as a syntax error until the server restarted. Contributed by [@bviolier](https://github.com/bviolier).
• **`safe_apply_edit` always failed under the default output format** ([#70](https://github.com/blackwell-systems/agent-lsp/pull/70))：it re-parsed the preview tool's rendered output as JSON, which is GCF by default, so every call returned "failed to parse preview result" and nothing was applied. It now takes the preview result directly. Contributed by [@davalillo](https://github.com/davalillo).
• **`safe_apply_edit` no longer applies an edit it could not verify**：an edit was applied whenever the preview reported no new errors, including when the diagnostics wait timed out or the server was still indexing, in which case nothing had been checked (a cold gopls was observed applying a type error this way). It now applies only when the diagnostics settled, and otherwise returns `applied: false` with the reason; `apply_edit` remains available to write an edit without verification.
• **`position_pattern` with the `@@text@@` form never matched** ([#70](https://github.com/blackwell-systems/agent-lsp/pull/70))：the closing marker stayed inside the search text, although every tool schema documents this form. It now matches the text between the markers and places the cursor at the end of the match; ambiguous or empty patterns are errors. On files that start with a UTF-8 byte-order mark, line-1 columns count the BOM as one UTF-16 unit, as the language servers and the other position paths do. Contributed by [@davalillo](https://github.com/davalillo).

### Changed
• **CI refreshes the package index before every `apt-get install`**, so a dependency Ubuntu has replaced on its mirror no longer fails the clangd install with a 404.

### Changed
• **`find_symbol` and `find_references` qualify empty results with an index-coverage caveat** ([#42](https://github.com/blackwell-systems/agent-lsp/issues/42))：some language servers index only opened documents (observed and wire-verified on `mql-lsp-server` v2.4.2 through 2.5.0-rc.5: `workspace/symbol` and `textDocument/references` return `[]` for symbols in files the session never `didOpen`ed, while `definition` resolves through live include-graph resolution), so an empty result can be an index-coverage artifact rather than a true "not found". `find_symbol` now distinguishes the empty causes: a server that does not declare `workspaceSymbolProvider` gets an explicit "workspace symbol search is unavailable" hint (previously the capability gate silently produced an empty result), and a server known to index only opened documents gets "this language server indexes only opened documents, so symbols or references in files not yet opened may be missing from this result; open the declaring file (open_document) and retry". `find_references` appends the same caveat to the qualified dead-code hint from #38/#46 when the workspace holds files the session never opened. The caveat is limited to servers verified to index only opened documents (currently `mql-lsp-server`, matched by executable or reported server name): whole-workspace indexers such as gopls, rust-analyzer, and pyright answer for unopened files, so their empty results stay authoritative and unhedged. For those servers, a bounded workspace probe (incremental directory reads capped at 2000 total entries — files, directories, and excluded entries all count toward the budget; budget exhaustion, walk errors, and cancellation report unknown coverage and still show the caveat) compares the workspace's files in that server's languages (other files cannot be missing from its index) against the session's opened path set, so a fully-opened workspace keeps the plain hint and opens outside the eligible set (e.g. `node_modules`) cannot mask unopened source files. Empty `find_symbol` responses keep the established response envelope for every detail level — the caveat is appended to the detail-specific encoding (the `workspaceSymbolsResponse` object with `total`/`symbols` for hover detail) rather than replacing it with a bare list. `go_to_definition` is deliberately untouched — its empty result is authoritative (position resolved to nothing) and the fuzzy-fallback provenance rules from #40 apply there. Cache-served provenance (`refs.db` results that the underlying server cannot produce live) remains future work tracked in #42.

### Fixed
• **`restart_lsp_server` no longer requires `root_dir` and re-opens the documents that were open** ([#54](https://github.com/blackwell-systems/agent-lsp/issues/54))：the schema marked `root_dir` optional but the handler rejected calls without it; it now defaults to the current workspace root. After a restart the fresh server previously knew no open documents, so servers that index only opened files (such as `mql-lsp-server`) returned empty workspace symbols until a document was reopened. The documents open before the restart are now re-sent with `didOpen`, using their current content read from disk through the workspace-root confinement checks, including when the workspace root is reached through a symlink. Contributed by [@davalillo](https://github.com/davalillo).
• **Reading from a language server could spend minutes of CPU on output with no message header** ([#65](https://github.com/blackwell-systems/agent-lsp/issues/65))：the LSP frame reader searched the whole accumulated buffer for the header terminator on every read, which is quadratic when a server writes a large amount of output without a `Content-Length` header (10 MB arriving in small reads took about three minutes). The search now resumes where the last one stopped. Normal traffic was not affected, since a message header sits at the start of the buffer. As a side effect the `internal/lsp

### Added
• **Pi coding agent support** ([#36](https://github.com/blackwell-systems/agent-lsp/pull/36))：`agent-lsp init` targets 9 (project) and 10 (global) configure [Pi](https://github.com/earendil-works/pi) through the `pi-mcp-adapter` package, writing the MCP config to `.mcp.json` or `~/.config/mcp/mcp.json` and skill awareness rules to `AGENTS.md` or `~/.pi/agent/AGENTS.md`; `uninstall` and `skills/install.sh` cover Pi's files too. Contributed by [@davalillo](https://github.com/davalillo).
• **`agent-lsp init --with-skills`** ([#36](https://github.com/blackwell-systems/agent-lsp/pull/36))：one-command setup that also installs the embedded skills (with their reference files) to the destination matching the chosen tool, no repo clone needed. Installs never write through a symlink planted in the destination, whether at a skill file or a skill directory, so a cloned project cannot redirect the write outside it; installed files are world-readable (0644). Contributed by [@davalillo](https://github.com/davalillo).

### Fixed
• **Dynamic capability registration no longer overwrites provider options** ([#37](https://github.com/blackwell-systems/agent-lsp/issues/37))：the `client/registerCapability` handler stored every dynamically registered method as a plain `true` boolean, destroying any options object the server had declared in `initialize` — e.g. mql-lsp-server declares `renameProvider: {"prepareProvider": true}` and then registers `textDocument/rename`, after which the stored capability became the bool `true` and `prepare_rename` never sent `textDocument/prepareRename` at all. Registrations now merge `registerOptions` over the existing value (an existing options map is kept when the registration carries no options; an existing bool `true` acts as an empty base for incoming options), and the debug log records whether each registration merged, kept, or set-true.
• **`prepare_rename` reports unsupported/null outcomes in words instead of empty output** ([#39](https://github.com/blackwell-systems/agent-lsp/issues/39))：when the server does not implement `textDocument/prepareRename` (or its declared support is masked, as in [#37]), the tool returned a single empty text content — rendered "(no tool output)" by clients and indistinguishable from a hang. It now returns "prepare_rename is not supported by this language server; rename_symbol may still work." for the capability gap, and "The server returned no rename range at this position; a rename here may not be valid." (plus a dry-run hint) when the server answered null. Defense in depth: `gcf.Encode(nil)` returns `null` instead of an empty string, so no tool can emit a silent empty content for a nil result.
• **`blast_radius` no longer treats nested parameters and locals as targets on non-Go languages** ([#41](https://github.com/blackwell-systems/agent-lsp/issues/41))：the exported-symbol walker applied Go export semantics to every language (for anything but Go, `langID != "go"` made every symbol "exported"), skipped only fields (kind 8), and recursed into children unconditionally. Servers that report a rich `textDocument/documentSymbol` tree nest parameters and local variables as children of functions (verified with mql-lsp-server v2.4.2: kind-12 functions with kind-13 children), so all of them became blast-radius "targets" — on a real MQL project, 48 targets mixing functions with parameters and locals. `scope=exported` now restricts nested symbols (depth > 0) to container/callable kinds (Module, Namespace, Package, Class, Method, Constructor, Enum, Interface, Constant, Struct, Event) and stops descending into excluded symbols, so parameters, locals, fields, properties, enum members, and literal-ish kinds are left out; function-local constants are excluded too (a nested constant stays a target only inside a container kind such as a class or namespace), top-level behavior and the Go uppercase rule are unchanged, and `scope=all` still reports the other excluded nested symbols (fields rem

### Added
• **MQL4/MQL5 support via `mql-lsp-server` (32nd CI-verified language)** ([#30](https://github.com/blackwell-systems/agent-lsp/pull/30))：MetaTrader 4/5's language, covering `.mq4`/`.mq5`/`.mqh` through a single neutral `mql` languageId (the server resolves the dialect per file, so shared `.mqh` headers do not misroute). The `multi-lang-mql` CI job runs the real server through the same harness as the other 31 languages. Contributed by [@davalillo](https://github.com/davalillo).

### Fixed
• **`open_document` sent an empty `didOpen` buffer** ([#34](https://github.com/blackwell-systems/agent-lsp/pull/34))：when the optional `text` argument was omitted, `open_document` opened the document with an empty buffer and relied on the language server reading the file from disk. That is not spec-compliant (LSP clients are expected to send the current document text), and servers that take the `didOpen` buffer literally degraded: cross-file resolution failed when the real content arrived later via `didChange`. `open_document` now reads the file and sends its real content in `didOpen`. The read runs on the workspace-validated path (the value returned by `ValidateFilePath` is now threaded through the URI, languageID, auto-scope, and the disk read), closing a time-of-check/time-of-use gap where a symlink swapped between validation and the read could escape the workspace root. Affects every language. Contributed by [@davalillo](https://github.com/davalillo).

### Changed
• **`multi-lang-mql` CI is pinned to `mql-lsp-server` v2.4.2 with a sha256 checksum** ([#32](https://github.com/blackwell-systems/agent-lsp/pull/32), [#34](https://github.com/blackwell-systems/agent-lsp/pull/34)) instead of fetching `releases/latest`. A floating version made the Tier-2 baseline (a deterministic contract of real server behavior) non-reproducible; v2.4.2 also fixes upstream defects surfaced by this integration (constructor-style declaration parsing and method-call signatureHelp). The MQL Tier-2 baseline was re-derived honestly against the pinned binary, with per-tool rationale for every allowed-skip.
• **Automated PR review via CodeRabbit**：added a `.coderabbit.yaml` tuned for this repo, with path instructions encoding the project's review priorities (pinned+checksummed third-party binaries in CI, honest Tier-2 baselines, `ValidatePath` confinement on file I/O, strict-YAML skill front-matter) and the relevant linters enabled. Advisory only; it never blocks a merge.

### Fixed
• **Three skill `SKILL.md` files had front-matter that broke strict YAML parsers** ([#28](https://github.com/blackwell-systems/agent-lsp/pull/28))：the `description` field in `lsp-architecture`, `lsp-understand`, and `lsp-explore` contained a `": "` that a strict YAML parser reads as a nested mapping key, rendering a red error on GitHub's file view and risking the skill being dropped by strict loaders (Claude Code's skill loader, GitHub's front-matter renderer). `lsp-architecture` and `lsp-understand` were unquoted values with an embedded colon; `lsp-explore` was double-quoted but an inner quote closed the scalar early. All three are now quoted correctly. agent-lsp's own MCP prompt loader was unaffected (it cuts on the first colon). A new `TestSkillFrontmatterYAMLSafe` walks every embedded `SKILL.md` and rejects both failure modes, with no new dependency. `lsp-architecture` contributed by [@petemounce](https://github.com/petemounce).

### Fixed
• **Argument injection via the `detect_changes` `range` argument** ([#23](https://github.com/blackwell-systems/agent-lsp/pull/23))：the `range` argument was split on `..` and passed directly to `git diff --name-only` as revisions. Because git is executed without a shell, an option-shaped piece was interpreted as a git flag: a value like `--output=<path>..<rev>` became `git diff --name-only --output=<path> <rev>`, and git's `--output` writes to an arbitrary file. Any `range` piece that is empty or starts with `-` is now rejected before git runs. Contributed by [@Choppaaahh](https://github.com/Choppaaahh).

### Added
• **Custom language routing for unrecognized file extensions** ([#21](https://github.com/blackwell-systems/agent-lsp/pull/21))：a file whose extension is not in the built-in list now routes to a matching configured server instead of silently falling back to `plaintext`, so it gets full hover, diagnostics, definition, and references. Extension-based routing takes priority over the current client in multi-server mode, and tool handlers no longer hardcode `plaintext`. This enables **Luau** (`luau-lsp`) as a first-class, CI-exercised language. Contributed by [@fluffy-den](https://github.com/fluffy-den). Closes #19, #20.

### Fixed
• **macOS auto-watcher file-descriptor exhaustion** ([#18](https://github.com/blackwell-systems/agent-lsp/issues/18))：the always-on auto-watcher walked the whole workspace and, because the fsnotify kqueue backend opens one fd per file in every watched directory, a tree containing large data/cache directories (browser profiles, leveldb, caches) could grow to hundreds of thousands of fds, peg `kern.maxfilesperproc`, and exhaust the system-wide file table (machine-wide `ENFILE`). The watcher is now bounded two ways. **At startup** it skips any single directory larger than `AGENT_LSP_WATCH_MAX_DIR_ENTRIES` (default 2048) and stops once total watched entries exceed `AGENT_LSP_WATCH_MAX_ENTRIES` (default 50000), applied to the initial walk, workspace-folder extension, and runtime directory creation. **At runtime** a guard samples the process's open-fd count every 30s and tears the watcher down if it exceeds `AGENT_LSP_WATCH_MAX_FDS` (default 60000), catching descriptors fsnotify opens for files *created while the watcher runs* (which the startup budget cannot see). `AGENT_LSP_DISABLE_WATCHER=1` turns the watcher off entirely. (FSEvents would avoid per-file fds outright, but it requires cgo and would break the project's `CGO_ENABLED=0` cross-compiled release; the runtime guard is the pure-Go equivalent.) Reported by [@ratacat](https://github.com/ratacat).

Fixes a file-corruption bug in rename_symbol (#12, reported by @V0idk), makes speculative confidence honest about still-indexing servers, and upgrades gcf-go to v1.5.0.
Fixed
• rename_symbol file corruption (#12)：rename_symbol (non-dry-run) used to return the raw WorkspaceEdit and rely on the caller copying it back into apply_edit — the only edit tool that did so; replace_symbol_body, insert_after_symbol, insert_before_symbol, and safe_delete_symbol all apply server-side. That round-trip corrupted files: under AGENT_LSP_OUTPUT_FORMAT=gcf the edit was GCF-encoded (a summary format that flattens each TextEdit's range into positional path columns like range>end>character and requires the verbatim newText to be copied out of tool output and back into a tool argument), so LLM callers transposed the range offsets and truncated a large newText, overwriting the file. gcf-go itself encodes and decodes these WorkspaceEdits losslessly (verified), so this was an agent-lsp wire-format and round-trip bug, not a gcf-go bug. Reported by @V0idk.

Changed
• BREAKING：rename_symbol now applies the edit itself and returns a summary instead of returning a WorkspaceEdit for the caller to apply. The result is Renamed to "X" across N location(s) in M file(s): ... plus a post-rename diagnostics count, consistent with the other edit tools — the WorkspaceEdit never leaves the server as data to reconstruct, which eliminates the round-trip that corrupted files (#12). A separate apply_edit call after a non-dry-run rename is no longer needed (or wanted); apply_edit remains for its text-match mode. The dry_run=true preview is unchanged in intent (returns the edit for inspection) but now serializes as self-labeling JSON regardless of AGENT_LSP_OUTPUT_FORMAT, plus file/location counts. The lsp-rename skill's execute phase is updated accordingly.
• gcf-go upgraded to v1.5.0. Brings nested-null flatten losslessness (a nested object null at an intermediate level, e.g. {meta:{owner:null}}, is no longer silently dropped on round-trip) and deterministic graph edge ordering (edges sorted by source, then target, then type). Generic-profile delta encoding and labeled streaming trailer counts are available as opt-in APIs; agent-lsp does not use them yet, so default output is byte-identical. No API changes required.

Added
• confidence："low" for unindexed speculative results. evaluate_session / preview_edit now report confidence: "low" when a clean result (net_delta <= 0) is read while the language server still has active $/progress work (indexing, cache priming, cargo check). Previously such results were reported as confidence: "high", so a still-priming server (notably rust-analyzer) could return a false all-clear — "no errors introduced" when the diagnostics simply had not been computed yet. Results that surface errors (net_delta > 0) are never downgraded, since diagnostics do not appear spuriously. New LSPClient.HasActiveProgress() exposes the signal.

Tests
• Added a live end-to-end regression (TestRenameSymbol_LiveGopls) that drives a real textDocument/rename through gopls and the full handler, asserting the file is renamed on disk and the tool returns a summary with no raw edit leaked. Skips cleanly when gopls is absent; CI's unit-and-smoke job now installs gopls so it runs there. Added unit coverage for the apply path against the pathological single-big-edit shape from #12 (TestApplyWorkspaceEdit_*), the JSON edit-encoding guard (TestEncodeResultJSON_*), and the rename summary counter (TestSummarizeWorkspaceEdit_*).

Fixes a file-corruption bug in rename_symbol (#12, reported by @V0idk), makes speculative confidence honest about still-indexing servers, and upgrades gcf-go to v1.5.0.
Fixed
- rename_symbol file corruption (#12): rename_symbol (non-dry-run) used to return the raw WorkspaceEdit and rely on the caller copying it back into apply_edit — the only edit tool that did so; replace_symbol_body, insert_after_symbol, insert_before_symbol, and safe_delete_symbol all apply server-side. That round-trip corrupted files: under AGENT_LSP_OUTPUT_FORMAT=gcf the edit was GCF-encoded (a summary format that flattens each TextEdit's range into positional path columns like range>end>character and requires the verbatim newText to be copied out of tool output and back into a tool argument), so LLM callers transposed the range offsets and truncated a large newText, overwriting the file. gcf-go itself encodes and decodes these WorkspaceEdits losslessly (verified), so this was an agent-lsp wire-format and round-trip bug, not a gcf-go bug. Reported by @V0idk.

Changed
- BREAKING: rename_symbol now applies the edit itself and returns a summary instead of returning a WorkspaceEdit for the caller to apply. The result is Renamed to "X" across N location(s) in M file(s): ... plus a post-rename diagnostics count, consistent with the other edit tools — the WorkspaceEdit never leaves the server as data to reconstruct, which eliminates the round-trip that corrupted files (#12). A separate apply_edit call after a non-dry-run rename is no longer needed (or wanted); apply_edit remains for its text-match mode. The dry_run=true preview is unchanged in intent (returns the edit for inspection) but now serializes as self-labeling JSON regardless of AGENT_LSP_OUTPUT_FORMAT, plus file/location counts. The lsp-rename skill's execute phase is updated accordingly.
- gcf-go upgraded to v1.5.0. Brings nested-null flatten losslessness (a nested object null at an intermediate level, e.g. {meta:{owner:null}}, is no longer silently dropped on round-trip) and deterministic graph edge ordering (edges sorted by source, then target, then type). Generic-profile delta encoding and labeled streaming trailer counts are available as opt-in APIs; agent-lsp does not use them yet, so default output is byte-identical. No API changes required.

Added
- confidence: "low" for unindexed speculative results. evaluate_session / preview_edit now report confidence: "low" when a clean result (net_delta <= 0) is read while the language server still has active $/progress work (indexing, cache priming, cargo check). Previously such results were reported as confidence: "high", so a still-priming server (notably rust-analyzer) could return a false all-clear — "no errors introduced" when the diagnostics simply had not been computed yet. Results that surface errors (net_delta > 0) are never downgraded, since diagnostics do not appear spuriously. New LSPClient.HasActiveProgress() exposes the signal.

Tests
- Added a live end-to-end regression (TestRenameSymbol_LiveGopls) that drives a real textDocument/rename through gopls and the full handler, asserting the file is renamed on disk and the tool returns a summary with no raw edit leaked. Skips cleanly when gopls is absent; CI's unit-and-smoke job now installs gopls so it runs there. Added unit coverage for the apply path against the pathological single-big-edit shape from #12 (TestApplyWorkspaceEdit_*), the JSON edit-encoding guard (TestEncodeResultJSON_*), and the rename summary counter (TestSummarizeWorkspaceEdit_*).

v0.15.2: GCF primer accuracy (spec v3.2)
Patch release. Corrects the GCF format primer embedded in agent-lsp's MCP server instructions so LLMs parse tool responses accurately from the first call.

Fixed
- Nested-object flattening path syntax — the primer now explains that a quoted header column like "caller>name" is a flattened nested path that decodes to {caller: {name: ...}}. This is the common shape for blast_radius callers, diagnostics, and explore_symbol output under gcf-go v1.3.1 (spec §7.4.6).
- Null vs. missing tokens — corrected to match spec §7.4.2: - is explicit null, ~ is an absent key. (Previously conflated as one.)
- ^ attachment marker — documented that ^ in a row cell marks a variable-shape or array value attached as an indented .fieldname block, with schema reuse across rows.
No code behavior changes — output encoding is unchanged. This only sharpens the instructions the model reads at session start.
GCF: gcformat.com · Spec v3.2 · gcf-go