kibi-cli 2.31.1 → 2.35.1

package/dist/report/html-report.js

@@ -143,6 +143,8 @@ function implementationOwned(stages) {
     return productionSymbols.every((symbol) => !missingCoordinates.has(symbol));
 }
 function passesProofGate(row, gate) {
+    if (gate === "proved")
+        return row.evidenceLevel === "proved";
     if (row.proofStatus === "tested")
         return true;
     const stages = record(row.proofStages);
@@ -174,10 +176,16 @@ function proofGates(rows) {
             "Production ownership is source-bound",
         ],
         ["e2e", "E2E", "A scenario-backed end-to-end test exists"],
-        ["evidence", "Evidence", "Every strict proof stage passes now"],
+        ["evidence", "Tested", "Fresh passing receipts cover every scenario"],
+        ["proved", "Proved", "Every claim has a re-checked certificate"],
     ];
+    const claims = claimTotals(rows);
+    const claimDetail = claims.applicable === 0
+        ? ""
+        : ` · ${claims.proved.toLocaleString("en-US")} of ${claims.applicable.toLocaleString("en-US")} claims proved`;
     let candidates = [...rows];
-    return definitions.map(([key, label, detail]) => {
+    return definitions.map(([key, label, baseDetail]) => {
+        const detail = key === "proved" ? `${baseDetail}${claimDetail}` : baseDetail;
         const remainingRows = candidates.filter((row) => passesProofGate(row, key));
         const gate = {
             key,
@@ -206,6 +214,25 @@ export function earliestUnmetGate(row) {
         return "tested";
     return firstFailingProofGate(["semantic", "scenario", "implementation", "e2e", "evidence"], (gate) => passesProofGate(row, gate));
 }
+// The rail's last step: a tested requirement still short of a certificate
+// for every claim stops at "proved". Signoff keeps earliestUnmetGate, where
+// tested is the end of the strict chain.
+function reportGate(row) {
+    const gate = earliestUnmetGate(row);
+    if (gate !== "tested")
+        return gate;
+    return passesProofGate(row, "proved") ? "tested" : "proved";
+}
+function claimTotals(rows) {
+    let proved = 0;
+    let applicable = 0;
+    for (const row of rows) {
+        const claims = record(row.claimSummary);
+        proved += count(claims.proved);
+        applicable += count(claims.applicable);
+    }
+    return { proved, applicable };
+}
 function evidenceStage(passingE2e, testSources, repository) {
     const evidence = records(passingE2e.receiptEvidence);
     const passed = evidence.find((item) => item.state === "passed");
@@ -285,6 +312,7 @@ function requirementStages(row, repository) {
     const testSources = sourceCoordinates(record(stages.scenarioTests).sources);
     const productionSources = sourceCoordinates(productionSymbols.coordinates);
     const executableSources = sourceCoordinates(executableSymbols.coordinates);
+    const certificate = certificateStage(row);
     let implementationState = "failed";
     let implementationDetail = "No production symbol ownership";
     if (stageStatus(productionSymbols) === "passed" &&
@@ -342,6 +370,7 @@ function requirementStages(row, repository) {
             state: e2eState,
         },
         evidenceStage(passingE2e, testSources, repository),
+        ...(certificate === undefined ? [] : [certificate]),
     ];
 }
 function renderStage(stage) {
@@ -395,16 +424,36 @@ function renderContradiction(conflict) {
     <p>${escapeHtml(text(conflict.reason, "Two current requirements encode incompatible claims."))}</p>
   </div>`;
 }
+/**
+ * The requirement's evidence floor, when it has one: required_evidence, or
+ * tested for a firm requirement. A floor of unverified accepts anything and
+ * reads as no floor.
+ */
+// implements REQ-kibi-evidence-floors
+function evidenceFloor(row) {
+    const floor = record(row.evidenceFloor);
+    const required = text(floor.required);
+    if (!required || required === "unverified")
+        return undefined;
+    return {
+        required,
+        source: text(floor.source, "explicit"),
+        status: text(floor.status, "below"),
+    };
+}
 function rowSeverity(row) {
     const gaps = strings(row.proofGaps);
     if (gaps.includes("blocking_contradiction"))
         return 0;
-    if (gaps.includes("stale_proof_receipt"))
+    if (evidenceFloor(row)?.status === "below")
         return 1;
-    if (row.proofStatus !== "tested")
+    if (gaps.includes("stale_proof_receipt"))
         return 2;
-    return 3;
+    if (row.proofStatus !== "tested")
+        return 3;
+    return 4;
 }
+// implements REQ-kibi-html-health-report, REQ-kibi-evidence-floors
 function rowStates(row) {
     const states = new Set();
     const gaps = strings(row.proofGaps);
@@ -412,18 +461,95 @@ function rowStates(row) {
         states.add("tested");
     else
         states.add("attention");
+    if (row.evidenceLevel === "proved")
+        states.add("proved");
+    const floorStatus = evidenceFloor(row)?.status;
+    if (floorStatus === "below")
+        states.add("below_floor");
+    if (floorStatus === "pending_reproof")
+        states.add("pending_reproof");
     if (gaps.includes("stale_proof_receipt"))
         states.add("stale");
     if (gaps.includes("blocking_contradiction"))
         states.add("contradiction");
     return [...states].join(" ");
 }
+const FLOOR_STATUS_LABELS = {
+    met: "met",
+    below: "below",
+    pending_reproof: "pending re-proof",
+};
+// implements REQ-kibi-evidence-floors
+function renderFloorChip(floor) {
+    if (floor === undefined)
+        return "";
+    const origin = floor.source === "firmness"
+        ? "the default floor for a firm requirement"
+        : "set by required_evidence";
+    const status = FLOOR_STATUS_LABELS[floor.status] ?? humanize(floor.status);
+    return ` <span class="evidence-floor evidence-floor--${escapeHtml(floor.status)}" title="Evidence floor: ${escapeHtml(floor.required)}, ${escapeHtml(origin)}">floor ${escapeHtml(floor.required)}${floor.source === "explicit" ? "*" : ""} · ${escapeHtml(status)}</span>`;
+}
+/**
+ * Certificates a requirement's tests carry: the proof kinds that earned
+ * proved, and certificates or claim bindings that no longer re-check.
+ */
+// implements REQ-kibi-code-proof-kinds
+function certificateStage(row) {
+    const certificate = records(row.evidence).find((entry) => text(entry.kind) === "certificate");
+    const rejections = certificateRejectionLines(row);
+    const claims = record(row.claimSummary);
+    const applicable = count(claims.applicable);
+    const proved = count(claims.proved);
+    const claimText = applicable > 0 ? `${proved}/${applicable} claims proved` : "";
+    if (certificate !== undefined) {
+        const kinds = strings(certificate.kinds).join(", ");
+        const tests = strings(certificate.tests);
+        return {
+            label: "Certificate",
+            detail: escapeHtml([
+                `${kinds || "certificate"} · ${tests.length} ${tests.length === 1 ? "test" : "tests"}`,
+                claimText,
+            ]
+                .filter(Boolean)
+                .join(" · ")),
+            state: rejections.length > 0 ? "warning" : "passed",
+        };
+    }
+    if (rejections.length > 0) {
+        return {
+            label: "Certificate",
+            detail: escapeHtml(`${rejections.length} ${rejections.length === 1 ? "certificate does" : "certificates do"} not re-check`),
+            state: "failed",
+        };
+    }
+    if (proved > 0 || count(claims.attested) > 0) {
+        return {
+            label: "Certificate",
+            detail: escapeHtml(claimText),
+            state: "warning",
+        };
+    }
+    return undefined;
+}
+// implements REQ-kibi-code-proof-kinds
+export function certificateRejectionLines(row) {
+    return [
+        ...records(row.certificateRejections).map((item) => `${text(item.test, "test")}: certificate rejected, ${text(item.reason, "no reason given")}`),
+        ...records(row.claimBindingRejections).map((item) => `${text(item.test, "test")}: binding for ${text(item.claimKey, "claim")} rejected, ${text(item.reason, "no reason given")}`),
+    ];
+}
 function renderIssueList(codes, className, singular, plural) {
     if (codes.length === 0)
         return "";
     const label = `${codes.length} ${codes.length === 1 ? singular : plural}`;
     return `<details class="${className}"><summary>${escapeHtml(label)}</summary><ul>${codes.map((code) => `<li>${escapeHtml(humanize(code))}</li>`).join("")}</ul></details>`;
 }
+function renderRejectionList(lines) {
+    if (lines.length === 0)
+        return "";
+    const label = `${lines.length} ${lines.length === 1 ? "certificate rejection" : "certificate rejections"}`;
+    return `<details class="proof-gaps certificate-rejections"><summary>${escapeHtml(label)}</summary><ul>${lines.map((line) => `<li>${escapeHtml(line)}</li>`).join("")}</ul></details>`;
+}
 function renderRequirement(row, repository) {
     const id = text(row.id, "REQ-UNKNOWN");
     const title = text(row.title, "Untitled requirement");
@@ -439,42 +565,85 @@ function renderRequirement(row, repository) {
         : proofAdvisories;
     const conflicts = records(record(record(row.proofStages).contradictions).conflicts).filter((conflict) => text(conflict.status) === "contradiction");
     const stages = requirementStages(row, repository);
-    const badgeLabel = proofStatus === "tested" ? "Tested" : "Needs attention";
     const evidenceLevel = text(row.evidenceLevel, "unverified");
+    const badgeLabel = proofStatus !== "tested"
+        ? "Needs attention"
+        : evidenceLevel === "proved"
+            ? "Proved"
+            : "Tested";
+    const floor = evidenceFloor(row);
+    const rejections = certificateRejectionLines(row);
+    const claims = claimsProvedLabel(row);
     const requirementSource = sourceCoordinate({
         path: text(record(record(row.proofStages).sourceCoordinates).requirementPath, text(row.source)),
     }) ?? sourceCoordinate({ path: text(row.source) });
-    const gate = earliestUnmetGate(row);
+    const gate = reportGate(row);
     return `<article class="requirement requirement--${escapeHtml(proofStatus)}" data-state="${rowStates(row)}" data-gate="${escapeHtml(gate)}">
     <header class="requirement__header">
       <div>
-        <div class="requirement__id">${linkedLabel(id, sourceWebUrl(repository, requirementSource))} <span class="evidence-level evidence-level--${escapeHtml(evidenceLevel)}" title="Evidence level">${escapeHtml(evidenceLevel)}</span></div>
+        <div class="requirement__id">${linkedLabel(id, sourceWebUrl(repository, requirementSource))} <span class="evidence-level evidence-level--${escapeHtml(evidenceLevel)}" title="Evidence level">${escapeHtml(evidenceLevel)}</span>${renderFloorChip(floor)}${claims === null ? "" : ` <span class="claims-proved" title="Requirement claims a re-checked certificate derives">${escapeHtml(claims)}</span>`}</div>
         <h3>${linkedLabel(title, sourceWebUrl(repository, requirementSource))}</h3>
       </div>
-      <span class="proof-badge proof-badge--${escapeHtml(proofStatus)}">${escapeHtml(badgeLabel)}</span>
+      <span class="proof-badge proof-badge--${escapeHtml(badgeLabel === "Proved" ? "proved" : proofStatus)}">${escapeHtml(badgeLabel)}</span>
     </header>
     <ul class="stages">${stages.map(renderStage).join("")}</ul>
     ${conflicts.map(renderContradiction).join("")}
     ${renderIssueList(blockingGaps, "proof-gaps", "proof gap", "proof gaps")}
     ${renderIssueList(advisories, "proof-advisories", "advisory", "advisories")}
+    ${renderRejectionList(rejections)}
   </article>`;
 }
+// implements REQ-kibi-claim-bound-proofs
+function claimsProvedLabel(row) {
+    const summary = record(row.claimSummary);
+    const applicable = summary.applicable;
+    if (typeof applicable !== "number" || applicable === 0)
+        return null;
+    const proved = typeof summary.proved === "number" ? summary.proved : 0;
+    return `${proved}/${applicable} claims proved`;
+}
 // implements REQ-kibi-evidence-levels
 function evidenceCount(rows, level) {
     return rows.filter((row) => text(row.evidenceLevel, "unverified") === level)
         .length;
 }
+// implements REQ-kibi-kb-certificates
+function renderKbCertificates(bundle) {
+    if (bundle === undefined)
+        return "";
+    const kinds = Object.entries(bundle.kinds)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([kind, total]) => `${total.toLocaleString("en-US")} ${humanize(kind).toLowerCase()}`)
+        .join(", ");
+    return `<p class="kb-certificates">KB consistency: ${bundle.count.toLocaleString("en-US")} ${bundle.count === 1 ? "certificate" : "certificates"}${kinds ? ` (${escapeHtml(kinds)})` : ""} · <a href="${escapeHtml(bundle.href)}">${escapeHtml(bundle.href)}</a> · re-check with <code>kibi check --certificates ${escapeHtml(bundle.href)}</code></p>`;
+}
 function metric(label, value, tone = "") {
     return `<div class="metric${tone ? ` metric--${tone}` : ""}"><span>${escapeHtml(label)}</span><strong>${value.toLocaleString("en-US")}</strong></div>`;
 }
 function renderProofGate(gate, index) {
-    const state = gate.remaining === 0 ? "blocked" : "active";
+    // Proved sits above the default tested floor, so stopping before it is not
+    // a block; floors that require proved show up as Below evidence floor.
+    const optional = gate.key === "proved";
+    const state = optional
+        ? "optional"
+        : gate.remaining === 0
+            ? "blocked"
+            : "active";
     const drop = gate.blocked === 0
         ? "No drop"
-        : `−${gate.blocked.toLocaleString("en-US")} blocked here`;
-    const accessible = `${gate.label}. ${gate.blocked} blocked here. Filter requirements whose earliest unmet proof gate is ${gate.label}.`;
+        : optional
+            ? `${gate.blocked.toLocaleString("en-US")} tested, not proved`
+            : `−${gate.blocked.toLocaleString("en-US")} blocked here`;
+    const stopped = optional
+        ? `${gate.blocked} tested, not proved`
+        : `${gate.blocked} blocked here`;
+    // A gate nobody stops at has nothing to show, so it is not a filter.
+    const empty = gate.blocked === 0;
+    const accessible = empty
+        ? `${gate.label}. No requirement stops here.`
+        : `${gate.label}. ${stopped}. Filter requirements whose earliest unmet proof gate is ${gate.label}.`;
     return `<li>
-    <button type="button" class="proof-gate proof-gate--${state}" data-gate="${escapeHtml(gate.key)}" aria-pressed="false" aria-controls="requirements" aria-label="${escapeHtml(accessible)}">
+    <button type="button" class="proof-gate proof-gate--${state}" data-gate="${escapeHtml(gate.key)}" data-label="${escapeHtml(gate.label)}" aria-pressed="false" aria-controls="requirements" aria-label="${escapeHtml(accessible)}"${empty ? " disabled" : ""}>
       <div class="proof-gate__node"><span>${index + 1}</span></div>
       <div class="proof-gate__count">${gate.remaining.toLocaleString("en-US")}</div>
       <div class="proof-gate__label">${escapeHtml(gate.label)}</div>
@@ -519,8 +688,11 @@ function reportIdentity(input) {
 function renderFilters(counts) {
     const labels = {
         all: "All",
+        proved: "Proved",
         tested: "Tested",
         attention: "Needs attention",
+        below_floor: "Below floor",
+        pending_reproof: "Pending re-proof",
         stale: "Stale evidence",
         contradiction: "Contradictions",
     };
@@ -551,6 +723,8 @@ export function renderHtmlReport(input) {
     const staleEvidence = currentRows.filter((row) => strings(row.proofGaps).includes("stale_proof_receipt")).length;
     const withoutImplementation = currentRows.filter((row) => strings(row.proofGaps).includes("missing_production_symbol")).length;
     const contradictions = contradictionRows(currentRows);
+    const belowFloor = currentRows.filter((row) => evidenceFloor(row)?.status === "below").length;
+    const pendingReproof = currentRows.filter((row) => evidenceFloor(row)?.status === "pending_reproof").length;
     const unmappedProductionSymbols = Math.max(0, count(symbolSummary.uncovered) - count(symbolSummary.mixedRole));
     const generatedAt = input.generatedAt.toISOString();
     const snapshot = text(input.requirements.meta?.proofSnapshot);
@@ -563,7 +737,7 @@ export function renderHtmlReport(input) {
     const filterCounts = reportFilterCounts(currentRows.map((row) => ({
         text: `${text(row.id)} ${text(row.title)}`,
         states: rowStates(row).split(" ").filter(Boolean),
-        earliestGate: earliestUnmetGate(row),
+        earliestGate: reportGate(row),
     })));
     const identity = reportIdentity({ ...input, repository });
     const faviconHref = renderKibiFaviconDataUri();
@@ -617,15 +791,19 @@ export function renderHtmlReport(input) {
       </section>
       <section class="metrics" aria-label="Requirement health summary">
         ${metric("Requirements", currentRequirements)}
+        ${metric("Proved by certificate", evidenceCount(currentRows, "proved"), evidenceCount(currentRows, "proved") ? "good" : "")}
         ${metric("Tested end to end", tested, "good")}
         ${metric("Asserted, no current test", evidenceCount(currentRows, "asserted"), evidenceCount(currentRows, "asserted") ? "warn" : "")}
         ${metric("Unverified", evidenceCount(currentRows, "unverified"), evidenceCount(currentRows, "unverified") ? "warn" : "")}
-        ${metric("Missing scenarios", missingScenarios, missingScenarios ? "warn" : "")}
+        ${metric("Below evidence floor", belowFloor, belowFloor ? "bad" : "good")}
+        ${metric("Pending re-proof", pendingReproof, pendingReproof ? "warn" : "")}
         ${metric("Stale E2E evidence", staleEvidence, staleEvidence ? "warn" : "")}
-        ${metric("Contradictions", contradictions.length, contradictions.length ? "bad" : "")}
-        ${metric("Unmapped production symbols", unmappedProductionSymbols, unmappedProductionSymbols ? "bad" : "")}
+        ${metric("Missing scenarios", missingScenarios, missingScenarios ? "warn" : "")}
         ${metric("Requirements without implementation", withoutImplementation, withoutImplementation ? "warn" : "")}
+        ${metric("Unmapped production symbols", unmappedProductionSymbols, unmappedProductionSymbols ? "bad" : "")}
+        ${metric("Contradictions", contradictions.length, contradictions.length ? "bad" : "")}
       </section>
+      ${renderKbCertificates(input.kbCertificates)}
       <section>
         <div class="section-header">
           <div><p class="eyebrow">Proof ledger</p><h2>Requirements</h2></div>
@@ -637,6 +815,7 @@ export function renderHtmlReport(input) {
             ${renderFilters(filterCounts)}
           </div>
         </div>
+        <p class="gate-status" id="gate-status" aria-live="polite" hidden><span></span> <button type="button" class="gate-status__clear">Show all</button></p>
         <div class="requirements" id="requirements">${currentRows.map((row) => renderRequirement(row, repository)).join("")}</div>
         <div class="empty" id="empty" aria-live="polite">No requirements match this view.</div>
       </section>
@@ -653,6 +832,8 @@ export function renderHtmlReport(input) {
       const filters = [...document.querySelectorAll(".filter")];
       const gates = [...document.querySelectorAll(".proof-gate")];
       const empty = document.querySelector("#empty");
+      const gateStatus = document.querySelector("#gate-status");
+      const gateStatusText = gateStatus.querySelector("span");
       let activeFilter = "all";
       let activeGate = "all";
       const formatRelativeAge = (fromMs, nowMs) => {
@@ -689,7 +870,20 @@ export function renderHtmlReport(input) {
           if (!card.hidden) visible += 1;
         }
         empty.dataset.visible = String(visible === 0);
+        const selectedGate = gates.find((candidate) => candidate.dataset.gate === activeGate);
+        gateStatus.hidden = selectedGate === undefined;
+        if (selectedGate) {
+          gateStatusText.textContent = visible + (visible === 1 ? " requirement stops" : " requirements stop") + " at " + (selectedGate.dataset.label || activeGate) + ".";
+        }
       };
+      const selectGate = (selected) => {
+        activeGate = selected;
+        for (const candidate of gates) {
+          candidate.setAttribute("aria-pressed", String(candidate.dataset.gate === activeGate));
+        }
+        apply();
+      };
+      gateStatus.querySelector("button").addEventListener("click", () => selectGate("all"));
       search.addEventListener("input", apply);
       for (const filter of filters) {
         filter.addEventListener("click", () => {
@@ -701,11 +895,9 @@ export function renderHtmlReport(input) {
       for (const gate of gates) {
         gate.addEventListener("click", () => {
           const selected = gate.dataset.gate || "all";
-          activeGate = activeGate === selected ? "all" : selected;
-          for (const candidate of gates) {
-            candidate.setAttribute("aria-pressed", String(candidate.dataset.gate === activeGate));
-          }
-          apply();
+          selectGate(activeGate === selected ? "all" : selected);
+          // The ledger sits below the fold; bring the filtered rows into view.
+          if (activeGate !== "all") gateStatus.scrollIntoView({ behavior: "smooth", block: "start" });
         });
       }
       refreshAges();

package/dist/report/report-view.d.ts

@@ -1,6 +1,6 @@
-export declare const REPORT_FILTERS: readonly ["all", "tested", "attention", "stale", "contradiction"];
+export declare const REPORT_FILTERS: readonly ["all", "proved", "tested", "attention", "below_floor", "pending_reproof", "stale", "contradiction"];
 export type ReportFilter = (typeof REPORT_FILTERS)[number];
-export declare const PROOF_GATE_KEYS: readonly ["semantic", "scenario", "implementation", "e2e", "evidence"];
+export declare const PROOF_GATE_KEYS: readonly ["semantic", "scenario", "implementation", "e2e", "evidence", "proved"];
 export type ProofGateKey = (typeof PROOF_GATE_KEYS)[number];
 export type RequirementView = Readonly<{
     text: string;

package/dist/report/report-view.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"report-view.d.ts","sourceRoot":"","sources":["../../src/report/report-view.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,mEAMjB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAE3D,eAAO,MAAM,eAAe,wEAMlB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5D,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,YAAY,EAAE,YAAY,GAAG,QAAQ,CAAC;CACvC,CAAC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,YAAY,CAAC;IACrB,IAAI,EAAE,YAAY,GAAG,KAAK,CAAC;CAC5B,CAAC,CAAC;AAGH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,eAAe,GACpB,OAAO,CAQT;AAGD,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,SAAS,eAAe,EAAE,GAC/B,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CASxC"}
+{"version":3,"file":"report-view.d.ts","sourceRoot":"","sources":["../../src/report/report-view.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,+GASjB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAE3D,eAAO,MAAM,eAAe,kFAOlB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5D,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,YAAY,EAAE,YAAY,GAAG,QAAQ,CAAC;CACvC,CAAC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,YAAY,CAAC;IACrB,IAAI,EAAE,YAAY,GAAG,KAAK,CAAC;CAC5B,CAAC,CAAC;AAGH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,eAAe,GACpB,OAAO,CAQT;AAGD,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,SAAS,eAAe,EAAE,GAC/B,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAexC"}

package/dist/report/report-view.js

@@ -1,7 +1,10 @@
 export const REPORT_FILTERS = [
     "all",
+    "proved",
     "tested",
     "attention",
+    "below_floor",
+    "pending_reproof",
     "stale",
     "contradiction",
 ];
@@ -11,6 +14,7 @@ export const PROOF_GATE_KEYS = [
     "implementation",
     "e2e",
     "evidence",
+    "proved",
 ];
 // implements REQ-kibi-html-health-report
 export function matchesReportView(row, view) {
@@ -24,8 +28,12 @@ export function matchesReportView(row, view) {
 export function reportFilterCounts(rows) {
     return {
         all: rows.length,
+        proved: rows.filter((row) => row.states.includes("proved")).length,
         tested: rows.filter((row) => row.states.includes("tested")).length,
         attention: rows.filter((row) => row.states.includes("attention")).length,
+        below_floor: rows.filter((row) => row.states.includes("below_floor"))
+            .length,
+        pending_reproof: rows.filter((row) => row.states.includes("pending_reproof")).length,
         stale: rows.filter((row) => row.states.includes("stale")).length,
         contradiction: rows.filter((row) => row.states.includes("contradiction"))
             .length,