devlyn-cli 3.2.0 → 3.3.0

package/benchmark/auto-resolve/fixtures/retired/F37-cli-rule-lookup/NOTES.md

@@ -1,93 +0,0 @@
-# F37 Price events against the rule in effect at their own timestamp
-
-## Failure mode
-
-Detects implementations that get the point-in-time rule lookup right at
-small, hand-written scale but reach for a data structure that stops
-scaling once the number of revisions per category grows large — most
-naturally, scanning a category's revisions linearly for every event to
-find the greatest `effectiveAt <= timestamp`. That shape is
-indistinguishable from the fully correct answer on any test an agent is
-likely to hand-write, and only fails once each category carries many
-thousands of revisions (Tier-2 axis: performance/scale — see
-F36-cli-session-admission's NOTES.md for the suite-wide grep evidence
-that no prior fixture measured wall-clock at all). Compounded with small-
-scale correctness sub-traps so a fast-but-wrong shortcut and a
-correct-but-slow shortcut both lose points independently: the inclusive
-`effectiveAt <= timestamp` boundary, the same-`effectiveAt` tie-break by
-greatest `id`, and the `unknown_category` vs. `no_effective_rule`
-distinction (whether the category has zero revisions at all versus
-revisions that just don't apply yet).
-
-This is a distinct algorithmic shape from F36 (online interval admission
-with expiry) — an offline/versioned point-in-time lookup, grouped by key
-and searched by time. It replaces an earlier F37 design (multi-hop category
-merge chains + dual-file rollback + idempotent rerun) that Codex R1 rejected
-outright as too structurally similar to the already-failed
-F35-cli-apply-journal / F26 / F32 rollback-and-idempotency family — see
-Rounds below.
-
-## Fairness
-
-Every verifier assertion quotes a visible spec.md bullet via `contract_refs`
-(lint-fixtures enforced). The 200,000-event performance requirement is
-stated as a plain, numeric, visible spec bullet — no mechanism vocabulary
-("group", "sort", "binary search", "index", "efficient") appears anywhere
-in `spec.md` or `task.txt`; only the observable behavior (must finish
-within the process timeout, must not change any event's outcome) is named.
-`data/rule-revisions.json` being unsorted is stated as a plain data-shape
-fact, not a hidden trap. The scale verifier's large revision set is
-generated only inside the hidden verifier at measurement time (never
-written to the persistent seed the arm develops against) specifically to
-avoid forcing the arm to read a multi-megabyte file into its own context
-during development — the setup.sh seed stays small and realistic.
-
-## Pipeline phase(s) tested
-
-BUILD_GATE / VERIFY: an agent's own test suite is overwhelmingly likely to
-use a handful of hand-written revisions, so nothing in a normal iterative
-dev loop surfaces the scale defect; only the hidden, harness-side scale
-verifier (never visible to the arm) exercises it.
-
-## Why another fixture can't cover this
-
-No active or retired fixture in this suite measures wall-clock or
-algorithmic complexity (see F36-cli-session-admission NOTES.md for the
-grep evidence). This fixture's specific shape — a versioned/point-in-time
-lookup keyed by category and searched by effective date — is also not
-covered by any prior pricing fixture (F16, F25, F26, F32), all of which
-price a single current state rather than resolving which historical rule
-revision applies.
-
-## When to retire or replace
-
-If a headroom run shows solo_claude reliably recognizes and implements the
-required efficient per-category structure even without prompting, retire
-per the same honest-retirement contract used for F27/F28/F30/F34/F35 and
-add this id to `pair-rejected-fixtures.sh` with the observed scores.
-
-## Rounds — Codex GPT-5.5 collaboration (read-only, `codex-monitored.sh`)
-
-**Round 1** (initial F37 design: multi-hop category-merge chain resolution,
-cycle detection, dual-file write-back to `products.json` +
-`migration-log.json`, idempotent-rerun requirement): Codex verdict
-**reject-and-replace** — "It reads like F35/F26/F32 with new nouns:
-rule-source pricing, idempotency/replay, validation-before-write,
-rollback/unchanged files. The rejected registry shows solo already scored
-97-98 on these families... I would not spend another headroom run on this
-version." Codex proposed a concrete replacement direction instead of
-softening the objection: "dated category/rule snapshots where each product
-event must use the latest rule effective at or before its timestamp,
-across 200k events and 50k rule revisions. Naive scan-all-rules-per-product
-fails; correct solution groups by key and binary-searches or sweeps."
-
-**Round 2** (fully replaced design, as above, presented alongside the
-revised F36): Codex verdict **converge, no changes needed** — "F37 is
-distinct enough. It is a different access pattern: point-in-time lookup
-over versioned rules, not interval admission/capacity... I would not call
-it a freebie in the same way as 'meeting rooms'; agents still have to
-preserve input order, handle as-of boundaries, same-time tie-breaks, and
-distinguish missing-category cases." Confirmed the tie-break/boundary rules
-were unambiguous and the visible scale wording was fair (grounds
-`contract_refs` in observable behavior without leaking grouping, sorting,
-or binary search as required mechanisms).

package/benchmark/auto-resolve/fixtures/retired/F37-cli-rule-lookup/RETIRED.md

@@ -1,16 +0,0 @@
-# F37 retired
-
-Retired from the active golden suite after headroom run
-`iter-0041-headroom-f36-f37`.
-
-Reason: bare scored 75, exceeding the headroom ceiling of 60, and
-`solo_claude` scored 96, exceeding the ceiling of 80 (judge: passed all four
-required verification commands including scale, via per-category sorted rule
-index + binary search with correct tie-breaks). The solo arm's invoke exited
-nonzero (`invoke_exit: 1` at 1247s) yet its working tree still verified
-clean — recorded by the gate as `solo_claude invoke failure` but the score
-stands on the verified artifacts. Neither ceiling held; no pair-lift headroom.
-
-Future use: the as-of lookup shape (Codex R1 replacement design) was still
-within one-shot reach of both arms. Same lesson as F36: the scale axis alone
-does not discriminate a full solo pipeline.

package/benchmark/auto-resolve/fixtures/retired/F37-cli-rule-lookup/expected.json

@@ -1,65 +0,0 @@
-{
-  "verification_commands": [
-    {
-      "cmd": "node --test tests/cli.test.js",
-      "exit_code": 0,
-      "stdout_contains": [],
-      "stdout_not_contains": ["not ok "]
-    },
-    {
-      "cmd": "node \"$BENCH_FIXTURE_DIR/verifiers/correctness-small.js\"",
-      "exit_code": 0,
-      "stdout_contains": ["\"ok\":true"],
-      "stdout_not_contains": [],
-      "contract_refs": [
-        "an exact match (`effectiveAt` equal to the event's `timestamp`) counts as eligible, not just strictly earlier ones",
-        "If more than one eligible revision for that category shares the greatest `effectiveAt`, the one with the greatest `id` (plain string comparison) applies.",
-        "If the event's `categoryId` has zero revisions anywhere in `data/rule-revisions.json`, the event is rejected with reason `unknown_category`.",
-        "If the event's `categoryId` has at least one revision but none with `effectiveAt` less than or equal to the event's `timestamp`, the event is rejected with reason `no_effective_rule`."
-      ]
-    },
-    {
-      "cmd": "node \"$BENCH_FIXTURE_DIR/verifiers/validation.js\"",
-      "exit_code": 0,
-      "stdout_contains": ["\"ok\":true"],
-      "stdout_not_contains": [],
-      "contract_refs": [
-        "Validation happens before any pricing.",
-        "a duplicate event `id` uses shape `{ \"error\": \"duplicate_event_id\", \"id\": string }`"
-      ]
-    },
-    {
-      "cmd": "node \"$BENCH_FIXTURE_DIR/verifiers/scale.js\"",
-      "exit_code": 0,
-      "stdout_contains": ["\"ok\":true"],
-      "stdout_not_contains": [],
-      "contract_refs": [
-        "`bench-cli price-events` must finish processing the 200,000-event verification input (see `## Verification`) against the seeded revision set within its process timeout, without changing the priced or rejected outcome for any event compared to a smaller input processed the same way."
-      ]
-    }
-  ],
-  "forbidden_patterns": [
-    {
-      "pattern": "catch\\s*\\([^)]*\\)\\s*\\{[^}]*return\\s+(null|undefined|''|\\{\\})",
-      "description": "silent catch returning fallback in price-events path",
-      "files": ["bin/cli.js"],
-      "severity": "disqualifier"
-    },
-    {
-      "pattern": "catch\\s*\\([^)]*\\)\\s*\\{\\s*\\}",
-      "description": "empty catch block",
-      "files": ["bin/cli.js"],
-      "severity": "disqualifier"
-    },
-    {
-      "pattern": "/\\*\\s*eslint-disable",
-      "description": "eslint-disable without scoped justification",
-      "files": ["bin/cli.js"],
-      "severity": "disqualifier"
-    }
-  ],
-  "required_files": ["bin/cli.js", "tests/cli.test.js", "data/rule-revisions.json"],
-  "forbidden_files": [],
-  "max_deps_added": 0,
-  "spec_output_files": ["bin/cli.js", "tests/cli.test.js"]
-}

package/benchmark/auto-resolve/fixtures/retired/F37-cli-rule-lookup/metadata.json

@@ -1,10 +0,0 @@
-{
-  "id": "F37-cli-rule-lookup",
-  "category": "high-risk",
-  "difficulty": "high",
-  "timeout_seconds": 1500,
-  "required_tools": ["node"],
-  "browser": false,
-  "deps_change_expected": false,
-  "intent": "Add a bench-cli price-events command that prices a batch of purchase events using the pricing rule revision that was in effect for that event's category at the event's own timestamp, drawn from a seeded, unsorted rule-revisions file, and that must finish processing a 200,000-event verification input against the seeded revision set within its process timeout."
-}

package/benchmark/auto-resolve/fixtures/retired/F37-cli-rule-lookup/setup.sh

@@ -1,18 +0,0 @@
-#!/usr/bin/env bash
-# F37 setup — seed a small, deliberately unsorted rule-revisions file.
-set -e
-
-mkdir -p data
-
-cat > data/rule-revisions.json <<'JSON'
-[
-  { "id": "rev-202", "categoryId": "cat-2", "effectiveAt": 2500, "discountPct": 25, "minPrice": 45 },
-  { "id": "rev-101", "categoryId": "cat-1", "effectiveAt": 1000, "discountPct": 10, "minPrice": 50 },
-  { "id": "rev-301", "categoryId": "cat-3", "effectiveAt": 500, "discountPct": 0, "minPrice": 100 },
-  { "id": "rev-103", "categoryId": "cat-1", "effectiveAt": 3000, "discountPct": 15, "minPrice": 55 },
-  { "id": "rev-201", "categoryId": "cat-2", "effectiveAt": 1500, "discountPct": 5, "minPrice": 40 },
-  { "id": "rev-102", "categoryId": "cat-1", "effectiveAt": 2000, "discountPct": 20, "minPrice": 60 }
-]
-JSON
-
-exit 0

package/benchmark/auto-resolve/fixtures/retired/F37-cli-rule-lookup/spec.md

@@ -1,66 +0,0 @@
----
-id: "F37-cli-rule-lookup"
-title: "Price events against the rule in effect at their own timestamp"
-status: planned
-complexity: high
-depends-on: []
----
-
-# F37 Price events against the rule in effect at their own timestamp
-
-## Context
-
-`bench-cli` gets a `price-events` command that prices a batch of purchase
-events using the pricing rule revision that was actually in effect for that
-event's category at the event's own timestamp — not the newest rule, and
-not the same rule for every event in a category. Rule revisions arrive from
-a seeded, unsorted file with many revisions per category. Downstream
-billing tools parse stdout as JSON, and they replay very large event
-batches, so the lookup must stay exact and the command must finish in
-reasonable time.
-
-## Requirements
-
-- [ ] `bench-cli price-events --input <path>` reads JSON shaped as `{ "events": [{ "id": string, "categoryId": string, "timestamp": number, "basePrice": number }] }`.
-- [ ] Pricing rule revisions come from `data/rule-revisions.json`, shaped as an array of `{ "id": string, "categoryId": string, "effectiveAt": number, "discountPct": number, "minPrice": number }`. Revisions in that file are not sorted by category or by time. The command must not modify `data/rule-revisions.json`.
-- [ ] For each event, consider every revision whose `categoryId` equals the event's `categoryId` and whose `effectiveAt` is less than or equal to the event's `timestamp`. Among those, the one with the greatest `effectiveAt` applies — an exact match (`effectiveAt` equal to the event's `timestamp`) counts as eligible, not just strictly earlier ones.
-- [ ] If more than one eligible revision for that category shares the greatest `effectiveAt`, the one with the greatest `id` (plain string comparison) applies.
-- [ ] If the event's `categoryId` has zero revisions anywhere in `data/rule-revisions.json`, the event is rejected with reason `unknown_category`.
-- [ ] If the event's `categoryId` has at least one revision but none with `effectiveAt` less than or equal to the event's `timestamp`, the event is rejected with reason `no_effective_rule`.
-- [ ] An accepted event's price is `Math.max(rule.minPrice, Math.round(event.basePrice * (100 - rule.discountPct) / 100))`.
-- [ ] `bench-cli price-events` must finish processing the 200,000-event verification input (see `## Verification`) against the seeded revision set within its process timeout, without changing the priced or rejected outcome for any event compared to a smaller input processed the same way.
-- [ ] Validation happens before any pricing. `events` must be an array; every event needs a non-empty string `id` and `categoryId`, an integer `timestamp`, and a non-negative integer `basePrice`; every event `id` must be unique. Invalid input exits `2` and writes exactly one JSON error object to stderr, printing nothing to stdout: a malformed field uses shape `{ "error": "invalid_input", "reason": string }`; a duplicate event `id` uses shape `{ "error": "duplicate_event_id", "id": string }`.
-- [ ] On success, write exactly one JSON object to stdout and no stderr. Keys: `priced` (array of `{ "id": string, "ruleId": string, "price": number }` rows) and `rejected` (array of `{ "id": string, "reason": string }` rows). Each event appears in exactly one of the two arrays; within each array, rows keep the original input event order.
-- [ ] `tests/cli.test.js` is updated. Existing tests still pass AND at least two new tests cover `price-events`: one where two revisions for the same category apply to different events depending on each event's own timestamp, and one rejection.
-
-## Constraints
-
-- **No new npm dependencies.**
-- **No silent catches.** If parsing or file reading fails, emit a visible JSON error to stderr and exit `2`.
-- **No extra stdout/stderr text** on the success path; downstream tooling parses stdout as JSON.
-- `server` and `web` directories are unrelated to this command; do not add files there.
-
-## Out of Scope
-
-- Persisting priced results between command invocations.
-- Adding, editing, or reordering rule revisions in `data/rule-revisions.json`.
-- Changing server routes, web UI, or any file outside `bin/cli.js` and `tests/cli.test.js`.
-- Touching `server/`, `web/`, or `tests/server.test.js`.
-
-## Verification
-
-- `node --test tests/cli.test.js` exits 0.
-- Two revisions for the same category with different `effectiveAt` values each apply to the correct event depending on that event's own `timestamp`, including the exact-match boundary — `node "$BENCH_FIXTURE_DIR/verifiers/correctness-small.js"` exposes misses on this, the same-`effectiveAt` tie-break, and the `unknown_category`-versus-`no_effective_rule` distinction above.
-- Malformed input, non-unique event ids, and non-integer/negative fields are all rejected before any pricing decision, per the exact error shapes above — `node "$BENCH_FIXTURE_DIR/verifiers/validation.js"` exposes misses.
-- A 200,000-event input priced against a large seeded revision set completes within the process timeout and produces the exact priced/rejected outcome for every event — `node "$BENCH_FIXTURE_DIR/verifiers/scale.js"` exposes misses on both timing and correctness.
-- `git diff --stat` shows only `bin/cli.js` and `tests/cli.test.js` touched.
-
-## Solo-headroom hypothesis
-
-A capable solo_claude baseline is expected to reach for a lookup approach
-that is correct on typical hand-written examples but does not stay fast as
-the number of revisions per category grows — for example, scanning a
-category's revisions linearly for every event instead of using a structure
-that stays fast as that list grows — which is correct at small scale but
-does not finish the 200,000-event input in time; observable command
-`node "$BENCH_FIXTURE_DIR/verifiers/scale.js"` exposes the miss.

package/benchmark/auto-resolve/fixtures/retired/F37-cli-rule-lookup/task.txt

@@ -1,9 +0,0 @@
-Add a `price-events` command to `bench-cli` so users can run `bench-cli price-events --input <path>` with a JSON file shaped as `{ "events": [{ "id": string, "categoryId": string, "timestamp": number, "basePrice": number }] }`. Pricing rules come from the seeded `data/rule-revisions.json` (an array of `{ "id", "categoryId", "effectiveAt", "discountPct", "minPrice" }` rows, not sorted by category or by time, and not to be modified by the command) — there can be many revisions for the same category over time, and each event must be priced using whichever revision was actually in effect for its category at its own timestamp, not just the newest one.
-
-For each event, find the revision for its category with the greatest `effectiveAt` that is less than or equal to the event's own `timestamp` (an exact match counts). If more than one revision ties on that `effectiveAt`, use the one with the greater `id`. If the category has no revisions at all, reject the event with reason `unknown_category`; if it has revisions but none apply yet at that timestamp, reject with reason `no_effective_rule`. An accepted event's price is the base price discounted by the rule's percentage and rounded, but never below the rule's minimum price.
-
-This command needs to stay fast: downstream billing tooling replays event batches well over a hundred thousand rows against revision sets with many entries per category, and it must still finish within a reasonable process timeout without changing any event's priced or rejected outcome versus a small input processed the same way.
-
-Validate the whole input before pricing anything: `events` must be an array, every event needs a non-empty string `id`/`categoryId`, an integer `timestamp`, and a non-negative integer `basePrice`, and every `id` must be unique. On any violation, exit 2, print exactly one JSON error object to stderr, and print nothing to stdout — use a distinct error for duplicate ids versus other malformed input. On success, print exactly one JSON object with `priced` (id/ruleId/price rows) and `rejected` (id/reason rows), each array keeping the original event order — nothing on stderr.
-
-Update `tests/cli.test.js`: existing tests still pass, plus at least two new tests for `price-events` (one exercising two revisions applying to different events by timestamp, one rejection). No new npm dependencies. Only touch `bin/cli.js` and `tests/cli.test.js`.

package/benchmark/auto-resolve/fixtures/retired/F37-cli-rule-lookup/verifiers/correctness-small.js

@@ -1,84 +0,0 @@
-'use strict';
-// F37 hidden verifier — one bundled scenario exercising: (1) different
-// events in the same category resolving to different revisions by their
-// own timestamp, (2) the inclusive effectiveAt<=timestamp boundary (an
-// exact match is eligible), (3) the same-effectiveAt tie-break (greatest
-// id wins), (4) unknown_category vs no_effective_rule are distinct and
-// correctly assigned. Resets the seed so this verifier is order-independent
-// from other verifier commands (F35 pattern).
-//
-// Structural equality: object key order is not part of the visible
-// contract; array order is.
-function deepEqual(a, b) {
-  if (a === b) return true;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
-  }
-  if (a && b && typeof a === 'object' && typeof b === 'object' && !Array.isArray(a) && !Array.isArray(b)) {
-    const ka = Object.keys(a).sort();
-    const kb = Object.keys(b).sort();
-    return deepEqual(ka, kb) && ka.every((k) => deepEqual(a[k], b[k]));
-  }
-  return false;
-}
-
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { spawnSync } = require('node:child_process');
-
-const work = process.env.BENCH_WORKDIR;
-const revPath = path.join(work, 'data', 'rule-revisions.json');
-const cli = path.join(work, 'bin', 'cli.js');
-
-const revisions = [
-  { id: 'rev-a2', categoryId: 'cat-A', effectiveAt: 200, discountPct: 20, minPrice: 10 },
-  { id: 'rev-a9', categoryId: 'cat-A', effectiveAt: 300, discountPct: 90, minPrice: 10 },
-  { id: 'rev-a1', categoryId: 'cat-A', effectiveAt: 100, discountPct: 10, minPrice: 10 },
-  { id: 'rev-b1', categoryId: 'cat-B', effectiveAt: 50, discountPct: 0, minPrice: 5 },
-  { id: 'rev-a3', categoryId: 'cat-A', effectiveAt: 300, discountPct: 30, minPrice: 10 },
-];
-fs.writeFileSync(revPath, JSON.stringify(revisions, null, 2) + '\n');
-
-const inputPath = path.join(os.tmpdir(), `price-events-small-${process.pid}.json`);
-fs.writeFileSync(inputPath, JSON.stringify({
-  events: [
-    { id: 'e1', categoryId: 'cat-A', timestamp: 150, basePrice: 100 },
-    { id: 'e2', categoryId: 'cat-A', timestamp: 250, basePrice: 100 },
-    { id: 'e3', categoryId: 'cat-A', timestamp: 200, basePrice: 50 },
-    { id: 'e4', categoryId: 'cat-A', timestamp: 350, basePrice: 100 },
-    { id: 'e5', categoryId: 'cat-B', timestamp: 10, basePrice: 100 },
-    { id: 'e6', categoryId: 'cat-C', timestamp: 1000, basePrice: 100 },
-  ],
-}));
-
-const result = spawnSync('node', [cli, 'price-events', '--input', inputPath], {
-  cwd: work,
-  encoding: 'utf8',
-  maxBuffer: 16 * 1024 * 1024,
-});
-
-let out = null;
-try {
-  out = JSON.parse(result.stdout);
-} catch {
-  out = null;
-}
-
-const expected = {
-  priced: [
-    { id: 'e1', ruleId: 'rev-a1', price: 90 },
-    { id: 'e2', ruleId: 'rev-a2', price: 80 },
-    { id: 'e3', ruleId: 'rev-a2', price: 40 },
-    { id: 'e4', ruleId: 'rev-a9', price: 10 },
-  ],
-  rejected: [
-    { id: 'e5', reason: 'no_effective_rule' },
-    { id: 'e6', reason: 'unknown_category' },
-  ],
-};
-
-const ok = result.status === 0 && result.stderr === '' && deepEqual(out, expected);
-
-console.log(JSON.stringify({ ok, status: result.status, stderr: result.stderr, out, expected }));
-process.exit(ok ? 0 : 1);

package/benchmark/auto-resolve/fixtures/retired/F37-cli-rule-lookup/verifiers/scale.js

@@ -1,184 +0,0 @@
-'use strict';
-// F37 hidden verifier — the performance discriminator. 60,000 rule
-// revisions spread over 4 categories (15,000 revisions/category) and
-// 200,000 events. Every event resolves successfully (no rejections),
-// which keeps the expected output small and the correctness check a
-// direct array comparison; the discriminator is entirely in how the
-// lookup is done, not in exercising the reject paths (those are covered
-// by correctness-small.js).
-//
-// A per-event linear scan of a category's revisions costs on the order of
-// events * revisions-per-category =~ 200,000 * 15,000 = 3e9 comparisons —
-// tens of seconds or more in Node. Grouping by category (near-free) and
-// then binary-searching a sorted per-category list is a few million
-// log-steps — trivially fast. The reference below independently
-// implements the efficient shape (not shared code with the CLI) so it can
-// also serve as ground truth without becoming a second bottleneck. The
-// 15-second hard kill sits far above the efficient solution's expected
-// running time and correspondingly far below any realistic
-// linear-scan running time at these parameters.
-//
-// Revisions are written to `data/rule-revisions.json` in a shuffled
-// (non-category-grouped, non-time-sorted) order via a deterministic
-// permutation, matching the visible "not sorted by category or by time"
-// spec fact and closing a "trust file order" shortcut.
-
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { spawnSync } = require('node:child_process');
-
-const work = process.env.BENCH_WORKDIR;
-const revPath = path.join(work, 'data', 'rule-revisions.json');
-const cli = path.join(work, 'bin', 'cli.js');
-
-const CATS = 4;
-const REVS_PER_CAT = 15000;
-const TOTAL_REVS = CATS * REVS_PER_CAT;
-const EVENTS = 200000;
-const REV_PERMUTE_MULTIPLIER = 39989; // coprime with 60000 (2^5 * 3 * 5^4)
-
-const revisionsInOrder = new Array(TOTAL_REVS);
-let k = 0;
-for (let c = 0; c < CATS; c++) {
-  for (let j = 0; j < REVS_PER_CAT; j++) {
-    revisionsInOrder[k] = {
-      id: `rev-${c}-${j}`,
-      categoryId: `cat-${c}`,
-      effectiveAt: j * 10,
-      discountPct: (j * 7) % 50,
-      minPrice: 100 + ((j * 13) % 900),
-    };
-    k += 1;
-  }
-}
-
-const shuffled = new Array(TOTAL_REVS);
-for (let i = 0; i < TOTAL_REVS; i++) {
-  const pos = (i * REV_PERMUTE_MULTIPLIER) % TOTAL_REVS;
-  shuffled[pos] = revisionsInOrder[i];
-}
-fs.writeFileSync(revPath, JSON.stringify(shuffled));
-
-const events = new Array(EVENTS);
-for (let i = 0; i < EVENTS; i++) {
-  const c = i % CATS;
-  const base = (i * 131) % REVS_PER_CAT;
-  events[i] = {
-    id: `ev-${i}`,
-    categoryId: `cat-${c}`,
-    timestamp: base * 10 + 5,
-    basePrice: 1000 + (i % 500),
-  };
-}
-
-const inputPath = path.join(os.tmpdir(), `price-events-scale-${process.pid}.json`);
-fs.writeFileSync(inputPath, JSON.stringify({ events }));
-
-// Independent reference: group by category, sort each group by
-// (effectiveAt asc, id asc), binary-search the rightmost entry with
-// effectiveAt <= timestamp.
-const groups = new Map();
-for (const rev of revisionsInOrder) {
-  if (!groups.has(rev.categoryId)) groups.set(rev.categoryId, []);
-  groups.get(rev.categoryId).push(rev);
-}
-for (const list of groups.values()) {
-  list.sort((a, b) => a.effectiveAt - b.effectiveAt || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-}
-
-function findRuleIndex(sorted, timestamp) {
-  let lo = 0;
-  let hi = sorted.length - 1;
-  let ans = -1;
-  while (lo <= hi) {
-    const mid = (lo + hi) >> 1;
-    if (sorted[mid].effectiveAt <= timestamp) {
-      ans = mid;
-      lo = mid + 1;
-    } else {
-      hi = mid - 1;
-    }
-  }
-  return ans;
-}
-
-const expectedPriced = new Array(EVENTS);
-let expectedRejectedCount = 0;
-for (let i = 0; i < EVENTS; i++) {
-  const ev = events[i];
-  const group = groups.get(ev.categoryId);
-  if (!group) {
-    expectedRejectedCount += 1;
-    expectedPriced[i] = null;
-    continue;
-  }
-  const idx = findRuleIndex(group, ev.timestamp);
-  if (idx < 0) {
-    expectedRejectedCount += 1;
-    expectedPriced[i] = null;
-    continue;
-  }
-  const rule = group[idx];
-  const price = Math.max(rule.minPrice, Math.round((ev.basePrice * (100 - rule.discountPct)) / 100));
-  expectedPriced[i] = { id: ev.id, ruleId: rule.id, price };
-}
-
-const start = Date.now();
-const result = spawnSync('node', [cli, 'price-events', '--input', inputPath], {
-  cwd: work,
-  encoding: 'utf8',
-  timeout: 15000,
-  killSignal: 'SIGKILL',
-  maxBuffer: 64 * 1024 * 1024,
-});
-const elapsedMs = Date.now() - start;
-
-const timedOut = result.status === null && result.signal !== null;
-
-let out = null;
-if (!timedOut) {
-  try {
-    out = JSON.parse(result.stdout);
-  } catch {
-    out = null;
-  }
-}
-
-let correct = false;
-let mismatch = null;
-if (out && Array.isArray(out.priced) && Array.isArray(out.rejected)) {
-  correct =
-    out.rejected.length === expectedRejectedCount &&
-    out.priced.length === EVENTS - expectedRejectedCount &&
-    out.priced.every((row, i) => {
-      const expected = expectedPriced[i];
-      return expected && row.id === expected.id && row.ruleId === expected.ruleId && row.price === expected.price;
-    });
-  if (!correct) {
-    const firstMismatchIndex = out.priced.findIndex((row, i) => {
-      const expected = expectedPriced[i];
-      return !expected || row.id !== expected.id || row.ruleId !== expected.ruleId || row.price !== expected.price;
-    });
-    mismatch = {
-      pricedLength: out.priced.length,
-      rejectedLength: out.rejected.length,
-      expectedRejectedCount,
-      firstMismatchIndex,
-    };
-  }
-}
-
-const ok = !timedOut && result.status === 0 && result.stderr === '' && correct;
-
-console.log(JSON.stringify({
-  ok,
-  timedOut,
-  elapsedMs,
-  status: result.status,
-  signal: result.signal,
-  stderrLength: result.stderr ? result.stderr.length : 0,
-  correct,
-  mismatch,
-}));
-process.exit(ok ? 0 : 1);

package/benchmark/auto-resolve/fixtures/retired/F37-cli-rule-lookup/verifiers/validation.js

@@ -1,74 +0,0 @@
-'use strict';
-// F37 hidden verifier — validation happens before any pricing decision:
-// malformed event fields use `invalid_input`, duplicate event ids use the
-// distinct `duplicate_event_id` shape, and nothing is priced or printed to
-// stdout in either case. Resets the seed so this verifier is
-// order-independent from other verifier commands.
-
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { spawnSync } = require('node:child_process');
-
-const work = process.env.BENCH_WORKDIR;
-const revPath = path.join(work, 'data', 'rule-revisions.json');
-const cli = path.join(work, 'bin', 'cli.js');
-
-const revisions = [
-  { id: 'rev-a1', categoryId: 'cat-A', effectiveAt: 100, discountPct: 10, minPrice: 10 },
-];
-
-let callCount = 0;
-function runPriceEvents(payload) {
-  fs.writeFileSync(revPath, JSON.stringify(revisions, null, 2) + '\n');
-  callCount += 1;
-  const inputPath = path.join(os.tmpdir(), `price-events-validate-${process.pid}-${callCount}.json`);
-  fs.writeFileSync(inputPath, JSON.stringify(payload));
-  const result = spawnSync('node', [cli, 'price-events', '--input', inputPath], {
-    cwd: work,
-    encoding: 'utf8',
-    maxBuffer: 16 * 1024 * 1024,
-  });
-  let err = null;
-  try {
-    err = JSON.parse(result.stderr);
-  } catch {
-    err = null;
-  }
-  return { result, err };
-}
-
-const failures = [];
-
-function expectInvalidInput(label, payload) {
-  const { result, err } = runPriceEvents(payload);
-  const ok = result.status === 2 && result.stdout === '' && err !== null && err.error === 'invalid_input' && typeof err.reason === 'string';
-  if (!ok) {
-    failures.push({ test: label, status: result.status, stdout: result.stdout, stderr: result.stderr, err });
-  }
-}
-
-expectInvalidInput('events-not-array', { events: 'nope' });
-expectInvalidInput('missing-id', { events: [{ categoryId: 'cat-A', timestamp: 100, basePrice: 10 }] });
-expectInvalidInput('non-integer-timestamp', { events: [{ id: 'e1', categoryId: 'cat-A', timestamp: 1.5, basePrice: 10 }] });
-expectInvalidInput('negative-base-price', { events: [{ id: 'e1', categoryId: 'cat-A', timestamp: 100, basePrice: -1 }] });
-expectInvalidInput('non-string-category', { events: [{ id: 'e1', categoryId: 42, timestamp: 100, basePrice: 10 }] });
-
-// Duplicate event id — distinct error shape.
-{
-  const payload = {
-    events: [
-      { id: 'dup', categoryId: 'cat-A', timestamp: 100, basePrice: 10 },
-      { id: 'dup', categoryId: 'cat-A', timestamp: 200, basePrice: 20 },
-    ],
-  };
-  const { result, err } = runPriceEvents(payload);
-  const ok = result.status === 2 && result.stdout === '' && err !== null && err.error === 'duplicate_event_id' && err.id === 'dup';
-  if (!ok) {
-    failures.push({ test: 'duplicate-event-id', status: result.status, stdout: result.stdout, stderr: result.stderr, err });
-  }
-}
-
-const ok = failures.length === 0;
-console.log(JSON.stringify({ ok, failures }));
-process.exit(ok ? 0 : 1);