@danceiny/gotry 0.0.1-rc.18 → 0.0.1-rc.20

package/dist/src/benchmark-environment-bridge.js

@@ -1,12 +1,19 @@
 import { accessSync, constants, lstatSync, readFileSync, statSync } from 'node:fs';
 import { getuid } from 'node:process';
 import { isAbsolute } from 'node:path';
-import { defineTool } from '@deepseek-ai/dsh-tools';
+import { assertSupportedJsonSchema, validateJsonSchemaValue, ToolArgsError } from '@deepseek-ai/dsh-tools';
 import { validateTerminalOutputConfig } from './benchmark-agent-conformance.js';
-const SCHEMA_VERSION = 'gotry_benchmark_environment_bridge_v2';
+const SCHEMA_VERSION = 'gotry_benchmark_environment_bridge_v3';
+export const BENCHMARK_TOOL_RESULT_SCHEMA_VERSION = 'gotry_benchmark_tool_result_v1';
+export const BENCHMARK_DOMAIN_RECOVERIES = [
+    'none',
+    'retry_same',
+    'revise_arguments',
+    'choose_alternative'
+];
 const IDENTIFIER = /^[A-Za-z][A-Za-z0-9_.-]*$/;
+const RECOVERIES = new Set(BENCHMARK_DOMAIN_RECOVERIES);
 const CONFIG_KEYS = [
-    'allowed_tools',
     'argv_prefix',
     'cwd',
     'enabled',
@@ -15,14 +22,87 @@ const CONFIG_KEYS = [
     'max_output_bytes',
     'schema_version',
     'terminal_output',
-    'timeout_ms'
-];
-const OPTIONAL_CONFIG_KEYS = [
-    'allowed_output_keys'
+    'timeout_ms',
+    'tools'
 ];
+const INPUT_SCHEMA_MAX_BYTES = 16 * 1024;
+const INPUT_SCHEMA_MAX_DEPTH = 8;
+const INPUT_SCHEMA_MAX_NODES = 256;
+const INPUT_SCHEMA_MAX_PROPERTIES = 256;
+const INPUT_SCHEMA_MAX_ENUM_VALUES = 256;
+const INPUT_SCHEMA_MAX_DESCRIPTION_LENGTH = 512;
+const INPUT_SCHEMA_TYPES = new Set([
+    'string',
+    'number',
+    'integer',
+    'boolean',
+    'null',
+    'array',
+    'object'
+]);
+function descriptorSchema(tools) {
+    return {
+        oneOf: [
+            {
+                type: 'object',
+                description: 'List the frozen benchmark tool descriptors.',
+                properties: {
+                    action: {
+                        type: 'string',
+                        const: 'tools'
+                    }
+                },
+                required: [
+                    'action'
+                ],
+                additionalProperties: false
+            },
+            {
+                type: 'object',
+                description: 'List the frozen bridge error contract.',
+                properties: {
+                    action: {
+                        type: 'string',
+                        const: 'errors'
+                    }
+                },
+                required: [
+                    'action'
+                ],
+                additionalProperties: false
+            },
+            ...tools.map((tool)=>({
+                    type: 'object',
+                    description: tool.description,
+                    properties: {
+                        action: {
+                            type: 'string',
+                            const: 'call'
+                        },
+                        tool: {
+                            type: 'string',
+                            const: tool.name
+                        },
+                        arguments: tool.input_schema
+                    },
+                    required: [
+                        'action',
+                        'tool',
+                        'arguments'
+                    ],
+                    additionalProperties: false
+                }))
+        ]
+    };
+}
 function plainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function deepFreezeJson(value) {
+    if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value;
+    for (const child of Object.values(value))deepFreezeJson(child);
+    return Object.freeze(value);
+}
 function existingExecutable(value) {
     if (typeof value !== 'string' || !isAbsolute(value)) return false;
     try {
@@ -41,13 +121,121 @@ function existingDirectory(value) {
         return false;
     }
 }
-function identifiers(value) {
-    return Array.isArray(value) && value.length > 0 && value.length <= 64 && new Set(value).size === value.length && value.every((item)=>typeof item === 'string' && item.length > 0 && IDENTIFIER.test(item));
+function identifiers(value, allowEmpty = false) {
+    return Array.isArray(value) && (allowEmpty || value.length > 0) && value.length <= 64 && new Set(value).size === value.length && value.every((item)=>typeof item === 'string' && item.length > 0 && IDENTIFIER.test(item));
+}
+function exactKeys(value, allowed) {
+    return Object.keys(value).every((key)=>allowed.includes(key));
+}
+function validDescription(value, required = false) {
+    if (value === undefined) return !required;
+    return typeof value === 'string' && (!required || value.trim().length > 0) && value.length <= INPUT_SCHEMA_MAX_DESCRIPTION_LENGTH && !/[\u0000-\u001f\u007f]/.test(value);
 }
-function allowedOutputKeys(value, allowedTools) {
+function scalarMatches(type, value) {
+    if (type === 'string') return typeof value === 'string' && value.length <= 512;
+    if (type === 'number') return typeof value === 'number' && Number.isFinite(value);
+    if (type === 'integer') return typeof value === 'number' && Number.isSafeInteger(value);
+    if (type === 'boolean') return typeof value === 'boolean';
+    return type === 'null' && value === null;
+}
+function validInputSchema(value) {
     if (!plainObject(value)) return false;
-    const keys = Object.keys(value);
-    return keys.length > 0 && keys.length <= 64 && keys.every((tool)=>allowedTools.includes(tool) && identifiers(value[tool]));
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    } catch  {
+        return false;
+    }
+    if (Buffer.byteLength(serialized, 'utf8') > INPUT_SCHEMA_MAX_BYTES) return false;
+    const pending = [
+        {
+            node: value,
+            depth: 0
+        }
+    ];
+    const seen = new Set();
+    let nodes = 0;
+    let properties = 0;
+    let enumValues = 0;
+    while(pending.length > 0){
+        const { node, depth } = pending.pop();
+        if (seen.has(node) || ++nodes > INPUT_SCHEMA_MAX_NODES || depth > INPUT_SCHEMA_MAX_DEPTH) return false;
+        seen.add(node);
+        if (!INPUT_SCHEMA_TYPES.has(String(node.type)) || !validDescription(node.description)) return false;
+        if (node.type === 'object') {
+            if (!exactKeys(node, [
+                'type',
+                'description',
+                'properties',
+                'required',
+                'additionalProperties'
+            ]) || !plainObject(node.properties) || !Array.isArray(node.required) || node.additionalProperties !== false) return false;
+            const propertyEntries = Object.entries(node.properties);
+            properties += propertyEntries.length;
+            if (properties > INPUT_SCHEMA_MAX_PROPERTIES || propertyEntries.some(([key, child])=>!IDENTIFIER.test(key) || !plainObject(child))) return false;
+            const required = node.required;
+            if (required.length > propertyEntries.length || new Set(required).size !== required.length || required.some((key)=>typeof key !== 'string' || !Object.hasOwn(node.properties, key))) return false;
+            for (const [, child] of propertyEntries)pending.push({
+                node: child,
+                depth: depth + 1
+            });
+            continue;
+        }
+        if (node.type === 'array') {
+            if (!exactKeys(node, [
+                'type',
+                'description',
+                'items'
+            ]) || !plainObject(node.items)) return false;
+            pending.push({
+                node: node.items,
+                depth: depth + 1
+            });
+            continue;
+        }
+        if (!exactKeys(node, [
+            'type',
+            'description',
+            'enum',
+            'const'
+        ]) || Object.hasOwn(node, 'enum') && Object.hasOwn(node, 'const')) return false;
+        if (Object.hasOwn(node, 'const') && !scalarMatches(String(node.type), node.const)) return false;
+        if (Object.hasOwn(node, 'enum')) {
+            if (!Array.isArray(node.enum) || node.enum.length === 0 || node.enum.length > 64) return false;
+            enumValues += node.enum.length;
+            if (enumValues > INPUT_SCHEMA_MAX_ENUM_VALUES || new Set(node.enum).size !== node.enum.length || node.enum.some((item)=>!scalarMatches(String(node.type), item))) return false;
+        }
+    }
+    return value.type === 'object';
+}
+function toolDescriptors(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 64) return false;
+    const names = new Set();
+    return value.every((item)=>{
+        if (!plainObject(item)) return false;
+        const keys = Object.keys(item).sort();
+        const required = [
+            'description',
+            'domain_outcomes',
+            'input_schema',
+            'name'
+        ];
+        if (JSON.stringify(keys) !== JSON.stringify([
+            ...required,
+            'output_keys'
+        ].sort())) return false;
+        if (typeof item.name !== 'string' || !IDENTIFIER.test(item.name) || names.has(item.name)) return false;
+        names.add(item.name);
+        if (!validDescription(item.description, true) || !validInputSchema(item.input_schema)) return false;
+        if (!Array.isArray(item.domain_outcomes) || item.domain_outcomes.length > 64) return false;
+        const outcomeKeys = new Set();
+        if (!item.domain_outcomes.every((outcome)=>plainObject(outcome) && JSON.stringify(Object.keys(outcome).sort()) === JSON.stringify([
+                'code',
+                'recovery',
+                'status'
+            ]) && (outcome.status === 'miss' || outcome.status === 'error') && typeof outcome.code === 'string' && IDENTIFIER.test(outcome.code) && typeof outcome.recovery === 'string' && RECOVERIES.has(outcome.recovery) && !outcomeKeys.has(outcome.code) && (outcomeKeys.add(outcome.code), true))) return false;
+        return identifiers(item.output_keys);
+    });
 }
 function argvPrefix(value) {
     return Array.isArray(value) && value.length > 0 && value.length <= 32 && value.every((item)=>typeof item === 'string' && item.length > 0 && item.length <= 256 && !item.includes('\0') && !item.includes('\r') && !item.includes('\n'));
@@ -69,14 +257,7 @@ function validate(value) {
     const baseKeys = [
         ...CONFIG_KEYS
     ].sort();
-    const extendedKeys = [
-        ...CONFIG_KEYS,
-        ...OPTIONAL_CONFIG_KEYS
-    ].sort();
-    if (!plainObject(value) || ![
-        baseKeys,
-        extendedKeys
-    ].some((keys)=>JSON.stringify(configKeys) === JSON.stringify(keys)) || value.schema_version !== SCHEMA_VERSION || value.enabled !== true || !existingExecutable(value.executable) || !existingDirectory(value.cwd) || !argvPrefix(value.argv_prefix) || !identifiers(value.allowed_tools) || !validBound(value.timeout_ms, 120_000) || !validBound(value.max_output_bytes, 10 * 1024 * 1024) || !validateTerminalOutputConfig(value.terminal_output) || !exactIsolation(value.isolation) || Object.hasOwn(value, 'allowed_output_keys') && !allowedOutputKeys(value.allowed_output_keys, value.allowed_tools)) return false;
+    if (!plainObject(value) || JSON.stringify(configKeys) !== JSON.stringify(baseKeys) || value.schema_version !== SCHEMA_VERSION || value.enabled !== true || !existingExecutable(value.executable) || !existingDirectory(value.cwd) || !argvPrefix(value.argv_prefix) || !toolDescriptors(value.tools) || !validBound(value.timeout_ms, 120_000) || !validBound(value.max_output_bytes, 10 * 1024 * 1024) || !validateTerminalOutputConfig(value.terminal_output) || !exactIsolation(value.isolation)) return false;
     return true;
 }
 export function loadBenchmarkEnvironmentConfig(path) {
@@ -87,7 +268,7 @@ export function loadBenchmarkEnvironmentConfig(path) {
         if (typeof getuid !== 'function' || metadata.uid !== getuid()) return null;
         if ((metadata.mode & 0o022) !== 0) return null;
         const parsed = JSON.parse(readFileSync(path, 'utf8'));
-        return validate(parsed) ? parsed : null;
+        return validate(parsed) ? deepFreezeJson(parsed) : null;
     } catch  {
         return null;
     }
@@ -116,6 +297,48 @@ const FORBIDDEN_OUTPUT_KEY_FRAGMENTS = [
     'reward',
     'score'
 ];
+export const BRIDGE_ERROR_CONTRACT = Object.freeze({
+    invalid_action: {
+        recoverable: true,
+        remedy: 'action 只允许 tools、call 或 errors'
+    },
+    disallowed_tool: {
+        recoverable: true,
+        remedy: '先 action=tools 列出 allowed_tools 清单,再从清单内选工具'
+    },
+    invalid_arguments: {
+        recoverable: true,
+        remedy: 'arguments 必须是可序列化 JSON 对象(≤64KB、深度≤12);收窄后重试'
+    },
+    timed_out: {
+        recoverable: true,
+        remedy: '上游超时;可原样重试一次或换其他工具'
+    },
+    output_truncated: {
+        recoverable: true,
+        remedy: '输出超出上限;让被调工具收窄查询范围后重试'
+    },
+    invalid_json: {
+        recoverable: true,
+        remedy: '上游输出不是合法 JSON;重试一次或换工具'
+    },
+    invalid_output: {
+        recoverable: true,
+        remedy: '上游输出结构不符;重试或换工具'
+    },
+    runner_failed: {
+        recoverable: true,
+        remedy: '上游进程非零退出;可重试一次,持续失败换工具'
+    },
+    spawn_failed: {
+        recoverable: false,
+        remedy: '可执行文件不可用——环境问题,调用方不可恢复'
+    },
+    forbidden_output: {
+        recoverable: false,
+        remedy: '输出含未授权键(策略边界)——不可恢复,换工具或放弃'
+    }
+});
 function inspectOutput(value) {
     const pending = [
         {
@@ -152,7 +375,8 @@ function inspectAllowedOutput(value, allowedKeys) {
     const pending = [
         {
             value,
-            depth: 0
+            depth: 0,
+            coveredByDeclaredKey: false
         }
     ];
     let nodes = 0;
@@ -162,16 +386,21 @@ function inspectAllowedOutput(value, allowedKeys) {
         if (Array.isArray(current.value)) {
             for (const child of current.value)pending.push({
                 value: child,
-                depth: current.depth + 1
+                depth: current.depth + 1,
+                coveredByDeclaredKey: current.coveredByDeclaredKey
             });
             continue;
         }
-        if (!plainObject(current.value)) continue;
+        if (!plainObject(current.value)) {
+            if (!current.coveredByDeclaredKey) return false;
+            continue;
+        }
         for (const [key, child] of Object.entries(current.value)){
             if (!allowed.has(key)) return false;
             pending.push({
                 value: child,
-                depth: current.depth + 1
+                depth: current.depth + 1,
+                coveredByDeclaredKey: true
             });
         }
     }
@@ -215,20 +444,16 @@ export function registerBenchmarkEnvironmentBridge(path, register, subprocess) {
     const bridge = loadBenchmarkEnvironmentConfig(path);
     if (!bridge) throw new Error('benchmark environment bridge configuration unavailable');
     if (!subprocess) throw new Error('benchmark environment bridge subprocess unavailable');
-    register(defineTool({
+    const parameters = deepFreezeJson({
+        oneOf: descriptorSchema(bridge.tools).oneOf
+    });
+    assertSupportedJsonSchema(parameters);
+    const definition = {
         name: 'gotry_benchmark_environment',
         description: 'When a prompt asks to run agent_env.cli, use action=call here with the mapped tool; arbitrary shell is not exposed.',
-        parameters: {
-            query: {
-                type: 'json',
-                required: true,
-                description: '{ action: "tools" | "call", tool?: string, arguments?: object }'
-            }
-        },
+        parameters,
         output: {
-            schema: {
-                type: 'json'
-            },
+            schema: {},
             render: (_args, value)=>[
                     {
                         type: 'text',
@@ -237,28 +462,45 @@ export function registerBenchmarkEnvironmentBridge(path, register, subprocess) {
                 ]
         },
         async execute (args) {
-            const query = plainObject(args?.query) ? args.query : {};
+            const violations = validateJsonSchemaValue(parameters, args, 'arguments');
+            if (violations.length > 0) throw new ToolArgsError(violations);
+            const query = args;
+            const tool = query.tool;
+            const descriptor = bridge.tools.find((item)=>item.name === tool);
             if (query.action === 'tools') return jsonObject({
                 ok: true,
-                tools: bridge.allowed_tools
+                tools: bridge.tools
             });
-            if (query.action !== 'call') return jsonObject({
-                ok: false,
-                error: 'invalid_action'
+            if (query.action === 'errors') return jsonObject({
+                ok: true,
+                errors: BRIDGE_ERROR_CONTRACT
             });
-            if (typeof query.tool !== 'string' || !bridge.allowed_tools.includes(query.tool)) {
+            if (query.action !== 'call') {
+                return jsonObject({
+                    ok: false,
+                    error: 'invalid_action'
+                });
+            }
+            if (typeof tool !== 'string' || !descriptor) {
                 return jsonObject({
                     ok: false,
                     error: 'disallowed_tool'
                 });
             }
-            if (query.arguments !== undefined && !plainObject(query.arguments)) {
+            if (!plainObject(query.arguments)) {
+                return jsonObject({
+                    ok: false,
+                    error: 'invalid_arguments'
+                });
+            }
+            const callArguments = query.arguments;
+            const argumentViolations = validateJsonSchemaValue(descriptor.input_schema, callArguments, 'arguments');
+            if (argumentViolations.length > 0) {
                 return jsonObject({
                     ok: false,
                     error: 'invalid_arguments'
                 });
             }
-            const callArguments = query.arguments === undefined ? {} : query.arguments;
             const serialized = serializedArguments(callArguments);
             if (serialized.reason) return jsonObject({
                 ok: false,
@@ -291,7 +533,7 @@ export function registerBenchmarkEnvironmentBridge(path, register, subprocess) {
                         bridge.executable,
                         ...bridge.argv_prefix,
                         'call',
-                        query.tool,
+                        tool,
                         serialized.json
                     ],
                     cwd: bridge.cwd,
@@ -341,13 +583,36 @@ export function registerBenchmarkEnvironmentBridge(path, register, subprocess) {
                     ok: false,
                     error: 'invalid_output'
                 });
-                const visibleResult = parsed.result ?? parsed;
+                if (parsed.schema_version !== BENCHMARK_TOOL_RESULT_SCHEMA_VERSION || typeof parsed.status !== 'string') {
+                    return jsonObject({
+                        ok: false,
+                        error: 'invalid_output'
+                    });
+                }
+                if (parsed.status === 'miss' || parsed.status === 'error') {
+                    if (typeof parsed.code !== 'string' || typeof parsed.recovery !== 'string' || !descriptor.domain_outcomes.some((outcome)=>outcome.status === parsed.status && outcome.code === parsed.code && outcome.recovery === parsed.recovery)) return jsonObject({
+                        ok: false,
+                        error: 'invalid_output'
+                    });
+                    if (Object.keys(parsed).sort().join(',') !== 'code,recovery,schema_version,status') return jsonObject({
+                        ok: false,
+                        error: 'invalid_output'
+                    });
+                    return jsonObject({
+                        ok: true,
+                        outcome: parsed
+                    });
+                }
+                if (parsed.status !== 'ok' || !Object.hasOwn(parsed, 'result') || Object.keys(parsed).sort().join(',') !== 'result,schema_version,status') return jsonObject({
+                    ok: false,
+                    error: 'invalid_output'
+                });
+                const visibleResult = parsed.result;
                 if (!plainObject(visibleResult) && !Array.isArray(visibleResult)) return jsonObject({
                     ok: false,
                     error: 'invalid_output'
                 });
-                const outputKeys = bridge.allowed_output_keys && Object.hasOwn(bridge.allowed_output_keys, query.tool) ? bridge.allowed_output_keys[query.tool] : undefined;
-                if (outputKeys && !inspectAllowedOutput(visibleResult, outputKeys)) return jsonObject({
+                if (!inspectAllowedOutput(visibleResult, descriptor.output_keys)) return jsonObject({
                     ok: false,
                     error: 'forbidden_output'
                 });
@@ -368,12 +633,11 @@ export function registerBenchmarkEnvironmentBridge(path, register, subprocess) {
                 clearTimeout(timer);
             }
         }
-    }));
+    };
+    register(definition);
     return Object.freeze({
         toolName: 'gotry_benchmark_environment',
-        allowedTools: Object.freeze([
-            ...bridge.allowed_tools
-        ]),
+        allowedTools: Object.freeze(bridge.tools.map((item)=>item.name)),
         terminal: Object.freeze({
             ...bridge.terminal_output
         })

package/dist/src/bookable-facts.js

@@ -52,7 +52,7 @@ export function factsFromFlyai(q, r, fetchedAt, alias) {
     const queryId = makeQueryId(source, q.kind, q.origin, q.destination, q.date);
     const origin = iataOf(alias, q.origin);
     const destination = iataOf(alias, q.destination);
-    if (r.verdict === 'error') return [];
+    if (r.verdict === 'error' || r.verdict === 'needs-setup') return [];
     if (r.verdict === 'miss') return [
         negativeFact(queryId, q.kind, q.origin, q.destination, q.date, source, fetchedAt, alias)
     ];
@@ -159,7 +159,7 @@ export function dedupeFacts(facts) {
     ].sort((a, b)=>a.fetched_at.localeCompare(b.fetched_at) || a.fact_id.localeCompare(b.fact_id));
 }
 export function latestFactsForRouteDate(facts, origin, destination, date) {
-    const hits = facts.filter((f)=>f.kind !== 'policy' && f.route.origin === origin && f.route.destination === destination && f.date === date);
+    const hits = facts.filter((f)=>(f.kind === 'flight' || f.kind === 'train') && f.route.origin === origin && f.route.destination === destination && f.date === date);
     const latestQueryTs = new Map();
     for (const f of hits){
         const prev = latestQueryTs.get(f.query_id);
@@ -173,7 +173,7 @@ export function latestFactsForRouteDate(facts, origin, destination, date) {
 }
 export function flightClaimVerdict(facts, claim) {
     const no = claim.flight_no.toUpperCase().replace(/\s+/g, '');
-    const sameNo = facts.filter((f)=>f.kind !== 'policy' && f.flight_no.toUpperCase() === no && f.bookability === 'bookable_exact_date');
+    const sameNo = facts.filter((f)=>(f.kind === 'flight' || f.kind === 'train') && f.flight_no.toUpperCase() === no && f.bookability === 'bookable_exact_date');
     const routeMatched = sameNo.filter((f)=>(!claim.origin || f.route.origin === claim.origin || f.route.origin_airport === claim.origin) && (!claim.destination || f.route.destination === claim.destination || f.route.dest_airport === claim.destination) && (!claim.date || f.date === claim.date));
     if (routeMatched.length > 0) return {
         verdict: 'traceable',
@@ -310,6 +310,10 @@ export function defaultReviewBy(tripDate) {
     return d.toISOString().slice(0, 10);
 }
 export function renderFlightFact(f) {
+    return renderFlightFactInner(f) + ` <!-- fact:${f.fact_id} -->`;
+}
+function renderFlightFactInner(f) {
+    const anchor = ` <!-- fact:${f.fact_id} -->`;
     const route = `${f.route.origin}→${f.route.destination}`;
     const evidence = `[${f.source}@${f.fetched_at} #${f.query_id}]`;
     if (f.bookability === 'unavailable_exact_date') {
@@ -344,6 +348,61 @@ export function renderNightsLine(it) {
     const flightLegs = it.od_segments.filter((s)=>s.mode === 'flight').reduce((acc, s)=>acc + s.legs, 0);
     return `共 ${daysBetween(it.trip_start, it.trip_end) + 1} 天 ${totalNights} 晚 = ${hotelNights} 个酒店夜 + ${it.onboard_nights} 个机上夜;航班按 O&D ${flightOd} 段(共 ${flightLegs} 个 flight legs)`;
 }
+export function factsFromHotel(input) {
+    if (!input.checkIn || !input.checkOut) return [];
+    if (input.verdict !== 'hit' && input.verdict !== 'miss') return [];
+    const queryId = `hotel:${input.source}:${input.destination}:${input.checkIn}_${input.checkOut}`;
+    return [
+        {
+            schema: BOOKABLE_FACT_SCHEMA,
+            kind: 'hotel',
+            fact_id: makeFactId([
+                input.destination,
+                input.checkIn,
+                input.checkOut,
+                queryId
+            ]),
+            destination: input.destination,
+            check_in: input.checkIn,
+            check_out: input.checkOut,
+            verdict: input.verdict,
+            bookability: input.verdict === 'hit' ? 'bookable_exact_date' : 'unavailable_exact_date',
+            options_masked: input.options,
+            source: input.source,
+            query_id: queryId,
+            fetched_at: input.fetchedAt,
+            as_of: input.fetchedAt.slice(0, 10),
+            tier: 'live_inventory'
+        }
+    ];
+}
+export function hotelClaimVerdict(facts, claim) {
+    const scoped = facts.filter((f)=>f.kind === 'hotel' && f.destination === claim.destination && (!claim.check_in || f.check_in === claim.check_in) && (!claim.check_out || f.check_out === claim.check_out));
+    if (scoped.length === 0) {
+        return {
+            verdict: 'unverified',
+            reason: `酒店 claim(${claim.destination}${claim.check_in ? ` ${claim.check_in}→${claim.check_out ?? '?'}` : ''})未经 exact-date 源核验——先检索再写结论`
+        };
+    }
+    const hit = scoped.find((f)=>f.bookability === 'bookable_exact_date');
+    if (hit) return {
+        verdict: 'traceable',
+        fact: hit,
+        reason: 'exact-date 命中'
+    };
+    const latest = scoped[scoped.length - 1];
+    return {
+        verdict: 'not_in_source',
+        fact: latest,
+        reason: `该档期 exact-date 源正常返回 0 条(${latest.fetched_at})——不得写有房/可订`
+    };
+}
+export function renderHotelFact(f) {
+    if (f.verdict !== 'hit') {
+        return `- ${f.destination} ${f.check_in}→${f.check_out}:exact-date 源 0 条在架(不可订) <!-- fact:${f.fact_id} -->`;
+    }
+    return `- ${f.destination} ${f.check_in}→${f.check_out}:住宿已核验(在架 ${f.options_masked} 家;价格上游打码,真实价以落地页为准) <!-- fact:${f.fact_id} -->`;
+}
 
 
 //# sourceURL=ts/src/bookable-facts.ts