-
+
Reviewer/operator answers for interpreting the local routing proof without turning demo evidence into a production claim.
+
How to Interpret This Decision
+
+
+
How was the selected backend chosen?
+
The first returned comparison result is the primary local decision. It names the selected backend/server, includes returned reason text, and should be read against the visible candidate list.
+
-
How the selected strategy affects the selected backend
-
The first returned strategy is the primary local comparison result; its routing rule ranks the visible candidate servers and returns the selected backend/server plus reason text.
+
How did the selected strategy influence the decision?
+
The selected strategy applies its scoring or selection behavior to the same visible candidates; compare the strategy name, selected backend/server, and reason text before treating two results as equivalent.
-
How input signals influence the routing proof
+
How did input signals affect the proof?
Health, in-flight load, configured weight/capacity, p95 latency, error rate, queue depth, and network-awareness fields are summarized from the visible payload so reviewers can inspect why a backend was preferred or avoided.
-
How scenario comparison deltas are summarized
-
Deltas are browser-local summaries comparing packaged baseline metrics against the current editor payload: candidate count, healthy/unhealthy count, total in-flight load, max p95 latency, max error rate, and queue depth.
+
How should reviewers interpret confidence/limits?
+
Confidence means the browser can repeat the same local sample flow, show deterministic visible inputs, and copy the same reviewer note; it does not mean the result is approved for production use.
-
How degradation, unhealthy, and recovery states are represented
-
Unhealthy backends are counted from healthy=false; all-unhealthy payloads are called out as a degradation boundary, while fewer unhealthy backends than the baseline are described as recovery.
+
How does this differ from production proof?
+
Local/demo proof uses synthetic payloads, same-origin local API responses, and browser-local notes; it does not prove production traffic, live cloud behavior, real tenant behavior, registry publication, container signing, or production certification.
+
+
How Strategy Choice Matters
+
-
How to reproduce the same proof locally
-
Run mvn spring-boot:run, open this page, load the sample scenario, run Compare strategies, and compare the visible response with the copyable curl and proof notes.
+
Strategy affects scoring/selection behavior
+
Each strategy can rank the same candidates differently, so reviewers should compare the selected strategy, selected backend/server, and returned reason before drawing conclusions.
-
How evidence pages relate to the proof
-
The routing page explains the request-level decision; reviewer, operator, timeline, and export packet pages provide navigation, evidence locations, history context, and handoff text.
+
Strategy changed but backend stayed the same
+
The selected backend can remain unchanged even if the strategy changes when multiple strategies still prefer the same local candidate.
-
How the copied association summary should be used
-
Use the copied association summary as a reviewer note that points to visible local proof and evidence pages; it is not an audit artifact created by the server.
+
Backend changed but strategy stayed the same
+
The selected backend can change under the same strategy when visible signals such as health, in-flight load, latency, error rate, queue depth, or capacity shift.
-
How local/demo proof differs from production proof
-
Local/demo proof uses synthetic payloads, same-origin local API responses, and browser-local notes; it does not prove production traffic, live cloud behavior, real tenant behavior, registry publication, container signing, or production certification.
+
Explanatory/demo evidence only
+
Cockpit output explains local sample behavior; it is not production certification, SLA/SLO proof, real-tenant proof, live-cloud proof, or registry/signing proof.
-
Edge-case reading guide
+
How to Reproduce This Proof
+
+ - Run the app locally and open
/routing-demo.html.
+ - Load a sample scenario so the request editor uses deterministic synthetic input.
+ - Run routing comparison to call the same-origin local
/api/routing/compare endpoint.
+ - Review selected strategy/backend in Routing Proof Summary.
+ - Compare scenario deltas for strategy, backend/server, input signal, and degradation/recovery changes.
+ - Copy proof, walkthrough, association, or how-to summaries from visible browser text.
+ - Follow evidence pages for reviewer dashboard, operator evidence, timeline/history, and export packet handoff.
+ - Use browser-local export/copy/print packet actions from
/evidence-export-packet.html.
+
+
How Evidence Supports the Decision
+
+
+
Routing Proof Summary is the immediate decision view
+
It shows the selected strategy, selected backend/server, visible input signals, and local/demo boundary for the current comparison.
+
+
+
Scenario Comparison shows change over time/input states
+
It summarizes previous/current scenario names, strategy/backend deltas, signal deltas, and degradation or recovery notes from visible local inputs.
+
+
+
Scenario comparison deltas are browser-local summaries
+
Deltas compare packaged baseline metrics against the current editor payload: candidate count, healthy/unhealthy count, total in-flight load, max p95 latency, max error rate, and queue depth.
+
+
+
Evidence Navigation links related reviewer pages
+
Reviewer, operator, timeline, and export packet pages are static navigation aids for following the proof path; they are not live telemetry or certification pages.
+
+
+
Export packet is a local reviewer handoff
+
The packet page supports browser-local copy, download, and print review; it is not a server-generated certification artifact.
+
+
+
How to Read Edge Cases
- No previous scenario has been captured yet; the packaged normal-load baseline remains the static reference.
- Same scenario run twice or unchanged from baseline: strategy order and input signal totals should read as unchanged.
@@ -530,7 +575,15 @@ Edge-case reading guide
- API error or unavailable local server: Local API response unavailable; static guidance remains available.
- Copy-to-clipboard failure fallback: Copy failed; select the visible text and copy manually.
- Static page loaded without prior interaction: static guidance and evidence links remain available before running a scenario.
+ - Evidence links before scenario execution: Evidence links are available even before running a scenario.
+
+ Copy boundary: the how-to reviewer explanation is assembled in the browser from visible static guidance
+ and local comparison state only; no upload/share endpoint, no server-side export/PDF/ZIP generation,
+ no external calls, and no telemetry.
+
+
Copyable how-to reviewer explanation
+
Static guidance remains available before running a scenario. Load the sample scenario and run Compare strategies to generate the how-to reviewer explanation.
@@ -920,7 +973,8 @@
6. Safety limitations
proofSummary: document.getElementById("proof-summary-output"),
scenarioComparison: document.getElementById("scenario-comparison-output"),
reviewerWalkthrough: document.getElementById("reviewer-walkthrough-output"),
- evidenceAssociation: document.getElementById("evidence-association-output")
+ evidenceAssociation: document.getElementById("evidence-association-output"),
+ howToReviewer: document.getElementById("how-to-reviewer-output")
};
const proofFields = {
strategy: document.getElementById("proof-strategy"),
@@ -1163,6 +1217,7 @@
6. Safety limitations
renderScenarioComparison();
renderEvidenceAssociations();
renderReviewerWalkthrough();
+ renderHowToReviewerExplanation();
}
function currentRequestPayload() {
@@ -1580,6 +1635,80 @@
6. Safety limitations
].join("\n");
}
+ function renderHowToReviewerExplanation() {
+ const results = lastRoutingBody && Array.isArray(lastRoutingBody.results)
+ ? lastRoutingBody.results
+ : [];
+ const primary = results.length > 0 ? results[0] : null;
+ const selectedStrategy = primary && primary.strategyId ? primary.strategyId : "not run";
+ const selectedBackend = primary && primary.chosenServerId ? primary.chosenServerId : "not run";
+ const reason = primary && primary.reason
+ ? primary.reason
+ : (lastRoutingError || "No routing reason is available until Compare strategies runs. Static guidance remains available before interaction.");
+ const proofSignals = proofFields.signals.textContent || "Run Compare strategies to summarize visible request fields.";
+ const comparisonSignals = scenarioFields.signals.textContent || "Run Compare strategies to compare input signal deltas.";
+ const degradation = scenarioFields.degradation.textContent || "Run Compare strategies to compare degradation or recovery notes.";
+
+ outputs.howToReviewer.textContent = [
+ "# Cockpit How-To Reviewer Explanation",
+ "",
+ "howQuestionInventory:",
+ "- already answered: selected strategy/backend, input signals, scenario deltas, degradation/recovery notes, evidence path, copy boundaries, and local/demo limits",
+ "- clarified in this panel: interpretation sequence, reproduction steps, edge-case reading, strategy-choice effects, and evidence support boundaries",
+ "",
+ "howToInterpretThisDecision:",
+ "- selectedBackendChosen: " + selectedBackend + " from the primary local comparison result",
+ "- selectedStrategyInfluence: " + selectedStrategy + " applies its scoring or selection behavior to visible local candidates",
+ "- returnedReason: " + reason,
+ "- inputSignalsAffectingProof: " + proofSignals,
+ "- confidenceLimits: local repeatability and deterministic visible inputs only; not production certification",
+ "- localVsProductionProof: synthetic payloads, same-origin local API responses, and browser-local notes do not prove production traffic, live cloud behavior, real tenant behavior, registry publication, container signing, GitHub settings mutation, or production certification",
+ "",
+ "howToReproduceThisProof:",
+ "1. run the app locally and open /routing-demo.html",
+ "2. load a sample scenario",
+ "3. run routing comparison",
+ "4. review selected strategy/backend in Routing Proof Summary",
+ "5. compare scenario deltas",
+ "6. copy proof, walkthrough, association, or how-to summaries",
+ "7. follow evidence pages",
+ "8. export/copy/print packet from /evidence-export-packet.html",
+ "",
+ "howToReadEdgeCases:",
+ "- no previous scenario selected: packaged normal-load baseline remains the static reference",
+ "- same scenario run twice: strategy order and input signal totals should read as unchanged",
+ "- backend unchanged but signals changed: inspect the reason and visible scores/signals",
+ "- strategy changed but backend stayed the same: multiple methods can still prefer the same local candidate",
+ "- backend changed but strategy stayed the same: signal deltas can change which candidate the same strategy prefers",
+ "- all unhealthy/degraded scenario: treat it as a degradation boundary, not production proof",
+ "- empty comparison response: Local API returned an empty comparison response; static guidance remains available",
+ "- API unavailable/error: Local API response unavailable; static guidance remains available",
+ "- copy fallback: Copy failed; select the visible text and copy manually. Browser clipboard permission may be unavailable",
+ "- page loaded before interaction: static guidance and evidence links remain available before running a scenario",
+ "- evidence links before scenario execution: Evidence links are available even before running a scenario",
+ "",
+ "evidenceSupport:",
+ "- routingProofSummary: immediate decision view",
+ "- scenarioComparison: change over time/input states",
+ "- evidenceNavigationPath: " + evidenceNavigationPath(),
+ "- exportPacket: local reviewer handoff, not server-generated certification",
+ "- comparisonSignalSummary: " + comparisonSignals,
+ "- degradationRecoveryExplanation: " + degradation,
+ "",
+ "copyBoundary: browser-local copy action only; no upload/share endpoint; no server-side export/PDF/ZIP generation; no external calls; no telemetry",
+ "",
+ "notProven:",
+ "- no production traffic proof",
+ "- no live cloud proof",
+ "- no real tenant proof",
+ "- no registry publication proof",
+ "- no container signing proof",
+ "- no GitHub settings mutation proof",
+ "- no production certification claim",
+ "- no service-level agreement or service-level objective evidence"
+ ].join("\n");
+ }
+
function resetDemo() {
lastRoutingBody = null;
lastRoutingError = "";
diff --git a/src/test/java/com/richmond423/loadbalancerpro/api/ReviewerTrustMapDocumentationTest.java b/src/test/java/com/richmond423/loadbalancerpro/api/ReviewerTrustMapDocumentationTest.java
index 2c7083a3..45ac9b86 100644
--- a/src/test/java/com/richmond423/loadbalancerpro/api/ReviewerTrustMapDocumentationTest.java
+++ b/src/test/java/com/richmond423/loadbalancerpro/api/ReviewerTrustMapDocumentationTest.java
@@ -110,6 +110,7 @@ void reviewerTrustMapCoversPrimaryEvidencePaths() throws Exception {
"PROXY_DEMO_FIXTURE_LAUNCHER.md",
"routing-demo.html",
"Reviewer Workflow Checklist",
+ "How This Proof Works",
"Evidence Associations",
"Association Legend",
"Routing Proof Summary",
@@ -150,6 +151,7 @@ void reviewerDemoPathAnswersFastDemoQuestionsAndLocksEvidenceFiles() throws Exce
assertTrue(demoPath.contains("http://localhost:8080/routing-demo.html"));
assertTrue(demoPath.contains("http://localhost:8080/load-balancing-cockpit.html"));
assertTrue(demoPath.contains("Reviewer Workflow Checklist"));
+ assertTrue(demoPath.contains("How This Proof Works"));
assertTrue(demoPath.contains("Evidence Associations"));
assertTrue(demoPath.contains("Association Legend"));
assertTrue(demoPath.contains("Routing Proof Summary"));
@@ -163,6 +165,7 @@ void reviewerDemoPathAnswersFastDemoQuestionsAndLocksEvidenceFiles() throws Exce
assertTrue(demoPath.contains("degradation/recovery notes"));
assertTrue(demoPath.contains("local verification commands"));
assertTrue(demoPath.contains("routing-to-evidence dashboard links"));
+ assertTrue(demoPath.contains("copyable how-to reviewer explanation"));
assertTrue(demoPath.contains("copyable evidence association summary"));
assertTrue(demoPath.contains("copyable end-to-end reviewer walkthrough"));
assertTrue(demoPath.contains("explicit not-proven boundaries"));
@@ -229,10 +232,17 @@ void routingDemoScenarioComparisonTrustMapEntryIsDiscoverableAndBounded() throws
assertTrue(matrix.contains("How should a reviewer walk the routing cockpit end-to-end?"));
assertTrue(matrix.contains("How do routing decisions connect to reviewer evidence pages?"));
+ assertTrue(matrix.contains("How should reviewers interpret routing proof details and edge cases?"));
assertTrue(matrix.contains("How do routing proof scenarios compare?"));
assertTrue(matrix.contains("/routing-demo.html"));
assertTrue(matrix.contains("RoutingDecisionDemoTest"));
assertTrue(matrix.contains("Reviewer Workflow Checklist"));
+ assertTrue(matrix.contains("How This Proof Works"));
+ assertTrue(matrix.contains("How to Interpret This Decision"));
+ assertTrue(matrix.contains("How to Reproduce This Proof"));
+ assertTrue(matrix.contains("How to Read Edge Cases"));
+ assertTrue(matrix.contains("How Strategy Choice Matters"));
+ assertTrue(matrix.contains("How Evidence Supports the Decision"));
assertTrue(matrix.contains("Evidence Associations"));
assertTrue(matrix.contains("Association Legend"));
assertTrue(matrix.contains("Routing Proof Summary"));
@@ -240,6 +250,7 @@ void routingDemoScenarioComparisonTrustMapEntryIsDiscoverableAndBounded() throws
assertTrue(matrix.contains("Reviewer Confidence Signals"));
assertTrue(matrix.contains("Evidence Navigation reviewer path"));
assertTrue(matrix.contains("copyable evidence association summary"));
+ assertTrue(matrix.contains("copyable how-to reviewer explanation"));
assertTrue(matrix.contains("selected scenario-to-decision mapping"));
assertTrue(matrix.contains("selected strategy/backend mapping"));
assertTrue(matrix.contains("key input signal mapping"));
@@ -260,6 +271,9 @@ void routingDemoScenarioComparisonTrustMapEntryIsDiscoverableAndBounded() throws
assertTrue(normalized.contains("edited local demo payloads"));
assertTrue(normalized.contains("same-origin local api responses"));
assertTrue(normalized.contains("browser-local copy text"));
+ assertTrue(normalized.contains("how the selected backend was chosen"));
+ assertTrue(normalized.contains("strategy and input signals influenced the proof"));
+ assertTrue(normalized.contains("edge cases should be read"));
assertTrue(normalized.contains("upload/share endpoint behavior"));
assertTrue(normalized.contains("server-side export/pdf/zip generation"));
assertTrue(normalized.contains("production deployment certification"));
@@ -271,6 +285,37 @@ void routingDemoScenarioComparisonTrustMapEntryIsDiscoverableAndBounded() throws
assertTrue(normalized.contains("container signing"));
}
+ @Test
+ void routingCockpitHowQuestionGuideTrustMapSectionIsDiscoverableAndBounded() throws Exception {
+ String trustMap = read(TRUST_MAP);
+ String section = section(trustMap, "### Cockpit How-Question Guide", "## Reviewer Demo Path");
+ String normalized = section.toLowerCase(Locale.ROOT);
+
+ assertTrue(section.contains("Cockpit How-Question Guide"));
+ assertTrue(section.contains("/routing-demo.html"));
+ assertTrue(section.contains("How This Proof Works panel"));
+ assertTrue(section.contains("interpret the selected decision"));
+ assertTrue(section.contains("reproduce the proof"));
+ assertTrue(section.contains("read edge cases"));
+ assertTrue(section.contains("understand strategy choice"));
+ assertTrue(section.contains("follow evidence support"));
+ assertTrue(section.contains("copyable how-to reviewer explanation"));
+ assertTrue(normalized.contains("browser-local text"));
+ assertTrue(normalized.contains("visible page guidance"));
+ assertTrue(normalized.contains("local comparison state"));
+ assertTrue(normalized.contains("no upload/share endpoint"));
+ assertTrue(normalized.contains("no server-side export/pdf/zip generation"));
+ assertTrue(normalized.contains("no external calls"));
+ assertTrue(normalized.contains("no telemetry"));
+ assertTrue(normalized.contains("no production traffic proof"));
+ assertTrue(normalized.contains("no live cloud proof"));
+ assertTrue(normalized.contains("no real tenant proof"));
+ assertTrue(normalized.contains("no registry publication proof"));
+ assertTrue(normalized.contains("no container signing proof"));
+ assertTrue(normalized.contains("no github settings mutation proof"));
+ assertTrue(normalized.contains("no production certification claim"));
+ }
+
@Test
void routingCockpitEvidenceAssociationsTrustMapSectionIsDiscoverableAndBounded() throws Exception {
String trustMap = read(TRUST_MAP);
diff --git a/src/test/java/com/richmond423/loadbalancerpro/api/RoutingDecisionDemoTest.java b/src/test/java/com/richmond423/loadbalancerpro/api/RoutingDecisionDemoTest.java
index 11c766ca..cec46617 100644
--- a/src/test/java/com/richmond423/loadbalancerpro/api/RoutingDecisionDemoTest.java
+++ b/src/test/java/com/richmond423/loadbalancerpro/api/RoutingDecisionDemoTest.java
@@ -111,15 +111,18 @@ void routingDemoPageContainsExpectedEndpointsControlsAndStrategyText() throws Ex
assertTrue(page.contains("Routing proof summary -> supporting evidence pages"));
assertTrue(page.contains("Evidence pages -> export packet / reviewer handoff"));
assertTrue(page.contains("How This Proof Works"));
- assertTrue(page.contains("How the selected strategy affects the selected backend"));
- assertTrue(page.contains("How input signals influence the routing proof"));
- assertTrue(page.contains("How scenario comparison deltas are summarized"));
- assertTrue(page.contains("How degradation, unhealthy, and recovery states are represented"));
- assertTrue(page.contains("How to reproduce the same proof locally"));
- assertTrue(page.contains("How evidence pages relate to the proof"));
- assertTrue(page.contains("How the copied association summary should be used"));
- assertTrue(page.contains("How local/demo proof differs from production proof"));
- assertTrue(page.contains("Edge-case reading guide"));
+ assertTrue(page.contains("Copy how-to reviewer explanation"));
+ assertTrue(page.contains("how-to-reviewer-output"));
+ assertTrue(page.contains("How to Interpret This Decision"));
+ assertTrue(page.contains("How was the selected backend chosen?"));
+ assertTrue(page.contains("How did the selected strategy influence the decision?"));
+ assertTrue(page.contains("How did input signals affect the proof?"));
+ assertTrue(page.contains("How should reviewers interpret confidence/limits?"));
+ assertTrue(page.contains("How does this differ from production proof?"));
+ assertTrue(page.contains("How Strategy Choice Matters"));
+ assertTrue(page.contains("How to Reproduce This Proof"));
+ assertTrue(page.contains("How Evidence Supports the Decision"));
+ assertTrue(page.contains("How to Read Edge Cases"));
assertTrue(page.contains("Association Legend"));
assertTrue(page.contains("scenario = demo input state"));
assertTrue(page.contains("strategy = selected routing method"));
@@ -400,19 +403,22 @@ void routingDemoHowToAndEdgeCasesAreExplicitReviewerGuidance() throws Exception
String normalized = page.toLowerCase(Locale.ROOT);
assertTrue(page.contains("id=\"reviewer-how-to-panel\""));
- assertTrue(page.contains("aria-label=\"Reviewer how-to explanation cards\""));
- assertTrue(page.contains("The first returned strategy is the primary local comparison result"));
- assertTrue(page.contains("its routing rule ranks the visible candidate servers"));
+ assertTrue(page.contains("aria-label=\"How to interpret this decision cards\""));
+ assertTrue(page.contains("The first returned comparison result is the primary local decision"));
+ assertTrue(page.contains("selected backend/server, includes returned reason text"));
+ assertTrue(page.contains("The selected strategy applies its scoring or selection behavior to the same visible candidates"));
assertTrue(page.contains("Health, in-flight load, configured weight/capacity, p95 latency, error rate, queue depth, and network-awareness fields"));
- assertTrue(page.contains("Deltas are browser-local summaries comparing packaged baseline metrics against the current editor payload"));
+ assertTrue(page.contains("Confidence means the browser can repeat the same local sample flow"));
+ assertTrue(page.contains("does not mean the result is approved for production use"));
+ assertTrue(page.contains("Run the app locally and open
/routing-demo.html"));
+ assertTrue(page.contains("Run routing comparison to call the same-origin local
/api/routing/compare endpoint"));
+ assertTrue(page.contains("Copy proof, walkthrough, association, or how-to summaries from visible browser text"));
+ assertTrue(page.contains("Routing Proof Summary is the immediate decision view"));
+ assertTrue(page.contains("Scenario Comparison shows change over time/input states"));
+ assertTrue(page.contains("Scenario comparison deltas are browser-local summaries"));
assertTrue(page.contains("candidate count, healthy/unhealthy count, total in-flight load, max p95 latency, max error rate, and queue depth"));
- assertTrue(page.contains("Unhealthy backends are counted from
healthy=false"));
- assertTrue(page.contains("all-unhealthy payloads are called out as a degradation boundary"));
- assertTrue(page.contains("fewer unhealthy backends than the baseline are described as recovery"));
- assertTrue(page.contains("Run
mvn spring-boot:run"));
- assertTrue(page.contains("reviewer, operator, timeline, and export packet pages provide navigation"));
- assertTrue(page.contains("Use the copied association summary as a reviewer note"));
- assertTrue(page.contains("it is not an audit artifact created by the server"));
+ assertTrue(page.contains("Evidence Navigation links related reviewer pages"));
+ assertTrue(page.contains("Export packet is a local reviewer handoff"));
assertTrue(page.contains("Local/demo proof uses synthetic payloads, same-origin local API responses, and browser-local notes"));
assertTrue(normalized.contains("does not prove production traffic"));
assertTrue(normalized.contains("live cloud behavior"));
@@ -437,6 +443,7 @@ void routingDemoEdgeCaseFallbackTextIsSpecificAndBrowserLocal() throws Exception
assertTrue(page.contains("API error or unavailable local server: Local API response unavailable; static guidance remains available."));
assertTrue(page.contains("Copy-to-clipboard failure fallback: Copy failed; select the visible text and copy manually."));
assertTrue(page.contains("Static page loaded without prior interaction: static guidance and evidence links remain available before running a scenario."));
+ assertTrue(page.contains("Evidence links before scenario execution: Evidence links are available even before running a scenario."));
assertTrue(page.contains("Local API returned HTTP "));
assertTrue(page.contains("Local API returned an empty comparison response; static guidance remains available."));
assertTrue(page.contains("Local API response unavailable; static guidance remains available."));
@@ -451,6 +458,45 @@ void routingDemoEdgeCaseFallbackTextIsSpecificAndBrowserLocal() throws Exception
assertFalse(normalized.contains("automatic upload"));
}
+ @Test
+ void routingDemoCopyableHowToReviewerExplanationIsBrowserLocalAndBounded() throws Exception {
+ String page = Files.readString(ROUTING_DEMO_PAGE, StandardCharsets.UTF_8);
+ String normalized = page.toLowerCase(Locale.ROOT);
+
+ assertTrue(page.contains("Copy how-to reviewer explanation"));
+ assertTrue(page.contains("data-copy-target=\"how-to-reviewer-output\""));
+ assertTrue(page.contains("# Cockpit How-To Reviewer Explanation"));
+ assertTrue(page.contains("howQuestionInventory:"));
+ assertTrue(page.contains("- already answered: selected strategy/backend, input signals, scenario deltas, degradation/recovery notes, evidence path, copy boundaries, and local/demo limits"));
+ assertTrue(page.contains("- clarified in this panel: interpretation sequence, reproduction steps, edge-case reading, strategy-choice effects, and evidence support boundaries"));
+ assertTrue(page.contains("howToInterpretThisDecision:"));
+ assertTrue(page.contains("- selectedBackendChosen: "));
+ assertTrue(page.contains("- selectedStrategyInfluence: "));
+ assertTrue(page.contains("- inputSignalsAffectingProof: "));
+ assertTrue(page.contains("- confidenceLimits: local repeatability and deterministic visible inputs only; not production certification"));
+ assertTrue(page.contains("howToReproduceThisProof:"));
+ assertTrue(page.contains("1. run the app locally and open /routing-demo.html"));
+ assertTrue(page.contains("8. export/copy/print packet from /evidence-export-packet.html"));
+ assertTrue(page.contains("howToReadEdgeCases:"));
+ assertTrue(page.contains("- no previous scenario selected: packaged normal-load baseline remains the static reference"));
+ assertTrue(page.contains("- API unavailable/error: Local API response unavailable; static guidance remains available"));
+ assertTrue(page.contains("evidenceSupport:"));
+ assertTrue(page.contains("- routingProofSummary: immediate decision view"));
+ assertTrue(page.contains("- scenarioComparison: change over time/input states"));
+ assertTrue(page.contains("- evidenceNavigationPath: "));
+ assertTrue(page.contains("- exportPacket: local reviewer handoff, not server-generated certification"));
+ assertTrue(page.contains("copyBoundary: browser-local copy action only; no upload/share endpoint; no server-side export/PDF/ZIP generation; no external calls; no telemetry"));
+ assertTrue(normalized.contains("no production traffic proof"));
+ assertTrue(normalized.contains("no live cloud proof"));
+ assertTrue(normalized.contains("no real tenant proof"));
+ assertTrue(normalized.contains("no registry publication proof"));
+ assertTrue(normalized.contains("no container signing proof"));
+ assertTrue(normalized.contains("no github settings mutation proof"));
+ assertTrue(normalized.contains("no production certification claim"));
+ assertFalse(normalized.contains("server-side how-to export"));
+ assertFalse(normalized.contains("telemetry upload"));
+ }
+
@Test
void routingDemoAssociationLegendExplainsProofTermsWithoutCertificationClaim() throws Exception {
String page = Files.readString(ROUTING_DEMO_PAGE, StandardCharsets.UTF_8);