@danceiny/gotry 0.0.1-rc.16 → 0.0.1-rc.17

package/dist/src/bridge.js

@@ -31,4 +31,4 @@ export async function recordLatency(logPath, latencyMs, kind) {
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry-publish/ts/src/bridge.ts
+//# sourceURL=ts/src/bridge.ts

package/dist/src/companions.js

@@ -109,4 +109,4 @@ export function upsertCompanion(profiles, patch) {
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry-publish/ts/src/companions.ts
+//# sourceURL=ts/src/companions.ts

package/dist/src/contracts.js

@@ -61,4 +61,4 @@ export const TRIP_STATE_JSON_SCHEMA = {
 };
 
 
-//# sourceURL=/Users/bytedance/work/gotry-publish/ts/src/contracts.ts
+//# sourceURL=ts/src/contracts.ts

package/dist/src/dsh-llm.js

@@ -195,4 +195,4 @@ export function createOpenAICompatLlm(flightPackPath, clock = ()=>new Date()) {
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry-publish/ts/src/dsh-llm.ts
+//# sourceURL=ts/src/dsh-llm.ts

package/dist/src/engine.js

@@ -397,4 +397,4 @@ function renderMarkdown(req, verdicts, recommended) {
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry-publish/ts/src/engine.ts
+//# sourceURL=ts/src/engine.ts

package/dist/src/evaluation-cadence.js

@@ -0,0 +1,234 @@
+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;
+}
+
+
+//# sourceURL=ts/src/evaluation-cadence.ts