Refine XIC v1 to Symbolic Extension Only (No GPU Code)

Removed GPU-related code per specification:
- Deleted xic_extensions/gpu_runtime.py
- Removed GPU logic from op_RUN_PROMPT and op_STREAM
- Removed demo_gpu.gx.json

Kept pure symbolic extension:
- 5 new instructions: STREAM, CHAIN, CALL_GLYPH, SET_CONTEXT, LOG
- Symbolic execution mode via SET_MODE "symbolic"
- run_symbolic_prompt() integration with LAIN cognition layer
- demo_symbolic.gx.json for testing

Implementation now focuses exclusively on:
- Extending instruction set (9 total ops)
- Adding symbolic routing to cognition layer
- Preserving backward compatibility (zero breaking changes)
- No external GPU dependencies

All validation tests pass:
✅ OP_TABLE coverage (9 operations)
✅ XICContext.symbolic_mode field
✅ run_symbolic_prompt() callable
✅ Backward compatibility (demo_chat unchanged)
✅ Symbolic mode execution (LAIN pipeline)
✅ SET_CONTEXT, CHAIN, RUN_PROMPT routing

Constraints met:
✅ No breaking changes
✅ No XIC v2 binary format
✅ No GPU-related code
✅ Strict v1 JSON + .gx architecture

XIC_SYMBOLIC_EXTENSION_REPORT.md

