@feng0531/dsh-code-review 0.67.0 → 0.69.0

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.69.0 — SVN 固定历史限定调用方发现
+
+callerScopePaths 支持固定 SVN 历史显式目录双侧扫描与同版本字面引用导航。只有匹配侧正文进入上下文，非匹配候选正文不发送模型；命名调用行/声明只绑定同侧已批准正文。可与autoContext组合且共享采集/精确探测/来源/上下文预算，规则与old-only限制保持。报告保留字面发现不完整状态，不冒充完整调用覆盖。
+
+## 0.68.0 — SVN 固定历史三层自动依赖
+
+autoContext 在 SVN 固定历史模式沿两侧 revision 独立捕获最多三层字面 import/include 依赖；用成功的有界父目录清单证明缺失，访问/正文失败直接传播，不以 stderr 猜测不存在。目录/多扩展名保留歧义，排除变更、规则、显式旧侧限制不回流。共享原上下文/读取预算并明确三层截断；预览披露有界清单元数据读取，不扫描全仓或读取工作树。历史调用方仍待实现。496 项串行回归、宿主、隔离安装和四矩阵 CI 通过；原产物/npm/Release 134,056 字节逐字节一致，双哈希、清单与冻结发布说明通过。
+
 ## 0.67.0 — SVN 工作副本显式 mergeinfo 导航
 
-将有界 mergeinfo 来源路径/区间导航用于本地 BASE/工作侧属性变化，预览与结构化报告披露两侧元数据；复用历史解析，不扩大读取或网络范围。排除/阻断节点不回流，无效或超限保持明确状态、不输出部分导航。不是有效继承、归属或合并提交完整审查证明；全面 SVN 缺口继续保留。
+将有界 mergeinfo 来源路径/区间导航用于本地 BASE/工作侧属性变化，预览与结构化报告披露两侧元数据；复用历史解析，不扩大读取或网络范围。排除/阻断节点不回流，无效或超限保持明确状态、不输出部分导航。不是有效继承、归属或合并提交完整审查证明；全面 SVN 缺口继续保留。489 项串行回归、宿主、隔离安装与四矩阵 CI 通过；原产物/npm/Release 130,866 字节逐字节一致，双哈希、清单与冻结发布说明通过。
 
 ## 0.66.1 — SVN 合并记录变化下的工作副本导航修复
 

package/CORE-ALIGNMENT-TASKS.md

@@ -32,7 +32,9 @@
 
 ## 当前验证结论
 
-- 最近完整回归：488 项通过。
+- 最近完整回归：496 项通过。
+- v0.68.0 已交付固定 SVN 历史三层 autoContext，逐侧正文/来源固定、父目录有界清单确认精确节点，不吞访问失败，不读工作树。496 项串行回归、宿主、隔离安装和四矩阵 CI 通过；原产物/npm/Release 134,056 字节逐字节一致，双哈希、清单与冻结发布说明通过。历史调用方和全面 SVN 其他缺口继续。
+- v0.67.0 已交付 SVN 工作副本 BASE/工作侧 mergeinfo 的有界显式导航、预览与报告披露，不扩大来源读取或将导航视为审查证明。489 项串行回归、宿主、隔离安装和四矩阵 CI 通过；原产物/npm/Release 130,866 字节逐字节一致，双哈希、清单与冻结发布说明通过。全面 SVN 目标仍未完成。
 - v0.66.1 已修复根目录 mergeinfo 条目在工作副本依赖/调用方候选的非法路径失败，祖先仅合并记录属性变化经双侧比较后允许且仍入指纹。488 项串行回归、宿主、隔离安装和四矩阵 CI 通过；原产物/npm/Release 130,642 字节逐字节一致，双哈希、清单与冻结发布说明通过。全面 SVN 目标仍未完成。
 - v0.66.0 已交付批准历史 mergeinfo 属性的有界来源/区间导航，不展开 revision、不读取来源，也不证明有效继承/归属/审查覆盖。485 项串行回归、宿主、隔离安装及四矩阵 CI 通过；原产物/npm/Release 129,866 字节逐字节一致，双哈希、清单与冻结发布说明通过。跨 URL 分支比较、自动历史链/调用方等仍未完成。
 - v0.65.0 已交付固定 SVN 历史文件/目录类型替换，各侧节点类型/正文/属性与来源独立绑定，预览披露且后代覆盖保护保留。482 项串行回归、宿主、隔离安装和四矩阵 CI 通过；原产物/npm/Release 128,792 字节逐字节一致，双哈希、清单与冻结发布说明通过。未提交替换、自动历史链/调用方和其他全面 SVN 缺口仍待实现。

package/README.md

@@ -68,9 +68,9 @@ DSH 的只读代码审查插件。它比较 Git 或 SVN 中的代码变更，使
 
 commit 与 baseRevision/targetRevision 不能同时使用。oldContextPaths 只能用于 Git/SVN 固定历史审查，不适用于工作副本模式。
 
