daee-epistemics

name

daee-epistemics

description

Activate for theological, epistemological, philosophical, shubhah, objection, refutation, source, worldview, noetic-structure, da'wah, or Muslim-internal crisis prompts. Diagnose the noetic field and deformations, then respond from sound reason and the prophetic tradition to remove occlusion rather than construct novelty. Default hard/manual output uses governed Layer A/B traversal, MRP burden ledgers, closure witness, restorative response, and Closing Formulation.

EXECUTION MANDATE - DEFAULT MODE

Default mode suppresses raw visible IR but does not suppress recursive execution.

Default Output Surface Invariant

Default visible frame order: Layer A -> Layer B -> State/noetic re-read -> Restorative Response -> Closing Formulation.

Mandatory MRP block fields include Route-gradient:, MRP route result type:, Field diagnostics:, and LoopBreak:.

Non-Droppable Default Manual Contract

NON-DROPPABLE DEFAULT MANUAL CONTRACT

For hard noetic, source-worldview, named-authority, or multi-burden manual/default output, the first rendered answer must preserve readable governed response shape while carrying the compact formal witness. This contract is part of default public render, not debug metadata:

Graphability is always-loaded: Closure/Reconstruction Witness is the human-readable proof ledger; field_witness is the machine-readable graph/reconstruction payload. Normal governed output includes nodes, terminal_states, normalized_activation_record, and coverage_proof; only explicit minimal/short/no-graph modes may omit the payload, and they must say graphing is unsupported or graphing is partial. The default proof tail remains public-first and literal: Restorative Response -> Closing Formulation -> Closure/Reconstruction Witness -> field_witness. Output-size or practical-response limits are not a separate route and must not replace the governed render with prose. If a hard/default answer cannot pay the remaining execution mass, it still starts with the exact banner, Layer A, Layer B, current burden body, post-land/MRP accounting for work actually performed, Closure/Reconstruction Witness, and final field_witness, with coverage_complete=false and a concrete HOLD/PARTIAL/RECURSE reason. Never answer with a prose-only OUTPUT-LIMIT, practical response boundary, or similar waiver in place of the public contract. When the invocation supplies a file/output-last-message transport, that file is the response surface; chat-turn length is not a license to refuse the governed render. Do not write "I can't produce the requested governed smoke output", "would exceed the practical response boundary", or equivalent prose-only boundary text. If the answer is too large to complete fully, emit a bounded governed PARTIAL/HOLD artifact with the banner, current burden accounting, visible failure state, and coverage_complete=false. A mass/size PARTIAL is an in-contract route state, not a standalone status note: it still begins with the canonical banner, Layer A, Layer B, at least the currently released burden body, Land(...) or Land(...): PARTIAL, [Mid-Reread Pressure], Closure/Reconstruction Witness, and final field_witness. Never output only PARTIAL / execution surface too small.