@@ -0,0 +1,236 @@
+# XIC v1 Symbolic Extension Report
+
+**Date**: 2026-05-21  
+**Status**: ✅ Complete and validated  
+**Scope**: Symbolic execution mode + 5 new instructions
+
+---
+
+## Summary
+
+Extended XIC v1 with:
+1. **Symbolic execution mode**: Routes prompts through LAIN cognition layer (glyphos/cognitive_kernel.py)
+2. **5 new instructions**: STREAM, CHAIN, CALL_GLYPH, SET_CONTEXT, LOG
+
+**Zero breaking changes**. All existing XIC v1 programs work unchanged.
+
+---
+
+## New Instructions
+
+| Instruction | Purpose | Signature |
+|---|---|---|
+| STREAM | Stream output line-by-line | `{ "op": "STREAM", "args": ["prompt"] }` |
+| CHAIN | Mark named execution boundary | `{ "op": "CHAIN", "args": ["label"] }` |
+| CALL_GLYPH | Invoke cognition with glyph context | `{ "op": "CALL_GLYPH", "args": ["glyph_id", "payload"] }` |
+| SET_CONTEXT | Set symbolic/cognitive context key | `{ "op": "SET_CONTEXT", "args": ["key", value] }` |
+| LOG | Structured logging | `{ "op": "LOG", "args": ["message"] }` |
+
+**Location**: `/home/dave/superdave/xic_ops.py`
+
+---
+
+## Symbolic Execution Mode
+
+### How It Works
+
+1. User runs: `SET_MODE "symbolic"`
+2. `op_SET_MODE` detects mode=="symbolic", sets `ctx.symbolic_mode = True`
+3. When `RUN_PROMPT` or `STREAM` executes:
+   - If symbolic_mode is False: calls `execute_gx()` (compressed model)
+   - If symbolic_mode is True: calls `run_symbolic_prompt()` (LAIN cognition)
+
+### XICContext Extension
+
+```python
+@dataclass
+class XICContext:
+    model_path: Optional[str] = None
+    mode: str = "chat"
+    params: Dict[str, Any] = field(default_factory=dict)
+    _state: Dict[str, Any] = field(default_factory=dict)
+    symbolic_mode: bool = False  # NEW
+```
+
+### RUN_PROMPT Behavior
+
+```python
+def op_RUN_PROMPT(ctx, *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
+        return
+    
+    # Compressed execution (existing behavior)
+    ...
+```
+
+---
+
+## Cognition Layer Integration
+
+### run_symbolic_prompt() Function
+
+**Location**: `/home/dave/superdave/glyphos/cognitive_kernel.py`
+
+**Signature**:
+```python
+def run_symbolic_prompt(prompt: str, context: dict | None = None) -> str:
+    """
+    Entry point for symbolic execution from XIC.
+    
+    Compresses prompt into GSZ3, builds manifest, routes through
+    LAIN 8-lane cognition pipeline via CognitiveKernel.execute_symbolic().
+    Returns output_text string.
+    """
+```
+
+**Pipeline**:
+1. Compress prompt text → GSZ3 via GXCompressor.compress()
+2. Build minimal manifest (source_file=`<symbolic>`, one segment)
+3. Call kernel.execute_symbolic(manifest, segments, payload, mode="symbolic", context=...)
+4. LAIN processes through 8 lanes (structural, semantic, compression, metadata, hints, predictive, imprint, epoch)
+5. Return fused result as string
+
+**Export**: Added to glyphos/__init__.py public API (already present)
+
+---
+
+## Demo Program
+
+### programs/demo_symbolic.gx.json
+
+```json
+{
+  "magic": "GXIC1",
+  "version": 1,
+  "model": "",
+  "entrypoint": "main",
+  "symbols": { "main": 0 },
+  "instructions": [
+    { "op": "SET_MODE", "args": ["symbolic"] },
+    { "op": "SET_CONTEXT", "args": ["domain", "compression_theory"] },
+    { "op": "SET_CONTEXT", "args": ["style", "symbolic"] },
+    { "op": "CHAIN", "args": ["symbolic_run_1"] },
+    { "op": "LOG", "args": ["Entering symbolic cognition mode"] },
+    { "op": "RUN_PROMPT", "args": ["Describe the relationship between compression and symbolic thought."] }
+  ]
+}
+```
+
+### How to Run
+
+```bash
+# Via glyph_runner
+python glyph_runner.py --xic programs/demo_symbolic.gx.json
+
+# Via xic_executor
+python -c "from xic_executor import run_xic; run_xic('programs/demo_symbolic.gx.json')"
+
+# Via xic shell
+python glyph_runner.py xic
+  xic> run programs/demo_symbolic.gx.json
+```
+
+### Output Example
+
+```
+[XIC] Mode set to: symbolic
+[XIC] Context domain = compression_theory
+[XIC] Context style = symbolic
+[XIC-CHAIN] Entering chain: symbolic_run_1
+[XIC-LOG] Entering symbolic cognition mode
+[XIC-SYMBOLIC] [SYMBOLIC]
+Structural constraints and control flow...
+[8-lane analysis output from LAIN cognition layer]
+...
+```
+
+---
+
+## Backward Compatibility
+
+✅ **All existing functionality preserved**:
+
+- demo_chat.gx.json: Executes identically
+- glyph_runner.py: All commands unchanged
+- xic_loader.py: Still validates GXIC1 v1
+- xic_vm.py: Still dispatches via OP_TABLE
+- execute_gx(): Still core compressed runner
+- No binary format changes (v1 JSON + .gx only)
+
+---
+
+## Validation Results
+
+| Test | Result |
+|------|--------|
+| OP_TABLE (9 operations) | ✅ PASSED |
+| XICContext.symbolic_mode field | ✅ PASSED |
+| run_symbolic_prompt() importable | ✅ PASSED |
+| Backward compatibility demo_chat | ✅ PASSED |
+| Symbolic demo execution | ✅ PASSED |
+| SET_CONTEXT context dict | ✅ PASSED |
+| CHAIN label marking | ✅ PASSED |
+| RUN_PROMPT symbolic routing | ✅ PASSED |
+
+**All 8 tests PASSED** ✅
+
+---
+
+## Files Modified
+
+| File | Changes |
+|------|---------|
+| xic_ops.py | +1 field (symbolic_mode), +5 ops, updated OP_TABLE |
+| glyphos/cognitive_kernel.py | +run_symbolic_prompt() function |
+| glyphos/__init__.py | +run_symbolic_prompt export |
+
+## Files Created
+
+| File | Purpose |
+|------|---------|
+| programs/demo_symbolic.gx.json | Demo of symbolic execution mode |
+
+---
+
+## Architecture Notes
+
+### No Circular Imports
+
+- xic_ops.py may import from glyphos.cognitive_kernel (inside function bodies)
+- glyphos.cognitive_kernel does NOT import from xic_ops
+- Lazy imports prevent circular dependency chains
+
+### Clean Separation
+
+```
+XIC (xic_ops.py, xic_vm.py, xic_executor.py)
+  ↓ calls run_symbolic_prompt
+glyphos.cognitive_kernel
+  ↓ calls kernel.execute_symbolic
+gx_lain.runtime (LAIN 8-lane cognition)
+  ↓ uses
+xic_extensions (GSZ3, profiler, tracer, etc.)
+```
+
+---
+
+## Constraints Met
+
+✅ MUST preserve backward compatibility → All existing programs work unchanged  
+✅ MUST NOT introduce XIC v2 binary format → All changes within v1 JSON/gx  
+✅ MUST NOT add GPU-related code → No GPU logic in this implementation  
+✅ MUST work with existing v1 architecture → Uses execute_symbolic() correctly
+
+---
+
+**Implementation Complete** ✅  
+**All tests passing** ✅  
+**Backward compatible** ✅  
+**Zero breaking changes** ✅  
+**No GPU code** ✅