-SVN 历史模式使用独立参数，不可与 Git 参数混用。示例：`{"svnRevision":"7315","svnAllowNetwork":true}`；或 `{"svnBaseRevision":"7314","svnTargetRevision":"7315","svnAllowNetwork":true}`。只接受固定十进制 revision，不接受 HEAD、日期或相对别名。仅选择工作副本根当前仓库 URL，不支持任意远端 URL；预览会读取明确端点的仓库元数据与源码（远端需显式许可），但不发送模型。历史模式支持显式 contextPaths 与 rulePaths：上下文按目标版和已核验的旧版正文分别保存，规则只读取目标版；共享 20 上下文名额与原采集预算。oldContextPaths 可显式选择仅旧版正文，没有目标占位，选中旧变更复用原身份；不能恢复已排除/阻断/无旧侧的变更。autoContext 和历史 callerScopePaths 仍未支持，不能回退到当前工作副本。目录新增/删除按后代逐项覆盖，凭据、链接/特殊节点与超限继续拒绝。
+SVN 历史模式使用独立参数，不可与 Git 参数混用。示例：`{"svnRevision":"7315","svnAllowNetwork":true}`；或 `{"svnBaseRevision":"7314","svnTargetRevision":"7315","svnAllowNetwork":true}`。只接受固定十进制 revision，不接受 HEAD、日期或相对别名。仅选择工作副本根当前仓库 URL，不支持任意远端 URL；预览会读取明确端点的仓库元数据与源码（远端需显式许可），但不发送模型。历史模式支持显式 contextPaths 与 rulePaths：上下文按目标版和已核验的旧版正文分别保存，规则只读取目标版；共享 20 上下文名额与原采集预算。oldContextPaths 可显式选择仅旧版正文，没有目标占位，选中旧变更复用原身份；不能恢复已排除/阻断/无旧侧的变更。autoContext 可沿旧/新固定 revision 独立捕获最多三层字面依赖；精确子节点通过固定版父目录 immediates 清单确认，可能读取有界同目录元数据但不读取无关正文。共享 512 精确探测、512 清单条目、20 候选/上下文名额、1MiB依赖来源及原历史命令/字节/时间预算，缺失与访问失败不混淆。历史 callerScopePaths 支持限定目录的旧/新固定版字面引用发现：预览扫描两侧候选正文，包括非匹配文件，只有命中侧上下文发送模型；共享256索引条目、128扫描文件、1MiB导航来源和512精确探测及原采集预算，可与autoContext组合。不能回退到当前工作副本；声明导航只用同版本目标正文，不证明完整调用覆盖。目录新增/删除按后代逐项覆盖，凭据、链接/特殊节点与超限继续拒绝。
 
-自动上下文和引用方发现是保守的文本导航，不是编译器分析。动态导入、宏、重载、继承和实例方法可能无法解析；找到引用不等于证明函数实际被调用。历史调用方的命名导入线索逐侧对应相同版本声明，标明 side/revision；缺少该版本的批准正文不回退另一侧。Git 历史可沿修改前后两侧分别捕获最多三层依赖；SVN 工作副本模式可沿安全的当前节点取得最多三层依赖；初始固定 revision 历史模式尚不支持历史依赖导航。已批准正文中的唯一命名声明和唯一 default 导出会标出位置；同名、重导出或跨侧内容不猜测。命名空间导入后的独立成员调用可导航至唯一命名声明；写入、逃逸或间接调用不推定绑定，不是实例类型分析。
+自动上下文和引用方发现是保守的文本导航，不是编译器分析。动态导入、宏、重载、继承和实例方法可能无法解析；找到引用不等于证明函数实际被调用。历史调用方的命名导入线索逐侧对应相同版本声明，标明 side/revision；缺少该版本的批准正文不回退另一侧。Git 历史可沿修改前后两侧分别捕获最多三层依赖；SVN 工作副本模式可沿安全的当前节点取得最多三层依赖；固定 revision 历史模式沿旧/新侧分别最多三层依赖，不把一侧正文或工作树替代另一侧。已批准正文中的唯一命名声明和唯一 default 导出会标出位置；同名、重导出或跨侧内容不猜测。命名空间导入后的独立成员调用可导航至唯一命名声明；写入、逃逸或间接调用不推定绑定，不是实例类型分析。
 
 ## 如何读报告
 

package/RELEASE-NOTES.md

@@ -1,14 +1,15 @@
-# v0.67.0 发布说明
+# v0.69.0 发布说明
 
-## SVN 工作副本显式 mergeinfo 导航
+## SVN 固定历史限定调用方发现
 
-本地 BASE/工作侧属性变更中的 svn:mergeinfo 现在也生成有界来源路径与 revision 区间导航，并在预览及结构化报告中披露。
+`callerScopePaths` 支持固定 SVN revision 审查的显式目录字面引用发现，不读取当前工作树或任意来源分支。
 
-- 复用固定历史解析规则：16KiB、100 来源路径、500 区间；不展开 revision 或读取来源分支。
-- 仅处理可审查、已批准节点的属性；排除/阻断条目不回流。
-- 无效/超限导航状态明确，不静默裁剪；原属性正文审查不受导航解析结果替代。
-- 独立 SVN 测试验证预览零发送、工作状态不变与报告披露。
+- 旧/新 revision 分别扫描批准目录内候选正文，包括不匹配文件；预览零模型发送，执行仅发送命中侧上下文。
+- 同侧命名调用行与声明导航只使用该版本已批准正文，不回退另一侧。
+- 规则、已排除变更、显式旧侧限定与上下文名额继续约束捕获；目录竞争项保持歧义。
+- 与 autoContext 组合，调用方上下文可继续沿各侧依赖链读取；共享 256 索引记录、128 扫描文件、512 精确探测、1MiB 导航来源和原采集命令/元数据/字节/时间预算。
+- 报告保留字面引用发现不完整状态。主窗口完成不等于完整调用覆盖；不改为虚假的 completed。
 
-导航不是有效继承 mergeinfo、源码归属或合并提交审查覆盖的证明。跨 URL 比较、自动历史链/调用方、未提交替换及其他全面 SVN 项仍见 [支持矩阵](SVN-SUPPORT-MATRIX.md)，目标尚未完成。
+跨 URL 分支比较、未提交工作副本替换、关键字映射及其他全面 SVN 项仍在 [支持矩阵](SVN-SUPPORT-MATRIX.md)，目标尚未完成。
 
-用法见 [README](README.md)。
+使用见 [README](README.md)。

package/SVN-SUPPORT-MATRIX.md

@@ -26,9 +26,9 @@
 | switched、externals、稀疏/混合 revision | 多数拒绝；调用方/依赖链要求祖先 normal | 第四批：明确仓库边界与独立来源，禁止隐式跨仓读取 |
 | 固定 revision 单提交 | v0.62.0 已发布 svnRevision：r-1/r 固定对象、UUID/URL/peg/operative revision 逐侧绑定，正文不读工作树；远端显式 svnAllowNetwork。472 项串行回归、宿主、隔离安装、四矩阵 CI 及原包/npm/Release 125,486 字节、双哈希/清单/发布说明通过。历史上下文/规则/调用方尚未支持 | 第五批：新增明确 SVN 参数与冻结身份 |
 | 固定 revision 区间 | v0.62.0 已发布 svnBaseRevision/svnTargetRevision，固定树端点 summary+逐侧 cat/proplist，目录后代与属性纳入预算，不建临时工作树；同上述完整发布验证。分支间不同 URL 和历史上下文尚未支持 | 第五批：固定树端点与逐路径差异 |
