@feng0531/dsh-code-review 0.60.1 → 0.62.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.62.0 — SVN 原生固定 revision 历史审查初始模式
+
+新增 svnRevision 与 svnBaseRevision/svnTargetRevision，读取工作副本根仓库 URL 的固定版本对象与双侧属性，不读脏工作树、不重建临时业务工作副本。来源绑定 UUID/URL/peg/operative revision/hash；远端含 UNC 文件共享必须显式 svnAllowNetwork。目录后代逐项覆盖、关键词用仓库未展开正文，保持原数量/源码/调用预算与预览确认链。初始模式不支持历史上下文、规则、调用方与跨 URL 分支比较。替换 diff 重建仅候选组件，未开放工作副本替换。
+
+## 0.61.0 — SVN 目录复制后代覆盖
+
+显式展开默认 status 隐藏的复制目录后代，冻结继承 copyfrom 来源；copied 的 normal/modified 后代按空目标旧侧新增审查，不把来源 BASE 误作目标旧侧。目录及后代分别覆盖，未全选、凭据或阻断子项使父目录覆盖不足。离线且共享原数量/字节预算，不新增来源正文读取或联网；复制替换仍阻断。465 项串行回归、宿主、隔离安装和四矩阵 CI 通过；原产物/npm/Release 120,159 字节逐字节一致，双哈希、清单与冻结发布说明通过。
+
 ## 0.60.1 — SVN 阻断状态的准确诊断
 
-对替换/复制替换、缺失、阻塞、不完整、文本/属性/树冲突、switched 与 external 分别给出稳定 blockCode 和解释，预览及结构化报告保留原因码。普通替换实测 local BASE 无 pristine，复制替换可能返回来源 BASE，因此继续明确阻断，不合成旧侧、不冒充新增。诊断改进不表示真实双侧替换审查已支持。
+对替换/复制替换、缺失、阻塞、不完整、文本/属性/树冲突、switched 与 external 分别给出稳定 blockCode 和解释，预览及结构化报告保留原因码。普通替换实测 local BASE 无 pristine，复制替换可能返回来源 BASE，因此继续明确阻断，不合成旧侧、不冒充新增。诊断改进不表示真实双侧替换审查已支持。463 项串行回归、宿主、隔离安装和四矩阵 CI 通过；原产物/npm/Release 119,462 字节逐字节一致，双哈希、清单与冻结发布说明通过。
 
 ## 0.60.0 — SVN 普通目录新增与删除后代覆盖
 

package/CORE-ALIGNMENT-TASKS.md

@@ -32,7 +32,9 @@
 
 ## 当前验证结论
 
-- 最近完整回归：461 项通过。
+- 最近完整回归：465 项通过。
+- v0.61.0 已交付同仓库目录复制后代显式覆盖与继承来源身份；目标新增空旧侧、预览零发送、离线及凭据后代保护通过。465 项串行回归、宿主、隔离安装和四矩阵 CI 通过；原产物/npm/Release 120,159 字节逐字节一致，双哈希、清单与冻结发布说明通过。替换、关键字与历史等继续待实现。
+- v0.60.1 已交付 SVN 阻断状态稳定诊断及预览/报告原因码；普通与复制替换仍明确拒绝，不冒充真实双侧支持。463 项串行回归、宿主、隔离安装和四矩阵 CI 通过；原产物/npm/Release 119,462 字节逐字节一致，双哈希、清单与冻结发布说明通过。全面 SVN 目标继续。
 - v0.60.0 已交付 SVN 普通目录新增/删除的后代逐项覆盖，离线补齐默认 status 隐藏的删除后代；显式选择、凭据排除与原预算仍生效。461 项串行回归、宿主、隔离安装和四矩阵 CI 通过；原产物/npm/Release 118,284 字节逐字节一致，双哈希、清单与冻结发布说明通过。目录复制、替换及历史等仍在后续矩阵中。
 - v0.59.0 已交付 SVN 同仓库复制新增文件和文件移动的新增/删除独立覆盖。459 项串行回归、实际宿主、隔离安装和四组 CI 通过；原产物/npm/Release 117,098 字节逐字节一致，SHA-256、SHA-512、清单与冻结发布说明通过。复制替换、目录后代和历史审查等仍未闭环。
 - v0.58.1 已交付 SVN 根目录 mergeinfo 属性预览修复及全面支持矩阵。456 项串行回归、实际宿主、隔离安装与四组 CI 通过；npm、Release 与原包 116,254 字节逐字节一致，SHA-256、SHA-512、清单与冻结发布说明核验通过。SVN 全面扩展目标仍在进行，历史与特殊状态尚未全部支持。

package/README.md

@@ -44,7 +44,8 @@ DSH 的只读代码审查插件。它比较 Git 或 SVN 中的代码变更，使
 | Git 工作区 | HEAD 与工作区的净变化，包含暂存和未暂存改动；没有单独的 staged/unstaged 模式 |
 | Git 单个提交 | 使用 commit 参数；与唯一父提交比较，根提交与空旧版本比较。合并提交请使用区间模式 |
 | Git 两个版本 | 使用 baseRevision 和 targetRevision；比较两个版本的文件树，不自动计算合并基点 |
-| SVN 工作副本 | 本地 BASE 与工作副本比较，不连接远端；不支持 SVN 历史区间审查 |
+| SVN 工作副本 | 本地 BASE 与工作副本比较，默认不连接远端 |
+| SVN 固定历史版本（初始模式） | svnRevision 对比 r-1/r，或 svnBaseRevision/svnTargetRevision 固定树端点；从工作副本根的仓库 URL 读取，不使用脏工作树。远端必须显式 svnAllowNetwork:true |
 | 多个子仓库 | 用 repositoryPath 指定会话工作区中的一个仓库根目录；每个仓库分别预览和执行 |
 
 未跟踪文件必须通过 selectedPaths 显式选入。省略 selectedPaths 时，审查范围是仓库根目录的变更，不只是当前子目录。
