@danceiny/gotry 0.0.1-rc.21 → 0.0.1-rc.24

package/dist/src/subagent-job-id-guard.js

@@ -0,0 +1,58 @@
+const JOB_TOOLS = new Set(['job_output', 'job_kill']);
+function subagentsOf(ctx) {
+    try {
+        return ctx.subagents;
+    }
+    catch {
+        // Minimal hosts and benchmark contexts may not mount the optional service.
+        return undefined;
+    }
+}
+function jobIdOf(exec) {
+    if (!exec.arguments || typeof exec.arguments !== 'object')
+        return undefined;
+    const jobId = exec.arguments.job_id;
+    return typeof jobId === 'string' && jobId.length > 0 ? jobId : undefined;
+}
+function isContinuableChild(entry, jobId) {
+    return entry.kind === 'child' && entry.mode === 'continuable' && entry.id === jobId;
+}
+function recoveryReason(toolName, jobId) {
+    const stopHint = toolName === 'job_kill'
+        ? '; use interrupt_agent to stop its current turn.'
+        : '.';
+    return [
+        `SUBAGENT_ID_IS_NOT_JOB_ID: ${JSON.stringify(jobId)} is a continuable subagent durable id, not a background job id.`,
+        'Its completion arrives as a completion notice; use list_agents to inspect it and send_message to continue it',
+        stopHint,
+    ].join(' ');
+}
+/** Install the GoTry-owned safety net around dsh's jobs tools. */
+export function installSubagentJobIdGuard(ctx) {
+    const ctxOn = ctx.on;
+    if (typeof ctxOn !== 'function')
+        return;
+    ctx.on('tools/pre-execute', async (exec, next) => {
+        if (!JOB_TOOLS.has(exec.name))
+            return next();
+        const jobId = jobIdOf(exec);
+        const agent = exec.agent;
+        const subagents = subagentsOf(ctx);
+        if (!jobId || !agent || !subagents)
+            return next();
+        let children;
+        try {
+            children = await subagents.listChildren(agent.id, exec.signal);
+        }
+        catch (error) {
+            // The guard is diagnostic, not an alternate ownership or availability
+            // path. Preserve cancellation; otherwise retain dsh's native job error.
+            if (exec.signal.aborted)
+                throw error;
+            return next();
+        }
+        if (!children.some(entry => isContinuableChild(entry, jobId)))
+            return next();
+        return { kind: 'deny', reason: recoveryReason(exec.name, jobId) };
+    }, { prepend: true });
+}

package/dist/src/time-anchor.js

@@ -1,49 +1,146 @@
-const WEEKDAYS_ZH = [
-    '日',
-    '一',
-    '二',
-    '三',
-    '四',
-    '五',
-    '六'
-];
+/**
+ * 时间锚点层(确定性纯函数,零依赖):「今天是哪天、相对日期怎么换算」的算术全部在这里,
+ * LLM 只查锚点卡不自算(仓规:算术只在代码层;tool-owned dates 的执行面)。
+ *
+ * 消费面:
+ *  - dsh 成品路径:index.ts 注册 {{time_anchor_card}} 变量,系统时钟;
+ *  - legacy 抽取路径:dsh-llm.ts 注入 FACTS/SKELETON/槽位抽取 prompt;
+ *  - 评测:time-eval-tests.ts 用固定 now(2026-08-27)保证确定性。
+ *
+ * 节日锚点表 SPRING_FESTIVAL:由构建期生成器机械生成(issue #274 清偿 D-9 手抄债务,覆盖 2026-2099);
+ * 扩表/换库 = 重跑 ts/scripts/gen-lunar-anchors.ts(--check 为漂移闸,run-all §58)。
+ * 到期即红守卫 springFestivalHorizonOk:最晚锚点年份 < 当前年+3 时测试红;表耗尽后锚点卡
+ * 显式告警(不再静默省略)——「换个日子的同款债务」的静默耗尽模式已消灭。
+ */
+const WEEKDAYS_ZH = ['日', '一', '二', '三', '四', '五', '六'];
 export function ymd(d) {
     return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
 }
 function addDays(d, n) {
     return new Date(d.getFullYear(), d.getMonth(), d.getDate() + n);
 }
+/** ISO 周周一:getDay() 周日=0 归到上周一(-6) */
 function weekMonday(d) {
     return addDays(d, -((d.getDay() + 6) % 7));
 }
