@thincoder/core 0.9.1

package/tools/glob-dialect.mjs

@@ -0,0 +1,130 @@
+/**
+ * glob-dialect.mjs — glob 方言（TOOLS.md §17 — 2026-09-06）单一权威模块（CLI）。
+ *
+ * `{a,b}` brace expansion is handled BEFORE the sentinel/escape flow (braces must
+ * not be literal-escaped — a bare "star-star slash star .{js,txt}" pattern
+ * previously escaped to a literal that silently matched nothing). Unsupported
+ * extglob dialects (`?(x)`/`@(a|b)`/`+(x)`/`*(x)`/`!(x)`) and malformed braces
+ * (empty `{}`, unclosed `{`, nested `{a,{b,c}}`) are EXPLICIT errors — never a
+ * silent no-match. Exclude prefixes (`!pattern`) are the CALLER's job: the
+ * glob/grep tools whitespace-split the pattern expression (splitGlobPatterns —
+ * never inside a brace group) and pass the parts to compileGlobMatchers, which
+ * intersects includes and excludes.
+ *
+ * Extracted from shared.mjs (2026-09-06 advisor #5 — shared.mjs exceeded the
+ * 500-line cap after §17); shared.mjs re-exports these symbols so all existing
+ * importers (system.mjs / ls filter / tests) keep their import paths.
+ */
+
+const BRACE_OPEN = "\u0003", BRACE_SEP = "\u0004", BRACE_CLOSE = "\u0005"
+const EXT_GLOB_RE = /[@?+*!]\(/
+
+export const GLOB_EXTGLOB_ERROR =
+  "glob syntax error: unsupported extglob syntax — ?(x)/@(a|b)/+(x)/*(x)/!(x) are not supported; use {a,b} brace expansion or multiple space-separated patterns instead"
+export const GLOB_EMPTY_BRACE_ERROR =
+  'glob syntax error: empty brace group "{}" — put at least one alternative between the braces (e.g. {js,txt})'
+export const GLOB_UNCLOSED_BRACE_ERROR =
+  'glob syntax error: unclosed brace group — add a matching "}" (e.g. {js,txt})'
+export const GLOB_NESTED_BRACE_ERROR =
+  "glob syntax error: nested brace groups are not supported (e.g. {a,{b,c}}) — use a flat alternative list (e.g. {a,b,c})"
+
+function assertNoExtglob(pattern) {
+  if (EXT_GLOB_RE.test(pattern)) throw new Error(GLOB_EXTGLOB_ERROR)
+}
+
+/** Replace every {a,b,c} group with placeholder alternation markers. Runs BEFORE
+ *  the sentinel/escape flow so the inserted alternation survives literal escaping. */
+function expandBraces(pattern) {
+  for (;;) {
+    const open = pattern.indexOf("{")
+    if (open === -1) return pattern
+    let close = -1
+    for (let j = open + 1; j < pattern.length; j++) {
+      if (pattern[j] === "{") throw new Error(GLOB_NESTED_BRACE_ERROR)
+      if (pattern[j] === "}") { close = j; break }
+    }
+    if (close === -1) throw new Error(GLOB_UNCLOSED_BRACE_ERROR)
+    const inner = pattern.slice(open + 1, close)
+    if (inner === "") throw new Error(GLOB_EMPTY_BRACE_ERROR)
+    const alts = inner.split(",").map((a) => a.trim())
+    pattern = pattern.slice(0, open) + BRACE_OPEN + alts.join(BRACE_SEP) + BRACE_CLOSE + pattern.slice(close + 1)
+  }
+}
+
+/** Convert a single glob pattern to a RegExp (anchored full match). Supports the
+ *  recursive "star-star" forms, single-star, "?", "[..]" character classes and
+ *  {a,b} brace expansion. Malformed braces and unsupported extglob syntax throw
+ *  explicit errors (no silent mismatch). */
+export function globToRegex(pattern) {
+  pattern = String(pattern)
+  assertNoExtglob(pattern)
+  pattern = expandBraces(pattern)
+  // Sentinel chars: \u0001/\u0002 never appear in real glob patterns (they
+  // come from model output or the filesystem) — safe as **/ and ** placeholders.
+  const DS = "\u0001", DP = "\u0002"
+  const escaped = pattern
+    .replace(/\*\*\//g, DS).replace(/\*\*/g, DP)
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]")
+    .replace(new RegExp(DS, "g"), "(?:.+/)?")
+    .replace(new RegExp(DP, "g"), ".*")
+    .replace(new RegExp(BRACE_OPEN, "g"), "(?:")
+    .replace(new RegExp(BRACE_SEP, "g"), "|")
+    .replace(new RegExp(BRACE_CLOSE, "g"), ")")
+  return new RegExp(`^${escaped}$`)
+}
+
+/** Whitespace-split a glob expression into parts WITHOUT splitting inside {a,b}
+ *  brace groups and WITHOUT splitting literal spaces inside a single pattern
+ *  (2026-09-06 audit F1 / advisor #4): a whitespace run is a pattern separator
+ *  ONLY when the next non-space token starts an exclusion ("!" — the §17
+ *  "include !exclude" form). So a BARE pattern like "docs/my file/*.md" and an
+ *  exclude like "!docs/my file/**" each stay ONE part; the standard
+ *  "js-pattern 空格 !test-pattern" form still splits into its two parts. */
+export function splitGlobPatterns(expr) {
+  const s = String(expr ?? "").trim()
+  if (!s) return []
+  const parts = []
+  let depth = 0
+  let cur = ""
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i]
+    if (ch === "{") depth++
+    else if (ch === "}") depth = Math.max(0, depth - 1)
+    if (/\s/.test(ch) && depth === 0) {
+      let j = i
+      while (j < s.length && /\s/.test(s[j])) j++
+      if (s[j] === "!") {
+        if (cur) { parts.push(cur); cur = "" }
+        i = j - 1 // next loop iteration continues at the "!"
+        continue
+      }
+      // literal space inside a pattern (or trailing) — keep it in the current part
+      cur += ch
+      continue
+    }
+    cur += ch
+  }
+  if (cur) parts.push(cur)
+  return parts
+}
+
+/** Compile whitespace-split pattern parts (see splitGlobPatterns) into a matcher:
+ *  non-"!" parts are includes, leading-"!" parts are excludes — a rel path matches
+ *  when it matches ≥1 include (or there are no includes) and no exclude. Every
+ *  part runs the full brace/error dialect through globToRegex (excludes too). */
+export function compileGlobMatchers(parts) {
+  const includes = []
+  const excludes = []
+  for (const p of parts) {
+    const part = String(p)
+    if (part.startsWith("!")) excludes.push(part.slice(1))
+    else if (part !== "") includes.push(part)
+  }
+  const include = includes.map((p) => globToRegex(p))
+  const exclude = excludes.map((p) => globToRegex(p))
+  const test = (relPath) =>
+    (include.length === 0 || include.some((re) => re.test(relPath))) &&
+    !exclude.some((re) => re.test(relPath))
+  return { include, exclude, test }
+}

