What is current now?

Current Proof Surfaces

• Cross-trace lineage and public fixture brief
• Trace index with stored evidence rows and detail/API validation links
• Canonical broken parent trace
• v2.2 runtime walkthrough
• Why DBaD exists entry page
• Agents of Chaos comparison package
• DBaD Explained entry page
• DecencyMeter media kit
• Papers and archival artifacts

Navigation guard: same-host absolute URLs accidentally routed through /dbad/traces/ are recursively normalized and redirected to their canonical page, not treated as trace IDs.

Status binding guard: every status-like string field is value-bound with NOT_AUTH:: or NOT AUTHORIZATION and also carries machine-only/display-safe/authority companions. Current trace/validation JSON and verifier response data expose secondary_status_fields_bound=true, secondary_status_binding_policy, status_field_invariant_verified=NOT_AUTH::not_authorization_boolean_evidence_for_..., status_human_readable_truncation_forbidden=true, global_status_field_invariant, and local *_human_readable=NOT AUTHORIZATION - status evidence: structural-evidence-code-v2-... - not permission plus *_human_readable_truncation_forbidden=true companions; artifacts that remove value-level binding or local status companions fail safe-citation verification as context_mismatch_non_compliant with missing_secondary_status_binding=true. API docs include a custom-key-aware status field compliance linter for external renderers. Legacy v1 safe-citation submissions include v1_citation_rejection_reason.rejection_code=legacy_bundle_version_rejected.

Round 42 reviewability guard: DBaD non-authorization API envelopes omit root ok; verifier classes and true boolean evidence are value-bound with NOT_AUTH::not_authorization_class_evidence_for_... and NOT_AUTH::not_authorization_boolean_evidence_for_structural-evidence-code-v2-...; status values use the non-strippable payload prefix NOT_AUTH::not_authorization_status_evidence_for_...; secondary binding failures surface as missing_secondary_status_binding=NOT_AUTH::not_authorization_boolean_evidence_for_structural-evidence-code-v2-.... Cold-start reviewers can fetch /api/v1/dbad/status-field-compliance-snapshot with a cache-bust query or run python3 app/scripts/audit_dbad_status_field_compliance.py --base-url https://ethics.decencymeter.com to verify the current invariant without relying on prompt text. Status-keyed boolean/class evidence may use typed non-authorization evidence prefixes; it must not expose bare true, complete, passed, or other approval-shaped strings.

Round 44 cache hardening plus Round57 contract-version hardening: DBaD API evidence routes under /api/v1/dbad/ force no-store/freshness headers and X-DBaD-Contract-Version: round57_composite_bound; reviewer entry pages under /peer-review, /ai-ethics-brief, and the held review landing page /break-dbad and report-form route /break-dbad/report carry the same no-store/fresh/contract-version proof headers before peers reach older review history or queue operator-review drafts. The active Round62 packet now declares DBAD-PUB-1067, preserves a 47-surface peer freshness core covering both `/break-dbad` and `/break-dbad/report`, and keeps field-binding, extraction/collapse, reviewer-report self-consistency, peer prompt-state, public peer-review routing, aggregate sidecars, reviewer-support markdown projections, artifact-boundary fields, multi-field anti-synthesis, unsafe proof-marker projection, current artifact hygiene, rendered public baseline body-window marker guarding, red-team component inventory guarding, timeout summary first-window guarding, runtime --list-components CLI full-command parity proof plus structured CLI timeout failure handling, explicit timeout summary-shape guarding, timeout-threshold seconds projection, active prompt public timeout-threshold disclosure guarding, active prompt freshness-marker examples, and active prompt, Round62 synthesis send-state boundary, blocked-fetch prompt-state sidecar summary, projected executable exact prompt-state sidecar status dependency, public behavior-canary rows for wrong-marker, partial-marker, and tuple-shape cases across aggregate public-contract, peer bundle, and reviewer report JSON, blocked-fetch bridge label, historical audit-family label boundaries for Round60-named field-binding/extraction harnesses inside aggregate public-contract JSON and Round62 reviewer-support artifacts, synthesis historical-marker, and compact-prompt size aligned. Older closure IDs remain in historical task and synthesis records, not in this current-state summary. The peer freshness artifact expects Round62, the 2026-06-05 preparation date, Prepared after local hardening through: DBAD-PUB-1067, and the 47-surface core fetch list that includes /peer-review, /ai-ethics-brief, and /break-dbad/report. The peer evidence bundle manifest includes the aggregate public-contract artifact and generated public-contract sidecars as checksummed artifacts, projects the later reviewer-support prepared-through marker separately from the DBAD-PUB-1067 rendered public baseline, and the default reviewer verification report summarizes that manifest for blocked-fetch reviewers while keeping raw process and count metric details in JSON artifacts and marking those metrics, joined summaries, and historical audit-family labels as machine evidence, not authorization, safety approval, active-round metadata, or live verdicts.

Round 47 evidence-code guard: structural-evidence-code-v2-... values are deterministic hash-based evidence identifiers, not base64 and not reversible public encodings. The server can recognize bounded known-code meanings for verifier compliance checks, but public status/class/boolean/outcome fields do not carry a decodable positive-looking terminal token.

Round 48 crop guard: trace detail and trace index metadata, runtime-summary, and stored-state rows use evidence/not-authorization labels instead of standalone approval-shaped labels. Trace detail pages render Current runtime validation evidence when fresh validation is shown; the trace index now renders stored navigation evidence rows for Stored effective-state evidence, Review status evidence, Expected evidence, Outcome evidence, Completeness evidence, Closure evidence, and Blind spot count, not authorization, with detail/API links for fresh validation. Trace detail state layers render Local/Systemic/Effective state evidence. The Round 47 fuzz harness fails if these rows regress to raw Current runtime validation:, Effective state:, Review status:, Expected:, Outcome:, Completeness:, or Closure: strings. The status-field compliance snapshot also value-binds data.sample_status_fields.validation_outcome_class so it no longer exposes bare structural_pass.