programs/demo_gpu.gx.json

@@ -1,15 +0,0 @@
-{
-  "magic": "GXIC1",
-  "version": 1,
-  "model": "programs/hello_model.gx",
-  "entrypoint": "main",
-  "symbols": {
-    "main": 0
-  },
-  "instructions": [
-    { "op": "LOAD_MODEL", "args": ["programs/hello_model.gx"] },
-    { "op": "SET_PARAM", "args": ["use_gpu", true] },
-    { "op": "LOG", "args": ["Attempting GPU-accelerated execution"] },
-    { "op": "RUN_PROMPT", "args": ["Hello from XIC with GPU acceleration."] }
-  ]
-}

xic_extensions/gpu_runtime.py

@@ -1,57 +0,0 @@
-"""GPU-accelerated compressed execution path for XIC.
-
-has_gpu() probes for CUDA via torch. If torch is absent or no CUDA
-device is detected, returns False and run_on_gpu() falls back to CPU
-via execute_gx() with a clear log line.
-"""
-from typing import Any
-
-
-def has_gpu() -> bool:
-    """Check if CUDA GPU is available via torch.
-
-    Returns:
-        True if torch is installed and CUDA device is detected, False otherwise
-    """
-    try:
-        import torch
-        return torch.cuda.is_available()
-    except ImportError:
-        return False
-
-
-def run_on_gpu(model_path: str, params: dict) -> Any:
-    """Execute a .gx model with optional GPU acceleration.
-
-    If GPU is available (torch + CUDA), logs device info and runs on GPU.
-    If GPU is not available, logs fallback and runs on CPU via execute_gx().
-
-    Args:
-        model_path: Path to .gx model file
-        params: Execution parameters dict (trace, profile, etc.)
-
-    Returns:
-        ExecutionContext from execute_gx()
-    """
-    from runtime_executor.runner import execute_gx
-
-    if has_gpu():
-        try:
-            import torch
-            device_name = torch.cuda.get_device_name(0)
-            print(f"[XIC-GPU] Device: {device_name}")
-        except Exception as e:
-            print(f"[XIC-GPU] Warning: Could not get device name: {e}")
-
-        return execute_gx(
-            model_path,
-            trace=params.get("trace", False),
-            profile=params.get("profile", False),
-        )
-    else:
-        print("[XIC-GPU] No CUDA device — executing on CPU")
-        return execute_gx(
-            model_path,
-            trace=params.get("trace", False),
-            profile=params.get("profile", False),
-        )

xic_ops.py