package/tools/index.mjs

@@ -0,0 +1,76 @@
+// tools/index.mjs — backend-compatible re-export
+export { toOpenAISchema } from "./shared.mjs";
+
+import { readTool, writeTool, editTool, insertAfterTool, hashlineEditTool, readImageTool } from "./file.mjs";
+import { applyPatchTool, deleteTool } from "./patch.mjs";
+import { bashTool } from "./bash.mjs";
+import { globTool, grepTool, lsTool } from "./search.mjs";
+import { websearchTool, fetchTool } from "./web.mjs";
+import { gitTool } from "./git.mjs";
+import { questionTool } from "./question.mjs";
+import { lintTool } from "./linter.mjs";
+import { lspTool } from "./lsp.mjs";
+import { executeTool } from "./execute.mjs";
+import { fileOpsTool, processTool, getCurrentTimeTool, waitForTool } from "./ops.mjs";
+import { treeTool } from "./tree.mjs";
+
+// Instance-independent built-in table. `read_image` is deliberately NOT here:
+// its registration is capability-gated per model — see `assembleBuiltinTools`.
+export const builtinTools = [
+  readTool, writeTool, editTool, insertAfterTool, hashlineEditTool, applyPatchTool,
+  bashTool, globTool, grepTool,
+  websearchTool, lsTool, fetchTool, deleteTool,
+  gitTool, questionTool,
+  lintTool, lspTool, executeTool,
+  fileOpsTool, processTool, getCurrentTimeTool, waitForTool,
+  treeTool,
+];
+
+export {
+  readTool, writeTool, editTool, insertAfterTool, hashlineEditTool, applyPatchTool,
+  readImageTool, bashTool, globTool, grepTool,
+  websearchTool, lsTool, fetchTool, deleteTool,
+  gitTool, questionTool,
+  lintTool, lspTool, executeTool,
+  fileOpsTool, processTool, getCurrentTimeTool, waitForTool,
+  treeTool,
+};
+
+// ── Full built-in registry (CORE-UNIFICATION TOOLS #70) ─────────────────────
+// The registry owns the COMPLETE built-in tool face for both shells. The VS Code
+// index registers the full table in one place; the CLI splits it between this
+// index and its consumer assembly (`cli/make-agent.mjs`). That consumer assembly
+// face moves here (`assembleBuiltinTools`) so both shells consume one registry:
+// `builtinTools` = the instance-independent static table, plus the instance-bound
+// faces (memory / code+doc search / repo outline / settings / peer instances)
+// whose factories need the shell's memory handle at run time.
+//
+// Host-only tools (VS Code `context` / `focus` — TOOLS #179 ④, IDE capabilities)
+// are NOT part of the core registry: the VS Code shell adds them itself.
+//
+// `read_image` registration follows VS Code (#70): it is registered only when the
+// model accepts image input (`specForModel(model).multimodal`) — the conservative
+// default spec carries no `multimodal`, so an unknown or absent model does NOT get
+// it. The runtime gate in `tools/file.mjs` stays as a second line of defence.
+export async function assembleBuiltinTools({ memory, cwd, projectDir = null, author = "unknown", team = null, model = null } = {}) {
+  const { specForModel } = await import("../model-specs.mjs");
+  const { memoryTools, codeSearchTool, docSearchTool } = await import("../memory.mjs");
+  const { repoOutlineTool } = await import("./repomap.mjs");
+  const { settingsTool } = await import("../agent-tools/settings.mjs");
+  const { peerInstancesTool } = await import("../peer-instances.mjs");
+  const { ledgerQueryTool, ledgerCountTool } = await import("../ledger.mjs"); // 动态 import（ledger 链静态达 node:sqlite——W8 契约②）
+  const imageOk = Boolean(specForModel(model)?.multimodal);
+  return [
+    ...builtinTools,
+    ...(imageOk ? [readImageTool] : []),
+    ...memoryTools(memory, { cwd, projectDir, author, team }),
+    codeSearchTool(memory),
+    docSearchTool(memory),
+    repoOutlineTool(memory.db, cwd),
+    settingsTool(),
+    peerInstancesTool,
+    // 台账查询命令族（M2 设计 §2.2 命令面接线——查询命令全角色面；写命令住 family-tools depthOnly 分支）
+    ledgerQueryTool,
+    ledgerCountTool,
+  ];
+}