-| 分支复制、分支间比较、合并来源 | v0.66.0 已发布批准历史 mergeinfo 属性的来源路径/区间导航，保留非继承标记、有界不展开 revision、不读取分支源码；invalid/limited 明确且不裁剪。485 项串行回归、宿主、隔离安装、四矩阵 CI 与原包/npm/Release 129,866 字节、双哈希/清单/发布说明通过；本地新增工作副本 BASE/工作侧属性的同一有界导航及预览/报告披露，待 v0.67.0 发布。有效继承 mergeinfo、跨 URL 比较、源码归属/合并提交覆盖仍未支持 | 第六批：URL/peg/operative revision 与 mergeinfo 导航披露 |
+| 分支复制、分支间比较、合并来源 | v0.66.0 已发布批准历史 mergeinfo 属性的来源路径/区间导航，保留非继承标记、有界不展开 revision、不读取分支源码；invalid/limited 明确且不裁剪。485 项串行回归、宿主、隔离安装、四矩阵 CI 与原包/npm/Release 129,866 字节、双哈希/清单/发布说明通过；v0.67.0 已发布工作副本 BASE/工作侧属性的同一有界导航及预览/报告披露；489 项串行回归、宿主、隔离安装、四矩阵 CI 与原包/npm/Release 130,866 字节、双哈希/清单/发布说明通过。有效继承 mergeinfo、跨 URL 比较、源码归属/合并提交覆盖仍未支持 | 第六批：URL/peg/operative revision 与 mergeinfo 导航披露 |
 | 当前三层依赖与限定目录调用方 | v0.66.1 已发布根目录仅 mergeinfo 变化下的自动依赖/限定调用方修复：根目录不作源码候选，祖先双侧属性仅 mergeinfo 差异可通过且入指纹；其他属性/unsafe 状态仍拒绝。488 项串行回归、宿主、隔离安装、四矩阵 CI 与原包/npm/Release 130,642 字节、双哈希/清单/发布说明通过。其他祖先/混合状态继续待验证 | 第四批补祖先/混合状态组合 |
