@3f-consulting/spec-controller-core 0.1.0-alpha.7 → 0.1.0-alpha.71

package/dist/domain/journal.js

@@ -1,138 +1,26 @@
-/**
- * The JOURNAL — the debit/credit input concepts of the reconciliation domain, co-located
- * as one module (module, not class). These are the raw entries a run RAISES (evidence
- * obligations, and the scenarios that raise them) and OBSERVES (evidence observations, runtime
- * and static), keyed by one flat `qualityCheck` per evidence obligation — the two-axis
- * `(kind, level)` grid collapsed to a single mutually-exclusive coordinate.
- *
- * `@lint` is one quality-check VALUE, not a second axis; `qualityCheck === "lint"` is the
- * watermelon discriminator (replacing the retired `kind === "static"`). The runtime
- * quality-checks (@unit/@integration/@e2e/@performance) reconcile against emitted test
- * results; the `lint` quality-check reconciles a static check over the source artifact.
- *
- * The reconciled OUTCOMES these entries produce live in the sibling concept modules
- * (`qualityCheckReconciliation`, `scenarioReconciliation`, `ledger`), which import this one.
- */
-/**
- * The NAMED `(scnId, quality-check)` pairs — the ONE rule for what a scenario names, keyed
- * `"<scnId> <qualityCheck>"`. A credit citing a scenario is reconciliation-matched only
- * when its pair is in this set; otherwise it is `no-evidence-obligation` (a real scenario, at a quality-check
- * it never named).
- *
- * A `pending` obligation is EXCLUDED — it names nothing. Canon, Pending Item: a
- * `<quality-check>pending` tag raises **no Evidence Obligation**, so an Evidence Observation
- * citing that scenario at a pending quality-check is `no-evidence-obligation` — exactly as when
- * nothing was raised at all. Nothing is named, so nothing can be attributed to it. (This also drops the
- * scenario-scope pending obligation, which carries no `qualityCheck` at all — it names no
- * specific check, so it never belonged in a pair set keyed by one.)
- *
- * ONE COPY, BY CONSTRUCTION (3F-1858). This loop existed TWICE, character-identical — in
- * `reconcile` and in the observation census — each building the set over ALL obligations
- * INCLUDING pending. They agreed by copy-paste, not by construction: either could have grown a
- * filter alone and nothing would have redded. That is exactly what the pending divergence was —
- * the pair-check excluded the credit from `no-evidence-obligation` while the pending partition excluded it
- * from the debit side, so it posted NOWHERE and the run read balanced, exit 0, over a fault canon
- * says must fail (@SCN-PND-005).
- *
- * Lives in the model, not in either caller: what a scenario NAMES is the model's rule, not a
- * reconciler's or a census's private business (`entity-owns-its-behaviour`) — the same reason
- * `OUT_OF_BALANCE_OUTCOMES` lives here rather than in the renderer that walks it.
- *
- * A runtime credit's quality-check is a `RuntimeQualityCheck`, so a `lint` obligation
- * never matches one — as intended; the two axes key differently, see below.
- *
- * THE FITNESS KEY CARRIES ITS CHECK TAG (@SCN-LNT-013), and the asymmetry with the runtime key is
- * the design rather than an inconsistency. A runtime credit's `qualityCheck` IS its discriminating
- * term — an obligation at `unit` is answered by a credit at `unit`, and there is nothing finer to
- * key on. On the fitness axis the axis word is `lint` for EVERY check, so the axis alone cannot
- * discriminate: keyed on it, a row's obligation for one check answers a credit for any other.
- *
- * WHICH IS EXACTLY THE FAULT THIS CLOSES. `@SCN-LNT-012` made the debit MATCH compare check tags —
- * the `@SCN` picks the row, the tag picks the obligation — so a credit whose tag no obligation on
- * its row names matches nothing, correctly. This set stayed keyed on the axis, so the credit it
- * newly failed to match was also excluded from the credit-side items that should have caught it,
- * and it reconciled to NOTHING: filtered out of the debit by its tag and out of the credit side by
- * its axis. Measured over a genuine watermelon, the run read balanced, exit 0.
- *
- * BUILT AND READ TOGETHER. `noEvidenceObligationReconciliationsOf` composes the same key from the
- * CREDIT's own `checkTag`. A key built one way and read another is this same bug in a new spelling,
- * so the two are one change and are described in both places.
- */
 export function evidenceObligationPairsOf(scenarios) {
     const pairs = new Set();
     for (const scenario of scenarios) {
         for (const obligation of scenario.evidenceObligations) {
             if (obligation.pending === true)
-                continue; // names nothing — see above.
-            pairs.add(evidenceObligationPairKey(scenario.scnId, obligation.qualityCheck, obligation.staticCheck));
+                continue;
+            pairs.add(evidenceObligationPairKey(scenario.scnId, obligation.qualityCheck));
         }
     }
     return pairs;
 }
