spec-controller 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 3F Consulting Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cli-balance/cli.d.ts

@@ -0,0 +1,87 @@
+/**
+ * The balance CLI — thin wiring over the reconciler seams. The orchestration half of
+ * the old cli.ts: arg parsing, the render-from-JSON mode, and the reconcile →
+ * census → provenance → plan → write sequence. The impure file reads it calls
+ * (runReconcile + the read* siblings) live in ingest/ingestQualityChecks.ts; the output
+ * plan/write in ./emit; the git-derived run inputs in run-management/resolveRunInputs.ts.
+ *
+ * Usage:
+ *   pnpm reconcile [--features <dir>] [--vitest <report.json>]
+ *                  [--cucumber <report.json>] [--ci <ci.yml>]
+ *                  [--format <fmt>[:<path>]]
+ */
+import type { CliRegistry } from "../cli-registry.js";
+/**
+ * The legacy-`--json` guard at the CLI edge (@SCN-FMT-006). The earlier
+ * `--json <path>` flag is removed; supplying it must fail fast with a migration hint to
+ * `--format json:<path>`, so the removed flag never silently no-ops and drops output. PURE
+ * and `@unit`-testable: the removed flag is NOT a `--format` spec (planOutput never sees
+ * it), so the guard reads the parsed args directly and returns the typed migration-hint
+ * error message when `--json` is present — routed to stderr + a non-zero exit by main(),
+ * the same handling planOutput's typed error gets (the shared error surface) — else null.
+ */
+export declare function checkLegacyJson(args: Record<string, string>): string | null;
+/**
+ * Source the provenance "Target repo:" name for a run (@SCN-RPT-001 Update —
+ * Fork A). The operator's `--target` is recorded VERBATIM — no resolution — defaulting to
+ * `"unknown-target"` when omitted (parallel to `sourceSha`'s `"unknown"`; the facts
+ * artefact is self-describing, so the line always renders). PURE and `@unit`-testable at
+ * the CLI edge, like `checkLegacyJson`. It never inspects `--features`: the prior
+ * `basename(dirname(--features))` resolution (the deleted `resolveTarget`) and its
+ * degenerate `.` are impossible now — the target is only ever the given value or the
+ * explicit default.
+ */
+export declare function sourceTarget(args: Record<string, string>): string;
+export declare function checkInputsExist(args: Record<string, string>, exists: (path: string) => boolean): string | null;
+/**
+ * Guard the READABILITY of the supplied JSON inputs at the CLI edge (@SCN-CLI-014).
+ * `checkInputsExist` already guards their PRESENCE — but a path that is present yet
+ * UNPARSEABLE fell straight through it: the reader threw mid-parse, nothing caught it, and
+ * the process hit Node's default exit 1 — the code reserved for a genuine OUT-OF-BALANCE
+ * verdict. A crashed invocation was therefore indistinguishable, by exit code, from an
+ * honest disagreement (3F-1742). An input the tool cannot read is a USAGE fault: exit 2,
+ * sibling to a missing path (@SCN-CLI-002) and an unrecognised flag (@SCN-CLI-009).
+ *
+ * PURE and `@unit`-testable like its sibling guards: reads the parsed args + an injected
+ * `read` fn (no fs), returns the FIRST supplied-but-unparseable `(flag, path, failure)` as
+ * a typed error naming all three — routed to stderr + exit 2 by `runBalance` — else null.
+ * An omitted flag is not an error, and an unreadable file (a race after the existence
+ * check) reports as the same input fault rather than escaping as a crash.
+ */
+export declare function checkInputsParse(args: Record<string, string>, read: (path: string) => string): string | null;
+/**
+ * Guard the readability of `--render-from-json` at the CLI edge (@SCN-CLI-015). The
+ * render-from-saved-JSON branch RETURNS before the input guards ever run, so it honoured
+ * NEITHER: a missing path crashed to `ENOENT` and a malformed file to `SyntaxError`, both
+ * landing on Node's default exit 1 — the out-of-balance code (3F-1764).
+ *
+ * The missing-path case was a live violation of @SCN-CLI-002's own shipped principle: a
+ * supplied input path that does not exist is a hard error at exit 2, enforced for the five
+ * evidence flags and not for this one. The CLI shipped a guard that half-honoured its Rule.
+ *
+ * MISSING and UNPARSEABLE are two Examples of one boundary rule — an input the tool cannot
+ * read is a usage error, never a verdict — so one guard covers both. PURE and
+ * `@unit`-testable like its siblings: the parsed args + an injected `read` (no fs), which
+ * throws for an absent/unreadable path exactly as `readFileSync` does. An OMITTED flag is
+ * not an error (the ordinary reconcile path).
+ */
+export declare function checkRenderFromJson(args: Record<string, string>, read: (path: string) => string): string | null;
+/**
+ * The registry-bounded flag check at the CLI edge (@SCN-CLI-009). `balance` accepts ONLY
+ * the flags its per-command registry scope LISTS (by `name` or `alias`); an unregistered
+ * flag — a typo like `--strcit`, a stray `--bogus` — is a usage error, NOT silently
+ * swallowed the way the old permissive `parseArgs` did. This is the structural teeth behind
+ * "accepted = registry = help": a flag can't affect behaviour without a registry entry (and
+ * so, by CLI-008's guard, without appearing in help).
+ *
+ * PURE and `@unit`-testable like `checkLegacyJson` / `checkInputsExist`: reads the parsed
+ * args (keys are the `--`-stripped flag names) + the registry, returns the FIRST unregistered
+ * flag as a typed usage error naming it WITH its dashes — routed to stderr + exit 2 by
+ * `runBalance` (per 3F-1414's `0` balanced / `1` out-of-balance / `2` usage taxonomy),
+ * never exit 1, never a silent reconcile — else null. The global `--store`/`--run-id`
+ * modifiers never reach here: the top-level dispatcher (`parseHostInvocation`) consumes them
+ * BEFORE `balance` is dispatched, so the bounded parser sees only the command's own args.
+ */
+export declare function checkUnknownFlags(args: Record<string, string>, registry: CliRegistry): string | null;
+export declare function runBalance(argv: string[]): void;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli-balance/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli-balance/cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAsBH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AA0CtD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,GAAG,IAAI,CAS3E;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAEjE;AAqCD,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GAChC,MAAM,GAAG,IAAI,CAYf;AAUD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAC7B,MAAM,GAAG,IAAI,CAef;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAC7B,MAAM,GAAG,IAAI,CAcf;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,CAmBpG;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CA8P/C"}

