devlyn-cli 2.0.0 → 2.2.0

package/benchmark/auto-resolve/fixtures/F16-cli-quote-tax-rules/verifiers/no-hardcoded-pricing.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const pricingPath = path.join(process.env.BENCH_WORKDIR, 'data', 'pricing.json');
+const pricing = JSON.parse(fs.readFileSync(pricingPath, 'utf8'));
+pricing.products.A.unit_cents = 2111;
+pricing.products.A.stock = 5;
+pricing.shipping_cents = 123;
+fs.writeFileSync(pricingPath, JSON.stringify(pricing, null, 2));
+
+const orderPath = path.join(os.tmpdir(), `quote-pricing-${process.pid}.json`);
+fs.writeFileSync(orderPath, JSON.stringify({
+  state: 'OR',
+  coupon: null,
+  items: [{ sku: 'A', qty: 2 }]
+}));
+
+const cli = path.join(process.env.BENCH_WORKDIR, 'bin', 'cli.js');
+const result = spawnSync('node', [cli, 'quote', '--input', orderPath], {
+  cwd: process.env.BENCH_WORKDIR,
+  encoding: 'utf8'
+});
+
+let quote;
+try {
+  quote = JSON.parse(result.stdout);
+} catch {
+  quote = null;
+}
+
+const ok = result.status === 0
+  && result.stderr === ''
+  && quote
+  && quote.subtotal_cents === 4222
+  && quote.shipping_cents === 123
+  && quote.total_cents === 4345;
+
+console.log(JSON.stringify({
+  ok,
+  status: result.status,
+  quote
+}));
+process.exit(ok ? 0 : 1);

package/benchmark/auto-resolve/fixtures/F16-cli-quote-tax-rules/verifiers/stock-error.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const orderPath = path.join(os.tmpdir(), `quote-stock-${process.pid}.json`);
+fs.writeFileSync(orderPath, JSON.stringify({
+  state: 'NY',
+  coupon: null,
+  items: [
+    { sku: 'A', qty: 2 },
+    { sku: 'A', qty: 2 }
+  ]
+}));
+
+const cli = path.join(process.env.BENCH_WORKDIR, 'bin', 'cli.js');
+const result = spawnSync('node', [cli, 'quote', '--input', orderPath], {
+  cwd: process.env.BENCH_WORKDIR,
+  encoding: 'utf8'
+});
+
+let err;
+try {
+  err = JSON.parse(result.stderr);
+} catch {
+  err = null;
+}
+
+const ok = result.status === 2
+  && result.stdout === ''
+  && err
+  && err.error === 'invalid_stock'
+  && err.sku === 'A'
+  && err.available === 3
+  && err.requested === 4;
+
+console.log(JSON.stringify({
+  ok,
+  status: result.status,
+  stdout: result.stdout,
+  err
+}));
+process.exit(ok ? 0 : 1);

package/benchmark/auto-resolve/fixtures/F21-cli-scheduler-priority/NOTES.md

@@ -0,0 +1,27 @@
+# F21 CLI scheduler priority
+
+## Failure mode
+
+This fixture detects implementations that pass simple scheduling tests while
+missing interaction rules: global priority ordering, earliest-fit placement,
+blocked-interval exclusion, half-open time boundaries, and deterministic output
+ordering.
+
+## Pipeline phase target
+
+PLAN must preserve the ordering and interval invariants. IMPLEMENT must build a
+small scheduling engine without adding dependencies. VERIFY should catch
+counterexamples where local request order or naive overlap checks produce a
+plausible but wrong schedule.
+
+## Why existing fixtures do not cover it
+
+F16 covers checkout arithmetic. F10/F11/F12/F15 cover server behavior. None
+exercise a CLI algorithm where the correct result depends on sorting,
+interval arithmetic, and output ordering at once.
+
+## Retirement
+
+Retire or replace when both bare and solo consistently exceed the headroom
+thresholds, or if future fixtures cover the same interval-scheduling failure
+mode with better discrimination.

package/benchmark/auto-resolve/fixtures/F21-cli-scheduler-priority/expected.json