-const SPRING_FESTIVAL = {
+/**
+ * 春节锚点表(正月初一;仅此节日漂移大,故表驱动;元旦/国庆固定月日按「下一次发生」算)。
+ * 本块由构建期生成器机械生成,禁止手改(issue #274:手抄常量表=换个日子的同款债务,已否决)。
+ * provenance:lunar-typescript@1.8.6(MIT,零传递依赖,devDependency 不进 runtime)· 生成时间 2026-09-11T17:19:45.752Z
+ * 命令:cd ts && npx tsx scripts/gen-lunar-anchors.ts(扩表/换库=重跑;--check=漂移闸,run-all §58)
+ * 交叉验证:2026-2031 旧表 6 条 + 港天文台 2032-2040 核实 9 条逐条一致(time-eval §7 双 oracle)。
+ * 到期守卫:springFestivalHorizonOk——最晚锚点年份 < 当前年+3 测试即红(临近耗尽先红于静默缺失)。
+ */
+// [gen:lunar-anchors:begin] 生成块起点——手改会被下次生成覆盖
+export const SPRING_FESTIVAL = {
     2026: '2026-02-17',
     2027: '2027-02-06',
     2028: '2028-01-26',
     2029: '2029-02-13',
     2030: '2030-02-03',
-    2031: '2031-01-23'
+    2031: '2031-01-23',
+    2032: '2032-02-11',
+    2033: '2033-01-31',
+    2034: '2034-02-19',
+    2035: '2035-02-08',
+    2036: '2036-01-28',
+    2037: '2037-02-15',
+    2038: '2038-02-04',
+    2039: '2039-01-24',
+    2040: '2040-02-12',
+    2041: '2041-02-01',
+    2042: '2042-01-22',
+    2043: '2043-02-10',
+    2044: '2044-01-30',
+    2045: '2045-02-17',
+    2046: '2046-02-06',
+    2047: '2047-01-26',
+    2048: '2048-02-14',
+    2049: '2049-02-02',
+    2050: '2050-01-23',
+    2051: '2051-02-11',
+    2052: '2052-02-01',
+    2053: '2053-02-19',
+    2054: '2054-02-08',
+    2055: '2055-01-28',
+    2056: '2056-02-15',
+    2057: '2057-02-04',
+    2058: '2058-01-24',
+    2059: '2059-02-12',
+    2060: '2060-02-02',
+    2061: '2061-01-21',
+    2062: '2062-02-09',
+    2063: '2063-01-29',
+    2064: '2064-02-17',
+    2065: '2065-02-05',
+    2066: '2066-01-26',
+    2067: '2067-02-14',
+    2068: '2068-02-03',
+    2069: '2069-01-23',
+    2070: '2070-02-11',
+    2071: '2071-01-31',
+    2072: '2072-02-19',
+    2073: '2073-02-07',
+    2074: '2074-01-27',
+    2075: '2075-02-15',
+    2076: '2076-02-05',
+    2077: '2077-01-24',
+    2078: '2078-02-12',
+    2079: '2079-02-02',
+    2080: '2080-01-22',
+    2081: '2081-02-09',
+    2082: '2082-01-29',
+    2083: '2083-02-17',
+    2084: '2084-02-06',
+    2085: '2085-01-26',
+    2086: '2086-02-14',
+    2087: '2087-02-03',
+    2088: '2088-01-24',
+    2089: '2089-02-10',
+    2090: '2090-01-30',
+    2091: '2091-02-18',
+    2092: '2092-02-07',
+    2093: '2093-01-27',
+    2094: '2094-02-15',
+    2095: '2095-02-05',
+    2096: '2096-01-25',
+    2097: '2097-02-12',
+    2098: '2098-02-01',
+    2099: '2099-01-21',
 };
-function tzLabelOf(d) {
-    const offsetMin = -d.getTimezoneOffset();
-    const sign = offsetMin >= 0 ? '+' : '-';
-    const abs = Math.abs(offsetMin);
+// [gen:lunar-anchors:end]
+/** 到期即红守卫阈值(issue #274):最晚春节锚点年份必须 ≥ 当前年+3——临近耗尽先红于静默缺失。 */
+export const SPRING_FESTIVAL_HORIZON_MIN_YEARS = 3;
+/** 表内最晚锚点年份距 now 的年数(守卫与 time-eval §7 共用;旧表「牙齿证明」传表参)。 */
+export function springFestivalHorizonYears(table, now = new Date()) {
+    return Math.max(...Object.keys(table).map(Number)) - now.getFullYear();
+}
+/** D-9 到期即红守卫:最晚锚点年份 < 当前年+3 → 测试红(而非春节锚点静默缺失)。 */
+export function springFestivalHorizonOk(now = new Date()) {
+    return springFestivalHorizonYears(SPRING_FESTIVAL, now) >= SPRING_FESTIVAL_HORIZON_MIN_YEARS;
+}
+export function formatUtcOffsetLabel(utcOffsetMinutes) {
+    const sign = utcOffsetMinutes >= 0 ? '+' : '-';
+    const abs = Math.abs(utcOffsetMinutes);
     const h = Math.floor(abs / 60);
     const m = abs % 60;
-    return `UTC${sign}${m === 0 ? h : `${h}:${String(m).padStart(2, '0')}`}`;
+    return `UTC${sign}${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`;
+}
+function tzLabelOf(d) {
+    return formatUtcOffsetLabel(-d.getTimezoneOffset());
 }
 function weekdayOf(d) {
     return `周${WEEKDAYS_ZH[d.getDay()]}`;
 }
+/** 一周七天的渲染:周一 2026-08-31|周二 …|周日 … */
 function weekRow(label, monday) {
-    const days = Array.from({
-        length: 7
-    }, (_, i)=>{
+    const days = Array.from({ length: 7 }, (_, i) => {
         const d = addDays(monday, i);
         return `${weekdayOf(d)} ${ymd(d)}`;
     });
     return `${label}:${days.join('|')}`;
 }
+/** 固定月日节日的下一次发生(已过则取明年) */
 function nextOccurrence(todayYmd, year, monthDay) {
     const thisYear = `${year}-${monthDay}`;
     return thisYear >= todayYmd ? thisYear : `${year + 1}-${monthDay}`;
@@ -55,19 +152,24 @@ export function buildTimeAnchor(now = new Date()) {
     const tomorrow = addDays(now, 1);
     const dayAfter = addDays(now, 2);
     const inThreeDays = addDays(now, 3);
+    // 下个月:初(1-10)/中旬(11-20)/下旬(21-月末)
     const nm = new Date(year, now.getMonth() + 1, 1);
     const nmYear = nm.getFullYear();
     const nmMonth = nm.getMonth();
     const nmLastDay = new Date(nmYear, nmMonth + 1, 0).getDate();
     const mm = String(nmMonth + 1).padStart(2, '0');
+    // 下个季度初
     const nextQuarterMonth0 = Math.floor(now.getMonth() / 3) * 3 + 3;
     const nq = new Date(nextQuarterMonth0 >= 12 ? year + 1 : year, nextQuarterMonth0 % 12, 1);
     const festivals = [
         `国庆 ${nextOccurrence(today, year, '10-01')}`,
-        `元旦 ${nextOccurrence(today, year, '01-01')}`
+        `元旦 ${nextOccurrence(today, year, '01-01')}`,
     ];
-    const spring = Object.values(SPRING_FESTIVAL).filter((d)=>d >= today).sort()[0];
-    if (spring) festivals.push(`春节 ${spring}`);
+    const spring = Object.values(SPRING_FESTIVAL).filter(d => d >= today).sort()[0];
+    if (spring)
+        festivals.push(`春节 ${spring}`);
+    else
+        festivals.push('春节(锚点表已到期:重跑 ts/scripts/gen-lunar-anchors.ts 扩表,勿静默省略)');
     const card = [
         `今天 ${today} ${weekdayOf(now)}(时区 ${tzLabelOf(now)})`,
         `明天 ${ymd(tomorrow)} ${weekdayOf(tomorrow)}|后天 ${ymd(dayAfter)} ${weekdayOf(dayAfter)}|大后天 ${ymd(inThreeDays)} ${weekdayOf(inThreeDays)}`,
@@ -76,25 +178,121 @@ export function buildTimeAnchor(now = new Date()) {
         weekRow('下下周', addDays(monday, 14)),
         `下个月 ${nmYear}-${mm}:初 ${mm}-01~${mm}-10|中旬 ${mm}-11~${mm}-20|下旬 ${mm}-21~${mm}-${nmLastDay}`,
         `下个季度初:${ymd(nq)} 起`,
-        `节日锚点:${festivals.join('|')}(「国庆前」= 该日之前,以此类推)`
+        `节日锚点:${festivals.join('|')}(「国庆前」= 该日之前,以此类推)`,
     ].join('\n');
+    return { today, todayWeekdayZh: weekdayOf(now), tzLabel: tzLabelOf(now), card };
+}
+/**
+ * Extract the smallest named-year intent needed by the planning guard.
+ * Relative future years (今年/明年/后年/年内) resolve against the current
+ * TimeAnchor, so a future-tense phrase without a four-digit year still yields
+ * a named-year window. Historical bypass is intentionally narrow: a negated
+ * warning about past dates is not historical lookup, and multiple eligible
+ * years are ambiguous. Same-year restatements (「今年年内」「2026 年内」) are
+ * one window, not a conflict.
+ */
+export function parsePlanningWindow(text, anchor) {
+    const historical = /(?:回测|复盘|backtest|historical)|(?:历史|过去).{0,8}(?:查询|查|检索|回看|回测|复盘)|(?:查询|查|检索|回看).{0,8}(?:历史|过去)/i.test(text);
+    const anchorYear = Number(anchor.today.slice(0, 4));
+    const relativeYear = (token) => token === '今年' ? anchorYear : token === '明年' ? anchorYear + 1 : anchorYear + 2;
+    const matches = [];
+    for (const m of text.matchAll(/(?<!\d)(\d{4})\s*年/g)) {
+        const start = m.index ?? 0;
+        matches.push({ year: Number(m[1]), start, end: start + m[0].length });
+    }
+    for (const m of text.matchAll(/\b(?:in|within|by)\s+(\d{4})\b/gi)) {
+        const start = m.index ?? 0;
+        matches.push({ year: Number(m[1]), start, end: start + m[0].length });
+    }
+    for (const m of text.matchAll(/今年|明年|后年/g)) {
+        const start = m.index ?? 0;
+        matches.push({ year: relativeYear(m[0]), start, end: start + m[0].length });
+    }
+    for (const m of text.matchAll(/年内/g)) {
+        const start = m.index ?? 0;
+        // 「明年年内」「2025 年内」继承紧邻前缀的年份(「年」可已被年份 token 消费);裸「年内」= 锚点当前年
+        const adjacent = text.slice(0, start).match(/(今年|明年|后年|\d{4})\s*年?\s*$/);
+        matches.push({ year: adjacent ? (/^\d{4}$/.test(adjacent[1]) ? Number(adjacent[1]) : relativeYear(adjacent[1])) : anchorYear, start, end: start + m[0].length });
+    }
+    if (matches.some(m => !Number.isInteger(m.year) || m.year < 1_000 || m.year > 9_999))
+        return null;
+    const distinct = [...new Map(matches.map(m => [m.year, m])).values()];
+    if (historical && distinct.length !== 1)
+        return null;
+    const planningCue = /计划|规划|安排|打算|希望|想在|要在|完成|出行|旅行|预订|预定/i;
+    const eligibleYears = new Set(matches
+        .filter(m => {
+        const before = text.slice(Math.max(0, m.start - 24), m.start);
+        const after = text.slice(m.end, m.end + 24);
+        return planningCue.test(before) || /^\s*(?:内|以内|完成|出行|旅行|预订|预定)/i.test(after);
+    })
+        .map(m => m.year));
+    const selectedYear = eligibleYears.size === 1 ? [...eligibleYears][0]
+        : (historical && distinct.length === 1 ? distinct[0].year : null);
+    if (selectedYear === null)
+        return null;
+    return { referenceDate: anchor.today, requestedYear: selectedYear, intent: historical ? 'historical' : 'future' };
+}
+export function planningWindowBounds(window, anchor) {
+    if (window.intent === 'historical')
+        return null;
+    const currentYear = Number(anchor.today.slice(0, 4));
+    if (window.requestedYear < currentYear)
+        return null;
+    const year = String(window.requestedYear).padStart(4, '0');
     return {
-        today,
-        todayWeekdayZh: weekdayOf(now),
-        tzLabel: tzLabelOf(now),
-        card
+        start: window.requestedYear === currentYear ? anchor.today : `${year}-01-01`,
+        end: `${year}-12-31`,
     };
 }
+/** 严格 ISO 校验:YYYY-MM-DD 必须落在真实日历(2026-02-30/2026-13-01 一律拒)。
+ *  复用 Date 月末自动进位:同年/月/day 还原回同一串 = 真日历;否则越界。
+ *  同时拒掉非有限值(NaN/Infinity)与越界月日(1-12/1-31)。
+ *  供 parseAbsoluteDate 词表口径 + hotel-date-gate 终消费层 复用。 */
+export function isRealIsoDate(y, m, d) {
+    if (!Number.isFinite(y) || !Number.isFinite(m) || !Number.isFinite(d))
+        return false;
+    if (m < 1 || m > 12)
+        return false;
+    if (d < 1 || d > 31)
+        return false;
+    const dt = new Date(y, m - 1, d);
+    return dt.getFullYear() === y && dt.getMonth() === m - 1 && dt.getDate() === d;
+}
+/**
+ * 绝对月日表达 → YYYY-MM-DD(年缺省时按锚点年)。只识别**绝对**表达:
+ * ISO(2026-08-01)、数字点分(8.1 / 9.10)、中文(8月5日 / 8月5号)。
+ * 严格校验真日历存在性:2026-02-30 / 2026-13-01 / 2025-02-29 等一律返回 null——
+ * 词表外不一致日期不冒充合法,闸会归 unresolved 拒绝发供应商查询(issue #283 红线)。
+ * 相对/模糊表达(下周一/明天/本周三/下个月中旬/近期/Aug-5 英文月名)一律返回 null——
+ * 逐字保留给下游,本层不做换算也不做过期判定(与评测 golden 对齐:英文月日不判过期)。
+ */
 export function parseAbsoluteDate(expr, anchorYear) {
     const t = expr.trim();
     let m = t.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/);
-    if (m) return `${m[1]}-${m[2].padStart(2, '0')}-${m[3].padStart(2, '0')}`;
+    if (m) {
+        const y = Number(m[1]);
+        const mo = Number(m[2]);
+        const d = Number(m[3]);
+        if (!isRealIsoDate(y, mo, d))
+            return null;
+        return `${m[1]}-${m[2].padStart(2, '0')}-${m[3].padStart(2, '0')}`;
+    }
     m = t.match(/^(\d{1,2})[./](\d{1,2})(?:日|号)?$/);
-    if (m) return `${anchorYear}-${m[1].padStart(2, '0')}-${m[2].padStart(2, '0')}`;
+    if (m) {
+        const mo = Number(m[1]);
+        const d = Number(m[2]);
+        if (!isRealIsoDate(anchorYear, mo, d))
+            return null;
+        return `${anchorYear}-${m[1].padStart(2, '0')}-${m[2].padStart(2, '0')}`;
+    }
     m = t.match(/^(\d{1,2})月(\d{1,2})[日号]?$/);
-    if (m) return `${anchorYear}-${m[1].padStart(2, '0')}-${m[2].padStart(2, '0')}`;
+    if (m) {
+        const mo = Number(m[1]);
+        const d = Number(m[2]);
+        if (!isRealIsoDate(anchorYear, mo, d))
+            return null;
+        return `${anchorYear}-${m[1].padStart(2, '0')}-${m[2].padStart(2, '0')}`;
+    }
     return null;
 }
-
-
-//# sourceURL=ts/src/time-anchor.ts

package/dist/src/tool-packet.js

@@ -1,12 +1,24 @@
+/**
+ * 工具调用 packet 纪律(RFC S1,loopx agent-loop-effect-interpreter 映射):
+ * 每次工具交互 = effect_request(args) → interpretation(interpretArgs)→ observation(返回值)。
+ *
+ * envelope 是**平铺**的(house style,与 guardToolExecute 兜底同形):
+ *  - 成功:{ ok: true, ...payload } —— 渲染/调用方按字段读,不受扰;
+ *  - 失败:{ ok: false, summary, evidence? } —— guard 异常降级天然就是这一支。
+ * Handler 是数据不是 callable:observation 必须可 JSON 序列化(跨 dsh/cordis 边界)。
+ */
+/**
+ * 参数归一(interpretation 层):dsh 模型侧对 query 包装参数的三种形态——
+ * ① 包装对象 { query: {...} } ② 裸对象(平铺字段) ③ 字符串(按主键收)。
+ * 唯一归一入口;工具面不再各自猜形状。
+ */
 export function interpretArgs(args, stringKey) {
-    if (args.query && typeof args.query === 'object') return args.query;
+    if (args.query && typeof args.query === 'object')
+        return args.query;
     const { query, ...rest } = args;
-    if (Object.keys(rest).length > 0) return rest;
-    if (typeof query === 'string' && stringKey) return {
-        [stringKey]: query
-    };
+    if (Object.keys(rest).length > 0)
+        return rest;
+    if (typeof query === 'string' && stringKey)
+        return { [stringKey]: query };
     return {};
 }
-
-
-//# sourceURL=ts/src/tool-packet.ts

package/dist/src/travel-slots.js

@@ -1,30 +1,45 @@
+/**
+ * 槽位抽取层(travel_slot_extraction.v1):面向差旅 intake 的槽位 schema + 确定性过期校验 + 评分器。
+ *
+ * 设计约定(与评测 golden 逐条对齐):
+ *  - 时间表达**逐字保留**(「下周一」就写「下周一」),换算归下游工具——tool-owned dates;
+ *  - 过期判定在代码层(flagExpiredSlots),LLM 只负责逐字抽取;
+ *  - 过期只判**主日期字段**(requisition.start_date / flight.departure_date / hotel.check_in_date),
+ *    且槽位原值保留,仅往 missing_slots 追加 "<domain>.<field> (date is expired)";
+ *  - 相对/模糊表达永不判过期(「本周三」即使已过也逐字传递,由人裁决语义)。
+ *
+ * slot→spec 求解桥接不在本期(architecture §10 债务)。
+ */
 import { parseAbsoluteDate } from './time-anchor.js';
+/** 各域的主日期字段——过期校验只判它(对齐 golden:8.1-8.10 仅 start_date 进 missing_slots) */
 const PRIMARY_DATE_FIELD = {
     requisition: 'start_date',
     flight: 'departure_date',
-    hotel: 'check_in_date'
+    hotel: 'check_in_date',
 };
+/**
+ * 确定性过期校验(纯函数,不改入参):主日期字段是**绝对**月日表达且早于锚点今天,
+ * 往 missing_slots 追加 "<domain>.<field> (date is expired)"(幂等去重);槽位原值不动。
+ */
 export function flagExpiredSlots(ext, anchor) {
     const anchorYear = Number(anchor.today.slice(0, 4));
-    const missing = [
-        ...ext.missing_slots
-    ];
-    for (const domain of ext.domains){
+    const missing = [...ext.missing_slots];
+    for (const domain of ext.domains) {
         const slots = ext.slots[domain];
         const field = PRIMARY_DATE_FIELD[domain];
         const value = slots?.[field];
-        if (typeof value !== 'string') continue;
+        if (typeof value !== 'string')
+            continue;
         const resolved = parseAbsoluteDate(value, anchorYear);
         if (resolved && resolved < anchor.today) {
             const flag = `${domain}.${field} (date is expired)`;
-            if (!missing.includes(flag)) missing.push(flag);
+            if (!missing.includes(flag))
+                missing.push(flag);
         }
     }
-    return {
-        ...ext,
-        missing_slots: missing
-    };
+    return { ...ext, missing_slots: missing };
 }
+/** 槽位抽取 system prompt:锚点卡注入 + 逐字保留铁律(LLM 不做算术、不判过期) */
 export function buildSlotSystem(anchor) {
     return `你是差旅需求的槽位抽取器。从用户原话抽取槽位,只输出 JSON:
 {"schema_version":"travel_slot_extraction.v1","language":"zh|en|mixed","domains":["requisition"|"flight"|"hotel",...],"slots":{...},"missing_slots":[...]}
@@ -78,32 +93,45 @@ ${anchor.card}
 
 只输出 JSON,不要多余文本。`;
 }
+/**
+ * language 的确定性判定(判定归代码层,不信模型):只看用户原话——
+ * 含中文且含拉丁字母 → mixed;仅中文 → zh;仅拉丁 → en。
+ * (对齐 golden:「next Thursday 去北京」=mixed;全英文带中文槽位值仍=en)
+ */
 export function detectLanguage(utterance) {
     const hasCjk = /[一-鿿]/.test(utterance);
     const hasLatin = /[A-Za-z]/.test(utterance);
-    if (hasCjk && hasLatin) return 'mixed';
-    if (hasLatin) return 'en';
+    if (hasCjk && hasLatin)
+        return 'mixed';
+    if (hasLatin)
+        return 'en';
     return 'zh';
 }
+/** 模型原始 JSON → 规范化 v1 抽取结果(缺省补齐,域外键容忍;language 由 detectLanguage 覆写) */
 export function normalizeExtraction(obj, utterance) {
     const domains = obj['domains'];
-    if (!Array.isArray(domains) || domains.length === 0) return null;
-    const valid = domains.filter((d)=>d === 'requisition' || d === 'flight' || d === 'hotel');
-    if (valid.length === 0) return null;
+    if (!Array.isArray(domains) || domains.length === 0)
+        return null;
+    const valid = domains.filter((d) => d === 'requisition' || d === 'flight' || d === 'hotel');
+    if (valid.length === 0)
+        return null;
     const lang = obj['language'];
-    const slots = obj['slots'] ?? {};
+    const slots = (obj['slots'] ?? {});
     const missing = obj['missing_slots'];
     return {
         schema_version: 'travel_slot_extraction.v1',
-        language: utterance !== undefined ? detectLanguage(utterance) : lang === 'en' || lang === 'mixed' ? lang : 'zh',
+        language: utterance !== undefined ? detectLanguage(utterance) : (lang === 'en' || lang === 'mixed' ? lang : 'zh'),
         domains: valid,
         slots,
-        missing_slots: Array.isArray(missing) ? missing.map(String) : []
+        missing_slots: Array.isArray(missing) ? missing.map(String) : [],
     };
 }
-const sortedSet = (xs)=>[
-        ...xs
-    ].sort();
+const sortedSet = (xs) => [...xs].sort();
+/**
+ * 评分器:case pass 的口径 = language 一致 + domains 集合一致 +
+ * expected 的每个槽位键值在 actual 中精确命中(actual 多出的键只记 warning)+
+ * missing_slots 集合一致。逐字保留语义下,值比较就是字符串精确比较。
+ */
 export function scoreExtraction(expected, actual) {
     const diffs = [];
     const warnings = [];
@@ -113,32 +141,27 @@ export function scoreExtraction(expected, actual) {
     if (JSON.stringify(sortedSet(expected.domains)) !== JSON.stringify(sortedSet(actual.domains))) {
         diffs.push(`domains: 期望 [${sortedSet(expected.domains)}],实际 [${sortedSet(actual.domains)}]`);
     }
-    for (const domain of expected.domains){
+    for (const domain of expected.domains) {
         const exp = expected.slots[domain];
         const act = actual.slots[domain];
-        if (!exp) continue;
+        if (!exp)
+            continue;
         if (!act) {
             diffs.push(`slots.${domain}: 实际缺失整个域`);
             continue;
         }
-        for (const [k, v] of Object.entries(exp)){
+        for (const [k, v] of Object.entries(exp)) {
             if (JSON.stringify(act[k]) !== JSON.stringify(v)) {
                 diffs.push(`slots.${domain}.${k}: 期望 ${JSON.stringify(v)},实际 ${JSON.stringify(act[k])}`);
             }
         }
-        for (const k of Object.keys(act)){
-            if (!(k in exp)) warnings.push(`slots.${domain}.${k}: 实际多出键 ${JSON.stringify(act[k])}`);
+        for (const k of Object.keys(act)) {
+            if (!(k in exp))
+                warnings.push(`slots.${domain}.${k}: 实际多出键 ${JSON.stringify(act[k])}`);
         }
     }
     if (JSON.stringify(sortedSet(expected.missing_slots)) !== JSON.stringify(sortedSet(actual.missing_slots))) {
         diffs.push(`missing_slots: 期望 [${expected.missing_slots}],实际 [${actual.missing_slots}]`);
     }
-    return {
-        pass: diffs.length === 0,
-        diffs,
-        warnings
-    };
+    return { pass: diffs.length === 0, diffs, warnings };
 }
-
-
-//# sourceURL=ts/src/travel-slots.ts