@@ -67,7 +68,9 @@ DSH 的只读代码审查插件。它比较 Git 或 SVN 中的代码变更，使
 
 commit 与 baseRevision/targetRevision 不能同时使用。oldContextPaths 只能用于 Git 历史审查。
 
-自动上下文和引用方发现是保守的文本导航，不是编译器分析。动态导入、宏、重载、继承和实例方法可能无法解析；找到引用不等于证明函数实际被调用。历史调用方的命名导入线索逐侧对应相同版本声明，标明 side/revision；缺少该版本的批准正文不回退另一侧。Git 历史可沿修改前后两侧分别捕获最多三层依赖；SVN 可沿安全的当前工作副本节点取得最多三层依赖，不读取 SVN 历史。已批准正文中的唯一命名声明和唯一 default 导出会标出位置；同名、重导出或跨侧内容不猜测。命名空间导入后的独立成员调用可导航至唯一命名声明；写入、逃逸或间接调用不推定绑定，不是实例类型分析。
+SVN 历史模式使用独立参数，不可与 Git 参数混用。示例：`{"svnRevision":"7315","svnAllowNetwork":true}`；或 `{"svnBaseRevision":"7314","svnTargetRevision":"7315","svnAllowNetwork":true}`。只接受固定十进制 revision，不接受 HEAD、日期或相对别名。仅选择工作副本根当前仓库 URL，不支持任意远端 URL；预览会读取明确端点的仓库元数据与源码（远端需显式许可），但不发送模型。初始历史模式不支持 autoContext、contextPaths、oldContextPaths、rulePaths、callerScopePaths，不能回退到当前工作副本。目录新增/删除按后代逐项覆盖，凭据、链接/特殊节点与超限继续拒绝。
+
+自动上下文和引用方发现是保守的文本导航，不是编译器分析。动态导入、宏、重载、继承和实例方法可能无法解析；找到引用不等于证明函数实际被调用。历史调用方的命名导入线索逐侧对应相同版本声明，标明 side/revision；缺少该版本的批准正文不回退另一侧。Git 历史可沿修改前后两侧分别捕获最多三层依赖；SVN 工作副本模式可沿安全的当前节点取得最多三层依赖；初始固定 revision 历史模式尚不支持历史依赖导航。已批准正文中的唯一命名声明和唯一 default 导出会标出位置；同名、重导出或跨侧内容不猜测。命名空间导入后的独立成员调用可导航至唯一命名声明；写入、逃逸或间接调用不推定绑定，不是实例类型分析。
 
 ## 如何读报告
 
@@ -89,7 +92,7 @@ commit 与 baseRevision/targetRevision 不能同时使用。oldContextPaths 只
 - 不执行项目代码、构建脚本或模型生成的 shell 命令。模型只能在批准的快照中查找、搜索和读取。
 - 常见凭据路径会被排除，但普通源码也可能含秘密。路径过滤不能代替人工检查。
 - 二进制、不能解码的文件、链接和超限内容会被阻断，不会自动截断后假装完成。
-- SVN 同仓库复制新增文件以空目标旧侧审查，copyfrom URL/revision/UUID 在预览中披露，仅作来源信息，不自动读取来源正文，也不认定为已验证重命名。文件移动的新增/删除两侧分别覆盖。普通目录新增/删除会逐项列出后代；选择目录不会自动批准后代，未全选或子项阻断会标明覆盖不足。复制目录、替换、切换目录、外部工作副本、冲突及部分属性状态仍未支持；含 svn:keywords 的文件仍阻断。全面扩展进度见 [SVN 支持矩阵](SVN-SUPPORT-MATRIX.md)。
+- SVN 同仓库复制新增文件以空目标旧侧审查，copyfrom URL/revision/UUID 在预览中披露，仅作来源信息，不自动读取来源正文，也不认定为已验证重命名。文件移动的新增/删除两侧分别覆盖。普通目录新增/删除会逐项列出后代；选择目录不会自动批准后代，未全选或子项阻断会标明覆盖不足。同仓库目录复制会显式展开后代，将继承 copied 的正常/修改节点作为空目标旧侧的新增审查，来源身份逐项披露。替换、切换目录、外部工作副本、冲突及部分属性状态仍未支持；含 svn:keywords 的文件仍阻断。全面扩展进度见 [SVN 支持矩阵](SVN-SUPPORT-MATRIX.md)。
 
 ## 默认规模限制
 

package/RELEASE-NOTES.md

@@ -1,13 +1,18 @@
-# v0.60.1 发布说明
+# v0.62.0 发布说明
 
-## SVN 阻断状态的准确诊断
+## SVN 原生固定 revision 历史审查初始模式
 
-区分普通替换、复制替换、缺失、阻塞、不完整、文本冲突、属性冲突、树冲突、switched 与 external，提供稳定 blockCode 与解释；预览和结构化审查报告保留原因码。
+新增 `svnRevision`（r-1 与 r）和 `svnBaseRevision` / `svnTargetRevision`（明确旧/新树端点），可直接审查工作副本根对应仓库 URL 的固定历史版本，无须在业务工作副本回退或合并。
 
-- 缺失不冒充计划删除；冲突标记不冒充已解决目标。
-- 普通替换的 local BASE 可能无 pristine，复制替换的 BASE 可能属于来源，均不能当作目标旧侧。
-- 独立 SVN 替换测试验证不读取伪造双侧、预览零发送、覆盖非完成及工作副本状态不变。
+- 来源逐侧绑定仓库 UUID、URL、peg revision、operative revision 和正文哈希，不使用脏工作树。
+- 非本地仓库访问必须显式 `svnAllowNetwork:true`（含 file://server 网络共享）。预览会读取指定历史元数据与源码，但零模型发送；确认执行仍重验快照。
+- 捕获正文、属性及目录增删后代；历史关键词用 svn cat --ignore-keywords 的未展开仓库正文，不伪造工作侧行号。
+- 共享原文件数、源码/快照上限及有界命令、元数据和总采集时间；超限不冒充成功。
 
