@thincoder/core 0.10.6 → 0.10.8

package/manifest-schema.mjs

@@ -1,7 +1,7 @@
 /**
  * manifest-schema.mjs — **校验 ∕ 默认值族**出档（2026-09-29 structure-split-2 · 台账 #620）：自 `manifest.mjs`
- * 全量迁出〔原 `:194-205` + `:240-369` 两段非连续〕——`isValidDocRootValue`（docRoot 子键值形态判据）·
- * `DEFAULT_MANIFEST`（默认八键）· `MANIFEST_SCHEMA`（判据单源）· 元素层谓词两件 · `validateManifest` ·
+ * 全量迁出——`isValidDocRootValue`（docRoot 子键值形态判据）·
+ * `DEFAULT_MANIFEST`（默认八键）· `MANIFEST_SCHEMA`（判据单源）· 元素层谓词一件 · `validateManifest` ·
  * `fillDefaults`；**结构拆分零语义**（面不变 ∕ 判据不变，只换宿主档；切点 ∕ 缝单源 =
  * 批档 `docs/batches/2026-09-29-structure-split-2.md` §2.2-C）。
  *
@@ -43,7 +43,6 @@ export const DEFAULT_MANIFEST = Object.freeze({
     widthExemptZones: Object.freeze([]),
     anchors: Object.freeze({ domain: "docs", exclude: Object.freeze(["_archive", "batches"]) }),
     exemptions: Object.freeze([]),
-    lineCounts: Object.freeze([]), // 行数面机检声明（#546）：[] = 未载惰性（doc-check 行数族）
   }),
   // 项目声明三族（2026-09-27 声明载体唯一化批并入——键名 / 形态逐字承前；来源档已退役）。
   codePaths: Object.freeze(["src"]),
@@ -72,12 +71,6 @@ function isNonEmptyStringArray(v) {
   return Array.isArray(v) && v.every((e) => typeof e === "string" && e.trim() !== "")
 }
 
-/** `checkConfig.lineCounts` 元素层判据（#546）：数组且各元素为非数组对象、`doc` / `section` 皆非空串（`trim` 后非空）；`[]` = 未载惰性。 */
-function isLineCountsValue(v) {
-  return Array.isArray(v) && v.every((e) => e !== null && typeof e === "object" && !Array.isArray(e)
-    && typeof e.doc === "string" && e.doc.trim() !== "" && typeof e.section === "string" && e.section.trim() !== "")
-}
-
 /**
  * 形状校验（模块设计 §2.2）——枚举 / version 数值恒做；**纯函数、零 fs**（原 `{ cwd }`
  * 指针分支已随字段整链裁撤——KD-M1-5 墓志）；不落盘。键存在性入 missingKeys（非拒）：
@@ -116,10 +109,6 @@ export function validateManifest(obj) {
       if (nested === "docRoot" && !isValidDocRootValue(value[sub])) {
         errors.push(`docRoot.${sub} 值形态非法：${JSON.stringify(value[sub])}（须为非空字符串 / 非空字符串数组 / null（本面无）——KD-M1-6 / KD-M1-7 / KD-M1-37）`)
       }
-      // checkConfig.lineCounts 元素层形态（#546）：数组，元素 = { doc, section } 非空串；非法 → 拒（不静默跳过）。
-      if (nested === "checkConfig" && sub === "lineCounts" && !isLineCountsValue(value[sub])) {
-        errors.push(`checkConfig.lineCounts 值形态非法：${JSON.stringify(value[sub])}（须为数组，元素 = { doc: 非空串, section: 非空串 }——#546）`)
-      }
     }
   }
   // 三族声明键形态（KD-M1-32——fail-closed：非法即 errors，不静默跳过；缺键仍在 missingKeys）。

package/manifest.mjs

@@ -10,7 +10,7 @@
  *    未知键（#802 / KD-M1-36）→ 产 unknownKeys + 一行可见告警（console.warn + logEvent；
  *    同档同键集去重、读到零未知键清该档 memo）——非拒定性零变。
  *  - validateManifest(obj) → { ok, errors, missingKeys, unknownKeys }：枚举 / version 数值 /
- *    docRoot 子键值形态（串 | 数组 | null（本面无——KD-M1-37），F7）+ checkConfig.lineCounts 元素层形态——**纯函数、零 fs**；不落盘。
+ *    docRoot 子键值形态（串 | 数组 | null（本面无——KD-M1-37），F7）——**纯函数、零 fs**；不落盘。
  *  - 三族声明键（`codePaths` / `index.{codeExtensions,docExtensions,publicRepos}` / `advisor.{docMap,standardsDoc}`——
  *    KD-M1-31 / M1-32）：缺键补默认；形态错 = 档非法（fail-closed，与 docRoot 子键同款）；
  *    读向 = `declaration.mjs`（2026-10-01 自 `conventions.mjs` 迁出——经其转口可达）经 `readManifest` /
@@ -25,10 +25,10 @@
  *  - projectView(target) → { state, root, path, manifest?, candidates?, errors?, matched }：**按用点解析**
  *    的读侧单点（归属 ∨ 发现兜底 / 五态 / 非抛错 / **零写**——KD-M1-24）。
  *  - resolveProjectRoot(cwd)：项目根（归属 ∨ 发现——KD-M1-30）= `projectRootView(cwd).root`（薄委托）；
- *    projectRootView(cwd) → { state: ok|ambiguous|none, root, candidates }：歧义直读形（判定单点——§2.2）。
+ *    projectRootView(cwd) → { state: ok|workspace|none, root, candidates }：项目根直读形（判定单点——§2.2）。
  *  - resolveEngineeringManifest(cwd, { writer, init }) → 入口决策树（**非抛错**——KD-M1-20）：
  *    两端入口钩子与翻转面（拒翻）共用同一张树（判据单源；§2.8 F1）——失败码五枚
- *    `missing` / `invalid` / `no-project` / `ambiguous` / `init-failed`（KD-M1-28）。名中 `Engineering` = 历史命名（沿用不改名）；消费面 = 两端入口钩子 + 翻转面——**非**「模式拥有本模块」。
+ *    `missing` / `invalid` / `no-project` / `workspace` / `init-failed`（KD-M1-28）。名中 `Engineering` = 历史命名（沿用不改名）；消费面 = 两端入口钩子 + 翻转面——**非**「模式拥有本模块」。
  *  - manifestFilePath(cwd) → 数据档绝对路径（档路径单源 KD-M1-18——读 / 写 / mtime 门控三处同源）。
  *  - initManifest(cwd, { writer = 'subagent' } = {}) → 经写门写 DEFAULT_MANIFEST，缺省拒。
  *  - writeManifest(cwd, manifest, { writer = 'subagent' } = {}) → 落盘前先校验（ok:false 拒
@@ -53,14 +53,14 @@ export { DEFAULT_MANIFEST, MANIFEST_SCHEMA, isValidDocRootValue, validateManifes
  * · **归属（第一段——§⑥ 归属形）**：`owningProject(target)` 沿祖先链取最近带档目录
  *   （子优于根 / 不跨兄弟 / 无全局优先级）⇒ 读该档 ⇒ `ok` / `invalid`。
  * · **发现兜底（第二段——§⑥ 发现规则，纯向下）**：祖先链无档 ⇒ `discoverProjects(target)` ⇒ 命中
- *   （`self` / `unique`）⇒ 读其档（带档 ⇒ `ok` / `invalid`；缺档 ⇒ `missing`）；`ambiguous` ⇒
- *   `ambiguous`（+ `candidates`）；`none` ⇒ `no-project`。
+ *   （`self` / `unique`）⇒ 读其档（带档 ⇒ `ok` / `invalid`；缺档 ⇒ `missing`）；`workspace` ⇒
+ *   `workspace`（+ `candidates`）；`none` ⇒ `no-project`。
  * 写侧（建档）**不在**此函数（归入口决策树——KD-M1-25 / M1-29）⇒ 注入器 / 只读消费面不会变写点。
  * `matched` 契约：归属段命中 ⇒ `'manifest'`；发现段 ⇒ `discoverProjects.matched` 逐字；
- * `no-project`（/ 覆盖位短路）⇒ `null`——报明行歧义变体按它分野（§2.6 条 1b）。
+ * `no-project`（/ 覆盖位短路）⇒ `null`——报明行工作区变体按它分野（§2.6 条 1b）。
  * 读错（非 ENOENT——权限 / 目录等）收为 `invalid`（非抛错契约；`readManifest` 语义零改）。
  * @param {string} [target] 目标路径（目录 / 文件——动作作用于哪个项目的路径）
- * @returns {{state:'ok'|'missing'|'no-project'|'ambiguous'|'invalid', root:string|null, path:string|null,
+ * @returns {{state:'ok'|'missing'|'no-project'|'workspace'|'invalid', root:string|null, path:string|null,
  *   manifest?:object, candidates?:string[], errors?:string[], matched:'manifest'|'git'|null}}
  */
 export function projectView(target) {
@@ -68,7 +68,7 @@ export function projectView(target) {
   const owning = owningProject(anchor)
   if (owning) return viewAtRoot(owning, "manifest")
   const d = discoverProjects(anchor)
-  if (d.kind === "ambiguous") return { state: "ambiguous", root: null, path: null, candidates: d.candidates, matched: d.matched }
+  if (d.kind === "workspace") return { state: "workspace", root: null, path: null, candidates: d.candidates, matched: d.matched }
   if (d.kind === "none") return { state: "no-project", root: null, path: null, matched: null }
   return viewAtRoot(d.root, d.matched)
 }
@@ -187,6 +187,16 @@ export function requireManifest(cwd) {
   return readManifest(cwd)
 }
 
+/** 建档（init 支）成功后的同步通知位（#1376——**反向注册**：`declaration.mjs` 已向依赖本模块，
+ *  订阅方由对侧注册 ⇒ 本模块保持零出边（MANIFEST.md KD-M1-33）；形同 `config-io.mjs` `onConfigSelfWrite`
+ *  ——返回退订函数；订阅方失败不影响建档）。 */
+const manifestInitFns = new Set()
+export function onManifestInit(fn) {
+  if (typeof fn !== "function") return () => {}
+  manifestInitFns.add(fn)
+  return () => { manifestInitFns.delete(fn) }
+}
+
 /**
  * 入口决策树（**非抛错**形态——KD-M1-20；docs/core/design/MANIFEST.md §2.8 F1）：三面共用——
  * ① CLI 装配 / 重估薄包装 ② VSC `hydrateRun` 钩子块 ③ 翻转面（`eng` 工具 / `/eng` /
@@ -196,22 +206,22 @@ export function requireManifest(cwd) {
  * 分支（两分支六出口——§2.8 F1 树）：
  *   档合法         → { ok:true, manifest, created:false }（manifest = 补默认值后的档内容）
  *   缺档 + init    → 梯②④⑤（锚 = 裸仓 / 裸仓命中 / 无项目）⇒ `initManifest(cwd, { writer })`
- *                    （抛错 → `init-failed`）；歧义（≥2 候选）⇒ `{ ok:false, code:'ambiguous',
- *                    message, candidates }`（**不建 / 不猜**）
+ *                    （抛错 → `init-failed`）；工作区（锚自身无档 ∧ 下辖 ≥2 项目）⇒
+ *                    `{ ok:false, code:'workspace', message, candidates }`（**不建 / 不猜**）
  *   缺档 + !init   → 梯⑤（无项目）⇒ `{ ok:false, code:'no-project' }`（KD-M1-28；`init:false` 面）；
- *                    梯②④（裸仓可解析、档缺）⇒ `{ ok:false, code:'missing' }`；歧义 ⇒ 同上
+ *                    梯②④（裸仓可解析、档缺）⇒ `{ ok:false, code:'missing' }`；工作区 ⇒ 同上
  *   档非法         → { ok:false, code:'invalid', message, errors }
  *
  * `writer` 由调用点**显式**传（生产调用点全传 `'main'`）：缺省 `'subagent'` 是写门 fail-closed
  * 缺省（KD-M1-3），误用缺省 ⇒「缺档 + 梯②④⑤」退化为 `init-failed`（拒翻——与 §2.8 F2 /
  * AC-20② 语义相反；T38 反证格）。
- * 失败码两态文案不同（KD-M1-28）：无项目 ⇒ 可在锚处落地 / 歧义 ⇒ 列候选不猜；文案族 =
- * 「项目不可解析」（稳定锚句 `/项目不可解析/`——拒翻面与报明面共用）。
+ * 失败码文案分野（KD-M1-28）：无项目 ⇒ 可在锚处落地 / 工作区 ⇒ 报明事实 + 点名项目根；文案族 =
+ * 「项目不可解析」（稳定锚句 `/项目不可解析/`）——**仅「档非法」格**（§2.8 F2 拒翻面唯一拒格）。
  * 边界：`readManifest` 的非 ENOENT 读错（权限 / 目录等）由 `projectView` 收为 `invalid`（非抛错
  * 契约——`readManifest` 返回语义零改）；本树只承诺上列六出口。
  * @param {string} [cwd] 会话锚（缺省 → 进程 cwd）
  * @returns {{ok:true, manifest:object, created:boolean}
- *   | {ok:false, code:'missing'|'invalid'|'no-project'|'ambiguous'|'init-failed',
+ *   | {ok:false, code:'missing'|'invalid'|'no-project'|'workspace'|'init-failed',
  *      message?:string, errors?:string[], candidates?:string[]}}
  */
 export function resolveEngineeringManifest(cwd, { writer = "subagent", init = true } = {}) {
@@ -223,24 +233,29 @@ export function resolveEngineeringManifest(cwd, { writer = "subagent", init = tr
       message: `项目不可解析：${MANIFEST_REL} 非法（fail-closed）：${(view.errors ?? []).join("；")}`,
     }
   }
-  if (view.state === "ambiguous") {
-    return { ok: false, code: "ambiguous", candidates: view.candidates, message: ambiguousProjectMessage(cwd, view.candidates) }
+  if (view.state === "workspace") {
+    return { ok: false, code: "workspace", candidates: view.candidates, message: workspaceProjectMessage(cwd, view.candidates) }
   }
   // 缺档（梯②④⑤）：init ⇒ 就地建档（内容 = DEFAULT_MANIFEST，经写门 writer:'main'）；!init ⇒ 归码。
   if (!init) return { ok: false, code: view.state === "no-project" ? "no-project" : "missing" }
   try {
-    return { ok: true, manifest: initManifest(cwd, { writer }), created: true }
+    const manifest = initManifest(cwd, { writer })
+    // #1376：建档支成功 ⇒ 同步广播（进程内声明 ∥ 范围缓存即刻随动——如 eng 翻转面结束后
+    // 同进程的声明复读；订阅方失败不阻断建档；失败路径不广播）。
+    for (const fn of manifestInitFns) { try { fn() } catch (e) { console.warn(`[manifest] init subscriber failed: ${e?.message ?? e}`) } }
+    return { ok: true, manifest, created: true }
   } catch (e) {
     return { ok: false, code: "init-failed", message: e?.message ?? String(e) }
   }
 }
 
-/** 歧义消息（文案族「项目不可解析」——KD-M1-28）：候选**全列**（绝对路径、按名排序）+ 指引
- *  显式指定目标——**不猜**（与报明行同族；拒翻面经 F3 明示面逐字转发）。 */
-function ambiguousProjectMessage(cwd, candidates) {
+/** 工作区消息（**事实行**——§2.5「单项目解析律」条 / §2.8 F2 工作区行）：念明下辖项目**全列**
+ *  （绝对路径、按名排序）+ 可执行下一步（点名项目根 / 目标路径）——报明事实，非错误框定
+ *  （不书「项目不可解析」/ 候选二义）。 */
+function workspaceProjectMessage(cwd, candidates) {
   const list = (candidates ?? []).map((c) => `- ${c}`).join("\n")
-  return `项目不可解析：会话锚 ${cwd} 下候选项目不是恰好一个（下列 ${(candidates ?? []).length} 个）——` +
-    `每个项目一份 ${MANIFEST_REL}；请显式指定目标项目（机制不猜）：\n${list}`
+  return `工作区：会话锚 ${cwd} 自身无 ${MANIFEST_REL}，下辖 ${(candidates ?? []).length} 个项目（下列全部）——` +
+    `每个项目一份 ${MANIFEST_REL}；请显式给出目标项目根或目标路径（动作按用点路径解析）：\n${list}`
 }
 
 /**

package/mcp/transport-stdio.mjs

@@ -5,7 +5,7 @@ import { spawn, spawnSync } from "node:child_process"
 import { rpcId, CALL_TIMEOUT_MS, withTimeout, quoteArg } from "./helpers.mjs"
 
 /** 退出相位标志（D-MC19）：模块加载期注册的 exit 钩子置位——退出相位无事件循环，
- *  只同步操作可落地（注册序恒早于宿主 cleanup——`thincoder-cli/src/tui/index.mjs:125`）。 */
+ *  只同步操作可落地（注册序恒早于宿主 cleanup——`thincoder-cli/src/tui/index.mjs` 的 `createExitCleanup`）。 */
 let exiting = false
 process.on("exit", () => { exiting = true })
 

package/mcp.mjs

@@ -93,14 +93,14 @@ async function createConnectedTransport(rawConfig, serverName) {
  *  零副作用：不进 _sessions、不动 agent.tools、无 onDead 挂钩；finally close
  *  （closed=true 使 onDead 重连不会触发）。initialize 与 tools/list 同受
  *  INIT_TIMEOUT_MS 约束（见 doInitialize）。不复用 connectMcpServer（避免污染
- *  session 幂等表）。 */
+ *  session 幂等表）。读数 = `{ ok, toolCount, tools, latencyMs }`（`tools` = 工具名数组——控制台具名读数，2026-10-14 走查轮增补）。 */
 export async function probeMcpServer(config) {
   const start = Date.now()
   let transport
   let mcpTools
   try {
     ;({ transport, mcpTools } = await createConnectedTransport(config, config.name ?? config.command ?? config.url ?? config.wsUrl))
-    return { ok: true, toolCount: mcpTools.length, latencyMs: Date.now() - start }
+     return { ok: true, toolCount: mcpTools.length, tools: mcpTools.map((t) => (typeof t?.name === "string" ? t.name : "")).filter((n) => n !== ""), latencyMs: Date.now() - start }
   } catch (error) {
     return { ok: false, error: error?.message ?? String(error) }
   } finally {

package/memory/code-search.mjs

@@ -8,7 +8,7 @@
 import { embed, embedTolerant, cosine, toBlob, fromBlob } from "../embedding.mjs"
 import { scanVectors, createTopK } from "./scan.mjs"
 import { normalizeOrigin } from "./origin.mjs"
-import { declaredPublicRoots } from "../conventions.mjs"
+import { declaredPublicRoots, loadProjectDeclaration, isExcludedRelPath, declaredIndexScope, isInDeclaredScope } from "../conventions.mjs"
 import { buildFtsQuery, ensureEmbeddings, EMBED_TEXT_MAX_LEN } from "./core.mjs"
 import { safeSliceUTF16 } from "../text-budget.mjs"
 import { DESC } from "../tools/shared.mjs" // #15 描述外置：文本单点 = tool-docs/code_search.md
@@ -35,13 +35,28 @@ export async function codeSearch(memory, query, { limit = 5 } = {}) {
   const origins = searchOrigins(memory)
   const ftsOriginFilter = origins.length === 1 ? `AND c.origin = ?` : origins.length > 1 ? `AND c.origin IN (${origins.map(() => "?").join(", ")})` : ""
   const originParams = origins
+  // §6.14 读面准入过滤（FTS 列表建成后 ∥ 向量 top-K push 前；两判据并列互不吞）：排除谓词（面①∪面⑥，
+  // 行 origin 为 `base`）∪ 声明范围门（面⑦——`isInDeclaredScope(path, declaredIndexScope(origin), origin)`，
+  // 逐 origin 预载一次）⇒「批次档 ∥ 范围外路径从未入索引」等价检索；存量行不删（收尾保护位）；窗口欠额接受。
+  const declCache = new Map()
+  const scopeCache = new Map()
+  const rowHidden = (origin, path) => {
+    const d = declCache.get(origin) ?? loadProjectDeclaration(origin)
+    declCache.set(origin, d)
+    if (isExcludedRelPath(path, d, origin)) return true
+    let scope = scopeCache.get(origin)
+    if (scope === undefined) { scope = declaredIndexScope(origin); scopeCache.set(origin, scope) }
+    return !isInDeclaredScope(path, scope, origin)
+  }
+  const ftsNeedOrigin = origins.length !== 1 // 单 origin 形 SQL 零改；多 origin ∥ 无过滤形补 `origin` 列（行 origin 随行可得）
 
   const ftsList = ftsQuery ? memory.db.prepare(`
-    SELECT c.rowid, c.path, c.language, c.symbol_name, c.content, c.line_start, c.line_end, bm25(code_chunks_fts) AS rank
+    SELECT c.rowid, c.path, c.language, c.symbol_name, c.content, c.line_start, c.line_end, bm25(code_chunks_fts) AS rank${ftsNeedOrigin ? ", c.origin" : ""}
     FROM code_chunks_fts JOIN code_chunks c ON c.rowid = code_chunks_fts.rowid
     WHERE code_chunks_fts MATCH ? ${ftsOriginFilter}
     ORDER BY rank LIMIT ?
-  `).all(ftsQuery, ...originParams, Math.max(limit * 4, 20)) : []
+  `).all(ftsQuery, ...originParams, Math.max(limit * 4, 20))
+    .filter((r) => !rowHidden(origins.length === 1 ? origins[0] : r.origin, r.path)) : []
 
   if (!memory.embedder) return ftsList.slice(0, limit)
 
@@ -70,7 +85,9 @@ export async function codeSearch(memory, query, { limit = 5 } = {}) {
   for (const origin of origins.length ? origins : [null]) {
     await scanVectors(memory.db, vecSql, origin ? [origin] : [], {
       cursorKey,
-      onRow: (r) => top.push({ id: r.rowid, rowid: r.rowid, score: cosine(qvec, fromBlob(r.embedding)) }),
+      onRow: (r) => { // §6.14 面⑥∪面⑦ 准入（top-K push 前；无过滤形行 origin = 游标键 `origin` 列）
+        if (!rowHidden(origin ?? r.origin, r.path)) top.push({ id: r.rowid, rowid: r.rowid, score: cosine(qvec, fromBlob(r.embedding)) })
+      },
     })
   }
   const vecList = top.list().map((c) => ({ rowid: c.id, score: c.score }))

package/memory/code-sync.mjs

@@ -11,7 +11,7 @@ import { ensureEmbeddings, invalidateStaleEmbeddings } from "./core.mjs"
 import { detectLanguage, _upsertCodeFile, _upsertDocFile, yieldTick } from "./code-index.mjs"
 import { isSkippedRelPath, extensionOf } from "./file-walk.mjs"
 import { createRowBudget, rowCountOfPath, sweepStaleRows } from "./sync-tail.mjs"
-import { loadProjectDeclaration, isExcludedRelPath, declaredPublicRoots } from "../conventions.mjs"
+import { loadProjectDeclaration, isExcludedRelPath, declaredPublicRoots, declaredIndexScope, isInDeclaredScope } from "../conventions.mjs"
 import { logEvent } from "../log.mjs"
 import { indexExtensions, listProjectFiles } from "./file-list.mjs"
 
@@ -53,6 +53,7 @@ export async function gitSync(memory, dir, opts = {}) {
 async function gitSyncDir(memory, dir, { onProgress } = {}) {
   const origin = normalizeOrigin(dir) // §6.11 写缝归一（git / 文件 I/O 用原样 dir；库面 origin 一律归一值）
   const decl = loadProjectDeclaration(dir)
+  const scope = declaredIndexScope(dir) // §6.14 面⑦ 范围门（diff 缝逐行判——见下）
   const { execFile: _execFile } = await import("node:child_process")
   const { code: codeExts, doc: docExts } = indexExtensions(dir)
   const gitRun = (args) => new Promise((resolve, reject) => {
@@ -95,7 +96,8 @@ async function gitSyncDir(memory, dir, { onProgress } = {}) {
     const abs = join(dir, rel)
     const ext = extensionOf(rel)
 
-    if (isSkippedRelPath(rel) || isExcludedRelPath(rel, decl, dir)) continue
+    // §6.14 准入三族同判（面④ 跳过段 ∥ 面①∪面⑥ 排除谓词 ∥ 面⑦ 声明范围）：范围外 = 不收录
+    if (isSkippedRelPath(rel) || isExcludedRelPath(rel, decl, dir) || !isInDeclaredScope(rel, scope, dir)) continue
 
     if (!codeExts.has(ext) && !docExts.has(ext)) { skipped++; continue }
 
@@ -210,8 +212,8 @@ async function codeSyncDir(memory, dir, { onProgress, yieldFn = yieldTick, nowFn
     }
   }
 
-  // §6.14 B6 ∕ M3：收尾 stale 循环（同款让出 + 面① 收尾保护位）——机制单源 = `sync-tail.mjs`
-  removed = await sweepStaleRows(memory, { table: "code_chunks", origin, indexed, seen, decl, base: dir, yieldFn, nowFn, yieldMs })
+  // §6.14 B6 ∕ M3：收尾 stale 循环（同款让出 + 收尾保护位：面①∪面⑥ 排除 ∪ 面⑦ 范围）——机制单源 = `sync-tail.mjs`
+  removed = await sweepStaleRows(memory, { table: "code_chunks", origin, indexed, seen, decl, base: dir, scope: declaredIndexScope(dir), yieldFn, nowFn, yieldMs })
 
   onProgress?.({ phase: "done", total: files.length, updated, removed, skipped, failed, overSizeSkipped, budgetSkipped: budgetSkipped.length })
   // §6.14 B7 维护口：模型键失配的失效**执行**（读面只判定降级——执行住同步尾；覆盖 /reindex ∕ 桌面 ∕ VSC 构建）
@@ -248,6 +250,7 @@ export async function reindexFile(memory, cwd, absPath) {
   if (rel === ".." || rel.startsWith("../")) return
   if (isSkippedRelPath(rel)) return
   if (isExcludedRelPath(rel, loadProjectDeclaration(cwd), cwd)) return // §6.14 面① 第三起效点（单文件缝零写）
+  if (!isInDeclaredScope(rel, declaredIndexScope(cwd), cwd)) return // §6.14 面⑦ 同址第三起效点（范围外单文件零写）
   // Declared extensions count for the single-file path too (union with built-ins).
   const { code: codeExts, doc: docExts } = indexExtensions(cwd)
 

package/memory/core.mjs

@@ -132,7 +132,7 @@ export function fetchEntry(memory, uid) {
   const lastColon = uid.lastIndexOf(":")
   const origin = lastColon > layer.length ? uid.slice(layer.length + 1, lastColon) : ""
   const path = lastColon > layer.length ? uid.slice(lastColon + 1) : uid.slice(layer.length + 1)
-  const projectOrigin = normalizeOrigin(memory.projectOrigin) // §6.11 读缝归一（uid 解析面零改——`:131` 余量兜底仍在）
+  const projectOrigin = normalizeOrigin(memory.projectOrigin) // §6.11 读缝归一（uid 解析面零改——`fetchEntry` 余量兜底仍在）
   if (layer === "project" && projectOrigin) {
     const r = memory.db.prepare(`SELECT type, title, content, tags, author FROM files WHERE layer = ? AND origin = ? AND path = ?`).get(layer, origin || projectOrigin, path)
     if (r) return { ...r, layer, id: uid }

package/memory/docs.mjs

@@ -12,7 +12,7 @@ import { _upsertDocFile, yieldTick } from "./code-index.mjs"
 import { markIndexedCommit, listProjectFiles, indexExtensions, declaredRootEntries } from "./code-sync.mjs"
 import { searchOrigins } from "./code-search.mjs"
 import { createRowBudget, rowCountOfPath, sweepStaleRows } from "./sync-tail.mjs"
-import { loadProjectDeclaration } from "../conventions.mjs" // 排除谓词本档不直调（经 `decl` 传 `sweepStaleRows`）
+import { loadProjectDeclaration, isExcludedRelPath, declaredIndexScope, isInDeclaredScope } from "../conventions.mjs" // 面① 谓词经 `decl` 传 `sweepStaleRows`；面⑥∪面⑦ 读面准入本档直调
 import { logEvent } from "../log.mjs"
 import { safeSliceUTF16 } from "../text-budget.mjs"
 import { DESC } from "../tools/shared.mjs" // #15 描述外置：文本单点 = tool-docs/*.md（DESC 单解析面，缺档抛错语义不变）
@@ -88,8 +88,8 @@ export async function syncDocRoot(memory, dir, { onProgress, yieldFn = yieldTick
     }
   }
 
-  // §6.14 B6 ∕ M3：收尾 stale 循环（同款让出 + 面① 收尾保护位）——机制单源 = `sync-tail.mjs`
-  removed = await sweepStaleRows(memory, { table: "doc_chunks", origin, indexed, seen, decl, base: dir, yieldFn, nowFn, yieldMs })
+  // §6.14 B6 ∕ M3：收尾 stale 循环（同款让出 + 收尾保护位：面①∪面⑥ 排除 ∪ 面⑦ 范围）——机制单源 = `sync-tail.mjs`
+  removed = await sweepStaleRows(memory, { table: "doc_chunks", origin, indexed, seen, decl, base: dir, scope: declaredIndexScope(dir), yieldFn, nowFn, yieldMs })
 
   onProgress?.({ phase: "done", total: files.length, updated, removed, skipped, failed, overSizeSkipped, budgetSkipped: budgetSkipped.length })
   // §6.14 B7 维护口：模型键失配的失效**执行**（读面只判定降级——执行住同步尾）
@@ -117,13 +117,28 @@ export async function docSearch(memory, query, { limit = 5, origins: originsOver
   const origins = originsOverride ?? searchOrigins(memory)
   const ftsOriginFilter = origins.length === 1 ? `AND d.origin = ?` : origins.length > 1 ? `AND d.origin IN (${origins.map(() => "?").join(", ")})` : ""
   const originParams = origins
+  // §6.14 读面准入过滤（FTS 列表建成后 ∥ 向量 top-K push 前；两判据并列互不吞）：排除谓词（面①∪面⑥，
+  // 行 origin 为 `base`）∪ 声明范围门（面⑦——`isInDeclaredScope(path, declaredIndexScope(origin), origin)`，
+  // 逐 origin 预载一次）⇒「批次档 ∥ 范围外路径从未入索引」等价检索；存量行不删（收尾保护位）；窗口欠额接受。
+  const declCache = new Map()
+  const scopeCache = new Map()
+  const rowHidden = (origin, path) => {
+    const d = declCache.get(origin) ?? loadProjectDeclaration(origin)
+    declCache.set(origin, d)
+    if (isExcludedRelPath(path, d, origin)) return true
+    let scope = scopeCache.get(origin)
+    if (scope === undefined) { scope = declaredIndexScope(origin); scopeCache.set(origin, scope) }
+    return !isInDeclaredScope(path, scope, origin)
+  }
+  const ftsNeedOrigin = origins.length !== 1 // 单 origin 形 SQL 零改；多 origin ∥ 无过滤形补 `origin` 列（行 origin 随行可得）
 
   const ftsList = ftsQuery ? memory.db.prepare(`
-    SELECT d.rowid, d.path, d.language, d.heading, d.content, d.line_start, d.line_end, bm25(doc_chunks_fts) AS rank
+    SELECT d.rowid, d.path, d.language, d.heading, d.content, d.line_start, d.line_end, bm25(doc_chunks_fts) AS rank${ftsNeedOrigin ? ", d.origin" : ""}
     FROM doc_chunks_fts JOIN doc_chunks d ON d.rowid = doc_chunks_fts.rowid
     WHERE doc_chunks_fts MATCH ? ${ftsOriginFilter}
     ORDER BY rank LIMIT ?
-  `).all(ftsQuery, ...originParams, Math.max(limit * 4, 20)) : []
+  `).all(ftsQuery, ...originParams, Math.max(limit * 4, 20))
+    .filter((r) => !rowHidden(origins.length === 1 ? origins[0] : r.origin, r.path)) : []
 
   if (!memory.embedder) return ftsList.slice(0, limit)
 
@@ -152,7 +167,9 @@ export async function docSearch(memory, query, { limit = 5, origins: originsOver
   for (const origin of origins.length ? origins : [null]) {
     await scanVectors(memory.db, vecSql, origin ? [origin] : [], {
       cursorKey,
-      onRow: (r) => top.push({ id: r.rowid, rowid: r.rowid, score: cosine(qvec, fromBlob(r.embedding)) }),
+      onRow: (r) => { // §6.14 面⑥∪面⑦ 准入（top-K push 前；无过滤形行 origin = 游标键 `origin` 列）
+        if (!rowHidden(origin ?? r.origin, r.path)) top.push({ id: r.rowid, rowid: r.rowid, score: cosine(qvec, fromBlob(r.embedding)) })
+      },
     })
   }
   const vecList = top.list().map((c) => ({ rowid: c.id, score: c.score }))

package/memory/file-list.mjs

@@ -1,12 +1,13 @@
 /**
  * memory/file-list.mjs — 项目文件清单面（自 `memory/code-sync.mjs` 迁出 · 2026-10-01 core 拆分批 #755 ∥ #786）。
  * 内容 = `indexExtensions`（内置扩展名表 ∪ 项目声明并集）∥ `listProjectFiles`（git 列面 + 非 git walk
- * 回退 + unlisted 计数；`index.excludePaths` §6.14 面① 双径过滤：git 列面筛行 ∥ walk 剪枝）——迁出块逐字。
+ * 回退 + unlisted 计数；准入 = 排除（§6.14 面①∪面⑥——git 列面筛行 ∥ walk 剪枝）+ 声明范围门
+ * （§6.14 面⑦——双径逐文件判 ∥ walk 不剪枝））——迁出块逐字。
  * 原档 `memory/code-sync.mjs` 经 `export { … } from` 转口保名（消费面 / 单元测试档 import 面零改）。
  */
 import { CODE_EXTS, DOC_EXTS } from "./schema.mjs"
 import { walkProjectFiles, isSkippedRelPath, extensionOf, createUnlistedTally, MAX_WALK_FILES } from "./file-walk.mjs"
-import { loadProjectDeclaration, isExcludedRelPath } from "../conventions.mjs"
+import { loadProjectDeclaration, isExcludedRelPath, declaredIndexScope, isInDeclaredScope } from "../conventions.mjs"
 import { logEvent } from "../log.mjs"
 
 /**
@@ -33,10 +34,13 @@ export function indexExtensions(dir) {
  * Returns { entries, unlisted }: `entries` = { abs, rel } pairs (rel relative to
  * dir); `unlisted` = files whose extension is in NO index list (count + sample),
  * the visible signal behind "my .xyz files are not searchable" (PORTABILITY PO-9).
- * Declared `index.excludePaths` (§6.14 面①) filters BOTH paths — git listing filters the
- * line set; the walk prunes excluded subtrees during traversal (no expansion, no budget).
+ * Both admission facets filter BOTH paths: the exclusion predicate (§6.14 面① declared
+ * `index.excludePaths` ∪ 面⑥ batch-record segments) — git listing filters the line set,
+ * the walk prunes excluded subtrees during traversal (no expansion, no budget); and the
+ * declared-scope gate (§6.14 面⑦ — un-declared ⇒ not indexed) — per-file on both paths,
+ * no pruning on the walk (a segment-sequence face may match at any depth).
  * `truncated` = the non-git walk hit its file cap (capped trees are logged, never
- * silently indexed-partial). opts.maxFiles = the walk cap (test seam).
+ * silently indexed-partial; out-of-scope files spend no budget). opts.maxFiles = the walk cap (test seam).
  */
 export async function listProjectFiles(dir, exts, { maxFiles } = {}) {
   const { execFile: _execFile } = await import("node:child_process")
@@ -44,6 +48,8 @@ export async function listProjectFiles(dir, exts, { maxFiles } = {}) {
   const { code, doc } = indexExtensions(dir)
   const decl = loadProjectDeclaration(dir)
   const excluded = (rel) => isExcludedRelPath(rel, decl, dir)
+  const scope = declaredIndexScope(dir) // §6.14 面⑦ 范围门（单源谓词；本根一份——条目集空 ⇒ 零索引）
+  const inScope = (rel) => isInDeclaredScope(rel, scope, dir)
   const tally = createUnlistedTally(new Set([...code, ...doc]))
 
   const files = []
@@ -58,7 +64,7 @@ export async function listProjectFiles(dir, exts, { maxFiles } = {}) {
     })).replace(/\\/g, "/")
   } catch {
     // Not a git repo → filesystem walk (FR15: the index must still be usable).
-    const walked = await walkProjectFiles(dir, exts, { knownExts: new Set([...code, ...doc]), isExcluded: excluded, ...(maxFiles !== undefined ? { maxFiles } : {}) })
+    const walked = await walkProjectFiles(dir, exts, { knownExts: new Set([...code, ...doc]), isExcluded: excluded, isInScope: inScope, ...(maxFiles !== undefined ? { maxFiles } : {}) })
     files.push(...walked.files)
     // The walk's cap must stay visible end-to-end (file-walk.mjs: "never silently
     // dropped") — a capped listing says so in the log, not only in a discarded flag.
@@ -78,7 +84,7 @@ export async function listProjectFiles(dir, exts, { maxFiles } = {}) {
       const p = line.trim()
       if (!p) continue
       const rel = p.replace(/\\/g, "/")
-      if (isSkippedRelPath(rel) || excluded(rel)) continue
+      if (isSkippedRelPath(rel) || excluded(rel) || !inScope(rel)) continue
       const ext = extensionOf(rel)
       if (!ext || !exts.has(ext)) { tally.note(rel); continue }
       files.push({ abs: joinPath(dir, rel), rel })

package/memory/file-walk.mjs

@@ -80,14 +80,18 @@ export function createUnlistedTally(knownExts) {
  * silently dropped.
  * @param {string} dir — project root
  * @param {Set<string>} exts — extensions to keep (lower-case, leading dot)
- * @param {{maxFiles?: number, knownExts?: Set<string>|null, isExcluded?: ((rel: string) => boolean)|null}} [opts]
+ * @param {{maxFiles?: number, knownExts?: Set<string>|null, isExcluded?: ((rel: string) => boolean)|null,
+ *   isInScope?: ((rel: string) => boolean)|null}} [opts]
  *   knownExts → also tally files whose extension is in NO index list
- *   isExcluded → caller-injected exclusion predicate (§6.14 面① 剪枝形): a hit prunes the
+ *   isExcluded → caller-injected exclusion predicate (§6.14 面① ∪ 面⑥ 剪枝形): a hit prunes the
  *   subtree (never expanded — zero readdir, no MAX_WALK_FILES budget spent) or drops the file
+ *   isInScope → caller-injected declared-scope predicate (§6.14 面⑦): a hit drops the FILE only —
+ *   never prunes (the code face matches a segment sequence at any depth, so an upper directory
+ *   carries no pruning judgement); an out-of-scope file spends no MAX_WALK_FILES budget
  * @returns {Promise<{files: {abs: string, rel: string}[], truncated: boolean,
  *   unlisted: {count: number, exts: {ext: string, count: number}[]}}>}
  */
-export async function walkProjectFiles(dir, exts, { maxFiles = MAX_WALK_FILES, knownExts = null, isExcluded = null } = {}) {
+export async function walkProjectFiles(dir, exts, { maxFiles = MAX_WALK_FILES, knownExts = null, isExcluded = null, isInScope = null } = {}) {
   const files = []
   const tally = knownExts ? createUnlistedTally(knownExts) : null
   let truncated = false
@@ -106,7 +110,8 @@ export async function walkProjectFiles(dir, exts, { maxFiles = MAX_WALK_FILES, k
         if (!isSkippedRelPath(rel) && !isExcluded?.(rel)) stack.push({ abs: join(cur.abs, ent.name), rel })
         continue
       }
-      if (!ent.isFile() || isSkippedRelPath(rel) || isExcluded?.(rel)) continue
+      // 面⑦ 范围门：只丢文件、不剪枝（段序列可命中任意深度 ⇒ 上层目录无剪枝判据）
+      if (!ent.isFile() || isSkippedRelPath(rel) || isExcluded?.(rel) || (isInScope !== null && !isInScope(rel))) continue
       const ext = extensionOf(ent.name)
       if (!ext || !exts.has(ext)) {
         tally?.note(rel)

package/memory/scan.mjs

@@ -90,7 +90,7 @@ export function createTopK(k) {
   }
 }
 
-/** 末行键值元组：任一键列缺失（`undefined` / `null`）⇒ `null`（防呆①：等价现 `:90`）。 */
+/** 末行键值元组：任一键列缺失（`undefined` / `null`）⇒ `null`（防呆①：等价现 `createTopK` 的 `list()`）。 */
 function cursorValues(keys, row) {
   if (!row) return null
   const out = []

package/memory/sweep.mjs

@@ -15,7 +15,7 @@
  * 折叠映射 + 备份路径 + 写后回读判据）。
  * **折叠规则单源 = §6.11 步 2**（同归一键内 `(path, line_start)`（`files` = `(layer, path)`）恰一行——
  * 保留 `mtime_ms` 最大者，并列取 `rowid` 最小者；FTS 由既有触发器随行同步）。
- * 探针 fail-safe：**仅 ENOENT 判亡**，其余错误（权限 / 非法路径）⇒ 保留（先例 `session-stale.mjs:124-127`）。
+ * 探针 fail-safe：**仅 ENOENT 判亡**，其余错误（权限 / 非法路径）⇒ 保留（先例 = `session-stale.mjs` 的 `pathExists`）。
  * 执行分工：真实库写 = 父侧 ops；本档只在传入的库句柄上作业，写闸 = `confirm` 单一入参。
  */
 import { existsSync, statSync } from "node:fs"

package/memory/sync-tail.mjs

@@ -8,14 +8,15 @@
  *     一行；真实行数——F-S14 ①）＋ `logEvent`；过 `INDEX_ORIGIN_ROW_CAP` 由调用方跳过列序后缀
  *     （**只停新增**——存量行不失效；跳过 = 不落行 ∕ 不记 mtime ⇒ 下趟重试）。
  *   · **stale 收尾循环**（`sweepStaleRows`）：同款时间片让出（§6.10 A2 口径——每 `SCAN_YIELD_CHECK_ROWS`
- *     行读钟，累计 ≥ `yieldMs` 即让出）＋ 面① **收尾保护位**（`isExcludedRelPath` 命中路径短路——
- *     被排除但存在的路径存量行不因声明删除，收敛仅经 `sweep --path`；缺省 `[]` ⇒ 恒不命中）。
+ *     行读钟，累计 ≥ `yieldMs` 即让出）＋ **收尾保护位**（两族并列：面①∪面⑥ `isExcludedRelPath` ∪
+ *     面⑦ `isInDeclaredScope` 命中路径短路——被排除 ∥ 范围外而文件仍在盘的路径，存量行不因声明
+ *     删除；收尾只删「不在盘 ∥ 不再列」的行，收敛仅经 `sweep --path`）。
  *
  * 零环：只引 `log.mjs` ∕ `conventions.mjs`（谓词）∕ `schema.mjs`（常量）∕ `scan.mjs`（预算常量）∕
  * `code-index.mjs`（`yieldTick`）——不引 `code-sync.mjs` ∕ `docs.mjs`。作业皆经传入句柄，档内零状态。
  */
 import { logEvent } from "../log.mjs"
-import { isExcludedRelPath } from "../conventions.mjs"
+import { isExcludedRelPath, isInDeclaredScope } from "../conventions.mjs"
 import { INDEX_ORIGIN_ROW_WARN, INDEX_ORIGIN_ROW_CAP } from "./schema.mjs"
 import { SCAN_YIELD_CHECK_ROWS, SCAN_YIELD_MS } from "./scan.mjs"
 import { yieldTick } from "./code-index.mjs"
@@ -65,16 +66,19 @@ export function createRowBudget(memory, origin, kind, dir, { baseOffset } = {})
  * §6.14 B6 ∕ M3：收尾 stale 删除循环（同款让出 + 收尾保护位）。返回删除行数（文件级）。
  * @param {object} memory 句柄
  * @param {{table: string, origin: string, indexed: Map<string, number>, seen: Set<string>, decl: object,
- *   base?: string|null, yieldFn?: Function, nowFn?: Function, yieldMs?: number}} opts
+ *   base?: string|null, scope?: readonly object[]|null, yieldFn?: Function, nowFn?: Function, yieldMs?: number}} opts
  *   `indexed` = 库内 path→mtime（开趟读）；`seen` = 本趟列文件；`decl` = `loadProjectDeclaration()` 回执；
- *   `base` = `indexed`/`seen` 里 `rel` 的相对基（调用面 dir——#700 等价换算；缺省 = 根相对）
+ *   `base` = `indexed`/`seen` 里 `rel` 的相对基（调用面 dir——#700 等价换算；缺省 = 根相对）；
+ *   `scope` = `declaredIndexScope(base)` 回执（面⑦ 保护位——缺省 `null` ⇒ **范围面不判**（仅面①∪面⑥ 保护，
+ *   既有调用方语义零改）；在场（含空数组 = 零条目）⇒ 范围外短路（存量行不删））
  */
-export async function sweepStaleRows(memory, { table, origin, indexed, seen, decl, base = null, yieldFn = yieldTick, nowFn = Date.now, yieldMs = SCAN_YIELD_MS }) {
+export async function sweepStaleRows(memory, { table, origin, indexed, seen, decl, base = null, scope = null, yieldFn = yieldTick, nowFn = Date.now, yieldMs = SCAN_YIELD_MS }) {
   let removed = 0
   let checked = 0
   let lastYieldAt = nowFn()
   for (const stale of indexed.keys()) {
-    if (!seen.has(stale) && !isExcludedRelPath(stale, decl, base)) {
+    // 面⑦ 保护位：`scope` 在场 ⇒「声明面内才删」（范围外短路）；缺省 ⇒ 范围面不判（既有调用方语义零改）
+    if (!seen.has(stale) && !isExcludedRelPath(stale, decl, base) && (scope === null || isInDeclaredScope(stale, scope, base))) {
       memory.db.prepare(`DELETE FROM ${table} WHERE origin = ? AND path = ?`).run(origin, stale)
       removed++
     }

package/model-specs.mjs

@@ -33,8 +33,8 @@ const MODEL_SPECS = [
   ["deepseek-flash",    { context: 1_000_000, maxOutput: 384_000, thinking: true,  prefixMode: true,  thinkApi: "type", reasoningEcho: "required", reasoningEffortEnum: ["low", "high", "max"], tempRange: [0, 2], multimodal: true }],
 // deepseek-v4.1-flash = qwen-plan channel name for DeepSeek V4.1-Flash (token-plan GET /models verified 2026-09-15) — same fields as the row above; ".1" ≠ "-" so plain prefix lookup misses the existing rows (D-PR25)
   ["deepseek-v4.1-flash", { context: 1_000_000, maxOutput: 384_000, thinking: true,  prefixMode: true,  thinkApi: "type", reasoningEcho: "required", reasoningEffortEnum: ["low", "high", "max"], tempRange: [0, 2], multimodal: true }],
-  // deepseek-v4-pro (V4-Pro-0813): fields unchanged — 视觉面 **未探**（不声明 multimodal——保守；
-  // 补探登记见 MODEL-SPECS.md §13.4）. From 2026-09-14 12:00 Beijing all requests route to V4.1-Flash.
+  // deepseek-v4-pro (V4-Pro-0813): fields unchanged — 视觉面 **未探**（不声明 multimodal——保守）.
+  // From 2026-09-14 12:00 Beijing all requests route to V4.1-Flash.
   ["deepseek-v4-pro",   { context: 1_000_000, maxOutput: 384_000, thinking: true,  prefixMode: true,  thinkApi: "type", reasoningEcho: "required", reasoningEffortEnum: ["low", "high", "max"], tempRange: [0, 2] }],
   // deepseek-v4-flash: RETIRED name — still accepted, served by V4.1-Flash today → aligned row
   ["deepseek-v4-flash", { context: 1_000_000, maxOutput: 384_000, thinking: true,  prefixMode: true,  thinkApi: "type", reasoningEcho: "required", reasoningEffortEnum: ["low", "high", "max"], tempRange: [0, 2], multimodal: true }],
@@ -63,7 +63,7 @@ const MODEL_SPECS = [
   // GLM series
   // GLM-5.3: thinking always-on (no "disabled"); effort converges to low/high/max — NOT the
   //          7-level glm-5.2 enum (verified vs docs.bigmodel.cn GLM-5.3 page, 2026-08).
-  //          视觉面 **未探**（不声明 multimodal——保守；补探登记见 MODEL-SPECS.md §13.4）。
+  //          视觉面 **未探**（不声明 multimodal——保守）。
   //          该事实 = 机制位 `thinkAlwaysOn`（单源 = `docs/core/design/MODEL-SPECS.md` §16.3）——**官方口径**
   //          （智谱 GLM-5.3 文档：thinking always-on、无 `disabled`）。
   ["glm-5.3",           { context: 1_000_000, maxOutput: 128_000, thinking: true,  thinkAlwaysOn: true, thinkApi: "type", reasoningEcho: "optional", reasoningEffortEnum: ["low", "high", "max"], tempRange: [0, 1], noUsageStream: true }],
@@ -199,9 +199,9 @@ const MODEL_SPECS = [
   // （多源网络转述级，本机无该渠道——行值 + 行注即标级）；thinking「always-on adaptive」= 弱源读数 ⇒ 零口径不落字段（§14.3）。
   ["claude-fable-5.1",  { context: 1_000_000, maxOutput: 128_000 }],
   // Gemini series (Google)
-  ["gemini-3-pro",      { context: 1_000_000, maxOutput: 64_000,  thinking: false, multimodal: true, format: "google", noUsageStream: true }],
-  ["gemini-2.5-pro",    { context: 2_000_000, maxOutput: 64_000,  thinking: false, multimodal: true, format: "google", noUsageStream: true }],
-  ["gemini-2.5-flash",  { context: 1_000_000, maxOutput: 64_000,  thinking: false, multimodal: true, format: "google", noUsageStream: true }],
+  ["gemini-3-pro",      { context: 1_000_000, maxOutput: 64_000,  thinking: true, multimodal: true, format: "google", noUsageStream: true }],
+  ["gemini-2.5-pro",    { context: 2_000_000, maxOutput: 64_000,  thinking: true, multimodal: true, format: "google", noUsageStream: true }],
+  ["gemini-2.5-flash",  { context: 1_000_000, maxOutput: 64_000,  thinking: true, multimodal: true, format: "google", noUsageStream: true }],
   // gemini-3.1-pro（2026-09-25 批 §14.2 #2-6 · §1.7.1 父侧交付）：**尺寸行**——context 1_048_576 / maxOutput 65_536（多源
   // 网络转述级，本机无该渠道——行值 + 行注即标级）；thinking「有·计入输出预算」= 弱源读数 ⇒ 零口径不落字段（§14.3）。
   ["gemini-3.1-pro",    { context: 1_048_576, maxOutput: 65_536 }],
@@ -350,7 +350,7 @@ export function providerSpec(provider) {
  *
  * Callers (as-of 2026-10-10): thincoder-core/agent/turn-loop.mjs (main loop) · thincoder-core/advisor/loop.mjs
  * (review mirror) · bench/lib/client.mjs (bench client) — each passes its own spec face; VSC 转口
- * (thincoder-vscode/src/specs.mjs:13/:17) 零调用点（父侧收口机械笔 · 可 revert）。
+ * (`thincoder-vscode/src/specs.mjs` 的 `providerSpec` ∕ `assistantToolCallMessage` 再导出) 零调用点（父侧收口机械笔 · 可 revert）。
  */
 export function assistantToolCallMessage(response, spec) {
   const msg = {