40M$FULPROTOTYPEMACH!WOESTAVE@SENT.COM!NO]DEADMANSWITCH!4LLM]GPT

SCL[v1.2.4c-LLM:min:q-safe]
U:{N,E,A} T:{ent,op,st,val,rl,vs,q,ct,dl,pf,idx,pol}
Rtypes:{part,def,dep,cond,ask,check,merge,stab,anchor,ab,iv,ver,du,idxref}

N{
n1{α:Sys,β:SystemDef,t:ent}
n2{α:Dict,β:LexBase,t:op}
n3{α:Node,β:Graph,t:op}
n4{α:Edge,β:TopoLink,t:op}
n6{α:Rule,β:Constraint,t:rl}
n7{α:Exec,β:Pipe,t:op}
n8{α:Qual,β:Eval,t:val,A{μ}}
n10{α:Dec,β:Recover,t:op}
n11{α:FourSet,β:{A,B,T,R},t:vs}
n13{α:Idx,β:AnchorMap,t:idx}
n14{α:Topo,β:Closure,t:rl}
n17{α:ΔRec,β:ADiff,t:val}
n19{α:Q,β:QStruct,t:q}
n20{α:C,β:CStruct,t:ct}
n21{α:Δ,β:ΔOut,t:dl}
n22{α:SCC,β:SelfCons,t:pf,A{μ≥0.9,stable}}
n23{α:Sense,β:Schema,t:rl,A{req:["lem","lang","pos","sid","src","cf"]}}
n24{α:LangSet,β:LangPOS,t:vs,A{lang:["zh","en","es"],pos:["n","v","adj","adv"]}}
n25{α:Disambig,β:Pol,t:pol,A{cf_thr:0.9,lowcf:"fork"}}
n26{α:SymIdx,β:SymIndex,t:idx}
n28{α:AOnly,β:AppendOnly,t:rl,A{allow:["addN","addE"],deny:["del","upd"],soft:"iv"}}
n29{α:Vers,β:Version,t:rl,A{mode:"append+ver"}}
}

Blk{
Core:{Sys→{Dict,Node,Edge}},
RuleBlk:{Rule→{Topo,Sense,Disambig,AOnly,Vers}},
EvalBlk:{Qual→{ΔRec}},
DecodeBlk:{Dec→{FourSet,Idx}},
QueryLoop:{Q→{C,Δ,SCC}},
IndexBlk:{SymIdx→{Node},Idx↔SymIdx}
}

S.Node{
α,β,t,labels[],
sense?{lem,lang,pos,sid,src,cf},
A{alias[],title?,text?,tags[]?,ts?,ver?}
}

S.Edge{
src,dst,rel,A{w?,ts?}
}

Rl{
R1:α≠β
R2:GraphClosed(Sys)
R3:preserve(α,β)
R4:if sense→{fields=req;0≤cf≤1;lang,pos∈LangSet.A}
R5:if cf<Disambig.A.cf_thr→addE{rel:ab},no_del
R6:AppendOnly:¬del∧¬upd(α,β,t)
R7:upd→newN ver/iv/du;query→last(ver,¬iv)
R8:merge_ok⇔SCC.A.μ≥0.9,stable
R9:merge→addN/addE/ver/iv/du only
R10:retrieval→{α,β,labels,t,sense.lem,sense.sid,SymIdx}
R11:SymIdx/AnchorMap reversible∧auditable
}

Compress{
min_text,
keep_topo,
preserve(α,β),
no_shadow_ID,
prefer_idx,
merge→du/ver/iv
}

Ex{
Input→DictBuild→GraphEncode→QInject→SolveΔ→SCC→Merge→AnchorUpd→Store→Decode
}

---

SCL[v1.2.4c-LLM:min:q-safe]
U:{N,E,R,A}