-本版本提升诊断，不宣称替换或冲突场景已经可进行完整代码审查；这些项目仍在 [SVN 支持矩阵](SVN-SUPPORT-MATRIX.md) 中保留待实现。正常节点的读取与预算不变。
+## 初始模式限制
 
-日常使用见 [README](README.md)。
+只接受数字 revision，不接受 HEAD/日期别名，不支持任意 URL、跨 URL 分支比较和历史 contextPaths/oldContextPaths/rulePaths/autoContext/callerScopePaths。历史依赖及调用方仍待后续实现。
+
+离线替换 diff 重建组件仅返回 candidate-only，不能独立证明旧节点完整来源/编码/属性，未接入工作副本替换采集。全面 SVN 目标尚未完成，见 [SVN 支持矩阵](SVN-SUPPORT-MATRIX.md)。
+
+参数与用法见 [README](README.md)。

package/SVN-SUPPORT-MATRIX.md

@@ -17,15 +17,15 @@
 | 常规文件修改、普通新增、删除 | 已有 BASE/工作字节与属性捕获测试 | 维持并扩充组合验收 |
 | 子目录属性变更 | 已有独立属性审查测试 | 第一批 |
 | 根目录属性/mergeinfo | v0.58.1 已发布；独立复现后修复，指定三文件和默认预览均通过、0 模型发送、状态不变；456 项串行回归、宿主、隔离安装和四矩阵 CI 通过，原产物/npm/Release 116,254 字节逐字节一致及双哈希/清单/发布说明通过 | 第一批先发布此修复 |
-| 复制/移动、copyfrom 及目录结构变更 | v0.59.0 已发布同仓库复制新增文件及文件移动的新增/删除独立覆盖：新增目标旧侧为空，copyfrom 只作来源信息，预览披露并冻结身份；离线与凭据来源拒绝测试通过。459 项串行回归、宿主、隔离安装、四矩阵 CI 通过；原产物/npm/Release 117,098 字节逐字节一致，双哈希/清单/冻结发布说明通过。复制目录及后代覆盖仍未实现 | 第二批：明确旧侧来源和后代覆盖 |
+| 复制/移动、copyfrom 及目录结构变更 | v0.59.0 已发布同仓库复制新增文件及文件移动的新增/删除独立覆盖：新增目标旧侧为空，copyfrom 只作来源信息，预览披露并冻结身份；离线与凭据来源拒绝测试通过。459 项串行回归、宿主、隔离安装、四矩阵 CI 通过；原产物/npm/Release 117,098 字节逐字节一致，双哈希/清单/冻结发布说明通过。v0.61.0 已发布同仓库目录复制后代展开与继承来源身份，目标旧侧为空且预览披露。465 项串行回归、宿主、隔离安装、四矩阵 CI 与原包/npm/Release 120,159 字节、双哈希/清单/冻结发布说明通过。复制替换仍未支持 | 第二批：明确旧侧来源和后代覆盖 |
 | 普通新增/删除目录及后代 | v0.60.0 已发布：补齐默认 status 隐藏的删除后代，离线递归枚举与末尾清单复核；普通结构目录只在后代全选且可审查时开放，凭据/阻断子项导致目录覆盖不足。461 项串行回归、宿主、隔离安装与四矩阵 CI 通过；原产物/npm/Release 118,284 字节逐字节一致，双哈希/清单/冻结发布说明通过 | 第二批普通目录子批 |
-| 替换、删除再新增、文件/目录类型变化 | 普通与复制替换分别用 SVN_REPLACEMENT/SVN_COPIED_REPLACEMENT 诊断；离线探测确认前者 BASE 无 pristine，后者可能返回复制来源，禁止伪造旧侧。真实双侧替换仍未支持 | 第二批：区分 BASE 旧节点与目标节点 |
-| 缺失、文本/属性/树冲突、阻塞 | 本地新增稳定状态诊断：SVN_MISSING_NODE/OBSTRUCTED_NODE/INCOMPLETE_NODE/TEXT_CONFLICT/PROPERTY_CONFLICT/TREE_CONFLICT 等；预览与报告透传 blockCode。诊断不算真实双侧审查支持，仍需后续场景实现，待本批发布核验 | 第三批：明确状态诊断；不能合成不存在的工作侧或声称审核通过 |
+| 替换、删除再新增、文件/目录类型变化 | 普通与复制替换分别用 SVN_REPLACEMENT/SVN_COPIED_REPLACEMENT 诊断；离线探测确认前者 BASE 无 pristine，后者可能返回复制来源，禁止伪造旧侧。已新增未接入采集的 candidate-only 完整 diff 重建组件及真实离线测试：匹配完整工作侧，拒绝片段、错侧、截断与超限。diff 仍不能独立证明旧节点/编码/旧属性，因此真实双侧替换仍未支持，不能把辅助组件算作支持完成 | 第二批：区分 BASE 旧节点与目标节点 |
+| 缺失、文本/属性/树冲突、阻塞 | v0.60.1 已发布稳定状态诊断：SVN_MISSING_NODE/OBSTRUCTED_NODE/INCOMPLETE_NODE/TEXT_CONFLICT/PROPERTY_CONFLICT/TREE_CONFLICT 等，预览与报告透传 blockCode。463 项串行回归、宿主、隔离安装、四矩阵 CI 与原包/npm/Release 119,462 字节、双哈希/清单/发布说明通过。诊断不算真实双侧支持，仍需后续实现 | 第三批：明确状态诊断；不能合成不存在的工作侧或声称审核通过 |
 | svn:keywords、svn:eol-style | keywords 当前阻断；换行保留原文但无规范化映射 | 第三批：双侧可验证映射，保留原字节和定位 |
 | svn:special/链接 | 当前阻断，不跟随链接取正文 | 第三批：如支持只审链接目标数据；不沿链接读取文件 |
 | switched、externals、稀疏/混合 revision | 多数拒绝；调用方/依赖链要求祖先 normal | 第四批：明确仓库边界与独立来源，禁止隐式跨仓读取 |
