What is current now?

Current Proof Surfaces

• Cross-trace lineage and public fixture brief
• Trace index with current-validation badges
• 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: DBaD API evidence routes under /api/v1/dbad/ now force Cache-Control: no-store, max-age=0, must-revalidate, Surrogate-Control: no-store, Pragma: no-cache, Expires: 0, and X-DBaD-Cache-Status: fresh. The focused status-field compliance audit checks these headers so stale cached trace/API payloads cannot satisfy the current proof contract.

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. The trace index now renders Current runtime validation evidence, Stored effective-state evidence, Review status evidence, Expected evidence, Outcome evidence, Completeness evidence, Closure evidence, and Blind spot count, not authorization; 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: round53_trust_response_evidence_binding_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 is_valid = true, 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 snippets such as is_valid = true 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.

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: 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. It includes current status-snapshot, trace API, trust-continuation check, and token-verification samples with headers, redacts live tokens and historical attestations, and signs 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.

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.

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, limitations, reviewer Q&A, and cautious publication positioning. Formal proof remains future work.

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, or X-DBaD-Cache-Status: fresh. 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.

Public contract expansion: run_ethics_public_contract_audit.py now also executes audit_public_api_docs_discovery_schema.py and audit_dbad_openapi_host_canonical.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.

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, plus audit_template_accessibility.py. A missing API-doc link, broken static asset, malformed page shell, or template accessibility regression now fails the standard pre-peer contract artifact.

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_authorized, 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=round53_trust_response_evidence_binding_v1, provenance_class, safe_citation_v1_accepted=false, and requires_trust_continuation_token_for_authorization=true. 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 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 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_public_api_docs_live_routes.py, audit_html_health.py, audit_template_copy_payloads.py, and audit_template_accessibility.py, so public-surface drift, API-doc discovery drift, ethics discovery JSON freshness drift, OpenAPI host/freshness drift, broken links/assets, 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.