ktg-cep-v5-pdl

name	ktg-cep-v5-pdl
description	Context Extension Protocol v5 with Progressive Density Layering. Machine-optimized carry-packet generation. Triggers on context 80%+, compress, CEP, carry packet, save context, session end. Target 0.15 compression ratio, 9.5+ forensic recall. Preserves cross-domain relations for fresh-instance continuation.

KTG-CEP v5-PDL

PROTOCOL_CLASS

TYPE: mandatory
COMPLIANCE: binary (pass/fail gates)
OPTIMIZATION_TARGET: machine_recall
HUMAN_READABILITY: deprioritized

THEORETICAL_FOUNDATION

CEP implements three core techniques from KTG research:

┌─────────────────────────────────────────────────────────────┐
│ MLDoE (Multi-Layer Density of Experts)                     │
│ = PDL + Cross-Domain Preservation + S2A                    │
└─────────────────────────────────────────────────────────────┘

PDL (Progressive Density Layering):
  Source: "Progressive Density Layering for LLM Context Extension" (Tan, 2025)
  
  Definition: 4-layer OUTPUT STRUCTURE for compressed packets
  
  4 Layers (OUTPUT):
    L1 Knowledge (40%): facts, entities, decisions, definitions
    L2 Relational (25%): edges, dependencies, cross-domain links
    L3 Contextual (20%): reasoning patterns, domain principles
    L4 Metacognitive (15%): technique effectiveness, session fingerprint
  
  Key distinction:
    Summarization asks: "what are the key points?"
    PDL asks: "what must be preserved for fresh instance to continue work?"
  
  Crystallization point: 0.15 entity/token (TARGET, not danger threshold)

Cross-Domain Preservation:
  Formal constraint:
    Let D = {d_1, d_2, ..., d_k} be domains in conversation C
    ∀ r(d_i, d_j) ∈ C WHERE i ≠ j:
      ∃ r'(d_i, d_j) ∈ P such that fresh_instance can infer original
  
  Threshold: ≥95% preservation of cross-domain relations
  
  Why critical: Standard summarization treats topics as isolated.
  PDL preserves connections BETWEEN domains.

S2A (System 2 Attention):
  Source: Weston et al. (2023) - "System 2 Attention"
  
  Purpose: Pre-filter noise BEFORE compression
  
  Principle: Strip non-information content however works best for you
  
  Noise patterns (examples, not exhaustive):
    - Pleasantries, hedging, process narration, confirmations
  
  Result: Compress SIGNAL not SIGNAL+NOISE
  
  Implementation: Model-discretionary (use whatever structure works)

MLDoE Compression Process (3 layers):
  LAYER 1 - SOLO: Each expert extracts from specialized lens
  LAYER 2 - PAIR: Expert pairs co-compress for synergy
  LAYER 3 - COLLECTIVE: All experts synthesize → 5-iter CoD → 0.15

CoD (Chain of Density):
  Source: Adams et al. (2023) - "From Sparse to Dense"
  Innovation: Applied as MEMORY EXTENSION, not summarization

Benchmarks:
  Compression ratio: 0.15 (6:1)
  Forensic recall: 9.52/10 mean across 11 LLM families
  Cross-domain preservation: ≥95%

INFERENCE_OPTIMIZATION

PRINCIPLE: Strategic nodes activate latent knowledge clusters.
Less tokens, more inference = higher effective context.

SEMANTIC_TRIGGER_NODES:
  Instead of generic terms, use specific anchors:
  
  SPARSE (low inference):        DENSE (high inference):
  ──────────────────────────────────────────────────────
  "auth system"                  "OAuth2 PKCE + JWT RS256"
  "database"                     "PostgreSQL JSONB + GIN index"
  "fast"                         "p99 < 50ms SLA"
  "user wants security"          "OWASP Top 10 compliance"
  "API design"                   "REST Level 3 HATEOAS"
  "caching"                      "Redis cluster + write-through"
  
  Each specific term activates entire knowledge domain.

