better-dsh 0.2.3-e → 0.2.3-g

package/lib/index.js

@@ -1,10 +1,11 @@
 import { a as RESERVED_ERROR_MEMBERS, i as RESERVED_BINDING_GLOBALS, n as DUNDER_MEMBER, o as ReplRuntime, r as PORTABLE_RESERVED_WORDS, t as isFlatBindableName } from "./py-sdk-Chvy92MB.js";
 import { s as resolveKernelEnv } from "./kernel-env-hxaihi9C.js";
-import { a as createDshHandler, c as createDvcHandler, d as registerDvcDevice, f as UrlSchemesError, i as createHttpHandler, l as dispatchDvcWrite, m as SCHEME_NAMES, n as wrapFsWithSchemes, o as UrlResolver, p as parseUrl, r as HTTP_SCHEMES, s as resolveDocsDir, u as listDvcDevices } from "./wrap-DC8O3SYz.js";
+import { a as createDshHandler, c as createDvcHandler, d as registerDvcDevice, f as UrlSchemesError, i as createHttpHandler, l as dispatchDvcWrite, m as SCHEME_NAMES, n as wrapFsWithSchemes, o as UrlResolver, p as parseUrl, r as HTTP_SCHEMES, s as resolveDocsDir, u as listDvcDevices } from "./wrap-JFjcWwZf.js";
+import { a as resolveCommandPath, i as primaryServerForFile, n as installHintFor, o as serverByName, s as serversForFile, t as findWorkspaceRoot } from "./lsp-server-registry-BexQagaK.js";
 import { createRequire } from "node:module";
 import { Context } from "@deepseek-ai/cordis";
 import { createHmac, randomBytes, randomUUID } from "node:crypto";
