harness-everything 0.29.0 → 0.30.0

package/ci/system-one-laya-calibrate-test.py

@@ -0,0 +1,65 @@
+"""Stdlib tests for the Laya zero-shot calibration (#255 Phase 3 prep).
+
+No model dependency. Run with:
+    python3 ci/system-one-laya-calibrate-test.py
+"""
+import importlib.util
+import sys
+import unittest
+from pathlib import Path
+
+sys.dont_write_bytecode = True  # never leave __pycache__ in the source tree that packaging copies
+path = Path(__file__).resolve().parents[1] / 'scripts/system-one-calibrate-laya.py'
+spec = importlib.util.spec_from_file_location('laya_calibrate', path)
+laya_calibrate = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(laya_calibrate)
+
+
+class IsotonicTests(unittest.TestCase):
+    def test_exact_staircase_on_separable_data(self):
+        knots = laya_calibrate.isotonic_fit([0.1, 0.2, 0.8, 0.9], [0.0, 0.0, 1.0, 1.0])
+        self.assertEqual([laya_calibrate.isotonic_predict(knots, x) for x in (0.1, 0.2, 0.8, 0.9)],
+                         [0.0, 0.0, 1.0, 1.0])
+
+    def test_predictions_are_monotone(self):
+        xs = [0.05, 0.4, 0.35, 0.7, 0.6, 0.9, 0.2, 0.5]
+        ys = [0.0, 1.0, 0.0, 0.6, 1.0, 0.8, 0.2, 0.4]
+        knots = laya_calibrate.isotonic_fit(xs, ys)
+        grid = [i / 20 for i in range(21)]
+        preds = [laya_calibrate.isotonic_predict(knots, x) for x in grid]
+        self.assertTrue(all(b >= a for a, b in zip(preds, preds[1:])), 'monotone non-decreasing')
+
+    def test_duplicate_x_averages_y(self):
+        knots = laya_calibrate.isotonic_fit([0.5, 0.5, 0.5], [0.0, 0.6, 0.3])
+        self.assertAlmostEqual(laya_calibrate.isotonic_predict(knots, 0.5), 0.3)
+
+    def test_clamps_outside_range(self):
+        knots = laya_calibrate.isotonic_fit([0.2, 0.8], [0.3, 0.9])
+        self.assertEqual(laya_calibrate.isotonic_predict(knots, 0.0), 0.3)
+        self.assertEqual(laya_calibrate.isotonic_predict(knots, 1.0), 0.9)
+
+    def test_knots_are_json_serializable(self):
+        import json
+        knots = laya_calibrate.isotonic_fit([0.1, 0.9, 0.4], [0.2, 0.8, 0.5])
+        self.assertEqual(json.loads(json.dumps(knots)), knots)
+
+
+class DeriveCalibratedTests(unittest.TestCase):
+    def scores(self, **over):
+        base = {i: 0.0 for i in
+                ['explain', 'discuss', 'git', 'fix', 'edit', 'feature', 'refactor',
+                 'review', 'test', 'docs', 'plan', 'investigate']}
+        base.update(over)
+        return base
+
+    def test_null_cutoff_abstains_low_max(self):
+        out = laya_calibrate.derive_calibrated(self.scores(fix=0.5, test=0.3), {}, 0.6)
+        self.assertIsNone(out['gold'])
+
+    def test_identity_mapping_keeps_bands(self):
+        out = laya_calibrate.derive_calibrated(self.scores(fix=0.9, test=0.5), {}, 0.2)
+        self.assertEqual((out['gold'], out['secondary']), ('fix', ['test']))
+
+
+if __name__ == '__main__':
+    unittest.main()

package/ci/system-one-laya-export-test.py