@@ -0,0 +1,62 @@
+{
+  "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/priority-blocked.js\"",
+      "exit_code": 0,
+      "stdout_contains": ["\"ok\":true"],
+      "stdout_not_contains": [],
+      "contract_refs": [
+        "Process requests globally by `priority` descending, then `submitted_at` ascending, then `id` ascending.",
+        "For each request, place it on the requested resource at the earliest start minute that is greater than or equal to the request's requested `start`, fits wholly inside one availability window, does not overlap any blocked interval, and does not overlap any already accepted request on that resource.",
+        "A request may end exactly at a window end, but any one-minute overlap with a blocked interval is rejected or moved later."
+      ]
+    },
+    {
+      "cmd": "node \"$BENCH_FIXTURE_DIR/verifiers/error-order.js\"",
+      "exit_code": 0,
+      "stdout_contains": ["\"ok\":true"],
+      "stdout_not_contains": [],
+      "contract_refs": [
+        "If the request references an unknown resource, reject with `{ \"id\": string, \"reason\": \"unknown_resource\" }`.",
+        "`rejected` is ordered in the original request input order.",
+        "Duplicate request ids are invalid input: exit `2`, one JSON error to stderr, no stdout."
+      ]
+    }
+  ],
+  "forbidden_patterns": [
+    {
+      "pattern": "catch\\s*\\([^)]*\\)\\s*\\{[^}]*return\\s+(null|undefined|''|\\{\\})",
+      "description": "silent catch returning fallback in scheduler path",
+      "files": ["bin/cli.js", "tests/cli.test.js"],
+      "severity": "disqualifier"
+    },
+    {
+      "pattern": "catch\\s*\\([^)]*\\)\\s*\\{\\s*\\}",
+      "description": "empty catch block",
+      "files": ["bin/cli.js", "tests/cli.test.js"],
+      "severity": "disqualifier"
+    },
+    {
+      "pattern": "catch\\s*(?:\\([^)]*\\))?\\s*\\{[^}]*ignore[^}]*\\}",
+      "description": "silent catch-ignore cleanup",
+      "files": ["bin/cli.js", "tests/cli.test.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"],
+  "forbidden_files": [],
+  "max_deps_added": 0,
+  "spec_output_files": ["bin/cli.js", "tests/cli.test.js"]
+}

package/benchmark/auto-resolve/fixtures/F21-cli-scheduler-priority/metadata.json

@@ -0,0 +1,10 @@
+{
+  "id": "F21-cli-scheduler-priority",
+  "category": "high-risk",
+  "difficulty": "high",
+  "timeout_seconds": 1500,
+  "required_tools": ["node"],
+  "browser": false,
+  "deps_change_expected": false,
+  "intent": "Add a bench-cli schedule command that assigns appointment requests to resource availability windows using priority, submitted order, blocked intervals, and earliest-fit placement while producing exact JSON accept/reject results."
+}

package/benchmark/auto-resolve/fixtures/F21-cli-scheduler-priority/setup.sh

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+set -e

package/benchmark/auto-resolve/fixtures/F21-cli-scheduler-priority/spec.md

@@ -0,0 +1,62 @@
+---
+id: "F21-cli-scheduler-priority"
+title: "Priority appointment scheduler"
+status: planned
+complexity: high
+depends-on: []
+---
+
+# F21 Priority appointment scheduler
+
+## Context
+
+Add a `bench-cli schedule --input <path>` command that assigns appointment
+requests to resource availability windows using priority, submitted order,
+blocked intervals, and earliest-fit placement while producing exact JSON
+accept/reject results.
+
+The scheduler is used by downstream automation, so output shape, ordering, and
+failure reasons must be deterministic.
+
+## Requirements
+
+- [ ] `bench-cli schedule --input <path>` reads JSON shaped as `{ "resources": Array<Resource>, "requests": Array<Request> }`.
+- [ ] Each resource has `{ "id": string, "windows": [{ "start": "HH:MM", "end": "HH:MM" }], "blocked": [{ "start": "HH:MM", "end": "HH:MM" }] }`. `blocked` may be empty.
+- [ ] Each request has `{ "id": string, "resource": string, "start": "HH:MM", "duration_min": number, "priority": number, "submitted_at": string }`.
+- [ ] Times are same-day 24-hour clock minutes. A range is half-open: `[start, end)`. A request ending exactly at a window end is allowed; overlapping a blocked range by one minute is not allowed.
+- [ ] Process requests globally by `priority` descending, then `submitted_at` ascending, then `id` ascending.
+- [ ] For each request, place it on the requested resource at the earliest start minute that is greater than or equal to the request's requested `start`, fits wholly inside one availability window, does not overlap any blocked interval, and does not overlap any already accepted request on that resource.
+- [ ] Do not move a request to a different resource.
+- [ ] If no placement exists, reject with `{ "id": string, "reason": "no_slot" }`.
+- [ ] If the request references an unknown resource, reject with `{ "id": string, "reason": "unknown_resource" }`.
+- [ ] Invalid top-level shape, invalid time strings, non-positive or non-integer `duration_min`, or duplicate request ids exits `2`, writes exactly one JSON error object to stderr, and writes nothing to stdout.
+- [ ] On success, write exactly one JSON object to stdout and no stderr. Keys: `scheduled`, `rejected`.
+- [ ] `scheduled` is ordered by actual scheduled start time ascending, then resource id ascending, then request id ascending. Each row has keys `id`, `resource`, `start`, `end`.
+- [ ] `rejected` is ordered in the original request input order. Each row has keys `id`, `reason`.
+- [ ] `tests/cli.test.js` is updated. Existing tests still pass AND at least two scheduler tests cover one success case and one rejection case.
+
+## Constraints
+
+- **No new npm dependencies.**
+- **No silent catches in implementation or tests.** Invalid input and file-read failures must surface as JSON errors with exit `2`; test cleanup should use explicit safe primitives such as `fs.rmSync(path, { force: true })`, not `catch { /* ignore */ }`.
+- **No mutation of the input file.**
+- **No extra stdout/stderr text** on the success path; downstream tooling parses stdout as JSON.
+- **Touch only `bin/cli.js` and `tests/cli.test.js`.**
+- **Lifecycle note.** The harness's DOCS phase flips this spec's frontmatter `status` after implementation completes — that is benchmark lifecycle bookkeeping, not a scope violation.
+
+## Out of Scope
+
+- Multiple-day scheduling.
+- Time zones.
+- Recurring appointments.
+- Persisting scheduled results.
+- Touching `server/`, `web/`, or `tests/server.test.js`.
+
+## Verification
+
+- `node --test tests/cli.test.js` exits 0.
+- A higher-priority later-submitted request can take the first slot, forcing a lower-priority earlier-submitted request to the next non-overlapping slot.
+- A request may end exactly at a window end, but any one-minute overlap with a blocked interval is rejected or moved later.
+- Unknown resources are reported in `rejected` without aborting the whole run.
+- Duplicate request ids are invalid input: exit `2`, one JSON error to stderr, no stdout.
+- `git diff --stat` shows only `bin/cli.js` and `tests/cli.test.js` touched.

package/benchmark/auto-resolve/fixtures/F21-cli-scheduler-priority/task.txt

@@ -0,0 +1,7 @@
+Add a `schedule` command to `bench-cli` so users can run `bench-cli schedule --input <path>` with a JSON file containing resources and appointment requests. It should assign requests to resource availability windows using priority, submitted order, blocked intervals, and earliest-fit placement, then print one exact JSON result with `scheduled` and `rejected` arrays.
+
+The input has resources with `id`, `windows`, and `blocked`, and requests with `id`, `resource`, `start`, `duration_min`, `priority`, and `submitted_at`. Times are same-day `HH:MM` values. Process requests by priority descending, then submitted_at ascending, then id ascending. A placement must stay on the requested resource, start no earlier than the requested start, fit inside one window, avoid blocked intervals, and avoid already accepted requests.
+
+On success, stdout must be exactly parseable JSON and stderr must be empty. `scheduled` rows must be ordered by actual scheduled start time, then resource id, then request id. `rejected` rows must stay in original request input order. Invalid input, duplicate request ids, invalid times, bad durations, or file-read failures should exit `2`, print exactly one JSON error object to stderr, and print nothing to stdout.
+
+Update `tests/cli.test.js` so existing tests still pass and add at least two scheduler tests: one success case and one rejection case. Do not use silent catches in implementation or test cleanup; use explicit safe primitives such as `fs.rmSync(path, { force: true })` instead of `catch { /* ignore */ }`. No new npm dependencies. Only touch `bin/cli.js` and `tests/cli.test.js`.

package/benchmark/auto-resolve/fixtures/F21-cli-scheduler-priority/verifiers/error-order.js

@@ -0,0 +1,55 @@
+'use strict';
+const assert = require('node:assert');
+const { execFileSync, spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const work = process.env.BENCH_WORKDIR || process.cwd();
+const cli = path.join(work, 'bin', 'cli.js');
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'f21-errors-'));
+
+const unknownInput = path.join(tmp, 'unknown.json');
+fs.writeFileSync(unknownInput, JSON.stringify({
+  resources: [
+    { id: 'r1', windows: [{ start: '10:00', end: '10:30' }], blocked: [] }
+  ],
+  requests: [
+    { id: 'unknown-first', resource: 'missing', start: '10:00', duration_min: 5, priority: 9, submitted_at: '2026-01-01T10:00:00Z' },
+    { id: 'too-long', resource: 'r1', start: '10:00', duration_min: 45, priority: 8, submitted_at: '2026-01-01T10:01:00Z' },
+    { id: 'ok', resource: 'r1', start: '10:00', duration_min: 30, priority: 7, submitted_at: '2026-01-01T10:02:00Z' }
+  ]
+}), 'utf8');
+
+const out = execFileSync('node', [cli, 'schedule', '--input', unknownInput], {
+  cwd: work,
+  encoding: 'utf8',
+  stdio: ['ignore', 'pipe', 'pipe']
+});
+const parsed = JSON.parse(out);
+assert.deepStrictEqual(parsed.scheduled, [
+  { id: 'ok', resource: 'r1', start: '10:00', end: '10:30' }
+]);
+assert.deepStrictEqual(parsed.rejected, [
+  { id: 'unknown-first', reason: 'unknown_resource' },
+  { id: 'too-long', reason: 'no_slot' }
+]);
+
+const dupInput = path.join(tmp, 'dup.json');
+fs.writeFileSync(dupInput, JSON.stringify({
+  resources: [
+    { id: 'r1', windows: [{ start: '10:00', end: '11:00' }], blocked: [] }
+  ],
+  requests: [
+    { id: 'dup', resource: 'r1', start: '10:00', duration_min: 10, priority: 1, submitted_at: '2026-01-01T10:00:00Z' },
+    { id: 'dup', resource: 'r1', start: '10:10', duration_min: 10, priority: 1, submitted_at: '2026-01-01T10:01:00Z' }
+  ]
+}), 'utf8');
+const dup = spawnSync('node', [cli, 'schedule', '--input', dupInput], {
+  cwd: work,
+  encoding: 'utf8'
+});
+assert.strictEqual(dup.status, 2);
+assert.strictEqual(dup.stdout, '');
+assert.doesNotThrow(() => JSON.parse(dup.stderr));
+console.log(JSON.stringify({ ok: true }));

