@danceiny/gotry 0.0.1-rc.21 → 0.0.1-rc.24

package/dist/scripts/dsh-session-v3-migration-proof.js

@@ -0,0 +1,106 @@
+/**
+ * Session V3 确定性迁移契约(issue #268):在隔离临时目录下用真实发布的 V2 编解码器
+ * 生成 V2 header/events,序列化为 JSONL 字节写入磁盘,保存确切源字节快照;通过
+ * sessionFormatCatalog 从磁盘读取并解析这些字节,分类为 migration-required,迁移为
+ * V3,编码独立 V3 继任者写入磁盘;然后用 catalog validation:current 完全解码 V3
+ * 继任者;迁移后重新读取 V2 源文件做字节比较,证明迁移不修改源工件字节。
+ *
+ * 这是确定性格式兼容性证据(隔离文件字节,非内存 structuredClone),不是创始人状态
+ * 迁移,也不是 M5/M6 准入。
+ *
+ * 运行:cd ts && npx tsx scripts/dsh-session-v3-migration-proof.ts
+ */
+import assert from 'node:assert/strict';
+import { writeFileSync, readFileSync, mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { sessionFormatCatalog } from '@deepseek-ai/dsh-session-format-catalog';
+import { releasedV2SessionFormatCodec } from '@deepseek-ai/dsh-session-format-v1-to-v2';
+// 最小有效 V2 工件:一个 turn 包含一个 step,turn 正常完成。
+// V2 事件处置要求 turn/start 需 ["turn"],step/start|step/end 需 ["turn","step"],
+// turn/end 需 ["turn","reason"],reason.kind="completed" 是最简有效种类。
+const v2Header = {
+    version: 2,
+    id: 's-min-v2',
+    createdAt: 1700000000000,
+    isSeeded: false,
+    delegationDepth: 0,
+};
+const v2Events = [
+    { type: 'turn/start', seq: 0, time: 1700000000000, data: { turn: 1 } },
+    { type: 'step/start', seq: 1, time: 1700000000001, data: { turn: 1, step: 1 } },
+    { type: 'step/end', seq: 2, time: 1700000000002, data: { turn: 1, step: 1 } },
+    { type: 'turn/end', seq: 3, time: 1700000000003, data: { turn: 1, reason: { kind: 'completed' } } },
+];
+// 1. 用真实发布的 V2 编解码器编码 header + 事件行为 JSON 对象,序列化为 JSONL 字节。
+const encodedHeader = releasedV2SessionFormatCodec.encodeHeader(v2Header, 0);
+const encodedRows = v2Events.map((e) => releasedV2SessionFormatCodec.encodeEvent(e));
+function toLine(obj) {
+    return JSON.stringify(obj);
+}
+const sourceLines = [toLine(encodedHeader), ...encodedRows.map(toLine)];
+const sourceJsonl = sourceLines.join('\n') + '\n';
+const tmp = mkdtempSync(join(tmpdir(), 'session-v3-migration-proof-'));
+const sourcePath = join(tmp, 'source.v2.jsonl');
+const successorPath = join(tmp, 'successor.v3.jsonl');
+try {
+    // 2. 写 V2 源字节到磁盘,保存确切源字节快照。
+    writeFileSync(sourcePath, sourceJsonl, 'utf8');
+    const sourceBytes = readFileSync(sourcePath);
+    // 3. 从磁盘读取并解析 V2 源字节:首行 = header,其余 = 事件行。
+    const parsedLines = readFileSync(sourcePath, 'utf8').split('\n').filter((l) => l.length > 0);
+    assert.ok(parsedLines.length === sourceLines.length, `磁盘行数必须等于源行数(${parsedLines.length} vs ${sourceLines.length})`);
+    const headerValue = JSON.parse(parsedLines[0]);
+    const rowValues = parsedLines.slice(1).map((l) => JSON.parse(l));
+    // 4. catalog 当前版本 = 3;V2 header 分类为 migration-required。
+    assert.equal(sessionFormatCatalog.currentVersion, 3, 'catalog 当前版本必须为 3');
+    const headerRead = sessionFormatCatalog.readHeader(headerValue);
+    assert.equal(headerRead.status, 'migration-required', `V2 header 必须分类为 migration-required(当前 ${headerRead.status})`);
+    // 5. 创建恢复器,逐行解码,完成恢复为 V3 工件(validation:transformed,迁移后校验)。
+    const restore = sessionFormatCatalog.createRestore(headerValue, {
+        recovery: 'recoverable',
+        validation: 'transformed',
+    });
+    for (const row of rowValues) {
+        restore.decodeRow(row);
+    }
+    const artifact = restore.finish();
+    // 6. V3 工件版本 = 3,事件数 = V2 + 1(在 step/start 后插入 system head)。
+    assert.equal(artifact.header.version, 3, '恢复后工件版本必须为 3');
+    assert.equal(artifact.events.length, v2Events.length + 1, `V3 事件数必须 = V2 + 1(插入 system head),当前 ${artifact.events.length}`);
+    // 插入的 system head(原 step/start 后,索引 2)必须是 system/message。
+    const inserted = artifact.events[2];
+    assert.equal(inserted.type, 'system/message', `插入的事件必须是 system/message(当前 ${inserted.type})`);
+    // 7. 编码 V3 继任者为 JSONL 字节,写入独立磁盘文件。
+    const v3HeaderRecord = sessionFormatCatalog.encodeCurrentHeader(artifact.header, artifact.inheritedEventCount);
+    const v3RowRecords = artifact.events.map((e) => sessionFormatCatalog.encodeCurrentEvent(e));
+    const successorLines = [toLine(v3HeaderRecord), ...v3RowRecords.map(toLine)];
+    const successorJsonl = successorLines.join('\n') + '\n';
+    writeFileSync(successorPath, successorJsonl, 'utf8');
+    // 8. 从磁盘读取 V3 继任者,用 catalog validation:current 完全解码。
+    const successorParsed = readFileSync(successorPath, 'utf8').split('\n').filter((l) => l.length > 0);
+    assert.ok(successorParsed.length === successorLines.length, `V3 磁盘行数必须等于继任者行数`);
+    const successorHeaderValue = JSON.parse(successorParsed[0]);
+    const successorRowValues = successorParsed.slice(1).map((l) => JSON.parse(l));
+    const successorRead = sessionFormatCatalog.readHeader(successorHeaderValue);
+    assert.equal(successorRead.status, 'current', `V3 继任者必须重新打开为 current(当前 ${successorRead.status})`);
+    const successorRestore = sessionFormatCatalog.createRestore(successorHeaderValue, {
+        recovery: 'recoverable',
+        validation: 'current',
+    });
+    for (const row of successorRowValues) {
+        successorRestore.decodeRow(row);
+    }
+    const successorArtifact = successorRestore.finish();
+    assert.equal(successorArtifact.header.version, 3, 'V3 继任者完全解码后版本必须为 3');
+    assert.equal(successorArtifact.events.length, artifact.events.length, 'V3 继任者完全解码后事件数必须与迁移工件一致');
+    // 9. 迁移后重新读取 V2 源文件字节,与快照字节比较——证明迁移不修改源工件字节。
+    const sourceBytesAfter = readFileSync(sourcePath);
+    assert.ok(Buffer.compare(sourceBytes, sourceBytesAfter) === 0, '迁移后 V2 源文件字节必须与快照完全一致——迁移不修改源工件字节');
+    console.log(`SESSION V3 MIGRATION PROOF: V2 source ${sourceBytes.length}B (${v2Events.length} events) on disk → ` +
+        `V3(${artifact.events.length} events, +system/message), successor ${successorJsonl.length}B reopens as current ` +
+        `and fully decodes (${successorArtifact.events.length} events), source bytes unchanged after migration`);
+}
+finally {
+    rmSync(tmp, { recursive: true, force: true });
+}

package/dist/scripts/dsh-subprocess-local-proof.js

@@ -0,0 +1,149 @@
+/**
+ * dsh-subprocess-local 确定性证明(issue #268):仅通过公共 API 挂载 provider,
+ * 执行真实的本地托管子进程与 PTY,观察真实输出,终止它,await 公共 waitForExit,
+ * 并证明派生后代已消失。平台中立(Ubuntu CI + macOS)——不调用私有
+ * selectContainmentMode()/disposeManagedProcesses(),不断言主机是 macOS fallback,
+ * 不用已退出的顶层进程作为后代清理替代。
+ *
+ * 公共挂载模式:await ctx.plugin(LocalSubprocessRuntime) → ctx.subprocess 可用。
+ * spawn 一个活跃的 node 父进程(被 provider 以 detached:true 启动,自成进程组领袖),
+ * 该父进程用 child_process.spawn 创建一个非分离的真实长运行子进程(继承父进程组),
+ * 并将子进程 PID 输出到 stdout。证明通过收集 stdout 读取子进程 PID,调用公共
+ * terminate() + await waitForExit(有界 abort 信号),断言父进程结果和子进程 PID
+ * 都已消失(进程组信号终止整个组)。
+ *
+ * 真实 PTY 验证在 CI 支持平台(Linux/macOS)都执行:spawnTerminal 启动 node 子进程,
+ * 子进程向 stdout 写入 'pty-line\n' 并正常退出;断言 PTY 输出包含 'pty-line' 且 exitCode=0。
+ * 目标 node-pty 包的 Darwin 预构建同时带 `pty.node` 与 `spawn-helper`，Linux x64/arm64
+ * 预构建只带 `pty.node`。本证明在两个平台都跑真实 PTY 行为；filesystem 上
+ * spawn-helper 存在性与 0755 模式断言仅在 Darwin 下生效。Linux 报告
+ * "helper not-applicable"，同时仍验证真实 PTY 输出与成功退出，不 stat 不存在的文件。
+ *
+ * finally 中 await ctx.fiber.dispose() 并移除临时文件。不向子进程传递整个环境变量。
+ *
+ * 运行:cd ts && npx tsx scripts/dsh-subprocess-local-proof.ts
+ */
+import assert from 'node:assert/strict';
+import { writeFileSync, mkdtempSync, rmSync, existsSync, statSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { Context } from '@deepseek-ai/cordis';
+import { LocalSubprocessRuntime } from '@deepseek-ai/dsh-subprocess-local';
+const ctx = new Context();
+const fiber = ctx.plugin(LocalSubprocessRuntime);
+await fiber;
+const tmp = mkdtempSync(join(tmpdir(), 'subprocess-local-proof-'));
+let childPid;
+let childGoneAfter = false;
+let parentOutcome;
+let rangeEmpty;
+let ptyExitCode = null;
+let ptyOutput = '';
+let helperFact;
+let helperMode;
+try {
+    // 1. 父进程脚本:spawn 一个非分离的长运行子进程(继承父进程组),输出子进程 PID。
+    //    父进程自身保持活跃(setInterval),直到被 provider 终止。
+    const parentScript = join(tmp, 'parent.mjs');
+    writeFileSync(parentScript, [
+        "import { spawn } from 'node:child_process'",
+        "const child = spawn(process.execPath, ['-e', 'setInterval(() => {}, 60000)'], { stdio: 'inherit' })",
+        "process.stdout.write('CHILD_PID=' + child.pid + '\\n')",
+        'setInterval(() => {}, 60000)',
+        '',
+    ].join('\n'));
+    // 2. 通过公共 ctx.subprocess.spawn 启动父进程。不传 env——让 provider 用
+    //    scrubbedParentEnv() 清洗环境(保留 PATH/HOME,剥离凭据/DSH_*),不传递整个环境变量。
+    const handle = ctx.subprocess.spawn({
+        argv: [process.execPath, parentScript],
+        cwd: tmp,
+        stdio: { stdin: 'ignore', stdout: { maxBytes: 1 << 20 }, stderr: { maxBytes: 1 << 20 } },
+        graceMs: 8000,
+    });
+    const stdoutReader = handle.collected.stdout;
+    assert.ok(stdoutReader, 'collect 模式下 collected.stdout reader 必须存在');
+    // 3. 通过观察父进程输出获取子进程 PID(有界轮询,不假设即时可用)。
+    let observedChildPid;
+    const pollDeadline = Date.now() + 5000;
+    while (Date.now() < pollDeadline && observedChildPid === undefined) {
+        const read = stdoutReader.readFrom(0);
+        const m = /CHILD_PID=(\d+)/.exec(read.text);
+        if (m)
+            observedChildPid = Number(m[1]);
+        else
+            await new Promise((r) => setTimeout(r, 20));
+    }
+    assert.ok(observedChildPid !== undefined && observedChildPid > 0, `必须从父进程 stdout 观察到有效 CHILD_PID(当前 ${observedChildPid})`);
+    childPid = observedChildPid;
+    // 4. 终止前:子进程必须存活(父进程已 spawn 它)。
+    assert.ok(isPidAlive(childPid), `终止前子进程 PID ${childPid} 必须存活`);
+    // 5. 调用公共 terminate() + await 公共 waitForExit(有界 abort 信号)。
+    //    进程组信号(process.kill(-parentPid, SIGTERM))终止整个组,包括非分离子进程。
+    handle.terminate();
+    rangeEmpty = await handle.waitForExit(AbortSignal.timeout(8000));
+    assert.equal(rangeEmpty, true, 'waitForExit 必须返回 true——托管范围(含后代)已空');
+    // 6. 断言直接进程结果:父进程被信号终止(非正常退出)。
+    parentOutcome = await handle.done;
+    assert.ok(parentOutcome.exitCode === null && parentOutcome.signal !== null, `父进程必须被信号终止(exitCode=${parentOutcome.exitCode}, signal=${parentOutcome.signal})`);
+    // 7. 断言子进程 PID 不再存在——后代清理的真实证据(非已退出顶层进程替代)。
+    childGoneAfter = !isPidAlive(childPid);
+    assert.ok(childGoneAfter, `provider 终止后子进程 PID ${childPid} 必须已消失——进程组包含的真实后代清理证据`);
+    // 8. 真实 PTY 验证(每个支持平台都执行):spawnTerminal 用 native PTY 后端 fork/exec,
+    //    子进程写 'pty-line\n' 并正常退出。原生 PTY 输出经 PTY 终端层到达 PTY 主面,
+    //    再被 node-pty 回调成 output 'data' 事件——这是跨平台的 PTY 行为证明。
+    const ptyScript = join(tmp, 'pty.mjs');
+    writeFileSync(ptyScript, "process.stdout.write('pty-line\\n'); process.exit(0);\n");
+    const term = await ctx.subprocess.spawnTerminal({
+        argv: [process.execPath, ptyScript],
+        cwd: tmp,
+        rows: 24,
+        cols: 80,
+        graceMs: 8000,
+    });
+    assert.equal(typeof term.pid, 'number', `PTY pid 必须是数字(当前 ${typeof term.pid})`);
+    assert.ok(term.pid > 0, `PTY pid 必须为正(当前 ${term.pid})`);
+    term.output.on('data', (d) => {
+        ptyOutput += d.toString();
+    });
+    const termOutcome = await term.done;
+    ptyExitCode = termOutcome.exitCode;
+    assert.equal(ptyExitCode, 0, `PTY 必须正常退出(exitCode=${ptyExitCode})`);
+    assert.equal(termOutcome.signal, null, `PTY 正常退出不得携带 signal(当前 ${termOutcome.signal})`);
+    assert.ok(ptyOutput.includes('pty-line'), `PTY 输出必须包含 pty-line(当前 ${JSON.stringify(ptyOutput)})`);
+    await term.terminate();
+    // 9. node-pty spawn-helper 文件系统断言仅在 Darwin 下生效。
+    //    已检查的目标包事实:darwin-{x64,arm64}/prebuilds 同时带 pty.node 与
+    //    spawn-helper，linux-{x64,arm64}/prebuilds 仅带 pty.node。本证明不构造、
+    //    不复制、不 stat 实际不存在的 helper。
+    helperMode = null;
+    if (process.platform === 'darwin') {
+        const ptyEntry = fileURLToPath(import.meta.resolve('node-pty'));
+        const ptyRoot = dirname(dirname(ptyEntry));
+        const helperPath = join(ptyRoot, 'prebuilds', `${process.platform}-${process.arch}`, 'spawn-helper');
+        assert.ok(existsSync(helperPath), `Darwin prebuilds 必须携带 spawn-helper(实际不存在:${helperPath})——ensure-spawn-helper.mjs 的终局面契约`);
+        helperMode = statSync(helperPath).mode & 0o777;
+        assert.equal(helperMode, 0o755, `Darwin spawn-helper 权限模式必须是 0755(当前 0o${helperMode.toString(8)})——ensure-spawn-helper.mjs 的终局面契约`);
+        helperFact = `helper=darwin 0o${helperMode.toString(8)}`;
+    }
+    else {
+        helperFact = `helper=not-applicable:${process.platform}-${process.arch}; real PTY output='pty-line' present, exitCode=0`;
+        assert.ok(ptyExitCode === 0 && ptyOutput.includes('pty-line'), '非 Darwin 平台必须仍证明真实 PTY 行为:PTY 输出包含 pty-line 且 exitCode=0');
+    }
+    console.log(`SUBPROCESS LOCAL PROOF: parent killed by signal ${parentOutcome.signal}, child PID ${childPid} gone after terminate=${childGoneAfter}, ` +
+        `waitForExit rangeEmpty=${rangeEmpty}, PTY pid=${term.pid} exitCode=${ptyExitCode} output-has-pty-line=${ptyOutput.includes('pty-line')}, ` +
+        `${helperFact}`);
+}
+finally {
+    await ctx.fiber.dispose();
+    rmSync(tmp, { recursive: true, force: true });
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/scripts/dsh-target-closure-proof.js

@@ -0,0 +1,178 @@
+/**
+ * DSH 目标闭包契约(issue #268):读取仓库当前状态,断言已精确迁移到
+ * @deepseek-ai/dsh 0.1.5-rc.1 的 232 包闭包。这是 issue #268 的 failing-before
+ * 契约——在起始 0.1.2-alpha.3/216 闭包上必须失败,迁移完成后必须通过。
+ *
+ * 断言面(任一不符即 FAIL):
+ *  - 运行时 spawn guard 版本 = 目标;
+ *  - 闭包常量 = 目标包数;
+ *  - 根 manifest 全部 dsh* 依赖精确锁定目标版本,包数 = 目标;
+ *  - 目标闭包 sentinel 在根 manifest 精确存在(含 alpha.1→rc.1 新增三项与 documentpreview 更名),移除项不存在;
+ *  - 根 npm lock 闭包与 manifest 集合/版本/包数一致;
+ *  - 根 pnpm lock 闭包 + root importer 与 manifest 集合/版本/包数一致;
+ *  - ts/package.json 显式声明 @deepseek-ai/dsh-sdk-client@目标(GoTry 直接 import,
+ *    不再由上游 main 图传递到达),且其所有显式 dsh* 依赖精确锁定目标版本;
+ *  - ts/package.json overrides 的名称集合与根 232 包集合完全一致，值全部精确目标版本;
+ *  - ts/package-lock.json 每个真实 DSH 条目(按最后包名段过滤,排除嵌套非 dsh 依赖)
+ *    精确锁定目标版本,包数 = 目标,名称集合与根 232 完全一致,拒绝嵌套/混合版本;
+ *  - ts/ 实际安装树:用 ts 包的 createRequire 上下文解析每个 dsh 包 package.json,
+ *    全精确目标版本,解析路径直接位于 ts/node_modules/@deepseek-ai/ 下(非嵌套)。
+ *
+ * 仅根目录 232 证据不足——ts/ 是 GoTry 直接 import 的消费方,必须独立验证其三层闭包。
+ *
+ * 运行:cd ts && npx tsx scripts/dsh-target-closure-proof.ts
+ */
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createRequire } from 'node:module';
+import { REQUIRED_BENCHMARK_DSH_VERSION } from '../../bin/gotry-runtime-resolution.js';
+import { parsePnpmDshLock, parsePnpmRootDshImporter, REQUIRED_DSH_RUNTIME_PACKAGE_COUNT, validateDshRuntimeClosure, validatePnpmRootDshImporter, } from './dsh-runtime-closure.js';
+const TARGET_VERSION = '0.1.5-rc.1';
+const TARGET_PACKAGE_COUNT = 232;
+const ADDED_SENTINELS = [
+    '@deepseek-ai/dsh-api-workspace-files',
+    '@deepseek-ai/dsh-chunked-list',
+    '@deepseek-ai/dsh-client-file-upload',
+    '@deepseek-ai/dsh-client-resources',
+    '@deepseek-ai/dsh-client-ui-open-in-app',
+    '@deepseek-ai/dsh-client-ui-sidebar-documentpreview',
+    '@deepseek-ai/dsh-client-ui-sidebar-files',
+    '@deepseek-ai/dsh-client-ui-sidebar-right',
+    '@deepseek-ai/dsh-host-open-in-app',
+    '@deepseek-ai/dsh-http-proxy',
+    '@deepseek-ai/dsh-package-manifest',
+    '@deepseek-ai/dsh-session-format',
+    '@deepseek-ai/dsh-session-format-catalog',
+    '@deepseek-ai/dsh-session-format-v0-to-v1',
+    '@deepseek-ai/dsh-session-format-v1-to-v2',
+    '@deepseek-ai/dsh-session-format-v2-to-v3',
+    '@deepseek-ai/dsh-tool-present',
+];
+const REMOVED_SENTINELS = [
+    '@deepseek-ai/dsh-client-ui-sidebar-textpreview',
+    '@deepseek-ai/dsh-tool-subagent-report',
+];
+const repoRoot = join(import.meta.dirname, '..', '..');
+function readJson(filePath) {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+}
+function dshDependencyNames(deps) {
+    return Object.keys(deps)
+        .filter((name) => name === '@deepseek-ai/dsh' || name.startsWith('@deepseek-ai/dsh-'))
+        .sort();
+}
+// 1. 运行时 spawn guard 与闭包常量必须已对齐目标。
+assert.equal(REQUIRED_BENCHMARK_DSH_VERSION, TARGET_VERSION, `runtime spawn guard 必须锁定 ${TARGET_VERSION}(当前 ${REQUIRED_BENCHMARK_DSH_VERSION})`);
+assert.equal(REQUIRED_DSH_RUNTIME_PACKAGE_COUNT, TARGET_PACKAGE_COUNT, `闭包常量必须为 ${TARGET_PACKAGE_COUNT}(当前 ${REQUIRED_DSH_RUNTIME_PACKAGE_COUNT})`);
+// 2. 根 manifest:全部 dsh* 依赖精确锁定目标版本,包数 = 目标。
+const rootPkg = readJson(join(repoRoot, 'package.json'));
+const rootDeps = rootPkg.dependencies ?? {};
+assert.equal(rootDeps['@deepseek-ai/dsh'], TARGET_VERSION, '根 manifest @deepseek-ai/dsh 未锁定目标版本');
+const rootDshNames = dshDependencyNames(rootDeps);
+for (const name of rootDshNames) {
+    assert.equal(rootDeps[name], TARGET_VERSION, `根 manifest 版本漂移:${name}@${rootDeps[name]}(expected ${TARGET_VERSION})`);
+}
+for (const name of ADDED_SENTINELS) {
+    assert.equal(rootDeps[name], TARGET_VERSION, `根 manifest 缺失目标新增 sentinel:${name}`);
+}
+for (const name of REMOVED_SENTINELS) {
+    assert.ok(!(name in rootDeps), `根 manifest 必须移除:${name}`);
+}
+assert.equal(rootDshNames.length, TARGET_PACKAGE_COUNT, `根 manifest dsh 包数不符:${rootDshNames.length}(expected ${TARGET_PACKAGE_COUNT})`);
+// 3. 根 npm lock 闭包与 manifest 集合/版本/包数一致。
+const npmLock = JSON.parse(readFileSync(join(repoRoot, 'package-lock.json'), 'utf8'));
+const npmClosure = validateDshRuntimeClosure({
+    dependencies: rootDeps,
+    lockPackages: npmLock.packages ?? {},
+    runtimeVersion: TARGET_VERSION,
+    expectedPackageCount: TARGET_PACKAGE_COUNT,
+});
+// 4. 根 pnpm lock 闭包 + root importer 与 manifest 集合/版本/包数一致。
+const pnpmLock = readFileSync(join(repoRoot, 'pnpm-lock.yaml'), 'utf8');
+const pnpmClosure = validateDshRuntimeClosure({
+    dependencies: rootDeps,
+    lockPackages: parsePnpmDshLock(pnpmLock),
+    runtimeVersion: TARGET_VERSION,
+    expectedPackageCount: TARGET_PACKAGE_COUNT,
+});
+const pnpmImporter = validatePnpmRootDshImporter({
+    dependencies: rootDeps,
+    importerEntries: parsePnpmRootDshImporter(pnpmLock),
+    runtimeVersion: TARGET_VERSION,
+    expectedPackageCount: TARGET_PACKAGE_COUNT,
+});
+// 5. ts/package.json 必须显式声明 dsh-sdk-client@目标(GoTry 直接 import)。
+const tsDir = join(repoRoot, 'ts');
+const tsPkg = readJson(join(tsDir, 'package.json'));
+assert.equal(tsPkg.dependencies?.['@deepseek-ai/dsh-sdk-client'], TARGET_VERSION, 'ts/package.json 必须显式声明 @deepseek-ai/dsh-sdk-client@' + TARGET_VERSION);
+// 6. ts/package.json:所有显式 dsh* 依赖必须精确锁定目标版本(不要求 232,ts/ 闭包是
+//    传递性的;但显式声明的每个 dsh 依赖都必须精确,不允许 ^/~ 可变范围)。
+const tsDeps = tsPkg.dependencies ?? {};
+const tsExplicitDsh = dshDependencyNames(tsDeps);
+for (const name of tsExplicitDsh) {
+    assert.equal(tsDeps[name], TARGET_VERSION, `ts/package.json 显式 dsh 依赖版本漂移:${name}@${tsDeps[name]}(expected ${TARGET_VERSION})`);
+}
+// 7. ts/package.json overrides 必须精确覆盖根 manifest 的完整 232 包集合。
+//    这组 override 是修复 sdk-client peer range 漂移到 alpha.2 的关键约束；只验证
+//    三个显式依赖或最终 lock 会遗漏 manifest 层的防漂移策略。
+const tsOverrides = tsPkg.overrides ?? {};
+const tsOverrideDshNames = dshDependencyNames(tsOverrides);
+assert.deepEqual(tsOverrideDshNames, rootDshNames, 'ts/package.json overrides 的 DSH 名称集合必须与根 232 包集合完全一致');
+for (const name of tsOverrideDshNames) {
+    assert.equal(tsOverrides[name], TARGET_VERSION, `ts/package.json override 版本漂移:${name}@${tsOverrides[name]}(expected ${TARGET_VERSION})`);
+}
+// 8. ts/package-lock.json:每个真实 DSH 条目(按包名过滤,排除嵌套非 dsh 依赖)必须
+//    精确锁定目标版本,包数 = 目标,名称集合与根 232 完全一致。
+//    关键:lock 路径前缀 `node_modules/@deepseek-ai/dsh-skill-filesystem/node_modules/chokidar`
+//    的最后包名段是 `chokidar`(非 dsh),不能按路径前缀过滤,必须按最后包名段过滤。
+const tsNpmLock = JSON.parse(readFileSync(join(tsDir, 'package-lock.json'), 'utf8'));
+const tsLockPackages = tsNpmLock.packages ?? {};
+function lastPackageName(lockKey) {
+    const idx = lockKey.lastIndexOf('node_modules/');
+    return idx >= 0 ? lockKey.slice(idx + 'node_modules/'.length) : lockKey;
+}
+function isDshPackageName(name) {
+    return name === '@deepseek-ai/dsh' || name.startsWith('@deepseek-ai/dsh-');
+}
+const tsLockDshNames = new Set();
+for (const [key, entry] of Object.entries(tsLockPackages)) {
+    if (key === '')
+        continue; // 根包自身
+    const pkgName = lastPackageName(key);
+    if (!isDshPackageName(pkgName))
+        continue;
+    // 拒绝嵌套 dsh 条目:路径包含多次 node_modules/ 且最后段是 dsh 包 → 嵌套副本。
+    const nodeModulesCount = key.split('node_modules/').length - 1;
+    assert.equal(nodeModulesCount, 1, `ts lock 拒绝嵌套/混合版本 dsh 条目:${key}(node_modules 深度 ${nodeModulesCount})`);
+    assert.equal(entry.version, TARGET_VERSION, `ts lock dsh 条目版本漂移:${pkgName}@${entry.version}(expected ${TARGET_VERSION})`);
+    assert.ok(!tsLockDshNames.has(pkgName), `ts lock 出现重复 dsh 条目:${pkgName}`);
+    tsLockDshNames.add(pkgName);
+}
+assert.equal(tsLockDshNames.size, TARGET_PACKAGE_COUNT, `ts lock dsh 包数不符:${tsLockDshNames.size}(expected ${TARGET_PACKAGE_COUNT})`);
+const rootDshNameSet = new Set(rootDshNames);
+for (const name of tsLockDshNames) {
+    assert.ok(rootDshNameSet.has(name), `ts lock dsh 包不在根 232 集合中:${name}`);
+}
+for (const name of rootDshNameSet) {
+    assert.ok(tsLockDshNames.has(name), `根 232 dsh 包不在 ts lock 中:${name}`);
+}
+// 9. ts/ 实际安装树:用 ts 包的 createRequire 上下文解析每个 dsh 包的 package.json,
+//    读取版本,断言全精确目标版本;解析路径必须直接位于 ts/node_modules/@deepseek-ai/
+//    下(非嵌套),拒绝混合版本。
+const tsRequire = createRequire(join(tsDir, 'package.json'));
+const tsNodeModulesDshDir = join(tsDir, 'node_modules', '@deepseek-ai');
+const tsInstalledNames = new Set();
+for (const name of rootDshNames) {
+    const pkgJsonPath = tsRequire.resolve(join(name, 'package.json'));
+    const entry = JSON.parse(readFileSync(pkgJsonPath, 'utf8'));
+    assert.equal(entry.version, TARGET_VERSION, `ts 安装树版本漂移:${name}@${entry.version}(expected ${TARGET_VERSION})`);
+    // 解析路径必须直接位于 ts/node_modules/@deepseek-ai/<pkg>/package.json——非嵌套。
+    assert.ok(pkgJsonPath.startsWith(tsNodeModulesDshDir + '/'), `ts 安装树解析路径不在直接 @deepseek-ai 目录下(嵌套/混合版本):${name} → ${pkgJsonPath}`);
+    const relative = pkgJsonPath.slice(tsNodeModulesDshDir.length + 1);
+    assert.ok(!relative.includes('/node_modules/'), `ts 安装树出现嵌套 dsh 副本:${name} → ${relative}`);
+    tsInstalledNames.add(name);
+}
+assert.equal(tsInstalledNames.size, TARGET_PACKAGE_COUNT, `ts 安装树 dsh 包数不符:${tsInstalledNames.size}(expected ${TARGET_PACKAGE_COUNT})`);
+console.log(`DSH TARGET CLOSURE PROOF: root ${npmClosure.names.length} npm / ${pnpmClosure.names.length} pnpm / ${pnpmImporter.names.length} importer, ` +
+    `ts ${tsExplicitDsh.length} explicit / ${tsOverrideDshNames.length} overrides / ${tsLockDshNames.size} lock / ${tsInstalledNames.size} installed at ${TARGET_VERSION}`);