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

package/dist/domain/evidenceReconciliation.js

@@ -1,69 +1,11 @@
-/**
- * THE EVIDENCE RECONCILIATION — canon's Layer 1, *"the whole reconciliation: all Scenario
- * Reconciliations taken together"*, and **the key concept the domain models**
- * (`double-entry-manifesto.md`). This module is its home.
- *
- * IT ARRIVED HERE FROM `reconcile/` (3F-2232). After 3F-2202/2203/2204 that module held no domain
- * rule — but it was still a named layer beside the domain doing the concept's own work, which is
- * the shape `functional-domain-modelling.md` rejects: *"orchestration is thin composition, not a
- * named layer."* Constructing a concept is the concept's business. The module's residual tell was
- * already visible — it re-exported `isBalanced` / `hasPendingItems` / `hasBrokenEvidence` FROM
- * `domain/ledger` purely to preserve importers' paths, a shell around behaviour that had already
- * gone home. Every importer now points at the module that OWNS the symbol.
- *
- * (3F-2233 completes the move: the concept's TYPE, its `Summary`, and the factory that fuses this
- * fold with the summary tally. Today this module holds the fold alone.)
- *
- * The pure obligation-vs-observation join, keyed by one flat
- * `qualityCheck` (the two-axis `(kind, level)` grid collapsed). This module is THIN
- * COMPOSITION: the domain RULES it once held moved to the
- * concept modules that own them (3F-1994) — `reconcileEvidenceObligation` (the per-obligation
- * outcome) to `domain/qualityCheckReconciliation`, `verdictFor` / `reconcilingItemsOf` (the
- * account roll-up) to `domain/scenarioReconciliation`, `isBalanced` / `hasPendingItems` /
- * `hasBrokenEvidence` (the whole-run predicates) to `domain/ledger`. `reconcile` is the fold that
- * WALKS the inputs, CALLS those rules, and BUILDS the rows; it is the orchestration, not their home.
- *
- * POSTING-DESTINATION left too (3F-2202) — WHERE an entry lands is canon's own glossary group
- * ("### Posting") and now lives on `domain/posting`: `postingOf`, the one citation route over both
- * axes (plus the no-evidence-obligation-static-check arm). The by-name half is gone (3F-2590).
- * The fold no longer DECIDES a destination anywhere — it
- * asks the rule once per credit and files the answer. What remains is assembly: which rows exist,
- * in what order, holding which items.
- *
- * Per the slice design: for each evidence obligation a scenario raises (a reconciling
- * item), present+pass → satisfied; present+fail → failing; absent →
- * missing. `reconcileEvidenceObligation` branches on the `qualityCheck === "lint"`
- * watermelon discriminator (replacing the retired `kind === "static"` split): a `lint`
- * evidence obligation reconciles against a static-check evidence observation (exists+wired → satisfied;
- * exists+unwired → watermelon; absent → missing); a runtime evidence obligation
- * reconciles against a test result matched by (scnId, quality-check).
- *
- * The scenario VERDICT is binary (superseding the earlier prioritising
- * aggregate): a scenario is `balanced` IFF every required quality-check balances;
- * otherwise `out-of-balance`, carrying the LIST of EVERY non-balanced reconciling
- * item — no prioritisation, no picked winner ("missing beats failing" was a false
- * order that hid one of two genuinely different problems). The renderers list
- * every item.
- *
- * Parent: @SCN-LDG-001.
- */
-import { evidenceObligationPairsOf, 
-// THE PENDING PARTITION (3F-2204) — the two exact complements over a scenario's obligations.
-evidenceObligationsOf, pendingItemsOf, } from "../model.js";
-import { reconcileEvidenceObligation, 
-// THE CREDIT-SIDE AND DEGENERATE OUTCOME RULES (3F-2204) — what an entry reconciles TO, as
-// opposed to where it lands. `reconcile` asks; it no longer maps outcomes itself.
-noEvidenceObligationReconciliationsOf, citesUnknownScenarioReconciliationsOf, suspenseReconciliationsOf, noScnCodeReconciliations, unspecifiedRowReconciliations, } from "./qualityCheckReconciliation.js";
-import { ledgerTally, runtimeObservationTally, staticObservationTally, } from "./ledger.js";
-import { verdictFor, reconcilingItemsOf, 
-// THE ROW-SHAPE RULE (3F-2204) — the both-missing degeneration and its pending clause.
-qualityCheckReconciliationsOf, } from "./scenarioReconciliation.js";
-// THE POSTING RULE (3F-2202) — where an entry lands is canon's own glossary group, so it lives on
-// its own concept module. `reconcile` no longer decides a destination; it ASKS.
+import { evidenceObligationPairsOf, evidenceObligationsOf, pendingItemsOf, } from "./journal.js";
+import { reconcileEvidenceObligation, noEvidenceObligationReconciliationsOf, citesUnknownScenarioReconciliationsOf, suspenseReconciliationsOf, noScnCodeReconciliations, duplicateScnCodeReconciliationsOf, } from "./qualityCheckReconciliation.js";
+import { ledgerTally, runtimeObservationTally, fitnessFunctionTally, } from "./ledger.js";
+import { verdictFor, reconcilingItemsOf, qualityCheckReconciliationsOf, } from "./scenarioReconciliation.js";
 import { postingOf } from "./posting.js";
