@sigloch/graphcode-client 1.6.0 → 3.0.0

package/dist/index.d.ts

@@ -18,6 +18,5 @@
  */
 export { HOST_SOCK_BASENAME, callHost, type ShimRequest, type ShimResponse, } from './host-client.js';
 export { MARKDOWN_VIEWS, VIEW_FILENAMES, type MarkdownView } from './view-catalog.js';
-export { GRAPHCODE_INCOSE_SCOPE, PHASE_GATE_RULES, PHASE_GATE_LABELS, PHASE_GATE_CREATIONS, IMPL_GATE_PHASE, IMPL_GATE_MILESTONES, IMPL_GATE_RULES, ABSENT_CREATION_PROVIDER, creationBlockingMsg, summarizeReadiness, computeReadiness, scoreReadiness, getFamilyRuleIds, type IncoseScope, type CreationCurrency, type CreationCurrencyProvider, type ReadinessDimension, type ReadinessGate, type ReadinessReport, } from './readiness.js';
-export { NEUTRAL_COMPLETENESS, COMPLETENESS_SLICES, scoreCompleteness, typeOf, type CGraph, type CNode, GateCompleteness, type CompletenessLeg, } from './readiness-completeness.js';
+export { GRAPHCODE_INCOSE_SCOPE, MARK_LABELS, computeMarks, countByStage, summarizeReadiness, computeReadiness, scoreReadiness, getFamilyRuleIds, type IncoseScope, type ReadinessMark, type StageCount, type ReadinessReport, } from './readiness.js';
 export * from './panels.js';

package/dist/index.js

@@ -18,6 +18,5 @@
  */
 export { HOST_SOCK_BASENAME, callHost, } from './host-client.js';
 export { MARKDOWN_VIEWS, VIEW_FILENAMES } from './view-catalog.js';
-export { GRAPHCODE_INCOSE_SCOPE, PHASE_GATE_RULES, PHASE_GATE_LABELS, PHASE_GATE_CREATIONS, IMPL_GATE_PHASE, IMPL_GATE_MILESTONES, IMPL_GATE_RULES, ABSENT_CREATION_PROVIDER, creationBlockingMsg, summarizeReadiness, computeReadiness, scoreReadiness, getFamilyRuleIds, } from './readiness.js';
-export { NEUTRAL_COMPLETENESS, COMPLETENESS_SLICES, scoreCompleteness, typeOf, GateCompleteness, } from './readiness-completeness.js';
+export { GRAPHCODE_INCOSE_SCOPE, MARK_LABELS, computeMarks, countByStage, summarizeReadiness, computeReadiness, scoreReadiness, getFamilyRuleIds, } from './readiness.js';
 export * from './panels.js';

package/dist/panels.d.ts

@@ -14,29 +14,12 @@
  *
  * @author andreas@siglochconsulting
  */
-import type { ReadinessReport, ReadinessGate, CreationCurrency, CreationCurrencyProvider } from './readiness.js';
+import type { ReadinessReport, ReadinessMark } from './readiness.js';
 import type { RuleViolation, LiveUpdateEvent } from '@sigloch/contracts/harness';
 import type { Graph } from '@sigloch/graph-api-core';