-| 固定 revision 单提交 | 未实现；Git commit 参数不能冒充 SVN revision | 第五批：新增明确 SVN 参数与冻结身份 |
-| 固定 revision 区间 | 未实现；不能通过临时重建工作树冒充原生历史能力 | 第五批：固定树端点与逐路径差异 |
+| 固定 revision 单提交 | 本地开发新增 svnRevision：r-1/r 固定对象、UUID/URL/peg/operative revision 逐侧绑定，正文不读工作树；远端读取显式 svnAllowNetwork，初始无历史上下文/规则/调用方，待最终回归与发布 | 第五批：新增明确 SVN 参数与冻结身份 |
+| 固定 revision 区间 | 本地开发新增 svnBaseRevision/svnTargetRevision，固定树端点 summary+逐侧 cat/proplist，目录后代与属性纳入预算；不建临时工作树，待最终回归与发布。分支间不同 URL 和历史上下文尚未支持 | 第五批：固定树端点与逐路径差异 |
 | 分支复制、分支间比较、合并来源 | mergeinfo 当前仅作为属性文本；不证明源码归属或被合并提交均已审查 | 第六批：URL/peg/operative revision 与 mergeinfo 导航披露 |
 | 当前三层依赖与限定目录调用方 | 已有安全 normal 节点的离线有界测试；根属性修改可能使祖先检查拒绝，需单独验证 | 第四批补祖先/混合状态组合 |
 | 历史两侧上下文与调用方 | 未实现 | 第六批：逐侧固定版本，不能回退至工作副本 |

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 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. Initial mode rejects context/rules/callers.' }, 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 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.60.1",
+  "version": "0.62.0",
   "private": false,
   "license": "SEE LICENSE IN LICENSE",
   "publishConfig": { "access": "public", "registry": "https://registry.npmjs.org/" },

package/src/service.mjs

