harness-reflex 0.0.0-stage → 0.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +20 -0
- package/README.md +266 -2
- package/USER_GUIDE.md +639 -0
- package/dist/adapters/agy.d.ts +8 -0
- package/dist/adapters/agy.js +80 -0
- package/dist/adapters/agy.js.map +1 -0
- package/dist/adapters/claude.d.ts +13 -0
- package/dist/adapters/claude.js +46 -0
- package/dist/adapters/claude.js.map +1 -0
- package/dist/adapters/codex.d.ts +139 -0
- package/dist/adapters/codex.js +368 -0
- package/dist/adapters/codex.js.map +1 -0
- package/dist/backend/defaults.d.ts +31 -0
- package/dist/backend/defaults.js +32 -0
- package/dist/backend/defaults.js.map +1 -0
- package/dist/backend/factory.d.ts +11 -0
- package/dist/backend/factory.js +40 -0
- package/dist/backend/factory.js.map +1 -0
- package/dist/backend/jev.d.ts +524 -0
- package/dist/backend/jev.js +1486 -0
- package/dist/backend/jev.js.map +1 -0
- package/dist/backend/mock.d.ts +26 -0
- package/dist/backend/mock.js +320 -0
- package/dist/backend/mock.js.map +1 -0
- package/dist/backend/route-prompt.d.ts +37 -0
- package/dist/backend/route-prompt.js +42 -0
- package/dist/backend/route-prompt.js.map +1 -0
- package/dist/backend/simple-jev.d.ts +35 -0
- package/dist/backend/simple-jev.js +273 -0
- package/dist/backend/simple-jev.js.map +1 -0
- package/dist/backend/types.d.ts +270 -0
- package/dist/backend/types.js +5 -0
- package/dist/backend/types.js.map +1 -0
- package/dist/cli/index.d.ts +2 -0
- package/dist/cli/index.js +278 -0
- package/dist/cli/index.js.map +1 -0
- package/dist/core/calibrate.d.ts +56 -0
- package/dist/core/calibrate.js +144 -0
- package/dist/core/calibrate.js.map +1 -0
- package/dist/core/closing.d.ts +90 -0
- package/dist/core/closing.js +111 -0
- package/dist/core/closing.js.map +1 -0
- package/dist/core/evidence.d.ts +119 -0
- package/dist/core/evidence.js +209 -0
- package/dist/core/evidence.js.map +1 -0
- package/dist/core/gate.d.ts +25 -0
- package/dist/core/gate.js +114 -0
- package/dist/core/gate.js.map +1 -0
- package/dist/core/judge.d.ts +221 -0
- package/dist/core/judge.js +251 -0
- package/dist/core/judge.js.map +1 -0
- package/dist/core/ledger.d.ts +67 -0
- package/dist/core/ledger.js +173 -0
- package/dist/core/ledger.js.map +1 -0
- package/dist/core/orchestrate-closing.d.ts +237 -0
- package/dist/core/orchestrate-closing.js +250 -0
- package/dist/core/orchestrate-closing.js.map +1 -0
- package/dist/core/orchestrate-correction.d.ts +209 -0
- package/dist/core/orchestrate-correction.js +141 -0
- package/dist/core/orchestrate-correction.js.map +1 -0
- package/dist/core/orchestrate-host.d.ts +225 -0
- package/dist/core/orchestrate-host.js +80 -0
- package/dist/core/orchestrate-host.js.map +1 -0
- package/dist/core/orchestrate-stagnation.d.ts +259 -0
- package/dist/core/orchestrate-stagnation.js +270 -0
- package/dist/core/orchestrate-stagnation.js.map +1 -0
- package/dist/core/orchestrate.d.ts +357 -0
- package/dist/core/orchestrate.js +418 -0
- package/dist/core/orchestrate.js.map +1 -0
- package/dist/core/policy.d.ts +122 -0
- package/dist/core/policy.js +102 -0
- package/dist/core/policy.js.map +1 -0
- package/dist/core/prune-plan.d.ts +141 -0
- package/dist/core/prune-plan.js +390 -0
- package/dist/core/prune-plan.js.map +1 -0
- package/dist/core/prune.d.ts +30 -0
- package/dist/core/prune.js +73 -0
- package/dist/core/prune.js.map +1 -0
- package/dist/core/route.d.ts +35 -0
- package/dist/core/route.js +39 -0
- package/dist/core/route.js.map +1 -0
- package/dist/core/score.d.ts +40 -0
- package/dist/core/score.js +49 -0
- package/dist/core/score.js.map +1 -0
- package/dist/core/screen.d.ts +22 -0
- package/dist/core/screen.js +117 -0
- package/dist/core/screen.js.map +1 -0
- package/dist/core/stagnation.d.ts +23 -0
- package/dist/core/stagnation.js +93 -0
- package/dist/core/stagnation.js.map +1 -0
- package/dist/core/text.d.ts +36 -0
- package/dist/core/text.js +66 -0
- package/dist/core/text.js.map +1 -0
- package/dist/hook/cli.d.ts +9 -0
- package/dist/hook/cli.js +52 -0
- package/dist/hook/cli.js.map +1 -0
- package/dist/hook/contract.d.ts +125 -0
- package/dist/hook/contract.js +159 -0
- package/dist/hook/contract.js.map +1 -0
- package/dist/hook/decision.d.ts +97 -0
- package/dist/hook/decision.js +955 -0
- package/dist/hook/decision.js.map +1 -0
- package/dist/hook/memory-store.d.ts +81 -0
- package/dist/hook/memory-store.js +157 -0
- package/dist/hook/memory-store.js.map +1 -0
- package/dist/hook/payload.d.ts +55 -0
- package/dist/hook/payload.js +129 -0
- package/dist/hook/payload.js.map +1 -0
- package/dist/hook/run.d.ts +48 -0
- package/dist/hook/run.js +218 -0
- package/dist/hook/run.js.map +1 -0
- package/dist/hook/store-port.d.ts +72 -0
- package/dist/hook/store-port.js +2 -0
- package/dist/hook/store-port.js.map +1 -0
- package/dist/index.d.ts +18 -0
- package/dist/index.js +19 -0
- package/dist/index.js.map +1 -0
- package/dist/mcp/server.d.ts +12 -0
- package/dist/mcp/server.js +368 -0
- package/dist/mcp/server.js.map +1 -0
- package/dist/ports/audit.d.ts +18 -0
- package/dist/ports/audit.js +11 -0
- package/dist/ports/audit.js.map +1 -0
- package/dist/ports/clock.d.ts +14 -0
- package/dist/ports/clock.js +11 -0
- package/dist/ports/clock.js.map +1 -0
- package/dist/ports/decision.d.ts +75 -0
- package/dist/ports/decision.js +2 -0
- package/dist/ports/decision.js.map +1 -0
- package/dist/ports/index.d.ts +14 -0
- package/dist/ports/index.js +2 -0
- package/dist/ports/index.js.map +1 -0
- package/dist/ports/log.d.ts +22 -0
- package/dist/ports/log.js +12 -0
- package/dist/ports/log.js.map +1 -0
- package/dist/ports/state.d.ts +46 -0
- package/dist/ports/state.js +13 -0
- package/dist/ports/state.js.map +1 -0
- package/dist/state/clock.d.ts +40 -0
- package/dist/state/clock.js +43 -0
- package/dist/state/clock.js.map +1 -0
- package/dist/state/file-store.d.ts +340 -0
- package/dist/state/file-store.js +849 -0
- package/dist/state/file-store.js.map +1 -0
- package/dist/state/paths.d.ts +41 -0
- package/dist/state/paths.js +73 -0
- package/dist/state/paths.js.map +1 -0
- package/docs/USER_GUIDE.en.md +721 -0
- package/docs/claude-code.md +281 -0
- package/docs/design/v0.2.0-harness-plugins.md +381 -0
- package/docs/design/v0.3.0-orchestration-unification.md +580 -0
- package/docs/dsh-plugin.md +578 -0
- package/docs/reflex-ui-regression-2026-10-20.md +34 -0
- package/docs/release-checklist-v0.1.0.md +315 -0
- package/docs/release-handbook-porting-notes.md +106 -0
- package/docs/release-handbook.md +393 -0
- package/docs/release-notes-v0.1.0.md +63 -0
- package/docs/release-notes-v0.3.0.md +152 -0
- package/docs/research/claude-code-harness.md +607 -0
- package/docs/research/pi-harness.md +621 -0
- package/experiments/data/calibration_sample.json +14 -0
- package/experiments/index.ts +29 -0
- package/experiments/runner.ts +156 -0
- package/package.json +82 -4
|
@@ -0,0 +1,580 @@
|
|
|
1
|
+
# v0.3.0 编排层统一设计:DSH 插件与 Claude 插件共用一份决策
|
|
2
|
+
|
|
3
|
+
> 定位:**决策文档,不是资料堆**。依据是当前 HEAD `6872581` 的两份实现——
|
|
4
|
+
> 共享层 `src/hook/decision.ts`(g-040 抽出的 `HookDecision`,下称 **HOOK**)、
|
|
5
|
+
> DSH 侧引擎 `packages/dsh-harness-reflex/src/interventions.ts`(下称 **DSH**,行号以 `6872581` 为准)。
|
|
6
|
+
> 边界:只写设计与范围,**不改任何实现代码与测试**;所有「文件:行号」都在本基线用 `read`/`grep` 核对过。
|
|
7
|
+
>
|
|
8
|
+
> 状态:**待负责人拍板**(§7 共 5 件事);快照 2026-11-02;设计基线 `0.3.0-harnesses` 的 `6872581`。
|
|
9
|
+
|
|
10
|
+
## 0. 结论速览
|
|
11
|
+
|
|
12
|
+
- **一个真实缺口**:DSH 与 Claude 侧共享 `core/`(`suspicionOf`/`applyPruneFloor`/`claimCandidates`/
|
|
13
|
+
`assembleEvidence`/`evidenceOf`),**不**共享「拿什么去问、花什么预算去问、问完怎么记账、记账怎么措辞」。
|
|
14
|
+
这四件事在两侧各写了一遍(HOOK §2.1 表)。
|
|
15
|
+
- **改造不是搬代码,是接缝**:七个差异里有五个是「宿主能力」,只有两个(会话粒度、判定窗口)是
|
|
16
|
+
「状态载体选错了」。因此**不把 DSH 塞进 `HookDecision`**(那会逼 HOOK 长出宿主编排,Claude 侧白白变复杂),
|
|
17
|
+
而是把两侧共同的那一层抽到 `core/` + 新增 `ports/host.ts`,让 `HookDecision` 成为它的第一个宿主、
|
|
18
|
+
DSH 引擎成为第二个。
|
|
19
|
+
- **最小可行第一批 = 剪枝**(§5.3):它的执行顺序本身就是安全属性(保留原文 → 判定 → 组合 → 比对缩小 →
|
|
20
|
+
才记节省),是四批里唯一「顺序错了会摧毁数据」的一批;先把它做成共享层,剩下三批的接缝形状就被逼出来了。
|
|
21
|
+
- **行为对照可执行**(§6):三层——① 决策序列对拍(同一输入序列 → 规范化 ledger/审计记录逐项相等);
|
|
22
|
+
② 全量信号对拍(把 DSH 的 `InterventionReport` 与 `readEvents(limit)` 快照压进同一基线);
|
|
23
|
+
③ 随机序列差分(固定种子生成输入,两侧引擎跑同一序列)。判据是 §6.3 的 12 条断言。
|
|
24
|
+
|
|
25
|
+
## 1. 归属拆分(问题一)
|
|
26
|
+
|
|
27
|
+
### 1.1 总表
|
|
28
|
+
|
|
29
|
+
| 编排项 | 归共享层 | 归宿主端口 | 依据 |
|
|
30
|
+
|---|---|---|---|
|
|
31
|
+
| **判定顺序**(先判什么) | ✅ 触发条件、预算门、锁存、模式分流 | ❌ 只在「顺序的接缝」处回调(下游已决策的判断、观测摄入) | DSH 把下游判断放在**最前**(`interventions.ts:897`)、HOOK 放在最后;顺序差异里只有「何时看下游」是宿主的 |
|
|
32
|
+
| **预算扣减** | ✅ 三类计数器的**语义与顺序**(动作 / 判定 / 每轮收尾上限) | ❌ 计数器的**存放与原子性**(锁 / 内存) | HOOK 的 `#reserve`/`#reserveClosing` 把「检查 + 自增」写成一个锁内读改写(`decision.ts:329-377`);DSH 的 `actionWithinBudget`+`bookAction` 是两步(`core/policy.ts:113-127`),但 DSH 是单线程进程内,两步之间没有 await,语义上等价 |
|
|
33
|
+
| **账本字段** | ✅ 「一条决策的最小可审计事实」:能力 / 动作 / 模式 / applied / skipReason / 计数 / 判定成本 / 轮次 | ❌ 存储形态与**宿主专属字段**(`agentId`、`originalLocator`、`transcriptPath`…) | HOOK 写 `HookLedgerRecord`(`state/file-store.ts:92-113`);DSH 写 `InterventionAuditRecord`(`session-audit.ts:96`)。两者重叠 9 个字段、各自独有 8–20 个字段 |
|
|
34
|
+
| **反馈文案模板** | ✅ 模板骨架(何处插变量、截断上限、空事件措辞) | ❌ 语言与语气(两侧现有文案不同、用户不同) | 现存两份:HOOK 英文陈述式(`decision.ts:620-625`、`823-827`、`983-987`、`1010-1013`);DSH 英文但带 `Reflex intervention:` 前缀与置信度(`interventions.ts:2308-2348`) |
|
|
35
|
+
|
|
36
|
+
### 1.2 判定顺序:逐项
|
|
37
|
+
|
|
38
|
+
「判定顺序」要被共享,必须先把每个判断拆成**与宿主无关的三类**。
|
|
39
|
+
|
|
40
|
+
| 类别 | 归属 | 内容 | HOOK 侧证据 | DSH 侧证据 |
|
|
41
|
+
|---|---|---|---|---|
|
|
42
|
+
| T 触发 | 共享 | 本事件是否值得判(重复 / 连续失败 / 振荡 / 跨行大 payload / 有完成声明) | `suspicionOf`(`decision.ts:546-551`)、阈值检查(`674-676`)、`claimCandidates`(`887`) | `suspicionOf`(`interventions.ts:929-934`、`1155-1160`、`1774-1779`)、阈值检查(`1425-1441`)、`claimCandidates`(`1233`) |
|
|
43
|
+
| G 门 | 共享 | 模式 off / 预算 / 会话冲突 / 已锁存 | `510-522`、`569-578`、`677-678`、`804-812`、`906-915` | `899`、`946-954`、`1129-1151`、`1449-1457`、`1472-1478`、`1780-1789`、`1235-1262` |
|
|
44
|
+
| H 宿主事实 | 端口 | **下游已给出的决策**、**本插件自家工具的排除**、**信号是否已中止**、**结果的有效内容** | HOOK 无此项(命令钩子没有瀑布流) | `897`(先 `next()`)、`900`/`1038`(ownTools)、`901`/`1127`/`1243`(signal)、`1054-1056`(取 `downstream.content`) |
|
|
45
|
+
|
|
46
|
+
**结论**:判定顺序 `T → G → 买判定 → 按模式执行或跳过 → 记账` 归共享;唯一真正属于宿主的是
|
|
47
|
+
**「H(下游事实)在顺序里的位置」**——DSH 必须在 T 之前拿到 `downstream`(它要决定 `applied` 是否成立,
|
|
48
|
+
`interventions.ts:998-1001`),而 HOOK 的 `downstream` 恒为空。这一条用一个回调表达:
|
|
49
|
+
`host.peekDownstream(): DownstreamFacts`,HOOK 实现返回 `{kind:'allow', content:undefined}`,
|
|
50
|
+
DSH 实现返回真实瀑布结果。顺序本身(谁先谁后)留在共享层。
|
|
51
|
+
|
|
52
|
+
### 1.3 预算扣减
|
|
53
|
+
|
|
54
|
+
| 预算 | 共享层负责 | 端口负责 | 一致性风险 |
|
|
55
|
+
|---|---|---|---|
|
|
56
|
+
| 每轮动作数 `maxInterventionsPerTurn` | 检查时机、扣减时机(**只有真的要执行时才扣**) | `updateState(mutate)` 的原子性 | DSH 在 observe 模式下也 `bookAction`(`interventions.ts:1004-1007`、`1190-1195`、`1604-1605`),理由写在注释里:observe 必须「像 active 一样消费同一个 episode」;HOOK 没有 observe 扣减的等价物,**这是要显式保留的语义差异,不是 bug** |
|
|
57
|
+
| 每轮判定数 `maxJudgmentsPerTurn` | 同上 | 同上 | 两侧都把「分类 + 核验」算成一次判定(DSH `1257`;HOOK `906`),但 DSH 的 `runJudgment` 内部还会再检查一次(`core/judge.ts:313-316`),HOOK 只有一次(`decision.ts:345-346`)。合并后必须只保留一处 |
|
|
58
|
+
| 每会话判定数 `maxJudgmentsPerSession` | 同上 | 会话生命周期(何时清零) | HOOK 的会话预算**永不清零**(`decision.ts:844-851` 只重置 turn 与 turn 级预算);DSH 同样只在 `#state` 首次创建时为零(`interventions.ts:2078`) |
|
|
59
|
+
| 每轮收尾上限 `maxClosingBlocksPerTurn` | `#reserveClosing` 的检查 + 扣减 | `continues.closing` 存放 | 只存在于 HOOK(`decision.ts:363-377`);DSH 侧等价物是 `applied.has('closing:turn:N')` 锁存(`interventions.ts:1235`、`1343-1344`)。**两者语义不同**:HOOK 限次,DSH 限一次 |
|
|
60
|
+
|
|
61
|
+
### 1.4 账本字段
|
|
62
|
+
|
|
63
|
+
| 字段组 | 归共享 | 归 DSH 端口 | 归 Claude 端口 | 证据 |
|
|
64
|
+
|---|---|---|---|---|
|
|
65
|
+
| 身份:`type/capability`、`action`、`mode`、`applied`、`shadow`、`skipReason` | ✅ | 落 `InterventionAuditRecord`(`session-audit.ts:96`) | 落 `HookLedgerRecord`(`file-store.ts:92`) | 两侧都能表达(`decision.ts:628-637` vs `interventions.ts:1921-1962`) |
|
|
66
|
+
| 判定结论:`isStuck`、`judged`、`passed`、`retention` | ✅(口径由共享层定) | 🟡 折进 `reason` / 明细,不设一级字段 | ✅ 一级字段(`file-store.ts:102-111`) | HOOK 侧同类字段在 `decision.ts:628-637`、`736-753` |
|
|
67
|
+
| 判定成本:`judgments`、`memoHits`、`judgeTokens`、`localLatencyMs`、`remoteLatencyMs` | ✅ | ✅ 有 | 🟡 只有单个 `latencyMs`(`file-store.ts:99`) | HOOK 用 `latencyMs` 单值(`decision.ts:597`、`603`),DSH 分本地/远端(`interventions.ts:1928-1930`)。**保守建议**:共享层产出分项,Claude 侧沿用 `latencyMs` 写总和的兼容字段 |
|
|
68
|
+
| 用量:`originalTokens`、`candidateTokens`、`potentialSavedTokens`、`actualSavedTokens`、`injectedTokens` | ✅ | ✅ 有 | 🟡 只有 `tokensSaved/originalTokens/prunedTokens` | `interventions.ts:1911-1918` vs `decision.ts:736-753` |
|
|
69
|
+
| 剪枝诊断:`digest`、`floored/floorMissed/markerOmitted`、`judgePath`、`*Segments`、`*Chars` | ✅(DSH 侧已是最全集) | ✅ 有 | 🟡 现存 9 个 `details.*` 键 | `interventions.ts:1938-1961` vs `decision.ts:747-752` |
|
|
70
|
+
| 归因:`agentId`、`turn`、`step`、`sessionKey` | ❌ | ✅ | ❌(无 agent 概念) | `interventions.ts:1937`、`1947-1948` |
|
|
71
|
+
| 留存:`originalLocator` | ❌ | ✅ | ❌(HOOK 写 `details.digest` + `retention`) | `interventions.ts:1946` vs `decision.ts:746` |
|
|
72
|
+
| 幂等:`dedupeKey`、`event`、`harness` | ❌ | 🟡 DSH 无 dedupe(进程内天然单次) | ✅ | `decision.ts:441-449` |
|
|
73
|
+
|
|
74
|
+
**结论**:共享层只定义 §1.4 前六行(约 24 个字段);后三行由端口自由扩展,落盘时按宿主 schema 展开。
|
|
75
|
+
|
|
76
|
+
### 1.5 反馈文案模板
|
|
77
|
+
|
|
78
|
+
两侧文案**都**是「前缀 + 计数 + System One 结论 + 建议」,只有措辞不同:
|
|
79
|
+
|
|
80
|
+
| 能力 | HOOK 文案 | DSH 文案 | 共享的部分 | 宿主的部分 |
|
|
81
|
+
|---|---|---|---|---|
|
|
82
|
+
| 停滞拒绝 | `harness-reflex: this call repeats a pattern …`(`decision.ts:620-625`) | `Reflex intervention: <tool> was called with identical arguments N times …`(`interventions.ts:2308-2316`) | 变量清单:工具名、重复次数、模式、置信度、建议文本、截断上限 | 前缀、人称、是否报置信度、是否报「调用未执行」 |
|
|
83
|
+
| 纠偏上下文 | `harness-reflex: N consecutive tool calls failed …`(`decision.ts:823-827`) | `Reflex intervention: <tool> failed N consecutive times with <err> …`(`interventions.ts:2330-2338`) | 同上 + 错误摘要 | 同上 |
|
|
84
|
+
| 收尾异议 | `harness-reflex: this turn claims completion but its own tool evidence contradicts it: …`(`decision.ts:983-987`) | `Reflex closing check: this turn is about to close …`(`interventions.ts:2341-2348`) | 反证清单、截断上限(HOOK 900 / DSH 600) | 同上 |
|
|
85
|
+
| 剪枝说明 | **无**(不发模型可见文本,`decision.ts:735` 只换 `updatedToolOutput`) | 有,但**只进审计**(`interventions.ts:2206-2250`、`1902-1906` 注释) | 模板骨架(`2206-2250` 已是结构化数据驱动) | DSH 独有;HOOK 不需要 |
|
|
86
|
+
|
|
87
|
+
**结论**:共享层只产出 `FeedbackVars`(结构体)与 `templateId`;渲染函数留在各宿主。
|
|
88
|
+
理由:文案是**用户可见的产品决策**,跨产品共享会让任一侧改文案都要动共享层,而且两侧的
|
|
89
|
+
「谁给谁看」不同(HOOK 的 deny 给模型看,DSH 的剪枝说明只给人看)。截断上限
|
|
90
|
+
(`FEEDBACK_CHARS = 600`,`interventions.ts:165`)归共享层作为默认值。
|
|
91
|
+
|
|
92
|
+
## 2. 目标架构
|
|
93
|
+
|
|
94
|
+
```
|
|
95
|
+
┌─────────────────────────── 共享层(新增,纯逻辑)───────────────────────────┐
|
|
96
|
+
│ core/orchestrate.ts │
|
|
97
|
+
│ decide(event, facts) → Decision │
|
|
98
|
+
│ T 触发 → G 门(预算由端口原子扣)→ 买判定(去重/缓存)→ 模式分流 → 记账 │
|
|
99
|
+
│ core/feedback.ts FeedbackVars + 默认模板(截断 600) │
|
|
100
|
+
│ core/audit.ts AuditableDecision(§1.4 前六行,约 24 字段) │
|
|
101
|
+
│ core/wait.ts WAIT_QUERY_TOOLS / isWaitQuery / pollShapeOf / │
|
|
102
|
+
│ waitGoalOf / annotateWaitHistory(从 DSH 迁入) │
|
|
103
|
+
└───────────────┬─────────────────────────────────────┬──────────────────────┘
|
|
104
|
+
▼ ▼
|
|
105
|
+
┌───────────────────────────────┐ ┌───────────────────────────────────────┐
|
|
106
|
+
│ ports/host.ts HostOrchestrationPort ││ state/ 与 hook/ 现状(不动) │
|
|
107
|
+
│ observe(input): ObservedStep ││ HookStorePort / MemoryStateStore │
|
|
108
|
+
│ peekDownstream(): DownstreamFacts ││ FileStateStore │
|
|
109
|
+
│ judge(input): JudgmentCharge ││ │
|
|
110
|
+
│ reserve / reserveClosing ││ │
|
|
111
|
+
│ render(templateId, vars): string ││ │
|
|
112
|
+
└───┬───────────────────────┬───────────┘
|
|
113
|
+
▼ ▼
|
|
114
|
+
┌──────────────────┐ ┌──────────────────────────────┐
|
|
115
|
+
│ Claude 宿主装配 │ │ DSH 宿主装配 │
|
|
116
|
+
│ hook/decision.ts │ │ dsh/interventions.ts │
|
|
117
|
+
│ → adapter 实现上述│ │ → adapter 实现上述 │
|
|
118
|
+
│ 5 个方法与3个端口│ │ 5 个方法与3个端口 │
|
|
119
|
+
└──────────────────┘ └──────────────────────────────┘
|
|
120
|
+
```
|
|
121
|
+
|
|
122
|
+
**依赖方向**:`core/* ← ports/host.ts ← 宿主装配`。`core/` 仍不得 import `node:fs`、不得 import 任何适配层
|
|
123
|
+
(沿用 `v0.2.0-harness-plugins.md` §2.1 的规则 1)。`ports/host.ts` 只放类型与接口,零实现。
|
|
124
|
+
|
|
125
|
+
**为什么不用 `HookDecision` 直接当共享层**(被否方案):
|
|
126
|
+
|
|
127
|
+
| 方案 | 否决理由 |
|
|
128
|
+
|---|---|
|
|
129
|
+
| A. DSH 直接 `new HookDecision({store: MemoryStateStore})` 并改 `handle` 的分支 | `handle` 是 `switch(event, 7 个 HookEvent)`(`decision.ts:485-504`),DSH 的四入口(`toolCall`/`toolResult`/`preStep`/`turnStopping`)没有一一对应;强行套用必须在 HOOK 里长出台词(ownTools、下游 peek、steer),Claude 侧背上无用的宿主编排,且 `CLAUDE_PLUGIN_OPTION_*` 兼容面受影响 |
|
|
130
|
+
| B. 把 DSH 的状态迁到 `HookStorePort` 并保留 `AgentState` 双写 | 两套状态必然漂移;且 `HookStorePort` 的 16 个方法(`store-port.ts:27-83`)里有 6 个只服务命令钩子的「每次一个进程 + 重投递」(`writeDecision`/`readDecision`/`claimDecision`/`releaseDecisionClaim`/`eventsHaveKey`/`ledgerHasKey`),DSH 是进程内单次执行,用不到这些幂等原语 |
|
|
131
|
+
| C. 先用一份「行为快照」把 DSH 冻住,再整个重写 | 风险不可控(`interventions.ts` 2580 行、4 个入口、92 条测试);且没有中间可回滚点。本文的 §5 分批方案是它的逐步版 |
|
|
132
|
+
|
|
133
|
+
**被采纳方案**:抽共享层(新),两侧各留一个**薄适配层**。适配层的目标体量:
|
|
134
|
+
HOOK 侧从 ~350 行(五个 handler + 两个 reserve)降到 ~120 行;DSH 侧从 4 个入口共 ~900 行降到 ~450 行
|
|
135
|
+
(估算,按 §5 的逐批统计校准)。
|
|
136
|
+
|
|
137
|
+
## 3. 七个差异的逐一方案(问题二)
|
|
138
|
+
|
|
139
|
+
### 3.1 状态载体:`AgentState` ↔ `HookStorePort`
|
|
140
|
+
|
|
141
|
+
| 项 | DSH 侧(`AgentState`) | 共享层需要的 | 方案 |
|
|
142
|
+
|---|---|---|---|
|
|
143
|
+
| 轮 / 步 | `turn`、`step`(`interventions.ts:2084-2085`,由 `preStep` 维护 `1106-1123`) | 事件归属 | 保留在 DSH 状态里;共享层只接收 `turn/step` 作为 `ObservedStep` 的字段 |
|
|
144
|
+
| 三个预算计数 | `interventions`、`judgmentsTurn`、`judgmentsCount`、`judgmentsSession`(`interventions.ts:2075-2078`;`judgmentsTurn` 实为「归属轮次」,`1109-1111` 只在换轮时写) | §1.3 | DSH 用 `MemoryStateStore` 的 `budgets`(`memory-store.ts:41`);DSH 现有的「每轮清零由 `preStep` 驱动」(`1106-1122`)改成 `resetTurn()` 端口方法 |
|
|
145
|
+
| 观测窗口 | `steps: ObservedStep[]`(`interventions.ts:2086`,上限 12,`147`) | 判定历史 | DSH 直接传数组(零拷贝);HOOK 由 `readEvents(30/40)` 回读(`decision.ts:771-783`、`1031-1037`) |
|
|
146
|
+
| 判定缓存 | `verdictTurn`/`verdictKey`/`verdict`(`interventions.ts:2079-2081`) | 摘要 | `runJudgment` 已把这两件事编码成键(`core/judge.ts:257-262`、`300-301`),把「键」提到共享层即可 |
|
|
147
|
+
| 锁存集合 | `waited`/`applied`/`denied`/`refused`(`interventions.ts:2081-2084`) | 摘要 | 四个集合语义**都归共享层**(它们是「这一轮不许重复干预」的规则,不是存储)。但**只有 DSH 用全四个**:`waited`(等待已判)、`refused`(被拒调用的结果不再判定,`1043-1049`)在 HOOK 侧没有对应物;HOOK 只用 `applied`(`pre` 事件的签名)与 `denied` 的等价物 `SessionState.appliedSignatures`(`file-store.ts:64`) |
|
|
148
|
+
| 剪枝 memo | `#memo`(`interventions.ts:711`,按 `sessionKey:digest`,键见 `2253-2258`) | 摘要 | 归共享层(「同一 payload 不重复付判定」是规则);键与 DSH 的 `sessionKeyOf`(`2552-2555`)一致 |
|
|
149
|
+
| claims / evidence | `claims`、`evidence`、`evidenceSuspect`(`interventions.ts:2072-2074`) | 收尾核验输入 | 归共享层(`core/evidence.ts` 已有 `evidenceOf`/`assembleEvidence`) |
|
|
150
|
+
| 周期维护 | `MAX_AGENTS=64`(`interventions.ts:159`)、`MAX_MEMO=128`(`161`)、`MAX_STEPS=12`(`147`) | 上界 | 端口方法 `evict()`;默认值放共享层配置 |
|
|
151
|
+
| 留存 | `#retain` 回调 → Session log(`interventions.ts:706`、`1442-1448`、`1621-1648`) | 原文留存 | 抽象为 `RetentionPort.persist(key, text): Locator \| undefined`;**`MemoryStateStore.retainOriginal`**(`memory-store.ts:183`)可作 DSH 的默认实现,DSH 现行 Session log 实现保留为第一实现(保留原文可被 `readPrunedOriginal` 读回,`session-audit.ts:546`) |
|
|
152
|
+
|
|
153
|
+
**关键判断**:`AgentState` 不是要「换成 `HookStorePort`」,而是**拆成「规则」与「存储」两半**——
|
|
154
|
+
规则(锁存、memo、窗口上限、预算语义)进共享层,存储(每 agent 一份、进程内生命周期)留在 DSH。
|
|
155
|
+
`HookStorePort` 是 Claude 侧的存储实现,不是共享层的接口;共享层只认 `HostOrchestrationPort`。
|
|
156
|
+
|
|
157
|
+
**风险**:`MAX_STEPS=12`(DSH)与 `readEvents(limit=30/40)`(HOOK,`decision.ts:772`、`1031`)是两个不同的窗口。
|
|
158
|
+
共享层如果取其一,会改变另一侧的行为。保守建议:**窗口大小由端口配置**,默认沿用各自现值,不进共享默认值。
|
|
159
|
+
|
|
160
|
+
### 3.2 会话粒度:`agent + native session` ↔ 单 `sessionId`
|
|
161
|
+
|
|
162
|
+
| 事实 | DSH | HOOK | 方案 |
|
|
163
|
+
|---|---|---|---|
|
|
164
|
+
| 主键 | `agentKeyOf(agent)`(`interventions.ts:2522-2528`),fallback `'anonymous'` | `sessionId`(`decision.ts:264`、`491`) | 共享层的输入是 `SessionScope { sessionId, agentId? }`;`agentId` 可选 |
|
|
165
|
+
| 隔离单位 | **每个 agent 一份** `AgentState`(`interventions.ts:690-710` 类注释「isolation is structural」) | 每 session 一份 | 保留:DSH 的 `agentId` 事实上必填,但 `agentKeyOf` 的 `'anonymous'` 兜底(`2527`)是个隐患——两个没有 `id` 的 agent 会共用一个状态槽。**这是行为变更**,是否顺手修见 §7-2 |
|
|
166
|
+
| memo 归属 | `sessionKey`(优先 `session.id`,fallback `agent:<agentId>`,`2552-2555`) | digest 存在 per-session store | 保留:共享层以 `SessionScope` 作 memo 命名空间,不猜 |
|
|
167
|
+
| 轮边界 | `agent/pre-step` 的 `payload.turn` 变化(`1106-1122`) | `stop` 事件自增(`decision.ts:842-851`) | **差异必须保留**:DSH 的轮边界是**开始**,HOOK 是**结束**。共享层的 `turn` 由端口提供,不自增 |
|
|
168
|
+
|
|
169
|
+
**为什么不能简单统一成 `sessionId`**:DSH 一个 session 里可以并发多个 agent,共享一个 session 状态会让
|
|
170
|
+
A agent 的干预预算/锁存串到 B agent。反过来让 HOOK 用 `agentId` 没有意义(命令钩子里只有一个 agent)。
|
|
171
|
+
**结论**:共享层接受的键是 `SessionScope`,DSH 传 `{sessionId: sessionKeyOf(agent), agentId}`,
|
|
172
|
+
HOOK 传 `{sessionId}`。共享层**不**做「按 agent 拆分」的判断——那是 DSH 适配层的职责。
|
|
173
|
+
|
|
174
|
+
**风险**:`sessionKeyOf` 的 fallback 是 `` `agent:${agentKeyOf(value)}` ``(`2554`),而 `agentKeyOf` 的
|
|
175
|
+
fallback 是 `'anonymous'`。三层 fallback 叠加后,两个没有 `session` 也没有 `id` 的 agent 会共享
|
|
176
|
+
memo 与预算。**保守建议**:第一批不改(会动测试),在 §7-2 显式提出。
|
|
177
|
+
|
|
178
|
+
### 3.3 判定窗口:`agent/pre-step` 实时维护 ↔ `readEvents` 回读
|
|
179
|
+
|
|
180
|
+
| 项 | DSH | HOOK | 方案 |
|
|
181
|
+
|---|---|---|---|
|
|
182
|
+
| 窗口来源 | 内存数组 `state.steps`(`interventions.ts:2086`),每次 `toolResult` 追加(`1058-1068`、`2116-2119`) | `readEvents(sessionId, 30/40)`(`decision.ts:771-783`、`1031-1037`) | 共享层接收 `ObservedStep[]`,来源由端口决定 |
|
|
183
|
+
| pre-execute 的「本次调用」 | 本地构造 `pending`,**不提交**历史(`interventions.ts:909-913`、`2101-2113`) | Hook 侧没有「调用前」窗口,`pre` 事件由 `#finish` 提交(`decision.ts:552-558`) | 共享层支持 `window: [...history, candidate]`,`candidate` 由 `host.observe({phase:'pre'})` 构造 |
|
|
184
|
+
| 等待剔除 | `progressSteps` 过滤 `step.wait === true`(`interventions.ts:476-478`、`919`、`1154`) | 无 | 归共享层(随 §3.4 一起上移),默认值是「有 wait 步骤就剔除」(`477`) |
|
|
185
|
+
| 证据回读 | `state.evidence` 累积(`interventions.ts:1077`、`2134-2149`) | 从 `events` 过滤 `kind in {post, failure}`(`decision.ts:1031-1037`) | 保留两种:共享层接收 `EvidenceEntry[]`,DSH 传内存,HOOK 传回读结果 |
|
|
186
|
+
|
|
187
|
+
**结论**:判定窗口的**语义**(哪些步骤算数、窗口多大、等待是否剔除)归共享;
|
|
188
|
+
**来源**(内存 / 回读)归端口。这是七个差异里唯一「只差实现方式」的一条,也是改造中最安全的一条。
|
|
189
|
+
|
|
190
|
+
**风险**:HOOK 的 `readEvents` 返回**最新在前**(`store-port.ts:37` 注释「newest first」),而 `suspicionOf`
|
|
191
|
+
期望**最旧在前**(`core/judge.ts:111` 从尾部切片)。共享层必须明确定义顺序并在 adapter 里做一次反转,
|
|
192
|
+
现有 `decision.ts:774-783` 的 `prior.map` 与 `1031-1037` 都**没有**反转,即已经依赖 store 返回的顺序。
|
|
193
|
+
**保守建议**:共享层入口一律要求「oldest first」,由 adapter 负责与 store 的约定对齐,并加一条顺序断言(§6.3 第 A10 条)。
|
|
194
|
+
**注意**:这一条如果判断错了(比如 `FileStateStore.readTail` 其实返回最旧在前),就是一次**静默的行为变更**
|
|
195
|
+
——所以 A10 断言必须**先**在 legacy 上跑通、再拿它守 shared,不能凭注释。
|
|
196
|
+
|
|
197
|
+
### 3.4 合法等待豁免:`isWaitQuery`/`pollShapeOf`(`job_kill` 边界)
|
|
198
|
+
|
|
199
|
+
| 事实 | 依据 | 方案 |
|
|
200
|
+
|---|---|---|
|
|
201
|
+
| 豁免是**身份 + 参数形状**,不解析文案 | `interventions.ts:327-348` 注释、`WAIT_QUERY_TOOLS`(`345-348`) | 整段迁入 `core/wait.ts`,**行为逐字保持** |
|
|
202
|
+
| `job_output` 需要非空 `job_id` 字符串 | `isWaitQuery`(`382-389`):`handles.some(...)` | 同上;字符串化参数也识别(`355-367`) |
|
|
203
|
+
| `job_list` 需要**无参数** | `argumentless: true`(`347`)、`387` | 同上 |
|
|
204
|
+
| **`job_kill` 不豁免** | `342-343` 注释 + 测试 `interventions.test.ts:2818` | **保留为显式反向断言**:`WAIT_QUERY_TOOLS` 不含 `job_kill`,且 `isWaitQuery(execOf('job_kill', {job_id})) === false` |
|
|
205
|
+
| 非白名单工具可用 `pollShapeOf` 成为「等待嫌疑」 | `404-413`(`POLL_HANDLE_FIELD`,`392`) | 迁入 `core/wait.ts`;**但注意**:`interventions.ts:920` 的 `pollShapeOf` 分支**没有测试覆盖**(`interventions.test.ts:3354-3357` 只测了函数本身,没有测引擎走这条分支的行为)。保守建议:上移时**一并补行为测试**(属于新增测试,不在本轮范围) |
|
|
206
|
+
| 等待步骤不计入重复/失败/振荡 | `progressSteps`(`476-478`) | 迁入 `core/wait.ts` |
|
|
207
|
+
| 等待嫌疑的判定上下文 | `waitGoalOf`(`433-441`)、`annotateWaitHistory`(`454-461`) | 迁入 `core/wait.ts`;`judgeKey` 已把 `goal` 编进缓存键(`core/judge.ts:258`),行为不变 |
|
|
208
|
+
| 已判定的等待不再复问 | `state.waited.has(signature)`(`interventions.ts:924-927`) | 归共享层锁存 |
|
|
209
|
+
|
|
210
|
+
**`job_kill` 边界的结论**(这是问题二里被点名的三条之一):
|
|
211
|
+
|
|
212
|
+
1. **语义**:`job_kill` 是终止动作,不是重复查询;一个反复 `job_kill` 的 run 不是在等待,而是在循环。
|
|
213
|
+
所以它**不豁免**,走普通重复判定(第 3 次被拦)。
|
|
214
|
+
2. **实现**:`WAIT_QUERY_TOOLS` 只有两项(`345-348`);`pollShapeOf` 的启发式也**不会**把它算作等待嫌疑——
|
|
215
|
+
它的参数是 `{job_id: 'job-7'}`,`POLL_HANDLE_FIELD`(`392`)匹配 `job_id`,所以 `pollShapeOf('job_kill')`
|
|
216
|
+
**会**返回 `'poll-handle'`。这意味着 `job_kill` 第 3 次重复时会被当作「等待嫌疑」去问 System One
|
|
217
|
+
(`interventions.ts:935-945`),而不是被当作普通重复**直接**拦。
|
|
218
|
+
**这不是 bug**,是「让判定者决定」:`935-944` 的注释写明「the tool list only decides that this repetition
|
|
219
|
+
is worth asking about」。但它必须作为**行为契约**保留,不能在上移时被简化掉。
|
|
220
|
+
3. **断言**(质量判据 4):迁移后必须有三条——`isWaitQuery(job_kill)` 为假、`job_kill` 第三次重复仍会买判定、
|
|
221
|
+
`waitGoalOf` 对 `job_kill` 给出的 `suspect` 字段是 `poll-handle`(而非 `wait-query`)。
|
|
222
|
+
|
|
223
|
+
**风险**:`WAIT_QUERY_TOOLS` 是**宿主工具名**(DSH Host 的 `@deepseek-ai/dsh-tool-jobs`),不是 harness 无关的。
|
|
224
|
+
放进 `core/` 意味着 Claude 侧也会带上 DSH 的工具名——虽然 Claude 侧永不触发(没有 `job_*` 工具),
|
|
225
|
+
但这是**概念污染**。保守建议:放进 `core/wait.ts` 但**保持导出**,并在文件头注明「DSH Host 的工具身份表,
|
|
226
|
+
其他宿主不注册同名工具即自然不触发」;比新建 `hosts/dsh/` 更小的改动面。
|
|
227
|
+
|
|
228
|
+
### 3.5 权限单调:`tools/pre-execute` 只在下游 allow 时追加 deny
|
|
229
|
+
|
|
230
|
+
| 事实 | DSH | HOOK |
|
|
231
|
+
|---|---|---|
|
|
232
|
+
| 先问下游 | ✅ `const downstream = await next()`(`interventions.ts:897`) | ❌ 无下游(`decision.ts:510` 起直接判) |
|
|
233
|
+
| 只在下游是 `allow` 时追加 deny | ✅ `downstream.kind === 'allow'`(`interventions.ts:998`) | ❌ 直接返回 `preToolUseDeny`(`decision.ts:627`) |
|
|
234
|
+
| 下游已 deny/ask/block 时原样传递 | ✅ `999-1001`(记 `downstream-decided`)、`1010-1019`(fail-open) | ❌ 不适用 |
|
|
235
|
+
| 结局单调性 | ✅ 只会把 allow 变成 deny,绝不把 deny 放宽成 allow(`880-895` 注释) | ❌ 不适用(无瀑布流) |
|
|
236
|
+
|
|
237
|
+
(表中「HOOK」列写作 ❌ 是**如实记录**:命令钩子没有瀑布流,因此「权限单调」在 Claude 侧不是一个可比的语义,
|
|
238
|
+
而不是「缺失的能力」。)
|
|
239
|
+
|
|
240
|
+
**方案**:`peekDownstream` 是 `HostOrchestrationPort` 的**可选**方法。
|
|
241
|
+
|
|
242
|
+
```ts
|
|
243
|
+
interface DownstreamFacts {
|
|
244
|
+
/** The waterfall's decision when the host has one; `'unknown'` for a host without a waterfall. */
|
|
245
|
+
kind: 'allow' | 'deny' | 'ask' | 'block' | 'unknown';
|
|
246
|
+
/** Whether the host lets this decision add a denial on top. */
|
|
247
|
+
mayRefine: boolean;
|
|
248
|
+
}
|
|
249
|
+
```
|
|
250
|
+
|
|
251
|
+
共享层的规则写成一条:**`deny` 只在 `mayRefine === true` 时产出;否则产 `skipReason: 'downstream-decided'`
|
|
252
|
+
并保持 `applied: false`。** DSH adapter 返回真实下游,HOOK adapter 返回 `{kind:'unknown', mayRefine:true}`
|
|
253
|
+
(命令钩子自己就是权威,等价于现有行为)。
|
|
254
|
+
|
|
255
|
+
**这不是可选优化,是安全属性**:如果顺序反了(先 deny 再调 `next()`),一个下游已经 `ask` 的调用会被
|
|
256
|
+
我们的 deny 覆盖,或者更糟——因为我们把 `next()` 的 deny 结果丢掉,调用会**继续执行**。
|
|
257
|
+
所以 §6.3 里给它单独一条断言(A6:下游 `deny` 时我们的返回对象**按对象身份相等**,
|
|
258
|
+
即 `assert.strictEqual(result, downstream)`,与 `interventions.ts:897-901` 的现行语义一致)。
|
|
259
|
+
|
|
260
|
+
### 3.6 `agent/turn-stopping` 的 steer 动作
|
|
261
|
+
|
|
262
|
+
| 事实 | DSH | HOOK |
|
|
263
|
+
|---|---|---|
|
|
264
|
+
| 判定 | 收尾证据 vs 完成声明(`interventions.ts:1220-1345`) | 同(`decision.ts:840-1001`) |
|
|
265
|
+
| 动作 | `agent.steer(message)`(`interventions.ts:1346`、`2301-2305`),**能失败**(agent 没有 `steer` 时静默) | `{decision:'block', reason}`(`decision.ts:989` → `contract.ts` 的 `stopBlock`)、`stop_hook_active` 短路(`877-886`) |
|
|
266
|
+
| 轮次上限 | `maxClosingBlocksPerTurn` **不存在**;用 `applied.has('closing:turn:N')` 限定一次(`interventions.ts:1235`、`1343-1344`) | `#reserveClosing`(`decision.ts:363-377`),默认 2 次(`decision.ts:87`) |
|
|
267
|
+
| 消息形状 | `UserMessage`,`source.kind = 'plugin:dsh-reflex'`(`interventions.ts:135`、`2289-2298`) | 纯文本 `reason` |
|
|
268
|
+
|
|
269
|
+
**方案(判定归共享、动作归宿主)**:
|
|
270
|
+
|
|
271
|
+
1. 共享层产出 `ClosingVerdict { contradicted: string[]; undecided: number; passed: boolean }` 与
|
|
272
|
+
`AuditableDecision`(含预算扣减结果 `skipReason`)。
|
|
273
|
+
2. 共享层的**唯一动作字段**是 `action: 'object-turn-close'`(与 `'deny-call'` 同级),**不含**执行代码。
|
|
274
|
+
3. 宿主实现 `applyClosingObject(verdict, vars): void`:
|
|
275
|
+
- DSH:`agent.steer(this.#message(...))`,保留 `plugin:dsh-reflex` 来源与 `boundContextSummary`(`interventions.ts:2291`);
|
|
276
|
+
- HOOK:返回 `stopBlock(render(...))`。
|
|
277
|
+
4. `maxClosingBlocksPerTurn` 是共享层的**配置**(默认 2),但 DSH 设 `1`——与现行的「一次」语义对齐。
|
|
278
|
+
**这是行为变更的边界**:DSH 现值是「一次」,HOOK 是「两次」,共享层必须允许两侧不同,否则必有一侧行为改变。
|
|
279
|
+
保守建议:DSH 显式传 `1`,并在 §6 的对拍里固定这个值。
|
|
280
|
+
|
|
281
|
+
**为什么 steer 不能上移**:`#message` 依赖 DSH 的 `MessageId`、`boundContextSummary`、`MessageSourceMap`
|
|
282
|
+
(`interventions.ts:2289-2298`、`141-146`),这些是 DSH 的会话格式契约(v4,`135-139` 注释),Claude 侧没有。
|
|
283
|
+
把它上移会把 DSH 的会话格式引入 `core/`,违反 §2 的依赖规则。
|
|
284
|
+
|
|
285
|
+
**风险**:`turnStopping` 只是「提议」,真正是否续轮由 DSH 的 loop 决定(`interventions.ts:1209-1216` 注释)。
|
|
286
|
+
共享层出的 `AuditableDecision.applied` 对 DSH 来说意味着「steer 被调用」,不意味着「回合被延长」。
|
|
287
|
+
这一条要写进共享层文档,否则将来有人会以为 `applied` 表示回合真的没关。
|
|
288
|
+
|
|
289
|
+
### 3.7 `agent/assistant-stream` 观测
|
|
290
|
+
|
|
291
|
+
| 事实 | DSH | HOOK |
|
|
292
|
+
|---|---|---|
|
|
293
|
+
| 观测入口 | `observeAssistantStream`(`interventions.ts:1362-1374`) | `payload.last_assistant_message`(`decision.ts:855`) |
|
|
294
|
+
| 累积 | `claims = clip(claims + text, 4000)`(`interventions.ts:1370`;`CLAIM_CHARS`,`149`) | 整段一次性给出 |
|
|
295
|
+
| 过滤 | `frame.type === 'chunk' && chunk.type === 'text-delta'`(`interventions.ts:1366`) | 无 |
|
|
296
|
+
| 失败 | 静默(`interventions.ts:1371-1373`) | 无 |
|
|
297
|
+
|
|
298
|
+
**方案**:`HostOrchestrationPort.observe({ kind: 'assistant-text', delta })` 是共享层的**纯观测**入口,
|
|
299
|
+
共享层负责 `clip` 与累积上限(4000),宿主负责取帧与过滤。
|
|
300
|
+
|
|
301
|
+
**注意这是 DSH 的「独有能力」,但它的**产物**不是**:`claims` 是收尾判定的输入,两侧都需要,
|
|
302
|
+
只是 DSH 是流式到达、HOOK 是整段到达。所以它属于「端口形态差异」,不需要保留在宿主侧——除了
|
|
303
|
+
**帧过滤规则**(`frame.type/chunk.type` 是 DSH 的流协议)。保守建议:帧过滤留在 DSH adapter
|
|
304
|
+
(`installInterventions` 的 `agent/assistant-stream` 监听器,`interventions.ts:2449-2453`),共享层只收 `delta: string`。
|
|
305
|
+
|
|
306
|
+
**断言要求**(判据 4):迁移后必须有一条断言证明**流式累积后的 claims 与整段一致**:
|
|
307
|
+
同一段文本分 3 个 delta 追加 vs 一次给全,收尾判定输入相同。这是四条 DSH 独有能力里最容易在迁移中丢的一条。
|
|
308
|
+
|
|
309
|
+
## 4. 不迁移清单(问题五)
|
|
310
|
+
|
|
311
|
+
| # | DSH 逻辑 | 位置 | 保留理由 |
|
|
312
|
+
|---|---|---|---|
|
|
313
|
+
| 1 | 四个 hook 的**注册与分组**(`frame`/`pipeline`/`closing`)与按模式增删 | `interventions.ts:2404-2515` | 这是 DSH 的宿主装配;`sync()`(`2476-2492`)依赖 `engine.serves()`。共享层不注册任何东西 |
|
|
314
|
+
| 2 | `agentKeyOf` / `sessionOf` / `sessionKeyOf` | `interventions.ts:2522-2555` | 从 DSH 对象图取身份,Claude 无此概念 |
|
|
315
|
+
| 3 | `#message` / `#steer` / `MessageId` / `MessageSourceMap` | `interventions.ts:141-146`、`2289-2305` | DSH 会话格式 v4 契约;上移即污染 `core/` |
|
|
316
|
+
| 4 | `#replaceText`(只替换第一个 text block,其余原样保留) | `interventions.ts:2170-2185` | DSH 的 `ContentBlock` 语义;`postToolUseReplace` 在 Claude 侧是整段字符串(`contract.ts`) |
|
|
317
|
+
| 5 | `#argumentsOf` / `callSignature` 的**字符串化策略** | `interventions.ts:2152-2160`、`2558-2570` | DSH 的 `exec.arguments` 可以是对象或字符串;HOOK 用 `canonicalJson`(`decision.ts:164-177`,按 key 排序)。**两者对同一参数算出的签名不同**(见 §6.4 风险 1),不能一刀切 |
|
|
318
|
+
| 6 | `InterventionReport` 的六个桶(baseline / observe / active / byCapability / skips / retained / evidence) | `interventions.ts:800-819`、`513-550` | 面板与测试的读取面;`#charge`(`1978-1983`)同时写「按模式」与「按能力」两套账——这是**双写规则**,不是共享层的「一条记录」能表达的。它不是编排规则,是 DSH 的观察面;Claude 侧没有面板 |
|
|
319
|
+
| 7 | `appendInterventionRecord` / `pruneLocator` / `readPrunedOriginal` / `PrunedOriginalRecord` | `session-audit.ts:354`、`434-436`、`546`、`475-488` | DSH 的 Session log 是插件记录通道(`INTERVENTION_RECORD_TYPE`,`session-audit.ts:31`),locator 格式是 `plugin:dsh-reflex/pruned-original#<digest>`(`43`、`435`),**与 Claude 侧 `<state>/sessions/<hash>/originals/<digest>.txt` 不同**(`file-store.ts:517-521`)。locator **由端口决定**,共享层只要求「同一 digest 恒定」 |
|
|
320
|
+
| 8 | DSH 的配置解析(`resolveConfig`、`pruneJudgeMinChars`、`claimMinConfidence: 0.5`、`closingEvidenceChars: 2400`) | `packages/dsh-harness-reflex/src/config.ts:365-391` | **两侧默认值不同**(HOOK `claimMinConfidence: 0.6`、`closingEvidenceChars: 2000`,`decision.ts:78-85`)。统一默认值会改变一侧行为;配置归宿主,共享层只收解析后的值 |
|
|
321
|
+
| 9 | `ownTools` 排除 | `interventions.ts:900`、`1038` | 本插件自己的工具输出已是优化结果;Claude 侧无 `reflex_*` 工具。保留为可选端口能力 |
|
|
322
|
+
| 10 | `runJudgment` 的**后端调用** | `interventions.ts:1846-1861` → `core/judge.ts:290` | 共享层调用判定**服务**(`judge` 端口),不持有后端实例;DSH 的 `StagnationDetector`(`interventions.ts:702`)与 HOOK 的 `DecisionBackend`(`decision.ts:592`)是两个不同接口 |
|
|
323
|
+
| 11 | `MAX_AGENTS` 淘汰(`interventions.ts:2087-2090`) | `interventions.ts:2056-2092` | DSH 的 LRU 是进程级内存纪律,Claude 侧按会话目录 gc(`gcSessions`) |
|
|
324
|
+
|
|
325
|
+
**不迁移的总判断**:十一条里 7 条是「DSH 宿主对象图」(1/2/3/4/9/10/11),3 条是「DSH 观察面」(6/7/8),
|
|
326
|
+
1 条是「两侧签名算法不同」(5)。**没有一条是「判定规则」**——这正是「统一编排」可行的理由。
|
|
327
|
+
|
|
328
|
+
## 5. 分批改造计划(问题三)
|
|
329
|
+
|
|
330
|
+
四批的顺序是**由「顺序本身是安全属性」的程度倒排的**,不是按行数:
|
|
331
|
+
|
|
332
|
+
| 批 | 能力 | 顺序敏感性 | 理由 |
|
|
333
|
+
|---|---|---|---|
|
|
334
|
+
| **P1** | 剪枝 | **最高** | 保留原文 → 判定 → 组合 → 比对缩小 → 才记节省(`interventions.ts:1379-1387` 注释「the order of operations here *is* the safety property」)。顺序错了会**摧毁数据**或**谎报节省** |
|
|
335
|
+
| **P2** | 停滞 | 高 | 前置 deny 需要「下游已决策」这一环(§3.5),是四批里唯一改变控制流的 |
|
|
336
|
+
| **P3** | 纠偏 | 中 | 只改结果内容(`interventions.ts:1822-1828`),不阻断 |
|
|
337
|
+
| **P4** | 收尾 | 中 | 动作靠 steer/block 分歧(§3.6);`maxClosingBlocksPerTurn` 两侧不同值 |
|
|
338
|
+
|
|
339
|
+
**P1 剪枝**
|
|
340
|
+
|
|
341
|
+
| 项 | 内容 |
|
|
342
|
+
|---|---|
|
|
343
|
+
| 改动面 | 新增 `core/orchestrate.ts` 的剪枝分支、`core/wait.ts`(静态)、`ports/host.ts`、`RetentionPort`;DSH `#pruneResult`(`interventions.ts:1397-1760`,~360 行)降为 adapter + 端口调用;HOOK `#postToolUse`(`decision.ts:641-754`,~114 行)降为 adapter |
|
|
344
|
+
| 回归门槛 | `test:plugin` 全绿且 `interventions.test.ts` 的剪枝用例**一条不改**;`npm test` 全绿;剪枝对拍 fixtures(§6.2 的 14 例)逐项相等;`npm run test:mutation` 通过;`npm run build:all` exit 0 |
|
|
345
|
+
| 风险点 | ① `memo` 的 `locator` 语义(DSH `interventions.ts:1742-1752` vs HOOK `decision.ts:709-711`);② 「留存成功才安装」的时序(DSH `1621-1648`,HOOK `708-716`);③ locator 命名两侧不同(§4-7) |
|
|
346
|
+
| 回滚方式 | 单 commit 回退(`git revert`);新增文件全部是**加法**,旧路径保留为 `LegacyPrunePath` 私有方法直到 P1 验收通过,可用一个内部开关 `orchestration.prune='legacy' \| 'shared'` 在运行时切换对照 |
|
|
347
|
+
|
|
348
|
+
**P2 停滞**
|
|
349
|
+
|
|
350
|
+
| 项 | 内容 |
|
|
351
|
+
|---|---|
|
|
352
|
+
| 改动面 | `toolCall`(`interventions.ts:896-1020`,125 行)、`preStep`(`1095-1207`,113 行)的判定段落;`peekDownstream` 端口;`core/wait.ts` 的收编(含 `job_kill` 边界、`pollShapeOf`) |
|
|
353
|
+
| 回归门槛 | P1 门槛 + 等待豁免 3 条断言(§3.4)+ 权限单调 1 条断言(§3.5)+ `WAIT_QUERY_TOOLS` 与 `isWaitQuery` 行为**逐例**不变(`interventions.test.ts:2810-2825`) |
|
|
354
|
+
| 风险点 | ① 下游身份传递(`strictEqual`);② `preStep` 的轮次重置(`interventions.ts:1106-1122`)如果被搬到共享层会改变 HOOK 的轮次语义;③ `pending` 步骤不计入历史(`909-913`) |
|
|
355
|
+
| 回滚方式 | 开关 `orchestration.stagnation='legacy' \| 'shared'`;P1 不受影响 |
|
|
356
|
+
|
|
357
|
+
**P3 纠偏**
|
|
358
|
+
|
|
359
|
+
| 项 | 内容 |
|
|
360
|
+
|---|---|
|
|
361
|
+
| 改动面 | `#correctFailure`(`interventions.ts:1763-1829`,67 行)与 `toolResult` 的分支选择(`1078-1079`);HOOK `#postToolUseFailure`(`decision.ts:757-838`) |
|
|
362
|
+
| 回归门槛 | P2 门槛 + 纠偏文案的对拍(§6.1:模型可见文本按字节相等,`FeedbackVars` 是它们的中间表示) |
|
|
363
|
+
| 风险点 | DSH 的 `block`(`interventions.ts:1822-1828`)与 HOOK 的 `additionalContext`(`decision.ts:829`)是**不同强度的动作**:DSH 替换结果,HOOK 追加说明。共享层只能产出「建议」,动作强度由端口定 |
|
|
364
|
+
| 回滚方式 | 开关 `orchestration.gate` |
|
|
365
|
+
|
|
366
|
+
**P4 收尾**
|
|
367
|
+
|
|
368
|
+
| 项 | 内容 |
|
|
369
|
+
|---|---|
|
|
370
|
+
| 改动面 | `turnStopping`(`interventions.ts:1220-1351`,131 行)、`observeAssistantStream`(`1362-1374`);HOOK `#stop`(`decision.ts:840-1001`);`maxClosingBlocksPerTurn` 的宿主值 |
|
|
371
|
+
| 回归门槛 | P3 门槛 + steer 断言 + assistant-stream 一致性断言(§3.7)+ `stop_hook_active` 短路行为不变(`decision.ts:877-886`) |
|
|
372
|
+
| 风险点 | ① DSH 的「一次」vs HOOK 的「2 次」(§3.6);② `evidence-truncated` 的记账(DSH `interventions.ts:1250-1252` 只记 skip 不扣预算,HOOK 无此分支);③ `escalate` 不算反证(`1314-1317` 注释) |
|
|
373
|
+
| 回滚方式 | 开关 `orchestration.closing`;P1–P3 均不回退 |
|
|
374
|
+
|
|
375
|
+
**四批共同门槛(每批都要过)**:`npm run test:all` 与 `npm run test:mutation` 全绿、
|
|
376
|
+
`docs/design/v0.2.0-harness-plugins.md` §2.1 的依赖规则测试仍通过、`node scripts/sync-vendor-core.mjs --check` 无 drift
|
|
377
|
+
(共享层文件同步进 `packages/dsh-harness-reflex/src/vendor/harness-reflex/`,见 `scripts/sync-vendor-core.mjs:30` 的 `CORE_MODULES` 白名单——**新增模块必须加进该列表**)。
|
|
378
|
+
|
|
379
|
+
## 6. 行为对照方案(问题四)
|
|
380
|
+
|
|
381
|
+
目标是可执行的「同一输入序列 → 相同决策序列」。分三层,缺一层都只能证明「没崩」,不能证明「没变」。
|
|
382
|
+
|
|
383
|
+
### 6.1 对照对象:什么算「同一个决策」
|
|
384
|
+
|
|
385
|
+
| 字段 | 算不算「决策序列」的一部分 | 为什么 |
|
|
386
|
+
|---|---|---|
|
|
387
|
+
| `applied` | ✅ | 判据 3 明确要求 |
|
|
388
|
+
| `skipReason` / `skip` | ✅ | 判据 3 明确要求 |
|
|
389
|
+
| 预算消耗(`budgets.interventions/judgmentsTurn/judgmentsSession` 前后差) | ✅ | 判据 3 明确要求 |
|
|
390
|
+
| 动作种类(`deny-call` / `prune-result` / `corrective-feedback` / `corrective-context` / `steer-closing`) | ✅ | 决定模型可见面的形状 |
|
|
391
|
+
| 模型可见文本(`feedback` / `updatedToolOutput` / `additionalContext` / `reason`) | ✅(按字节) | 任何一字的差异都是产品回归 |
|
|
392
|
+
| 剪枝副产物(`originalTokens`、`candidateTokens`、`actualSavedTokens`、`floored`、`floorMissed`、`markerOmitted`、`digest`) | ✅ | 谎报节省是安全属性 |
|
|
393
|
+
| `at`、`localLatencyMs`、`remoteLatencyMs` | ❌(置零或剔除) | 时钟与调度噪声 |
|
|
394
|
+
| `id`(`hr_...`) | ❌(剔除) | 随机后缀 |
|
|
395
|
+
| `agentId`、`originalLocator`、`turn`、`step` | ✅(保留但归一化) | 归一化:`turn/step` 照原样,`originalLocator` 只比较**存在性**与 digest 后缀 |
|
|
396
|
+
|
|
397
|
+
### 6.2 三种对拍方法,组合使用
|
|
398
|
+
|
|
399
|
+
**方法 A:决策序列对拍(主方法,每批必跑)**
|
|
400
|
+
|
|
401
|
+
构造同一组输入序列,分别喂给旧引擎(legacy)与新引擎(shared),把两侧的审计输出规范化后 `deepEqual`。
|
|
402
|
+
输入序列用一个**共享的 script 结构**描述(不依赖任何一侧的接口):
|
|
403
|
+
|
|
404
|
+
```ts
|
|
405
|
+
type Step =
|
|
406
|
+
| { ev: 'tool'; tool: string; args: unknown; result: string; isError?: boolean; downstream?: 'allow' | 'deny' | 'ask' | 'block'; failDownstream?: boolean }
|
|
407
|
+
| { ev: 'pre-step'; turn: number; step: number; downstream?: 'enter' | 'abort' }
|
|
408
|
+
| { ev: 'assistant'; delta: string }
|
|
409
|
+
| { ev: 'turn-stopping'; turn: number; stopHookActive?: boolean };
|
|
410
|
+
```
|
|
411
|
+
|
|
412
|
+
两侧各写一个 ~80 行的 `replay()`:DSH 侧把 `tool` 翻译成 `{toolCall, toolResult}`,把 `pre-step` 翻译成
|
|
413
|
+
`preStep`,把 `turn-stopping` 翻译成 `turnStopping`;新引擎(shared 模式)走同一组公开入口。
|
|
414
|
+
HOOK 侧不进这条流水线(见方法 B)。
|
|
415
|
+
|
|
416
|
+
**方法 B:跨宿主信号对拍(用现有 parity 模式扩展)**
|
|
417
|
+
|
|
418
|
+
现有 `src/hook/parity.test.ts` 已经把「同一事件序列过 `FileStateStore` 与 `MemoryStateStore` 必须逐字节相等」
|
|
419
|
+
做成了测试(`src/hook/parity.test.ts:93-104`),它比较的是 `outputs` 与 `ledger` 的「意义」
|
|
420
|
+
(`readLedgerMeaning`,`parity.test.ts:80-87`)——**这套 `replay()` + 规范化 `deepEqual` 的骨架可直接复用**。
|
|
421
|
+
把同一个思路扩展一份**跨引擎**版本:
|
|
422
|
+
让 DSH 的 `toolCall/toolResult` 与 HOOK 的 `handle('pretooluse'|'posttooluse')` 吃同一条 script 的对应切片,
|
|
423
|
+
比较「规范化后的 `AuditableDecision`」(§1.4 前六行)。这条**不能**要求 100% 相等:
|
|
424
|
+
七项差异(`ownTools`、`deny` 强度、`maxClosingBlocksPerTurn`、轮边界……)注定不同,比较的是**同一能力同一触发**下的
|
|
425
|
+
`applied`/`skipReason`/预算三列,其余列以 §6.4 的「已知差异清单」形式显式排除,排除清单本身进测试(每条一个 `it()`,
|
|
426
|
+
理由写死)。
|
|
427
|
+
|
|
428
|
+
**方法 C:随机序列差分(防风化,每批收尾跑一次)**
|
|
429
|
+
|
|
430
|
+
固定种子(`mulberry32(seed)`,自己写 6 行,不引依赖)生成 200 条随机 script:
|
|
431
|
+
|
|
432
|
+
| 生成维度 | 取值 |
|
|
433
|
+
|---|---|
|
|
434
|
+
| 工具名 | `['bash', 'job_output', 'job_list', 'job_kill', 'reflex_choice', 'read']` |
|
|
435
|
+
| 参数 | 随机 0–2 个键,键从 `['command', 'job_id', 'run_id', 'path']` 取,值随机 |
|
|
436
|
+
| 结果 | 4 类:短、长且多行(可剪)、失败(`isError`)、恰好 100_000 字符边界 |
|
|
437
|
+
| 下游 | `['allow', 'deny', 'ask', 'block', 'throw']` |
|
|
438
|
+
| 轮边界 | 随机 3–20 步一换 |
|
|
439
|
+
|
|
440
|
+
同一条 script 跑 legacy 与 shared,`deepEqual` 规范化的决策序列。失败时把 seed 写进断言消息,
|
|
441
|
+
可单条复现(`DRIFT_SEED=1234 npm test`)。
|
|
442
|
+
|
|
443
|
+
### 6.3 断言(伪代码,落地到 `*.test.ts`,本轮**不写**,仅供下一批执行者照抄)
|
|
444
|
+
|
|
445
|
+
```ts
|
|
446
|
+
// A1 legacy 与 shared 的决策序列逐项相等
|
|
447
|
+
test('prune: shared orchestration decides exactly like legacy', async () => {
|
|
448
|
+
for (const script of PRUNE_SCRIPTS) { // §6.2 的 14 例固定 script
|
|
449
|
+
const legacy = await replayLegacy(script); // 旧 #pruneResult 路径
|
|
450
|
+
const shared = await replayShared(script); // 新 core/orchestrate 路径
|
|
451
|
+
assert.deepEqual(normalizeDecisions(shared), normalizeDecisions(legacy));
|
|
452
|
+
}
|
|
453
|
+
});
|
|
454
|
+
|
|
455
|
+
// A2 规范化不吞掉关键字段(防「规范化太狠,什么都相等」)
|
|
456
|
+
test('normalize keeps every decision-bearing field', () => {
|
|
457
|
+
const keys = new Set(PRUNE_SCRIPTS.flatMap((s) => replaySharedSync(s)).flatMap((d) => Object.keys(d)));
|
|
458
|
+
for (const required of ['applied', 'skipReason', 'action', 'originalTokens', 'candidateTokens',
|
|
459
|
+
'actualSavedTokens', 'floored', 'floorMissed', 'markerOmitted', 'digest'])
|
|
460
|
+
assert.ok(keys.has(required), `${required} must survive normalization`);
|
|
461
|
+
});
|
|
462
|
+
|
|
463
|
+
// A3 预算消耗逐项相等:快照三个计数器,不是只看总量
|
|
464
|
+
test('budgets move identically', async () => {
|
|
465
|
+
const before = store.readState(SCOPE); // MemoryStateStore
|
|
466
|
+
await replayShared(script);
|
|
467
|
+
const after = store.readState(SCOPE);
|
|
468
|
+
assert.deepEqual(
|
|
469
|
+
{ i: after.budgets.interventions - before.budgets.interventions,
|
|
470
|
+
jt: after.budgets.judgmentsTurn - before.budgets.judgmentsTurn,
|
|
471
|
+
js: after.budgets.judgmentsSession - before.budgets.judgmentsSession },
|
|
472
|
+
LEGACY_EXPECTED[script.id] // 由 legacy 跑出后冻结
|
|
473
|
+
);
|
|
474
|
+
});
|
|
475
|
+
|
|
476
|
+
// A4 DSH 独有能力 1:等待豁免
|
|
477
|
+
test('wait exemption survives: job_output/job_list yes, job_kill no', async () => {
|
|
478
|
+
assert.equal(isWaitQuery(execOf('job_output', { job_id: 'j1' })), true);
|
|
479
|
+
assert.equal(isWaitQuery(execOf('job_list', {})), true);
|
|
480
|
+
assert.equal(isWaitQuery(execOf('job_kill', { job_id: 'j1' })), false); // 边界
|
|
481
|
+
const script = repeat(query('job_output', { job_id: 'j1' }), 5); // 同一 job 轮询 5 次
|
|
482
|
+
const out = await replayShared(script);
|
|
483
|
+
assert.equal(out.filter((d) => d.action === 'deny-call').length, 0); // 轮询不算停滞
|
|
484
|
+
});
|
|
485
|
+
|
|
486
|
+
// A5 job_kill 重复仍要买判定(边界行为,不是直接拦也不是豁免)
|
|
487
|
+
test('a repeated job_kill is asked about, not refused outright', async () => {
|
|
488
|
+
const judge = recordingJudge();
|
|
489
|
+
const out = await replayShared(repeat(query('job_kill', { job_id: 'j1' }), 3), { judge });
|
|
490
|
+
assert.equal(judge.calls.length, 1, 'the third job_kill buys one judgment');
|
|
491
|
+
assert.match(judge.calls[0].goal ?? '', /suspect: poll-handle/);
|
|
492
|
+
});
|
|
493
|
+
|
|
494
|
+
// A6 DSH 独有能力 2:权限单调
|
|
495
|
+
test('a denial is only added on top of a downstream allow; otherwise passed by identity', async () => {
|
|
496
|
+
for (const kind of ['deny', 'ask', 'block'] as const) {
|
|
497
|
+
const downstream = { kind };
|
|
498
|
+
assert.strictEqual(await engine.toolCall(thirdIdentical(), async () => downstream), downstream);
|
|
499
|
+
}
|
|
500
|
+
assert.strictEqual((await engine.toolCall(thirdIdentical(), async () => ({ kind: 'allow' }))).kind, 'deny');
|
|
501
|
+
});
|
|
502
|
+
|
|
503
|
+
// A7 DSH 独有能力 3:turn-stopping steer
|
|
504
|
+
test('a contradicted closing claim steers exactly one message, carrying the vars', async () => {
|
|
505
|
+
const agent = fakeAgent({ steer: (m) => steered.push(m) });
|
|
506
|
+
await replayShared(contradictedTurn, { agent });
|
|
507
|
+
assert.equal(steered.length, 1);
|
|
508
|
+
assert.equal(steered[0].source.kind, 'plugin:dsh-reflex'); // 与 interventions.ts:135 的 INTERVENTION_SOURCE_KIND 一致
|
|
509
|
+
assert.deepEqual(feedbackVarsOf(steered[0]), expectedVars);
|
|
510
|
+
});
|
|
511
|
+
|
|
512
|
+
// A8 DSH 独有能力 4:assistant-stream 观测 — 流式与整段等价
|
|
513
|
+
test('streamed deltas assemble the same claims the hook gets in one piece', async () => {
|
|
514
|
+
const viaStream = await replayShared([...splitIntoDeltas(TEXT, 3), turnStopping]);
|
|
515
|
+
const viaWhole = await replayShared([{ ev: 'assistant', delta: TEXT }, turnStopping]);
|
|
516
|
+
assert.equal(claimsOf(viaStream), claimsOf(viaWhole)); // 流式累积 == 整段
|
|
517
|
+
});
|
|
518
|
+
|
|
519
|
+
// A9 observe 模式零模型可见变化
|
|
520
|
+
test('observe mode changes nothing model-visible but records the plan', async () => {
|
|
521
|
+
const active = await replayShared(script, { modes: ACTIVE });
|
|
522
|
+
const observe = await replayShared(script, { modes: OBSERVE });
|
|
523
|
+
assert.deepEqual(modelVisible(observe), modelVisible(await replayShared(script, { modes: OFF })));
|
|
524
|
+
assert.deepEqual(observe.map((d) => [d.action, d.applied]),
|
|
525
|
+
active.map((d) => [d.action, false])); // 同样的动作,applied=false
|
|
526
|
+
});
|
|
527
|
+
```
|
|
528
|
+
|
|
529
|
+
(A9 之后还有两条通用断言,同样进下一批的测试:)
|
|
530
|
+
|
|
531
|
+
```ts
|
|
532
|
+
// A10 窗口顺序:共享层入口一律 oldest-first
|
|
533
|
+
test('the window handed to a judgment is oldest-first', () => {
|
|
534
|
+
assert.deepEqual(windowOrderOf(script).map(s => s.tool), EXPECTED_OLDEST_FIRST);
|
|
535
|
+
});
|
|
536
|
+
|
|
537
|
+
// A11 失败放行:任何端口抛错都不改变下游决策
|
|
538
|
+
test('a throwing port never changes the downstream decision', async () => {
|
|
539
|
+
const base = await engine.toolResult(exec, result, async () => ({ kind: 'accept', content }));
|
|
540
|
+
const boom = engineWith({ retain: () => { throw new Error('sink down') } });
|
|
541
|
+
assert.deepEqual(await boom.toolResult(exec, result, async () => ({ kind: 'accept', content })), base);
|
|
542
|
+
});
|
|
543
|
+
```
|
|
544
|
+
|
|
545
|
+
**A1–A9 覆盖判据 3 与判据 4;A10/A11 覆盖改造中最易出错的两个横向不变量。**
|
|
546
|
+
|
|
547
|
+
### 6.4 已知差异清单(跨宿主对拍时显式排除,每条一个理由)
|
|
548
|
+
|
|
549
|
+
| # | 差异 | 排除理由 | 风险 |
|
|
550
|
+
|---|---|---|---|
|
|
551
|
+
| 1 | `callSignature` 算法不同(DSH 用 `exec.arguments` 原字符串或 `JSON.stringify`,`interventions.ts:2558-2570`;HOOK 用 `canonicalJson` 排序后 digest,`decision.ts:164-177` + `520-521`) | 两侧入参形态不同;统一会改变至少一侧的签名 → 改变锁存与拒绝对齐 | **高**:如果 P2 把签名算法一并统一,同一参数对象按不同键序到达时行为会变。**保守建议:本批次不动签名算法**,共享层接收已归一化的 `signature` 字符串 |
|
|
552
|
+
| 2 | 默认配置值不同(`claimMinConfidence` 0.5 vs 0.6;`closingEvidenceChars` 2400 vs 2000;`pruneJudgeMinChars` 10000 vs 无) | 产品调参,非语义 | 中:共享层不得给默认值,只收解析后的值 |
|
|
553
|
+
| 3 | 轮边界方向(DSH 开始计轮,HOOK 结束自增) | 宿主生命周期 | 中:见 §3.2 |
|
|
554
|
+
| 4 | `maxClosingBlocksPerTurn`(DSH 一次 vs HOOK 两次) | 见 §3.6 | 中 |
|
|
555
|
+
| 5 | 动作强度(纠偏:替换 vs 追加;收尾:steer vs block) | 见 §3.6/§5 | 低 |
|
|
556
|
+
| 6 | `ownTools`、`peekDownstream`(Claude 侧恒为 `unknown`/无) | 见 §3.5 | 低 |
|
|
557
|
+
|
|
558
|
+
## 7. 待负责人拍板的 5 件事
|
|
559
|
+
|
|
560
|
+
| # | 事项 | 默认建议 |
|
|
561
|
+
|---|---|---|
|
|
562
|
+
| 1 | 共享层放哪:`src/core/orchestrate.ts`(根包,随 vendor 同步进插件)还是直接写在 `packages/dsh-harness-reflex/src/` 再被根包反向依赖 | **根包 `src/core/`**:与 `text/policy/judge/closing/evidence/prune-plan` 同一位置,`sync-vendor-core.mjs` 的 `CORE_MODULES` 白名单加一行即可;反向依赖会破坏 §2.1 规则 |
|
|
563
|
+
| 2 | `agentKeyOf` 的 `'anonymous'` 兜底(`interventions.ts:2527`)是否在 P1 顺手修 | **不修**:修了是行为变更,且不在本轮范围;单列一个 patch 目标 |
|
|
564
|
+
| 3 | `pollShapeOf` 分支(`interventions.ts:920`)当前**无行为测试**,上移时是否一并补 | **补**:上移时补 2 条行为测试(`task_poll` 重复仍在第 3 次被问、`job_kill` 走 `poll-handle`),否则迁移动的是没被守住的分支 |
|
|
565
|
+
| 4 | P1 是否引入运行时开关 `orchestration.<cap>=legacy\|shared` | **引入**:这是四批的唯一现实回滚手段;开关默认 `legacy`,P1 验收后翻成 `shared`,下一版删除 |
|
|
566
|
+
| 5 | 是否接受「DSH 的 `applied` 只代表 steer 被调用、不代表回合未关」的语义 | **接受**并写进共享层文档(§3.6 风险段),不承诺更强的语义 |
|
|
567
|
+
|
|
568
|
+
## 附录 A:引用索引
|
|
569
|
+
|
|
570
|
+
| 记号 | 文件 | 本文引用点 |
|
|
571
|
+
|---|---|---|
|
|
572
|
+
| HOOK | `src/hook/decision.ts`(1059 行) | §1.2–1.5、§2、§3.2–3.7、§6.1–6.2 |
|
|
573
|
+
| PORT | `src/hook/store-port.ts`(83 行)、`src/hook/memory-store.ts`(220 行) | §2、§3.1、§6.2 |
|
|
574
|
+
| DSH | `packages/dsh-harness-reflex/src/interventions.ts`(2580 行) | §1–§5 全部、§6.3–6.4 |
|
|
575
|
+
| TEST | `packages/dsh-harness-reflex/src/interventions.test.ts`、`src/hook/parity.test.ts` | §3.4、§5、§6.2 |
|
|
576
|
+
| AUDIT | `packages/dsh-harness-reflex/src/session-audit.ts`(577 行) | §1.4、§3.6、§4 |
|
|
577
|
+
| CORE | `src/core/{policy,judge,evidence,closing,text,prune-plan}.ts` | §1.2、§1.3、§3.1、§3.3 |
|
|
578
|
+
| SYNC | `scripts/sync-vendor-core.mjs` | §5 共同门槛 |
|
|
579
|
+
|
|
580
|
+
> 本文所有行号基于 `6872581`。行号会漂移;以 `grep -n '<锚点>' <文件>` 复核为准(锚点已逐条写在各表右列)。
|