@3f-consulting/spec-controller-core 0.1.0-alpha.8 → 0.1.0-alpha.80

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): {
+    readonly scenarioReconciliations: readonly ScenarioReconciliation[];
+}
+export declare function isBalanced(ledger: Ledger): boolean;
+export declare function hasPendingItems(ledger: Ledger): boolean;
+export declare function hasBrokenEvidence(ledger: Ledger): boolean;
+export declare function hasNothingToReconcile(ledger: Ledger): boolean;
+export declare function brokenItemsOf(ledger: Ledger): QualityCheckReconciliation[];
+export declare function fitnessReconciliationsOf(ledger: 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;
+    readonly total: number;
+    readonly balanced: number;
+    readonly outOfBalance: number;
+    readonly phantom: number;
+    readonly 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;
+    readonly subject: string;
+    readonly 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[];
+    readonly total: number;
+    readonly byOutcome: Record<Outcome, number>;
+    readonly outOfBalance: number;
+    readonly missingByQualityCheck: readonly 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 {
-    satisfied: number;
-    total: number;
+export interface FitnessTally {
+    readonly satisfied: number;
+    readonly 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;
+    readonly scenarioReconciliations: ScenarioReconciliationTotals;
+    readonly evidenceObligations: EvidenceObligationTotals;
+    readonly pending: number;
+    readonly 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 ledgerTally(ledger: Ledger): LedgerTally;
+export declare function fitnessTally(ledger: 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;
+    readonly rawByRuntimeQualityCheck: Record<RuntimeQualityCheck, number>;
+    readonly total: number;
+    readonly onScenario: number;
+    readonly onPhantomScenario: number;
+    readonly 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 {
+    readonly runningFitnessFunctionCount: number;
+    readonly 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;AAGpF,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,uBAAuB,EAAE,SAAS,sBAAsB,EAAE,CAAC;CACrE;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAIlD;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,0BAA0B,EAAE,CAI1E;AAED,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,GACb;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,0BAA0B,CAAA;CAAE,EAAE,CAMjE;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC5C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,qBAAqB,EAAE,SAAS,qBAAqB,EAAE,CAAC;CAClE;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,uBAAuB,EAAE,4BAA4B,CAAC;IAC/D,QAAQ,CAAC,mBAAmB,EAAE,wBAAwB,CAAC;IACvD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;CAChC;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAQvD;AA8DD,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAMzD;AAED,eAAO,MAAM,sBAAsB,EAAE,SAAS,mBAAmB,EAEhE,CAAC;AAEF,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAAC;IACvE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;CACrC;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,uBAAuB,CAwB/E;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,2BAA2B,EAAE,MAAM,CAAC;IAC7C,QAAQ,CAAC,2BAA2B,EAAE,MAAM,CAAC;CAC9C;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,oBAAoB,CAczE"}