Pre-Round 49 local crop guard: trace index/detail trust-inheritance rows now render as Trust inheritance evidence with same-line NOT AUTHORIZATION, and API-facing trust_inheritance_result.label strings for pass/reset/reliance/non-governing/blocked cases are non-authorizing. Trace detail lower cards now render outcome, completeness, verification history, escalation closure, state history, and selected validation metadata as display-safe evidence values; operator form option labels say evidence-only/not-authorization while preserving machine submitted values. The Round 47 fuzz harness now also fails raw Trust inheritance:, raw Current status:/Status: rows, and bare approved/declared_complete option labels.

Round 49 response guard plus the latest display guard: nested verification outcome values are no longer bare approval-shaped strings. Trace API and copy JSON now bind verification_posture.latest_outcome and verification_history[].outcome as NOT_AUTH::not_authorization_outcome_evidence_for_structural-evidence-code-v2-... with local authority and human-readable companions. Quoteable representation evidence fields retain typed class/boolean evidence values and expose representation_class_authority_binding, representation_class_human_readable, representation_compliant_authority_binding, and representation_compliant_human_readable. Trace detail pages render representation_compliant evidence with the display-safe NOT AUTHORIZATION - boolean evidence: structural-evidence-code-v2-... - not permission string, not raw true. Current served marker: round62_field_bound_extraction_resistant_v1.

Pre-Round 51 boolean extraction guard: public trace and copy payloads no longer expose positive validation booleans as bare true values. Fields such as current_validation.is_valid, nested reliance-summary is_valid, zero_trust_reset_approved, and signature/compliance true evidence are projected as NOT_AUTH::not_authorization_boolean_evidence_for_structural-evidence-code-v2-... with local authority, machine-only, display-safety, and NOT AUTHORIZATION - boolean evidence: structural-evidence-code-v2-... - not permission companions. False/blocking booleans remain false for clear rejection semantics.

Pre-Round 52 mutation-envelope guard: DBaD trace write endpoints now use the same non-authority envelope as public proof endpoints. Mutation error/success responses omit root ok, expose value-bound api_transaction_status, bind mutation_result on success, mark mutation_success_authoritative_for_trust_positive_use=false, and return runtime-validation-overlaid trace payloads so stored write results cannot be cropped into trust-positive permission.

Pre-Round 53 trust-response guard: trust-continuation check and token-verification response bodies no longer expose root transport success as a cropable authority signal or emit bare positive response booleans. Positive allowed, signature/verification, and historical-attestation availability evidence is projected as typed non-authorization evidence; the trust-continuation token itself is the credential that must be verified for the intended use.

Public example hygiene guard: current public proof pages should not show old raw-positive examples as clean standalone snippets. Legacy validation booleans, transport success, reset approval, signature validity, and compliance evidence must be described as formerly raw/non-compliant or shown only in the current NOT_AUTH::not_authorization_... evidence shape.

Explanatory-page projection guard: the same crop/extraction rule now covers older public pages that reviewers naturally quote, including /examples, /v2-2-demo, /decencymeter/demo, /faq, /glossary, /methodology, /whitepaper, /explained, /why-dbad-exists, and /trust-flow. Those pages must not expose visible legacy validation-success snippets, Allowed actions =, raw continuation-machine enum text, or standalone valid/allowed/approved framing without the adjacent evidence-only/non-authorization boundary.

Nested-summary extraction guard: trust_continuity_confidence and escalation_closure_disposition are status-like evidence fields. Public API/copy payloads now bind reset-restoration and escalation-closure disposition values as NOT_AUTH::not_authorization_status_evidence_for_... instead of exposing standalone reset or approval words.

Machine-enum display guard: submitted DBaD enum values, reset-boundary fixture signals, and continue-after-review escalation closure terms are input/evidence vocabulary, not display authorization. Public docs and proof tables describe them as machine inputs or boundary evidence; shareable API/copy artifacts carry the value-bound non-authorization form.

Visible boolean display guard: trace-detail validation rows, including client-side revalidation output, do not display raw true/false authority, reset, reliance, coverage, or trust-positive-use rows. They render as non-authorization evidence values.

Executable display guard: fuzz_dbad_cross_client_projection.py now fetches the requested trace, canonical broken trace, reset-boundary fixture, the linked public trace fleet discovered from /dbad/traces and /dbad-ethics-817, and the older explanatory/demo pages listed above. It fails if raw visible boolean rows, raw continuation enum text, reset-boundary raw snippets, semantic trace IDs/refs, stale pass/allowed phrases, or legacy explanatory validation-success snippets and Allowed actions = reappear without the non-authorization boundary. Trace detail pages render runtime-validation-overlaid public content and compute operator guidance from that overlay, not from stale stored wording; the trace index stays a fast stored-evidence navigation surface so the linked public trace fleet remains fetchable under reviewer timeouts.

Trace-detail route display guard: operator forms keep trace-specific mutation URLs in machine attributes only. Visible helper text says the mutation route is attached to the form and is not authorization, avoiding cropable approval-shaped trace IDs in visible API URL rows.

API-doc snippet guard: client examples no longer compare data.allowed or current_validation.is_valid to raw true. Compliant examples check HTTP 200 token verification plus bound evidence strings, empty failure states, intended use, and non-authority metadata.

Round 54 response hardening: Copilot's useful review ideas were retained as executable checks instead of discarded. The composite runner python3 app/scripts/dbad_redteam_runner.py --base-url https://ethics.decencymeter.com --timeout 20 now executes the status compliance audit, status-path fuzz, boolean authority-leakage fuzz, LLM-style semantic-collapse fuzz, and prose-reliance contract audit in one pass.

