ELNOR REPO READER TEXT MIRROR Original path: Memory Rebuild Docs/Flattening/Reviews/Stage 6 Reviews/Stage 6 E0 Red Teaming/Claude Stage 6 EO RT Review 1.md Source repo: /Users/OpenClaw1/Elnor/Elnor Specs Git branch: main Git commit: dbaa25962edc11ab30e8d4ca1715f9ae5bf77331 Generated: 2026-06-09T01:23:58.539Z --- ```` # E0 / DOC80-Core Charter — Unified Red-Team Review & Remediation Plan (Final, v2 — completeness-audit folded in) ## 0. Document control | Field | Value | |---|---| | **Target** | `Memory Rebuild Docs/Stage_6_Charters/E0_DOC80_Core/Charter_Draft.md` (1083 lines; §0–§17) | | **Review prompt** | `…/E0_DOC80_Core/E0_Red_Team_Review_Prompt.md` | | **Method** | 3-round decorrelated red-team: Claude (2-pass) × GPT-5.5-Pro (2-pass), repo-verified against ground truth via the GitHub connector | | **Ground truth checked** | ABC R0.2, Round D R0.2, Concept Model, Owner Map, Import Graph, Retired Names, ADQ (46 rows), Supersession Matrix, Stage 5R synthesis, Stage 5R2/5R2c patch summaries, OPA_V4, STAGE_6_CHARTER_INPUT_INDEX | | **Scope discipline** | E0 is the family **grammar** — names, one-owner assignments, invariants, lint *names*. Field-level schema bodies belong to Stage 7; fixtures to Stage 8; lint implementation to Stage 9; member semantics to DOC81–DOC87. A finding earns a full E0 schema body only if **E0 owns the object AND its design is settled**. | | **Output** | Review document only. No repo writes performed. | | **v2 changelog** | This version folds in a completeness audit of v1. Added: §2.5 (named-lint inventory verification); UR-21 (citation collision — closes the v1 numbering gap); UR-46 (named-lint preservation — the full synthesis lint inventory v1 under-captured); UR-47 (four-way monotonicity invariant family, skeletal §11.9); UR-48 (three-column invariant enforcement table). Corrected: UR-02 and UR-29 lint names to canonical source tokens; UR-08 (+7th revocation lint); UR-18 (+canonical bitemporal lint); UR-30 (N12 sub-points); §8 (provenance caveat on ChatGPT-coined lint names). Added §12 (fidelity notes) and the audit-fold changelog appendix. | **Tag legend:** `BUG` (wrong, not just incomplete) · `GAP` (missing) · `SUGGESTION` · `CONFIRMED` (verified correct) · `BETTER_IDEA` (forward pattern) · `ARCHITECT_STOP` (do not proceed / do not reopen) · `OOS-ADVISORY` (out of scope, flagged). **Disposition classes:** **A** full E0-owned body · **B** E0 name + invariant + lint names only · **C** E0 registry/grammar, body downstream · **D** Stage 7 schema-body handoff · **E** Stage 8 fixture handoff · **F** Stage 9 lint implementation · **G** source-pack drift / assurance patch · **H** rejected / do-not-reopen. **Provenance tags** on each finding: `[C-A#/C-N#]` = Claude round 1 / round 2; `[G-F#]` = GPT-5.5-Pro; `[both]` = independent convergence. --- ## 1. Executive verdict **`E0_NEEDS_REVISION_BEFORE_RED_TEAM_CLOSES`.** - **Severity:** Moderate, surgical hardening — **with one P0 source conflict that blocks E7/E8** (`ContextProductKind`). Not a global architecture restart; not a Stage 6 family failure. - **Grade:** Architecture direction A-/B+. Draft as a load-bearing source of truth B+/A- after the verified must-fix preservation is credited (the 12 Stage 5R synthesis must-fixes **did** land — verified). Ratifiable as final foundation **only after** the patch set below. - **What it blocks:** E7/E8 cannot safely bind `ContextProduct` until the kind registry is corrected. E9 (learning) cannot bind until final-prompt-truth gating is named. - **The one-line why:** The draft is ~90% sound and citation-accurate, but it (a) reconstructed the `ContextProductKind` registry from memory and got it ~88% wrong against the senior source, (b) gates learning on *packet assembly* rather than *final-prompt execution*, and (c) drops a substantial set of named lints (and one cross-plane cascade) that the synthesis treats as load-bearing. The correct grading lens is **misuse-resistance**: can a downstream charter author, Stage 7 schema author, Stage 8 fixture author, and Stage 9 lint author proceed without re-discovering Stage 5R2 work or inventing core semantics? Today: not quite. After this patch set: yes. --- ## 2. Verified ground truth (what was checked against the repo) This review is empirical, not armchair. **2.1 The `ContextProductKind` conflict — VERIFIED, and it is the headline.** `ABC R0.2 §9.2` ("Context product registry") enumerates **exactly 17** `ContextProductKind` values. ABC is **senior per DR-001** (Skeletal §3.3) and is a **target-freeze input** (Flatten Plan §3.5). `SM-060` says **14** with no documented merge rationale. The draft's §3.1 list of 14 "illustrative" names matches **neither** — only `null_result_notice` and `reference_only_notice` overlap; **12 of the draft's 14 are invented** and **15 of ABC's 17 are absent** from the draft. **Finality check:** the two candidate "later" sources the draft itself named — `Round D R0.2` and `Concept Model §17` — were checked for a competing enumeration. **Neither re-enumerates.** Round D references the type once and scatters 5 names in prose; Concept Model scatters 8; **neither contains an enum block.** ABC §9.2 is the only full enumeration in the corpus. **Conclusion: adopt 17; SM-060's "14" is stale.** **2.2 Source-pack drift — all three claims VERIFIED.** - Owner Map still carries a retired-name row `| CognitiveDiff + Resume card | DOC84 | DOC86 surfaces | … |` with **no** `ResumeProjection`/`ResumeCard` row. (Drift is in the **Owner Map**, a baseline artifact; the draft's §5.3 correctly uses `ResumeProjection`/`ResumeCard`.) - `STAGE_6_CHARTER_INPUT_INDEX` **omits ADQ-313** from the E0 section while listing ADQ-203/208/210/211/310/403/404. The Input Deck **includes** ADQ-313; the draft correctly followed the Deck (§2.2). - `DOC8` appears as a `ReasonCode` producer at **Owner Map L86** and **ADQ-310**, contradicting **ADQ-221** ("DOC8 capability-mining only, not runtime"). The draft correctly dropped DOC8 from §2.1 and states the capability-mining-only posture at §7.3 — but **added DOC25** to the producer list, which is not in the source. The review-prompt read-order path for the Stage 5R synthesis is also stale (points to `Red Team Ready/`; file lives under `Red Team Responses/`). **2.3 Preservation — the 12 synthesis must-fixes DID land (refutes a "systemic loss" diagnosis).** All 12 Stage 5R synthesis must-fixes are present and consumed appropriately in the draft. The real preservation gap is **narrow but specific**: a named-lint set (see §2.5 / UR-46), the five-plane revocation cascade, the SemanticProjection split, the golden scenario, F-struct #3/#4, and the 17-kind enum — not a wholesale dropped payload. **2.4 Faithfulness — CONFIRMED accurate.** Owner Map line citations in the draft are accurate (L80, L86, L125–128, L143–150, L153, L171, L204, L238). Import Graph topo order matches §15.2 exactly (`DOC80 < DOC81 < DOC82 < DOC87 < DOC83 < DOC84 < DOC85, DOC86`), acyclic, DOC9 not imported. The 7 ABC §21 objects are genuinely absent from the Owner Map, validating the §13 placement-check premise. OPA_V4: 117 obligations target DOC81–87, **zero** target DOC80 core. ADQ resolutions (207, 209, 210, 305, 313, 316, 405, 202, 221) are faithfully implemented. Retired-name compliance holds in the draft body (`CognitiveDiff`/`NonAssertionExtractionOutcome`/`SourceBoundSynthesisProjection` appear only in lineage citations; `DAMS` only as the DOC84 substrate). **2.5 Named-lint inventory — VERIFIED against the synthesis + skeletal (grounds UR-46/UR-47).** The synthesis (`…/Red Team Responses/DOC80_Stage_5R_Red_Team_Reviews_and_Synthesis.md`) and skeletal baseline contain a substantial set of **named lints absent from the draft**. Confirmed present in source: `projection.*` (4), `revocation.*` (7), `assertion.doc82_resolution_missing_doc83_emission_ref` / `assertion.doc83_final_resolution_without_doc82` / `assertion.overlapping_resolution_disposition_enum`, `learning.utility_without_final_prompt_proof`, `learning.writeback_without_ec_execution`, `erasure.retired_used_as_erased`, `erasure.legal_hold_bypassed_without_adq_resolution`, `versioned_claim.lineage_table_missing` / `versioned_claim.unmapped_to_assertion_variant`, `doc15.context_budget_import_missing`, `dynamic_header_ledger.owner_unresolved_at_doc84_charter`, `bitemporal.evidence_edge_missing_source_span_temporal_snapshot`, `fixture.membership.removed_edge_appears_nowhere`, plus the flatten-governance families `import_graph.*` (6), `owner_map.*` (7), `opa.*` (5). The four monotonicity properties are stated as algebraic laws at **skeletal §11.9** (not as named lint tokens). **Provenance note:** the `adapter.*`, `cu_doc73.*`, and `monotonicity.*` lint *tokens* cited in the GPT review were coinage — the underlying invariants/concerns are real (adapter convergence appears 5×, CU divergence 2×, monotonicity §11.9), but those exact tokens are not verbatim source. --- ## 3. Remediation taxonomy Each finding is dispositioned into one of eight classes so the revision stays surgical and E0 does not absorb Stages 7–9 or member-charter work: ```text A Full E0-owned contract body E Stage 8 fixture handoff B E0 name + invariant + lint names F Stage 9 lint implementation C E0 registry/grammar, body downstream G Source-pack drift / assurance patch D Stage 7 schema-body handoff H Rejected / do-not-reopen ``` --- ## 4. The patch set — full findings inventory ### 4.1 `UR-01` · BUG · P0 · Class C — `ContextProductKind` is a source conflict, not a Stage-7 cleanup `[both: C-G1 / G-F2]` **§3.1.** The draft treats its 14-kind list as illustrative pending Stage 7. Per §2.1, the senior source (ABC §9.2) defines 17, SM-060 says 14, and the draft's names match neither. `ContextProduct` is a precondition for DOC84/E7/E8; an unstable registry blocks context assembly. **Fix — adopt ABC §9.2's 17 verbatim; patch SM-060; replace the §3.1 enum; align the entry shape to ABC §9.3:** ```ts type ContextProductKind = | "assertion_packet" | "direct_memory_item" | "topic_notice" | "topic_slice" | "library_notice" | "library_source_slice" | "cu_source_bound_synthesis" | "recent_work_orientation" | "issue_frame_orientation" | "directive_block" | "procedure_block" | "warning_constraint" | "null_result_notice" | "conflict_notice" | "search_affordance" | "reference_only_notice" | "blocked_scope_notice"; type ContextProductRegistryEntry = { kind: ContextProductKind; registry_owner: "DOC80"; payload_schema_owner: OwnerDocId; assembly_contract_owner: "DOC84"; packet_executor: "DOC24"; role_band: RoleBand; allowed_warrants: UseWarrant[]; allowed_support_roles: SupportRole[]; header_fields_required: string[]; default_budget_band: "xs" | "s" | "m" | "l"; evictable: boolean; degrades_to?: ContextProductKind; learning_target: LearningTarget; candidate_injectable: boolean; final_prompt_instance_spine_required: boolean; // ties to UR-02 }; ``` **Lints (F):** `context_product.kind_not_in_registry`, `context_product.payload_schema_owner_missing`, `context_product.assembly_contract_owned_by_doc80`, `context_product.instance_id_not_preserved_to_final_prompt`. **Residual decision:** senior-vs-senior (ABC §9.2 vs Supersession Matrix). Absent a documented 14-compression — none found — ABC wins. Ratify "17 canonical," or surface a compression decision if one exists outside the named candidates. ### 4.2 `UR-02` · BUG · P0 · Class B — Final-prompt truth is not wired; learning can attribute to never-injected context `[both: C-Theme-A / G-F5]` **§3.3, §4.1.** `ContextPacketProof` (§4.1) proves *packet assembly* — not what reached the executed prompt. DOC85 can therefore learn from context that was planned, packet-assembled, then trimmed/suppressed/never injected. The trace (§3.4) already references a `FinalPromptInjectionManifest`, and Skeletal DOC80 §18 already states "final prompt proof → learning eligibility, proof-gated" — so this is a wiring gap, not a new concept. **Fix — NAME the hook in E0; DOC11/OpenClaw owns the runtime body (NOT a full E0 schema):** ```md ### FinalPromptTruthRef — NAMED-only E0 contract hook Runtime-truth body owner: DOC11 / OpenClaw | E0 role: name the dependency + bind family invariants Invariant (add to §12.1): No learning attribution, utility credit, or prompt-shell-exposure learning may attach unless the cited context-product / prompt-shell span survived into the executed final prompt under a FinalPromptTruthRef (final_prompt_text_hash + manifest + surviving span refs). ``` **Lints (F):** `learning.utility_without_final_prompt_proof` (← canonical source name; the v1 draft's `learning.utility_credit_without_final_prompt_truth` was non-canonical coinage), plus proposed `learning.utility_credit_for_trimmed_span`, `learning.utility_credit_for_suppressed_span`, `render.context_product_instance_id_lost_before_final_prompt` (confirm tokens at Stage 9). ### 4.3 Proof spine #### `UR-03` · BUG · P0 · Class A — `MemoryFlowCertificate` must be a discriminated union `[both: C-N4 / G-F4]` **§3.3.** ADQ-207 mandates MFC for durable_write, render, export, carryover, delegation, learning_attribution (internal candidate reads exempt). The draft uses one interface with optional refs + prose comments — a coding agent can mint a render certificate with no `ContextPacketProof`, no `RenderSafetyProof`, no final-prompt truth. MFC is E0-owned and settled → full body in E0. ```ts type MemoryFlowKind = "durable_write"|"render"|"export"|"carryover"|"delegation"|"learning_attribution"; interface BaseMFC { certificate_id: MemoryFlowCertificateId; schema_owner: "DOC80"; issued_by: "EC"; coordination_trace_ref: MemoryCoordinationTraceRef; policy_generation_id: PolicyGenerationId; effective_policy_ref: EffectiveMemoryPolicyRef; ec_path: "serialized_durable" | "anchored_attestation"; // <- THEME-C, see UR-04 created_at: string; // RFC3339 UTC } interface WithheldMFC extends BaseMFC { outcome:"withheld"; flow_kind:MemoryFlowKind; withheld_reason_code: ReasonCodeId; } interface DurableWriteMFC extends BaseMFC { outcome:"issued"; flow_kind:"durable_write"; ec_path:"serialized_durable"; mutation_envelope_ref: MemoryMutationEnvelopeRef; } interface RenderMFC extends BaseMFC { outcome:"issued"; flow_kind:"render"; ec_path:"anchored_attestation"; context_packet_proof_ref: ContextPacketProofRef; render_safety_proof_ref: RenderSafetyProofRef; final_prompt_truth_ref: FinalPromptTruthRefId; } interface ExportMFC extends BaseMFC { outcome:"issued"; flow_kind:"export"; ec_path:"anchored_attestation"; context_packet_proof_ref: ContextPacketProofRef; export_manifest_ref: ExportManifestRef; } interface CarryoverMFC extends BaseMFC { outcome:"issued"; flow_kind:"carryover"; ec_path:"anchored_attestation"; context_packet_proof_ref: ContextPacketProofRef; carryover_capsule_ref: CarryoverCapsuleRef; } interface DelegationMFC extends BaseMFC { outcome:"issued"; flow_kind:"delegation"; ec_path:"anchored_attestation"; context_packet_proof_ref: ContextPacketProofRef; delegation_payload_ref: DelegationPayloadRef; } interface LearningAttributionMFC extends BaseMFC { outcome:"issued"; flow_kind:"learning_attribution"; ec_path:"serialized_durable"; context_packet_proof_ref: ContextPacketProofRef; final_prompt_truth_ref: FinalPromptTruthRefId; learning_signal_ref: LearningSignalRef; } type MemoryFlowCertificate = WithheldMFC|DurableWriteMFC|RenderMFC|ExportMFC|CarryoverMFC|DelegationMFC|LearningAttributionMFC; ``` **Lints (F):** `proof.{durable_write|render|export|carryover|delegation|learning_attribution}_without_memory_flow_certificate`, `proof.withheld_certificate_missing_reason_code`, `proof.flow_kind_required_ref_missing`. #### `UR-04` · BUG · high · Class A — MFC issuance must separate the serialized write path from delivery attestations (THEME-C) `[C-Theme-C; absent from GPT review]` **§3.3, §7.1.** The union above stamps `issued_by:"EC"` on *every* certificate, including `RenderMFC`. Combined with ECSeam (single serialized durable writer + ordering + CAS), that puts **every interactive render** on the durable-write commit path. Durable writes are rare and *should* serialize through EC; renders happen every turn and are latency-sensitive. The contract must not conflate "EC-anchored against the current policy generation" with "serialized through EC's durable-write queue." **Fix:** the `ec_path` discriminator (`serialized_durable` for `durable_write` + `learning_attribution`; `anchored_attestation` for `render`/`export`/`carryover`/`delegation`) + §12.1 invariant: *delivery attestations are EC-signed against a read-consistent policy generation and MUST NOT take a write-queue lock.* **Lint (F):** `ec.delivery_attestation_on_serialized_write_path`. #### `UR-05` · BUG · high · Class A — `ContextPacketProof` membership eligibility must be edge-level, not boolean (instance of THEME-A) `[both: C-§4.E / G-F6]` **§4.1.** A boolean cannot prove which edges were checked, their lifecycle state, who gated them, or why. §12 requires removed/blocked membership never reach injection and `injection_eligible` to be total. ```ts type MembershipLifecycleState = "candidate"|"active"|"blocked"|"removed"|"stale"|"suppressed"|"archived"; interface MembershipEligibilityProof { membership_edge_ref: MemoryMembershipEdgeRef; lifecycle_state: MembershipLifecycleState; injection_eligible: boolean; gate_owner: "DOC87"|"DOC84"; policy_generation_id: PolicyGenerationId; reason_codes: ReasonCodeId[]; } // ContextPacketProof carries: membership_eligibility_results: MembershipEligibilityProof[] // plus included_set_hash + excluded_set_hash (THEME-A content binding) ``` **Lints (F):** `proof.membership_eligibility_boolean_only`, `proof.injected_membership_without_edge_level_result`, `proof.injected_membership_lifecycle_not_active`, `proof.injected_membership_missing_reason_codes`. #### `UR-06` · BUG · medium · Class A — `RenderSafetyProof` outcome must be derived from `checks_failed` `[C-N4 render half; absent from GPT final list]` **§4.2.** Add the inter-field invariant: `outcome === "blocked"` iff any required check is in `checks_failed`; the outcome field is not independently writable. The contract/execution split (§4.2 title already says "DOC84 executes; DOC11 finalizes") is otherwise correct — keep the *contract* in E0, the *executed body* in DOC84. **Lints (F):** `render_safety.outcome_not_derived_from_checks`, `render_safety.failed_check_did_not_block_render`, `render_safety.executed_body_defined_in_doc80`. #### `UR-07` · GAP · high · Class A — Proof artifacts need retention classes (resolves canonical-vs-derived ambiguity) `[both: C-N9 / G-F19]` **§11.3.** §11.3 leaves `ContextPacketProof`, `RenderSafetyProof`, `MemoryFlowCertificate`, `FinalPromptTruthRef`, `MemoryCoordinationTrace` ambiguously canonical-vs-derived → replay re-derivation risk. ```ts type ProofRetentionClass = "durable_audit_required"|"durable_if_effect_committed"|"transient_allowed_only_if_effect_not_committed"|"derived_rebuildable"; interface ProofArtifactRetentionRule { artifact_type: string; retention_class: ProofRetentionClass; retained_by: "EC"|"DOC11"|"DOC84"|"DOC85"; replay_required: boolean; audit_required: boolean; } ``` **Rule:** any proof that gates a durable write, learning signal, export, carryover, delegation, or final-prompt render is `durable_audit_required` (canonical, append-only, never recomputed) or referenced by its originating `MemoryMutationEnvelope`. **Lints (F):** `proof.gated_effect_without_retained_proof`, `proof.retention_class_missing`, `proof.transient_proof_used_for_durable_effect`. ### 4.4 Source-revocation cascade & monotonicity #### `UR-08` · GAP · high · Class B/C — `CascadingSourceInvalidation` five-plane fan-out is collapsed to one monotonicity row `[both: C-A1 / G-F9]` **§12.1.** Stage 5R2 (Skeletal §10.11) requires revocation to fan out across **five planes** with named lints; the synthesis calls this "the real source-revocation finding." The draft abstracts it to a single §12 monotonicity row. The *invariant* is cross-plane → E0; per-plane *execution* → members. ```ts interface SourceRevocationCascade { source_ref: SourceRef; revocation_event_ref: MemoryMutationEnvelopeRef; required_outcomes: { doc82_support_edges: "invalidated"|"verify_required"; doc87_memberships: "restamped"|"removed"|"hidden"; doc84_delivery_artifacts: "invalidated"; doc85_learning_signals: "ineligible_for_future_utility"; doc86_surfaces: "safe_labeled"|"suppressed"; }; ec_receipt_refs: ECReceiptRef[]; reason_codes: ReasonCodeId[]; } ``` **Lints (F) — canonical synthesis tokens (7):** `revocation.support_edge_survives_revoked_source`, `revocation.membership_survives_revoked_source_without_restamp`, `revocation.carryover_capsule_survives_revoked_source`, `revocation.learning_credit_after_revocation`, `revocation.learning_signal_survives_revoked_source`, `revocation.inspector_leaks_revoked_source`, `revocation.published_view_not_invalidated_after_revocation`. #### `UR-09` · BUG · high · Class B/F — Revocation monotonicity is FALSE for contrary edges `[C-N3, refined by GPT]` **§12.1.** A blanket "revocation raised/lowered eligibility" lint is wrong: revoking a **supporting** source lowers warrant, but revoking a **contradicting** source *raises* net warrant. **Fix — polarity-aware recompute-trigger lints:** `revocation.supporting_source_removed_without_recompute`, `revocation.contrary_source_removed_without_recompute`, `revocation.net_warrant_changed_without_recompute_trace`. (See UR-47 for the four-way monotonicity invariant family this sits within.) ### 4.5 Registries #### `UR-10` · GAP · high · Class A — `ReasonCode` registry is not collision-proof; DOC8 producer residue `[both: C-§5.4 / G-F13]` **§2.1.** ADQ-310 makes DOC80 the canonical registry with namespaced producer entries. The draft has the concept but loose namespace strings, no reserved-prefix/lifecycle/collision/case rules. Source drift: DOC8 still listed as a producer (Owner Map L86 / ADQ-310) vs ADQ-221. ```ts interface ReasonCodeNamespaceAllocation { namespace: ReasonCodeNamespace; pattern: "^[A-Z][A-Z0-9_]{1,31}$"; owner_doc: OwnerDocId; state: "reserved"|"active"|"deprecated"|"retired"|"legacy_reserved"; allocated_in: SchemaVersionRef; replacement_namespace?: ReasonCodeNamespace; legacy_allowed_only?: boolean; } interface ReasonCodeRegistryEntry { reason_code_id: ReasonCodeId; namespace: ReasonCodeNamespace; local_name: string; pattern: "^[A-Z][A-Z0-9_]{1,63}$"; owner_doc: OwnerDocId; lifecycle_state: "active"|"deprecated"|"retired"; introduced_in: SchemaVersionRef; replacement_reason_code_id?: ReasonCodeId; } ``` **DOC8 decision:** remove DOC8 from active producers (capability-mining only per ADQ-221) or mark `legacy_reserved` incapable of emitting runtime codes. Reconcile the producer list — the draft dropped DOC8 (correct) but added DOC25 (not in source); confirm DOC25's status explicitly. **Lints (F):** `reason_code.namespace_unallocated`, `reason_code.namespace_collision`, `reason_code.namespace_state_legacy_emitted_runtime_code`, `reason_code.retired_code_emitted`, `reason_code.case_pattern_violation`. #### `UR-11` · GAP · high · Class C — `DomainProfile` fallback needs a per-axis conservative meet, not a scalar rank `[G-F14, upgrades C-H4]` **§2.2.** The draft uses `restrictiveness_rank: number`. A scalar cannot represent a profile that is strict on export but loose on render. E0 owns the **registry + fallback rule**; DOC81 owns the **axis values**. ```ts type RestrictivenessLevel = "open"|"normal"|"restricted"|"highly_restricted"|"blocked"; interface DomainProfileRestrictivenessVector { extraction:RestrictivenessLevel; rendering:RestrictivenessLevel; disclosure:RestrictivenessLevel; export:RestrictivenessLevel; carryover:RestrictivenessLevel; delegation:RestrictivenessLevel; learning:RestrictivenessLevel; retention:RestrictivenessLevel; source_authority:RestrictivenessLevel; } // E0 fallback rule: effective = per-axis most-restrictive applicable profile. // missing | unknown | incomparable on any axis => that axis resolves conservative. // multi-axis action allowed only if EVERY touched axis allows it. DOC81 owns axis vocabulary + semantics. ``` **Lints (F):** `domain_profile.scalar_rank_used`, `domain_profile.missing_conservative_fallback`, `domain_profile.incomparable_axis_without_fail_closed`, `domain_profile.unknown_profile_did_not_resolve_conservative`. #### `UR-12` · GAP · high · Class A — `ExternalDependencyRecord` is not reproducible `[G-F15]` **§7.4.** Add audit-grade pins (drop heavy human-verifier fields; `last_verified_at` optional): ```ts interface ExternalDependencyRecordMinimum { dependency_doc: OwnerDocId; dependency_kind: "schema_import"|"runtime_dependency"|"requirements_source"|"capability_mining_only"|"aspirational"; repo_path: string; git_commit_sha: string; source_line_ranges: string[]; content_hash: string; hash_algorithm: "sha256"; dependency_status: "stable"|"partial"|"moving"|"stale"|"retired"|"blocked"; drift_response: "block"|"warn"|"degrade"|"manual_review"|"ignore_until_next_stage"; drift_action_owner: OwnerDocId; importing_members: OwnerDocId[]; last_verified_at?: string; } ``` **Lints (F):** `external_dependency.hash_algorithm_missing`, `external_dependency.commit_sha_missing`, `external_dependency.line_pin_missing`, `external_dependency.phantom_marked_runtime_import`, `external_dependency.moving_dependency_without_drift_response`. #### `UR-13` · SUGGESTION · medium-high · Class A/B — `PromptShellVariant` cache eligibility should be derived `[G-F17]` **§2.3.** ADQ-305: stable headers are stable only if hash-pinned AND policy-invariant. Make eligibility derived, not authored: ```ts function kv_cache_eligible(v: PromptShellVariant): boolean { return Boolean(v.content_hash) && v.policy_invariant === true && v.lifecycle_state === "active"; } ``` **Lints (F):** `prompt_shell.cache_eligible_without_content_hash`, `prompt_shell.cache_eligible_policy_variant`, `prompt_shell.retired_variant_used_for_new_packet`. #### `UR-14` · CONFIRMED · Class A — Warrant-degradation-trigger registry is correctly E0-owned **§2.4.** ADQ-312 + Owner Map L171 put the trigger registry at DOC80; the draft places it correctly. Keep the entry mechanics in E0. (See UR-22 for the authority-exemption gap in degradation *behavior*, and UR-47 for the monotonicity invariant the trigger's `monotonic_effect` field encodes.) ### 4.6 Context planning & delivery #### `UR-15` · GAP · high · Class C — `MemoryContextPlan` needs per-product request/disposition grammar `[both: C-N5 tie / G-F16]` **§3.2.** A plan-level requested-product list lets dropped context disappear invisibly. E0 owns the **request/disposition grammar**; DOC84 **records** runtime outcomes. ```ts type ContextProductDisposition = "assembled"|"degraded"|"blocked"|"suppressed_manifest_only"|"not_found"; interface MemoryContextProductRequest { request_id: string; kind: ContextProductKind; purpose: "answer"|"orientation"|"constraint"|"source_support"|"search_affordance"|"warning"|"carryover"; priority: "must_include"|"high"|"normal"|"low"; allowed_dispositions: ContextProductDisposition[]; max_budget_band: "xs"|"s"|"m"|"l"; fallback_kind?: ContextProductKind; required_proofs: ProofRequirement[]; } // DOC84 records MemoryContextProductOutcome { request_id; disposition; product_instance_ref?; reason_codes } ``` **Lints (F):** `context_plan.product_request_without_outcome`, `context_plan.must_include_product_silently_dropped`, `context_plan.fallback_kind_not_in_registry`, `context_plan.required_proof_missing_for_product`. (Three-plan separation per ADQ-209 is CONFIRMED correct; keep it.) #### `UR-16` · BUG · medium-high · Class C — `ContextProduct` registry-vs-assembly boundary should be tightened (downgraded from P0) `[G-F3]` **§3.1.** The draft already labels `assembly_owner:"DOC84"` (so not a P0), but `required_inputs_by_kind` can drift into DOC84 assembly-body semantics. Keep the registry entry + cross-cutting determinism contract (UR-19) in E0; move per-kind input *bodies* to DOC84. Remaining force tied to UR-01. ### 4.7 EC seam & bitemporal #### `UR-17` · BUG · medium-high · Class A — `ECSeamContract` must explicitly list read-model-refresh + no-non-EC-durable-writer `[both: C-A7/Q11 / G-F27]` **§7.1.** Skeletal §10.9's 12-item EC seam is mostly covered; make the two implicit items explicit + lints: ```ts interface ECSeamContract { schema_owner:"DOC80"; executor:"EC"; owns_durable_writes:true; owns_command_execution:true; owns_policy_scope_execution:true; owns_membership_writes:true; owns_learning_writeback:true; owns_source_revocation_execution:true; owns_audit_replay:true; owns_transaction_ordering:true; owns_compare_and_swap:true; owns_read_model_refresh:true; non_ec_durable_writers_forbidden:true; } ``` **Lints (F):** `ec.non_ec_durable_writer_detected`, `ec.read_model_refresh_without_ec_receipt`, `ec.cas_missing_for_generation_sensitive_write`, `ec.policy_regate_not_executed_by_ec`, `learning.writeback_without_ec_execution` (canonical synthesis token — learning write-back is an EC-owned durable write). (See UR-04 for the attestation-path pairing.) #### `UR-18` · CONFIRMED-with-hardening · Class B/D — Bitemporal carrier split is right but must be explicit `[both: C-Q10 / G-F28]` **§8.2.** Keep both carriers, make the split explicit: `MemoryMutationEnvelope` carries mutation/replay/order time; DOC82 `Assertion`/`AssertionVariant`/`EvidenceSupportEdge` retain domain-valid + transaction-time axes; **linkable, not collapsed**. **Lints (F):** `bitemporal.evidence_edge_missing_source_span_temporal_snapshot` (canonical synthesis token), `assertion.bitemporal_axes_missing_transaction_time`, `assertion.bitemporal_axes_missing_valid_time`, `memory_mutation_envelope.valid_time_used_as_replay_order`. ### 4.8 Determinism, reproducibility, tracing #### `UR-19` · BUG · high · Class A/B — Determinism rule contradicts learned shell reweighting; restate over content/selection (THEME-B) `[C-N2, precision-corrected vs GPT]` **§3.1.** The draft's determinism rule (`product_is_a_pure_function_of_named_inputs`) breaks once any learned shell weighting / utility model affects assembly — unless that learned input is *named*. **Precision:** state the property over **product content and the selected-product set** (the replayable thing), **not** over `context_product_instance_id` (an identifier may be a fresh UUID; content-addressing the ID is a separate optional choice). Unify the named-input bundle into one **reproducibility key** (THEME-B) referenced by both the determinism invariant and §11.3 replay: ```ts interface ReproducibilityKey { request_input_hash: ContentHash; policy_generation_id: PolicyGenerationId; context_product_registry_version: SchemaVersionRef; memory_context_plan_version: string; prompt_shell_variant_id: string; shell_weight_generation_id: string; source_generation_id: string; membership_generation_id: string; budget_profile_id: string; } // Invariant: identical ReproducibilityKey => identical assembled product CONTENT and selected-product SET. // Any learned weighting MUST be a named input. ``` **Lint (F):** `determinism.learned_weight_not_named_input`. #### `UR-20` · GAP · medium-high · Class A — `MemoryCoordinationTrace` lacks turn/session correlation `[C-N5; absent from GPT]` **§3.4.** Without correlation fields the Inspector cannot stitch all events caused by one user turn. Add `session_ref`, `turn_id`, `parent_trace_ref?`, `request_correlation_id`. E0-owned; do not defer. **Lint (F):** `memory_coordination_trace.missing_turn_correlation`. ### 4.9 Warrant degradation behavior #### `UR-22` · GAP · high · Class B/C — Warrant degradation must exempt authority-fixed / user-asserted / static facts `[C-N6]` **§2.4.** Degradation must not erode facts that should not decay ("living memory erodes static facts"). E0 names the exemption **rule** + lints; the **mechanism** is an `authority_class` field on the assertion (`user_asserted`|`authority_fixed`|`source_derived`|`inferred`), owned by DOC82/DOC81, that the degradation triggers consult. **Exempt/special-handle:** user-asserted durable facts, authority-fixed content, static facts, legal citations/dates/named entities marked fixed, user-locked memories. **Lints (F):** `warrant_degradation.authority_fixed_fact_degraded`, `warrant_degradation.static_fact_degraded`, `warrant_degradation.user_locked_memory_degraded`. ### 4.10 Operational observability, quotas, runtime #### `UR-23` · GAP · high · Class A/C — Health read model is dashboard-shaped, not operational `[G-F18]` **§9.1.** Add `measurement_window`, `generated_at`, `last_successful_refresh_at`, `freshness_status` (fresh|stale|failed), `severity` (info|warning|degraded|blocked), `source_trace_refs`. Health must drive real degraded/blocked states. **Lints (F):** `health.counter_window_missing`, `health.counter_stale_without_status`, `health.counter_source_trace_missing`, `health.counter_missing_last_successful_refresh`. #### `UR-24` · GAP · high · Class A — `MemoryOperationQuota` lacks units/windows/enforcement/exhaustion `[both: C-N8 / G-F18]` **§10.2.** Add `unit` (items|tokens|runs|seconds|bytes), `window`, `default_value`, `hard_max`, `enforcement_owner`, `on_exhaustion` (pause|degrade|queue_for_review|suppress_noncritical|block), `resume_policy_ref`. **Lints (F):** `quota.unit_missing`, `quota.window_missing`, `quota.enforcement_owner_missing`, `quota.exhaustion_behavior_missing`, `quota.resume_policy_missing`. #### `UR-25` · GAP · medium-high · Class C — `background_yield_to_hot_path: boolean` is unenforceable on single-threaded Node `[C-N8, expanded]` **§10.3.** On OpenClaw (single-thread Node) a boolean "yield" cannot be honored. E0 names the field + required checkpoints on the quota; DOC11/OpenClaw owns execution semantics: ```ts background_execution_strategy: "cooperative_chunking"|"worker_thread"|"child_process"|"deferred_queue_only"; // companions: max_chunk_ms; yield_checkpoint_required; hot_path_preemption_supported; cancellation_checkpoint_required ``` **Lint (F):** `quota.background_yield_boolean_without_runtime_strategy`. ### 4.11 Schema conventions #### `UR-26` · GAP · P1 · Class B/D — Schema-version convention is missing `[both: C-F1 / G-F10]` **§8.** E0 carries a field convention (not a migration subsystem): durable records include `schema_version`; a breaking change requires a named migration plan; Stage 7 owns the migration-plan schema body. **Lints (F):** `schema.version_missing`, `schema.migration_plan_required_for_breaking_change`, `schema.timestamp_not_rfc3339_utc`, `schema.hash_algorithm_missing`. #### `UR-27` · GAP · medium · Class A — Branded IDs + field-naming conventions should be declared globally `[both: C-H1 / G-F32]` **§8.4.** Formalize: JSON fields `snake_case`; TS interfaces `PascalCase`; enums lowercase `snake_case` unless source-canonical differs; durable IDs are branded strings with schema-specific prefixes; every durable record carries `created_at` (+ `updated_at` where mutable) and `schema_owner`. Timestamps RFC3339 UTC; hashes sha256. (Field-naming consistency is otherwise a Q20 PASS — the draft is consistent snake_case.) #### `UR-28` · OOS-ADVISORY → scope-down · Class D/E/F — JSON-Schema-per-contract / lint-registry / fixture-manifest meta-schemas belong to Stages 7/8/9 `[G-F10/F11/F12/F33, held]` E0 should **name** the lint and fixture *shapes* (the draft does) and require `schema_version`; it should **not** build the `LintRegistryEntry` meta-schema (Stage 9), the `FixtureManifest` meta-schema (Stage 8), the full `MemorySchemaMigrationPlan` (Stage 7), or JSON-Schema bodies per contract (Stage 7). Naming the shape is in scope; populating the registries is not. ### 4.12 Lifecycle / erasure #### `UR-29` · ARCHITECT_STOP · Class H + a few F lints — Reject the full lifecycle/erasure state machine; keep only non-equivalence lints `[both: C / G-F20, partially rejected]` **§1.4.** Synthesis §6 **deliberately collapsed** the lifecycle/DOC88 question ("degradation, not destruction; one DOC80 sentence + a DOC81 `LegalHoldState` flag + OP-A rows; do not build DOC88"). A full `MemoryLifecycleState` contract with `may_render`/`may_export`/`may_delete` flags rebuilds the rejected engine. **Do not reopen.** Keep one DOC80 sentence preventing vocabulary collapse + cheap non-equivalence lints. **Canonical source tokens** (use these, not v1's `retired_is_not_erased`-style coinage): `erasure.retired_used_as_erased`, `erasure.legal_hold_bypassed_without_adq_resolution`. Additional proposed non-equivalence lints (confirm tokens at Stage 9): `stale_is_not_erased`, `suppressed_is_not_erased`, `reference_only_is_not_erased`, `archived_is_not_erased`, `revoked_is_not_hard_deleted`. ### 4.13 Object classification #### `UR-30` · GAP · medium · Class A — Add E0-defined objects to the §6 classification table; fix three N12 specifics `[both: C-N12 / G-F21]` **§6.** Classify the E0-*defined* objects now: `ContextPacketProof`, `RenderSafetyProof`, `MemoryFlowCertificate`, `MemoryCoordinationTrace`, `MemoryMutationEnvelope`, `MemoryProvenanceGraph`, `PromptShellVariant`, `FinalPromptTruthRef`, `SemanticProjectionContract` + the four projections, `ExternalDependencyRecord`, `MemoryPlaneHealthReadModel`, `MemoryOperationQuota`. Add an `audit_replay_class` value set (`canonical`|`durable_audit`|`derived`|`transient`|`external_ref`|`named_only`) folded into existing canonical/derived columns (do not duplicate). **Three N12 specifics to fix:** (1) the `ContextProduct` classification row currently reads `"varies"` — enumerate per kind instead; (2) ref-type inconsistency (`ContentReference` vs naked `string` across schemas) — normalize under the UR-27 branded-ID convention and call out the inconsistency explicitly; (3) a phantom `DOC8` `importing_member` entry on a §7.4 dependency — distinct from DOC8-as-ReasonCode-producer; remove and route through the UR-37 drift sweep. ### 4.14 Missing contracts, cross-charter gates, acceptance criteria #### `UR-31` · BUG · P1 · Class C — `SemanticProjectionContract` is named but unspecified `[both: C-C3/A2 / G-F8]` Define the E0 umbrella + axis-owner registration; member docs own the projection bodies (GPT's F8 split is correct — keep it): ```ts interface SemanticProjectionContract { schema_owner:"DOC80"; projection_may_own_truth:false; required_fields:["source_refs","generation_id","invalidation_policy_ref","projection_owner","proof_or_read_model_refs"]; allowed_axes:("delivery"|"ui"|"organization"|"knowledge")[]; } interface SemanticProjectionAxisRegistration { axis:"delivery"|"ui"|"organization"|"knowledge"; concrete_projection_schema:"DeliveryProjection"|"UIProjection"|"OrganizationProjection"|"KnowledgeProjection"; schema_owner:"DOC82"|"DOC84"|"DOC86"|"DOC87"; canonical_truth_owner:OwnerDocId; invalidation_policy_owner:OwnerDocId; } ``` **Lints (F) — canonical synthesis tokens:** `projection.used_as_canonical_truth`, `projection.owner_missing`, `projection.missing_invalidation_policy`, `projection.missing_source_refs` (+ proposed `projection.generation_id_missing`). #### `UR-32` · GAP · high · Class B/G — Add a cross-charter gate table `[G-F23]` **Extend §15.** Downstream charters need a visible "do not cross until X is true" table: ```md ## §15.4 Cross-Charter Gate Table | Gate | Source | Blocked Charter(s) | Required Before | Owner | Blocking | | ContextProductKind conflict (UR-01) | ABC §9.2 / SM-060 | E7/E8 | registry ratified | DOC80 | yes | | FinalPromptTruthRef (UR-02) | Skeletal §18 | E8/E9 | named + invariant | DOC11 | yes | | SourceRevocationCascade (UR-08) | Skeletal §10.11 | E3/E4/E7/E8/E9/E10 | invariant + lints | DOC80 | yes | | SemanticProjectionContract (UR-31) | Owner Map | E3/E7/E8/E10 | umbrella + axis table | DOC80 | yes | | DOC15 context-budget import check | Skeletal | E7/E8 | seam confirmed (lint doc15.context_budget_import_missing) | DOC15 | - | | DOC26 citation-validation check | Skeletal | E10 / ADQ-202 lib | seam confirmed | DOC26 | - | | SourceBoundSynthesisAdapter convergence | Skeletal | E3/E4 | convergence plan | DOC82 | - | | DOC85 two-phase BDSM coordination | Skeletal | E9 | two-phase charter | DOC85 | - | | Library decomposition ADQ-202 gate | ADQ-202 | E4/E_org/E10 | corpus hierarchy | DOC87 | yes | | TopicIdentityContract stub | Skeletal | E5 (before TopicCollectionDirective) | stub | DOC87 | - | ``` #### `UR-33` · GAP · medium · Class A/G — Harden AC-004 / AC-005 `[both: C-Q16/Q17 / G-F26]` **§14.** AC-004 completion = schema + owner boundary + **positive fixture + negative fixture + Stage 9 lint** (do not close at schema+owner-boundary). AC-005 is dependency-gated and cannot close independently in E0 — gated on ADQ-202 **and** ECSeamContract **and** DOC25 materialization/source-binding **and** DOC82 source/evidence semantics. Treat acceptance criteria as gates, not labels. #### `UR-34` · GAP · medium · Class C — `IngestionCostBudget` = DOC25 primary; `WarrantConsequenceRegistry` = DOC82 primary `[both: C-§5.1 / G-F24/F25]` **§16.1 open items.** `IngestionCostBudget` is DOC25-primary (declared against the DOC80 quota envelope). `WarrantConsequenceRegistry` is DOC82-primary unless consequence namespaces become cross-plane (then a DOC80 registry hook only). E0 owns the cross-cutting *trigger* registry (ADQ-312); it does not auto-own warrant *consequences*. Record both as downstream-owned. ### 4.15 Golden scenario & Stage 8 readiness #### `UR-35` · BUG · high · Class A/E — §18 golden scenario is referenced but the draft ends at §17 `[both: C-A3 / G-F30]` **Add §18.** The end-to-end golden scenario (Skeletal DOC80 §18; F-struct #2) is named-not-populated. Populate with the synthesis-corrected phase order and negative fixtures: ```text Golden order: 1 request/source observation -> 2 policy preflight -> 3 extraction admission -> 4 source preparation/materialization -> 5 candidate emission -> 6 canonical resolution -> 7 membership assignment -> 8 policy re-check -> 9 context-product planning -> 10 packet assembly -> 11 rendering -> 12 final-prompt proof -> 13 learning eligibility -> 14 UI/Inspector read-model update -> 15 replay/audit verification Negative fixtures (E): fixture.golden.learning_credit_without_final_prompt_truth_fails fixture.golden.revoked_source_invalidates_support_membership_delivery_learning_ui fixture.golden.removed_membership_cannot_inject (cf. fixture.membership.removed_edge_appears_nowhere) fixture.golden.non_ec_write_detected fixture.golden.context_product_kind_unknown_blocks_assembly fixture.golden.policy_tighten_between_plan_and_render_blocks_or_restamps ``` ### 4.16 Preservation matrix & drift sweep #### `UR-36` · GAP->assurance · high · Class G — Add a Stage 5R/5R2/5R2b preservation matrix `[G-F1, severity corrected]` **Add §17.4 (or §17A).** An assurance artifact proving every synthesis decision lands / defers / exits scope. **Severity corrected:** frame as "high-value assurance gap," not "systemic preservation failure" — the 12 must-fixes verified as landed (§2.3). The matrix surfaces the narrow real gaps (UR-08/09/16 lints, UR-31 split, UR-35 scenario, UR-01 enum, UR-46 lint inventory, F-struct #3/#4). #### `UR-37` · BUG · medium-high · Class G — Run the source-pack drift sweep `[both: C / G-F22/F13]` Patch the verified drifts (§2.2): the `CognitiveDiff + Resume card` Owner Map row -> `ResumeProjection`/`ResumeCard`; add ADQ-313 to the Charter Input Index E0 section; remove DOC8 (and reconcile DOC25) in the Owner Map L86 / ADQ-310 `ReasonCode` producer list; remove the phantom DOC8 `importing_member` on the §7.4 dependency (N12); fix the stale synthesis path in the review prompt read-order. The flatten-governance lints `owner_map.owner_cell_contains_plus_sign` / `owner_map.compound_schema_owner` and `opa.stale_doc8_runtime_learning_reference` are precisely what enforce this sweep (see UR-46(b)). #### `UR-38` · GAP · high · Class G — Reconcile F-struct #3/#4 + shared-runtime-vocab (root cause: commission diverged from Skeletal §2) `[C-A4/A5/A8/A9]` The commission outline diverged from the Skeletal DOC80 §2 target section map without reconciling, dropping **shared-runtime-vocabulary (DOC80 §4)**, **F-struct #3 (DOC80 §19 amendment-magnitude)**, and **F-struct #4 (DOC80 §20 per-member obligations)**. Architect decision: fold these in or record an explicit deferral with owner — do not leave them silently absent. ### 4.17 Residual deeper-dive items | ID | Tag/Sev | Class | §cite | Finding | |---|---|---|---|---| | `UR-21` | BUG / low-med | G | §17.1/§17.2 (and body cites to §9.4/§14/§15/§18) | **Citation collision.** The draft cites DOC80-*target-map* sections §9.4/§14/§15/§18 as bare "Skeletal §N," colliding with the skeletal *document's* own numbering (which stops at §11.13). Ambiguous between "skeletal doc §N" and "DOC80 target-map §N." Disambiguate every cite as either `Skeletal-doc §N` or `DOC80-target §N`. `[C-A; closes the v1 UR-21 numbering gap]` | | `UR-39` | BUG / low-med | G | §17.2 | Mislabels Skeletal §10.7 as "Proof spine -> §4"; it is the DOC82<->DOC83 disposition seam, landed §12 (lints `assertion.doc82_resolution_missing_doc83_emission_ref`, `assertion.doc83_final_resolution_without_doc82`). `[C-N1; absent from GPT]` | | `UR-40` | GAP / low-med | B | §4.1, §12 | `injection_eligible` phrasing needs an explicit "membership eligibility is **necessary, not sufficient** — policy and scope still gate" clause, or it reads as policy-bypass. `[C-N10; absent from GPT]` | | `UR-41` | GAP / low | B/D | §8.1 | Embedding-model migration may require **un-merging** previously-merged assertions; route through review, never a silent split. `[C-N11; absent from GPT]` | ### 4.18 Named-lint preservation, monotonicity invariants, enforcement-point table (audit additions) #### `UR-46` · GAP · high · Class F/G — Preserve the full synthesis named-lint inventory `[C-J1, verified against synthesis/skeletal in §2.5]` **§16.3 roll-up + §17.4 matrix.** The draft (and v1 of this review) enumerated only the `projection.*` and `revocation.*` families and gestured at the rest. The synthesis carries a substantial named-lint set absent from the draft. Preserve it explicitly, split by ownership: **(a) DOC80-substance lints — preserve as Stage 9 names (Class F):** ```text learning.utility_without_final_prompt_proof (ties UR-02 — canonical name) learning.writeback_without_ec_execution (ties UR-17) erasure.retired_used_as_erased (ties UR-29 — canonical name) erasure.legal_hold_bypassed_without_adq_resolution (ties UR-29 — canonical name) assertion.doc82_resolution_missing_doc83_emission_ref (DOC82<->DOC83 seam; ties UR-39) assertion.doc83_final_resolution_without_doc82 (ties UR-39) assertion.overlapping_resolution_disposition_enum versioned_claim.lineage_table_missing versioned_claim.unmapped_to_assertion_variant doc15.context_budget_import_missing (ties UR-32 DOC15 gate) dynamic_header_ledger.owner_unresolved_at_doc84_charter bitemporal.evidence_edge_missing_source_span_temporal_snapshot (ties UR-18) revocation.learning_signal_survives_revoked_source (7th revocation lint; ties UR-08) fixture.membership.removed_edge_appears_nowhere (fixture; ties UR-05) ``` **(b) Flatten-governance lints — real, in the synthesis, but they govern the Import Graph / Owner Map / OPA artifacts. Owner = flatten governance suite, NOT the E0 charter. Acknowledge in the preservation matrix; the `opa.*`/`owner_map.*` ones enforce the UR-37 drift sweep:** ```text import_graph.bidirectional_schema_import_without_architect_approval import_graph.command_flow_listed_as_schema_import import_graph.runtime_flow_listed_as_schema_import import_graph.storage_flow_listed_as_schema_import import_graph.upward_schema_import_to_policy import_graph.invalid_authorization_citation owner_map.compound_schema_owner owner_map.consumer_redefines_schema owner_map.implementation_restates_schema owner_map.multiple_schema_owners owner_map.non_doc_owner_label owner_map.owner_cell_contains_plus_sign owner_map.schema_owner_missing opa.row_contradicts_owner_map opa.stale_dams_owner_reference opa.stale_doc72_assertion_schema_reference opa.stale_doc73_evidence_owner_reference opa.stale_doc8_runtime_learning_reference ``` **(c) Provenance caveat.** The `adapter.activated_without_convergence_plan`, `adapter.permanent_activation_without_architect_blessing`, `cu_doc73.divergence_unresolved_after_charter`, and `monotonicity.<...>_violates_<...>_monotone` lint *tokens* circulated in the cross-LLM review were **coinage, not verbatim source**. The underlying invariants/concerns are real (adapter convergence appears 5x, CU divergence 2x in the skeletal; monotonicity is skeletal §11.9 — see UR-47). Preserve the invariants; treat those exact lint tokens as **proposed**, to be confirmed at Stage 9. #### `UR-47` · GAP · high · Class B — Preserve the four-way monotonicity invariant family (skeletal §11.9) `[C; skeletal §11.9 algebraic laws]` **§12.1.** Skeletal §11.9 states four monotonicity / algebraic laws (enforcement landing in Stage 9 lints + Stage 6 fixtures). UR-09 only addressed the revocation-polarity nuance; the full family must be carried as invariants in §12.1: ```text 1. policy meet is monotonic conservative 2. membership never increases warrant 3. source revocation never increases warrant 4. learning cannot increase epistemic warrant beyond the non-learning ceiling ``` The draft already encodes (2)-style intent via the warrant-degradation-trigger `monotonic_effect: 'lowers_or_holds_eligibility'` field (§2.4) — extend that discipline to all four laws. Lint tokens are proposed (UR-46c); confirm at Stage 9. #### `UR-48` · SUGGESTION · medium · Class B — Upgrade §12.1 to a three-column invariant enforcement table `[G-F29]` **§12.1.** Each load-bearing invariant should map to all three: runtime gate, Stage 9 lint, Stage 8 negative fixture. (Addressed in §7.2 Q14 + the acceptance checklist; promoted here to an explicit suggestion.) ```md | Invariant | Runtime Gate | Stage 9 Lint | Stage 8 Negative Fixture | Owner | Blocking | ``` Minimum invariants to row: no_non_ec_durable_writer; no_learning_without_final_prompt_truth; no_render_without_{context_packet_proof|render_safety_proof|memory_flow_certificate}; no_removed_membership_injection; no_projection_as_truth; no_source_revocation_without_cascade; the four UR-47 monotonicity laws; no_schema_break_without_migration_plan; no_unregistered_reason_code; no_unknown_domain_profile_without_conservative_fallback. --- ## 5. Cross-cutting themes - **THEME-A — proofs must bind content, not presence.** Replace boolean "checked" fields with inspectable, content-bound proof (edge-level results + included/excluded-set hashes). Instances: UR-05 (membership), UR-06 (render-safety outcome), UR-07 (retention). General principle beyond any single finding. - **THEME-B — one reproducibility key, not scattered version refs.** Unify `policy_generation_id`, registry version, plan version, shell-variant + shell-weight generation, source/membership generation, budget profile into a single referenced bundle (UR-19); both the determinism invariant and §11.3 replay reference it. - **THEME-C — separate the serialized durable-write path from delivery attestations.** Durable mutations serialize through EC (ordering/CAS/replay); render/export/carryover/delegation certificates are EC-*anchored* against a read-consistent policy generation and must not block on the write queue (UR-03/04/17). The one architectural decision the external review missed and its discriminated-union MFC silently worsened. --- ## 6. Forward-looking / cutting-edge (2027-2028 differentiation) `BETTER_IDEA` — net-new capability proposals; not blocking, but they exploit the proof spine you are already building and would differentiate ELNOR's memory plane from anything shipping in 2027-2028. All are litigation-relevant. - **`UR-42` Tamper-evident hash-chained proof log.** Make the proof spine append-only and hash-chained — each `MemoryFlowCertificate` / `MemoryMutationEnvelope` references the prior entry's hash. Yields cryptographic **chain-of-custody** over memory provenance: prove to a court or co-counsel that a memory state was not retroactively altered. Pairs with UR-07 retention classes. - **`UR-43` "As-of" time-travel queries as a named capability.** With bitemporal axes (UR-18) + MME replay, expose "reconstruct the memory state as of {instant}" as a first-class query. For litigation: "what did the system know, and on what authority, on the date of the filing?" - **`UR-44` Click-to-provenance verifiable-memory Inspector.** Every rendered claim traces, in one click, to its source spans + warrant + policy generation + the `FinalPromptTruthRef` that proves it actually reached the model. Turns the Inspector from explanation into **verification**. - **`UR-45` Scoped/redacted co-counsel export.** Export a memory subset with policy-enforced per-axis redaction (UR-11 vector) + an export manifest + an `ExportMFC`. Hand a co-counsel exactly the slice they are cleared for, with proof of what was withheld and why. --- ## 7. Responses to the red-team prompt ### 7.1 The 10 lenses (§4.A–§4.J) - **§4.A Completeness vs build-plan substance** — Strong. 12 synthesis must-fixes landed (verified). Narrow misses: UR-08 (5-plane cascade), UR-31 (projection split), UR-35 (golden scenario), the named-lint inventory (UR-46), the monotonicity laws (UR-47), F-struct #3/#4 (UR-38). - **§4.B Architectural soundness** — Sound, with one decision missing: THEME-C (UR-04). Otherwise owner boundaries, import graph, and proof-spine topology are coherent. - **§4.C Phantom features** — One material phantom: the §3.1 `ContextProductKind` enum (UR-01, ~88% invented). Otherwise NAMED-only discipline (§5 of the draft) is clean. - **§4.D Coding-agent test** — Fails in spots: optional-ref MFC (UR-03), boolean membership proof (UR-05), scalar DomainProfile (UR-11), boolean background-yield (UR-25). The discriminated-union/vector/edge-level fixes close these. - **§4.E Schema quality** — B-grade overall; no D's. Needs branded IDs (UR-27), discriminated unions (UR-03), derived eligibility (UR-13), inter-field invariants (UR-06). Field-naming consistency is a PASS. - **§4.F Missing contracts** — `SemanticProjectionContract` (UR-31), `FinalPromptTruthRef` hook (UR-02), `SourceRevocationCascade` (UR-08), schema-version convention (UR-26), proof retention classes (UR-07). - **§4.G Cross-charter wiring** — Needs the gate table (UR-32) and the AC-004/005 gating (UR-33). Does `ContextProduct`+`MemoryContextPlan`+MFC compose into a DOC84 pipeline? Not until UR-01/02/03/15 land. - **§4.H Better patterns** — THEME-A/B/C; forward ideas UR-42–45; "rename `ContextProduct`→`ContextArtifact`" (prompt §4.H) — **reject**, ABC §9.2 is senior and uses `ContextProduct`. - **§4.I Failure modes** — Strongest gaps: revocation polarity (UR-09), the four monotonicity laws (UR-47), authority-fixed degradation (UR-22), quota exhaustion (UR-24), withheld-MFC reason-code (UR-03). Lifecycle non-equivalence preserved as lints (UR-29). - **§4.J Lints/fixtures** — §16.3 roll-up is incomplete; the full named-lint inventory (UR-46) and §18 golden scenario (UR-35) are absent. Names belong in E0; implementation to Stages 8/9. ### 7.2 Specific questions §5.1–§5.20 (direct answers) 1. **`IngestionCostBudget` / `WarrantConsequenceRegistry` placement** — DOC25-primary / DOC82-primary; E0 owns only the quota envelope and (conditionally) a cross-plane registry hook (UR-34). 2. **Are the 14 §3.1 kinds correct?** — **No.** Verified against ABC §9.2 (17, senior); §3.1 is ~88% invented. Adopt 17, patch SM-060 (UR-01). 3. **MFC invocation points** — All six present, but the schema is too weak; discriminated union + missing render/learning lints (UR-03), paired with the attestation-path decision (UR-04). 4. **ReasonCode namespace scheme — survives 50 producers?** — Not as written; needs allocation/lifecycle/collision/case rules + the DOC8 producer fix (UR-10). 5. **DomainProfile `conservative` fallback** — Right in spirit, but a scalar rank can't represent it; per-axis conservative meet, axis values at DOC81 (UR-11). 6. **PromptShellVariant stable-vs-volatile (ADQ-305)** — Carried correctly; harden by deriving `kv_cache_eligible` (UR-13). 7. **Proof-spine composition** — Composes for *assembly* but not *final-prompt truth*; add `FinalPromptTruthRef` + gate learning on it (UR-02); edge-level membership proof (UR-05). 8. **`MemoryMutationEnvelope` scoping (NAMED-only)** — Tight enough for Stage 7; keep NAMED-only (Class D). Ensure it carries the reproducibility/order axes (UR-18/19). 9. **`MemoryProvenanceGraph` scoping** — NAMED-only fine; the distinction from `MemoryCoordinationTrace` is crisp *once* the trace gains turn/session correlation (UR-20). 10. **Bitemporal carrier (§8.2)** — Both carriers needed; MME for mutation/replay, DOC82 objects for valid/transaction; linkable not collapsed (UR-18). 11. **ECSeamContract coverage (12 items)** — Mostly covered; make read-model-refresh + no-non-EC-writer explicit (UR-17); add the attestation-path split (UR-04). 12. **MemoryOperationQuota completeness** — Not exhaustive; units/windows/enforcement/exhaustion/resume + runtime strategy for background work (UR-24/25). 13. **Replay-completeness testability (§11.3)** — Testable only once proofs are classified (canonical vs derived); add retention classes (UR-07). 14. **Invariant enforcement-point naming (§12)** — Each invariant should map runtime-gate + Stage 9 lint + Stage 8 negative fixture (UR-48). Load-bearing gaps: UR-02/04/08/09/22/47. 15. **ABC §21 dispositions (§13: 4→DOC82, 2→DOC84, 1→DOC25)** — Premise validated (7 objects genuinely absent from Owner Map). Dispositions reasonable; confirm during E3/E4. 16. **AC-004 `schema_plus_lints_and_fixtures`** — Right bar; do not weaken; require positive + negative fixtures + Stage 9 lint (UR-33). 17. **AC-005 ADQ-202 dependency** — Correctly gated but under-specified; also gate on ECSeam + DOC25 + DOC82 (UR-33). 18. **§13.2 deferral of 7 Owner Map rows to E3/E4** — Honest deferral; ensure the gate table (UR-32) records them. 19. **17 fold-ins vs the brief's "14" headline** — The 14→17 reconciliation Claude Code did is sound. **Distinct** from the `ContextProductKind` 14-vs-17 source conflict (UR-01) — do not conflate the two "14 vs 17"s. 20. **Field-naming consistency (15 schemas)** — Consistent snake_case JSON / PascalCase interfaces. **PASS.** Formalize as a convention (UR-27). ### 7.3 Brutal questions §6.1–§6.10 1. **Production-grade or good first attempt?** — Strong, near-final foundation — not yet production-grade. The `ContextProductKind` reconstruction and the final-prompt-truth gap are exactly the kind of foundational errors that cascade. Production-grade after this patch set. 2. **Single biggest weakness?** — The `ContextProductKind` source conflict (UR-01): a load-bearing registry reconstructed from memory, ~88% wrong against the senior source, blocking E7/E8. 3. **Single biggest improvement opportunity?** — Final-prompt truth as a named invariant (UR-02): closes a subtle catastrophic learning bug and unlocks the verifiable-memory Inspector (UR-44). 4. **Enough time, or rushing?** — Evidence of *under-verification against the senior source* (ABC §9.2 not consulted for the enum; §1.3 cited where §9.2 holds the list), not careless rushing. The faithful ADQ/Owner-Map/Import-Graph work shows care. 5. **Did Claude Code miss build-plan work?** — Mostly no (12 must-fixes landed). Specific misses: the named-lint inventory (UR-46), the 5-plane cascade (UR-08), the monotonicity laws (UR-47), the SemanticProjection split (UR-31), the golden scenario (UR-35), the 17-kind enum (UR-01), F-struct #3/#4 (UR-38). 6. **What would you have done differently?** — Consulted ABC §9.2 before writing the enum; reconciled the commission outline against Skeletal §2 (catching F-struct #3/#4); made the determinism rule range over content/selection from the start (UR-19); and pulled the full named-lint set from the synthesis (UR-46). 7. **Skeptical Stage 7 schema author would say is missing** — schema-version convention (UR-26), reproducibility key (UR-19), discriminated-union MFC (UR-03), branded IDs (UR-27), crisp owner boundaries for the NAMED-only objects. 8. **Skeptical Stage 8 fixture author would say is missing** — the §18 golden scenario + negative fixtures (UR-35), the fixture *taxonomy* names, per-invariant negative-fixture names (UR-33/UR-48). 9. **Skeptical Stage 9 lint author would say is missing** *(inferred — see §12 fidelity note)* — the full named-lint inventory by canonical token (UR-46), the revocation polarity lints (UR-09), the monotonicity-law lints (UR-47), and a per-lint owner/severity convention (named, not built, in E0 — UR-28). 10. **Final recommendation** *(inferred)* — `E0_NEEDS_REVISION_BEFORE_RED_TEAM_CLOSES`. Revise in one concentrated, scope-disciplined round driven by the preservation matrix; do not patch only the obvious schemas. Not ratifiable until UR-01/02/03/04/08/46 land; not safe for E7/E8 to bind `ContextProduct` until UR-01 closes. --- ## 8. Cross-LLM adjudication (Claude × GPT-5.5-Pro) **Convergence (high):** Both reviewers independently flagged ContextProductKind instability, SemanticProjection under-spec, source-revocation cascade, MFC weakness, membership boolean, golden scenario, DomainProfile, quota units, ECSeam read-model, bitemporal split, AC-004/005, schema versioning, and the preservation matrix. Decorrelation worked — the overlap is strong evidence these are real. **Where GPT was right and Claude updated:** the **17-kind ABC source** (GPT's single best catch — verified, not confabulated); **final-prompt truth** as a first-class invariant; the **DomainProfile vector** argument; **proof retention classes**; **per-product MemoryContextPlan**; **ExternalDependencyRecord** audit pins; the three verified **drift instances**. **Where Claude held against GPT:** the **severity** ("major hardening / not ratifiable / B-/C+" is overstated — moderate surgical, given the verified must-fix preservation); the **over-scoping** (GPT pulled Stage 7 bodies + Stage 8 fixtures + Stage 9 lint mechanics + member work + a collapsed lifecycle decision into E0); the **lifecycle state machine** (re-litigates synthesis §6 — UR-29); and the "**preservation payload systematically dropped**" root cause (refuted by the 12-must-fix verification). **Findings Claude caught that GPT missed (kept additive):** THEME-C (UR-04), the determinism-vs-learning contradiction (UR-19), the contrary-edge monotonicity hole (UR-09), trace turn-correlation (UR-20), authority-fixed degradation (UR-22), the §10.7 mislabel (UR-39), the injection "necessary-not-sufficient" clause (UR-40), embedding un-merge (UR-41), the citation collision (UR-21), and the full named-lint inventory (UR-46). **Provenance caveat on GPT's lint names (audit finding).** GPT's F31 "Stage 5R2b lint families" were **partly coinage, not verbatim source.** Verified against the synthesis + skeletal: the `adapter.*`, `cu_doc73.*`, and `monotonicity.<...>_monotone` tokens are **not** in the source; the *underlying* invariants are real (adapter convergence 5×, CU divergence 2×, monotonicity §11.9). Preserve the invariants (UR-47); treat those exact tokens as proposed. Conversely, the source's own canonical tokens (`learning.utility_without_final_prompt_proof`, `erasure.retired_used_as_erased`, the `projection.*`/`revocation.*` families) should be used verbatim — v1 of this review coined non-canonical variants for two of them (corrected in UR-02/UR-29). **Meta-observation (with receipt).** The Stage 5R synthesis (§4) documented that GPT, given latitude, over-builds ("~15 new schemas, ~50 lints, ~20 fixtures from leading questions; disciplined when reacting to a review"). This pass repeated the pattern — high-recall gap detection wrapped in ~15+ new schemas and ~80+ lints, including re-expanding the collapsed lifecycle area. **Operational guidance:** the *findings* are the trustworthy half; aim the subtractive stroke at the *additive schema layer*. The A–H disposition classes do this mechanically — extract each gap, then ask "does E0 own the object, and is its design settled?" If yes → full body (UR-03, UR-10, UR-31 umbrella). If plane-owned, runtime-owned, or a later-stage mechanic → name + invariant + lint, body downstream (UR-02, UR-25, UR-28, UR-46). This is the subtractive pass that tends to be under-run when material is plausible-but-low-yield rather than wrong. (Self-applied: v1 of this review under-preserved the named-lint inventory — the same preservation failure it flagged in the draft — corrected here as UR-46.) --- ## 9. Patch priority order ```text 1. ContextProductKind P0 — adopt ABC §9.2's 17; patch SM-060; align entry to §9.3 (UR-01) C 2. FinalPromptTruthRef — name only (DOC11 body) + no-learning-without-FPT invariant (UR-02) B 3. CascadingSourceInvalidation — 5-plane invariant + 7 lints (§12) (UR-08) B/C 4. Named-lint preservation + §16.3 roll-up completeness (full synthesis inventory) (UR-46) F/G + four monotonicity laws (UR-47) + revocation polarity lints (UR-09) 5. SemanticProjectionContract — E0 umbrella + axis-owner table; bodies downstream (UR-31) C 6. MemoryFlowCertificate discriminated union + EC issuance-path decision (THEME-C) (UR-03/04) A 7. DomainProfile per-axis conservative meet (E0 rule; DOC81 axis values) (UR-11) C 8. Proof retention classes (E0-owned rule) (UR-07) A 9. MemoryContextPlan request/disposition grammar (DOC84 records outcomes) (UR-15) C 10. ExternalDependencyRecord — sha256 + commit SHA + line pins (optional verify ts) (UR-12) A 11. schema_version convention (Stage 7 owns migration schema) (UR-26) B/D 12. ECSeam explicit items — read-model-refresh + no-non-EC-writer (UR-17) A 13. §18 golden scenario — populate w/ revocation + policy-change + negative fixtures (UR-35) A/E 14. F-struct #3/#4 + shared-runtime-vocab (DOC80 §4) — architect decision row (UR-38) G 15. Source-pack drift sweep (CognitiveDiff row, ADQ-313 index, DOC8 ReasonCode + importing_member, prompt path) (UR-37) G 16. Add residuals: UR-05, UR-06, UR-13, UR-16, UR-18, UR-19, UR-20, UR-21, UR-22, UR-23, UR-24, UR-25, UR-27, UR-29 (lints only), UR-30, UR-32, UR-33, UR-34, UR-39, UR-40, UR-41, UR-48 mixed Then: preservation matrix (UR-36) as the assurance driver + a fresh confirmation pass. ``` --- ## 10. Disposition lists **Keep as full / near-full E0 bodies (Class A — E0 owns it and the design is settled):** ```text MemoryFlowCertificate discriminated union (+ ec_path) ReasonCode namespace/registry mechanics ContextProduct registry entry (NOT assembly body) SemanticProjectionContract umbrella + axis-owner table Proof retention classes ExternalDependencyRecord minimum pinning fields MemoryCoordinationTrace correlation fields Warrant-degradation-trigger registry entry mechanics ContextPacketProof edge-level membership proof ECSeamContract explicit item set ``` **Preserve as names/invariants only (Class B/F — E0 names them; bodies/impl downstream):** ```text FinalPromptTruthRef invariant + lints (UR-02) Full synthesis named-lint inventory (UR-46) Four monotonicity laws (UR-47) Three-column invariant table (UR-48) SourceRevocationCascade invariant + 7 lints (UR-08) Revocation polarity lints (UR-09) ``` **Cut / downgrade out of E0 (body lives elsewhere):** ```text FinalPromptTruthRef body -> DOC11 / Stage 7 FixtureManifest meta-schema -> Stage 8 LintRegistry meta-schema -> Stage 9 MemorySchemaMigrationPlan body -> Stage 7 Full lifecycle/erasure state machine-> REJECTED (do-not-reopen) DomainProfile policy-axis values -> DOC81 RenderSafetyProof executed body -> DOC84 MemoryMutationEnvelope full body -> Stage 7 (NAMED-only) MemoryProvenanceGraph full body -> Stage 7 (NAMED-only) background_execution semantics -> DOC11/OpenClaw JSON-Schema bodies per contract -> Stage 7 authority_class field values -> DOC82/DOC81 import_graph.* / owner_map.* / opa.* lints -> flatten governance suite (not E0 charter; acknowledge in matrix) ``` --- ## 11. Revised acceptance checklist for E0 closure E0 closes red-team when: 1. `ContextProductKind` = ABC §9.2's 17; SM-060 patched; §3.1 enum replaced; entry shape = ABC §9.3 (UR-01). 2. `FinalPromptTruthRef` named with the no-learning-without-final-prompt-truth invariant + `learning.utility_without_final_prompt_proof` lint (UR-02). 3. `SourceRevocationCascade` five-plane invariant + seven lints present (UR-08); monotonicity lints are polarity-aware (UR-09). 4. The full synthesis named-lint inventory is preserved in the §16.3 roll-up / matrix, split by owner (UR-46); the four monotonicity laws are in §12.1 (UR-47). 5. `MemoryFlowCertificate` is a discriminated union with the `ec_path` attestation-vs-serialized decision (UR-03/04). 6. `SemanticProjectionContract` umbrella + axis-owner table present; bodies deferred (UR-31). 7. `DomainProfile` uses a per-axis conservative meet; axis values deferred to DOC81 (UR-11). 8. Proof retention classes present; proofs that gate durable effects are canonical (UR-07). 9. `MemoryContextPlan` request/disposition grammar present; outcomes recorded by DOC84 (UR-15). 10. `ExternalDependencyRecord` carries sha256 + commit SHA + line pins (UR-12). 11. `schema_version` convention stated (UR-26). 12. `ECSeamContract` lists read-model-refresh + no-non-EC-writer (UR-17). 13. §18 golden scenario populated with revocation + policy-change + negative fixtures (UR-35). 14. F-struct #3/#4 + shared-runtime-vocab folded in or explicitly deferred with owner (UR-38). 15. Drift sweep applied incl. DOC8 importing_member + ADQ-313 index (UR-37); §12.1 upgraded to the three-column table (UR-48). 16. Lifecycle non-equivalence lints present (canonical `erasure.*` tokens); **no** lifecycle state machine introduced (UR-29). 17. Citation collisions disambiguated (Skeletal-doc §N vs DOC80-target §N) (UR-21); §17.2 §10.7 mislabel fixed (UR-39). 18. Preservation matrix proves no Stage 5R/5R2/5R2b mechanism, lint, or downstream gate was silently lost (UR-36). 19. Every E0-owned contract has TS + lint *names* + fixture *names*; every downstream-owned contract has an explicit owner and a gate-table row (UR-32); no Stage 7/8/9 author must invent core conventions. **Net verdict (unchanged in kind, heavier in degree):** moderate surgical hardening, one P0 E7/E8-blocking source conflict; not a rebuild; not ratifiable until patched; not safe for E7/E8 to bind `ContextProduct` yet. --- ## 12. Fidelity notes - **Brutal questions §6.9–§6.10** were *inferred*: the prompt's machine extract surfaced 8 brutal questions clearly. §7.3 Q9 (skeptical Stage 9 author) and Q10 (final recommendation) are reasonable reconstructions; confirm against the prompt's exact brutal set if precise fidelity is required. - **RenderSafetyProof "discriminated union"** (a Claude round-1 schema note) was *intentionally superseded* by the contract/body split + outcome-derivation invariant (UR-06/UR-07), since RenderSafetyProof has no natural variants. Disposition, not an omission. - **Coined lint tokens.** Where a finding's lint name is not a verified source token, it is flagged "proposed — confirm at Stage 9." Canonical source tokens (UR-02, UR-08, UR-18, UR-29, UR-31, UR-46) should be used verbatim. --- ## Appendix — audit fold-in changelog (v1 → v2) | Change | Type | Where | |---|---|---| | Named-lint preservation inventory (substance + flatten-governance + provenance) | **new finding** | UR-46, §2.5 | | Four-way monotonicity invariant family (skeletal §11.9) | **new finding** | UR-47 | | Three-column invariant enforcement table (GPT F29) | **new finding** | UR-48 | | Citation collision (bare "Skeletal §N" vs §11.13 cap) | **new finding; closes UR-21 numbering gap** | UR-21 | | `learning.utility_credit_without_final_prompt_truth` → `learning.utility_without_final_prompt_proof` | name correction | UR-02 | | `retired_is_not_erased` etc. → `erasure.retired_used_as_erased`, `erasure.legal_hold_bypassed_without_adq_resolution` | name correction | UR-29 | | +7th revocation lint `revocation.learning_signal_survives_revoked_source` | completeness | UR-08 | | +canonical `bitemporal.evidence_edge_missing_source_span_temporal_snapshot` | completeness | UR-18 | | +`learning.writeback_without_ec_execution` | completeness | UR-17 | | N12 three specifics (ContextProduct "varies", ref-type inconsistency, DOC8 importing_member) | sharpening | UR-30, UR-37 | | Provenance caveat on GPT-coined lint tokens (adapter/cu_doc73/monotonicity) | accuracy | §8, UR-46c | | Fidelity notes (brutal Q9–10 inferred; RenderSafetyProof disposition) | transparency | §12 | | Patch order #4 reframed to lint preservation; acceptance items 4/15/16/17 added | integration | §9, §11 | *End of unified review v2.* ````