@feng0531/dsh-code-review 0.41.0 → 0.43.1

package/CHANGELOG.md

@@ -2,9 +2,17 @@
 
 本文件介绍对使用者有意义的变化。安装与参数见 [README](README.md)，本次发布正文见 [发布说明](RELEASE-NOTES.md)。历史提交和安装包保留在 [GitHub Releases](https://github.com/f-e-n-g-0531/dsh-code-review/releases)；本文不把开发日志当作功能介绍。
 
+## 0.43.1 — 已批准正文中的唯一定义位置
+
+命名导入可标出已批准目标正文里唯一的 function、const、let 或 class 位置。没有调用也会进入审查输入；重复、注释、重导出和跨侧正文不猜测。默认导出与命名导入不混用，同一行竞争及续行字符串拒绝提示。不新增读取权限，也不表示完整语义绑定。v0.43.0 候选在发布前复核被替代，未作为正式交付。
+
+## 0.42.0 — SVN 安全依赖链
+
+SVN 工作副本的自动上下文支持最多三层依赖及手动入口。精确路径探测替代全上下文索引；读取前检查节点与祖先身份，捕获后重新核验。歧义、未跟踪依赖及不安全属性不取得正文权限，各层共享数量、字节与时间上限。已正式发布；400 项回归、实际宿主、独立安装及四组 CI 通过，公开安装包与原包一致。
+
 ## 0.41.0 — Git 历史两侧依赖链
 
-启用 autoContext 后，提交和区间审查沿固定修改前后版本的静态依赖读取最多三层上下文。两侧共享预算；旧侧专用上下文保持旧侧权限，不读取工作区，不恢复排除或阻断内容。SVN 仍为直接导航。
+启用 autoContext 后，提交和区间审查沿固定修改前后版本的静态依赖读取最多三层上下文。两侧共享预算；旧侧专用上下文保持旧侧权限，不读取工作区，不恢复排除或阻断内容。SVN 仍为直接导航。已正式发布；393 项回归、实际宿主、独立安装及四组 CI 通过，公开安装包与原包一致。
 
 ## 0.40.0 — 手动上下文的依赖导航
 

package/CORE-ALIGNMENT-TASKS.md

@@ -23,22 +23,24 @@
 
 | 优先级 | 未完成项 | 验收重点 |
 |---|---|---|
-| 1 | 必要语义调用者、定义、别名及实例上下文 | 歧义不能猜测；不扩大到全仓无界扫描 |
-| 2 | Git 历史两侧及 SVN 的依赖链 | 旧新版本分别捕获；共享读取上限；排除文件不能重新进入 |
+| 1 | 必要语义调用者、别名及实例上下文 | 唯一定义位置已接入已批准正文；完整调用者与实例仍待验收 |
+| 2 | 剩余历史来源与旧侧组合 | Git 历史与 SVN 三层链已交付；其他旧侧来源仍待验收 |
 | 3 | 其他旧侧独有来源 | 来源、版本、权限与删除场景保持一致 |
 | 4 | 剩余语言与路径专用指导 | 只提示具体缺陷和反证；不照搬风格禁令 |
 | 5 | 剩余预算组合与端到端矩阵 | 分组、窗口、检索、多次审查的终态与覆盖一致 |
 | 后置 | 真实模型质量评测 | 保存真实输出，人工裁决，分开统计失败和未完成 |
 
-Git 工作区三层字面依赖链已实现并通过测试。这解决了“导入转发文件后，未取得后续实现正文”的部分问题，但仍不是完整定义绑定。本批还补齐了手动上下文作为链入口，真实 Git、服务与独立安装四项测试通过，388 项全量回归和实际宿主检查通过，已随 v0.40.0 正式交付。Git 历史三层链本批已实现，5 项独立安装验收及 393 项回归、实际宿主检查通过，待固定版本正式发布；SVN 尚未具备同样的链式能力。
+Git 工作区三层字面依赖链已实现并通过测试。这解决了“导入转发文件后，未取得后续实现正文”的部分问题，但仍不是完整定义绑定。本批还补齐了手动上下文作为链入口，真实 Git、服务与独立安装四项测试通过，388 项全量回归和实际宿主检查通过，已随 v0.40.0 正式交付。Git 历史三层链本批已实现，5 项独立安装验收及 393 项回归、实际宿主检查通过，已随 v0.41.0 正式交付；SVN 安全三层链本批已实现，6 项独立安装验收及节点属性变化专项通过，400 项完整回归与实际宿主检查通过，已随 v0.42.0 正式交付。唯一定义位置本批已接入审查输入，原候选 8 项独立安装验收及 403 项回归通过；发布前复核发现默认导出误匹配，已修正并增加反例，v0.43.1 待完整复验和正式发布。
 
 ## 当前验证结论
 
-- 最近完整回归：393 项通过。
+- 最近完整回归：403 项通过。
 - 实际 DSH 工具运行时检查通过；模型响应受控，不是质量成绩。
 - v0.39.0 独立安装包的真实 Git、服务与预算测试：5 项通过。
 - v0.39.1 已正式交付，包含 Git 工作区三层依赖能力。四组 CI 通过；npm、Release 与保存原包的 91,502 字节完全一致，SHA-256、SHA-512 和校验清单通过。v0.39.0 不单独计作已核验交付。
-- v0.40.0 已正式交付手动上下文依赖导航。四组 CI 与唯一发布通过，npm、Release 与保存原包的 91,901 字节完全一致，双哈希及校验清单通过。准确语义绑定、历史与 SVN 依赖链等差距仍保留。
+- v0.40.0 已正式交付手动上下文依赖导航。四组 CI 与唯一发布通过，npm、Release 与保存原包的 91,901 字节完全一致，双哈希及校验清单通过。准确语义绑定和剩余旧侧来源等差距仍保留。
+- v0.42.0 已正式交付 SVN 安全三层链。400 项回归、实际宿主、独立安装与四组 CI 通过；npm、Release 与原包的 94,404 字节一致，双哈希及校验清单通过。
+- v0.41.0 已正式交付 Git 历史两侧三层链。393 项回归、实际宿主、独立安装与四组 CI 通过；npm、Release 与原包的 93,202 字节一致，双哈希及校验清单通过。
 
 ## 不在范围内
 

package/DEVELOPMENT.md

@@ -19,6 +19,7 @@
 - 每个主文件的模型与检索阶段共享默认 120 秒；关联综合沿用相关主文件的生命周期，不因切换阶段重新计时。
 - 每阶段最多三轮检索；全局最多 50 次读取请求，返回内容累计 256 KiB，单次最多 64 KiB，读取最多 200 行。
 - Git 工作区依赖链最多三层、512 个精确路径查询、20 个候选、手动入口与自动依赖共享 1 MiB 正文；文件读取与最终复核共享 30 秒。
+- SVN 依赖链最多三层，以精确本地路径和安全正常节点捕获；512 路径、20 候选和上下文、1 MiB 来源及 30 秒含核验，拒绝切换、外部与特殊属性节点。
 - Git 历史依赖链同样最多三层，两侧共享 512 个路径、20 个候选和上下文、1 MiB 正文及 30 秒；只读取固定对象。
 - 引用方发现最多四个不重叠的非根目录；128 个候选正文共 1 MiB，目录索引最多 256 条／64 KiB，竞争路径最多 512 个。发现与复核共享 30 秒。
 

package/README.md

@@ -58,7 +58,7 @@ DSH 的只读代码审查插件。它比较 Git 或 SVN 中的代码变更，使
 | selectedPaths | 只审查选中的变更文件 | ["src/api.ts"] |
 | repositoryPath | 指定工作区内的子仓库 | "project-a" |
 | contextPaths | 手动加入理解代码所需的文件 | ["src/types.ts"] |
-| autoContext | 从变更及手动上下文寻找依赖；Git 工作区最多沿三层依赖链读取 | true |
+| autoContext | 从变更及手动上下文寻找依赖；Git 和 SVN 最多沿三层依赖链读取 | true |
 | callerScopePaths | 在指定目录中寻找引用变更文件的代码 | ["src/clients"] |
 | oldContextPaths | Git 历史审查中，只加入旧版本的上下文 | ["src/removed-helper.ts"] |
 | rulePaths | 加入项目审查规则，最多四个 UTF-8 Markdown 或文本文件 | ["review-rules.md"] |
@@ -67,7 +67,7 @@ DSH 的只读代码审查插件。它比较 Git 或 SVN 中的代码变更，使
 
 commit 与 baseRevision/targetRevision 不能同时使用。oldContextPaths 只能用于 Git 历史审查。
 
-自动上下文和引用方发现是保守的文本导航，不是编译器分析。动态导入、宏、重载、继承和实例方法可能无法解析；找到引用不等于证明函数实际被调用。Git 历史可沿修改前后两侧分别捕获最多三层依赖；SVN 目前仍限直接依赖。
+自动上下文和引用方发现是保守的文本导航，不是编译器分析。动态导入、宏、重载、继承和实例方法可能无法解析；找到引用不等于证明函数实际被调用。Git 历史可沿修改前后两侧分别捕获最多三层依赖；SVN 可沿安全的当前工作副本节点取得最多三层依赖，不读取 SVN 历史。已批准正文中的唯一命名声明会标出位置；同名或跨侧内容不猜测。
 
 ## 如何读报告
 

package/RELEASE-NOTES.md

@@ -1,22 +1,19 @@
-# v0.41.0 发布说明
+# v0.43.1 发布说明
 
-## 新增：Git 历史依赖链
+## 新增：已批准正文中的唯一定义位置
 
-审查 Git 提交或明确版本区间时，启用 autoContext 可以从修改前后源码分别沿静态导入和包含关系取得最多三层必要上下文。手动指定的历史上下文也可作为入口。
+命名导入现在可以标出目标文件里唯一的直接声明位置，包括 function、const、let 和 class。没有实际调用时也会保留该位置，供审查输入使用。
 
-所有正文来自固定 Git 对象，不读取当前工作区。两侧共享 512 个路径查询、20 个候选及上下文名额、1 MiB 来源正文和 30 秒捕获上限，不因切换版本重新计时。
+只检查已经批准的变更或上下文正文，不新增文件读取，也不扫描整个仓库。
 
-## 版本与证据边界
+## 限制
 
-- oldContextPaths 仍只批准旧侧，不自动增加新侧正文权限。
-- 删除文件复用原批准变更的旧侧身份，不重复作为上下文加入。
-- 排除、阻断或无法确定的依赖不会被恢复为可读证据。
-- 自动取得的普通历史上下文沿用原有两侧正文规则；各版本的依赖分别解析，不用工作区猜测。
-
-SVN 仍仅支持直接依赖。此功能是保守文本导航，不是完整定义绑定或语义调用图。
+- 默认导出不能匹配命名导入；同一行重复名称、别名冲突、注释、模板、续行字符串、重导出或未导入名称不生成定义位置。
+- 旧侧只使用旧正文，不会借用目标侧声明。
+- 这些位置仍是语法线索，不证明语义绑定、调用可达或因果。
 
 ## 验证
 
-真实 Git 测试覆盖三层深度、脏工作区隔离、旧侧身份、上下文名额、循环、取消及共享上限。完整回归、宿主检查、独立安装与四组 CI 是正式发布条件，不代表真实模型效果已达标。
+测试覆盖无调用的唯一定义、旧侧隔离、重复声明和审查输入过滤。全量回归、实际宿主、独立安装和四组 CI 是正式发布条件，不是模型效果成绩。
 
-使用方法见 [README](README.md)，维护流程见 [开发指南](DEVELOPMENT.md)。
+使用方法见 [README](README.md)，维护步骤见 [开发指南](DEVELOPMENT.md)。

package/index.mjs

@@ -12,7 +12,7 @@ export function apply(ctx, config = {}) {
   };
   ctx.tools.register({
     name: 'code_review_preview', description: 'Preview Git/SVN working-copy or Git commit/range review scope and model destination without sending source to a model. repositoryPath selects an explicit child repository relative to session workspace; file paths are repository-relative. Preview each repository separately. Show the preview before execution.',
-    parameters: { type: 'object', additionalProperties: false, properties: { reviewRounds: { type: 'integer', minimum: 1, maximum: 3, description: 'Explicit independent review passes, default 1. Preview discloses extra sends; later passes omit the first risk plan. Shares existing timeout, call and retrieval budgets, not provider reasoning effort. Bound to this preview; execute cannot override.' }, oldContextPaths: { type: 'array', maxItems: 20, items: { type: 'string' }, description: 'Explicit Git historical baseline-only blob context paths. Shares 20 context slots. No target text is inferred; selected old changes reuse their original identity, excluded changes cannot reenter. Unsupported on working reviews and SVN.' }, callerScopePaths: { type: 'array', minItems: 1, maxItems: 4, items: { type: 'string' }, description: 'Explicit non-root repository-relative directories for bounded tracked literal reverse import/include discovery. Git/SVN working review or Git fixed commit/range review. SVN uses offline normal nodes, rejects unsafe ancestor states and special/keyword properties. Historical sides share scan budgets and use object blobs only. Preview reads candidate bodies, including nonmatches; only captured matching context is sent. Navigation only, not complete caller coverage.' }, businessRequirement: { type: 'string', maxLength: 16384, description: 'Optional business constraint text up to 16KiB UTF8; untrusted data, not evidence or permission. Bound to preview and sent in review phases.' }, commit: { type: 'string', description: 'Git commit versus sole parent; root empty, merge requires range.' }, baseRevision: { type: 'string', description: 'Git old endpoint; requires targetRevision, mutually exclusive with commit.' }, targetRevision: { type: 'string', description: 'Git new endpoint, exact tree endpoints not merge-base. Explicit context uses target tree with available baseline provenance; oldContextPaths is baseline-only. Historical caller discovery scans fixed sides; explicit rules use target-tree blobs.' }, repositoryPath: { type: 'string', description: 'Workspace-relative explicit child Git/SVN repository root, forward slashes; omit for current repository.' }, selectedPaths: { type: 'array', items: { type: 'string' }, maxItems: 200 }, autoContext: { type: 'boolean', description: 'Opt in to tracked literal import/include context shown in preview. Working Git follows changed and explicitly selected context sources at most 3 dependency layers under shared 512 exact probes, 20 candidates/context slots, 1MiB source and 30s verification budget. Git history follows at most 3 baseline/target dependency layers with shared limits, object reads only; SVN remains direct navigation. Not semantic binding or complete definitions.' }, contextPaths: { type: 'array', items: { type: 'string' }, maxItems: 20 }, rulePaths: { type: 'array', items: { type: 'string' }, maxItems: 4 } } },
+    parameters: { type: 'object', additionalProperties: false, properties: { reviewRounds: { type: 'integer', minimum: 1, maximum: 3, description: 'Explicit independent review passes, default 1. Preview discloses extra sends; later passes omit the first risk plan. Shares existing timeout, call and retrieval budgets, not provider reasoning effort. Bound to this preview; execute cannot override.' }, oldContextPaths: { type: 'array', maxItems: 20, items: { type: 'string' }, description: 'Explicit Git historical baseline-only blob context paths. Shares 20 context slots. No target text is inferred; selected old changes reuse their original identity, excluded changes cannot reenter. Unsupported on working reviews and SVN.' }, callerScopePaths: { type: 'array', minItems: 1, maxItems: 4, items: { type: 'string' }, description: 'Explicit non-root repository-relative directories for bounded tracked literal reverse import/include discovery. Git/SVN working review or Git fixed commit/range review. SVN uses offline normal nodes, rejects unsafe ancestor states and special/keyword properties. Historical sides share scan budgets and use object blobs only. Preview reads candidate bodies, including nonmatches; only captured matching context is sent. Navigation only, not complete caller coverage.' }, businessRequirement: { type: 'string', maxLength: 16384, description: 'Optional business constraint text up to 16KiB UTF8; untrusted data, not evidence or permission. Bound to preview and sent in review phases.' }, commit: { type: 'string', description: 'Git commit versus sole parent; root empty, merge requires range.' }, baseRevision: { type: 'string', description: 'Git old endpoint; requires targetRevision, mutually exclusive with commit.' }, targetRevision: { type: 'string', description: 'Git new endpoint, exact tree endpoints not merge-base. Explicit context uses target tree with available baseline provenance; oldContextPaths is baseline-only. Historical caller discovery scans fixed sides; explicit rules use target-tree blobs.' }, repositoryPath: { type: 'string', description: 'Workspace-relative explicit child Git/SVN repository root, forward slashes; omit for current repository.' }, selectedPaths: { type: 'array', items: { type: 'string' }, maxItems: 200 }, autoContext: { type: 'boolean', description: 'Opt in to tracked literal import/include context shown in preview. Working Git follows changed and explicitly selected context sources at most 3 dependency layers under shared 512 exact probes, 20 candidates/context slots, 1MiB source and 30s verification budget. Git history follows at most 3 baseline/target dependency layers with shared limits, object reads only; SVN follows at most 3 safe offline current-side layers with exact path probes and node/ancestor identity verification, sharing limits; no SVN historical review. Not semantic binding or complete definitions.' }, contextPaths: { type: 'array', items: { type: 'string' }, maxItems: 20 }, rulePaths: { type: 'array', items: { type: 'string' }, maxItems: 4 } } },
     output,
     async execute(args, exec) { const preview = await service.preview(args, exec); return { json: JSON.stringify(preview), markdown: '' }; },
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feng0531/dsh-code-review",
-  "version": "0.41.0",
+  "version": "0.43.1",
   "private": false,
   "license": "SEE LICENSE IN LICENSE",
   "publishConfig": { "access": "public", "registry": "https://registry.npmjs.org/" },

package/src/context-relations.mjs

@@ -26,7 +26,7 @@ export function inferContextRelations(input, file) {
   const all = [primary, ...entries, ...competitors];
   if (all.length > 200) return [];
   const byId = new Map(all.map(f => [f.id, f.path]));
-  const imports = inferImportRelations(all).filter(e => e.specifier && (e.from === 'primary' || e.to === 'primary')).map(e => ({ fromPath: byId.get(e.from), toPath: byId.get(e.to), side: e.from === 'primary' ? e.side : 'context', line: e.line, specifier: e.specifier, callSites: e.callSites, bindingHints: e.bindingHints, reason: 'relative-import:approved-context' }));
+  const imports = inferImportRelations(all).filter(e => e.specifier && (e.from === 'primary' || e.to === 'primary')).map(e => ({ fromPath: byId.get(e.from), toPath: byId.get(e.to), side: e.from === 'primary' ? e.side : 'context', line: e.line, specifier: e.specifier, callSites: e.callSites, bindingHints: e.bindingHints, definitionHints: e.definitionHints, reason: 'relative-import:approved-context' }));
   const cpp = inferCppRelations(all).filter(e => e.from === 'primary' || e.to === 'primary').map(e => ({ fromPath: byId.get(e.from), toPath: byId.get(e.to), side: e.from === 'primary' ? e.side : 'context', line: e.line, specifier: e.specifier, reason: e.reason, contextVersion: 'approved-current-not-historical' }));
   return [...imports, ...cpp].slice(0, 2000);
 }

package/src/import-bindings.mjs

@@ -17,11 +17,50 @@ export function directImportBindings(lines, importLine, calls, targetText) {
   if (positions.some(call => [...lines[call.line - 1].matchAll(occurrences)].length !== 1)) continue;
   // Every other occurrence may be declaration, parameter, mutation or escape.
   if (lines.some((line, i) => i + 1 !== importLine && !positions.some(c => c.line === i + 1) && token.test(line))) continue;
-  const declarations = targets.map((line, i) => ({ line, number: i + 1 })).filter(item => /^\s*export\s+(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/.exec(item.line)?.[1] === imported);
+  const declarations = uniqueApprovedDeclarations(targets, imported);
   if (declarations.length !== 1) continue;
   const exportedToken = new RegExp('(^|[^A-Za-z0-9_$])' + imported.replaceAll('$', String.fromCharCode(92) + '$') + '([^A-Za-z0-9_$]|$)');
   if (targets.some((line, i) => i + 1 !== declarations[0].number && exportedToken.test(line))) continue;
-  result.push(...positions.map(call => ({ imported, local, importLine, callLine: call.line, declarationLine: declarations[0].number, confidence: 'conservative-syntax-only' })));
+  result.push(...positions.map(call => ({ imported, local, importLine, callLine: call.line, declarationLine: declarations[0].number, declarationKind: declarations[0].kind, confidence: 'conservative-syntax-only' })));
+ }
+ return result.slice(0, 20);
+}
+
+// Only one direct declaration inside already approved text. No extra file reads.
+export function uniqueApprovedDeclarations(lines, imported) {
+ if (!Array.isArray(lines) || lines.length > 20000 || typeof imported !== 'string' || !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(imported)) return [];
+ const text=lines.join(String.fromCharCode(10));
+ if (lines.some(line=>typeof line!=='string') || Buffer.byteLength(text)>256*1024 || text.includes('/*') || text.includes(String.fromCharCode(96)) || text.includes(String.fromCharCode(92,10)) || text.includes(String.fromCharCode(92,13,10))) return [];
+ const forms = [
+  ['function', /^\s*export\s+(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/],
+  ['const', /^\s*export\s+(?:const|let)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=/],
+  ['class', /^\s*export\s+class\s+([A-Za-z_$][A-Za-z0-9_$]*)(?=\s|\{)/]
+ ];
+ const found = [];
+ for (let i = 0; i < lines.length; i++) {
+  for (const [kind, pattern] of forms) {
+   if (pattern.exec(lines[i])?.[1] === imported) found.push({ number: i + 1, kind });
+  }
+ }
+ if (found.length !== 1) return [];
+ const occurrences=new RegExp('(^|[^A-Za-z0-9_$])'+imported.replaceAll('$','\\$')+'(?=[^A-Za-z0-9_$]|$)','g');
+ if ([...lines[found[0].number-1].matchAll(occurrences)].length!==1) return [];
+ const token = new RegExp('(^|[^A-Za-z0-9_$])' + imported.replaceAll('$', '\\$') + '([^A-Za-z0-9_$]|$)');
+ if (lines.some((line, i) => i + 1 !== found[0].number && token.test(line))) return [];
+ return found;
+}
+
+// Named imports only. Missing, duplicate, comment, or reexport names stay unresolved.
+export function namedImportDefinitions(importLine, targetText) {
+ if (typeof targetText !== 'string' || Buffer.byteLength(targetText) > 256 * 1024 || /[\x60]|\/\*/.test(targetText)) return [];
+ const match = /^\s*import\s+\{([^}]+)\}\s+from\s+(['"])[^'"]+\2\s*;?\s*(?:\/\/.*)?$/.exec(importLine);
+ if (!match) return [];
+ const names = match[1].split(',').map(part => /^\s*([A-Za-z_$][A-Za-z0-9_$]*)(?:\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*))?\s*$/.exec(part));
+ if (!names.length || names.some(item => !item) || new Set(names.map(item => item[1])).size !== names.length || new Set(names.map(item => item[2] ?? item[1])).size !== names.length) return [];
+ const lines = targetText.split(String.fromCharCode(10)), result = [];
+ for (const name of names) {
+  const found = uniqueApprovedDeclarations(lines, name[1]);
+  if (found.length === 1) result.push({ imported: name[1], declarationLine: found[0].number, declarationKind: found[0].kind, confidence: 'approved-unique-syntax-only' });
  }
  return result.slice(0, 20);
 }

package/src/import-relations.mjs

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { directImportBindings } from './import-bindings.mjs';
+import { directImportBindings, namedImportDefinitions } from './import-bindings.mjs';
 import { importedCallSites, indexStandaloneCalls } from './import-call-sites.mjs';
 
 const extensions = ['.mjs', '.cjs', '.js', '.jsx', '.ts', '.tsx'];
@@ -39,7 +39,8 @@ export function inferImportRelations(files) {
         const callSites = importedCallSites(lines, i + 1, callIndex);
         const targetText = (side === 'old' ? matches[0].left : matches[0].right)?.text;
         const bindingHints = directImportBindings(lines, i + 1, callSites, targetText);
-        edges.push({ from: file.id, to: matches[0].id, reason: 'relative-import:' + side + ':L' + (i + 1), side, line: i + 1, specifier: match[2], callSites, bindingHints });
+        const definitionHints = namedImportDefinitions(lines[i], targetText);
+        edges.push({ from: file.id, to: matches[0].id, reason: 'relative-import:' + side + ':L' + (i + 1), side, line: i + 1, specifier: match[2], callSites, bindingHints, definitionHints });
         if (callSites.length && edges.length < 2000) edges.push({ from: file.id, to: matches[0].id, reason: 'imported-call-syntax:' + side + ':L' + callSites.map(c => c.line).join(','), side, callSites });
         if (edges.length >= 2000) return edges;
       }

package/src/primary-input.mjs

@@ -36,7 +36,7 @@ export function preparePrimaryInput(input, file, { instructions, scope, grouping
     const relatedFiles = input.files.filter(f => f.id !== file.id && f.eligibility === 'reviewable' && group.fileIds.includes(f.id));
     if (relatedFiles.length) {
       const relations = grouping.links.filter(link => !link.split && group.fileIds.includes(link.from) && group.fileIds.includes(link.to));
-      const bindingRelations = inferImportRelations(input.files).filter(edge => edge.bindingHints?.length && (edge.from === file.id || edge.to === file.id) && group.fileIds.includes(edge.from) && group.fileIds.includes(edge.to)).map(({ from, to, side, bindingHints }) => ({ from, to, side, bindingHints }));
+      const bindingRelations = inferImportRelations(input.files).filter(edge => (edge.bindingHints?.length || edge.definitionHints?.length) && (edge.from === file.id || edge.to === file.id) && group.fileIds.includes(edge.from) && group.fileIds.includes(edge.to)).map(({ from, to, side, bindingHints, definitionHints }) => ({ from, to, side, bindingHints, ...(definitionHints?.length ? { definitionHints } : {}) }));
       const grouped = JSON.stringify({ ...base, relatedFiles, relations, bindingRelations, relationNotice: '命名和相对导入关系仅为源码线索，可能被同名局部变量遮蔽，不证明绑定、调用可达或因果；只报告主file的问题，不为relatedFiles重复生成发现。' });
       if (measure(grouped).fits) { payload = grouped; metadata.relatedFileIds = relatedFiles.map(f => f.id); }
       else metadata.groupFallback = 'input-budget';

package/src/snapshot.mjs

@@ -1,10 +1,10 @@
+import {captureSvnDependencyChain} from './svn-dependency-chain.mjs';
 import {captureDependencyChain} from './dependency-chain.mjs';
 import {captureSvnCallers} from './svn-caller-capture.mjs';
 import { captureCallers } from './caller-capture.mjs';
 import { validateCallerScopes } from './caller-index.mjs';
 import { bindBusinessRequirement, validateBusinessRequirement } from './business-requirement.mjs';
 import { gitContextIndex, svnContextIndex } from './tracked-context.mjs';
-import { contextCandidates } from './context-candidates.mjs';
 import { lstat, realpath } from 'node:fs/promises';
 import path from 'node:path';
 import { captureGitHistory } from './git-history.mjs';
@@ -49,22 +49,13 @@ export async function captureSnapshot(cwd, options = {}) {
   if (!Array.isArray(rulePaths) || rulePaths.some(name => contextPaths.includes(name))) throw new Error('Rule paths must be separate from context paths');
   const rules = await captureProjectRules(snapshot.root, rulePaths, { signal: options.signal, files: snapshot.files });
   const context = [];
-  let autoContext, index, explicitSeeds = [], indexOptions = options;
+  let autoContext, index, verifyDependencies, explicitSeeds = [], indexOptions = options;
   if (options.autoContext === true && type==='git') {
     const chain=await captureDependencyChain(snapshot.root,snapshot.files,options);
     explicitSeeds=chain.explicitSeeds;context.push(...chain.context);autoContext=chain.autoContext;index=chain.index;indexOptions=chain.indexOptions;
   } else if (options.autoContext === true) {
-    if(type==='git'){const probes=new Set();contextCandidates(snapshot.files,[],{onProbe:paths=>{for(const p of paths)probes.add(p);if(probes.size>512)throw new Error('Git context lookup limit exceeded');}});indexOptions={...options,probePaths:[...probes]};}
-    index = await (type === 'git' ? gitContextIndex : svnContextIndex)(snapshot.root, indexOptions);
-    const plan = contextCandidates(snapshot.files, index.paths);
-    autoContext = { ...plan, candidates: plan.candidates.filter(c => !contextPaths.includes(c.path) && !rulePaths.includes(c.path)), capturedPaths: [] };
-    for (const candidate of autoContext.candidates) {
-      if (context.length + new Set(contextPaths).size >= maxContextFiles) { candidate.status = 'blocked'; candidate.reason = 'Context file limit exceeded'; continue; }
-      try {
-        context.push({ path: candidate.path, ...await readLocal(snapshot.root, candidate.path, options) });
-        candidate.status = 'captured'; autoContext.capturedPaths.push(candidate.path);
-      } catch (error) { options.signal?.throwIfAborted(); candidate.status = 'blocked'; candidate.reason = error.message; }
-    }
+    const chain=await captureSvnDependencyChain(snapshot.root,snapshot.files,options);
+    explicitSeeds=chain.explicitSeeds;context.push(...chain.context);autoContext=chain.autoContext;indexOptions=chain.indexOptions;verifyDependencies=chain.verify;
   }
   for (const name of [...new Set(contextPaths)].sort()) {
     const changed = snapshot.files.find(f => f.path === name);
@@ -103,6 +94,7 @@ export async function captureSnapshot(cwd, options = {}) {
   if (index && (await (type === 'git' ? gitContextIndex : svnContextIndex)(snapshot.root, indexOptions)).fingerprint !== index.fingerprint) throw new Error('Tracked context index changed during capture');
   const verifiedRules = await captureProjectRules(snapshot.root, rulePaths, { signal: options.signal, files: snapshot.files });
   if (JSON.stringify(verifiedRules) !== JSON.stringify(rules)) throw new Error('Rules changed during capture');
+  if (verifyDependencies) await verifyDependencies();
   if (verifyCallers) await verifyCallers();
   const result = { ...snapshot, context, ...(callerDiscovery ? {callerDiscovery} : {}), ...(autoContext ? { autoContext } : {}), ...(rules.length ? { rules } : {}) };
   delete result.id;

package/src/svn-dependency-chain.mjs

@@ -0,0 +1,26 @@
+import {contextCandidates} from './context-candidates.mjs';
+import {svnCallerNode,svnCallerProbes} from './svn-caller-node.mjs';
+import {readLocal} from './content.mjs';
+// Exact local path probes only. Every body requires safe offline SVN node identity.
+export async function captureSvnDependencyChain(root,files,options={}){
+ const signal=AbortSignal.any([AbortSignal.timeout(30000),...(options.signal?[options.signal]:[])]),bounded={...options,signal,maxFileBytes:Math.min(options.maxFileBytes??256*1024,256*1024)};
+ const visited=new Set(files.map(f=>f.path)),reserved=new Set([...(options.contextPaths??[]),...(options.rulePaths??[])]),probes=new Set(),context=[],candidates=[],nodes=[];let frontier=[...files],bytes=0,truncated=false,index;
+ const limit=Math.min(options.maxContextFiles??20,20);if(new Set(options.contextPaths??[]).size>limit)throw new Error('Context file limit exceeded');
+ // Explicit context remains separately selected; safe normal nodes can seed navigation.
+ const explicitSeeds=[];for(const name of [...new Set(options.contextPaths??[])].sort()){
+  const changed=files.find(f=>f.path===name);if(changed){if(changed.eligibility!=='reviewable'||changed.rightExists===false)throw new Error('Context path is an excluded blocked or deleted change');continue;}
+  const node=await svnCallerNode(root,name,bounded),item={path:name,...await readLocal(root,name,bounded)};bytes+=item.bytes;if(bytes>1024*1024)throw new Error('SVN dependency source byte limit exceeded');nodes.push({path:name,fingerprint:node.fingerprint});explicitSeeds.push(item);visited.add(name);frontier.push({path:name,eligibility:'reviewable',right:item});
+ }
+ const onProbe=paths=>{for(const p of paths)probes.add(p);if(probes.size>512)throw new Error('SVN dependency lookup limit exceeded');};
+ for(let depth=1;depth<=3&&frontier.length;depth++){
+  for(let i=0;i<frontier.length;i+=200)contextCandidates(frontier.slice(i,i+200),[],{onProbe});index=await svnCallerProbes(root,[...probes],bounded);
+  const plans=[];for(let i=0;i<frontier.length;i+=200)plans.push(contextCandidates(frontier.slice(i,i+200),index.paths));const next=[];
+  for(const plan of plans){truncated ||= plan.truncated;for(const entry of plan.candidates){if(visited.has(entry.path)||reserved.has(entry.path))continue;visited.add(entry.path);const c={...entry,depth};candidates.push(c);if(candidates.length>20)throw new Error('SVN dependency candidate limit exceeded');
+   if(context.length+new Set(options.contextPaths??[]).size>=limit){c.status='blocked';c.reason='Context file limit exceeded';continue;}
+   try{const node=await svnCallerNode(root,entry.path,bounded),item={path:entry.path,...await readLocal(root,entry.path,bounded)};bytes+=item.bytes;if(bytes>1024*1024)throw new Error('SVN dependency source byte limit exceeded');context.push(item);nodes.push({path:item.path,fingerprint:node.fingerprint});c.status='captured';next.push({path:item.path,eligibility:'reviewable',right:item});}
+   catch(error){signal.throwIfAborted();if(error.message==='SVN dependency source byte limit exceeded')throw error;c.status='blocked';c.reason=error.message;}
+  }}frontier=next;
+ }if(frontier.length)truncated=true;
+ const verify=async()=>{for(const node of nodes)if((await svnCallerNode(root,node.path,bounded)).fingerprint!==node.fingerprint)throw new Error('SVN dependency node changed during capture');if(index&&(await svnCallerProbes(root,[...probes],bounded)).fingerprint!==index.fingerprint)throw new Error('SVN dependency resolution changed during capture');signal.throwIfAborted();};
+ return {context,explicitSeeds,indexOptions:bounded,verify,autoContext:{candidates,capturedPaths:context.map(c=>c.path),truncated,maxDepth:3,sourceBytes:bytes,probeCount:probes.size,notice:'Offline safe SVN current-side literal dependencies, at most 3 layers, 512 exact probes, 20 candidates/context slots, 1MiB source and 30s including verification. Not symbol binding or complete caller coverage.'}};
+}