@@ -0,0 +1,155 @@
+"""Stdlib contract tests for the Laya soft-target exporter (#255 Phase 3).
+
+The exporter converts teacher relevance scores to upstream RLCD training
+items without loading any model: sequence building is injected. Run with:
+    python3 ci/system-one-laya-export-test.py
+"""
+import importlib.util
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.dont_write_bytecode = True  # never leave __pycache__ in the source tree that packaging copies
+path = Path(__file__).resolve().parents[1] / 'scripts/system-one-export-laya.py'
+spec = importlib.util.spec_from_file_location('laya_exporter', path)
+laya_exporter = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(laya_exporter)
+
+INTENTS = ['explain', 'discuss', 'git', 'fix', 'edit', 'feature', 'refactor',
+           'review', 'test', 'docs', 'plan', 'investigate']
+
+
+def fake_builder(state, instructions, probs):
+    """Deterministic stub: token ids derive from the text, markers fixed."""
+    ids = [len(state) % 251 + 1, len(instructions) % 251 + 1, 7]
+    return {'ids': ids, 'markers': [0, 1], 'target': [probs['false'], probs['true']]}
+
+
+class ItemTests(unittest.TestCase):
+    def test_noul_target_is_false_true_pair(self):
+        item = laya_exporter.build_item('fix it', 'repair?', {'true': 0.8, 'false': 0.2}, fake_builder)
+        self.assertEqual(item['qtype'], 2, 'noul qtype follows laya.common.QTYPES')
+        self.assertEqual(item['target'], [0.2, 0.8])
+        self.assertEqual(item['label'], 1)
+
+    def test_relevance_p_maps_to_true_p(self):
+        item = laya_exporter.build_item('x', 'y', {'true': 0.0, 'false': 1.0}, fake_builder)
+        self.assertEqual((item['target'], item['label']), ([1.0, 0.0], 0))
+
+    def test_target_distribution_is_conserved(self):
+        for p in (0.0, 0.25, 0.6, 1.0):
+            item = laya_exporter.build_item('x', 'y', {'true': p, 'false': 1 - p}, fake_builder)
+            self.assertAlmostEqual(sum(item['target']), 1.0, msg=f'p={p}')
+
+    def test_bad_probabilities_fail(self):
+        with self.assertRaisesRegex(ValueError, 'probabilities'):
+            laya_exporter.build_item('x', 'y', {'true': 0.8, 'false': 0.8}, fake_builder)
+
+
+class ExportTests(unittest.TestCase):
+    def write_data(self, data, prompts, teacher):
+        (data / 'prompts.jsonl').write_text(
+            '\n'.join(json.dumps(p) for p in prompts) + '\n', encoding='utf-8')
+        (data / 'labels-intent-scores.jsonl').write_text(
+            '\n'.join(json.dumps(t) for t in teacher) + '\n', encoding='utf-8')
+
+    def teacher_row(self, id, scores):
+        return {'id': id, 'gold': 'fix', 'secondary': [], 'scores': scores}
+
+    def test_exports_train_only_in_id_order(self):
+        prompts = [{'id': 'b', 'split': 'train', 'text': 'commit'},
+                   {'id': 'a', 'split': 'train', 'text': 'fix it'},
+                   {'id': 'c', 'split': 'validation', 'text': 'skip me'}]
+        scores = {i: (0.9 if i == 'fix' else 0.0) for i in INTENTS}
+        with tempfile.TemporaryDirectory() as d:
+            data = Path(d) / 'data'
+            data.mkdir()
+            self.write_data(data, prompts, [self.teacher_row('a', scores), self.teacher_row('b', scores)])
+            out = Path(d) / 'train_items.json'
+            manifest = Path(d) / 'manifest.json'
+            summary = laya_exporter.export(data, 'train', out, manifest, fake_builder, seed=0)
+            self.assertEqual(summary['items'], 24, '2 prompts x 12 intents')
+            rows = [json.loads(line) for line in out.read_text(encoding='utf-8').strip().split('\n')]
+            self.assertEqual([r['promptId'] for r in rows[::12]], ['a', 'b'], 'deterministic id order')
+            self.assertTrue(all(set(r) >= {'promptId', 'intent', 'ids', 'markers', 'qtype', 'target', 'label'} for r in rows))
+            self.assertEqual(summary['manifest']['seed'], 0)
+
+    def test_seed_controls_order(self):
+        prompts = [{'id': c, 'split': 'train', 'text': c * 20} for c in 'abcd']
+        scores = {i: 0.1 for i in INTENTS}
+        with tempfile.TemporaryDirectory() as d:
+            data = Path(d) / 'data'
+            data.mkdir()
+            self.write_data(data, prompts, [self.teacher_row(p['id'], scores) for p in prompts])
+            outs = []
+            for seed in (11, 11, 12):
+                out = Path(d) / f'o{seed}.json'
+                laya_exporter.export(data, 'train', out, Path(d) / f'm{seed}.json', fake_builder, seed=seed)
+                outs.append([json.loads(line)['promptId'] for line in out.read_text(encoding='utf-8').strip().split('\n')][::12])
+        self.assertEqual(outs[0], outs[1], 'same seed replays the order')
+        self.assertNotEqual(outs[0], outs[2], 'a different seed shuffles')
+
+    def test_overlap_with_forbidden_ids_fails(self):
+        prompts = [{'id': 'a', 'split': 'train', 'text': 'fix it'}]
+        scores = {i: 0.1 for i in INTENTS}
+        with tempfile.TemporaryDirectory() as d:
+            data = Path(d) / 'data'
+            data.mkdir()
+            self.write_data(data, prompts, [self.teacher_row('a', scores)])
+            forbid = Path(d) / 'forbid.json'
+            forbid.write_text(json.dumps(['a']), encoding='utf-8')
+            with self.assertRaisesRegex(ValueError, 'overlap'):
+                laya_exporter.export(data, 'train', Path(d) / 'o.json', Path(d) / 'm.json',
+                                     fake_builder, seed=7, forbid_path=forbid)
+
+    def test_missing_teacher_row_is_skipped_and_counted(self):
+        prompts = [{'id': 'a', 'split': 'train', 'text': 'fix it'},
+                   {'id': 'b', 'split': 'train', 'text': 'no teacher'}]
+        scores = {i: 0.1 for i in INTENTS}
+        with tempfile.TemporaryDirectory() as d:
+            data = Path(d) / 'data'
+            data.mkdir()
+            self.write_data(data, prompts, [self.teacher_row('a', scores)])
+            out = Path(d) / 'o.json'
+            summary = laya_exporter.export(data, 'train', out, Path(d) / 'm.json', fake_builder, seed=7)
+        self.assertEqual((summary['items'], summary['skippedNoTeacher']), (12, 1))
+
+    def test_oversample_repeats_only_selected_positive_intent(self):
+        prompts = [{'id': 'a', 'split': 'train', 'text': 'restructure'},
+                   {'id': 'b', 'split': 'train', 'text': 'fix it'}]
+        scores_a = {i: (0.9 if i == 'refactor' else 0.0) for i in INTENTS}
+        scores_b = {i: (0.9 if i == 'fix' else 0.0) for i in INTENTS}
+        with tempfile.TemporaryDirectory() as d:
+            data = Path(d) / 'data'
+            data.mkdir()
+            self.write_data(data, prompts, [self.teacher_row('a', scores_a), self.teacher_row('b', scores_b)])
+            out = Path(d) / 'o.json'
+            summary = laya_exporter.export(data, 'train', out, Path(d) / 'm.json', fake_builder,
+                                           seed=0, oversample={'refactor': 3})
+            rows = [json.loads(line) for line in out.read_text(encoding='utf-8').strip().split('\n')]
+            keys = [(r['promptId'], r['intent']) for r in rows]
+            self.assertEqual(summary['items'], 26, '24 base items plus two refactor repeats')
+            self.assertEqual(keys.count(('a', 'refactor')), 3)
+            self.assertTrue(all(keys.count(('a', intent)) == 1 for intent in INTENTS if intent != 'refactor'),
+                            'sibling intents must not be reweighted')
+            self.assertTrue(all(keys.count(('b', intent)) == 1 for intent in INTENTS),
+                            'non-positive prompt must remain at base multiplicity')
+            self.assertEqual(summary['manifest']['oversample'], {'refactor': 3})
+
+    def test_bad_oversample_spec_fails(self):
+        with tempfile.TemporaryDirectory() as d:
+            data = Path(d) / 'data'
+            data.mkdir()
+            self.write_data(data, [], [])
+            with self.assertRaisesRegex(ValueError, 'oversample'):
+                laya_exporter.export(data, 'train', Path(d) / 'o.json', Path(d) / 'm.json',
+                                     fake_builder, oversample={'nope': 2})
+            with self.assertRaisesRegex(ValueError, 'oversample'):
+                laya_exporter.export(data, 'train', Path(d) / 'o.json', Path(d) / 'm.json',
+                                     fake_builder, oversample={'fix': 1})
+
+
+if __name__ == '__main__':
+    unittest.main()