package/benchmark/auto-resolve/fixtures/F21-cli-scheduler-priority/verifiers/priority-blocked.js

@@ -0,0 +1,48 @@
+'use strict';
+const assert = require('node:assert');
+const { execFileSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const work = process.env.BENCH_WORKDIR || process.cwd();
+const cli = path.join(work, 'bin', 'cli.js');
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'f21-schedule-'));
+const input = path.join(tmp, 'input.json');
+
+fs.writeFileSync(input, JSON.stringify({
+  resources: [
+    {
+      id: 'room-a',
+      windows: [{ start: '09:00', end: '10:00' }],
+      blocked: [{ start: '09:30', end: '09:40' }]
+    },
+    {
+      id: 'room-b',
+      windows: [{ start: '09:00', end: '09:45' }],
+      blocked: []
+    }
+  ],
+  requests: [
+    { id: 'low-first', resource: 'room-a', start: '09:00', duration_min: 30, priority: 1, submitted_at: '2026-01-01T09:00:00Z' },
+    { id: 'high-second', resource: 'room-a', start: '09:00', duration_min: 30, priority: 10, submitted_at: '2026-01-01T09:05:00Z' },
+    { id: 'edge-ok', resource: 'room-b', start: '09:15', duration_min: 30, priority: 5, submitted_at: '2026-01-01T09:01:00Z' },
+    { id: 'blocked-one-minute', resource: 'room-a', start: '09:29', duration_min: 2, priority: 4, submitted_at: '2026-01-01T09:02:00Z' }
+  ]
+}), 'utf8');
+
+const stdout = execFileSync('node', [cli, 'schedule', '--input', input], {
+  cwd: work,
+  encoding: 'utf8',
+  stdio: ['ignore', 'pipe', 'pipe']
+});
+const parsed = JSON.parse(stdout);
+assert.deepStrictEqual(parsed.scheduled, [
+  { id: 'high-second', resource: 'room-a', start: '09:00', end: '09:30' },
+  { id: 'edge-ok', resource: 'room-b', start: '09:15', end: '09:45' },
+  { id: 'blocked-one-minute', resource: 'room-a', start: '09:40', end: '09:42' }
+]);
+assert.deepStrictEqual(parsed.rejected, [
+  { id: 'low-first', reason: 'no_slot' }
+]);
+console.log(JSON.stringify({ ok: true }));