-// The `lint` quality-check's own predicate, asked here to NARROW what the posting rule has already
-// routed — see the fitness arm below.
-import { isStaticCheckObservation } from "../model.js";
+import { CORE_MESSAGES, CoreMessage } from "./messages.js";
+import { inEvidenceOrder } from "./evidenceOrder.js";
+import { isFitnessObservation } from "./journal.js";
 function citationIndex() {
     const byScn = new Map();
     const phantomIds = [];
@@ -80,164 +22,99 @@ function citationIndex() {
         phantomIds,
     };
 }
-/**
- * THE ONE ROUTING PASS (3F-2202). Every credit is routed ONCE, by THE posting rule
- * (`domain/posting`), into the structures the fold reads. `reconcile` no longer DECIDES a
- * destination anywhere — it asks, and files the answer.
- *
- * This replaces two passes that re-stated the SAME four routing decisions (the citation index and
- * the phantom-id scan) plus three stream filters. They agreed by copy-paste, not by construction:
- * either could have grown an arm alone and nothing would have redded — the identical anaemia
- * `evidenceObligationPairsOf` was extracted to cure.
- *
- * ITS OWN FUNCTION, extracted at @SCN-LNT-026 when the static axis gained its second suspense
- * reason and took `reconcile` past the `complexity` and `max-lines-per-function` ceilings. Routing
- * is one idea with a name and the fold below is another; nothing about what it decides moved, and
- * the exception list is untouched — an exception buys no headroom.
- */
+function routeFitnessCredit(observation, posting, citations, streams) {
+    if (posting.kind !== "suspense-scenario") {
+        citations.file(posting, observation);
+        return;
+    }
+    if (posting.posted === "broken" && isFitnessObservation(observation)) {
+        streams.brokenEvidence.push(observation);
+    }
+    else
+        streams.noEvidenceObligationFitnessFunctions.push(observation);
+}
+function routeRuntimeCredit(observation, posting, citations, streams) {
+    switch (posting.kind) {
+        case "scenario":
+        case "phantom-scenario": {
+            citations.file(posting, observation);
+            break;
+        }
+        case "suspense-scenario":
+            if (posting.posted === "broken")
+                streams.brokenEvidence.push(observation);
+            else
+                streams.uncited.push(observation);
+            break;
+    }
+}
 function routeCredits(evidenceObservations, scenarioIds) {
-    // THE CITATION INDEX holds BOTH axes now (@SCN-LNT-001): a fitness check's run cites the
-    // scenario that raises its obligation, so it files here exactly as a test result does.
     const citations = citationIndex();
-    // The three SUSPENSE streams, kept separate and each in observation order — the suspense row's
-    // item order (broken first, then uncited, then the no-evidence-obligation static checks) is row
-    // assembly, owned by the fold in `reconcile`, not a routing decision.
-    // BROKEN EVIDENCE FROM EITHER AXIS (@SCN-LNT-026). It was a runtime-only stream while `broken`
-    // was a runtime-only fact; a converted static check that did not run is the same fact about the
-    // same kind of absence, so it lands in the same stream and renders through the same section.
-    const brokenEvidence = [];
-    const uncited = [];
-    const noEvidenceObligationGuards = [];
+    const streams = {
+        brokenEvidence: [],
+        uncited: [],
+        noEvidenceObligationFitnessFunctions: [],
+    };
+    const { brokenEvidence, uncited, noEvidenceObligationFitnessFunctions } = streams;
     for (const o of evidenceObservations) {
-        // The union NARROW — `qualityCheck === "lint"` is the `EvidenceObservation` union's TYPE TAG,
-        // not a posting decision. Which axis a credit rides is read here; where it LANDS is the rule's,
-        // on both branches.
-        if (o.qualityCheck === "lint") {
-            const posting = postingOf(o, scenarioIds);
-            // THE SPLIT ON THIS AXIS TOO (@SCN-LNT-026), the twin of the runtime arm's below. Both
-            // reasons post to suspense because neither names a row, and they stay in separate streams
-            // because they are different facts with different remedies: a check nobody named RAN and
-            // wants an obligation written for it; a broken one never ran and wants its harness fixed.
-            //
-            // THE SECOND CLAUSE IS THE NARROW, NOT A SECOND DECISION. `postingOf` reaches `broken` on
-            // this axis only through `isStaticCheckObservation`, so asking the same predicate here
-            // cannot disagree with it — it re-states what the rule already settled in the one form the
-            // compiler accepts. Nothing falls between the two arms: an observation that somehow took
-            // neither still lands in the second, misfiled rather than vaporised.
-            if (posting.kind === "suspense-scenario") {
-                if (posting.posted === "broken" && isStaticCheckObservation(o))
-                    brokenEvidence.push(o);
-                else
-                    noEvidenceObligationGuards.push(o);
-            }
-            // A CITING run files into the citation index like any other credit (@SCN-LNT-001) —
-            // exactly one row, real or invented. There is no third destination left (3F-2590).
-            else
-                citations.file(posting, o);
+        if (o.qualityCheck === "fitness") {
+            routeFitnessCredit(o, postingOf(o, scenarioIds), citations, streams);
             continue;
         }
-        const posting = postingOf(o, scenarioIds);
-        switch (posting.kind) {
-            case "scenario":
-            case "phantom-scenario": {
-                // THE CITATION INDEX holds real AND invented ids alike — a phantom row reads its posted
-                // credits from here too, so both citation-routed destinations file together.
-                citations.file(posting, o);
-                break;
-            }
-            case "suspense-scenario":
-                // THE SPLIT (@SCN-LDG-017) — `broken` and `cites-nothing` both land on suspense because
-                // neither names a scenario, but they are different facts with different remedies (fix the
-                // harness vs add the @SCN), so their streams stay apart. The rule already told them apart.
-                if (posting.posted === "broken")
-                    brokenEvidence.push(o);
-                else
-                    uncited.push(o);
-                break;
-        }
+        routeRuntimeCredit(o, postingOf(o, scenarioIds), citations, streams);
     }
-    return { citations, brokenEvidence, uncited, noEvidenceObligationGuards };
+    return { citations, brokenEvidence, uncited, noEvidenceObligationFitnessFunctions };
 }
-/**
- * ONE REAL SCENARIO'S ROW — the debit side reconciled against the observed evidence, the credit
- * side's no-evidence-obligation items beside it, and the row assembled from both.
- *
- * ITS OWN FUNCTION, extracted at @SCN-LNT-027 (3F-3472) when the fourth population took `reconcile`
- * past the `max-lines-per-function` ceiling — `routeCredits`' own precedent, and the same seam.
- * Routing is one idea with a name, what each population RECONCILES to is another, and `reconcile`
- * is the ORDER they are filed in. Nothing any of them decides moved.
- */
 function scenarioRow(d, evidenceObservations, citations, evidenceObligationPairs) {
-    // THE PENDING PARTITION (@SCN-PND-004) — `pendingItemsOf` and `evidenceObligationsOf`
-    // are exact complements over the scenario's obligations, so nothing is dropped and nothing is
-    // counted twice. Rule + rationale: `domain/journal`.
     const pendingItems = pendingItemsOf(d);
-    // The DEBIT side — each NAMED obligation reconciled against the observed evidence.
-    const reconciledEvidenceObligations = evidenceObligationsOf(d.evidenceObligations).map((req) => reconcileEvidenceObligation(d.scnId, req, evidenceObservations));
-    // The CREDIT side — NO-EVIDENCE-OBLIGATION (@SCN-LDG-008): a credit citing THIS real scenario at a
-    // quality-check it never named. Rule + rationale: `domain/qualityCheckReconciliation`.
+    const reconciledEvidenceObligations = evidenceObligationsOf(d.evidenceObligations).map((obligation) => reconcileEvidenceObligation(d.scnId, obligation, evidenceObservations));
     const noEvidenceObligationItems = noEvidenceObligationReconciliationsOf(d.scnId, citations.creditsFor(d.scnId), evidenceObligationPairs);
-    // The row's SUB-ROWS, degenerating to one `both-missing` item when the row reconciled to
-    // nothing either way (@SCN-LDG-009). Rule + rationale: `domain/scenarioReconciliation`.
     const qualityCheckReconciliations = qualityCheckReconciliationsOf(reconciledEvidenceObligations, noEvidenceObligationItems, pendingItems);
     return {
         scnId: d.scnId,
         kind: "scenario",
         verdict: verdictFor(qualityCheckReconciliations),
-        // THE POSTED CREDITS (@SCN-LDG-022) — every credit CITING this scenario, whatever it
-        // reconciles to above. The citation index holds every citing credit, so this includes one citing a
-        // PENDING quality-check, which reconciles `no-evidence-obligation` (3F-1858 — it used to reconcile to
-        // NO ROW AT ALL, the false-green this posting made visible without fixing). It posts and is
-        // findable WHATEVER it reconciles to; posting is not classifying, and a misclassification
-        // must misfile an entry, never vaporise it. A fitness check's run is in here too and by the
-        // SAME route (3F-2590): it cites this scenario, so the citation index holds it like any other.
         evidenceObservations: citations.creditsFor(d.scnId),
-        // THE POSTED DEBITS (@SCN-LDG-023) — every obligation THIS scenario RAISES, in document
-        // order, keyed by quality-check. The debit half of the same posting: where a credit is
-        // routed by its citation, a debit needs no routing at all — the account IS the scenario.
-        // Includes a PENDING obligation, which partitioned off above and earns NO reconciled row: it
-        // posts ANYWAY. Posting is not classifying, on this side too.
         evidenceObligations: [...d.evidenceObligations],
         qualityCheckReconciliations,
         reconcilingItems: reconcilingItemsOf(qualityCheckReconciliations),
         pendingItems,
     };
 }
-/**
- * THE PHANTOM ROWS, assembled (@SCN-LDG-006). Extracted beside its siblings at 3F-3472; the
- * routing that produced `citations.phantomIds` is `routeCredits`', and unchanged.
- */
+function accountsByCode(scenarios) {
+    const byCode = new Map();
+    for (const scenario of scenarios) {
+        const sharers = byCode.get(scenario.scnId) ?? [];
+        sharers.push(scenario);
+        byCode.set(scenario.scnId, sharers);
+    }
+    return [...byCode.values()];
+}
+function duplicateScnCodeRow(sharers, citations) {
+    const scnId = sharers[0].scnId;
+    const evidenceObligations = sharers.flatMap((s) => s.evidenceObligations);
+    const items = duplicateScnCodeReconciliationsOf(evidenceObligations);
+    return {
+        scnId,
+        kind: "scenario",
+        verdict: verdictFor(items),
+        evidenceObservations: citations.creditsFor(scnId),
+        evidenceObligations,
+        qualityCheckReconciliations: items,
+        reconcilingItems: reconcilingItemsOf(items),
+        pendingItems: [],
+    };
+}
 function phantomScenarioRows(citations) {
     const rows = [];
-    // CREDIT-SIDE — PHANTOM scenarios (@SCN-LDG-006). One phantom Scenario Reconciliation per
-    // UNKNOWN cited id, in first-seen order, its Quality Check Reconciliation(s) carrying the
-    // outcome `cites-unknown-scenario` (and the evidence observation's locator, ruling Q5), verdict
-    // ALWAYS out-of-balance. Grouped AFTER the scenario rows.
-    //
-    // `phantomIds` was ROUTED ABOVE (3F-2202) — this block only ASSEMBLES the rows. The scan that
-    // stood here re-stated the citation index's four routing decisions verbatim, including the
-    // fail-safe arms (a BROKEN credit mints no phantom row; an uncited credit is suspense, never
-    // phantom); both now come from the one `postingOf` call.
     for (const scnId of citations.phantomIds) {
         const credits = citations.creditsFor(scnId);
-        // ASKED, not decided (3F-2204).
         const items = citesUnknownScenarioReconciliationsOf(credits);
         rows.push({
             scnId,
             kind: "phantom-scenario",
-            // ASKED, not restated (3F-2204, the close-gate read). Canon says a phantom row is ALWAYS
-            // out-of-balance, and it is — BY CONSTRUCTION, because a phantom row exists only where a
-            // credit minted it, so it always carries ≥1 `cites-unknown-scenario` item. Deriving the
-            // verdict from the items keeps that a consequence of the rule rather than a constant asserted
-            // beside it: a hardcoded verdict would go on reading `out-of-balance` even if the row ever
-            // came to carry none, which is precisely the drift the verdict/items lock-step exists to stop.
             verdict: verdictFor(items),
-            // The credits that CITE this invented scenario post to it — canon organises the ledger by
-            // "real or INVENTED scenario", so a phantom account holds its postings like any other.
             evidenceObservations: [...credits],
-            // A phantom account is MINTED BY A CREDIT — no scenario raises it, so nothing can have
-            // been named of it. Its debit side is empty by construction (@SCN-LDG-023); the asymmetry
-            // with the credit side is real, not an omission.
             evidenceObligations: [],
             qualityCheckReconciliations: items,
             reconcilingItems: items,
@@ -246,33 +123,15 @@ function phantomScenarioRows(citations) {
     }
     return rows;
 }
-/**
- * THE SUSPENSE ROW, assembled (@SCN-LDG-007) — nil rows or one. Extracted beside its siblings at
- * 3F-3472; what lands on it is `routeCredits`' decision, and unchanged.
- */
-function suspenseScenarioRows(brokenEvidence, uncited, noEvidenceObligationGuards) {
+function suspenseScenarioRows(brokenEvidence, uncited, noEvidenceObligationFitnessFunctions) {
     const rows = [];
-    // THE SUSPENSE ROW (@SCN-LDG-007) — every entry that names no scenario aggregates into ONE row
-    // (sentinel scnId `(no scenario)`), grouped LAST, verdict always out-of-balance.
-    //
-    // Its three streams were ROUTED by the posting rule (3F-2202); their OUTCOMES and their ORDER
-    // are the item concept's (3F-2204, `suspenseReconciliationsOf` — rule + rationale there). What
-    // is decided HERE is only whether the row exists at all: suspense is minted by a credit landing
-    // on it, so no credit means no row.
-    if (brokenEvidence.length > 0 || uncited.length > 0 || noEvidenceObligationGuards.length > 0) {
-        const items = suspenseReconciliationsOf(brokenEvidence, uncited, noEvidenceObligationGuards);
+    if (brokenEvidence.length > 0 || uncited.length > 0 || noEvidenceObligationFitnessFunctions.length > 0) {
+        const items = suspenseReconciliationsOf(brokenEvidence, uncited, noEvidenceObligationFitnessFunctions);
         rows.push({
-            scnId: "(no scenario)",
+            scnId: CORE_MESSAGES[CoreMessage.SuspenseScenarioId],
             kind: "suspense-scenario",
-            // ASKED, not restated — same reason as the phantom row. The `if` above is what makes this
-            // out-of-balance by construction: the row exists only when a credit landed on it.
             verdict: verdictFor(items),
-            // The credits citing NO scenario post here (@SCN-LDG-022) — the uncited, the broken (it
-            // named no test, so it cites nothing whatever scnId it structurally carries), and the
-            // no-evidence-obligation static checks. With the citation index this exhausts the credit stream.
-            evidenceObservations: [...brokenEvidence, ...uncited, ...noEvidenceObligationGuards],
-            // Suspense is MINTED BY A CREDIT too — it raises nothing, so it names nothing
-            // (@SCN-LDG-023). It can therefore carry no Pending Item either.
+            evidenceObservations: [...brokenEvidence, ...uncited, ...noEvidenceObligationFitnessFunctions],
             evidenceObligations: [],
             qualityCheckReconciliations: items,
             reconcilingItems: items,
@@ -281,32 +140,15 @@ function suspenseScenarioRows(brokenEvidence, uncited, noEvidenceObligationGuard
     }
     return rows;
 }
-/**
- * THE UNCODED-WORK ROWS, assembled (@SCN-LDG-021). Extracted beside its siblings at 3F-3472.
- */
 function untaggedScenarioRows(untaggedScenarios) {
     const rows = [];
-    // UNCODED WORK (@SCN-LDG-021) — a scenario carrying no @SCN. It is REAL and ORDINARY
-    // (`kind: "scenario"`, never phantom or suspense: it exists, and cucumber runs it); what is
-    // absent is the CODE its obligation needs in order to link to an observation. It gets its own
-    // out-of-balance row so the verdict can see it at all.
-    //
-    // The item's outcome, its scenario-scope shape and the synthesised `{}` obligation it carries
-    // are the item concept's (3F-2204, `noScnCodeReconciliations` — rule + rationale there).
     for (const name of untaggedScenarios) {
         const items = noScnCodeReconciliations();
         rows.push({
-            // The scenario's NAME is its only handle — it has no code. (Precedent: the suspense row's
-            // "(no scenario)" sentinel; `featureCodeOf` falls back to the raw id when it cannot parse.)
             scnId: name,
             kind: "scenario",
-            // ASKED, not restated — `noScnCodeReconciliations` always returns the one `no-scn-code`
-            // item, so the verdict follows from it rather than being asserted alongside it.
             verdict: verdictFor(items),
-            // An untagged scenario carries no @SCN, so no credit can cite it — nothing can post here.
             evidenceObservations: [],
-            // It reaches the ledger by NAME, carrying no parsed obligations — so it posts no debits
-            // either (@SCN-LDG-023).
             evidenceObligations: [],
             qualityCheckReconciliations: items,
             reconcilingItems: items,
@@ -315,184 +157,47 @@ function untaggedScenarioRows(untaggedScenarios) {
     }
     return rows;
 }
-/**
- * THE ROWS A CONFIGURED ROW WITH NO SCENARIO EARNS, assembled (@SCN-LNT-027, 3F-3472).
- */
-function unspecifiedFitnessRowRows(unspecifiedFitnessRows) {
-    const rows = [];
-    // A CONFIGURED ROW THE CORPUS CARRIES NO SCENARIO FOR (@SCN-LNT-027, 3F-3472) — a check the
-    // target's manifest declares and nothing in its corpus specifies. The obligations travel with
-    // the scenarios, so such a row raised NOTHING: it was not `missing`, not phantom, not suspense,
-    // and a tree carrying one reconciled balanced at exit 0 over a check declared and never written.
-    // `features/fitness-checks.feature` promises the opposite in terms — "a row whose scenario the
-    // corpus does not carry as an Evidence Obligation nothing observed" — and this is that promise.
-    //
-    // THE PRECEDENT IS UNCODED WORK, three lines up: a fact the ordinary obligation path cannot raise
-    // reaches the ledger by a reading of its own and gets its own out-of-balance row so the verdict
-    // can see it at all. There the CORPUS supplies a row the obligations cannot; here the MANIFEST
-    // does.
-    //
-    // THE ROW IS NOT IN `scenarioIds`, WHICH IS WHAT MAKES IT UNDISCHARGEABLE. That set was built
-    // from `scenarios` alone and is not widened here, so a credit citing this row's code still mints
-    // a PHANTOM row (@SCN-LDG-006, @SCN-LNT-009) and a broken credit still lands on SUSPENSE — and
-    // there is no route left by which any credit settles this debit. Synthesising a `Scenario` for
-    // the row instead would have put it INTO that set, so a run whose CI step cited a declared-but-
-    // unwritten check would reconcile BALANCED: a new false green, in the case the phantom row
-    // already covers.
-    for (const row of unspecifiedFitnessRows) {
-        const items = unspecifiedRowReconciliations(row.characteristic);
-        rows.push({
-            scnId: row.scnId,
-            kind: "scenario",
-            // ASKED, not restated — the phantom and suspense rows' rule. `unspecifiedRowReconciliations`
-            // always returns the one `missing` item, so the verdict follows from it.
-            verdict: verdictFor(items),
-            // No scenario carries this code, so the citation router posts no credit here — see above.
-            evidenceObservations: [],
-            // THE DEBIT IS REAL AND IS POSTED (@SCN-LDG-023). Unlike the untagged row above, which
-            // reaches the ledger by name and names no check, this row names exactly one characteristic:
-            // that is the obligation, and the manifest is what raised it.
-            evidenceObligations: [...items.map((item) => item.evidenceObligation)],
-            qualityCheckReconciliations: items,
-            reconcilingItems: items,
-            pendingItems: [],
-        });
-    }
-    return rows;
-}
-export function reconcile(scenarios, evidenceObservations, untaggedScenarios = [], 
-/**
- * The CONFIGURED ROWS the target's corpus carries no scenario for (@SCN-LNT-027, 3F-3472) — the
- * fourth population, minted below.
- *
- * IT DEFAULTS, WHERE THE TWO GATES BELOW DELIBERATELY DO NOT (3F-2875). A gate that defaults is a
- * gate a caller can forget and thereby CHANGE what the summary claims. This is a population, and
- * an omitted population is indistinguishable from an empty one in the only way that matters:
- * both mint no rows, and neither says anything about a manifest. Every caller that constructs
- * `Scenario[]` by hand has no manifest to read rows from, which is `untaggedScenarios`' own
- * argument for the default it already carries.
- */
-unspecifiedFitnessRows = []) {
-    // THE OBLIGATION SIDE, prepared once — the three sets the posting rule and the outcome rules read.
-    // Each is already the MODEL's own rule (never re-derived here), and each is built ONCE and
-    // shared, so no two consumers can drift: `scenarioIds` is which scenarios exist,
-    // and `evidenceObligationPairs` is what they name at each quality-check (3F-1858).
+export function reconcile(scenarios, evidenceObservations, untaggedScenarios = []) {
     const scenarioIds = new Set(scenarios.map((d) => d.scnId));
-    // The NAMED pairs — the model's rule, built ONCE and shared with the census (3F-1858).
-    // Pending obligations are excluded: a pending obligation names nothing.
     const evidenceObligationPairs = evidenceObligationPairsOf(scenarios);
-    // THE ONE ROUTING PASS (3F-2202) — asked of the posting rule, in one place, and read back as
-    // four streams. What each of them then RECONCILES to is the fold's, below.
-    const { citations, brokenEvidence, uncited, noEvidenceObligationGuards } = routeCredits(evidenceObservations, scenarioIds);
-    // THE ORDER THE POPULATIONS ARE FILED IN IS THE LEDGER'S GROUPING, and it is the whole of what
-    // this function decides now: the real scenario rows, then the phantom rows a credit invented,
-    // then the one suspense row, then uncoded work, then the configured rows no scenario specifies.
+    const observations = inEvidenceOrder(evidenceObservations);
+    const { citations, brokenEvidence, uncited, noEvidenceObligationFitnessFunctions } = routeCredits(observations, scenarioIds);
     return {
         scenarioReconciliations: [
-            ...scenarios.map((d) => scenarioRow(d, evidenceObservations, citations, evidenceObligationPairs)),
+            ...accountsByCode(scenarios).map((sharers) => sharers.length === 1
+                ? scenarioRow(sharers[0], observations, citations, evidenceObligationPairs)
+                : duplicateScnCodeRow(sharers, citations)),
             ...phantomScenarioRows(citations),
-            ...suspenseScenarioRows(brokenEvidence, uncited, noEvidenceObligationGuards),
+            ...suspenseScenarioRows(brokenEvidence, uncited, noEvidenceObligationFitnessFunctions),
             ...untaggedScenarioRows(untaggedScenarios),
-            ...unspecifiedFitnessRowRows(unspecifiedFitnessRows),
         ],
     };
 }
-/**
- * Materialise the 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). THIN COMPOSITION (3F-2000): the LEDGER-PURE totals
- * (`scenarioReconciliations`, `evidenceObligations`, `pending`, `lint`) come from `ledgerTally`
- * — the Ledger owns its own totals ("the summary is its totals") — and are MERGED here with the
- * census pass-throughs (`testVolume`, `staticChecks`), which are NOT Ledger-pure. The keys are
- * assembled in DOCUMENT ORDER (…, testVolume?, staticChecks?, lint) so the JSON stays
- * byte-identical.
- */
-export function summaryOf(ledger, withRuntimeObservations, withStaticChecks) {
+export function summaryOf(ledger, withRuntimeObservations, withFitnessFunctions) {
     const tally = ledgerTally(ledger);
-    // The runtime evidence-observation totals are a FOLD OVER THE LEDGER (@SCN-RMD-003, 3F-2102) —
-    // the Ledger counts its own posted credits; the parallel census is RETIRED. `testVolume` and the
-    // re-homed `rawByRuntimeQualityCheck` derive from THIS fold. The `withRuntimeObservations` flag is
-    // now only the GATE (is the runtime-observation axis in play?) — the caller no longer threads a
-    // census object at all (the assembler folds the Ledger it already has).
     const observations = runtimeObservationTally(ledger);
-    // The static-check totals are a FOLD OVER THE LEDGER too (3F-2118) — the Ledger counts its own
-    // posted static-check credits; the parallel static census is RETIRED. `staticChecks` derives from
-    // THIS fold. The `withStaticChecks` flag is now only the GATE (is the static-check axis in play?) —
-    // the caller no longer threads a census object at all (the assembler folds the Ledger it holds).
-    const staticChecks = staticObservationTally(ledger);
+    const fitnessFunctions = fitnessFunctionTally(ledger);
     return {
         scenarioReconciliations: tally.scenarioReconciliations,
         evidenceObligations: tally.evidenceObligations,
         pending: tally.pending,
-        // The runtime test-volume kind-counts (RMD-005), materialised only when the evidenceObservations
-        // read is threaded. The surface reads the fold's per-scenario-kind counts DIRECTLY (an identity
-        // — the fold already groups by the scenario-kind the credit posted to). `onScenario` is every
-        // credit posted to a scenario's account, which INCLUDES no-evidence-obligation as a subset
-        // (matched-pair + no-evidence-obligation) — a DIFFERENT number from the reconciliation-matched-attributed
-        // (the retired section's `attributed[]` sum, which excluded no-evidence-obligation). Keeping no-evidence-obligation
-        // inside this count preserves the 3-termed identity `totalEvidenceObservations = onScenario +
-        // onPhantomScenario + onSuspenseScenario` (no-evidence-obligation is a subset here, NOT a 4th identity term)
-        // — the same shape the markdown's `### Test volume` line derives. `onPhantomScenario` /
-        // `onSuspenseScenario` are the credits posted to the phantom / suspense accounts (suspense
-        // includes `broken`).
         ...(withRuntimeObservations
             ? {
                 testVolume: {
-                    // ASKED, not re-derived (3F-2231) — the Ledger's fold computes this total and now
-                    // returns it. The assembler summed the same record again for it, which is an adapter
-                    // owning a model number by copied arithmetic.
                     totalEvidenceObservations: observations.total,
                     onScenario: observations.onScenario,
                     onPhantomScenario: observations.onPhantomScenario,
                     onSuspenseScenario: observations.onSuspenseScenario,
                 },
-                // The re-homed raw per-quality-check headline (@SCN-RMD-003) — a materialised Ledger
-                // fold, sibling of `testVolume` and present on the SAME gate.
                 rawByRuntimeQualityCheck: observations.rawByRuntimeQualityCheck,
             }
             : {}),
-        // The static-check kind-counts (RMD-005), materialised only when the static-check axis is in
-        // play — now a FOLD OVER THE LEDGER (3F-2118, `staticObservationTally`), symmetric with the
-        // runtime `testVolume` fold. The surface keeps the census shape exactly
-        // (`{ runningStaticCheckCount, uncitedStaticCheckCount }`; named is implicit). The member detail
-        // lives in the rows (named → each scenario's `@lint` sub-row; no-evidence-obligation → the suspense
-        // row) — there is no census section (2.4).
-        ...(withStaticChecks ? { staticChecks } : {}),
-        // The static-only lint tally (RMD-005), a LEDGER-PURE derive from `ledgerTally` — LAST key in
-        // document order (after the census pass-throughs).
-        lint: tally.lint,
+        ...(withFitnessFunctions ? { fitnessFunctions } : {}),
+        fitness: tally.fitness,
     };
 }
-/**
- * BUILD the Evidence Reconciliation from the journal — THE FACTORY (3F-2233).
- *
- * Journal inputs in, whole concept out: the fold posts every entry into the Ledger, and the tally
- * totals it. They are ONE act, not two stages a caller sequences — which is the point. While
- * `reconcile()` and `buildSummary()` were separate, an adapter held a Ledger and derived its own
- * totals, so "the procedure can sum the wrong rows" (`why-ddd-for-spec-controller.md`) was a
- * REACHABLE state. Here there is no such seam: you cannot obtain a summary except from the concept
- * that owns the rows it counts.
- *
- * The two flags are GATES, not data — they state whether the runtime-observation and static-check
- * axes are in play for this run; the counts themselves are always folded from the Ledger.
- *
- * WHY THE TRAILING THREE ARE REQUIRED AND CARRY NO DEFAULTS (3F-2875). A gate that defaults to
- * `false` is a gate a caller can forget to state, and forgetting it CHANGES THE REPORT — the
- * summary then claims neither axis is in play, silently and plausibly. That is not a hypothetical:
- * when the defaults were removed, eleven call sites turned out to have been leaning on them. Every
- * one wanted exactly what it had been getting, so nothing moved; what changed is that each now says
- * so. A default is the wrong shape for an argument whose omission is indistinguishable from a
- * deliberate `false`.
- */
-export function evidenceReconciliationOf(scenarios, evidenceObservations, untaggedScenarios, withRuntimeObservations, withStaticChecks, 
-/**
- * The CONFIGURED ROWS the corpus carries no scenario for (@SCN-LNT-027, 3F-3472) — passed
- * through to `reconcile`, which mints one row apiece. It defaults for the reason given there, and
- * that reason is NOT the trailing three's: a population omitted mints nothing and claims nothing,
- * where a gate omitted silently changes what the summary says is in play.
- */
-unspecifiedFitnessRows = []) {
-    const ledger = reconcile(scenarios, evidenceObservations, untaggedScenarios, unspecifiedFitnessRows);
-    return { summary: summaryOf(ledger, withRuntimeObservations, withStaticChecks), ledger };
+export function evidenceReconciliationOf(scenarios, evidenceObservations, untaggedScenarios, withRuntimeObservations, withFitnessFunctions) {
+    const ledger = reconcile(scenarios, evidenceObservations, untaggedScenarios);
+    return { summary: summaryOf(ledger, withRuntimeObservations, withFitnessFunctions), ledger };
 }
 //# sourceMappingURL=evidenceReconciliation.js.map