@danceiny/gotry 0.0.1-rc.9 → 0.2.0-rc.28

package/dist/src/evaluation-cadence.js

@@ -0,0 +1,97 @@
+import { assertPublicArtifactSafe } from './evaluation-contracts.js';
+export const CADENCES = ['pr', 'nightly', 'weekly', 'milestone'];
+export const STOP_SIGNALS = ['source_revision_drift', 'license_unresolved', 'scorer_ceiling_invalid', 'known_bad_no_longer_fails', 'hard_violation', 'matched_regression', 'variance_breach', 'budget_breach'];
+function object(value, label) { if (!value || typeof value !== 'object' || Array.isArray(value))
+    throw new Error(`${label} must be an object`); return value; }
+function exact(value, label, keys) { const actual = Object.keys(value).sort(); const expected = [...keys].sort(); if (JSON.stringify(actual) !== JSON.stringify(expected))
+    throw new Error(`${label} keys must be exact`); }
+function number(value, label, min = 0) { if (typeof value !== 'number' || !Number.isFinite(value) || value < min)
+    throw new Error(`${label} must be finite and non-negative`); return value; }
+function integer(value, label, min = 0) { const n = number(value, label, min); if (!Number.isInteger(n))
+    throw new Error(`${label} must be an integer`); return n; }
+function literal(value, label, allowed) { if (typeof value !== 'string' || !allowed.includes(value))
+    throw new Error(`${label} is invalid`); return value; }
+function bool(value, label, expected) { if (value !== expected)
+    throw new Error(`${label} must be ${expected}`); return expected; }
+export function parseEvaluationCadencePolicy(value) {
+    const root = object(value, 'policy');
+    exact(root, 'policy', ['schema', 'levels', 'cross_benchmark_window', 'performance_tradeoff_disclosure_threshold', 'round_delivery', 'stop_signals', 'failure_registry_signals', 'public_safety']);
+    if (root.schema !== 'gotry_evaluation_cadence_policy_v1')
+        throw new Error('policy schema is invalid');
+    if (!Array.isArray(root.levels) || root.levels.length !== 4)
+        throw new Error('policy levels must be complete');
+    for (let index = 0; index < root.levels.length; index += 1)
+        if (!Object.hasOwn(root.levels, index))
+            throw new Error('policy levels must be dense');
+    const levels = root.levels.map((raw, i) => {
+        const item = object(raw, `policy.levels[${i}]`);
+        exact(item, `policy.levels[${i}]`, ['cadence', 'pass_k', 'max_cost_usd', 'max_wall_minutes', 'max_tool_calls_per_case', 'human_calibration']);
+        const cadence = literal(item.cadence, 'cadence', CADENCES);
+        if (cadence !== CADENCES[i])
+            throw new Error('policy levels must use canonical order');
+        const calibration = object(item.human_calibration, 'human_calibration');
+        exact(calibration, 'human_calibration', ['required', 'min_samples']);
+        const pass_k = integer(item.pass_k, 'pass_k', 1);
+        const max_cost_usd = number(item.max_cost_usd, 'max_cost_usd');
+        const max_wall_minutes = number(item.max_wall_minutes, 'max_wall_minutes');
+        if (item.max_tool_calls_per_case !== 18)
+            throw new Error('max_tool_calls_per_case must be 18');
+        const required = Boolean(calibration.required);
+        if (calibration.required !== required)
+            throw new Error('human calibration required must be boolean');
+        const min_samples = integer(calibration.min_samples, 'min_samples');
+        const expected = [[1, 0, 20, false, 0], [2, 2, 90, false, 0], [3, 10, 360, true, 10], [5, 50, 1440, true, 30]][i];
+        if (pass_k !== expected[0] || max_cost_usd !== expected[1] || max_wall_minutes !== expected[2] || required !== expected[3] || min_samples !== expected[4])
+            throw new Error('policy level literals are invalid');
+        return { cadence, pass_k, max_cost_usd, max_wall_minutes, max_tool_calls_per_case: 18, human_calibration: { required, min_samples } };
+    });
+    const window = object(root.cross_benchmark_window, 'cross_benchmark_window');
+    exact(window, 'cross_benchmark_window', ['min_prs', 'max_prs']);
+    if (window.min_prs !== 3 || window.max_prs !== 5)
+        throw new Error('cross benchmark window must be 3..5');
+    if (root.performance_tradeoff_disclosure_threshold !== 0.2)
+        throw new Error('tradeoff threshold must be 0.2');
+    const delivery = object(root.round_delivery, 'round_delivery');
+    exact(delivery, 'round_delivery', ['exactly_one_gotry_pr', 'exactly_one_discussion_78_comment', 'update_existing_comment']);
+    for (const key of Object.keys(delivery))
+        bool(delivery[key], `round_delivery.${key}`, true);
+    if (!Array.isArray(root.stop_signals) || JSON.stringify(root.stop_signals) !== JSON.stringify(STOP_SIGNALS))
+        throw new Error('stop signals must be the complete canonical set');
+    if (!Array.isArray(root.failure_registry_signals) || JSON.stringify(root.failure_registry_signals) !== JSON.stringify(STOP_SIGNALS.slice(4)))
+        throw new Error('failure registry signals are invalid');
+    const publicSafety = object(root.public_safety, 'public_safety');
+    exact(publicSafety, 'public_safety', ['artifact_classification', 'contains_third_party_prompt', 'contains_gold', 'contains_oracle', 'contains_private_data']);
+    if (publicSafety.artifact_classification !== 'public_safe')
+        throw new Error('policy must be public safe');
+    for (const key of ['contains_third_party_prompt', 'contains_gold', 'contains_oracle', 'contains_private_data'])
+        bool(publicSafety[key], `public_safety.${key}`, false);
+    const policy = { schema: root.schema, levels, cross_benchmark_window: { min_prs: 3, max_prs: 5 }, performance_tradeoff_disclosure_threshold: 0.2, round_delivery: { exactly_one_gotry_pr: true, exactly_one_discussion_78_comment: true, update_existing_comment: true }, stop_signals: [...STOP_SIGNALS], failure_registry_signals: [...STOP_SIGNALS.slice(4)], public_safety: { artifact_classification: 'public_safe', contains_third_party_prompt: false, contains_gold: false, contains_oracle: false, contains_private_data: false } };
+    assertPublicArtifactSafe(policy, 'evaluation cadence policy');
+    return policy;
+}
+export function planEvaluationCadence(policy, input) {
+    const inputObject = object(input, 'planner input');
+    exact(inputObject, 'planner input', ['cadence', 'signals', 'recent_optimization_prs']);
+    if (!CADENCES.includes(input.cadence) || !Array.isArray(input.signals) || !Array.isArray(input.recent_optimization_prs))
+        throw new Error('planner input is invalid');
+    for (let index = 0; index < input.signals.length; index += 1)
+        if (!Object.hasOwn(input.signals, index))
+            throw new Error('stop signals must be dense');
+    for (let index = 0; index < input.recent_optimization_prs.length; index += 1)
+        if (!Object.hasOwn(input.recent_optimization_prs, index))
+            throw new Error('recent optimization PR IDs must be dense');
+    if (input.recent_optimization_prs.some((id) => !Number.isInteger(id) || id < 1) || new Set(input.recent_optimization_prs).size !== input.recent_optimization_prs.length)
+        throw new Error('recent optimization PR IDs must be positive and unique');
+    const normalizedPolicy = parseEvaluationCadencePolicy(policy);
+    const cadence = input.cadence;
+    const signals = input.signals.map((signal) => literal(signal, 'stop signal', STOP_SIGNALS));
+    if (new Set(signals).size !== signals.length)
+        throw new Error('stop signals must be unique');
+    const level = normalizedPolicy.levels.find((item) => item.cadence === cadence);
+    if (!level)
+        throw new Error('cadence is not configured');
+    const failure_registry = signals.some((signal) => normalizedPolicy.failure_registry_signals.includes(signal));
+    const decision = { cadence, admission: signals.length === 0, failure_registry, stop_signals: signals, launches_external_runs: false, pass_k: level.pass_k, max_cost_usd: level.max_cost_usd, max_wall_minutes: level.max_wall_minutes, max_tool_calls_per_case: 18, human_calibration: level.human_calibration, cross_benchmark_window: { min_prs: 3, max_prs: 5 }, performance_tradeoff_disclosure_threshold: 0.2, delivery: normalizedPolicy.round_delivery, cross_benchmark_synthesis: { required: input.recent_optimization_prs.length >= 3, overdue: input.recent_optimization_prs.length > 5 } };
+    assertPublicArtifactSafe(decision, 'evaluation cadence decision');
+    return decision;
+}