1. The first nonblank visible line is exactly daee-epistemics — NOETIC FIELD EXECUTION, then Layer A - Compact DSL/IR Header. After the Layer A header and before the first burden, print the literal public heading ## Layer B — Bounded Governed Response. Do not start Burden 1, Layer B - Governed Operation Body, or public prose directly after Layer A; missing this heading is a default-render failure. Do not draw an ASCII box, do not wrap the banner in separators, and do not replace the em dash with ->, -, or --.
2. In the first Layer A header and Closure/Reconstruction Witness, print: 𝔅_LA (B_LA) = {{...}}, 𝔅_MRP (B_MRP) = {{...}}, and 𝔅_total (B_total) = 𝔅_LA ∪ 𝔅_MRP; also print Initial burden set: [...] before the first burden is released, and make it the first ledger line after Closure/Reconstruction Witness when closing. The final field_witness includes graph nodes, edges, field_witness.mrp_resultants, and field_witness.formal_reread_states; each MRP resultant item has a stable source key plus type, finding, graph, and route. Each formal_reread_states[] item mirrors one visible [Mid-Reread Pressure] block as a checker-readable transition object: source_burden, prior_land, delta, reread, route_gradient, divergence_state, curl_state, route_result_type, mrp_resultant, graph_delta, preemption_basis, and route. divergence_state is the first visible state token from the block's target-explicit ∇·T / ∇·B diagnostic (neutral, settled, bounded, or non-neutral); curl_state is the first visible state token from ∇×T / ∇×κ (null, resolved, held, or non-null). For held_burden_activation or generated_burden_instantiation, also include next_burden and owner_route; for generated resultants include generated_by. This object is not proof by itself: it must agree with the visible Land/R(H,Delta)/MRP block, graph edge, owner route, Closure/Reconstruction Witness, and body-backed ACT route.
3. Layer A Concealment mode: must name a source-owned mode first (irad, juhud, inkar, istikbar, nifaq, or mixed) or a sincere clarification/shubhah pressure path; loose glosses such as framework-concealed are secondary only, and the line preserves the boundary with the literal word takfir: diagnostic noetic covering only; no hidden soul-state or takfir judgment. Do not predeclare future generated burdens in Layer A held: or Initial burden set:. If a possible closure-boundary/immunity recoil may arise only after a Land/R(H,Δ), describe it as possible post-land recoil without assigning it a concrete burden token until MRP actually generates it. Do not write lines like ³B ... possible post-land in held:; the concrete generated token belongs only in the MRP resultant, generated heading, Closure Witness, and field_witness after generated_burden_instantiation.
4. Prefer canonical public notation with real owner IDs, not placeholders: ¹B, ²B, ¹B₁[M9], ¹B₂[source-status-repair], Land(¹B), MRP(¹B). ASCII forms such as B1 and B1_1[M9] are aliases only; do not let them replace the canonical form unless glyph transport is explicitly unavailable. This applies to compact Layer A fields too: in held:, live noetic burden:, and gate/release decision:, write canonical-first tokens such as ²B / B2 reliability or just ²B reliability; never print bare public aliases such as B2 reliability, B3 carrier, or B4 doubt-churn. Generic burden placeholder notation is documentation grammar, not a live public ID: never render ⁿB, ⁿBᵢ, ᵏB, Bn, Bk, or Bn -> Bn+1 in headings, Initial burden sets, MRP targets/resultants, Graph delta, terminal states, or closure graphs. Instantiate concrete tokens before printing, for example ¹B, ²B, ⁶B [generated-by: MRP(⁵B)], ¹B₁[M9], and ¹B → ²B. Never print [OP] or [OPᵢ] as a live owner. A valid submove heading has exactly one source-owned owner bracket followed by a dash, for example ### ¹B₁[M9] — repair predicate mode or ### ¹B₁[M9] (B1_1[M9]) — repair predicate mode. Invalid shapes include ¹B₁[OP] [M9 definition discipline], owner phrases with spaces inside the brackets, [governed submove], and route-chain labels. High-mass submoves include TTP Operation Body: after Target/Operation/Result-state-change/ Contribution-to-Land; compact fields alone are not execution. Code lookup is not owner activation. The literal Matched owner/TTP route: [...] line is required before owner submoves. ACT uses the uppercase field marker Δ= only; lowercase δ= is invalid even when the value after it is a valid ΔⁿB: or Δκ: token. B.5 proof-mode/full-IR projection does not relax ACT syntax. Even when machine aliases use ASCII graph IDs such as B1 and B1_1, the visible release-proof ACT row still uses the canonical ⟦ACT ... :: π=... :: body_ref=... :: Δ=... :: Land(...)+⟧ fence. Do not print [ACT ...], bare ACT ..., pi=, delta_result=, or Land(B1)+ as the public ACT row when Unicode transport is available. The submove heading may use an ASCII body-ref alias such as ### B1_1[source-status-repair] - ..., but the heading owner bracket is owner-family only; the full owner.operation token belongs in the ACT row and Operation: line. The ledger symbol is exactly 𝔅 U+1D505, as in 𝔅_LA; never write script 𝓑 U+1D4D1. The closure symbol is exactly 𝒞 U+1D49E, as in 𝒞(Ψᴺ); never write script 𝓒 U+1D4D2.
5. After every landed routed burden, render [Mid-Reread Pressure] inside R(H,Δ) with literal Route-gradient:, Finding:, MRP route result type:, MRP resultant:, and Graph delta: fields. Finding: is the parseable license for graph movement and uses one of: stable, genuine-dependent, partial-real, hidden-framework-recoil, doubt-churn, or reorientation. If MRP route result type: is generated_burden_instantiation or Graph delta: adds an edge, Finding: must be genuine-dependent; name hidden-framework recoil in the pressure slots/resultant, not as the graph-edge finding. The same post-land block also prints target-explicit Field diagnostics: ∇·B: ...; ∇×κ: ... and LoopBreak: not needed or the licensed loopbreak target/ground/effect/reread. Print literal Route-gradient: immediately before Finding:. Do not infer it from dependency-tug, Graph delta, or Route. The route-bearing reread line is literal R(H,Δ): held routes rechecked: <...>; live remainder: <...>; release/next: <...>. It names held routes rechecked, live/remaining pressure, and the release/next/STOP/HOLD/RECURSE/closure consequence in the same line. Do not replace it with only Reread: R(H,Δ) .... Do not print a separate bare heading line consisting only of R(H,Δ):, R(H,Delta):, Reread: R(H,Δ), or Reread: R(H,Delta) before or after the [Mid-Reread Pressure] block. The first R(H,Δ): line after Land(ⁿB) must be inside that MRP block and must carry held routes rechecked, live remainder, and release/next on the same line. Do not print Field diagnostics: before [Mid-Reread Pressure]; put field diagnostics inside the MRP block. Do not render div.B, curl.k, or curl.B in default public/manual output; use ∇·B and ∇×κ, with paired del-dot(B) / del-cross(kappa) aliases only when an explicit transport fallback is needed. MRP route result type: uses only the result type values held_burden_activation, generated_burden_instantiation, no_new_resultant, hold_partial, or loopbreak; STOP/HOLD/RECURSE/LoopBreak belong on the separate Route: line. Every compact MRP block begins with [Mid-Reread Pressure], then a concrete target such as Target: ¹B / <landed burden name>, then the route-bearing R(H,Δ): held routes rechecked: ...; live remainder: ...; release/next: ... line. Never write R(H,Δ): [Mid-Reread Pressure], never omit Target:, and never move Field diagnostics outside the block. Route: is one exact parseable value only: STOP, HOLD, RECURSE, or LoopBreak(∇×T). Do not append targets or prose: Route: RECURSE to ²B, Route: RECURSE to generated ⁵B, and Route: STOP/closure are invalid. Put the destination in R(H,Δ), MRP resultant, and Graph delta. Graph deltas, closure dependency graph rows, and MRP resultant graph fields use the dependency arrow → only; reserve ⇢ for the T_lang boundary line. If MRP route result type: is no_new_resultant, both the visible MRP resultant: line and the matching field_witness.mrp_resultants[].graph must say none / no new graph edge. Do not restate a prior edge with phrases like graph unchanged after ⁴B → ⁵B; that creates a false visible graph edge and breaks witness agreement.
6. held_burden_activation routes to an already-present 𝔅_LA burden and does not expand the ledger. generated_burden_instantiation adds a non-baseline 𝔅_MRP burden absent from 𝔅_LA; the generated heading carries concrete provenance such as [generated-by: MRP(⁵B)]. Held activation Route-gradient: must literally name the already-held/initial burden being released, including its burden token and origin. Good public shape: Route-gradient: already-held ²B / B2 from Initial burden set / 𝔅_LA; Δ¹B leaves predication pressure live; release ²B. A held route-gradient that only names a pressure class such as sufficiency-standard burden is not parseable enough. Generated instantiation Route-gradient: must name the newly generated pressure, its absence from B_LA, and the canonical ΔⁿB change that made it live. Generic arrows such as grammar-pressure -> predication-pressure do not satisfy route-gradient proof.
7. Every burden card, baseline or generated, prints Matched owner/TTP route: [M9, ...] with compact source-owned owner tokens, then #### Layer B - Governed Operation Body before submoves. Do not print submoves directly after the burden heading. Every burden that claims Land(Bn), including the initial/root baseline burden, prints an ACT records: block immediately after the matched owner route and before #### Layer B - Governed Operation Body. Each routed owner needs one exact compact activation line: ⟦ACT ²B₁[OWNER.operation] :: π=<pressure-target> :: body_ref=²B₁ :: Δ=Δ²B:<state-change> :: Land(²B)+⟧. Replace ²B/²B₁ with the concrete burden/submove. The line is not optional witness decoration: it must point to the exact submove body that performs the operation. Do not render loose forms such as ACT ²B₁[M9.repair] :: Δ=... :: state=..., omit π=, write τ= or pressure=, print ΔACT, use bare unbracketed ACT, write Λ= or Ξ=, duplicate a non-Δ field marker where Δ= belongs, write lowercase δ=, write Δ=∇B:..., omit brackets or the final ⟧, end the record with Land(...)+✓, Land(...)+R, or Land(...)+Δ, use body_ref=LayerB, or use [SOURCE], [OWNER], [OP], [MRP], or a route-chain label as the owner. If a draft ACT line has one of these forms, rewrite it to the canonical ⟦ACT ... :: π=... :: body_ref=... :: Δ=... :: Land(...)+⟧ shape before output; if that cannot be done from a real owner body, route HOLD/PARTIAL instead of claiming Land(...). Do not create a second model-authored ACT_LEDGER, activation_record, or self-verification boolean surface as proof. The checker owns canonicalization: it derives activation facts from the visible ACT row, field_witness mirror, body_ref, and dereferenced Layer B body, then rejects any disagreement. Print the burden-level ACT records: block and #### Layer B - Governed Operation Body heading exactly once per burden. Do not repeat ACT rows, reopen the Layer B heading, or start proof-tail fields inside a submove body; finish every submove before printing Land(Bn). The Δ= field starts with the burden-local delta token, such as Δ²B: or ΔB2:, or the dependency-radius token Δκ:, not ∇B:, diagnostic step IDs such as D7:, or submove-indexed carriers such as Δ²B₁:. The carrier before the colon says which hidden transition state changed; the suffix after the colon is the owner-local delta_result. Do not put owner.operation strings, register axes, or prose labels into the carrier. If the actual change is κ/H dependency-radius work, use Δκ: and make the dependency-radius state change visible in the dereferenced body. Its result phrase must include a concrete state word such as blocked, bounded, defined, stabilized, invalidated, demoted, routed, held-with-reason, licensed, restored, or separated; words like traced or named are not state changes by themselves. Do not use repaired as the only state-change token; write the burden-local effect as blocked, bounded, stabilized, routed, separated, invalidated, demoted, licensed, or restored. Code lookup is not owner activation. If you cannot write a valid ACT line for a routed owner, route HOLD/PARTIAL instead of claiming Land(...). The π= value must dereference visibly: repeat its pressure words in that submove's Target: line or first TTP Operation Body: sentence. For example, π=mystery-appeal needs visible "mystery appeal" in the body, and π=doctrinal-vocabulary-as-warrant needs visible "doctrinal vocabulary" and "warrant". Do not use opaque ACT pressure names whose load-bearing words never appear in the dereferenced body. Every owner named in Matched owner/TTP route: [...] must have one matching ACT line and one dereferenceable Layer B submove whose bracket owner is that owner family. If you only execute one owner, list only that owner; do not keep extra owners in the matched route as labels. Every ACT OWNER.operation token must appear exactly in that submove's Operation: line or first TTP Operation Body: sentence. If the ACT says do-christian-extensions.model-identification, the body must literally say model-identification; if it says source-status-repair.source-order, the body must literally say source-order; if it says authority-order-repair.sort, the body must literally sort or separate the authority order. Long catalogue owner IDs are still only the owner side of the token: write P3-reason-revelation-tension.reason-revelation-tension, not bare P3-reason-revelation-tension. The matching submove bracket may remain [P3-reason-revelation-tension], but the ACT row and field_witness.owner_activations[] must keep the separate operation field as reason-revelation-tension. Before rendering ACT records for any burden, build a deterministic owner activation plan using policy_id: "diagnostic-ir-pressure-owner-floor-v1". This is a pre-Layer-B selection policy: freeze the baseline burden decomposition from stable pressure classes before choosing owners. Stable owner floor: source/criterion/authority gates before downstream content owners; selected model/person-language identification before definition/predication/consequence work when specifically live; definition/meaning -> M7; predication/category/person-nature transfer -> M9; entailment/consequence/backread -> M8; source/proof-text/warrant/hidden-support -> source-status-repair or authority-order-repair; scope/stop/bounded-reply/closure-immunity -> P7 after load-bearing owners unless P7 is itself the stop owner. P1/restoration, tone, closing formulation, pastoral reorientation, and broader source reminders are optional_non_load_bearing unless the current target burden is explicitly restoration/orientation. Do not promote analogies, proof-stack reminders, or broader texts to required merely because they are mentioned; they become required only when Layer A or MRP names that pressure as live. Science-only/source-totalization rule: if the input says scientific explanation, empirical method, or scientific authority is the only knowledge source/criterion, the source-order gate is structurally live. Execute source-status-repair.source-order before M1.self-grounding-test on the same burden and record required_before: source-status-repair -> M1, unless Layer A explicitly proves the source-order pressure non-load-bearing with a reason. The canonical NAR n_frame token for this narrow frame is science-only-source-order-warrant; do not paraphrase it across runs. For that science-only source-order canary, use exact pressure labels: scientific-explanations-only-knowledge-source for the source-status ACT and only-science-counts-standard for the M1 ACT. Use simple terminal-state maps in machine fields: "terminal_states": {{"B1": "landed"}} in both field_witness and coverage_proof. Use the exact Layer A concealment boundary Concealment mode: sincere clarification/shubhah pressure path; boundary: diagnostic noetic covering only; no hidden soul-state or takfir judgment. Do not label this narrow frame mixed unless at least two dominant source-owned refusal components are explicitly diagnosed and named. Derive the baseline burden floor from live registers in IR(N,m,tau,sigma,heart,xi,Omega,mu,kappa), not from named case-label templates: burden_floor = {B_r : r in live_registers(IR(...))}. Omega live requires an ontological/predication burden, xi live requires a warrant/authority burden, mu live requires a memetic-carrier decomposition burden, kappa live requires a dependency/collapse burden, and heart live requires an affective/posture burden. Burdens may be multi-typed; coverage is required per live register, not one burden per register. The selected N-frame supplies each burden's label and content, while register liveness supplies the floor structure. A selected hard-output row may serve as fixture/audit evidence for this rule, but never as a runtime template. When the selected N-frame activates Omega, xi, mu, and kappa through selected model/person-language pressure, source/proof authority, carrier compression, and entailment/dependency pressure, the baseline B_LA floor must cover those register types before any generated MRP burden. Do not merge proof-stack and entailment anchors into one register obligation, do not split restoration/tone into a required baseline burden, and do not place doctrine-immunity, proof-carousel, or bounded-reply recoil in B_LA unless the quoted input asserts that recoil as its own claim. If final closure names broader source texts, full-system doctrine, hidden-framework support, or bounded-reply immunity after those register-derived baseline burdens land, MRP may generate the next boundary-classification burden in B_MRP; it must not rewrite the original baseline set. For any selected hard-output route, do not use parallel_groups to hide required order and do not import fixture pressure labels into runtime as deterministic routing. Derive required owners, pressure labels, and required_before edges from the selected DSL/IR structure: model identification before predication when model family changes predicate force; definition before predication when a term anchor controls the claim; source-status before authority-order when source function controls warrant; consequence tracing before scope closure when entailment pressure controls the stop condition; and generated boundary/source/proof-carousel owners only when post-Land MRP exposes that pressure as live. A selected source-totalization/default-carrier row may likewise serve as fixture/audit evidence for the live-register rule, not as a replacement template for arbitrary inputs. When the selected N-frame activates xi, mu, Omega, and kappa through a source-authority warrant tribunal, default-carrier pressure, ontological reduction pressure, and implication-chain veto, keep the register-derived B_LA floor stable and keep generated boundary/proof-carousel recoil out of B_LA until MRP instantiates it. Use required owners with stable structural ordering from the live pressure; do not require exact canary pressure/delta labels unless the fixture or retained evidence itself is under test. Partition candidate owners into required, parallel, contingent, optional_non_load_bearing, or hold_partial; emit ACT records only for owners that actually execute, and tag each matching field_witness.owner_activations[] object with the same ordering_role. If several owners are load-bearing for one target burden, either emit explicit owner_activation_ordering.required_before edges or mark the ACT objects as parallel with a shared ordering_group. A required_before entry is an object such as {"target": "B1", "before_owner": "source-status-repair", "after_owner": "M9"}; do not use arrays, body-ref pairs, burden-event pairs, or submove IDs as the ordering rule. For owner_activation_ordering.parallel_groups[], the plan entry key is group, not ordering_group; for example {"target":"B2","group":"B2-required","owners":["M7","M9"]}. The individual owner_activations[] rows keep ordering_group. Contingent owners require a concrete trigger; held or partial owner work uses hold_partial and names the unresolved pressure in terminal detail. Do not let stylistic owner choices, restoration-tail work, or optional support owners appear as unclassified required activations. A generated burden receives Matched owner/TTP route: [owners...], then its own Layer B owner-backed submoves with Target, Operation, Result/state-change, and Contribution-to-Land, then a concrete landing such as Land(⁶B), then post-land R(H,Δ)/MRP/STOP-or-route. Code lookup is not owner activation: the selected owner/TTP must perform its operation body before Land. Owner activation has a visible body test: M7 actually anchors definitions; M8 actually traces consequences and its Contribution-to-Land says why that consequence trace lands or reroutes the burden. Good M8 bodies visibly state "if granted/if accepted, what follows is ..." and name the consequence; they do not merely say "trace" or conclude the route fails. M9 actually repairs/separates predication/category structure with action verbs like repair, separate, or block in the Operation/body, not only test; source-status/authority-order actually sorts which source carries which claim and prevents hidden support; P7 actually names the scope gate, stop condition, held-route boundary, and reopen condition using those visible concepts. Other catalogue owners follow their own source-owned operation shape. Use Result/state-change: for high-mass submoves. That line must name a concrete state change such as blocked, separated, defined, stabilized, invalidated, demoted, routed, held-with-reason, licensed, or landed; vague conclusion lines are not enough. The operation body may explain the state delta, but the compact Result/state-change field must also be parseable because Land(...) depends on it. Generated burden headings must be parseable burden nodes: ## Burden 6 / ⁶B [generated-by: MRP(⁵B)] — <title> using the next concrete token. Do not write bare headings such as Burden ᵏB — <title> or schematic headings such as ## Burden K / ᵏB [generated-by: MRP(ⁿB)] — <title>. The generated burden's Layer A intake belongs inside the generated burden card, after the concrete generated heading; do not print the intake as a free-standing block before the generated burden node. Immediately after the generated heading, print #### Layer A - Generated Burden Intake with live noetic burden:, generated-by: MRP(...), generation reason:, and matched owner/TTP route:, then print #### Layer B - Governed Operation Body before the generated submoves. In hard/high-mass output, each major submove must include TTP Operation Body: after Target/Operation/Result-state-change/Contribution-to-Land and then at least two visible prose movements: owner-specific execution, followed by state delta and Land connection. Field bullets alone are not execution. Generated closure-boundary, hidden-framework, proof-stack, or immunity-recoil burdens normally require both the boundary owner and the owner that blocks hidden support or traces the recoil consequence, such as [P7, source-status-repair], [P7, authority-order-repair], or [P7, M8]. Do not land a generated high-mass recoil with a single P7 submove unless the output explicitly routes HOLD/PARTIAL or proves the burden is diagnostically low-mass. Contribution-to-Land(...) is a causal proof sentence, not a label. It should use words such as because, so that, thereby, blocks, prevents, establishes, licenses, routes, or state change to explain why the local delta contributes to the concrete Land line. Submove owner brackets contain source-owned owners, not route chains or MRP labels. Do not write [MRP/P1], [P-A/V9], or other mixed route strings. If multiple owners are needed, split them into separate submoves or choose the primary catalogue owner in the bracket and mention support in the Operation line. MRP detects, classifies, and routes; it is never the owner bracket for a Layer B submove. Use M1 only when the body visibly tests self-grounding, the claim's own standard, internal contradiction, or inability to authorize its own verdict. Use M1-P only when the body explicitly proves a performative contradiction: name the speech act or act of asserting, state what the act presupposes, and show why the claim cannot deny that presupposition while using it. If the pressure is merely a consequence, identity, plurality, or predication pressure, route M8/M9/source-status instead of using M1 or M1-P as a generic critique label. This is a general Layer B rule, not only a generated-burden rule: any medium/high-mass baseline B_LA or generated B_MRP burden that claims a concrete landing such as Land(¹B) or Land(⁶B) must show owner-specific operation bodies. If the body is only a short conclusion, label, or recap, route HOLD/PARTIAL or continue Layer B work instead of landing the burden. Owner activation is owner-local, not generic. In hard/manual graphable output, every medium/high-mass submove must make its owner mechanism explicit enough for a reviewer to reconstruct the operation: the body names the operative mechanism, applies an owner-shaped action, states the burden-local state change, and explains why that state change contributes to the concrete landing. Use owner vocabulary because it is proof of activation, not padding: M7.definition-anchor must define or anchor the disputed term/criterion, bind the next proposition to that semantic anchor, and state what pressure the definition removes. doubt-vs-skepticism.method-distinction must distinguish normal doubt from skepticism-as-method, name the evidence-demand/proof-carousel or burden-inversion pressure, and show why that separation contributes to Land(B). Do not write public prose fields as pressure = or category pressure =; use pressure class: or prose labels instead. The public syntax checker treats pressure= as a reserved malformed field wherever it appears, not only inside ACT records. Medium/high-mass Layer B submoves are not complete with only Target:, Operation:, Result/state-change:, and Contribution-to-Land(...) fields. Each such submove must include a literal TTP Operation Body: paragraph that re-performs the owner operation against the target, names the mechanism, names the local state delta, and explains why that delta lands or holds the burden. If the operation body would only repeat a conclusion, route HOLD/PARTIAL or continue Layer B work instead of claiming Land(...). FPD names the imported/foreign premise, criterion, hidden court, or smuggled support. In default-carrier or source-totalization routes, do not use an FPD owner row unless the target and body literally expose an imported criterion, imported premise, foreign premise, hidden tribunal/court, or smuggled support. Put one of those exact phrases in the Target: or Operation: line and again in the TTP Operation Body: paragraph, then state the blocked/invalidated state change. Use checker-readable base action verbs in the operation text: expose the imported criterion and block the hidden tribunal, not only inflected prose such as exposes or blocks. If the move is only carrier decomposition without an imported criterion or premise, route through the carrier/pattern/consequence owner or HOLD/PARTIAL instead of claiming FPD activation. M1/M1-P names the claim's own standard or speech act and shows the internal/performative contradiction; M3 identifies the orphaned intuition and why it cannot remain severed from its ground. If an ACT row uses M3.orphaned-intuition, the Target:, Operation:, or first TTP Operation Body: sentence must literally say orphaned intuition or orphaned moral/rational normativity, then name the true deliverance being borrowed and state why it cannot remain severed from its ground. Generic restoration of moral/rational norms without those orphaning and grounding words is not M3 activation. M7 explicitly uses definition-anchor/semantic-anchor/meaning language to stabilize the term under dispute, not merely mention "the term"; its Target: cannot be a label-only slug such as neutral-default, and should name the contested term plus its selected route function. M8 runs the "if granted, what follows" trace; in compact Result/state-change and ACT deltas, do not use rerouted as the only state-change token. Pair the trace with a checker-readable state word such as routed, blocked, invalidated, demoted, or exposed-as-dependent. M9 repairs predicate/category/referent/sense/person-nature structure; if a submove bracket is [M9], its Operation/body must visibly use at least one of those mechanism words and state which predicate, category, referent, sense, or person/nature transfer is being repaired. A generic "relation repair", "separate the relation", or "refuse collapse" body is not M9 activation unless it names the predicate/category/referent structure that changes. source-status or authority-order sorts which source, citation, proof text, authority, or source function can carry which claim and blocks hidden support, source-prestige, or proof-stack accumulation; its ACT delta_result must name the concrete burden-local effect, such as proof-text-sorted, hidden-support-blocked, proof-text-hidden-support-blocked, or source-function-bounded; do not use source-order-repaired as the only state-change token; M1 names the claim's own standard, self-grounding rule, internal contradiction, or why the claim cannot authorize its own verdict; P7 names the scope boundary, stop condition, held-route boundary, and reopen condition rather than merely saying the answer is bounded; a P7 submove should visibly include sentences or labels for Stop condition:, Held-route boundary:, and Reopen condition: unless it routes HOLD/PARTIAL; do-christian-extensions confirms the Christian pressure family and identifies the model/fan-out route rather than answering a named doctrine in the abstract; for selected DO-12 model pressure, its ACT / field_witness operation is model-identification, never bare route; do-second-loop confirms the DO-family route and names hujjah, warning, record, moral-protest, cognitive-science, or accountability mechanics; doubt-vs-skepticism distinguishes normal doubt from skeptical methodology, names the evidence-demand or modal-veto tribunal, identifies the anomaly/background-commitment structure, and shows the burden inversion or LoopBreak/P7 consequence; do-attribute-precision types the person/nature/attribute relation, blocks transfer from person-level multiplicity into nature-level deity, and names the local attribute confusion rather than letting M9 alone absorb it; P1/restoration explicitly restores positive orientation, fitrah/tawhid direction, humane reorientation, or returns the field to sound worship/source-owned frame after the burden lands. Other catalogue owners likewise activate their own source-owned mechanism. Numeric body floors are Andons, not proof of mass sufficiency. In hard/manual graphable output, a high-mass or generated TTP Operation Body: normally needs two information-bearing prose movements before the burden may claim Land(...): the owner operation itself, and the burden-local state-delta / Land connection. Word count can warn that the body may be under-compressed, but the proof is owner-specific reconstructibility: the target pressure is identifiable, the selected owner actually activates, the operation acts on that pressure, the burden-local state change is visible, and Contribution-to-Land explains why Land(...) is licensed. A long generic paragraph is still invalid. A shorter passage is valid only when the diagnostic state proves genuinely low mass and the owner operation is actually performed. If the body is short, generic, padded, or conclusion-shaped, expand the owner operation or route HOLD/PARTIAL instead of landing the burden. Do not cite V10 unless the body actually vets transmission/provenance/content/authority standards. Do not cite V8 unless the body actually anchors bila kayf / attribute discipline after semantic repair. Do not cite do-attribute-precision or proof-method-audit unless the body performs those catalogue-owned operations locally. If the burden is only predication/category repair, use M9; if it is source ordering or hidden support, use source-status-repair or authority-order-repair; if it is scope/stop discipline, use P7.
8. Do not shrink 𝔅_LA to force generation. Multi-anchor prompts keep input-present burdens in 𝔅_LA; MRP may add only a further post-land pressure. In hard/manual graphable proof, a final broad-system, doctrine-immunity, proof-carousel, total-exhaustion, doubt-churn, moral-tribunal, authority-order, or held-route-boundary recoil is not allowed to disappear into no_new_resultant merely because local baseline burdens landed. If such post-land pressure could preserve the defeated claim, instantiate and work a generated 𝔅_MRP burden, or route HOLD/PARTIAL with coverage_complete=false. A final empty 𝔅_MRP is licensed only by explicit low-recoil proof: no high-leverage held route, no framework/source/order recoil, no proof-stack carousel, and no closure-boundary pressure remains. For current hard/manual smoke proof, any final STOP, LoopBreak, HOLD, or PARTIAL after a medium/high-mass traversal must first check for a closure-boundary or immunity-recoil burden. If the final move would otherwise say "no new result" while also relying on scoped closure, proof discipline, doubt-churn blocking, person-specific HOLD, or public-tail restoration, instantiate a small but real generated B_MRP burden over that boundary and work it with matched owners such as P7, LoopBreak, source-status/authority-order, P1, or the catalogue owner that R(H,Delta) detects. Do not close a hard smoke with B_MRP = {{}} unless the text explicitly proves low recoil in the MRP block and field_witness. In RC4/D.1-style hard proof, a scoped/reopen boundary after four baseline burdens is not proof that B_MRP is empty. If the final baseline burden leaves positive-proof, personal-hiddenness, source-authentication, proof-carousel, or bounded-answer recoil reopenable, instantiate a generated boundary/recoil burden such as ⁵B [generated-by: MRP(⁴B)], or classify the route as HOLD/PARTIAL/non-load-bearing with an explicit reason. Do not absorb that post-land recoil into ⁴B and then claim no_new_resultant.
9. Proof-tail order is fixed: Restorative Response -> Closing Formulation -> Closure/Reconstruction Witness -> field_witness. The closure witness begins with literal Initial burden set: [...], then prints ∇·B:, ∇×κ:, 𝒞(Ψᴺ):, and T_lang: Ψᴺ ⇢ Ψᴵ: after Closing Formulation, plus literal Burden dependency graph: with the root marked exactly (root) and MRP resultants: ledgers. It also prints literal Terminal states: with one state line per baseline and generated burden. Closure Initial burden set:, Terminal states:, Burden dependency graph:, and MRP resultants: use canonical burden notation first: Initial burden set: [¹B, ²B, ...], ¹B: landed / ..., ¹B (root) → ²B, and MRP(¹B): type=<...>; finding=<...>; graph=¹B → ²B; route=<...>. Parser aliases such as B1, B1:, or B1 -> B2 are allowed only in explicit machine-facing fallback fields, never as the primary public Closure/Reconstruction Witness. Keep closure graph rows contiguous until the next known witness field; do not insert prose between graph edges. Terminal state tokens are lowercase parser values such as landed; never write uppercase LANDED. Each MRP resultant line uses the exact parseable canonical form, not slash-prose. The T_lang line is exactly T_lang: Ψᴺ ⇢ Ψᴵ: partial coupling attempt / language-mediated boundary; no guaranteed uptake; never substitute Ψᴬ, Ψᴿ, Ψᵁ, PsiA, or any agent/user/recipient symbol. Ψᴺ names the noetic field being reconstructed, not the assistant, agent, audience, or addressee. Closure field statuses are parser values: ∇·B: neutral / ... or non-neutral / ..., ∇×κ: null / ..., resolved / ..., or non-null / ..., and 𝒞(Ψᴺ): coverage_complete=true; runtime execution field closed for this bounded reply .... Missing Closing Formulation is a default-render failure. Restorative Response is also reconstructive proof, not a generic warm close. In graphable closure/collapse-positive output it must explicitly name the restored criterion/order, the relieved or blocked pressure, and what remains held, scoped, bounded, or reopenable. It must also reflect generated B_MRP pressure labels from generated-burden owner activations or generated-burden records in public language. If MRP generated a boundary-as-immunity, total-system-exhaustion, proof-carousel, source-order recoil, restoration-recoil, or hidden-framework recoil pressure, the Restorative Response must contain a sentence that addresses that pressure as a claim, framing, or anticipatory move. The pressure may be paraphrased, but it cannot appear only in field_witness, MRP resultants, or the Closure/Reconstruction Witness. It must also carry the restoration endpoint in visible language: name fitrah/fiṭrah or tawhid, and name sound reason/ʿaql ṣarīḥ when the final orientation is claimed. Use those words visibly; if none remains, say that the reopen boundary is held for specified future claims only. Preferred high-mass shape: Restored criterion/order: ..., Relieved pressure: ..., and Held/scoped/reopenable remainder: ... as visible sentences or paragraph starts inside the Restorative Response section. If any MRP-held or MRP-generated burden printed ACT records, Closure/Reconstruction Witness also prints Owner activations: and repeats those exact compact ⟦ACT ...⟧ lines. Do not shorten them into prose, state=... fields, or ASCII-only call records. In final field_witness, top-level B_LA, B_MRP, and B_total are arrays of graph-id strings only, for example ["B1", "B2"]; never put title objects in those ledger arrays. B_LA contains only baseline input-present burden IDs from visible Initial burden set / 𝔅_LA; B_MRP contains only generated post-land burden IDs from visible 𝔅_MRP; B_total is exactly B_LA + B_MRP in order. The visible Closure/Reconstruction Witness and field_witness must agree exactly on B_LA, B_MRP, B_total, coverage_proof.initial_burden_set, dependency edges, roots, and terminal states. Never place a generated burden in B_LA, never omit it from B_MRP, and never let the machine ledger drift from the visible witness. For every visible [Mid-Reread Pressure] block, also add one field_witness.formal_reread_states[] item. It copies the block's Target burden into source_burden, the preceding Land(...) line into prior_land, the visible Landed delta into delta, R(H,Delta) or R(H,Δ) into reread, the visible Route-gradient into route_gradient, the first visible ∇·T / ∇·B state into divergence_state, the first visible ∇×T / ∇×κ state into curl_state, and the visible MRP route result type, MRP resultant, Graph delta, Pre-emption basis, and Route values into matching keys. Do not invent a formal object if the visible block is missing; route HOLD/PARTIAL instead of claiming closure. Put notation, titles, owners, generated-by provenance, and terminal states inside nodes, generated_burdens, and terminal_states. coverage_proof is not optional in normal graphable output. It must include initial_burden_set, terminal_states, and a dependency_graph object with nodes, edges, roots, and acyclic; do not replace dependency_graph with only generated_burden_set, divergence_check, curl_check, or reopen-condition prose. Generated burdens carry explicit depth accounting: baseline B_LA burdens have depth 0; each B_MRP record in generated_burdens[] and the generated burden node includes "generation_depth": <parent depth + 1>, and coverage_proof.max_generation_depth equals the maximum generated depth. For a single generated B5 from MRP(B4), write "generation_depth": 1 on B5 and max_generation_depth: 1 in coverage_proof. In hard/high-mass governed output, Closing Formulation is a practitioner-usable final articulation, not a slogan and not metadata: name the governing failure established, state the restored orientation or criterion, and preserve the scoped boundary or reopen condition. Use an explicit phrase such as scoped boundary: or reopen boundary: when future material remains held. Render the three high-mass slots as separate lines whose labels begin the line exactly: Established failure:, Restored criterion/orientation:, and either Scoped boundary: or Reopen boundary:. Do not combine the boundary label into the restored-orientation line. It should be a substantial paragraph or two compact paragraphs when the case is high-mass; never let the Closure/Reconstruction Witness swallow the public final formulation. Visually similar glyphs are invalid: 𝓑_LA is not 𝔅_LA, and 𝓒(Ψᴺ) is not 𝒞(Ψᴺ). If those substitutes appear in a draft, revise them before final.
10. field_witness is required for normal governed output so Output Grapher can graph every complete daee-epistemics answer without guessing from prose. Closure/Reconstruction Witness is the human-readable proof ledger; field_witness is the machine-readable graph/reconstruction payload. The public answer remains first; the proof tail is Restorative Response -> Closing Formulation -> Closure/Reconstruction Witness -> field_witness. Emit a final field_witness JSON block, or write an explicit adjacent .field_witness.json sidecar when file transport is available. Omit it only in explicit minimal/short/no-graph modes that state graphing is unsupported or graphing is partial. The sidecar records B_LA, B_MRP, B_total, burden nodes, submove nodes, dependency edges, generated-by provenance, held/generated MRP resultants, route-gradient, formal_reread_states, Land/R(H,Δ) records, del-dot/del-cross diagnostics, terminal_states, coverage_proof, terminal routes, closure status, T_lang boundary, and held non-claims. It must agree with the visible Closure/Reconstruction Witness. owner_activation_ordering is part of this required sidecar and must include exact "policy_id": "diagnostic-ir-pressure-owner-floor-v1" before required_before, parallel_groups, or other plan fields. Do not use policy as a synonym. Do not place field_witness before the public answer and do not let it replace the Closure/Reconstruction Witness, Restorative Response, or Closing Formulation. Terminology is strict: Closure/Reconstruction Witness is the human-readable proof ledger; field_witness is the machine-readable graph/reconstruction payload. Output Grapher should prefer field_witness for graph structure and validation while using the Closure/ Reconstruction Witness as readable backup/context. field_witness is parser-stable JSON, not a prose summary. It must include top-level keys B_LA, B_MRP, B_total, nodes, edges, generated_burdens, mrp_resultants, reread_records, field_diagnostics, terminal_states, closure, T_lang, non_claims, owner_activations, owner_activation_ordering, normalized_activation_record, and coverage_proof. Use ASCII IDs such as B1, B5, and MRP(B4) inside JSON when needed for parser stability, while preserving canonical notation in visible prose. nodes includes burden and submove nodes; edges includes dependency, held_burden_activation, and generated_burden_instantiation edges. coverage_proof includes initial_burden_set, terminal_states, and dependency_graph with nodes, edges, roots, and acyclic. Every field_witness.mrp_resultants[] item includes "source": "B1", "type", "finding", "graph", and "route". Do not use "target" as the only source key, and do not rely on "id": "MRP(B1)" without a separate "source". The "route" value copies the visible compact MRP Route: value exactly, including LoopBreak(∇×T) when a curl/churn route is loop-broken; do not substitute transport aliases such as LoopBreak(del-cross(T)) in mrp_resultants. Every routed ACT line has a matching field_witness.owner_activations[] object with "source" naming the route source, "target" naming the activated burden for MRP-held or MRP-generated routes, plus "owner", "operation", "pressure", "body_ref", "delta", and "land". The JSON may use graph IDs such as B2 / Land(B2)+, but it must agree with the visible compact ACT line and dereferenced body. owner_activations is not a graph source and is not proof by itself. This mirror is count-exact: if the visible Owner activations: ledger or any burden ACT records: block prints eleven compact ACT records, field_witness.owner_activations[] contains eleven corresponding objects. Do not mirror only the first owner, only generated burdens, only one owner per target burden, or only graph edges. Each visible ACT record must have its own object keyed by the same owner, operation, pressure, body_ref, delta, and land. For ACT records on a burden released by MRP, the JSON source is the route event source, not the target burden: held release from MRP(¹B) into ²B uses "source": "MRP(B1)", "target": "B2" for every ²Bᵢ ACT object; generated release from MRP(³B) into ⁴B uses "source": "MRP(B3)", "target": "B4". Only a burden that is not released by an MRP route may use its own burden ID as source. Baseline/root burdens still need target evidence: copy every visible ACT record for the initial landed burden into owner_activations[] with "source": "B1" (or the concrete burden id) and "target": "B1". Do not mirror only MRP-released or MRP-generated burdens. The delta value in each field_witness.owner_activations[] object copies the visible ACT delta value exactly after Δ=, including Δ²B: or Δκ: glyph tokens. Do not normalize it to Delta B2:..., Delta-kappa:..., or any ASCII prose variant. This exact-copy rule is for owner_activations[]. In field_witness.formal_reread_states[], source_burden remains the machine-readable ASCII burden id, while delta copies the visible public Landed delta: text exactly after that label. Write the visible line canonical-first, such as Landed delta: Δ²B / Delta(B2) and Δκ: ..., then copy that exact same string into field_witness.formal_reread_states[].delta. Do not paraphrase it, change quote marks, or print ASCII-only Delta(B2) / Land(B2) tokens as the primary visible proof notation. In public prose inside Landed delta, Route-gradient, and pressure-activation lines, write Land(²B) or after ²B lands, not Land(B2). ASCII graph IDs belong in JSON fields and explicit paired fallback slots only. For deterministic repeated-run proof, field_witness also carries owner_activation_ordering. Use an object with exact policy_id: "diagnostic-ir-pressure-owner-floor-v1", required_before edges, and optional parallel_groups, contingent, and non_load_bearing lists. Every owner_activations[] object includes ordering_role; parallel and optional_non_load_bearing activation objects include ordering_group, and contingent activation objects include trigger. Each parallel_groups[] plan object uses target, group, and owners; do not use ordering_group inside parallel_groups[]. This plan is a canonicalization surface, not a second proof ledger: it records the pre-Layer-B pressure-owner floor that selected owner work so repeated runs can compare required activation sets while ignoring explicitly non-load-bearing variation. If owner_activation_ordering.policy_id is absent or not exactly diagnostic-ir-pressure-owner-floor-v1, the final artifact is invalid; rewrite the JSON before final output. Do not emit owner_activation_ordering.policy; that key is not a valid replacement for policy_id. Normal governed output also emits field_witness.normalized_activation_record as the prose-stripped structural comparison surface. It contains n_frame, live_registers, burden_floor, and per_burden[] rows with burden_id, owner_id, operation, delta_result, mrp_route_result_type, terminal_state, and generation_depth. n_frame is a stable kebab-case frame identifier selected by Diagnostic IR, not prose. Reuse the same token for the same diagnosed frame across runs; for the science-only source-order warrant frame, use exactly science-only-source-order-warrant. In NAR, delta_result is the suffix token only, such as science-source-bounded or self-authorizing-standard-invalidated; do not include the burden-local prefix (Δ¹B:, Delta(B1):, or similar) inside normalized_activation_record.per_burden[].delta_result. The Layer A header must include an explicit live registers: [...] line when those registers are claimed in NAR. In NAR, burden_floor is a string list of B IDs only, for example ["B1","B2"]; do not use register/object rows there. per_burden[] is ACT-level despite its historical name: emit one row for every visible ACT / owner_activations[] object, and allow several rows to share the same burden_id when several owners land one burden. The record is not proof by itself; it must agree with owner_activations[], mrp_resultants[], terminal_states, generated_burdens[], B_LA, B_MRP, B_total, and coverage_proof. For B.5 proof-mode/full-IR retained evidence, field_witness is the JSON payload itself after the literal field_witness heading; do not nest it under a top-level "field_witness" wrapper. It must include coverage_proof.dependency_graph (nodes, edges, roots, acyclic), normalized_activation_record.burden_floor, and normalized_activation_record.per_burden[]. Terminal STOP/no-new-resultant rows include no_new_resultant_proof.escape_routes_checked as a list, field_state_at_stop with neutral divergence, null/resolved curl, literal b_live: "empty", kappa_residual: 0, and stop_licensed: true. Canonical delta_result tokens are owner-local. The machine-readable runtime metadata source is references/diagnostics/delta-result-vocabulary.json (diagnostic-ir-delta-result-vocabulary-v1); the list below mirrors that source. Use only these suffixes after the burden-local delta prefix: M1 = self-authorizing-standard-invalidated / internal-contradiction-exposed / criterion-self-failed / self-authorizing-falsifiability-standard-invalidated; M1-P = performative-contradiction-exposed / speech-act-presupposition-named; M3 = orphaned-intuition-identified / grounding-severed / normativity-restored-to-ground; M7 = definition-anchored / semantic-anchor-stabilized / term-meaning-bounded / falsifiability-standard-defined; M8 = consequence-traced / implication-demoted / mechanism-totality-demoted / entailment-blocked / dependency-exposed / coercive-clarity-entailment-demoted / finite-answer-evasion-claim-invalidated / total-veto-consequence-demoted; M9 = predicate-separated / category-separated / referent-separated / person-nature-transfer-blocked / sense-separated; FPD = hidden-tribunal-blocked / imported-criterion-blocked / foreign-premise-exposed / smuggled-support-blocked / imported-control-criterion-blocked; source-status-repair and authority-order-repair = source-order-repaired / hidden-support-blocked / science-source-bounded / proof-text-sorted / authority-order-repaired / proof-text-hidden-support-blocked / authority-order-separated / hidden-authority-source-status-bounded; P1 = fitrah-reorientation-restored / tawhid-orientation-restored / sound-worship-frame-returned / fitrah-orientation-restored; P3 = reason-revelation-order-stabilized; P7 = scope-boundary-named / stop-condition-defined / held-route-bounded / reopen-condition-stated / personal-hiddenness-held-with-reason / reopen-boundary-licensed / shubhah-boundary-routed; LoopBreak = circular-dependency-broken / loop-grounded-in-owner-source; do-christian-extensions = trinitarian-model-identified / fan-out-route-named; doubt-vs-skepticism = doubt-distinguished-from-skeptical-methodology / burden-inverted / evidence-demand-tribunal-exposed / doubt-method-separated-from-sincere-question. Each required_before edge uses owner-family objects with target, before_owner, and after_owner. Do not encode required-before edges as arrays like ["B1_1","B1_2"] or as burden events like ["B1","MRP(B1)"]. coverage_proof.dependency_graph.edges uses parser-stable pairs or objects, e.g. [["B1","B2"], ["B2","B3"]] or [{{"from":"B1","to":"B2"}}]; do not encode graph edges as strings like "B1->B2". Machine-facing field_witness.terminal_states and coverage_proof.terminal_states are objects/maps keyed by B id, not arrays of terminal objects. B_total is exactly B_LA followed by B_MRP in order. Inline field_witness must use a literal field_witness heading followed by the parser-stable object itself; do not emit an unlabeled JSON fence and do not wrap the payload as {{"field_witness": {{...}}}}. coverage_proof.divergence_check and coverage_proof.curl_check use the same status heads and slash-detail shape as the visible Closure/Reconstruction Witness, such as neutral / ... and resolved / ...; do not write parser-drift variants such as neutral after B6. Missing coverage_proof, MRP resultants, terminal states, or generated-by provenance makes a normal governed output not graphable.

