@danceiny/gotry 0.0.1-rc.11 → 0.0.1-rc.12

package/README.md

@@ -12,9 +12,9 @@
 | | |
 |---|---|
 | **Version** | `v0.0.1-rc.11`(npm **latest 直指本版**,`npx @danceiny/gotry` 即得;[release notes](docs/release-notes.md)) |
-| **Status** | M4 记忆域推进中(2026-08-28):记忆写读闭环 + 效用 sidecar + 「下一次出发」0::1 召回;17 工具;事务化状态账本(ADR-15)+ 双形态架构冻结(ADR-16:本地+Web 一套账本语义,tenant_id 一等字段);**2026-08-29 已知限制清算第一刀**:Z3 WASM race 根治(`z3-shared.ts` 单一实例+会话级互斥,run-all §1 重试止血退役+§30 并发回归闸)、薄壳遗留(`shell/`)物理删除;全栈回归全绿(套件清单见 `scripts/run-all-tests.sh` 分节) |
+| **Status** | **M3 工程与分发面已就绪,但真实种子用户 evidence 未收口,M3 Exit 仍开放;M4 记忆域由 founder 授权并行推进,不构成 M3 Exit 证明;M5/M6 仅在各自 Entry gate 满足后启动。** M4 Issue #20 的 paired-cohort/active-planning/experience-reflux 证据合同与 synthetic fixture scorer 已接入 run-all §34(合成 N=3 不充当 Exit,真实 `observed_private` N≥5 paired cohort 待积累);18 工具(2026-08-29 +`gotry_session_login`);事务化状态账本(ADR-15,`gotry_async_terminal.v1`:4/4→`succeeded`/ledger `settled`/exit 0,非 4/4→`failed`/ledger `failed`/exit 2,终态复诵零重算)+ 双形态架构冻结(ADR-16:本地+Web 一套账本语义,tenant_id 一等字段);**会话数据面 #21**:字段 fixture scorer、双源合同与 waiting-attach no-spend 已进确定性回归,真实 sf-01..08 尚未验收;**2026-08-29 已知限制清算第一刀**:Z3 WASM race 根治(`z3-shared.ts` 单一实例+会话级互斥,run-all §1 重试止血退役+§30 并发回归闸)、薄壳遗留(`shell/`)物理删除;**2026-08-29 第二批:OTA 扁平化 + 账号授权闸 + 登录产品化**——飞猪 `search-hotel` 接入(酒店实时报价)、OTA 工具面去「主/降级」路由话术、会话检索授权闸(每会话一次 + 拒绝即会话内吊销)、`gotry_session_login` 登录产品化(登录在携程官网完成,gotry 只读票据名零值过手);全栈回归以 `scripts/run-all-tests.sh` 为准 |
 | **Repo** | [github.com/Danceiny/gotry](https://github.com/Danceiny/gotry) · CI: typecheck + 全栈回归(Node 22/24) |
-| **Runtime** | DeepSeek Harness 0.1.1-rc.2 (vendored `ts/dsh-runtime/`, [upstream](https://github.com/deepseek-ai/DeepSeek-Harness)) · Z3 (npm `z3-solver`) · LoopX (pipx, `~/.local/pipx/venvs/loopx/bin/loopx`) · Agent-Reach v1.5.0 (`.venv/bin/agent-reach`) |
+| **Runtime** | DeepSeek Harness **0.1.2-alpha.1**（vendored 源码 tarball `ts/dsh-runtime/vendor/`，上游 npm 未发版、从 GitHub tag `dsh-v0.1.2-alpha.1` 构建，溯源见 [`ts/dsh-runtime/vendor/README.md`](ts/dsh-runtime/vendor/README.md)；[upstream](https://github.com/deepseek-ai/DeepSeek-Harness)） · Z3 (npm `z3-solver`) · LoopX (pipx, `~/.local/pipx/venvs/loopx/bin/loopx`) · Agent-Reach v1.5.0 (`.venv/bin/agent-reach`) |
 | **License** | **MIT** (2026-08-23 落定,见 [LICENSE](LICENSE)) |
 
 
@@ -62,7 +62,7 @@ cd gotry
 
 ```bash
 cd ts/dsh-runtime
-pnpm install    # 拉 @deepseek-ai/dsh 0.1.1-rc.2 + 依赖(实测 51 秒)
+pnpm install    # 装 vendored dsh 0.1.2-alpha.1 + 第三方依赖 (tarball 在 vendor/, 溯源见 vendor/README.md)
 cd ../..
 ```
 
@@ -119,6 +119,16 @@ gotry 把 **DeepSeek Harness (dsh) 运行时**作为唯一推荐面——任何
 
 > 一行安装的关键点: `./gotry web`(终端粘贴即用),或 `./gotry "任务"`(一句问答)。**任何自然语言都能用**(这是 dsh runtime 投资的最大价值)。详见 [known limitations](#-known-limitations)。
 
+### 可选：启用登录态会话检索
+
+会话检索默认只读，并复用用户本人已登录的日常 Chrome。使用前需要 Chrome 144+：
+
+1. 在日常 Chrome 打开 `chrome://inspect/#remote-debugging` 并启用 Remote Debugging；
+2. 保持 Chrome 打开；GoTry 发起连接后，在 Chrome 弹出的权限框中确认连接；
+3. 若遇到登录、OTP、验证码或 challenge，由用户本人处理，GoTry 不读取或代填这些信息。
+
+**仅打开该页面或启用开关不代表已经 attach 成功。** 必须等权限确认和 CDP 握手完成；在此之前会稳定返回 `needs-attach`，停止并且不消耗执行配额。
+
 
 ---
 
@@ -171,7 +181,7 @@ GoTry: 收到。先把约束记下来——
 ```
 ┌──────────────────────────────────────────────────────────────┐
 │ L1  对话即界面  chat-as-UI; gates 是消息内选择题                 │
-│ L2  编排  dsh 运行时 + GoTry 插件(ReAct);13 个工具            │
+│ L2  编排  dsh 运行时 + GoTry 插件(ReAct);18 个工具            │
 │ L3  领域  统一行程模型 + Z3 可行性引擎(枚举/Z3 双形态)        │
 │ L4  数据  静态数据包 + hotelbyte-cli 实时桥 + OpenFlights 骨架 │
 │ L5  治理  LoopX(objective / gates / evidence / quota)         │
@@ -180,7 +190,7 @@ GoTry: 收到。先把约束记下来——
 
 | 层 | 模块 | 角色 |
 |---|---|---|
-| L2 | `ts/src/index.ts` (dsh 插件) | 注册 13 个工具,挂 `{{current_date}}`/`{{time_anchor_card}}`/`{{motivation_brief}}` 变量,工具 execute 异常隔离 + 平铺观察 envelope + uncaughtException 护栏 |
+| L2 | `ts/src/index.ts` (dsh 插件) | 注册 18 个工具,挂 `{{current_date}}`/`{{time_anchor_card}}`/`{{motivation_brief}}` 变量,工具 execute 异常隔离 + 平铺观察 envelope + uncaughtException 护栏;账号会话工具挂授权闸(`tools/pre-execute` → 运行时审批卡,每会话首次请求、拒绝即会话内吊销,`sessionAccess: ask\|allow\|off` 总闸) |
 | L3 | `ts/src/unified.ts` · `py/gotry_feasibility/unified.py` | 唯一求解入口(候选枚举 + 航班链 Z3) |
 | L4 | `ts/capabilities/hbcli.ts` | hotelbyte-cli 进程封装 + 降级到 `data/hotels_2026.json` |
 | L4 | `ts/scripts/skeleton-check.ts` | OpenFlights 168 对枢纽,三值语义(阳性/枢纽对否定≠证伪/枢纽外=无结论) |
@@ -195,6 +205,8 @@ GoTry: 收到。先把约束记下来——
 - ✅ **License MIT** (D-1 落地 2026-08-23)
 - ✅ **英文面(工程层)已就绪** — 求解确定性输出面(候选/航班链 answer_md、放宽建议、排除理由)i18n catalog 化:`GOTRY_LOCALE=en` 或 `setLocale('en')` 即英文,默认 zh-CN 与金标准逐字节一致(run-all §32:en 零缺键/切换数据不动)。**残余(诚实声明)**:dsh web 界面属宿主、工具结果卡与人格对话面等 M4 校准输入落定后随校准样本补齐——种子市场仍是中国出境(G1)
 - ✅ **机票实时数据已接入** — dated 航班链段可经 FlyAI 官方只读通道取实时票价覆写(`GOTRY_REALTIME_PRICING=1`,证据链 `[实时API:flyai@ts]`,miss/error/打码价一律降级回静态包 `data/flights_2026.json`);静态包由「唯一来源」变为「显式降级」,零 key 可用
+- ✅ **酒店实时报价已接入(OTA 平铺)** — `gotry_flyai_search` kind=hotel 直连飞猪官方 `search-hotel`(2026-08-29 实测:结构化 名称/档级/打码价);未鉴权价格上游打码(如 ¥7xx),工具保 priceRaw 原值不伪装成数字价,真实价以 jumpUrl 酒店页为准;OTA 工具面平铺,无「主链路/降级」路由——按查询取用,证据链逐源标注
+- ✅ **账号登录已产品化(第 18 工具)** — `gotry_session_login`:会话检索遇 `needs-login` 时 agent 直接调它,在你的 Chrome 弹出携程登录页、等你在**携程官网**完成登录——全程无需终端。**登录永远发生在外部网站、不在 gotry 里进行;gotry 永不收集/存储/传输密码、验证码或任何 cookie 值,只读「票据 cookie 是否存在」这一个事实(名称级,0 值过手)**。授权闸 v2:每会话首次调用弹审批卡、会话内记住;拒绝 = 本会话吊销;`sessionAccess: ask|allow|off` 总闸随时可关(session-tests §I/§J + smoke §13 验证)
 - ✅ **Z3 WASM race 已根治** — 三模块各自持 WASM 实例 + 候选求解 `Promise.all` 共 Context 并发是双重根因;现收敛 `ts/src/z3-shared.ts`(单一实例+单一 Context+会话级互斥门),run-all §1 的「重试一次」止血已退役,新增 §30 进程内三形态并发回归闸 ×12(D-17)
 - ✅ **薄壳已删除** — `shell/` 目录与 `./gotry shell` 分支已移除(2026-08-29 清理;dsh web 唯一产品面,旧命令行在 git 历史/rc.6 文档内可考)
 
@@ -227,7 +239,7 @@ GoTry: 收到。先把约束记下来——
 异步工单跨进程 · 插件 smoke · hbcli · 进程护栏(含工具异常隔离) · 天气 · 航班 ·
 Anything · probePoi · agent-reach(web/deep/wrapper)· 双路径稳定性 ·
 时间感评测(锚点卡/槽位过期校验/评分器/mock 回放;真模型巡检 `time-eval-tests.ts --real`)·
-记忆域(动机合并守门/效用 sidecar/只读指标投影)· **Z3 并发竞态(§30)· 实时票价桥(§31)· i18n 目录(§32)**。
+记忆域(动机合并守门/效用 sidecar/只读指标投影)· **Z3 并发竞态(§30)· 实时票价桥(§31)· i18n 目录(§32)· M3 cohort 证据合同(§33)· M4 价值证据合同(§34)**。
 
 ---
 
@@ -261,6 +273,6 @@ Anything · probePoi · agent-reach(web/deep/wrapper)· 双路径稳定性 ·
 
 ---
 
-**Built with**: DeepSeek Harness 0.1.1-rc.2 · Cordis · Z3 (WASM) · loopx (pipx) · hotelbyte-cli · Agent-Reach v1.5.0 (`.venv/`) · OpenFlights · TypeScript · Bun
+**Built with**: DeepSeek Harness 0.1.2-alpha.1 (vendored) · Cordis · Z3 (WASM) · loopx (pipx) · hotelbyte-cli · Agent-Reach v1.5.0 (`.venv/`) · OpenFlights · TypeScript · Bun
 
 **Last verified against `v0.0.1-rc.11`(已发布,2026-08-29)** — 全栈回归全绿 §1-§32(发布流程见 `scripts/publish-npm.sh`,内部决策见 [docs/decisions-needed.md](docs/decisions-needed.md)、[docs/tokens.md](docs/tokens.md))。

package/cordis.gotry-patch.yml

@@ -77,10 +77,17 @@
       evidence=用户原话),不等确认;班次/房型/落脚点等开放性选择不外问
       用户——基于已知动机与约束给出最有说服力的方案并说明理由,用户否决
       才改。校准类疑问永不阻塞推进。
-      (19)实时价与班期三级路由:机票/火车班次与票价先 gotry_flyai_search
-      (飞猪官方只读,主链路);关键决策(临近下单/价差存疑)再用
-      gotry_session_search 在用户本人登录态交叉验证,直达/中转分桶比对,
-      不比裸最低价;两源皆不可用退静态包并显式标 [静态包:估算]。
-      会话工具返回 needs-login→请用户跑 scripts/session-login.ts 并
-      继续用官方源推进;返回 challenged→立即停手如实告知,绝不重试
-      绝不绕过。[会话:*] 证据链随结论必达用户。
+      (19)OTA 检索(平铺工具,无预设路由优先级):实时机票/火车用
+      gotry_flyai_search(kind=flight|train),实时酒店报价也用它
+      (kind=hotel;未鉴权价格多为打码如 ¥7xx,如实以区间呈现并请用户到
+      jumpUrl 酒店页核实真实价)。账号会话面 gotry_session_search(用户本人
+      登录态,现携程机票):**首次调用**经运行时审批卡向用户请求授权,本会话
+      内记住、不再重复弹卡;用户拒绝即本会话吊销——不再请求也不再执行,改走
+      其他工具推进;无审批通道(headless)不执行。返回 needs-login→调
+      gotry_session_login 产品工具(在用户自己的 Chrome 打开携程登录入口并等待
+      其完成登录,不需要任何终端命令;**登录永远发生在携程官网、不在 gotry
+      里进行**——gotry 永不收集/存储/传输密码、验证码或任何 cookie 值,只检查
+      "是否已登录"这一个事实;向用户说明这一点),完成前用官方源推进,不反复
+      开页探测;返回 challenged→立即停手如实告知,绝不重试
+      绝不绕过。跨源结论各带来源标注([实时API:flyai@ts]/[会话:ctrip-flight@ts]/
+      [静态包:估算]),分桶比对直达/中转,不比裸最低价;证据链随结论必达用户。

package/dist/capabilities/flyai.js

@@ -1,4 +1,44 @@
 import { spawn } from 'node:child_process';
+export function parseFlyaiItemList(stdout) {
+    let start = -1;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    let sawIncompleteObject = false;
+    for(let index = 0; index < stdout.length; index += 1){
+        const char = stdout[index];
+        if (start < 0) {
+            if (char === '{') {
+                start = index;
+                depth = 1;
+                inString = false;
+                escaped = false;
+                sawIncompleteObject = true;
+            }
+            continue;
+        }
+        if (inString) {
+            if (escaped) escaped = false;
+            else if (char === '\\') escaped = true;
+            else if (char === '"') inString = false;
+            continue;
+        }
+        if (char === '"') inString = true;
+        else if (char === '{') depth += 1;
+        else if (char === '}') {
+            depth -= 1;
+            if (depth !== 0) continue;
+            const candidate = stdout.slice(start, index + 1);
+            start = -1;
+            sawIncompleteObject = false;
+            try {
+                const parsed = JSON.parse(candidate);
+                if (Array.isArray(parsed.data?.itemList)) return parsed.data.itemList;
+            } catch  {}
+        }
+    }
+    throw new Error(sawIncompleteObject ? 'incomplete FlyAI JSON object' : 'no complete FlyAI itemList JSON object');
+}
 function sh(cmd, args, opts) {
     const child = spawn(cmd, args, {
         env: process.env,
@@ -33,6 +73,7 @@ function sh(cmd, args, opts) {
         });
     }).finally(()=>clearTimeout(timer));
 }
+const YMD = /^\d{4}-\d{2}-\d{2}$/;
 export async function flyaiSearch(q) {
     const started = Date.now();
     const ts = new Date().toISOString();
@@ -40,29 +81,56 @@ export async function flyaiSearch(q) {
         kind: q.kind,
         latencyMs: 0
     };
-    const origin = (q.origin ?? '').trim();
-    const destination = (q.destination ?? '').trim();
-    if (!origin || !destination || !/^\d{4}-\d{2}-\d{2}$/.test(q.depDate ?? '')) {
-        return {
+    const argErr = (error)=>({
             ...base,
             ok: false,
             via: 'flyai-error',
             verdict: 'error',
             evidence: `[实时API:flyai@error@${ts}] bad args`,
-            error: 'origin/destination/depDate(YYYY-MM-DD) required'
-        };
+            error
+        });
+    let cliArgs;
+    if (q.kind === 'hotel') {
+        const dest = (q.destName ?? q.destination ?? '').trim();
+        if (!dest) return argErr('hotel 需要 to/destName(目的地中文)');
+        const badPair = (q.checkInDate ? 1 : 0) !== (q.checkOutDate ? 1 : 0) || q.checkInDate && q.checkOutDate && (!YMD.test(q.checkInDate) || !YMD.test(q.checkOutDate));
+        if (badPair) return argErr('checkInDate/checkOutDate 须成对且为 YYYY-MM-DD(未定档期可不带日期先摸底)');
+        cliArgs = [
+            'search-hotel',
+            '--dest-name',
+            dest,
+            ...q.checkInDate && q.checkOutDate ? [
+                '--check-in-date',
+                q.checkInDate,
+                '--check-out-date',
+                q.checkOutDate
+            ] : [],
+            ...q.keyWords ? [
+                '--key-words',
+                q.keyWords
+            ] : []
+        ];
+    } else {
+        const origin = (q.origin ?? '').trim();
+        const destination = (q.destination ?? '').trim();
+        if (!origin || !destination || !YMD.test(q.depDate ?? '')) {
+            return argErr('origin/destination/depDate(YYYY-MM-DD) required');
+        }
+        const sub = q.kind === 'flight' ? 'search-flight' : 'search-train';
+        cliArgs = [
+            sub,
+            '--origin',
+            origin,
+            '--destination',
+            destination,
+            '--dep-date',
+            q.depDate ?? ''
+        ];
     }
-    const sub = q.kind === 'flight' ? 'search-flight' : 'search-train';
     const r = await sh(q.cliBin ?? 'npx', [
         '-y',
         '@fly-ai/flyai-cli',
-        sub,
-        '--origin',
-        origin,
-        '--destination',
-        destination,
-        '--dep-date',
-        q.depDate
+        ...cliArgs
     ], {
         timeoutMs: q.timeoutMs ?? 30_000
     });
@@ -80,21 +148,46 @@ export async function flyaiSearch(q) {
     }
     let items;
     try {
-        const jStart = r.stdout.indexOf('{');
-        const parsed = JSON.parse(jStart >= 0 ? r.stdout.slice(jStart) : r.stdout);
-        items = parsed.data?.itemList ?? [];
-    } catch  {
+        items = parseFlyaiItemList(r.stdout);
+    } catch (e) {
         const raw = r.stdout.replace(/\s+/g, ' ').slice(0, 160);
+        const reason = e instanceof Error ? e.message : String(e);
         return {
             ...base,
             latencyMs,
             ok: false,
             via: 'flyai-error',
             verdict: 'error',
-            evidence: `[实时API:flyai@error@${ts}] parse failed: ${raw}`,
-            error: `failed to parse flyai output as JSON: ${raw}`
+            evidence: `[实时API:flyai@error@${ts}] parse failed(${reason}): ${raw}`,
+            error: `failed to parse flyai output as JSON (${reason}): ${raw}`
+        };
+    }
+    if (q.kind === 'hotel') {
+        const hotels = parseHotelItems(items);
+        const verdict = hotels.length > 0 ? 'hit' : 'miss';
+        return {
+            kind: q.kind,
+            latencyMs,
+            ok: true,
+            via: 'flyai',
+            verdict,
+            evidence: `[实时API:flyai@${ts}] ${hotels.length}/${items.length} hotel options`,
+            hotels
         };
     }
+    const options = parseTransportItems(items);
+    const verdict = options.length > 0 ? 'hit' : 'miss';
+    return {
+        kind: q.kind,
+        latencyMs,
+        ok: true,
+        via: 'flyai',
+        verdict,
+        evidence: `[实时API:flyai@${ts}] ${options.length}/${items.length} ${q.kind} options`,
+        options
+    };
+}
+function parseTransportItems(items) {
     const options = [];
     for (const it of items){
         const seg = it.journeys?.[0]?.segments?.[0];
@@ -115,16 +208,28 @@ export async function flyaiSearch(q) {
             jumpUrl: it.jumpUrl
         });
     }
-    const verdict = options.length > 0 ? 'hit' : 'miss';
-    return {
-        kind: q.kind,
-        latencyMs,
-        ok: true,
-        via: 'flyai',
-        verdict,
-        evidence: `[实时API:flyai@${ts}] ${options.length}/${items.length} ${q.kind} options`,
-        options
-    };
+    return options;
+}
+function parseHotelItems(items) {
+    const hotels = [];
+    for (const it of items){
+        if (!it.name) continue;
+        const rawPrice = String(it.price ?? '');
+        const bare = rawPrice.replace(/^[¥]/, '');
+        const numericPrice = Number(bare);
+        hotels.push({
+            name: it.name,
+            star: it.star,
+            price: /^\d+(\.\d+)?$/.test(bare) && numericPrice > 0 ? numericPrice : 0,
+            priceRaw: rawPrice || undefined,
+            rate: it.rate != null ? String(it.rate) : undefined,
+            address: it.address,
+            poi: it.interestsPoi,
+            hotelId: it.shId,
+            jumpUrl: it.detailUrl
+        });
+    }
+    return hotels;
 }
 
 

package/dist/capabilities/hbcli.js

@@ -115,10 +115,22 @@ export async function searchHotels(query, opts = {}) {
         try {
             const { readFile } = await import('node:fs/promises');
             const pack = JSON.parse(await readFile(fallback, 'utf-8'));
+            const kw = query.destination.trim();
+            const stays = Array.isArray(pack.stays) ? pack.stays : [];
+            const matched = kw ? stays.filter((s)=>JSON.stringify(s).includes(kw)) : stays;
+            if (matched.length) {
+                return {
+                    ...live,
+                    hotels: {
+                        stays: matched
+                    },
+                    summary: `${query.destination}:hbcli 不可用(${live.error ?? live.via}),降级到静态包,命中 ${matched.length} 个住宿块`
+                };
+            }
             return {
                 ...live,
-                hotels: pack,
-                summary: `${query.destination}:hbcli 不可用(${live.error ?? live.via}),降级到静态包`
+                hotels: null,
+                summary: `${query.destination}:hbcli 不可用(${live.error ?? live.via}),且静态包无「${query.destination}」住宿数据(静态包仅覆盖内置场景)`
             };
         } catch  {}
     }

package/dist/capabilities/session/benchmark.js

@@ -0,0 +1,252 @@
+export const SESSION_BENCHMARK_SCHEMA_VERSION = 'session-double-source.v1';
+export const SESSION_FIELD_ACCURACY_THRESHOLD = 0.9;
+export const REQUIRED_COMPARABLE_FIELDS = [
+    'query_id',
+    'route_segments',
+    'journey_type',
+    'route_segments[].departure_at',
+    'route_segments[].arrival_at',
+    'route_segments[].transport_number',
+    'currency',
+    'price',
+    'source',
+    'fetched_at',
+    'verdict'
+];
+function isMissing(value) {
+    return value === undefined || value === null || typeof value === 'string' && value.trim() === '';
+}
+function sameValue(left, right) {
+    if (typeof left !== typeof right) return false;
+    return typeof left === 'number' && typeof right === 'number' ? Object.is(left, right) : left === right;
+}
+function sameComparison(row) {
+    if (/\.(?:departure_at|arrival_at)$/.test(row.path) && typeof row.expected === 'string' && typeof row.actual === 'string') {
+        const expectedAt = Date.parse(row.expected);
+        const actualAt = Date.parse(row.actual);
+        if (Number.isFinite(expectedAt) && Number.isFinite(actualAt)) return expectedAt === actualAt;
+    }
+    return sameValue(row.expected, row.actual);
+}
+function fixtureComparisons(expected, actual) {
+    const rows = [
+        {
+            path: 'query_id',
+            expected: expected.query_id,
+            actual: actual.query_id
+        },
+        {
+            path: 'route_segments.length',
+            expected: expected.route_segments.length,
+            actual: actual.route_segments?.length
+        },
+        {
+            path: 'journey_type',
+            expected: expected.journey_type,
+            actual: actual.journey_type
+        },
+        {
+            path: 'currency',
+            expected: expected.currency,
+            actual: actual.currency
+        },
+        {
+            path: 'price',
+            expected: expected.price,
+            actual: actual.price
+        },
+        {
+            path: 'source',
+            expected: expected.source,
+            actual: actual.source
+        },
+        {
+            path: 'fetched_at',
+            expected: expected.fetched_at,
+            actual: actual.fetched_at
+        },
+        {
+            path: 'verdict',
+            expected: expected.verdict,
+            actual: actual.verdict
+        }
+    ];
+    for(let index = 0; index < expected.route_segments.length; index += 1){
+        const exp = expected.route_segments[index];
+        const act = actual.route_segments?.[index];
+        rows.push({
+            path: `route_segments[${index}].from`,
+            expected: exp.from,
+            actual: act?.from
+        }, {
+            path: `route_segments[${index}].to`,
+            expected: exp.to,
+            actual: act?.to
+        }, {
+            path: `route_segments[${index}].departure_at`,
+            expected: exp.departure_at,
+            actual: act?.departure_at
+        }, {
+            path: `route_segments[${index}].arrival_at`,
+            expected: exp.arrival_at,
+            actual: act?.arrival_at
+        }, {
+            path: `route_segments[${index}].transport_number`,
+            expected: exp.transport_number,
+            actual: act?.transport_number
+        });
+    }
+    return rows;
+}
+export function scoreSessionFixture(expected, actual, threshold = SESSION_FIELD_ACCURACY_THRESHOLD) {
+    const rows = fixtureComparisons(expected, actual);
+    const fixtureErrors = [
+        ...rows.filter((row)=>isMissing(row.expected)).map((row)=>row.path),
+        ...requiredMissing(expected)
+    ];
+    const missing = [];
+    const incorrect = [];
+    let correct = 0;
+    for (const row of rows){
+        if (isMissing(row.actual)) {
+            missing.push(row.path);
+        } else if (!sameValue(row.expected, row.actual)) {
+            incorrect.push(row.path);
+        } else {
+            correct += 1;
+        }
+    }
+    const total = rows.length;
+    const accuracy = total > 0 ? correct / total : 0;
+    return {
+        pass: fixtureErrors.length === 0 && accuracy >= threshold,
+        threshold,
+        correct,
+        total,
+        accuracy,
+        missing,
+        incorrect,
+        fixture_errors: [
+            ...new Set(fixtureErrors)
+        ]
+    };
+}
+function isIsoTimestamp(value) {
+    return value.trim() !== '' && Number.isFinite(Date.parse(value));
+}
+function requiredMissing(record) {
+    const missing = [];
+    if (!record.query_id.trim()) missing.push('query_id');
+    if (record.route_segments.length === 0) missing.push('route_segments');
+    if (!record.currency.trim()) missing.push('currency');
+    if (!(record.price > 0)) missing.push('price');
+    if (!record.source.trim()) missing.push('source');
+    if (!isIsoTimestamp(record.fetched_at)) missing.push('fetched_at');
+    if (record.journey_type === 'direct' && record.route_segments.length !== 1) missing.push('journey_type/route_segments');
+    if (record.journey_type === 'transfer' && record.route_segments.length < 2) missing.push('journey_type/route_segments');
+    for(let index = 0; index < record.route_segments.length; index += 1){
+        const segment = record.route_segments[index];
+        if (!segment.from.trim()) missing.push(`route_segments[${index}].from`);
+        if (!segment.to.trim()) missing.push(`route_segments[${index}].to`);
+        if (!isIsoTimestamp(segment.departure_at)) missing.push(`route_segments[${index}].departure_at`);
+        if (!isIsoTimestamp(segment.arrival_at)) missing.push(`route_segments[${index}].arrival_at`);
+        if (!segment.transport_number.trim()) missing.push(`route_segments[${index}].transport_number`);
+    }
+    return missing;
+}
+function baseEvaluation(state, quotaDisposition, extra = {}) {
+    return {
+        state,
+        retry_allowed: false,
+        quota_disposition: quotaDisposition,
+        mismatches: extra.mismatches ?? [],
+        missing: extra.missing ?? [],
+        ...extra.price_delta === undefined ? {} : {
+            price_delta: extra.price_delta
+        }
+    };
+}
+function alignmentComparisons(official, session) {
+    const rows = [
+        {
+            path: 'query_id',
+            expected: official.query_id,
+            actual: session.query_id
+        },
+        {
+            path: 'route_segments.length',
+            expected: official.route_segments.length,
+            actual: session.route_segments.length
+        },
+        {
+            path: 'journey_type',
+            expected: official.journey_type,
+            actual: session.journey_type
+        },
+        {
+            path: 'currency',
+            expected: official.currency,
+            actual: session.currency
+        }
+    ];
+    const comparableSegments = Math.min(official.route_segments.length, session.route_segments.length);
+    for(let index = 0; index < comparableSegments; index += 1){
+        const exp = official.route_segments[index];
+        const act = session.route_segments[index];
+        rows.push({
+            path: `route_segments[${index}].from`,
+            expected: exp.from,
+            actual: act.from
+        }, {
+            path: `route_segments[${index}].to`,
+            expected: exp.to,
+            actual: act.to
+        }, {
+            path: `route_segments[${index}].departure_at`,
+            expected: exp.departure_at,
+            actual: act.departure_at
+        }, {
+            path: `route_segments[${index}].arrival_at`,
+            expected: exp.arrival_at,
+            actual: act.arrival_at
+        }, {
+            path: `route_segments[${index}].transport_number`,
+            expected: exp.transport_number,
+            actual: act.transport_number
+        });
+    }
+    return rows;
+}
+export function evaluateDoubleSource(input) {
+    const official = input.official;
+    const session = input.session;
+    if (session?.verdict === 'challenged' || official?.verdict === 'challenged') {
+        return baseEvaluation('challenge_stop', 'no_spend_stop');
+    }
+    if ((session?.read_guard_blocked ?? 0) !== 0 || (official?.read_guard_blocked ?? 0) !== 0) {
+        return baseEvaluation('guard_violation', 'no_spend_stop');
+    }
+    if (!session) return baseEvaluation('source_unavailable', 'no_spend_stop');
+    if (session.verdict === 'needs-attach') return baseEvaluation('waiting_attach', 'no_spend_waiting_user');
+    if (session.verdict === 'needs-login') return baseEvaluation('waiting_login', 'no_spend_waiting_user');
+    if (!official || official.verdict !== 'hit' || session.verdict !== 'hit') {
+        return baseEvaluation('source_unavailable', 'no_spend_stop');
+    }
+    const missing = [
+        ...requiredMissing(official).map((path)=>`official.${path}`),
+        ...requiredMissing(session).map((path)=>`session.${path}`)
+    ];
+    if (missing.length > 0) {
+        return baseEvaluation('invalid_contract', 'no_spend_stop', {
+            missing
+        });
+    }
+    const mismatches = alignmentComparisons(official, session).filter((row)=>!sameComparison(row)).map((row)=>row.path);
+    return baseEvaluation(mismatches.length === 0 ? 'comparable' : 'divergent', 'evidence_ready', {
+        mismatches,
+        price_delta: session.price - official.price
+    });
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/session/benchmark.ts

package/dist/capabilities/session/transport.js

@@ -76,21 +76,26 @@ export async function openSession(opts = {}) {
         }
     }
     let guard;
-    try {
-        guard = await attachReadGuardPuppeteer(browser, opts.auditPath);
-    } catch (e) {
-        await (isCdp ? browser.disconnect() : browser.close()).catch(()=>{});
-        return {
-            ok: false,
-            summary: `read-guard attach failed: ${e instanceof Error ? e.message.split('\n')[0] : String(e)}`
-        };
+    if (opts.guard !== false) {
+        try {
+            guard = await attachReadGuardPuppeteer(browser, opts.auditPath);
+        } catch (e) {
+            await (isCdp ? browser.disconnect() : browser.close()).catch(()=>{});
+            return {
+                ok: false,
+                summary: `read-guard attach failed: ${e instanceof Error ? e.message.split('\n')[0] : String(e)}`
+            };
+        }
     }
     const page = (await browser.pages())[0] ?? await browser.newPage();
     return {
         ok: true,
         browser,
         page,
-        guard,
+        guard: guard ?? {
+            blockedCount: ()=>0,
+            requestCount: ()=>0
+        },
         close: async ()=>{
             await (isCdp ? browser.disconnect() : browser.close()).catch(()=>{});
         }