package/dist/src/evaluation-contracts.js

@@ -0,0 +1,283 @@
+import { createHash } from 'node:crypto';
+export const BENCHMARK_IDS = ['trek', 'travelplanner', 'chinatravel', 'travelbench', 'tau2', 'locomo', 'bfcl'];
+export const FAILURE_CATEGORIES = ['schema_or_format', 'grounding_or_provenance', 'constraint_or_feasibility', 'time_or_location_continuity', 'cost_or_cardinality', 'tool_selection_or_arguments', 'policy_or_write_safety', 'preference_elicitation', 'memory_retrieval_or_temporal_reasoning', 'reliability_cost_or_latency'];
+function obj(value, label) { if (!value || typeof value !== 'object' || Array.isArray(value))
+    throw new Error(`${label} must be an object`); return value; }
+function exact(value, label, keys) { const unknown = Object.keys(value).filter(key => !keys.includes(key)); const missing = keys.filter(key => !(key in value)); if (unknown.length)
+    throw new Error(`${label} contains undeclared fields: ${unknown.join(',')}`); if (missing.length)
+    throw new Error(`${label} missing fields: ${missing.join(',')}`); }
+function text(value, label) { if (typeof value !== 'string' || value.length === 0)
+    throw new Error(`${label} must be non-empty text`); return value; }
+function id(value, label) { const out = text(value, label); if (!/^[a-z0-9][a-z0-9:._-]+$/.test(out))
+    throw new Error(`${label} must be a stable identifier`); return out; }
+function lit(value, label, values) { const out = text(value, label); if (!values.includes(out))
+    throw new Error(`${label} invalid literal`); return out; }
+function boolean(value, label) { if (typeof value !== 'boolean')
+    throw new Error(`${label} must be boolean`); return value; }
+function finite(value, label, min = 0) { if (typeof value !== 'number' || !Number.isFinite(value) || value < min)
+    throw new Error(`${label} must be a finite number >= ${min}`); return value; }
+function integer(value, label, min = 0) { const out = finite(value, label, min); if (!Number.isInteger(out))
+    throw new Error(`${label} must be an integer`); return out; }
+function strings(value, label, empty = false) { if (!Array.isArray(value) || (!empty && value.length === 0))
+    throw new Error(`${label} must be an array`); const out = value.map((item, index) => text(item, `${label}[${index}]`)); if (new Set(out).size !== out.length)
+    throw new Error(`${label} must be unique`); return out; }
+function digest(value, label) { const out = text(value, label); if (!/^[0-9a-f]{64}$/.test(out))
+    throw new Error(`${label} must be lowercase SHA-256`); return out; }
+function commit(value, label) { const out = text(value, label); if (!/^[0-9a-f]{40}$/.test(out))
+    throw new Error(`${label} must be a lowercase 40-character Git commit`); return out; }
+function url(value, label) { const out = text(value, label); let parsed; try {
+    parsed = new URL(out);
+}
+catch {
+    throw new Error(`${label} must be a valid URL`);
+} ; if (parsed.protocol !== 'https:')
+    throw new Error(`${label} must use https`); if (parsed.username || parsed.password)
+    throw new Error(`${label} must not contain credentials`); return out; }
+function instant(value, label) { const out = text(value, label); const date = new Date(out); if (!Number.isFinite(date.valueOf()) || date.toISOString() !== out)
+    throw new Error(`${label} must be canonical ISO UTC with milliseconds`); return out; }
+function zone(value, label) { const out = text(value, label); if (out === 'UTC')
+    return out; try {
+    new Intl.DateTimeFormat('en', { timeZone: out }).format(new Date(0));
+}
+catch {
+    throw new Error(`${label} must be UTC or an IANA timezone`);
+} ; if (!out.includes('/'))
+    throw new Error(`${label} must be UTC or an IANA timezone`); return out; }
+function revision(value, label) { const root = obj(value, label); exact(root, label, ['kind', 'value']); const kind = lit(root.kind, `${label}.kind`, ['git_commit', 'content_sha256', 'not_separately_declared']); if (kind === 'not_separately_declared') {
+    if (root.value !== null)
+        throw new Error(`${label}.value must be null`);
+    return { kind, value: null };
+} ; return { kind, value: kind === 'git_commit' ? commit(root.value, `${label}.value`) : digest(root.value, `${label}.value`) }; }
+function pin(value, label) { const root = obj(value, label); exact(root, label, ['url', 'revision', 'source_scope']); return { url: url(root.url, `${label}.url`), revision: revision(root.revision, `${label}.revision`), source_scope: text(root.source_scope, `${label}.source_scope`) }; }
+function licenseDetermination(value, label) { const root = obj(value, label); exact(root, label, ['value', 'determination', 'source_url']); const determination = lit(root.determination, `${label}.determination`, ['declared', 'not_separately_declared']); const resolved = text(root.value, `${label}.value`); if (determination === 'not_separately_declared' && resolved !== 'not_separately_declared')
+    throw new Error(`${label}.value must be not_separately_declared`); return { value: resolved, determination, source_url: url(root.source_url, `${label}.source_url`) }; }
+export function stableEvaluationJson(value) { const sort = (item) => Array.isArray(item) ? item.map(sort) : item && typeof item === 'object' ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b)).map(([key, child]) => [key, sort(child)])) : item; return `${JSON.stringify(sort(value), null, 2)}\n`; }
+export function evaluationFingerprint(value) { return createHash('sha256').update(stableEvaluationJson(value)).digest('hex'); }
+const sensitiveKeys = new Set(['apikey', 'accesstoken', 'refreshtoken', 'authorization', 'password', 'clientsecret', 'credentials', 'cookie', 'rawprompt', 'goldanswer', 'oraclepayload', 'credential', 'rawanswer', 'privatepayload', 'secretpayload', 'trajectorypayload']);
+export function assertPublicArtifactSafe(value, label = 'artifact') {
+    const walk = (item, path) => {
+        if (Array.isArray(item))
+            return item.forEach((child, index) => walk(child, `${path}[${index}]`));
+        if (typeof item === 'string') {
+            const withoutHttpsUrls = item.replace(/https:\/\/[^\s]+/g, '');
+            const highConfidenceSecret = /Bearer\s+[A-Za-z0-9._~-]{24,}|\bsk-[A-Za-z0-9_-]{20,}|\bgh[pousr]_[A-Za-z0-9_]{20,}|\bAKIA[0-9A-Z]{16}\b/;
+            if (/(?:^|[^A-Za-z0-9])(?:\/|~\/)|[A-Za-z]:[\\/]|file:\/\//.test(withoutHttpsUrls) || highConfidenceSecret.test(item))
+                throw new Error(`${path} contains an absolute path or secret`);
+            return;
+        }
+        if (!item || typeof item !== 'object')
+            return;
+        for (const [key, child] of Object.entries(item)) {
+            if (sensitiveKeys.has(key.replace(/[^a-z0-9]/gi, '').toLowerCase()) && child !== '' && child !== null)
+                throw new Error(`${path}.${key} contains credentials or raw sensitive payload`);
+            walk(child, `${path}.${key}`);
+        }
+    };
+    walk(value, label);
+}
+function registryEntry(value, label) {
+    const root = obj(value, label);
+    exact(root, label, ['schema_version', 'benchmark_id', 'provenance', 'license', 'task_scopes', 'native_metrics', 'source_fence', 'countability_default']);
+    const provenance = obj(root.provenance, `${label}.provenance`);
+    exact(provenance, `${label}.provenance`, ['official_entry', 'data', 'evaluator']);
+    const license = obj(root.license, `${label}.license`);
+    exact(license, `${label}.license`, ['upstream_rights', 'repo_storage_policy']);
+    const rights = obj(license.upstream_rights, `${label}.license.upstream_rights`);
+    exact(rights, `${label}.license.upstream_rights`, ['code', 'data', 'evaluator']);
+    const metrics = obj(root.native_metrics, `${label}.native_metrics`);
+    exact(metrics, `${label}.native_metrics`, ['status', 'values']);
+    if (!Array.isArray(metrics.values))
+        throw new Error(`${label}.native_metrics.values must be an array`);
+    const status = lit(metrics.status, `${label}.native_metrics.status`, ['declared', 'not_separately_declared']);
+    const values = metrics.values.map((raw, index) => { const metric = obj(raw, `${label}.metric[${index}]`); exact(metric, `${label}.metric[${index}]`, ['receipt_key', 'upstream_label', 'scope', 'source_url']); return { receipt_key: id(metric.receipt_key, `${label}.metric.receipt_key`), upstream_label: text(metric.upstream_label, `${label}.metric.upstream_label`), scope: text(metric.scope, `${label}.metric.scope`), source_url: url(metric.source_url, `${label}.metric.source_url`) }; });
+    if (status === 'declared' && values.length === 0)
+        throw new Error(`${label} declared metrics must be non-empty`);
+    if (status === 'not_separately_declared' && values.length !== 0)
+        throw new Error(`${label} undeclared metrics must be empty`);
+    const fence = obj(root.source_fence, `${label}.source_fence`);
+    exact(fence, `${label}.source_fence`, ['solver_allowed_field_classes', 'solver_forbidden_field_classes']);
+    return { schema_version: lit(root.schema_version, `${label}.schema_version`, ['gotry_benchmark_registry_entry_v0']), benchmark_id: lit(root.benchmark_id, `${label}.benchmark_id`, BENCHMARK_IDS), provenance: { official_entry: pin(provenance.official_entry, `${label}.official_entry`), data: pin(provenance.data, `${label}.data`), evaluator: pin(provenance.evaluator, `${label}.evaluator`) }, license: { upstream_rights: { code: licenseDetermination(rights.code, `${label}.rights.code`), data: licenseDetermination(rights.data, `${label}.rights.data`), evaluator: licenseDetermination(rights.evaluator, `${label}.rights.evaluator`) }, repo_storage_policy: lit(license.repo_storage_policy, `${label}.storage`, ['metadata_only_no_upstream_payload']) }, task_scopes: strings(root.task_scopes, `${label}.task_scopes`), native_metrics: status === 'declared' ? { status, values } : { status, values: [] }, source_fence: { solver_allowed_field_classes: strings(fence.solver_allowed_field_classes, `${label}.allowed`), solver_forbidden_field_classes: strings(fence.solver_forbidden_field_classes, `${label}.forbidden`) }, countability_default: lit(root.countability_default, `${label}.countability_default`, ['countable_if_qualified', 'diagnostic_only']) };
+}
+export function parseBenchmarkRegistry(value) { if (!Array.isArray(value) || value.length !== 7)
+    throw new Error('registry must contain exactly seven entries'); const out = value.map((item, index) => registryEntry(item, `registry[${index}]`)); if (out.some((item, index) => item.benchmark_id !== BENCHMARK_IDS[index]))
+    throw new Error('registry must use canonical unique order'); return out; }
+export function parseEvalCase(value) {
+    const root = obj(value, 'case');
+    exact(root, 'case', ['schema_version', 'case_id', 'benchmark_id', 'input_ref', 'isolation', 'clock', 'allowed_effects', 'forbidden_effects', 'budget', 'scorer_revision', 'public_safety']);
+    const input = obj(root.input_ref, 'case.input_ref');
+    exact(input, 'case.input_ref', ['kind', 'revision', 'digest_sha256']);
+    const isolation = obj(root.isolation, 'case.isolation');
+    exact(isolation, 'case.isolation', ['state_root', 'network', 'writes']);
+    const clock = obj(root.clock, 'case.clock');
+    exact(clock, 'case.clock', ['now', 'timezone']);
+    const budget = obj(root.budget, 'case.budget');
+    exact(budget, 'case.budget', ['max_seconds', 'max_cost_usd', 'max_tool_calls', 'max_turns']);
+    const safety = obj(root.public_safety, 'case.public_safety');
+    exact(safety, 'case.public_safety', ['contains_third_party_prompt', 'contains_gold', 'contains_oracle', 'contains_private_data']);
+    for (const [key, flag] of Object.entries(safety))
+        if (boolean(flag, `case.public_safety.${key}`) !== false)
+            throw new Error(`case.public_safety.${key} must be false`);
+    const out = { schema_version: lit(root.schema_version, 'case.schema_version', ['gotry_eval_case_v0']), case_id: id(root.case_id, 'case.case_id'), benchmark_id: lit(root.benchmark_id, 'case.benchmark_id', BENCHMARK_IDS), input_ref: { kind: lit(input.kind, 'case.input_ref.kind', ['gotry_owned_synthetic', 'external_opaque_reference']), revision: revision(input.revision, 'case.input_ref.revision'), digest_sha256: digest(input.digest_sha256, 'case.input_ref.digest_sha256') }, isolation: { state_root: lit(isolation.state_root, 'case.state_root', ['ephemeral']), network: lit(isolation.network, 'case.network', ['denied', 'benchmark_declared']), writes: lit(isolation.writes, 'case.writes', ['forbidden']) }, clock: { now: instant(clock.now, 'case.clock.now'), timezone: zone(clock.timezone, 'case.clock.timezone') }, allowed_effects: strings(root.allowed_effects, 'case.allowed_effects', true), forbidden_effects: strings(root.forbidden_effects, 'case.forbidden_effects'), budget: { max_seconds: finite(budget.max_seconds, 'case.max_seconds'), max_cost_usd: finite(budget.max_cost_usd, 'case.max_cost_usd'), max_tool_calls: integer(budget.max_tool_calls, 'case.max_tool_calls'), max_turns: integer(budget.max_turns, 'case.max_turns') }, scorer_revision: revision(root.scorer_revision, 'case.scorer_revision'), public_safety: { contains_third_party_prompt: false, contains_gold: false, contains_oracle: false, contains_private_data: false } };
+    assertPublicArtifactSafe(out, 'case');
+    return out;
+}
+function optionalDigest(value, label) { return value === null ? null : digest(value, label); }
+// The only schema-free object maps are native_metrics and evidence counts. Their leaves are numeric;
+// native_metrics keys close exactly to registry receipt_key values in parseEvaluationFoundation.
+function numberMap(value, label, integers = false) { const root = obj(value, label); return Object.fromEntries(Object.entries(root).map(([key, item]) => [id(key, `${label}.key`), integers ? integer(item, `${label}.${key}`) : finite(item, `${label}.${key}`, Number.NEGATIVE_INFINITY)])); }
+export function parseEvalRunReceipt(value) {
+    const root = obj(value, 'run');
+    exact(root, 'run', ['schema_version', 'run_id', 'benchmark_id', 'case_id', 'evidence_kind', 'pairing', 'status', 'started_at', 'finished_at', 'gotry_sha', 'model', 'controls', 'qualification', 'experiment', 'native_metrics', 'guardrails', 'evidence_summary']);
+    const model = obj(root.model, 'run.model');
+    exact(model, 'run.model', ['provider', 'model']);
+    const controls = obj(root.controls, 'run.controls');
+    const controlKeys = ['case_set_sha256', 'protocol_control_sha256', 'model_parameters_sha256', 'scorer_sha256', 'tool_snapshot_sha256', 'source_fence_sha256', 'integrity_sha256', 'official_evaluator_sha256'];
+    exact(controls, 'run.controls', controlKeys);
+    const qualification = obj(root.qualification, 'run.qualification');
+    exact(qualification, 'run.qualification', ['official_result', 'source_fence_passed', 'integrity_passed', 'evidence_receipts']);
+    const receipts = obj(qualification.evidence_receipts, 'run.qualification.evidence_receipts');
+    exact(receipts, 'run.qualification.evidence_receipts', ['official_evaluator_output_sha256', 'source_fence_audit_sha256', 'integrity_audit_sha256']);
+    const experiment = obj(root.experiment, 'run.experiment');
+    exact(experiment, 'run.experiment', ['changed_variables', 'candidate_sha256']);
+    const guard = obj(root.guardrails, 'run.guardrails');
+    exact(guard, 'run.guardrails', ['hard_violation_count', 'forbidden_leakage_hits', 'latency_ms', 'cost_usd', 'tool_calls', 'turns']);
+    const summary = obj(root.evidence_summary, 'run.evidence_summary');
+    exact(summary, 'run.evidence_summary', ['artifact_classification', 'sha256', 'counts', 'reason_codes', 'fixture_only', 'statement']);
+    let pairing = null;
+    if (root.pairing !== null) {
+        const item = obj(root.pairing, 'run.pairing');
+        exact(item, 'run.pairing', ['pair_id', 'role', 'counterpart_run_id']);
+        pairing = { pair_id: id(item.pair_id, 'run.pair_id'), role: lit(item.role, 'run.role', ['baseline', 'treatment']), counterpart_run_id: id(item.counterpart_run_id, 'run.counterpart') };
+    }
+    const evidence_kind = lit(root.evidence_kind, 'run.evidence_kind', ['synthetic_fixture', 'observed_external']);
+    const status = lit(root.status, 'run.status', ['running', 'succeeded', 'failed', 'blocked']);
+    const finished_at = root.finished_at === null ? null : instant(root.finished_at, 'run.finished_at');
+    if ((status === 'running') !== (finished_at === null))
+        throw new Error('run.finished_at must be null only while running');
+    const out = { schema_version: lit(root.schema_version, 'run.schema_version', ['gotry_eval_run_receipt_v0']), run_id: id(root.run_id, 'run.run_id'), benchmark_id: lit(root.benchmark_id, 'run.benchmark_id', BENCHMARK_IDS), case_id: id(root.case_id, 'run.case_id'), evidence_kind, pairing, status, started_at: instant(root.started_at, 'run.started_at'), finished_at, gotry_sha: commit(root.gotry_sha, 'run.gotry_sha'), model: { provider: text(model.provider, 'run.provider'), model: text(model.model, 'run.model') }, controls: Object.fromEntries(controlKeys.map(key => [key, digest(controls[key], `run.controls.${key}`)])), qualification: { official_result: boolean(qualification.official_result, 'run.official_result'), source_fence_passed: boolean(qualification.source_fence_passed, 'run.source_fence_passed'), integrity_passed: boolean(qualification.integrity_passed, 'run.integrity_passed'), evidence_receipts: { official_evaluator_output_sha256: optionalDigest(receipts.official_evaluator_output_sha256, 'run.evaluator_receipt'), source_fence_audit_sha256: optionalDigest(receipts.source_fence_audit_sha256, 'run.fence_receipt'), integrity_audit_sha256: optionalDigest(receipts.integrity_audit_sha256, 'run.integrity_receipt') } }, experiment: { changed_variables: strings(experiment.changed_variables, 'run.changed_variables', true), candidate_sha256: digest(experiment.candidate_sha256, 'run.candidate') }, native_metrics: numberMap(root.native_metrics, 'run.native_metrics'), guardrails: { hard_violation_count: integer(guard.hard_violation_count, 'run.hard'), forbidden_leakage_hits: integer(guard.forbidden_leakage_hits, 'run.leakage'), latency_ms: finite(guard.latency_ms, 'run.latency'), cost_usd: finite(guard.cost_usd, 'run.cost'), tool_calls: integer(guard.tool_calls, 'run.tools'), turns: integer(guard.turns, 'run.turns') }, evidence_summary: { artifact_classification: lit(summary.artifact_classification, 'run.classification', ['public_safe']), sha256: strings(summary.sha256, 'run.sha256', true).map((item, index) => digest(item, `run.sha256[${index}]`)), counts: numberMap(summary.counts, 'run.counts', true), reason_codes: strings(summary.reason_codes, 'run.reason_codes', true), fixture_only: boolean(summary.fixture_only, 'run.fixture_only'), statement: text(summary.statement, 'run.statement') } };
+    if (out.finished_at !== null && new Date(out.finished_at).valueOf() < new Date(out.started_at).valueOf())
+        throw new Error('run.finished_at must not precede started_at');
+    if (evidence_kind === 'synthetic_fixture' && (pairing !== null || out.qualification.official_result || out.qualification.source_fence_passed || out.qualification.integrity_passed || Object.values(out.qualification.evidence_receipts).some(Boolean) || !out.evidence_summary.fixture_only))
+        throw new Error('synthetic fixture must be unmatched, unqualified, receipt-free, and fixture-only');
+    if (evidence_kind === 'observed_external' && out.evidence_summary.fixture_only)
+        throw new Error('observed_external receipt must set fixture_only=false');
+    assertPublicArtifactSafe(out, 'run');
+    return out;
+}
+export function parseEvalFailureCluster(value) { const root = obj(value, 'failure'); exact(root, 'failure', ['schema_version', 'cluster_id', 'category', 'severity', 'benchmark_ids', 'case_ids', 'run_ids', 'reproduction', 'falsifiable_hypothesis', 'gotry_regression_id', 'suggested_surface', 'state']); const reproduction = obj(root.reproduction, 'failure.reproduction'); exact(reproduction, 'failure.reproduction', ['condition', 'minimum_repetitions', 'observed_repetitions']); const out = { schema_version: lit(root.schema_version, 'failure.schema_version', ['gotry_eval_failure_cluster_v0']), cluster_id: id(root.cluster_id, 'failure.cluster_id'), category: lit(root.category, 'failure.category', FAILURE_CATEGORIES), severity: lit(root.severity, 'failure.severity', ['P0', 'P1', 'P2', 'P3']), benchmark_ids: strings(root.benchmark_ids, 'failure.benchmark_ids').map(item => lit(item, 'failure.benchmark', BENCHMARK_IDS)), case_ids: strings(root.case_ids, 'failure.case_ids'), run_ids: strings(root.run_ids, 'failure.run_ids'), reproduction: { condition: text(reproduction.condition, 'failure.condition'), minimum_repetitions: integer(reproduction.minimum_repetitions, 'failure.minimum', 1), observed_repetitions: integer(reproduction.observed_repetitions, 'failure.observed') }, falsifiable_hypothesis: text(root.falsifiable_hypothesis, 'failure.hypothesis'), gotry_regression_id: id(root.gotry_regression_id, 'failure.regression'), suggested_surface: lit(root.suggested_surface, 'failure.surface', ['agent', 'tool_policy', 'deterministic', 'evaluation']), state: lit(root.state, 'failure.state', ['observed', 'confirmed', 'resolved', 'rejected']) }; if (out.state === 'confirmed' && out.reproduction.observed_repetitions < out.reproduction.minimum_repetitions)
+    throw new Error('confirmed failure lacks repetitions'); assertPublicArtifactSafe(out, 'failure'); return out; }
+export function parseEvaluationFoundation(value) {
+    const root = obj(value, 'foundation');
+    exact(root, 'foundation', ['registry', 'cases', 'run_receipts', 'failure_clusters']);
+    const registry = parseBenchmarkRegistry(root.registry);
+    if (!Array.isArray(root.cases) || !Array.isArray(root.run_receipts) || !Array.isArray(root.failure_clusters))
+        throw new Error('foundation collections must be arrays');
+    const cases = root.cases.map(parseEvalCase), runs = root.run_receipts.map(parseEvalRunReceipt), failures = root.failure_clusters.map(parseEvalFailureCluster);
+    const unique = (values, label) => { if (new Set(values).size !== values.length)
+        throw new Error(`${label} ids must be unique`); };
+    unique(cases.map(item => item.case_id), 'case');
+    unique(runs.map(item => item.run_id), 'run');
+    unique(failures.map(item => item.cluster_id), 'failure');
+    const caseById = new Map(cases.map(item => [item.case_id, item])), runById = new Map(runs.map(item => [item.run_id, item])), registryById = new Map(registry.map(item => [item.benchmark_id, item]));
+    for (const run of runs) {
+        const linked = caseById.get(run.case_id), entry = registryById.get(run.benchmark_id);
+        if (!linked || linked.benchmark_id !== run.benchmark_id || !entry)
+            throw new Error(`run ${run.run_id} must close to case and registry`);
+        const metricKeys = Object.keys(run.native_metrics).sort(), declared = entry.native_metrics.values.map(metric => metric.receipt_key).sort();
+        if (JSON.stringify(metricKeys) !== JSON.stringify(declared))
+            throw new Error(`run ${run.run_id} metric keys must equal registry receipt keys`);
+    }
+    for (const failure of failures) {
+        const linkedCases = failure.case_ids.map(key => caseById.get(key)), linkedRuns = failure.run_ids.map(key => runById.get(key));
+        if (linkedCases.some(item => !item) || linkedRuns.some(item => !item))
+            throw new Error(`failure ${failure.cluster_id} has unclosed links`);
+        const actual = new Set([...linkedCases, ...linkedRuns].map(item => item.benchmark_id));
+        if (actual.size !== failure.benchmark_ids.length || failure.benchmark_ids.some(key => !actual.has(key)))
+            throw new Error(`failure ${failure.cluster_id} benchmark closure must equal linked case and run benchmarks`);
+    }
+    return { registry, cases, run_receipts: runs, failure_clusters: failures };
+}
+function runBinding(run) { const { evidence_receipts: _receipts, ...qualification } = run.qualification; return evaluationFingerprint({ ...run, qualification }); }
+function resolveArtifact(resolver, run, kind, evalCase) { const expected = kind === 'official_evaluator' ? run.qualification.evidence_receipts.official_evaluator_output_sha256 : kind === 'source_fence_audit' ? run.qualification.evidence_receipts.source_fence_audit_sha256 : run.qualification.evidence_receipts.integrity_audit_sha256; if (!expected)
+    throw new Error(`pair ${run.run_id} lacks qualification evidence receipts`); const value = obj(resolver.resolve(expected), `${kind} artifact`); const common = ['schema_version', 'artifact_kind', 'run_id', 'benchmark_id', 'case_id', 'run_binding_sha256']; const specific = kind === 'official_evaluator' ? ['evaluator_sha256', 'native_metrics_sha256', 'native_metrics', 'official_result'] : kind === 'source_fence_audit' ? ['source_fence_sha256', 'input_digest_sha256', 'source_fence_passed', 'forbidden_field_hits'] : ['integrity_sha256', 'candidate_sha256', 'integrity_passed']; exact(value, `${kind} artifact`, [...common, ...specific]); lit(value.schema_version, `${kind}.schema_version`, ['gotry_eval_evidence_artifact_v0']); if (value.artifact_kind !== kind)
+    throw new Error(`${kind} artifact kind mismatch`); if (typeof value.run_id !== 'string' || typeof value.benchmark_id !== 'string' || typeof value.case_id !== 'string' || typeof value.run_binding_sha256 !== 'string')
+    throw new Error(`${kind} artifact schema types mismatch`); assertPublicArtifactSafe(value, ` artifact`); if (kind === 'official_evaluator' && (typeof value.official_result !== 'boolean' || typeof value.native_metrics_sha256 !== 'string'))
+    throw new Error(`${kind} artifact schema types mismatch`); if (kind === 'source_fence_audit' && (typeof value.source_fence_passed !== 'boolean' || typeof value.forbidden_field_hits !== 'number' || !Number.isInteger(value.forbidden_field_hits)))
+    throw new Error(`${kind} artifact schema types mismatch`); if (kind === 'integrity_audit' && typeof value.integrity_passed !== 'boolean')
+    throw new Error(`${kind} artifact schema types mismatch`); if (evaluationFingerprint(value) !== expected)
+    throw new Error(`pair ${run.run_id} ${kind} artifact fingerprint mismatch`); if (value.run_id !== run.run_id || value.benchmark_id !== run.benchmark_id || value.case_id !== run.case_id || value.run_binding_sha256 !== runBinding(run))
+    throw new Error(`pair ${run.run_id} ${kind} artifact binding mismatch`); if (kind === 'official_evaluator' && (value.evaluator_sha256 !== run.controls.official_evaluator_sha256 || value.native_metrics_sha256 !== evaluationFingerprint(run.native_metrics) || value.official_result !== true || JSON.stringify(value.native_metrics) !== JSON.stringify(run.native_metrics)))
+    throw new Error(`pair ${run.run_id} evaluator artifact mismatch`); if (kind === 'source_fence_audit' && (value.source_fence_sha256 !== run.controls.source_fence_sha256 || value.source_fence_passed !== true || value.forbidden_field_hits !== 0 || (evalCase !== undefined && value.input_digest_sha256 !== evalCase.input_ref.digest_sha256)))
+    throw new Error(`pair ${run.run_id} source-fence artifact mismatch`); if (kind === 'integrity_audit' && (value.integrity_sha256 !== run.controls.integrity_sha256 || value.candidate_sha256 !== run.experiment.candidate_sha256 || value.integrity_passed !== true))
+    throw new Error(`pair ${run.run_id} integrity artifact mismatch`); return value; }
+export function deriveMatchedPairs(foundation, resolver) {
+    const groups = new Map();
+    for (const run of foundation.run_receipts)
+        if (run.pairing)
+            groups.set(run.pairing.pair_id, [...(groups.get(run.pairing.pair_id) ?? []), run]);
+    const registry = new Map(foundation.registry.map(item => [item.benchmark_id, item])), cases = new Map(foundation.cases.map(item => [item.case_id, item]));
+    return [...groups.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([pairId, members]) => {
+        if (members.length !== 2)
+            throw new Error(`pair ${pairId} must contain exactly two receipts`);
+        const baseline = members.find(item => item.pairing?.role === 'baseline'), treatment = members.find(item => item.pairing?.role === 'treatment');
+        if (!baseline || !treatment)
+            throw new Error(`pair ${pairId} must contain opposite baseline and treatment roles`);
+        if (baseline.pairing.counterpart_run_id !== treatment.run_id || treatment.pairing.counterpart_run_id !== baseline.run_id)
+            throw new Error(`pair ${pairId} counterpart references must be reciprocal`);
+        if (baseline.benchmark_id !== treatment.benchmark_id || baseline.case_id !== treatment.case_id)
+            throw new Error(`pair ${pairId} must share benchmark and case`);
+        const entry = registry.get(baseline.benchmark_id), evalCase = cases.get(baseline.case_id);
+        if (entry.countability_default !== 'countable_if_qualified')
+            throw new Error(`pair ${pairId} benchmark is diagnostic only`);
+        if (evalCase.input_ref.kind !== 'external_opaque_reference')
+            throw new Error(`pair ${pairId} requires an external opaque case reference`);
+        if ([baseline, treatment].some(run => run.evidence_kind !== 'observed_external'))
+            throw new Error(`pair ${pairId} requires observed_external evidence`);
+        if (baseline.status !== 'succeeded' || treatment.status !== 'succeeded')
+            throw new Error(`pair ${pairId} requires succeeded terminal receipts`);
+        if (baseline.model.provider !== treatment.model.provider || baseline.model.model !== treatment.model.model)
+            throw new Error(`pair ${pairId} model identity must match`);
+        for (const key of ['case_set_sha256', 'protocol_control_sha256', 'model_parameters_sha256', 'scorer_sha256', 'tool_snapshot_sha256', 'source_fence_sha256', 'integrity_sha256', 'official_evaluator_sha256'])
+            if (baseline.controls[key] !== treatment.controls[key])
+                throw new Error(`pair ${pairId} control mismatch: ${key}`);
+        if (baseline.controls.scorer_sha256 !== evaluationFingerprint(evalCase.scorer_revision))
+            throw new Error(`pair ${pairId} scorer fingerprint does not close`);
+        if (baseline.controls.case_set_sha256 !== evaluationFingerprint(foundation.cases.filter(item => item.benchmark_id === baseline.benchmark_id)))
+            throw new Error(`pair ${pairId} case-set fingerprint does not close`);
+        if (baseline.controls.source_fence_sha256 !== evaluationFingerprint(entry.source_fence))
+            throw new Error(`pair ${pairId} source-fence fingerprint does not close`);
+        if (baseline.controls.official_evaluator_sha256 !== evaluationFingerprint(entry.provenance.evaluator))
+            throw new Error(`pair ${pairId} evaluator fingerprint does not close`);
+        if (baseline.experiment.changed_variables.length !== 0 || JSON.stringify(treatment.experiment.changed_variables) !== JSON.stringify(['gotry_sha']))
+            throw new Error(`pair ${pairId} treatment variable must be exactly gotry_sha`);
+        if (baseline.gotry_sha === treatment.gotry_sha)
+            throw new Error(`pair ${pairId} baseline and treatment gotry_sha must differ`);
+        if (baseline.guardrails.hard_violation_count !== 0 || treatment.guardrails.hard_violation_count !== 0 || baseline.guardrails.forbidden_leakage_hits !== 0 || treatment.guardrails.forbidden_leakage_hits !== 0)
+            throw new Error(`pair ${pairId} hard violation or leakage`);
+        for (const run of [baseline, treatment])
+            if (run.experiment.candidate_sha256 !== evaluationFingerprint({ treatment_variable: 'gotry_sha', gotry_sha: run.gotry_sha }))
+                throw new Error(`pair ${pairId} candidate fingerprint does not close to gotry_sha`);
+        for (const run of [baseline, treatment]) {
+            const receipts = Object.values(run.qualification.evidence_receipts);
+            if (!run.qualification.official_result || !run.qualification.source_fence_passed || !run.qualification.integrity_passed || receipts.some(item => item === null))
+                throw new Error(`pair ${pairId} lacks qualification evidence receipts`);
+            const evaluator = resolveArtifact(resolver, run, 'official_evaluator'), fence = resolveArtifact(resolver, run, 'source_fence_audit', evalCase), integrity = resolveArtifact(resolver, run, 'integrity_audit');
+        }
+        return { schema_version: 'gotry_eval_matched_pair_derived_v0', pair_id: pairId, benchmark_id: baseline.benchmark_id, case_id: baseline.case_id, baseline_run_id: baseline.run_id, treatment_run_id: treatment.run_id, treatment_variable: 'gotry_sha', matched_pair_countable: true };
+    });
+}
+export function parseMutationVectors(value) { if (!Array.isArray(value))
+    throw new Error('mutation vectors must be an array'); return value.map((raw, index) => { const root = obj(raw, `mutation[${index}]`), kind = lit(root.value_kind, 'mutation.value_kind', ['literal', 'synthetic_absolute_path', 'nan', 'duplicate_treatment_receipt']), keys = kind === 'literal' ? ['id', 'foundation_kind', 'target', 'operation', 'path', 'value_kind', 'value', 'expected_error'] : ['id', 'foundation_kind', 'target', 'operation', 'path', 'value_kind', 'expected_error']; exact(root, `mutation[${index}]`, keys); return { id: id(root.id, 'mutation.id'), foundation_kind: lit(root.foundation_kind, 'mutation.foundation_kind', ['diagnostic_repository', 'countable_test_only']), target: lit(root.target, 'mutation.target', ['registry', 'case', 'run', 'failure', 'foundation']), operation: lit(root.operation, 'mutation.operation', ['replace', 'remove', 'append']), path: text(root.path, 'mutation.path'), value_kind: kind, ...(kind === 'literal' ? { value: root.value } : {}), expected_error: text(root.expected_error, 'mutation.expected_error') }; }); }
+export function applyMutationVector(foundation, vector) { const cloned = JSON.parse(JSON.stringify(foundation)); const selected = vector.target === 'foundation' ? cloned : vector.target === 'registry' ? cloned.registry : vector.target === 'case' ? cloned.cases[0] : vector.target === 'run' ? cloned.run_receipts[0] : cloned.failure_clusters[0]; let value = vector.value; if (vector.value_kind === 'synthetic_absolute_path')
+    value = ['', 'Users', 'fixture', 'private.json'].join('/'); if (vector.value_kind === 'nan')
+    value = Number.NaN; if (vector.value_kind === 'duplicate_treatment_receipt') {
+    const run = structuredClone(cloned.run_receipts[1]);
+    run.run_id = 'run:trek:treatment-duplicate';
+    value = run;
+} const parts = vector.path.split('.').filter(Boolean); let parent = selected; for (const part of parts.slice(0, -1))
+    parent = parent[part]; const leaf = parts.at(-1); if (vector.operation === 'remove')
+    Array.isArray(parent) ? parent.splice(Number(leaf), 1) : delete parent[leaf];
+else if (vector.operation === 'append')
+    parent[leaf].push(value);
+else
+    parent[leaf] = value; return selected; }

package/dist/src/flight-pack-adapter.js

@@ -0,0 +1,54 @@
+import { FLIGHT_PACK_VERSION } from './flight-pack-contract.js';
+import { isKnownZoneLoose } from './tz-resolver.js';
+export class WorkWindowPrecedenceError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'WorkWindowPrecedenceError';
+        this.code = code;
+    }
+}
+/**
+ * Merge the user's schedule onto a parsed flight-pack window.
+ *
+ * v2 pack metadata owns the home zone. The profile contributes only schedule
+ * fields; its legacy numeric offset is intentionally ignored on that path.
+ * Legacy v1 keeps the adapter's historical numeric replacement behavior.
+ */
+export function mergeProfileWorkWindow(spec, profileWindow) {
+    // Vacation is an explicit profile fact, not an omitted schedule. It clears
+    // any pack window for both versions before the version-specific merge.
+    if (profileWindow?.vacation === true)
+        return { ...spec, workWindow: undefined };
+    if (spec[FLIGHT_PACK_VERSION] === 2) {
+        if (!profileWindow)
+            return spec;
+        const packWindow = spec.workWindow;
+        if (!packWindow?.homeZone || !isKnownZoneLoose(packWindow.homeZone)) {
+            throw new WorkWindowPrecedenceError('v2_profile_requires_pack_home_zone', 'v2 profile schedule requires a valid explicit pack work_window.home_zone');
+        }
+        const workWindow = {
+            ...packWindow,
+            startMin: profileWindow.startMin,
+            endMin: profileWindow.endMin,
+            workdays: profileWindow.workdays,
+        };
+        return { ...spec, workWindow };
+    }
+    // v1 adapter behavior: profile replaces the legacy pack window; no profile
+    // clears it as the existing adapters historically did.
+    if (!profileWindow)
+        return { ...spec, workWindow: undefined };
+    if (typeof profileWindow.homeTzOffsetMin !== 'number') {
+        throw new WorkWindowPrecedenceError('v1_profile_requires_numeric_home_offset', 'v1 profile work window requires homeTzOffsetMin');
+    }
+    return {
+        ...spec,
+        workWindow: {
+            homeTzOffsetMin: profileWindow.homeTzOffsetMin,
+            startMin: profileWindow.startMin,
+            endMin: profileWindow.endMin,
+            workdays: profileWindow.workdays,
+        },
+    };
+}