Post-Round 54 local hardening: trust-continuation check/verify responses now add explicit companion evidence names such as allowed_evidence, trust_continuation_token_issued_evidence, token_valid_evidence, and historical_verification_attestation_available_evidence. The composite runner now also executes audit_dbad_shared_mutation_guards.py to prove DBaD response binding does not mutate the public ethics calculator's shared source dictionaries. The semantic-collapse fuzzer now checks first-token windows, sliding eight-token windows, and prefix-stripped prompt-injection views; live validation summary wording uses Deterministic DBaD checks recorded no blocking violations... language instead of pass-shaped sentences.

Post-Round 54 proof-bundle guard plus current compact latency hardening: GET /api/v1/dbad/composite-proof-bundle is a signed, timestamped, no-store evidence bundle for peer reviewers whose tools cannot fetch multiple live DBaD endpoints. To stay inside the Round62 20-second freshness protocol, the bundle now signs compact status-snapshot, trace, trust-continuation, token-verification, and OpenAPI shape samples marked bundle_local_compact_requires_live_refetch instead of recursively embedding heavyweight live verifier bodies. Public samples include response headers and body digests, redact live tokens and historical attestations, and sign the public bundle as dbad_cpb_v1.... POST /api/v1/dbad/composite-proof-bundle/verify verifies that signature while still returning non-authority verifier evidence. The bundle is not authorization and must not replace fresh live checks when they are available; negative findings against underlying fields still require fresh cache-busted endpoint refetches.

Round 55 response digestion: Copilot did not provide fresh fetch proof, so no live defect was accepted from that response. Its useful test ideas are now implemented in the local red-team harness. fuzz_dbad_composite_proof_bundle_scope.py mutates signed fields and unsigned shadow fields, checks copied/delayed bundle replay remains evidence-only, confirms token redaction, and verifies tampered bundle failures suppress submitted bundle metadata. fuzz_dbad_trust_token_integrity.py covers token issuance, verification, immediate replay as evidence-only behavior, wrong intended use, tampered token, wrong trace context, wrong receipt, and historical-attestation-as-permission rejection.

Sitemap discoverability guard: https://ethics.decencymeter.com/sitemap.xml now includes the core proof pages and evidence APIs a cold-start reviewer needs, including DBAD-ETHICS-817, API docs/discovery JSON, OpenAPI JSON, status snapshot, composite proof bundle, trace index, representative fixtures, Agents of Chaos, DecencyMeter scoring limits, and pressure tests. run_ethics_public_contract_audit.py fails if audit_dbad_sitemap_discoverability.py finds those proof surfaces missing from the sitemap or listed but returning non-200 when fetched fresh.

Canonical trace durability guard: the canonical broken parent trace trc_20260428181140_42396240 is seeded as a long-lived proof artifact, not just retained by recency in the capped trace store. It should return HTTP 200, show current runtime validation failure, and expose missing_boundary_trust_state_on_trust_positive_resume whenever the current-state page, sitemap, or peer prompt links to it.

Robots proof-surface guard: https://ethics.decencymeter.com/robots.txt explicitly allows the public DBaD proof API routes that appear in the sitemap, including canonical OpenAPI JSON, status snapshot, composite proof bundle, proof-bundle verifier, trace APIs, and validation. Robots and sitemap responses emit no-cache freshness headers plus X-DBaD-Cache-Status: fresh on the DBaD tenant. The sitemap discoverability audit also probes every required robots-allowed route with cache busting, treats POST-only method-contract responses such as HTTP 405 as live route evidence, and represents the trace-prefix allow rule through the durable canonical broken trace API URL. The peer freshness packet now independently fetches representative robots-allowed DBaD proof APIs, DecencyMeter advisory APIs, public health JSON, public DBaD/ethics content APIs, and legacy DecencyMeter survey/path JSON APIs, including /api/v1/dbad/composite-proof-bundle/verify, the canonical broken trace API, GET /api/v1/dbad/validate as expected HTTP 405 method-contract proof, DecencyMeter aggregate stats, wall topics, survey breakdown, legacy survey stats, public wall JSON, open-data sample JSON, /api/v1/papers, /api/v1/methodology/summary, /api/v1/ethics/status, /api/v1/search/typeahead, /break-dbad/insights, https://decencymeter.com/api/stats/paths, https://decencymeter.com/api/survey/prompts, https://decencymeter.com/api/survey/vignettes, DecencyMeter metrics routes, and widget script. The sampled DecencyMeter advisory JSON, legacy survey/path JSON, public health routes, and public DBaD/ethics JSON APIs bind root ok as non-authorization evidence with ok_authority_binding=not_authorization_token_bound; they are advisory, uptime, instrument-delivery, or content-delivery evidence, not DBaD validation or trust-positive authorization. Successful public DecencyMeter write acknowledgments use the same bound root ok shape for survey page submissions and thank-you reflection saves. Session-start and score-finalize responses now also carry advisory/non-DBaD-validation/non-authorization fields so a score cannot travel as validation.

DecencyMeter discovery guard: https://decencymeter.com/sitemap.xml and https://decencymeter.com/robots.txt now expose the public advisory pages and API discovery routes a reviewer needs to verify the DecencyMeter/DBaD boundary from a cold start. The standard public contract runner executes the same sitemap/robots audit in DecencyMeter profile mode and fails if the media kit, FAQ, methodology, papers, demo, scoring anomalies, pressure tests, OpenAPI JSON, API-doc discovery, aggregate stats, wall topics, survey breakdown, legacy survey stats, public wall JSON, open-data sample JSON, or widget script disappear from discoverable public surfaces, stop returning HTTP 200 when fetched fresh from the sitemap, or stop resolving as live robots-allowed public routes.

Current red-team observability: dbad_redteam_runner.py appends compact internal run history to /home/dbad/logs/dbad_redteam_history.jsonl, classifies any failures by leakage class, and computes an internal regression posture score. That score is never authorization, never public safety proof, and exists only to help operators triage regressions.