@@ -30,7 +30,7 @@ export function createReviewService(llm, { capture = captureSnapshot, now = Date
       exec = bind(exec);
       exec.signal.throwIfAborted();
       if (busy) throw new Error('Review service busy');
-      if (!args || Object.keys(args).some(k => !['repositoryPath', 'selectedPaths', 'contextPaths', 'rulePaths', 'autoContext', 'commit', 'baseRevision', 'targetRevision','businessRequirement','callerScopePaths','oldContextPaths','reviewRounds'].includes(k))) throw new Error('Unknown preview argument');
+      if (!args || Object.keys(args).some(k => !['repositoryPath', 'selectedPaths', 'contextPaths', 'rulePaths', 'autoContext', 'commit', 'baseRevision', 'targetRevision','businessRequirement','callerScopePaths','oldContextPaths','reviewRounds','svnRevision','svnBaseRevision','svnTargetRevision','svnAllowNetwork'].includes(k))) throw new Error('Unknown preview argument');
       if (args.autoContext !== undefined && typeof args.autoContext !== 'boolean') throw new Error('Invalid autoContext option');
       for (const key of ['selectedPaths', 'contextPaths', 'rulePaths', 'oldContextPaths']) if (args[key] !== undefined && (!Array.isArray(args[key]) || args[key].length > (key === 'rulePaths' ? 4 : key === 'oldContextPaths' ? 20 : 200) || args[key].some(p => typeof p !== 'string'))) throw new Error('Invalid path list');
       const rounds=validateReviewRounds(args.reviewRounds === undefined ? reviewRounds : args.reviewRounds);

package/src/snapshot.mjs

@@ -11,6 +11,7 @@ import { captureGitHistory } from './git-history.mjs';
 import { captureGit } from './git.mjs';
 import { captureProjectRules } from './project-rules.mjs';
 import { captureSvn } from './svn.mjs';
+import { captureSvnHistory } from './svn-history.mjs';
 import { readLocal, relativePath, hash } from './content.mjs';
 
 export async function detectVcs(cwd) {
@@ -39,6 +40,10 @@ export async function captureSnapshot(cwd, options = {}) {
   if (options.oldContextPaths !== undefined && (!Array.isArray(options.oldContextPaths) || options.oldContextPaths.length > 20 || new Set(options.oldContextPaths).size !== options.oldContextPaths.length)) throw new Error('Invalid old context paths');
   for (const name of options.oldContextPaths ?? []) relativePath(name);
   const type = await detectVcs(cwd);
+  if (['svnRevision','svnBaseRevision','svnTargetRevision','svnAllowNetwork'].some(key=>options[key]!==undefined)) {
+    if (type!=='svn') throw new Error('SVN revision parameters require SVN working copy');
+    return bindBusinessRequirement(await captureSvnHistory(cwd,options),options.businessRequirement);
+  }
   if (options.oldContextPaths !== undefined && (type !== 'git' || !['commit','baseRevision','targetRevision'].some(k => options[k] !== undefined))) throw new Error('Old context requires Git historical review');
   if (['commit','baseRevision','targetRevision'].some(k => options[k] !== undefined)) {
     if (type !== 'git') throw new Error('Git revision review is unsupported on SVN');

package/src/svn-history.mjs

@@ -0,0 +1,128 @@
+import {realpath} from 'node:fs/promises';
+import {checked} from './process.mjs';
+import {xml} from './svn.mjs';
+import {hash,decode,relativePath} from './content.mjs';
+import {isSecretPath} from './secret-path.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');
+  return value;
+};
+export function svnHistoryRange(options) {
+  if (['commit','baseRevision','targetRevision'].some(key=>options[key]!==undefined)) throw new Error('SVN and Git revision parameters cannot be mixed');
+  if (options.svnRevision!==undefined) {
+    if (options.svnBaseRevision!==undefined || options.svnTargetRevision!==undefined) throw new Error('SVN revision and range are mutually exclusive');
+    const target=revision(options.svnRevision);
+    if (target==='0') throw new Error('SVN revision zero has no previous revision');
+    return {base:String(Number(target)-1),target,mode:'svn-revision'};
+  }
+  const base=revision(options.svnBaseRevision),target=revision(options.svnTargetRevision);
+  if (Number(base)>=Number(target)) throw new Error('SVN range requires base before target');
+  return {base,target,mode:'svn-range'};
+}
+
+export function svnHistoryDestination(value, allowNetwork) {
+  const scope=new URL(value);
+  if(scope.username||scope.password||scope.search||scope.hash||!['file:','https:','http:','svn:','svn+ssh:'].includes(scope.protocol))throw new Error('Unsafe SVN repository URL');
+  const networkAccess=scope.protocol!=='file:' || !!scope.hostname;
+  if(networkAccess && allowNetwork!==true)throw new Error('SVN remote history requires explicit svnAllowNetwork: true before repository access');
+  return {url:scope.href.replace(/\/$/,''),networkAccess};
+}
+
+// Fixed URL objects only. No checkout, update, merge, working body or lazy HEAD read.
+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 || ['contextPaths','oldContextPaths','rulePaths'].some(key=>options[key]!==undefined && (!Array.isArray(options[key]) || options[key].length))) throw new Error('SVN historical context, rules and callers are not supported in this initial mode');
+  const {maxFiles=200,maxFileBytes=256*1024,maxSnapshotBytes=4*1024*1024,selectedPaths}=options;
+  for(const [value,cap]of [[maxFiles,200],[maxFileBytes,256*1024],[maxSnapshotBytes,4*1024*1024]])if(!Number.isSafeInteger(value)||value<1||value>cap)throw new Error('Invalid SVN history limit');
+  if(selectedPaths!==undefined && (!Array.isArray(selectedPaths)||selectedPaths.length>200||new Set(selectedPaths).size!==selectedPaths.length))throw new Error('Invalid SVN history selection');
+  for(const name of selectedPaths??[])if(name!=='.')relativePath(name);
+  const signal=AbortSignal.any([AbortSignal.timeout(30000),...(options.signal?[options.signal]:[])]);
+  let commands=0,metadataBytes=0,sourceBytes=0;
+  const budgetError = message => Object.assign(new Error(message), {code:'SVN_HISTORY_BUDGET'});
+  const run=async(args,body=false)=>{
+    signal.throwIfAborted();if(++commands>512 || metadataBytes>1024*1024 || sourceBytes>maxSnapshotBytes)throw budgetError('SVN historical shared budget exceeded');
+    const bytes=await checked('svn',['--non-interactive',...args],{cwd,signal,maxBytes:body?maxFileBytes:1024*1024});
+    if(body){sourceBytes+=bytes.length;if(sourceBytes>maxSnapshotBytes)throw budgetError('SVN historical source budget exceeded');}
+    else{metadataBytes+=bytes.length;if(metadataBytes>1024*1024)throw budgetError('SVN historical metadata budget exceeded');}
+    return bytes;
+  };
+  const local=xml(await run(['info','--xml','--','.@'])).info?.entry?.[0];
+  if(!local?.['wc-info']?.['wcroot-abspath'] || !local.repository?.uuid || !local.url)throw new Error('Missing SVN working-copy identity');
+  const root=await realpath(local['wc-info']['wcroot-abspath']);
+  if(root!==await realpath(cwd))throw new Error('SVN historical scope must be working-copy root');
+  const {url,networkAccess}=svnHistoryDestination(local.url,options.svnAllowNetwork);
+  const at=(name,rev)=>(name==='.'?url:url+'/'+name.split('/').map(encodeURIComponent).join('/'))+'@'+rev;
+  const identity=async(name,rev)=>{
+    const node=xml(await run(['info','--xml','-r',rev,'--',at(name,rev)])).info?.entry?.[0];
+    const expected=at(name,rev).slice(0,-rev.length-1);
+    if(!node||node.url!==expected||String(node['@_revision'])!==rev||node.repository?.uuid!==local.repository.uuid||node.repository?.root!==local.repository.root||!['file','dir'].includes(node['@_kind']))throw new Error('SVN fixed historical identity mismatch');
+    return node;
+  };
+  await identity('.',range.base);await identity('.',range.target);
+  const summary=await run(['diff','--summarize','--xml','--notice-ancestry','-r',range.base+':'+range.target,'--',at('.',range.target)]);
+  const raw=xml(summary).diff?.paths?.path;
+  const paths=raw===undefined?[]:Array.isArray(raw)?raw:[raw];
+  if(paths.length>maxFiles)throw new Error('SVN historical change count limit exceeded');
+  const records=new Map();
+  for(const item of paths){
+    const value=item['#text'];
+    if(typeof value!=='string'||(value!==url&&!value.startsWith(url+'/')))throw new Error('SVN historical path escaped scope');
+    const name=value===url?'.':value.slice(url.length+1).split('/').map(part=>{
+      const decoded=decodeURIComponent(part);if(decoded.includes('/')||decoded.includes('\\'))throw new Error('Encoded SVN path separator');return decoded;
+    }).join('/');
+    if(name!=='.')relativePath(name);
+    if(records.has(name)||!['added','deleted','modified','none'].includes(item['@_item'])||!['file','dir'].includes(item['@_kind']))throw new Error('Ambiguous or unsupported SVN history summary');
+    records.set(name,item);
+  }
+  if(selectedPaths?.some(name=>!records.has(name)))throw new Error('Selected path is not an SVN historical change');
+  const properties=async(name,rev)=>{
+    const targets=xml(await run(['proplist','--xml','--verbose','-r',rev,'--',at(name,rev)])).properties?.target??[];
+    const result=Object.create(null);
+    for(const prop of targets.flatMap(t=>t.property??[])){
+      if(typeof prop['@_name']!=='string'||prop['@_encoding']||Object.hasOwn(result,prop['@_name']))throw new Error('Unsupported historical property representation');
+      result[prop['@_name']]=prop['#text']??'';
+    }
+    return Object.fromEntries(Object.entries(result).sort(([a],[b])=>a.localeCompare(b)));
+  };
+  const files=[];
+  for(const [name,record]of [...records].sort(([a],[b])=>a<b?-1:a>b?1:0)){
+    signal.throwIfAborted();
+    const status=record['@_item'],item={id:hash(name),path:name,kind:record['@_kind'],rawStatus:status,eligibility:'reviewable',properties:[],rightExists:status!=='deleted'};
+    files.push(item);
+    if(isSecretPath(name)){item.eligibility='excluded';item.reason='Credential path excluded';continue;}
+    if(selectedPaths&&!selectedPaths.includes(name)){item.eligibility='excluded';item.reason='Not explicitly selected';continue;}
+    try{
+      const readSide=async(rev,exists)=>{
+        if(!exists)return {content:decode(Buffer.alloc(0)),props:{}};
+        const node=await identity(name,rev),props=await properties(name,rev);
+        if(node['@_kind']!==item.kind)throw new Error('Historical node kind differs');
+        if(Object.hasOwn(props,'svn:special'))throw new Error('Historical SVN special node excluded');
+        const content=node['@_kind']==='dir'?decode(Buffer.alloc(0)):decode(await run(['cat','--ignore-keywords','-r',rev,'--',at(name,rev)],true));
+        return {content,props,source:{repositoryUuid:local.repository.uuid,url:at(name,rev).slice(0,-rev.length-1),pegRevision:rev,operativeRevision:rev,hash:content.hash}};
+      };
+      const left=await readSide(range.base,status!=='added'),right=await readSide(range.target,status!=='deleted');
+      item.left=left.content;item.right=right.content;
+      item.svnSources={...(left.source?{old:left.source}:{}),...(right.source?{new:right.source}:{})};
+      for(const key of [...new Set([...Object.keys(left.props),...Object.keys(right.props)])].sort())if(left.props[key]!==right.props[key])item.properties.push({name:key,old:left.props[key]??null,new:right.props[key]??null});
+      item.propertyIdentity=hash(JSON.stringify([left.props,right.props]));
+      item.textNotice='Fixed revision repository text; keywords unexpanded by svn cat --ignore-keywords. No working-copy text or keyword line remapping.';
+    }catch(error){signal.throwIfAborted();if(error.code==='SVN_HISTORY_BUDGET')throw error;item.eligibility='blocked';item.reason=error.message;delete item.left;delete item.right;}
+    if(Buffer.byteLength(JSON.stringify(files))>maxSnapshotBytes)throw new Error('SVN historical snapshot limit exceeded');
+  }
+  for(const item of files.filter(f=>f.kind==='dir'&&['added','deleted'].includes(f.rawStatus)&&f.eligibility==='reviewable')){
+    if(files.some(child=>child.path.startsWith(item.path==='.'?'':item.path+'/')&&child!==item&&child.eligibility!=='reviewable')){item.eligibility='blocked';item.reason='Historical directory descendant coverage incomplete';delete item.left;delete item.right;}
+  }
+  // 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:[],history:{...range,vcs:'svn',url,repositoryUuid:local.repository.uuid,pegRevision:range.target,networkAccess,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)};
+}
+function isDeepSummary(a,b){
+  const canonical=v=>Array.isArray(v)?v.map(canonical):v&&typeof v==='object'?Object.fromEntries(Object.keys(v).sort().map(k=>[k,canonical(v[k])])):v;
+  return JSON.stringify(canonical(xml(a)))===JSON.stringify(canonical(xml(b)));
+}

package/src/svn-replacement-text.mjs

@@ -0,0 +1,57 @@
+import { relativePath } from './content.mjs';
+
+// Candidate reconstruction only: a diff does not establish old-node identity or
+// old properties. Capture must verify those separately before approving a source.
+export function replacementTextCandidate(diff, name, workingText, { maxBytes = 256 * 1024 } = {}) {
+  relativePath(name);
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > 16 * 1024 * 1024) throw new Error('Invalid replacement byte limit');
+  if (typeof diff !== 'string' || typeof workingText !== 'string' || Buffer.byteLength(diff) > 2 * maxBytes + 16 * 1024 || Buffer.byteLength(workingText) > maxBytes) throw new Error('Replacement diff input limit exceeded');
+  if (!diff.endsWith('\n')) throw new Error('Replacement diff record is truncated');
+  const lines = diff.split('\n');
+  const header = index => lines[index]?.replace(/\r$/, '');
+  if (header(0) !== 'Index: ' + name || !/^=+$/.test(header(1) ?? '')) throw new Error('Unexpected replacement diff scope');
+  const oldHeader = header(2), newHeader = header(3);
+  const prefix = '--- ' + name + '\t(revision ';
+  if (!oldHeader?.startsWith(prefix) || !/^[0-9]+\)$/.test(oldHeader.slice(prefix.length)) || newHeader !== '+++ ' + name + '\t(working copy)') throw new Error('Replacement diff requires target revision and working side');
+  const hunk = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@$/.exec(header(4) ?? '');
+  if (!hunk) throw new Error('Replacement diff requires one full hunk');
+  const oldStart = Number(hunk[1]), oldCount = Number(hunk[2] ?? 1), newStart = Number(hunk[3]), newCount = Number(hunk[4] ?? 1);
+  if (![oldStart,oldCount,newStart,newCount].every(Number.isSafeInteger) || oldStart !== (oldCount ? 1 : 0) || newStart !== (newCount ? 1 : 0) || oldCount > maxBytes || newCount > maxBytes) throw new Error('Replacement hunk does not start at both file boundaries');
+  const oldLines = [], newLines = [];
+  let previous, oldNoEol = false, newNoEol = false;
+  for (let i = 5; i < lines.length; i++) {
+    const line = lines[i];
+    if (i === lines.length - 1 && line === '') break;
+    if (header(i) === '\') {
+      if (!previous) throw new Error('Detached replacement EOF marker');
+      if (previous !== '+') {
+        if (oldNoEol) throw new Error('Duplicate old EOF marker');
+        oldNoEol = true;
+      }
+      if (previous !== '-') {
+        if (newNoEol) throw new Error('Duplicate new EOF marker');
+        newNoEol = true;
+      }
+      previous = undefined;
+      continue;
+    }
+    const marker = line[0];
+    if (![' ', '-', '+'].includes(marker)) throw new Error('Unexpected replacement diff record');
+    if (marker !== '+') {
+      if (oldNoEol) throw new Error('Old text follows EOF marker');
+      oldLines.push(line.slice(1));
+    }
+    if (marker !== '-') {
+      if (newNoEol) throw new Error('New text follows EOF marker');
+      newLines.push(line.slice(1));
+    }
+    previous = marker;
+    if (oldLines.length > oldCount || newLines.length > newCount) throw new Error('Replacement hunk count exceeded');
+  }
+  if (oldLines.length !== oldCount || newLines.length !== newCount) throw new Error('Replacement hunk truncated');
+  const text = (items, noEol) => items.join('\n') + (items.length && !noEol ? '\n' : '');
+  const oldText = text(oldLines, oldNoEol), newText = text(newLines, newNoEol);
+  if (Buffer.byteLength(oldText) > maxBytes || Buffer.byteLength(newText) > maxBytes) throw new Error('Replacement text limit exceeded');
+  if (newText !== workingText) throw new Error('Replacement diff does not match complete working text');
+  return { oldText, newText, oldRevision: oldHeader.slice(prefix.length, -1), status: 'candidate-only', notice: 'Not approved old-node identity, bytes, encoding or properties; capture still requires independent provenance verification.' };
+}