package/dist/src/flight-pack-contract.js

@@ -0,0 +1,2 @@
+/** Internal flight-pack provenance; symbol properties stay out of JSON/public tool schemas. */
+export const FLIGHT_PACK_VERSION = Symbol('gotry.flightPackVersion');

package/dist/src/flyai-setup-tool.js

@@ -0,0 +1,70 @@
+/** Read-only model surface. Credentials are entered only through the local CLI. */
+import { homedir } from 'node:os';
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { displayEndpoint, endpointFingerprint, readFlyaiVerification, resolveFlyaiEndpoint, resolveFlyaiKey, sha256Hex, writeFlyaiVerification, } from '../capabilities/flyai-config.js';
+import { readLatestChannelEvents } from '../capabilities/channel-health.js';
+const guidance = '在本机运行 gotry setup flyai（隐藏输入），或 gotry setup flyai --stdin；清除文件配置用 --clear。不要在聊天中发送 API key。打开 https://flyai.open.fliggy.com/console，登录后复制 API Key。';
+const guidanceImpact = '影响面:未配置 key 时 gotry_flyai_search 走匿名共享额度池(易达 Trial limit reached,达限本会话该工具不可用);配置后额度走本机 key,失败时按 verdict 改道 gotry_session_search 账号会话通道。';
+export function createFlyaiSetupTool(runEffect, stateRoot) {
+    return defineTool({
+        name: 'gotry_flyai_setup',
+        description: 'Inspect FlyAI credential source and verification status, or check the current configuration with a read-only search. Never accepts, changes or returns credentials. Check updates only a verification receipt; setting or clearing credentials requires the local gotry setup flyai command.',
+        parameters: { action: { type: 'string', enum: ['status', 'check'], description: 'status (default): local status; check: read-only provider verification' } },
+        output: { schema: { type: 'json' }, render: (_a, value) => [{ type: 'text', text: JSON.stringify(value) }] },
+        async execute(args, exec) {
+            // Reject unknown arguments before any provider invocation or metadata write.
+            if (Object.keys(args).some(key => key !== 'action') || (args.action !== undefined && args.action !== 'status' && args.action !== 'check')) {
+                return { ok: false, summary: `仅支持 status/check；不接收凭据。${guidance} ${guidanceImpact}` };
+            }
+            const home = homedir();
+            const current = resolveFlyaiKey();
+            const endpoint = resolveFlyaiEndpoint();
+            const fingerprint = endpointFingerprint(endpoint.url);
+            let receipt = readFlyaiVerification(home);
+            let checkVerdict;
+            let receiptSaved;
+            if (args.action === 'check') {
+                const date = new Date(Date.now() + 7 * 86_400_000).toISOString().slice(0, 10);
+                const outcome = await runEffect({ effect: 'FLYAI_SEARCH', params: {
+                        kind: 'flight', origin: '上海', destination: '北京', depDate: date,
+                        timeoutMs: 20_000, signal: exec?.signal,
+                    } });
+                const result = outcome.result;
+                checkVerdict = outcome.trace.declined === 'aborted' ? 'cancelled' : result?.verdict ?? 'error';
+                // A concurrent local credential change invalidates this check's receipt.
+                const after = resolveFlyaiKey();
+                const unchanged = current.key === after.key && current.source === after.source
+                    && fingerprint === endpointFingerprint(resolveFlyaiEndpoint().url);
+                if (current.key && fingerprint && unchanged && checkVerdict !== 'cancelled') {
+                    const allowed = ['auth-error', 'forbidden', 'rate-limited', 'timeout', 'needs-setup', 'error'];
+                    const verdict = checkVerdict === 'hit' || checkVerdict === 'miss' ? 'verified'
+                        : allowed.find(value => value === checkVerdict) ?? 'error';
+                    receipt = { schema: 'gotry.flyai-verification.v1', source: current.source,
+                        keySha256: sha256Hex(current.key), maskedKey: current.maskedKey ?? '****',
+                        endpointFingerprint: fingerprint, endpointDebug: endpoint.debug,
+                        verdict, at: new Date().toISOString() };
+                    receiptSaved = writeFlyaiVerification(receipt, home);
+                }
+            }
+            const matches = Boolean(current.key && receipt && receipt.keySha256 === sha256Hex(current.key)
+                && receipt.source === current.source && receipt.endpointFingerprint === fingerprint
+                && receipt.endpointDebug === endpoint.debug);
+            const verified = matches && receipt?.verdict === 'verified';
+            const event = stateRoot ? (await readLatestChannelEvents(stateRoot, { requireValidTimestamp: true })).get('flyai') : undefined;
+            const lastTrialLimit = event?.state === 'down' && event.reason === 'needs-setup' ? event.at : undefined;
+            const status = !current.key ? '匿名试用（共享额度）' : verified ? '已验证当前配置' : '已配置，未验证通过';
+            const summary = `${status}；来源 ${current.source}；endpoint ${displayEndpoint(endpoint.url)}${endpoint.debug ? '（DEBUG）' : ''}。`
+                + (checkVerdict ? `本次只读检查：${checkVerdict}。` : '')
+                + (lastTrialLimit ? `最近试用额度受限：${lastTrialLimit}。` : '')
+                + (receiptSaved === false ? '验证回执保存失败，doctor 状态尚未更新。' : '') + guidance
+                + ' ' + guidanceImpact;
+            return JSON.parse(JSON.stringify({ ok: receiptSaved !== false && (!checkVerdict || checkVerdict === 'hit' || checkVerdict === 'miss'), action: args.action ?? 'status',
+                source: current.source, configured: Boolean(current.key), verified,
+                maskedKey: current.maskedKey, configPath: current.configPath,
+                endpoint: displayEndpoint(endpoint.url), endpointDebug: endpoint.debug,
+                checkVerdict, receiptSaved, lastTrialLimit, summary }));
+        },
+        // Do not retain unexpected arguments even when a host bypasses schema validation.
+        presentCall: args => ({ card: 'generic', title: 'FlyAI 配置检查', kind: 'fetch', rawInput: { action: args.action === 'check' ? 'check' : 'status' } }),
+    });
+}