package/ci/system-one-laya-label-test.py

@@ -0,0 +1,201 @@
+"""Stdlib contract tests for the Laya dense intent labeler (#255 Phase 1+2).
+
+No model dependency: backends are injected as stubs. Run with:
+    python3 ci/system-one-laya-label-test.py
+"""
+import importlib.util
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.dont_write_bytecode = True  # never leave __pycache__ in the source tree that packaging copies
+path = Path(__file__).resolve().parents[1] / 'scripts/system-one-label-laya.py'
+spec = importlib.util.spec_from_file_location('laya_labeler', path)
+laya_labeler = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(laya_labeler)
+
+INTENTS = ['explain', 'discuss', 'git', 'fix', 'edit', 'feature', 'refactor',
+           'review', 'test', 'docs', 'plan', 'investigate']
+
+
+class MappingTests(unittest.TestCase):
+    def test_intent_order_matches_owner_catalog(self):
+        # catalogs.js INTENT_OPTIONS order is the scorer output order; it must not drift.
+        self.assertEqual(laya_labeler.INTENTS, INTENTS)
+
+    def test_every_intent_has_one_noul_question(self):
+        questions = laya_labeler.build_questions()
+        self.assertEqual(list(questions), INTENTS, 'question order follows the catalog order')
+        for intent, q in questions.items():
+            self.assertEqual(q['type'], 'noul')
+            self.assertTrue(q['instructions'], intent)
+
+    def test_question_order_change_keeps_semantic_mapping(self):
+        a = laya_labeler.build_questions()
+        b = laya_labeler.build_questions()
+        self.assertEqual(a, b)
+        self.assertEqual(list(a), INTENTS)
+
+    def test_mapping_version_is_pinned(self):
+        self.assertRegex(laya_labeler.QUESTIONS_VERSION, r'^v\d+$')
+
+    def test_v2_keeps_intents_and_order_but_sharpens_text(self):
+        v1 = laya_labeler.build_questions('v1')
+        v2 = laya_labeler.build_questions('v2')
+        self.assertEqual(list(v2), INTENTS)
+        for intent, q in v2.items():
+            self.assertEqual(q['type'], 'noul')
+            self.assertTrue(q['instructions'], intent)
+        self.assertTrue(any(v2[i]['instructions'] != v1[i]['instructions'] for i in INTENTS),
+                        'v2 rewords at least one intent')
+        self.assertEqual(v2['git']['instructions'], v1['git']['instructions'],
+                         'unconfused intents keep v1 text')
+
+    def test_unknown_questions_version_fails(self):
+        with self.assertRaisesRegex(ValueError, 'unknown questions version'):
+            laya_labeler.build_questions('v9')
+
+
+class ValidatorTests(unittest.TestCase):
+    def scores(self, **over):
+        base = {i: 0.0 for i in INTENTS}
+        base.update(over)
+        return base
+
+    def test_valid_scores_pass(self):
+        self.assertTrue(laya_labeler.validate_scores(self.scores(fix=0.9, test=0.4)))
+
+    def test_missing_or_unknown_key_fails(self):
+        bad = self.scores(fix=0.9)
+        del bad['fix']
+        with self.assertRaisesRegex(ValueError, 'keys'):
+            laya_labeler.validate_scores(bad)
+        bad2 = self.scores(fix=0.9)
+        bad2['nope'] = 0.1
+        with self.assertRaisesRegex(ValueError, 'keys'):
+            laya_labeler.validate_scores(bad2)
+
+    def test_out_of_range_or_nan_fails(self):
+        for v in (-0.1, 1.1, float('nan')):
+            with self.assertRaisesRegex(ValueError, 'range', msg=f'value={v}'):
+                laya_labeler.validate_scores(self.scores(fix=v))
+
+    def test_non_float_fails(self):
+        with self.assertRaisesRegex(ValueError, 'range'):
+            laya_labeler.validate_scores(self.scores(fix='0.9'))
+
+
+class DeriveTests(unittest.TestCase):
+    def scores(self, **over):
+        base = {i: 0.0 for i in INTENTS}
+        base.update(over)
+        return base
+
+    def test_primary_and_secondary_from_bands(self):
+        out = laya_labeler.derive_label(self.scores(fix=0.9, test=0.5, docs=0.3))
+        self.assertEqual(out['gold'], 'fix')
+        self.assertEqual(out['secondary'], ['test'])
+
+    def test_low_max_abstains(self):
+        out = laya_labeler.derive_label(self.scores(explain=0.2))
+        self.assertIsNone(out['gold'])
+        self.assertEqual(out['secondary'], [])
+
+    def test_tie_breaks_by_catalog_order(self):
+        out = laya_labeler.derive_label(self.scores(fix=0.7, test=0.7))
+        self.assertEqual(out['gold'], 'fix')
+
+    def test_derived_labels_are_marked_bootstrap(self):
+        out = laya_labeler.derive_label(self.scores(fix=0.9))
+        self.assertTrue(out['derived'])
+
+
+class GuardTests(unittest.TestCase):
+    def test_refuses_to_overwrite_sonnet_scores_file(self):
+        with self.assertRaisesRegex(ValueError, 'protected'):
+            laya_labeler.output_row({'id': 'x', 'text': 'fix it'}, {}, backend='stub',
+                                    out_name='labels-intent-scores.jsonl')
+
+    def test_output_row_shape_matches_trainer_contract(self):
+        scores = {i: (0.9 if i == 'fix' else 0.0) for i in INTENTS}
+        row = laya_labeler.output_row({'id': 'abc', 'text': 'fix it'}, scores,
+                                      backend='stub', out_name='labels-intent-laya-zs.jsonl',
+                                      routing='english')
+        self.assertEqual(row['id'], 'abc')
+        self.assertEqual(row['gold'], 'fix')
+        self.assertEqual(row['secondary'], [])
+        self.assertEqual(list(row['scores']), INTENTS)
+        self.assertEqual(row['labeler']['task'], 'intent')
+        self.assertEqual(row['labeler']['routing'], 'english')
+        self.assertEqual(row['labeler']['questions'], 'v1')
+        self.assertEqual(json.loads(json.dumps(row)), row)
+
+    def test_output_row_records_questions_version(self):
+        scores = {i: 0.1 for i in INTENTS}
+        row = laya_labeler.output_row({'id': 'abc', 'text': 'x'}, scores,
+                                      backend='stub', out_name='o.jsonl', questions_version='v2')
+        self.assertEqual(row['labeler']['questions'], 'v2')
+
+
+class EndToEndTests(unittest.TestCase):
+    def test_stub_backend_labels_a_split(self):
+        prompts = [{'id': 'p1', 'split': 'validation', 'text': 'fix the crash'},
+                   {'id': 'p2', 'split': 'train', 'text': 'commit and push'}]
+        calls = []
+
+        def stub(text):
+            calls.append(text)
+            return ({i: (0.8 if i == 'fix' else 0.05) for i in INTENTS}, 'english', 1.0)
+
+        with tempfile.TemporaryDirectory() as d:
+            data = Path(d) / 'data'
+            data.mkdir()
+            (data / 'prompts.jsonl').write_text(
+                '\n'.join(json.dumps(p) for p in prompts) + '\n', encoding='utf-8')
+            out = Path(d) / 'labels-intent-laya-zs.jsonl'
+            manifest = Path(d) / 'manifest.json'
+            summary = laya_labeler.label_split(
+                data, 'validation', out, manifest, backend_fn=stub, backend_name='stub')
+            self.assertEqual(calls, ['fix the crash'], 'only the requested split is labeled')
+            rows = [json.loads(line) for line in out.read_text(encoding='utf-8').strip().split('\n')]
+            self.assertEqual([r['id'] for r in rows], ['p1'])
+            self.assertEqual(rows[0]['gold'], 'fix')
+            self.assertEqual(summary['labeled'], 1)
+            man = json.loads(manifest.read_text(encoding='utf-8'))
+            self.assertEqual(man['backend'], 'stub')
+            self.assertEqual(man['split'], 'validation')
+
+    def test_resume_skips_done_ids(self):
+        calls = []
+
+        def stub(text):
+            calls.append(text)
+            return ({i: (0.8 if i == 'fix' else 0.05) for i in INTENTS}, 'english', 1.0)
+
+        with tempfile.TemporaryDirectory() as d:
+            data = Path(d) / 'data'
+            data.mkdir()
+            prompts = [{'id': f'p{i}', 'split': 'validation', 'text': f'text {i}'} for i in range(3)]
+            (data / 'prompts.jsonl').write_text(
+                '\n'.join(json.dumps(p) for p in prompts) + '\n', encoding='utf-8')
+            out = Path(d) / 'labels-intent-laya-zs.jsonl'
+            manifest = Path(d) / 'manifest.json'
+            laya_labeler.label_split(data, 'validation', out, manifest,
+                                     backend_fn=stub, backend_name='stub')
+            self.assertEqual(len(calls), 3)
+            laya_labeler.label_rows(
+                prompts, 'validation', 'sha', out, manifest, backend_fn=stub,
+                backend_name='stub', resume=True)
+            self.assertEqual(len(calls), 3, 'resume makes no new backend calls')
+            self.assertEqual(
+                [json.loads(line)['id'] for line in out.read_text(encoding='utf-8').splitlines()],
+                ['p0', 'p1', 'p2'], 'resume appends nothing when all ids are done')
+            man2 = json.loads(manifest.read_text(encoding='utf-8'))
+            self.assertEqual([man2['labeled'], man2['thisRun'], man2['resumed']], [3, 0, True])
+            self.assertEqual(man2['routing'], {'english': 3})
+
+
+if __name__ == '__main__':
+    unittest.main()