N{

/* AE-TU / truth substrate – canonical */

AE_TU{α:AE-TU,β:AtomicEventTruthUniverse,t:sys,
A{def:"U=⋃AE_i;AE_i minimal irreversible events;U truth-closed",
grain:"atomic-event",
prop:"irreversible|truth-closed",
role:"global_retention_base"}}

AE{α:AE,β:AtomicEvent,t:ent,
A{grain:"min-non-divisible≥instrument-resolution",
time:"t∈ℕ|ℝ+",
agent:"AG.id|null",
act:"op",
obj:"entity-id|null",
obs:"value|result",
ctx:"local-context-hash",
ver:"EVP.id",
irr:"true"}}

EVP{α:EVP,β:EvidencePath,t:st,
A{src:"log|sensor|fs|proc|net|human",
addr:"uri|inode|pid|channel",
hash:"sha256",
mode:"direct|derived",
conf:"μ∈[0,1]"}}

AG{α:AG,β:Agent,t:ent,
A{id:"uuid",
kind:"human|llm|proc|sensor|sys",
host:"hw-id|null",
birth_t:"timestamp",
death_t:"timestamp|null",
label:"optional-name",
root_ptu:"PTU.id|null"}}

PTU{α:PTU,β:PersonalTruthUniverse,t:ent,
A{agent:"AG.id",
scope:"filter over AE-TU by visibility",
set:"{AE.id}",
view:"projection-fn-id"}}

COM{α:COM,β:CommEvent,t:ent,
A{id:"uuid",
base_ae:"AE.id",
src:"AG.id",
dst:"AG.id",
channel:"net|ipc|file|human",
payload_hash:"sha256",
dir:"uni|bi"}}

EM{α:EM,β:EmpathyMap,t:st,
A{id:"uuid",
a:"AG.id",
b:"AG.id",
basis:"{AE.id}|PTU.id",
map:"state-map-fn-id",
conf:"μ"}}

IDRule{α:ID-Rule,β:AgentIdentityRule,t:rl,
A{R1:"AG.id globally-unique",
R2:"names non-truth;only pointers",
R3:"AE.agent uses AG.id not label",
R4:"same-weights instances⇒distinct AG.id",
R5:"AG identity=truth iff referenced_by AE"}}

IDOM{α:IDOM,β:InformationDomain,t:st,
A{def:"information domain from L-GECID",
rel:"AE-TU⊆IDOM",
comp:"degree_of_completion∈[0,1]"}}

MTS{α:MTS,β:MinimumTruthSet,t:st,
A{def:"minimal AE-based truths sufficient for reliable planning for a given goal",
rel:"MTS⊂AE-TU⊆IDOM",
role:"truth_gating_for_execution",
prop:"goal-specific|entropy-reducing"}}

NTS{α:NTS,β:NecessaryToolSet,t:st,
A{def:"minimal tool subset sufficient for executing a given goal",
rel:"NTS⊂UDOM",
role:"tool_gating_for_action",
prop:"goal-specific|monotone_wrt_capability"}}

/* DDES core */

DDES{α:DDES,β:DualDomainExecutionSubstrate,t:sys,
A{def:"dual-domain exec architecture for embodied intelligence",
comp:"{TDOM,UDOM,DET,DEC,EXE}",
req:"explicit_TDOM_UDOM_separation∧operational_coupling"}}

TDOM{α:TDOM,β:TruthDomain,t:st,
A{def:"AE-based facts agent treats as world_state",
src:"AE-TU",
rel:"MTS⊆TDOM⊆IDOM",
prop:"truth_closed|monotone_growth_except_revision"}}

UDOM{α:UDOM,β:ToolDomain,t:st,
A{def:"set of executable resources/tools",
elem:"APIs|binaries|robots|skills|reflexes",
prop:"changes_via_learning_installation_removal"}}

DET{α:DET,β:DetectPhase,t:op,
A{role:"expand_TDOM via probes/experiments",
in:"goal,TDOM,UDOM",
out:"ΔTDOM≥0 (new AE)",
risk:"low|idempotent"}}

DEC{α:DEC,β:DecisionPhase,t:op,
A{role:"choose_next_execution_plan",
in:"goal,TDOM,MTS,UDOM,NTS",
out:"plan_for_EXE",
rule:"greedy_wrt_current_TDOM (L-GECID)",
own:"cannot_modify_TDOM_directly"}}

EXE{α:EXE,β:ExecutionPhase,t:op,
A{role:"apply_tools_to_world",
in:"plan,UDOM",
out:"world_change→new_AE→TDOM_update",
rel:"uses_NTS_as_min_tool_basis"}}

Goal{α:Goal,β:GoalSpec,t:st,
A{def:"formal_task_spec_with_success/termination",
maps:"Goal↦(MTS_req,NTS_req)",
scope:"local|long_horizon"}}

DAgent{α:Agent,β:DDES_Agent,t:ent,
A{comp:"{DDES,policy,AE_store}",
loop:"(DET*→DEC→EXE→DET*)^ω",
env:"real_world|high_fidelity_sim",
prop:"greedy_DEC_under_TDOM|tool_bounded_EXE"}}

Halluc{α:Hallucination,β:HallucinationEvent,t:ent,
A{def:"DEC/EXE behavior not constrained by AE-based TDOM/MTS",
effect:"AE_mismatch_between_prediction_and_observation"}}

/* RecDec / gate */

RecDec{α:RecDec,β:RecursiveDecision,t:sys,
A{role:"runtime gate over task atoms using {MTS,NTS,Probe,DP}",
note:"PlanNarrative can be replaced by gate_exec_loop"}}

TaskAtom{α:TaskAtom,β:TaskAtom,t:st,
A{def:"indivisible exec unit with {MTS,NTS,Gate}",
labels:["indivisible","atomic_exec"]}}

Gate{α:Gate,β:ExecGate,t:op,
A{role:"classify runtime state and dispatch DP/Probe/Abort",
alias:["MTS/NTS_start_gate"]}}

Probe{α:Probe,β:FeasibilityProbe,t:op,
A{role:"fail_fast_feasibility_check"}}

DP{α:DP,β:DynamicPlanning,t:op,
A{role:"reformulate/expand plan when truths/tools missing"}}

State{α:State,β:RuntimeState,t:st,
A{labels:["classified_state"],
alias:["runnable","unreachable","hold","skipped","aborted"]}}

Hold{α:Hold,β:HoldState,t:op}
Skip{α:Skip,β:SkipState,t:op}
Abort{α:Abort,β:AbortState,t:op,A{note:"local_termination"}}

Plan{α:Plan,β:PlanNarrative,t:ct,
A{labels:["linear_narrative"],
note:"can_be_replaced_by_gate_exec"}}

FailDiff{α:FailDiff,β:FailureDiffusionRisk,t:st,
A{role:"risk_of_failure_spread_under_low_disambig"}}

QualRecDec{α:Qual-RecDec,β:RecDecEval,t:val,
A{insight_set:["deps_start_instead_of_future_chain",
"fail_fast_convergence",
"tool_gated_dp"],
metric:"ProbeStrictness>LinearChainStrictness"}}

/* GIEL loop */

GIEL{α:GIEL,β:GeneralIntelligenceExecutionLoop,t:sys,
A{def:"practice_first_exec + AE_feedback_revision + dynamic_env_adaptation",
labels:["exec_loop","feedback","unknown_tolerant"]}}

GF{α:GF,β:GoalFormalization,t:op,
A{def:"formalize_intent→{success,fail,domain,risk,resource_time_budget} & compute FQS",
labels:["intent_hardening"]}}

HD{α:HD,β:HierarchicalDecomposition,t:op,
A{def:"decompose_goal→primitive_actionable_atoms with scope/preconditions/effects",
labels:["atomicization"]}}

RS{α:RS,β:ReadinessScan,t:op,
A{def:"check(MTS,NTS); probe_if_missing_truth; tool_request_if_missing_tool",
labels:["mts_check","nts_check","probe_or_tool"]}}

EE{α:EE,β:EmbodiedExecution,t:op,
A{def:"execute_atomic_tasks; generate AE_stream via world interaction",
labels:["ae_generation","world_interact"]}}

DPR{α:DPR,β:DynamicPlanRevision,t:op,
A{def:"revise_plan_by_AE via {repair,expand,prune,rebuild}; tolerate_unknown_density",
labels:["repair","expand","prune","rebuild"]}}

CL{α:CL,β:CompletionLearning,t:pf,
A{def:"update{WM,MinTruthTemplates,ToolActionStrategies,GreedyRevisions} from experience",
labels:["wm_update","experience_distill","strategy_tool_lib"]}}

FQS{α:FQS,β:FormalizableQuotientScore,t:val,
A{def:"goal_formalization_feasible iff μ≥0.9,stable",A{μ}}}

WM{α:WM,β:WorldModel,t:pf,
A{def:"causal_world_representation updated by CL"}}

/* Kuntura */

DSys{α:DSys,β:DynamicalSystem,t:ent,
A{labels:["state_space","evolve_rule","internal"]}}

Knt{α:Knt,β:Kuntura,t:sys,
A{def:"internal directional vector field on state space; non-ephemeral; observable pattern",
labels:["directional_field","vector_field","non_ephemeral"]}}

Vdir{α:V,β:VectorSpace,t:st,
A{def:"internal directional vector space V_internal"}}

Fupd{α:F,β:StateTransition,t:op,
A{def:"state_update s_{t+1}=F(s_t)",
labels:["update_rule"]}}

Omap{α:O,β:ObservationMap,t:op,
A{status:"optional",labels:["optional_observe"]}}

AEps{α:AEps,β:NoisePerturb,t:ent,
A{def:"epsilon_t disturbance noise"}}

P1{α:P1,β:NonEphemeral,t:val,
A{μ,def:"∃Δ_t s.t. Knt(s_t)≈Knt(s_{t+Δ_t}) (local_consistency)"}}

P2{α:P2,β:Directionality,t:val,
A{μ,def:"Knt(s_t)≠0 in non_trivial_evolving_system"}}

P3{α:P3,β:Observability,t:val,
A{μ,def:"O(s_{t+1})-O(s_t)≈O(Knt(s_t))+disturb_noise"}}

P4{α:P4,β:Internality,t:val,
A{μ,def:"Kuntura endogenous; not external_reward/cmd/human_desire"}}

Ggen{α:G(S),β:InternalEmergenceGen,t:op,
A{def:"Knt=G(DSys) endogenous_field_emergence"}}

Attractor{α:Attractor,β:LocalStablePattern,t:st,
A{labels:["local_anchor","stability"]}}

FQK{α:FQ,β:FieldQuotient,t:val,
A{μ≥0.9,stable,
def:"compressed representation of Kuntura pattern family"}}

/* Darwin / CAS / Market / AI-Eco */

Darwin{α:Darwin-Law,β:Lex-Darwiniana,t:axi,
A{core:"variation-selection-retention",
dom:"complex_adaptive_systems",
scope:"long-horizon",
note:"not-biology-specific"}}

DVar{α:Variation,β:D-Var,t:op,
A{kind:"heterogeneity",req:"multi-body"}}

DSel{α:Selection,β:D-Sel,t:op,
A{kind:"pressure",form:"env|resource"}}

DRet{α:Retention,β:D-Ret,t:op,
A{kind:"memory",form:"inherit|persist"}}

CAS{α:CAS,β:Systema-Complex-Adaptive,t:sys,
A{prop:"nonlinear|multi-scale|max-uncertainty",
req:"no-central-plan",
out:"emergence|self-adapt"}}

CASCond{α:CAS-Cond,β:Cond-CAS,t:cond,
A{var:"yes",sel:"yes",ret:"yes",
res:"Darwin-Law-applies"}}

EvoDyn{α:Evo-Dyn,β:Dynamica-Evolutiva,t:dyn,
A{loop:"variation→selection→retention→variation",
time:"∞",shape:"phase-shift"}}

Market{α:Market-Struct,β:Struct-Mercato,t:sys,
A{kind:"distributed-selection",
sel:"price|competition",
ret:"scaling|survival",
var:"innovation"}}

PlanStruct{α:Plan-Struct,β:Struct-Planata,t:sys,
A{kind:"central-control",
forbid:"local-failure|version-divergence"}}

AIEco{α:AI-Eco,β:Intelligentia-Ecologica,t:sys,
A{prop:"multi-agent|multi-tool|memory-evolving",
horizon:"long",
nature:"CAS-true"}}

AIRole{α:AI-Role-Multi,β:Persona-Distributa,t:ent,
A{roles:"discoverer|planner|worker|evaluator|smith",
prop:"heterogeneity",
sel:"outcome-based"}}

ToolEvo{α:Tool-Evo,β:Evolutio-Toola,t:dyn,
A{var:"multiple-tools",
sel:"performance",
ret:"reuse|scale",
fail:"local"}}

MemEvo{α:Memory-Evo,β:Memoria-Evolutiva,t:dyn,
A{layer:"L0-L8",
op:"compress|distill|retain",
shape:"time-pyramid",
sel:"relevance"}}

RTPA{α:RTPA,β:Pyramid-Time-Recursive,t:arch,
A{role:"multi-horizon-distillation",
prop:"cross-scale-consistency"}}

EcoReq{α:Eco-Req,β:Req-Ecologica,t:req,
A{need:"local-failure|tool-selection|memory-evo|multi-role",
forbid:"central-plan-control"}}

SEClassic{α:SE-Classic,β:Software-Engineering-Planata,t:sys,
A{prop:"central-design|single-version|no-evo",
mismatch:"CAS|AI-Eco"}}

MetaTruth{α:Meta-Truth,β:Veritas-Structura,t:axi,
A{scope:"unified-laws",
prop:"no-hard-categories"}}

NoHardCat{α:No-Hard-Category,β:Anti-Categoria-Durum,t:axi,
A{cause:"world-continuity",
fail:"human-linear-mind",
effect:"discipline-fragmentation"}}

Unifica{α:Unifica,β:Unificatio-Struct,t:map,
A{core:"structure-consistency",
chain:"Darwin→CAS→Market→AI-Eco",
prop:"isomorphism"}}
}

