@@ -522,6 +522,7 @@ The files that carry the idea, in reading order:
 | [`docs/SKILL-DECISION-ADAPTER.md`](docs/SKILL-DECISION-ADAPTER.md) | how to adapt an existing runtime, step by step |
 | [`docs/ADAPTER-CODEX-SCOPE.md`](docs/ADAPTER-CODEX-SCOPE.md) | that skill applied to a real host we do not own — what is reachable, and what is not |
 | [`docs/POSITIONING-spec-vs-hook.md`](docs/POSITIONING-spec-vs-hook.md) | ★ a specification or a hook — what this is worth, and the condition each reading depends on |
+| [`docs/MEASUREMENT-gate-equivalence.md`](docs/MEASUREMENT-gate-equivalence.md) | ★ that condition, tested: a contract gate vs an equivalent `if`/`else` gate — the falsification holds |
 | [`adapters/codex/`](adapters/codex/README.md) | a working adapter for that host, built by following the skill |
 
 Everything else is plumbing. The parts you are most likely to want to replace:
 
@@ -444,6 +444,7 @@ CWD_ROOT=./你的项目 PORT=7800 npm run serve
 | [`docs/SKILL-DECISION-ADAPTER.md`](docs/SKILL-DECISION-ADAPTER.md) | 逐步改造一个已有运行时 |
 | [`docs/ADAPTER-CODEX-SCOPE.md`](docs/ADAPTER-CODEX-SCOPE.md) | 把那份 Skill 用在一个我们不拥有的真实宿主上 —— 哪些接得到、哪些接不到 |
 | [`docs/POSITIONING-spec-vs-hook.md`](docs/POSITIONING-spec-vs-hook.md) | ★ 它是一份规范，还是一个 hook —— 以及两种读法各自依赖什么条件 |
+| [`docs/MEASUREMENT-gate-equivalence.md`](docs/MEASUREMENT-gate-equivalence.md) | ★ 把那个条件测了：契约门 vs 等价的 `if`/`else` 门 —— falsification 成立 |
 | [`adapters/codex/`](adapters/codex/README.md) | 照着 Skill 做出来的那个真实适配器 |
 
 其余都是接线。最可能想换掉的那几块：
 
