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

package/dist/scripts/engine-run.js

@@ -1,3 +1,4 @@
+// TS 引擎直接跑洱海金标准用例,打印与 Python 相同结构的结果
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { parseCandidate, parseRequest } from '../src/model.js';
@@ -9,6 +10,3 @@ const t0 = Date.now();
 const result = await solve(req, candidates);
 console.log(`(TS 引擎总耗时含 WASM init: ${Date.now() - t0}ms, recommended=${result['recommended']})\n`);
 console.log(result['answer_md']);
-
-
-//# sourceURL=ts/scripts/engine-run.ts

package/dist/scripts/engine-tests.js

@@ -1,3 +1,7 @@
+/**
+ * TS 引擎金标准断言(与 py/tests/test_engine.py 同一套洱海用例)。
+ * 运行(在 ts/ 下):npx tsx scripts/engine-tests.ts
+ */
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -7,39 +11,41 @@ const payload = JSON.parse(await readFile(join('..', 'data', 'golden_erhai.json'
 const req = parseRequest(payload['request']);
 const candidates = payload['candidates'].map(parseCandidate);
 const result = await solve(req, candidates);
-const verdicts = Object.fromEntries(result.verdicts.map((v)=>[
-        v['candidate_id'],
-        v
-    ]));
+const verdicts = Object.fromEntries(result.verdicts.map(v => [v['candidate_id'], v]));
+// 1. 洱海在周末窗口不可行,unsat core 必须点名 duration
 assert.equal(verdicts['dali']['feasible'], false);
 assert.ok(verdicts['dali']['unsat_core'].includes('duration'));
+// 2. 憧憬不被拒绝:进 wish pool,带成行条件
 const wp = verdicts['dali']['wish_pool'];
 assert.ok(wp, 'dali wish pool exists');
 assert.ok(wp['conditions']['days'] >= 5);
 assert.ok('budget_cny' in wp['conditions']);
 assert.ok(wp['conditions']['best_months'].length > 0);
+// 3. 最小修改建议必须写明代价
 assert.ok(verdicts['dali']['suggestions'].length > 0);
-assert.ok(verdicts['dali']['suggestions'].some((s)=>s['text'].includes('天')));
+assert.ok(verdicts['dali']['suggestions'].some((s) => s['text'].includes('天')));
+// 4. 千岛湖可行且被推荐
 assert.equal(verdicts['qiandao']['feasible'], true);
 assert.equal(result.recommended, 'qiandao');
+// 5. 全成本六要素齐全
 const t = verdicts['qiandao']['true_cost'];
 assert.ok(t['money_cny'] <= 3000);
 assert.ok(Number(String(t['wake']).replace(':', '')) >= 630);
 assert.ok(t['energy_arrival_pct'] >= 40);
 assert.ok(t['usable_hours'] >= requiredUsableHours(req.motivation));
+// 6. 太湖也可行且更便宜(同一可行口径内)
 assert.equal(verdicts['taihu']['feasible'], true);
 assert.ok(verdicts['taihu']['true_cost']['money_cny'] <= verdicts['qiandao']['true_cost']['money_cny']);
+// 7. 回答不空手而归
 assert.ok(result.answer_md.includes('千岛湖'));
 assert.ok(result.answer_md.includes('下一次出发'));
 assert.ok(result.answer_md.includes('待你决定的两个问题'));
+// 8. 预算差一口气的场景:报告差额而非拒绝
 const tight = structuredClone(payload);
 tight['request']['budget_cny'] = 900;
 const tightReq = parseRequest(tight['request']);
-const v = await solveCandidate(candidates.find((c)=>c.id === 'qiandao'), tightReq);
+const v = await solveCandidate(candidates.find(c => c.id === 'qiandao'), tightReq);
 assert.equal(v.feasible, false);
 assert.ok(v.unsatCore.includes('budget'));
-assert.ok(v.suggestions.some((s)=>s.text.includes('预算提高到')));
+assert.ok(v.suggestions.some(s => s.text.includes('预算提高到')));
 console.log('TS ENGINE TESTS: 8/8 OK');
-
-
-//# sourceURL=ts/scripts/engine-tests.ts

package/dist/scripts/evaluation-cadence-tests.js

@@ -1,10 +1,15 @@
+/**
+ * Contract tests for the evaluation cadence policy and planner.
+ * Run from ts/: npx tsx scripts/evaluation-cadence-tests.ts
+ */
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import assert from 'node:assert/strict';
-import { parseEvaluationCadencePolicy, planEvaluationCadence } from '../src/evaluation-cadence.js';
+import { parseEvaluationCadencePolicy, planEvaluationCadence, } from '../src/evaluation-cadence.js';
 import { assertPublicArtifactSafe } from '../src/evaluation-contracts.js';
 const policyPath = join(process.cwd(), 'data', 'evaluation', 'cadence-policy.json');
 async function loadPolicyFixture() {
+    // This must remain a real fixture load: policy behavior is not tested with an inline mock.
     return JSON.parse(await readFile(policyPath, 'utf8'));
 }
 function expectThrows(fn, message) {
@@ -14,66 +19,16 @@ async function testCanonicalPolicyAndHealthyWeeklyPlan() {
     const raw = await loadPolicyFixture();
     const policy = parseEvaluationCadencePolicy(raw);
     assertPublicArtifactSafe(policy, 'test policy safety');
-    assert.deepEqual(policy.levels.map((level)=>level.cadence), [
-        'pr',
-        'nightly',
-        'weekly',
-        'milestone'
-    ]);
-    assert.deepEqual(policy.levels.map((level)=>level.pass_k), [
-        1,
-        2,
-        3,
-        5
-    ]);
-    assert.deepEqual(policy.levels.map((level)=>level.max_cost_usd), [
-        0,
-        2,
-        10,
-        50
-    ]);
-    assert.deepEqual(policy.levels.map((level)=>level.max_wall_minutes), [
-        20,
-        90,
-        360,
-        1440
-    ]);
-    assert.deepEqual(policy.levels.map((level)=>level.max_tool_calls_per_case), [
-        18,
-        18,
-        18,
-        18
-    ]);
-    assert.deepEqual(policy.levels.map((level)=>[
-            level.human_calibration.required,
-            level.human_calibration.min_samples
-        ]), [
-        [
-            false,
-            0
-        ],
-        [
-            false,
-            0
-        ],
-        [
-            true,
-            10
-        ],
-        [
-            true,
-            30
-        ]
-    ]);
+    assert.deepEqual(policy.levels.map((level) => level.cadence), ['pr', 'nightly', 'weekly', 'milestone']);
+    assert.deepEqual(policy.levels.map((level) => level.pass_k), [1, 2, 3, 5]);
+    assert.deepEqual(policy.levels.map((level) => level.max_cost_usd), [0, 2, 10, 50]);
+    assert.deepEqual(policy.levels.map((level) => level.max_wall_minutes), [20, 90, 360, 1440]);
+    assert.deepEqual(policy.levels.map((level) => level.max_tool_calls_per_case), [18, 18, 18, 18]);
+    assert.deepEqual(policy.levels.map((level) => [level.human_calibration.required, level.human_calibration.min_samples]), [[false, 0], [false, 0], [true, 10], [true, 30]]);
     const decision = planEvaluationCadence(policy, {
         cadence: 'weekly',
         signals: [],
-        recent_optimization_prs: [
-            81,
-            84,
-            87,
-            89
-        ]
+        recent_optimization_prs: [81, 84, 87, 89],
     });
     assert.deepEqual(decision, {
         cadence: 'weekly',
@@ -85,24 +40,15 @@ async function testCanonicalPolicyAndHealthyWeeklyPlan() {
         max_cost_usd: 10,
         max_wall_minutes: 360,
         max_tool_calls_per_case: 18,
-        human_calibration: {
-            required: true,
-            min_samples: 10
-        },
-        cross_benchmark_window: {
-            min_prs: 3,
-            max_prs: 5
-        },
+        human_calibration: { required: true, min_samples: 10 },
+        cross_benchmark_window: { min_prs: 3, max_prs: 5 },
         performance_tradeoff_disclosure_threshold: 0.2,
         delivery: {
             exactly_one_gotry_pr: true,
             exactly_one_discussion_78_comment: true,
-            update_existing_comment: true
+            update_existing_comment: true,
         },
-        cross_benchmark_synthesis: {
-            required: true,
-            overdue: false
-        }
+        cross_benchmark_synthesis: { required: true, overdue: false },
     });
     assertPublicArtifactSafe(decision, 'test decision safety');
 }
@@ -110,214 +56,98 @@ async function testStopSignalsDenyAdmissionAndRegisterFailures() {
     const policy = parseEvaluationCadencePolicy(await loadPolicyFixture());
     const decision = planEvaluationCadence(policy, {
         cadence: 'weekly',
-        signals: [
-            'source_revision_drift',
-            'hard_violation'
-        ],
-        recent_optimization_prs: [
-            81,
-            84,
-            87
-        ]
+        signals: ['source_revision_drift', 'hard_violation'],
+        recent_optimization_prs: [81, 84, 87],
     });
     assert.equal(decision.admission, false);
-    assert.deepEqual(decision.stop_signals, [
-        'source_revision_drift',
-        'hard_violation'
-    ]);
+    assert.deepEqual(decision.stop_signals, ['source_revision_drift', 'hard_violation']);
     assert.equal(decision.failure_registry, true);
     const nonRegistry = planEvaluationCadence(policy, {
         cadence: 'weekly',
-        signals: [
-            'license_unresolved'
-        ],
-        recent_optimization_prs: [
-            81,
-            84,
-            87
-        ]
+        signals: ['license_unresolved'],
+        recent_optimization_prs: [81, 84, 87],
     });
     assert.equal(nonRegistry.admission, false);
     assert.equal(nonRegistry.failure_registry, false);
     const allSignals = planEvaluationCadence(policy, {
         cadence: 'weekly',
-        signals: [
-            'source_revision_drift',
-            'license_unresolved',
-            'scorer_ceiling_invalid',
-            'known_bad_no_longer_fails',
-            'hard_violation',
-            'matched_regression',
-            'variance_breach',
-            'budget_breach'
-        ],
-        recent_optimization_prs: []
+        signals: ['source_revision_drift', 'license_unresolved', 'scorer_ceiling_invalid', 'known_bad_no_longer_fails', 'hard_violation', 'matched_regression', 'variance_breach', 'budget_breach'],
+        recent_optimization_prs: [],
     });
     assert.equal(allSignals.admission, false);
     assert.equal(allSignals.failure_registry, true);
-    const duplicatePrs = {
-        cadence: 'weekly',
-        signals: [],
-        recent_optimization_prs: [
-            81,
-            81,
-            82
-        ]
-    };
-    expectThrows(()=>planEvaluationCadence(policy, duplicatePrs), 'duplicate optimization PR IDs must fail closed');
+    const duplicatePrs = { cadence: 'weekly', signals: [], recent_optimization_prs: [81, 81, 82] };
+    expectThrows(() => planEvaluationCadence(policy, duplicatePrs), 'duplicate optimization PR IDs must fail closed');
     const sparsePrs = [];
     sparsePrs[2] = 81;
-    expectThrows(()=>planEvaluationCadence(policy, {
-            cadence: 'weekly',
-            signals: [],
-            recent_optimization_prs: sparsePrs
-        }), 'sparse optimization PR IDs must fail closed');
-    expectThrows(()=>planEvaluationCadence(policy, {
-            cadence: 'weekly',
-            signals: [],
-            recent_optimization_prs: [
-                0
-            ]
-        }), 'non-positive optimization PR IDs must fail closed');
-    expectThrows(()=>planEvaluationCadence(policy, {
-            cadence: 'weekly',
-            signals: [],
-            recent_optimization_prs: [
-                1.5
-            ]
-        }), 'fractional optimization PR IDs must fail closed');
+    expectThrows(() => planEvaluationCadence(policy, { cadence: 'weekly', signals: [], recent_optimization_prs: sparsePrs }), 'sparse optimization PR IDs must fail closed');
+    expectThrows(() => planEvaluationCadence(policy, { cadence: 'weekly', signals: [], recent_optimization_prs: [0] }), 'non-positive optimization PR IDs must fail closed');
+    expectThrows(() => planEvaluationCadence(policy, { cadence: 'weekly', signals: [], recent_optimization_prs: [1.5] }), 'fractional optimization PR IDs must fail closed');
 }
 async function testRoundDeliveryAndMilestoneCalibration() {
     const policy = parseEvaluationCadencePolicy(await loadPolicyFixture());
     const milestone = planEvaluationCadence(policy, {
         cadence: 'milestone',
         signals: [],
-        recent_optimization_prs: [
-            81,
-            84,
-            87,
-            89,
-            91
-        ]
+        recent_optimization_prs: [81, 84, 87, 89, 91],
     });
     assert.equal(milestone.admission, true);
     assert.equal(milestone.pass_k, 5);
-    assert.deepEqual(milestone.human_calibration, {
-        required: true,
-        min_samples: 30
-    });
-    assert.deepEqual(milestone.cross_benchmark_window, {
-        min_prs: 3,
-        max_prs: 5
-    });
+    assert.deepEqual(milestone.human_calibration, { required: true, min_samples: 30 });
+    assert.deepEqual(milestone.cross_benchmark_window, { min_prs: 3, max_prs: 5 });
     assert.equal(milestone.performance_tradeoff_disclosure_threshold, 0.2);
     assert.deepEqual(milestone.delivery, {
         exactly_one_gotry_pr: true,
         exactly_one_discussion_78_comment: true,
-        update_existing_comment: true
-    });
-    assert.deepEqual(milestone.cross_benchmark_synthesis, {
-        required: true,
-        overdue: false
-    });
-    assert.deepEqual(planEvaluationCadence(policy, {
-        cadence: 'weekly',
-        signals: [],
-        recent_optimization_prs: []
-    }).cross_benchmark_synthesis, {
-        required: false,
-        overdue: false
-    });
-    assert.deepEqual(planEvaluationCadence(policy, {
-        cadence: 'weekly',
-        signals: [],
-        recent_optimization_prs: [
-            81,
-            82,
-            83,
-            84,
-            85,
-            86
-        ]
-    }).cross_benchmark_synthesis, {
-        required: true,
-        overdue: true
+        update_existing_comment: true,
     });
+    assert.deepEqual(milestone.cross_benchmark_synthesis, { required: true, overdue: false });
+    assert.deepEqual(planEvaluationCadence(policy, { cadence: 'weekly', signals: [], recent_optimization_prs: [] }).cross_benchmark_synthesis, { required: false, overdue: false });
+    assert.deepEqual(planEvaluationCadence(policy, { cadence: 'weekly', signals: [], recent_optimization_prs: [81, 82, 83, 84, 85, 86] }).cross_benchmark_synthesis, { required: true, overdue: true });
 }
 async function testMalformedPolicyFailsClosed() {
     const fixture = await loadPolicyFixture();
-    const malformed = (change)=>{
+    const malformed = (change) => {
         const copy = structuredClone(fixture);
         change(copy);
-        expectThrows(()=>parseEvaluationCadencePolicy(copy), 'malformed policy must fail closed');
+        expectThrows(() => parseEvaluationCadencePolicy(copy), 'malformed policy must fail closed');
     };
-    malformed((copy)=>{
-        copy.unknown_key = true;
-    });
-    malformed((copy)=>{
-        copy.levels[0].cadence = 'hourly';
-    });
-    malformed((copy)=>{
-        copy.levels[0].pass_k = -1;
-    });
-    malformed((copy)=>{
-        copy.levels[0].pass_k = 1.5;
-    });
-    malformed((copy)=>{
-        copy.levels = [
-            ...copy.levels
-        ].reverse();
-    });
-    malformed((copy)=>{
-        const sparse = [];
-        sparse[3] = copy.levels[3];
-        copy.levels = sparse;
-    });
-    malformed((copy)=>{
-        delete copy.stop_signals;
-    });
+    malformed((copy) => { copy.unknown_key = true; });
+    malformed((copy) => { copy.levels[0].cadence = 'hourly'; });
+    malformed((copy) => { copy.levels[0].pass_k = -1; });
+    malformed((copy) => { copy.levels[0].pass_k = 1.5; });
+    malformed((copy) => { copy.levels = [...copy.levels].reverse(); });
+    malformed((copy) => { const sparse = []; sparse[3] = copy.levels[3]; copy.levels = sparse; });
+    malformed((copy) => { delete copy.stop_signals; });
     const policy = parseEvaluationCadencePolicy(fixture);
     const tamperedPolicy = structuredClone(policy);
     tamperedPolicy.levels[2].max_cost_usd = 999;
-    expectThrows(()=>planEvaluationCadence(tamperedPolicy, {
-            cadence: 'weekly',
-            signals: [],
-            recent_optimization_prs: []
-        }), 'tampered policy budget must fail closed');
+    expectThrows(() => planEvaluationCadence(tamperedPolicy, { cadence: 'weekly', signals: [], recent_optimization_prs: [] }), 'tampered policy budget must fail closed');
     const tamperedDelivery = structuredClone(policy);
     tamperedDelivery.round_delivery.exactly_one_gotry_pr = false;
-    expectThrows(()=>planEvaluationCadence(tamperedDelivery, {
-            cadence: 'weekly',
-            signals: [],
-            recent_optimization_prs: []
-        }), 'tampered policy delivery must fail closed');
-    expectThrows(()=>planEvaluationCadence(policy, {
-            cadence: 'hourly',
-            signals: [],
-            recent_optimization_prs: []
-        }), 'unknown cadence must fail closed');
-    expectThrows(()=>planEvaluationCadence(policy, {
-            cadence: 'weekly',
-            signals: [
-                'unknown_signal'
-            ],
-            recent_optimization_prs: []
-        }), 'unknown stop signal must fail closed');
-    expectThrows(()=>planEvaluationCadence(policy, {
-            cadence: 'weekly',
-            signals: [
-                'hard_violation',
-                'hard_violation'
-            ],
-            recent_optimization_prs: []
-        }), 'duplicate stop signals must fail closed');
+    expectThrows(() => planEvaluationCadence(tamperedDelivery, { cadence: 'weekly', signals: [], recent_optimization_prs: [] }), 'tampered policy delivery must fail closed');
+    expectThrows(() => planEvaluationCadence(policy, {
+        cadence: 'hourly',
+        signals: [],
+        recent_optimization_prs: [],
+    }), 'unknown cadence must fail closed');
+    expectThrows(() => planEvaluationCadence(policy, {
+        cadence: 'weekly',
+        signals: ['unknown_signal'],
+        recent_optimization_prs: [],
+    }), 'unknown stop signal must fail closed');
+    expectThrows(() => planEvaluationCadence(policy, {
+        cadence: 'weekly',
+        signals: ['hard_violation', 'hard_violation'],
+        recent_optimization_prs: [],
+    }), 'duplicate stop signals must fail closed');
     const sparseSignals = [];
     sparseSignals[1] = 'hard_violation';
-    expectThrows(()=>planEvaluationCadence(policy, {
-            cadence: 'weekly',
-            signals: sparseSignals,
-            recent_optimization_prs: []
-        }), 'sparse stop signals must fail closed');
+    expectThrows(() => planEvaluationCadence(policy, {
+        cadence: 'weekly',
+        signals: sparseSignals,
+        recent_optimization_prs: [],
+    }), 'sparse stop signals must fail closed');
 }
 async function testPolicyPublicSafety() {
     const policy = parseEvaluationCadencePolicy(await loadPolicyFixture());
@@ -326,7 +156,7 @@ async function testPolicyPublicSafety() {
         contains_third_party_prompt: false,
         contains_gold: false,
         contains_oracle: false,
-        contains_private_data: false
+        contains_private_data: false,
     });
 }
 async function main() {
@@ -337,11 +167,8 @@ async function main() {
     await testPolicyPublicSafety();
     console.log('evaluation cadence tests: PASS');
 }
-main().catch((error)=>{
+main().catch((error) => {
     console.error('evaluation cadence tests: FAIL');
     console.error(error);
     process.exitCode = 1;
 });
-
-
-//# sourceURL=ts/scripts/evaluation-cadence-tests.ts