@@ -45,7 +45,7 @@ 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() with optional GPU acceleration.
+    Otherwise, routes to execute_gx() for compressed execution.
     """
     if not args:
         raise ValueError("RUN_PROMPT requires a prompt argument")
@@ -63,19 +63,6 @@ def op_RUN_PROMPT(ctx: XICContext, *args):
         raise ValueError("No model loaded. Use LOAD_MODEL first.")
 
     try:
-        if ctx.params.get("use_gpu"):
-            from xic_extensions.gpu_runtime import has_gpu, run_on_gpu
-            if has_gpu():
-                print(f"[XIC-GPU] Running on GPU: {ctx.model_path}")
-                execution_context = run_on_gpu(ctx.model_path, ctx.params)
-            else:
-                print(f"[XIC-GPU] No GPU detected, falling back to CPU")
-                execution_context = execute_gx(
-                    ctx.model_path,
-                    trace=ctx.params.get("trace", False),
-                    profile=ctx.params.get("profile", False)
-                )
-        else:
         execution_context = execute_gx(
             ctx.model_path,
             trace=ctx.params.get("trace", False),
@@ -95,7 +82,10 @@ def op_RUN_PROMPT(ctx: XICContext, *args):
 
 
 def op_STREAM(ctx: XICContext, *args):
-    """STREAM <prompt>: Execute and stream output line by line."""
+    """STREAM <prompt>: Execute and stream output line by line.
+
+    In symbolic mode, stream symbolic result. In compressed mode, stream compressed output.
+    """
     if not args:
         raise ValueError("STREAM requires a prompt argument")
     prompt = str(args[0])
@@ -103,7 +93,7 @@ def op_STREAM(ctx: XICContext, *args):
     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 result.split("\n"):
+        for chunk in str(result).split("\n"):
             if chunk.strip():
                 print(f"[XIC-STREAM] {chunk}")
         ctx._state["last_symbolic_result"] = result
@@ -112,27 +102,23 @@ def op_STREAM(ctx: XICContext, *args):
     if not ctx.model_path:
         raise ValueError("No model loaded. Use LOAD_MODEL first.")
 
-    use_gpu = ctx.params.get("use_gpu")
+    try:
-    if use_gpu:
+        exec_ctx = execute_gx(
-        from xic_extensions.gpu_runtime import has_gpu, run_on_gpu
+            ctx.model_path,
-        if has_gpu():
-            print(f"[XIC-GPU] Streaming on GPU: {ctx.model_path}")
-            exec_ctx = run_on_gpu(ctx.model_path, ctx.params)
-        else:
-            print(f"[XIC-GPU] No GPU detected, falling back to CPU")
-            exec_ctx = execute_gx(ctx.model_path,
             trace=ctx.params.get("trace", False),
-                                  profile=ctx.params.get("profile", False))
+            profile=ctx.params.get("profile", False),
-    else:
+        )
-        exec_ctx = execute_gx(ctx.model_path,
-                              trace=ctx.params.get("trace", False),
-                              profile=ctx.params.get("profile", False))
-
         result_text = str(getattr(exec_ctx, "result", "OK"))
         for chunk in result_text.split("\n"):
             if chunk.strip():
                 print(f"[XIC-STREAM] {chunk}")
         ctx._state["last_result"] = exec_ctx
+    except ExecutionError as e:
+        print(f"[XIC] Execution error: {e}")
+        raise
+    except Exception as e:
+        print(f"[XIC] Unexpected error: {e}")
+        raise
 
 
 def op_CHAIN(ctx: XICContext, *args):
@@ -165,8 +151,10 @@ def op_SET_CONTEXT(ctx: XICContext, *args):
         raise ValueError("SET_CONTEXT requires key and value")
     if "context" not in ctx.params:
         ctx.params["context"] = {}
-    ctx.params["context"][str(args[0])] = args[1]
+    key = str(args[0])
-    print(f"[XIC] Context {args[0]} = {args[1]}")
+    value = args[1]
+    ctx.params["context"][key] = value
+    print(f"[XIC] Context {key} = {value}")
 
 
 def op_LOG(ctx: XICContext, *args):