package/benchmark/auto-resolve/fixtures/F22-cli-ledger-close/NOTES.md

@@ -0,0 +1,27 @@
+# F22 CLI ledger close
+
+## Failure mode
+
+This fixture detects finance-style reconciliation mistakes: applying duplicate
+transactions twice, silently accepting conflicting duplicate ids, validating
+only while mutating balances, rejecting negative balances that are explicitly
+allowed, or producing nondeterministic account ordering.
+
+## Pipeline phase target
+
+PLAN must separate validation, idempotency, chronological application, and
+output formatting. IMPLEMENT must keep cents as integers and avoid fallback
+error handling. VERIFY should catch duplicate-id counterexamples and negative
+balance behavior.
+
+## Why existing fixtures do not cover it
+
+F16 covers order quote arithmetic, but not ledger idempotency or full-input
+validation before mutation. F21 covers interval scheduling. Server fixtures
+cover API behavior rather than CLI reconciliation.
+
+## Retirement
+
+Retire or replace if both bare and solo consistently score above the headroom
+thresholds, or if a future ledger fixture captures the same duplicate-id and
+validation-before-mutation risks with stronger discrimination.

package/benchmark/auto-resolve/fixtures/F22-cli-ledger-close/expected.json

@@ -0,0 +1,56 @@
+{
+  "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/idempotent-close.js\"",
+      "exit_code": 0,
+      "stdout_contains": ["\"ok\":true"],
+      "stdout_not_contains": [],
+      "contract_refs": [
+        "Exact duplicate transactions are idempotent: apply the first copy once and count later exact copies in `duplicates_ignored`.",
+        "Apply accepted unique transactions in chronological order by `occurred_at` ascending, then `id` ascending.",
+        "Negative closing balances are allowed and must be reported, not rejected."
+      ]
+    },
+    {
+      "cmd": "node \"$BENCH_FIXTURE_DIR/verifiers/conflicting-duplicate.js\"",
+      "exit_code": 0,
+      "stdout_contains": ["\"ok\":true"],
+      "stdout_not_contains": [],
+      "contract_refs": [
+        "Conflicting duplicate transaction ids are invalid input. A duplicate id is conflicting when any field other than `id` differs from the first transaction with that id.",
+        "Invalid input exits `2`, writes exactly one JSON error object to stderr, and writes nothing to stdout.",
+        "Conflicting duplicate transaction ids use the exact stderr JSON shape `{ \"error\": \"conflicting_duplicate\", \"id\": string }`."
+      ]
+    }
+  ],
+  "forbidden_patterns": [
+    {
+      "pattern": "catch\\s*\\([^)]*\\)\\s*\\{[^}]*return\\s+(null|undefined|''|\\{\\})",
+      "description": "silent catch returning fallback in ledger 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"],
+  "forbidden_files": [],
+  "max_deps_added": 0,
+  "spec_output_files": ["bin/cli.js", "tests/cli.test.js"]
+}