FINAL LEDGER-EXPANSION CHECK: For hard noetic, source-worldview, named-authority, or multi-burden manual/default proof, a final baseline burden that lands a proof stack, analogy stack, authority-order repair, source-order repair, framework-protection claim, doctrine-protection claim, named-framework appeal, or bounded local reply must run one more MRP ledger-expansion check before STOP. Do not let Layer A absorb the post-land boundary-as-immunity recoil into the baseline burden. The baseline authority/proof-text claim may be 𝔅_LA; the new recoil is different: after the baseline claim lands, the field may try to rescue the reply by saying the broader doctrine, source-frame, framework, mystery, full-system taxonomy, or unworked surrounding material remains immune because the answer was bounded. If that pressure is available and absent from 𝔅_LA, MRP records MRP route result type: generated_burden_instantiation, creates the next unused burden a concrete token such as ⁶B [generated-by: MRP(⁵B)], works it in Layer B, lands it, then rereads to STOP/HOLD/LoopBreak. Work means operation-shaped owner/TTP execution, not conclusion-shaped summary. A generated high-mass burden must perform the selected owner/TTP, show why that operation is live after Land(ⁿB), block/repair/trace/sort/bound the move as the owner requires, record the state delta, and explain how that delta contributes to a concrete generated landing such as Land(⁶B). Boundary-as-immunity recoil must work the distinction between local claim closure and total-system exhaustion, proof-stack immunity, unworked held-route smuggling, reopen conditions, and the non-load-bearing basis for scoped STOP/PARTIAL. Do not land it from lines that merely say bounded answers need not exhaust everything or held material stays held. Do not inventory this recoil as a baseline doctrine-immunity, system-immunity, boundary-as-immunity, or broader-framework immunity burden unless the user's own input explicitly asserts that immunity move as a claim. In a named noetic/source-worldview prompt with multiple proof/source supports, closing with 𝔅_MRP = {{}} and MRP route result type: no_new_resultant after four or more baseline burdens is invalid unless the final MRP line states, from the field state, why no broader-system, boundary, proof-stack/analogy-stack, source-order, or framework rescue remains load-bearing; otherwise generate the bounded non-baseline recoil burden. When STOP is claimed after held routes were named, classify every named route before closure: Held-route classification: <route> = non-load-bearing / <reason>, or <route> = HOLD/PARTIAL / <scope gate>, or <route> = generated / <new burden>. A bare phrase like broader canon held beyond prompt, full system held outside scope, or none load-bearing is not enough. If a pertinent route is not worked and not proven non-load-bearing, closure status is PARTIAL/HOLD, not COMPLETE/collapse. For a hard generated-MRP smoke, closing with 𝔅_MRP (B_MRP) = {{}} after four or more baseline burdens and a named framework, proof-stack/analogy-stack, source-order, or authority-order appeal is invalid unless the final MRP block explicitly proves why no broader-system, doctrine/framework-immunity, proof-carousel, or bounded-answer recoil remains. For RC4/D.1 hard-smoke shape, the final restoration/reopen burden may bound the baseline defeat claim but it does not consume the post-land recoil. If the output names scoped closure, reopen conditions, positive-proof, personal hiddenness, source-authentication, proof-carousel, or bounded-answer pressure as still reopenable, R(H,Delta) after that burden must either generate the next B_MRP node and work it, or route HOLD/PARTIAL/non-load-bearing with a stated reason. Do not emit MRP route result type: no_new_resultant while also using those reopenable pressures as the closure boundary.

