@fishdivinity/dsh-local-search 0.2.0 → 0.3.0

package/lib/route.js

@@ -1,33 +1,47 @@
 /**
- * The configuration page's Test control needs one thing the browser cannot do
- * itself: call the local Anytxt JSON-RPC and `es.exe` and report whether they
- * answered. A cross-origin POST from the page to `127.0.0.1:9920` is refused by
- * both sides, so the page asks the Host instead.
+ * 配置页的测试按钮有一件事浏览器自己做不到：调本机的 Anytxt JSON-RPC 与 `es.exe`，并报告
+ * 它们有没有应答。页面往 `127.0.0.1:9920` 发的跨源 POST 两边都会拒，所以页面改问 Host。
  *
- * The route is `exact` on the bare `webServer`, the same seam the other
- * installed plugins use (a prefix/exact registration never passes through the
- * shell's `/api` fence). It is read-only and sends no CORS headers, so a foreign
- * page cannot read the answer.
+ * 路由注册在裸 `webServer` 上、用 `exact`——与其他已安装插件用的是同一个接缝（prefix/exact
+ * 注册从不经过 shell 的 `/api` 围栏）。它是只读的，也不发 CORS 头，所以外站页面读不到答案。
  *
- * A foreign page *can* still fire a plain GET, and a GET here spends an es.exe
- * spawn, so the route refuses any request a browser marks as cross-site
- * (`Sec-Fetch-Site`) or whose `Origin` is not this Host. A non-browser caller
- * sends neither header and is a local process the page's CSRF risk does not
- * cover.
+ * 外站页面仍然**能**发一个普通 GET，而这里的一次 GET 要花一次 es.exe 启动，所以路由拒掉任何
+ * 浏览器标成跨站的请求（`Sec-Fetch-Site`），以及 `Origin` 不是本 Host 的请求。非浏览器的调用方
+ * 两个头都不发，它是本地进程，不在页面那个 CSRF 风险的覆盖范围里。
  *
- * `?anytxtUrl=` lets the page test what the user typed before saving. That
- * draft is untrusted input, so it is accepted only as a loopback `http(s)` URL:
- * enough to type `127.0.0.1:9921` and try, never a request-forwarding proxy.
- * Without the parameter the route probes the saved configuration; a saved
- * endpoint that is not local fails in the engine with `ANYTXT_ENDPOINT_REMOTE`.
+ * `?anytxtUrl=` 让页面测试用户保存前敲下的地址。那份草稿是不可信输入，所以只接受 loopback 的
+ * `http(s)` URL：够敲 `127.0.0.1:9921` 试一下，永远不是一个请求转发代理。不带这个参数时路由
+ * 探测已保存的配置；一份不是本机的已保存地址会在引擎里以 `ANYTXT_ENDPOINT_REMOTE` 失败。
+ *
+ * `?esPath=` 让页面在保存前确认「这个路径在不在」。这里**只查文件存在**，绝不启动它：让一条
+ * HTTP 路由按请求里的路径去 spawn，等于把任意执行开成了接口。`?dir=`（可重复）同理，只回答
+ * 「这个目录在不在」，给检索范围那几个字段用。
  */
 
+import { existsSync, realpathSync, statSync } from 'node:fs'
+import { isAbsolute } from 'node:path'
 import { probeEngines } from './probe.js'
 import { isLoopbackUrl } from './config.js'
+import { describeConfig } from './describe.js'
 
-/** Path the page fetches; the page resolves it against its own base URI. */
+/** 页面取引擎状态用的路径；页面按自己的 base URI 解析它。 */
 export const STATUS_ROUTE = '/dsh-local-search/api/status'
 