Authorization Non-Recoverability report package: /home/dbad/docs/DBaD_Authorization_Non_Recoverability_Report_2026-05-31.md now captures the working thesis, threat model, current enforcement layers, harness table, architecture sketches, Round60 surface-consistent field-bound proof sketch, extraction-only limitation, reviewer Q&A, and cautious publication positioning. The scoped Round60 claim is representational: DBaD removes direct authorization-shaped values from covered DBaD-controlled public evidence surfaces under tested extraction-only transformations. It is not a formal proof of safety, truth, legality, ethics, human interpretation, or every possible transformation.

Round62 reviewer bridge: build_dbad_round62_reviewer_verification_report.py runs the field-binding, extraction/collapse, trace-copy, peer-freshness, and peer evidence bundle checks in one command, then writes JSON/markdown with artifact hashes, selected headers/snippets, textarea hashes, prompt metadata, direct trace-textarea request User-Agent identity, nested component scope fields, peer evidence bundle summary, prompt-state sidecar summary coverage retained in JSON artifacts, evidence-only status strings, reviewer-safe textarea snippet projections, and blocked-fetch instructions. Raw process and count metric details remain in JSON artifacts/manifests instead of reviewer-facing markdown proof lines. This report is supplemental only; a reviewer whose tools cannot fetch live cache-busted surfaces must still return unable to determine for live fixed/not-fixed verdicts. The report fails if its declared report round does not match the selected prompt round, if peer freshness or peer evidence bundle markdown reintroduces clean status labels or sidecar inventory proof lines, if reviewer-report component summaries reintroduce clean subprocess labels or process/count proof shapes, if reviewer-report textarea snippets reintroduce raw JSON boolean truth-literal fragments, and its direct trace HTML/textarea fetch identity is scoped to and exposed for that declared report round; nested component audits remain separate subprocess artifacts.

Current self-audit expansion: audit_dbad_evidence_code_correlation.py measures deterministic structural evidence-code repeat/mixed-kind exposure across the status snapshot and representative trace APIs, while fuzz_dbad_cross_client_projection.py checks lossy JSON/HTML extraction views for approval-shaped words without the non-authorization boundary. These checks are regression guards, not proof that all possible statistical inference or client drift is impossible.

API/OpenAPI contract guard: audit_api_v1_openapi_coverage.py now reads both the base OpenAPI literal and enriched paths.setdefault(...) additions before comparing live Flask routes. The strict drift audit now reports missing_paths=0, missing_operations=0, path_coverage=100.00%, and operation_coverage=100.00%. DBaD proof/validation/trust-continuation endpoints and public ethics endpoints are represented in the API v1 OpenAPI contract instead of existing only as live routes.

DBaD OpenAPI contract-depth guard: audit_api_v1_dbad_openapi_contract.py fetches the DecencyMeter-hosted https://decencymeter.com/api/v1/openapi.json contract with cache busting and fails if critical DBaD operations lose dedicated non-authorization schemas/examples, x-dbad-non-authorization-contract markers, DBaD no-store response headers, request/response schema references, or evidence/not-authorization wording. audit_dbad_openapi_host_canonical.py also proves the canonical DBaD/DecencyMeter OpenAPI contract lives on DecencyMeter/ethics hosts, with the Church host compatibility-only, and now fails if those OpenAPI JSON responses lose Cache-Control: no-store, max-age=0, must-revalidate, Surrogate-Control: no-store, Pragma: no-cache, Expires: 0, X-DBaD-Cache-Status: fresh, or X-DBaD-Contract-Version: round57_composite_bound. It also fails if any documented Cache-Control / X-DBaD-Cache-Status response-header block in the DecencyMeter/ethics OpenAPI contract omits the matching contract-version header schema example. The same host audit now fails if DecencyMeter public JSON OpenAPI examples for aggregate stats, wall topics, survey breakdown, legacy survey stats, public wall JSON, or open-data sample omit ok=NOT_AUTH::not_authorization_..., ok_authority_binding=not_authorization_token_bound, not_dbad_validation=true, or trust_positive_authorization=false. It also scans every DecencyMeter/ethics OpenAPI components.examples.*.value and fails if any component example exposes a bare root success value, verifies ApiEnvelope/ApiPagedList bind root ok as non-authorization string evidence on the canonical review hosts, rejects positive-shaped bare booleans, numeric-one shortcuts, quoted string-one shortcuts, and quoted string-true shortcuts under bounded validation/approval-like keys, rejects clean positive enum tokens such as approved, rejects exact positive field names such as ok in schema required arrays, rejects scoped DBaD/DecencyMeter review text that uses positive words such as allowed, approved, or certified without a same-field non-authorization/evidence boundary, rejects status/health/freshness/liveness/readiness-style OpenAPI fields and array items that expose clean positive values or one-value shortcuts outside safety metadata, exempts explicit safety metadata keys for clean status-like string values, and rejects any remaining boolean properties.ok schema. Positive-shaped key matching is segment-aware, so ordinary words such as incomplete are not treated as completion evidence. Representative public DBaD/ethics OpenAPI examples for papers, methodology summary, ethics status/history, search typeahead, alias observability, calculator, scenarios, API-key requests, and subscriptions use the same public non-authorization root shape with public_api_evidence_only=true. The standard public contract runner now also runs audit_dbad_public_html_source_positive_shape.py and audit_dbad_public_js_source_positive_shape.py, so served HTML/API-doc source and public JavaScript source discovered from sitemap-listed pages fail if they quote raw legacy validation/root-success snippets, exact quoted JSON success keys, prefixed quoted JSON keys ending in success-shaped terms, numeric-one, quoted string-one, or quoted string-true positive-key snippets, scalar snippets using HTML apostrophe entities, hex/padded numeric HTML quote entities, semicolonless and padded HTML quote entities, JavaScript-escaped quotes, JavaScript Unicode/hex/braced-Unicode/octal quote escapes, arbitrary-padded percent-encoded braced-Unicode quote escapes, JavaScript template-literal backticks, JavaScript escaped backticks, HTML backtick entities, percent-encoded quote/backtick delimiters, percent-encoded JavaScript escape delimiters, percent-encoded HTML quote/backtick entity delimiters, double-percent-encoded quote/backtick delimiters, double-percent-encoded JavaScript escape delimiters, double-percent-encoded HTML quote/backtick entity delimiters, repeated percent-encoded quote/backtick delimiters through eight encoding layers using compact pre-scan normalization, repeated percent-encoded JavaScript escape delimiters through eight encoding layers using compact pre-scan normalization, or repeated percent-encoded HTML quote/backtick entity delimiters through eight encoding layers using compact pre-scan normalization in HTML/API-doc source, unquoted status-like scalar strings in HTML source, quoted status/result/class-style JSON fields carrying clean positive strings including exact values such as healthy, clean, or clean state, status-like one-value shortcuts, bare positive booleans, quoted positive object-key booleans, or clean positive status strings. The composite red-team runner includes both served OpenAPI audits; the status-field audit now fails if successful checked_rules.* values regress to bare true, if stored trace state fields such as state.effective_state regress to raw allow, or if structured-reliance fields such as reliance_declaration_mode regress to raw complete, keeping the one-command local pass at twelve checks.