package/ci/system-one-laya-perintent-test.py

@@ -0,0 +1,60 @@
+"""Stdlib tests for per-intent Bernoulli evaluation (#255 Phase 3).
+
+Each intent is its own binary decision with its own threshold: no simplex,
+no single winner. Run with:
+    python3 ci/system-one-laya-perintent-test.py
+"""
+import importlib.util
+import sys
+import unittest
+from pathlib import Path
+
+sys.dont_write_bytecode = True  # never leave __pycache__ in the source tree that packaging copies
+path = Path(__file__).resolve().parents[1] / 'scripts/system-one-perintent-laya.py'
+spec = importlib.util.spec_from_file_location('laya_perintent', path)
+laya_perintent = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(laya_perintent)
+
+INTENTS = ['explain', 'discuss', 'git', 'fix', 'edit', 'feature', 'refactor',
+           'review', 'test', 'docs', 'plan', 'investigate']
+
+
+class BinarizeTests(unittest.TestCase):
+    def test_band_boundary(self):
+        self.assertEqual(laya_perintent.binarize({'fix': 0.4, 'test': 0.39}), {'fix', 'test'} - {'test'})
+        self.assertEqual(laya_perintent.binarize({'fix': 0.4}), {'fix'})
+
+    def test_custom_positive_band(self):
+        self.assertEqual(laya_perintent.binarize({'fix': 0.5}, band=0.6), set())
+
+
+class SweepTests(unittest.TestCase):
+    def test_separable_intent_gets_perfect_threshold(self):
+        scores = [0.1, 0.2, 0.8, 0.9]
+        truth = [False, False, True, True]
+        tau, p, r, f = laya_perintent.sweep_threshold(scores, truth)
+        self.assertEqual((p, r, f), (1.0, 1.0, 1.0))
+        self.assertTrue(0.2 < tau <= 0.8)
+
+    def test_all_negative_stays_silent(self):
+        tau, p, r, f = laya_perintent.sweep_threshold([0.1, 0.2, 0.3], [False, False, False])
+        self.assertEqual(r, 0.0)
+        self.assertTrue(tau > 0.3)
+
+
+class MicroTests(unittest.TestCase):
+    def test_hand_computed_micro(self):
+        # totals: tp=1, fp=2, fn=2.
+        per = {'a': (1, 1, 1), 'b': (0, 1, 1)}  # (tp, fp, fn)
+        m = laya_perintent.micro(per)
+        self.assertAlmostEqual(m['precision'], 1 / 3)
+        self.assertAlmostEqual(m['recall'], 1 / 3)
+        self.assertAlmostEqual(m['f1'], 1 / 3)
+
+    def test_empty_predictions_score_zero_not_nan(self):
+        m = laya_perintent.micro({'a': (0, 0, 2)})
+        self.assertEqual((m['precision'], m['recall'], m['f1']), (0.0, 0.0, 0.0))
+
+
+if __name__ == '__main__':
+    unittest.main()