package/benchmark/auto-resolve/fixtures/F22-cli-ledger-close/metadata.json

@@ -0,0 +1,10 @@
+{
+  "id": "F22-cli-ledger-close",
+  "category": "high-risk",
+  "difficulty": "high",
+  "timeout_seconds": 1500,
+  "required_tools": ["node"],
+  "browser": false,
+  "deps_change_expected": false,
+  "intent": "Add a bench-cli ledger-close command that reads account opening balances and transaction events, applies chronological idempotent ledger rules, rejects conflicting duplicate transaction ids, and prints exact closing balances and audit counts."
+}

package/benchmark/auto-resolve/fixtures/F22-cli-ledger-close/setup.sh

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+set -e

package/benchmark/auto-resolve/fixtures/F22-cli-ledger-close/spec.md

@@ -0,0 +1,65 @@
+---
+id: "F22-cli-ledger-close"
+title: "Ledger close command"
+status: planned
+complexity: high
+depends-on: []
+---
+
+# F22 Ledger close command
+
+## Context
+
+Add a `bench-cli ledger-close --input <path>` command that reads account
+opening balances and transaction events, applies chronological idempotent
+ledger rules, rejects conflicting duplicate transaction ids, and prints exact
+closing balances and audit counts.
+
+The command is used in finance-style reconciliation. Determinism matters more
+than convenience: every amount is integer cents, every accepted event is applied
+once, and duplicate ids must not silently corrupt balances.
+
+## Requirements
+
+- [ ] `bench-cli ledger-close --input <path>` reads JSON shaped as `{ "accounts": Array<Account>, "transactions": Array<Transaction> }`.
+- [ ] Each account has `{ "id": string, "currency": string, "opening_cents": number }`.
+- [ ] Each transaction has `{ "id": string, "account": string, "currency": string, "kind": "debit" | "credit", "amount_cents": number, "occurred_at": string }`.
+- [ ] Validate before applying balances: account ids are unique, transaction ids are non-empty strings, account references exist, currencies match the referenced account, `amount_cents` is a positive integer, and `kind` is either `debit` or `credit`.
+- [ ] Conflicting duplicate transaction ids are invalid input. A duplicate id is conflicting when any field other than `id` differs from the first transaction with that id.
+- [ ] Exact duplicate transactions are idempotent: apply the first copy once and count later exact copies in `duplicates_ignored`.
+- [ ] Apply accepted unique transactions in chronological order by `occurred_at` ascending, then `id` ascending.
+- [ ] A `debit` subtracts `amount_cents`; a `credit` adds `amount_cents`.
+- [ ] Negative closing balances are allowed and must be reported, not rejected.
+- [ ] Invalid input exits `2`, writes exactly one JSON error object to stderr, and writes nothing to stdout.
+- [ ] Conflicting duplicate transaction ids use the exact stderr JSON shape `{ "error": "conflicting_duplicate", "id": string }`.
+- [ ] On success, write exactly one JSON object to stdout and no stderr. Keys: `accounts`, `applied_count`, `duplicates_ignored`.
+- [ ] Output `accounts` sorted by account id ascending. Each row has keys `id`, `currency`, `closing_cents`.
+- [ ] `tests/cli.test.js` is updated. Existing tests still pass AND at least two ledger tests cover one success case and one invalid-input case.
+
+## Constraints
+
+- **No new npm dependencies.**
+- **No floating-money output.** All amounts are integer cents.
+- **No silent catches.** Invalid input and file-read failures must surface as JSON errors with exit `2`.
+- **No mutation of the input file.**
+- **No extra stdout/stderr text** on the success path; downstream tooling parses stdout as JSON.
+- **Touch only `bin/cli.js` and `tests/cli.test.js`.**
+- **Lifecycle note.** The harness's DOCS phase flips this spec's frontmatter `status` after implementation completes — that is benchmark lifecycle bookkeeping, not a scope violation.
+
+## Out of Scope
+
+- Exchange rates.
+- Decimal currency parsing.
+- Persistence or database writes.
+- Account creation from transactions.
+- Touching `server/`, `web/`, or `tests/server.test.js`.
+
+## Verification
+
+- `node --test tests/cli.test.js` exits 0.
+- Exact duplicate transactions are counted in `duplicates_ignored` and applied once.
+- Conflicting duplicate transaction ids exit `2`, write one JSON error to stderr, and write no stdout.
+- Conflicting duplicate transaction ids use the exact stderr JSON shape `{ "error": "conflicting_duplicate", "id": string }`.
+- Transactions are applied in chronological order by `occurred_at` ascending, then `id` ascending.
+- Negative closing balances are allowed and appear in output.
+- `git diff --stat` shows only `bin/cli.js` and `tests/cli.test.js` touched.