package/tools/linter.mjs

@@ -0,0 +1,120 @@
+import { DESC, resolveInCwd } from "./shared.mjs"
+// #61（可中断执行按端注入——CORE-UNIFICATION §2.13.4）：检查器执行全部经核内执行面单点
+// `runCommand`（默认径 = execFileSync，CLI 语义零行为变；端侧 injected ⇒ 可中断执行器）。
+import { runCommand } from "./exec-run.mjs"
+import { existsSync } from "node:fs"
+import { join } from "node:path"
+
+export const lintTool = {
+  name: "lint",
+  description: DESC("lint"),
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "File to check (default: most recently modified file)" },
+      full: { type: "boolean", description: "Run the full language-aware cascade instead of just node --check (default false)" },
+    },
+    required: [],
+  },
+  readonly: true,
+  async execute(args, ctx) {
+    const abs = args.path
+      ? resolveInCwd(ctx, args.path)
+      : (ctx.agent?._touchedFiles?.at(-1) || null)
+    if (!abs) return "lint: no file specified and no recently modified file to check"
+
+    if (!args.full) {
+      // Fast path: node --check only
+      return nodeCheckResult(abs, ctx.signal)
+    }
+
+    // Full cascade: language-aware (tsc → node --check, ruff, cargo, go vet —
+    // third-party linter cascade removed 2026-09-02, TOOLS.md §10.2: zero-dependency lint)
+    const ext = abs.split(".").pop()?.toLowerCase()
+    const checkers = LANG_CHECKERS[ext]
+    if (!checkers) return nodeCheckResult(abs, ctx.signal) // fall back to node --check
+
+    for (const checker of checkers) {
+      const result = await checker(abs, { cwd: ctx.cwd, signal: ctx.signal, existsSync, join, run: runCommand })
+      if (result !== null) return result
+    }
+    return `lint: no linter available for ${abs}. Install one?`
+  },
+}
+
+async function nodeCheckResult(abs, signal) {
+  if (!/\.(?:m?js|cjs|m?ts|cts|jsx|tsx)$/.test(abs)) {
+    return `lint (check): only JS/TS-family files supported for fast syntax check; use full=true for other languages. Path: ${abs}`
+  }
+  try {
+    await runCommand(process.execPath, ["--check", abs], { timeout: 10000, signal })
+    return `Syntax OK: ${abs}`
+  } catch (e) {
+    const msg = (e.stderr || e.stdout || e.message || "").trim()
+    return `Syntax error in ${abs}:\n${msg || "(unknown)"}`
+  }
+}
+
+// ─── Full-check cascade checkers (third-party linter branch removed 2026-09-02, TOOLS.md §10.2) ──────
+
+async function tscCheck(file, { cwd, signal, existsSync, join, run }) {
+  if (!existsSync(join(cwd, "tsconfig.json"))) return null
+  if (!/\.(ts|tsx|mts|cts)$/.test(file)) return null
+  try {
+    await run("npx", ["tsc", "--noEmit", "--pretty", "false"], { cwd, timeout: 60000, signal })
+    return "✓ tsc: no type errors"
+  } catch (e) {
+    const stdout = (e.stdout || "").trim()
+    if (stdout) return stdout
+    return `✗ tsc: ${(e.stderr || e.message).slice(0, 500)}`
+  }
+}
+
+async function ruffCheck(file, { cwd, signal, run }) {
+  if (!/\.py$/.test(file)) return null
+  try {
+    await run("ruff", ["check", "--output-format", "concise", file], { cwd, timeout: 30000, signal })
+    return "✓ ruff: no issues"
+  } catch (e) {
+    if (e.code === "ENOENT") return "lint: ruff not installed. Run: pip install ruff"
+    const stdout = (e.stdout || "").trim()
+    if (stdout) return stdout
+    return `✗ ruff: ${(e.stderr || e.message).slice(0, 500)}`
+  }
+}
+
+async function cargoCheck(file, { cwd, signal, existsSync, join, run }) {
+  if (!/\.rs$/.test(file)) return null
+  if (!existsSync(join(cwd, "Cargo.toml"))) return null
+  const fname = file.split(/[\\/]/).pop()
+  try {
+    const out = await run("cargo", ["check", "--message-format", "short"], { cwd, timeout: 120000, signal })
+    const errors = out.split("\n").filter(l => l.includes(fname))
+    return errors.length > 0 ? errors.join("\n") : "✓ cargo check: no errors"
+  } catch (e) {
+    const combined = ((e.stdout || "") + "\n" + (e.stderr || "")).trim()
+    const errors = combined.split("\n").filter(l => l.includes(fname) || l.startsWith("error"))
+    return errors.length > 0 ? errors.join("\n") : `✗ cargo check failed:\n${combined.slice(0, 1000)}`
+  }
+}
+
+async function goVet(file, { cwd, signal, run }) {
+  if (!/\.go$/.test(file)) return null
+  try {
+    await run("go", ["vet", file], { cwd, timeout: 60000, signal })
+    return "✓ go vet: no issues"
+  } catch (e) {
+    return `✗ go vet: ${(e.stderr || e.message).slice(0, 500)}`
+  }
+}
+
+const LANG_CHECKERS = {
+  // js/mjs/cjs/jsx fall back to node --check (no entry — third-party linter cascade removed 2026-09-02, TOOLS.md §10.2)
+  ts:  [tscCheck],
+  tsx: [tscCheck],
+  mts: [tscCheck],
+  cts: [tscCheck],
+  py:  [ruffCheck],
+  rs:  [cargoCheck],
+  go:  [goVet],
+}