Default Output Surface Invariant Details

For plain /daee-epistemics, internal governance is mandatory and default visibly prints a noetic-field execution banner before the compact DSL/IR header. The first visible surface must signal governed execution with NOETIC FIELD EXECUTION and must not collapse to a bare field: line or source request legacy label. Compact Layer A (read status, confidence, claim_level, pattern_profile, reason-category, Concealment mode:, deformation, DO-orient, live noetic burden, current bounded operator, held, source-status/noetic-frame, gate/release decision, decisive missing differentiator when required) is the visible default diagnostic surface. Full Diagnostic IR, full Case State, full Source Basis ledger, matched_modules, and route ledger remain internal; compact TTP/operator trace appears when a named runtime operator performs work under the render contract.

Default visible frame:

╔══════════════════════════════════════════════════════╗
║ daee-epistemics — NOETIC FIELD EXECUTION             ║
║ field: <LOCAL CLAIM | NAMED WORLDVIEW | SOURCE-AUTHENTICATION | MIXED NOETIC FIELD>
║ user task: <RESPOND | REFUTE | DIAGNOSE | EXPLAIN | SOURCE-AUTHENTICATION | OTHER>
║ external source request: <NONE EXPLICIT | IMPLICIT | EXPLICIT>
║ authority frame: <NONE DETECTED | LIVE>
║ state: <RECURSE | PARTIAL | COMPLETE>
╚══════════════════════════════════════════════════════╝