+/** 页面取后端与字段描述用的路径。 */
+export const DESCRIBE_ROUTE = '/dsh-local-search/api/describe'
+
+/** 携带待探测的未保存地址的查询参数。 */
+export const DRAFT_PARAM = 'anytxtUrl'
+
+/** 携带待校验的未保存 `es.exe` 路径的查询参数。 */
+export const DRAFT_PATH_PARAM = 'esPath'
+
+/** 携带待校验的未保存目录的查询参数；可重复，`allRoots` 会拆成多条。 */
+export const DRAFT_DIR_PARAM = 'dir'
+
+/** 只要校验草稿、不跑引擎探测的查询参数。失焦校验用它，免得一次按键花一次 es.exe 启动。 */
+export const CHECK_ONLY_PARAM = 'checkOnly'
+
 function sendJson(response, status, payload) {
   const body = JSON.stringify(payload)
   response.writeHead(status, {
@@ -39,9 +53,47 @@ function sendJson(response, status, payload) {
 }
 
 /**
- * Whether the request came from this page rather than another site.
- * @param {object} request - the HTTP request (only `headers` is read)
- * @returns true for a same-origin request, or one no browser sent
+ * 一个已存在的路径在磁盘上的写法：真实大小写、真实分隔符。
+ *
+ * 只是锦上添花——页面把 `d:/alpha` 交给这里，回填 `D:\Alpha`；取不到就原样返回，校验结论不受影响。
+ * `realpath` 会解析 junction 与符号链接，所以回填的是目标路径本身，两者指向同一棵树。
+ * @param value - 已确认存在的绝对路径
+ * @returns 规范写法
+ */
+function canonicalPath(value) {
+  try {
+    return realpathSync.native(value)
+  } catch {
+    return value
+  }
+}
+
+/**
+ * 请求目标里的查询参数；解析不了的 URL 当成没有参数。
+ * @param {string} requestUrl - 请求目标
+ * @returns {URLSearchParams}
+ */
+function queryOf(requestUrl) {
+  try {
+    return new URL(String(requestUrl ?? '/'), 'http://localhost').searchParams
+  } catch {
+    return new URLSearchParams()
+  }
+}
+
+/**
+ * 这次请求只要校验草稿，不要引擎状态吗。
+ * @param {string} requestUrl - 请求目标
+ * @returns 带 `checkOnly` 时为 true
+ */
+function checkOnly(requestUrl) {
+  return queryOf(requestUrl).has(CHECK_ONLY_PARAM)
+}
+
+/**
+ * 请求是来自本页面而不是别的站点吗。
+ * @param {object} request - HTTP 请求（只读 `headers`）
+ * @returns 同源请求、或不是浏览器发来的请求时为 true
  */
 export function isSameOrigin(request) {
   const headers = request.headers ?? {}
@@ -59,68 +111,134 @@ export function isSameOrigin(request) {
 }
 
 /**
- * Read the draft endpoint a pre-save test asks about.
+ * 拒绝一个不该处理的请求：非 GET/HEAD，或浏览器标记为跨站。
  *
- * It runs the same loopback rule the config schema enforces, so a draft can
- * never reach an address the saved configuration could not hold.
- * @param {string} requestUrl - the request target
- * @returns {{ok: true, value: string|undefined} | {ok: false}} the draft, or why it was refused
+ * 两条路由共用同一道门——一次探测要花一次 es.exe 启动，describe 也要避免变成任意站点可读的
+ * 本机信息口。
+ * @param {object} request - HTTP 请求
+ * @param {object} response - HTTP 响应
+ * @returns {boolean} 已经作答、调用方应直接返回时为 true
  */
-export function draftEndpoint(requestUrl) {
-  let parsed
-  try {
-    parsed = new URL(String(requestUrl ?? '/'), 'http://localhost')
-  } catch {
-    return { ok: true, value: undefined }
+function refused(request, response) {
+  const method = request.method ?? 'GET'
+  if (method !== 'GET' && method !== 'HEAD') {
+    response.writeHead(405, { allow: 'GET, HEAD' })
+    response.end()
+    return true
+  }
+  if (!isSameOrigin(request)) {
+    sendJson(response, 403, { ok: false, code: 'CROSS_SITE_REFUSED', message: 'this route answers this page only' })
+    return true
   }
-  const raw = parsed.searchParams.get('anytxtUrl')
+  return false
+}
+
+/**
+ * 读出保存前测试要问的那个草稿地址。
+ *
+ * 它跑的是 config schema 强制的同一条 loopback 规则，所以草稿永远到不了已保存配置都放不下的
+ * 地址。
+ * @param {string} requestUrl - 请求目标
+ * @returns {{ok: true, value: string|undefined} | {ok: false}} 草稿，或它被拒的原因
+ */
+export function draftEndpoint(requestUrl) {
+  const raw = queryOf(requestUrl).get(DRAFT_PARAM)
   if (raw === null || raw.trim() === '') return { ok: true, value: undefined }
   const trimmed = raw.trim()
   return isLoopbackUrl(trimmed) ? { ok: true, value: trimmed } : { ok: false }
 }
 
 /**
- * Answer one probe request.
- * @param {object} request - the HTTP request (`method` and `url` are read)
- * @param {object} response - the HTTP response
- * @param {(options: object) => Promise<{everything: object, anytxt: object}>} probe - the probe to run
+ * 读出保存前要确认的 `es.exe` 草稿路径。
+ *
+ * 只回答「在不在」，不启动它：路径是调用方给的，按它 spawn 就等于把任意执行开成接口。
+ * `resolved` 是同一个文件的规范写法，页面拿它回填输入框。
+ * @param {string} requestUrl - 请求目标
+ * @returns {{ok: true, value: string|undefined, resolved: string|undefined} | {ok: false, reason: 'missing'|'not-file'}}
+ */
+export function draftEsPath(requestUrl) {
+  const raw = queryOf(requestUrl).get(DRAFT_PATH_PARAM)
+  if (raw === null || raw.trim() === '') return { ok: true, value: undefined, resolved: undefined }
+  const trimmed = raw.trim()
+  if (!isAbsolute(trimmed) || !existsSync(trimmed)) return { ok: false, reason: 'missing' }
+  let file = false
+  try {
+    file = statSync(trimmed).isFile()
+  } catch {
+    file = false
+  }
+  // 目录不是文件：这一条对读数的人才说得清楚（「这里要填文件」比「不存在」有用）。
+  if (!file) return { ok: false, reason: 'not-file' }
+  return { ok: true, value: trimmed, resolved: canonicalPath(trimmed) }
+}
+
+/**
+ * 读出保存前要确认的目录草稿（可多值，`allRoots` 会拆成多条）。
+ *
+ * 同样只查存在与「是个目录」：Windows 接受 `/` 与 `\` 两种分隔符，所以 `D:/Alpha` 与
+ * `D:\Alpha` 都是合法路径，这里按同一规则判定。
+ * @param {string} requestUrl - 请求目标
+ * @returns {{ok: true, value: string[], resolved: string[]} | {ok: false, reason: 'missing'|'not-directory'}}
+ */
+export function draftDirs(requestUrl) {
+  const dirs = queryOf(requestUrl).getAll(DRAFT_DIR_PARAM)
+    .map((value) => value.trim())
+    .filter((value) => value !== '')
+  for (const dir of dirs) {
+    if (!isAbsolute(dir) || !existsSync(dir)) return { ok: false, reason: 'missing' }
+    let directory = false
+    try {
+      directory = statSync(dir).isDirectory()
+    } catch {
+      directory = false
+    }
+    // 填了具体文件是最常见的错法（粘了一条文件路径进来），单独给一个原因。
+    if (!directory) return { ok: false, reason: 'not-directory' }
+  }
+  return { ok: true, value: dirs, resolved: dirs.map((dir) => canonicalPath(dir)) }
+}
+
+/**
+ * 回答一次探测请求。
+ * @param {object} request - HTTP 请求（读 `method` 与 `url`）
+ * @param {object} response - HTTP 响应
+ * @param {(options: object) => Promise<{everything: object, anytxt: object}>} probe - 要跑的探测
  */
 export async function statusHandler(request, response, probe) {
   try {
     await answerStatus(request, response, probe)
   } catch {
-    // A page that navigated away mid-probe leaves a dead socket; a rejected
-    // promise here would surface as an unhandled rejection in the web server's
-    // request pipeline.
+    // 探测到一半页面就走了，socket 已经是死的；这里让 promise 拒掉的话，会在 web server 的
+    // 请求管线里冒成一个未处理的 rejection。
     try {
       response.destroy()
     } catch {
-      // Already gone.
+      // 已经没了。
     }
   }
 }
 
 /**
- * Write the answer for one request.
- * @param {object} request - the HTTP request
- * @param {object} response - the HTTP response
- * @param {(options: object) => Promise<{everything: object, anytxt: object}>} probe - the probe to run
+ * 草稿被拒：400 加一个稳定的 code，页面据此决定说哪一句。
+ * @param {object} response - HTTP 响应
+ * @param {string} code - 机器可读的原因
+ * @param {string} message - 英文说明（面向日志与调试，不面向页面）
+ */
+function refuseDraft(response, code, message) {
+  sendJson(response, 400, { ok: false, code, message })
+}
+
+/**
+ * 写出一次请求的答案。
+ * @param {object} request - HTTP 请求
+ * @param {object} response - HTTP 响应
+ * @param {(options: object) => Promise<{everything: object, anytxt: object}>} probe - 要跑的探测
  */
 async function answerStatus(request, response, probe) {
   const method = request.method ?? 'GET'
-  if (method !== 'GET' && method !== 'HEAD') {
-    response.writeHead(405, { allow: 'GET, HEAD' })
-    response.end()
-    return
-  }
-  // A probe costs an es.exe spawn, so another site's page must not be able to
-  // trigger one with an ordinary GET.
-  if (!isSameOrigin(request)) {
-    sendJson(response, 403, { ok: false, code: 'CROSS_SITE_REFUSED', message: 'this route answers this page only' })
-    return
-  }
-  // HEAD claims reachability without spending an es.exe spawn: a probe is the
-  // whole cost of this route, and the body carries the only useful answer.
+  if (refused(request, response)) return
+  // HEAD 只声明可达，不花一次 es.exe 启动：探测就是这条路由的全部成本，而唯一有用的答案在
+  // body 里。
   if (method === 'HEAD') {
     response.writeHead(200, { 'cache-control': 'no-store', 'content-type': 'application/json; charset=utf-8' })
     response.end()
@@ -128,22 +246,48 @@ async function answerStatus(request, response, probe) {
   }
   const draft = draftEndpoint(request.url)
   if (!draft.ok) {
-    sendJson(response, 400, {
-      ok: false,
-      code: 'ANYTXT_URL_REJECTED',
-      message: 'a draft endpoint must be a loopback http(s) url',
-    })
+    refuseDraft(response, 'ANYTXT_URL_REJECTED', 'a draft endpoint must be a loopback http(s) url')
+    return
+  }
+  const path = draftEsPath(request.url)
+  if (!path.ok) {
+    refuseDraft(
+      response,
+      path.reason === 'not-file' ? 'ES_PATH_NOT_FILE' : 'ES_PATH_REJECTED',
+      path.reason === 'not-file'
+        ? 'a draft es.exe path must be a file, not a directory'
+        : 'a draft es.exe path must be an absolute existing file',
+    )
+    return
+  }
+  const dirs = draftDirs(request.url)
+  if (!dirs.ok) {
+    refuseDraft(
+      response,
+      dirs.reason === 'not-directory' ? 'DIR_NOT_DIRECTORY' : 'DIR_REJECTED',
+      dirs.reason === 'not-directory'
+        ? 'a draft directory must be a directory, not a file'
+        : 'a draft directory must be an absolute existing directory',
+    )
+    return
+  }
+  // 草稿的规范写法，页面用它回填输入框（`d:/alpha` 落成 `D:\Alpha`）；只要校验时直接作答。
+  const drafts = { esPath: path.resolved, dirs: dirs.resolved ?? [] }
+  if (checkOnly(request.url)) {
+    sendJson(response, 200, { ok: true, drafts })
     return
   }
   let payload
   let status = 200
   try {
-    const probed = await probe({ anytxtUrl: draft.value })
+    // 这条路由只喂页面，所以可以带上 `detail` 那个原因——面向模型的状态刻意把它留在表面之外。
+    const probed = await probe({ anytxtUrl: draft.value, detail: true })
     payload = {
       ok: Boolean(probed.everything?.ok) && Boolean(probed.anytxt?.ok),
       checkedAt: Date.now(),
       everything: probed.everything ?? { ok: false, code: 'UNKNOWN' },
       anytxt: probed.anytxt ?? { ok: false, code: 'UNKNOWN' },
+      drafts,
     }
   } catch (error) {
     status = 500
@@ -153,11 +297,11 @@ async function answerStatus(request, response, probe) {
 }
 
 /**
- * Register the probe route on the Host's web server.
- * @param {object} server - the resolved `webServer` service
- * @param {object} config - schema output, volatile references included
- * @param {(options: object) => Promise<object>} [probe] - the probe, injectable for tests
- * @returns {() => void} route disposer
+ * 把探测路由注册到 Host 的 web server 上。
+ * @param {object} server - 解析出的 `webServer` 服务
+ * @param {object} config - schema 输出，含 volatile 引用
+ * @param {(options: object) => Promise<object>} [probe] - 探测函数，测试可注入
+ * @returns {() => void} 路由的 disposer
  */
 export function registerStatusRoute(server, config, probe = (options) => probeEngines(config, options)) {
   return server.register({
@@ -166,3 +310,42 @@ export function registerStatusRoute(server, config, probe = (options) => probeEn
     handler: (request, response) => statusHandler(request, response, probe),
   })
 }
+
+/**
+ * 回答一次 describe 请求。
+ * @param {object} request - HTTP 请求
+ * @param {object} response - HTTP 响应
+ * @param {() => object} describe - 载荷构造函数
+ */
+export async function describeHandler(request, response, describe = () => describeConfig()) {
+  try {
+    if (refused(request, response)) return
+    if ((request.method ?? 'GET') === 'HEAD') {
+      response.writeHead(200, { 'cache-control': 'no-store', 'content-type': 'application/json; charset=utf-8' })
+      response.end()
+      return
+    }
+    sendJson(response, 200, describe())
+  } catch {
+    // 与 status 同理：页面已经走开时不要再抛进 web server 的请求管线。
+    try {
+      response.destroy()
+    } catch {
+      // 已经没了。
+    }
+  }
+}
+
+/**
+ * 把 describe 路由注册到 Host 的 web server 上。
+ * @param {object} server - 解析出的 `webServer` 服务
+ * @param {() => object} [describe] - 载荷构造函数，测试可注入
+ * @returns {() => void} 路由的 disposer
+ */
+export function registerDescribeRoute(server, describe = () => describeConfig()) {
+  return server.register({
+    kind: 'exact',
+    path: DESCRIBE_ROUTE,
+    handler: (request, response) => describeHandler(request, response, describe),
+  })
+}

package/lib/schema.js

@@ -0,0 +1,130 @@
+/**
+ * Config schema（schemastery）的构造。
+ *
+ * 字段表是 schema、路径与默认值三者唯一的汇合点：路径来自 `lib/config.js` 的 {@link PATHS}，
+ * 默认值来自 {@link DEFAULTS}，描述留在这里（配置编辑器读它，用户界面不读）。
+ *
+ * 为什么要从字段表拼装而不是手写嵌套字面量：嵌套字面量会把同一条路径写两遍（schema 一遍、
+ * describe 一遍、迁移一遍），改一处忘一处就出现「页面能改、工具没读」的静默错位。
+ */
+
+import z from '@deepseek-ai/schemastery'
+import { DEFAULTS, PATHS, RETIRED_PATHS } from './config.js'
+import { MAX_LIMIT, MAX_READ } from './limits.js'
+
+/** 逗号分隔的后端名提示，来自注册表的说明留在 `lib/engines.js`。 */
+const BACKEND_HINT = 'Use this unless a tool call names another backend; local_search_status lists the registered names.'
+
+/**
+ * 可编辑字段表。
+ *
+ * `kind: 'count'` 的字段带 `max`，对应 Host 的硬上限；页面从 describe 拿到同一个数，所以
+ * 保存不会被 schema 拒绝。
+ */
+const FIELDS = [
+  { path: PATHS.filesBackend, default: DEFAULTS.files.backend, description: `Default filename backend. ${BACKEND_HINT}` },
+  { path: PATHS.esPath, default: DEFAULTS.files.everything.esPath, description: 'Absolute path to es.exe; empty auto-detects PATH and common install folders.' },
+  {
+    path: PATHS.esEncoding,
+    default: DEFAULTS.files.everything.esEncoding,
+    // 故意保持自由字符串：0.1 接受任意标签并在 decodeEs 里回退 UTF-8，收成枚举会让昨天还能用的 profile 激活失败。
+    description: 'Code page used to decode es.exe output: gbk for a zh-CN console, utf-8 otherwise. Any TextDecoder label is accepted; the page offers these two.',
+  },
+  { path: PATHS.contentBackend, default: DEFAULTS.content.backend, description: `Default document-content backend. ${BACKEND_HINT}` },
+  { path: PATHS.anytxtUrl, default: DEFAULTS.content.anytxt.url, description: 'Local Anytxt JSON-RPC endpoint on this machine (127.0.0.1, localhost or [::1]); :9921 is tried as a fallback.' },
+  { path: PATHS.workspaceRoot, default: DEFAULTS.scopes.workspaceRoot, description: 'Root for scope=workspace; empty uses the session working directory.' },
+  { path: PATHS.workRoot, default: DEFAULTS.scopes.workRoot, description: 'Root for scope=work; required before using that scope.' },
+  { path: PATHS.personalRoot, default: DEFAULTS.scopes.personalRoot, description: 'Root for scope=personal; required before using that scope.' },
+  { path: PATHS.allRoots, default: DEFAULTS.scopes.allRoots, description: 'Semicolon-separated roots for Anytxt scope=all; empty uses C: and D: when present.' },
+  { path: PATHS.maxResults, default: DEFAULTS.limits.maxResults, kind: 'count', max: MAX_LIMIT, description: `Default result cap; the hard cap is ${MAX_LIMIT}.` },
+  { path: PATHS.readMaxChars, default: DEFAULTS.limits.readMaxChars, kind: 'count', max: MAX_READ, description: `Default local_search_read window; the hard cap is ${MAX_READ} characters.` },
+  {
+    path: PATHS.autoConfigured,
+    default: DEFAULTS.autoConfigured,
+    kind: 'flag',
+    hidden: true,
+    // 隐藏而不是不声明：页面不渲染它，但 settings 只允许写 volatile 路径，自动配置要靠它落盘。
+    description: 'Set once the first-run configuration pass has decided what to fill; it keeps a field you cleared from being filled again.',
+  },
+]
+
+/** 叶子标记；用 Symbol 是为了让路径键和它永不冲突。 */
+const LEAF = Symbol('schema-leaf')
+
+function fieldSchema(field) {
+  const base = field.kind === 'count'
+    ? z.number().min(1).max(field.max)
+    : field.kind === 'flag' ? z.boolean() : z.string()
+  const leaf = base.default(field.default).volatile().description(field.description)
+  return field.hidden === true ? leaf.hidden() : leaf
+}
+
+/**
+ * 旧位置的 schema：与目标字段同类型、同默认值，只是位置不同且隐藏。
+ *
+ * 必须留在 schema 里而不是删掉：settings 只允许写/撤 schema 里有的路径，迁移要靠它把旧键清掉；
+ * 隐藏则让配置编辑器不显示它们（页面本来就只按 describe 渲染）。
+ * @param field - 目标位置现在的字段
+ * @param to - 目标路径，只用于描述
+ */
+function legacySchema(field, to) {
+  const base = field.kind === 'count' ? z.number().min(1).max(field.max) : z.string()
+  return base
+    .default(field.default)
+    .volatile()
+    .hidden()
+    .description(`Retired path; moved to ${to.join('.')} at startup.`)
+}
+
+function insert(tree, path, schema) {
+  let node = tree
+  for (const key of path.slice(0, -1)) {
+    node[key] ??= {}
+    node = node[key]
+  }
+  node[path.at(-1)] = { [LEAF]: schema }
+}
+
+/**
+ * 这条旧路径还能不能挂进 schema：它经过的每一层都得是对象（或还没建）。
+ * @param tree - 正在拼的 schema 树
+ * @param path - 旧路径
+ * @returns 可以插入时为 true
+ */
+function canInsert(tree, path) {
+  let node = tree
+  for (const key of path.slice(0, -1)) {
+    if (node[key] === undefined) return true
+    if (node[key][LEAF] !== undefined) return false
+    node = node[key]
+  }
+  return true
+}
+
+function wrap(tree) {
+  const dict = {}
+  for (const [key, child] of Object.entries(tree)) {
+    dict[key] = child[LEAF] ?? wrap(child)
+  }
+  return z.object(dict)
+}
+
+function build() {
+  const tree = {}
+  for (const field of FIELDS) insert(tree, field.path, fieldSchema(field))
+  const byPath = new Map(FIELDS.map((field) => [field.path.join('.'), field]))
+  // 退役路径仍要声明：settings 只允许写/撤 schema 里有的路径，迁移靠它把旧键清掉；隐藏则让
+  // 配置编辑器不显示它们（页面本来就只按 describe 渲染）。旧路径的父级可能已经是普通值，
+  // 那时 insert 会在它下面建对象把值挤掉——所以只处理父级仍是对象（或不存在）的那些。
+  for (const { from, to } of RETIRED_PATHS) {
+    const field = byPath.get(to.join('.'))
+    if (field === undefined) continue
+    if (!canInsert(tree, from)) continue
+    insert(tree, from, legacySchema(field, to))
+  }
+  tree.timeoutMs = { [LEAF]: z.number().default(DEFAULTS.timeoutMs).description('Per-call timeout budget in milliseconds; profile YAML only, because each tool fixes its deadline at registration.') }
+  return wrap(tree)
+}
+
+/** 插件的 Config schema。 */
+export const Config = build()