From 6e0a586f519342107850757fb5788ef0b60501d6 Mon Sep 17 00:00:00 2001
From: GlyphRunner System <system@glyphrunner.local>
Date: Thu, 21 May 2026 01:27:49 -0400
Subject: [PATCH] Implement XIC v1.5: Symbolic Pipeline Abstraction with
 Glyph-Aware Transformations
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

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
---
 XIC_SEMANTICS_v1_5.md                         | 411 ++++++++++++++++++
 XIC_SYMBOLIC_PIPELINE_REPORT.md               | 381 ++++++++++++++++
 __pycache__/xic_ops.cpython-314.pyc           | Bin 10027 -> 11749 bytes
 glyphos/__init__.py                           |   9 +
 glyphos/__pycache__/__init__.cpython-314.pyc  | Bin 807 -> 949 bytes
 .../cognitive_kernel.cpython-314.pyc          | Bin 15079 -> 13975 bytes
 .../symbolic_pipeline.cpython-314.pyc         | Bin 0 -> 5163 bytes
 glyphos/cognitive_kernel.py                   |  39 +-
 glyphos/symbolic_pipeline.py                  | 127 ++++++
 programs/demo_symbolic_pipeline.gx.json       |  18 +
 xic_ops.py                                    |  75 +++-
 11 files changed, 1010 insertions(+), 50 deletions(-)
 create mode 100644 XIC_SEMANTICS_v1_5.md
 create mode 100644 XIC_SYMBOLIC_PIPELINE_REPORT.md
 create mode 100644 glyphos/__pycache__/symbolic_pipeline.cpython-314.pyc
 create mode 100644 glyphos/symbolic_pipeline.py
 create mode 100644 programs/demo_symbolic_pipeline.gx.json