-/**
- * THE ONE SPELLING of a `(scenario, what-it-names)` key — shared by the set above and by the
- * credit-side lookup, so the two cannot drift.
- *
- * `checkTag` is the FITNESS discriminator (the obligation's `staticCheck`, the credit's `checkTag`)
- * and is ignored on the runtime axis, where the quality-check already discriminates. A fitness
- * entry with NO tag keys distinctly from every tagged one rather than collapsing onto a bare
- * `"<scn> lint"` that a tagged obligation could answer — an uncited credit never reaches a real
- * row (`citationOfCitedRow` resolves the `@SCN` and the tag together or neither), and if one ever
- * did, it must not match by having nothing to compare.
- */
-export function evidenceObligationPairKey(scnId, qualityCheck, checkTag) {
-    return qualityCheck === "lint"
-        ? `${scnId} lint ${checkTag}`
-        : `${scnId} ${qualityCheck}`;
+export function evidenceObligationPairKey(scnId, qualityCheck) {
+    return `${scnId} ${qualityCheck}`;
 }
-/**
- * THE PENDING PARTITION, debit half (@SCN-PND-004, 3F-2204) — the evidence obligations a scenario
- * actually NAMES: every non-pending one, in document order. These are the obligations that
- * reconcile; the complement becomes one-sided Pending Items (`pendingItemsOf`, below).
- *
- * A pending obligation is EXCLUDED for the SAME reason, and by the same canon clause, as in
- * `evidenceObligationPairsOf`: a `<quality-check>pending` tag raises
- * NO Evidence Obligation, so it names nothing. This completes that family — the three now state
- * one rule over three keyings (the whole obligations, the `(scnId, quality-check)` pairs, the
- * static-check handles) instead of two stating it and a third restating it inline in the fold.
- *
- * Lives here rather than in the reconciler: what a scenario NAMES is the model's rule, not the
- * reconciler's private business (`entity-owns-its-behaviour`).
- *
- * Takes the OBLIGATIONS rather than a `Scenario` (3F-2203) so the one rule serves both sides of the
- * pipeline: `reconcile` passes the obligations a scenario raises, and the renderer passes a Ledger
- * row's POSTED DEBITS (`ScenarioReconciliation.evidenceObligations`) to answer "does this row
- * name this quality-check?" for the grid. The renderer previously re-encoded the `!pending`
- * clause itself — the same rule in a second home, agreeing by copy.
- */
 export function evidenceObligationsOf(evidenceObligations) {
     return evidenceObligations.filter((obligation) => !obligation.pending);
 }
-/**
- * THE PENDING PARTITION, deferred half (@SCN-PND-004, 3F-2204) — the one-sided Pending Items a
- * scenario's deferred obligations raise, one per `<quality-check>pending` obligation, in document
- * order. The exact complement of `evidenceObligationsOf`: together they partition the
- * scenario's obligations, so nothing is dropped and nothing is counted twice.
- *
- * A Pending Item carries ONLY the quality-check owed — `undefined` for the scenario-scope deferral
- * (@SCN-PND-022, a bare `@wip` raising no obligations), which owes no specific check. It is
- * partitioned off BEFORE the observation match, so it never becomes a Quality Check Reconciliation
- * and never a reconciling item: "one-sided — nothing is reconciled".
- */
 export function pendingItemsOf(scenario) {
     return scenario.evidenceObligations
         .filter((obligation) => obligation.pending)
         .map((obligation) => ({ qualityCheck: obligation.qualityCheck }));
 }
-/**
- * Is this observation a STATIC-CHECK fact? The predicate every reader that wants a static check's
- * OWN fields — its runnable handle, its `exists`, its `enforcedOverRealSource` — asks.
- *
- * It outlived the measured member it was written to tell apart from (3F-3516): the `lint`
- * quality-check is a single interface again, so this is the quality-check clause alone, and its
- * readers keep naming what they mean rather than spelling `qualityCheck === "lint"` at each site.
- */
-export function isStaticCheckObservation(observation) {
-    return observation.qualityCheck === "lint";
+export function isFitnessObservation(observation) {
+    return observation.qualityCheck === "fitness";
 }
 //# sourceMappingURL=journal.js.map

package/dist/domain/journal.js.map

@@ -1 +1 @@
-{"version":3,"file":"journal.js","sourceRoot":"","sources":["../../src/domain/journal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AA4DH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,UAAU,yBAAyB,CAAC,SAA8B;IACtE,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;IAChC,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QACjC,KAAK,MAAM,UAAU,IAAI,QAAQ,CAAC,mBAAmB,EAAE,CAAC;YACtD,IAAI,UAAU,CAAC,OAAO,KAAK,IAAI;gBAAE,SAAS,CAAC,6BAA6B;YACxE,KAAK,CAAC,GAAG,CAAC,yBAAyB,CAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,YAAY,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC;QACxG,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,yBAAyB,CACvC,KAAa,EACb,YAAsC,EACtC,QAA4B;IAE5B,OAAO,YAAY,KAAK,MAAM;QAC5B,CAAC,CAAC,GAAG,KAAK,SAAS,QAAQ,EAAE;QAC7B,CAAC,CAAC,GAAG,KAAK,IAAI,YAAY,EAAE,CAAC;AACjC,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,qBAAqB,CACnC,mBAAkD;IAElD,OAAO,mBAAmB,CAAC,MAAM,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;AACzE,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAAC,QAAkB;IAC/C,OAAO,QAAQ,CAAC,mBAAmB;SAChC,MAAM,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC;SAC1C,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,UAAU,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;AACtE,CAAC;AAyOD;;;;;;;GAOG;AACH,MAAM,UAAU,wBAAwB,CACtC,WAAgC;IAEhC,OAAO,WAAW,CAAC,YAAY,KAAK,MAAM,CAAC;AAC7C,CAAC"}
+{"version":3,"file":"journal.js","sourceRoot":"","sources":["../../src/domain/journal.ts"],"names":[],"mappings":"AAcA,MAAM,UAAU,yBAAyB,CAAC,SAA8B;IACtE,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;IAChC,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QACjC,KAAK,MAAM,UAAU,IAAI,QAAQ,CAAC,mBAAmB,EAAE,CAAC;YACtD,IAAI,UAAU,CAAC,OAAO,KAAK,IAAI;gBAAE,SAAS;YAC1C,KAAK,CAAC,GAAG,CAAC,yBAAyB,CAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC;QAChF,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,UAAU,yBAAyB,CACvC,KAAa,EACb,YAAsC;IAEtC,OAAO,GAAG,KAAK,IAAI,YAAY,EAAE,CAAC;AACpC,CAAC;AAED,MAAM,UAAU,qBAAqB,CACnC,mBAAkD;IAElD,OAAO,mBAAmB,CAAC,MAAM,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;AACzE,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,QAAkB;IAC/C,OAAO,QAAQ,CAAC,mBAAmB;SAChC,MAAM,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC;SAC1C,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,UAAU,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;AACtE,CAAC;AAyBD,MAAM,UAAU,oBAAoB,CAClC,WAAgC;IAEhC,OAAO,WAAW,CAAC,YAAY,KAAK,SAAS,CAAC;AAChD,CAAC"}

package/dist/domain/ledger.d.ts

@@ -1,379 +1,59 @@
-/**
- * THE LEDGER — the accounts with their posted entries, co-located with its OWN whole-run
- * behaviour: `isBalanced`, `hasPendingItems`, `hasBrokenEvidence` (module, not class). These
- * three pure predicates are the whole-run verdict surface the CLI edge maps to exit codes;
- * they were the reconcile orchestration's exports and now live WITH the concept they fold over.
- */
 import type { Outcome, QualityCheckReconciliation } from "./qualityCheckReconciliation.js";
 import type { ScenarioReconciliation } from "./scenarioReconciliation.js";
 import type { RuntimeQualityCheck } from "./journal.js";
-/**
- * THE LEDGER — the accounts with their POSTED ENTRIES. Canon (double-entry-manifesto, chain
- * step 4 + the Ledger entry): "the evidence obligations (debits) and evidence observations
- * (credits) organised by real or invented scenario, keyed by quality-check — THIS IS WHERE
- * RECONCILIATION HAPPENS."
- *
- * RENAMED FROM `Ledger` (3F-1846 / 3F-1830). 3F-1138 corrected a real error — the
- * rendered report was titled `# Ledger`, and the per-scenario reconciliation is the trial balance,
- * not the ledger — but corrected it by DELETING the concept rather than distinguishing it. The
- * Ledger was never the report, so removing the report's wrong name should not have removed the
- * Ledger. This restores it. `Ledger` is now canon's name for LAYER 1 — the
- * assembled statement (`assemble/report.ts`, formerly `EvidenceReconciliation`); the four layers are
- * `Ledger` → `Ledger` → `ScenarioReconciliation` → `QualityCheckReconciliation`,
- * under canon's four names.
- *
- * The Ledger is NOT a second name for the Evidence Reconciliation, and NOT a pre-reconciliation
- * input stage: the SAME accounts live in it before and after balancing off, gaining their verdict
- * IN PLACE. It holds entries, so it is an OBJECT and never a bare array of rows — the code and the
- * JSON are one vocabulary (`interface Ledger { scenarioReconciliations }` ↔
- * `"ledger": { "scenarioReconciliations": [...] }`).
- *
- * `scenarioReconciliations` (renamed from `scenarios`) is the collection of Scenario
- * Reconciliation rows — real (`kind: scenario`, including the degenerate `both-missing`
- * row a zero-evidence scenario posts), cited-but-UNKNOWN (`kind: phantom-scenario`), and
- * cites-nothing (`kind: suspense-scenario`). The name reserves `scenario`/`scenarios` for the
- * real kind (a phantom / suspense is NOT a scenario).
- *
- * EVERY scenario is a row now: the separate-axis authoring-quality
- * `warnings` collection was RETIRED — a scenario raising zero evidence obligations and cited
- * by no evidence observation reconciles to a `both-missing` out-of-balance row, not a warning excluded
- * from the balance.
- */
 export interface Ledger {
     scenarioReconciliations: ScenarioReconciliation[];
 }
-/**
- * The WHOLE-RUN verdict — is the ENTIRE reconciliation balanced? A pure domain
- * derivation over the WHOLE `Ledger`: balanced IFF NO reconciling
- * item exists ANYWHERE, across every Scenario Reconciliation row — scenario,
- * phantom, and suspense alike. Out-of-balance iff ANY row carries a reconciling
- * item: a scenario's out-of-balance items (failing / missing /
- * no-evidence-obligation / both-missing) AND the credit-side suspense/phantom rows (a
- * no-evidence-obligation static-check watermelon, an uncited credit, a phantom scenario).
- *
- * It is deliberately NOT a scan of scenario verdicts alone — that would
- * let a watermelon-only run (every scenario balanced, yet a no-evidence-obligation
- * static check sitting unreconciled in the suspense row) read as balanced, the
- * false pass a CI gate must never give. Every row's `reconcilingItems` is
- * consulted, so the suspense/phantom rows (verdict ALWAYS out-of-balance) count.
- *
- * The CLI edge maps this boolean to the process exit code — balanced → 0,
- * out-of-balance → EXACTLY 1 — an ENUMERATED status, never a count (a count would
- * 8-bit `& 0xFF` wrap → false pass).
- */
 export declare function isBalanced(reconciliation: Ledger): boolean;
-/**
- * Does the WHOLE reconciliation carry any Pending Item? A pure domain predicate over the
- * WHOLE `Ledger`, SYMMETRIC with `isBalanced` — together they are the
- * whole-run verdict surface. True iff ANY Scenario Reconciliation row carries a Pending
- * Item (a deferred `<quality-check>pending` obligation partitioned off before reconciliation,
- * @SCN-PND-004). Pending Items are run-neutral by default (@SCN-PND-008); the CLI edge
- * consults this ALONGSIDE `isBalanced` to escalate an otherwise-balanced run to the distinct
- * exit code 3 under `--strict` (@SCN-CLI-011) — an OPT-IN gate on deferred obligations,
- * checked only when `isBalanced` is true (out-of-balance dominates, exit 1).
- */
 export declare function hasPendingItems(reconciliation: Ledger): boolean;
-/**
- * Does the WHOLE reconciliation carry BROKEN evidence — i.e. is the run UNSOUND? The THIRD
- * whole-run predicate (@SCN-LDG-018), beside `isBalanced` and `hasPendingItems`, and the
- * EXISTENTIAL TWIN of the latter: the same `some(row => some(item => item.outcome === X))` scan.
- *
- * Soundness is a property of the RUN, not of a scenario. If any PROOF NEVER RAN — a vitest suite
- * that failed to collect (@SCN-LDG-017), or a cucumber step matched by two or more definitions
- * (@SCN-LDG-019) — the evidence never fully materialised, so every `missing` in that run is
- * SUSPECT: it may be a broken proof rather than an absent one, and the remedies differ (fix the
- * harness vs write a test). The scenario's own row stays honest at its own resolution (`missing`);
- * the RUN is what is stamped unsound.
- *
- * DERIVED, NEVER STORED — no soundness flag is written onto `Ledger`, the same
- * no-drift reason `isBalanced` and `hasPendingItems` derive. Machine consumers read soundness off
- * `summary.byOutcome.broken > 0` (type-forced into the JSON the moment `broken` joined the
- * `Outcome` union); the markdown renderer prints the HEADLINE word — "unsound" is the render word,
- * never the predicate's name, exactly as "out-of-balance" is for `isBalanced`.
- *
- * Keyed on the `broken` OUTCOME specifically, never on `!isBalanced`: an ordinary out-of-balance
- * run (an honest `missing`, no broken evidence) is perfectly SOUND. The three whole-run
- * predicates are INDEPENDENT — a run may carry Pending Items and be sound; a run may carry broken
- * evidence and no Pending Items. (A broken run is ALWAYS out-of-balance, since the `broken` item
- * sits on the suspense row — which is why the CLI edge must consult THIS predicate BEFORE the
- * balance verdict, @SCN-CLI-012, or its exit code would be unreachable.)
- */
 export declare function hasBrokenEvidence(reconciliation: Ledger): boolean;
-/**
- * Does the WHOLE run have NOTHING TO RECONCILE — no accounts at all? The FOURTH whole-run
- * predicate (@SCN-CLI-019), beside `isBalanced` / `hasPendingItems` / `hasBrokenEvidence`, and the
- * one shape the other three cannot speak about.
- *
- * THE FAULT IT EXISTS TO NAME. `isBalanced` is `.every()` over the rows, so on an EMPTY ledger it
- * is VACUOUSLY TRUE; `hasPendingItems` and `hasBrokenEvidence` are `.some()`, so they are
- * vacuously FALSE. A target that declared nothing and produced nothing therefore satisfied every
- * existing predicate in the direction that reads as a pass, and was told "BALANCED … (exit 0)" — a
- * green over silence, from the tool whose whole claim is that silence is not the same as nothing
- * wrong. No combination of the three separates an empty run from a clean one, which is why this is
- * a predicate and not a derivation of one.
- *
- * ITS OWN ENUMERATED STATE, exit 5 (taxonomy: 0 balanced / 1 out-of-balance / 2 usage / 3
- * pending-under-strict / 4 unsound / 5 nothing to reconcile). Not balanced — there are no accounts
- * to agree. Not out-of-balance — nothing disagrees. Not a usage fault — the invocation was valid
- * and `new-client` is a supported adoption state, not a degraded one. Not unsound — no proof
- * failed; none was owed.
- *
- * KEYED ON THE EMPTY LEDGER, NEVER ON THE EMPTY CORPUS, and that is load-bearing rather than
- * pedantic: a target with no corpus but uncited credits HAS a row — its suspense row — and is an
- * ordinary out-of-balance report at exit 1 (@SCN-CLI-020). Keyed on "no corpus" instead, the modal
- * first run's whole report would disappear behind exit 5.
- *
- * DERIVED, NEVER STORED — no emptiness flag is written onto `Ledger`, the same no-drift reason its
- * three siblings derive, and the reason no JSON-schema change is owed: a machine consumer reads
- * the row count off the ledger it already has. The markdown renderer prints the HEADLINE word —
- * "NOTHING TO RECONCILE" is the render word, never the predicate's name, exactly as "unsound" is
- * for `hasBrokenEvidence`.
- *
- * WHERE IT MUST BE ASKED, MEASURED RATHER THAN ARGUED (3F-3344). The ticket predicted this would
- * be @SCN-CLI-012's pre-emption one code further on — ask it after `isBalanced` and the branch
- * goes unreachable. IT IS NOT, and the plant that was supposed to prove it stayed GREEN. An empty
- * ledger is MUTUALLY EXCLUSIVE with all three siblings: with no rows there is no row to carry a
- * broken item, a reconciling item or a Pending Item, so it fires NONE of them and its position
- * AMONG them is unobservable. Moving it below `!isBalanced` in the CLI ladder still exits 5
- * (measured).
- *
- * WHAT IS LOAD-BEARING is its position against the chain's DEFAULT. "Balanced" is not a predicate
- * branch — it is the fall-through — so there is no "after the balanced case" to append a fifth
- * code to, and a chain that reaches its default has already called the run balanced. Appended
- * after the default the branch is dead code and the run exits 0 (measured: the plant that DID red).
- * That is also why the fault survived: a fifth code cannot be ADDED to this chain, it has to
- * DISPLACE the default, and nothing about the other three predicates says so.
- */
 export declare function hasNothingToReconcile(reconciliation: Ledger): boolean;
-/**
- * The BROKEN reconciling items across the WHOLE run (3F-2203) — every proof that never ran, in row
- * order, each carrying its WHERE-to-fix (locator) and WHAT-broke (the runner's message).
- *
- * The QUANTITATIVE twin of `hasBrokenEvidence`, which is now derived FROM it: "is this run
- * unsound?" and "which proofs never ran?" are one question at two resolutions, so they are one
- * scan. The markdown's Run-integrity section listed these by re-deriving the scan itself — a model
- * query living in the renderer, and a second statement of which outcome means broken.
- *
- * The renderer READS this list and takes its length for the count-phrase; asking a list you were
- * given how long it is is projection, not derivation.
- */
 export declare function brokenItemsOf(reconciliation: Ledger): QualityCheckReconciliation[];
-/**
- * The OBLIGATION-SIDE static-check sub-rows across the whole Ledger (3F-2203) — each `lint` Quality
- * Check Reconciliation with the scnId of the row that names it, in row-then-document order.
- *
- * SCENARIO ROWS ONLY. A `lint` obligation is obligation-side, so a phantom or suspense row can carry
- * none; the suspense row's lint CREDIT (a no-evidence-obligation static check, `cites-no-scenario`) is an
- * observation, not an obligation, and must never inflate the obligation-side lint total.
- *
- * ONE COPY, BY CONSTRUCTION. That scenario-rows-only filter plus the lint cut existed TWICE,
- * character-identical — here in `lintTally` and in the markdown's `### Lint evidence obligations`
- * table. They agreed by copy-paste, not construction: either could have grown a clause alone and
- * nothing would have redded. Same anaemia, same cure as `evidenceObligationPairsOf` and
- * the corpus's own fitness obligations; the tally and the table are now two readings of ONE list.
- */
-export declare function lintReconciliationsOf(reconciliation: Ledger): {
+export declare function fitnessReconciliationsOf(reconciliation: Ledger): {
     scnId: string;
     reconciliation: QualityCheckReconciliation;
 }[];
-/**
- * The materialised totals over the Scenario Reconciliations — the headline verdict tally,
- * counted over EVERY row (@SCN-RMD-001, 3F-1724).
- *
- * The Evidence Reconciliation is ALL Scenario Reconciliations assembled, and the summary is
- * its totals (`strategy/double-entry-manifesto.md`). There are three row kinds — real
- * (`scenario`), `phantom-scenario` (cited by a credit, carried by no feature) and
- * `suspense-scenario` (credits citing no scenario at all) — and phantom / suspense
- * reconciliations are ALWAYS out-of-balance. So `total` / `balanced` / `outOfBalance` count
- * every row, phantom and suspense among them.
- *
- * (The earlier "ruling Q3" — a scenario-only tally with phantom / suspense bucketed APART —
- * was a divergence from the manifesto, not a decision: it let `isBalanced` (which correctly
- * walks every row's reconciling items → exit 1) disagree with a tally reading 0
- * out-of-balance, so a failing run rendered a headline that read as a pass. RETRACTED by the
- * operator, 2026-07-13; the bug it caused is 3F-1703.)
- */
 export interface ScenarioReconciliationTotals {
-    /** Every Scenario Reconciliation — scenario, phantom and suspense rows alike. */
     total: number;
     balanced: number;
-    /** Every out-of-balance row — the phantom and suspense rows among them (they always are). */
     outOfBalance: number;
-    /**
-     * Phantom-scenario rows (cited by a credit, carried by no feature) — a SUB-COUNT, i.e. a
-     * breakdown OF `total` / `outOfBalance`, not a bucket outside them.
-     */
     phantom: number;
-    /**
-     * Suspense-scenario rows — credits citing NO scenario, aggregated into the one
-     * `(no scenario)` row. A SUB-COUNT like `phantom`: counted INSIDE `total` and
-     * `outOfBalance`, and surfaced separately so a reader recovers the scenario count as
-     * `total − phantom − suspense`.
-     */
     suspense: number;
 }
-/** A missing bucket — a rendered subject (a quality-check: `lint` or a runtime quality-check) and its count. */
 export interface MissingByQualityCheck {
     subject: string;
     count: number;
 }
-/**
- * The materialised evidence-obligation totals — the aggregate the markdown's Evidence
- * reconciliation table derives, carried AS DATA (the MATERIALISE ruling): the total, the
- * per-reconciliation-outcome breakdown, the out-of-balance sum, and the missing
- * split by rendered subject.
- */
 export interface EvidenceObligationTotals {
     total: number;
     byOutcome: Record<Outcome, number>;
     outOfBalance: number;
     missingByQualityCheck: MissingByQualityCheck[];
 }
-/**
- * The materialised lint tally (RMD-005) — the static-only evidenceObligation tally the markdown's
- * `### Lint evidence obligations` total line derives: how many `@lint` (static) evidence obligations
- * reconcile satisfied (balanced), out of the total raised. `summary.byOutcome` is
- * kind-agnostic and cannot express the static-only lint total, so it is materialised explicitly.
- */
-export interface LintTally {
+export interface FitnessTally {
     satisfied: number;
     total: number;
 }
-/**
- * The LEDGER-PURE part of the report summary — every totals field derived from the `Ledger`
- * alone. The assembler merges this with the census pass-throughs (`testVolume`, `staticChecks`)
- * and interleaves the keys in document order to build the full `Summary`.
- */
 export interface LedgerTally {
     scenarioReconciliations: ScenarioReconciliationTotals;
     evidenceObligations: EvidenceObligationTotals;
     pending: number;
-    lint: LintTally;
+    fitness: FitnessTally;
 }
-/**
- * Tally the LEDGER-PURE summary totals from the balance — the aggregate the markdown's
- * trial-balance table derives, carried AS DATA so a later render-from-saved-JSON rebuilds it with
- * zero computation (the MATERIALISE ruling). The census pass-throughs (`testVolume`,
- * `staticChecks`) are not Ledger-pure and are merged in by the assembler.
- */
 export declare function ledgerTally(balance: Ledger): LedgerTally;
-/**
- * The static-only lint tally (RMD-005) — how many `@lint` (static) evidence obligations reconcile
- * satisfied (`balanced`), out of the total raised. Byte-for-byte the markdown's
- * `countStaticEvidenceObligations` (`src/render/markdown.ts`), so slice 2 can read `satisfied` / `total`
- * with zero byte change. `summary.byOutcome` counts ALL kinds, so the static-only total is derived
- * here explicitly.
- */
-export declare function lintTally(balance: Ledger): LintTally;
-/** The canonical runtime quality-check order, in reading order. */
+export declare function fitnessTally(balance: Ledger): FitnessTally;
 export declare const RUNTIME_QUALITY_CHECKS: readonly RuntimeQualityCheck[];
-/**
- * The materialised runtime-observation totals — the aggregate the markdown's `### Test volume`
- * cut derives, carried AS DATA (the MATERIALISE ruling). Two keyings of the SAME posted credits:
- *   - `rawByRuntimeQualityCheck` — the per-quality-check evidence-observation total over ALL
- *     runtime credits, regardless of `@SCN` (the runtime axis; `lint` credits are not counted).
- *   - the per-scenario-kind counts — how many credits posted to a scenario's account
- *     (`onScenario`), to an invented `phantom-scenario` account (`onPhantomScenario`), and to the
- *     `suspense-scenario` account (`onSuspenseScenario`).
- * These jointly exhaust the raw total by construction:
- * `Σ rawByRuntimeQualityCheck = onScenario + onPhantomScenario + onSuspenseScenario`.
- */
 export interface RuntimeObservationTally {
-    /** Raw per-quality-check evidence-observation totals — ALL runtime credits, regardless of `@SCN`. */
     rawByRuntimeQualityCheck: Record<RuntimeQualityCheck, number>;
-    /**
-     * The runtime credit total — `Σ rawByRuntimeQualityCheck`, and equally
-     * `onScenario + onPhantomScenario + onSuspenseScenario` (3F-2231).
-     *
-     * RETURNED, not left for the caller to re-derive. The fold computed this sum and discarded it,
-     * so the assembler summed the same record again to fill `summary.testVolume` — the identical
-     * `reduce`, in an adapter, for a number the Ledger already knew. Two homes for one total is the
-     * shape this domain model exists to remove: the Ledger counts its own posted credits because it
-     * IS the balance, and a consumer asks rather than counts.
-     */
     total: number;
-    /** Runtime credits posted to a scenario's account (matched-attributed OR no-evidence-obligation). */
     onScenario: number;
-    /** Runtime credits posted to an invented `phantom-scenario` account (an `@SCN` no feature carries). */
     onPhantomScenario: number;
-    /** Runtime credits posted to the `suspense-scenario` account (citing no scenario, or broken). */
     onSuspenseScenario: number;
 }
-/**
- * Tally the runtime evidence observations from the Ledger — a FOLD OVER THE POSTED CREDITS
- * (@SCN-RMD-003), the credit-side twin of `ledgerTally`'s debit-side fold. It walks the POSTED
- * CREDITS on each Scenario Reconciliation row (@SCN-LDG-022) and reads each credit's account off
- * THE ROW IT POSTED TO — a scenario row ⇒ `onScenario`, a phantom row ⇒ `onPhantomScenario`,
- * the suspense row ⇒ `onSuspenseScenario` — summing the raw per-quality-check total in lockstep.
- *
- * It RE-DERIVES NOTHING and it does NOT classify: the reconciler already decided which account
- * every credit posts to (the account IS the citation, @SCN-LDG-022), so asking the row is asking
- * that decision. There is ONE place that decides what a credit is, so this tally can never disagree
- * with the verdict — the views (Test volume, the per-quality-check table) are projections of the
- * same rows, not a parallel opinion kept in step.
- *
- * Static check (`lint`) credits are SKIPPED, ON THE CHECK and never on the absence of a citation
- * (@SCN-RPT-023). A fitness credit now CITES its own scenario and posts to an ordinary
- * scenario row, so to a naive walk it is indistinguishable from a runtime credit by the account it
- * landed on; the `qualityCheck` is the only thing that tells them apart. Counting one would fold
- * the static axis into the Test volume, which must not see it at all.
- *
- * The per-scenario-kind counts feed `summary.testVolume` directly (`onScenario` counts credits
- * citing a scenario, INCLUDING no-evidence-obligation — so the 3-termed identity
- * `total = onScenario + onPhantomScenario + onSuspenseScenario` holds); `rawByRuntimeQualityCheck`
- * is the re-homed per-quality-check headline the by-level table renders.
- */
 export declare function runtimeObservationTally(ledger: Ledger): RuntimeObservationTally;
-/**
- * The materialised static-check totals — the STATIC-axis analogue of `RuntimeObservationTally`,
- * two counts read off the SAME posted static-check credits: `runningStaticCheckCount` (the volume of
- * distinct static checks that RAN — every static check a CI step invokes, whether or not its red is
- * that job's verdict, 3F-3280) and `uncitedStaticCheckCount` (how many of THOSE no scenario cites — a
- * static check running with nothing naming it, the mirror of a runtime `cites-no-scenario` credit).
- * The named count is IMPLICIT (`runningStaticCheckCount − uncitedStaticCheckCount`) and NOT carried:
- * every cited static check is already a reconciled `lint` sub-row and adds nothing the rows do not
- * already hold.
- *
- * THE SECOND COUNT IS A SUBSET OF THE FIRST, AND THAT IS WHAT MAKES THE IMPLICIT COUNT SOUND
- * (@SCN-LNT-033). Both take the same running membership rule, so the subtraction a reader performs
- * on the pair can never go below nil — it is a partition of the running set into the named and the
- * uncited, not two independently-drawn populations that happen to be printed on one line.
- */
-export interface StaticObservationTally {
-    /**
-     * The running static-check set volume — every check a step of the target's CI runs, whatever
-     * form the step takes (@SCN-USG-013): a check can be an action as readily as a command. A check
-     * whose red the job survives RAN and is counted (3F-3280); that it enforces nothing is its own
-     * row's watermelon (@SCN-LNT-032), not a smaller number here.
-     */
-    runningStaticCheckCount: number;
-    /** Running static checks NO `@lint` cites — a SUBSET of the count above (named is implicit). */
-    uncitedStaticCheckCount: number;
+export interface FitnessFunctionTally {
+    runningFitnessFunctionCount: number;
+    uncitedFitnessFunctionCount: number;
 }
-/**
- * Tally the static-check observations from the Ledger — a FOLD OVER THE POSTED static-check CREDITS
- * (3F-2118), the static-axis twin of `runtimeObservationTally`. It walks the POSTED CREDITS on each
- * Scenario Reconciliation row (@SCN-LDG-022), reads each credit off THE ROW IT POSTED TO, and — like
- * its runtime sibling — RE-DERIVES NOTHING: the reconciler already decided which account every credit
- * posts to, so this can never disagree with the verdict.
- *
- * `uncitedStaticCheckCount` is the count of RUNNING lint credits on the SUSPENSE row — the
- * no-evidence-obligation static checks the reconciler folded there (a static check running with no
- * scenario citing it, `cites-no-scenario` on the credit side). THE RUNNING QUALIFIER IS APPLIED
- * HERE RATHER THAN ASSUMED (@SCN-LNT-033): the uncited count is the running count's suspense-row
- * subset, so the two take one membership rule. A severed check nobody cites RAN, and is in both
- * (3F-3280). A BROKEN credit reaches the same row by a different route (@SCN-LNT-026) and is
- * excluded: it is a check a scenario DID name, which did not run.
- *
- * `runningStaticCheckCount` is the count of lint credits that RAN, across ALL rows. One care-move
- * the runtime axis does not need (see the block comment above):
- *   - FILTER TO WHAT RAN (`exists`): a missing (absent) or broken check STILL posts (posting is not
- *     classifying), but it did not run, so it is excluded — as the retired census's running-only
- *     `continue` excluded it. A severed check (wired, and the job's verdict does not depend on it)
- *     ran and is counted; its row reads the watermelon (3F-3280, ruled 2026-09-17).
- *
- * The named (implicit) count is `runningStaticCheckCount − uncitedStaticCheckCount`, and it cannot
- * go below nil: the uncited count is drawn from inside the running one.
- */
-export declare function staticObservationTally(ledger: Ledger): StaticObservationTally;
+export declare function fitnessFunctionTally(ledger: Ledger): FitnessFunctionTally;
 //# sourceMappingURL=ledger.d.ts.map

package/dist/domain/ledger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ledger.d.ts","sourceRoot":"","sources":["../../src/domain/ledger.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ledger.d.ts","sourceRoot":"","sources":["../../src/domain/ledger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAC3F,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAE1E,OAAO,KAAK,EAAE,mBAAmB,EAA8B,MAAM,cAAc,CAAC;AAEpF,MAAM,WAAW,MAAM;IACrB,uBAAuB,EAAE,sBAAsB,EAAE,CAAC;CACnD;AAED,wBAAgB,UAAU,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAI1D;AAED,wBAAgB,eAAe,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAE/D;AAED,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAEjE;AAED,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAErE;AAED,wBAAgB,aAAa,CAAC,cAAc,EAAE,MAAM,GAAG,0BAA0B,EAAE,CAIlF;AAED,wBAAgB,wBAAwB,CACtC,cAAc,EAAE,MAAM,GACrB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,0BAA0B,CAAA;CAAE,EAAE,CAMjE;AAED,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,qBAAqB,EAAE,qBAAqB,EAAE,CAAC;CAChD;AAED,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,uBAAuB,EAAE,4BAA4B,CAAC;IACtD,mBAAmB,EAAE,wBAAwB,CAAC;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,YAAY,CAAC;CACvB;AAID,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAQxD;AA8DD,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,CAM1D;AAED,eAAO,MAAM,sBAAsB,EAAE,SAAS,mBAAmB,EAAkD,CAAC;AAEpH,MAAM,WAAW,uBAAuB;IACtC,wBAAwB,EAAE,MAAM,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAAC;IAC9D,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,uBAAuB,CAwB/E;AAED,MAAM,WAAW,oBAAoB;IACnC,2BAA2B,EAAE,MAAM,CAAC;IACpC,2BAA2B,EAAE,MAAM,CAAC;CACrC;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,oBAAoB,CAczE"}