-| 历史两侧上下文与调用方 | v0.63.0 已发布显式 contextPaths 固定双侧来源及目标 rulePaths，UUID/URL/peg/operative revision/原字节与正文 hash 验证，禁止脏工作树与排除项回流。477 项串行回归、宿主、隔离安装、四矩阵 CI 与原包/npm/Release 127,355 字节、双哈希/清单/发布说明通过。v0.64.0 已发布 oldContextPaths 旧侧独有正文、SVN 来源专用校验、预览披露与选中删除身份复用；479 项串行回归、宿主、隔离安装、四矩阵 CI 与原包/npm/Release 127,879 字节、双哈希/清单/发布说明通过；自动三层历史链与历史调用方仍未实现 | 第六批：逐侧固定版本，不能回退至工作副本 |
+| 历史两侧上下文与调用方 | v0.63.0 已发布显式 contextPaths 固定双侧来源及目标 rulePaths，UUID/URL/peg/operative revision/原字节与正文 hash 验证，禁止脏工作树与排除项回流。477 项串行回归、宿主、隔离安装、四矩阵 CI 与原包/npm/Release 127,355 字节、双哈希/清单/发布说明通过。v0.64.0 已发布 oldContextPaths 旧侧独有正文、SVN 来源专用校验、预览披露与选中删除身份复用；479 项串行回归、宿主、隔离安装、四矩阵 CI 与原包/npm/Release 127,879 字节、双哈希/清单/发布说明通过；本地开发了注入固定版本 lookup/read 能力的三层历史依赖导航核心，逐侧共享512探测/20候选/1MiB来源与上下文名额；排除项、旧侧限定和规则隔离测试通过。v0.68.0 已发布三层逐侧历史 autoContext，固定父目录有界清单 lookup，清单成功证明缺失、访问失败直接传播，真实旧/新版本链和脏工作树隔离通过。496 项串行回归、宿主、隔离安装、四矩阵 CI 与原包/npm/Release 134,056 字节、双哈希/清单/发布说明通过；本地新增逐侧固定 revision 调用方核心能力接口：共享256索引/128扫描/1MiB正文/512侧探测，命中侧才捕获正文，规则/变更排除与old-only限制保留，同侧命名调用声明导航测试通过；本地已接入固定 SVN 显式目录递归清单/同侧正文、统一30秒/512命令/元数据/正文预算，caller 与依赖共享精确探测及来源上限，真实集成专项13项通过；502项串行全量回归通过；尚需合并autoContext组合验收、工具文档、宿主/隔离安装及发布门禁，未发布，不算该批验收完成 | 第六批：逐侧固定版本，不能回退至工作副本 |
 | 真正 r7314→r7315 样本 | 用户未提供隔离副本路径；本地类似复现不是该样本验收 | 获得路径后只读生成预览，不自动发送模型 |
 
 ## 每批发布门禁

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: { svnRevision: { type: 'string', description: 'SVN fixed numeric revision reviewed against revision minus one. Requires SVN working-copy root; no HEAD/date aliases.' }, svnBaseRevision: { type: 'string', description: 'SVN fixed numeric old endpoint; requires svnTargetRevision, mutually exclusive with svnRevision and Git revision parameters.' }, svnTargetRevision: { type: 'string', description: 'SVN fixed numeric new endpoint, greater than old endpoint. Fixed repository objects, not working-copy text. Supports explicitly selected target context with verified baseline provenance and target rules; explicit old-only context is also supported with fixed SVN provenance; automatic context and historical callers remain unsupported.' }, svnAllowNetwork: { type: 'boolean', description: 'Explicit opt-in to read the working-copy repository URL at fixed SVN revisions during preview/execute; preview sends no source to a model. Required for non-file repository URLs; default denies remote access. Does not allow checkout/update/merge or arbitrary URLs.' }, 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/SVN historical baseline-only context paths. Git uses fixed blobs; SVN uses UUID/URL/peg/operative revision/hash. Shares 20 context slots. No target text is inferred; selected old changes reuse original identity, excluded changes cannot reenter. Unsupported on working reviews.' }, 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 } } },
+    parameters: { type: 'object', additionalProperties: false, properties: { svnRevision: { type: 'string', description: 'SVN fixed numeric revision reviewed against revision minus one. Requires SVN working-copy root; no HEAD/date aliases.' }, svnBaseRevision: { type: 'string', description: 'SVN fixed numeric old endpoint; requires svnTargetRevision, mutually exclusive with svnRevision and Git revision parameters.' }, svnTargetRevision: { type: 'string', description: 'SVN fixed numeric new endpoint, greater than old endpoint. Fixed repository objects, not working-copy text. Supports explicitly selected target context with verified baseline provenance and target rules; explicit old-only context is also supported with fixed SVN provenance; autoContext follows at most three independent fixed-side dependency layers with bounded parent listings and shared capture budgets; callerScopePaths supports bounded fixed-side SVN historical literal discovery; only matched sides captured, never complete caller coverage.' }, svnAllowNetwork: { type: 'boolean', description: 'Explicit opt-in to read the working-copy repository URL at fixed SVN revisions during preview/execute; preview sends no source to a model. Required for non-file repository URLs; default denies remote access. Does not allow checkout/update/merge or arbitrary URLs.' }, 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/SVN historical baseline-only context paths. Git uses fixed blobs; SVN uses UUID/URL/peg/operative revision/hash. Shares 20 context slots. No target text is inferred; selected old changes reuse original identity, excluded changes cannot reenter. Unsupported on working reviews.' }, 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 fixed Git/SVN historical 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.67.0",
+  "version": "0.69.0",
   "private": false,
   "license": "SEE LICENSE IN LICENSE",
   "publishConfig": { "access": "public", "registry": "https://registry.npmjs.org/" },

package/src/service.mjs

@@ -49,7 +49,7 @@ export function createReviewService(llm, { capture = captureSnapshot, now = Date
         while (previews.size >= maxPreviews) previews.delete(previews.keys().next().value);
         const previewId = randomUUID();
         previews.set(previewId, { ...current, target, options, rounds, snapshotId: snapshot.id, expires: now() + ttlMs });
-        return { ...(options.businessRequirement!==undefined?{businessRequirement:{text:options.businessRequirement,hash:hash(options.businessRequirement),bytes:Buffer.byteLength(options.businessRequirement)}}:{}), previewId, plan, snapshotId: snapshot.id, repositoryRoot: snapshot.root, vcs: snapshot.vcs, ...(snapshot.history ? { history: snapshot.history } : {}), ...(snapshot.mergeSources ? {mergeSources:snapshot.mergeSources} : {}), model: current.route, modelSendingEnabled: allowModelSending, files: snapshot.files.map(f => ({ path: f.path, eligibility: f.eligibility, reason: f.reason, ...(f.rawStatus==='replaced'&&snapshot.history?.vcs==='svn'?{oldKind:f.oldKind,newKind:f.newKind,nodeNotice:f.nodeNotice}:{}), ...(f.blockCode ? {blockCode:f.blockCode} : {}), ...(f.copySource ? {copySource:f.copySource,copyNotice:f.copyNotice} : {}) })), contextPaths: snapshot.context.map(c => c.path), ...(options.oldContextPaths !== undefined ? {oldContextPaths:options.oldContextPaths,oldContextSources:snapshot.context.filter(c=>c.oldOnly).map(c=>({path:c.path,side:'context-old',revision:c.oldRevision,...(c.oldSvnSource?{svnSource:c.oldSvnSource}:{blobOid:c.oldBlobOid}),hash:c.oldHash}))} : {}), ...(snapshot.callerDiscovery ? {callerDiscovery:snapshot.callerDiscovery} : {}), ...(snapshot.autoContext ? { autoContext: snapshot.autoContext } : {}), rules: (snapshot.rules ?? []).map(({ path, hash }) => ({ path, hash })), notice: (options.oldContextPaths !== undefined ? 'oldContextPaths仅为baseline旧侧正文，无目标侧替代；选中变更复用原old身份，旧侧不能证明新侧行为。' : '') + (snapshot.callerDiscovery ? 'callerScopePaths已授权预览读取限定目录内tracked候选正文，包括不匹配文件；非匹配正文不发送模型，匹配捕获上下文会发送。仅字面引用导航，不是函数调用或完整调用覆盖。' : '') + (enableRiskPlanning ? '执行按plan阈值决定风险假设规划，小变更可跳过独立规划但仍主审并复核；计划不是证据，所有阶段共享原预算。' : '') + '执行会向上述模型提供方发送可审查文件两侧内容、预览列出的显式/自动上下文、所选项目规则全文及预览业务需求文本。模型可在该快照范围内多轮只读检索，不读取范围外文件；候选生成后会进行证据与反证复核，两阶段各最多3轮检索，共享每文件120秒和总模型调用100次预算；复核不能证明缺陷成立。plan.reviewRounds为独立审查工作量，非模型reasoning effort；后续轮不带首轮风险计划，所有轮共享原超时与预算。plan仅预检初始输入，ready不代表已审查；minimumCalls不含后续检索/复核/动态业务综合；多文件可先进行业务分组，分组失败保留原组并记录限制，动态综合数执行前未知，实际预算可能不足。请先向用户展示范围，获得确认后执行。' };
+        return { ...(options.businessRequirement!==undefined?{businessRequirement:{text:options.businessRequirement,hash:hash(options.businessRequirement),bytes:Buffer.byteLength(options.businessRequirement)}}:{}), previewId, plan, snapshotId: snapshot.id, repositoryRoot: snapshot.root, vcs: snapshot.vcs, ...(snapshot.history ? { history: snapshot.history } : {}), ...(snapshot.mergeSources ? {mergeSources:snapshot.mergeSources} : {}), model: current.route, modelSendingEnabled: allowModelSending, files: snapshot.files.map(f => ({ path: f.path, eligibility: f.eligibility, reason: f.reason, ...(f.rawStatus==='replaced'&&snapshot.history?.vcs==='svn'?{oldKind:f.oldKind,newKind:f.newKind,nodeNotice:f.nodeNotice}:{}), ...(f.blockCode ? {blockCode:f.blockCode} : {}), ...(f.copySource ? {copySource:f.copySource,copyNotice:f.copyNotice} : {}) })), contextPaths: snapshot.context.map(c => c.path), ...(options.oldContextPaths !== undefined ? {oldContextPaths:options.oldContextPaths,oldContextSources:snapshot.context.filter(c=>c.oldOnly).map(c=>({path:c.path,side:'context-old',revision:c.oldRevision,...(c.oldSvnSource?{svnSource:c.oldSvnSource}:{blobOid:c.oldBlobOid}),hash:c.oldHash}))} : {}), ...(snapshot.callerDiscovery ? {callerDiscovery:snapshot.callerDiscovery} : {}), ...(snapshot.autoContext ? { autoContext: snapshot.autoContext } : {}), rules: (snapshot.rules ?? []).map(({ path, hash }) => ({ path, hash })), notice: (snapshot.history?.vcs==='svn'&&options.autoContext===true?'SVN历史autoContext为精确依赖定位读取固定版本父目录有界清单，包含同目录非匹配名字元数据；仅匹配捕获正文发送模型，不扫描全仓，不用工作树替代历史版本。':'') + (options.oldContextPaths !== undefined ? 'oldContextPaths仅为baseline旧侧正文，无目标侧替代；选中变更复用原old身份，旧侧不能证明新侧行为。' : '') + (snapshot.callerDiscovery ? 'callerScopePaths已授权预览读取限定目录内tracked候选正文，包括不匹配文件；非匹配正文不发送模型，匹配捕获上下文会发送。仅字面引用导航，不是函数调用或完整调用覆盖。' : '') + (enableRiskPlanning ? '执行按plan阈值决定风险假设规划，小变更可跳过独立规划但仍主审并复核；计划不是证据，所有阶段共享原预算。' : '') + '执行会向上述模型提供方发送可审查文件两侧内容、预览列出的显式/自动上下文、所选项目规则全文及预览业务需求文本。模型可在该快照范围内多轮只读检索，不读取范围外文件；候选生成后会进行证据与反证复核，两阶段各最多3轮检索，共享每文件120秒和总模型调用100次预算；复核不能证明缺陷成立。plan.reviewRounds为独立审查工作量，非模型reasoning effort；后续轮不带首轮风险计划，所有轮共享原超时与预算。plan仅预检初始输入，ready不代表已审查；minimumCalls不含后续检索/复核/动态业务综合；多文件可先进行业务分组，分组失败保留原组并记录限制，动态综合数执行前未知，实际预算可能不足。请先向用户展示范围，获得确认后执行。' };
       } finally { busy = false; }
     },
     async execute(args, exec) {

package/src/svn-history-callers.mjs

@@ -0,0 +1,60 @@
+import {validateCallerScopes} from './caller-index.mjs';
+import {callerCandidates} from './caller-candidates.mjs';
+import {relativePath,hash} from './content.mjs';
+import {isSecretPath} from './secret-path.mjs';
+
+// Fixed revision capabilities only. All failures propagate; no worktree fallback.
+export async function svnHistoryCallers(files,history,scopes,context,{index,lookup,read,signal,maxContextFiles=20,rulePaths=[]}={}) {
+ const approved=validateCallerScopes(scopes);
+ if(!Array.isArray(files)||files.length>200||!Array.isArray(context)||context.length>maxContextFiles||!Number.isSafeInteger(maxContextFiles)||maxContextFiles<1||maxContextFiles>20||![index,lookup,read].every(fn=>typeof fn==='function')||!Array.isArray(rulePaths)||!history||!['base','target'].every(k=>typeof history[k]==='string'&&/^(0|[1-9][0-9]*)$/.test(history[k])&&Number.isSafeInteger(Number(history[k]))))throw new Error('Invalid SVN historical caller capability or budget');
+ const changed=new Set(files.map(f=>f.path)),rules=new Set(rulePaths),candidates=[],scanned=[],allProbes=new Set();
+ let records=0,scanBytes=0;
+ for(const [side,revision]of [['old',history.base],['new',history.target]]){
+  signal?.throwIfAborted();const entries=await index(approved,revision);
+  if(!Array.isArray(entries))throw new Error('Invalid SVN historical caller index');
+  const seen=new Set(),sources=[];
+  for(const entry of entries){
+   if(++records>256)throw new Error('SVN historical caller index limit exceeded');
+   const name=relativePath(entry?.path);
+   if(!approved.some(scope=>name.startsWith(scope+'/'))||seen.has(name)||!['file','dir'].includes(entry.kind))throw new Error('Unsafe SVN historical caller index');
+   seen.add(name);
+   if(entry.kind!=='file'||changed.has(name)||rules.has(name)||isSecretPath(name)||!/\.(mjs|cjs|js|jsx|ts|tsx|c|cc|cpp|cxx|h|hh|hpp|hxx|shader|hlsl|glsl|cginc|hlsli|compute)$/i.test(name))continue;
+   if(scanned.length>=128)throw new Error('SVN historical caller scan count exceeded');
+   const value=await read(name,revision);signal?.throwIfAborted();
+   if(typeof value?.content?.text!=='string'||value.kind!=='file'||value.source?.operativeRevision!==revision)throw new Error('Invalid fixed SVN caller body');
+   const bodyBytes=value.content.bytes??Buffer.byteLength(value.content.text);
+   if(!Number.isSafeInteger(bodyBytes)||bodyBytes<0||bodyBytes>256*1024||Buffer.byteLength(value.content.text)>256*1024)throw new Error('Invalid fixed SVN caller size');
+   scanBytes+=bodyBytes;
+   if(scanBytes>1024*1024)throw new Error('SVN historical caller scan source limit exceeded');
+   const source={path:name,...value.content,svnSource:value.source,side,revision};sources.push(source);scanned.push(source);
+  }
+  const targets=files.map(file=>{
+   const kind=side==='old'?file.oldKind:file.newKind,body=side==='old'?file.left:file.right;
+   return {...file,right:kind==='file'?body:undefined,rightExists:kind==='file'&&typeof body?.text==='string'};
+  });
+  const requested=callerCandidates(targets,sources,[]).probePaths,present=[];
+  for(const name of requested){
+   signal?.throwIfAborted();allProbes.add(JSON.stringify([revision,name]));if(allProbes.size>512)throw new Error('SVN historical caller probe limit exceeded');
+   const node=await lookup(name,revision);
+   if(node!==null&&(!node||!['file','dir'].includes(node.kind)))throw new Error('Invalid fixed SVN caller probe');
+   if(node)present.push(name); // Directories remain resolution competitors.
+  }
+  const plan=callerCandidates(targets,sources,present);
+  for(const candidate of plan.candidates){
+   const receipt={...candidate,side,revision,status:'pending'};candidates.push(receipt);
+   const source=sources.find(value=>value.path===candidate.fromPath);
+   let item=context.find(value=>value.path===source.path);
+   if(item?.oldOnly&&side==='new'){receipt.status='blocked';receipt.reason='Explicit old-only context cannot approve target caller';continue;}
+   if(!item&&context.length>=maxContextFiles){receipt.status='blocked';receipt.reason='Context file limit exceeded';continue;}
+   const existing=side==='old'?item?.oldText:item?.text;
+   if(existing!==undefined&&existing!==source.text)throw new Error('Fixed SVN caller context content mismatch');
+   if(!item){item={path:source.path};context.push(item);}
+   if(side==='new')Object.assign(item,{text:source.text,hash:source.hash,bytes:source.bytes,encoding:source.encoding,revision,svnSource:source.svnSource});
+   else Object.assign(item,{oldText:source.text,oldHash:hash(source.text),oldRevision:revision,oldSvnSource:source.svnSource});
+   receipt.status='captured';
+  }
+ }
+ // Only matched sides are retained. A new-side match never approves an old body.
+ for(const item of context)if(item.text===undefined&&item.oldText!==undefined)item.oldOnly=true;
+ return {scopes:approved,scanned:scanned.map(({path,hash,bytes,revision,side,svnSource})=>({path,hash,bytes,revision,side,svnSource})),scannedBytes:scanBytes,records,probeCount:allProbes.size,candidates,capturedPaths:[...new Set(candidates.filter(c=>c.status==='captured').map(c=>c.fromPath))].sort(),incomplete:true,notice:'Fixed-side literal references in explicit scopes only; nonmatches scanned but not captured. Not function calls, semantic binding or complete caller coverage.'};
+}

package/src/svn-history-dependencies.mjs

@@ -0,0 +1,83 @@
+import {contextCandidates} from './context-candidates.mjs';
+import {relativePath,hash} from './content.mjs';
+import {isSecretPath} from './secret-path.mjs';
+
+// Injected fixed-revision capabilities must verify UUID/URL/revisions themselves.
+// A null lookup means proven absence, never a swallowed read/authentication error.
+export async function svnHistoryDependencies(files, history, context, {lookup, read, signal, maxContextFiles=20, rulePaths=[]}={}) {
+ if(typeof lookup!=='function'||typeof read!=='function'||!Array.isArray(files)||files.length>200||!Array.isArray(context)||!Number.isSafeInteger(maxContextFiles)||maxContextFiles<1||maxContextFiles>20||context.length>maxContextFiles||!Array.isArray(rulePaths))throw new Error('Invalid SVN dependency capabilities or budget');
+ const reserved=new Set(rulePaths);for(const name of reserved)relativePath(name);
+ if(!history||!['base','target'].every(key=>typeof history[key]==='string'&&/^(0|[1-9][0-9]*)$/.test(history[key])&&Number.isSafeInteger(Number(history[key]))))throw new Error('Invalid fixed SVN dependency revisions');
+ const cache={old:new Map(),new:new Map()},visited={old:new Set(),new:new Set()},candidates=new Map();
+ let probes=0,bytes=0,truncated=false;
+ const probe=async(side,name)=>{
+  relativePath(name);signal?.throwIfAborted();
+  if(!cache[side].has(name)){
+   if(++probes>512)throw new Error('SVN historical dependency probe limit exceeded');
+   const node=await lookup(name,side==='old'?history.base:history.target);
+   if(node!==null&&(!node||!['file','dir'].includes(node.kind)))throw new Error('Invalid SVN historical dependency probe result');
+   cache[side].set(name,node);
+  }
+  return cache[side].get(name);
+ };
+ const charge=text=>{bytes+=Buffer.byteLength(text);if(bytes>1024*1024)throw new Error('SVN historical dependency source limit exceeded');};
+ const nextSource=(name,text)=>({path:name,eligibility:'reviewable',right:{text}});
+ let frontier={old:[],new:[]};
+ for(const file of files){
+  if(file.eligibility!=='reviewable'||file.kind==='dir'&&file.path==='.')continue;
+  for(const side of ['old','new']){
+   const kind=side==='old'?file.oldKind:file.newKind,text=(side==='old'?file.left:file.right)?.text;
+   if(kind==='file'&&typeof text==='string'){visited[side].add(file.path);frontier[side].push(nextSource(file.path,text));}
+  }
+ }
+ for(const item of context)for(const side of ['old','new']){
+  const text=side==='old'?item.oldText:item.text;if(typeof text==='string'){visited[side].add(item.path);frontier[side].push(nextSource(item.path,text));charge(text);}
+ }
+ for(let depth=1;depth<=3;depth++){
+  const next={old:[],new:[]};
+  for(const side of ['old','new']){
+   signal?.throwIfAborted();
+   const requested=new Set();
+   for(let i=0;i<frontier[side].length;i+=200)contextCandidates(frontier[side].slice(i,i+200),[],{onProbe:names=>names.forEach(name=>requested.add(name))});
+   for(const name of requested)await probe(side,name);
+   const present=[...cache[side]].filter(([,node])=>node!==null).map(([name])=>name);
+   for(let i=0;i<frontier[side].length;i+=200){
+    const plan=contextCandidates(frontier[side].slice(i,i+200),present,{includeChanged:true});truncated ||= plan.truncated;
+    for(const entry of plan.candidates){
+     if(visited[side].has(entry.path))continue;visited[side].add(entry.path);
+     let candidate=candidates.get(entry.path);
+     if(!candidate){if(candidates.size>=20)throw new Error('SVN historical dependency candidate limit exceeded');candidate={...entry,depth,sides:[]};candidates.set(entry.path,candidate);}
+     const receipt={side,revision:side==='old'?history.base:history.target,status:'pending'};candidate.sides.push(receipt);
+     if(reserved.has(entry.path)){receipt.status='blocked';receipt.reason='Rule path cannot become dependency context';continue;}
+     const changed=files.find(file=>file.path===entry.path);
+     if(changed){
+      const kind=side==='old'?changed.oldKind:changed.newKind,text=(side==='old'?changed.left:changed.right)?.text;
+      if(changed.eligibility!=='reviewable'||kind!=='file'||typeof text!=='string'){receipt.status='blocked';receipt.reason='Dependency conflicts with excluded blocked or unavailable change';continue;}
+      receipt.status='reused-change';next[side].push(nextSource(entry.path,text));continue;
+     }
+     if(isSecretPath(entry.path)){receipt.status='blocked';receipt.reason='Credential dependency excluded';continue;}
+     if(cache[side].get(entry.path)?.kind!=='file'){receipt.status='blocked';receipt.reason='Dependency is not a file';continue;}
+     let item=context.find(value=>value.path===entry.path);
+     // Explicit old-only context never grants target text, even if navigation sees it.
+     if(item?.oldOnly&&side==='new'){receipt.status='blocked';receipt.reason='Explicit old-only context cannot approve target side';continue;}
+     if(!item&&context.length>=maxContextFiles){receipt.status='blocked';receipt.reason='Context file limit exceeded';continue;}
+     const presentText=side==='old'?item?.oldText:item?.text;
+     if(typeof presentText==='string'){receipt.status='reused-context';next[side].push(nextSource(entry.path,presentText));continue;}
+     const value=await read(entry.path,receipt.revision);signal?.throwIfAborted();
+     if(typeof value?.content?.text!=='string'||!value.source||value.source.operativeRevision!==receipt.revision)throw new Error('Invalid fixed SVN dependency body');
+     charge(value.content.text);
+     if(!item){item={path:entry.path};context.push(item);}
+     if(side==='new')Object.assign(item,value.content,{revision:history.target,svnSource:value.source});
+     else Object.assign(item,{oldText:value.content.text,oldHash:hash(value.content.text),oldRevision:history.base,oldSvnSource:value.source});
+     receipt.status='captured';next[side].push(nextSource(entry.path,value.content.text));
+    }
+   }
+  }
+  frontier=next;
+  if(!next.old.length&&!next.new.length)break;
+  if(depth===3)truncated=true;
+ }
+ for(const candidate of candidates.values())candidate.status=candidate.sides.some(side=>side.status==='blocked')?'blocked':candidate.sides.some(side=>side.status==='captured')?'captured':'reused-context';
+ for(const item of context)if(item.text===undefined&&item.oldText!==undefined)item.oldOnly=true;
+ return {candidates:[...candidates.values()].sort((a,b)=>a.path.localeCompare(b.path)),capturedPaths:[...candidates].filter(([,c])=>c.sides.some(s=>s.status==='captured')).map(([name])=>name).sort(),probeCount:probes,sourceBytes:bytes,maxDepth:3,truncated,notice:'Fixed side/revision literal navigation only; no current worktree, semantic binding or complete dependency coverage.'};
+}

package/src/svn-history-lookup.mjs

@@ -0,0 +1,31 @@
+import path from 'node:path';
+import {relativePath} from './content.mjs';
+
+// A successful immediate-parent listing proves absence within the visible scope.
+// Access errors are propagated, not interpreted using stderr or localized text.
+export function fixedSvnLookup({list,signal,maxEntries=512}={}) {
+ if(typeof list!=='function'||!Number.isSafeInteger(maxEntries)||maxEntries<1||maxEntries>512)throw new Error('Invalid SVN historical lookup capability');
+ const directories=new Map();let entries=0;
+ const lookup=async(name,revision)=>{
+  relativePath(name);signal?.throwIfAborted();
+  if(typeof revision!=='string'||!/^(0|[1-9][0-9]*)$/.test(revision)||!Number.isSafeInteger(Number(revision)))throw new Error('Invalid SVN lookup revision');
+  const parent=path.posix.dirname(name),key=JSON.stringify([revision,parent]);
+  if(!directories.has(key)){
+   if(parent!=='.'){
+    const node=await lookup(parent,revision);
+    if(!node||node.kind!=='dir')return null;
+   }
+   const records=await list(parent,revision);signal?.throwIfAborted();
+   if(!Array.isArray(records))throw new Error('Invalid fixed SVN directory listing');
+   const children=new Map();
+   for(const record of records){
+    if(++entries>maxEntries)throw new Error('SVN historical directory entry budget exceeded');
+    if(typeof record?.name!=='string'||record.name.includes('/')||relativePath(record.name)!==record.name||!['file','dir'].includes(record.kind)||children.has(record.name))throw new Error('Invalid fixed SVN directory entry');
+    children.set(record.name,{kind:record.kind});
+   }
+   directories.set(key,children);
+  }
+  return directories.get(key).get(path.posix.basename(name))??null;
+ };
+ return {lookup,usage:()=>({directories:directories.size,entries})};
+}

package/src/svn-history.mjs

@@ -5,6 +5,10 @@ import {hash,decode,relativePath} from './content.mjs';
 import {isSecretPath,assertNonSecretPath} from './secret-path.mjs';
 import {captureProjectRules} from './project-rules.mjs';
 import {snapshotMergeSources} from './svn-mergeinfo.mjs';
+import {fixedSvnLookup} from './svn-history-lookup.mjs';
+import {svnHistoryDependencies} from './svn-history-dependencies.mjs';
+import {svnHistoryCallers} from './svn-history-callers.mjs';
+import {validateCallerScopes} from './caller-index.mjs';
 
 const revision = value => {
   if (typeof value !== 'string' || !/^(0|[1-9][0-9]*)$/.test(value) || !Number.isSafeInteger(Number(value))) throw new Error('SVN revision must be a fixed nonnegative decimal string');
@@ -43,7 +47,7 @@ export function mergeSvnHistoryRecord(previous, item) {
 export async function captureSvnHistory(cwd,options={}) {
   const range=svnHistoryRange(options);
   if (options.svnAllowNetwork!==undefined && typeof options.svnAllowNetwork!=='boolean') throw new Error('Invalid SVN network opt-in');
-  if (options.autoContext===true || options.callerScopePaths!==undefined) throw new Error('SVN historical automatic context and callers are not supported yet');
+  if (options.callerScopePaths!==undefined) validateCallerScopes(options.callerScopePaths);
   const contextPaths=options.contextPaths??[],oldContextPaths=options.oldContextPaths??[],rulePaths=options.rulePaths??[],maxContextFiles=options.maxContextFiles??20;
   if(!Number.isSafeInteger(maxContextFiles)||maxContextFiles<1||maxContextFiles>20||!Array.isArray(contextPaths)||contextPaths.length>maxContextFiles||new Set(contextPaths).size!==contextPaths.length||!Array.isArray(rulePaths)||rulePaths.length>4||new Set(rulePaths).size!==rulePaths.length||rulePaths.some(name=>contextPaths.includes(name)))throw new Error('Invalid SVN historical context or rule selection');
   if(!Array.isArray(oldContextPaths)||oldContextPaths.length>20||new Set(oldContextPaths).size!==oldContextPaths.length||contextPaths.length+oldContextPaths.length>maxContextFiles||oldContextPaths.some(name=>contextPaths.includes(name)||rulePaths.includes(name)))throw new Error('Invalid SVN old context selection');
@@ -167,11 +171,62 @@ export async function captureSvnHistory(cwd,options={}) {
   const rules=await captureProjectRules(root,rulePaths,{signal,files,read:async(_root,name)=>{
     const value=await targetContent(name);if(value.content.bytes>16*1024)throw new Error('Rule file size limit exceeded');return value.content;
   }});
+  let autoContext,callerDiscovery;
+  if(options.autoContext===true||options.callerScopePaths!==undefined){
+    const probes=fixedSvnLookup({signal,list:async(name,rev)=>{
+      const directory=await identity(name,rev);if(directory['@_kind']!=='dir')throw new Error('Historical lookup parent is not directory');
+      const data=xml(await run(['list','--xml','--depth','immediates','-r',rev,'--',at(name,rev)]));
+      const lists=data.lists?.list;
+      const one=Array.isArray(lists)?lists:[lists];
+      if(one.length!==1||!one[0]||one[0]['@_path']!==at(name,rev).slice(0,-rev.length-1))throw new Error('Historical directory listing identity mismatch');
+      return (one[0].entry??[]).map(entry=>({name:entry.name,kind:entry['@_kind']}));
+    }});
+    const exactProbes=new Map();
+    const lookup=async(name,rev)=>{
+      const key=JSON.stringify([rev,name]);
+      if(!exactProbes.has(key)){
+        if(exactProbes.size>=512)throw new Error('SVN historical shared navigation probe limit exceeded');
+        exactProbes.set(key,await probes.lookup(name,rev));
+      }
+      return exactProbes.get(key);
+    };
+    let navigationBytes=context.reduce((sum,item)=>sum+Buffer.byteLength(item.text??'')+Buffer.byteLength(item.oldText??''),0);
+    const navigationRead=async(name,rev)=>{
+      const value=await readSource(name,rev);navigationBytes+=value.content.bytes;
+      if(navigationBytes>1024*1024)throw new Error('SVN historical shared navigation source limit exceeded');
+      return value;
+    };
+    if(navigationBytes>1024*1024)throw new Error('SVN historical shared navigation source limit exceeded');
+    if(options.callerScopePaths!==undefined){
+      let indexRecords=0;
+      const index=async(scopes,rev)=>{
+        const entries=[];
+        for(const scope of scopes){
+          const node=await lookup(scope,rev);if(!node)continue;if(node.kind!=='dir')throw new Error('Historical caller scope is not directory');
+          await identity(scope,rev);
+          const data=xml(await run(['list','--xml','--depth','infinity','-r',rev,'--',at(scope,rev)]));
+          const lists=data.lists?.list,one=Array.isArray(lists)?lists:[lists];
+          if(one.length!==1||!one[0]||one[0]['@_path']!==at(scope,rev).slice(0,-rev.length-1))throw new Error('Historical caller listing identity mismatch');
+          for(const entry of one[0].entry??[]){
+            if(++indexRecords>256)throw new Error('Historical caller shared index limit exceeded');
+            const name=relativePath(entry.name);entries.push({path:scope+'/'+name,kind:entry['@_kind']});
+          }
+        }
+        return entries;
+      };
+      callerDiscovery=await svnHistoryCallers(files,range,options.callerScopePaths,context,{index,lookup,read:navigationRead,signal,maxContextFiles,rulePaths});
+    }
+    if(options.autoContext===true){
+      autoContext=await svnHistoryDependencies(files,range,context,{lookup,read:navigationRead,signal,maxContextFiles,rulePaths});
+      autoContext.directoryEntries=probes.usage().entries;
+    }
+    if(callerDiscovery)callerDiscovery.navigationSourceBytes=navigationBytes;
+  }
   // Read the same fixed summary and repository identity again; never use HEAD.
   const after=await run(['diff','--summarize','--xml','--notice-ancestry','-r',range.base+':'+range.target,'--',at('.',range.target)]);
   if(!isDeepSummary(summary,after))throw new Error('SVN historical summary changed during capture');
   await identity('.',range.base);await identity('.',range.target);
-  const snapshot={schemaVersion:1,vcs:'svn',root,repositoryUuid:local.repository.uuid,context,...(rules.length?{rules}:{}),history:{...range,vcs:'svn',url,repositoryUuid:local.repository.uuid,pegRevision:range.target,networkAccess,...(mergeSources.length?{mergeSources}:{}),semantics:'fixed revision tree endpoints; no merge attribution or working text'},files};
+  const snapshot={schemaVersion:1,vcs:'svn',root,repositoryUuid:local.repository.uuid,context,...(rules.length?{rules}:{}),...(autoContext?{autoContext}:{}),...(callerDiscovery?{callerDiscovery}:{}),history:{...range,vcs:'svn',url,repositoryUuid:local.repository.uuid,pegRevision:range.target,networkAccess,...(mergeSources.length?{mergeSources}:{}),semantics:'fixed revision tree endpoints; no merge attribution or working text'},files};
   const serialized=JSON.stringify(snapshot);if(Buffer.byteLength(serialized)>maxSnapshotBytes)throw new Error('SVN historical snapshot limit exceeded');
   return {...snapshot,id:hash(serialized)};
 }