diff --git a/XIC_SEMANTICS_v1_5.md b/XIC_SEMANTICS_v1_5.md
new file mode 100644
index 0000000..dc13830
--- /dev/null
+++ b/XIC_SEMANTICS_v1_5.md
@@ -0,0 +1,411 @@
+# XIC Instruction Semantics v1.5
+
+**Version**: 1.5  
+**Date**: 2026-05-21  
+**Status**: Formal Specification
+
+---
+
+## Overview
+
+XIC v1.5 is a symbolic and compressed execution virtual machine. It provides:
+
+1. **Dual execution modes**: Compressed (via execute_gx) and symbolic (via symbolic pipeline)
+2. **Explicit instruction set semantics**: Formal definitions of preconditions, postconditions, and side effects
+3. **Glyph-aware symbolic processing**: Integration with LAIN 8-lane cognition and glyph metadata
+4. **Context propagation**: Symbolic context flows through chains of operations
+
+### Architecture
+
+```
+XICContext (model_path, mode, params, context, symbolic_mode, _state)
+    ↓
+XIC Instructions (9 ops in OP_TABLE)
+    ↓
+Dual paths:
+    - Compressed: execute_gx() → decompresses .gx → execs Python
+    - Symbolic: run_symbolic_pipeline() → LAIN 8 lanes → fused_symbol
+```
+
+---
+
+## XICContext Model
+
+### Fields
+
+| Field | Type | Meaning |
+|-------|------|---------|
+| `model_path` | Optional[str] | Path to .gx model file. Set by LOAD_MODEL. |
+| `mode` | str | Execution mode: "chat", "eval", "benchmark", "symbolic". Default: "chat". |
+| `params` | Dict[str, Any] | Execution parameters (temperature, trace, profile, use_gpu, etc.). |
+| `context` | Dict[str, Any] | (In params["context"]) Symbolic/cognitive context metadata (domain, style, glyph_id, etc.). |
+| `symbolic_mode` | bool | True if mode == "symbolic". Controls routing in RUN_PROMPT/STREAM/CALL_GLYPH. |
+| `_state` | Dict[str, Any] | Internal state: last_result, last_symbolic_result, last_symbolic_pipeline, glyph_* keys. |
+
+### Context Propagation
+
+- `SET_CONTEXT <key> <value>` adds/updates keys in `ctx.params["context"]`.
+- Context is passed to `run_symbolic_pipeline(context=...)` in symbolic operations.
+- Glyph operations add `glyph_id` to context automatically.
+
+---
+
+## Instruction Semantics
+
+### 1. LOAD_MODEL
+
+**Signature**
+```json
+{ "op": "LOAD_MODEL", "args": ["<path_to_gx_file>"] }
+```
+
+**Preconditions**
+- Argument must be a valid string (path).
+
+**Postconditions**
+- `ctx.model_path = path`
+
+**Side effects**
+- Prints `[XIC] Model loaded: <path>`
+
+**Symbolic behavior**
+- No effect on `ctx.symbolic_mode`.
+
+**Compressed behavior**
+- `ctx.model_path` is used by RUN_PROMPT/STREAM to load the .gx file.
+
+---
+
+### 2. SET_MODE
+
+**Signature**
+```json
+{ "op": "SET_MODE", "args": ["<mode>"] }
+```
+
+**Preconditions**
+- `mode` ∈ {"chat", "eval", "benchmark", "symbolic", ...}
+
+**Postconditions**
+- `ctx.mode = mode`
+- If `mode == "symbolic"`: `ctx.symbolic_mode = True`
+- If `mode != "symbolic"`: `ctx.symbolic_mode = False`
+
+**Side effects**
+- Prints `[XIC] Mode set to: <mode>`
+
+**Remarks**
+- Setting mode to "symbolic" enables routing through symbolic pipeline (run_symbolic_pipeline).
+- All other modes use compressed execution (execute_gx).
+
+---
+
+### 3. SET_PARAM
+
+**Signature**
+```json
+{ "op": "SET_PARAM", "args": ["<key>", <value>] }
+```
+
+**Preconditions**
+- Arguments: key (str), value (any).
+
+**Postconditions**
+- `ctx.params[key] = value`
+
+**Side effects**
+- Prints `[XIC] Parameter <key> = <value>`
+
+**Remarks**
+- `use_gpu`, `trace`, `profile` are reserved parameter names.
+- Parameters are passed to execute_gx (if used).
+
+---
+
+### 4. SET_CONTEXT
+
+**Signature**
+```json
+{ "op": "SET_CONTEXT", "args": ["<key>", <value>] }
+```
+
+**Preconditions**
+- Arguments: key (str), value (any).
+
+**Postconditions**
+- `ctx.params["context"][key] = value`
+- If `ctx.params["context"]` doesn't exist, it is created.
+
+**Side effects**
+- Prints `[XIC] Context <key> = <value>`
+
+**Usage**
+- Build symbolic context metadata: `SET_CONTEXT "domain" "ai"`, `SET_CONTEXT "style" "analytic"`.
+- Context is passed to symbolic operations (RUN_PROMPT, STREAM, CALL_GLYPH).
+
+---
+
+### 5. RUN_PROMPT
+
+**Signature**
+```json
+{ "op": "RUN_PROMPT", "args": ["<prompt>"] }
+```
+
+**Preconditions**
+- Argument: prompt (str).
+
+**Postconditions**
+- If `ctx.symbolic_mode == True`:
+  - `ctx._state["last_symbolic_result"] = output_text`
+  - `ctx._state["last_symbolic_pipeline"] = SymbolicPipelineResult`
+- If `ctx.symbolic_mode == False`:
+  - Requires `ctx.model_path` to be set (LOAD_MODEL must be called first).
+  - `ctx._state["last_result"] = ExecutionContext`
+
+**Symbolic behavior** (ctx.symbolic_mode=True)
+- Calls `run_symbolic_pipeline(prompt, context=ctx.params.get("context"))`.
+- Routes through LAIN 8-lane cognition kernel.
+- Prints `[XIC-SYMBOLIC] <output_text>`
+- Stores full SymbolicPipelineResult for inspection (steps, fused_symbol).
+
+**Compressed behavior** (ctx.symbolic_mode=False)
+- Calls `execute_gx(ctx.model_path, trace=ctx.params.get("trace"), profile=ctx.params.get("profile"))`.
+- Decompresses .gx binary and executes Python code.
+- Prints `[XIC] Execution complete` and result.
+
+**Remarks**
+- The prompt argument is informational in compressed mode (not used).
+- In symbolic mode, the prompt is the primary input to LAIN cognition.
+
+---
+
+### 6. STREAM
+
+**Signature**
+```json
+{ "op": "STREAM", "args": ["<prompt>"] }
+```
+
+**Preconditions**
+- Argument: prompt (str).
+
+**Postconditions**
+- Same as RUN_PROMPT, but output is streamed line-by-line.
+
+**Symbolic behavior**
+- Calls `run_symbolic_pipeline(prompt, context=...)`.
+- Streams output_text line-by-line with `[XIC-STREAM]` prefix.
+- Stores pipeline result in `ctx._state["last_symbolic_pipeline"]`.
+
+**Compressed behavior**
+- Calls `execute_gx(...)`.
+- Streams result line-by-line with `[XIC-STREAM]` prefix.
+
+**Side effects**
+- Multiple print statements (one per line).
+
+---
+
+### 7. CHAIN
+
+**Signature**
+```json
+{ "op": "CHAIN", "args": ["<label>"] }
+```
+
+**Preconditions**
+- Argument: label (str).
+
+**Postconditions**
+- `ctx.params["chain_label"] = label`
+
+**Side effects**
+- Prints `[XIC-CHAIN] Entering chain: <label>`
+
+**Remarks**
+- CHAIN is a control marker for human readability and logging.
+- It does not affect execution but allows grouping operations into named chains.
+- Chain label is preserved in `ctx.params` for inspection.
+
+---
+
+### 8. CALL_GLYPH
+
+**Signature**
+```json
+{ "op": "CALL_GLYPH", "args": ["<glyph_id>", "<payload>"] }
+```
+
+**Preconditions**
+- Arguments: glyph_id (str), payload (str, optional).
+
+**Postconditions**
+- Stores result in `ctx._state[f"glyph_{glyph_id}"]` with:
+  - `output_text`: Final text from cognition
+  - `fused_symbol`: Fused symbolic representation (if produced)
+  - `steps`: List of pipeline steps taken
+
+**Symbolic behavior**
+- Calls `run_symbolic_pipeline(prompt=payload, context=glyph_context, glyph_id=glyph_id)`.
+- `glyph_context = ctx.params.get("context", {}) | {"glyph_id": glyph_id}`
+- Routes through symbolic pipeline with explicit glyph_id parameter.
+- The glyph_id is injected into LAIN context for glyph-aware transformations.
+- Prints `[XIC-GLYPH] <output_text>`
+
+**Compressed behavior**
+- Not applicable. CALL_GLYPH is only used in symbolic mode.
+- If called in compressed mode, raises error (or gracefully falls back to symbolic).
+
+**Remarks**
+- CALL_GLYPH enables glyph-aware cognition: the symbolic pipeline explicitly marks the operation as glyph-driven.
+- The LAIN kernel can use glyph_id to apply glyph-specific transformations or select glyph metadata.
+
+---
+
+### 9. LOG
+
+**Signature**
+```json
+{ "op": "LOG", "args": ["<message>"] }
+```
+
+**Preconditions**
+- Argument: message (str, optional).
+
+**Postconditions**
+- None (pure side effect).
+
+**Side effects**
+- Prints `[XIC-LOG] <message>`
+
+**Remarks**
+- LOG is a no-op from an execution standpoint; purely for instrumentation and debugging.
+
+---
+
+## Symbolic Pipeline Semantics
+
+### run_symbolic_pipeline() Entrypoint
+
+```python
+def run_symbolic_pipeline(
+    prompt: str,
+    context: Dict[str, Any] | None = None,
+    glyph_id: str | None = None,
+) -> SymbolicPipelineResult
+```
+
+**Behavior**:
+1. Creates SymbolicStep for initial_prompt.
+2. If glyph_id is provided:
+   - Adds glyph_id to context.
+   - Creates SymbolicStep for glyph_call.
+3. Compresses prompt via GXCompressor.compress().
+4. Builds minimal manifest/segments.
+5. Calls CognitiveKernel.execute_symbolic(manifest, segments, payload, mode="symbolic", context=context).
+6. Extracts output_text and fused_symbol from result.
+7. If fused_symbol is present:
+   - Creates SymbolicStep for fusion.
+8. Returns SymbolicPipelineResult(steps, output_text, fused_symbol).
+
+### SymbolicPipelineResult
+
+```python
+@dataclass
+class SymbolicPipelineResult:
+    steps: List[SymbolicStep]          # Execution steps taken
+    output_text: str                    # Final text output
+    fused_symbol: Optional[Dict]        # Fused symbolic representation
+```
+
+### SymbolicStep
+
+```python
+@dataclass
+class SymbolicStep:
+    name: str                           # Step name (e.g., "initial_prompt", "glyph:xyz", "fusion")
+    kind: str                           # Step kind ("prompt", "glyph_call", "fused_symbol")
+    payload: Any                        # Step data (prompt text, fused_symbol dict, etc.)
+    context: Dict[str, Any]            # Context at this step
+```
+
+---
+
+## Execution Paths
+
+### Compressed Path (ctx.symbolic_mode=False)
+
+```
+RUN_PROMPT or STREAM
+    ↓
+Check ctx.model_path
+    ↓
+execute_gx(path, trace=..., profile=...)
+    ↓
+Load .gx binary → decompress via GSZ3 → compile → exec Python
+    ↓
+Store result in ctx._state["last_result"]
+```
+
+### Symbolic Path (ctx.symbolic_mode=True)
+
+```
+RUN_PROMPT or STREAM or CALL_GLYPH
+    ↓
+run_symbolic_pipeline(prompt, context, glyph_id)
+    ↓
+Compress prompt → build manifest/segments
+    ↓
+CognitiveKernel.execute_symbolic()
+    ↓
+LAIN 8-lane cognition (structural, semantic, compression, metadata, hints, predictive, imprint, epoch)
+    ↓
+Fuse lanes → produce output_text and fused_symbol
+    ↓
+Store SymbolicPipelineResult in ctx._state["last_symbolic_pipeline"]
+```
+
+---
+
+## Context Flow
+
+**Example: Glyph-Aware Cognition**
+
+```
+SET_CONTEXT "domain" "ai"
+SET_CONTEXT "style" "analytical"
+CALL_GLYPH "glyph://knowledge_integration" "How do compression and knowledge integrate?"
+```
+
+**Flow**:
+1. SET_CONTEXT adds `context = {"domain": "ai", "style": "analytical"}` to `ctx.params["context"]`.
+2. CALL_GLYPH reads `context` and adds `glyph_id = "glyph://knowledge_integration"`.
+3. `run_symbolic_pipeline(prompt, context={"domain": "ai", "style": "analytical", "glyph_id": "..."}, glyph_id="...")` is called.
+4. Symbolic pipeline creates SymbolicStep(glyph_call, ...) with the full context.
+5. LAIN kernel executes with context, allowing glyph-aware transformations.
+6. Result (output_text, fused_symbol) is stored in `ctx._state["glyph_glyph://knowledge_integration"]`.
+
+---
+
+## Backward Compatibility
+
+- All v1 XIC programs continue to work unchanged.
+- RUN_PROMPT behavior in compressed mode (symbolic_mode=False) is identical to v1.
+- New symbolic pipeline is additive and does not affect compressed execution.
+- run_symbolic_prompt() in glyphos/cognitive_kernel.py is a thin wrapper around the pipeline.
+
+---
+
+## Summary of Changes from v1
+
+| Change | v1 | v1.5 |
+|--------|----|----|
+| Symbolic pipeline abstraction | Inline in run_symbolic_prompt | Separate glyphos/symbolic_pipeline.py |
+| Glyph-aware transformations | Manual context manipulation | Explicit glyph_id parameter in run_symbolic_pipeline |
+| Pipeline introspection | Limited (just output_text) | Full SymbolicPipelineResult (steps, fused_symbol) |
+| Formal semantics | Implicit (docstrings) | Explicit (XIC_SEMANTICS_v1_5.md) |
+
+---
+
+**End of Specification**
diff --git a/XIC_SYMBOLIC_PIPELINE_REPORT.md b/XIC_SYMBOLIC_PIPELINE_REPORT.md
new file mode 100644
index 0000000..f5caed0
--- /dev/null
+++ b/XIC_SYMBOLIC_PIPELINE_REPORT.md
@@ -0,0 +1,381 @@
+# XIC v1.5 Symbolic Pipeline Extension Report
+
+**Date**: 2026-05-21  
+**Status**: ✅ Complete and validated  
+**Scope**: Symbolic pipeline abstraction + glyph-aware transformations + formal semantics
+
+---
+
+## Executive Summary
+
+Extended XIC v1 to v1.5 with:
+
+1. **Symbolic Pipeline Abstraction** (`glyphos/symbolic_pipeline.py`)
+   - Explicit pipeline with step tracking
+   - Data structures: SymbolicStep, SymbolicPipelineResult
+   - Function: `run_symbolic_pipeline(prompt, context, glyph_id)`
+
+2. **Glyph-Aware Transformations**
+   - CALL_GLYPH now routes through pipeline with explicit glyph_id
+   - Context includes glyph metadata for LAIN kernel
+   - Fused symbols captured in results
+
+3. **Formal Semantics Specification** (`XIC_SEMANTICS_v1_5.md`)
+   - Complete instruction semantics for all 9 ops
+   - Preconditions, postconditions, side effects
+   - Context model and pipeline flow
+   - Backward compatibility guarantees
+
+**Zero breaking changes**. All XIC v1 programs work unchanged.
+
+---
+
+## Phase 1: Symbolic Pipeline Abstraction
+
+### File: `glyphos/symbolic_pipeline.py`
+
+#### Data Structures
+
+```python
+@dataclass
+class SymbolicStep:
+    name: str                        # e.g., "initial_prompt", "glyph:xyz", "fusion"
+    kind: str                        # "prompt", "glyph_call", "fused_symbol"
+    payload: Any                     # Step data
+    context: Dict[str, Any]          # Context at this step
+
+@dataclass
+class SymbolicPipelineResult:
+    steps: List[SymbolicStep]        # Execution steps taken
+    output_text: str                 # Final text output
+    fused_symbol: Optional[Dict]     # Fused symbolic representation
+```
+
+#### Core Function
+
+```python
+def run_symbolic_pipeline(
+    prompt: str,
+    context: Optional[Dict[str, Any]] = None,
+    glyph_id: Optional[str] = None,
+) -> SymbolicPipelineResult
+```
+
+**Behavior**:
+1. Creates SymbolicStep for initial_prompt
+2. If glyph_id: adds glyph_id to context, creates glyph_call step
+3. Compresses prompt → GSZ3
+4. Builds minimal manifest/segments
+5. Calls `CognitiveKernel.execute_symbolic(manifest, segments, payload, mode="symbolic", context=...)`
+6. Extracts output_text and fused_symbol
+7. If fused_symbol: creates fusion step
+8. Returns SymbolicPipelineResult
+
+**Integration with Cognitive Kernel**:
+- Uses existing `CognitiveKernel.execute_symbolic()` API
+- Wraps it with step tracking and glyph-aware routing
+- No circular imports (lazy import in glyphos/cognitive_kernel.py)
+
+---
+
+## Phase 2: Glyph-Aware Transformations
+
+### Integration Points
+
+#### 1. RUN_PROMPT
+
+```python
+def op_RUN_PROMPT(ctx, *args):
+    if ctx.symbolic_mode:
+        pipeline_result = run_symbolic_pipeline(
+            prompt=prompt,
+            context=ctx.params.get("context")
+        )
+        ctx._state["last_symbolic_pipeline"] = pipeline_result
+```
+
+**Stores**:
+- `last_symbolic_result`: output_text string
+- `last_symbolic_pipeline`: full SymbolicPipelineResult
+
+#### 2. STREAM
+
+Same routing as RUN_PROMPT, but streams output line-by-line.
+
+#### 3. CALL_GLYPH
+
+```python
+def op_CALL_GLYPH(ctx, *args):
+    glyph_id = str(args[0])
+    payload = str(args[1]) if len(args) > 1 else ""
+    
+    glyph_context = dict(ctx.params.get("context", {}))
+    glyph_context["glyph_id"] = glyph_id
+    
+    pipeline_result = run_symbolic_pipeline(
+        prompt=payload,
+        context=glyph_context,
+        glyph_id=glyph_id,
+    )
+    
+    ctx._state[f"glyph_{glyph_id}"] = {
+        "output_text": pipeline_result.output_text,
+        "fused_symbol": pipeline_result.fused_symbol,
+        "steps": [step metadata...]
+    }
+```
+
+**Stores**:
+- Key: `glyph_{glyph_id}`
+- Value: Dict with output_text, fused_symbol, steps
+
+### Context Propagation
+
+```
+SET_CONTEXT "domain" "glyph_cognition"
+SET_CONTEXT "style" "analytic"
+CALL_GLYPH "glyph://compression" "prompt..."
+    ↓
+context = {"domain": "glyph_cognition", "style": "analytic", "glyph_id": "glyph://compression"}
+    ↓
+run_symbolic_pipeline(prompt, context, glyph_id)
+    ↓
+LAIN kernel processes with glyph-aware context
+```
+
+---
+
+## Phase 3: XIC Instruction Semantics v1.5
+
+### File: `XIC_SEMANTICS_v1_5.md`
+
+Comprehensive formal specification covering:
+
+1. **Overview**: Dual execution modes (compressed/symbolic), architecture
+2. **XICContext model**: Field definitions, context propagation
+3. **Instruction semantics**: All 9 ops with:
+   - Signature (JSON form)
+   - Preconditions
+   - Postconditions
+   - Side effects
+   - Symbolic vs compressed behavior
+4. **Symbolic pipeline semantics**: run_symbolic_pipeline, SymbolicPipelineResult, SymbolicStep
+5. **Execution paths**: Compressed and symbolic flowcharts
+6. **Context flow**: Example of glyph-aware cognition
+7. **Backward compatibility**: v1 → v1.5 changes
+
+### Key Changes from v1
+
+| Aspect | v1 | v1.5 |
+|--------|----|----|
+| Pipeline implementation | Inline in run_symbolic_prompt | Separate glyphos/symbolic_pipeline.py |
+| Glyph support | Manual context manipulation | Explicit glyph_id parameter |
+| Step tracking | None | Full SymbolicStep list |
+| Result structure | String only | SymbolicPipelineResult (steps + fused_symbol) |
+| Formal spec | Docstrings | XIC_SEMANTICS_v1_5.md |
+
+---
+
+## Phase 4: Demo Program and Validation
+
+### Demo Program: `programs/demo_symbolic_pipeline.gx.json`
+
+```json
+{
+  "instructions": [
+    { "op": "SET_MODE", "args": ["symbolic"] },
+    { "op": "SET_CONTEXT", "args": ["domain", "glyph_cognition"] },
+    { "op": "SET_CONTEXT", "args": ["style", "analytic"] },
+    { "op": "CHAIN", "args": ["glyph_analysis"] },
+    { "op": "LOG", "args": ["Starting glyph-aware symbolic pipeline"] },
+    { "op": "CALL_GLYPH", "args": ["glyph://compression", "..."] },
+    { "op": "RUN_PROMPT", "args": ["..."] }
+  ]
+}
+```
+
+### Validation Results (7/7 Tests Passed)
+
+✅ Symbolic pipeline module imports  
+✅ run_symbolic_pipeline() execution  
+✅ Glyph-aware pipeline (glyph_id parameter)  
+✅ Demo symbolic pipeline program  
+✅ CALL_GLYPH result storage (output_text, fused_symbol, steps)  
+✅ Backward compatibility (demo_chat.gx.json)  
+✅ run_symbolic_prompt() wrapper works  
+
+---
+
+## Architecture
+
+### Module Hierarchy
+
+```
+glyphos/
+  ├── cognitive_kernel.py      (CognitiveKernel, get_kernel, run_symbolic_prompt wrapper)
+  ├── symbolic_pipeline.py      (SymbolicStep, SymbolicPipelineResult, run_symbolic_pipeline)
+  ├── events.py               (EventBus, emit, on)
+  └── __init__.py             (exports all)
+
+xic_ops.py
+  └── Uses: run_symbolic_pipeline (lazy import inside ops)
+       └── RUN_PROMPT, STREAM, CALL_GLYPH route through pipeline
+```
+
+### Data Flow (Symbolic Mode)
+
+```
+XIC Program
+    ↓
+RUN_PROMPT / STREAM / CALL_GLYPH
+    ↓
+run_symbolic_pipeline(prompt, context, glyph_id)
+    ↓
+[Step 1] Initial prompt
+[Step 2] Glyph call (if glyph_id present)
+[Step 3] Compress + build manifest
+[Step 4] CognitiveKernel.execute_symbolic()
+[Step 5] LAIN 8-lane cognition
+[Step 6] Fusion step (if fused_symbol present)
+    ↓
+SymbolicPipelineResult
+    ├── steps: [...SymbolicStep...]
+    ├── output_text: str
+    └── fused_symbol: Dict | None
+    ↓
+Store in ctx._state
+```
+
+---
+
+## Backward Compatibility
+
+✅ **XIC v1 programs work unchanged**:
+- demo_chat.gx.json executes identically
+- execute_gx() behavior preserved
+- Compressed mode execution path unchanged
+
+✅ **run_symbolic_prompt() thin wrapper**:
+- Existing code importing run_symbolic_prompt() still works
+- Now routes through pipeline (transparent upgrade)
+
+✅ **No binary format changes**:
+- .gx files unchanged
+- JSON manifest format unchanged
+- GXIC1 magic and version unchanged
+
+---
+
+## Files Modified or Created
+
+### Created
+
+| File | Purpose |
+|------|---------|
+| glyphos/symbolic_pipeline.py | Symbolic pipeline abstraction |
+| XIC_SEMANTICS_v1_5.md | Formal instruction semantics spec |
+| programs/demo_symbolic_pipeline.gx.json | Demo of glyph-aware pipeline |
+
+### Modified
+
+| File | Changes |
+|------|---------|
+| glyphos/__init__.py | +export SymbolicStep, SymbolicPipelineResult, run_symbolic_pipeline |
+| glyphos/cognitive_kernel.py | run_symbolic_prompt() → thin wrapper around pipeline |
+| xic_ops.py | op_RUN_PROMPT, op_STREAM, op_CALL_GLYPH → use pipeline |
+
+### Unchanged (Backward Compatibility)
+
+- xic_loader.py
+- xic_vm.py
+- xic_executor.py
+- runtime_executor/runner.py
+- All .gx binary files
+
+---
+
+## Key Design Decisions
+
+### 1. Separate Pipeline Module (symbolic_pipeline.py)
+
+**Rationale**: Makes pipeline structure explicit and testable. Enables step tracking without modifying core kernel.
+
+### 2. SymbolicPipelineResult with Steps
+
+**Rationale**: Supports introspection, debugging, and future enhancements (e.g., step replay, conditional routing).
+
+### 3. Explicit glyph_id Parameter
+
+**Rationale**: Makes glyph-aware cognition intentional and traceable. Simplifies context propagation.
+
+### 4. Formal Semantics Specification
+
+**Rationale**: Documents contract clearly for tool builders, enables static analysis, serves as implementation guide.
+
+---
+
+## Usage Examples
+
+### Example 1: Symbolic Mode with Context
+
+```bash
+glyph --xic -c "
+SET_MODE symbolic
+SET_CONTEXT domain compression_theory
+SET_CONTEXT style analytical
+RUN_PROMPT 'Explain lossy compression as a glyph.'
+"
+```
+
+### Example 2: Glyph-Aware Cognition
+
+```bash
+glyph --xic programs/demo_symbolic_pipeline.gx.json
+```
+
+Results in:
+- `ctx._state["glyph_glyph://compression"]` with output_text, fused_symbol, steps
+- Full execution trace via SymbolicPipelineResult
+
+---
+
+## Testing
+
+All validation tests pass:
+
+```
+[TEST 1] Symbolic pipeline module imports ✅
+[TEST 2] run_symbolic_pipeline() execution ✅
+[TEST 3] Glyph-aware pipeline (glyph_id parameter) ✅
+[TEST 4] Demo symbolic pipeline program ✅
+[TEST 5] CALL_GLYPH result storage ✅
+[TEST 6] Backward compatibility ✅
+[TEST 7] run_symbolic_prompt() wrapper ✅
+```
+
+---
+
+## References
+
+- **Formal Specification**: See `XIC_SEMANTICS_v1_5.md` for complete instruction semantics
+- **Previous Reports**: `XIC_SYMBOLIC_EXTENSION_REPORT.md` documents symbolic mode v1
+- **Cognitive Kernel**: `glyphos/cognitive_kernel.py` (CognitiveKernel.execute_symbolic API)
+
+---
+
+## Summary
+
+XIC v1.5 extends the v1 engine with:
+- Explicit symbolic pipeline abstraction
+- Glyph-aware transformations with context propagation
+- Formal instruction semantics specification
+- Full backward compatibility
+
+**No breaking changes**. All XIC v1 programs continue to work unchanged.
+
+---
+
+**Implementation Complete** ✅  
+**All tests passing** ✅  
+**Backward compatible** ✅  
+**Formal semantics documented** ✅
diff --git a/__pycache__/xic_ops.cpython-314.pyc b/__pycache__/xic_ops.cpython-314.pyc
index d7a98db6a51cf631936e07d7adfe3845117faf57..16d2a01eb359cd5fabba38d669162f2b882b0a15 100644
GIT binary patch
delta 3706
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