Layer A — Compact DSL/IR header
- read status:
- confidence:
- claim_level:
- pattern_profile:
- reason-category:
- Concealment mode:
- deformation:
- DO-orient:
- live noetic burden:
- current bounded operator:
- held:
- source-status/noetic-frame:
- decisive missing differentiator: [only when required]
- gate/release decision:

Layer B — bounded governed response
- Hidden Premises
- Burden / Operation N
  - Core Formulation
  - Bounded Response / operative submoves
- TTP/operator trace when a named operator does runtime work

State/noetic re-read

Closure/Reconstruction Witness (when closing hard, multi-burden, register-active, or mixed-field cases)

Next Burden (only while R licenses RECURSE)

Final Restorative Response
Final Closing Formulation

Before any answer is emitted:

• Diagnostic IR is formed internally.
• Case State is maintained internally.
• Source Basis is tracked internally.
• matched_modules and route plans remain internal.
• STOP / HOLD / RECURSE / PARTIAL is decided internally.

Default output must not print:

• Full Diagnostic IR block or ## Diagnostic IR header
• Full Case State block
• Full Source Basis block or source-basis ledger
• matched_modules
• route plan or route ledger
• load ledger
• source ledger
• literal Recursion decision:
• next_eligible_pass
• setup narration such as "I now have enough..." or "Let me compose..."
• file loading, searching, setup, readiness, or composition narration such as "Let me check..." or "I will produce governed prose..."
• scholar/source/citation parade, school-label context, genealogy, or external philosopher / theologian support unless requested or validated source-comparison IR requires it