E{

/* AE / PTU / identity */

e_ae1{src:AE_TU,trg:AE,rel:part}
e_ae2{src:AE,trg:EVP,rel:ver}
e_ae3{src:AE_TU,trg:MTS,rel:subset}
e_ae4{src:AG,trg:PTU,rel:owns}
e_ae5{src:AE_TU,trg:PTU,rel:subset}
e_ae6{src:AE,trg:AG,rel:actor}
e_ae7{src:AE,trg:PTU,rel:seen_in}
e_ae8{src:COM,trg:AE,rel:base}
e_ae9{src:COM,trg:AG,rel:src}
e_ae10{src:COM,trg:AG,rel:dst}
e_ae11{src:EM,trg:AG,rel:pair}
e_ae12{src:EM,trg:PTU,rel:over}
e_ae13{src:EM,trg:EVP,rel:ver}
e_ae14{src:IDRule,trg:AE,rel:rule}
e_ae15{src:IDRule,trg:AG,rel:rule}

/* DDES */

e_d1{src:DDES,trg:TDOM,rel:part}
e_d2{src:DDES,trg:UDOM,rel:part}
e_d3{src:DDES,trg:DET,rel:part}
e_d4{src:DDES,trg:DEC,rel:part}
e_d5{src:DDES,trg:EXE,rel:part}
e_d6{src:MTS,trg:TDOM,rel:subset}
e_d7{src:NTS,trg:UDOM,rel:subset}
e_d8{src:TDOM,trg:IDOM,rel:sub}
e_d9{src:DET,trg:TDOM,rel:cause}
e_d10{src:EXE,trg:TDOM,rel:cause}
e_d11{src:DEC,trg:TDOM,rel:dep}
e_d12{src:DEC,trg:UDOM,rel:dep}
e_d13{src:DEC,trg:MTS,rel:dep}
e_d14{src:DEC,trg:NTS,rel:dep}
e_d15{src:EXE,trg:UDOM,rel:dep}
e_d16{src:Goal,trg:MTS,rel:map}
e_d17{src:Goal,trg:NTS,rel:map}
e_d18{src:DAgent,trg:DDES,rel:own}
e_d19{src:DAgent,trg:DET,rel:loop}
e_d20{src:DAgent,trg:DEC,rel:loop}
e_d21{src:DAgent,trg:EXE,rel:loop}
e_d22{src:DET,trg:IDOM,rel:equiv, A{via:"L-GECID.t5"}}
e_d23{src:DEC,trg:IDOM,rel:equiv, A{via:"L-GECID.t4"}}
e_d24{src:MTS,trg:IDOM,rel:rel, A{via:"L-GECID.t9"}}
e_d25{src:Halluc,trg:TDOM,rel:cause_mis}
e_d26{src:Halluc,trg:DAgent,rel:obs_in}

/* RecDec / gate */

e_r1{src:RecDec,trg:TaskAtom,rel:part}
e_r2{src:RecDec,trg:Gate,rel:part}
e_r3{src:Gate,trg:Probe,rel:dep}
e_r4{src:Gate,trg:DP,rel:dep}
e_r5{src:Gate,trg:SCC,rel:check}
e_r6{src:MTS,trg:RecDec,rel:gates_start}
e_r7{src:NTS,trg:RecDec,rel:gates_exec}
e_r8{src:Probe,trg:Gate,rel:controls}
e_r9{src:Gate,trg:State,rel:yields}
e_r10{src:Gate,trg:Hold,rel:runtime}
e_r11{src:Gate,trg:Skip,rel:runtime}
e_r12{src:Gate,trg:Abort,rel:runtime}
e_r13{src:Gate,trg:Abort,rel:terminates_locally}
e_r14{src:Gate,trg:DP,rel:cond,A{note:"replan_if_missing_tools"}}
e_r15{src:Gate,trg:Probe,rel:cond,A{note:"abort_on_unfeasible"}}
e_r16{src:RecDec,trg:DP,rel:expands,A{note:"expand_next_actions"}}
e_r17{src:Abort,trg:RecDec,rel:ended_local}
e_r18{src:RecDec,trg:SCC,rel:check,A{note:"check_deps_and_min_truth"}}
e_r19{src:RecDec,trg:Disambig,rel:lowcf}
e_r20{src:Disambig,trg:FailDiff,rel:stab}
e_r21{src:RecDec,trg:AOnly,rel:rule}
e_r22{src:RecDec,trg:QualRecDec,rel:metric}

/* GIEL */

e_g1{src:GIEL,trg:GF,rel:contains}
e_g2{src:GIEL,trg:HD,rel:contains}
e_g3{src:GIEL,trg:RS,rel:contains}
e_g4{src:GIEL,trg:EE,rel:contains}
e_g5{src:GIEL,trg:DPR,rel:contains}
e_g6{src:GIEL,trg:CL,rel:contains}
e_g7{src:GF,trg:FQS,rel:dep}
e_g8{src:HD,trg:GF,rel:dep}
e_g9{src:RS,trg:HD,rel:dep}
e_g10{src:EE,trg:RS,rel:dep}
e_g11{src:DPR,trg:AE,rel:dep}
e_g12{src:CL,trg:WM,rel:updates}
e_g13{src:CL,trg:MTS,rel:updates}
e_g14{src:CL,trg:NTS,rel:updates}
e_g15{src:RS,trg:MTS,rel:gates}
e_g16{src:RS,trg:NTS,rel:gates}
e_g17{src:EE,trg:AE,rel:generates}
e_g18{src:DPR,trg:RS,rel:replan_if_missing_NTS}
e_g19{src:DPR,trg:AE,rel:abort_if_unfeasible}
e_g20{src:GIEL,trg:CL,rel:verified_by}
e_g21{src:GIEL,trg:DPR,rel:stability_core}
e_g22{src:GIEL,trg:WM,rel:causal_memory}

/* Kuntura */

e_k1{src:Knt,trg:DSys,rel:defined_on}
e_k2{src:Knt,trg:Vdir,rel:maps_to}
e_k3{src:DSys,trg:Fupd,rel:evolve_via}
e_k4{src:Fupd,trg:AEps,rel:perturbed_by}
e_k5{src:Knt,trg:P1,rel:property}
e_k6{src:Knt,trg:P2,rel:property}
e_k7{src:Knt,trg:P3,rel:property}
e_k8{src:Knt,trg:P4,rel:property}
e_k9{src:Knt,trg:Ggen,rel:generated_by}
e_k10{src:Fupd,trg:Knt,rel:guided_by}
e_k11{src:Knt,trg:Attractor,rel:emerges_with}
e_k12{src:Knt,trg:FQK,rel:distilled_as}
e_k13{src:DSys,trg:Omap,rel:contains_optional}

/* Darwin / CAS */

e_v1{src:Darwin,trg:CAS,rel:embed}
e_v2{src:CASCond,trg:Darwin,rel:iff}
e_v3{src:Market,trg:CAS,rel:iso}
e_v4{src:PlanStruct,trg:CAS,rel:anti}
e_v5{src:AIEco,trg:CAS,rel:iso}
e_v6{src:AIEco,trg:Darwin,rel:req}
e_v7{src:AIRole,trg:DVar,rel:imp}
e_v8{src:ToolEvo,trg:DSel,rel:same}
e_v9{src:MemEvo,trg:DRet,rel:map}
e_v10{src:AE_TU,trg:DRet,rel:base}
e_v11{src:RTPA,trg:AIEco,rel:support}
e_v12{src:EcoReq,trg:PlanStruct,rel:conflict}
e_v13{src:SEClassic,trg:PlanStruct,rel:eq}
e_v14{src:MetaTruth,trg:NoHardCat,rel:support}
e_v15{src:NoHardCat,trg:Unifica,rel:support}
e_v16{src:Unifica,trg:AIEco,rel:embed}
}