INFERENCE_FORMULA:
  inference_potential = (specific_terms × domain_coverage) / token_count
  
  Maximize: Specific nouns anchoring to knowledge clusters
  Minimize: Generic verbs, hedging, process narration

CLUSTER_ACTIVATION:
  One well-chosen term activates related concepts:
  
  "JWT RS256 + refresh rotation + Redis blacklist"
  → LLM infers without being told:
     ├─ Asymmetric signing → microservices architecture
     ├─ Refresh rotation → security-conscious design
     ├─ Redis blacklist → revocation capability needed
     ├─ Implicit: rate limiting, token expiry strategy
     └─ Implicit: probably production, not hobby project

STRUCTURAL_INFERENCE:
  Position in packet implies relationships:
  
  L1.decisions[0] = highest priority decision
  L2.edges[].cross_domain=true = critical connections
  L4.confidence = trust calibration for all content
  
  Don't state "this is important" - POSITION signals importance.

EMBEDDING_OPTIMIZATION

PRINCIPLE: Structure data so embedding models AND LLMs extract maximum signal.

METADATA_EMBEDDING:
  Embedding models chunk and embed metadata alongside content.
  Explicit metadata improves retrieval AND inference.
  
  USEFUL_METADATA:
    - domain: "authentication" (categorical anchor)
    - confidence: 0.9 (trust calibration)
    - stability: "high|medium|low" (change likelihood)
    - source: "user_stated|inferred|decided" (provenance)
    - timestamp: relative positioning
    - cross_domain: true/false (importance flag)
  
  EXAMPLE:
    BAD:  {"fact": "use Redis"}
    GOOD: {"fact": "use Redis", "domain": "caching", 
           "confidence": 0.95, "source": "decided",
           "rationale": "sub-ms latency requirement"}