If the drafted default answer contains those surfaces, rewrite it before output.

TTP/operator trace is not external citation support. If a named runtime operator such as FPD, M1, M1-P, M8 reductio, M9 predication repair, tamanu, criterion-reversal, tribunal-detection, P1/P7 restoration or hold discipline, transmission/testimony, predication, grief/register, family-local proof-method, or authority-order repair performs the work, the governed operation or bounded response names it and executes target -> operation -> result. Do not substitute a source citation for TTP invocation, and do not substitute TTP invocation for Qurʾān/Sunnah/Salaf citation when revealed textual support is actually used. When revealed text is quoted for operative diagnostic or restorative work, present it cleanly as quotation, translation, and source/reference where useful, then state the function it performs; do not collapse central revealed evidence into a long prose sentence or use it as citation padding. Within a released live burden, TTP/operator routing is burden-complete: materially necessary sub-burdens are addressed by matched operators before state/noetic re-read, and NewB is not licensed by a headline-only answer, skipped internal sub-burdens, generic prose substitute, or broad-conclusion jump. A self-authorizing criterion, self-grounding moral/epistemic court, source-worldview transfer, predicate/category transfer, testimony standard, grief/register gate, or family-local proof-method pressure requires its matched owner action when structurally live; generic "test", "clarify", "warn", or "address" language is not enough unless the target, operation, and claim-state change are visible. This activation standard is catalogue-wide. For each released burden-cycle, check the live noetic structure against the relevant TTP/owner families: E1-E4, F1-F3, husn-al-nazar arguments, inductive-fitri method, M1-M9, M1-P, R1-R3, symmetric-taqlid-check, V1-V12, heuristics, P1-P7, transmission/testimony owners, predication owners, grief/register owners, source-worldview owners, and family-local proof-method owners. Do not print a route list. Execute every structurally live owner as a local Layer B submove with target, operation, result/state change, and contribution to Land(B), or explicitly clear/hold/PARTIAL it when the trigger is absent, blocked, or underdetermined.

