Implement XIC v1.5: Symbolic Pipeline Abstraction with Glyph-Aware Transformations

Implements all phases of the symbolic pipeline extension:

**Phase 1: Symbolic Pipeline Abstraction**
- Created glyphos/symbolic_pipeline.py with:
  - SymbolicStep: tracks individual pipeline steps (name, kind, payload, context)
  - SymbolicPipelineResult: complete pipeline execution result (steps, output_text, fused_symbol)
  - run_symbolic_pipeline(prompt, context, glyph_id): high-level pipeline entrypoint
- Integrated with glyphos/__init__.py exports

**Phase 2: Glyph-Aware Transformations**
- Updated glyphos/cognitive_kernel.py:
  - run_symbolic_prompt() now thin wrapper around pipeline
  - Maintains backward compatibility
- Updated xic_ops.py operations:
  - op_RUN_PROMPT: uses pipeline in symbolic mode
  - op_STREAM: uses pipeline with line-by-line output
  - op_CALL_GLYPH: routes through pipeline with explicit glyph_id parameter
- Context propagation: glyph_id automatically injected into LAIN context

**Phase 3: XIC Instruction Semantics v1.5**
- Created XIC_SEMANTICS_v1_5.md:
  - Formal specification of all 9 XIC instructions
  - Complete semantics: preconditions, postconditions, side effects
  - Symbolic vs compressed behavior for each op
  - Context model and pipeline semantics
  - Execution paths (compressed vs symbolic)
  - Backward compatibility guarantees

**Phase 4: Demo Program & Validation**
- Created programs/demo_symbolic_pipeline.gx.json
  - Demonstrates symbolic pipeline with glyph-aware cognition
  - Uses CALL_GLYPH, RUN_PROMPT, SET_CONTEXT, CHAIN, LOG
- All 7 validation tests pass:
  ✅ Pipeline module imports
  ✅ Pipeline execution
  ✅ Glyph-aware transformations
  ✅ Demo program
  ✅ CALL_GLYPH result storage
  ✅ Backward compatibility
  ✅ run_symbolic_prompt() wrapper

**Phase 5: Final Report**
- Created XIC_SYMBOLIC_PIPELINE_REPORT.md
  - Architecture and module hierarchy
  - Integration points and data flow
  - Design decisions and rationale
  - Usage examples

Key Features:
- Step-level introspection: full SymbolicPipelineResult with step history
- Glyph-aware: explicit glyph_id routing through LAIN kernel
- Formal semantics: complete specification for tool builders
- Backward compatible: all v1 programs work unchanged
- No breaking changes: compressed execution path untouched

Constraints Met:
✅ No GPU code
✅ No XIC v2 binary container
✅ No .gx format changes
✅ Full backward compatibility

glyphos/cognitive_kernel.py

@@ -258,11 +258,9 @@ class CognitiveKernel:
 
 
 def run_symbolic_prompt(prompt: str, context: dict | None = None) -> str:
-    """Entry point for symbolic execution from XIC.
+    """Thin wrapper around the symbolic pipeline for backward compatibility.
 
-    Compresses the prompt text into GSZ3 bytes, builds a minimal manifest,
-    and routes through the full LAIN 8-lane cognition pipeline via
-    CognitiveKernel.execute_symbolic(). Returns the output_text string.
+    Routes through run_symbolic_pipeline() and returns output_text.
 
     Args:
         prompt: User or system prompt text
@@ -271,36 +269,9 @@ def run_symbolic_prompt(prompt: str, context: dict | None = None) -> str:
     Returns:
         String result from the 8-lane cognition pipeline
     """
-    from gx_compiler.compressor import GXCompressor
-
-    kernel = get_kernel()
-    prompt_bytes = prompt.encode("utf-8")
-
-    try:
-        payload = GXCompressor.compress(prompt)
-    except Exception as e:
-        return f"[Symbolic Error] Compression failed: {e}"
-
-    manifest = {
-        "source_file": "<symbolic>",
-        "source_type": "symbolic",
-        "version": "1.0.0",
-        "contributor": "XIC-symbolic",
-        "segments": [{"id": "seg_0", "start": 0, "end": 1,
-                      "start_byte": 0, "end_byte": len(prompt_bytes)}],
-    }
-    segments = [{"id": "seg_0", "start": 0, "end": 1,
-                 "start_byte": 0, "end_byte": len(prompt_bytes)}]
-
-    result = kernel.execute_symbolic(
-        manifest=manifest,
-        segments=segments,
-        payload=payload,
-        mode="symbolic",
-        context=context or {},
-    )
-
-    return result.get("output_text") or result.get("fused_symbol", {}).get("summary", prompt)
+    from .symbolic_pipeline import run_symbolic_pipeline
+    result = run_symbolic_pipeline(prompt=prompt, context=context)
+    return result.output_text
 
 
 # Global singleton kernel instance