package/tools/lsp.mjs

@@ -0,0 +1,335 @@
+/**
+ * tools/lsp.mjs — LSP (Language Server Protocol) code intelligence tool
+ * Zero-dependency JSON-RPC 2.0 over stdio client.
+ *
+ * Provides: go-to-definition, find-references, hover info, document symbols, diagnostics.
+ * Lazy-starts language servers on first call. Configurable via config.json lsp.servers.
+ *
+ * Config format:
+ *   "lsp": {
+ *     "servers": {
+ *       "typescript": { "command": "typescript-language-server", "args": ["--stdio"] },
+ *       "python": { "command": "pyright-langserver", "args": ["--stdio"] }
+ *     }
+ *   }
+ */
+
+import { spawn } from "node:child_process"
+import { existsSync, readFileSync } from "node:fs"
+import { join, extname } from "node:path"
+import { DESC } from "./shared.mjs"
+
+// ─── 宿主语言服务径注入缝（#66——「宿主语言服务径按端注入」，形态参 §2.13.5 注入缝）──────
+/**
+ * 宿主语言服务桥注入位（**缺省不覆盖** = 核内 JSON-RPC over stdio 径——CLI 语义，零行为变；
+ * 端装配层可覆盖为宿主语言服务径）。核内零端名分支（契约 5——本档只认 `handle` 函数名）。
+ * 契约：`handle(args, ctx) → string | null | undefined | Promise<同>`——null / undefined =
+ * 未处理 ⇒ 回核内径（其余返回值为该次调用的工具结果）。
+ */
+let injectedHost = null
+export function configureLspHost(impl) {
+  injectedHost = impl && typeof impl.handle === "function" ? impl.handle : null
+}
+/** 撤销注入（测试与端装配生命周期用——缺省态 = 核内 JSON-RPC 径）。 */
+export function resetLspHost() { injectedHost = null }
+
+// ---- JSON-RPC transport over stdio ----
+
+/** Send a JSON-RPC request to the server via stdin */
+function send(proc, message) {
+  const body = JSON.stringify(message)
+  const header = `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n`
+  proc.stdin.write(header + body)
+}
+
+/** Read one JSON-RPC message from stdout. Returns parsed JSON, or null on EOF. */
+function readMessage(proc) {
+  return new Promise((resolve) => {
+    let header = ""
+    let contentLength = -1
+
+    const onData = (chunk) => {
+      if (contentLength < 0) {
+        header += chunk.toString()
+        const match = header.match(/Content-Length: (\d+)\r\n\r\n/)
+        if (match) {
+          contentLength = parseInt(match[1])
+          const bodyStart = header.indexOf("\r\n\r\n") + 4
+          const remaining = header.slice(bodyStart)
+          header = ""
+          if (remaining.length >= contentLength) {
+            proc.stdout.removeListener("data", onData)
+            try { resolve(JSON.parse(remaining.slice(0, contentLength))) } catch { resolve(null) }
+            return
+          }
+          // Need more data — leave remaining in a buffer-like state
+          proc.stdout.removeListener("data", onData)
+          readBody(proc, remaining, contentLength).then(resolve)
+        }
+      }
+    }
+
+    proc.stdout.on("data", onData)
+  })
+}
+
+function readBody(proc, buf, targetLen) {
+  return new Promise((resolve) => {
+    const onData = (chunk) => {
+      buf += chunk.toString()
+      if (buf.length >= targetLen) {
+        proc.stdout.removeListener("data", onData)
+        try { resolve(JSON.parse(buf.slice(0, targetLen))) } catch { resolve(null) }
+      }
+    }
+    proc.stdout.on("data", onData)
+  })
+}
+
+/** Send a request and wait for the matching response */
+async function request(proc, method, params, id) {
+  send(proc, { jsonrpc: "2.0", id, method, params })
+  while (true) {
+    const msg = await readMessage(proc)
+    if (!msg) return null
+    if (msg.id === id) return msg
+    // Store notifications for later retrieval (diagnostics)
+    if (msg.method === "textDocument/publishDiagnostics") {
+      proc._diagnostics = proc._diagnostics || {}
+      proc._diagnostics[msg.params.uri] = msg.params.diagnostics
+    }
+  }
+}
+
+/** Send a notification (no response expected) */
+function notify(proc, method, params) {
+  send(proc, { jsonrpc: "2.0", method, params })
+}
+
+// ---- Language server process management ----
+
+const servers = new Map() // ext → { proc, rootUri, ready }
+
+/** Convert file path to file:// URI */
+function toUri(absPath) {
+  return "file:///" + absPath.replace(/\\/g, "/").replace(/^([A-Z]):/, (_, d) => d.toLowerCase() + "%3A")
+}
+
+/** Resolve which language server to use for a file extension */
+function resolveServerConfig(config, ext) {
+  const map = {
+    ".js": "typescript", ".mjs": "typescript", ".cjs": "typescript",
+    ".ts": "typescript", ".tsx": "typescript", ".mts": "typescript", ".cts": "typescript",
+    ".py": "python", ".pyi": "python",
+    ".rs": "rust",
+    ".go": "go",
+  }
+  const key = map[ext] || ext.slice(1)
+  const servers = config?.lsp?.servers ?? {}
+  return servers[key] || null
+}
+
+/** Start or reuse a language server for the given file */
+async function getServer(cwd, filePath, config) {
+  const ext = extname(filePath).toLowerCase()
+  const srvConfig = resolveServerConfig(config, ext)
+  if (!srvConfig) return null
+
+  const abs = join(cwd, ...filePath.split("/"))
+  if (!existsSync(abs)) return null
+
+  const rootUri = toUri(cwd)
+  const key = `${ext}:${cwd}`
+  let entry = servers.get(key)
+
+  if (entry && entry.ready) return entry
+
+  // Start new server
+  const proc = spawn(srvConfig.command, srvConfig.args || [], {
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true,
+  })
+
+  proc.stderr.on("data", () => {}) // suppress stderr noise
+
+  entry = { proc, rootUri, ready: false }
+  servers.set(key, entry)
+
+  // Initialize handshake
+  const initResult = await request(proc, "initialize", {
+    processId: null,
+    rootUri,
+    capabilities: {
+      textDocument: {
+        definition: { linkSupport: false },
+        references: {},
+        hover: { contentFormat: ["plaintext"] },
+        documentSymbol: { hierarchicalDocumentSymbolSupport: true },
+      },
+    },
+    workspace: {},
+  }, 1)
+
+  if (!initResult) {
+    proc.kill()
+    servers.delete(key)
+    return null
+  }
+
+  notify(proc, "initialized", {})
+  entry.ready = true
+  return entry
+}
+
+/** Notify the server that a file is open (required before queries) */
+async function ensureOpen(proc, uri, ext) {
+  const langMap = { ".js": "javascript", ".mjs": "javascript", ".cjs": "javascript", ".ts": "typescript", ".tsx": "typescript", ".mts": "typescript", ".cts": "typescript", ".py": "python", ".rs": "rust", ".go": "go" }
+  const languageId = langMap[ext] || ext.slice(1)
+  notify(proc, "textDocument/didOpen", {
+    textDocument: {
+      uri,
+      languageId,
+      version: 1,
+      text: readFileSync(uri.replace(/^file:\/\/\//, "").replace(/%3A/, ":").replace(/\//g, "\\"), "utf8"),
+    },
+  })
+}
+
+// ---- Tool definition ----
+
+export const lspTool = {
+  name: "lsp",
+  description: DESC("lsp"),
+  parameters: {
+    type: "object",
+    properties: {
+      subcommand: {
+        type: "string",
+        enum: ["definition", "references", "hover", "symbols", "diagnostics"],
+        description: "LSP operation to perform",
+      },
+      uri: {
+        type: "string",
+        description: "Target file path (relative to project root)",
+      },
+      line: {
+        type: "integer",
+        description: "1-based line number (for definition/references/hover)",
+      },
+      character: {
+        type: "integer",
+        description: "1-based character offset (for definition/references/hover)",
+      },
+    },
+    required: ["subcommand", "uri"],
+  },
+  readonly: true,
+
+  async execute(args, ctx) {
+    const config = ctx.agent?.config ?? {}
+    const cwd = ctx.cwd
+    const filePath = args.uri
+
+    try {
+      // 宿主语言服务径（#66）：注入面命中（非 null/undefined）⇒ 以其返回值为准；未处理回核内径。
+      if (injectedHost) {
+        const out = await injectedHost(args, ctx)
+        if (out !== null && out !== undefined) return out
+      }
+      const entry = await getServer(cwd, filePath, config)
+      if (!entry) {
+        const ext = extname(filePath).toLowerCase()
+        return `No LSP server configured for "${ext}" files. Add one to config.json:\n"lsp": { "servers": { "${ext.slice(1)}": { "command": "...", "args": ["--stdio"] } } }`
+      }
+
+      const { proc } = entry
+      const abs = join(cwd, ...filePath.split("/"))
+      const uri = toUri(abs)
+      const ext = extname(filePath).toLowerCase()
+      await ensureOpen(proc, uri, ext)
+
+      // Wait briefly for diagnostics to arrive
+      await new Promise((r) => setTimeout(r, 300))
+
+      switch (args.subcommand) {
+        case "definition": {
+          if (!args.line || !args.character) return "Error: line and character required for definition"
+          const res = await request(proc, "textDocument/definition", {
+            textDocument: { uri },
+            position: { line: args.line - 1, character: args.character - 1 },
+          }, 10)
+          if (!res?.result) return "(no definition found)"
+          const locs = Array.isArray(res.result) ? res.result : [res.result]
+          return locs.map((l) => {
+            const path = l.uri.replace(/^file:\/\/\//, "").replace(/%3A/, ":")
+            return `${path}:${l.range.start.line + 1}:${l.range.start.character + 1}`
+          }).join("\n")
+        }
+
+        case "references": {
+          if (!args.line || !args.character) return "Error: line and character required for references"
+          const res = await request(proc, "textDocument/references", {
+            textDocument: { uri },
+            position: { line: args.line - 1, character: args.character - 1 },
+            context: { includeDeclaration: false },
+          }, 10)
+          if (!res?.result?.length) return "(no references found)"
+          return res.result.slice(0, 50).map((l) => {
+            const path = l.uri.replace(/^file:\/\/\//, "").replace(/%3A/, ":")
+            return `${path}:${l.range.start.line + 1}:${l.range.start.character + 1}`
+          }).join("\n") + (res.result.length > 50 ? `\n... and ${res.result.length - 50} more` : "")
+        }
+
+        case "hover": {
+          if (!args.line || !args.character) return "Error: line and character required for hover"
+          const res = await request(proc, "textDocument/hover", {
+            textDocument: { uri },
+            position: { line: args.line - 1, character: args.character - 1 },
+          }, 10)
+          if (!res?.result?.contents) return "(no hover info)"
+          const contents = res.result.contents
+          if (typeof contents === "string") return contents
+          if (Array.isArray(contents)) return contents.map((c) => typeof c === "string" ? c : c.value).join("\n")
+          if (contents.value) return contents.value
+          return JSON.stringify(contents)
+        }
+
+        case "symbols": {
+          const res = await request(proc, "textDocument/documentSymbol", {
+            textDocument: { uri },
+          }, 10)
+          if (!res?.result?.length) return "(no symbols found)"
+          function render(nodes, depth) {
+            const lines = []
+            for (const n of nodes) {
+              const kind = n.kind != null ? ` [${symbolKind(n.kind)}]` : ""
+              lines.push(`${"  ".repeat(depth)}${n.name}${kind} — L${n.range.start.line + 1}`)
+              if (n.children?.length) lines.push(...render(n.children, depth + 1))
+            }
+            return lines
+          }
+          return render(res.result, 0).join("\n")
+        }
+
+        case "diagnostics": {
+          const diags = proc._diagnostics?.[uri]
+          if (!diags?.length) return "(no diagnostics)"
+          return diags.slice(0, 30).map((d) => {
+            const sev = { 1: "ERROR", 2: "WARN", 3: "INFO", 4: "HINT" }[d.severity] || "?"
+            return `L${d.range.start.line + 1}: ${sev}: ${d.message}${d.code ? ` [${d.code}]` : ""}`
+          }).join("\n") + (diags.length > 30 ? `\n... and ${diags.length - 30} more` : "")
+        }
+
+        default:
+          return `Unknown subcommand: ${args.subcommand}`
+      }
+    } catch (err) {
+      return `lsp error: ${err.message}`
+    }
+  },
+}
+
+function symbolKind(k) {
+  const kinds = { 1: "file", 2: "module", 3: "namespace", 4: "package", 5: "class", 6: "method", 7: "property", 8: "field", 9: "constructor", 10: "enum", 11: "interface", 12: "function", 13: "variable", 14: "constant", 15: "string", 16: "number", 17: "boolean", 18: "array", 19: "object", 20: "key", 21: "null", 22: "enumMember", 23: "struct", 24: "event", 25: "operator", 26: "typeParameter" }
+  return kinds[k] || `kind-${k}`
+}