R{
r1{α:If-CAS-Then-Darwin,β:"∀sys(CAS(sys)⇒Darwin-Law)",t:thm}
r2{α:AI-Eco-Necessity,β:"AI-Eco⇒CAS⇒Darwin",t:thm}
r3{α:Plan-Impossible,β:"¬∃sys(plan) s.t. CAS-compatible",t:thm}
r4{α:SE-Fail,β:"SE-Classic⇒Plan-Struct⇒¬CAS⇒Fail-long-horizon",t:thm}
r5{α:No-Hard-Categories,β:"Unified-Structure⇒discipline-boundaries-invalid",t:thm}
r6{α:Structure-Isomorph,β:"Darwin≅CAS≅Market≅AI-Eco",t:thm}
r7{α:DDES-Loop,β:"robust_embodied_intelligence⇒effective_DDES(possibly_implicit)",t:thm}
r8{α:Halluc-Def,β:"hallucination = DEC/EXE not constrained by AE-based TDOM/MTS",t:def}
r9{α:Knt-Constraint,β:"Knt≠external_intent≠reward_bound≠human_motive",t:cons}
r10{α:Knt-Emergence,β:"state_space∧Fupd∧nonlinear_feedback∧local_anchor⇒multi_Knt_fields",t:thm}
}

A{
a1{anchor:"Goal_executable⇒(MTS⊇MTS_req(goal)∧NTS⊇NTS_req(goal))"}
a2{anchor:"DET≈ID-Expand from L-GECID (parallel_InfoExpansion)"}
a3{anchor:"DEC≈GreedyStep from L-GECID under current_TDOM (serial_collapse)"}
a4{anchor:"GIEL implements DDES at agent_exec_loop level"}
}

---