-export interface GatePanel {
-    id: string;
-    label: string;
-    passed: boolean;
-    score: number;
-    /** The blocking elements — the drill-down behind the traffic light. */
-    blocking: string[];
-    /**
-     * Structural completeness (CR-GC-250): ONE value per gate (covered/total) for
-     * the panel; `missing[]` is the on-click per-leg drill-down, same mechanic as
-     * `blocking`. REQ-completeness-single-value.
-     */
-    completeness: ReadinessGate['completeness'];
-}
 export interface ReadinessPanel {
-    compliancePct: number;
-    totalElements: number;
-    elementsWithErrors: number;
-    phaseGates: GatePanel[];
-    implGates: GatePanel[];
+    /** SRR, PDR, CDR, TRR, Bau — reached or not, with the findings that hold each (CR-SM-395). */
+    marks: ReadinessMark[];
 }
 export declare function readinessPanel(report: ReadinessReport): ReadinessPanel;
 export interface RecommendationItem {
@@ -85,11 +68,12 @@ export interface ViolationGroup {
 export declare function groupViolations(violations: RuleViolation[], elementLimit?: number): ViolationGroup[];
 export type Freshness = 'live' | 'stale' | 'absent';
 /**
- * Two artifact kinds with TWO distinct staleness mechanisms (CR-GC-222):
+ * Two artifact kinds (CR-GC-222):
  * - `render`   — a deterministic `docs/views/*.md` projection; stale via file mtime vs graph.
- * - `analysis` — judgment work (FMEA/ConOps/Trade/…); stale when the analyzed SCOPE moved,
- *                NEVER via mtime. The single `staleVsGraph` boolean was the defect (it applied
- *                an mtime check to analyses that don't refresh on mtime).
+ * - `analysis` — judgment work (FMEA/ConOps/Trade/Assumption Review); carried out or not. Its
+ *                only record is the stamp under `SYS.attributes.analysisFreshness` — there is no
+ *                "stale" for an analysis (CR-SM-395: the currency computation is gone; it ran
+ *                without effect in the product path since CR-GC-259).
  */
 export type ArtifactKind = 'render' | 'analysis';
 /** INCOSE/SE-standard vs graphcode-specific — so non-INCOSE rows are not mislabeled as INCOSE. */
@@ -103,15 +87,16 @@ export interface ArtifactCatalogEntry {
 }
 /**
  * The canonical INCOSE-tab artifact catalog (readiness-artifact-model.md §6). Renders are the
- * deterministic CR-GC-220 views; the 5 analysis ids are exactly CR-GC-221's creation keys
- * (`conops`/`assumption-review`/`fmea`/`trade`/`implplan`). `irr` is renamed to "Assumption
- * Review" and grouped graphcode-specific (it is not a standard INCOSE artifact).
+ * deterministic CR-GC-220 views; the four analysis ids are exactly contracts' `AnalysisArtifactId`
+ * (`conops`/`assumption-review`/`fmea`/`trade`). `irr` is renamed to "Assumption Review" and
+ * grouped graphcode-specific (it is not a standard INCOSE artifact).
+ *
+ * CR-SM-395: the implementation plan is a RENDER. The plan is the set of open CRs, not a stamp;
+ * its document (`implplan.md`) is a projection of the CR/MS structure like any other view.
  */
 export declare const ARTIFACT_CATALOG: readonly ArtifactCatalogEntry[];
 /** Classify a RENDER artifact. `exists` = doc present; `staleVsGraph` = graph changed since render. */
 export declare function artifactFreshness(exists: boolean, staleVsGraph: boolean): Freshness;
-/** Classify an ANALYSIS artifact from its scope-currency — 🟢 current / 🟡 stale / 🔴 absent. */
-export declare function analysisFreshness(currency: CreationCurrency): Freshness;
 export interface ArtifactStatus {
     id: string;
     label: string;
@@ -119,15 +104,13 @@ export interface ArtifactStatus {
     group: ArtifactGroup;
     freshness: Freshness;
 }
-/** One artifact's freshness signal: render rows carry exists/staleVsGraph, analysis rows carry currency. */
+/** One artifact's signal. An analysis row reads `exists` only: the stamp is there, or it is not. */
 export interface ArtifactSignal {
     id: string;
-    /** RENDER: a materialized doc is present. */
+    /** RENDER: a materialized doc is present. ANALYSIS: the analysis is on record (stamp present). */
     exists?: boolean;
-    /** RENDER: the graph changed since the doc was generated (mtime). */
+    /** RENDER only: the graph changed since the doc was generated (mtime). */
     staleVsGraph?: boolean;
-    /** ANALYSIS: scope-currency of the judgment work (the ONLY signal read for analysis rows). */
-    currency?: CreationCurrency;
 }
 export interface ArtifactsPanel {
     artifacts: ArtifactStatus[];
@@ -136,39 +119,19 @@ export interface ArtifactsPanel {
     absentCount: number;
 }
 /**
- * Shape artifact freshness signals into the tab view-model. The catalog decides each row's
- * kind/group/label; the kind decides WHICH mechanism classifies it — render rows go through
- * the mtime path, analysis rows through the scope-currency path (so a creation is NEVER
- * classified by mtime, even if a caller passes `staleVsGraph` — it is ignored). Renderer groups
- * by `group` to show "INCOSE / SE-standard" and "graphcode-specific" separately.
+ * Shape artifact signals into the tab view-model. The catalog decides each row's
+ * kind/group/label; the kind decides how it is classified — a render row by mtime, an analysis
+ * row by presence alone (`staleVsGraph` is ignored there: an analysis is NEVER classified by
+ * mtime). Renderer groups by `group` to show "INCOSE / SE-standard" and "graphcode-specific"
+ * separately.
  */
 export declare function artifactsPanel(signals: ArtifactSignal[]): ArtifactsPanel;
 /**
- * Build the CreationCurrencyProvider that CR-GC-221's readiness scorer consumes (CR-GC-222
- * delivers the `analysis`-currency to 221). Maps each creation id → its scope-currency; an
- * unknown/never-analyzed creation reads as 🔴 absent.
+ * The signals of the four analysis artifacts, read off the graph: an analysis is on record iff
+ * its stamp under `SYS.attributes.analysisFreshness.<id>` is valid (CR-SM-227 — the same
+ * condition AF-01..04 check). No comparison against the live graphVersion (CR-SM-395).
  */
-export declare function creationCurrencyProvider(analysis: Array<{
-    id: string;
-    currency: CreationCurrency;
-}>): CreationCurrencyProvider;
-/**
- * Real scope-currency for the 5 analysis artifacts (CR-SM-227) — replaces the
- * `ABSENT_CREATION_PROVIDER` placeholder (CR-GVE-225 F10: GVE showed `absent`
- * correctly because no scope-currency check existed yet). Reads the
- * `graphVersion` freshness stamp AF-01..05 (contracts) check for presence of
- * (`SYS.attributes.analysisFreshness.<id>`) and classifies it against the
- * live graphVersion: missing/invalid stamp → absent; stamp older than the
- * current graphVersion → stale; stamp at (or ahead of) it → current.
- * Grober Graph-Versions-Stempel only, no scope-hash — CR-SM-227's declared
- * first-cut limitation ("Achtung" section), not full scope-precise staleness.
- */
-export declare function computeAnalysisCurrency(graph: Pick<Graph, 'nodes'>, currentGraphVersion: number): Array<{
-    id: string;
-    currency: CreationCurrency;
-}>;
-/** Convenience: build the real CreationCurrencyProvider straight off the graph + its live version. */
-export declare function analysisCreationCurrencyProvider(graph: Pick<Graph, 'nodes'>, currentGraphVersion: number): CreationCurrencyProvider;
+export declare function analysisSignals(graph: Pick<Graph, 'nodes'>): ArtifactSignal[];
 export interface ImpactPanel {
     root: string;
     blastRadiusNodes: number;

package/dist/panels.js

@@ -1,15 +1,6 @@
 import { AnalysisArtifactId, AnalysisFreshnessStampSchema } from '@sigloch/contracts/se';
-function toGatePanel(g) {
-    return { id: g.id, label: g.label, passed: g.passed, score: g.score, blocking: g.blocking, completeness: g.completeness };
-}
 export function readinessPanel(report) {
-    return {
-        compliancePct: Math.round(report.compliance.score * 1000) / 10,
-        totalElements: report.compliance.totalElements,
-        elementsWithErrors: report.compliance.elementsWithErrors,
-        phaseGates: report.phaseGates.map(toGatePanel),
-        implGates: report.implGates.map(toGatePanel),
-    };
+    return { marks: report.marks };
 }
 const SEVERITY_RANK = { error: 0, warning: 1, info: 2 };
 export function recommendationsPanel(violations, limit = 5) {
@@ -70,9 +61,12 @@ export function groupViolations(violations, elementLimit = 10) {
 }
 /**
  * The canonical INCOSE-tab artifact catalog (readiness-artifact-model.md §6). Renders are the
- * deterministic CR-GC-220 views; the 5 analysis ids are exactly CR-GC-221's creation keys
- * (`conops`/`assumption-review`/`fmea`/`trade`/`implplan`). `irr` is renamed to "Assumption
- * Review" and grouped graphcode-specific (it is not a standard INCOSE artifact).
+ * deterministic CR-GC-220 views; the four analysis ids are exactly contracts' `AnalysisArtifactId`
+ * (`conops`/`assumption-review`/`fmea`/`trade`). `irr` is renamed to "Assumption Review" and
+ * grouped graphcode-specific (it is not a standard INCOSE artifact).
+ *
+ * CR-SM-395: the implementation plan is a RENDER. The plan is the set of open CRs, not a stamp;
+ * its document (`implplan.md`) is a projection of the CR/MS structure like any other view.
  */
 export const ARTIFACT_CATALOG = [
     // Renders — INCOSE/SE-standard deterministic views (mtime-classified).
@@ -86,11 +80,11 @@ export const ARTIFACT_CATALOG = [
     { id: 'intplan', label: 'Integration & Test Plan', kind: 'render', group: 'incose' },
     { id: 'changelog', label: 'Change Log', kind: 'render', group: 'incose' },
     { id: 'references', label: 'Requirements Traceability', kind: 'render', group: 'incose' },
-    // Creations — judgment work (scope-classified, NEVER mtime).
+    { id: 'implplan', label: 'Implementation Plan', kind: 'render', group: 'incose' },
+    // Analyses — judgment work (carried out or not, NEVER mtime).
     { id: 'conops', label: 'Concept of Operations', kind: 'analysis', group: 'incose' },
     { id: 'fmea', label: 'FMEA', kind: 'analysis', group: 'incose' },
     { id: 'trade', label: 'Trade Study', kind: 'analysis', group: 'incose' },
-    { id: 'implplan', label: 'Implementation Plan', kind: 'analysis', group: 'incose' },
     { id: 'assumption-review', label: 'Assumption Review', kind: 'analysis', group: 'graphcode' },
 ];
 /** Classify a RENDER artifact. `exists` = doc present; `staleVsGraph` = graph changed since render. */
@@ -99,25 +93,19 @@ export function artifactFreshness(exists, staleVsGraph) {
         return 'absent';
     return staleVsGraph ? 'stale' : 'live';
 }
-/** Classify an ANALYSIS artifact from its scope-currency — 🟢 current / 🟡 stale / 🔴 absent. */
-export function analysisFreshness(currency) {
-    return currency === 'current' ? 'live' : currency === 'stale' ? 'stale' : 'absent';
-}
 /**
- * Shape artifact freshness signals into the tab view-model. The catalog decides each row's
- * kind/group/label; the kind decides WHICH mechanism classifies it — render rows go through
- * the mtime path, analysis rows through the scope-currency path (so a creation is NEVER
- * classified by mtime, even if a caller passes `staleVsGraph` — it is ignored). Renderer groups
- * by `group` to show "INCOSE / SE-standard" and "graphcode-specific" separately.
+ * Shape artifact signals into the tab view-model. The catalog decides each row's
+ * kind/group/label; the kind decides how it is classified — a render row by mtime, an analysis
+ * row by presence alone (`staleVsGraph` is ignored there: an analysis is NEVER classified by
+ * mtime). Renderer groups by `group` to show "INCOSE / SE-standard" and "graphcode-specific"
+ * separately.
  */
 export function artifactsPanel(signals) {
     const byId = new Map(ARTIFACT_CATALOG.map((e) => [e.id, e]));
     const statuses = signals.map((s) => {
         const entry = byId.get(s.id);
         const kind = entry?.kind ?? 'render';
-        const freshness = kind === 'analysis'
-            ? analysisFreshness(s.currency ?? 'absent')
-            : artifactFreshness(s.exists ?? false, s.staleVsGraph ?? false);
+        const freshness = artifactFreshness(s.exists ?? false, kind === 'render' && (s.staleVsGraph ?? false));
         return { id: s.id, label: entry?.label ?? s.id, kind, group: entry?.group ?? 'graphcode', freshness };
     });
     return {
@@ -128,41 +116,14 @@ export function artifactsPanel(signals) {
     };
 }
 /**
- * Build the CreationCurrencyProvider that CR-GC-221's readiness scorer consumes (CR-GC-222
- * delivers the `analysis`-currency to 221). Maps each creation id → its scope-currency; an
- * unknown/never-analyzed creation reads as 🔴 absent.
+ * The signals of the four analysis artifacts, read off the graph: an analysis is on record iff
+ * its stamp under `SYS.attributes.analysisFreshness.<id>` is valid (CR-SM-227 — the same
+ * condition AF-01..04 check). No comparison against the live graphVersion (CR-SM-395).
  */
-export function creationCurrencyProvider(analysis) {
-    const m = new Map(analysis.map((a) => [a.id, a.currency]));
-    return (creation) => m.get(creation) ?? 'absent';
-}
-/**
- * Real scope-currency for the 5 analysis artifacts (CR-SM-227) — replaces the
- * `ABSENT_CREATION_PROVIDER` placeholder (CR-GVE-225 F10: GVE showed `absent`
- * correctly because no scope-currency check existed yet). Reads the
- * `graphVersion` freshness stamp AF-01..05 (contracts) check for presence of
- * (`SYS.attributes.analysisFreshness.<id>`) and classifies it against the
- * live graphVersion: missing/invalid stamp → absent; stamp older than the
- * current graphVersion → stale; stamp at (or ahead of) it → current.
- * Grober Graph-Versions-Stempel only, no scope-hash — CR-SM-227's declared
- * first-cut limitation ("Achtung" section), not full scope-precise staleness.
- */
-export function computeAnalysisCurrency(graph, currentGraphVersion) {
+export function analysisSignals(graph) {
     const sys = graph.nodes.find((n) => n.type === 'SYS');
     const stamps = (sys?.attributes?.analysisFreshness ?? {});
-    return AnalysisArtifactId.options.map((id) => {
-        const parsed = AnalysisFreshnessStampSchema.safeParse(stamps[id]);
-        const currency = !parsed.success
-            ? 'absent'
-            : parsed.data.graphVersion >= currentGraphVersion
-                ? 'current'
-                : 'stale';
-        return { id, currency };
-    });
-}
-/** Convenience: build the real CreationCurrencyProvider straight off the graph + its live version. */
-export function analysisCreationCurrencyProvider(graph, currentGraphVersion) {
-    return creationCurrencyProvider(computeAnalysisCurrency(graph, currentGraphVersion));
+    return AnalysisArtifactId.options.map((id) => ({ id, exists: AnalysisFreshnessStampSchema.safeParse(stamps[id]).success }));
 }
 export function impactPanel(impact) {
     return { root: impact.rootId, blastRadiusNodes: impact.nodeCount, blastRadiusEdges: impact.edgeCount };
@@ -182,7 +143,7 @@ export function healthPanel(health) {
 const DOMAIN_TO_PANELS = {
     graph: ['graph', 'impact', 'artifacts'],
     rules: ['recommendations', 'readiness'],
-    readiness: ['readiness', 'implGates', 'artifacts'],
+    readiness: ['readiness', 'artifacts'],
     suggestions: ['recommendations'],
 };
 /** Which panel ids a viewer should refresh for this invalidation event. */

package/dist/readiness.d.ts

@@ -1,230 +1,89 @@
-/**
- * ReadinessScorer — CR-GC-107 (compliance) + CR-GC-125 (readiness model).
- *
- * Computes readiness for a graphcode graph purely from `@sigloch/contracts`
- * V3_RULES violations (via `harness.evaluateRules()`, the L2 gate — see
- * FCHAIN-apply-gate) PLUS the MS milestone nodes and element status. This is
- * the in-repo deliverable that proves readiness is measured against the FAMILY
- * rule base, NOT the aimprove predecessor rules (BQ-2.0.0 / INCOSE-style
- * BQ-06/BQ-02). The foreign BQ path is explicitly NOT used; it is removed from
- * family readiness scoring.
- *
- * REQ-readiness-model (CR-GC-125) — the model, defined here AND in the graph:
- *
- *   INCOSE-Artifact-Scope = LEAN, refined (CR-GC-226, supersedes the CR-GC-125
- *   `lean = no artifacts` stance). graphcode is a headless QM-level governance
- *   harness, not an ASIL-rated system. The graph is the SSOT and every RENDER
- *   (SRS/SDD/RTM/ICD/…) is a DETERMINISTIC PROJECTION of it (CR-GC-220) — not a
- *   separate hand-authored deliverable. CREATION artifacts (ConOps, FMEA,
- *   Assumption Review, Trade, Impl Plan) ARE in scope as lightweight judgment
- *   inputs and gate preconditions — tracked in the artifact tab (CR-GC-222) and
- *   required by the gates (CR-GC-221). Only ASIL-D-grade evidence (full FMEA
- *   S/O/D rigor, ASIL isolation proof) stays out of scope — graphcode carries no
- *   `asil`-rated elements. Refined model: docs/proposals/readiness-artifact-model.md §3.
- *
- *   Phase-Readiness — 4 INCOSE technical-review gates (SRR/PDR/CDR/TRR), each a
- *   DISJOINT + EXHAUSTIVE partition of the element-level V3_RULES. A gate is
- *   `passed` iff none of its rules fire an error-severity violation; warnings/
- *   info are advisory (`open`). The four gates collectively == element
- *   compliance, so nothing is measured outside V3_RULES.
- *
- *   Implementation-Readiness — 4 program/build acceptance gates
- *   (SAR/FCA/SVR/FRR), each bound to a milestone tier (MS-1..MS-4). A gate is
- *   `ready` iff every CR assigned to its milestone (CR -relation-> MS) is
- *   status=done AND the milestone scope (MS -compose-> X) carries no
- *   error-severity violation. Derived from the MS nodes + element status, i.e.
- *   the MS-01/MS-02 milestone-rule concerns — the remaining 2 of the 17 rules.
- *
- * Host/dashboard wiring (panels) lives in MOD-dashboard (CR-GC-115); this module
- * provides the scoring primitive only — no dashboard, no renderer.
- *
- * @author andreas@siglochconsulting
- */
-import type { Graph } from '@sigloch/graph-api-core';
+import { type MarkType, type RuleStage } from '@sigloch/contracts/se';
 import type { RuleViolation } from '@sigloch/contracts/harness';
-import { type GateCompleteness } from './readiness-completeness.js';
-/**
- * A readiness dimension score in [0, 1].
- * 0 = fully non-compliant, 1 = fully compliant.
- */
-export interface ReadinessDimension {
-    /** Score in [0, 1]. */
-    score: number;
-    /** Short human-readable label for display. */
-    label: string;
-    /** How many elements were evaluated. */
-    totalElements: number;
-    /** How many elements carry at least one error-severity violation. */
-    elementsWithErrors: number;
-}
 /**
  * INCOSE artifact scope for the system under governance.
- * `lean`  — graph = SSOT; renders are deterministic projections, creations are
- *           lightweight judgment inputs + gate preconditions (graphcode's stance,
- *           refined CR-GC-226). NOT "no artifacts".
+ * `lean`  — graph = SSOT; renders are deterministic projections, analyses are lightweight
+ *           judgment inputs (graphcode's stance, refined CR-GC-226). NOT "no artifacts".
  * `full`  — ASIL-D-grade evidence (full FMEA S/O/D rigor, ASIL isolation) (not graphcode).
  */
 export type IncoseScope = 'lean' | 'full';
-/** graphcode's declared scope — see the module header for the rationale. */
+/** graphcode's declared scope. */
 export declare const GRAPHCODE_INCOSE_SCOPE: IncoseScope;
-/**
- * Which rules the impl gates own: the milestone- and change-level family. The impl
- * gates ARE the milestone/CR burndown (SAR/FCA/SVR/FRR ↔ MS-1..MS-4), so a rule about
- * a milestone or a change request belongs there and not on a design review.
- *
- * Derived from the prefix over the contracts catalog (CR-GC-312) — a new `MS-`/`CR-R`
- * rule lands here without an edit. Before, this was `['MS-01','MS-02']` written out,
- * frozen at the two rules that existed when it was authored.
- */
-export declare const IMPL_GATE_RULES: readonly string[];
-/**
- * Phase-Readiness gates (INCOSE technical reviews) → the rules each gate owns.
- * DISJOINT + EXHAUSTIVE over the rule catalog; asserted by TEST-readiness-model
- * against SE_DESCRIPTOR at runtime, never a hardcoded count.
- *
- * DERIVED from `RULE_TO_PHASE` (CR-GC-312). This used to be a hand-written literal —
- * and contracts had already replaced it: CR-SM-226 removed `emergentPhase`/`phaseScore`
- * as "a third, undocumented phase construct next to RULE_TO_DIMENSION and the (then
- * still ad-hoc) phase-gate grouping", introducing `RULE_TO_PHASE` as the one
- * replacement, "exported so no consumer reinvents it". That ad-hoc grouping was THIS
- * object, and the replacement was never carried through here.
- *
- * The cost of leaving it: the literal and `RULE_TO_PHASE` had drifted apart on 21 of
- * 33 shared rules — R-01 SRR vs TRR, R-08 TRR vs PDR, RD-01..03 CDR vs SRR, and so on.
- * Two live gate assignments for the same rules, and readiness was scored against the
- * frozen one. Deriving moves those rules onto the assignment contracts declares; gate
- * scores change accordingly, which is the correction, not a side effect.
- */
-export declare const PHASE_GATE_RULES: Record<string, readonly string[]>;
-/** Human labels for the phase gates. */
-export declare const PHASE_GATE_LABELS: Record<string, string>;
-/**
- * Creation artifacts each phase gate requires (CR-GC-221): the judgment work
- * ("rule-green ≠ analysis-done") a rule-clean structure cannot prove was ever
- * done. A gate is only `passed` if its required creations are 🟢-current.
- * TRR carries none (tests are inline in the graph, not a separate creation).
- */
-export declare const PHASE_GATE_CREATIONS: Record<string, readonly string[]>;
-/** Impl gate → the phase whose creations it inherits as an anti-vacuous-green precondition. */
-export declare const IMPL_GATE_PHASE: Record<string, string>;
-/** Currency of a creation artifact: 🟢 current / 🟡 stale / 🔴 absent. */
-export type CreationCurrency = 'current' | 'stale' | 'absent';
-/**
- * Resolves whether a creation artifact is current/stale/absent (CR-GC-221 = the
- * INTERFACE; CR-GC-222's classifier supplies the real implementation). When no
- * provider is passed to `computeReadiness`, creation enforcement is OFF
- * (back-compat) — the gates still report their `creationArtifacts`, but currency
- * is not checked until 222 wires a provider in.
- */
-export type CreationCurrencyProvider = (creation: string) => CreationCurrency;
-/** Default stub provider (CR-GC-221, "Default 🔴"): everything absent until CR-GC-222 lands. */
-export declare const ABSENT_CREATION_PROVIDER: CreationCurrencyProvider;
-/** Format a "<Creation> not performed (<gate> creation)" blocking message.
- *  Exported so the help layer (CR-GC-228) can identify creation blockers in
- *  `ReadinessGate.blocking[]` without re-deriving the format (single source). */
-export declare function creationBlockingMsg(creation: string, gateId: string): string;
-/**
- * Implementation-Readiness gates (program/build acceptance) → milestone tier.
- * Ready iff every CR assigned to the MS is done + the MS scope is error-clean.
- */
-export declare const IMPL_GATE_MILESTONES: Record<string, {
-    ms: string;
+/** Human labels for the marks. */
+export declare const MARK_LABELS: Readonly<Record<MarkType, string>>;
+/** One mark: reached or not, and the findings that hold it. */
+export interface ReadinessMark {
+    id: MarkType;
+    /** Human-readable name. */
     label: string;
-}>;
+    /** True iff `holding` is empty. */
+    reached: boolean;
+    /** The findings that hold the mark — the answer to "why not". */
+    holding: RuleViolation[];
+}
+/** The marks in order, each with the findings that hold it. */
+export declare function computeMarks(violations: RuleViolation[]): ReadinessMark[];
+/** One stage of the rule catalog and the number of findings whose rule lies at it. */
+export interface StageCount {
+    /** 1–12, or `'immer'` for the rules over all elements. */
+    stage: RuleStage;
+    /** The set of the stage (`STAGE_SETS`); `'immer'` carries its own value. */
+    name: string;
+    /** Number of findings of the rules at this stage — every severity, accepted or not. */
+    findings: number;
+}
 /**
- * A single readiness gate outcome.
- * `passed` is the hard verdict (no blocking/error item); `score` ∈ [0,1] is a
- * continuous maturity indicator; `open` items are advisory (warnings/CR debt).
+ * The findings counted per stage: the stages 1 to 12 in order, then `'immer'` — always 13 entries.
+ * Derived from the stage each rule carries at its definition and from nothing else: no table, no
+ * denominator, no percentage. The sum over the entries is the number of findings. A finding of a
+ * rule the catalog does not know throws, as in `holds`.
+ *
+ * This replaces the eight readiness dimensions and their scores (decision of the author,
+ * 2026-10-07: "Stufe statt Dimension, Befunde zaehlen statt Prozent").
  */
-export interface ReadinessGate {
-    /** Gate id — SRR/PDR/CDR/TRR (phase) or SAR/FCA/SVR/FRR (impl). */
-    id: string;
-    /** Human-readable review name. */
-    label: string;
-    /** True iff no blocking (error-severity / not-done) item remains. */
-    passed: boolean;
-    /** Continuous maturity in [0, 1]. */
-    score: number;
-    /** Blocking items that hold the gate closed (errors / open CRs / scope errors). */
-    blocking: string[];
-    /** Advisory items surfaced but not blocking (warnings, info, scope notes). */
-    open: string[];
-    /** Creation artifacts this gate requires (CR-GC-221) — judgment work, not rules. */
-    creationArtifacts: string[];
-    /**
-     * Structural completeness of the derivation chain owned by this gate
-     * (CR-GC-250) — orthogonal to violation severity. `covered/total` over the
-     * DRIVING population, so absence counts (0 FCHAIN → all UCs incomplete → SRR
-     * red). One value per gate for the dashboard; `missing[]` is the on-click
-     * per-leg detail. A gate cannot pass while `covered < total`. Impl gates carry
-     * a neutral `{0,0,[]}` (completeness is a phase-gate concept).
-     */
-    completeness: GateCompleteness;
-}
+export declare function countByStage(violations: RuleViolation[]): StageCount[];
 /**
- * Full readiness snapshot derived from V3_RULES evaluation + MS + status.
- * All violation ruleIds are contracts rule-IDs (R-xx / RD-xx / MS-xx) — never BQ-*.
+ * Full readiness snapshot derived from rule violations.
+ * All violation ruleIds are contracts rule-IDs — never a foreign rule set.
  */
 export interface ReadinessReport {
-    /**
-     * Compliance dimension: fraction of graph elements with NO error-severity
-     * violation. 1.0 = all elements clean, 0.0 = all elements have ≥1 error.
-     */
-    compliance: ReadinessDimension;
     /** Declared INCOSE artifact scope for this system (graphcode = `lean`). */
     incoseScope: IncoseScope;
-    /** Phase-Readiness gates (INCOSE technical reviews) in lifecycle order. */
-    phaseGates: ReadinessGate[];
-    /** Implementation-Readiness gates (program/build acceptance) in tier order. */
-    implGates: ReadinessGate[];
-    /**
-     * Per-contracts-rule-ID violation counts. Keys are exactly the
-     * `SE_DESCRIPTOR.rules` members that fired. Foreign BQ-* IDs cannot appear —
-     * the scorer delegates exclusively to the V3 rule engine.
-     */
+    /** The marks SRR, PDR, CDR, TRR, Bau — in order. */
+    marks: ReadinessMark[];
+    /** Per-contracts-rule-ID violation counts. */
     violationsByRule: Record<string, number>;
     /** All raw violations, ordered by severity (error → warning → info). */
     violations: RuleViolation[];
-    /**
-     * Whether creation-artifact currency was ENFORCED in this report (CR-GC-259).
-     * `off` means no `CreationCurrencyProvider` was supplied, so every gate's
-     * `creationArtifacts` was REPORTED but never checked — a gate can read
-     * `passed` with a never-performed FMEA/ConOps behind it. Made explicit because
-     * a silently-unenforced gate is the same false-green class CR-GC-250 closed:
-     * a consumer cannot distinguish "no creation blockers" from "not checked".
-     * graphcode itself has no classifier yet (the real provider is fed by the
-     * dashboard), so the product path reports `off` until one lands.
-     */
-    creationEnforcement: 'on' | 'off';
     /** Timestamp (ISO 8601) when this report was computed. */
     computedAt: string;
 }
 /**
  * Summary projection of a ReadinessReport (CR-GC-203 item 2): drops the heavy
- * per-element lists — `violations` and every gate's `blocking`/`open` — while
- * keeping scores, counts and `violationsByRule`. `graph_readiness` returns this
+ * per-element lists — `violations` and every mark's `holding` — while keeping
+ * `reached`, counts and `violationsByRule`. `graph_readiness` returns this
  * by default; `detail:true` returns the full lists. On a fully-red graph the
- * full report inlined every blocking element (86k+ chars, past the MCP tool
+ * full report inlined every finding (86k+ chars, past the MCP tool
  * result limit) forcing a file-spill; the summary stays small.
  */
 export declare function summarizeReadiness(report: ReadinessReport): ReadinessReport;
 /**
- * Compute readiness from a violations array + the full graph (nodes + edges).
+ * Compute readiness from a violations array — and from nothing else (CR-SM-402: the graph was
+ * read for the compliance percentage only).
  *
- * @param violations - from `harness.evaluateRules()` (contracts V3 rule IDs)
- * @param graph      - from `harness.getGraph()` (elements + traces)
+ * @param violations - from `harness.evaluateRules()` (contracts rule IDs), UNFILTERED: a finding
+ *                     the human accepted with a reason still holds its mark (CR-SM-396).
  */
-export declare function computeReadiness(violations: RuleViolation[], graph: Pick<Graph, 'nodes' | 'edges'>, creationCurrency?: CreationCurrencyProvider): ReadinessReport;
+export declare function computeReadiness(violations: RuleViolation[]): ReadinessReport;
 /**
- * Convenience wrapper: runs `evaluateRules()` + `getGraph()` on the harness
- * and returns the full ReadinessReport.
+ * Convenience wrapper: runs `evaluateRules()` on the harness and returns the full
+ * ReadinessReport.
  *
  * Accepts a minimal harness-duck-type so callers can pass `GraphCodeHarness`
  * directly without importing its class (avoids circular dep risk in consumers).
  */
 export declare function scoreReadiness(harness: {
     evaluateRules(): RuleViolation[];
-    getGraph(): Pick<Graph, 'nodes' | 'edges'>;
 }): ReadinessReport;
 /**
  * The authoritative set of family rule-IDs (derived at runtime from

package/dist/readiness.js

@@ -1,278 +1,127 @@
-import { SE_DESCRIPTOR } from '@sigloch/graph-api-core';
-import { CODE_CONFORMANCE_RULES, RULE_TO_PHASE } from '@sigloch/contracts/se';
-import { scoreCompleteness, NEUTRAL_COMPLETENESS, } from './readiness-completeness.js';
-/** graphcode's declared scope — see the module header for the rationale. */
-export const GRAPHCODE_INCOSE_SCOPE = 'lean';
 /**
- * Which rules the impl gates own: the milestone- and change-level family. The impl
- * gates ARE the milestone/CR burndown (SAR/FCA/SVR/FRR ↔ MS-1..MS-4), so a rule about
- * a milestone or a change request belongs there and not on a design review.
+ * Readiness — the marks and the findings (CR-GC-107, CR-GC-125; rebuilt CR-SM-395).
  *
- * Derived from the prefix over the contracts catalog (CR-GC-312) — a new `MS-`/`CR-R`
- * rule lands here without an edit. Before, this was `['MS-01','MS-02']` written out,
- * frozen at the two rules that existed when it was authored.
- */
-export const IMPL_GATE_RULES = Object.keys(RULE_TO_PHASE)
-    .filter((id) => /^(MS-|CR-R)/.test(id))
-    .sort();
-/**
- * `RULE_TO_PHASE` covers the whole catalog including the CODING profile (`BQ-` and
- * `ND-` prefixes). The readiness model is the SE profile only — `SE_DESCRIPTOR.rules`
- * deliberately excludes those, so a gate must not claim one and then never see it fire.
- */
-const isCodingProfile = (id) => /^(BQ-|ND-)/.test(id);
-/**
- * Which conformance rule sits on which gate. RC-* are deliberately outside
- * `ALL_RULE_DEFS` (they need `CodeFacts` from a repo checkout, which contracts has no
- * access to), so `RULE_TO_PHASE` cannot carry them and this is the one legitimate
- * local addition.
+ * Computed purely from rule violations of `@sigloch/contracts` (the family rule base, never a
+ * foreign rule set) and the stage each rule carries at its definition. There is no gate
+ * computation of its own in this package any more.
  *
- * Still not hand-picked: each RC rule inherits the gate of the PRESENCE rule it
- * resolves — the Presence/Resolution split contracts documents (R-19/R-20/R-26 declare
- * a binding, RC-01/02/03/04 check it actually resolves on disk). RC-05 (cross-module
- * import drift) has no presence partner; it is module coupling, so it follows R-23.
+ * THE MARKS. The rule catalog orders its sets in twelve stages (`STAGE_SETS`); a mark lies
+ * between two stages: SRR after stage 4, PDR after 7, CDR after 8, TRR after 9, Bau after 12.
+ * A mark is REACHED iff no finding holds it. A finding holds a mark when its rule lies at or
+ * before the mark's stage — or at every stage (`'immer'`) — and it is
+ *   - an error, or
+ *   - a finding of an existence rule: a set the stage requires is missing.
+ * Other warnings do not hold a mark; "free of warnings" is a separate statement.
  *
- * CR-SM-262: RC-06 folgt RC-05 aus demselben Grund. Ein Praesenz-Partner kaeme nicht in
- * Frage — die Regel prueft ausschliesslich `external === true`, und genau diese Knoten sind
- * von R-20 AUSGENOMMEN ("exempt from the R-20 realRef-binding requirement", ELEMENT_ATTRIBUTES).
- * Sie loest also keine Praesenzforderung auf, sondern stellt eine eigene: das Paket, auf das
- * eine externe Bindung zeigt, muss in den dependencies stehen. Ihr Gegenstand ist damit die
- * Paket-Abhaengigkeit, die groebste Form von Modul-Kopplung — dieselbe Kategorie wie RC-05.
- */
-const RC_PRESENCE_PARTNER = {
-    'RC-01': 'R-20', // FUNC realRef → declared symbol
-    'RC-02': 'R-19', // testRefs → runnable test cases
-    'RC-03': 'R-26', // SCHEMA realRef → declared export
-    'RC-04': 'R-26', // SCHEMA realRef parsed at its interface
-    'RC-05': 'R-23', // cross-module import the graph does not document
-    'RC-06': 'R-23', // external binding on a package the consumer does not depend on
-    'RC-07': 'CR-R01', // CR node agrees with docs/cr — the CR presence rule's gate (CR-SM-329)
-    'RC-08': 'R-26', // SCHEMA realRef is a Zod schema, not a type (CR-SM-358)
-    'RC-09': 'R-26', // SCHEMA parsed only at its modelled interface — code → model (CR-SM-358)
-    'RC-10': 'R-23', // MOD without resolvable files — RC-05 is blind there, module coupling (CR-SM-377)
-};
-/**
- * Phase-Readiness gates (INCOSE technical reviews) → the rules each gate owns.
- * DISJOINT + EXHAUSTIVE over the rule catalog; asserted by TEST-readiness-model
- * against SE_DESCRIPTOR at runtime, never a hardcoded count.
+ * The mark Bau additionally is held by every warning of the stages 10 to 12 (plan, binding,
+ * conformance): those findings ARE the work list of the build, and the mark reads "nothing left
+ * to plan, bind or reconcile". It opens again with every change.
+ *
+ * A NOTE (severity `info`, e.g. MS-03, VR-01) holds no mark, at no stage (CR-SM-396).
+ *
+ * AN ACCEPTED FINDING HOLDS ITS MARK (CR-SM-396). The rules keep firing on a finding the human
+ * accepted with a reason (`acceptedFindings`), and the marks are computed from all of them: an
+ * accepted AF-05 ("unbuilt, no order") still holds Bau. Acceptance takes a finding out of the
+ * work focus; it is no way to read a mark as reached. Callers pass the findings UNFILTERED.
  *
- * DERIVED from `RULE_TO_PHASE` (CR-GC-312). This used to be a hand-written literal —
- * and contracts had already replaced it: CR-SM-226 removed `emergentPhase`/`phaseScore`
- * as "a third, undocumented phase construct next to RULE_TO_DIMENSION and the (then
- * still ad-hoc) phase-gate grouping", introducing `RULE_TO_PHASE` as the one
- * replacement, "exported so no consumer reinvents it". That ad-hoc grouping was THIS
- * object, and the replacement was never carried through here.
+ * Why "0 of 0" cannot read as reached: every mandatory set is demanded by an existence rule of
+ * the stage before it (no system → R-33, no use case → R-17, …). An empty set is therefore either
+ * voluntary, or the existence rule before it is open and holds the mark. Stage 8 (schema) carries
+ * no existence rule of its own (CR-SM-396): a data flow without a schema is a grammar error
+ * (R-18, every stage), and no data flow at all is held by R-31 (stage 6).
  *
- * The cost of leaving it: the literal and `RULE_TO_PHASE` had drifted apart on 21 of
- * 33 shared rules — R-01 SRR vs TRR, R-08 TRR vs PDR, RD-01..03 CDR vs SRR, and so on.
- * Two live gate assignments for the same rules, and readiness was scored against the
- * frozen one. Deriving moves those rules onto the assignment contracts declares; gate
- * scores change accordingly, which is the correction, not a side effect.
+ * What is gone with CR-SM-395: the three-valued gate state and its labels, the gate score, the
+ * gate completeness and its legs (`COMPLETENESS_SLICES`), the four build gates bound to milestone
+ * ids, the required creations per gate and the currency of analysis artifacts. The assignment
+ * rule → mark is `ALL_RULE_DEFS[].mark` in contracts, not a list here.
+ *
+ * What is gone with CR-SM-402: the compliance percentage (share of elements without an error
+ * finding) with its denominator and its two counts. The report carries marks and findings — what
+ * the agent reads and acts on — and nothing a viewer would see on top of that.
+ *
+ * Host/dashboard wiring (panels) lives in `panels.ts`; this module provides the scoring
+ * primitive only — no dashboard, no renderer.
+ *
+ * @author andreas@siglochconsulting
  */
-export const PHASE_GATE_RULES = (() => {
-    const implOwned = new Set(IMPL_GATE_RULES);
-    const gates = { SRR: [], PDR: [], CDR: [], TRR: [] };
-    for (const [ruleId, gate] of Object.entries(RULE_TO_PHASE)) {
-        if (implOwned.has(ruleId))
-            continue; // the impl axis owns these
-        if (isCodingProfile(ruleId))
-            continue; // not part of the SE readiness model
-        gates[gate]?.push(ruleId);
-    }
-    for (const [rcId, partner] of Object.entries(RC_PRESENCE_PARTNER)) {
-        const gate = RULE_TO_PHASE[partner];
-        if (gate)
-            gates[gate].push(rcId);
-    }
-    for (const ids of Object.values(gates))
-        ids.sort();
-    return gates;
-})();
-/** Human labels for the phase gates. */
-export const PHASE_GATE_LABELS = {
+import { SE_DESCRIPTOR } from '@sigloch/graph-api-core';
+import { ALL_RULE_DEFS, CODE_CONFORMANCE_RULES, Mark, MARK_STAGE, STAGE_SETS } from '@sigloch/contracts/se';
+/** graphcode's declared scope. */
+export const GRAPHCODE_INCOSE_SCOPE = 'lean';
+// ---------------------------------------------------------------------------
+// Marks (CR-SM-395)
+// ---------------------------------------------------------------------------
+/** Human labels for the marks. */
+export const MARK_LABELS = {
     SRR: 'System Requirements Review',
     PDR: 'Preliminary Design Review',
     CDR: 'Critical Design Review',
     TRR: 'Test Readiness Review',
+    Bau: 'Bau',
 };
-/**
- * Creation artifacts each phase gate requires (CR-GC-221): the judgment work
- * ("rule-green ≠ analysis-done") a rule-clean structure cannot prove was ever
- * done. A gate is only `passed` if its required creations are 🟢-current.
- * TRR carries none (tests are inline in the graph, not a separate creation).
- */
-export const PHASE_GATE_CREATIONS = {
-    SRR: ['conops', 'assumption-review'],
-    PDR: ['fmea', 'trade'],
-    CDR: ['implplan'],
-    TRR: [],
-};
-/** Human labels for creation artifacts (used in blocking messages). */
-const CREATION_LABELS = {
-    conops: 'ConOps',
-    'assumption-review': 'Assumption Review',
-    fmea: 'FMEA',
-    trade: 'Trade study',
-    implplan: 'Impl plan',
-};
-/** Impl gate → the phase whose creations it inherits as an anti-vacuous-green precondition. */
-export const IMPL_GATE_PHASE = {
-    SAR: 'SRR',
-    FCA: 'PDR',
-    SVR: 'CDR',
-    FRR: 'TRR',
-};
-/** Default stub provider (CR-GC-221, "Default 🔴"): everything absent until CR-GC-222 lands. */
-export const ABSENT_CREATION_PROVIDER = () => 'absent';
-/** Format a "<Creation> not performed (<gate> creation)" blocking message.
- *  Exported so the help layer (CR-GC-228) can identify creation blockers in
- *  `ReadinessGate.blocking[]` without re-deriving the format (single source). */
-export function creationBlockingMsg(creation, gateId) {
-    return `${CREATION_LABELS[creation] ?? creation} not performed (${gateId} creation)`;
+const RULES = new Map(ALL_RULE_DEFS.map((r) => [r.id, r]));
+/** Does this finding hold this mark? See the module header for the rule. */
+function holds(v, mark) {
+    // A finding of a rule the catalog does not know is a programming error and throws (CR-SM-399).
+    const rule = RULES.get(v.ruleId);
+    const stage = rule.stage;
+    if (v.severity === 'info')
+        return false; // a note holds no mark (CR-SM-396)
+    if (stage !== 'immer' && stage > MARK_STAGE[mark])
+        return false;
+    if (v.severity === 'error' || rule.role === 'existence')
+        return true;
+    return mark === 'Bau' && stage !== 'immer' && stage > MARK_STAGE.TRR;
+}
+/** The marks in order, each with the findings that hold it. */
+export function computeMarks(violations) {
+    return Mark.options.map((id) => {
+        const holding = violations.filter((v) => holds(v, id));
+        return { id, label: MARK_LABELS[id], reached: holding.length === 0, holding };
+    });
 }
 /**
- * Implementation-Readiness gates (program/build acceptance) → milestone tier.
- * Ready iff every CR assigned to the MS is done + the MS scope is error-clean.
+ * The findings counted per stage: the stages 1 to 12 in order, then `'immer'` — always 13 entries.
+ * Derived from the stage each rule carries at its definition and from nothing else: no table, no
+ * denominator, no percentage. The sum over the entries is the number of findings. A finding of a
+ * rule the catalog does not know throws, as in `holds`.
+ *
+ * This replaces the eight readiness dimensions and their scores (decision of the author,
+ * 2026-10-07: "Stufe statt Dimension, Befunde zaehlen statt Prozent").
  */
-export const IMPL_GATE_MILESTONES = {
-    SAR: { ms: 'MS-1-specification', label: 'System Acceptance Review' },
-    FCA: { ms: 'MS-2-coding-vv', label: 'Functional Configuration Audit' },
-    SVR: { ms: 'MS-3-mvp-readiness', label: 'System Verification Review' },
-    FRR: { ms: 'MS-4-mvp2', label: 'Functional Readiness Review' },
-};
+export function countByStage(violations) {
+    const count = (stage) => violations.filter((v) => RULES.get(v.ruleId).stage === stage).length;
+    return [
+        ...STAGE_SETS.map((name, i) => ({ stage: (i + 1), name, findings: count((i + 1)) })),
+        { stage: 'immer', name: 'immer', findings: count('immer') },
+    ];
+}
 /**
  * Summary projection of a ReadinessReport (CR-GC-203 item 2): drops the heavy
- * per-element lists — `violations` and every gate's `blocking`/`open` — while
- * keeping scores, counts and `violationsByRule`. `graph_readiness` returns this
+ * per-element lists — `violations` and every mark's `holding` — while keeping
+ * `reached`, counts and `violationsByRule`. `graph_readiness` returns this
  * by default; `detail:true` returns the full lists. On a fully-red graph the
- * full report inlined every blocking element (86k+ chars, past the MCP tool
+ * full report inlined every finding (86k+ chars, past the MCP tool
  * result limit) forcing a file-spill; the summary stays small.
  */
 export function summarizeReadiness(report) {
-    const stripGate = (g) => ({
-        ...g,
-        blocking: [],
-        open: [],
-        // Keep the one-value covered/total for the dashboard; drop the per-leg drill-down.
-        completeness: { ...g.completeness, missing: [] },
-    });
     return {
         ...report,
-        phaseGates: report.phaseGates.map(stripGate),
-        implGates: report.implGates.map(stripGate),
+        marks: report.marks.map((m) => ({ ...m, holding: [] })),
         violations: [],
     };
 }
 // ---------------------------------------------------------------------------
 // Scorer
 // ---------------------------------------------------------------------------
-/** Group violations by element-id for per-element error lookups. */
-function elementsWithErrorSet(violations) {
-    return new Set(violations
-        .filter((v) => v.severity === 'error' && v.elementId !== undefined)
-        .map((v) => v.elementId));
-}
-/**
- * Score one phase gate from the violations whose ruleId it owns, plus its
- * required creation artifacts (CR-GC-221): a gate is only `passed` if it is
- * rule-clean AND every required creation is 🟢-current. When `currency` is
- * undefined, creation enforcement is OFF (back-compat) — `creationArtifacts`
- * is still reported. Creations affect `passed`/`blocking`, not the rule `score`.
- */
-function scorePhaseGate(id, ruleIds, violations, creations, graph, currency) {
-    const owned = violations.filter((v) => ruleIds.includes(v.ruleId));
-    const errors = owned.filter((v) => v.severity === 'error');
-    const rulesWithError = new Set(errors.map((v) => v.ruleId));
-    const ruleBlocking = errors.map((v) => `${v.ruleId}: ${v.message}`);
-    const open = owned.filter((v) => v.severity !== 'error').map((v) => `${v.ruleId}: ${v.message}`);
-    // Phase gate requires every creation 🟢-current — stale OR absent blocks.
-    const creationBlocking = currency
-        ? creations.filter((c) => currency(c) !== 'current').map((c) => creationBlockingMsg(c, id))
-        : [];
-    // Structural completeness (CR-GC-250): one aggregated blocking line, not N warnings.
-    // CR-SM-226: reads off the SAME violations array (the rule stream), no re-walk.
-    const completeness = scoreCompleteness(id, graph, violations);
-    const complete = completeness.covered === completeness.total;
-    const completenessBlocking = complete
-        ? []
-        : [`${id} completeness ${completeness.covered}/${completeness.total} — ${completeness.missing.join('; ')}`];
-    const blocking = [...ruleBlocking, ...creationBlocking, ...completenessBlocking];
-    // Maturity = share of the gate's hard checks with no error, floored by completeness coverage:
-    // a gate cannot read green while a mandated chain leg is empty.
-    const ruleScore = ruleIds.length > 0 ? (ruleIds.length - rulesWithError.size) / ruleIds.length : 1;
-    const completenessRatio = completeness.total > 0 ? completeness.covered / completeness.total : 1;
-    return {
-        id,
-        label: PHASE_GATE_LABELS[id] ?? id,
-        passed: rulesWithError.size === 0 && creationBlocking.length === 0 && complete,
-        score: Math.min(ruleScore, completenessRatio),
-        blocking,
-        open,
-        creationArtifacts: [...creations],
-        completeness,
-    };
-}
-/**
- * Score one implementation gate from its milestone's CRs + scope (MS + status),
- * plus an anti-vacuous-green creation check (CR-GC-221): the gate additionally
- * blocks when a creation required by its phase is 🔴 **absent** — even with no
- * representing CR (a never-done FMEA must not pass silently). Only `absent`
- * blocks here (not `stale`); enforcement is off when `currency` is undefined.
- */
-function scoreImplGate(id, ms, label, graph, elementsWithError, creations, currency) {
-    const msNode = graph.nodes.find((n) => n.uid === ms);
-    if (!msNode) {
-        return {
-            id,
-            label,
-            passed: false,
-            score: 0,
-            blocking: [`milestone ${ms} missing`],
-            open: [],
-            creationArtifacts: [...creations],
-            completeness: NEUTRAL_COMPLETENESS,
-        };
-    }
-    const nodeById = new Map(graph.nodes.map((n) => [n.uid, n]));
-    // CRs assigned to this milestone: CR -relation-> MS (the MS-01 scope semantics).
-    const crs = graph.edges
-        .filter((e) => e.edgeType === 'relation' && e.targetId === ms)
-        .map((e) => nodeById.get(e.sourceId))
-        .filter((n) => !!n && n.type === 'CR');
-    const openCrs = crs.filter((c) => c.attributes?.status !== 'done');
-    // Milestone scope: composed elements (MS -compose-> X) must be error-clean.
-    const scopeErrors = graph.edges
-        .filter((e) => e.sourceId === ms && e.edgeType === 'compose')
-        .map((e) => e.targetId)
-        .filter((id2) => elementsWithError.has(id2));
-    // Anti-vacuous-green: a phase creation that is 🔴 absent blocks the impl gate
-    // even when every CR is done and the scope is clean (the analysis was never done).
-    const creationBlocking = currency
-        ? creations.filter((c) => currency(c) === 'absent').map((c) => creationBlockingMsg(c, id))
-        : [];
-    const blocking = [
-        ...openCrs.map((c) => `${c.uid} not done`),
-        ...scopeErrors.map((id2) => `${id2} has an error-severity violation`),
-        ...creationBlocking,
-    ];
-    const msStatus = msNode.attributes?.status;
-    const score = crs.length > 0
-        ? (crs.length - openCrs.length) / crs.length
-        : msStatus === 'done' || msStatus === 'reviewed' ? 1 : 0;
-    return { id, label, passed: blocking.length === 0, score, blocking, open: [], creationArtifacts: [...creations], completeness: NEUTRAL_COMPLETENESS };
-}
 /**
- * Compute readiness from a violations array + the full graph (nodes + edges).
+ * Compute readiness from a violations array — and from nothing else (CR-SM-402: the graph was
+ * read for the compliance percentage only).
  *
- * @param violations - from `harness.evaluateRules()` (contracts V3 rule IDs)
- * @param graph      - from `harness.getGraph()` (elements + traces)
+ * @param violations - from `harness.evaluateRules()` (contracts rule IDs), UNFILTERED: a finding
+ *                     the human accepted with a reason still holds its mark (CR-SM-396).
  */
-export function computeReadiness(violations, graph, creationCurrency) {
-    const totalElements = graph.nodes.length;
-    const elementsWithError = elementsWithErrorSet(violations);
-    const elementsWithErrors = elementsWithError.size;
-    const complianceScore = totalElements > 0 ? (totalElements - elementsWithErrors) / totalElements : 1;
-    // Violation counts keyed by contracts rule-ID (never BQ-*).
+export function computeReadiness(violations) {
     const violationsByRule = {};
     for (const v of violations) {
         violationsByRule[v.ruleId] = (violationsByRule[v.ruleId] ?? 0) + 1;
@@ -280,35 +129,23 @@ export function computeReadiness(violations, graph, creationCurrency) {
     // Sort: error → warning → info.
     const severityRank = { error: 0, warning: 1, info: 2 };
     const sorted = [...violations].sort((a, b) => (severityRank[a.severity] ?? 3) - (severityRank[b.severity] ?? 3));
-    const phaseGates = Object.entries(PHASE_GATE_RULES).map(([id, ruleIds]) => scorePhaseGate(id, ruleIds, violations, PHASE_GATE_CREATIONS[id] ?? [], graph, creationCurrency));
-    const implGates = Object.entries(IMPL_GATE_MILESTONES).map(([id, { ms, label }]) => scoreImplGate(id, ms, label, graph, elementsWithError, PHASE_GATE_CREATIONS[IMPL_GATE_PHASE[id]] ?? [], creationCurrency));
     return {
-        compliance: {
-            score: complianceScore,
-            label: 'Compliance (V3_RULES, error-severity)',
-            totalElements,
-            elementsWithErrors,
-        },
         incoseScope: GRAPHCODE_INCOSE_SCOPE,
-        phaseGates,
-        implGates,
+        marks: computeMarks(violations),
         violationsByRule,
         violations: sorted,
-        creationEnforcement: creationCurrency ? 'on' : 'off',
         computedAt: new Date().toISOString(),
     };
 }
 /**
- * Convenience wrapper: runs `evaluateRules()` + `getGraph()` on the harness
- * and returns the full ReadinessReport.
+ * Convenience wrapper: runs `evaluateRules()` on the harness and returns the full
+ * ReadinessReport.
  *
  * Accepts a minimal harness-duck-type so callers can pass `GraphCodeHarness`
  * directly without importing its class (avoids circular dep risk in consumers).
  */
 export function scoreReadiness(harness) {
-    const violations = harness.evaluateRules();
-    const graph = harness.getGraph();
-    return computeReadiness(violations, graph);
+    return computeReadiness(harness.evaluateRules());
 }
 /**
  * The authoritative set of family rule-IDs (derived at runtime from

package/dist/view-catalog.d.ts

@@ -22,7 +22,7 @@
  * grouped by type and answered the same question as `srs` (the ISO-29148 narrative)
  * with different completeness — two requirements documents, one truth. `srs` stays.
  */
-export declare const MARKDOWN_VIEWS: readonly ["architecture", "cr-list", "references", "srs", "nfr", "rtm", "icd", "testconcept", "testmatrix", "intplan", "changelog", "fmea", "conops", "trade", "implplan"];
+export declare const MARKDOWN_VIEWS: readonly ["architecture", "cr-list", "references", "srs", "nfr", "rtm", "icd", "testconcept", "testmatrix", "intplan", "changelog", "fmea", "conops", "implplan"];
 export type MarkdownView = (typeof MARKDOWN_VIEWS)[number];
 /** Default file name for each view (under docs/views/). */
 export declare const VIEW_FILENAMES: Record<MarkdownView, string>;

package/dist/view-catalog.js

@@ -38,7 +38,6 @@ export const MARKDOWN_VIEWS = [
     'changelog',
     'fmea',
     'conops',
-    'trade',
     'implplan',
 ];
 /** Default file name for each view (under docs/views/). */
@@ -56,6 +55,5 @@ export const VIEW_FILENAMES = {
     changelog: 'changelog.md',
     fmea: 'fmea.md',
     conops: 'conops.md',
-    trade: 'trade.md',
     implplan: 'implplan.md',
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigloch/graphcode-client",
-  "version": "1.6.0",
+  "version": "3.0.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -40,11 +40,11 @@
     "zod": "^4.3.6"
   },
   "peerDependencies": {
-    "@sigloch/contracts": ">=10 <11",
+    "@sigloch/contracts": ">=12 <13",
     "@sigloch/graph-api-core": ">=5 <6"
   },
   "devDependencies": {
-    "@sigloch/contracts": ">=10 <11",
+    "@sigloch/contracts": ">=12 <13",
     "@sigloch/graph-api-core": ">=5.4 <6"
   }
 }

package/dist/readiness-completeness.d.ts

@@ -1,78 +0,0 @@
-/**
- * readiness-completeness.ts — the COMPLETENESS dimension of readiness (CR-GC-250,
- * split out of readiness.ts by CR-GC-260; rebuilt on the rule stream CR-SM-226).
- *
- * Its own module because it answers a different question than the rest of readiness:
- * compliance/gates ask "does any element violate a rule", completeness asks "is the
- * structural chain covered at all" — the absence case rules cannot see (0 FCHAIN → a
- * per-element warning rule fires 0 times and the gate reads green).
- *
- * CR-SM-226: every leg now reads off a named `@sigloch/contracts` rule instead of
- * re-walking the graph locally. The former local out-edge/actor-boundary/testRefs/
- * codeRef/leaf-function helpers were a SECOND, drifting implementation of exactly
- * what R-15/UC-01/UC-03/FC-04/SC-04/R-19/R-20 already check in `@sigloch/contracts/se`
- * — deleted. The rule engine stays the single source of truth; this file only
- * re-groups its violations by the DRIVING population per leg, so an EMPTY
- * population still counts against the gate (the vacuous-complete case a
- * per-element warning rule cannot see on its own — closed for real by
- * `@sigloch/contracts/se`'s R-28 Ebenen-Präsenz, CR-SM-226; die Regel selbst ist mit CR-SM-247 entfallen).
- *
- * BROWSER-SAFE — no `node:*` import may enter this file: the panels layer builds on it.
- *
- * @author andreas@siglochconsulting
- */
-import { z } from 'zod/v4';
-import type { Graph } from '@sigloch/graph-api-core';
-import type { RuleViolation } from '@sigloch/contracts/harness';
-export type CGraph = Pick<Graph, 'nodes' | 'edges'>;
-export type CNode = Graph['nodes'][number];
-/** A gate's structural completeness over its driving population — ein Zod-Vertrag (CR-SM-361). */
-export declare const GateCompleteness: z.ZodObject<{
-    covered: z.ZodNumber;
-    total: z.ZodNumber;
-    missing: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-export type GateCompleteness = z.infer<typeof GateCompleteness>;
-/** Neutral completeness for gates that carry no chain slice (impl gates). */
-export declare const NEUTRAL_COMPLETENESS: GateCompleteness;
-export declare const typeOf: (byId: Map<string, CNode>, id: string) => string | undefined;
-/**
- * One completeness leg: every node of `sourceType` (the driving population)
- * must carry NO violation of `ruleId` (its `@sigloch/contracts` rule twin),
- * else it is a `missing` source for the owning gate. Cardinality legs use the
- * id `"<SRC>→<TGT>"` so the drift test can match them against the
- * meta-model's `1..*` patterns.
- */
-export interface CompletenessLeg {
-    id: string;
-    sourceType: string;
-    ruleId: string;
-}
-/**
- * Phase-gate → chain legs that must be complete AT THAT PHASE, each backed by
- * its `@sigloch/contracts` rule twin (CR-SM-226):
- *   SRR: SYS→UC ≈ R-17 (SYS must have compose; not UC-typed specifically —
- *        no dedicated SYS→UC rule exists, R-17 is the closest twin),
- *        UC→FCHAIN = UC-03, UC→REQ = UC-01.
- *   PDR: FCHAIN→FUNC = R-15, FCHAIN-actor-bounded = FC-04 (trigger+consumer),
- *        FUNC→MOD = R-22 (CR-SM-389: jede FUNC wohnt in einem Modul). Der Pattern ist
- *        `0..1` — seine Untergrenze ist R-22 (warning, nicht error: das Apply-Gate lehnt
- *        neu eingefuehrte Errors ab, jede FUNC muesste sonst mit ihrem Modul im selben
- *        Zug entstehen). Das Bein sperrt `passed`, nicht das Gate. R-23 (MOD ohne FUNC)
- *        ist bewusst KEIN Bein: ein leeres Modul laesst keine Funktion unverortet — es
- *        ist Ueberschuss, keine Luecke; die treibende Population ist FUNC, und dieselbe
- *        allocate-Kante wuerde nur ein zweites Mal von der anderen Seite gezaehlt.
- *   CDR: FLOW→SCHEMA = R-18 (seit CR-SM-271: die Untergrenze ist Grammatik,
- *        `FLOW -relation-> SCHEMA [1..1]` — SC-04 existiert nicht mehr; ein
- *        R-18-Befund am FLOW heisst "Kanten ungrammatisch", inkl. fehlendem
- *        oder doppeltem SCHEMA).
- *   TRR: TEST.testRefs = R-19, FUNC.realRef = R-20.
- */
-export declare const COMPLETENESS_SLICES: Record<string, CompletenessLeg[]>;
-/**
- * Score one phase gate's structural completeness over its driving population.
- * `total === 0` (no source elements to cover) → vacuously complete (ratio 1).
- * `violations` is the full rule-stream output (e.g. `harness.evaluateRules()`);
- * only the leg's own `ruleId` is consulted per node.
- */
-export declare function scoreCompleteness(gateId: string, graph: CGraph, violations: RuleViolation[]): GateCompleteness;

package/dist/readiness-completeness.js

@@ -1,109 +0,0 @@
-/**
- * readiness-completeness.ts — the COMPLETENESS dimension of readiness (CR-GC-250,
- * split out of readiness.ts by CR-GC-260; rebuilt on the rule stream CR-SM-226).
- *
- * Its own module because it answers a different question than the rest of readiness:
- * compliance/gates ask "does any element violate a rule", completeness asks "is the
- * structural chain covered at all" — the absence case rules cannot see (0 FCHAIN → a
- * per-element warning rule fires 0 times and the gate reads green).
- *
- * CR-SM-226: every leg now reads off a named `@sigloch/contracts` rule instead of
- * re-walking the graph locally. The former local out-edge/actor-boundary/testRefs/
- * codeRef/leaf-function helpers were a SECOND, drifting implementation of exactly
- * what R-15/UC-01/UC-03/FC-04/SC-04/R-19/R-20 already check in `@sigloch/contracts/se`
- * — deleted. The rule engine stays the single source of truth; this file only
- * re-groups its violations by the DRIVING population per leg, so an EMPTY
- * population still counts against the gate (the vacuous-complete case a
- * per-element warning rule cannot see on its own — closed for real by
- * `@sigloch/contracts/se`'s R-28 Ebenen-Präsenz, CR-SM-226; die Regel selbst ist mit CR-SM-247 entfallen).
- *
- * BROWSER-SAFE — no `node:*` import may enter this file: the panels layer builds on it.
- *
- * @author andreas@siglochconsulting
- */
-import { z } from 'zod/v4';
-/** A gate's structural completeness over its driving population — ein Zod-Vertrag (CR-SM-361). */
-export const GateCompleteness = z.object({
-    /** Source elements whose chain leg is complete. */
-    covered: z.number().int().nonnegative(),
-    /** Total source elements evaluated across the gate's legs (the denominator). */
-    total: z.number().int().nonnegative(),
-    /** Per-leg misses as `"<leg>: <uid>"` — the on-click drill-down detail. */
-    missing: z.array(z.string()),
-});
-/** Neutral completeness for gates that carry no chain slice (impl gates). */
-export const NEUTRAL_COMPLETENESS = GateCompleteness.parse({ covered: 0, total: 0, missing: [] });
-export const typeOf = (byId, id) => byId.get(id)?.type;
-/**
- * Phase-gate → chain legs that must be complete AT THAT PHASE, each backed by
- * its `@sigloch/contracts` rule twin (CR-SM-226):
- *   SRR: SYS→UC ≈ R-17 (SYS must have compose; not UC-typed specifically —
- *        no dedicated SYS→UC rule exists, R-17 is the closest twin),
- *        UC→FCHAIN = UC-03, UC→REQ = UC-01.
- *   PDR: FCHAIN→FUNC = R-15, FCHAIN-actor-bounded = FC-04 (trigger+consumer),
- *        FUNC→MOD = R-22 (CR-SM-389: jede FUNC wohnt in einem Modul). Der Pattern ist
- *        `0..1` — seine Untergrenze ist R-22 (warning, nicht error: das Apply-Gate lehnt
- *        neu eingefuehrte Errors ab, jede FUNC muesste sonst mit ihrem Modul im selben
- *        Zug entstehen). Das Bein sperrt `passed`, nicht das Gate. R-23 (MOD ohne FUNC)
- *        ist bewusst KEIN Bein: ein leeres Modul laesst keine Funktion unverortet — es
- *        ist Ueberschuss, keine Luecke; die treibende Population ist FUNC, und dieselbe
- *        allocate-Kante wuerde nur ein zweites Mal von der anderen Seite gezaehlt.
- *   CDR: FLOW→SCHEMA = R-18 (seit CR-SM-271: die Untergrenze ist Grammatik,
- *        `FLOW -relation-> SCHEMA [1..1]` — SC-04 existiert nicht mehr; ein
- *        R-18-Befund am FLOW heisst "Kanten ungrammatisch", inkl. fehlendem
- *        oder doppeltem SCHEMA).
- *   TRR: TEST.testRefs = R-19, FUNC.realRef = R-20.
- */
-export const COMPLETENESS_SLICES = {
-    // Behavioral spine exists: system has use cases, every UC derives a chain AND requirements.
-    SRR: [
-        { id: 'SYS→UC', sourceType: 'SYS', ruleId: 'R-17' },
-        { id: 'UC→FCHAIN', sourceType: 'UC', ruleId: 'UC-03' },
-        { id: 'UC→REQ', sourceType: 'UC', ruleId: 'UC-01' },
-    ],
-    // Functional architecture: every chain has functions AND is actor-bounded (trigger + consumer),
-    // and every function is allocated to a module (CR-SM-389).
-    PDR: [
-        { id: 'FCHAIN→FUNC', sourceType: 'FCHAIN', ruleId: 'R-15' },
-        { id: 'FCHAIN-actor-bounded', sourceType: 'FCHAIN', ruleId: 'FC-04' },
-        { id: 'FUNC→MOD', sourceType: 'FUNC', ruleId: 'R-22' },
-    ],
-    // Interfaces carry a data contract: every FLOW has a SCHEMA (CR-GC-106 schema-before-code).
-    // CR-SM-271: SC-04 entfiel — der Fall meldet als R-18 (Untergrenzen-Bein) am FLOW.
-    CDR: [
-        { id: 'FLOW→SCHEMA', sourceType: 'FLOW', ruleId: 'R-18' },
-    ],
-    // Binding: tests are runnable and functions carry code — concept/external exemptions
-    // are R-19/R-20's own business now (single source of truth), not re-decided here.
-    TRR: [
-        { id: 'TEST.testRefs', sourceType: 'TEST', ruleId: 'R-19' },
-        { id: 'FUNC.realRef', sourceType: 'FUNC', ruleId: 'R-20' },
-    ],
-};
-/**
- * Score one phase gate's structural completeness over its driving population.
- * `total === 0` (no source elements to cover) → vacuously complete (ratio 1).
- * `violations` is the full rule-stream output (e.g. `harness.evaluateRules()`);
- * only the leg's own `ruleId` is consulted per node.
- */
-export function scoreCompleteness(gateId, graph, violations) {
-    const legs = COMPLETENESS_SLICES[gateId] ?? [];
-    let covered = 0;
-    let total = 0;
-    const missing = [];
-    for (const leg of legs) {
-        const violatingIds = new Set(violations
-            .filter((v) => v.ruleId === leg.ruleId && v.elementId !== undefined)
-            .map((v) => v.elementId));
-        for (const node of graph.nodes) {
-            if (node.type !== leg.sourceType)
-                continue;
-            total += 1;
-            if (violatingIds.has(node.uid))
-                missing.push(`${leg.id}: ${node.uid}`);
-            else
-                covered += 1;
-        }
-    }
-    return GateCompleteness.parse({ covered, total, missing }); // CR-SM-361: der Erzeuger prueft seinen Vertrag
-}