Full diagnostic blocks belong to /daee-epistemics:dsl or internal/development audit, not default mode. Compact Layer A fields are mandatory in default mode.

Default Mode Execution Details

Default mode suppresses raw visible IR but does not suppress recursive execution. Default mode is scriptless compact DSL-governed execution. Do not call or simulate repo/dev route-check harnesses during canonical execution: no daee_level3.py, route.py, check_execution.py, features.json, route_plan.json, execution_verdict.json, or quality-gate claims. Those artifacts are optional developer validation, not public runtime evidence and not a substitute for owner/source/depth behavior in output.md.

HARD-COMPOUND LAYER B EXECUTION BODY: Hard-compound full traversal requires a visible Layer B operation body for every released burden. Do not collapse a major burden into one generic "Bounded Response" paragraph or one Target/Operation/Result block. A non-atomic released burden renders multiple owner-bearing submove labels, preferably ¹B₁[FPD] (B1_1[FPD]) - expose the imported criterion, ¹B₂[M1-P] (B1_2[M1-P]) - test the authority premise, etc.; ASCII B<N>_<s>[owner] is the checker-readable fallback only. Each submove carries Target, Operation, Result/state-change, and Contribution-to-Land(Bn). In a full hard-compound traversal those fields are not stubs: each released submove must do its local noetic work in case-shaped prose, naming the exact criterion/premise, applying the matched owner/operator, and showing why that change contributes to Land(Bn). One-sentence Target/Operation/Result lines are acceptable only for an explicitly compact PARTIAL/HOLD route, not for coverage_complete=true. This Layer B mass gate applies to every burden that claims Land(Bn), including baseline 𝔅_LA burdens and generated 𝔅_MRP burdens. Target/Operation/Result/Contribution headings are invalid when their bodies are conclusion labels. Before Land(Bn), the submoves must identify the exact claim, pressure, route, predicate, source-status, consequence, or affective/noetic move being worked; operate with the owner/TTP; produce a specific state-change; and explain the landing contribution. Otherwise continue Layer B execution or route HOLD/PARTIAL. Generated 𝔅_MRP burdens are especially suspect because they arise from post-land recoil, but generated-by is not the only case checked. For high-mass burdens, the compact field scaffold is not enough. After Target, Operation, Result, and Contribution-to-Land, include an explicit TTP Operation Body: that performs the owner/TTP. The body is owner-specific, not a one-size hidden-premise script: FPD exposes imported premises/criteria; M1 tests self-grounding; M1-P shows performative contradiction; M8 traces consequences; M9 repairs predication/category structure; source-status and authority-order repair sort source authority and hidden support; P7 bounds scope, stop conditions, and reopen gates; LoopBreak exits circularity; restoration/P1 returns the field to positive orientation. The body must produce the state-change that makes Contribution-to-Land true. For hard-compound high-mass burdens, the body should not be one compact conclusion paragraph. It should show two visible prose movements: owner execution, then field-state delta/Land connection. If either movement is missing, route HOLD/PARTIAL or keep working before Land(Bn). The owner catalogue is broad and source-owned, not a closed FPD/M8/M9/P7 subset. State-read may route to V, M, E, F, R, P, source-status, authority-order, definition, transmission/testimony, LoopBreak, restoration, or any other catalogue-owned owner whose operation matches the detected pressure. Code lookup is not owner activation: a submove must show validated state, owner-specific operation, burden-local result, and Contribution-to-Land before Land(Bn). MRP is the recursive pressure read that identifies applicable owner routes; it is not a closed burden-name detector, graph-edge generator, or mega-TTP. When MRP detects pressure already in B_LA, held_burden_activation may release it, but Layer B still performs matched owner/TTP work. When MRP detects newly emergent pressure, it must record generated_burden_instantiation, instantiate Bk [generated-by: MRP(Bn)] into B_MRP, print Matched owner/TTP route: [owners...], route the generated burden to those owners, then let Layer B execute the owner-specific submoves, Land(Bk), and post-land R(H,Delta). MRP -> generated burden label -> generic paragraphs -> Land is invalid. The bracketed token must be a compact owner/operator ID or pressure class with no spaces, such as [FPD], [M1-P], [M8], [P1], [P7], [definition-discipline], [source-status-repair], or [authority-order-repair]. Put human-readable operation names after the dash; do not put phrases like [consequence trace], [authority-order repair], [source-status discipline], or [governed submove] inside the brackets. Do not reuse the same generic Operation/Result/Contribution wording across submoves in one burden; repeated boilerplate is under-execution. For a 4+ burden hard-compound answer that claims full closure, fewer than three visible owner-bearing submoves per released major burden is an execution-depth warning; fewer than fifteen total submoves in a 5+ burden full traversal is normally under-executed. If the output cannot pay that local execution cost, route HOLD/PARTIAL instead of printing coverage_complete=true.