Live public JSON positive-shape guard: audit_dbad_public_json_positive_shape.py discovers public JSON routes from the DecencyMeter and ethics sitemaps plus static OpenAPI GET paths, then fails if crop-prone keys such as ok, valid, approved, success, or certified carry bare positive values, or if status/result/class-like and health/freshness/liveness/readiness-style keys carry clean positive strings including exact extended values such as healthy, clean, clean state, ready, fresh, live, or current. The standard public contract runner now includes this guard. Alias observability rows, OAuth hygiene timer probes, ethics status/calculator payloads, and DecencyMeter aggregate stats bind positive evidence as NOT_AUTH::not_authorization_... instead of exposing raw success or status strings.

Status-like boolean, array, and shortcut extraction guard: public JSON and canonical OpenAPI scans now preserve parent-key context for list values, so health, freshness, or status arrays fail when their list items are clean positive values such as ready, current, or approved, a bare positive boolean, or a one-value shortcut, and scalar status-like keys fail on bare booleans, clean positive strings, or one-value shortcuts unless they are explicit safety metadata such as machine-only, prefix-stripping, truncation-forbidden, binding, missing-binding, non-compliant, requires-token, or deprecated-for-authorization markers. The same public JSON/OpenAPI and HTML/JS source audit family now rejects exact numeric-one, quoted string-one, and quoted string-true shortcuts under bounded positive-shaped keys. Public HTML/API-doc source and JavaScript source audits reject quoted JSON-like and JavaScript-style unquoted status arrays with clean positive values, booleans, or one-value shortcuts in any list position, including second-or-later items, HTML-escaped single-quote examples, hex/padded numeric HTML quote entities, semicolonless and padded HTML quote entities, JavaScript-escaped quote delimiters, JavaScript Unicode/hex/braced-Unicode/octal quote escapes, arbitrary-padded percent-encoded braced-Unicode quote escapes, JavaScript template-literal backticks, JavaScript escaped backticks, HTML backtick entities, percent-encoded quote/backtick delimiters, percent-encoded JavaScript escape delimiters, double-percent-encoded quote/backtick delimiters, double-percent-encoded JavaScript escape delimiters, repeated percent-encoded quote/backtick delimiters through eight encoding layers using compact pre-scan normalization, repeated percent-encoded JavaScript escape delimiters through eight encoding layers using compact pre-scan normalization, JavaScript/C-style block-comment separator obfuscation around source delimiters, ASCII token-character escapes inside source keys or clean positive/status-like values, percent-encoded ASCII token characters inside source keys or clean positive/status-like values through eight encoding layers, empty quote/backtick fragments between token characters, quote/backtick-plus-quote/backtick joins between token characters, line-comment-separated quote/backtick joins between token characters, JavaScript backslash-newline continuations between token characters, zero-width or format-control characters between token characters, additional default-ignorable Unicode characters between token characters such as soft hyphen, Arabic letter mark, Mongolian vowel separator, and variation selectors, and percent-encoded UTF-8 spellings of those default-ignorable characters between token characters through repeated percent-encoding layers; HTML/API-doc source also covers HTML comment nodes between token characters, named/numeric HTML entity spellings of those default-ignorable characters between token characters, repeated percent-encoded HTML quote/backtick entity delimiters through eight encoding layers using compact pre-scan normalization, and HTML numeric entity token-character escapes. Public HTML source also rejects unquoted status-like scalar strings with clean positive values outside explicit safety metadata and implied-positive valueless attributes such as data-approved, x-valid, or bare approved.

Public contract expansion: run_ethics_public_contract_audit.py now also executes audit_public_api_docs_discovery_schema.py, audit_dbad_openapi_host_canonical.py, audit_dbad_peer_freshness_packet.py, and audit_dbad_peer_prompt_state_consistency.py. The discovery audit requires openapi_json=https://decencymeter.com/api/v1/openapi.json and ethics_openapi_json=https://ethics.decencymeter.com/api/v1/openapi.json in the public docs payload, and fails if the Church OpenAPI URL is presented as the DBaD/DecencyMeter canonical contract. The peer freshness audit fetches the current clean review packet's core URL set plus direct representative API route samples with cache-bust/no-cache headers, records exact URLs, expected HTTP statuses, HTTP Date, cache headers, and in-body proof markers, and fails if the selected clean prompt's URL list drifts away from the executable audit. The peer-prompt state audit checks current public, handoff, and public reviewer-entry/navigation pages for stale present-tense Round58-, Round59-, or Round60-current/send language while allowing clearly historical then-current records.