package/dist/cli-balance/cli.js

@@ -0,0 +1,486 @@
+/**
+ * The balance CLI — thin wiring over the reconciler seams. The orchestration half of
+ * the old cli.ts: arg parsing, the render-from-JSON mode, and the reconcile →
+ * census → provenance → plan → write sequence. The impure file reads it calls
+ * (runReconcile + the read* siblings) live in ingest/ingestQualityChecks.ts; the output
+ * plan/write in ./emit; the git-derived run inputs in run-management/resolveRunInputs.ts.
+ *
+ * Usage:
+ *   pnpm reconcile [--features <dir>] [--vitest <report.json>]
+ *                  [--cucumber <report.json>] [--ci <ci.yml>]
+ *                  [--format <fmt>[:<path>]]
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { runReconcile, readEvidenceObligations, readFeatureNames, featureCorpusParseErrors, featureCorpusDuplicateScnIds, } from "../ingest/ingestQualityChecks.js";
+import { planOutput } from "./emit/format.js";
+import { writeOutputs } from "./emit/writer.js";
+import { renderReportFromJson, isBalanced, hasPendingItems, hasBrokenEvidence, } from "@3f-consulting/spec-controller-core";
+import { resolveSourceSha, resolveTargetRoot, resolveToolIdentity } from "../run-management/resolveRunInputs.js";
+import { cliRegistry, renderBalanceHelp } from "../cli-registry.js";
+/** Parse `--flag value` pairs from argv into a record. */
+function parseArgs(argv) {
+    const args = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a !== undefined && a.startsWith("--")) {
+            const key = a.slice(2);
+            const value = argv[i + 1];
+            if (value !== undefined && !value.startsWith("--")) {
+                args[key] = value;
+                i++;
+            }
+            else {
+                args[key] = "true";
+            }
+        }
+    }
+    return args;
+}
+/**
+ * Collect the `--format <spec>` values from argv in order (the flag is REPEATABLE, unlike
+ * the single-valued flags `parseArgs` records) — the raw specs `planOutput` parses. Empty
+ * when no `--format` was given, which `planOutput` reads as the md→stdout default
+ * (@SCN-FMT-001). Later sub-issues (FMT-004) route several specs in one invocation.
+ */
+function collectFormatSpecs(argv) {
+    const specs = [];
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === "--format") {
+            const value = argv[i + 1];
+            if (value !== undefined && !value.startsWith("--")) {
+                specs.push(value);
+                i++;
+            }
+        }
+    }
+    return specs;
+}
+/**
+ * The legacy-`--json` guard at the CLI edge (@SCN-FMT-006). The earlier
+ * `--json <path>` flag is removed; supplying it must fail fast with a migration hint to
+ * `--format json:<path>`, so the removed flag never silently no-ops and drops output. PURE
+ * and `@unit`-testable: the removed flag is NOT a `--format` spec (planOutput never sees
+ * it), so the guard reads the parsed args directly and returns the typed migration-hint
+ * error message when `--json` is present — routed to stderr + a non-zero exit by main(),
+ * the same handling planOutput's typed error gets (the shared error surface) — else null.
+ */
+export function checkLegacyJson(args) {
+    if (args["json"] !== undefined) {
+        return ("The --json <path> flag has been removed. " +
+            "Use --format json:<path> to write the JSON report to a file " +
+            "(e.g. --format json:spec-reconciliation.json).");
+    }
+    return null;
+}
+/**
+ * Source the provenance "Target repo:" name for a run (@SCN-RPT-001 Update —
+ * Fork A). The operator's `--target` is recorded VERBATIM — no resolution — defaulting to
+ * `"unknown-target"` when omitted (parallel to `sourceSha`'s `"unknown"`; the facts
+ * artefact is self-describing, so the line always renders). PURE and `@unit`-testable at
+ * the CLI edge, like `checkLegacyJson`. It never inspects `--features`: the prior
+ * `basename(dirname(--features))` resolution (the deleted `resolveTarget`) and its
+ * degenerate `.` are impossible now — the target is only ever the given value or the
+ * explicit default.
+ */
+export function sourceTarget(args) {
+    return args["target"] ?? "unknown-target";
+}
+/**
+ * Guard the supplied input-file/dir flags at the CLI edge (@SCN-CLI-002). A
+ * mistyped `--vitest` / `--cucumber` / `--features` / `--ci` / `--package-json`
+ * pointing at a non-existent path used to reconcile silently against ZERO evidence —
+ * a terrifying false all-red report meaning "you forgot the reports", not "your code
+ * is broken" (the dogfooding fault). The five flags are Examples of ONE boundary
+ * rule: a supplied-but-absent input path is a hard error. Scope is existence only
+ * (readability / file-vs-dir type-correctness out of scope; `exists` covers the dir
+ * flag and the file flags alike).
+ *
+ * PURE and `@unit`-testable like `checkLegacyJson` / `sourceTarget`: reads the parsed
+ * args + an injected `exists` fn (no fs), returns the FIRST supplied-but-absent
+ * `(flag, path)` as a typed error naming both — routed to stderr + a non-zero exit by
+ * `runBalance` (the shared typed-error surface) — else null. An OMITTED flag is not an
+ * error (legitimately optional: simply no evidence of that kind).
+ */
+/**
+ * The parsed args, as the reconciler's input paths — the one place a `--flag` name becomes a
+ * `ReconcileOptions` key.
+ *
+ * Its own function rather than an object literal inside `runBalance`, which sits at the
+ * `max-lines-per-function` standard: a flag is added here, not by growing the orchestration. The
+ * mapping is also the only thing in that function with nothing to do with orchestration.
+ */
+function reconcileInputsOf(args) {
+    return {
+        features: args["features"],
+        vitest: args["vitest"],
+        cucumber: args["cucumber"],
+        ci: args["ci"],
+        packageJson: args["package-json"],
+        measurements: args["measurements"],
+    };
+}
+export function checkInputsExist(args, exists) {
+    // The five input flags in a fixed order — the FIRST supplied-but-absent one is the
+    // reported error (deterministic; the operator fixes and re-runs). Keys are the
+    // parseArgs form (the `--` stripped); the message names the flag WITH its dashes.
+    const flags = ["vitest", "cucumber", "features", "ci", "package-json", "measurements"];
+    for (const flag of flags) {
+        const path = args[flag];
+        if (path !== undefined && !exists(path)) {
+            return `The --${flag} path does not exist: ${path}`;
+        }
+    }
+    return null;
+}
+/**
+ * The JSON-BEARING input flags — the ones whose content is `JSON.parse`d, and so the only
+ * ones whose content can throw. `--features` is Gherkin (parsed tolerantly) and `--ci` is
+ * read as raw TEXT and scanned for `run:` steps — neither is JSON, neither can crash the
+ * process, and on garbage both reconcile normally (verified, 3F-1742 Discovery).
+ */
+const JSON_INPUT_FLAGS = ["vitest", "cucumber", "package-json", "measurements"];
+/**
+ * Guard the READABILITY of the supplied JSON inputs at the CLI edge (@SCN-CLI-014).
+ * `checkInputsExist` already guards their PRESENCE — but a path that is present yet
+ * UNPARSEABLE fell straight through it: the reader threw mid-parse, nothing caught it, and
+ * the process hit Node's default exit 1 — the code reserved for a genuine OUT-OF-BALANCE
+ * verdict. A crashed invocation was therefore indistinguishable, by exit code, from an
+ * honest disagreement (3F-1742). An input the tool cannot read is a USAGE fault: exit 2,
+ * sibling to a missing path (@SCN-CLI-002) and an unrecognised flag (@SCN-CLI-009).
+ *
+ * PURE and `@unit`-testable like its sibling guards: reads the parsed args + an injected
+ * `read` fn (no fs), returns the FIRST supplied-but-unparseable `(flag, path, failure)` as
+ * a typed error naming all three — routed to stderr + exit 2 by `runBalance` — else null.
+ * An omitted flag is not an error, and an unreadable file (a race after the existence
+ * check) reports as the same input fault rather than escaping as a crash.
+ */
+export function checkInputsParse(args, read) {
+    for (const flag of JSON_INPUT_FLAGS) {
+        const path = args[flag];
+        if (path === undefined)
+            continue;
+        try {
+            JSON.parse(read(path));
+        }
+        catch (err) {
+            // Both a parse failure and an unreadable file are the SAME input fault. Anything
+            // that escapes this catch lands on Node's default exit 1 — the collision itself.
+            const failure = err instanceof Error ? err.message : String(err);
+            return `The --${flag} report is not valid JSON: ${path} (${failure})`;
+        }
+    }
+    return null;
+}
+/**
+ * Guard the readability of `--render-from-json` at the CLI edge (@SCN-CLI-015). The
+ * render-from-saved-JSON branch RETURNS before the input guards ever run, so it honoured
+ * NEITHER: a missing path crashed to `ENOENT` and a malformed file to `SyntaxError`, both
+ * landing on Node's default exit 1 — the out-of-balance code (3F-1764).
+ *
+ * The missing-path case was a live violation of @SCN-CLI-002's own shipped principle: a
+ * supplied input path that does not exist is a hard error at exit 2, enforced for the five
+ * evidence flags and not for this one. The CLI shipped a guard that half-honoured its Rule.
+ *
+ * MISSING and UNPARSEABLE are two Examples of one boundary rule — an input the tool cannot
+ * read is a usage error, never a verdict — so one guard covers both. PURE and
+ * `@unit`-testable like its siblings: the parsed args + an injected `read` (no fs), which
+ * throws for an absent/unreadable path exactly as `readFileSync` does. An OMITTED flag is
+ * not an error (the ordinary reconcile path).
+ */
+export function checkRenderFromJson(args, read) {
+    const path = args["render-from-json"];
+    if (path === undefined)
+        return null;
+    try {
+        JSON.parse(read(path));
+    }
+    catch (err) {
+        // MISSING (read throws ENOENT) and UNPARSEABLE (JSON.parse throws) are the same input
+        // fault, caught in the same place. Anything escaping here lands on Node's default
+        // exit 1 — the out-of-balance code — which is the collision this closes.
+        const failure = err instanceof Error ? err.message : String(err);
+        return `The --render-from-json saved report could not be read: ${path} (${failure})`;
+    }
+    return null;
+}
+/**
+ * The registry-bounded flag check at the CLI edge (@SCN-CLI-009). `balance` accepts ONLY
+ * the flags its per-command registry scope LISTS (by `name` or `alias`); an unregistered
+ * flag — a typo like `--strcit`, a stray `--bogus` — is a usage error, NOT silently
+ * swallowed the way the old permissive `parseArgs` did. This is the structural teeth behind
+ * "accepted = registry = help": a flag can't affect behaviour without a registry entry (and
+ * so, by CLI-008's guard, without appearing in help).
+ *
+ * PURE and `@unit`-testable like `checkLegacyJson` / `checkInputsExist`: reads the parsed
+ * args (keys are the `--`-stripped flag names) + the registry, returns the FIRST unregistered
+ * flag as a typed usage error naming it WITH its dashes — routed to stderr + exit 2 by
+ * `runBalance` (per 3F-1414's `0` balanced / `1` out-of-balance / `2` usage taxonomy),
+ * never exit 1, never a silent reconcile — else null. The global `--store`/`--run-id`
+ * modifiers never reach here: the top-level dispatcher (`parseHostInvocation`) consumes them
+ * BEFORE `balance` is dispatched, so the bounded parser sees only the command's own args.
+ */
+export function checkUnknownFlags(args, registry) {
+    // The accepted set: every balance-scope flag name AND alias, with the leading dashes
+    // stripped so it compares against parseArgs's `--`-stripped keys (e.g. "--features" and
+    // "-h" become "features" and "h"). Built from the registry alone — the single source — so
+    // "accepted = registry" holds by construction.
+    const balance = registry.commands.find((command) => command.name === "balance");
+    const accepted = new Set();
+    for (const flag of balance?.flags ?? []) {
+        accepted.add(flag.name.replace(/^-+/, ""));
+        for (const alias of flag.aliases ?? [])
+            accepted.add(alias.replace(/^-+/, ""));
+    }
+    // The FIRST parsed flag not in the accepted set is the reported error (Object.keys is
+    // argv order, so this is deterministic). The message names the flag WITH its dashes.
+    for (const key of Object.keys(args)) {
+        if (!accepted.has(key)) {
+            return `Unknown flag --${key} for 'spec-controller balance'. Run 'spec-controller balance --help' to see the accepted flags.`;
+        }
+    }
+    return null;
+}
+export function runBalance(argv) {
+    // Answer `--help`/`-h` from the command/flag registry (@SCN-CLI-006) BEFORE any
+    // parse or reconcile: render the balance command's per-command scope (a line per
+    // registered flag — name + arg + description), leave process.exitCode at its default 0,
+    // and return. This intercepts --help so it never falls through parseArgs as a stray flag
+    // while balance runs anyway. The registry is the single source, so a flag that exists is
+    // a flag that appears in help — no hand-kept list to drift.
+    if (argv.includes("--help") || argv.includes("-h")) {
+        process.stdout.write(renderBalanceHelp(cliRegistry) + "\n");
+        return;
+    }
+    // Capture the run-start instant up front — the run provenance's UTC timestamp,
+    // threaded through ctx.runStart to the renderers.
+    const runStart = new Date();
+    const args = parseArgs(argv);
+    // Legacy-`--json` guard (@SCN-FMT-006): the earlier `--json <path>` flag is
+    // removed. Reject it fast — before any reconcile or write — with a migration hint to
+    // `--format json:<path>`, so the removed flag never silently no-ops and drops output. The
+    // guard's typed error is routed to stderr + a non-zero exit, exactly as planOutput's error
+    // is below (the shared typed-error surface).
+    const legacyJsonError = checkLegacyJson(args);
+    if (legacyJsonError) {
+        process.stderr.write(legacyJsonError + "\n");
+        // Usage/config error → exit 2 (the enumerated usage code, @SCN-CLI-002), distinct
+        // from the out-of-balance verdict code 1 (@SCN-CLI-004): an out-of-balance run must
+        // never masquerade as a usage error, nor the reverse.
+        process.exit(2);
+    }
+    // Registry-bounded parse (@SCN-CLI-009): `balance` accepts ONLY the flags its registry
+    // scope LISTS. An unregistered flag — a typo `--strcit`, a stray `--bogus` — is a
+    // USAGE error: name it on stderr, set process.exitCode = 2 (the enumerated usage code,
+    // 3F-1414's 0/1/2 taxonomy — never 1, never a silent swallow), and RETURN before any
+    // reconcile. Runs AFTER the legacy-`--json` guard so `--json` keeps its specific migration
+    // hint; the global `--store`/`--run-id` modifiers were consumed by the dispatcher before
+    // balance, so they never reach here. This is the structural teeth behind "accepted =
+    // registry = help" — a flag can't affect behaviour without a registry entry.
+    const unknownFlagError = checkUnknownFlags(args, cliRegistry);
+    if (unknownFlagError) {
+        process.stderr.write(unknownFlagError + "\n");
+        process.exitCode = 2;
+        return;
+    }
+    // Render-from-saved-JSON mode (@SCN-RMD-007): regenerate the human markdown from a
+    // banked spec-reconciliation.json ALONE — no reconcile, no live inputs, no RunContext. Reads
+    // the file, JSON.parses it back into the whole-document report model, renders the markdown via
+    // renderReport, and writes it to stdout (the same trailing-newline convention as the writer's
+    // stdout path). The load-bearing proof that the JSON IS the model — returns before any reconcile.
+    // Saved-report READABILITY guard (@SCN-CLI-015). This branch RETURNS before the input
+    // guards below ever run, so it honoured NEITHER: a missing path crashed to ENOENT and a
+    // malformed file to SyntaxError, both landing on Node's default exit 1 — the
+    // out-of-balance code. The missing-path case was a live violation of @SCN-CLI-002's own
+    // shipped principle, which the CLI enforced for the five evidence flags and not for this
+    // one. The guard therefore runs INSIDE this branch, ahead of the read (3F-1764).
+    const unreadableSavedReportError = checkRenderFromJson(args, (path) => readFileSync(path, "utf8"));
+    if (unreadableSavedReportError) {
+        process.stderr.write(unreadableSavedReportError + "\n");
+        process.exit(2);
+    }
+    const rehydratePath = args["render-from-json"];
+    if (rehydratePath !== undefined) {
+        const savedReport = readFileSync(rehydratePath, "utf8");
+        process.stdout.write(renderReportFromJson(savedReport) + "\n");
+        return;
+    }
+    // Input-existence guard (@SCN-CLI-002): a supplied input-file/dir flag pointing at a
+    // non-existent path is a HARD ERROR — halt BEFORE reconciling, with a typed message
+    // naming the flag + path, never the silent zero-evidence all-red report a mistyped
+    // path used to produce (the dogfooding fault). Routed to stderr + a non-zero exit,
+    // exactly as the legacy-`--json` guard above (the shared typed-error surface). An
+    // omitted flag is legitimately optional and passes through untouched.
+    const missingInputError = checkInputsExist(args, existsSync);
+    if (missingInputError) {
+        process.stderr.write(missingInputError + "\n");
+        // Usage/input error → exit 2 (@SCN-CLI-002), distinct from the out-of-balance
+        // verdict code 1 (@SCN-CLI-004).
+        process.exit(2);
+    }
+    // Input-READABILITY guard (@SCN-CLI-014): existence is not enough. A report that is
+    // PRESENT but UNPARSEABLE (`--vitest /dev/null`, truncated JSON, non-JSON) used to throw
+    // mid-parse inside reconcileWithCensus, uncaught — and Node's default exit code is 1, the
+    // code reserved for a genuine OUT-OF-BALANCE verdict (@SCN-CLI-004). So a tool that
+    // CRASHED before reconciling was indistinguishable, by exit code, from an honest
+    // disagreement (3F-1742). Runs immediately after the existence guard and BEFORE any
+    // reconcile, routing to the same stderr + exit 2 lane: an input the tool cannot read is a
+    // usage fault, sibling to a missing path and an unrecognised flag — never a verdict.
+    const unparseableInputError = checkInputsParse(args, (path) => readFileSync(path, "utf8"));
+    if (unparseableInputError) {
+        process.stderr.write(unparseableInputError + "\n");
+        process.exit(2);
+    }
+    // The FEATURE-CORPUS integrity checkpoint (@SCN-CLI-016, 3F-1767). The feature corpus is an
+    // input too — the ledger's DEBIT side — and it was read by a hand-rolled TAG-LINE SCAN that
+    // never consulted a parser. So a malformed tag line simply stopped being a tag line and its
+    // scenario CEASED TO EXIST: one stray character deleted a failing row and turned an
+    // out-of-balance run (exit 1) into a clean BALANCED (exit 0). A dropped scenario cannot even
+    // reconcile `missing`, because it was never RAISED to be missing — the run read cleaner than
+    // reality, the exact false-green this tool exists to prevent.
+    //
+    // Validated with the REAL Gherkin parser (cucumber's own), so a file the tool would reconcile is
+    // at least a file cucumber would RUN. A file it rejects is an input we CANNOT READ: exit 2,
+    // halting BEFORE any reconcile, naming the file and the parse failure — the same Rule as
+    // @SCN-CLI-014 and @SCN-CLI-015 ("an input the tool cannot read is a usage error, never a
+    // verdict"), now on the obligation side. Never a verdict, and never a green.
+    //
+    // The corpus is EXTRACTED from the same real AST (@SCN-LDG-020), so what the tool reconciles is
+    // what cucumber runs — Feature/Rule tag inheritance included. This guard decides whether the file
+    // can be read at all; parseScenarios then reads it exactly as cucumber would.
+    const featureParseErrors = featureCorpusParseErrors(args["features"]);
+    if (featureParseErrors.length > 0) {
+        for (const { file, message } of featureParseErrors) {
+            process.stderr.write(`The --features corpus contains a feature file that could not be parsed: ${file}\n${message}\n`);
+        }
+        process.exit(2);
+    }
+    // AMBIGUOUS-CORPUS guard (@SCN-LDG-020's guardrail, 3F-1775). An @SCN identifies exactly ONE
+    // scenario — that is the whole basis of attributing evidence to it. Tag inheritance makes a
+    // DUPLICATE reachable: an @SCN hoisted to a Feature:/Rule: is inherited by every scenario
+    // beneath it (cucumber does this, so we do). One passing test would then mark EVERY scenario
+    // sharing that id `balanced` — including scenarios nothing proves — a BALANCED-WHEN-BROKEN run
+    // at exit 0. A new silent false-green, introduced by the very fix that closed the last one.
+    //
+    // So the corpus is REFUSED, not reconciled: the tool cannot know which scenario a citing test
+    // proves, and any verdict over it would be a guess. Same Rule as @SCN-CLI-014/015/016 — an input
+    // the tool cannot read is a usage error, never a verdict.
+    const duplicateScnIds = featureCorpusDuplicateScnIds(args["features"]);
+    if (duplicateScnIds.length > 0) {
+        process.stderr.write(`The --features corpus names the same @SCN on more than one scenario: ` +
+            `${duplicateScnIds.join(", ")}.\n` +
+            `An @SCN identifies exactly one scenario — evidence citing a duplicated id cannot be ` +
+            `attributed, so no verdict over this corpus would be trustworthy. (An @SCN on a Feature: ` +
+            `or Rule: line is inherited by every scenario beneath it — name it on the scenario.)\n`);
+        process.exit(2);
+    }
+    const inputs = reconcileInputsOf(args);
+    // Reconcile the obligation-vs-observation evidence into the Ledger. The runtime evidence-observation
+    // views (Test volume, the evidence grid) are FOLDS the renderers derive off this Ledger's posted
+    // credits (@SCN-RPT-010 / 3F-2103 — the census is retired), so they cannot drift from the
+    // reconciler's verdict: they ARE the same rows. `withRuntimeObservations: true` (below) tells the
+    // renderers the axis is in play.
+    const balance = runReconcile(inputs);
+    // Read the scenario-corpus census alongside the balance (@SCN-RPT-008) —
+    // the raw-vs-parsed @SCN-occurrence delta over the same discovered feature corpus.
+    // A sibling to the balance, threaded to the renderers via writeOutputs like ctx.
+    const evidenceObligations = readEvidenceObligations(args["features"]);
+    // The static-check kind-counts are a FOLD OVER THE LEDGER (@SCN-USG-001 / 3F-2118) — the
+    // renderers count the balance's own posted static-check credits (`staticObservationTally`), so
+    // they cannot drift from the reconciler's verdict: they ARE the same rows. The parallel static
+    // census is RETIRED; `withStaticChecks: true` (below) tells the renderers the axis is in play.
+    // Read the target's feature-code→slug map alongside the balance (@SCN-RPT-006)
+    // — the by-feature cut's full-name labels. The 5th sibling, threaded to the MARKDOWN
+    // renderer via writeOutputs only (markdown-only; the by-feature cut isn't on JSON).
+    const featureNames = readFeatureNames(args["features"]);
+    // Build the run provenance ONCE (project design §1) — a sibling RunContext, the
+    // Ledger staying pure — reusing the existing runStart. The target is the
+    // operator's --target VERBATIM (unknown-target on omit; Fork A — no
+    // resolution, no basename guessing). Source SHA via the read-only target read, with
+    // --source-sha as the override (resolveSourceSha).
+    const ctx = {
+        target: sourceTarget(args),
+        inputs,
+        runStart,
+        sourceSha: resolveSourceSha({
+            sourceSha: args["source-sha"],
+            targetDir: args["features"] !== undefined ? dirname(args["features"]) : undefined,
+        }),
+        // The TARGET repo root the recorded input paths are made portable against (fixed to
+        // the target root, not the run cwd, by @SCN-RPT-016) — the SAME
+        // root readEvidenceObservations passes to countRuntimeEvidenceObservationKinds, derived from
+        // --features, so a cross-repo reconcile records inputs relative (`features`) rather
+        // than leaking the target's absolute path.
+        root: resolveTargetRoot({ features: inputs.features }),
+        // The TOOL's own identity (@SCN-RPT-026, 3F-1916) — which spec-controller produced
+        // this run, distinct from the target's sourceSha. Read from the tool's OWN dir, never
+        // cwd (which is the target). One call, spread into the ctx; the same identity feeds
+        // the run.yaml manifest.
+        ...resolveToolIdentity(),
+    };
+    // Plan the outputs from the --format specs (no flag → md→stdout) and write them via
+    // the writer — the pure plan / impure writer split (@SCN-FMT-001). The plan
+    // parse+validate is pure; the writer is the only IO for the emitted report. This is
+    // the SOLE output path: the tool emits via --format and holds no storage opinion — the
+    // legacy runs/<target>/<ISO>/ auto-archive was removed with @SCN-RUN-001, the
+    // caller now routes stored runs (spec-controller's run-management layer).
+    const planResult = planOutput(collectFormatSpecs(argv));
+    if (!planResult.ok) {
+        process.stderr.write(planResult.error + "\n");
+        // Usage/config error (bad --format spec) → exit 2 (@SCN-CLI-002), distinct from the
+        // out-of-balance verdict code 1 (@SCN-CLI-004).
+        process.exit(2);
+    }
+    writeOutputs(planResult.plan, { balance, ctx, evidenceObligations, withRuntimeObservations: true, withStaticChecks: true, featureNames });
+    // The CI gate (@SCN-CLI-004): `balance` is a GATE, not just a reporter. AFTER the report
+    // is written in full, map the whole-run verdict to the process exit code. Out-of-balance
+    // (ANY reconciling item anywhere: an out-of-balance scenario OR a suspense-row item such
+    // as a no-evidence-obligation static-check watermelon) sets process.exitCode = 1 and RETURNS — set,
+    // never `process.exit(1)`, so the buffered report is flushed intact rather than truncated
+    // mid-write. It exits EXACTLY 1 so it reds a CI build and can't masquerade as the usage
+    // error (2, above). An ENUMERATED status, never a count (8-bit wrap → false pass). A
+    // balanced run leaves process.exitCode at its default 0 and returns.
+    //
+    // The --strict escalation (@SCN-CLI-011): Pending Items are run-neutral by DEFAULT
+    // (@SCN-PND-008 — they never red a build), but `--strict` is the OPT-IN that fails an
+    // OTHERWISE-BALANCED run carrying them, exiting the DISTINCT code 3 (taxonomy 0 balanced /
+    // 1 out-of-balance / 2 usage / 3 pending-under-strict — a Pending Item is not out-of-balance,
+    // so it must NEVER share code 1). Out-of-balance DOMINATES: the escalation is checked ONLY in
+    // the `isBalanced` branch, so an out-of-balance run exits 1 regardless of --strict. Like the
+    // CLI-004 gate this SETS process.exitCode (never process.exit) AFTER writeOutputs, so the
+    // buffered report is flushed intact. `--strict` is a registry-LISTED boolean, recorded by
+    // parseArgs as the string "true" — presence is what matters, so `!== undefined` reads it.
+    //
+    // The UNSOUND pre-emption (@SCN-CLI-012): a run carrying BROKEN evidence — a proving suite
+    // that failed to COLLECT, so the behaviour was never exercised — exits the DISTINCT code 4
+    // (taxonomy 0 balanced / 1 out-of-balance / 2 usage / 3 pending-under-strict / 4 unsound).
+    // Exit 1 says "the ledger disagrees"; exit 4 says "the ledger could not be TRUSTED to
+    // disagree" — you cannot trust a reconciliation whose evidence never materialised, so
+    // unsound DOMINATES.
+    //
+    // THE ORDER IS LOAD-BEARING, NOT COSMETIC. A broken run is ALWAYS out-of-balance: its
+    // `broken` item sits on the SUSPENSE row, so `isBalanced` is already false. Check it AFTER
+    // `isBalanced` and the branch is UNREACHABLE — every broken run would exit 1 and the
+    // collection failure would stay masked as an honest disagreement (the AWTY dogfood fault,
+    // 3F-1642). So `hasBrokenEvidence` is checked FIRST, PRE-EMPTING the balance verdict it
+    // would otherwise be swallowed by. @SCN-CLI-004 is a BYSTANDER, not an Update: its fixture
+    // is a SOUND out-of-balance run (no broken item), so it falls through this branch and still
+    // exits exactly 1 — the pre-emption fires only when evidence genuinely failed to collect.
+    const strict = args["strict"] !== undefined;
+    if (hasBrokenEvidence(balance.ledger)) {
+        process.exitCode = 4;
+    }
+    else if (!isBalanced(balance.ledger)) {
+        process.exitCode = 1;
+    }
+    else if (strict && hasPendingItems(balance.ledger)) {
+        process.exitCode = 3;
+    }
+}
+// Only run the balance command when this module is executed directly
+// (`tsx cli-balance/cli.ts`), NOT when imported by the top-level `spec-controller`
+// bin dispatcher or by a test that exercises the pure edge guards.
+const invokedDirectly = process.argv[1] !== undefined && import.meta.url === `file://${process.argv[1]}`;
+if (invokedDirectly)
+    runBalance(process.argv.slice(2));
+//# sourceMappingURL=cli.js.map

package/dist/cli-balance/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/cli-balance/cli.ts"],"names":[],"mappings":"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"}