@tacet-ink/journal-core 0.1.6 → 0.2.1

package/scripts/verify-core-crypto.ts

@@ -27,6 +27,7 @@ import {
   wrapNoteKeyDual,
   unwrapNoteKeyDual,
   normalizePin,
+  normalizePassphrase,
   encryptAttach,
   decryptAttach,
   encryptLocal,
@@ -36,6 +37,9 @@ import {
   decryptWithKey,
   b64 as modB64,
   unb64 as unb64Mod,
+  deriveGuestKey,
+  sealNoteKey,
+  importAesGcm,
 } from '../src/client/note-crypto.ts';
 import {
   verifyArgonKat,
@@ -43,12 +47,19 @@ import {
   unwrapNoteKey3,
   wrapNoteKeyDual3,
   unwrapNoteKeyDual3,
+  wrapNoteKey4,
+  unwrapNoteKey4,
+  wrapNoteKeyDual4,
+  unwrapNoteKeyDual4,
+  unwrapNoteKeyDual4WithSalt,
   ARGON_MEMORY_KIB,
   ARGON_ITERATIONS,
   ARGON_PARALLELISM,
   ARGON_TAG_LEN,
   derivePh1Argon,
+  derivePh1ArgonV3,
   PH1_V2_SALT,
+  PH1_V3_SALT,
   type Argon3Config,
 } from '../src/client/argon2.ts';
 import { makeKeyStore } from '../src/client/keys.ts';
@@ -71,6 +82,15 @@ import {
 import { checkRate, isRateAllowed, SQL_RATE_BUMP, type RateWindow } from '../src/server/ratelimit.ts';
 import { generateSessionToken, timingSafeEq } from '../src/server/hash.ts';
 import { CORS_HEADERS, corsResponse } from '../src/server/cors.ts';
+import {
+  PH2_LADDER_TABLE,
+  PH2_LADDER_KIND_LEGACY,
+  PH2_LADDER_KIND_V2,
+  makePh2LadderStore,
+} from '../src/server/ladder.ts';
+
+type Row19 = { account_id: string; ph2_kind: string };
+type Env19 = { DB: { prepare(sql: string): { bind(...params: unknown[]): { first(): Promise<Row19 | null>; run(): Promise<void> } } } };
 
 const enc = new TextEncoder();
 
@@ -141,8 +161,8 @@ await A('AAD 防搬移：跨身份 guest 解密失敗回 null',
 // 舊版明文相容層：無前綴 = 原樣返回
 await A('舊明文原樣返回', (await decryptNote(TACET, held, '純舊明文', 'x', { current: () => identityA })) === '純舊明文');
 
-// ── 3. 包裹三件套（pass / rec / 本機；2026-09-24 效能審查節——buildBindPayload 兩段
-//      PBKDF2 600k 已由卡C t_7361b68c 收 Promise.all 並行，node 實測 133-152ms→68-84ms） ──
+// ── 3. 包裹三件套（pass / rec / 本機；2026-09-24 效能節——buildBindPayload 兩段
+//      PBKDF2 600k 已收 Promise.all 並行，node 實測 133-152ms→68-84ms） ──
 
 console.log('\n[3] 金鑰包裹（passphrase / 復原 / 本機）');
 const pass = 'correct-horse-battery-staple-42';
@@ -235,8 +255,8 @@ await A('dual unwrapNoteKeyDual 拒收 jr1w 字串', (await unwrapNoteKeyDual(TA
 await A('既有 jr1w 包裹不受 dual 並存影響', (await unwrapNoteKey(TACET2, wrapped, pass, salt)) !== null);
 
 // payload 竄改 → 一律 null（自描述完整性：pinSalt/hksalt/iv/ct 任一區）
-// 卡C 收口：本地複製退場、直呼模組 unb64（單一真相；t_7361b68c [14] 導入面；
-// round 2 NIT-5：轉手 wrapper 本身退場——呼叫端直用模組 unb64）。
+// 收口：本地複製退場、直呼模組 unb64（單一真相；[14] 導入面；
+// 轉手 wrapper 本身退場——呼叫端直用模組 unb64）。
 const payload2 = unb64Mod(dual.wrapped.slice('jr2w.'.length));
 const tamperedAt = async (idx: number): Promise<boolean> => {
   const copy = payload2.slice();
@@ -390,7 +410,7 @@ await A('25 詞 → null', (await bip.wordsToRecToken([...kitWords, kitWords[0]]
 await A('詞表外 → null', (await bip.wordsToRecToken(kitWords.slice(0, 23).concat('notaword').join(' '))) === null);
 
 // checksum 面：錯一詞（詞表內不同詞）→ 幾乎必被 checksum 抓；固定種子 64 樣本全抓。
-// （t_d1cf3846：真隨機取樣時 P(漏 ≥2)≈0.4%＝偶發 62/64 flake 實證——改 xorshift 常數
+// （真隨機取樣時 P(漏 ≥2)≈0.4%＝偶發 62/64 flake 實證——改 xorshift 常數
 // 種子樣本集（bip39.seededSampleBytes），向量可重放、閘輸出逐輪恆定；種子窗 1..64
 // 經五窗 320 樣本探針驗證全抓後採用，非挑窗）
 const wlArr: readonly string[] = wl.wordlist;
@@ -464,7 +484,7 @@ await A('附件錯鑰匙 → null',
 // ── 11. 本機 IDB 密文（jr1d. cipherLocal opt-in）＋ guest 選配拒絕面 ──────────
 
 console.log('\n[11] 本機 IDB 密文（jr1d. cipherLocal opt-in）＋ guest 選配拒絕面');
-// 分享包裹（jrsw.，wrapShare 選配）＋ jr3s. roundtrip（t_7710c766 目標 8：閘本有 roundtrip 斷言缺席）
+// 分享包裹（jrsw.，wrapShare 選配）＋ jr3s. roundtrip（閘本有 roundtrip 斷言缺席）
 const TACET_SHARE: NoteCryptoConfig = { ...TACET, wrapShare: 'jrsw.' };
 const shareWrapped = await wrapNoteKeyShare(TACET_SHARE, noteKey, 'share-pass-42');
 await A('分享包裹前綴 jrsw.', shareWrapped.wrapped.startsWith('jrsw.'));
@@ -474,7 +494,7 @@ await A('jrsw unwrap 等值 noteKey（extractable 再 export）',
   shareUnwrapped !== null && hex(new Uint8Array(await crypto.subtle.exportKey('raw', shareUnwrapped))) === origRaw);
 await A('分享錯密語 → null', (await unwrapNoteKeyShare(TACET_SHARE, shareWrapped.wrapped, 'wrong-share-pass', shareWrapped.salt)) === null);
 await A('分享錯 salt → null', (await unwrapNoteKeyShare(TACET_SHARE, shareWrapped.wrapped, 'share-pass-42', 'zz'.repeat(16))) === null);
-await A('分享 malformed salt（zz 字元）→ null（t_7710c766：salt1 hex 形檢查）',
+await A('分享 malformed salt（zz 字元）→ null（salt1 hex 形檢查）',
   (await unwrapNoteKeyShare(TACET_SHARE, shareWrapped.wrapped, 'share-pass-42', '0'.repeat(31) + 'z')) === null);
 await A('分享 payload 長度不符 → null',
   (await unwrapNoteKeyShare(TACET_SHARE, shareWrapped.wrapped.slice(0, -3) + 'abc', 'share-pass-42', shareWrapped.salt)) === null);
@@ -550,7 +570,7 @@ await A('本機 payload 竄改 iv 區 → null', await tamperLocal(3));
 await A('篡改索引越界＝顯性失敗（runner 自檢：靜默 no-op 即假紅）', await tamperLocal(-1) === false);
 await A('本機 payload 竄改 ct 尾 → null', await tamperLocal(59));
 
-// guest 選配未配置拒絕面（2026-09-19 收編：cipherGuest 轉選配；未配置即拒鐵律）
+// guest 選配未配置拒絕面（2026-09-19 定案：cipherGuest 轉選配；未配置即拒鐵律）
 const TACET_NOGUEST: NoteCryptoConfig = { ...TACET, cipherGuest: undefined };
 const guestThrowsMsg = async (): Promise<string | null> => {
   try { await encryptNote(TACET_NOGUEST, makeHeldKey(), note, 'noteId:n1', { current: () => identityA }); return null; }
@@ -568,10 +588,10 @@ await A('未配置 guest → decryptNote 不明字串 null（guest 家族整面
   (await decryptNote(TACET_NOGUEST, makeHeldKey(), 'jr9x.somestring', 'x', { current: () => identityA })) === null);
 await A('配置 guest → decryptNote 舊明文相容層原樣（既有契約不變）',
   (await decryptNote(TACET, makeHeldKey(), '純舊明文', 'x', { current: () => identityA })) === '純舊明文');
-await A('既有 guest 配置 roundtrip 不受選配收編影響',
+await A('既有 guest 配置 roundtrip 不受選配化影響',
   (await decryptNote(TACET, makeHeldKey(), cipherGuest, 'noteId:n1', { current: () => identityA })) === note);
 
-// guest 空 identity 拒絕面（t_7710c766 目標 3）：K_u = SHA-256(prefix ‖ '') 靜默產出「空帳號金鑰」是誤配炸彈
+// guest 空 identity 拒絕面：K_u = SHA-256(prefix ‖ '') 靜默產出「空帳號金鑰」是誤配炸彈
 const TACET_GUESTOK: NoteCryptoConfig = { ...TACET }; // cipherGuest='jr1g.' 在場，專測 identity 面
 const emptyIdp = { current: () => '' };
 let emptyIdMsg: string | null = null;
@@ -587,7 +607,7 @@ await A('guest 解密面空 identity → null（對稱面 fail-closed）',
 await A('guest 空 identity 的既有 roundtrip 恆正常（identity 在場零新拒絕面）',
   (await decryptNote(TACET_GUESTOK, makeHeldKey(), cipherGuest, 'noteId:n1', { current: () => identityA })) === note);
 
-// 畸形配置 ''（空字串）正規化面（follow-up ②，t_44239f5f）：空字串前綴＝startsWith('') 恆真，
+// 畸形配置 ''（空字串）正規化面：空字串前綴＝startsWith('') 恆真，
 // bound 列會被誤導 guest 分支回 null。正規化後：加密面與未配置同拒、解密面 bound 照解、
 // guest 密文（他家族形）null——與「未配置」行為完全同構。
 const TACET_EMPTYGUEST: NoteCryptoConfig = { ...TACET, cipherGuest: '' };
@@ -600,14 +620,14 @@ await A("畸形 guest 前綴 '' → decryptNote guest 密文 null（guest 家族
 await A("畸形 guest 前綴 '' → decryptNote 舊明文相容層同「未配置」形（null，不當明文）",
   (await decryptNote(TACET_EMPTYGUEST, makeHeldKey(), '純舊明文', 'x', { current: () => identityA })) === null);
 
-// ── 12. 伺服器端原語（t_7710c766 目標 8：makeInboundCipher/validWrappedKey/pickKeyPackage/
-//         checkRate/timingSafeEq）＋ 本機鎖定全函式（pinlock jr1p.，目標 8） ──────────
+// ── 12. 伺服器端原語（makeInboundCipher/validWrappedKey/pickKeyPackage/
+//         checkRate/timingSafeEq）＋ 本機鎖定全函式（pinlock jr1p.） ──────────
 
 console.log('\n[12] 伺服器端原語（auth/ratelimit/hash）＋ 本機鎖定（pinlock）');
-// ratelimit 行為面（t_b91ed07f；r2 MAJOR-2 收口）：真 node:sqlite 直載 UPSERT…RETURNING 單句，
+// ratelimit 行為面（UPSERT…RETURNING 單句設計收口）：真 node:sqlite 直載 UPSERT…RETURNING 單句，
 // 行為斷言全數「真生產函式 checkRate 直驅」——D1 形 shim 包 node:sqlite 只做 D1 run() 的
 // {results} 回帶形，無測試端 glue 副本。表名直插 SQL＝注入面驗證；放行判準 count<=max
-// 單一真相。同 IP 真併發不 undercount 的 D1 活線證據見卡 comments（wrangler dev 探針：
+// 單一真相。同 IP 真併發不 undercount 的 D1 活線證據由 wrangler dev 探針承載（
 // UPSERT…RETURNING 於 wrangler 4.129.0 workerd 逐發回真值；併發首發兩發計數 1→2）。
 type RateRow = { ip: string; window_start: number; count: number };
 const RATE: RateWindow = { table: 'login_rate', windowMs: 60_000, max: 3 };
@@ -700,7 +720,7 @@ await A('rate：表名 \\w 合法（字母數字底線）', await (async () => {
   try { await checkRate({ DB: { prepare: () => { throw new Error('D1_DOWN_FAILOPEN'); } } } as unknown as Parameters<typeof checkRate>[0], { table: 'login_rate_2', windowMs: 1000, max: 3 }, 'ip'); return true; }
   catch (e) { return String((e as Error).message).startsWith('ERR_RATE_TABLE_NAME') === false && String((e as Error).message).includes('D1_DOWN_FAILOPEN'); }
 })());
-await A('rate：RETURNING 異形回應守衛 fail-open（results 空／alias 斷裂——與儲存故障同向，r2 MINOR-3 不反向 deny）', await (async () => {
+await A('rate：RETURNING 異形回應守衛 fail-open（results 空／alias 斷裂——與儲存故障同向，異形不反向 deny）', await (async () => {
   const mkEnv = (run: () => Promise<unknown>) =>
     ({ DB: { prepare: () => ({ bind: () => ({ run }) }) } } as unknown as Parameters<typeof checkRate>[0]);
   const empty = await checkRate(mkEnv(async () => ({ results: [] })), RATE, 'ip');
@@ -731,7 +751,7 @@ await A('inboundCipher：真明文照收', inbound('純明文') === '純明文')
 await A('inboundCipher：非字串 null', inbound(42) === null);
 await A('isCipherFor：家族前綴 true／非家族 false',
   isCipherFor('jr1b.abc', formats) && isCipherFor('jr1u.abc', formats) && !isCipherFor('jr2x.abc', formats));
-await A('isCipherFor 空字首組態 → false（\x27\x27 態 startsWith(\x27\x27) 恆真 accept-all——run 574 MINOR-3：cipherPrefixRe 守衛不覆蓋直讀 tuple 面，同向收口；非字串 false 契約照舊）',
+await A('isCipherFor 空字首組態 → false（\x27\x27 態 startsWith(\x27\x27) 恆真 accept-all——cipherPrefixRe 守衛不覆蓋直讀 tuple 面，同向收口；非字串 false 契約照舊）',
   (() => {
     const emptyTuple: CipherFormats = { cipherPrefixes: ['', ''], wrapPrefix: 'jr1w.', cipherMax: 5000 };
     const mixed: CipherFormats = { cipherPrefixes: ['', 'jr1b.'], wrapPrefix: 'jr1w.', cipherMax: 5000 };
@@ -740,31 +760,31 @@ await A('isCipherFor 空字首組態 → false（\x27\x27 態 startsWith(\x27\x2
       isCipherFor('jr1b.abc', mixed) === true && // 真前綴面零誤傷
       isCipherFor(null, formats) === false; // 非字串 false 面（typed 形合法態；運行時 typeof 守衛承載 unknown 呼叫端）
   })());
-await A('makeInboundCipher regex 跳脫全字面（r2 MAJOR-1 辨別形重推——探針新舊碼輸出一手實測，兩向分歧各一）',
+await A('makeInboundCipher regex 跳脫全字面（辨別形重推——探針新舊碼輸出一手實測，兩向分歧各一）',
   (() => {
     // 舊碼 .replace('.','\\.') 只跳第一個點，前綴含 regex 符號（| ( )）時家族 regex 失真，
     // 兩方向輸出分歧（一手對照探針帳面：tmp probe-d1.cjs，main 舊碼 vs 分支新碼）：
     // ①完整前綴形『a.b|c()』+A*600（真家族密文標記）：正碼辨得前綴 → >max 密文丟棄 null；
     //   舊碼 regex 辨不出自家前綴 → 誤落明文截斷（>max 密文截半損毀＝舊碼 slice(0,500)）。
     // ②點前截形『a.b』+A*600：舊碼 a\.b 殘臂（從頭起 b64 全程）誤咬 → 丟棄 null；
-    //   正碼前綴不完整非家族 → 明文截斷照收 slice(0,500)。兩形缺一即探針無齒（r1 教訓）。
+    //   正碼前綴不完整非家族 → 明文截斷照收 slice(0,500)。兩形缺一即探針無齒。
     const f: CipherFormats = { cipherPrefixes: ['a.b|c()', 'jr1b.'], wrapPrefix: 'jr1w.', cipherMax: 500 };
     const m = makeInboundCipher(f);
     const full = 'a.b|c()' + 'A'.repeat(600);
     const dotHead = 'a.b' + 'A'.repeat(600);
     return m(full) === null && m(dotHead) === dotHead.slice(0, 500);
   })());
-// N-7（t_580f9c54）：cipherPrefixRe 空字首組態毒形——never-match 守衛的行為面。
-// run 574 r2 校正（新舊碼組裝對照一手實測 /tmp/t580f9c54-r2/n7-corrected-probe.mjs）：舊碼
+// 空字首組態毒形防線：cipherPrefixRe never-match 守衛的行為面。
+// 校正（新舊碼組裝對照一手實測）：舊碼
 // `[]` 與 `['']` 組裝出 byte-identical `^()[A-Za-z0-9+/]+={0,2}$`（join('|') 同為空串），
 // `['','']` 僅多空首選交替 `^(|)…`＝同面——真洞＝無點純 b64 串（≤200）在舊碼
 // validWrappedKey/pickKeyPackage 放行（NON-NULL）；帶點前綴向量（'jr1w.'+b64）舊碼本就 null
-// （'.' 在 b64 charset 外）＝帳面無承載。r1 版敘事（charset 恆假自帶防線／空槽首選交替洞）經
-// run 574 一手實證俱誤——本段已按實測帳重寫（revert-poison 案為守衛還原面的直接承載）。
+// （'.' 在 b64 charset 外）＝帳面無承載。初版敘事（charset 恆假自帶防線／空槽首選交替洞）經
+// 一手實證俱誤——本段已按實測帳重寫（revert-poison 案為守衛還原面的直接承載）。
 // 守衛後（usable 過濾＋never-match）：家族/re 面整面拒絕；inboundCipher 輸出面 zero delta
 // （家族路摘除後長路徑 b64≤max 短路進 legacy 慣例層、超限丟棄、明文相容層照收——出口與舊碼
 // RE 路徑恆等，probe 33 組合實證）；混合『['','jr1b.']』形只摘空槽、真前綴家族面照活（降級非全拒）。
-await A('N-7 真洞還原面：無點純 b64 ≤200 空字首組態 → null（cipherPrefixRe never-match——守衛摘除即翻紅；三組態）',
+await A('空字首真洞還原面：無點純 b64 ≤200 空字首組態 → null（cipherPrefixRe never-match——守衛摘除即翻紅；三組態）',
   (() => {
     const pureB64 = b64(new Uint8Array(32)); // 無點 b64（44 字符）——舊碼本就放行＝真洞載體（帶點向量舊碼本就 null，無承載）
     const emptyTuple = ['', ''];
@@ -772,7 +792,7 @@ await A('N-7 真洞還原面：無點純 b64 ≤200 空字首組態 → null（c
       validWrappedKey(pureB64, emptyTuple) === null &&
       validWrappedKey(pureB64, '') === null; // string 形空前綴同面
   })());
-await A('N-7 pickKeyPackage 空字首組態 → 整組放棄（validWrappedKey never-match 傳播——wrapped/salt 同 null）',
+await A('空字首組態 pickKeyPackage → 整組放棄（validWrappedKey never-match 傳播——wrapped/salt 同 null）',
   (() => {
     const p = pickKeyPackage({ wrapped: b64(new Uint8Array(32)), salt: 'a'.repeat(32) }, ['', '']);
     return p.wrapped === null && p.salt === null;
@@ -802,7 +822,7 @@ await A('pickKeyPackage：缺 wrapped 整組放棄',
 await A('pickKeyPackage：錯前綴整組放棄',
   (() => { const p = pickKeyPackage({ wrapped: 'jr9x.' + b64(new Uint8Array(32)), salt: 'a'.repeat(32) }, 'jr1w.'); return p.wrapped === null; })());
 
-// 本機鎖定（jr1p.）：全函式 roundtrip＋嚴格檢查面（t_7710c766：pinlock 閘本有斷言缺席）
+// 本機鎖定（jr1p.）：全函式 roundtrip＋嚴格檢查面（閘本有斷言缺席）
 const PINLOCK: PinLockConfig = { pinLock: 'jr1p.', pinLockSaltPrefix: 'tacet-pinlock-v1:', pinLockAad: 'notekey-pinlock' };
 const pinWrapped = await wrapNoteKeyPinLock(PINLOCK, noteKey, '2580ab');
 await A('jr1p 包裹前綴 jr1p.', pinWrapped.startsWith('jr1p.'));
@@ -833,10 +853,10 @@ await A('jr1p 跨家族：jr1w. 字串餵 pinlock → null',
 await A('jr1p 跨家族：jr1p. 字串餵 jr1w unwrap → null',
   (await unwrapNoteKey(TACET2, pinWrapped, pass, salt)) === null);
 
-// ── 13. 新契約面（t_7710c766：hex fail-closed／salt hex 形收口／PH1 鹽注入／錯誤碼語意分離） ──
+// ── 13. 新契約面（hex fail-closed／salt hex 形收口／PH1 鹽注入／錯誤碼語意分離） ──
 
 console.log('\n[13] unwrap 驗證統一新契約（fail-closed ＋ 語意分離）');
-// hexToBytes fail-closed（目標 #2；note-crypto 與 bip39 同步——bip39 面是 HEX64_RE 前置自守）
+// hexToBytes fail-closed（note-crypto 與 bip39 同步——bip39 面是 HEX64_RE 前置自守）
 await A('hexToBytes 合法輸出不變（舊碼同值；新向量）', hexToBytes('00ff10').join(',') === '0,255,16');
 await A('hexToBytes 大小寫正規化（新行為，舊碼同值）', (() => { const a = Array.from(hexToBytes('AB')); const b = Array.from(hexToBytes('ab')); return a.length === b.length && a.every((v, i) => v === b[i]); })());
 await A("hexToBytes 非法字元 'zz' → throw ERR_BAD_HEX", await (async () => {
@@ -849,7 +869,7 @@ await A('hexToBytes 空字串 → throw', await (async () => {
   try { hexToBytes(''); return false; } catch (e) { return (e as Error).message === 'ERR_BAD_HEX'; }
 })());
 await A(`hexToBytes 全形正規化（'${'ｆｆ'}'）→ Bytes [255] 等值`, (() => { try { return Array.from(hexToBytes('ｆｆ')).join(',') === '255'; } catch { return false; } })());
-await A(`hexToBytes 全形數字（'２ｆ'）→ Bytes 等值（NFKC 窗殲滅——round 1 MINOR-4：parse 原始串 NaN 歸零殘形）`, (() => { try { return Array.from(hexToBytes('２ｆ')).join(',') === '47'; } catch { return false; } })());
+await A(`hexToBytes 全形數字（'２ｆ'）→ Bytes 等值（NFKC 窗殲滅——parse 原始串 NaN 歸零殘形）`, (() => { try { return Array.from(hexToBytes('２ｆ')).join(',') === '47'; } catch { return false; } })());
 await A('bip39 hexToBytes 同步（HEX64_RE 自守前提下的舊向量不變）', (await bip.recTokenToWords('ab'.repeat(32)))?.length === 24);
 await A('unwrap：鹽 hex 非法字元 → 假錯誤誘餌面 null（原碼靜默歸零會錯誤炸出成功路徑）',
   (await unwrapNoteKey(TACET2, dual.wrapped, passD, 'a'.repeat(31) + 'z')) === null);
@@ -866,19 +886,19 @@ const craftKek = (async (): Promise<CryptoKey> => {
 })();
 // 鍛造面（格式嚴格契約的可觀察承載；毒化前提）：KEK 已知者可造任意形 payload——
 // 舊碼（無 rawHex 長度/形檢）下 'zz' 前綴零化 hex 與 32-hex 假 noteKey 皆 NON-NULL＝假金鑰生產器。
-// round 1 審查 MAJOR-1 校正：鍛造 encrypt 必帶 additionalData('notekey')＝與 decryptWithKey
+// 鍛造校正：encrypt 必帶 additionalData('notekey')＝與 decryptWithKey
 // 同 AAD——缺 AAD 的鍛造 GCM 層恆拒＝rawHex 形檢從未執行（斷言空轉）。
 // craftKek 鏡像真 deriveKek（同 pass 同 salt 同 600k）＝鍛造鏈與真 unwrap 同 KEK：
 // 有效形鍛造真解開（NON-NULL 自證鏈活）、畸形形由各檢查點拒——機制面直接可觀察。
-// AAD 單一化（r2 NIT-a）：F_AAD 是四鍛造向量唯一 AAD 源（對 decryptWithKey 同 AAD 律的 helper 收口）。
+// AAD 單一化：F_AAD 是四鍛造向量唯一 AAD 源（對 decryptWithKey 同 AAD 律的 helper 收口）。
 const F_AAD: BufferSource = enc.encode('notekey');
-await A('MAJOR-1 機制面：帶 AAD 鍛造 ct 可解回 rawHex（形檢層可達＝斷言活）', await (async () => {
+await A('鍛造機制面：帶 AAD 鍛造 ct 可解回 rawHex（形檢層可達＝斷言活）', await (async () => {
   const kekC = await craftKek;
   const ivC = crypto.getRandomValues(new Uint8Array(12));
   const ctC = new Uint8Array(await crypto.subtle.encrypt({ name: 'AES-GCM', iv: ivC, additionalData: F_AAD }, kekC, enc.encode('zz' + 'a'.repeat(62)) as BufferSource));
   return (await decryptWithKey(kekC, new Uint8Array([...ivC, ...ctC]), 'notekey')) === 'zz' + 'a'.repeat(62);
 })());
-await A('MAJOR-1 空轉形：同 payload 無 AAD 鍛造 → decryptWithKey null（GCM 層恆拒＝round 1 空轉病理）', await (async () => {
+await A('鍛造空轉形：同 payload 無 AAD 鍛造 → decryptWithKey null（GCM 層恆拒＝空轉病理）', await (async () => {
   const kekC = await craftKek;
   const ivC = crypto.getRandomValues(new Uint8Array(12));
   const ctC = new Uint8Array(await crypto.subtle.encrypt({ name: 'AES-GCM', iv: ivC }, kekC, enc.encode('zz' + 'a'.repeat(62)) as BufferSource));
@@ -924,7 +944,7 @@ await A('guest 空 identity 自洽密文 → decryptNote null（「空帳號金
   const cipherEmpty = 'jr1g.' + await encryptWithKey(kuEmpty, note, 'noteId:n1');
   return (await decryptNote(TACET_GUESTOK, makeHeldKey(), cipherEmpty, 'noteId:n1', emptyIdp)) === null;
 })());
-// 錯誤碼語意分離（目標 6）：空 PIN ≠ 未配置；jr3d 兩 case 同碼分流
+// 錯誤碼語意分離：空 PIN ≠ 未配置；jr3d 兩 case 同碼分流
 await A('wrapNoteKeyDual 空 PIN → ERR_PIN_EMPTY（非 NOT_CONFIGURED）', await (async () => {
   try { await wrapNoteKeyDual(TACET2, noteKey, passD, ''); return false; } catch (e) { return (e as Error).message === 'ERR_PIN_EMPTY'; }
 })());
@@ -934,13 +954,13 @@ await A('wrapNoteKeyDual 空 PIN 全形空白正規化後 → ERR_PIN_EMPTY', aw
 await A('wrapNoteKeyDual 未配置 wrapDual → ERR_DUAL_NOT_CONFIGURED（契約不變）', await (async () => {
   try { await wrapNoteKeyDual(TACET, noteKey, passD, pinD); return false; } catch (e) { return (e as Error).message === 'ERR_DUAL_NOT_CONFIGURED'; }
 })());
-await A('wrapNoteKeyDual3 空 PIN → ERR_PIN_EMPTY（t_7710c766：兩 case 同碼分流）', await (async () => {
+await A('wrapNoteKeyDual3 空 PIN → ERR_PIN_EMPTY（兩 case 同碼分流）', await (async () => {
   try { await wrapNoteKeyDual3(TACET3, noteKey, passD, ''); return false; } catch (e) { return (e as Error).message === 'ERR_PIN_EMPTY'; }
 })());
 await A('wrapNoteKeyDual3 未配置 wrapDual3 → ERR_JR3W_NOT_CONFIGURED（契約不變）', await (async () => {
   try { await wrapNoteKeyDual3({}, noteKey, passD, pinD); return false; } catch (e) { return (e as Error).message === 'ERR_JR3W_NOT_CONFIGURED'; }
 })());
-// PH1 鹽注入（目標 4）：預設舊值零行為變更
+// PH1 鹽注入：預設舊值零行為變更
 await A('derivePh1Argon 預設鹽零行為變更（同 pass 同值）',
   (await derivePh1Argon('probe-determinism-pass-42')) === ph1v2a);
 async function srcOf(rel: string): Promise<string> {
@@ -957,14 +977,14 @@ await A('derivePh1Argon 預設分支源碼面 = encode(PH1_V2_SALT)（鹽預設
 await A('derivePh1Argon 自選鹽 → 不同派生值', (await derivePh1Argon('probe-determinism-pass-42', new Uint8Array(12))) !== ph1v2a);
 await A('derivePh1Argon 自選鹽 hex64 形', /^[0-9a-f]{64}$/.test(await derivePh1Argon('x', new Uint8Array(12))));
 await A('PH1_V2_SALT re-export 在場（index barrel；其他產品可見可注入同源鹽）', PH1_V2_SALT === 'tacet-ph1-v1');
-// index barrel 新匯出（目標 5）：clearLocalWrap/buildBindPayload（review「缺匯出」條誤差已校正＝本卡以閘承載）
+// index barrel 新匯出：clearLocalWrap/buildBindPayload（「缺匯出」條誤差已校正——以閘承載）
 await A('index barrel 匯出 clearLocalWrap/buildBindPayload', await (async () => {
   const src = await import('../src/index.ts');
   return typeof src.clearLocalWrap === 'function' && typeof src.buildBindPayload === 'function';
 })());
-// PinLockConfig 死欄退場（t_7710c766）：型別面真齒＝excess-property 探針（round 1 審查 MINOR-3：
-// 舊形 typeof cfg==='object' 恆真空轉）。r2 MINOR-2 實測校正（t_580f9c54；行號帳由 P12 毒化 tsc 輸出承載
-// 而非註解寫死——新增段推移行號＝註解行號帳漂移，NIT-a 同病禁再犯）：required 復活形＝TS2741（PINLOCK
+// PinLockConfig 死欄退場：型別面真齒＝excess-property 探針（
+// 舊形 typeof cfg==='object' 恆真空轉——實測校正；行號帳由毒化 tsc 輸出承載
+// 而非註解寫死——新增段推移行號＝註解行號帳漂移）：required 復活形＝TS2741（PINLOCK
 // 常數面）＋TS2345（未配置兩案），optional 復活形＝舊形探針未帶該欄＝excess-property 檢照不到＝tsc 0 綠——robust 形＝pristine 就在探針字面量帶 `noteKeyExtractable:
 // undefined as never`＋前置 @ts-expect-error：欄位復活任何形（required/optional/false 字面量）都多出待位錯誤＝TS2578 紅；
 // pristine 態錯誤恰由 expect-error 吸收＝全 repo tsc 0 綠（探針字面量缺 false 形欄不另生錯＝零加值面除名）。
@@ -972,7 +992,7 @@ await A('index barrel 匯出 clearLocalWrap/buildBindPayload', await (async () =
 // @ts-expect-error — 死欄退場待位錯誤面（pristine 恰此一待位錯由本指令吸收；欄位復活任何形＝本指令反噬 TS2578＝P12 案紅）
 const _cfgProbe: PinLockConfig = { pinLock: 'jr1p.', pinLockSaltPrefix: 'p:', pinLockAad: 'notekey-pinlock', noteKeyExtractable: undefined as never };
 void _cfgProbe;
-// 壞 b64 面向量（openNoteKey 誠實契約「任何不符恆回 null 不拋」的可觀察承載——round 1 MINOR-5）：
+// 壞 b64 面向量（openNoteKey 誠實契約「任何不符恆回 null 不拋」的可觀察承載）：
 await A('鍛造壞 base64 面字符 → unwrapNoteKey null（openNoteKey unb64 拋點吞收＝不拋契約；家族面毒化形＝頂層 crash，本面包 try/catch 收乾淨 ✗）', await (async () => {
   try {
     return (await unwrapNoteKey(TACET, 'jr1w.' + '!!not-base64!!', pass, salt)) === null;
@@ -983,13 +1003,13 @@ await A('openNoteKey 直接呼叫：壞 base64 → null 不拋（本體吞收點
   return (await openNoteKey('jr1w.' + '!!not-base64!!', kekC, 'notekey', 'jr1w.')) === null;
 })());
 
-// ── 14. 效能形契約（卡C t_7361b68c：零行為變更——輸出 byte 等價是合約；錨面咬「形」） ──
+// ── 14. 效能形契約（零行為變更——輸出 byte 等價是合約；錨面咬「形」） ──
 //
 // 效能批的閘承載物理：執行時間不能進閘（機器相依）——咬「並行形在場＋串行殘留歸零」
 // 靜態錨＋「Argon 串行刻意保留」負向＋b64 輸出等價行為面＋Max-Age/sideEffects 字面＋
 // ikm 組裝序行為向量（KAT14 凍結 blob）。執行帳（node 26.8.1 實測，2026-10-04）：
 // buildBindPayload 串行 133-152ms→並行 68-84ms；dual 串行 234→並行 179ms median；
-// b64 4MiB 132-181ms→18ms。瀏覽器帳=review 222ms→27ms。
+// b64 4MiB 132-181ms→18ms。瀏覽器實測 222ms→27ms。
 
 console.log('\n[14] 效能形契約（buildBindPayload 並行／b64 分塊／argon 禁並行／CORS Max-Age／sideEffects）');
 
@@ -998,23 +1018,23 @@ const argon2Src14 = await srcOf('../src/client/argon2.ts');
 const corsSrc14 = await srcOf('../src/server/cors.ts');
 await A('[14] buildBindPayload 兩段共用 Promise.all 並行錨（wrapNoteKey＋wrapNoteKeyWithRecToken）',
   /await Promise\.all\(\[\r?\n\s*wrapNoteKey\(cfg, noteKey, passphrase\),\r?\n\s*wrapNoteKeyWithRecToken\(cfg, noteKey, recToken, identity\)/.test(noteCryptoSrc14));
-await A('[14] deriveKek2 pass/pin 兩段 PBKDF2 共用 Promise.all 並行錨（RHS 指令序面）',
+await A('[14] deriveKek2 輸入順序錨（pass 段 raw 收口形＋Promise.all 相鄰形——O2 毒形即本錨翻面）',
   /await Promise\.all\(\[\r?\n\s*derivePbkdf2Bits\(passphrase, salt1, PBKDF2_ITERATIONS\),\r?\n\s*derivePbkdf2Bits\(pin,/.test(noteCryptoSrc14));
 await A('[14] deriveKek2Argon 正向串行錨（pass/pin 兩段 deriveArgon2id 串行在場）',
   /const passBits = await deriveArgon2id\(/.test(argon2Src14) && /const pinBits = await deriveArgon2id\(/.test(argon2Src14));
-await A('[14] argon2 destructure 並行形歸零（舊串行面對稱收口——r2 MAJOR-1 防逆向回歸）',
+await A('[14] argon2 destructure 並行形歸零（舊串行面對稱收口——防逆向回歸）',
   argon2Src14.split('const [passBits, pinBits] = await Promise.all([').length === 1);
 await A('[14] buildBindPayload 舊串行形歸零（await wrapNoteKeyWithRecToken 串行殘留）',
   !noteCryptoSrc14.includes('await wrapNoteKeyWithRecToken'));
 await A('[14] deriveKek2 舊串行形歸零（串行 passBits 殘留）',
   !/const passBits = await derivePbkdf2Bits/.test(noteCryptoSrc14));
-// r2 MAJOR-1：並行錨升左手側——destructure 與 Promise.all 相鄰形恰一，對調滑接（pin‖pass）
+// 並行錨升左手側——destructure 與 Promise.all 相鄰形恰一，對調滑接（pin‖pass）
 // 即 RED（RHS 指令序不變＝原本體並行錨不動，兩錨分工：RHS 面／組件序面）。
 await A('[14] deriveKek2 destructure 左手側恰一（const [passBits, pinBits] ＋ Promise.all 相鄰形——swap 滑接即 RED）',
   noteCryptoSrc14.split('const [passBits, pinBits] = await Promise.all([').length === 2);
-// MAJOR-1 行為面：bea6ab8 逐值凍結 jr2w. blob（手工 pristine 組裝＝passBits@0‖pinBits@32 序）——
-// destructure 對調滑接產 pin‖pass ikm＝本 blob 不可解（reviewer rev-harm 雙向一手：pristine 自解
-// true／互解 null；r2 樹 A/C/B/D/E/F 六腿同帳，探針存證 kanban 工作區）。凍結定值自足：
+// 行為面：逐值凍結 jr2w. blob（手工 pristine 組裝＝passBits@0‖pinBits@32 序）——
+// destructure 對調滑接產 pin‖pass ikm＝本 blob 不可解（pristine 自解
+// true／互解 null 雙向一手實證）。凍結定值自足：
 // salt1 'a1'×16／pinSalt 0xb2+i×16／iv 0x44+i×12／raw 'c3'×32／pass/pin 明寫——重放＝按定值
 // 重建 KEK2（HKDF info 'journal-kek2-v1:jr2w.'、aad 'notekey2'）比對 unwrap=raw。
 const KAT14 = {
@@ -1022,9 +1042,9 @@ const KAT14 = {
   salt1: 'a1'.repeat(16),
   pass: 'correct-horse-battery-staple-42',
   pin: '482913',
-  raw: 'c3'.repeat(32), // 計算式構造（手打對數面禁止——r2 首跑 1 FAIL 即手打 raw 對數錯的實證）
+  raw: 'c3'.repeat(32), // 計算式構造（手打對數面禁止——首跑 1 FAIL 即手打 raw 對數錯的實證）
 };
-await A('[14] jr2w. ikm 組裝序行為向量（bea6ab8 凍結 blob unwrap=raw——destructure 對調滑接不可解）',
+await A('[14] jr2w. ikm 組裝序行為向量（凍結 blob unwrap=raw——destructure 對調滑接不可解）',
   (async () => {
     const k = await unwrapNoteKeyDual(TACET2, KAT14.blob, KAT14.pass, KAT14.pin, KAT14.salt1);
     if (k === null) return false;
@@ -1085,7 +1105,7 @@ await A('[14] corsResponse 仍完整轉發四頭（corsResponse 面帶 Max-Age
   }).process?.getBuiltinModule?.('node:fs');
   const pkg14 = JSON.parse(fsPkg14!.readFileSync!(new URL('../package.json', import.meta.url).pathname, 'utf8')) as { sideEffects?: boolean; version: string };
   await A('[14] package.json sideEffects:false（tree-shake server 模組＋BIP39 詞表）', pkg14.sideEffects === false);
-  // sideEffects 前提（round 2 MINOR-1 升級）：src 標目 **遞迴** 枚舉（硬編碼清單退場——新模組
+  // sideEffects 前提：src 標目 **遞迴** 枚舉（硬編碼清單退場——新模組
   // 自動入掃），頂層語句白名單化＋**宣告行初始化式呼叫面檢查**（const x = fn() 形＝執行點；
   // Object.freeze(...)/純常數結構白名單——wordlist.ts:7 即此形）。
   await A('[14] sideEffects 前提：src 頂層零副作用語句＋宣告行初始化式零裸呼叫（Object.freeze 白名單）',
@@ -1112,7 +1132,7 @@ await A('[14] corsResponse 仍完整轉發四頭（corsResponse 面帶 Max-Age
             // 頂層語句白名單：import/export＋註解＋純宣告（const/let/var/function/async/
             // interface/type/enum/class/declare）——其餘字母開頭頂層＝執行面 side effect。
             if (/^(import\b|export\b|\/\*\*|\*|\/\/|const\b|let\b|var\b|function\b|async\b|interface\b|type\b|enum\b|class\b|declare\b)/.test(line)) {
-              // 宣告行初始化面：const x = <呼叫形>()＝模組載入即執行（NIT MINOR-1 缺口）。
+              // 宣告行初始化面：const x = <呼叫形>()＝模組載入即執行（缺口面）。
               // 白名單：Object.freeze（純凍結常數）。其餘呼叫形初始化＝offender。
               if (/^(const\b|let\b|var\b|export const\b).*=.*\b[A-Za-z_$][\w$]*\(\s*[^)]/.test(line) &&
                   !/Object\.freeze\(/.test(line)) offenders++;
@@ -1124,11 +1144,1119 @@ await A('[14] corsResponse 仍完整轉發四頭（corsResponse 面帶 Max-Age
     })());
 }
 
+// ── 15. 密語正規化 v3 世代（normalizePassphrase＋jr4w./jr4d.＋PH1 v3） ──
+//
+// 帶內版本化母型實例：密語 KEK 輸入契約改變（raw → normalizePassphrase NFKC-only）＝新前綴。
+// 命名兩軸分離：「v3 家族」＝PH1 規格代（derivePh1ArgonV3）；前綴數字軸 jr4w./jr4d.
+// ＝KDF 世代代（jr1w→jr2w→jr3w→jr4w，README 家族表對照）。舊家族（jr1w./jr2w./jr3w./jr3d.）
+// 函式體零改＝raw 契約永久不變——本節同字面雙家族對照向量（ＰＡＳＳ１２x／PASS12x）就是
+// 「免換前綴合約證明」的承載面：同組字串在舊家族恆異 KEK（raw 直派生）、在 v3 家族恆同 KEK（NFKC 收容）。
+
+console.log('\n[15] 密語正規化 v3 世代（normalizePassphrase／jr4w.／jr4d.／PH1 v3）');
+
+const noteCryptoSrc15 = await srcOf('../src/client/note-crypto.ts');
+const argon2Src15 = await srcOf('../src/client/argon2.ts');
+const TACET4: Argon3Config = { wrap4: 'jr4w.', wrapDual4: 'jr4d.', pinSalt3Prefix: 'tacet-note-pin3:' };
+const pass4 = 'v3-generation-passphrase-42';
+const passD4 = 'ｄｕａｌ－ｆａｃｔｏｒ－ｐａｓｓｐｈｒａｓｅ－４２'; // NFKC → passD 的全形形
+const passD4_NFKC = normalizePassphrase(passD4); // 與 passD 恆等（NFKC 收容）——P2 毒化翻面本體（毒形即收口形計數錨翻＋毒翻 = NFKC-effective 帳面翻，雙承載）
+
+// 函式契約面（單一真相本體：normalizePassphrase 與 normalizePin 並存不混）
+await A('normalizePassphrase NFKC 契約：全形收容（ｐａｓｓ=pass）', normalizePassphrase('ｐａｓｓ') === 'pass');
+await A('normalizePassphrase NFKC 契約：結合序列合成（カ+U+3099=ガ——NFD/NFC 裝置差收容）',
+  normalizePassphrase('カ\u3099x') === 'ガx');
+await A('normalizePassphrase 分離向量一：不 trim（首尾空白保留）', normalizePassphrase(' pass ') === ' pass ');
+await A('normalizePassphrase 分離向量二：大小寫恆異（大小寫摺疊禁絕——大小寫差＝不同 KEK/ph2）',
+  normalizePassphrase('PaSs') === 'PaSs' && normalizePassphrase('PaSs') !== normalizePassphrase('pass') && normalizePassphrase('PaSs') !== normalizePassphrase('PASS'));
+await A('normalizePassphrase 與 normalizePin 契約並存不混（同輸入兩形＝兩輸出）',
+  normalizePin(' Ｐｉｎ42 ') === 'pin42' && normalizePassphrase(' Ｐｉｎ42 ') === ' Pin42 ');
+
+// jr4w. 單因子（v3 密語）roundtrip
+const w4 = await wrapNoteKey4(TACET4, noteKey, pass4);
+await A('wrapped 前綴 jr4w.', w4.wrapped.startsWith('jr4w.'));
+await A('jr4w salt = 16B hex', /^[0-9a-f]{32}$/.test(w4.salt));
+const unwrapped4 = await unwrapNoteKey4(TACET4, w4.wrapped, pass4, w4.salt);
+await A('jr4w unwrap 等值 noteKey（extractable 再 export）',
+  unwrapped4 !== null && hex(new Uint8Array(await crypto.subtle.exportKey('raw', unwrapped4))) === origRaw);
+await A('jr4w 正規化等價：ASCII wrap → 全形 unwrap（unwrap 入口 NFKC 承載）', (await unwrapNoteKey4(TACET4, w4.wrapped, 'ｖ３－ｇｅｎｅｒａｔｉｏｎ－ｐａｓｓｐｈｒａｓｅ－４２', w4.salt)) !== null);
+const w4Nfd = await wrapNoteKey4(TACET4, noteKey, 'カ\u3099ｘｙ');
+await A('jr4w NFKC 等價：NFD 形 wrap → NFC 形 unwrap', (await unwrapNoteKey4(TACET4, w4Nfd.wrapped, 'ガxy', w4Nfd.salt)) !== null);
+const w4Case = await wrapNoteKey4(TACET4, noteKey, 'V3-Generation-Pass-42');
+await A('jr4w raw 大小寫不折疊（v3 契約只收容寫法差，不收大小寫差）',
+  (await unwrapNoteKey4(TACET4, w4Case.wrapped, 'v3-generation-pass-42', w4Case.salt)) === null);
+const w4Sp = await wrapNoteKey4(TACET4, noteKey, ' spaced pass ');
+await A('jr4w raw 首尾空白為不同密語（不 trim 契約家族面）',
+  (await unwrapNoteKey4(TACET4, w4Sp.wrapped, 'spaced pass', w4Sp.salt)) === null);
+await A('jr4w 錯 pass → null', (await unwrapNoteKey4(TACET4, w4.wrapped, 'wrong-passphrase', w4.salt)) === null);
+await A('jr4w 錯 salt → null', (await unwrapNoteKey4(TACET4, w4.wrapped, pass4, 'ab'.repeat(16))) === null);
+
+// jr4d. 雙因子（v3 密語＋PIN 照舊）——wrap 端吃全形（NFKC 載體），unwrap 端兩向都咬
+const dual4 = await wrapNoteKeyDual4(TACET4, noteKey, passD4, pinD); // 全形 wrap＝NFKC 載體（cp1=0xFF44——ASCII 化即本面 RED）
+await A('dual4 前綴 jr4d.', dual4.wrapped.startsWith('jr4d.'));
+await A('dual4 salt1 = 16B hex', /^[0-9a-f]{32}$/.test(dual4.salt));
+const unwrappedD4 = await unwrapNoteKeyDual4(TACET4, dual4.wrapped, passD, pinD, dual4.salt);
+const dual4NfkEq = unwrappedD4 !== null
+  && hex(new Uint8Array(await crypto.subtle.exportKey('raw', unwrappedD4))) === origRaw; // 全形 wrap → NFKC 形：unwrap 真救回（null 恆 false＝normalize 摘除不可藏）
+await A('dual4 unwrap 等值 noteKey（extractable 再 export；全形 wrap 面 NFKC 等價自證——not-null 恆 false 恆真盲區免疫）', dual4NfkEq);
+const dual4a = await wrapNoteKeyDual4(TACET4, noteKey, passD, pinD); // ASCII NFKC 慣用形 wrap（passD＝passD4 的 NFKC 位——上式自證）
+const dual4NfkRev = dual4a !== null && (await unwrapNoteKeyDual4(TACET4, dual4a.wrapped, passD4, pinD, dual4a.salt)) !== null; // ASCII 包 → 全形解（修真向：feed passD4；無 NFKC 即 null）
+await A('dual4 pass 段 NFKC 反向等價（ASCII wrap → 全形 unwrap；PIN 段契約不動）', dual4NfkRev === true);
+await A('dual4 PIN 大小寫不敏感（normalizePin 契約 v3 世代照舊）', (await unwrapNoteKeyDual4(TACET4, dual4.wrapped, passD, '2580AB', dual4.salt)) !== null);
+await A('dual4 PIN 全形 NFKC 等價', (await unwrapNoteKeyDual4(TACET4, dual4.wrapped, passD, '２５８０ＡＢ', dual4.salt)) !== null);
+await A('dual4 錯 PIN → null', (await unwrapNoteKeyDual4(TACET4, dual4.wrapped, passD, '999999', dual4.salt)) === null);
+await A('dual4 空 PIN → null（unwrap 面）', (await unwrapNoteKeyDual4(TACET4, dual4.wrapped, passD, '', dual4.salt)) === null);
+await A('wrapNoteKeyDual4 空 PIN → ERR_PIN_EMPTY（非 NOT_CONFIGURED——分流語意 v3 世代照舊）', await (async () => {
+  try { await wrapNoteKeyDual4(TACET4, noteKey, passD, ''); return false; } catch (e) { return (e as Error).message === 'ERR_PIN_EMPTY'; }
+})());
+await A('dual4 payload 嚴格 108B（截短 → null——鹽內嵌族 own 檢查在場）', await (async () => {
+  try {
+    const short = new Uint8Array(107);
+    crypto.getRandomValues(short);
+    let bin = '';
+    for (let i = 0; i < short.byteLength; i++) bin += String.fromCharCode(short[i]);
+    return (await unwrapNoteKeyDual4(TACET4, 'jr4d.' + btoa(bin), passD, pinD, dual4.salt)) === null;
+  } catch { return false; }
+})());
+await A('dual4 pass 段大小寫與空白恆異（不摺疊不 trim——v3 契約 unwrap 側真行為面）',
+  (await unwrapNoteKeyDual4(TACET4, dual4.wrapped, 'DUAL-FACTOR-PASSPHRASE-42', pinD, dual4.salt)) === null
+  && (await unwrapNoteKeyDual4(TACET4, dual4.wrapped, passD + ' ', pinD, dual4.salt)) === null);
+await A('jr4d unwrap 配置面 {wrapDual4 有、pinSalt3Prefix 無} → null（家族守衛雙腿各自承載）',
+  (await unwrapNoteKeyDual4({ wrapDual4: 'jr4d.' }, dual4.wrapped, passD, pinD, dual4.salt)) === null);
+
+// 同字面兩家族對照（帶內版本化本質向量）：ＰＡＳＳ１２x／PASS12x
+const fwPass15 = 'ＰＡＳＳ１２x';
+const asciiPass15 = 'PASS12x';
+await A('[15] NFKC 契約向量（fwPass15 ＝ asciiPass15 的 NFKC-effective 全形——self-proving 錨：字面漂移即本面 RED）',
+  normalizePassphrase(fwPass15) === asciiPass15);
+const w4fw = await wrapNoteKey4(TACET4, noteKey, fwPass15);
+await A('jr4w 全形/ASCII 同密語（NFKC 收容）', (await unwrapNoteKey4(TACET4, w4fw.wrapped, asciiPass15, w4fw.salt)) !== null);
+const w3fw = await wrapNoteKey3(TACET3, noteKey, fwPass15); // 舊家族 raw 對照組（同字面）
+await A('jr3w 全形 wrap 照解（舊家族 raw 契約——全形字面恆可解）', (await unwrapNoteKey3(TACET3, w3fw.wrapped, fwPass15, w3fw.salt)) !== null);
+await A('jr3w 拒收 normalized 慣用形（舊家族零正規化——帶內版本化「契約面永不變」承載）', (await unwrapNoteKey3(TACET3, w3fw.wrapped, asciiPass15, w3fw.salt)) === null);
+await A('jr4w unwrap 拒收 jr3w 字串（家族隔離；wrap3 未配置面）', (await unwrapNoteKey4(TACET4, w3.wrapped, pass, w3.salt)) === null);
+await A('jr3w unwrap 拒收 jr4w 字串（家族隔離——wrap3 在場、payload 前綴不符恆 null）',
+  (await unwrapNoteKey3(TACET3, w4.wrapped, pass4, w4.salt)) === null);
+await A('jr3d payload 餵 jr4d 路徑 → null（家族隔離）', (await unwrapNoteKeyDual4(TACET4, dual3.wrapped, passD, pinD, dual3.salt)) === null);
+await A('jr4d payload 餵 jr3d 路徑 → null（家族隔離）', (await unwrapNoteKeyDual3(TACET3, dual4.wrapped, passD, pinD, dual4.salt)) === null);
+
+// 跨前綴隔離：jr4w.↔jr1w. 双向（PBKDF2 族面——鹽外置同構家族跨世代隔離；jr3↔jr4 面在下方 jr3d/jr4d 兩案）
+await A('jr4w unwrap 拒收 jr1w 字串（家族隔離——raw 世代 payload 餵 v3 路徑）',
+  (await unwrapNoteKey4(TACET4, wrapped, pass, salt)) === null);
+await A('jr1w unwrapNoteKey 拒收 jr4w 字串（家族隔離——v3 payload 餵 raw 世代路徑）',
+  (await unwrapNoteKey(TACET2, w4.wrapped, pass4, w4.salt)) === null);
+
+// 舊家族凍結向量（PBKDF2 族面）：jr1w./jr2w. 契約面永不變——全形字面 raw 恆解、normalized 慣用形恆拒
+//（帶內版本化承載與 jr3w. 對照組同構；jr3 面雙案在上方 fwPass15 三案）
+const old1fw = await wrapNoteKey(TACET, noteKey, fwPass15);
+await A('jr1w 凍結（raw 契約）：全形 wrap 照解（raw 字面恆可解）',
+  (await unwrapNoteKey(TACET, old1fw.wrapped, fwPass15, old1fw.salt)) !== null);
+await A('jr1w 凍結：normalized 慣用形解 → null（不隨 v3 正規化——帶內版本化）',
+  (await unwrapNoteKey(TACET, old1fw.wrapped, asciiPass15, old1fw.salt)) === null);
+const old2fw = await wrapNoteKeyDual(TACET2, noteKey, fwPass15, pinD);
+await A('jr2w 凍結（pass 段 raw 契約）：normalized 解 → null（pin 段 normalizePin 契約不動）',
+  (await unwrapNoteKeyDual(TACET2, old2fw.wrapped, asciiPass15, pinD, old2fw.salt)) === null);
+await A('jr2w 凍結：全形 wrap 照解（raw 字面恆可解）',
+  (await unwrapNoteKeyDual(TACET2, old2fw.wrapped, fwPass15, pinD, old2fw.salt)) !== null);
+// 未配置拒絕（opt-in 鐵律 v3 世代照舊）
+await A('未配置 wrap4 → wrapNoteKey4 拒絕', await (async () => { try { await wrapNoteKey4({}, noteKey, pass4); return false; } catch (e) { return (e as Error).message === 'ERR_JR4W_NOT_CONFIGURED'; } })());
+await A('未配置 wrapDual4 → wrapNoteKeyDual4 拒絕（ERR_JR4D_NOT_CONFIGURED——錯誤碼語意分離）', await (async () => { try { await wrapNoteKeyDual4({}, noteKey, passD, pinD); return false; } catch (e) { return (e as Error).message === 'ERR_JR4D_NOT_CONFIGURED'; } })());
+await A('未配置 wrap4 → unwrap 拒收 jr4w', (await unwrapNoteKey4({ wrapDual4: 'jr4d.' }, w4.wrapped, pass4, w4.salt)) === null);
+
+// PH1 v3（normalizePassphrase 派生＋新鹽域）
+const ph1v3a = await derivePh1ArgonV3('probe-v3-pass-42');
+await A('ph1v3 確定性（同 pass 兩跑逐位元同）', ph1v3a === (await derivePh1ArgonV3('probe-v3-pass-42')));
+await A('ph1v3 hex64 形', /^[0-9a-f]{64}$/.test(ph1v3a));
+await A('ph1v3 NFKC 等價（全形=NFKC 形同 ph2——PH2 UNIQUE 契約面）', (await derivePh1ArgonV3('ｐｒｏｂｅ－ｖ３－ｐａｓｓ－４２')) === ph1v3a);
+await A('ph1v3 大小寫恆異（不分大小寫＝不同 ph2）', (await derivePh1ArgonV3('PROBE-V3-PASS-42')) !== ph1v3a);
+await A('ph1v3 空白恆異（不 trim＝不同 ph2）', (await derivePh1ArgonV3(' probe-v3-pass-42 ')) !== ph1v3a);
+await A('ph1v3 ≠ v2 形（同字面不同值——鹽域世代分離）', ph1v3a !== (await derivePh1Argon('probe-v3-pass-42')));
+await A('PH1_V3_SALT = "tacet-ph1-v2"（鹽域值代沿 PH1_V2_SALT 先例；與 v2 鹽域及包裹鹽前綴零重疊）',
+  PH1_V3_SALT === 'tacet-ph1-v2' && (PH1_V3_SALT as string) !== PH1_V2_SALT && !PH1_V3_SALT.startsWith('tacet-note') && !PH1_V3_SALT.startsWith('tacet-pinlock'));
+await A('derivePh1ArgonV3 預設分支源碼面 = encode(PH1_V3_SALT)（鹽預設單一真相錨；同 v2 母型）',
+  /saltArg \?\? new TextEncoder\(\)\.encode\(PH1_V3_SALT\)/.test(argon2Src15));
+await A('derivePh1ArgonV3 自選鹽 → 不同派生值（saltArg 慣例）',
+  (await derivePh1ArgonV3('probe-v3-pass-42', new Uint8Array(12))) !== ph1v3a);
+await A('derivePh1Argon v2 預設零動（raw 契約——舊世代派生面零變更）', (await derivePh1Argon('probe-determinism-pass-42')) === ph1v2a);
+
+// 源碼結構面（帶內版本化「舊家族零改」的錨）
+await A('[15] normalizePassphrase 本體＝單行 NFKC（三面單一真相——函式體禁夾帶 trim/toLowerCase）',
+  /export function normalizePassphrase\(passphrase: string\): string \{\r?\n  return passphrase\.normalize\('NFKC'\);\r?\n\}/.test(noteCryptoSrc15));
+await A('[15] 舊家族 KEK 派生 raw 面守衛（deriveKekArgon(passphrase 恰 2＝jr3w wrap/unwrap；deriveInput 形恰 2＝jr4w 兩面）',
+  argon2Src15.split('deriveKekArgon(passphrase, salt)').length === 3
+  && argon2Src15.split('deriveKekArgon(deriveInput(passphrase)').length === 3);
+await A('[15] deriveKek2Argon 零改（共用派生本體不吃 normalize——kekk2Argon 簽名與 body 兩錨在場）',
+  /async function deriveKek2Argon\(/.test(argon2Src15) && /const passBits = await deriveArgon2id\(passphrase,/.test(argon2Src15));
+await A('[15] jr4w/jr4d 入口 normalize 走 deriveInput 收口（兩面恰 2——normalize 形歸零非旁路；正規化禁進共用本體）',
+  argon2Src15.split('deriveKek2Argon(cfg, deriveInput(passphrase)').length === 3
+  && argon2Src15.split('deriveKekArgon(deriveInput(passphrase)').length === 3
+  && argon2Src15.split('deriveArgon2id(\n    deriveInput(passphrase)').length === 2
+  && !argon2Src15.includes('deriveKekArgon(normalizePassphrase(passphrase'));
+await A('[15] deriveKek2Argon HKDF info 參數化（jr3d/jr4d 域由呼叫端帶入——本體 hardcoded info 域殘留=0）',
+  /hkdfInfo: string,/.test(argon2Src15)
+  && argon2Src15.split("deriveKek2Argon(cfg, passphrase, pinNorm, salt1, pinSalt, 'journal-kek2-v1:' + cfg.wrapDual3)").length === 3
+  && argon2Src15.split("deriveKek2Argon(cfg, deriveInput(passphrase), pinNorm, salt1, pinSalt, 'journal-kek2-v1:' + cfg.wrapDual4)").length === 3
+  && !argon2Src15.includes("encode('journal-kek2-v1:' + cfg.wrapDual3)"));
+
+// barrel 匯出面
+await A('index barrel 匯出 v3 世代七識別字（normalizePassphrase／jr4 家族四／derivePh1ArgonV3／PH1_V3_SALT）', await (async () => {
+  const src = await import('../src/index.ts');
+  return typeof src.normalizePassphrase === 'function' && typeof src.wrapNoteKey4 === 'function'
+    && typeof src.unwrapNoteKey4 === 'function' && typeof src.wrapNoteKeyDual4 === 'function'
+    && typeof src.unwrapNoteKeyDual4 === 'function' && typeof src.derivePh1ArgonV3 === 'function'
+    && src.PH1_V3_SALT === 'tacet-ph1-v2';
+})());
+
 // ── 決議 ────────────────────────────────────────────────────────────────────
 
+// ── 16. 常駐毒化矩陣（自帶——對真模組行為斷言的毒化證據隨每執行重建） ──
+//
+// 母型（閘常駐毒化面）：對 /tmp 拷貝樹做突變後重跑同一組行為斷言——
+// 「毒化態恰翻面」meta 斷言承載外部 poison runner 的證據；毒化跑在拷貝樹＝本 repo 樹零接觸。
+// 期望值每毒型真跑實測（/tmp 拷貝樹一手實測，見各案歸屬帳）；還原面由
+// /tmp 樹的出生即棄承載（本 repo 樹 byte 不動）。每案還原後重跑回綠（還原正確性的行為帳）。
+//
+// 案期望值（修正後程式碼上 /tmp 毒化重測，本 run 一手帳——還原後重跑回綠帶）：
+//   P1 摘 jr4w unwrap 入口 normalize → nfail=4 帳（正規化等價面＋KAT 慣用形帳面＋兩 [15] 錨跟隨）
+//   P2 本體夾帶 lowercase → nfail=11 帳（NFKC-effective 帳面翻面集；P3/P4/P5 針毒形零匹配＝全格向量化）
+//   P3 摘 derivePh1ArgonV3 入口 normalize → nfail=2 帳（ph1v3 NFKC 等價面＋[15] 收口形錨）
+//   P4 摘 jr4w wrap 入口 normalize → nfail=4 帳（NFD 收容面＋全形/ASCII 同密語面＋兩 [15] 錨）
+//   P5 摘 jr4d wrap 入口 normalize → nfail=5 帳（dual4 等值面＋PIN 兩面＋兩 [15] 錨）
+//   O1 jr3w.wrap 入口接 normalize（禁手）→ nfail=4 帳（jr3w 凍結兩面＋兩 [15] 錨）
+//   O2 deriveKek2 pass 段接 normalize（禁手）→ nfail=2 帳（[14] 輸入順序錨＋jr2w 凍結 normalized 面）
+//   O3 normalizePin 摘 trim/lowercase → nfail=9 帳（>=帽——韌性；PIN 契約毒化真 RED）
+//   O4 摘 jr4d unwrap 入口 normalize（反拉禁手）→ nfail=4 帳（NFKC 反向等價面＋KAT 慣用形帳面＋兩 [15] 錨）
+//   O1-src/O2-src/O4-src 源碼計數錨（[15] 同形複寫——防單點誤删）：
+//   v3 家族入口 normalize 收口形恰 3×3＋PBKDF2 raw 恰 1——毒化形即計數變異，本 repo 樹直接斷言。
+// 每案結束後還原／清樹（出生即棄）；designated 面帳寫在案例名內。
+
+console.log('\n[16] 常駐毒化矩陣（v3 家族語意毒＋舊家族不變毒）');
+{
+  const getBuiltin = (id: string): unknown =>
+    (globalThis as unknown as { process?: { getBuiltinModule?: (i: string) => unknown } }).process?.getBuiltinModule?.(id);
+  const cpMod = getBuiltin('node:child_process') as { execFileSync?: (cmd: string, args: string[], opts: { cwd: string; encoding: string; stdio: unknown[]; env?: Record<string, string>; timeout?: number }) => string } | undefined;
+  const osMod = getBuiltin('node:os') as { tmpdir?: () => string } | undefined;
+  const nodeEnvOk = !!cpMod?.execFileSync && !!osMod?.tmpdir && typeof (globalThis as unknown as { process?: { getBuiltinModule?: unknown } }).process?.getBuiltinModule === 'function';
+  const processMod = (globalThis as unknown as { process?: { env?: Record<string, string | undefined> } }).process;
+  const inner16 = processMod?.env?.POISON_GATE_INNER === '1';
+  if (!nodeEnvOk || inner16) {
+    await A('[16] 毒化矩陣載體就緒（node 內建模組在場；內層遞迴由 sentinel 跳過＝正常；缺席＝顯性 FAIL）', inner16, 'env unavailable AND not inner');
+  } else {
+    const exec16 = cpMod!.execFileSync!;
+    const path16 = {
+      join: (...parts: string[]): string => parts.join('/').replace(/\/{2,}/g, '/'),
+      resolve: (...parts: string[]): string => parts.join('/').replace(/\/\.(?=\/|$)/g, '').replace(/\/{2,}/g, '/'),
+    };
+    const fs16 = getBuiltin('node:fs') as {
+      rmSync?: (p: string, o?: { recursive: boolean; force: boolean }) => void;
+      cpSync?: (a: string, b: string, o?: { recursive: boolean; dereference?: boolean; filter?: (src: string) => boolean }) => void;
+      readFileSync?: (p: string, e?: string) => string;
+      writeFileSync?: (p: string, c: string, e?: string) => void;
+      mkdtempSync?: (p: string) => string;
+      existsSync?: (p: string) => boolean;
+    } | undefined;
+    if (!fs16?.mkdtempSync || !fs16.cpSync || !fs16.readFileSync || !fs16.writeFileSync) {
+      await A('[16] node:fs 原語在場（mkdtemp/cp/read/write）', false);
+    } else {
+      const treePaths16: string[] = []; // 殘留判準只看本 run 喚出的 tree16 路徑（跨執行/跨 host 零耦合）
+      const tmpdir16 = osMod!.tmpdir!();
+      const coreNM = path16.resolve(new URL('.', import.meta.url).pathname, '../node_modules');
+      const repoRoot16 = path16.resolve(new URL('.', import.meta.url).pathname, '..'); // repo root 錨定（禁 cwd 依賴——自 repo 外呼叫 cp 樹也恆真）
+      const gitIgnoreSkip = (src: string): boolean => src === '.git' || src.endsWith('/.git') || src.includes('/.git/') || src === 'node_modules' || src.endsWith('/node_modules') || src.includes('/node_modules/');
+      let tree16 = '';
+      const mkTree = (): void => {
+        fs16!.rmSync!(tree16, { recursive: true, force: true });
+        tree16 = fs16!.mkdtempSync!(path16.join(tmpdir16, 'core-poison-'));
+        treePaths16.push(tree16); // 本 run 喚出記帳（收尾殘留判準的封閉集）
+        fs16!.cpSync!(repoRoot16, tree16, { recursive: true, filter: (src: string) => !gitIgnoreSkip(src) }); // 零 .git/零 node_modules 實拷（repo root 錨定——非 cwd；CI 冷複製成本歸零——毒化樹 node_modules 走下方 symlink）
+        fs16!.rmSync!(path16.join(tree16, 'node_modules'), { recursive: true, force: true });
+        // node_modules 走 symlink（worktree 慣例 cp 語意不跟隨）：本閘執行樹一定有 node_modules
+        //（@scure 對照組＋typescript）——毒化樹補 symlink 即可；缺席環境（bare npm ci 後無 install）
+        // 本閘自己在主樹就跑不起來，不是毒化矩陣的責任面。
+        exec16('ln', ['-s', nodeEnvOk ? coreNM : '', path16.join(tree16, 'node_modules')], { cwd: tree16, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+      };
+      const runGate16 = (): { rc: number; out: string } => {
+        // 內層 gate 執行帶 POISON_GATE_INNER=1 sentinel——[16] 矩陣在內層自我跳過＝遞迴防線
+        //（拷貝樹的閘檔含本節全文；無 sentinel 會自拷貝再自跑＝18+ 連鎖行程實證）。
+        try { return { rc: 0, out: exec16('node', ['--experimental-strip-types', 'scripts/verify-core-crypto.ts'], { cwd: tree16, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], env: { ...(processMod?.env ?? {}), POISON_GATE_INNER: '1' }, timeout: 240000 }) }; }
+        catch (e: unknown) {
+          const err = e as { stdout?: string; stderr?: string; status?: number };
+          return { rc: err.status ?? 1, out: (err.stdout ?? '') + (err.stderr ?? '') };
+        }
+      };
+      const poison16 = (rel: string, needle: string, replacement: string): { applied: boolean; restore: () => void } => {
+        const p = path16.join(tree16, rel);
+        const before = fs16!.readFileSync!(p, 'utf8');
+        const cnt = before.split(needle).length - 1;
+        fs16!.writeFileSync!(p, before.split(needle).join(replacement), 'utf8');
+        return { applied: cnt > 0 && !(fs16!.readFileSync!(p, 'utf8').includes(needle)), restore: (): void => fs16!.writeFileSync!(p, before, 'utf8') };
+      };
+      const realFails = (out: string): string[] => out.split('\n').filter((l: string) => l.trimStart().startsWith('✗')).map((l: string) => l.trim());
+      const nfail = (out: string): number => realFails(out).length;
+      mkTree();
+      const pristine = runGate16();
+
+      await A('[16] 基準：拷貝樹 pristine = 全綠（毒化矩陣前提；rc=1 即環境病非本節）', pristine.rc === 0, 'rc=' + pristine.rc + (pristine.rc === 0 ? '' : ' | stderr tail: ' + pristine.out.split('\n').filter((l: string) => l.trim()).slice(-3).join(' ;; ').slice(0, 220)));
+
+      // P1 摘 jr4w unwrap 入口 normalize → 行為翻 4 面帳（本 run 毒化重測：jr4w 正規化等價面＋[15] raw
+      // 守衛錨＋[15] 收口形錨＋[17] jr4w NFKC 慣用形帳面）——名單面 designated＝正規化等價面＋dual4 等值面（案內檢）。
+      {
+        mkTree();
+        const mut = poison16('src/client/argon2.ts',
+          "    const kek = await deriveKekArgon(deriveInput(passphrase), salt);\n    return await openNoteKey(wrapped, kek, 'notekey', cfg.wrap4);",
+          "    const kek = await deriveKekArgon(passphrase, salt);\n    return await openNoteKey(wrapped, kek, 'notekey', cfg.wrap4);");
+        const g = runGate16();
+        // P1 名單面 designated（本 run 重測帳）：jr4w 正規化等價面＋[17] jr4w NFKC 慣用形
+        // 帳面兩面真翻——摘除 unwrap 入口 normalize 時 normalized 形失去收容（dual4 等值面不翻＝wrap 端
+        // normalize 仍承載，P1 針只咬 unwrap 面——P5 已咬 wrap 面；兩針分工面帳）。
+        const p1eqRed = g.out.split('\n').some((l: string) => l.includes('jr4w 正規化等價') && l.trimStart().startsWith('✗'));
+        const p1katRed = g.out.split('\n').some((l: string) => l.includes('NFKC-effective 全形 unwrap = 原始 noteKey（v3 契約收容自己——全形 wrap 的 KAT 慣用形）') && l.trimStart().startsWith('✗'));
+        const red = mut.applied && g.rc === 1 && nfail(g.out) >= 2 && p1eqRed && p1katRed;
+        await A('[16] P1 摘 jr4w unwrap 入口 normalize → 正規化等價面＋KAT 慣用形帳面真翻（nfail=4 帳——非錨影）', red, 'nfail=' + nfail(g.out));
+        mut.restore();
+        const g2 = runGate16();
+        fs16!.rmSync!(tree16, { recursive: true, force: true });
+        await A('[16] P1 還原回綠（出生即棄樹上還原；P2 共樹後不可達案由出生即棄承載）', g2.rc === 0, String(g2.rc));
+      }
+      // P2 本體夾帶 lowercase → NFKC-effective 行為翻面集（重測：nfail=11 帳——非 crash 形）
+      {
+        mkTree();
+        const mut = poison16('src/client/note-crypto.ts',
+          "export function normalizePassphrase(passphrase: string): string {\n  return passphrase.normalize('NFKC');\n}",
+          "export function normalizePassphrase(passphrase: string): string {\n  return passphrase.normalize('NFKC').toLowerCase();\n}");
+        const g = runGate16();
+        // P2 名單面 designated（重測帳）：NFKC-effective 帳面翻面集（分離向量二＋並存不混＋jr4w
+        // raw 大小寫不折疊＋dual4 case/space＋[15] NFKC 契約向量＋ph1v3 大小寫恆異＋[17] 大寫兩形 null 四面＋本體
+        // 單行形錨）＝11 面帳；同 P3/P4/P5 毒形零匹配（全格向量化——毒化矩陣單點真值面）。
+        const p2normRed = g.out.split('\n').some((l: string) => l.includes('分離向量二') && l.trimStart().startsWith('✗'));
+        await A('[16] P2 本體夾帶 lowercase → NFKC-effective 帳面翻面集（nfail>=11 帳＋分離向量二名單面）', mut.applied && g.rc === 1 && nfail(g.out) >= 11 && p2normRed, 'rc=' + g.rc + ' nfail=' + nfail(g.out));
+        fs16!.rmSync!(tree16, { recursive: true, force: true });
+      }
+      // P3 摘 derivePh1ArgonV3 入口 normalize → 行為翻 2 面帳（本 run 毒化重測：ph1v3 NFKC 等價面＋[15] 收口形
+      // 錨跟隨）——名單面 designated＝ph1v3 NFKC 等價面（案內檢）；P3 毒形＝derivePh1Argon v2 名同型不匹配（全格向量化）。
+      {
+        mkTree();
+        const mut = poison16('src/client/argon2.ts',
+          "    deriveInput(passphrase),\n    saltArg ?? new TextEncoder().encode(PH1_V3_SALT),",
+          "    passphrase,\n    saltArg ?? new TextEncoder().encode(PH1_V3_SALT),");
+        const g = runGate16();
+        // P3 名單面 designated：ph1v3 NFKC 等價面（全形 vs ASCII 同 ph2）真翻。
+        const p3red = g.out.split('\n').some((l: string) => l.includes('ph1v3 NFKC 等價') && l.trimStart().startsWith('✗'));
+        await A('[16] P3 摘 derivePh1ArgonV3 入口 normalize → ph1v3 NFKC 等價面真翻（名單級承載）', mut.applied && g.rc === 1 && nfail(g.out) >= 1 && p3red, 'nfail=' + nfail(g.out));
+        fs16!.rmSync!(tree16, { recursive: true, force: true });
+      }
+      // P4 摘 jr4w wrap 入口 normalize → 行為翻 4 面帳（本 run 毒化重測：NFD wrap→NFC unwrap 面＋全形/ASCII 同
+      // 密語面＋[15] raw 守衛錨＋[15] 收口形錨）——名單面 designated＝全形/ASCII 同密語面（案內檢）。
+      {
+        mkTree();
+        const mut = poison16('src/client/argon2.ts',
+          "  const kek = await deriveKekArgon(deriveInput(passphrase), salt);\n  const wrapped = await sealNoteKey(cfg.wrap4, noteKey, kek, 'notekey');",
+          "  const kek = await deriveKekArgon(passphrase, salt);\n  const wrapped = await sealNoteKey(cfg.wrap4, noteKey, kek, 'notekey');");
+        const g = runGate16();
+        // P4 名單面 designated：jr4w 全形/ASCII 同密語面（全形 wrap 的 NFKC 收容）真翻。
+        const p4red = g.out.split('\n').some((l: string) => l.includes('jr4w 全形/ASCII 同密語') && l.trimStart().startsWith('✗'));
+        await A('[16] P4 摘 jr4w wrap 入口 normalize → 全形/ASCII 同密語面真翻（名單級承載）', mut.applied && g.rc === 1 && nfail(g.out) >= 1 && p4red, 'nfail=' + nfail(g.out));
+        fs16!.rmSync!(tree16, { recursive: true, force: true });
+      }
+      // P5 摘 jr4d wrap 入口 normalize → 行為翻 5 面帳（本 run 毒化重測：dual4 等值面＋PIN 兩面＋[15] 收口形
+      // 錨＋[15] HKDF info 錨）——名單面 designated＝dual4 等值面（dual4red 檈）；PIN 兩面翻＝毒化 wrap 端
+      // normalize 摘除的帳面（wrap 端 NFKC-effective 面倒灌 PIN 段）。
+      {
+        mkTree();
+        const mut = poison16('src/client/argon2.ts',
+          "  const kek2 = await deriveKek2Argon(cfg, deriveInput(passphrase), pinNorm, salt1, pinSalt, 'journal-kek2-v1:' + cfg.wrapDual4);\n  const iv = crypto.getRandomValues(new Uint8Array(DUAL_IV_LEN));\n  const ct = new Uint8Array(await crypto.subtle.encrypt(",
+          "  const kek2 = await deriveKek2Argon(cfg, passphrase, pinNorm, salt1, pinSalt, 'journal-kek2-v1:' + cfg.wrapDual4);\n  const iv = crypto.getRandomValues(new Uint8Array(DUAL_IV_LEN));\n  const ct = new Uint8Array(await crypto.subtle.encrypt(");
+        const g = runGate16();
+        const dual4red = g.out.split('\n').some((l: string) => l.includes('dual4 unwrap 等值') && l.trimStart().startsWith('✗'));
+        await A('[16] P5 摘 jr4d wrap 入口 normalize → dual4 self-proving 面翻（帳面 ✗ 計數免疫——✓-line 內嵌 ✗ 標記不入計）', mut.applied && g.rc === 1 && dual4red, 'rc=' + g.rc);
+        fs16!.rmSync!(tree16, { recursive: true, force: true });
+      }
+      // O3 normalizePin 本體摘 trim/lowercase → 行為翻 ≥9 面（外部探針帳實值）
+      {
+        mkTree();
+        const mut = poison16('src/client/note-crypto.ts',
+          '  return pin.normalize(\'NFKC\').trim().toLowerCase();',
+          '  return pin.toLowerCase();');
+        const g = runGate16();
+        await A('[16] O3 normalizePin 本體摘 trim/lowercase → 行為翻 9 面（PIN 契約毒化承載）', mut.applied && g.rc === 1 && nfail(g.out) >= 9, 'nfail=' + nfail(g.out) + ' want >=9');
+        fs16!.rmSync!(tree16, { recursive: true, force: true });
+      }
+      // O2 deriveKek2 pass 段接 normalize（禁手形）→ 真翻面案（名單級承載；本 run 重測帳＝
+      // [14] 輸入順序錨翻＋jr2w 凍結 normalized 面翻，恰 2 面——兩面各自 designated，帳寫在案斷言內）。
+      {
+        mkTree();
+        const mut = poison16('src/client/note-crypto.ts',
+          "  const [passBits, pinBits] = await Promise.all([\n    derivePbkdf2Bits(passphrase, salt1, PBKDF2_ITERATIONS),",
+          "  const [passBits, pinBits] = await Promise.all([\n    derivePbkdf2Bits(normalizePassphrase(passphrase), salt1, PBKDF2_ITERATIONS),");
+        const g = runGate16();
+        // O2 行為翻 2 面帳（本 run 毒化重測）：[14] 輸入順序錨（毒形不匹配 raw 收口形恰-1 形）＋jr2w 凍結
+        // normalized 解翻面（毒化 wrap 也 normalize → ascii 形同 KEK）——名單級承載＝[14] 輸入順序錨面（案內檢）；
+        // nfail 精確 2 帳＝P5/P1 形的錨翻面恰補位（新案新增 PIN/dual 覆蓋時 >= 帽韌性）。
+        const o2rawRed = g.out.split('\n').some((l: string) => l.includes('[14] deriveKek2 輸入順序錨') && l.trimStart().startsWith('✗'));
+        await A('[16] O2 deriveKek2 pass 段接 normalize（禁手形）→ raw 收口形錨翻＋jr2w 凍結面翻（nfail>=2；名單級承載）',
+          mut.applied && g.rc === 1 && nfail(g.out) >= 2 && o2rawRed, 'rc=' + g.rc + ' nfail=' + nfail(g.out) + ' fails=' + realFails(g.out).map(s => s.slice(0, 44)).join(';;'));
+        fs16!.rmSync!(tree16, { recursive: true, force: true });
+      }
+      // O1 jr3w.wrap 入口接 normalize（禁手形）→ 行為翻 4 面帳（本 run 毒化重測：jr3w 全形照解面翻＋normalized
+      // 恆拒面翻＋[15] raw 守衛錨＋[15] 收口形錨）——行為 designated＝凍結兩面（raw 入口契約復活即翻）。
+      {
+        mkTree();
+        const mut = poison16('src/client/argon2.ts',
+          "  const kek = await deriveKekArgon(passphrase, salt);\n  const wrapped = await sealNoteKey(cfg.wrap3, noteKey, kek, 'notekey');",
+          "  const kek = await deriveKekArgon(deriveInput(passphrase), salt);\n  const wrapped = await sealNoteKey(cfg.wrap3, noteKey, kek, 'notekey');");
+        const g = runGate16();
+        // O1 名單面 designated（本 run 重測帳）：jr3w 凍結兩面（全形照解面翻＋normalized 恆拒
+        // 面翻）＝raw 入口契約復活的行為齒；4 面帳＝兩行為面＋兩 [15] 錨跟隨。
+        const o1fwRed = g.out.split('\n').some((l: string) => l.includes('jr3w 全形 wrap 照解') && l.trimStart().startsWith('✗'));
+        const o1normRed = g.out.split('\n').some((l: string) => l.includes('jr3w 拒收 normalized 慣用形') && l.trimStart().startsWith('✗'));
+        await A('[16] O1 jr3w.wrap 入口接 normalize（禁手形）→ 凍結兩面真翻（nfail=4 帳；名單級承載）',
+          mut.applied && g.rc === 1 && nfail(g.out) >= 2 && o1fwRed && o1normRed, 'rc=' + g.rc + ' nfail=' + nfail(g.out) + ' fails=' + realFails(g.out).map(s => s.slice(0, 44)).join(';;'));
+        fs16!.rmSync!(tree16, { recursive: true, force: true });
+      }
+      // O4 unwrapNoteKeyDual4 入口接 raw（v3 反拉形）→ 「毒態」行為面翻轉樣本（修正後真有齒）
+      {
+        mkTree();
+        const mut = poison16('src/client/argon2.ts',
+          "    const kek2 = await deriveKek2Argon(cfg, deriveInput(passphrase), pinNorm, salt1, pinSalt, 'journal-kek2-v1:' + cfg.wrapDual4);\n    const rawHex = await decryptWithKey(kek2, ivPrefixedCt, 'notekey2');",
+          "    const kek2 = await deriveKek2Argon(cfg, passphrase, pinNorm, salt1, pinSalt, 'journal-kek2-v1:' + cfg.wrapDual4);\n    const rawHex = await decryptWithKey(kek2, ivPrefixedCt, 'notekey2');");
+        const g = runGate16();
+        // O4 名單面 designated（本 run 重測帳）：dual4 pass 段 NFKC 反向等價面（修正後
+        // unwrap 餵 passD4 的真反向）＋[17] jr4d NFKC 慣用形帳面——反拉 normalize 時 unwrap 餵 normalized 形
+        // 失去收容 = 該面 null = 行為齒（非只 rc 計數）；行為翻 4 面帳＝反向等價面＋兩 [15] 錨＋[17] 帳面。
+        const o4red = g.out.split('\n').some((l: string) => l.includes('dual4 pass 段 NFKC 反向等價') && l.trimStart().startsWith('✗'));
+        const o4katRed = g.out.split('\n').some((l: string) => l.includes('NFKC-effective 全形 unwrap = 原始 noteKey（v3 契約收容自己；info=jr4d 域）') && l.trimStart().startsWith('✗'));
+        await A('[16] O4 unwrapNoteKeyDual4 入口接 raw（反拉禁手形）→ NFKC 反向等價面＋KAT 慣用形帳面真翻（nfail=4 帳）',
+          mut.applied && g.rc === 1 && nfail(g.out) >= 2 && o4red && o4katRed, 'rc=' + g.rc + ' nfail=' + nfail(g.out) + ' fails=' + realFails(g.out).map(s => s.slice(0, 44)).join(';;'));
+        fs16!.rmSync!(tree16, { recursive: true, force: true });
+      }
+      // O1/O2/O4 的真防線＝源碼計數錨（normalize 收口形恰 3／raw 形恰 2——毒化形即計數變異，本 repo
+      // 樹直接斷言＝毒化態「本節自身」翻而不是只翻拷貝樹）：
+      {
+        const argonSrcNow = await srcOf('../src/client/argon2.ts');
+        const ncSrcNow = await srcOf('../src/client/note-crypto.ts');
+        // 與 [15] 同形計數錨＝「複寫防單點誤删」（[16] 內層保留 O-案源碼錨——[15] 錨被未來誤删時本段仍咬）。
+        await A('[16] O1-src 計數錨（[15] 同形複寫——防單點誤删）：argon2 normalize 收口入口形恰 3（禁手形任何復活＝計數變異即 RED）',
+          argonSrcNow.split('deriveKekArgon(deriveInput(passphrase)').length === 3
+            && argonSrcNow.split('deriveArgon2id(\n    deriveInput(passphrase)').length === 2
+            && argonSrcNow.split('deriveKek2Argon(cfg, deriveInput(passphrase)').length === 3);
+        await A('[16] O2-src 計數錨：note-crypto PBKDF2 家族 pass 段 raw 形恰 1 處（deriveKek2；接 normalize 即 RED——raw 錨 length 2）',
+          ncSrcNow.split('derivePbkdf2Bits(passphrase, salt1, PBKDF2_ITERATIONS)').length === 2);
+        await A('[16] O4-src 計數錨（[15] 同形複寫）：jr4d unwrap 入口 normalize 形恰 2（wrap/unwrap 對稱；摘除或反拉即變異）',
+          argonSrcNow.split('deriveKek2Argon(cfg, deriveInput(passphrase), pinNorm').length === 3);
+      }
+      // 收尾：毒化樹清理自證（封閉集——只核對本 run 喚出的 tree16 路徑；跨執行/
+      // 並行/host 殘留零耦合——其他 core-poison-* 不入本判準）；每棵出生即棄 rmSync 強制在場。
+      {
+        const exists16 = fs16!.existsSync!;
+        let residual = 0;
+        for (const t of treePaths16) if (exists16(t)) residual++;
+        await A('[16] 毒化樹零殘留（本 run 喚出 ' + treePaths16.length + ' 棵全清——封閉集判準）',
+          treePaths16.length >= 10 && residual === 0, 'trees=' + treePaths16.length + ' residual=' + residual);
+      }
+    }
+  }
+}
+
+// ── 17. KAT 凍結向量：HKDF info 域世代分離（修正承載面） ──────────────
+//
+// 凍結常數計算式構造（KAT 母型——raw 'c3'.repeat(32) 寫 c3x32 帳面）：
+// jr3w./jr3d.＝舊 raw 族凍結 blob（全形字面 RAW 派生承載；normalized 慣用形恆拒）；
+// jr4w./jr4d.＝v3 族凍結 blob（KEK 輸入契約＝normalizePassphrase：normalized 慣用形可解、
+// raw 全形形恆拒）。KDF 派生輸入正規化收口（v3）：入口 deriveInput(pass)＝normalizePassphrase
+// 本體同語意（NFKC-only：不 trim、不分大小寫——大小寫摺疊禁絕，大小寫差＝不同 KEK/ph2）；
+// 正規化禁進共用派生本體（舊家族 raw 契約永不變）。
+// jr4d. 的 KEK2 HKDF info 域＝'journal-kek2-v1:' + cfg.wrapDual4（呼叫端帶入）——
+// NFKC-effective 密語下 jr3d/jr4d 兩入參數同輸入（bits 段同值），域分離由 info 承載：
+// 兩 blob 互解 null（下方案）＋各自 ASCII/全形 unwrap=raw＝KDF 域世代的真行為承載。
+// 凍結值：fixed rawKey 'c3'×32；jr3w/jr3d＝全形 RAW 樣本 blob（舊族 raw 承載）；jr4w/jr4d＝
+// 全形 NFKC 載體 blob（v3 契約收容態）；pin '2580ab'；salt/pinSalt 逐值自 baked 資料（外探針實測入冊）。
+// 大小寫摺疊禁絕帳：ASCII 大寫與全形大寫兩形 → null（全形面上限非 NFKC-only 帳面缺口——大小寫
+// 摺疊是另一禁絕面，兩形各自承載）。凍結 blob 逐字面恆定（非動態重演）——驗證期重放＝以 unwrap 端
+// KEK 派生（凍結參數）比對 blob 內 baked 密文；「重放」語意＝派生確定性重驗，blob 本體恆凍結。
+const KAT17_PASS_NORM = pass4; // v3 段 ASCII 慣用形（NFKC-effective：normalizePassphrase(pass4)==pass4）
+const KAT17 = {
+  raw: 'c3'.repeat(32),
+  // 舊族全形凍結樣本由 ASCII 源計算式派生（同 KAT14 母型「凍結常數計算式構造」——
+  // 帶 confusable 字面直接入冊曾實證漂移：gate literal 與真全形一位點碼差＝KAT 靜默拒解）。
+  pass3Raw: Array.from('PASS12x').map((c) => String.fromCodePoint(c.codePointAt(0)! + 0xfee0)).join(''),
+  pass4fw: Array.from(pass4).map((c) => String.fromCodePoint(c.codePointAt(0)! + 0xfee0)).join(''),
+  passDbRaw: Array.from(passD).map((c) => String.fromCodePoint(c.codePointAt(0)! + 0xfee0)).join(''),
+  jr3w: 'jr3w.BeQ8F6s3DdJWY853l2jRv5dHtVEMd+tjJ3XuIisu2ymuK7IInuqIvxtwPD3WzhTkEtCRr+h7KOfWo5FM6ELGjPxwxHAp5LtM5zcEg8hmCqH3dMX9iHF7IOQl3Ak=',
+  s3: 'f6a511fb29b131869d282d89f9eaa90a',
+  jr3d: 'jr3d.nOB7P29euSEa+LM8qMSTRe6r32TbBX7nS2R/WyRJ7N1NO+mqXuW5u9HLiLzYObKHq3NURwiEaxD9qwli646qDoG4/5wlHD7UE9nBT485oUeEx/vYIkmOu4muJQ42avl8zX9M1PSgaP+Bk+R9',
+  sd3: 'a06bd4b1f293b8c8ebff4b6a02f13a34',
+  jr4w: 'jr4w.x6cZmk7UVUAf8abE3mLps22+BLTdWGTDOZpTs4DqHFUDUcz5p5VpdIqYub/9r+sE2/hYE1fPb68ABSCdDeEvJVXlGOsbDr9L//xsdFcZZYlRtrMO3APSwJQBrv0=',
+  s4: '31a8d4ae616ccc0a6def28a9b0db4860',
+  jr4d: 'jr4d.Dz8wgY5Lphif69Fh5fE+54J4YBlUJgfVLHBeM7RGr3HUmplys5FpcIK/AZT8zstvsUSpox2mwnpo4eQA9eqtbRK3kTowaWRyAEjTfx4kJS9eMoPQEWsr+GRRYgtdINlgAoVJxyi/NaCNqhDR',
+  sd4: 'd6ebccb6c9bb3a0d13905183d2b2977d',
+  pin: pinD,
+};
+  {
+    const katRawUnlock = async (key: CryptoKey | null): Promise<boolean> =>
+      key !== null && (await hex(new Uint8Array(await crypto.subtle.exportKey('raw', key)))) === KAT17.raw;
+    console.log('\n[17] KAT 凍結向量：HKDF info 域世代分離＋v3/raw 入口契約（jr3w./jr3d./jr4w./jr4d. 四 blob）');
+    await A('[17] jr3w 凍結 blob：全形 RAW unwrap = 原始 noteKey（舊家族 raw 契約——KAT 承載）',
+      katRawUnlock(await unwrapNoteKey3(TACET3, KAT17.jr3w, KAT17.pass3Raw, KAT17.s3)));
+    await A('[17] jr3w 凍結 blob：normalized 慣用形 → null（normalized 面恆拒——raw 族零正規化承載）',
+      (await unwrapNoteKey3(TACET3, KAT17.jr3w, KAT17_PASS_NORM, KAT17.s3)) === null);
+    await A('[17] jr3d 凍結 blob：全形 RAW unwrap = 原始 noteKey（舊家族 raw 契約——KAT 承載；info=jr3d 域）',
+      katRawUnlock(await unwrapNoteKeyDual3(TACET3, KAT17.jr3d, KAT17.passDbRaw, KAT17.pin, KAT17.sd3)));
+    await A('[17] jr3d 凍結 blob：normalized 慣用形 → null（normalized 面恆拒——鹽內嵌 raw 契約；info=jr3d 域）',
+      (await unwrapNoteKeyDual3(TACET3, KAT17.jr3d, passD, KAT17.pin, KAT17.sd3)) === null);
+    await A('[17] jr4w 凍結 blob：normalized 慣用形 unwrap = 原始 noteKey（v3 契約——KAT 承載）',
+      katRawUnlock(await unwrapNoteKey4(TACET4, KAT17.jr4w, KAT17_PASS_NORM, KAT17.s4)));
+    await A('[17] jr4w 凍結 blob：NFKC-effective 全形 unwrap = 原始 noteKey（v3 契約收容自己——全形 wrap 的 KAT 慣用形）',
+      katRawUnlock(await unwrapNoteKey4(TACET4, KAT17.jr4w, KAT17.pass4fw, KAT17.s4)));
+    await A('[17] jr4w 凍結 blob：fw 大寫形 → null（大小寫差＝不同 KEK——全形載體面上的摺疊禁絕）',
+      (await unwrapNoteKey4(TACET4, KAT17.jr4w, KAT17.pass4fw.toUpperCase(), KAT17.s4)) === null);
+    await A('[17] jr4w 凍結 blob：ASCII 大寫形 → null（大小寫差＝不同 KEK，v3 契約）',
+      (await unwrapNoteKey4(TACET4, KAT17.jr4w, KAT17_PASS_NORM.toUpperCase(), KAT17.s4)) === null);
+    await A('[17] jr4d 凍結 blob：normalized 慣用形 unwrap = 原始 noteKey（v3 契約；KEK2 info=jr4d 自有域）',
+      katRawUnlock(await unwrapNoteKeyDual4(TACET4, KAT17.jr4d, passD, KAT17.pin, KAT17.sd4)));
+    await A('[17] jr4d 凍結 blob：NFKC-effective 全形 unwrap = 原始 noteKey（v3 契約收容自己；info=jr4d 域）',
+      katRawUnlock(await unwrapNoteKeyDual4(TACET4, KAT17.jr4d, KAT17.passDbRaw, KAT17.pin, KAT17.sd4)));
+    await A('[17] jr4d 凍結 blob：fw 大寫形 → null（大小寫差＝不同 KEK——全形載體面上的摺疊禁絕）',
+      (await unwrapNoteKeyDual4(TACET4, KAT17.jr4d, KAT17.passDbRaw.toUpperCase(), KAT17.pin, KAT17.sd4)) === null);
+    await A('[17] jr4d 凍結 blob：ASCII 大寫形 → null（大小寫差＝不同 KEK，v3 契約）',
+      (await unwrapNoteKeyDual4(TACET4, KAT17.jr4d, passD.toUpperCase(), KAT17.pin, KAT17.sd4)) === null);
+    await A('[17] family isolation：jr4d blob 餵 jr3d 路徑 → null（HKDF info 域對不上——域世代分離）',
+      (await unwrapNoteKeyDual3(TACET3, KAT17.jr4d, passD, KAT17.pin, KAT17.sd4)) === null);
+    await A('[17] family isolation：jr3d blob 餵 jr4d 路徑 → null（KEK2 info 域分離對稱面）',
+      (await unwrapNoteKeyDual4(TACET4, KAT17.jr3d, passD, KAT17.pin, KAT17.sd3)) === null);
+  }
+
+// ── 18. 本機包裹專用前綴（wrapLocal opt-in＋讀舊寫新自癒；jr1l.） ──
+//
+// 舊實作借用 cfg.wrap（jr1w. passphrase 包裹前綴）寫本機包裹＝「一個前綴一份契約」的第二
+// 違例（wrappedRec 專用前綴歸 v0.2.0 世代收口）。收口三面：
+//   ①寫面專用前綴：storeLocalWrap 寫入恆 cfg.wrapLocal（jr1l.）；未配置＝退場無寫入
+//     （cipherLocal opt-in 母型——未配置面零寫入零拋）。
+//   ②讀舊寫新自癒：loadLocalWrap 先試新前綴（本體嚴格面）；命中舊形（借用期 jr1w. blob）
+//     回落解密後重包 cfg.wrapLocal 回寫（自癒恰一次）；解不回（損壞/他機搬來）誠實 null
+//     不硬遷移。
+//   ③未配置態讀取面：照走舊形 cfg.wrap（行為不變），且不自癒重寫（heal 綁在新前綴面）。
+// KEK 不動＝deriveGuestKey（identity 派生、passphrase-free——session 期免重打密語的機制
+// 原樣）；本段只界「前綴」面（payload 布局的 KDF/prefix 契約由前綴界定——帶內版本化母型）。
+console.log('\n[18] 本機包裹專用前綴（wrapLocal=jr1l. opt-in＋讀舊寫新自癒）');
+{
+  // section 專用 Map store：node 端 localStorage 死位（keys.ts try/catch 恆 null）——stored 面
+  // 行為斷言要可觀察可重放，結構 KeyStore 注入（同 cfg 注入母型；TACET 基座 fixture 不動）。
+  const mapS18 = (() => { const m = new Map<string, string>(); return {
+    get: (k: string): string | null => (m.has(k) ? m.get(k)! : null),
+    set: (k: string, v: string): void => { m.set(k, v); },
+    remove: (k: string): void => { m.delete(k); },
+    noteKeyWrap: (soul: string): string => 't18_notekey:' + soul,
+  }; })();
+  const TACET_L18 = { ...TACET, wrapLocal: 'jr1l.', store: mapS18 };
+  const { wrapLocal: _omit18, ...restN18 } = TACET_L18;
+  const TACET18_NOLOCAL: NoteCryptoConfig = restN18; // wrap 帶、wrapLocal 無（行為不變態）
+  const { wrap: _omitw18, ...restW18 } = TACET_L18;
+  const TACET18_NOWRAP = restW18 as unknown as NoteCryptoConfig; // wrapLocal 帶、wrap 無（回落守衛態）
+
+  const RAW18 = hex(new Uint8Array(await crypto.subtle.exportKey('raw', noteKey)));
+  const eqNoteKey18 = async (k: CryptoKey | null): Promise<boolean> =>
+    k !== null && hex(new Uint8Array(await crypto.subtle.exportKey('raw', k))) === RAW18;
+  const storedOf18 = (c: NoteCryptoConfig, id: string): string | null => c.store.get(c.store.noteKeyWrap(id));
+  const guestOf18 = async (c: NoteCryptoConfig, id: string): Promise<CryptoKey> => deriveGuestKey(c, id);
+
+  // 舊形向量＝借用期工件真本體：sealNoteKey(cfg.wrap, key, guest, 'notekey-local') 形直呼
+  //（PRE 樹一對照實測：舊碼 storeLocalWrap 產出即此形——92B 嚴格面（hex64 字串 payload））。
+  const guestL18 = await guestOf18(TACET_L18, 'acct-l2');
+  const legacyL18 = await sealNoteKey(TACET.wrap, noteKey, guestL18, 'notekey-local');
+  await A('[18] 舊形向量自洽錨：回落前直解 jr1w. blob = 原 noteKey（樣本可重放）',
+    eqNoteKey18(await openNoteKey(legacyL18, guestL18, 'notekey-local', TACET.wrap)));
+
+  // ── P1 寫面：寫入恆新前綴；未配置退場 ──
+  await storeLocalWrap(TACET_L18, 'acct-l2', noteKey);
+  const freshL18 = storedOf18(TACET_L18, 'acct-l2');
+  await A('[18] 寫前綴 jr1l.（store 契約——借用 cfg.wrap 舊形＝反）', !!freshL18 && freshL18!.startsWith('jr1l.'));
+  await A('[18] 寫入 payload unwrap = 原 noteKey（KEK=deriveGuestKey 原樣——本體 92B 嚴格面）',
+    freshL18 !== null && eqNoteKey18(await openNoteKey(freshL18!, guestL18, 'notekey-local', TACET_L18.wrapLocal!)));
+  await A('[18] 未配置 wrapLocal store 退場（noop——stored 殘留零，opt-in 母型）',
+    (async () => { await storeLocalWrap(TACET18_NOLOCAL, 'acct-l1', noteKey); return storedOf18(TACET18_NOLOCAL, 'acct-l1') === null; })());
+
+  // ── P1b 讀面通路（loadLocalWrap 唯一消費點：encryptNote/decryptNote 的 held 設值面） ──
+  const heldB18 = makeHeldKey(); heldB18.set(noteKey);
+  const ctB18 = await encryptNote(TACET_L18, heldB18, 'plain-read-18', 'aad-18b', { current: () => 'acct-l3' });
+  await A('[18] 樣本自洽：bound 密文前綴 jr1b.（held 預置面）', ctB18.startsWith('jr1b.'));
+  await storeLocalWrap(TACET_L18, 'acct-l3r', noteKey);
+  await A('[18] 空-held decrypt 經本機包裹通路 = 原文（read 通路行為面）',
+    (await decryptNote(TACET_L18, makeHeldKey(), ctB18, 'aad-18b', { current: () => 'acct-l3r' })) === 'plain-read-18');
+  await A('[18] 該 identity 無 stored → null（通路不無中生有）',
+    (await decryptNote(TACET_L18, makeHeldKey(), ctB18, 'aad-18b', { current: () => 'acct-l3x' })) === null);
+
+  // ── P2 舊形回落＋自癒回寫（讀舊寫新） ──
+  TACET_L18.store.set(TACET_L18.store.noteKeyWrap('acct-l2'), legacyL18);
+  await A('[18] 舊形（借用期 jr1w. blob）讀回 = 解密成立（回落面行為）',
+    (await decryptNote(TACET_L18, makeHeldKey(), ctB18, 'aad-18b', { current: () => 'acct-l2' })) === 'plain-read-18');
+  const healedL18 = storedOf18(TACET_L18, 'acct-l2');
+  await A('[18] 自癒回寫恆新前綴（stored 舊形摘除——v1 借用面行為翻轉）', !!healedL18 && healedL18!.startsWith(TACET_L18.wrapLocal!));
+  await A('[18] 自癒 blob unwrap 等值（同一 guest KEK 重包）',
+    healedL18 !== null && eqNoteKey18(await openNoteKey(healedL18!, guestL18, 'notekey-local', TACET_L18.wrapLocal!)));
+  await A('[18] 自癒 blob 舊形恆拒（新形不落舊前綴——家族隔離）',
+    (await openNoteKey(healedL18!, guestL18, 'notekey-local', TACET.wrap)) === null);
+  const beforeRe18 = storedOf18(TACET_L18, 'acct-l2');
+  await A('[18] 自癒後二次讀回（fresh face 通路承載）',
+    (await decryptNote(TACET_L18, makeHeldKey(), ctB18, 'aad-18b', { current: () => 'acct-l2' })) === 'plain-read-18');
+  await A('[18] 二次讀不自癒二次（byte-identical——自癒恰一次）', storedOf18(TACET_L18, 'acct-l2') === beforeRe18);
+
+  // ── P2b/P3 垃圾面：回落解不回＝誠實 null 零回寫；他家族/明文殘留零 crash ──
+  const guestB18 = await guestOf18(TACET_L18, 'acct-l2b');
+  const brokenL18 = (await sealNoteKey(TACET.wrap, noteKey, guestB18, 'notekey-local')).slice(0, -8) + 'AAAABBBB';
+  TACET_L18.store.set(TACET_L18.store.noteKeyWrap('acct-l2b'), brokenL18);
+  const blobBeforeBf18 = storedOf18(TACET_L18, 'acct-l2b');
+  const heldT18 = makeHeldKey(); heldT18.set(noteKey);
+  const ctT18 = await encryptNote(TACET_L18, heldT18, 'plain-bf-18', 'aad-18t', { current: () => 'acct-l2t' });
+  await A('[18] 壞舊形（ct 竄改）讀回 → null（誠實降級非拋）',
+    (await decryptNote(TACET_L18, makeHeldKey(), ctT18, 'aad-18t', { current: () => 'acct-l2b' })) === null);
+  await A('[18] 壞舊形零回寫（自癒條款面：解不回不遷移）', storedOf18(TACET_L18, 'acct-l2b') === blobBeforeBf18);
+  const otherK18 = await importAesGcm(crypto.getRandomValues(new Uint8Array(32)), false);
+  TACET_L18.store.set(TACET_L18.store.noteKeyWrap('acct-l2c'), 'jr3d.' + await encryptWithKey(otherK18, 'y'.repeat(50), 'x'));
+  await A('[18] 他家族 blob（鹽內嵌形）讀回 → null（前綴路由不串家族）',
+    (await decryptNote(TACET_L18, makeHeldKey(), ctT18, 'aad-18t', { current: () => 'acct-l2c' })) === null);
+  TACET_L18.store.set(TACET_L18.store.noteKeyWrap('acct-l2p'), 'plain-leftover-18');
+  await A('[18] 明文殘留讀回 → null（零 crash——舊資料層不進包裹通路）',
+    (await decryptNote(TACET_L18, makeHeldKey(), ctT18, 'aad-18t', { current: () => 'acct-l2p' })) === null);
+
+  // ── P3d cfg.wrap 缺席態（回落守衛面：無舊形可解，wrapLocal 帶著也不硬寫） ──
+  const guestW18 = await guestOf18(TACET18_NOWRAP, 'acct-l2w');
+  const legacyW18 = await sealNoteKey('jr1w.', noteKey, guestW18, 'notekey-local');
+  TACET18_NOWRAP.store.set(TACET18_NOWRAP.store.noteKeyWrap('acct-l2w'), legacyW18);
+  const blobBeforeW18 = storedOf18(TACET18_NOWRAP, 'acct-l2w');
+  await A('[18] cfg.wrap 缺席讀舊形 → null（回落守衛面）',
+    (await decryptNote(TACET18_NOWRAP, makeHeldKey(), ctB18, 'aad-18b', { current: () => 'acct-l2w' })) === null);
+  await A('[18] 守衛面 stored 不變（零硬寫）', storedOf18(TACET18_NOWRAP, 'acct-l2w') === blobBeforeW18);
+
+  // ── P5 未配置態讀取面（wrap 帶、wrapLocal 無——v1 行為不變且不自癒） ──
+  const guestN18 = await guestOf18(TACET18_NOLOCAL, 'acct-l2n');
+  const legacyN18 = await sealNoteKey(TACET18_NOLOCAL.wrap, noteKey, guestN18, 'notekey-local');
+  TACET18_NOLOCAL.store.set(TACET18_NOLOCAL.store.noteKeyWrap('acct-l2n'), legacyN18);
+  const blobBeforeN18 = storedOf18(TACET18_NOLOCAL, 'acct-l2n');
+  await A('[18] 未配置態讀舊形 = 解密成立（v1 行為不變——讀取面回落照走）',
+    (await decryptNote(TACET18_NOLOCAL, makeHeldKey(), ctB18, 'aad-18b', { current: () => 'acct-l2n' })) === 'plain-read-18');
+  await A('[18] 未配置態讀取不自癒重寫（heal 綁在新前綴面）', storedOf18(TACET18_NOLOCAL, 'acct-l2n') === blobBeforeN18);
+
+  // ── P6/P7 分離面＋fail-open（私隱模式） ──
+  const gCt18 = await encryptNote(TACET_L18, makeHeldKey(), 'guest-note-18', 'aad-18g', { current: () => 'acct-l5' });
+  await A('[18] guest 期零本機觸碰（stored 殘留零＋前綴 jr1g. 分離面）',
+    storedOf18(TACET_L18, 'acct-l5') === null && gCt18.startsWith('jr1g.'));
+  const FIXQ18 = { get: (): string | null => { throw new Error('LS_GET_DENIED'); }, set: (): void => { throw new Error('LS_SET_DENIED'); }, remove: (): void => { throw new Error('LS_RM_DENIED'); }, noteKeyWrap: (soul: string): string => 't18q_notekey:' + soul };
+  const TACET_Q18: NoteCryptoConfig = { ...TACET_L18, store: FIXQ18 };
+  await A('[18] 私隱模式 store 拋錯不外拋：empty-held encrypt 降級 guest 面（fail-open）',
+    (await encryptNote(TACET_Q18, makeHeldKey(), 'plain-q-18', 'aad-18q', { current: () => 'acct-l4q' })).startsWith('jr1g.'));
+  await A('[18] 私隱模式 get 拋錯 decrypt → null（誠實降級非外拋）',
+    (await decryptNote(TACET_Q18, makeHeldKey(), ctB18, 'aad-18b', { current: () => 'acct-l4q' })) === null);
+  await A('[18] guest 分支零 store 依賴（私隱模式 guest 密文照解）',
+    (await decryptNote(TACET_Q18, makeHeldKey(), gCt18, 'aad-18g', { current: () => 'acct-l5' })) === 'guest-note-18');
+
+  // ── clearLocalWrap 契約原樣 ──
+  await A('[18] clearLocalWrap 摘除面（契約原樣）', (async () => {
+    await storeLocalWrap(TACET_L18, 'acct-l6', noteKey);
+    const had = storedOf18(TACET_L18, 'acct-l6') !== null;
+    clearLocalWrap(TACET_L18, 'acct-l6');
+    return had && storedOf18(TACET_L18, 'acct-l6') === null;
+  })());
+
+  // ── 源碼窗靜態錨（本地段結構——毒化形即計數/窗錨變異） ──
+  const ncSrc18 = await srcOf('../src/client/note-crypto.ts');
+  const localWin18 = ncSrc18.slice(ncSrc18.indexOf('── 本機包裹'), ncSrc18.indexOf('── 日記密文入口'));
+  await A('[18] 源碼窗：窗尾 floor 三值帳（真窗 1984B／Δ_p18b≈70B→摘後 1933 持／餘裕 +74B——floor 是帳漂移承重件，隨窗漂移即帳錯）', localWin18.length > 1910);
+  await A('[18] 源碼窗：本機段零 throw 面（ERR_WRAP_NOT_CONFIGURED 禁令——未配置＝無寫入無拋；P18d 毒化咬復活）',
+    !localWin18.includes('ERR_WRAP_NOT_CONFIGURED'));
+  await A('[18] 源碼窗：寫面唯 cfg.wrapLocal seal＋舊借形零殘留（v1 借用面復活即反）',
+    localWin18.split('sealNoteKey(cfg.wrapLocal').length === 2 && !localWin18.includes('sealNoteKey(cfg.wrap,'));
+  await A('[18] 源碼窗：回落三元恰 1（收口形——自癒腿與未配置態同走單一 cfg.wrap 面；借用形復活即 2+）＋自癒接線（if legacy → storeLocalWrap identity legacy 恰 1）',
+    localWin18.split('openNoteKey(stored, guest, \'notekey-local\', cfg.wrap)').length === 2
+    && localWin18.split('await storeLocalWrap(cfg, identity, legacy)').length === 2
+    && /if \(legacy\) \{\s*await storeLocalWrap\(cfg, identity, legacy\);/.test(localWin18));
+  await A('[18] 界面欄：wrapLocal? 宣告恰 1（note-crypto 全檔——NoteCryptoConfig 選配欄）',
+    ncSrc18.split('wrapLocal?: string;').length === 2);
+  // ── [18] 常駐毒化矩陣（本機段結構毒三案——母型 [16] gate-rerun 形：/tmp 拷貝突變＋內層整組閘重跑＋出生即棄） ──
+  {
+    const getBuiltin18 = (id: string): unknown =>
+      (globalThis as unknown as { process?: { getBuiltinModule?: (i: string) => unknown } }).process?.getBuiltinModule?.(id);
+    const os18 = getBuiltin18('node:os') as { tmpdir?: () => string } | undefined;
+    const fs18 = getBuiltin18('node:fs') as {
+      rmSync?: (p: string, o?: { recursive: boolean; force: boolean }) => void;
+      cpSync?: (a: string, b: string, o?: { recursive: boolean; filter?: (src: string) => boolean }) => void;
+      readFileSync?: (p: string, e?: string) => string;
+      writeFileSync?: (p: string, c: string, e?: string) => void;
+      mkdtempSync?: (p: string) => string;
+    } | undefined;
+    const inner18 = (globalThis as unknown as { process?: { env?: Record<string, string | undefined> } }).process?.env?.POISON_GATE_INNER === '1';
+    const ready18 = !!os18?.tmpdir && !!fs18?.mkdtempSync && !!fs18?.cpSync && !!fs18?.readFileSync && !!fs18?.writeFileSync && !!fs18?.rmSync;
+    if (inner18 || !ready18) {
+      await A('[18] 毒化矩陣載體就緒（node 內建模組在場；內層遞迴由 sentinel 跳過＝正常；缺席＝顯性 FAIL）', inner18 && !ready18 ? false : inner18, 'env unavailable AND not inner');
+    } else {
+      const repoRoot18 = new URL('..', import.meta.url).pathname;
+      const skip18 = (s: string): boolean => s.endsWith('/.git') || s.includes('/.git/') || s.includes('/node_modules') || s.split('/').pop() === 'node_modules';
+      const needlePA18 = "\n    const fresh = cfg.wrapLocal\n      ? await openNoteKey(stored, guest, 'notekey-local', cfg.wrapLocal) // 本體嚴格面（92B＋rawHex hex 形）\n      : null;\n    if (fresh) return fresh;";
+      const needlePB18 = "      await storeLocalWrap(cfg, identity, legacy);\n      return legacy;";
+      const needlePC18 = "sealNoteKey(cfg.wrapLocal,";
+      const existsSync18 = (p: string): boolean => {
+        const fsx18 = getBuiltin18('node:fs') as { existsSync?: (p: string) => boolean } | undefined;
+        return typeof fsx18?.existsSync === 'function' ? fsx18.existsSync(p) : false;
+      };
+      const cp18 = getBuiltin18('node:child_process') as { execFileSync?: (cmd: string, args: string[], opts: { cwd: string; encoding: string; stdio: unknown[]; env?: Record<string, string>; timeout: number }) => string } | undefined;
+      const runGate18 = (workDir: string): { rc: number; out: string } => {
+        // 內層 gate 執行帶 POISON_GATE_INNER=1 sentinel——三毒化節在內層自我跳過＝遞迴防線
+        //（[16] runGate16 同形；拷貝樹的閘檔含三節全文，無 sentinel 會自拷貝再自跑）。
+        try {
+          const out = cp18!.execFileSync!('node', ['--experimental-strip-types', 'scripts/verify-core-crypto.ts'], { cwd: workDir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], env: { ...((globalThis as unknown as { process?: { env?: Record<string, string | undefined> } }).process?.env ?? {}), POISON_GATE_INNER: '1' }, timeout: 240000 });
+          return { rc: 0, out };
+        } catch (e: unknown) {
+          const err = e as { stdout?: string; stderr?: string; status?: number };
+          return { rc: err.status ?? 1, out: (err.stdout ?? '') + (err.stderr ?? '') };
+        }
+      };
+      // 毒化窗（同字面點數律——needlePA18/PB18/PC18/P18d 毒化前點數自檢在 withPoisonRun18 內）。
+      // byte-exact 帳：srcBefore sha256 毒前釘死；srcAfter 同值＝毒化零突變本樹。
+      const sha18 = (s: string): string =>
+        (getBuiltin18('node:crypto') as { createHash?: (a: string) => { update: (s: string) => { digest: (e: string) => string } } } | undefined)?.createHash?.('sha256')!.update(s)!.digest('hex')!;
+      const srcBefore18 = await srcOf('../src/client/note-crypto.ts');
+      const shaBefore18 = sha18(srcBefore18);
+      const trees18: string[] = [];
+
+      // 三案改 gate-rerun 形（改形照 [16] runGate16 母型）：
+      // 拷貝樹突變 src/client/note-crypto.ts 後重跑內層整組閘（POISON_GATE_INNER=1 遞迴
+      // 防線——內層三毒化節自我跳過），數 [18] 名單 ✗ 真紅：designated-FAIL 帳＝毒化不只
+      // 翻面，更要咬「未來有人把 [18] 主斷言改弱」——弱化後毒化名單帳不齊即 RED。
+      const withPoisonRun18 = async (label: string, needle: string, replacement: string, cases: string[], want: number): Promise<void> => {
+        const dir = fs18!.mkdtempSync!(os18!.tmpdir!() + '/t18-lw-')!;
+        trees18.push(dir);
+        try {
+          fs18!.cpSync!(repoRoot18, dir, { recursive: true, filter: (s: string) => !skip18(s) });
+          const p = dir + '/src/client/note-crypto.ts';
+          const s0 = fs18!.readFileSync!(p, 'utf8');
+          const cnt = s0.split(needle).length - 1;
+          if (cnt !== 1) { await A(label + '（毒化 needle 對位自檢——錨缺席＝runner 設計錯非閘病）', false, 'needle cnt=' + cnt); return; }
+          fs18!.writeFileSync!(p, s0.split(needle).join(replacement), 'utf8');
+          const g = runGate18(dir);
+          const failLines18 = g.out.split('\n').filter((l: string) => l.trimStart().startsWith('✗') && l.includes('[18]'));
+          const others18 = g.out.split('\n').filter((l: string) => l.trimStart().startsWith('✗') && !l.includes('[18]'));
+          const designated18 = cases.filter((kw) => failLines18.some((l: string) => l.includes(kw)));
+          const account18 = failLines18.map((l: string) => l.replace(/^\s*✗\s*/, '').slice(0, 40)).join(';;');
+          await A(label + '→ [18] 名單真紅 ' + want + '（designated-FAIL 帳：實測 ' + designated18.length + '/' + want +
+            '；' + account18.slice(0, 110) + '；others=' + others18.length + '）',
+            g.rc === 1 && designated18.length === want && failLines18.length === want
+            && others18.length === 1 && others18[0]!.includes('與 @scure/bip39 參照 200 組雙向一致')
+            && cases.every((kw) => failLines18.filter((l: string) => l.includes(kw)).length === 1),
+            'rc=' + g.rc + ' n18=' + failLines18.length + ' d=' + designated18.length + ' others=' + others18.length);
+        } finally {
+          fs18!.rmSync!(dir, { recursive: true, force: true });
+        }
+      };
+      // P18 摘 fresh-face（三元→null）→ stored jr1l. blob 通路讀死＋源碼窗 floor 面翻（窗 shrink 1833<1910；throw 禁令面由 P18d 獨立承載）
+      await withPoisonRun18('[18] 毒化 P18 gate-rerun（P18：摘 fresh-face 三元→null）',
+        needlePA18, '\n    const fresh = null;',
+        ['空-held decrypt 經本機包裹通路', '自癒後二次讀回', '窗尾 floor 三值帳'], 3);
+      // P18b 摘自癒回寫 → 讀面照解（通路讀面不依賴回寫線）＋回寫線計數窗錨翻面
+      await withPoisonRun18('[18] 毒化 P18b gate-rerun（P18b：摘自癒回寫）',
+        needlePB18, '      return legacy;',
+        ['自癒回寫恆新前綴', '自癒 blob unwrap 等值', '自癒 blob 舊形恆拒', '回落三元恰 1'], 4);
+      // P18c 寫面接回借用形（禁手）→ 寫面 fallback jr1w.（v1 借用面復活的行為翻轉）＋寫面唯一 seal 計數窗錨翻面
+      await withPoisonRun18('[18] 毒化 P18c gate-rerun（P18c：寫面接回借用形）',
+        needlePC18, 'sealNoteKey(cfg.wrap,',
+        ['寫前綴 jr1l.', '寫入 payload unwrap', '自癒回寫恆新前綴', '自癒 blob unwrap 等值', '自癒 blob 舊形恆拒', '二次讀不自癒二次', '寫面唯 cfg.wrapLocal seal'], 7);
+      // P18d 本機段禁令復活（ERR 半邊——長度中性＋36B）：storeLocalWrap 守衛 return→throw
+      //（storeLocalWrap 自身 try/catch 吸收＝行為面零變；可觀察面＝本窗禁令錨，毒後窗 +36B）。
+      await withPoisonRun18('[18] 毒化 P18d gate-rerun（P18d：storeLocalWrap 守衛復活 throw）',
+        '    if (!cfg.wrapLocal) return;',
+        "    if (!cfg.wrapLocal) throw new Error('ERR_WRAP_NOT_CONFIGURED');",
+        ['本機段零 throw 面'], 1);
+      // 真樹 needle 對位錨＋byte-exact：毒化全程跑
+      // 拷貝樹，真樹 sha256 毒前毒後恆等＝零突變帳；needle 恰 1×4 計數防線＝誤改斷言窗本體
+      // （含守衛行）即 RED——名實一致帳）。
+      const srcAfter18 = await srcOf('../src/client/note-crypto.ts');
+      await A('[18] 還原 byte-exact 對照（真樹 sha256 毒前毒後恆等——' + shaBefore18.slice(0, 12) + '…）', sha18(srcAfter18) === shaBefore18);
+      await A('[18] 真樹 needle 對位錨（恰 1×4——真樹零突變的行程帶）',
+        srcAfter18.split(needlePA18).length === 2 && srcAfter18.split(needlePB18).length === 2
+        && srcAfter18.split(needlePC18).length === 2
+        && srcAfter18.split('    if (!cfg.wrapLocal) return;').length === 2);
+      await A('[18] 毒化樹零殘留（本 run 喚出 ' + trees18.length + ' 棵全清——封閉集判準）',
+        trees18.length === 4 && trees18.every((t) => !fs18!.rmSync || !existsSync18(t)));
+    }
+  }
+}
+
+// ── 19. ladder 表與重取鹽面（(a+) 案） ──────────────
+//
+// 驗證策略（真 SQLite，node:sqlite）：①ph2_ladder DDL（FK CASCADE／UNIQUE account_id）；
+// ②重取鹽面 unwrapNoteKeyDual4WithSalt＝雙腿重試形為（ladder 遷移旋轉 salt1 後，呼叫端
+// 以 login 回帶的新 salt 重試 jr4d 重包──新面 unwrap 必中、陳舊 salt 必 null 兩面承載）；
+// ③ladder 表語意面（kinds 常數／表名單一真相）＋值主權威 upsert 行為面（真 node:sqlite
+// 直驅 makePh2LadderStore：upsert 恰一列、同一舊值最新持有者勝、無 DELETE 語句面）。
+// 表名/kind 常數的契約面（PH2_LADDER_TABLE='ph2_ladder'、KIND legacy/v2）由本段斷言直接咬住
+//（fork migration 0011 與 core 原語同字面——漂移＝fork schema 與 core 原語脫鉤＝表缺席 fail-open 面）。
+console.log('\n[19] ladder 表與重取鹽面（unwrapNoteKeyDual4WithSalt＋ph2_ladder）');
+{
+  const { DatabaseSync } = (globalThis as unknown as {
+    process?: { getBuiltinModule?: (id: string) => { DatabaseSync?: unknown } };
+  }).process?.getBuiltinModule?.('node:sqlite') ?? {};
+  if (!DatabaseSync) throw new Error('ERR_SQLITE_UNAVAILABLE');
+  await A('[19] ladder 表名契約：PH2_LADDER_TABLE = ph2_ladder（fork migration 同字面）', PH2_LADDER_TABLE === 'ph2_ladder');
+  await A('[19] ladder kinds 契約：legacy/v2 兩形（常數面）', PH2_LADDER_KIND_LEGACY === 'legacy' && PH2_LADDER_KIND_V2 === 'v2');
+  // 值主權威行為面（真 node:sqlite 直驅本體）：建表走 fork migration 同形（PK=ph2）。
+  {
+    const DatabaseSync19 = DatabaseSync as new (p: string) => { exec: (s: string) => void; prepare: (s: string) => { run: (...p: unknown[]) => { changes: number | bigint }; get: (...p: unknown[]) => unknown } };
+    const db19 = new DatabaseSync19(':memory:');
+    db19.exec('CREATE TABLE users (account_id TEXT PRIMARY KEY, ph2 TEXT)');
+    db19.exec("INSERT INTO users (account_id, ph2) VALUES ('acc19', 'ph2-new')");
+    db19.exec("INSERT INTO users (account_id, ph2) VALUES ('ghost19', 'ph2-ghost')");
+    const migSrc19 = await srcOf('../migrations/0011-ph2-ladder.sql');
+    const ddlPos19 = migSrc19.indexOf('CREATE TABLE IF NOT EXISTS ph2_ladder');
+    const ddl19 = migSrc19.slice(ddlPos19, migSrc19.indexOf(';', ddlPos19) + 1);
+    db19.exec(ddl19.replace(/IF NOT EXISTS /g, ''));
+    const env19 = {
+      DB: {
+        prepare(sql: string) {
+          return {
+            bind(...params: unknown[]) {
+              return {
+                async first() { return db19.prepare(sql).get(...params) as Row19 | null; },
+                async run() { db19.prepare(sql).run(...params); return { changes: 1 }; },
+              };
+            },
+          };
+        },
+      },
+    } as unknown as Env19;
+    const ladder19 = makePh2LadderStore(env19 as unknown as Parameters<typeof makePh2LadderStore>[0]);
+    await ladder19.insert('acc19', 'old-19', PH2_LADDER_KIND_V2);
+    await ladder19.insert('acc19', 'old-19b', PH2_LADDER_KIND_V2); // 同帳戶第二個舊值歷列
+    await ladder19.insert('acc19', 'old-19', PH2_LADDER_KIND_LEGACY); // 同舊值 upsert（值主權威覆蓋）
+    await ladder19.insert('ghost19', 'old-19', PH2_LADDER_KIND_V2); // 幽靈帳同舊值＝最新持有者勝
+    const r19a = await ladder19.findByOldPh2('old-19');
+    await A('[19] ladder upsert 值主權威：同一舊值恰一列（PK=ph2）且最新持有者勝',
+      r19a !== null && r19a.accountId === 'ghost19' && r19a.ph2Kind === 'v2',
+      JSON.stringify(r19a));
+    const cnt19 = db19.prepare('SELECT COUNT(*) AS n FROM ph2_ladder').get() as { n: number };
+    await A('[19] ladder upsert 恆一列（三案同表恰 2 列——值唯一＋多舊值歷列並存）', cnt19.n === 2, String(cnt19.n));
+    const r19b = await ladder19.findByOldPh2('old-19b');
+    await A('[19] ladder 多舊值歷列：第二舊值仍在場（同帳戶兩段遷移各存）', r19b !== null && r19b.accountId === 'acc19');
+    await A('[19] ladder miss 面：查無列回 null', (await ladder19.findByOldPh2('nope-19')) === null);
+  }
+
+  // 重取鹽面：wrap 吃 passD4 全形（NFKC 載體）→ unwrap 以新 salt（ladder 遷移後重取）必中
+  const rewrapD4 = await wrapNoteKeyDual4(TACET4, noteKey, passD4, pinD);
+  const withSalt = await unwrapNoteKeyDual4WithSalt(TACET4, rewrapD4.wrapped, passD, pinD, rewrapD4.salt);
+  await A('[19] WithSalt 重試面：重取 salt1（ladder 遷移後新值）→ unwrap = 原 noteKey',
+    withSalt !== null && hex(new Uint8Array(await crypto.subtle.exportKey('raw', withSalt))) === origRaw);
+  await A('[19] WithSalt 陳舊鹽面：wrap 期的 salt1（已旋轉面）→ null（鹽旋轉後舊鹽解不開）',
+    (await unwrapNoteKeyDual4WithSalt(TACET4, rewrapD4.wrapped, passD, pinD, dual4.salt)) === null);
+  await A('[19] WithSalt 錯 passphrase → null（同 unwrapNoteKeyDual4 本體契約）',
+    (await unwrapNoteKeyDual4WithSalt(TACET4, rewrapD4.wrapped, 'wrong-passphrase', pinD, rewrapD4.salt)) === null);
+  await A('[19] WithSalt 未配置 cfg（wrapDual4 缺）→ null（opt-in 鐵律同向）',
+    (await unwrapNoteKeyDual4WithSalt({ pinSalt3Prefix: 'tacet-note-pin3:' }, rewrapD4.wrapped, passD, pinD, rewrapD4.salt)) === null);
+}
+// ── 20. 復原套件專用前綴＋HKDF 派生世代 ──
+//
+// 裁定：採搭車——wrappedRec 專用前綴＋KEK_rec 改
+// HKDF-SHA256（jr3d KEK2 HKDF 為先例）；「一個前綴一份契約」第二違例（wrappedRec 共用
+// cfg.wrap＋同 AAD）同步收口。收口五面（檢查對齊定案）：
+//   ①專用前綴 cfg.wrapRec（jr1r.；命名＝語意後綴軸，沿 jr1l. 定案）＋專屬 AAD
+//     'notekey-rec'（帶內版本化：payload 契約面綁派生世代）。
+//   ②世代配對門（檢查對齊 C1/C2）：wrapRec＋recKekHkdf 兩欄一體（同缺同在）——
+//     部分配置（XOR）＝ERR_REC_CFG_PARTIAL 拒寫（fail-closed 禁寫出「jr1r.×PBKDF2」
+//     寫得出讀不回 blob 與「jr1w.×HKDF」借用 blob）；讀面部分配置照走舊面回落
+//     （承諾面：配置形正確時舊 blob 永遠可解）。
+//   ③KEK_rec 派生世代 cfg.recKekHkdf（HKDF 專責）：HKDF-SHA256( ikm = recToken（256-bit
+//     實體因子——KDF 強度無意義，世代收的是派生域分離）, salt = recKekSalt？
+//     16B hex（未配置＝零鹽）, info = 'journal-kek-rec-v1:' + recKekHkdf, L = 32 )。
+//     info 合成名沿 argon2 家族慣例（HKDF info 呼叫端帶入定形）。
+//     PBKDF2 舊派生＝deriveRecLegacyKek 單一本體（寫面未配置世代＋讀面回落同源）。
+//   ④讀舊寫新雙試：兩欄齊備 unwrap＝jr1r. 面（HKDF）先行、未中→舊面（cfg.wrap＋
+//     notekey＋PBKDF2）回落（救回動線順向雙試＝裁定過渡保護
+//     涵蓋；摘雙試＝遷移率裁定非日曆）。兩欄皆缺席（舊 cfg）＝單試舊面（行為不變）。
+//   ⑤四象限 write→read 矩陣（檢查對齊 M1）：每象限「自 wrap 可自 unwrap 或 wrap 拒絕」
+//     ＋超集 cfg 可讀子集 blob（升級路徑保護）＋B01 歷史缺陷形恆拒（升 KDF＝換前綴）。
+console.log('\n[20] 復原套件專用前綴（wrapRec=jr1r. opt-in）＋KEK_rec HKDF 世代（recKekHkdf opt-in，兩欄一體配對門）');
+{
+  const recSalt20 = 'a1b2c3d4e5f60718293a4b5c6d7e8f90';
+  const TACET5: NoteCryptoConfig = { ...TACET, wrapRec: 'jr1r.', recKekHkdf: 'jr1r.', recKekSalt: recSalt20 };
+  const raw20 = hex(new Uint8Array(await crypto.subtle.exportKey('raw', noteKey)));
+  const eqNoteKey20 = async (k: CryptoKey | null): Promise<boolean> =>
+    k !== null && hex(new Uint8Array(await crypto.subtle.exportKey('raw', k))) === raw20;
+  const rawKat20 = '57c72afacd486194c41227f42311600e287a7d48baa7a3e9de32fa460c089699'; // KAT 凍結 noteKey（外探針實測入冊）
+  const eqRawKat20 = async (k: CryptoKey | null): Promise<boolean> =>
+    k !== null && hex(new Uint8Array(await crypto.subtle.exportKey('raw', k))) === rawKat20;
+  const recToken20 = generateRecToken();
+  const KAT_BLOB_R20 = 'jr1r.bkvBFdKjNVfidHcfn0WoyyRJLkajWhXF7WmPdc3Q9FCNNxDz+7PgN0x25BjuAZPFi1oP3t+8dblrnSQEltkieBh33xoyChcGKe1wEfaStQF6ITBNb6vBZKVXDEQ=';
+
+  // P1 寫面：兩欄齊備＝jr1r.＋專屬 AAD；cfg.wrap 腿（passphrase 包裹）不受牽連
+  const freshRec20 = await wrapNoteKeyWithRecToken(TACET5, noteKey, recToken20, identityA);
+  await A('[20] 新世代 wrappedRec 前綴 jr1r.（寫面契約——借用期 cfg.wrap 形＝反）', freshRec20.startsWith('jr1r.'));
+  await A('[20] KAT 自洽前置（live wrap 樣本可重放）：jr1r. blob＋同 identity → 原 noteKey',
+    eqNoteKey20(await unwrapNoteKeyWithRecToken(TACET5, freshRec20, recToken20, identityA)));
+  await A('[20] 寫面 jr1w. 腿不受牽連（passphrase 包裹照走本前綴）',
+    (await wrapNoteKey(TACET5, noteKey, pass)).wrapped.startsWith('jr1w.'));
+
+  // P2 舊契約面凍結：未配置世代 wrap/unwrap（byte 不變承載——函式體零改面）
+  const legacyRec20 = await wrapNoteKeyWithRecToken(TACET, noteKey, recToken20, identityA);
+  await A('[20] 未配置世代 wrappedRec 前綴 jr1w.（契約面永不變——借用面凍結）', legacyRec20.startsWith('jr1w.'));
+  await A('[20] 未配置世代 unwrap = 原 noteKey（PBKDF2 舊派生契約原樣）',
+    eqNoteKey20(await unwrapNoteKeyWithRecToken(TACET, legacyRec20, recToken20, identityA)));
+  await A('[20] KAT 凍結 blob（舊 PBKDF2 契約面）：凍結 recToken＋凍結 identity 鹽域＋凍結 blob 逐位可解（凍結常數計算式構造——KAT 母型；對錨＝凍結 noteKey raw 非本段活金鑰）',
+    eqRawKat20(await unwrapNoteKeyWithRecToken(TACET, 'jr1w.a4xchJ+EPui8iQy5dKpQyGjalu0nlJMsDd0LaLyRrY3mt+6112Se4NvaibymRFHsMg1LgOYsBVy15t0CiU1ipf9g8rniqBmdf1R5LzVXQdNJDCzbAfubPUKc/FE=', '62ff0221e30b56740ec210cd36df2e9667841585c6d0fcd5200826b965aa36a5', 'kat-id-0000000000000000')));
+  await A('[20] seal 未配置守衛：cfg.wrap 缺席 legacy 路徑直呼 → ERR_WRAP_NOT_CONFIGURED（呼叫端亦可先行拒絕——雙防線外層）',
+    (async () => {
+      const noWrap20 = { ...TACET, wrap: undefined } as unknown as NoteCryptoConfig;
+      try { await wrapNoteKeyWithRecToken(noWrap20, noteKey, recToken20, identityA); return false; }
+      catch { return true; }
+    })());
+  await A('[20] 帳面 92B 錨（鹽內嵌面契約）：jr1r. payload 嚴格 92B（hex64 64B＋iv 12＋tag 16——HKDF 鹽屬「派生面內嵌 cfg、payload 零內嵌」，pinSalt 前綴不在 rec 鹽形契約內）',
+    freshRec20.length > 'jr1r.'.length && unb64Mod(freshRec20.slice('jr1r.'.length)).length === 92);
+
+  // P3 新世代讀舊寫新（雙試）＋家族互斥＋KAT 世代帶
+  await A('[20] 新世代讀舊 blob（過渡保護）：舊 PBKDF2/AAD/前綴面回落雙試 → 原 noteKey',
+    eqNoteKey20(await unwrapNoteKeyWithRecToken(TACET5, legacyRec20, recToken20, identityA)));
+  await A('[20] 家族互斥：jr1r. blob 餵未配置世代 cfg → null（新面恆拒——家族隔離對稱面）',
+    (await unwrapNoteKeyWithRecToken(TACET, freshRec20, recToken20, identityA)) === null);
+  await A('[20] KAT 凍結 blob：jr1r. 逐位重放（凍結 recToken/salt/identity/blob 恆定——HKDF 世代派生確定性重驗；對錨＝凍結 noteKey raw 非本段活金鑰）',
+    eqRawKat20(await unwrapNoteKeyWithRecToken(TACET5, KAT_BLOB_R20, '62ff0221e30b56740ec210cd36df2e9667841585c6d0fcd5200826b965aa36a5', 'kat-id-0000000000000000')));
+  await A('[20] KAT 世代齒（鹽入派生正向翻面）：凍結 recToken/identity/blob 不變、鹽域換值 → null（鹽 A wrap→鹽 B unwrap 恆不重合——HKDF salt 有入派生）',
+    (await unwrapNoteKeyWithRecToken({ ...TACET5, recKekSalt: 'ffeeddccbbaa99887766554433221100' }, KAT_BLOB_R20, '62ff0221e30b56740ec210cd36df2e9667841585c6d0fcd5200826b965aa36a5', 'kat-id-0000000000000000')) === null);
+  await A('[20] KAT 世代齒（info 域帶毒化案同錨）：HKDF info 尾綴換值（鹽/identity/blob 恆定）→ null（info 有入派生——R2 毒化翻轉的 clean 鏡）',
+    (await unwrapNoteKeyWithRecToken({ ...TACET5, recKekHkdf: 'jr1r-x' }, KAT_BLOB_R20, '62ff0221e30b56740ec210cd36df2e9667841585c6d0fcd5200826b965aa36a5', 'kat-id-0000000000000000')) === null);
+  await A('[20] HKDF 世代正交面（配對門收口後契約）：僅 recKekHkdf（wrapRec 缺席）＝配對門拒寫，讀面 jr1r. blob 照舊面回落零接納（cfg.wrap 在場＝PBKDF2 腿零承載——HKDF 派生禁借 jr1w. 前綴）',
+    (await unwrapNoteKeyWithRecToken({ ...TACET, recKekHkdf: 'jr1r.' }, freshRec20, recToken20, identityA)) === null);
+
+  // identity 參數語意（HKDF 族零接觸面——docstring identity-free by design 承載）
+  const freshB20 = await wrapNoteKeyWithRecToken(TACET5, noteKey, recToken20, 'acct-bbbbbbbbbbbbbbbb');
+  await A('[20] identity HKDF 族零接觸（docstring identity-free 契約自證化——誤接線即 RED）',
+    freshB20.startsWith('jr1r.') && eqNoteKey20(await unwrapNoteKeyWithRecToken(TACET5, freshB20, recToken20, 'acct-cccccccccccccccc')));
+  await A('[20] identity 互斥面（舊契約面）：錯 identity unwrap → null（rec 鹽＝recSaltPrefix‖identity 定值——同 recToken 異 KEK）',
+    (await unwrapNoteKeyWithRecToken(TACET, legacyRec20, recToken20, 'acct-bbbbbbbbbbbbbbbb')) === null);
+
+  // P4 契約面守衛（形檢 fail-closed）
+  await A('[20] 壞 recKekSalt fail-closed：unwrap → null（HKDF 腿 throw→catch，零 legacy 回落——cfg 誤配整面 fail-closed）',
+    (await unwrapNoteKeyWithRecToken({ ...TACET5, recKekSalt: 'xyz123' }, freshRec20, recToken20, identityA)) === null);
+  await A('[20] 壞 recKekSalt wrap 面拋 ERR_REC_KEK_SALT（fail-closed 拒寫——派生世代誤配即禁寫）',
+    (async () => { try { await wrapNoteKeyWithRecToken({ ...TACET5, recKekSalt: 'xyz123' }, noteKey, recToken20, identityA); return false; } catch (e) { return (e as Error).message === 'ERR_REC_KEK_SALT'; } })());
+
+  // P5 世代配對門（檢查對齊 C1/C2 收口——兩欄一體，fail-closed 拒寫）
+  await A('[20] 配對門 wrapRec-only（C1 象限）：拋 ERR_REC_CFG_PARTIAL（禁寫「jr1r.×PBKDF2」寫得出讀不回 blob）',
+    (async () => { try { await wrapNoteKeyWithRecToken({ ...TACET, wrapRec: 'jr1r.' }, noteKey, recToken20, identityA); return false; } catch (e) { return (e as Error).message === 'ERR_REC_CFG_PARTIAL'; } })());
+  await A('[20] 配對門 recKekHkdf-only（C2 象限）：拋 ERR_REC_CFG_PARTIAL（禁借 jr1w. 前綴 carrying HKDF 派生）',
+    (async () => { try { await wrapNoteKeyWithRecToken({ ...TACET, recKekHkdf: 'jr1r.' }, noteKey, recToken20, identityA); return false; } catch (e) { return (e as Error).message === 'ERR_REC_CFG_PARTIAL'; } })());
+  // B01 歷史缺陷形向量（收口後零接納面）：HKDF-on-jr1w. 借形 blob——守衛形拒寫＝
+  // 無構造源（升級探針缺陷形），凍結重放式對借形 blob 的恆拒承載（對錨＝null 非 noteKey）。
+  const legacyB01_20 = 'jr1w.' + modB64(new Uint8Array(92).fill(7));
+  await A('[20] 配對門錯誤序前於鹽形檢（部分配置形不驗鹽——門先收）',
+    (async () => { try { await wrapNoteKeyWithRecToken({ ...TACET, recKekHkdf: 'jr1r.', recKekSalt: 'xyz123' }, noteKey, recToken20, identityA); return false; } catch (e) { return (e as Error).message === 'ERR_REC_CFG_PARTIAL'; } })());
+  await A('[20] 配對門讀面寬容：wrapRec-only cfg 讀舊 jr1w. blob → 原 noteKey（部分配置禁寫不禁讀——舊 blob 永遠可解）',
+    eqNoteKey20(await unwrapNoteKeyWithRecToken({ ...TACET, wrapRec: 'jr1r.' }, legacyRec20, recToken20, identityA)));
+  await A('[20] 配對門讀面寬容（C1 歷史缺陷形救回面）：wrapRec-only cfg 逐位重放凍結舊 blob（PBKDF2 鹽域）→ 凍結 noteKey',
+    eqRawKat20(await unwrapNoteKeyWithRecToken({ ...TACET, wrapRec: 'jr1r.' }, 'jr1w.a4xchJ+EPui8iQy5dKpQyGjalu0nlJMsDd0LaLyRrY3mt+6112Se4NvaibymRFHsMg1LgOYsBVy15t0CiU1ipf9g8rniqBmdf1R5LzVXQdNJDCzbAfubPUKc/FE=', '62ff0221e30b56740ec210cd36df2e9667841585c6d0fcd5200826b965aa36a5', 'kat-id-0000000000000000')));
+  await A('[20] 配對門讀面恆拒（B01 歷史缺陷形）：recKekHkdf-only cfg 讀 HKDF-on-jr1w. 形 blob → null（借形缺陷 blob 零接納面；升 KDF＝換前綴）',
+    (await unwrapNoteKeyWithRecToken({ ...TACET, recKekHkdf: 'jr1r.', recKekSalt: recSalt20 }, legacyB01_20, recToken20, identityA)) === null);
+
+  // M1 四象限 write→read 矩陣（檢查對齊——四象限配置（wrapRec，recKekHkdf）逐格對帳面；
+  // 每格「write：blob 前綴（或配對門拒）→ read：同 cfg 自解行為」＋超集 cfg 讀子集 blob）。
+  {
+    const qCfg10 = (): NoteCryptoConfig => ({ ...TACET, wrapRec: 'jr1r.' });
+    const qCfg01 = (): NoteCryptoConfig => ({ ...TACET, recKekHkdf: 'jr1r.', recKekSalt: recSalt20 });
+    const wrapQ = async (c: NoteCryptoConfig): Promise<string> => {
+      try { return await wrapNoteKeyWithRecToken(c, noteKey, recToken20, identityA); }
+      catch (e) { return (e as Error).message; }
+    };
+    const b00q = await wrapQ({ ...TACET });
+    const b10q = await wrapQ(qCfg10());
+    const b01q = await wrapQ(qCfg01());
+    const b11q = await wrapQ({ ...TACET5 });
+    await A('[20] M1 write 面四格：B00→jr1w.／B10→ERR_REC_CFG_PARTIAL／B01→ERR_REC_CFG_PARTIAL／B11→jr1r.（部分配置零寫出面——C1/C2 借形禁產）',
+      b00q.startsWith('jr1w.') && b10q === 'ERR_REC_CFG_PARTIAL' && b01q === 'ERR_REC_CFG_PARTIAL' && b11q.startsWith('jr1r.'),
+      b00q.slice(0, 5) + '/' + b10q + '/' + b01q + '/' + b11q.slice(0, 5));
+    const r00q = await unwrapNoteKeyWithRecToken({ ...TACET }, b00q, recToken20, identityA);
+    const r11q = await unwrapNoteKeyWithRecToken({ ...TACET5 }, b11q, recToken20, identityA);
+    await A('[20] M1 read 面自解格：B00/B11 同 cfg 自 wrap 自 unwrap＝原 noteKey（B10/B01 無 blob＝write 面承載）',
+      (await eqNoteKey20(r00q)) && (await eqNoteKey20(r11q)));
+    await A('[20] M1 超集讀子集（升級路徑保護）：B10/B01 cfg 皆可讀 B00 舊 blob（舊面回落）',
+      (await eqNoteKey20(await unwrapNoteKeyWithRecToken(qCfg10(), b00q, recToken20, identityA)))
+      && (await eqNoteKey20(await unwrapNoteKeyWithRecToken(qCfg01(), b00q, recToken20, identityA))));
+    await A('[20] M1 超集讀子集：B11 cfg 讀 B00 blob（雙試回落＝原 noteKey）、B00 cfg 讀 B11 blob（子集讀超集＝null——家族隔離對稱面）',
+      (await eqNoteKey20(await unwrapNoteKeyWithRecToken({ ...TACET5 }, b00q, recToken20, identityA)))
+      && ((await unwrapNoteKeyWithRecToken({ ...TACET }, b11q, recToken20, identityA)) === null));
+  }
+
+  // 源碼窗（計數錨——接線漂移即 RED；needle+1 式對照 [14][15][16] 母型；錨為敘述形且 docstring 零咬；
+  // 檢查對齊 M1 後配對門落地——窗口全體重錨隨修正形；「HKDF 腿零借 cfg.wrap」的接線由 R2 贊毒化承載）
+  const noteCryptoSrc20 = await srcOf('../src/client/note-crypto.ts');
+  await A('[20] 源碼窗：專屬 AAD 接線恰 2（wrap seal 面與 unwrap open 面各恰 1——回收共用面復活/錯位接線即變異）',
+    noteCryptoSrc20.split("kek, 'notekey-rec')").length === 2 && noteCryptoSrc20.split("'notekey-rec', cfg.wrapRec)").length === 2);
+  await A('[20] 源碼窗：世代配對門恰 1（ERR_REC_CFG_PARTIAL 拋點，split 帳＝出現＋1——門摘除＝拒寫面失效即 RED）',
+    noteCryptoSrc20.split("throw new Error('ERR_REC_CFG_PARTIAL')").length === 2);
+  await A('[20] 源碼窗：配對門接線形恰 1（wrapRec 或 recKekHkdf 在場即入門——單欄短路復活即形變異）',
+    noteCryptoSrc20.split('if (cfg.wrapRec || cfg.recKekHkdf) {').length === 2
+    && noteCryptoSrc20.split("if (!cfg.wrapRec || !cfg.recKekHkdf) throw new Error('ERR_REC_CFG_PARTIAL');").length === 2);
+  await A('[20] 源碼窗：HKDF 專責接線恰 1（兩欄齊備守衛——派生雙模/C2 借形復活即變異）',
+    noteCryptoSrc20.split('if (cfg.wrapRec && cfg.recKekHkdf) {').length === 2);
+  await A('[20] 源碼窗：PBKDF2 fallback 殘留歸零＋deriveRecKek 呼叫面恰 3（非空洞計數：fallback 形歸零＋def＋兩呼叫端在場——C2 收口面）',
+    noteCryptoSrc20.split('if (!cfg.recKekHkdf) return deriveKek').length === 1
+    && noteCryptoSrc20.split('deriveRecKek(').length === 4);
+  await A('[20] 源碼窗：deriveRecLegacyKek def＋呼叫恰 3（split 帳＝出現＋1；legacy 本體單一真相——寫面＋讀面同源）',
+    noteCryptoSrc20.split('deriveRecLegacyKek(').length === 4);
+  await A('[20] 源碼窗：cfg.wrapRec 敘述形恰 2（配對門 XOR 一對——借用面復活即計數變異）',
+    noteCryptoSrc20.split('cfg.wrapRec ||').length === 3
+    && noteCryptoSrc20.split('!cfg.wrapRec ||').length === 2);
+
+  // R 系毒化（自毒化驗齒——/tmp 拷貝樹 fresh import，出生即棄；期望值真跑後定值，帳面直覺禁沿；
+  // 檢查對齊：R2 重錨＝info 字面→KAT 世代齒、R4 label 對齊、R5 新案＝配對門（C1/C2 唯一閘承載））
+  const getBuiltin20 = (id: string): unknown =>
+    (globalThis as unknown as { process?: { getBuiltinModule?: (i: string) => unknown } }).process?.getBuiltinModule?.(id);
+  const fs20 = getBuiltin20('node:fs') as {
+    rmSync?: (p: string, o?: { recursive: boolean; force?: boolean }) => void;
+    cpSync?: (a: string, b: string, o?: { recursive: boolean; filter?: (s: string) => boolean }) => void;
+    readFileSync?: (p: string, e?: string) => string;
+    writeFileSync?: (p: string, c: string, e?: string) => void;
+    mkdtempSync?: (p: string) => string;
+    existsSync?: (p: string) => boolean;
+  } | undefined;
+  const os20 = getBuiltin20('node:os') as { tmpdir?: () => string } | undefined;
+  const inner20 = (getBuiltin20('node:process') as { env?: Record<string, string | undefined> } | undefined)?.env?.POISON_GATE_INNER === '1';
+  const ready20 = !!os20?.tmpdir && !!fs20?.mkdtempSync && !!fs20?.cpSync && !!fs20?.readFileSync && !!fs20?.writeFileSync && !!fs20?.rmSync;
+  const needleR1 = "    return sealNoteKey(cfg.wrapRec, noteKey, kek, 'notekey-rec');";
+  const needleR3 = "    const legacyKek = await deriveRecLegacyKek(cfg, recToken, identity);";
+  const needleR5 = "if (!cfg.wrapRec || !cfg.recKekHkdf) throw new Error('ERR_REC_CFG_PARTIAL');";
+  const srcNow20 = await srcOf('../src/client/note-crypto.ts');
+  await A('[20] 毒化錨前綴自檢（毒化窗同字面點數先行；split 計數帳＝出現數＋1）',
+    srcNow20.split(needleR1).length === 2 && srcNow20.split(needleR3).length === 2
+    && srcNow20.split("const info = 'journal-kek-rec-v1:'").length === 2 && srcNow20.split(needleR5).length === 2);
+  if (inner20 || !ready20) {
+    await A('[20] 毒化矩陣載體就緒（node 內建模組在場；內層遞迴由 sentinel 跳過＝正常；缺席＝顯性 FAIL）',
+      inner20 && !ready20 ? false : inner20, 'env unavailable AND not inner');
+  } else {
+    const repoRoot20 = new URL('..', import.meta.url).pathname;
+    const skip20 = (s: string): boolean => s.endsWith('/.git') || s.includes('/.git/') || s.includes('/node_modules') || s.split('/').pop() === 'node_modules';
+    const trees20: string[] = [];
+    const withPoison20 = async (applyS: (s: string) => string, probe: (dir: string) => Promise<void>): Promise<void> => {
+      const dir = fs20!.mkdtempSync!(os20!.tmpdir!() + '/t20-')!;
+      trees20.push(dir);
+      try {
+        fs20!.cpSync!(repoRoot20, dir, { recursive: true, filter: (s: string) => !skip20(s) });
+        const p = dir + '/src/client/note-crypto.ts';
+        const s0 = fs20!.readFileSync!(p, 'utf8');
+        fs20!.writeFileSync!(p, applyS(s0), 'utf8');
+        await probe(dir);
+      } finally {
+        fs20!.rmSync!(dir, { recursive: true, force: true });
+      }
+    };
+    const freshImport20 = async (dir: string): Promise<Record<string, unknown>> => await import('file://' + dir + '/src/client/note-crypto.ts') as Record<string, unknown>;
+    const baseCfg20 = (): NoteCryptoConfig => ({ ...TACET, wrapRec: 'jr1r.', recKekHkdf: 'jr1r.', recKekSalt: recSalt20 });
+
+    // R1 摘專屬 AAD（寫面接回共用 'notekey'）→ jr1r. 新面 unwrap 死＝單純換前綴假收口（designated）
+    await withPoison20(
+      (s: string) => s.replace(needleR1, "    return sealNoteKey(cfg.wrapRec, noteKey, kek, 'notekey');"),
+      async (dir: string) => {
+        const mod = (await freshImport20(dir)) as typeof import('../src/client/note-crypto.ts');
+        const cfg = baseCfg20();
+        const nk = await mod.generateNoteKey();
+        const rt = mod.generateRecToken();
+        const blob = await mod.wrapNoteKeyWithRecToken(cfg, nk, rt, identityA);
+        const back = await mod.unwrapNoteKeyWithRecToken(cfg, blob, rt, identityA);
+        await A('[20] 毒化 R1 摘專屬 AAD → 新面 unwrap 死（blob 內 AAD 舊契約形——designated）', back === null, String(back !== null));
+      });
+    // R2 HKDF info 域摘除（重錨：毒化打 info 字面——info 變數吃 recKekHkdf 值本身、
+    // 家族成名域零在場→KAT 凍結 blob unwrap 死＝KAT 世代齒一次到位（designated））
+    await withPoison20(
+      (s: string) => s.replace("const info = 'journal-kek-rec-v1:' + hkdfTail;", 'const info = hkdfTail;'),
+      async (dir: string) => {
+        const mod = (await freshImport20(dir)) as typeof import('../src/client/note-crypto.ts');
+        const back = await mod.unwrapNoteKeyWithRecToken(baseCfg20(), KAT_BLOB_R20, '62ff0221e30b56740ec210cd36df2e9667841585c6d0fcd5200826b965aa36a5', 'kat-id-0000000000000000');
+        await A('[20] 毒化 R2 info 字面移除 → KAT blob unwrap 死（KAT 世代齒——info 有入派生的正向翻面——designated）', back === null, String(back !== null));
+      });
+    // R3 摘舊面雙試（legacy 派生錯鹽）→ 新世代讀舊 blob 死（過渡保護有齒）＋舊 cfg 面同死（同一本體）
+    await withPoison20(
+      (s: string) => s.replace(needleR3, "    const legacyKek = await deriveRecLegacyKek(cfg, recToken, identity + 'x');"),
+      async (dir: string) => {
+        const mod = (await freshImport20(dir)) as typeof import('../src/client/note-crypto.ts');
+        const cfg = baseCfg20();
+        const nk = await mod.generateNoteKey();
+        const rt = mod.generateRecToken();
+        const legacy = await mod.wrapNoteKeyWithRecToken(TACET, nk, rt, identityA);
+        const back = await mod.unwrapNoteKeyWithRecToken(cfg, legacy, rt, identityA);
+        await A('[20] 毒化 R3 摘舊面雙試 → 新世代讀舊 blob 死（designated——過渡保護有齒）', back === null, String(back !== null));
+        const backOld = await mod.unwrapNoteKeyWithRecToken(TACET, legacy, rt, identityA);
+        await A('[20] 毒化 R3 舊 cfg 面同死（legacy 派生本體單一真相——兩處呼叫同源）', backOld === null, String(backOld !== null));
+      });
+    // R4 前綴借用面復活（wrapRec 面接回 cfg.wrap）→ 寫面 fallback jr1w.（designated；契約翻轉齒由 P1 前綴斷言承載）
+    await withPoison20(
+      (s: string) => s.replace(needleR1, "    return sealNoteKey(cfg.wrap, noteKey, kek, 'notekey-rec');"),
+      async (dir: string) => {
+        const mod = (await freshImport20(dir)) as typeof import('../src/client/note-crypto.ts');
+        const cfg = baseCfg20();
+        const nk = await mod.generateNoteKey();
+        const rt = mod.generateRecToken();
+        const blob = await mod.wrapNoteKeyWithRecToken(cfg, nk, rt, identityA);
+        await A('[20] 毒化 R4 前綴借用面復活 → 寫面 fallback jr1w.（毒化執行證——契約翻轉齒由 P1 前綴斷言承載）',
+          typeof blob === 'string' && blob.startsWith('jr1w.'), String(blob ?? '').slice(0, 8));
+      });
+    // R5 忠實回退（檢查對齊新增案——C1/C2 拒寫面的唯一閘承載；designated）：
+    // 門分支回寫生產形（wrapRec 面吃 legacy 派生＋notekey-rec 契約），尾端
+    // cfg.wrap 腿原樣留任（wrapRec 缺席續走 cfg.wrap＋poisoned deriveRecKef HKDF）＝
+    // 兩歷史缺陷象限（C1＝jr1r.×PBKDF2／C2＝jr1w.×HKDF）寫出面精確重現——毒化代碼照寫、
+    // 兩缺陷形復活並自解 null 的行為翻面承載。
+    const poisonR5 = (s: string): string => s.replace(
+      "  if (cfg.wrapRec || cfg.recKekHkdf) {\n    if (!cfg.wrapRec || !cfg.recKekHkdf) throw new Error('ERR_REC_CFG_PARTIAL');\n    const kek = await deriveRecKek(cfg, recToken);\n    return sealNoteKey(cfg.wrapRec, noteKey, kek, 'notekey-rec');\n  }",
+      '  if (cfg.wrapRec) {\n    const kek = await deriveRecLegacyKek(cfg, recToken, identity);\n    return sealNoteKey(cfg.wrapRec, noteKey, kek, "notekey-rec");\n  }',
+    );
+    await withPoison20(poisonR5, async (dir: string) => {
+      const mod = (await freshImport20(dir)) as typeof import('../src/client/note-crypto.ts');
+      const nk = await mod.generateNoteKey();
+      const rt = mod.generateRecToken();
+      const blobC1 = await mod.wrapNoteKeyWithRecToken({ ...TACET, wrapRec: 'jr1r.' }, nk, rt, identityA);
+      const blobC2 = await mod.wrapNoteKeyWithRecToken({ ...TACET, recKekHkdf: 'jr1r.', recKekSalt: recSalt20 }, nk, rt, identityA);
+      const backC1 = await mod.unwrapNoteKeyWithRecToken({ ...TACET, wrapRec: 'jr1r.' }, blobC1, rt, identityA);
+      await A('[20] 毒化 R5 忠實回退 → C1 歷史缺陷形復活（jr1r.×PBKDF2 blob 寫出＋毒形讀面自解 null＝B10 象限寫得出讀不回——designated）',
+        typeof blobC1 === 'string' && blobC1.startsWith('jr1r.') && backC1 === null,
+        String(blobC1 ?? '').slice(0, 5) + '/' + String(backC1 !== null));
+      await A('[20] 毒化 R5 忠實回退 → C2 歷史缺陷形復活（jr1w. 前綴 carrying 派生 HKDF blob 寫出——designated；借形契約面重現）',
+        typeof blobC2 === 'string' && blobC2.startsWith('jr1w.'), String(blobC2 ?? '').slice(0, 5));
+    });
+    // 檢核：R5 毒化代碼（忠實回退形）寫出的 C1 形 blob，在守衛形（未毒化）讀面下不可救——配對門價值的直接行為證（缺口行為化）
+    {
+      const dirP = fs20!.mkdtempSync!(os20!.tmpdir!() + '/t20r5-')!;
+      trees20.push(dirP);
+      try {
+        fs20!.cpSync!(repoRoot20, dirP, { recursive: true, filter: (s: string) => !skip20(s) });
+        const pP = dirP + '/src/client/note-crypto.ts';
+        const sP = fs20!.readFileSync!(pP, 'utf8');
+        if (poisonR5(sP) === sP) throw new Error('R5 anchor missing');
+        fs20!.writeFileSync!(pP, poisonR5(sP), 'utf8');
+        const modP = (await import('file://' + dirP + '/src/client/note-crypto.ts')) as typeof import('../src/client/note-crypto.ts');
+        const nkP = await modP.generateNoteKey();
+        const rtP = (await modP.generateRecToken());
+        const rawP = hex(new Uint8Array(await crypto.subtle.exportKey('raw', nkP)));
+        const blobC1 = await modP.wrapNoteKeyWithRecToken({ ...TACET, wrapRec: 'jr1r.' }, nkP, rtP, identityA);
+        const rawEqP = async (k: CryptoKey | null): Promise<boolean> => k !== null && hex(new Uint8Array(await crypto.subtle.exportKey('raw', k))) === rawP;
+        const back = await unwrapNoteKeyWithRecToken({ ...TACET, wrapRec: 'jr1r.' }, blobC1, rtP, identityA);
+        const backUp = await unwrapNoteKeyWithRecToken(TACET5, blobC1, rtP, identityA);
+        await A('[20] 配對門價值行為證：R5 毒化代碼寫出 C1 形 blob → 守衛形讀面自解 null（B10 象限缺口的行為化翻面）',
+          back === null, String(back === null));
+        await A('[20] 配對門價值行為證：C1 形 blob 在完整新世代 cfg 下讀面亦 null（HKDF KEK≠PBKDF2 KEK——升級不救 B10）',
+          backUp === null && !(await rawEqP(back)),
+          String(backUp === null) + '/' + String(await rawEqP(back)));
+      } finally {
+        fs20!.rmSync!(dirP, { recursive: true, force: true });
+      }
+    }
+    // 還原自證：毒化樹零殘留（本 run 喚出 6 棵全清——封閉集判準；出生即棄拷貝樹＋真樹 needle 計數自證）
+    const srcAfter20 = (getBuiltin20('node:fs') as { readFileSync?: (p: string, e?: string) => string })!.readFileSync!(
+      new URL('../src/client/note-crypto.ts', import.meta.url).pathname, 'utf8');
+    await A('[20] 真樹 needle 對位錨（真樹零突變的行程帶）',
+      srcAfter20.split(needleR1).length === 2 && srcAfter20.split(needleR3).length === 2
+      && srcAfter20.split("const info = 'journal-kek-rec-v1:'").length === 2 && srcAfter20.split(needleR5).length === 2);
+    const existsSync20 = (p: string): boolean =>
+      typeof fs20!.existsSync === 'function' ? fs20!.existsSync!(p) : false;
+    await A('[20] 毒化樹零殘留（本 run 喚出 ' + trees20.length + ' 棵全清——封閉集判準）',
+      trees20.length === 6 && trees20.every((t) => !existsSync20(t)));
+  }
+}
+
 console.log(`\n${passed} 斷言全綠` + (failures.length ? `；${failures.length} 失敗` : ''));
 if (failures.length) {
   console.error('失敗項：', failures);
   process.exit(1);
 }
+
 console.log('CORE-CRYPTO-VERIFY-OK');