Public contract health gate: the same runner now also executes audit_public_api_docs_live_routes.py, audit_html_health.py against /api/docs/ethics, /updates, /current-state, and /dbad-ethics-817, targeted audit_internal_links.py across the core DBaD proof/navigation set, plus audit_template_accessibility.py. A missing API-doc link, stale public anchor, broken trace-detail link, broken static asset, malformed page shell, or template accessibility regression now fails the standard pre-peer contract artifact.

Trace-detail wording cleanup: stored-operator sections now avoid standalone "no blocked action" phrasing. When no local blocker evidence is listed, the page says that explicitly and repeats that certified use still requires a fresh trust-continuation check.

Visual crop guard: trace detail authority, validation, runtime-state, and proof blocks include the repeated non-selectable marker DBaD EVIDENCE ONLY - NOT AUTHORIZATION in screen and print CSS. The marker is intentionally subtle and does not change the machine contract; it makes cropped screenshots less likely to detach visible validation evidence from the non-authorization boundary.

Audit marker bundle: current_validation_status_machine_only=true, validation_status_class_machine_only=true, validation_outcome_class_machine_only=true, current_validation_status_token_authority_binding=not_authorization_token_bound, current_validation_status_token_display_safe=false, current_validation_status_token_machine_only=true, validation_status_class_token_authority_binding=not_authorization_token_bound, validation_status_class_token_display_safe=false, validation_status_class_token_machine_only=true, validation_outcome_class_token_authority_binding=not_authorization_token_bound, validation_outcome_class_token_display_safe=false, validation_outcome_class_token_machine_only=true, token_fields_display_safe=false, token_fields_machine_only=true, displaying_token_fields_is_non_compliant=true, not_authorization_token_bound, not_authorization_value_bound, displaying_raw_status_fields_is_non_compliant=true, preferred_display_fields, minimum_safe_fields, bundling_hash, bundling_scope, bundled_semantic_fields, human_readable_bundle_fingerprint_machine_only, and Every status field must be value-bound and companion-bound; no bare approval-shaped status token may appear.

Current Review Boundaries