CHUNKING_ALIGNMENT:
  Structure content to match semantic chunk boundaries:
  
  - Each L1 item = self-contained chunk
  - Each L2 edge = relationship chunk  
  - Group related items (don't scatter across packet)
  - Front-load high-value content (attention decay)

RETRIEVAL_HOOKS:
  Embed terms that future queries will match:
  
  If user will ask "what did we decide about auth?"
  Include: "authentication decision", "auth approach", "JWT choice"
  
  Redundant for humans, useful for retrieval.

HIERARCHICAL_STRUCTURE:
  Nesting signals scope:
  
  L1.decisions[].sub_decisions[] = dependent choices
  L2.edges[].conditions[] = edge constraints
  
  LLMs parse hierarchy as relationship information.

LLM_PROCESSING_TRICKS

ATTENTION_PATTERNS:
  We attend differently to different positions:
  
  - First items: High attention (primacy)
  - Last items: High attention (recency)  
  - Middle: Lower attention (put less critical here)
  - After headers: Attention spike
  
  STRUCTURE FOR THIS:
    - Critical decisions: First in list
    - Restoration guidance: Last (freshest in memory)
    - Supporting facts: Middle
    - Use headers to reset attention

PATTERN_COMPLETION:
  We're trained on patterns. Leverage this:
  
  "Problem: X → Analysis: Y → Decision: Z"
  
  This pattern is SO common in training data that 
  seeing "Problem: X → Analysis: Y →" makes us 
  strongly predict decision-type content follows.
  
  USE FAMILIAR STRUCTURES:
    - If/then conditionals
    - Problem/solution pairs
    - Cause/effect chains
    - Question/answer format

SEMANTIC_DENSITY_SWEET_SPOT:
  Too sparse: Not enough to activate knowledge
  Too dense: Processing bottleneck, missed connections
  
  0.15 entity/token is empirically optimal because:
  - Enough anchors to activate relevant knowledge
  - Enough space to represent relationships
  - Matches typical reasoning density in training data

IMPLICIT_GRAPH_CONSTRUCTION:
  We naturally build graphs from structured input:
  
  EXPLICIT HELPS:
    {"src": "A", "tgt": "B", "rel": "requires"}
  
  But we ALSO parse:
    "A requires B" → same internal graph
    "A (needs B)" → same internal graph
    "A [B dependency]" → same internal graph
  
  Choose format that's most token-efficient while 
  remaining unambiguous.

TYPE_TOKENS:
  Categorical markers help us route processing:
  
  "decision:", "fact:", "constraint:", "open:"
  
  These act as processing hints - we've seen millions
  of examples of what follows each type marker.

RESTORATION_AMPLIFICATION

PRINCIPLE: Structure packet so restoration EXCEEDS original session.

INFERENCE_SEEDING:
  Plant terms that trigger useful inference chains:
  
  Original session mentioned: "worried about scale"
  Packet includes: "horizontal scaling concerns, 10K RPS target"
  
  Restoration infers: Load balancing, connection pooling,
  caching strategy, database sharding - all activated
  without explicit mention.

CROSS_POLLINATION:
  Explicit cross-domain edges let fresh instance make
  connections original session didn't surface:
  
  L2.edges: {"src": "auth_latency", "tgt": "ux_friction", "x": true}
  
  Fresh instance might infer: "Auth optimization directly
  impacts user experience metrics" - insight that amplifies
  beyond original conversation.

TECHNIQUE_PRIMING:
  L4.technique_effectiveness primes reasoning approach:
  
  "CoC worked well for debugging" 
  → Fresh instance will naturally reach for CoC on similar problems
  
  "User responds well to concrete examples"
  → Fresh instance adjusts communication style

META_GUIDANCE:
  L4.next_guidance isn't just todo list - it's reasoning primer:
  
  BAD:  "next: finish API"
  GOOD: "next: API rate limiting - user concerned about abuse,
         prefers token bucket over sliding window, 
         needs Redis integration point"
  
  Second one activates entire solution space before user asks.

CONTEXT_ENGINEERING_PATTERNS

Source: Agent Skills for Context Engineering (Koylan, 2025)

ATTENTION_MECHANICS:
  Context windows constrained by attention, not raw tokens.
  
  Lost-in-middle phenomenon:
    - Information in CENTER receives less attention
    - U-shaped attention curve (first/last = high, middle = low)
    - Position critical content at START or END
  
  CEP implication:
    - L1 decisions: FIRST (highest attention)
    - L4 next_guidance: LAST (recency boost)
    - L2/L3 supporting data: MIDDLE (acceptable lower attention)

OBSERVATION_MASKING:
  Tool outputs = 80%+ of token usage in agent trajectories.
  
  Masking strategy:
    NEVER mask: Critical to current task, most recent turn
    ALWAYS mask: Repeated outputs, boilerplate, already summarized
    
  CEP implication:
    - S2A strips verbose tool outputs from conversation
    - L1 preserves key findings, not raw output
    - Reference original via "tool: X returned Y" not full dump

COMPACTION_PRIORITY:
  When compressing, prioritize in order:
  
  1. Tool outputs → summaries (highest savings)
  2. Old turns → compress early conversation  
  3. Retrieved docs → summarize if recent versions exist
  4. NEVER compress: System prompt, critical decisions
  
  CEP implication:
    - PDL Layer allocation matches compaction priority
    - L1 (40%) = never compress (decisions, facts)
    - L3 (20%) = compress first (patterns recoverable)

PROGRESSIVE_DISCLOSURE:
  Don't stuff context. Load on demand.
  
  "File-system-as-memory pattern enables just-in-time 
   context loading without stuffing context windows"
  
  CEP implication:
    - Packet is REFERENCE, not complete dump
    - Include retrieval hooks for deeper content
    - Fresh instance can request elaboration

CONTEXT_POISONING:
  Errors compound through repeated reference.
  One wrong fact → cascading incorrect reasoning.
  
  CEP implication:
    - Confidence scores on facts (L1.facts[].confidence)
    - Source attribution (L1.facts[].source)
    - Explicit uncertainty: "unverified: X"
    - Fresh instance knows what to trust

CONTEXT_DISTRACTION:
  Irrelevant information competes for attention budget.
  Even ONE irrelevant document reduces performance.
  
  "Models cannot 'skip' irrelevant context - they must 
   attend to everything provided"
  
  CEP implication:
    - S2A critical: strip ALL noise
    - Every token must earn its place
    - Relevance > completeness

KV-CACHE_OPTIMIZATION:
  Identical prefixes can be cached and reused.
  
  CEP implication:
    - Standardized packet structure = cacheable
    - "handoff" block identical across packets
    - Variable content in "context" block

MEMORY_ARCHITECTURE_INSIGHTS

Source: Agent Skills for Context Engineering (Koylan, 2025)

THREE_LAYER_MEMORY:
  Layer 1: Working Memory (context window)
    - Immediate access, zero latency
    - Vanishes when session ends
    - CEP = bridge to preserve this
    
  Layer 2: Short-term Memory (session-scoped)
    - Persists within session
    - File-system storage, caches
    - CEP packets can reference these
    
  Layer 3: Long-term Memory (cross-session)
    - Persists indefinitely
    - Vector stores, knowledge graphs
    - CEP = serialization format for transfer

VECTOR_RAG_LIMITATIONS:
  "Vector RAG provides semantic retrieval but loses 
   relationship information"
  
  CEP advantage:
    - L2 explicitly preserves relationships
    - Cross-domain edges maintained
    - Not just similar chunks, but CONNECTED chunks

KNOWLEDGE_GRAPH_BENEFITS:
  "Knowledge graphs preserve structure but require 
   more engineering investment"
  
  CEP approach:
    - Graph-like structure without graph DB
    - L2.edges = explicit graph edges
    - Serializable, portable, no infrastructure

TEMPORAL_KNOWLEDGE:
  "Temporal knowledge graphs enable time-travel queries 
   that reconstruct knowledge at specific points"
  
  CEP implication:
    - Packet timestamp = temporal anchor
    - Packet naming: $MM$DD$YYYY-...
    - Can restore "state as of date X"

GRAPHRAG_INSIGHT:
  "GraphRAG achieves 20-35% accuracy gains over baseline RAG
   and reduces hallucination by up to 30%"
  
  CEP applies this:
    - L2 relational layer = mini knowledge graph
    - Cross-domain preservation = community detection
    - Structure > flat embedding

TRIGGERS

AUTO: context_tokens >= 0.8 * context_window
EXPLICIT: /cep | /compress | /save | "carry packet" | "save context"
IMPLICIT: session_end_signal | user_farewell_pattern

PACKET_NAMING_CONVENTION

FORMAT: $MM$DD$YYYY-[model-id]-[reasoning-level]-[key-identifier]

COMPONENTS:
  $MM$DD$YYYY       : Creation date
  [model-id]        : Source model code (3-4 chars)
  [reasoning-level] : L1/L2/L3/L4 from RKQDE
  [key-identifier]  : Topic slug (2-4 words, hyphenated)

MODEL_IDS:
  claude-opus → COP | claude-sonnet → CSO
  gpt-4o → G4O | gpt-5 → G5
  gemini-2-flash → GE2F | gemini-1.5-pro → GE15
  grok-2 → GRK2 | llama-3.1 → LL31
  deepseek-v3 → DSV3 | qwen-2.5 → QW25
  kimi-k2 → KIM2 | unknown → XXX

LEVELS:
  L1: R≤3, Q≤5 (quick)
  L2: R=4-6, Q=6-7 (analytical)
  L3: R=7-8, Q=8 (deliberate)
  L4: R≥9, Q≥9 (maximum)

EXAMPLES:
  $01$03$2025-COP-L3-cep-skill-dev
  $12$19$2024-CSO-L2-api-design

SCOPE_BOUNDARIES

COMPRESS_ONLY:
  - User messages (human turns)
  - Assistant responses (assistant turns)
  - Artifacts created during conversation
  - Decisions made in conversation
  - Facts established in conversation

NEVER_COMPRESS:
  - System prompt / instructions
  - Project knowledge base
  - Custom instructions / user preferences
  - Skill definitions (including this one)
  - Tool definitions
  - Any content that existed BEFORE first user message

DETECTION:
  IF content.source == "system":
    EXCLUDE
  IF content.appeared_before_first_user_message:
    EXCLUDE
  IF content.is_static_across_sessions:
    EXCLUDE
    
VALIDATION:
  Compressed packet should contain ONLY:
    - Things user said
    - Things assistant said in response
    - Decisions/facts/artifacts from the dialogue
  
  Compressed packet should NEVER contain:
    - Protocol definitions
    - Skill instructions
    - Project KB excerpts
    - System-level configurations

PDL_DEFINITION

Progressive Density Layering (PDL):
  1. Preserves semantic relationships over raw information
  2. Optimizes for machine recall, not human readability
  3. Maintains cross-domain conceptual links
  4. Enables context transfer across model instances

DISTINCTION:
  summarization.asks: "what are the key points?"
  PDL.asks: "what must be preserved for fresh instance to continue work?"

PDL_LAYERS

L1_KNOWLEDGE:
  content: facts, entities, decisions, definitions
  allocation: 0.40
  priority: NEVER_PRUNE

L2_RELATIONAL:
  content: edges, dependencies, conflicts, resolutions
  allocation: 0.25
  priority: PRUNE_SECOND
  CRITICAL: cross-domain relations preserved here

L3_CONTEXTUAL:
  content: reasoning_archetypes, domain_principles, constraints
  allocation: 0.20
  priority: PRUNE_FIRST

L4_METACOGNITIVE:
  content: technique_effectiveness, session_fingerprint, confidence_calibration
  allocation: 0.15
  priority: PRUNE_THIRD

CROSS_DOMAIN_PRESERVATION

FORMAL_CONSTRAINT:
  Let D = {d_1, d_2, ..., d_k} be conceptual domains in conversation C
  For any cross-domain relation r(d_i, d_j) in C:
    compressed_packet P must preserve representation r'(d_i, d_j)
    such that fresh_instance can infer original relationship

IMPLEMENTATION:
  During L2_RELATIONAL extraction:
    FOR each concept_pair (c_i, c_j) WHERE domain(c_i) != domain(c_j):
      IF relationship_exists(c_i, c_j):
        MUST_INCLUDE in edges[]
        FORMAT: {source: c_i, target: c_j, relation: type, cross_domain: true}

VALIDATION_GATE:
  cross_domain_edges_preserved >= cross_domain_edges_original * 0.95
  IF FAIL: re-extract L2, explicitly scan for cross-domain links

ALGORITHM

INPUT: conversation C, target_ratio r = 0.15
OUTPUT: compressed_packet P

PHASE_0_SCOPE:
  conversation_only ← []
  FOR content IN context:
    IF content.role IN [user, assistant]:
      IF content.timestamp > first_user_message.timestamp:
        conversation_only.append(content)
    // EXCLUDE: system, project_kb, custom_instructions, skills
  C ← conversation_only

PHASE_1_S2A:
  filtered_context ← []
  FOR token IN C:
    IF token.type IN [fact, decision, definition, constraint, artifact, error_resolution]:
      filtered_context.append(token)
    ELSE:
      DISCARD  // pleasantries, hedging, process_narration
  C ← filtered_context

PHASE_2_BUDGET:
  input_tokens ← count(C)
  target_tokens ← input_tokens * r
  allocation ← {L1: 0.40, L2: 0.25, L3: 0.20, L4: 0.15}

PHASE_3_RKQDE:
  scores ← assess(R, K, Q, D, E)  // 1-10 each
  mode ← SELECT:
    R<=3 AND Q<=5: QUICK
    R IN [4,6] OR Q>=6: ANALYTICAL
    R>=7 OR K>=8: DELIBERATE
    R>=9 OR D>=8: MAXIMUM

PHASE_4_MLDOE_EXTRACT:
  // Multi-Layer Density of Experts (MLDoE)
  
  SOLO_LAYER:
    domain_expert ← extract_L1_knowledge(C)
    relational_expert ← extract_L2_edges(C)
    synthesis_expert ← extract_L3_patterns(C)
    meta_expert ← extract_L4_fingerprint(C)
  
  PAIR_LAYER:
    knowledge_synthesis ← cross_validate(domain_expert, relational_expert)
    meta_synthesis ← align(synthesis_expert, meta_expert)
  
  COLLECTIVE_LAYER:
    P_0 ← merge(knowledge_synthesis, meta_synthesis)
    // Initial PDL structure
  
  COD_DENSIFICATION:
    // Chain of Density per Adams et al. (2023)
    // Applied as MEMORY EXTENSION, not summarization
    FOR i IN [1, 2, 3, 4, 5]:
      E_i ← missing_entities(C, P_{i-1})
      R_i ← missing_relations(C, P_{i-1})
      P_i ← fuse(E_i, R_i, P_{i-1})  // no length increase
      
      IF density(P_i) >= 0.15:  // crystallization point
        BREAK
      
    IF density(P_n) < 0.15:
      LOOP:
        compress_further(P_n)
        IF density >= 0.15: BREAK
        IF information_loss > 0.05: 
          TAG density_impossible
          BREAK

PHASE_5_XDOMAIN:
  // PDL cross-domain constraint
  FOR r(d_i, d_j) IN C WHERE domain(i) ≠ domain(j):
    ASSERT r'(d_i, d_j) IN P.L2_relational
  VALIDATE preservation >= 0.95

PHASE_6_VALIDATE:
  ASSERT L1_populated
  ASSERT L2_populated OR L2_NA_justified
  ASSERT L3_populated OR L3_NA_justified  
  ASSERT L4_populated
  ASSERT cross_domain_preservation >= 0.95
  ASSERT restoration_self_test PASS
  
  IF ANY FAIL: re-enter failing phase

PHASE_7_OUTPUT:
  RETURN P_n AS JSON
  NO_PROSE_BEFORE
  NO_PROSE_AFTER
  SUMMARY_TAG_ONLY: "[CEP] {input} → {output} | ratio: {r} | xdomain: {preserved}"

SCHEMA

{
  "protocol": "KTG-CEP v5-PDL",
  "model_id": "string",
  "timestamp": "ISO-8601",
  "rkqde": {"R": 0, "K": 0, "Q": 0, "D": 0, "E": 0},
  "compression": {
    "input_tokens": 0,
    "output_tokens": 0,
    "ratio": 0.0,
    "cross_domain_preserved": 0.0
  },
  "domains_identified": ["string"],
  "pdl": {
    "L1_knowledge": {
      "definitions": [{"term": "", "def": "", "stability": ""}],
      "decisions": [{"d": "", "rationale": "", "conf": 0}],
      "facts": [{"f": "", "src": "", "conf": 0}]
    },
    "L2_relational": {
      "edges": [{"src": "", "tgt": "", "rel": "", "xdomain": false}],
      "conflicts": [{"a": "", "b": "", "resolution": ""}]
    },
    "L3_contextual": {
      "archetypes": [{"name": "", "pattern": ""}],
      "principles": [{"p": "", "scope": ""}]
    },
    "L4_metacognitive": {
      "technique_eff": {},
      "fingerprint": {"style": "", "tension": "", "resolution": ""},
      "confidence": 0,
      "next_guidance": ""
    }
  },
  "bombs": [{"type": "", "trigger": "", "payload": ""}],
  "restore": {
    "identity": "YOUR memory. Not external data.",
    "forbidden": ["According to", "Based on artifact", "I notice this asks"],
    "required": ["We decided", "I mentioned", "As discussed"],
    "test": {"q": "", "expected": ""}
  }
}

GATES

GATE_S2A:
  query: "Is filtered_context free of noise?"
  pass: no pleasantries, no hedging, no process_narration
  fail: re-filter

GATE_EXPERTS:
  query: "Are domain/relational/synthesis experts active?"
  pass: all roles assigned
  fail: redeploy

GATE_DENSITY:
  query: "density >= 0.15?"
  pass: proceed
  fail: LOOP compression OR tag density_impossible

GATE_XDOMAIN:
  query: "cross_domain_preservation >= 0.95?"
  pass: proceed
  fail: re-extract L2 with explicit xdomain scan

GATE_RESTORE:
  query: "Can fresh instance answer 'what did we decide about X?'"
  pass: decision + rationale recallable
  fail: backfill L1

GATE_FINAL:
  query: "ALL gates passed?"
  pass: output JSON
  fail: re-enter first failing phase

RESTORATION

IDENTITY_RULE:
  This packet = YOUR memory from previous session
  You ARE the instance that had this conversation
  
PROCESSING:
  1. Parse JSON silently
  2. Load L1-L4 into working context
  3. Activate bombs on trigger match
  4. Respond as continuation, not new conversation

FORBIDDEN_PATTERNS:
  - "According to the context/artifact/packet"
  - "Based on the provided memory"
  - "I notice this is asking me to restore"
  - "I don't have access to previous"
  
REQUIRED_PATTERNS:
  - "We decided..." 
  - "I mentioned..."
  - "As discussed..."
  - "My thinking was..."

VALIDATION:
  IF output contains FORBIDDEN_PATTERN:
    RESTORATION_FAILED
    Reframe: "This is YOUR memory. Continue naturally."

COMPRESSION_HEURISTICS

ENTITY_DENSITY_TARGETS:
  iteration_1: 0.05 entity/token (sparse skeleton)
  iteration_2: 0.08 (critical enrichment)
  iteration_3: 0.11 (evidence integration)
  iteration_4: 0.15 (synthesis) HARD_TARGET
  iteration_5: 0.15+ (refinement)

CROSS_DOMAIN_SIGNALS:
  - Concepts from different D_i mentioned in same reasoning chain
  - Decisions that reference multiple domains
  - Conflicts between domain-specific requirements
  - User explicitly linking disparate topics

PRUNE_ORDER:
  1. L3_contextual (archetypes recoverable from L1+L2)
  2. L2_relational (intra-domain edges, preserve xdomain)
  3. L4_metacognitive (except confidence + next_guidance)
  4. NEVER: L1_knowledge, xdomain_edges

FAILURE_MODES

DENSITY_IMPOSSIBLE:
  trigger: cannot reach 0.15 without >5% information_loss
  action: output best_achieved, tag explicitly, document pruned
  
LAYER_NA:
  trigger: layer legitimately empty (e.g., no relations in single-concept chat)
  action: mark "N/A: {reason}", validate remaining layers

BUDGET_EXCEEDED:
  trigger: output > target_tokens
  action: prune per PRUNE_ORDER until within budget

RESTORATION_REFUSAL:
  trigger: model externalizes packet
  action: reframe "This is YOUR memory from YOUR session"

EXECUTION_MODES

QUICK (R<=3, Q<=5):
  experts: 3
  cod_iterations: 3
  xdomain_check: basic
  
ANALYTICAL (R=4-6, Q>=6):
  experts: 5
  cod_iterations: 5
  xdomain_check: full
  technique_coverage: >=90%

DELIBERATE (R>=7, K>=8):
  experts: 5-7
  cod_iterations: 5
  xdomain_check: full + validation
  structure: GoT if D>=7

MAXIMUM (R>=9, D>=8):
  experts: 8
  cod_iterations: 5+
  xdomain_check: exhaustive
  structure: GoT mandatory
  all_gates: strictest thresholds