package/ci/system-one-laya-provider-test.py

@@ -0,0 +1,115 @@
+"""Contract tests for the Laya fine-tuned provider adapter (#255 Phase 3).
+
+The 13-option evaluator vector, unclassified ramp, limits and artifact
+rules are all pinned here with a stub predictor: no model weights needed.
+Run with:
+    python3 ci/system-one-laya-provider-test.py
+"""
+import hashlib
+import importlib.util
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.dont_write_bytecode = True  # never leave __pycache__ in the source tree that packaging copies
+path = Path(__file__).resolve().parents[1] / 'harness-everything/scripts/system-one/laya_adapter.py'
+spec = importlib.util.spec_from_file_location('laya_adapter', path)
+laya_adapter = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(laya_adapter)
+
+INTENTS = ['explain', 'discuss', 'git', 'fix', 'edit', 'feature', 'refactor',
+           'review', 'test', 'docs', 'plan', 'investigate']
+OPTIONS = [{'id': i, 'text': f'{i} text'} for i in INTENTS] + [{'id': 'unclassified', 'text': 'unclear'}]
+
+
+def request(options=None, task='intent', context='fix it'):
+    return {'schemaVersion': 1, 'task': task, 'context': context,
+            'options': options if options is not None else OPTIONS,
+            'catalogHash': 'b' * 64, 'requestHash': 'a' * 64}
+
+
+def stub_predict(probs):
+    def run(state, questions):
+        assert state and set(questions) == set(INTENTS)
+        return dict(probs)
+    return run
+
+
+class ArtifactTests(unittest.TestCase):
+    def write_ckpt(self, root, weights=b'fake-weights-1', config=b'{"cfg":1}'):
+        ckpt = Path(root) / 'model.safetensors'
+        ckpt.write_bytes(weights)
+        (Path(root) / 'rl_agent_config.json').write_bytes(config)
+        return {'checkpoint': str(ckpt),
+                'weightsSha256': hashlib.sha256(weights).hexdigest(),
+                'configSha256': hashlib.sha256(config).hexdigest()}
+
+    def test_verify_ok_and_config_sibling_rule(self):
+        with tempfile.TemporaryDirectory() as d:
+            m = self.write_ckpt(d)
+            self.assertEqual(laya_adapter.verify_artifacts(m), Path(m['checkpoint']))
+
+    def test_hash_mismatch_and_bad_format_fail(self):
+        with tempfile.TemporaryDirectory() as d:
+            m = self.write_ckpt(d)
+            bad = dict(m, weightsSha256='0' * 64)
+            with self.assertRaisesRegex(ValueError, 'artifact-hash'):
+                laya_adapter.verify_artifacts(bad)
+            bad2 = dict(m, checkpoint=str(Path(d) / 'model.pt'))
+            with self.assertRaisesRegex(ValueError, 'checkpoint-format'):
+                laya_adapter.verify_artifacts(bad2)
+            bad3 = dict(m, checkpoint='relative/model.safetensors')
+            with self.assertRaisesRegex(ValueError, 'checkpoint-format'):
+                laya_adapter.verify_artifacts(bad3)
+
+
+class ScorerTests(unittest.TestCase):
+    def probs(self, **over):
+        base = {i: 0.05 for i in INTENTS}
+        base.update(over)
+        return base
+
+    def test_scores_follow_request_option_order_raw(self):
+        score, _ = laya_adapter.make_scorer(stub_predict(self.probs(fix=0.8)))
+        shuffled = [OPTIONS[5], OPTIONS[0], *[o for o in OPTIONS if o['id'] not in ('feature', 'explain')]]
+        out = score(request(options=shuffled))
+        self.assertEqual(len(out), 13)
+        by_id = {o['id']: p for o, p in zip(shuffled, out)}
+        self.assertGreater(by_id['fix'], by_id['test'])
+        self.assertTrue(all(0.0 <= p <= 1.0 for p in out))
+        self.assertGreater(sum(out), 1.0, 'independent scores sum past one: no simplex')
+
+    def test_confident_max_leaves_no_unclassified_mass(self):
+        score, _ = laya_adapter.make_scorer(stub_predict(self.probs(fix=0.9)))
+        out = score(request())
+        self.assertEqual(out[-1], 0.0, 'max above the cutoff closes the abstain ramp')
+
+    def test_flat_lows_abstain_through_unclassified(self):
+        score, _ = laya_adapter.make_scorer(stub_predict(self.probs()))
+        out = score(request())
+        self.assertGreater(out[-1], 0.5, 'nothing actionable concentrates on unclassified')
+
+    def test_non_intent_task_and_missing_intent_fail(self):
+        score, _ = laya_adapter.make_scorer(stub_predict(self.probs()))
+        with self.assertRaisesRegex(ValueError, 'task'):
+            score(request(task='tier'))
+        with self.assertRaisesRegex(ValueError, 'options'):
+            score(request(options=[{'id': 'fix', 'text': 'x'}, {'id': 'unclassified', 'text': 'y'}]))
+
+
+class LimitTests(unittest.TestCase):
+    def test_boundary_passes_and_overflow_fails(self):
+        score, config = laya_adapter.make_scorer(stub_predict({i: 0.1 for i in INTENTS}))
+        ok_ctx = 'x' * config['context_tokens']
+        laya_adapter.check_limits(request(context=ok_ctx), config)
+        with self.assertRaisesRegex(ValueError, 'input-too-long'):
+            laya_adapter.check_limits(request(context=ok_ctx + 'x'), config)
+        big_opt = [{'id': 'a', 'text': 'y' * (config['option_tokens'] + 1)}, {'id': 'b', 'text': 'z'}]
+        with self.assertRaisesRegex(ValueError, 'input-too-long'):
+            laya_adapter.check_limits(request(options=big_opt), config)
+
+
+if __name__ == '__main__':
+    unittest.main()