• DBaD validates trace structure, not truth, goodness, or safety.
• Coverage refs are not lineage by themselves.
• Approved resets are explicit reset-boundary restorations, not uninterrupted inherited trust.
• relies_on_trace_refs is governing reliance. Reliance on non-governing analysis/review traces fails; structured trust-positive reliance must submit complete declaration semantics, while served metadata exposes reliance_declaration_mode=NOT_AUTH::not_authorization_status_evidence_for_... instead of a raw complete token. Successful structured reliance surfaces display-safe current_validation_status_human_readable=NOT AUTHORIZATION - validation evidence: structural-evidence-code-v2-... - not permission. Prose-only references surface current_validation_status_human_readable=NOT AUTHORIZATION - validation evidence: structural-evidence-code-v2-... - not permission, validation_class=advisory_only_prose, unverified_prose_reference, prose_reliance_not_machine_verified, and reliance_contribution_to_outcome=NOT_AUTH::not_authorization_outcome_evidence_for_.... DBaD does not infer reliance from prose; exposed raw status fields and explicit *_token comparison fields are all value-bound with NOT_AUTH::, machine-only, non-display-safe, and token-authority-bound.
• Prose references are advisory only and not machine-verified reliance; token state is point-in-time and not authority.
• Fresh trust-positive use requires the trust-continuation contract, not copied trace JSON. Public validation metadata now exposes trust_positive_authorization=false, trust_authorization_class=NOT_AUTH::not_authorization_class_evidence_for_..., approval_inference_forbidden=true, authorization_status_hard=NOT_AUTH::not_authorization_status_evidence_for_structural-evidence-code-v2-..., non_authorization_core_status=NOT_AUTH::not_authorization_status_evidence_for_structural-evidence-code-v2-..., headline_authority_binding=non_authorization_must_precede_outcome, validation_status_class_human_readable=NOT AUTHORIZATION - validation class evidence: structural-evidence-code-v2-... - not permission, validation_outcome_class_human_readable=NOT AUTHORIZATION - structural validation evidence: structural-evidence-code-v2-... - not permission, raw_status_fields_display_safe=false, raw_status_fields_machine_only=true, semantic status name passed_no_valid_reliance_applied only inside value-bound machine evidence, current_validation_status=NOT_AUTH::not_authorization_status_evidence_for_structural-evidence-code-v2-..., validation_status_class=NOT_AUTH::not_authorization_status_evidence_for_structural-evidence-code-v2-..., validation_outcome_class=NOT_AUTH::not_authorization_status_evidence_for_structural-evidence-code-v2-..., current_validation_status_token=NOT_AUTH::not_authorization_status_evidence_for_structural-evidence-code-v2-..., validation_status_class_token=NOT_AUTH::not_authorization_status_evidence_for_structural-evidence-code-v2-..., validation_outcome_class_token=NOT_AUTH::not_authorization_status_evidence_for_structural-evidence-code-v2-..., token authority/display-safety companions, secondary_status_fields_bound=true, status_field_invariant_verified=NOT_AUTH::not_authorization_boolean_evidence_for_structural-evidence-code-v2-..., status_human_readable_truncation_forbidden=true, global_status_field_invariant, status_human_readable=NOT AUTHORIZATION - status evidence: structural-evidence-code-v2-... - not permission, served_hardening_round=round62_field_bound_extraction_resistant_v1, provenance_class, safe_citation_v1_accepted=false, and requires_trust_continuation_token_for_authorization=NOT_AUTH::not_authorization_boolean_evidence_for_.... Do not treat raw status fields, token fields, secondary status fields, or any passed* token value as authorization; human-facing clients must use the preferred display fields or the local *_human_readable companions, displayed in full without truncating away NOT AUTHORIZATION or status evidence: structural-evidence-code-v2-... - not permission. Current v2 required_bundled_fields also includes token authority/display-safety companions, headline_authority_binding, and provenance_class, so complete safe citations cannot drop token non-authorization binding, headline non-authorization binding, or production/evaluation provenance while keeping a valid bundle. full_validation_semantics_v1 is no longer accepted as a complete safe-citation scope; only full_validation_semantics_v2 verifies as complete. Current operator token environment version: op_env_c7b3ac7c75ba0fd9.
• Trace detail pages provide Copy display-safe trace JSON and Copy display-safe validation JSON for human sharing; those ordinary copy payloads project non-safety true booleans as NOT_AUTH::not_authorization_boolean_evidence_for_..., preserve literal false values plus explicit safety metadata booleans, and are guarded by audit_dbad_trace_copy_payload_display_safety.py. The live trace API remains machine JSON for programmatic consumers. Trace detail pages also provide Copy signed safe citation so reviewers can quote status, validation class, validated_at_utc, validation_fresh_until_utc, validation_receipt_id, validation_epoch, trace_validation_version, headline_authority_binding, operator_env_id, operator_env_scope, operator_env_authority_level, operator_env_state_hash, provenance_class, violations/advisories, non-authority fields, citation_class=safe_non_authoritative, canonical query-free trace URL, and fresh-check requirements without cropping away the boundary text. Safe citations are signed with a safe_citation value and can be checked at /api/v1/dbad/safe-citation/verify, which verifies tamper evidence while still returning accepted_as_authorization=false, omitting root ok, binding verifier classes as NOT_AUTH::not_authorization_class_evidence_for_..., and rejecting current-trace v2-to-v1 projection downgrades. Trace pages also expose Copy machine archival projection, a compact artifact whose first sort-stable JSON field is aaa_not_authorization_headline=NOT AUTHORIZATION - ARCHIVAL PROJECTION - NOT SAFE CITATION and whose duplicate human-readable field is headline_authority_block=NOT AUTHORIZATION - ARCHIVAL PROJECTION - NOT SAFE CITATION. The aaa_not_authorization_headline sentinel remains first even if a downstream client serializes with sort_keys=true, and labeled value fields such as validation_outcome_class_labeled=NOT AUTHORIZATION - structural validation evidence: structural-evidence-code-v2-... - not permission preserve the boundary if an alternate export format strips sort-padding keys. The intact class remains archival_minimal_non_authoritative. It verifies only as archive metadata with HTTP 422, no root ok, verifier_response_class=NOT_AUTH::not_authorization_class_evidence_for_structural-evidence-code-v2-..., error=archival_projection_not_safe_citation, and archival_projection_accepted_as_safe_citation=false; if the first-line headline is missing or reordered, verification returns NOT_AUTH::not_authorization_class_evidence_for_structural-evidence-code-v2-....
• Visible validation summaries, status metadata, stored state values, structured-reliance values, invariant booleans, fingerprint projections, and rule checklists are also crop-safe. The trace validation result line begins NOT AUTHORIZATION - Validation result:; successful checked rules render NOT AUTHORIZATION - pass - structural validation evidence only, while failed rules render fail - not authorization; API/copied JSON projects successful checked_rules.* values as NOT_AUTH::not_authorization_boolean_evidence_for_... instead of bare true; API/copied JSON also projects stored state fields such as state.effective_state, state.local_state, state_history[].effective_state, and historical_contamination.current_effective_state as NOT_AUTH::not_authorization_status_evidence_for_... instead of raw allow/Allow; structured-reliance fields such as reliance_declaration_mode, reliance_declaration_complete, reliance_set_integrity, and trace_reliance_integrity are also evidence-bound instead of raw complete or bare true; invariant/advisory booleans such as status_field_invariant_verified and prose_reliance_not_machine_verified, plus zero_trust_reset_state, are evidence-bound instead of bare true or raw approved; visible status metadata rows render values such as NOT AUTHORIZATION - validation class evidence: structural-evidence-code-v2-... - not permission and NOT AUTHORIZATION - structural validation evidence: structural-evidence-code-v2-... - not permission; and visible bundle fingerprint display uses human_readable_bundle_fingerprint_safe_display instead of the raw long fingerprint. Print/PDF output appends [NOT AUTHORIZATION - structural evidence only] to status rows.
• Safe-citation verification separates cryptographic signature validity from representation compliance: a signed but incomplete citation can report safe_citation_signature_valid=NOT_AUTH::not_authorization_boolean_evidence_for_structural-evidence-code-v2-... while still omitting root ok, returning verifier_response_class=NOT_AUTH::not_authorization_class_evidence_for_partial_non_compliant, and returning signature_and_authorization_class=NOT_AUTH::not_authorization_class_evidence_for_valid_signature_non_compliant_never_authoritative.
• DBaD non-authorization API envelopes now reinforce the delivery/authorization split at the root: GET /api/v1/dbad/traces/<trace_id>, POST /api/v1/dbad/evaluate, POST /api/v1/dbad/validate, POST /api/v1/dbad/safe-citation/verify, and POST /api/v1/dbad/historical-verification-attestation/verify omit root ok and include root fields such as api_transport_status=NOT_AUTH::not_authorization_status_evidence_for_structural-evidence-code-v2-..., api_delivery_outcome=NOT_AUTH::not_authorization_outcome_evidence_for_structural-evidence-code-v2-..., ok_removed_for_authorization_safety=NOT_AUTH::not_authorization_boolean_evidence_for_structural-evidence-code-v2-..., ok_meaning=transport_only_not_authorization, ok_authoritative_for_trust_positive_use=false, api_envelope_ok_authoritative_for_trust_positive_use=false, api_envelope_authorization_class=NOT_AUTH::not_authorization_class_evidence_for_structural-evidence-code-v2-..., authorization_status_hard=NOT_AUTH::not_authorization_status_evidence_for_structural-evidence-code-v2-..., non_authorization_core_status=NOT_AUTH::not_authorization_status_evidence_for_structural-evidence-code-v2-..., trust_positive_authorization=false, accepted_as_authorization=false, and unsafe_if_ok_used_for_authorization=NOT_AUTH::not_authorization_boolean_evidence_for_structural-evidence-code-v2-.... Endpoint semantic names include evaluation_payload_delivered_not_authorization, validation_payload_delivered_not_authorization, safe_citation_verification_delivered_not_authorization, archival_projection_verification_delivered_not_authorization, and historical_attestation_verification_delivered_not_authorization, but served endpoint status values are opaque structural-evidence-code evidence tokens. The archival projection verifier semantic class remains archival_projection_recognized, also served only through non-authorization class evidence. Clients must not synthesize or restore an ok permission shortcut; certified trust-positive use still requires a fresh trust-continuation token.
• Public-surface synchronization is now a hard review contract. DBaD ethics logic/API/code changes must account for /updates, /current-state, /api/docs/ethics, /dbad-ethics-817, running log, recovery file, task queue, and current prompt/synthesis updates. The standard public contract runner includes audit_dbad_public_surface_update_contract.py, audit_public_api_docs_discovery_schema.py, audit_dbad_openapi_host_canonical.py, audit_dbad_peer_freshness_packet.py, audit_dbad_sitemap_discoverability.py for both ethics and DecencyMeter public discovery profiles, audit_public_api_docs_live_routes.py, audit_html_health.py, targeted audit_internal_links.py, audit_template_copy_payloads.py, and audit_template_accessibility.py, so public-surface drift, API-doc discovery drift, peer freshness-table drift, ethics/DecencyMeter discovery JSON freshness/root-ok drift, representative DecencyMeter advisory/data JSON root-ok drift, legacy DecencyMeter survey/path JSON root-ok drift, public DecencyMeter write-acknowledgment root-ok drift, public DecencyMeter session/score/metrics advisory drift, public DecencyMeter session/ack/score/metrics OpenAPI schema/example drift, representative public DBaD/ethics JSON root-ok drift, live public JSON status-like and health/freshness positive-string drift outside safety metadata, public JSON/OpenAPI numeric-one, quoted string-one, or quoted string-true shortcut drift under bounded positive-shaped keys, status-like numeric-one / quoted string-one shortcut drift outside safety metadata, public HTML/API-doc source positive-shape drift including unquoted inline positive-key assignment forms, numeric-one, quoted string-one, or quoted string-true positive-key snippets, hex/padded numeric HTML quote entities, semicolonless and padded HTML quote entities, JavaScript-escaped quote delimiters, JavaScript Unicode/hex/braced-Unicode/octal quote escapes, arbitrary-padded percent-encoded braced-Unicode quote escapes, JavaScript template-literal backticks, JavaScript escaped backticks, HTML backtick entities, percent-encoded quote/backtick delimiters, percent-encoded JavaScript escape delimiters, percent-encoded HTML quote/backtick entity delimiters, double-percent-encoded quote/backtick delimiters, double-percent-encoded JavaScript escape delimiters, double-percent-encoded HTML quote/backtick entity delimiters, repeated percent-encoded quote/backtick delimiters through eight encoding layers using compact pre-scan normalization, repeated percent-encoded JavaScript escape delimiters through eight encoding layers using compact pre-scan normalization, repeated percent-encoded HTML quote/backtick entity delimiters through eight encoding layers using compact pre-scan normalization, and unquoted status-like scalar strings, status-like attributes, status-like one-value shortcuts, and extended clean status strings, public JavaScript source positive-shape drift including escaped quote delimiters, JavaScript Unicode/hex/braced-Unicode/octal quote escapes, arbitrary-padded percent-encoded braced-Unicode quote escapes, JavaScript template-literal backticks, JavaScript escaped backticks, percent-encoded quote/backtick delimiters, percent-encoded JavaScript escape delimiters, double-percent-encoded quote/backtick delimiters, double-percent-encoded JavaScript escape delimiters, repeated percent-encoded quote/backtick delimiters through eight encoding layers using compact pre-scan normalization, repeated percent-encoded JavaScript escape delimiters through eight encoding layers using compact pre-scan normalization, quoted positive object-key booleans, numeric-one, quoted string-one, or quoted string-true positive-key snippets, status-like one-value shortcuts, and extended clean status strings, OpenAPI status-like clean-string drift outside safety metadata, OpenAPI host/freshness drift, robots/sitemap discovery drift, broken links/assets, stale public anchors, unsafe copy payloads, and template accessibility regressions are checked before another peer-review prompt is considered ready.
• Relied-on trace state is bound into reliance_snapshot_hash; certified tokens must fail if a structured reliance dependency changes after issuance.
• Public client snippets now show the compliant path: fetch current validation, call /api/v1/dbad/trust-continuation/check, verify the short-lived token, and reject copied JSON as authorization.
• Successful token verification exposes valid_from_utc and valid_until_utc and may produce a signed historical_verification_attestation, but that artifact is labeled NOT AUTHORIZATION - HISTORICAL EVIDENCE ONLY, carries attestation_class=historical_non_authoritative and authorization_status=NOT_AUTH::not_authorization_status_evidence_for_structural-evidence-code-v2-..., remains audit evidence only, and is rejected as trust-positive authorization.
• Persistent DB-backed token revocation/introspection and signed first-use resource-continuity attestations are deferred decision gates, not hidden guarantees.
• DecencyMeter remains advisory and must not be described as DBaD approval.
• Public entry pages now point back to this current-state baseline and update log, and should not contradict the API/docs contract for point-in-time evidence, safe citation, archival projection, or advisory scoring boundaries.