-import { accessSync, constants, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { accessSync, constants, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import * as path from "node:path";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import z from "@deepseek-ai/schemastery";
@@ -2266,7 +2267,7 @@ var DashrRuntime = class extends ReplRuntime {
 };
 
 //#endregion
-//#region src/url-schemes/vendored/devices/ast/natives-loader.ts
+//#region src/devices/ast/natives-loader.ts
 /** Platform tags with a published leaf package (mirrors the upstream loader). */
 const SUPPORTED_PLATFORM_TAGS = [
 	"linux-x64",
@@ -2379,7 +2380,7 @@ function loadPiNatives(options = {}) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/devices/ast/ast-device.ts
+//#region src/devices/ast/ast-device.ts
 /** Per-run cap on distinct rewritten files (upstream `PI_MAX_AST_FILES` default). */
 const MAX_FILES = 1e3;
 /** Glob metacharacters that mark a path segment as a pattern (upstream `GLOB_PATH_CHARS`). */
@@ -2572,7 +2573,7 @@ const summaries = {
 };
 
 //#endregion
-//#region src/url-schemes/vendored/devices/browser/browser-device.ts
+//#region src/devices/browser/browser-device.ts
 let puppeteerModule;
 /** Load puppeteer-core once; missing package → structured BROWSER_NO_PUPPETEER. */
 async function loadPuppeteer() {
@@ -2802,12 +2803,12 @@ function registerBrowserDevice(registry = registerDvcDevice) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/devices/lsp/lsp-jsonrpc.ts
+//#region src/devices/lsp/lsp-jsonrpc.ts
 /**
 * Content-Length JSON-RPC framing for the vendored `dvc://lsp` device.
 *
 * Vendored from `upstream/oh-my-pi` (packages/coding-agent/src/jsonrpc/
-* message-framing.ts, MIT — see ../LICENSE-OMP.md): near-verbatim port to
+* message-framing.ts, MIT — see ../NOTICE-OMP.md): near-verbatim port to
 * plain Node Buffer APIs; upstream's private `#` fields kept. This is the
 * whole vendored surface of that module — no trims were needed.
 */
@@ -2930,7 +2931,7 @@ var MessageFramer = class {
 };
 
 //#endregion
-//#region src/url-schemes/vendored/devices/lsp/lsp-language.ts
+//#region src/devices/lsp/lsp-language.ts
 /** Extension (without dot) → LSP language id (defaults.json coverage). */
 const EXTENSION_LANGUAGE_ID = {
 	rs: "rust",
@@ -3033,7 +3034,7 @@ function detectLanguageId(filePath) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/devices/lsp/lsp-client.ts
+//#region src/devices/lsp/lsp-client.ts
 /** Default per-request timeout when no explicit budget is given (upstream 30s). */
 const DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
 /** Max time to wait for the `initialize` response (upstream WARMUP/init budget). */
@@ -3553,6 +3554,10 @@ async function shutdownClientInstance(client) {
 	killClient(client);
 	return waitForExit(client, EXIT_TIMEOUT_MS);
 }
+/** Snapshot of every live client (stage 2/3: workspace aggregation + fan-out). */
+function listLiveClients() {
+	return [...clients.values()];
+}
 /** Shut down every live client (upstream shutdownAll). */
 async function shutdownAllLspClients() {
 	const toShutdown = [...clients.values()];
@@ -3564,886 +3569,127 @@ if (typeof process !== "undefined") process.on("beforeExit", () => {
 });
 
 //#endregion
-//#region src/url-schemes/vendored/devices/lsp/defaults.json
-var defaults_default = {
-	"rust-analyzer": {
-		"command": "rust-analyzer",
-		"args": [],
-		"fileTypes": [".rs"],
-		"rootMarkers": ["Cargo.toml", "rust-analyzer.toml"],
-		"initOptions": {},
-		"settings": { "rust-analyzer": { "checkOnSave": false } },
-		"capabilities": {
-			"flycheck": true,
-			"ssr": true,
-			"expandMacro": true,
-			"runnables": true,
-			"relatedTests": true
-		}
-	},
-	tlaplus: {
-		"command": "tlapm_lsp",
-		"args": ["--stdio"],
-		"fileTypes": [".tla", ".tlaplus"],
-		"rootMarkers": ["*.tla"]
-	},
-	clangd: {
-		"command": "clangd",
-		"args": [
-			"--background-index",
-			"--clang-tidy",
-			"--header-insertion=iwyu"
-		],
-		"fileTypes": [
-			".c",
-			".cpp",
-			".cc",
-			".cxx",
-			".h",
-			".hpp",
-			".hxx",
-			".m",
-			".mm"
-		],
-		"rootMarkers": [
-			"compile_commands.json",
-			"CMakeLists.txt",
-			".clangd",
-			".clang-format",
-			"Makefile"
-		]
-	},
-	zls: {
-		"command": "zls",
-		"args": [],
-		"fileTypes": [".zig"],
-		"rootMarkers": [
-			"build.zig",
-			"build.zig.zon",
-			"zls.json"
-		]
-	},
-	gopls: {
-		"command": "gopls",
-		"args": ["serve"],
-		"fileTypes": [
-			".go",
-			".mod",
-			".sum"
-		],
-		"rootMarkers": [
-			"go.mod",
-			"go.work",
-			"go.sum"
-		],
-		"settings": { "gopls": {
-			"analyses": {
-				"unusedparams": true,
-				"shadow": true
-			},
-			"staticcheck": true,
-			"gofumpt": true
-		} }
-	},
-	"typescript-language-server": {
-		"command": "typescript-language-server",
-		"args": ["--stdio"],
-		"fileTypes": [
-			".ts",
-			".tsx",
-			".js",
-			".jsx",
-			".mjs",
-			".cjs"
-		],
-		"rootMarkers": [
-			"package.json",
-			"tsconfig.json",
-			"jsconfig.json"
-		],
-		"initOptions": {
-			"hostInfo": "omp-coding-agent",
-			"preferences": {
-				"includeInlayParameterNameHints": "all",
-				"includeInlayVariableTypeHints": true,
-				"includeInlayFunctionParameterTypeHints": true
-			}
-		}
-	},
-	biome: {
-		"command": "biome",
-		"args": ["lsp-proxy"],
-		"fileTypes": [
-			".ts",
-			".tsx",
-			".js",
-			".jsx",
-			".mjs",
-			".cjs",
-			".json",
-			".jsonc",
-			".css"
-		],
-		"rootMarkers": ["biome.json", "biome.jsonc"],
-		"isLinter": true
-	},
-	eslint: {
-		"command": "vscode-eslint-language-server",
-		"args": ["--stdio"],
-		"fileTypes": [
-			".ts",
-			".tsx",
-			".js",
-			".jsx",
-			".mjs",
-			".cjs",
-			".vue",
-			".svelte"
-		],
-		"rootMarkers": [
-			".eslintrc",
-			".eslintrc.js",
-			".eslintrc.json",
-			".eslintrc.yml",
-			"eslint.config.js",
-			"eslint.config.mjs"
-		],
-		"isLinter": true,
-		"settings": {
-			"validate": "on",
-			"run": "onType"
-		}
-	},
-	denols: {
-		"command": "deno",
-		"args": ["lsp"],
-		"fileTypes": [
-			".ts",
-			".tsx",
-			".js",
-			".jsx"
-		],
-		"rootMarkers": [
-			"deno.json",
-			"deno.jsonc",
-			"deno.lock"
-		],
-		"initOptions": {
-			"enable": true,
-			"lint": true,
-			"unstable": true
-		}
-	},
-	"vscode-html-language-server": {
-		"command": "vscode-html-language-server",
-		"args": ["--stdio"],
-		"fileTypes": [".html", ".htm"],
-		"rootMarkers": ["package.json", ".git"],
-		"initOptions": { "provideFormatter": true }
-	},
-	"vscode-css-language-server": {
-		"command": "vscode-css-language-server",
-		"args": ["--stdio"],
-		"fileTypes": [
-			".css",
-			".scss",
-			".sass",
-			".less"
-		],
-		"rootMarkers": ["package.json", ".git"],
-		"initOptions": { "provideFormatter": true }
-	},
-	"vscode-json-language-server": {
-		"command": "vscode-json-language-server",
-		"args": ["--stdio"],
-		"fileTypes": [".json", ".jsonc"],
-		"rootMarkers": ["package.json", ".git"],
-		"initOptions": { "provideFormatter": true }
-	},
-	tailwindcss: {
-		"command": "tailwindcss-language-server",
-		"args": ["--stdio"],
-		"fileTypes": [
-			".html",
-			".css",
-			".scss",
-			".js",
-			".jsx",
-			".ts",
-			".tsx",
-			".vue",
-			".svelte"
-		],
-		"rootMarkers": [
-			"tailwind.config.js",
-			"tailwind.config.ts",
-			"tailwind.config.mjs",
-			"tailwind.config.cjs"
-		]
-	},
-	svelte: {
-		"command": "svelteserver",
-		"args": ["--stdio"],
-		"fileTypes": [".svelte"],
-		"rootMarkers": [
-			"svelte.config.js",
-			"svelte.config.mjs",
-			"package.json"
-		]
-	},
-	"vue-language-server": {
-		"command": "vue-language-server",
-		"args": ["--stdio"],
-		"fileTypes": [".vue"],
-		"rootMarkers": [
-			"vue.config.js",
-			"nuxt.config.js",
-			"nuxt.config.ts",
-			"package.json"
-		]
-	},
-	astro: {
-		"command": "astro-ls",
-		"args": ["--stdio"],
-		"fileTypes": [".astro"],
-		"rootMarkers": [
-			"astro.config.mjs",
-			"astro.config.js",
-			"astro.config.ts"
-		]
-	},
-	pyright: {
-		"command": "pyright-langserver",
-		"args": ["--stdio"],
-		"fileTypes": [".py", ".pyi"],
-		"rootMarkers": [
-			"pyproject.toml",
-			"pyrightconfig.json",
-			"setup.py",
-			"setup.cfg",
-			"requirements.txt",
-			"Pipfile"
-		],
-		"settings": { "python": { "analysis": {
-			"autoSearchPaths": true,
-			"diagnosticMode": "openFilesOnly",
-			"useLibraryCodeForTypes": true
-		} } }
-	},
-	basedpyright: {
-		"command": "basedpyright-langserver",
-		"args": ["--stdio"],
-		"fileTypes": [".py", ".pyi"],
-		"rootMarkers": [
-			"pyproject.toml",
-			"pyrightconfig.json",
-			"setup.py",
-			"requirements.txt"
-		],
-		"settings": { "basedpyright": { "analysis": {
-			"autoSearchPaths": true,
-			"diagnosticMode": "openFilesOnly",
-			"useLibraryCodeForTypes": true
-		} } }
-	},
-	pylsp: {
-		"command": "pylsp",
-		"args": [],
-		"fileTypes": [".py"],
-		"rootMarkers": [
-			"pyproject.toml",
-			"setup.py",
-			"setup.cfg",
-			"requirements.txt",
-			"Pipfile"
-		]
-	},
-	ty: {
-		"command": "ty",
-		"args": ["server"],
-		"fileTypes": [".py", ".pyi"],
-		"rootMarkers": [
-			"pyproject.toml",
-			"ty.toml",
-			"setup.py",
-			"setup.cfg",
-			"requirements.txt",
-			"Pipfile"
-		]
-	},
-	ruff: {
-		"command": "ruff",
-		"args": ["server"],
-		"fileTypes": [".py", ".pyi"],
-		"rootMarkers": [
-			"pyproject.toml",
-			"ruff.toml",
-			".ruff.toml"
-		],
-		"isLinter": true
-	},
-	jdtls: {
-		"command": "jdtls",
-		"args": [],
-		"fileTypes": [".java"],
-		"rootMarkers": [
-			"pom.xml",
-			"build.gradle",
-			"build.gradle.kts",
-			"settings.gradle",
-			".project"
-		]
-	},
-	"kotlin-lsp": {
-		"command": "kotlin-lsp",
-		"args": ["--stdio"],
-		"fileTypes": [".kt", ".kts"],
-		"rootMarkers": [
-			"build.gradle",
-			"build.gradle.kts",
-			"pom.xml",
-			"settings.gradle",
-			"settings.gradle.kts"
-		]
-	},
-	metals: {
-		"command": "metals",
-		"args": [],
-		"fileTypes": [
-			".scala",
-			".sbt",
-			".sc"
-		],
-		"rootMarkers": [
-			"build.sbt",
-			"build.sc",
-			"build.gradle",
-			"pom.xml"
-		],
-		"initOptions": {
-			"statusBarProvider": "show-message",
-			"isHttpEnabled": true
-		}
-	},
-	hls: {
-		"command": "haskell-language-server-wrapper",
-		"args": ["--lsp"],
-		"fileTypes": [".hs", ".lhs"],
-		"rootMarkers": [
-			"stack.yaml",
-			"cabal.project",
-			"hie.yaml",
-			"package.yaml",
-			"*.cabal"
-		],
-		"settings": { "haskell": {
-			"formattingProvider": "ormolu",
-			"checkProject": true
-		} }
-	},
-	ocamllsp: {
-		"command": "ocamllsp",
-		"args": [],
-		"fileTypes": [
-			".ml",
-			".mli",
-			".mll",
-			".mly"
-		],
-		"rootMarkers": [
-			"dune-project",
-			"dune-workspace",
-			"*.opam",
-			".ocamlformat"
-		]
-	},
-	elixirls: {
-		"command": "elixir-ls",
-		"args": [],
-		"fileTypes": [
-			".ex",
-			".exs",
-			".heex",
-			".eex"
-		],
-		"rootMarkers": ["mix.exs", "mix.lock"],
-		"settings": { "elixirLS": {
-			"dialyzerEnabled": true,
-			"fetchDeps": false
-		} }
-	},
-	expert: {
-		"command": "expert",
-		"args": ["--stdio"],
-		"fileTypes": [
-			".ex",
-			".exs",
-			".heex",
-			".eex"
-		],
-		"rootMarkers": ["mix.exs", "mix.lock"]
-	},
-	erlangls: {
-		"command": "erlang_ls",
-		"args": [],
-		"fileTypes": [".erl", ".hrl"],
-		"rootMarkers": [
-			"rebar.config",
-			"erlang.mk",
-			"rebar.lock"
-		]
-	},
-	gleam: {
-		"command": "gleam",
-		"args": ["lsp"],
-		"fileTypes": [".gleam"],
-		"rootMarkers": ["gleam.toml"]
-	},
-	solargraph: {
-		"command": "solargraph",
-		"args": ["stdio"],
-		"fileTypes": [
-			".rb",
-			".rake",
-			".gemspec"
-		],
-		"rootMarkers": [
-			"Gemfile",
-			".solargraph.yml",
-			"Rakefile"
-		],
-		"initOptions": { "formatting": true },
-		"settings": { "solargraph": {
-			"diagnostics": true,
-			"completion": true,
-			"hover": true,
-			"formatting": true,
-			"references": true,
-			"rename": true,
-			"symbols": true
-		} }
-	},
-	"ruby-lsp": {
-		"command": "ruby-lsp",
-		"args": [],
-		"fileTypes": [
-			".rb",
-			".rake",
-			".gemspec",
-			".erb"
-		],
-		"rootMarkers": [
-			"Gemfile",
-			".ruby-version",
-			".ruby-gemset"
-		],
-		"initOptions": { "formatter": "auto" }
-	},
-	rubocop: {
-		"command": "rubocop",
-		"args": ["--lsp"],
-		"fileTypes": [".rb", ".rake"],
-		"rootMarkers": [".rubocop.yml", "Gemfile"],
-		"isLinter": true
-	},
-	bashls: {
-		"command": "bash-language-server",
-		"args": ["start"],
-		"fileTypes": [
-			".sh",
-			".bash",
-			".zsh"
-		],
-		"rootMarkers": [".git"],
-		"settings": { "bashIde": { "globPattern": "*@(.sh|.inc|.bash|.command)" } }
-	},
-	"lua-language-server": {
-		"command": "lua-language-server",
-		"args": [],
-		"fileTypes": [".lua"],
-		"rootMarkers": [
-			".luarc.json",
-			".luarc.jsonc",
-			".luacheckrc",
-			".stylua.toml",
-			"stylua.toml"
-		],
-		"settings": { "Lua": {
-			"runtime": { "version": "LuaJIT" },
-			"diagnostics": { "globals": ["vim"] },
-			"workspace": { "checkThirdParty": false },
-			"telemetry": { "enable": false }
-		} }
-	},
-	intelephense: {
-		"command": "intelephense",
-		"args": ["--stdio"],
-		"fileTypes": [".php", ".phtml"],
-		"rootMarkers": [
-			"composer.json",
-			"composer.lock",
-			".git"
-		]
-	},
-	phpactor: {
-		"command": "phpactor",
-		"args": ["language-server"],
-		"fileTypes": [".php"],
-		"rootMarkers": [
-			"composer.json",
-			".phpactor.json",
-			".phpactor.yml"
-		]
-	},
-	omnisharp: {
-		"command": "omnisharp",
-		"args": [
-			"-z",
-			"--hostPID",
-			"$PID",
-			"--encoding",
-			"utf-8",
-			"--languageserver"
-		],
-		"fileTypes": [".cs", ".csx"],
-		"rootMarkers": [
-			"*.sln",
-			"*.csproj",
-			"omnisharp.json",
-			".git"
-		],
-		"settings": {
-			"FormattingOptions": { "EnableEditorConfigSupport": true },
-			"RoslynExtensionsOptions": { "EnableAnalyzersSupport": true }
-		}
-	},
-	yamlls: {
-		"command": "yaml-language-server",
-		"args": ["--stdio"],
-		"fileTypes": [".yaml", ".yml"],
-		"rootMarkers": [".git"],
-		"settings": {
-			"yaml": {
-				"validate": true,
-				"format": { "enable": true },
-				"hover": true,
-				"completion": true
-			},
-			"redhat": { "telemetry": { "enabled": false } }
-		}
-	},
-	terraformls: {
-		"command": "terraform-ls",
-		"args": ["serve"],
-		"fileTypes": [".tf", ".tfvars"],
-		"rootMarkers": [
-			".terraform",
-			"terraform.tfstate",
-			"*.tf"
-		]
-	},
-	dockerls: {
-		"command": "docker-langserver",
-		"args": ["--stdio"],
-		"fileTypes": [".dockerfile", "Dockerfile"],
-		"rootMarkers": [
-			"Dockerfile",
-			"docker-compose.yml",
-			"docker-compose.yaml",
-			".dockerignore"
-		]
-	},
-	"helm-ls": {
-		"command": "helm_ls",
-		"args": ["serve"],
-		"fileTypes": [
-			".yaml",
-			".yml",
-			".tpl"
-		],
-		"rootMarkers": ["Chart.yaml", "Chart.yml"]
-	},
-	nixd: {
-		"command": "nixd",
-		"args": [],
-		"fileTypes": [".nix"],
-		"rootMarkers": [
-			"flake.nix",
-			"default.nix",
-			"shell.nix"
-		]
-	},
-	nil: {
-		"command": "nil",
-		"args": [],
-		"fileTypes": [".nix"],
-		"rootMarkers": [
-			"flake.nix",
-			"default.nix",
-			"shell.nix"
-		]
-	},
-	ols: {
-		"command": "ols",
-		"args": [],
-		"fileTypes": [".odin"],
-		"rootMarkers": ["ols.json", ".git"]
-	},
-	dartls: {
-		"command": "dart",
-		"args": ["language-server", "--protocol=lsp"],
-		"fileTypes": [".dart"],
-		"rootMarkers": ["pubspec.yaml", "pubspec.lock"],
-		"initOptions": {
-			"closingLabels": true,
-			"flutterOutline": true,
-			"outline": true
-		}
-	},
-	marksman: {
-		"command": "marksman",
-		"args": ["server"],
-		"fileTypes": [".md", ".markdown"],
-		"rootMarkers": [".marksman.toml", ".git"],
-		"warmupTimeoutMs": 2e3
-	},
-	texlab: {
-		"command": "texlab",
-		"args": [],
-		"fileTypes": [
-			".tex",
-			".bib",
-			".sty",
-			".cls"
-		],
-		"rootMarkers": [
-			".latexmkrc",
-			"latexmkrc",
-			".texlabroot",
-			"texlabroot",
-			"Tectonic.toml"
-		],
-		"settings": { "texlab": {
-			"build": {
-				"executable": "latexmk",
-				"args": [
-					"-pdf",
-					"-interaction=nonstopmode",
-					"-synctex=1",
-					"%f"
-				]
-			},
-			"chktex": { "onOpenAndSave": true }
-		} }
-	},
-	graphql: {
-		"command": "graphql-lsp",
-		"args": [
-			"server",
-			"-m",
-			"stream"
-		],
-		"fileTypes": [".graphql", ".gql"],
-		"rootMarkers": [
-			".graphqlrc",
-			".graphqlrc.json",
-			".graphqlrc.yml",
-			".graphqlrc.yaml",
-			"graphql.config.js"
-		]
-	},
-	prismals: {
-		"command": "prisma-language-server",
-		"args": ["--stdio"],
-		"fileTypes": [".prisma"],
-		"rootMarkers": ["schema.prisma", "prisma/schema.prisma"]
-	},
-	vimls: {
-		"command": "vim-language-server",
-		"args": ["--stdio"],
-		"fileTypes": [".vim", ".vimrc"],
-		"rootMarkers": [".git"],
-		"initOptions": {
-			"isNeovim": true,
-			"diagnostic": { "enable": true }
-		}
-	},
-	"emmet-language-server": {
-		"command": "emmet-language-server",
-		"args": ["--stdio"],
-		"fileTypes": [
-			".html",
-			".css",
-			".scss",
-			".less",
-			".jsx",
-			".tsx",
-			".vue",
-			".svelte"
-		],
-		"rootMarkers": [".git"]
-	},
-	"sourcekit-lsp": {
-		"command": "sourcekit-lsp",
-		"args": [],
-		"fileTypes": [".swift"],
-		"rootMarkers": [
-			"Package.swift",
-			"*.xcodeproj",
-			"*.xcworkspace",
-			"project.yml",
-			".swiftpm"
-		]
-	},
-	swiftlint: {
-		"command": "swiftlint",
-		"args": [
-			"lint",
-			"--quiet",
-			"--reporter",
-			"json"
-		],
-		"fileTypes": [".swift"],
-		"rootMarkers": [
-			".swiftlint.yml",
-			".swiftlint.yaml",
-			"Package.swift",
-			"*.xcodeproj"
-		],
-		"isLinter": true
+//#region src/devices/lsp/lsp-gate.ts
+/** Nag ceiling per session (spec: at most 10 availability notices). */
+const NAG_CAP = 10;
+/** Languages eligible for the availability notice. */
+const NAG_LANGUAGES = new Set([
+	"python",
+	"typescript",
+	"javascript",
+	"rust",
+	"go"
+]);
+/** Must-have languages installed proactively at first availability check. */
+const MUST_HAVE = new Set([
+	"python",
+	"typescript",
+	"javascript"
+]);
+/** Language id from a file extension (table-driven; unknown → undefined). */
+function languageOf(filePath) {
+	const ext = path.extname(filePath).toLowerCase();
+	if (ext === ".py") return "python";
+	if (ext === ".ts" || ext === ".tsx" || ext === ".mts" || ext === ".cts") return "typescript";
+	if (ext === ".js" || ext === ".jsx" || ext === ".mjs" || ext === ".cjs") return "javascript";
+	if (ext === ".rs") return "rust";
+	if (ext === ".go") return "go";
+}
+const gates = /* @__PURE__ */ new Map();
+function gateOf(sessionId) {
+	let gate = gates.get(sessionId);
+	if (gate === void 0) {
+		gate = {
+			state: "unasked",
+			nags: 0,
+			installTried: /* @__PURE__ */ new Set(),
+			warmed: /* @__PURE__ */ new Set()
+		};
+		gates.set(sessionId, gate);
 	}
-};
-
-//#endregion
-//#region src/url-schemes/vendored/devices/lsp/lsp-server-registry.ts
-/** The verbatim upstream registry (54 servers), keyed by server name. */
-const REGISTRY = defaults_default;
-/** Server names in registry (insertion) order — deterministic selection. */
-const REGISTRY_NAMES = Object.keys(REGISTRY);
-/** Cache resolved-command probes: command → absolute path or null (missing). */
-const commandProbeCache = /* @__PURE__ */ new Map();
-/**
-* Find servers whose `fileTypes` cover `filePath` (upstream getServersForFile,
-* extension match plus the basename entries defaults.json uses for Dockerfiles).
-*/
-function serversForFile(filePath) {
-	const lower = filePath.toLowerCase();
-	const baseName = path.posix.basename(lower.replaceAll("\\", "/"));
-	const extension = path.extname(lower);
-	const matches = [];
-	for (const name$2 of REGISTRY_NAMES) {
-		const config = REGISTRY[name$2];
-		if (config === void 0) continue;
-		if (config.fileTypes.some((fileType) => fileType === extension || fileType !== "" && !fileType.startsWith(".") && fileType === baseName)) matches.push([name$2, config]);
-	}
-	return matches;
+	return gate;
 }
-/**
-* The primary server for a file: first non-linter match in registry order,
-* falling back to the first linter (upstream getServerForFile preference —
-* type intelligence over linting).
-*/
-function primaryServerForFile(filePath) {
-	const matches = serversForFile(filePath);
-	return matches.find(([, config]) => config.isLinter !== true) ?? matches[0] ?? null;
-}
-/** Look up a named registry entry (device `server` arg). */
-function serverByName(name$2) {
-	return REGISTRY[name$2];
-}
-/** One-level wildcard marker match: `*` crosses everything but `/` (upstream glob markers). */
-function markerMatchesEntry(marker, entry) {
-	const star = marker.indexOf("*");
-	if (star === -1) return marker === entry;
-	const prefix = marker.slice(0, star);
-	const suffix = marker.slice(star + 1);
-	return entry.length >= prefix.length + suffix.length && entry.startsWith(prefix) && entry.endsWith(suffix) && !entry.slice(prefix.length, entry.length - suffix.length).includes("/");
-}
-/** Whether any root marker exists directly in `dir` (upstream hasRootMarkers). */
-function hasRootMarkers(dir, markers) {
-	let entries = null;
-	for (const marker of markers) {
-		if (marker.includes("*")) {
-			if (entries === null) try {
-				entries = readdirSync(dir);
-			} catch {
-				return false;
-			}
-			if (entries.some((entry) => markerMatchesEntry(marker, entry))) return true;
-			continue;
-		}
-		if (existsSync(path.join(dir, marker))) return true;
-	}
-	return false;
+/** Drop a session's gate state (agent dispose). */
+function disposeLspGate(sessionId) {
+	gates.delete(sessionId);
+}
+/** Current gate state for a session (read side: `dvc://lsp` status). */
+function lspGateState(sessionId) {
+	return gateOf(sessionId).state;
 }
 /**
-* Nearest ancestor of `filePath` holding a root marker, stopping at the
-* filesystem root; `null` when no ancestor matches (upstream
-* hasRootMarkerAncestor walk, returning the dir instead of a boolean).
+* Must-have install (stage 5): for python/typescript/javascript, probe the
+* registry's primary server binary once per session; when missing, run its
+* package-manager install in the background (fail-soft — a failed install
+* degrades to the device's structured LSP_SERVER_MISSING at spawn time, and
+* is never retried within the session). Niche languages install only after
+* an explicit gate-on (spec: on-demand).
 */
-function findWorkspaceRoot(filePath, markers) {
-	if (markers.length === 0) return null;
-	let dir = path.dirname(path.resolve(filePath));
-	for (;;) {
-		if (hasRootMarkers(dir, markers)) return dir;
-		const parent = path.dirname(dir);
-		if (parent === dir) return null;
-		dir = parent;
-	}
-}
-function isExecutableFile(candidate) {
-	try {
-		accessSync(candidate, constants.X_OK);
-		return true;
-	} catch {
-		return false;
-	}
+function ensureMustHave(gate, language) {
+	if (!MUST_HAVE.has(language) || gate.installTried.has(language)) return;
+	gate.installTried.add(language);
+	(async () => {
+		const registry = await import("./lsp-server-registry-B8DNonhS.js");
+		const probePath = `/tmp/x.${language === "python" ? "py" : "ts"}`;
+		const primary = registry.primaryServerForFile(probePath);
+		if (primary === null) return;
+		const [name$2, config] = primary;
+		if (registry.resolveCommandPath(config.command, "/tmp") !== null) return;
+		if (!await registry.installServer(config.command)) {}
+	})().catch(() => {});
 }
 /**
-* Resolve `command` to an absolute executable: the project's
-* `node_modules/.bin`, then every `$PATH` directory (upstream
-* resolveCommandFromLocalRoot + PATH scan). Absolute overrides (device
-* `command` args, fake-server fixtures) are probed directly. Result cached
-* per command; returns `null` when the binary is missing.
+* Maybe produce the availability notice for a just-landed mutation.
+* Returns undefined when silent (gate decided, cap reached, non-table
+* language). Pure — no side effects beyond the nag counter.
 */
-function resolveCommandPath(command, cwd) {
-	const cacheKey$1 = `${command}\0${cwd}`;
-	const cached = commandProbeCache.get(cacheKey$1);
-	if (cached !== void 0) return cached;
-	const resolved = (path.isAbsolute(command) ? [command] : [path.join(cwd, "node_modules", ".bin", command), ...(process.env.PATH ?? "").split(path.delimiter).filter((dir) => dir !== "").map((dir) => path.join(dir, command))]).find((candidate) => isExecutableFile(candidate)) ?? null;
-	commandProbeCache.set(cacheKey$1, resolved);
-	return resolved;
-}
-/** Per-command install hints for the common servers (device-side aid; upstream only names the command). */
-const INSTALL_HINTS = {
-	"typescript-language-server": "npm install -g typescript-language-server typescript",
-	"vscode-eslint-language-server": "npm install -g vscode-languageserver-types eslint vscode-eslint-language-server",
-	"pyright-langserver": "npm install -g pyright",
-	pylsp: "pip install \"python-lsp-server[all]\"",
-	gopls: "go install golang.org/x/tools/gopls@latest",
-	"rust-analyzer": "rustup component add rust-analyzer",
-	clangd: "apt install clangd (or brew install llvm)",
-	biome: "npm install -g @biomejs/biome",
-	ruff: "pip install ruff",
-	"bash-language-server": "npm install -g bash-language-server",
-	"lua-language-server": "install from https://github.com/LuaLS/lua-language-server/releases",
-	marksman: "install from https://github.com/artempyanykh/marksman/releases"
-};
-/** Install hint for a missing server binary; generic fallback otherwise. */
-function installHintFor(command) {
-	const hint = INSTALL_HINTS[command];
-	if (hint !== void 0) return hint;
-	return `install the "${command}" language server and make sure it is on $PATH`;
+function lspGateNotice(sessionId, filePath) {
+	const gate = gateOf(sessionId);
+	if (gate.state !== "unasked") return void 0;
+	const language = languageOf(filePath);
+	if (language === void 0 || !NAG_LANGUAGES.has(language)) return void 0;
+	ensureMustHave(gate, language);
+	if (gate.nags >= NAG_CAP) return void 0;
+	gate.nags += 1;
+	const remaining = NAG_CAP - gate.nags;
+	return `lsp diagnostics available for this language — write dvc://lsp {"action":"on"} to enable, {"action":"off"} to mute${remaining > 0 ? ` (${remaining} reminders left)` : " (final reminder)"}`;
+}
+/** Apply a gate decision. Returns a human-readable ack. */
+function lspGateDecide(sessionId, on) {
+	const gate = gateOf(sessionId);
+	gate.state = on ? "on" : "off";
+	return on ? "lsp on for this session: servers warm-start per language on first file contact; no repo artifacts are written." : "lsp off for this session: no servers will spawn and notices are muted.";
+}
+let transport;
+/** The device registers its sync/spawn entry point at mount time. */
+function registerLspGateTransport(fn) {
+	transport = fn;
+}
+function lspGateSyncOnLand(sessionId, kind, filePath, content) {
+	if (gateOf(sessionId).state !== "on" || transport === void 0) return;
+	if (languageOf(filePath) === void 0) return;
+	transport({
+		sessionId,
+		kind,
+		filePath,
+		content
+	}).catch(() => {});
 }
 
 //#endregion
-//#region src/url-schemes/vendored/devices/lsp/lsp-device.ts
+//#region src/devices/lsp/lsp-device.ts
 const ACTIONS = new Set([
 	"diagnostics",
 	"definition",
 	"references",
 	"hover",
-	"format"
+	"format",
+	"on",
+	"off",
+	"status",
+	"rename",
+	"code_actions",
+	"reload"
 ]);
 const SEVERITY_NAMES = {
 	1: "error",
@@ -4655,12 +3901,107 @@ function isEmptyPositionResult(result) {
 	}
 	return false;
 }
+/** Apply a WorkspaceEdit file entry through the in-memory applier; returns the changed path. */
+async function applyFileTextEdits(uri, edits) {
+	const filePath = uriToFile(uri);
+	const updated = applyTextEdits(await fsPromises.readFile(filePath, "utf-8"), edits);
+	await fsPromises.writeFile(filePath, updated, "utf-8");
+	return filePath;
+}
+/** Apply or preview a WorkspaceEdit; returns per-file summaries. */
+async function applyOrPreviewWorkspaceEdit(edit, apply$2) {
+	const perFile = [];
+	for (const [uri, edits] of Object.entries(edit.changes ?? {})) perFile.push({
+		uri,
+		edits
+	});
+	for (const doc of edit.documentChanges ?? []) perFile.push({
+		uri: doc.textDocument.uri,
+		edits: doc.edits
+	});
+	if (perFile.length === 0) return [];
+	if (!apply$2) return perFile.map(({ uri, edits }) => `  ${uriToFile(uri)}: ${edits.length} edit(s) (preview — pass "apply":true to apply)`);
+	const out = [];
+	for (const { uri, edits } of perFile) out.push(`  ${await applyFileTextEdits(uri, edits)} (${edits.length} edit(s))`);
+	return out;
+}
+const BARE_IDENTIFIER_RE = /^[$A-Za-z_][\w$]*$/;
+const IDENTIFIER_CHAR_RE = /[A-Za-z0-9_$]/;
+/** `symbol` / `symbol#N` — N-th 1-based occurrence of the identifier on the line. */
+function parseSymbolSpec(spec) {
+	const match = spec.match(/^(.+)#(\d+)$/);
+	if (match === null) return {
+		symbol: spec,
+		occurrence: 1
+	};
+	return {
+		symbol: match[1] ?? spec,
+		occurrence: Math.max(1, Number.parseInt(match[2] ?? "1", 10))
+	};
+}
+/** Match indexes for the symbol on the line: exact (word-bounded for bare identifiers), then case-insensitive. */
+function findSymbolMatchIndexes(lineText, symbol, caseInsensitive = false) {
+	if (symbol.length === 0) return [];
+	const haystack = caseInsensitive ? lineText.toLowerCase() : lineText;
+	const needle = caseInsensitive ? symbol.toLowerCase() : symbol;
+	const requireWordBoundary = BARE_IDENTIFIER_RE.test(symbol);
+	const indexes = [];
+	let fromIndex = 0;
+	for (;;) {
+		const matchIndex = haystack.indexOf(needle, fromIndex);
+		if (matchIndex === -1) break;
+		if (requireWordBoundary) {
+			const before = matchIndex > 0 ? haystack[matchIndex - 1] ?? "" : "";
+			const afterIdx = matchIndex + needle.length;
+			const after = afterIdx < haystack.length ? haystack[afterIdx] ?? "" : "";
+			if (IDENTIFIER_CHAR_RE.test(before) || IDENTIFIER_CHAR_RE.test(after)) {
+				fromIndex = matchIndex + 1;
+				continue;
+			}
+		}
+		indexes.push(matchIndex);
+		fromIndex = matchIndex + needle.length;
+	}
+	return indexes;
+}
+/**
+* Resolve the query column on `line` (1-based): no `symbol` → first
+* non-whitespace column; `symbol` → the occurrence's 0-based column,
+* exact case-sensitive first, case-insensitive fallback. Mirrors upstream
+* resolveSymbolColumn (OMP utils.ts).
+*/
+function resolveSymbolColumn(lines, line, symbolSpec) {
+	const targetLine = lines[line - 1] ?? "";
+	if (symbolSpec === void 0 || symbolSpec === "") {
+		const match = targetLine.match(/\S/);
+		return match && match.index !== void 0 ? match.index : 0;
+	}
+	const { symbol, occurrence } = parseSymbolSpec(symbolSpec);
+	const exact = findSymbolMatchIndexes(targetLine, symbol);
+	const fallback = exact.length > 0 ? exact : findSymbolMatchIndexes(targetLine, symbol, true);
+	if (fallback.length === 0) throw new UrlSchemesError("LSP_SYMBOL_NOT_FOUND", `lsp device: symbol "${symbol}" not found on line ${line}`);
+	if (occurrence > fallback.length) throw new UrlSchemesError("LSP_SYMBOL_NOT_FOUND", `lsp device: symbol "${symbol}" occurrence ${occurrence} out of bounds on line ${line} (found ${fallback.length})`);
+	return fallback[occurrence - 1] ?? 0;
+}
 /** The `dvc://lsp` device: dispatch on `action`, structured errors on every bad path. */
 const lspDevice = {
-	async execute(args) {
+	async execute(args, ctx) {
 		const record = requireObjectArgs(args);
 		const action = record.action;
-		if (typeof action !== "string" || !ACTIONS.has(action)) throw new UrlSchemesError("LSP_BAD_ARGS", `lsp device: unknown action ${JSON.stringify(action ?? null)} — expected "diagnostics", "definition", "references", "hover", or "format"`);
+		const sessionId = ctx?.session;
+		if (typeof action !== "string" || !ACTIONS.has(action)) throw new UrlSchemesError("LSP_BAD_ARGS", `lsp device: unknown action ${JSON.stringify(action ?? null)} — expected "diagnostics", "definition", "references", "hover", "format", "rename", "code_actions", "reload", "on", "off", or "status"`);
+		if (action === "on" || action === "off" || action === "status") {
+			if (sessionId === void 0) throw new UrlSchemesError("LSP_BAD_ARGS", "lsp device: gate actions require a session context (the write dispatcher injects it automatically)");
+			if (action === "status") return {
+				ok: true,
+				gate: lspGateState(sessionId)
+			};
+			return {
+				ok: true,
+				gate: action,
+				message: lspGateDecide(sessionId, action === "on")
+			};
+		}
 		const file = record.file;
 		if (typeof file !== "string" || file === "") throw new UrlSchemesError("LSP_BAD_ARGS", "lsp device: this action requires a non-empty \"file\" string");
 		const content = record.content;
@@ -4671,6 +4012,8 @@ const lspDevice = {
 		const filePath = path.resolve(file);
 		if (content === void 0 && !existsSync(filePath)) throw new UrlSchemesError("LSP_BAD_ARGS", `lsp device: file not found: ${filePath}`);
 		const position = requirePosition(record);
+		let symbolCharacter;
+		if (typeof record.symbol === "string" && record.symbol !== "" && position.character === 1 && existsSync(filePath)) symbolCharacter = resolveSymbolColumn((await fsPromises.readFile(filePath, "utf-8")).split("\n"), position.line, record.symbol);
 		const { name: name$2, client } = await obtainClient(record, filePath);
 		const base = {
 			ok: true,
@@ -4681,13 +4024,134 @@ const lspDevice = {
 		const uri = fileToUri(filePath);
 		const wirePosition = {
 			line: position.line - 1,
-			character: position.character - 1
+			character: symbolCharacter ?? position.character - 1
 		};
 		const diagnosticsBaseline = client.diagnosticsVersion;
 		if (content === void 0) await ensureFileOpen(client, filePath);
 		else await syncFileContent(client, filePath, content);
 		if (action !== "diagnostics" && client.config.isLinter !== true) await waitForProjectLoaded(client);
 		const retryCold = action !== "diagnostics" && client.config.isLinter !== true;
+		if (action === "reload") {
+			const { name: name$3, client: client$1 } = await obtainClient(record, file);
+			await shutdownClientInstance(client$1);
+			return `${name$3}: reloaded — the next lsp call respawns the server fresh (config re-read from disk).`;
+		}
+		if (action === "diagnostics" && record.all === true) {
+			const candidates = serversForFile(file);
+			if (candidates.length <= 1) {} else {
+				const results = [];
+				for (const [srvName] of candidates) try {
+					const outcome = await thisDispatch({
+						...record,
+						all: void 0,
+						server: srvName
+					});
+					results.push({
+						server: srvName,
+						diagnostics: outcome.diagnostics ?? [],
+						summary: outcome.summary ?? ""
+					});
+				} catch (error) {
+					results.push({
+						server: srvName,
+						diagnostics: [],
+						summary: error instanceof Error ? error.message : String(error)
+					});
+				}
+				const total = results.reduce((n, r) => n + r.diagnostics.length, 0);
+				return {
+					ok: true,
+					fanout: true,
+					servers: results.map((r) => r.server),
+					diagnostics: results.flatMap((r) => r.diagnostics),
+					summary: `fan-out ${file}: ${total} diagnostic(s) across ${results.length} server(s) — ${results.map((r) => `${r.server}: ${r.diagnostics.length}`).join(", ")}`
+				};
+			}
+		}
+		if (action === "diagnostics" && file === "*") {
+			const servers = listLiveClients().filter((c) => c.status === "ready");
+			const files = [];
+			for (const c of servers) for (const [uri$1, published] of c.diagnostics) {
+				const diags = published.diagnostics ?? [];
+				files.push({
+					file: uriToFile(uri$1),
+					server: c.config.command,
+					count: diags.length,
+					errors: diags.filter((d) => (d.severity ?? 1) === 1).length,
+					warnings: diags.filter((d) => (d.severity ?? 1) === 2).length
+				});
+			}
+			files.sort((a, b) => b.count - a.count);
+			const totalErrors = files.reduce((n, f) => n + f.errors, 0);
+			const totalWarnings = files.reduce((n, f) => n + f.warnings, 0);
+			const lines = files.slice(0, 50).map((f) => `  ${f.file} [${f.server}]: ${f.count} (${f.errors}E/${f.warnings}W)`);
+			return {
+				ok: true,
+				scope: "workspace",
+				servers: servers.length,
+				files: files.length,
+				errors: totalErrors,
+				warnings: totalWarnings,
+				summary: `workspace diagnostics: ${files.length} file(s) with findings across ${servers.length} live server(s) — ${totalErrors} error(s), ${totalWarnings} warning(s)`,
+				detail: lines.length > 0 ? lines.join("\n") : "no cached diagnostics"
+			};
+		}
+		if (action === "rename") {
+			const newName = record.new_name;
+			if (typeof newName !== "string" || newName === "") throw new UrlSchemesError("LSP_BAD_ARGS", "lsp device: \"rename\" requires a non-empty \"new_name\" string");
+			const { name: name$3, client: client$1 } = await obtainClient(record, file);
+			const { line } = requirePosition(record);
+			const character = resolveSymbolColumn((await fsPromises.readFile(file, "utf-8")).split("\n"), line, typeof record.symbol === "string" ? record.symbol : void 0);
+			await ensureFileOpen(client$1, file);
+			const result = await lspPositionRequest(client$1, "textDocument/rename", {
+				textDocument: { uri: fileToUri(file) },
+				position: {
+					line: line - 1,
+					character
+				},
+				newName
+			}, false);
+			if (result === null || result.changes === void 0 && result.documentChanges === void 0) return `${name$3}: rename returned no edits`;
+			const apply$2 = record.apply !== false;
+			const lines = await applyOrPreviewWorkspaceEdit(result, apply$2);
+			return `${name$3}: rename ${apply$2 ? "applied" : "preview"}:\n${lines.join("\n")}`;
+		}
+		if (action === "code_actions") {
+			const { name: name$3, client: client$1 } = await obtainClient(record, file);
+			const { line, character } = requirePosition(record);
+			await ensureFileOpen(client$1, file);
+			const actions = await lspPositionRequest(client$1, "textDocument/codeAction", {
+				textDocument: { uri: fileToUri(file) },
+				range: {
+					start: {
+						line: line - 1,
+						character: character - 1
+					},
+					end: {
+						line: line - 1,
+						character: character - 1
+					}
+				},
+				context: {
+					diagnostics: client$1.diagnostics.get(fileToUri(file))?.diagnostics ?? [],
+					triggerKind: 1
+				}
+			}, false) ?? [];
+			if (actions.length === 0) return `${name$3}: no code actions available`;
+			const applyIndex = typeof record.apply === "number" ? record.apply : void 0;
+			if (applyIndex === void 0) return `${name$3}: code actions (pass "apply":<index> to apply):\n` + actions.map((a, i) => `  [${i}] ${a.title ?? "(untitled)"}${a.kind ? ` (${a.kind})` : ""}`).join("\n");
+			const chosen = actions[applyIndex];
+			if (chosen === void 0) throw new UrlSchemesError("LSP_BAD_ARGS", `lsp device: "apply" index ${applyIndex} out of range (0..${actions.length - 1})`);
+			if (chosen.edit !== void 0) {
+				const lines = await applyOrPreviewWorkspaceEdit(chosen.edit, true);
+				return `${name$3}: applied code action "${chosen.title ?? applyIndex}":\n${lines.join("\n")}`;
+			}
+			if (chosen.command?.command !== void 0) {
+				await sendRequest(client$1, "workspace/executeCommand", chosen.command);
+				return `${name$3}: executed command "${chosen.command.command}" for "${chosen.title ?? applyIndex}"`;
+			}
+			return `${name$3}: code action "${chosen.title ?? applyIndex}" carries neither edit nor command`;
+		}
 		switch (action) {
 			case "diagnostics": {
 				if (saved !== true) {
@@ -4708,12 +4172,25 @@ const lspDevice = {
 					timeoutMs: DIAGNOSTICS_FEEDBACK_WAIT_MS
 				});
 				const kept = waited.diagnostics.filter((diagnostic) => !(waited.timedOut && diagnostic.source === "rustc")).map(diagnosticRecord);
-				return {
+				const out = {
 					...base,
 					diagnostics: kept,
 					summary: diagnosticsSummary(kept),
 					check: waited.timedOut ? "timeout-dropped-rustc" : "completed"
 				};
+				if (client.serverCapabilities !== void 0 && "diagnosticProvider" in client.serverCapabilities) try {
+					const pulled = await sendRequest(client, "textDocument/diagnostic", { textDocument: { uri } });
+					if (pulled !== null && Array.isArray(pulled.items)) {
+						const items = pulled.items.map((d) => diagnosticRecord(d));
+						return {
+							...out,
+							diagnostics: items,
+							summary: diagnosticsSummary(items),
+							pull: true
+						};
+					}
+				} catch {}
+				return out;
 			}
 			case "definition": {
 				const result = await lspPositionRequest(client, "textDocument/definition", {
@@ -4780,13 +4257,59 @@ const lspDevice = {
 			default: throw new UrlSchemesError("LSP_BAD_ARGS", `lsp device: unhandled action "${String(action)}"`);
 		}
 	},
-	summary: "LSP queries over stdio language servers (defaults.json registry) — diagnostics / definition / references / hover on {file,line,character}"
+	summary: "LSP queries over stdio language servers (defaults.json registry) — diagnostics / definition / references / hover on {file,line,character}",
+	read: lspDeviceRead
 };
+/** One-level recursion for fan-out: re-dispatch with a specific `server`. */
+const thisDispatch = (args) => lspDevice.execute(args);
+const READ_ACTIONS = new Set([
+	"status",
+	"diagnostics",
+	"definition",
+	"references",
+	"hover"
+]);
+function parseReadQuery(subpath) {
+	const qIndex = subpath.indexOf("?");
+	const action = qIndex === -1 ? subpath : subpath.slice(0, qIndex);
+	if (!READ_ACTIONS.has(action)) return void 0;
+	const args = { action };
+	if (qIndex !== -1) for (const [k, v] of new URLSearchParams(subpath.slice(qIndex + 1))) args[k] = k === "all" || k === "apply" ? v === "1" || v === "true" : v;
+	return {
+		action,
+		args
+	};
+}
+async function lspDeviceRead(subpath, session) {
+	const parsed = parseReadQuery(subpath);
+	if (parsed === void 0) return `unknown read path dvc://lsp/${subpath} — reads: status | diagnostics?file=…[&all=1] | definition?file=&line=[&character=|&symbol=] | references?… | hover?…`;
+	if (parsed.action === "status") {
+		if (session !== void 0) return JSON.stringify({
+			ok: true,
+			gate: lspGateState(session)
+		});
+		return JSON.stringify({
+			ok: true,
+			note: "per-session gate — read from a session for its gate (session missing in read env)"
+		});
+	}
+	const result = await lspDevice.execute(parsed.args);
+	return JSON.stringify(result, null, 2);
+}
 /**
 * Mount the lsp device. `registry` defaults to the dvc:// module-level registry
 * (`registerDvcDevice`); tests may pass their own recorder instead.
 */
 function installLspDevices(registry = registerDvcDevice) {
+	registerLspGateTransport(async ({ kind, filePath, content }) => {
+		const { client } = await obtainClient({}, filePath);
+		if (kind === "read") {
+			await ensureFileOpen(client, filePath);
+			return;
+		}
+		await syncFileContent(client, filePath, typeof content === "string" && content !== "" ? content : await import("node:fs/promises").then((fs) => fs.readFile(filePath, "utf-8")));
+		await notifyDidSave(client, filePath);
+	});
 	registry("lsp", lspDevice);
 }
 
@@ -5364,8 +4887,8 @@ function loadSectionText() {
 }
 const SECTION_TEXT = loadSectionText();
 /** Render the section when the URL capability is on; `undefined` gates it off. */
-function generalSection(gates) {
-	if (!gates.urlSchemes) return void 0;
+function generalSection(gates$1) {
+	if (!gates$1.urlSchemes) return void 0;
 	return {
 		name: GENERAL_SECTION_NAME,
 		order: GENERAL_SECTION_ORDER,
@@ -5418,9 +4941,24 @@ function lookupOptions(env) {
 * maps a URL to its on-disk location so `grep`/`glob` can search the real
 * files instead of resolved text.
 */
+/**
+* Render the cwd-scoped skill catalog: one line per winning summary
+* (`name — description`, plus `whenToUse` when present). Empty registry →
+* an explicit empty answer, never an error.
+*/
+async function renderSkillList(skills, env) {
+	const all = await skills.list(lookupOptions(env));
+	if (all.length === 0) return "No skills available in this workspace scope.";
+	const lines = all.map((skill) => {
+		const when = skill.whenToUse !== void 0 && skill.whenToUse !== "" ? ` (use when: ${skill.whenToUse})` : "";
+		return `skill://${skill.name} — ${skill.description}${when}`;
+	});
+	return `${all.length} available skill(s):\n${lines.join("\n")}`;
+}
 function createSkillHandler(deps) {
 	return {
 		async resolve(env, path$1) {
+			if (path$1 === "" || path$1 === "/") return await renderSkillList(deps.skills, env);
 			const { name: name$2, subpath } = splitSkillPath(path$1);
 			const skill = await deps.skills.get(name$2, lookupOptions(env));
 			if (skill === void 0) throw new UrlSchemesError("URL_SKILL_NOT_FOUND", `skill "${name$2}" is unknown or no longer available`);
@@ -5574,6 +5112,26 @@ function isSchemeUrl$2(raw) {
 		throw error;
 	}
 }
+/**
+* Split a URL-with-glob pattern into `{ urlPart, globTail }`: the first glob
+* metacharacter (`*?[`) in the path portion starts the glob tail, which the
+* path-backed branch applies WITHIN the resource's real disk directory
+* (`skill://grp/*` → root = the skill dir, pattern `*`). A URL with no
+* metacharacters keeps the bare-URL listing behavior (tail empty → the
+* all-depth default pattern).
+*/
+function splitUrlGlob(pattern) {
+	const metachar = pattern.search(/[*?\[]/);
+	if (metachar === -1) return {
+		urlPart: pattern,
+		globTail: ""
+	};
+	const tail = pattern.slice(metachar).replace(/^\/+/, "");
+	return {
+		urlPart: pattern.slice(0, metachar).replace(/\/+$/, ""),
+		globTail: tail
+	};
+}
 /** Structured error for calls that cannot run without the native delegate. */
 function nativeUnavailable$1() {
 	return new UrlSchemesError("NATIVE_GLOB_UNAVAILABLE", "the host did not deploy a native glob tool — URL-aware glob cannot delegate discovery");
@@ -5626,12 +5184,14 @@ function createGlobTool(deps) {
 		async execute(args, exec) {
 			if (isSchemeUrl$2(args.pattern)) {
 				const env = execEnv$1(exec, args.pattern);
-				const diskDir = await resolver.resolvePath(env, args.pattern);
+				const { urlPart, globTail } = splitUrlGlob(args.pattern);
+				const diskDir = await resolver.resolvePath(env, urlPart);
 				if (diskDir !== void 0) {
 					if (nativeGlob === void 0) throw nativeUnavailable$1();
+					const rootedPattern = globTail === "" ? "**/*" : globTail;
 					return nativeGlob.execute({
 						...args,
-						pattern: "**/*",
+						pattern: rootedPattern,
 						path: diskDir
 					}, exec);
 				}
@@ -5752,10 +5312,25 @@ function createGrepTool(deps) {
 			if (args.path !== void 0 && isSchemeUrl$1(args.path)) {
 				const env = execEnv(exec, args.path);
 				const diskPath = await resolver.resolvePath(env, args.path);
-				if (diskPath !== void 0) return nativeGrep.execute({
-					...args,
-					path: diskPath
-				}, exec);
+				if (diskPath !== void 0) {
+					const result = await nativeGrep.execute({
+						...args,
+						path: diskPath
+					}, exec);
+					if (!Array.isArray(result.matches)) return result;
+					const prefix = diskPath.endsWith("/") ? diskPath : `${diskPath}/`;
+					return { matches: result.matches.map((m) => {
+						if (m.path.startsWith(prefix)) return {
+							...m,
+							path: `${args.path}/${m.path.slice(prefix.length)}`
+						};
+						if (!m.path.startsWith("/")) return {
+							...m,
+							path: `${args.path}/${m.path}`
+						};
+						return m;
+					}) };
+				}
 				return withTempMaterialization(await resolver.resolve(env, args.path), (tempDir) => nativeGrep.execute({
 					...args,
 					path: join(tempDir, "content.txt")
@@ -5767,7 +5342,231 @@ function createGrepTool(deps) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/constants.js
+//#region src/url-schemes/tools/read.ts
+/** Mirrors `parseUrl`'s scheme prefix so the fork matches the resolver exactly. */
+/**
+* Shape args toward the delegate's declared parameters: move the file path
+* between the `path`/`file_path` aliases according to which key the
+* delegate's schema actually declares (host-native read = `file_path`,
+* hashline = `path`). Unknown-key tolerant delegates are unaffected.
+*/
+function shapeArgsForDelegate(delegate, args, rawPath) {
+	const shaped = { ...args };
+	if (rawPath === "") {
+		delete shaped.path;
+		delete shaped.file_path;
+		return shaped;
+	}
+	const props = delegate.parameters?.properties;
+	if (props === void 0) return shaped;
+	const declaresPath = props["path"] !== void 0;
+	const declaresFilePath = props["file_path"] !== void 0;
+	if (declaresFilePath && !declaresPath) {
+		shaped.file_path = rawPath;
+		delete shaped.path;
+	} else if (declaresPath && !declaresFilePath) {
+		shaped.path = rawPath;
+		delete shaped.file_path;
+	} else {
+		shaped.path = rawPath;
+		shaped.file_path = rawPath;
+	}
+	return shaped;
+}
+const SCHEME_URL_RE = /^[a-z][a-z0-9]*:\/\//;
+/**
+* Build the scheme-aware `read` wrapper. The URL branch builds the resolver
+* env per call (agent + cwd + rawUrl); the scheme handlers read whichever
+* fields they need off it. File paths delegate to the terminal delegate so
+* the owning feature (hashline anchors or the native read) surfaces its own
+* result — never a silent reimplementation here.
+*/
+function createSchemeReadTool(deps) {
+	const { resolver, capturedRead } = deps;
+	return defineTool({
+		name: "read",
+		description: "Read a text file (each line returned as `HASH│content` with a 3-char hash anchor for later edit calls). File reads page with offset/limit. Also accepts resource URIs (skill://, agent://, dsh://, dvc://, ctx://, http(s)://).",
+		parameters: {
+			path: {
+				type: "string",
+				description: "File path, or a resource URI (skill://, agent://, dsh://, dvc://, ctx://, http(s)://)."
+			},
+			file_path: {
+				type: "string",
+				description: "Alias of `path` (accepted for host-native compatibility)."
+			},
+			offset: {
+				type: "number",
+				description: "Line number to start reading from (1-indexed, file reads only)"
+			},
+			limit: {
+				type: "number",
+				description: "Maximum number of lines to read (file reads only)"
+			}
+		},
+		output: {
+			schema: { type: "string" },
+			render: (_args, value) => [{
+				type: "text",
+				text: value
+			}]
+		},
+		async execute(args, exec) {
+			const rawPath = typeof args?.path === "string" ? args.path : typeof args?.file_path === "string" ? args.file_path : "";
+			if (resolver !== void 0 && SCHEME_URL_RE.test(rawPath)) {
+				const cwd = exec.agent?.session.header.cwd;
+				const env = cwd === void 0 ? {
+					agent: exec.agent,
+					rawUrl: rawPath
+				} : {
+					agent: exec.agent,
+					cwd,
+					rawUrl: rawPath
+				};
+				return resolver.resolve(env, rawPath);
+			}
+			if (capturedRead !== void 0 && capturedRead.execute !== void 0) {
+				const delegated = await capturedRead.execute(shapeArgsForDelegate(capturedRead, args, rawPath), exec);
+				if (typeof delegated === "string") return delegated;
+				return delegated === void 0 || delegated === null ? "" : JSON.stringify(delegated);
+			}
+			throw new UrlSchemesError("NATIVE_READ_UNAVAILABLE", "no read delegate is available: neither hashline nor the native read is in place");
+		}
+	});
+}
+
+//#endregion
+//#region src/url-schemes/tools/write.ts
+/**
+* Schemes the URL schema registers (v0.1.8d): the default write dispatch
+* keys off this table; the integration step can replace the whole
+* dispatch through `writeScheme` when it needs the live registry.
+*
+* Rendered from `catalog.ts` rather than written out here — this literal was
+* one of the hand-maintained copies that drifted from the scheme set.
+*/
+const REGISTERED_SCHEMES = SCHEME_NAMES;
+/** Detects a `scheme://` prefix with the resolver layer's own parser. */
+function isSchemeUrl(raw) {
+	try {
+		parseUrl(raw);
+		return true;
+	} catch (error) {
+		if (error instanceof UrlSchemesError && error.code === "URL_NO_SCHEME") return false;
+		throw error;
+	}
+}
+/**
+* Default scheme-write dispatch: `dvc://` routes through the device
+* registry (`dispatchDvcWrite`); every other write channel is rejected.
+*/
+async function defaultSchemeWrite(scheme, path$1, content, meta = {}) {
+	if (scheme === "dvc") {
+		const result = await dispatchDvcWrite(path$1, content, meta.session);
+		return {
+			path: `dvc://${path$1}`,
+			operation: "execute",
+			before: "",
+			after: JSON.stringify(result, null, 2)
+		};
+	}
+	if (scheme === "ctx") throw new UrlSchemesError("URL_READ_ONLY", `ctx:// is a curated read-only snapshot — write to ctx://${path$1} is not supported`);
+	if (REGISTERED_SCHEMES.includes(scheme)) throw new UrlSchemesError("URL_WRITE_UNSUPPORTED", `write to ${scheme}:// is not supported (read-only scheme, or its write channel is not wired yet)`);
+	throw new UrlSchemesError("URL_UNREGISTERED_SCHEME", `no handler registered for scheme "${scheme}" (registered: ${REGISTERED_SCHEMES.join(", ")})`);
+}
+/**
+* Build the `write` {@link ToolDefinition}: `scheme://` paths route to the
+* scheme write dispatch, ordinary paths delegate to the captured native
+* write definition with args and exec passed through untouched.
+*/
+function createWriteTool(deps) {
+	const { nativeWrite, postWrite, preWriteFormat, sandbox } = deps;
+	const writeScheme = deps.writeScheme ?? defaultSchemeWrite;
+	return defineTool({
+		name: "write",
+		description: "Create or fully replace a UTF-8 text file.",
+		parameters: {
+			file_path: {
+				type: "string",
+				required: true,
+				description: "Path to write, resolved by the filesystem backend."
+			},
+			content: {
+				type: "string",
+				required: true,
+				description: "Full UTF-8 text content to write."
+			},
+			...sandbox !== void 0 && sandbox.escalationModes.length > 0 ? sandbox.schemaFields() : {}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					path: {
+						type: "string",
+						required: true
+					},
+					operation: {
+						type: "string",
+						required: true,
+						enum: [
+							"create",
+							"update",
+							"execute"
+						]
+					},
+					before: {
+						required: true,
+						oneOf: [{ type: "string" }, { type: "null" }]
+					},
+					after: {
+						type: "string",
+						required: true
+					},
+					diagnostics: { type: "string" }
+				}
+			},
+			render: (_args, value) => {
+				const verb = value.operation === "update" ? "Updated" : value.operation === "execute" ? "Executed" : "Created";
+				let text = value.diagnostics === void 0 ? `${verb} ${value.path}` : `${verb} ${value.path}\n${value.diagnostics}`;
+				if (value.operation === "execute" && value.after !== void 0) text += `\n${value.after}`;
+				return [{
+					type: "text",
+					text
+				}];
+			}
+		},
+		async execute(args, exec) {
+			if (isSchemeUrl(args.file_path)) {
+				const parsed = parseUrl(args.file_path);
+				return writeScheme(parsed.scheme, parsed.path, args.content, { session: exec.agent?.id });
+			}
+			if (nativeWrite === void 0) throw new UrlSchemesError("NATIVE_WRITE_UNAVAILABLE", "the host did not deploy a native write tool — URL-aware write cannot delegate filesystem writes");
+			let content = args.content;
+			try {
+				const formatted = await preWriteFormat?.(args.file_path, content);
+				if (formatted !== void 0 && formatted !== content) content = formatted;
+			} catch {}
+			const writeArgs = content === args.content ? args : {
+				...args,
+				content
+			};
+			const outcome = await nativeWrite.execute(writeArgs, exec);
+			try {
+				const diagnostics = await postWrite?.(args.file_path, content);
+				if (diagnostics !== void 0) return {
+					...outcome,
+					diagnostics
+				};
+			} catch {}
+			return outcome;
+		}
+	});
+}
+
+//#endregion
+//#region src/hashline/constants.js
 const MAX_BYTES = 100 * 1024 * 1024;
 const MAX_READ_LINE_BYTES = 200 * 1024;
 const HASH_STORE_BUSY_TIMEOUT = 1e3;
@@ -5779,7 +5578,7 @@ const NOOP_LOOP_THRESHOLD = 3;
 const NEW_CONTENT_NOT_STRING_MSG = "[E_BAD_SHAPE] \"replacement_text\" must be a string with \\n line separators, not an array. Do not pass an array of lines — pass the replacement text as one string: \"line1\\nline2\". Use \"\" to delete a range.";
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/utils.js
+//#region src/hashline/utils.js
 function isRec(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -5832,7 +5631,7 @@ function clipLine(line, maxLen = 200) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/contract.js
+//#region src/hashline/contract.js
 const normalizedEdit = Symbol("normalizedEdit");
 function isNormalizedEdit(input) {
 	return isRec(input) && input[normalizedEdit] === true;
@@ -5923,7 +5722,7 @@ function assertUndoRequest(request) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/paths.js
+//#region src/hashline/paths.js
 /**
 * On-disk home for dsh-better-edit state: ONE centralized store per harness
 * home — `$DSH_HOME/storages/dsh-better-edit` (default
@@ -5940,11 +5739,11 @@ function hashStorePath() {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/fs-write.js
+//#region src/hashline/fs-write.js
 const STALE_TEMP_MS = 3600 * 1e3;
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/hashline/hash-assign.js
+//#region src/hashline/hashline/hash-assign.js
 let hasher = null;
 function getH() {
 	if (hasher) return hasher;
@@ -6158,7 +5957,7 @@ function mapStableHashes(oldContent, oldHashes, newContent, removedHashes) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/hash-store.js
+//#region src/hashline/hash-store.js
 function isValidHashList(value) {
 	if (!Array.isArray(value)) return false;
 	for (const hash of value) if (typeof hash !== "string" || !HASH_RE.test(hash)) return false;
@@ -6648,7 +6447,7 @@ async function upsertSnapshotFor(path$1, checksum, lineCount, hashes) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/hashline/hash.js
+//#region src/hashline/hashline/hash.js
 let defaultHashSnapshotIO;
 function snapshotIOFor(store) {
 	if (store) return {
@@ -6697,7 +6496,7 @@ async function lineHashes(content, path$1, previous, ioOrStore, persist) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/session-view.js
+//#region src/hashline/session-view.js
 const current = new AsyncLocalStorage();
 function withWorkspace(cwd, fn) {
 	return current.run(cwd, fn);
@@ -6918,7 +6717,7 @@ async function scanDrift(input) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/hashline/anchor-pipeline.js
+//#region src/hashline/hashline/anchor-pipeline.js
 function diagRef(ref) {
 	const trimmed = ref.trim();
 	if (!trimmed.length) return `[E_BAD_REF] Invalid anchor. Expected a 3-char alphanumeric anchor (e.g. "aB3").`;
@@ -7561,7 +7360,7 @@ function changedRange(original, result) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/edit-diff.js
+//#region src/hashline/edit-diff.js
 function detectEnding(content) {
 	const lfIdx = content.indexOf("\n");
 	if (lfIdx === -1) return content.indexOf("\r") >= 0 ? "\r" : "\n";
@@ -7676,7 +7475,7 @@ function genDiff(oldContent, newContent, contextLines = 2, newContentHashes, old
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/file-view.js
+//#region src/hashline/file-view.js
 const MAX_HASH_LINES$1 = HASH_SPACE;
 const DEFAULT_MAX_LINES = 2e3;
 const DEFAULT_MAX_BYTES = 50 * 1024;
@@ -7900,7 +7699,7 @@ async function readView(io, path$1, cwd, opts = {}) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/fs-bridge.js
+//#region src/hashline/fs-bridge.js
 /**
 * Map an `ctx.fs` failure onto the hashline model-facing vocabulary so the
 * model sees the same structured error codes as the pure pipeline.
@@ -7919,296 +7718,95 @@ function mapFsError(error, displayPath) {
 		if (code === "FS_ABORTED") throw new Error("Operation aborted");
 	}
 	throw error;
-}
-/** FileIO over the deployment's `ctx.fs` service. */
-function ctxFsIO(fs, ctx) {
-	return {
-		async resolve(path$1, cwd, signal) {
-			const target = await fs.resolve(path$1, {
-				...cwd !== void 0 ? { cwd } : {},
-				...signal !== void 0 ? { signal } : {}
-			});
-			return fs.processPath(target);
-		},
-		async readText(absolutePath, signal) {
-			try {
-				const target = await fs.resolve(absolutePath, { ...signal !== void 0 ? { signal } : {} });
-				return await fs.readText(target, signal);
-			} catch (error) {
-				return mapFsError(error, absolutePath);
-			}
-		},
-		async writeText(absolutePath, content, signal, exec, sandboxPolicy) {
-			try {
-				const target = await fs.resolve(absolutePath, { ...signal !== void 0 ? { signal } : {} });
-				const intent = await ctx.waterfall("fs/write-intent", target, exec, () => void 0);
-				const outcome = await fs.writeText(target, content, intent, signal, sandboxPolicy);
-				ctx.emit("fs/observed", target, {
-					kind: "present",
-					version: outcome.version
-				}, exec);
-			} catch (error) {
-				return mapFsError(error, absolutePath);
-			}
-		},
-		async emitObserved(absolutePath, exec, signal) {
-			try {
-				const target = await fs.resolve(absolutePath, { ...signal !== void 0 ? { signal } : {} });
-				const info = await fs.stat(target, signal);
-				if (info !== void 0) ctx.emit("fs/observed", target, {
-					kind: "present",
-					version: info.version
-				}, exec);
-			} catch (error) {
-				console.error(`dsh-better-edit: fs/observed emission failed for ${absolutePath}: ${error instanceof Error ? error.message : String(error)}`);
-			}
-		},
-		async statVersion(absolutePath, signal) {
-			try {
-				const target = await fs.resolve(absolutePath, { ...signal !== void 0 ? { signal } : {} });
-				return (await fs.stat(target, signal))?.version ?? void 0;
-			} catch {
-				return;
-			}
-		}
-	};
-}
-
-//#endregion
-//#region src/url-schemes/vendored/hashline/read-and-serve.js
-/** Appended when the file had non-UTF-8 bytes; editing rewrites it as UTF-8. */
-const UTF8_REWRITE_NOTE = "[Non-UTF-8 bytes shown as U+FFFD; editing rewrites the file as UTF-8.]";
-/**
-* Perform one read-and-serve: normalize the file at `rawPath`, render its
-* hashline preview, record the shown rows as served for the session, and clear
-* the reported-drift marks (a fresh read resets them). The returned text
-* carries the UTF-8 rewrite note when the file had decode errors.
-*
-* Emits nothing on the fs-observation gate — callers that need the
-* observation recorded (the `read` tool) do that themselves with their exec
-* context.
-*/
-async function readAndServe(io, rawPath, cwd, options) {
-	const { signal } = options;
-	abortIf(signal);
-	const view = await readView(io, rawPath, cwd, {
-		offset: options.offset,
-		limit: options.limit,
-		signal
-	});
-	if (view.served.length > 0) await recordServed(view.absolutePath, view.served, view.hashes.length);
-	await clearDriftReported(view.absolutePath);
-	return {
-		text: view.hadUtf8DecodeErrors ? `${view.text}\n\n${UTF8_REWRITE_NOTE}` : view.text,
-		served: view.served,
-		hadUtf8DecodeErrors: view.hadUtf8DecodeErrors,
-		absolutePath: view.absolutePath
-	};
-}
-
-//#endregion
-//#region src/url-schemes/tools/read.ts
-/** Mirrors `parseUrl`'s scheme prefix so the fork matches the resolver exactly. */
-const SCHEME_URL_RE = /^[a-z][a-z0-9]*:\/\//;
-/**
-* Build the URL-aware `read` tool.
-*
-* The URL branch builds the resolver env per call (agent + cwd + rawUrl); the
-* scheme handlers read whichever fields they need off it.
-*/
-function createReadTool(deps) {
-	const { resolver, fs, ctx, gates, capturedRead } = deps;
-	const io = ctxFsIO(fs, ctx);
-	return defineTool({
-		name: "read",
-		description: "Read a text file (each line returned as `HASH│content` with a 3-char hash anchor for later edit calls). File reads page with offset/limit.",
-		parameters: {
-			path: {
-				type: "string",
-				description: "File path (hashline-anchored read)."
-			},
-			offset: {
-				type: "number",
-				description: "Line number to start reading from (1-indexed, file reads only)"
-			},
-			limit: {
-				type: "number",
-				description: "Maximum number of lines to read (file reads only)"
-			}
-		},
-		output: {
-			schema: { type: "string" },
-			render: (_args, value) => [{
-				type: "text",
-				text: value
-			}]
-		},
-		async execute(args, exec) {
-			const canonical = normalizeRequest(args);
-			assertReadRequest(canonical);
-			const rawPath = canonical.path;
-			const isScheme = SCHEME_URL_RE.test(rawPath);
-			if (gates.urlSchemes && isScheme) {
-				const cwd = exec.agent?.session.header.cwd;
-				const env = cwd === void 0 ? {
-					agent: exec.agent,
-					rawUrl: rawPath
-				} : {
-					agent: exec.agent,
-					cwd,
-					rawUrl: rawPath
-				};
-				return resolver.resolve(env, rawPath);
-			}
-			if (gates.hashline && !isScheme) return withWorkspace(execCwd(exec), async () => {
-				const cwd = execCwd(exec);
-				const signal = exec.signal;
-				const { text, absolutePath } = await readAndServe(io, rawPath, cwd, {
-					signal,
-					offset: canonical.offset,
-					limit: canonical.limit
-				});
-				await io.emitObserved(absolutePath, exec, signal);
-				return text;
-			});
-			if (capturedRead !== void 0 && capturedRead.execute !== void 0) return capturedRead.execute(args, exec);
-			throw new UrlSchemesError("NATIVE_READ_UNAVAILABLE", "no read delegate is available: urlSchemes and hashline gates are both disabled");
-		}
-	});
-}
-
-//#endregion
-//#region src/url-schemes/tools/write.ts
-/**
-* Schemes the URL schema registers (v0.1.8d): the default write dispatch
-* keys off this table; the integration step can replace the whole
-* dispatch through `writeScheme` when it needs the live registry.
-*
-* Rendered from `catalog.ts` rather than written out here — this literal was
-* one of the hand-maintained copies that drifted from the scheme set.
-*/
-const REGISTERED_SCHEMES = SCHEME_NAMES;
-/** Detects a `scheme://` prefix with the resolver layer's own parser. */
-function isSchemeUrl(raw) {
-	try {
-		parseUrl(raw);
-		return true;
-	} catch (error) {
-		if (error instanceof UrlSchemesError && error.code === "URL_NO_SCHEME") return false;
-		throw error;
-	}
-}
-/**
-* Default scheme-write dispatch: `dvc://` routes through the device
-* registry (`dispatchDvcWrite`); every other write channel is rejected.
-*/
-async function defaultSchemeWrite(scheme, path$1, content) {
-	if (scheme === "dvc") {
-		const result = await dispatchDvcWrite(path$1, content);
-		return {
-			path: `dvc://${path$1}`,
-			operation: "execute",
-			before: "",
-			after: JSON.stringify(result, null, 2)
-		};
-	}
-	if (scheme === "ctx") throw new UrlSchemesError("URL_READ_ONLY", `ctx:// is a curated read-only snapshot — write to ctx://${path$1} is not supported`);
-	if (REGISTERED_SCHEMES.includes(scheme)) throw new UrlSchemesError("URL_WRITE_UNSUPPORTED", `write to ${scheme}:// is not supported (read-only scheme, or its write channel is not wired yet)`);
-	throw new UrlSchemesError("URL_UNREGISTERED_SCHEME", `no handler registered for scheme "${scheme}" (registered: ${REGISTERED_SCHEMES.join(", ")})`);
-}
-/**
-* Build the `write` {@link ToolDefinition}: `scheme://` paths route to the
-* scheme write dispatch, ordinary paths delegate to the captured native
-* write definition with args and exec passed through untouched.
-*/
-function createWriteTool(deps) {
-	const { nativeWrite, postWrite, preWriteFormat, sandbox } = deps;
-	const writeScheme = deps.writeScheme ?? defaultSchemeWrite;
-	return defineTool({
-		name: "write",
-		description: "Create or fully replace a UTF-8 text file.",
-		parameters: {
-			file_path: {
-				type: "string",
-				required: true,
-				description: "Path to write, resolved by the filesystem backend."
-			},
-			content: {
-				type: "string",
-				required: true,
-				description: "Full UTF-8 text content to write."
-			},
-			...sandbox !== void 0 && sandbox.escalationModes.length > 0 ? sandbox.schemaFields() : {}
-		},
-		output: {
-			schema: {
-				type: "object",
-				additionalProperties: false,
-				properties: {
-					path: {
-						type: "string",
-						required: true
-					},
-					operation: {
-						type: "string",
-						required: true,
-						enum: [
-							"create",
-							"update",
-							"execute"
-						]
-					},
-					before: {
-						required: true,
-						oneOf: [{ type: "string" }, { type: "null" }]
-					},
-					after: {
-						type: "string",
-						required: true
-					},
-					diagnostics: { type: "string" }
-				}
-			},
-			render: (_args, value) => {
-				const verb = value.operation === "update" ? "Updated" : value.operation === "execute" ? "Executed" : "Created";
-				let text = value.diagnostics === void 0 ? `${verb} ${value.path}` : `${verb} ${value.path}\n${value.diagnostics}`;
-				if (value.operation === "execute" && value.after !== void 0) text += `\n${value.after}`;
-				return [{
-					type: "text",
-					text
-				}];
+}
+/** FileIO over the deployment's `ctx.fs` service. */
+function ctxFsIO(fs, ctx) {
+	return {
+		async resolve(path$1, cwd, signal) {
+			const target = await fs.resolve(path$1, {
+				...cwd !== void 0 ? { cwd } : {},
+				...signal !== void 0 ? { signal } : {}
+			});
+			return fs.processPath(target);
+		},
+		async readText(absolutePath, signal) {
+			try {
+				const target = await fs.resolve(absolutePath, { ...signal !== void 0 ? { signal } : {} });
+				return await fs.readText(target, signal);
+			} catch (error) {
+				return mapFsError(error, absolutePath);
 			}
 		},
-		async execute(args, exec) {
-			if (isSchemeUrl(args.file_path)) {
-				const parsed = parseUrl(args.file_path);
-				return writeScheme(parsed.scheme, parsed.path, args.content, {});
+		async writeText(absolutePath, content, signal, exec, sandboxPolicy) {
+			try {
+				const target = await fs.resolve(absolutePath, { ...signal !== void 0 ? { signal } : {} });
+				const intent = await ctx.waterfall("fs/write-intent", target, exec, () => void 0);
+				const outcome = await fs.writeText(target, content, intent, signal, sandboxPolicy);
+				ctx.emit("fs/observed", target, {
+					kind: "present",
+					version: outcome.version
+				}, exec);
+			} catch (error) {
+				return mapFsError(error, absolutePath);
 			}
-			if (nativeWrite === void 0) throw new UrlSchemesError("NATIVE_WRITE_UNAVAILABLE", "the host did not deploy a native write tool — URL-aware write cannot delegate filesystem writes");
-			let content = args.content;
+		},
+		async emitObserved(absolutePath, exec, signal) {
 			try {
-				const formatted = await preWriteFormat?.(args.file_path, content);
-				if (formatted !== void 0 && formatted !== content) content = formatted;
-			} catch {}
-			const writeArgs = content === args.content ? args : {
-				...args,
-				content
-			};
-			const outcome = await nativeWrite.execute(writeArgs, exec);
+				const target = await fs.resolve(absolutePath, { ...signal !== void 0 ? { signal } : {} });
+				const info = await fs.stat(target, signal);
+				if (info !== void 0) ctx.emit("fs/observed", target, {
+					kind: "present",
+					version: info.version
+				}, exec);
+			} catch (error) {
+				console.error(`dsh-better-edit: fs/observed emission failed for ${absolutePath}: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		},
+		async statVersion(absolutePath, signal) {
 			try {
-				const diagnostics = await postWrite?.(args.file_path, content);
-				if (diagnostics !== void 0) return {
-					...outcome,
-					diagnostics
-				};
-			} catch {}
-			return outcome;
+				const target = await fs.resolve(absolutePath, { ...signal !== void 0 ? { signal } : {} });
+				return (await fs.stat(target, signal))?.version ?? void 0;
+			} catch {
+				return;
+			}
 		}
+	};
+}
+
+//#endregion
+//#region src/hashline/read-and-serve.js
+/** Appended when the file had non-UTF-8 bytes; editing rewrites it as UTF-8. */
+const UTF8_REWRITE_NOTE = "[Non-UTF-8 bytes shown as U+FFFD; editing rewrites the file as UTF-8.]";
+/**
+* Perform one read-and-serve: normalize the file at `rawPath`, render its
+* hashline preview, record the shown rows as served for the session, and clear
+* the reported-drift marks (a fresh read resets them). The returned text
+* carries the UTF-8 rewrite note when the file had decode errors.
+*
+* Emits nothing on the fs-observation gate — callers that need the
+* observation recorded (the `read` tool) do that themselves with their exec
+* context.
+*/
+async function readAndServe(io, rawPath, cwd, options) {
+	const { signal } = options;
+	abortIf(signal);
+	const view = await readView(io, rawPath, cwd, {
+		offset: options.offset,
+		limit: options.limit,
+		signal
 	});
+	if (view.served.length > 0) await recordServed(view.absolutePath, view.served, view.hashes.length);
+	await clearDriftReported(view.absolutePath);
+	return {
+		text: view.hadUtf8DecodeErrors ? `${view.text}\n\n${UTF8_REWRITE_NOTE}` : view.text,
+		served: view.served,
+		hadUtf8DecodeErrors: view.hadUtf8DecodeErrors,
+		absolutePath: view.absolutePath
+	};
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/sandbox.js
+//#region src/hashline/sandbox.js
 /**
 * The filesystem escalation API: advertisement gating, per-call policy
 * resolution, the one-approved wider retry, and denial-marker mapping. A pure
@@ -8294,7 +7892,7 @@ var FsSandboxController = class {
 };
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/undo-edit.js
+//#region src/hashline/undo-edit.js
 /** Load the last undo row for a path from the active store, if any. */
 async function readUndo(path$1) {
 	return (await loadHashStore()).getUndo(path$1);
@@ -8376,7 +7974,7 @@ async function clearUndo(path$1) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/noop-guard.js
+//#region src/hashline/noop-guard.js
 const noopLoopTracker = /* @__PURE__ */ new Map();
 function noopPayloadKey(absolutePath, removeFrom, removeTo, replacementText) {
 	return JSON.stringify([
@@ -8400,7 +7998,7 @@ function clearNoopLoop(absolutePath) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/edit-engine.js
+//#region src/hashline/edit-engine.js
 /** The hashes a range edit removes, for stable re-hash bookkeeping. */
 function collectRemovedHashes(edit, originalHashes) {
 	const removedHashes = /* @__PURE__ */ new Set();
@@ -8735,7 +8333,7 @@ async function persistUndoAndWrite(opts) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/edit-response.js
+//#region src/hashline/edit-response.js
 function buildMetrics(args) {
 	const metrics = {
 		edits_attempted: args.editsAttempted,
@@ -8826,7 +8424,7 @@ function buildBatchResult(sections) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/mutation.js
+//#region src/hashline/mutation.js
 /**
 * Deep seam: execute the full mutation lifecycle.
 *
@@ -8929,7 +8527,7 @@ async function commit(opts) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/prompts.js
+//#region src/hashline/prompts.js
 /**
 * Model-facing prompt text for the hashline tools, embedded so the bundle
 * ships no external prompt files. Each tool's schema `description` is short;
@@ -8964,7 +8562,7 @@ const UNDO_GUIDANCE = {
 };
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/tool-edit.js
+//#region src/hashline/tool-edit.js
 async function resolveNullPath(edits) {
 	if (edits.length === 0) return void 0;
 	const first = edits[0];
@@ -9064,7 +8662,7 @@ function registerEditTool(_rootCtx, agentCtx, io, sandbox) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/tool-undo.js
+//#region src/hashline/tool-undo.js
 /**
 * Register the `undo_last_edit` tool on the calling agent's scope.
 * @param _rootCtx - host context.
@@ -9164,7 +8762,7 @@ function registerUndoTool(_rootCtx, agentCtx, io, sandbox) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/guidance/parse.js
+//#region src/hashline/guidance/parse.js
 /**
 * Pure parser for per-preset guidance override files.
 *
@@ -9235,7 +8833,7 @@ function isBlankOverride(content) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/guidance/resolve.js
+//#region src/hashline/guidance/resolve.js
 /**
 * Render one tool's guidance as its intro line, a blank line, then bullets.
 * Uniform across the four sections: no tool-schema description is duplicated
@@ -9333,7 +8931,7 @@ async function composeSections(presetId, homeDir) {
 }
 
 //#endregion
-//#region src/url-schemes/vendored/hashline/guidance/materialize.js
+//#region src/hashline/guidance/materialize.js
 /** The presets shipped by the harness, each seeded with editable guidance. */
 const DEFAULT_PRESETS = [
 	"standard",
@@ -9508,6 +9106,138 @@ async function ensurePresetGuidance(homeDir) {
 	}));
 }
 
+//#endregion
+//#region src/hashline/install.ts
+/**
+* One-time process init: warm the hasher and materialize the editable
+* per-preset guidance overrides (idempotent; failures are noise, never a
+* failed boot).
+*/
+function initHashlineRuntime() {
+	initHasher().catch(() => {});
+	ensurePresetGuidance(configDir()).catch(() => {});
+}
+/**
+* The hashline `read` doer: every path is a filesystem path run through the
+* anchored read-and-serve pipeline (`HASH│content` anchors + served-row store
+* that the `edit` tool consumes). No scheme knowledge — scheme-aware wrapping
+* is the caller's business (composition root chains this under its wrapper;
+* standalone callers register it as `read` directly).
+*/
+function createHashlineReadTool(deps) {
+	const { io } = deps;
+	return defineTool({
+		name: "read",
+		description: "Read a text file (each line returned as `HASH│content` with a 3-char hash anchor for later edit calls). File reads page with offset/limit.",
+		parameters: {
+			path: {
+				type: "string",
+				description: "File path (hashline-anchored read)."
+			},
+			offset: {
+				type: "number",
+				description: "Line number to start reading from (1-indexed, file reads only)"
+			},
+			limit: {
+				type: "number",
+				description: "Maximum number of lines to read (file reads only)"
+			}
+		},
+		output: {
+			schema: { type: "string" },
+			render: (_args, value) => [{
+				type: "text",
+				text: value
+			}]
+		},
+		async execute(args, exec) {
+			const canonical = normalizeRequest(args);
+			assertReadRequest(canonical);
+			const rawPath = canonical.path;
+			return withWorkspace(execCwd(exec), async () => {
+				const cwd = execCwd(exec);
+				const signal = exec.signal;
+				const { text, absolutePath } = await readAndServe(io, rawPath, cwd, {
+					signal,
+					offset: canonical.offset,
+					limit: canonical.limit
+				});
+				await io.emitObserved(absolutePath, exec, signal);
+				return text;
+			});
+		}
+	});
+}
+/**
+* Register the hashline feature on one agent's own scope layer (async: the
+* `edit`/`undo` tools, the tool guidance sections (preset-aware, compiled
+* defaults on failure), and the lsp post-edit diagnostics hook. `read` is NOT
+* registered here — the caller owns the single `read` registration and should
+* register {@link createHashlineReadTool}'s output (directly or chained).
+*/
+async function installHashline(rootCtx, agent, opts = {}) {
+	const disposers = [];
+	const sandbox = opts.sandbox ?? new FsSandboxController(rootCtx);
+	const io = ctxFsIO(rootCtx.fs, rootCtx);
+	const readTool = createHashlineReadTool({ io });
+	disposers.push(registerEditTool(rootCtx, agent.ctx, io, sandbox));
+	disposers.push(registerUndoTool(rootCtx, agent.ctx, io, sandbox));
+	const diagnosticsHook = opts.editFeedback;
+	if (diagnosticsHook !== void 0) disposers.push(agent.ctx.on("tools/post-execute", async (exec, result, next) => {
+		const decision = await next();
+		if (exec.name !== "edit" || result.isError) return decision;
+		const rawPath = exec.arguments?.path;
+		if (typeof rawPath !== "string" || rawPath === "") return decision;
+		try {
+			const content = await io.readText(rawPath, exec.signal);
+			if (typeof content !== "string") return decision;
+			const summary = await diagnosticsHook(rawPath, content);
+			if (summary === void 0) return decision;
+			const decisionRecord = decision;
+			if (decisionRecord.kind !== "accept") return decision;
+			decisionRecord.content = [...decisionRecord.content ?? result.content ?? [], {
+				type: "text",
+				text: `\n${summary}`
+			}];
+			return decision;
+		} catch {
+			return decision;
+		}
+	}));
+	try {
+		const agentPresets = rootCtx.get("agentPresets");
+		let sections = GUIDANCE_SECTIONS.map((section) => ({
+			name: section.name,
+			order: section.defaultOrder,
+			text: section.renderDefault()
+		}));
+		if (agentPresets !== void 0) try {
+			sections = (await composeSections(agentPresets.composedPreset(agent.ctx), configDir())).map((section) => ({
+				name: section.name,
+				order: section.order,
+				text: section.text
+			}));
+		} catch {}
+		for (const section of sections) disposers.push(agent.ctx.systemPrompt.section(section));
+	} catch {}
+	return {
+		disposers,
+		io,
+		sandbox,
+		readTool
+	};
+}
+
+//#endregion
+//#region src/url-schemes/gates.ts
+/** Every key defaults on — the service is opt-out, not opt-in. */
+function resolveGates(config) {
+	return {
+		urlSchemes: config?.urlSchemes !== false,
+		hashline: config?.hashline !== false
+	};
+}
+
 //#endregion
 //#region src/url-schemes/index.ts
 /** Cordis plugin name. */
@@ -9529,13 +9259,6 @@ const inject$1 = [
 	"agents",
 	"sessionPersistence"
 ];
-/** Every key defaults on — the service is opt-out, not opt-in. */
-function resolveGates(config) {
-	return {
-		urlSchemes: config?.urlSchemes !== false,
-		hashline: config?.hashline !== false
-	};
-}
 /** Register the four URL-aware tools on one agent's own scope layer. */
 /**
 * The lsp feedback loop (native-tools Wave3): both hooks route through the
@@ -9588,71 +9311,39 @@ function buildLspWriteFeedback() {
 		postWrite: (filePath, content) => lspFeedback("diagnostics", filePath, content)
 	};
 }
-function installAgentTools(rootCtx, agent, resolver, gates) {
+async function installAgentTools(rootCtx, agent, resolver, gates$1) {
 	agent.ctx.effect(async () => {
 		const native = captureNativeTools(rootCtx, agent);
 		const disposers = [];
 		const hashlineSandbox = new FsSandboxController(rootCtx);
-		const hashlineIo = ctxFsIO(rootCtx.fs, rootCtx);
-		if (gates.hashline) disposers.push(agent.ctx.tools.register(createReadTool({
-			resolver,
-			fs: rootCtx.fs,
-			ctx: rootCtx,
-			gates,
-			capturedRead: native.read
-		})));
-		if (gates.urlSchemes) disposers.push(agent.ctx.tools.register(createWriteTool({
+		let readDelegate = native.read;
+		if (gates$1.hashline) {
+			const hashline = await installHashline(rootCtx, agent, {
+				sandbox: hashlineSandbox,
+				editFeedback: buildLspWriteFeedback().postWrite
+			});
+			disposers.push(...hashline.disposers);
+			readDelegate = hashline.readTool;
+		}
+		if (gates$1.urlSchemes || gates$1.hashline) {
+			const readTool = gates$1.urlSchemes && readDelegate !== void 0 ? createSchemeReadTool({
+				resolver,
+				capturedRead: readDelegate
+			}) : readDelegate;
+			if (readTool !== void 0) disposers.push(agent.ctx.tools.register(readTool));
+		}
+		if (gates$1.urlSchemes) disposers.push(agent.ctx.tools.register(createWriteTool({
 			nativeWrite: native.write,
 			sandbox: hashlineSandbox,
 			...buildLspWriteFeedback()
 		})));
-		if (gates.hashline) {
-			disposers.push(registerEditTool(rootCtx, agent.ctx, hashlineIo, hashlineSandbox));
-			disposers.push(registerUndoTool(rootCtx, agent.ctx, hashlineIo, hashlineSandbox));
-		}
-		if (gates.hashline) {
-			const diagnosticsHook = buildLspWriteFeedback().postWrite;
-			disposers.push(agent.ctx.on("tools/post-execute", async (exec, result, next) => {
-				const decision = await next();
-				if (exec.name !== "edit" || result.isError) return decision;
-				const rawPath = exec.arguments?.path;
-				if (typeof rawPath !== "string" || rawPath === "") return decision;
-				try {
-					const content = await hashlineIo.readText(rawPath, exec.signal);
-					if (typeof content !== "string") return decision;
-					const summary = await diagnosticsHook(rawPath, content);
-					if (summary === void 0) return decision;
-					const decisionRecord = decision;
-					if (decisionRecord.kind !== "accept") return decision;
-					decisionRecord.content = [...decisionRecord.content ?? result.content ?? [], {
-						type: "text",
-						text: `\n${summary}`
-					}];
-					return decision;
-				} catch {
-					return decision;
-				}
-			}));
-		}
 		try {
-			const agentPresets = rootCtx.get("agentPresets");
-			let sections = GUIDANCE_SECTIONS.map((section) => ({
-				name: section.name,
-				order: section.defaultOrder,
-				text: section.renderDefault()
-			}));
-			if (agentPresets !== void 0) try {
-				sections = (await composeSections(agentPresets.composedPreset(agent.ctx), configDir())).map((section) => ({
-					name: section.name,
-					order: section.order,
-					text: section.text
-				}));
-			} catch {}
-			for (const section of sections) disposers.push(agent.ctx.systemPrompt.section(section));
-			const general = generalSection(gates);
-			if (general !== void 0) disposers.push(agent.ctx.systemPrompt.section(general));
+			if (gates$1.urlSchemes) {
+				const general = generalSection(gates$1);
+				if (general !== void 0) disposers.push(agent.ctx.systemPrompt.section(general));
+			}
 		} catch {}
-		if (gates.urlSchemes) {
+		if (gates$1.urlSchemes) {
 			disposers.push(agent.ctx.tools.register(createGrepTool({
 				resolver,
 				nativeGrep: native.grep
@@ -9662,6 +9353,31 @@ function installAgentTools(rootCtx, agent, resolver, gates) {
 				nativeGlob: native.glob
 			})));
 		}
+		const sessionId = agent.id;
+		disposers.push(agent.ctx.on("tools/post-execute", async (exec, result, next) => {
+			const decision = await next();
+			const name$2 = exec.name;
+			if (name$2 !== "read" && name$2 !== "edit" && name$2 !== "write") return decision;
+			const args = exec.arguments;
+			const filePath = args?.path ?? args?.file_path;
+			if (typeof filePath !== "string" || filePath === "") return decision;
+			if (name$2 === "read") {
+				lspGateSyncOnLand(sessionId, "read", filePath);
+				return decision;
+			}
+			lspGateSyncOnLand(sessionId, name$2, filePath);
+			if (result.isError) return decision;
+			const notice = lspGateNotice(sessionId, filePath);
+			if (notice === void 0) return decision;
+			const record = decision;
+			if (record.kind !== "accept") return decision;
+			record.content = [...record.content ?? result.content ?? [], {
+				type: "text",
+				text: `\n${notice}`
+			}];
+			return decision;
+		}));
+		disposers.push(() => disposeLspGate(sessionId));
 		return () => {
 			for (const dispose of disposers) dispose();
 		};
@@ -9669,8 +9385,7 @@ function installAgentTools(rootCtx, agent, resolver, gates) {
 }
 /** Mount the resolver + scheme handlers, then install the tools per agent. */
 function apply$1(ctx, config) {
-	initHasher().catch(() => {});
-	ensurePresetGuidance(configDir()).catch(() => {});
+	initHashlineRuntime();
 	const resolver = new UrlResolver();
 	if (resolveGates(config).urlSchemes && ctx.fs) try {
 		wrapFsWithSchemes(ctx.fs, { settings: ctx.settings });
@@ -9702,11 +9417,9 @@ function apply$1(ctx, config) {
 	ctx.on("agent/session-start", ({ agent }) => {
 		if (registered.has(agent)) return;
 		registered.add(agent);
-		try {
-			installAgentTools(ctx, agent, resolver, resolveGates(config));
-		} catch (error) {
+		installAgentTools(ctx, agent, resolver, resolveGates(config)).catch((error) => {
 			ctx.logger("dsh-url-schemes").warn(`failed to install URL-aware tools for agent ${agent.id}: ${error instanceof Error ? error.message : String(error)}`);
-		}
+		});
 	});
 }
 var url_schemes_default = {
@@ -10400,7 +10113,7 @@ function splitRoute(route) {
 //#endregion
 //#region src/failover/index.ts
 /** The `failover` settings schema: two optional fallback slots, both default "not set". */
-const Config$1 = z.object({
+const Config$2 = z.object({
 	fallback1: z.string().default(""),
 	fallback2: z.string().default("")
 });
@@ -10416,9 +10129,9 @@ function overrideConfig(seed, to) {
 /** Install the failover. A no-op composition degrades gracefully (empty chain = pass-through). */
 function installFailover(ctx, config = defaultFailoverConfig) {
 	const logger = ctx.logger("llm-failover");
-	let source = () => Config$1(config);
+	let source = () => Config$2(config);
 	ctx.inject(["settings"], (sctx) => {
-		sctx.settings.installSection(ctx, FAILOVER_SETTINGS_NS, Config$1, Config$1(config), {
+		sctx.settings.installSection(ctx, FAILOVER_SETTINGS_NS, Config$2, Config$2(config), {
 			setSource: (current$1) => {
 				source = current$1;
 			},
@@ -10472,6 +10185,143 @@ function installFailover(ctx, config = defaultFailoverConfig) {
 	});
 }
 
+//#endregion
+//#region src/compaction/config.ts
+/**
+* The `compaction-tuning` General-row config: the share of the routed context
+* window at which automatic condensation starts.
+*
+* Pure module — no `@deepseek-ai/*` value imports — so the host half and the
+* client half may both import it without dragging either runtime into the
+* browser bundle: the host takes the namespace and the schema defaults, the
+* client takes the namespace literal plus the stepper bounds.
+*
+* @module dashr/compaction/config
+*/
+/** The settings namespace the General row reads and writes. */
+const COMPACTION_SETTINGS_NS = "compaction-tuning";
+/** Upstream `compaction-basic`'s own default: condense at 80% of the window. */
+const DEFAULT_THRESHOLD_RATIO = .8;
+/**
+* Absolute recent-tail budget, in estimated tokens (~50 KB of English text).
+*
+* Composition-only, deliberately: the General row drives `thresholdRatio`
+* alone, so the recency window stays a deployment decision (its base layer is
+* the row config in `cordis.patch.yml`) rather than a second knob on the
+* settings page. The host half still applies it to the engine.
+*/
+const DEFAULT_RETAIN_TOKENS = 5e4;
+/** Ratio bounds the settings schema accepts (a config file may use either end). */
+const THRESHOLD_MIN_RATIO = .05;
+/** @see THRESHOLD_MIN_RATIO */
+const THRESHOLD_MAX_RATIO = 1;
+/** Spec defaults — `Config({})` must equal this. */
+const defaultCompactionTuningConfig = {
+	thresholdRatio: DEFAULT_THRESHOLD_RATIO,
+	retainTokens: DEFAULT_RETAIN_TOKENS
+};
+
+//#endregion
+//#region src/compaction/index.ts
+/**
+* The `compaction-tuning` settings schema.
+*
+* `thresholdRatio` is the field the General row drives; `retainTokens` is
+* composition-only (see {@link DEFAULT_RETAIN_TOKENS}) but still validated and
+* applied, so the recency window keeps one source of truth.
+*/
+const Config$1 = z.object({
+	thresholdRatio: z.number().step(.01).min(THRESHOLD_MIN_RATIO).max(THRESHOLD_MAX_RATIO).default(DEFAULT_THRESHOLD_RATIO),
+	retainTokens: z.number().step(1).min(0).default(DEFAULT_RETAIN_TOKENS)
+});
+/**
+* Install the settings namespace and keep the live compaction engine in sync.
+* @param ctx - host context of the row that owns this capability.
+* @param config - composition base layer; schema defaults fill the rest.
+*/
+function installCompactionTuning(ctx, config = defaultCompactionTuningConfig) {
+	const logger = ctx.logger("compaction-tuning");
+	let source = () => Config$1(config);
+	/** Smallest routed context window seen so far (advisory guard, best effort). */
+	let minWindow;
+	let probing = false;
+	/**
+	* Learn the routed context windows so a write can be refused when it would
+	* leave `retainTokens >= floor(window x thresholdRatio)` — the condition
+	* under which the engine raises `TargetPressureConfigError` per route and
+	* automatic condensation quietly stops for that route.
+	*/
+	const probeWindows = () => {
+		if (probing || minWindow !== void 0) return;
+		const llm = ctx.get("llm");
+		if (llm === void 0) return;
+		probing = true;
+		(async () => {
+			try {
+				let smallest;
+				for (const provider of llm.listProviders()) for (const model of await llm.listModels(provider.id)) {
+					const window = (await llm.resolveModelInfo(provider.id, model.id)).context?.contextWindow;
+					if (typeof window !== "number" || window <= 0) continue;
+					smallest = smallest === void 0 ? window : Math.min(smallest, window);
+				}
+				if (smallest !== void 0) {
+					minWindow = smallest;
+					logger.info(`smallest routed context window: ${smallest} tokens`);
+				}
+			} catch (error) {
+				logger.warn(`context-window probe failed (retention guard disabled): ${error instanceof Error ? error.message : String(error)}`);
+			} finally {
+				probing = false;
+			}
+		})();
+	};
+	/**
+	* Overwrite only this module's two fields on the engine's current policy and
+	* hand the engine a fresh frozen object.
+	* @param reason - short diagnostic tag for the log line.
+	*/
+	const push = (reason) => {
+		const compaction = ctx.get("compaction");
+		if (compaction === void 0) return;
+		const base = compaction.config;
+		if (base === void 0) return;
+		const value = source();
+		const next = {
+			...base,
+			thresholdRatio: value.thresholdRatio,
+			retainTokens: value.retainTokens
+		};
+		delete next.retainRatio;
+		compaction.config = Object.freeze(next);
+		logger.info(`applied (${reason}): thresholdRatio=${value.thresholdRatio} retainTokens=${value.retainTokens}`);
+	};
+	ctx.inject(["compaction"], () => {
+		push("compaction-ready");
+		probeWindows();
+	});
+	ctx.inject(["settings"], (settingsCtx) => {
+		if (settingsCtx.settings.get(COMPACTION_SETTINGS_NS) !== void 0) {
+			logger.info("settings namespace already served; leaving it to its owner");
+			return;
+		}
+		settingsCtx.settings.installSection(ctx, COMPACTION_SETTINGS_NS, Config$1, Config$1(config), {
+			setSource: (current$1) => {
+				source = current$1;
+			},
+			onChange: () => {
+				push("settings-updated");
+			},
+			validate: (value) => {
+				if (minWindow === void 0) return;
+				const thresholdTokens = Math.floor(minWindow * value.thresholdRatio);
+				if (value.retainTokens >= thresholdTokens) throw new Error(`retainTokens (${value.retainTokens}) must stay below the threshold tokens for every routed model; the smallest window here is ${minWindow}, so ${value.thresholdRatio} leaves only ${thresholdTokens}`);
+			}
+		});
+		push("settings-installed");
+		probeWindows();
+	});
+}
+
 //#endregion
 //#region src/mobile/zoom-guard.ts
 /**
@@ -11391,6 +11241,7 @@ function apply(ctx, config) {
 	ctx.plugin(DashrRuntime, pickRuntimeConfig(config));
 	ctx.plugin(url_schemes_default, config);
 	installFailover(ctx);
+	installCompactionTuning(ctx);
 	installWebTrust(ctx, config);
 	const logger = ctx.logger("dashr-repl");
 	const maxParallel = resolveMaxParallelSubCalls(config.maxParallelSubCalls);