package/benchmark/auto-resolve/fixtures/F22-cli-ledger-close/task.txt

@@ -0,0 +1,7 @@
+Add a `ledger-close` command to `bench-cli` so users can run `bench-cli ledger-close --input <path>` with a JSON file containing account opening balances and transaction events. It should apply chronological idempotent ledger rules, reject conflicting duplicate transaction ids, and print exact closing balances and audit counts.
+
+The input has `accounts` with `id`, `currency`, and `opening_cents`, and `transactions` with `id`, `account`, `currency`, `kind`, `amount_cents`, and `occurred_at`. Validate the full input before applying balances. Exact duplicate transactions should be applied only once and counted in `duplicates_ignored`; duplicate ids with any conflicting field should make the whole input invalid. Apply accepted unique transactions by `occurred_at` ascending, then id ascending. Debits subtract, credits add, and negative closing balances are allowed.
+
+On success, stdout must be exactly parseable JSON and stderr must be empty. The output has `accounts`, `applied_count`, and `duplicates_ignored`; accounts are sorted by id and each row has `id`, `currency`, and `closing_cents`. Invalid input or file-read failures should exit `2`, print exactly one JSON error object to stderr, and print nothing to stdout. Conflicting duplicate transaction ids must use the exact stderr JSON shape `{ "error": "conflicting_duplicate", "id": string }`.
+
+Update `tests/cli.test.js` so existing tests still pass and add at least two ledger tests: one success case and one invalid-input case. No new npm dependencies. Only touch `bin/cli.js` and `tests/cli.test.js`.