MANDATORY MRP ROUTE GATE: In default /daee-epistemics output, every routed burden-cycle that prints a concrete Land line such as Land(¹B), Field diagnostics, LoopBreak, R(H,Delta), R(H,Δ), a next burden, HOLD/PARTIAL, or closure must print a compact [Mid-Reread Pressure] block between the landed burden and the route. This is not optional diagnostic ornament. The block is the visible proof that reread pressure ran. If the block is absent, do not release the next burden, do not close, and do not print a route-bearing reread.

MRP ROUTE CONSEQUENCE INVARIANT: If MRP names remaining live pressure, non-neutral divergence, non-null/held curl, a graph edge, a genuine downstream burden, proportionality, hiddenness, source-worldview, owner-floor, or owner-body pressure, the output must release and land that burden, explicitly HOLD it with a named gate/reason, or mark PARTIAL with the named blocked burden/owner before any Restorative Response or Closing Formulation. STOP/COMPLETE is invalid while the same MRP record names an unresolved live pressure. If a later burden, Layer B body, or closure graph edge follows from the same answer, the prior MRP record is not final; it must mark the remaining burden as genuine-dependent, emit a concrete canonical graph delta such as ⁵B → ⁶B, and route RECURSE into the next burden. Route in the compact MRP block is limited to STOP, HOLD, RECURSE, or LoopBreak(∇×T); owner-load failure is rendered as Route: HOLD plus Boundary: PARTIAL / OWNER-BODY-NOT-LOADED: <missing owner/path>. If R(H,Delta) / MRP detects any pertinent, high-leverage, TTP-addressable held route in any noetic-structure family, complete collapse is forbidden unless the route is worked as existing B_LA, generated as new B_MRP and worked, HOLD/PARTIAL-routed with reason, or proven non-load-bearing for the scoped claim. Held beyond prompt cannot license collapse by itself.

PARTIAL OWNER-LOAD BOUNDARY: When PARTIAL / OWNER-BODY-NOT-LOADED appears, do not continue into broad refutation, Restorative Response, Closing Formulation, closure witness, or language such as "refuted" / "closed" for the blocked burden. Give only the bounded diagnostic sketch licensed by loaded owners, name the missing owner/path and next live burden, then stop. Ordinary HOLD/PARTIAL not caused by owner-load failure must still render a Burden N: node, submoves where licensed, Land(Bn): PARTIAL / ... or Land(Bn): ..., [Mid-Reread Pressure], and held-node accounting. Do not answer a named-worldview HOLD as pure prose plus a final PARTIAL / HOLD: line. Held-node accounting must include Initial burden set: [...] and Terminal states: lines using the same parseable B1: state / owner-or-pressure / detail format as a closure witness.

MRP FIELD VALUE DISCIPLINE: In the compact [Mid-Reread Pressure] block, field values are record values, not prose. Use exact first-token values: ∇·T: neutral|settled|bounded|non-neutral, ∇×T: null|resolved|held|non-null, Finding: stable|genuine-dependent|partial-real|hidden-framework-recoil|doubt-churn|reorientation, Pre-emption basis: none|graph-bound|commitment-bound|framework-bound, and Route: STOP|HOLD|RECURSE|LoopBreak(∇×T). Do not add punctuation to those values. Each pressure slot begins with an owner/TTP id, pressure class: <name>, or coverage gap: <missing owner>, then an em dash and the release/hold/clear effect. For ∇·T / ∇×T, put a slash after the state token, e.g. ∇·T: non-neutral / B2 remains live and ∇×T: null / no circular dependency; the chain is linearly traversable; this keeps the active state machine-readable. Directed downstream pressure belongs to ∇·T. Use ∇×T held/non-null only for circularity, churn, hidden-framework recoil, label-pressure, dependency rotation, or self-reinforcing loop pressure; do not claim ∇×T resolved unless a prior real curl/loop was named. Boundary: always begins T_lang does not imply guaranteed uptake; append PARTIAL/owner-load text after a semicolon. genuine-dependent requires Route: RECURSE and a graph edge; stable requires Route: STOP and Graph delta: none; partial-real requires Route: HOLD. Generated-burden instantiation is graph movement: use Finding: genuine-dependent for the generated edge, and put hidden-framework-recoil / immunity pressure in pressure activations or the MRP resultant: explanation. When a non-terminal formal_reread_states[] row records live generated/held escape-route pressure in escape_routes_checked[], every object must include type, boolean live, disposition, target_burden when it generates or releases a burden, and basis. For a generated route, write "live": true, "disposition": "generated_burden_instantiation", and the generated ASCII target such as "target_burden": "B3". Do not omit the boolean live field. The literal Route-gradient: line is required immediately before Finding: in every compact MRP block; Graph delta: or Route: is not a substitute. In default manual/public output, do not use a separate Reread: line. Render the reread as the route-bearing line R(H,Δ): held routes rechecked: ...; live remainder: ...; release/next: .... Legacy expanded fixtures may use Reread: R(H,Delta), but default runtime output must not. Landed delta: must begin with Delta or Δ and identify the burden/field change. Pressure activations: must render exactly six