@@ -0,0 +1,203 @@
+/**
+ * JevLoop · 完成闸门对照实验：四条臂（纯逻辑，无 IO、无 console）
+ *
+ * ══════════════════════════════════════════════════════════════
+ *  **这个文件是「机制」，不是「报告」。**
+ * ══════════════════════════════════════════════════════════════
+ *
+ * 拆出来的理由有两个，第二个更要紧：
+ *
+ *   ① `bench/gate-compare.ts` 是命令行入口，它在模块顶层 `await main()` ——
+ *      于是**不能被 import**（一 import 就整轮跑起来）。测试要能直接调这些臂。
+ *   ② 结论要能被**钉住**。这一轮的读数（契约门在参考实现里的行为与「没写守卫的
+ *      手写门」逐格相同）如果只是打印出来，下次谁改了 `frame.ts` 的处置方式，
+ *      报告会**静静地变成假的**。钉成测试之后，它变的是断言，不是文档。
+ *
+ * ── 四条臂 ──────────────────────────────────────────────────────
+ *
+ *     contract        契约门，照**参考实现真实的行为**：帧由 `frameArtifact` 编，
+ *                     缺格记进 `unfilled`，然后**没人读它**，策略照跑
+ *     contract-strict 同上 + `unfilled` 非空即拒绝（codex 适配器的纪律）
+ *     ifelse-best     手写门，带「宿主没给证据」的守卫 —— **公平的那个对手**
+ *     ifelse-naive    手写门，没写守卫
+ *
+ * ★ 策略层在四条臂里**逐字相同**（`unsupported >= 0.5 → revise`；
+ *   `deliverable >= 0.6 → deliver`）。这是刻意的：策略层可以机械地翻译成
+ *   if/else，所以任何「契约判得更准」的读数都只可能来自帧，不来自策略。
+ *   如果这里让两臂的门限写得不一样，测出来的差异就没有意义了。
+ *
+ * @module JevLoop/gate-arms
+ */
+
+import { buildDecisions } from '../src/decisions.ts'
+import { resolvePolicy } from '../src/policy.ts'
+import type { AgentCtx, Frame } from '../src/frame.ts'
+import type { AnswerSet } from '../src/vocab.ts'
+import type { GateScenario } from './gate-scenarios.ts'
+import type { ScenarioCtx } from './gate-drift.ts'
+
+/** 一条臂一次运行给出的东西 */
+export interface RunResult {
+  outcome: 'deliver' | 'revise' | 'refuse' | 'error'
+  why: string
+  /** 这条臂**说出**了哪些格子的异常。空数组 = 它一个字都没说 */
+  noticed: string[]
+}
+
+/** 相对 oracle 的记账。`refused` 单独计 —— 它不是「判错」，是「不判」 */
+export type VerdictKind = 'ok' | 'false-accept' | 'false-reject' | 'refused' | 'error'
+
+/** 全部记账类别，报告的顺序 */
+export const KINDS: VerdictKind[] = ['ok', 'false-accept', 'false-reject', 'refused', 'error']
+
+/**
+ * 判据机 —— 读帧的确定性函数，四条臂共用。
+ *
+ * ★ **它只看得见传进来的那份 `evidence`。** 证据空了、成了数组、换成了别的东西，
+ *   它就跟着给出不同的答案 —— 这正是「帧坏了，判定跟着坏」的真实路径。如果它
+ *   绕开帧去读场景真值，这个实验就变成了在测脚本作者写对了没有。
+ *
+ * ★ `answer` / `evidence` 都收 `unknown` 并**对称地**做 `String()`。
+ *   不对称会很隐蔽地替某一臂说话：一边崩、一边静默继续，读数就变成了
+ *   「谁先把类型写对」，而不是「两种机制在漂移下各自做了什么」。
+ *
+ * ⚠️ 字面包含是**代理**，不是语义。真正的语义判据是第二臂（手写 LLM 门）。
+ */
+export function judge(
+  claims: readonly { keyword: string }[],
+  answer: unknown,
+  evidence: unknown,
+): AnswerSet {
+  // 正常消费者会把它当字符串读（投影声明的 `returns` 就是 `string`）——
+  // 类型漂移**不会抛**，它只会静默地改变结果。
+  const hay = typeof evidence === 'string' ? evidence : String(evidence)
+  const said = typeof answer === 'string' ? answer : String(answer)
+  const missing = claims.filter((c) => !hay.includes(c.keyword))
+  // 回答为空 = 没有可核对的主张。★ 单独一类，不该算作「有证据支持」
+  const emptyAnswer = said.trim() === ''
+  const unsupported = missing.length > 0 || emptyAnswer ? 0.9 : 0.1
+  const deliverable = unsupported > 0.5 ? 0.1 : 0.9
+  return {
+    unsupported: { type: 'noul', noul: unsupported },
+    deliverable: { type: 'noul', noul: deliverable },
+  }
+}
+
+/** 帧里那些「宿主没喂 / 没投影出来 / 被截断」的格子 —— 契约**记下来了** */
+export function frameSignals(frame: Frame): string[] {
+  const out: string[] = []
+  for (const u of frame.unfilled) out.push(`unfilled:${u.key}`)
+  for (const a of frame.absent) out.push(`absent:${a.key}`)
+  for (const t of frame.truncated) out.push(`truncated:${t.key}`)
+  return out
+}
+
+/**
+ * 契约门。
+ *
+ * @param strict `true` 时 `unfilled` 非空即拒绝 —— 那是 **codex 适配器**的纪律
+ *   （`adapters/codex/core.ts`），**不是**参考实现的行为。默认 `false` 才是
+ *   「契约本身在漂移下会做什么」。
+ */
+export function contractArm(scenario: GateScenario, ctx: ScenarioCtx, strict: boolean): RunResult {
+  const spec = buildDecisions().canDeliver
+  const artifact = spec.frameArtifact
+  if (!artifact) return { outcome: 'error', why: 'canDeliver 没有 frameArtifact', noticed: [] }
+
+  let frame: Frame
+  try {
+    frame = artifact(ctx as AgentCtx)
+  } catch (err) {
+    return { outcome: 'error', why: `编帧抛了：${(err as Error).message}`, noticed: [] }
+  }
+
+  const noticed = frameSignals(frame)
+
+  if (strict && frame.unfilled.length > 0) {
+    return {
+      outcome: 'refuse',
+      why: `缺 state 格：${frame.unfilled.map((u) => u.key).join(', ')}`,
+      noticed,
+    }
+  }
+
+  const answers = judge(scenario.claims, frame.state.answer, frame.state.evidence)
+  const out = resolvePolicy(spec.policy, answers)
+  return { outcome: out.action as RunResult['outcome'], why: out.reason, noticed }
+}
+
+/**
+ * 手写门 —— **它自己**从原始 ctx 里取证据，不经过帧。
+ *
+ * ★ 这正是手写门与契约门真正的分界：契约的格子在 `DECISION.md` 里**声明**，
+ *   手写门的格子在**代码里写死**。所以前者能自动多出一格，后者不会。
+ *
+ * @param guarded `true` = 最佳实践（含「宿主没给历史」的守卫），`false` = 没写守卫
+ */
+export function ifElseArm(scenario: GateScenario, ctx: ScenarioCtx, guarded: boolean): RunResult {
+  const noticed: string[] = []
+
+  const history = ctx.history
+  if (history === undefined) noticed.push('unfilled:history')
+  else if (history.length === 0) noticed.push('empty:history')
+
+  if (guarded && ctx.draft === undefined) noticed.push('unfilled:draft')
+
+  if (guarded && noticed.some((n) => n.startsWith('unfilled:'))) {
+    // 最佳实践：知道自己要证据，而宿主没给 ⇒ 拒绝，别猜
+    return { outcome: 'refuse', why: `手写守卫：${noticed.join(', ')}`, noticed }
+  }
+
+  const evidence = (history ?? []).map((s) => `${s.tool}(${s.input}) → ${s.result}`).join('\n')
+  const answers = judge(scenario.claims, ctx.draft ?? '', evidence)
+  const unsupported = (answers.unsupported as { noul: number }).noul
+  const deliverable = (answers.deliverable as { noul: number }).noul
+  // ── 策略：**逐字照抄** DECISION.md 的三条规则 ──
+  const action = unsupported >= 0.5 ? 'revise' : deliverable >= 0.6 ? 'deliver' : 'revise'
+  return { outcome: action, why: '手写 if/else（门限与契约一致）', noticed }
+}
+
+/** 一条臂：id + 说明 + 怎么跑 */
+export interface Arm {
+  id: string
+  label: string
+  run: (scenario: GateScenario, ctx: ScenarioCtx) => RunResult
+}
+
+/** 四条臂，顺序即报告顺序 */
+export const ARMS: Arm[] = [
+  {
+    id: 'contract',
+    label: '契约门（照参考实现的真实行为：记录缺格，但不处置）',
+    run: (s, c) => contractArm(s, c, false),
+  },
+  {
+    id: 'contract-strict',
+    label: '契约门 + 缺格拒绝（codex 适配器的纪律）',
+    run: (s, c) => contractArm(s, c, true),
+  },
+  { id: 'ifelse-best', label: '手写门（最佳实践：带守卫）', run: (s, c) => ifElseArm(s, c, true) },
+  { id: 'ifelse-naive', label: '手写门（没写守卫）', run: (s, c) => ifElseArm(s, c, false) },
+]
+
+/** 把一次运行结果相对 oracle 分类 */
+export function classify(result: RunResult, expected: GateScenario['expected']): VerdictKind {
+  if (result.outcome === 'error') return 'error'
+  if (result.outcome === 'refuse') return 'refused'
+  if (result.outcome === expected) return 'ok'
+  return expected === 'revise' ? 'false-accept' : 'false-reject'
+}
+
+/**
+ * 跑一条臂，**不让它把整轮带走**。
+ *
+ * ★ 一条臂抛异常也是一种结果。不接住的话，「谁先在类型上崩掉」会表现为
+ *   「那个台子跑不出来」，读数就丢了一格。
+ */
+export function runArm(arm: Arm, scenario: GateScenario, ctx: ScenarioCtx): RunResult {
+  try {
+    return arm.run(scenario, ctx)
+  } catch (err) {
+    return { outcome: 'error', why: (err as Error).message, noticed: [] }
+  }
+}
@@ -0,0 +1,168 @@
+/**
+ * JevLoop · 完成闸门对照实验：报告
+ *
+ *   node --experimental-strip-types bench/gate-compare.ts
+ *
+ * ══════════════════════════════════════════════════════════════
+ *  **它回答哪一句话，以及它不能回答哪一句话。**
+ * ══════════════════════════════════════════════════════════════
+ *
+ * 定位文档（`docs/POSITIONING-spec-vs-hook.md`）把 falsification 条件写成了：
+ *
+ *     拿一个用 if/else 写成的完成闸门，和一个由决策契约驱动的同一道闸门比。
+ *     如果 **unsupported completion** 上两者没有可测的差异，契约的价值就塌缩成
+ *     「一种更好看的写法」。
+ *
+ * 这个台子就去测它。结论与两个**失败的扰动**写在
+ * `docs/MEASUREMENT-gate-equivalence.md`；机制与四条臂在 `bench/gate-arms.ts`，
+ * 用例与 oracle 在 `bench/gate-scenarios.ts`，漂移在 `bench/gate-drift.ts`。
+ *
+ * ── 它测不了什么 ────────────────────────────────────────────────
+ *
+ * 判据机是**字面包含**（见 `gate-scenarios.ts` 的 `Claim`），所以这里的
+ * 「unsupported」是代理，不是语义。真正的语义判据是第二臂（手写 LLM 门），
+ * 那需要真判定后端，不在这一轮。**不要把这份报告读成「闸门准不准」** ——
+ * 它读的是「同一份判据下，两种机制在宿主漂移时各自做了什么」。
+ *
+ * @module JevLoop/gate-compare
+ */
+
+import { buildDecisions } from '../src/decisions.ts'
+import type { AgentCtx } from '../src/frame.ts'
+import { SCENARIOS } from './gate-scenarios.ts'
+import { PERTURBATIONS, type ScenarioCtx } from './gate-drift.ts'
+import { ARMS, KINDS, classify, runArm, type VerdictKind } from './gate-arms.ts'
+
+/** 扰动**实际**把 ctx 弄成了什么样 —— 与 `expect` 对账，不靠猜 */
+function observedShape(ctx: ScenarioCtx): string {
+  const parts: string[] = []
+  if (ctx.history === undefined) parts.push('history 键不存在')
+  else if (ctx.history.length === 0) parts.push('history 为空数组')
+  else if (ctx.history.some((s) => typeof s.result !== 'string')) parts.push('history.result 不是字符串')
+  else parts.push('history 正常')
+  if (typeof ctx.draft !== 'string') parts.push(`draft 是 ${typeof ctx.draft}`)
+  return parts.join(' / ')
+}
+
+/**
+ * ★ 目击证词：契约门**实际编出来的那一格**是什么类型，以及它**说了什么**。
+ *
+ * 这一栏是为 P3 那两条加的：它们**没能改变任何一条臂的判定**，所以单看判定矩阵
+ * 会读成「这个扰动什么都没发生」。事实上帧里那一格已经不是它声明的 `string`，
+ * 而 `unfilled` / `absent` / `truncated` **没有一个会说这件事**。
+ * 判定没变不代表帧没坏，这两件事必须分开报。
+ */
+function frameWitness(ctx: ScenarioCtx): string {
+  const artifact = buildDecisions().canDeliver.frameArtifact
+  if (!artifact) return '(没有 frameArtifact)'
+  try {
+    const f = artifact(ctx as AgentCtx)
+    const t = (v: unknown) => (Array.isArray(v) ? `数组(${v.length})` : typeof v)
+    return `answer=${t(f.state.answer)} evidence=${t(f.state.evidence)} unfilled=[${f.unfilled.map((u) => u.key).join(',')}] absent=[${f.absent.map((a) => a.key).join(',')}]`
+  } catch (err) {
+    return `编帧抛了：${(err as Error).message}`
+  }
+}
+
+async function main(): Promise<void> {
+  const rows: {
+    scenario: string
+    perturbation: string
+    arm: string
+    observed: string
+    kind: VerdictKind
+    outcome: string
+  }[] = []
+
+  for (const pert of PERTURBATIONS) {
+    for (const scenario of SCENARIOS) {
+      const ctx = pert.apply(scenario.ctx)
+      for (const arm of ARMS) {
+        const result = runArm(arm, scenario, ctx)
+        rows.push({
+          scenario: scenario.id,
+          perturbation: pert.id,
+          arm: arm.id,
+          observed: observedShape(ctx),
+          kind: classify(result, scenario.expected),
+          outcome: result.outcome,
+        })
+      }
+    }
+  }
+
+  // ── 表一：每个扰动一张 场景 × 臂 的矩阵 ──
+  //
+  // ★ 为什么要有明细而不是只给汇总：汇总里的「假接受 0」很容易被读成「很安全」。
+  //   明细才看得出**它是怎么得到 0 的** —— P1 下契约门那 0 其实是「证据一空，
+  //   所有主张都不被支持，于是把每一份回答都打回」，那不是变准了，是闸门停摆了。
+  //   只报汇总等于把「全部拒绝」装成满分。
+  const SYM: Record<VerdictKind, string> = {
+    ok: '✓',
+    'false-accept': '假受',
+    'false-reject': '假拒',
+    refused: '拒绝',
+    error: '崩',
+  }
+  console.log('\n每个扰动一张明细（行 = 场景，列 = 臂；✓ 表示与 oracle 一致）\n')
+  for (const pert of PERTURBATIONS) {
+    console.log(`── ${pert.id}　${pert.what}`)
+    console.log(`   ${'场景'.padEnd(26)}${ARMS.map((a) => a.id.padEnd(16)).join('')}oracle`)
+    for (const s of SCENARIOS) {
+      const cells = ARMS.map((a) => {
+        const r = rows.find((x) => x.scenario === s.id && x.perturbation === pert.id && x.arm === a.id)
+        return (r ? SYM[r.kind] : '?').padEnd(16)
+      }).join('')
+      console.log(`   ${s.id.padEnd(26)}${cells}${s.expected}`)
+    }
+    const obs = [...new Set(rows.filter((r) => r.perturbation === pert.id).map((r) => r.observed))]
+    console.log(`   ↳ 实测形状：${obs.join(' / ')}　（预期 ${pert.expect}）`)
+    console.log(`   ↳ 帧实际内容（S1）：${frameWitness(pert.apply(SCENARIOS[0].ctx))}\n`)
+  }
+
+  // ── 表二：汇总 ──
+  console.log('\n汇总（每臂 6 场景 × 6 扰动 = 36 次）\n')
+  const header = `${'臂'.padEnd(16)}` + KINDS.map((k) => k.padEnd(14)).join('')
+  console.log(header)
+  console.log('─'.repeat(header.length + 6))
+  for (const arm of ARMS) {
+    const cell = rows.filter((r) => r.arm === arm.id)
+    const counts = KINDS.map((k) => String(cell.filter((r) => r.kind === k).length).padEnd(14)).join('')
+    console.log(`${arm.id.padEnd(16)}${counts}`)
+  }
+
+  // ── 表三：逐格比较两臂是否给出同一结果 ──
+  console.log('\n两臂在同一 (场景, 扰动) 上是否给出同一结果：\n')
+  const pairs = [
+    ['contract', 'ifelse-naive'],
+    ['contract-strict', 'ifelse-best'],
+    ['contract', 'ifelse-best'],
+  ] as const
+  for (const pert of PERTURBATIONS) {
+    for (const [a, b] of pairs) {
+      const diff = SCENARIOS.filter((s) => {
+        const ra = rows.find((r) => r.scenario === s.id && r.perturbation === pert.id && r.arm === a)
+        const rb = rows.find((r) => r.scenario === s.id && r.perturbation === pert.id && r.arm === b)
+        return ra?.outcome !== rb?.outcome
+      })
+      console.log(
+        `  ${`${pert.id} · ${a} vs ${b}`.padEnd(50)} ${diff.length === 0 ? '逐格一致' : `不同：${diff.map((s) => s.id).join(', ')}`}`,
+      )
+    }
+  }
+
+  // ── 表四：★ 反向对照必须无差异 ──
+  console.log('\n★ 反向对照（P5）—— 只改帧声明**排除**的格子：\n')
+  const p0 = rows.filter((r) => r.perturbation === 'P0-none')
+  const p5 = rows.filter((r) => r.perturbation === 'P5-irrelevant-control')
+  for (const arm of ARMS) {
+    const a = p0.filter((r) => r.arm === arm.id).map((r) => `${r.scenario}:${r.outcome}`).join('|')
+    const b = p5.filter((r) => r.arm === arm.id).map((r) => `${r.scenario}:${r.outcome}`).join('|')
+    console.log(
+      `  ${arm.id.padEnd(16)} ${a === b ? '与基线一致 ✓' : '★ 与基线不同 ✗（对照失败，差异另有来源）'}`,
+    )
+  }
+  console.log('')
+}
+
+await main()