package/src/svn.mjs

@@ -23,11 +23,11 @@ async function properties(root, name, baseline, options) {
   }
   return Object.fromEntries(Object.entries(result).sort(([a], [b]) => a.localeCompare(b)));
 }
-// Default status hides deleted directory descendants. Expand only explicit deleted
-// versioned roots, sharing one metadata cap and the original change-count limit.
-async function deletedEntries(root, entries, options, limit) {
+// Default status hides deleted and copied directory descendants. Expand only
+// explicit structural roots under the shared metadata and change-count caps.
+async function structuralEntries(root, entries, options, limit) {
   const byPath = new Map(entries.map(entry => [entry['@_path'].replaceAll('\\', '/'), entry]));
-  const roots = entries.filter(entry => entry['wc-status']?.['@_item'] === 'deleted').map(entry => entry['@_path'].replaceAll('\\', '/')).sort();
+  const roots = entries.filter(entry => entry['wc-status']?.['@_item'] === 'deleted' || (entry['wc-status']?.['@_item'] === 'added' && entry['wc-status']?.['@_copied'] === 'true')).map(entry => entry['@_path'].replaceAll('\\', '/')).sort();
   const visited = [];
   let bytes = 0;
   for (const name of roots) {
@@ -41,8 +41,11 @@ async function deletedEntries(root, entries, options, limit) {
       const child = entry['@_path'].replaceAll('\\', '/');
       relativePath(child);
       if (child !== name && !child.startsWith(name + '/')) throw new Error('SVN deleted descendant escaped scope');
-      if (entry['wc-status']?.['@_item'] !== 'deleted') throw new Error('Unexpected SVN deleted descendant state');
-      if (!byPath.has(child)) byPath.set(child, entry);
+      const parentState = byPath.get(name)['wc-status'];
+      if (parentState['@_item'] === 'deleted' && entry['wc-status']?.['@_item'] !== 'deleted') throw new Error('Unexpected SVN deleted descendant state');
+      const item = structuredClone(entry);
+      if (parentState['@_item'] === 'added' && child !== name && item['wc-status']?.['@_copied'] === 'true') item.copyRoot = name;
+      if (!byPath.has(child) || item.copyRoot) byPath.set(child, item);
       if (byPath.size > limit) throw new Error('Change count limit exceeded');
     }
   }
@@ -57,7 +60,7 @@ export async function captureSvn(cwd, options = {}) {
   const before = await svn(root, statusArgs, options);
   const originalEntries = xml(before).status.target.flatMap(t => t.entry ?? []);
   if (originalEntries.length > maxFiles) throw new Error('Change count limit exceeded');
-  const entries = await deletedEntries(root, originalEntries, options, maxFiles);
+  const entries = await structuralEntries(root, originalEntries, options, maxFiles);
   const known = new Set(entries.map(e => e['@_path'].replaceAll('\\', '/')));
   if (selectedPaths?.some(p => !known.has(p))) throw new Error('Selected path is not a current change');
   const files = [];
@@ -73,24 +76,33 @@ export async function captureSvn(cwd, options = {}) {
     }
     try {
       if (name !== '.') relativePath(name);
-      const issue = svnStateIssue(state);
+      const copiedDescendant = !!entry.copyRoot && ['normal', 'modified', 'added'].includes(status) && state['@_copied'] === 'true';
+      const issue = svnStateIssue(copiedDescendant ? {...state, '@_item':'added'} : state);
       if (issue) { item.blockCode = issue.code; throw new Error(issue.reason); }
-      const hasBase = !['added', 'unversioned'].includes(status);
+      const hasBase = !copiedDescendant && !['added', 'unversioned'].includes(status);
       let kind;
       if (status === 'unversioned') kind = (await lstat(path.join(root, name))).isDirectory() ? 'dir' : 'file';
       else {
         const node = xml(await svn(root, ['info', '--xml', '--', target(name)], options)).info.entry[0];
         kind = node['@_kind'];
         if (state['@_copied'] === 'true' || node['wc-info']?.['copy-from-url']) {
-          const source = node['wc-info']?.['copy-from-url'], revision = node['wc-info']?.['copy-from-rev'];
-          if (status !== 'added' || kind !== 'file' || typeof source !== 'string' || !source || !/^[0-9]+$/.test(String(revision)) || node.repository?.uuid !== info.repository.uuid || node.repository?.root !== info.repository.root) throw new Error('Copied node requires a same-repository added file with fixed copy source');
+          let source = node['wc-info']?.['copy-from-url'], revision = node['wc-info']?.['copy-from-rev'];
+          if (!source && copiedDescendant) {
+            const parent = files.find(file => file.path === entry.copyRoot);
+            if (!parent?.copySource || parent.eligibility !== 'reviewable') throw new Error('Copied ancestor identity unavailable');
+            source = parent.copySource.url.replace(/\/$/,'') + '/' + name.slice(entry.copyRoot.length+1).split('/').map(encodeURIComponent).join('/');
+            revision = parent.copySource.revision;
+            item.copyAncestor = entry.copyRoot;
+          }
+          if ((!copiedDescendant && status !== 'added') || !['file','dir'].includes(kind) || typeof source !== 'string' || !source || !/^[0-9]+$/.test(String(revision)) || node.repository?.uuid !== info.repository.uuid || node.repository?.root !== info.repository.root) throw new Error('Copied node requires a same-repository added target with fixed copy source');
           if (isSecretPath(decodeURIComponent(new URL(source).pathname))) throw new Error('Credential copy source excluded');
           item.copySource = { url: source, revision: String(revision), repositoryUuid: node.repository.uuid };
           item.copyNotice = 'Target addition is reviewed against an empty target baseline; copy source is provenance only, not an approved source body or verified rename.';
-          item.copyNodeIdentity = hash(JSON.stringify([node.url, node['@_kind'], node['@_revision'], node['wc-info']?.schedule, node['wc-info']?.['wcroot-abspath'], source, String(revision), node.repository]));
+          item.copyNodeIdentity = hash(JSON.stringify([node.url, node['@_kind'], node['@_revision'], node['wc-info']?.schedule, node['wc-info']?.['wcroot-abspath'], node['wc-info']?.['copy-from-url'] ?? null, node['wc-info']?.['copy-from-rev'] ?? null, node.repository]));
         }
       }
       item.kind = kind;
+      if (copiedDescendant) item.targetAddition = true;
       item.rightExists = status !== 'deleted';
       const leftProps = hasBase ? await properties(root, name, true, options) : {};
       const rightProps = status === 'deleted' || status === 'unversioned' ? {} : await properties(root, name, false, options);
@@ -103,7 +115,7 @@ export async function captureSvn(cwd, options = {}) {
       item.propertyIdentity = hash(JSON.stringify([leftProps, rightProps]));
       if (kind === 'dir') {
         if (status === 'unversioned') throw new Error('Unversioned directory requires explicit descendant tracking');
-        if (status === 'deleted' || status === 'added') {
+        if (status === 'deleted' || status === 'added' || copiedDescendant) {
           const descendants = entries.filter(entry => entry['@_path'].replaceAll('\\', '/').startsWith(name + '/')).map(entry => entry['@_path'].replaceAll('\\', '/'));
           if (selectedPaths && descendants.some(child => !selectedPaths.includes(child))) throw new Error('Directory descendants are not all explicitly selected');
           item.structuralDescendants = descendants;
@@ -121,7 +133,7 @@ export async function captureSvn(cwd, options = {}) {
   }
   const after = await svn(root, statusArgs, options);
   if (!isDeepStrictEqual(xml(after), xml(before))) throw new Error('Working copy changed during capture');
-  if (!isDeepStrictEqual(await deletedEntries(root, xml(after).status.target.flatMap(t => t.entry ?? []), options, maxFiles), entries)) throw new Error('Deleted descendants changed during capture');
+  if (!isDeepStrictEqual(await structuralEntries(root, xml(after).status.target.flatMap(t => t.entry ?? []), options, maxFiles), entries)) throw new Error('Deleted descendants changed during capture');
   // A directory must not look complete when any descendant was blocked/excluded.
   for (const item of files.filter(f => f.structuralDescendants).sort((a,b) => b.path.length - a.path.length)) {
     if (item.structuralDescendants.some(name => files.find(f => f.path === name)?.eligibility !== 'reviewable')) {
@@ -132,11 +144,11 @@ export async function captureSvn(cwd, options = {}) {
   for (const item of files.filter(f => f.eligibility === 'reviewable')) {
     if (item.copySource) {
       const node = xml(await svn(root, ['info', '--xml', '--', target(item.path)], options)).info.entry[0];
-      const identity = hash(JSON.stringify([node.url, node['@_kind'], node['@_revision'], node['wc-info']?.schedule, node['wc-info']?.['wcroot-abspath'], node['wc-info']?.['copy-from-url'], String(node['wc-info']?.['copy-from-rev']), node.repository]));
+      const identity = hash(JSON.stringify([node.url, node['@_kind'], node['@_revision'], node['wc-info']?.schedule, node['wc-info']?.['wcroot-abspath'], node['wc-info']?.['copy-from-url'] ?? null, node['wc-info']?.['copy-from-rev'] ?? null, node.repository]));
       if (identity !== item.copyNodeIdentity) throw new Error('Copy source identity changed during capture');
     }
     if (item.kind === 'file' && item.rawStatus !== 'deleted' && (await readLocal(root, item.path, options)).hash !== item.right.hash) throw new Error('Content changed during capture');
-    const left = !['added', 'unversioned'].includes(item.rawStatus) ? await properties(root, item.path, true, options) : {};
+    const left = !item.targetAddition && !['added', 'unversioned'].includes(item.rawStatus) ? await properties(root, item.path, true, options) : {};
     const right = ['deleted', 'unversioned'].includes(item.rawStatus) ? {} : await properties(root, item.path, false, options);
     if (hash(JSON.stringify([left, right])) !== item.propertyIdentity) throw new Error('Properties changed during capture');
   }