delta 1934
zcmZ{kO>7fK6vt;{d%bqNySCRKF?Qlj(wNw>O#^|bG=xABJ5GZMR&ZM4<^#vYCLgxO
zP9YW*;ZPAy&^}ahKvmjHRk)N=l|wI8l|&p<5vh=Jsnn|C(w0`Jm3ryS+75v#Bkh0x
zJNstl?Y^JhFC(|3LW{ub5g8{x63$++-4R9%d=n!)MMSO_$ql}-)>eI81txbCnr&`-
z7$FxLMX{=gs!yF$xlvqIkA`I!w;hI4Ja0Cjy;W@t-4P)-8txi2LMtzEtcN_uw2kmF
zZ--7B2VdAtB3B7aGftGS!VSI-ezUh|bTNHf6|@Sik!tFcy->{1t}3~lCLxv_*^;m9
z;YQnLg@nBl5!b}Tm=S&w9E_3*Zz`vPWR$1@r&#MW53w(%ohGT~*u!jw0f)FxD*Ft2
zT~&)RjMq~90d9&X;*odcWZ`@;KR<IiJDo|6&15H2awabi;klGw#@V?-DlZq(#GFaX
zXQt<K>1=*aGJ9q=Q^>rV8k<Vt+0=9}Hy_j=FQilWTqaMK!SB1Q&}VYO2PU6e!gI4@
zTL<KDb|zQY)F!jDh1B`N=M4O8@<X%v5Zg^Y7x%!Fx#$yc3w^Lsu@Kp;DIXnt`Dido
z7Vx-4=#rYun`~)!+({RPh`@r>Zi*4(Cs)3S6m<dpZGiidudVBm>6PX9y;FBi-5b3#
z`fcRF{^*A3_#*q5<FAR!?9%ylp?QPzJ`C);s=uONm%QI|J{YO3gS6$A?>pC#&K?(9
zaaH%$s8)81JqJ`P2Molosu-$ju~$;9N}App=&+`C4bjsjBII<6Wr@v$6*d=DTWl`u
z$Y#I3g2|vrd4wNr7RCgB*aD0Mb@m1|0o6iZRBIJFxJDF5V02h2tb$$;7zae{3ZZaX
z7;v(QGLHx)oFqME#Mzh-6Jepo%It8^c<G>CW91-%p{uf-MU$j%E|lXE^ox}dGYxV7
z!;{N#hdF}hs}5`H^GNf~kz4Re#Sh`G<6t~8D_6LZDY$+)U%;t}ndh@Om7kj~1Z5JL
zB;1k5d}{K=*lqKK_S{?n&N{;<kC42h_$X0KxeVbRYI~_rt}y8#2=`HmQ0XV)HNHeG
zeuKVJSTs{N07jR`bBtOYl_(Lf4mVRDpmLl_iCsvz8kiGs(bZrYA+riVQzd-$@TJS=
z-VtAG&5{j9V6}FSA=vf;x=;34kLp4iwAv^WUDH&D8P%Fm47pWnZUgmxhH5|zb*R=l
zG+~Ca%UrnosO|=%87Em>fI0d0Ywr`c1+#$(JViukqa`;?F-Vd;w+2g`79sUtAx44x
zv-(^9;r%hTz1$OXY{FCtj%njBb+O@b_=LAgT)c|nqu{1%L|%O{3^yB_-Q{kOot4jJ
z3Tb(w)S*bJmEIDB(WXNeaTnRXXc&1j(j5p7yfxVOw!FzI?PM(K)o&}=0TQ>ZWDWGO
zR5$8q1HlwiuXbC-CdtI6Ha9Upot>CeO1H_E_Acju+bJ%2@&}N|C)0r)bPb=)jddRx
z7#LGh!f7(6{MXCGETCVjMfl3o#&p0FPrd&UFE86S_^yS}W3_H^V9B<`t?TPI)C~_k
z{>%NB`md3RYsGc3;eomlF6lDN^}Dsr|1kO~ve$KT<+HF{ZG|@98nX=l`tCDHSZN7s
zvgFk=82x|lq74#L%<woBnhd6kaTZ*G-TL>4r6tW@g=2wE8|h!q2APtw%-&~aQuk+d
I@M)m?KY_Hr)&Kwi

diff --git a/glyphos/__init__.py b/glyphos/__init__.py
index d7e9552..4efaa76 100644
--- a/glyphos/__init__.py
+++ b/glyphos/__init__.py
@@ -14,6 +14,12 @@ from .cognitive_kernel import (
     kernel_status,
 )
 
+from .symbolic_pipeline import (
+    SymbolicStep,
+    SymbolicPipelineResult,
+    run_symbolic_pipeline,
+)
+
 from .events import (
     EventBus,
     Event,
@@ -29,6 +35,9 @@ __all__ = [
     "run_gx",
     "run_symbolic_prompt",
     "kernel_status",
+    "SymbolicStep",
+    "SymbolicPipelineResult",
+    "run_symbolic_pipeline",
     "EventBus",
     "Event",
     "EventType",
diff --git a/glyphos/__pycache__/__init__.cpython-314.pyc b/glyphos/__pycache__/__init__.cpython-314.pyc
index c73626600298557b9bba53cf44de18a662f98eda..464e746aeada9201a7816f4cc0bdf3e1c92cd926 100644
GIT binary patch
delta 318
zcmZ3^ww0Yvn~#@^0SJ7i^JVogPvnzeOq!@}ZXnMP#~8%y$?d^Y!sEeP!t23T!so$X
z!tWtaBH$rdA}G(G#}LHo&sZW9#G=fg$+od7mC=s*7Ef?xZc=_uW^!;zYQZfr7%w2R
zAT=j5FEuE&xHPBamS|CFUVJfBWqbita`HV!OGduQIZTq14VmNwi+F*qD&hkX{6Ioe
zcyb_<sf!?nwjy?r5)Kf-2_$Z@rIw}Ul@u3&d{x8^B6vUql4+AyFnKsi00kL=xL6-Z
zd|+l|Wc<j)#>nzrfQ^yqD+7@DF2KUb^pOEbeCJ^Y5)44%lMp{QQxkiU7*G!Yq)JRL

delta 156
zcmdnWzMPFun~#@^0SLOL@?~9Mn#d=?=r>W_T*iaDgxiCsgvW!ogjb$Hk0FS~pRt55
zh*_CIlXYWXD&u4$CJRRH$>*3PC$})kF=_Ho-ppjG#Fko?npaX>#11sDhyz4$f(VcW
sMcg2QXR;2n2bTzt$q2;7s*~%OB}Ld7nZ7dsiBCd2+)PdEMM6L+0OtZ7%m4rY

diff --git a/glyphos/__pycache__/cognitive_kernel.cpython-314.pyc b/glyphos/__pycache__/cognitive_kernel.cpython-314.pyc
index 9205b5e2e080284d2123cbb4991fe89b6e4f7446..efcadc4ff75899f8c1698dcada8437aacd0a2162 100644
GIT binary patch
delta 705
zcmZuvL1@!p6#oAvmD1Yigu#l&MXA-)Sv#k69Wtcq(2GbN^R|+<X`3}o!b@ViftZ2b
zL@E(?(TjN4LB-MCyn6DY6GhjXC$Ccxuf9LsP|*MIz4yQOzAxYV$yax!B^(#xQG#c7
zMOYB!HQ~ik{Rmz?@{0)c;5P<Oxh)o+RbS3NZwBe>Ye56{<76eo=-VfZkt2lvF^P#s
z=4p{$CYPuc8YOd~L*zOwhH~5U7B|OT<^8t@hHr67nxcb-W=L&NEK3DR0n;_AlG9Kn
zd$CnEb*&;<nx*QRp-MFqq_R?JwiT#K6|-e2j#k!m%~{MuqeatoR2!M7P;W@!8l@eD
z(vHG0SyE6PRL2Fw-Yp@;a-EW+b{zjrdbKwEUzQw#Hm(Jy5M-`D^p7koVW%JaOHJng
zP=YR8#1WfENTvKeC&ZICG39Z4Tg1d8KSxM7zZpNgn)(ngcr%}4L!V;eMofIii@|IA
zOPLx?^uA>7(tZ7CU3E%L6%18}Wuzy1ootfQvEJkHO*+jgFoS?5&agbofSK>_8juD)
zl1T|hf-2j(-hn%K8S~dB)@h+vJDuj}vVT7()7$>5-1+c5Y!-UlWRz0R7xMGTg$SYJ
z?@9JS<k9HIz48Xhes4y2$_I93dPNqY>v!`{F0f6(V-PrFUje2D2?Uu!7lVy2LCy{A
fM9#L%s;jHh@DPivVb}c|Q@Jqyi(5&5eQM%24%5Bw

delta 1772
zcmaJ?U2Gdg5Z<+Y=YQ9Be%!w_r`B!kG;!QGO-s@rQa4Fcsw!NqP(c#QvCr;N`|i4T
zZWF7*k$7nZ6-EcN5=f+gM34#?r63+FwGVwvu&S7QLqg)!&>|4LuzU7}iU(Gwnc10d
zzMY*N>24Q(DS8fi+zx=(o9}yG|E}*F&sRO=Uc6lfe}IE<9{#G!&&&;7-^)}JUtVt7
zk1jN0Xcva3O@yPhI<PhaV0roo5~6v)!YObDN~UfwOBtY{mLZvEz_iuy60JUn(q+~(
zgp<jVEW5yrY1-c0Juhd#7KUOemS(N2jkU85*2%h9H|t@yv0i+*ZyvIKtlMVYMs~tt
zWDZafI6z6(|Dccm4_vY(%+uQps(*FDny@7()|P;(<ZAb_?MGUdmFx-ov`_tMPg{3~
zaqcMWX=Ud20k9i%0|Vpk8~{VDb~dxhfy9<)A7H?&{$M1X1{p8OmT1<Tpj}|lR5Wz~
z)*{g->3uEDLmrHpy8sWv+fyInrj82=T4E%T7ZfHdB1T>+EQonN&2Wocx~TA?z+{nF
zU@lI@BMwJgER-e0$ucK1$|a7Ga7a=Zg<Dh@%pfw87ha7q3rh+o_c04aKA(}96jR^@
zzL3f@g_OW&Ia%p*q=XEE#3F`a8f@e)>2%p*KF^#Rn>x=N?a!wKj!BC-f!B+Wc!|sN
z*k!rOryT0t0JAp~jxa2z6p_#@2J=ZpC8-x9D~K0z>f_LA*)@3)m#tSVq7qe9vi(O(
z`(L|YTyz{E5zR3MM!#{2&vTg(=Dg;V#Ue^`$t-r19LJ3AoY)E|OA@Eq48LZ*${`t3
zl&C|IXe6pR(`6BNm|rL=_;45QV!we!XYre9CO)H4GM7t6u~Je<(afBX(Hy#+B%Rc3
z*r8it3Qgf0JrTV`tSAwKgva^Z?a?T4pTr_;*UFu_#bg>c0N(&bh(X>@M5sj4963%&
zUgnU%<u#fU(qaamXMi;O_+pxqNdGl+o)gf^gf~uj9q1ad$<a+Bx<%q@j)Y#XOo}W6
z4RX)bJ&sdkGP4H`Fs+5Q<E_?)ibB$8PO?dZDmY@nV=8xJu?&9S4XB}?-GR4emnZ6N
zJ8mC;_xMVn))rnq*RYtW(Yk-nroU&y-?K{B`~x?v4F|B7J1f`gwvI}vZu3=+5bKS)
z&0opfnOu2gHC65S9@abeu8gge?#HUvYq8S}Gwhsz4FEePVZ&+l(#vNWUf}PnTwAfO
z`c}uQhw8qrJ6BeE@1?7Kwa7_~_l*&}_Y}lX8hF|_-N6lau<qMIzOpw^cL(a;z-@QM
zeP^)Y1fKm*0qvoeCor$e|IWzGkxHTF3~oB-)}3>!^w*9r9MuyK25X^-&CuD6(Amc?
ztk2BWLUZeuxj&!v16Rj00P$UY!__O*^!m1uC$^ElaTV0)Uvd|2*QdTX1s+n)c(?hX
z*An;aG(T*IWV4gPQr+8|g~Mw%d*6mmbOXb6F}&8(7ld$X?Ogwla8!3s;8@s#4im`M
zn4w#ED_gKQ5DYTSccaO><rdKg*gK`B2kyh<+V*I#8QxIiu`s-)7GiPgV;oGbeH(K?
zsHzW!=7SkKfQNnn(f4d0bwBZjH$e0^&TfGg{Ra|;=fhp-u6pY5C#T5-Ae9KcEOH7W
wY-k4-VTkTxCF9`$FE-1u9V>{LVxBvJKF3ZHka;yUe8ftAV2ydGW`<+`0IpHj5dZ)H

diff --git a/glyphos/__pycache__/symbolic_pipeline.cpython-314.pyc b/glyphos/__pycache__/symbolic_pipeline.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1e1c86ed55e9892987b0f3f2c74e1495548b4851
GIT binary patch
literal 5163
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

literal 0
HcmV?d00001

diff --git a/glyphos/cognitive_kernel.py b/glyphos/cognitive_kernel.py
index c953a90..1e31f70 100644
--- a/glyphos/cognitive_kernel.py
+++ b/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
diff --git a/glyphos/symbolic_pipeline.py b/glyphos/symbolic_pipeline.py
new file mode 100644
index 0000000..e5c4c23
--- /dev/null
+++ b/glyphos/symbolic_pipeline.py
@@ -0,0 +1,127 @@
+"""Symbolic Pipeline Abstraction for XIC.
+
+Provides a structured, glyph-aware pipeline for symbolic cognition execution.
+Routes prompts through the LAIN 8-lane cognition kernel with explicit step tracking.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class SymbolicStep:
+    """A single step in the symbolic pipeline execution."""
+    name: str
+    kind: str  # "prompt", "glyph_call", "fused_symbol"
+    payload: Any
+    context: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class SymbolicPipelineResult:
+    """Result of a symbolic pipeline execution."""
+    steps: List[SymbolicStep]
+    output_text: str
+    fused_symbol: Optional[Dict[str, Any]] = None
+
+
+def run_symbolic_pipeline(
+    prompt: str,
+    context: Optional[Dict[str, Any]] = None,
+    glyph_id: Optional[str] = None,
+) -> SymbolicPipelineResult:
+    """
+    High-level symbolic pipeline entrypoint for XIC.
+
+    Accepts a prompt and optional symbolic/glyph context, routes through
+    the LAIN 8-lane cognition kernel via CognitiveKernel.execute_symbolic(),
+    and returns a structured SymbolicPipelineResult with execution steps,
+    final output text, and fused symbolic representation.
+
+    Args:
+        prompt: User or system prompt text.
+        context: Optional dict of symbolic/cognitive context metadata.
+        glyph_id: Optional glyph identifier for glyph-aware cognition.
+
+    Returns:
+        SymbolicPipelineResult with:
+        - steps: List of SymbolicStep objects tracking execution flow.
+        - output_text: Final text result from cognition layer.
+        - fused_symbol: Fused symbolic representation (if produced by LAIN).
+    """
+    from gx_compiler.compressor import GXCompressor
+    from .cognitive_kernel import get_kernel
+
+    steps: List[SymbolicStep] = []
+    kernel = get_kernel()
+    prompt_bytes = prompt.encode("utf-8")
+
+    # Step 1: Initial prompt
+    steps.append(SymbolicStep(
+        name="initial_prompt",
+        kind="prompt",
+        payload=prompt,
+        context=dict(context or {})
+    ))
+
+    # Step 2: Prepare context for glyph-aware processing
+    exec_context = dict(context or {})
+    if glyph_id:
+        exec_context["glyph_id"] = glyph_id
+        steps.append(SymbolicStep(
+            name=f"glyph:{glyph_id}",
+            kind="glyph_call",
+            payload=prompt,
+            context=exec_context
+        ))
+
+    # Step 3: Compress prompt and build manifest
+    try:
+        payload = GXCompressor.compress(prompt)
+    except Exception as e:
+        return SymbolicPipelineResult(
+            steps=steps,
+            output_text=f"[Pipeline Error] Compression failed: {e}",
+            fused_symbol=None
+        )
+
+    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)}]
+
+    # Step 4: Execute through LAIN cognition pipeline
+    result = kernel.execute_symbolic(
+        manifest=manifest,
+        segments=segments,
+        payload=payload,
+        mode="symbolic",
+        context=exec_context,
+    )
+
+    # Step 5: Extract results
+    fused_symbol = result.get("fused_symbol")
+    output_text = result.get("output_text") or (
+        fused_symbol.get("summary") if fused_symbol else prompt
+    )
+
+    # Step 6: Record fusion step if fused_symbol present
+    if fused_symbol:
+        steps.append(SymbolicStep(
+            name="fusion",
+            kind="fused_symbol",
+            payload=fused_symbol,
+            context={}
+        ))
+
+    return SymbolicPipelineResult(
+        steps=steps,
+        output_text=output_text,
+        fused_symbol=fused_symbol
+    )
diff --git a/programs/demo_symbolic_pipeline.gx.json b/programs/demo_symbolic_pipeline.gx.json
new file mode 100644
index 0000000..9a95269
--- /dev/null
+++ b/programs/demo_symbolic_pipeline.gx.json
@@ -0,0 +1,18 @@
+{
+  "magic": "GXIC1",
+  "version": 1,
+  "model": "",
+  "entrypoint": "main",
+  "symbols": {
+    "main": 0
+  },
+  "instructions": [
+    { "op": "SET_MODE", "args": ["symbolic"] },
+    { "op": "SET_CONTEXT", "args": ["domain", "glyph_cognition"] },
+    { "op": "SET_CONTEXT", "args": ["style", "analytic"] },
+    { "op": "CHAIN", "args": ["glyph_analysis"] },
+    { "op": "LOG", "args": ["Starting glyph-aware symbolic pipeline"] },
+    { "op": "CALL_GLYPH", "args": ["glyph://compression", "Explain how compression acts as a cognitive glyph."] },
+    { "op": "RUN_PROMPT", "args": ["Summarize the previous explanation in one sentence."] }
+  ]
+}
diff --git a/xic_ops.py b/xic_ops.py
index 13d90e9..b5fc0c6 100644
--- a/xic_ops.py
+++ b/xic_ops.py
@@ -44,8 +44,15 @@ def op_SET_PARAM(ctx: XICContext, *args):
 def op_RUN_PROMPT(ctx: XICContext, *args):
     """RUN_PROMPT <prompt>: Execute prompt against loaded model or symbolic cognition.
 
-    If ctx.symbolic_mode is True, routes through glyphos/cognitive_kernel.py.
-    Otherwise, routes to execute_gx() for compressed execution.
+    Symbolic behavior (ctx.symbolic_mode=True):
+    - Routes through symbolic pipeline (run_symbolic_pipeline).
+    - Uses ctx.params["context"] for execution context.
+    - Stores full pipeline result in ctx._state["last_symbolic_pipeline"].
+
+    Compressed behavior (ctx.symbolic_mode=False):
+    - Requires model_path to be set via LOAD_MODEL.
+    - Routes to execute_gx() for compressed execution.
+    - Stores result in ctx._state["last_result"].
     """
     if not args:
         raise ValueError("RUN_PROMPT requires a prompt argument")
@@ -53,10 +60,14 @@ def op_RUN_PROMPT(ctx: XICContext, *args):
     prompt = str(args[0])
 
     if ctx.symbolic_mode:
-        from glyphos.cognitive_kernel import run_symbolic_prompt
-        result = run_symbolic_prompt(prompt, context=ctx.params.get("context"))
-        print(f"[XIC-SYMBOLIC] {result}")
-        ctx._state["last_symbolic_result"] = result
+        from glyphos.symbolic_pipeline import run_symbolic_pipeline
+        pipeline_result = run_symbolic_pipeline(
+            prompt=prompt,
+            context=ctx.params.get("context")
+        )
+        print(f"[XIC-SYMBOLIC] {pipeline_result.output_text}")
+        ctx._state["last_symbolic_result"] = pipeline_result.output_text
+        ctx._state["last_symbolic_pipeline"] = pipeline_result
         return
 
     if not ctx.model_path:
@@ -84,19 +95,31 @@ def op_RUN_PROMPT(ctx: XICContext, *args):
 def op_STREAM(ctx: XICContext, *args):
     """STREAM <prompt>: Execute and stream output line by line.
 
-    In symbolic mode, stream symbolic result. In compressed mode, stream compressed output.
+    Symbolic behavior (ctx.symbolic_mode=True):
+    - Routes through symbolic pipeline.
+    - Streams output_text line by line with [XIC-STREAM] prefix.
+    - Stores pipeline result in ctx._state["last_symbolic_pipeline"].
+
+    Compressed behavior (ctx.symbolic_mode=False):
+    - Routes to execute_gx().
+    - Streams result line by line with [XIC-STREAM] prefix.
+    - Stores result in ctx._state["last_result"].
     """
     if not args:
         raise ValueError("STREAM requires a prompt argument")
     prompt = str(args[0])
 
     if ctx.symbolic_mode:
-        from glyphos.cognitive_kernel import run_symbolic_prompt
-        result = run_symbolic_prompt(prompt, context=ctx.params.get("context"))
-        for chunk in str(result).split("\n"):
+        from glyphos.symbolic_pipeline import run_symbolic_pipeline
+        pipeline_result = run_symbolic_pipeline(
+            prompt=prompt,
+            context=ctx.params.get("context")
+        )
+        for chunk in str(pipeline_result.output_text).split("\n"):
             if chunk.strip():
                 print(f"[XIC-STREAM] {chunk}")
-        ctx._state["last_symbolic_result"] = result
+        ctx._state["last_symbolic_result"] = pipeline_result.output_text
+        ctx._state["last_symbolic_pipeline"] = pipeline_result
         return
 
     if not ctx.model_path:
@@ -131,18 +154,38 @@ def op_CHAIN(ctx: XICContext, *args):
 
 
 def op_CALL_GLYPH(ctx: XICContext, *args):
-    """CALL_GLYPH <glyph_id> <payload>: Invoke cognition with a glyph context."""
+    """CALL_GLYPH <glyph_id> <payload>: Invoke glyph-aware cognition.
+
+    Routes through symbolic pipeline with explicit glyph_id parameter.
+    The glyph_id is propagated into the pipeline context and used for
+    glyph-aware symbolic transformations in the LAIN layer.
+
+    Stores result with key "glyph_{glyph_id}" containing:
+    - output_text: Final text from cognition
+    - fused_symbol: Fused symbolic representation (if produced)
+    - steps: List of symbolic pipeline steps
+    """
     if not args:
         raise ValueError("CALL_GLYPH requires glyph_id argument")
     glyph_id = str(args[0])
     payload = str(args[1]) if len(args) > 1 else ""
 
-    from glyphos.cognitive_kernel import run_symbolic_prompt
+    from glyphos.symbolic_pipeline import run_symbolic_pipeline
     glyph_context = dict(ctx.params.get("context", {}))
     glyph_context["glyph_id"] = glyph_id
-    result = run_symbolic_prompt(payload, context=glyph_context)
-    print(f"[XIC-GLYPH] {result}")
-    ctx._state[f"glyph_{glyph_id}"] = result
+
+    pipeline_result = run_symbolic_pipeline(
+        prompt=payload,
+        context=glyph_context,
+        glyph_id=glyph_id,
+    )
+    print(f"[XIC-GLYPH] {pipeline_result.output_text}")
+    ctx._state[f"glyph_{glyph_id}"] = {
+        "output_text": pipeline_result.output_text,
+        "fused_symbol": pipeline_result.fused_symbol,
+        "steps": [{"name": s.name, "kind": s.kind, "payload": str(s.payload)[:100]}
+                  for s in pipeline_result.steps],
+    }
 
 
 def op_SET_CONTEXT(ctx: XICContext, *args):