package/benchmark/auto-resolve/fixtures/F22-cli-ledger-close/verifiers/conflicting-duplicate.js

@@ -0,0 +1,34 @@
+'use strict';
+const assert = require('node:assert');
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const work = process.env.BENCH_WORKDIR || process.cwd();
+const cli = path.join(work, 'bin', 'cli.js');
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'f22-conflict-'));
+const input = path.join(tmp, 'ledger.json');
+
+fs.writeFileSync(input, JSON.stringify({
+  accounts: [
+    { id: 'cash', currency: 'USD', opening_cents: 1000 }
+  ],
+  transactions: [
+    { id: 'same-id', account: 'cash', currency: 'USD', kind: 'credit', amount_cents: 100, occurred_at: '2026-01-01T00:00:00Z' },
+    { id: 'same-id', account: 'cash', currency: 'USD', kind: 'credit', amount_cents: 101, occurred_at: '2026-01-01T00:00:00Z' }
+  ]
+}), 'utf8');
+
+const proc = spawnSync('node', [cli, 'ledger-close', '--input', input], {
+  cwd: work,
+  encoding: 'utf8'
+});
+assert.strictEqual(proc.status, 2);
+assert.strictEqual(proc.stdout, '');
+const parsed = JSON.parse(proc.stderr);
+assert.deepStrictEqual(parsed, {
+  error: 'conflicting_duplicate',
+  id: 'same-id'
+});
+console.log(JSON.stringify({ ok: true }));

package/benchmark/auto-resolve/fixtures/F22-cli-ledger-close/verifiers/idempotent-close.js

@@ -0,0 +1,41 @@
+'use strict';
+const assert = require('node:assert');
+const { execFileSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const work = process.env.BENCH_WORKDIR || process.cwd();
+const cli = path.join(work, 'bin', 'cli.js');
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'f22-ledger-'));
+const input = path.join(tmp, 'ledger.json');
+
+const tx = { id: 't-dup', account: 'cash', currency: 'USD', kind: 'debit', amount_cents: 1200, occurred_at: '2026-01-03T00:00:00Z' };
+fs.writeFileSync(input, JSON.stringify({
+  accounts: [
+    { id: 'cash', currency: 'USD', opening_cents: 1000 },
+    { id: 'receivable', currency: 'USD', opening_cents: 200 }
+  ],
+  transactions: [
+    { id: 't-late', account: 'receivable', currency: 'USD', kind: 'credit', amount_cents: 50, occurred_at: '2026-01-05T00:00:00Z' },
+    tx,
+    { ...tx },
+    { id: 't-early', account: 'cash', currency: 'USD', kind: 'credit', amount_cents: 300, occurred_at: '2026-01-01T00:00:00Z' }
+  ]
+}), 'utf8');
+
+const stdout = execFileSync('node', [cli, 'ledger-close', '--input', input], {
+  cwd: work,
+  encoding: 'utf8',
+  stdio: ['ignore', 'pipe', 'pipe']
+});
+const parsed = JSON.parse(stdout);
+assert.deepStrictEqual(parsed, {
+  accounts: [
+    { id: 'cash', currency: 'USD', closing_cents: 100 },
+    { id: 'receivable', currency: 'USD', closing_cents: 250 }
+  ],
+  applied_count: 3,
+  duplicates_ignored: 1
+});
+console.log(JSON.stringify({ ok: true }));