50b1e3fc0c
ci: add workflow
CI / check (push) Successful in 14s
2026-07-09 13:57:33 -04:00
c3a826b65c
Implement XIC v2 control flow with IF, MATCH, LOOP operations
...
PHASE A: Safe predicate evaluator (glyphos/control/predicate.py)
- AST-based safe expression evaluation
- Supports comparisons, boolean ops, attribute access
- Helper function: dominant_contains()
- Protected against code injection attacks
PHASE B: XICContext queue helpers
- enqueue_chain(label) for FIFO chain scheduling
- pop_next_chain() to get next scheduled chain
- jump_to(label) for immediate destination changes
PHASE C: Control flow operations (xic_ops.py)
- op_IF: Conditional branching with optional else
- op_MATCH: Pattern matching against fused fields
- op_LOOP: Iterative execution with guardrails
- Added to OP_TABLE for operation dispatch
PHASE D: Execution loop enhancement (xic_vm.py)
- Chain queue scheduling with label matching
- Total steps tracking for guardrail enforcement
- max_total_steps limit across all operations
- Graceful execution stop on guardrail trigger
PHASE E: Comprehensive test suite (tests/test_control_flow.py)
- 14 unit tests covering all operations
- Predicate evaluator tests
- IF/MATCH/LOOP operation tests
- Queue helper and guardrail tests
- All tests passing (14/14)
PHASE F: Example programs
- demo_control_flow_if.gx.json: IF branching example
- demo_control_flow_loop.gx.json: LOOP iteration example
PHASE G: Complete documentation
- XIC_V2_CONTROL_FLOW_SUMMARY.md: Technical guide
- XIC_V2_QUICK_REFERENCE.md: Developer quick reference
- FedMart UI and integration documentation
Integration points:
- FedMart telemetry captures control flow steps
- UI dashboard displays control branching
- Symbolic pipeline predicate evaluation
- 100% backward compatible with XIC v1.5
Test results: 36/36 passing (14 control flow + 12 FedMart + 10 UI)
Status: Production ready
2026-05-21 03:40:39 -04:00
8f55949b11
Integrate XIC telemetry with FedMart (Phase 1)
...
Implement telemetry schema, adapter, and pipeline integration for
FedMart real-time monitoring of XIC symbolic pipeline execution.
## Components
### Telemetry Schema (integrations/fedmart/telemetry_schema.json)
- JSON schema defining XIC telemetry event structure
- Required fields: event_type, timestamp, run_id, glyph_count, etc.
- Optional: metadata, raw_payload for detailed analysis
- Supports multi-glyph resonance summaries and guardrail events
### FedMart Adapter (integrations/fedmart/xic_adapter.py)
- FedMartAdapter class for telemetry emission and spec registration
- emit_telemetry(): normalize and forward telemetry events
- register_spec_map(): push XIC specification status
- Control hooks: pause_run(), throttle_run() for guardrail actions
- Local mode (buffering) and remote mode (HTTP POST)
- Global singleton instance via get_adapter()
### Pipeline Integration (glyphos/symbolic_pipeline.py)
- Emit telemetry at end of run_symbolic_pipeline()
- Captures: glyph_ids, resonance scores, execution steps, guardrails
- Builds resonance_map_summary with top glyphs and averages
- Optional import (graceful degradation if FedMart not available)
### Validation Suite (tests/validate_fedmart_integration.py)
- 12 comprehensive tests covering all adapter functions
- Tests: telemetry emission, normalization, spec registration
- Tests: control actions, buffer operations, schema compliance
- Tests: multi-glyph resonance tracking, guardrail event capture
- All 12 tests passing ✅
## Key Features
✅ Telemetry normalization (timestamp ISO 8601, run_id generation)
✅ Multi-glyph resonance summaries (top 5 glyphs, average resonance)
✅ Guardrail event tracking (truncation, max steps, etc.)
✅ Spec map registration for specification tracking
✅ Control actions (pause/throttle for guardrail responses)
✅ Local mode for testing, remote mode for production
✅ Schema compliance validation
✅ Graceful degradation if FedMart not available
## Testing
All 12 validation tests passing:
✅ Schema validation
✅ Adapter initialization
✅ Telemetry emission (local mode)
✅ Normalization with defaults
✅ Spec map registration
✅ Control actions
✅ Pipeline telemetry integration
✅ Guardrail event capture
✅ Multi-glyph resonance tracking
✅ Buffer operations
✅ Schema compliance
✅ Empty buffer handling
## Next Steps
Phase 2: UI Visualization - real-time dashboard for FedMart
Phase 3: XIC v2 Control Flow - IF, MATCH, LOOP operations
Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com >
2026-05-21 02:40:10 -04:00
150a036604
Implement multi-glyph resonance system for XIC v1.5 (6 phases)
...
Complete end-to-end multi-glyph resonance enabling simultaneous analysis
of multiple glyphs with cross-glyph resonance metrics, guardrails, and
comprehensive telemetry.
## Phase 1: XIC Layer - Context Accumulation
### XICContext Enhancement
- Added glyph_contexts: list field for accumulating glyph IDs
### New Operations
- PUSH_GLYPH_CONTEXT: accumulate glyph with guardrail enforcement
- CLEAR_GLYPH_CONTEXT: reset context for new analysis chains
### Enhanced Existing Operations
- CALL_GLYPH: detects populated glyph_contexts, passes glyph_ids to pipeline
- RUN_PROMPT: supports multi-glyph context via glyph_ids parameter
- STREAM: supports multi-glyph context via glyph_ids parameter
### Guardrail Integration
- max_resonance_glyphs (default 10, configurable)
- enable_resonance_guardrails (default True)
- Enforced at PUSH_GLYPH_CONTEXT to prevent exceeding limit
## Phase 2: Symbolic Pipeline - Multi-Glyph Support
### Extended Signature
- run_symbolic_pipeline now accepts glyph_ids parameter
- Multi-glyph mode detection and routing
- glyph_ids takes precedence over glyph_id if both provided
### Multi-Glyph Processing
- SymbolicStep(kind="multi_glyph_resonance") for glyph_ids
- SymbolicStep(kind="guardrail") when truncation needed
- Guardrail enforcement with pipeline-level truncation to max_resonance_glyphs
### Null-Safety Fixes
- extract_glyph_resonances: handles None resonance_map
- get_dominant_glyphs: handles None resonance_map
- format_glyph_resonance_report: handles None resonance_map
## Phase 3: LAIN Cognitive Kernel - Resonance Computation
### New Method: compute_multi_glyph_resonance
- Takes glyph_ids list and execution result
- Computes 5-dimensional metrics per glyph:
- weight: relative importance [0.0, 1.0]
- lineage_score: symbolic ancestry [0.0, 1.0]
- contributor_score: contribution to fusion [0.0, 1.0]
- frequency_score: occurrence frequency [0.0, 1.0]
- grammar_score: structural alignment [0.0, 1.0]
- Returns global_resonance_score as weighted average
### Enhanced execute_symbolic
- Detects context["glyph_ids"] for multi-glyph mode
- Post-processes LAIN result via compute_multi_glyph_resonance
- Merges multi-glyph metrics into fused_symbol
- Maintains backward compatibility (single-glyph unaffected)
## Phase 4: Guardrails & Telemetry
### Guardrail Enforcement
- PUSH_GLYPH_CONTEXT rejects pushes exceeding max_resonance_glyphs
- run_symbolic_pipeline truncates glyph_ids if needed
- Guardrail step recorded in pipeline with reason message
### Telemetry Collection
- ctx._state["last_resonance_stats"] stores:
- glyph_count: number of glyphs processed
- global_resonance_score: weighted average [0.0, 1.0]
- guardrails_triggered: list of guardrail messages
- timestamp: execution time
## Phase 5: Validation Suite
### 12 Comprehensive Tests (all passing)
1. New operations in OP_TABLE
2. XICContext.glyph_contexts field
3. PUSH_GLYPH_CONTEXT accumulation
4. CLEAR_GLYPH_CONTEXT reset
5. Guardrail enforcement on PUSH
6. run_symbolic_pipeline signature
7. compute_multi_glyph_resonance method
8. Multi-glyph resonance structure
9. execute_symbolic multi-glyph processing
10. Single-glyph backward compatibility
11. Demo programs validity
12. Multi-glyph demo structure
### Test File: test_multi_glyph_resonance.py
- Unit tests for all components
- Integration tests for data flow
- Backward compatibility validation
- Mock-based testing for isolated units
## Phase 6: Documentation
### Updated XIC_SEMANTICS_v1_5.md
- Added PUSH_GLYPH_CONTEXT instruction semantics
- Added CLEAR_GLYPH_CONTEXT instruction semantics
- Added comprehensive Multi-Glyph Resonance section with:
- Context accumulation model diagram
- Complete workflow documentation
- Guardrail specifications
- Telemetry format definition
- Three-glyph analysis example with JSON/Python output
### Created demo_multi_glyph_resonance.gx.json
- Two-chain demonstration program
- Chain 1: 3-glyph analysis (compression, entropy, information)
- Chain 2: 4-glyph analysis (cognition, language, symbol, meaning)
- Shows complete resonance query pipeline
- Demonstrates context clearing and reset
### Created XIC_MULTI_GLYPH_RESONANCE_REPORT.md
- Comprehensive implementation documentation
- All 6 phases detailed with code examples
- Architecture overview and data flow diagrams
- Design decisions with rationale
- Backward compatibility guarantees
- Usage examples (CLI, JSON, programmatic)
- Future enhancement suggestions
## Key Features
✅ Explicit context accumulation (PUSH_GLYPH_CONTEXT)
✅ Automatic multi-glyph detection in CALL_GLYPH/RUN_PROMPT/STREAM
✅ Guardrails prevent exceeding max_resonance_glyphs
✅ Telemetry tracking for analytics
✅ Full backward compatibility maintained
✅ Single-glyph mode unaffected
✅ Comprehensive validation suite (12/12 tests passing)
✅ Complete formal specification updates
✅ Demo program showcase
## Backward Compatibility
- All XIC v1 programs work unchanged
- Single-glyph CALL_GLYPH still works identically
- Empty glyph_contexts → single-glyph behavior
- .gx binary format unchanged
- No breaking changes to APIs
Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com >
2026-05-21 02:29:22 -04:00
bce6b6fa37
Implement XIC v1.5 glyph resonance awareness upgrade (Phase 3-4)
...
This commit completes the comprehensive glyph resonance awareness upgrade
with queryable resonance metrics, new instruction, and formal specification.
## Changes
### Phase 3: New GET_GLYPH_RESONANCE Instruction
- Added op_GET_GLYPH_RESONANCE to xic_ops.py for querying glyph resonance data
- Supports metrics: report, global, dominant, weight, lineage, contributor, frequency, grammar
- Results printed with [XIC-RESONANCE] prefix and stored in ctx._state
- Handles both full pipeline result (preferred) and fallback to resonance_metrics dict
- Updated OP_TABLE to include 10th operation
### Phase 4: Formal Specification & Demo
#### XIC_SEMANTICS_v1_5.md Updates
- Added comprehensive "Glyph Resonance Structure" section documenting:
- FusedSymbol dataclass with summary, glyph_ids, resonance_map
- GlyphResonanceMap with resonances dict and utility methods
- GlyphResonanceMetrics (weight, lineage_score, contributor_score, frequency_score, grammar_score)
- Example JSON structure from LAIN cognition
- Added "GET_GLYPH_RESONANCE" instruction semantics with:
- Signature and preconditions/postconditions
- Metric table describing all query types
- Detailed side effects and remarks
- Data access patterns
#### New Demo Program
- Created programs/demo_glyph_resonance.gx.json
- Two-chain demonstration:
- Chain 1: compression_theory glyph with report, global, dominant, weight queries
- Chain 2: neural_dynamics glyph with individual metric queries (lineage, contributor, frequency, grammar)
- Full instrumentation with CHAIN markers and LOG statements
#### Comprehensive Report
- Created XIC_GLYPH_RESONANCE_REPORT.md documenting:
- Executive summary of resonance awareness upgrade
- Detailed explanation of all components
- Architecture and data flow diagrams
- All 10 validation test results
- Usage examples and design decisions
- Backward compatibility guarantees
- Future extensibility notes
## Implementation Details
### Enhanced Data Structures (glyphos/symbolic_pipeline.py)
- GlyphResonanceMetrics: 5-dimensional resonance scoring
- GlyphResonanceMap: with get_glyph_resonance(), get_top_glyphs(), get_average_resonance()
- FusedSymbol.from_lain_result(): parses LAIN output structure
### Glyph Resonance Utilities
- extract_glyph_resonances(): extract per-glyph metrics from pipeline result
- get_dominant_glyphs(n): rank glyphs by weight
- format_glyph_resonance_report(): human-readable resonance output
### Enhanced CALL_GLYPH
- Now stores comprehensive resonance data in ctx._state["glyph_{glyph_id}"]
- Captures output_text, fused_symbol, resonance_metrics, global_resonance_score, steps
- Also stores full SymbolicPipelineResult for direct access
### New op_GET_GLYPH_RESONANCE
- Query stored resonance metrics with flexible metric selection
- Integrates with symbolic_pipeline utilities for full introspection
- Prints results and stores in ctx._state for programmatic access
## Exports (glyphos/__init__.py)
- GlyphResonanceMetrics
- GlyphResonanceMap
- extract_glyph_resonances
- get_dominant_glyphs
- format_glyph_resonance_report
## Testing
All 10 validation tests pass:
✅ GlyphResonanceMetrics instantiation
✅ GlyphResonanceMap methods (get_glyph_resonance, get_top_glyphs, get_average_resonance)
✅ FusedSymbol.from_lain_result() parsing
✅ extract_glyph_resonances() functionality
✅ get_dominant_glyphs() ranking
✅ format_glyph_resonance_report() generation
✅ OP_TABLE has GET_GLYPH_RESONANCE
✅ op_GET_GLYPH_RESONANCE callable
✅ demo_glyph_resonance.gx.json valid
✅ All exports available from glyphos
## Backward Compatibility
- Zero breaking changes
- All XIC v1 and v1.5 programs work unchanged
- New resonance features are additive
- Existing instruction signatures preserved
- Compressed mode execution unaffected
Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com >
2026-05-21 02:21:44 -04:00
6e0a586f51
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
2026-05-21 01:27:49 -04:00
b4ba84c1d2
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
2026-05-21 01:23:48 -04:00
69c97e125a
Extend XIC v1 Engine with Symbolic Mode, 5 New Ops, GPU Path, Cognition Integration
...
New instructions:
- STREAM: Line-by-line execution and output
- CHAIN: Named execution boundaries
- CALL_GLYPH: Invoke glyph-aware cognition
- SET_CONTEXT: Set symbolic/cognitive context metadata
- LOG: Structured logging
Symbolic execution mode:
- SET_MODE "symbolic" routes prompts through LAIN 8-lane cognition pipeline
- run_symbolic_prompt() compresses prompt, builds manifest, executes via execute_symbolic()
- Full integration with glyphos/cognitive_kernel.py
GPU-accelerated path:
- xic_extensions/gpu_runtime.py: has_gpu() probes torch.cuda, run_on_gpu() executes
- SET_PARAM "use_gpu" true enables GPU (auto-fallback to CPU if unavailable)
- No required GPU dependencies; system works equally on CPU
Demo programs:
- demo_symbolic.gx.json: Shows symbolic mode through LAIN pipeline
- demo_gpu.gx.json: Shows GPU mode with CPU fallback
Backward compatibility:
- All 4 original ops unchanged; 5 new ops added to OP_TABLE
- xic_vm.py, xic_executor.py: No changes (pure dispatcher pattern holds)
- demo_chat.gx.json: Still executes identically
- All existing GlyphRunner commands: Unchanged behavior
Architecture:
- Lazy imports prevent circular dependencies (xic_ops, glyphos, xic_extensions)
- Clean separation: XIC is client of cognition layer
- Zero breaking changes; additive extension only
- No XIC v2 binary format; all within v1 JSON+.gx architecture
Validation:
- 10 integration tests: all passing
- Backward compat verified with original demo
- Symbolic and GPU modes tested end-to-end
- No external dependencies required (GPU optional)
Co-contributors: LAIN cognition engine, gx_compiler GSZ3, glyphos event system
2026-05-21 01:19:40 -04:00
df19777505
Add XIC v1 Engine — Execute-In-Compressed Runtime Integration
...
- Implemented XIC loader, VM, ops, and executor
- Wired RUN_PROMPT directly to execute_gx() (no stubs)
- Added demo compressed model and demo XIC program
- Integrated XIC into glyph_runner.py with --xic flag and shell support
- Added full validation suite and XIC_INTEGRATION_REPORT.md
- Verified real GSZ3 decompression and execution pipeline
This commit introduces a complete compressed-space execution engine
with zero breaking changes and full backward compatibility.
2026-05-21 01:01:10 -04:00
0f5e42dce6
Add Terminal Launcher - Windows desktop launcher for WSL, PowerShell, Ubuntu
...
Simple double-click launchers for opening terminal environments:
Files:
- TerminalLauncher.vbs: VBScript launcher (no dependencies) - RECOMMENDED
- TerminalLauncher.py: Python GUI with three buttons
- TerminalLauncher.bat: Batch wrapper for Python version
- TERMINAL_LAUNCHER_SETUP.md: Complete setup and usage guide
Features:
✓ Double-click to open
✓ VBScript version requires no external dependencies
✓ Python version provides prettier GUI with buttons
✓ Three terminal options: WSL (default), PowerShell, Ubuntu (WSL)
✓ Works on Windows 7 and later
Usage:
1. Copy .vbs or .bat/.py to Windows Desktop
2. Double-click
3. Select terminal
4. Opens immediately
Ready for production use.
2026-05-20 22:46:50 -04:00
1a0b45df9c
Add LLMCompress subsystem - sandbox for symbolic compression of LLM behavior
...
New subsystem fully self-contained:
Components:
- LLMCompress/llm_adapter.py: LLMAdapter + LLMResponse (abstract over LLM backends)
- LLMCompress/compression_report.py: CompressionReport (symbolic analysis results)
- LLMCompress/llm_compressor.py: compress_interaction() and compress_session()
- LLMCompress/tests/test_llm_compress.py: 5 comprehensive tests
Integration:
- Uses GlyphOS Cognitive Kernel for symbolic analysis
- Integrates with GlyphOS Event System
- Emits cognition.started and cognition.completed events
- Supports in-memory GX execution via execute_symbolic()
Test Coverage:
- LLMCompress tests: 5/5 PASS
- All existing tests still pass (52/52)
- Total: 57 tests passing
Bug fixes in cognitive_kernel.py:
- Fixed execute_symbolic() method calls to use correct function signatures
- normalize_segments(manifest, segments, payload)
- map_lanes(segments)
- build_envelope(manifest, lanes, payload, context)
- execute_with_lain(envelope)
Constraints:
- No modifications to gx_compiler/*
- No modifications to glyphs/super_registry.py
- Self-contained subsystem with proper isolation
- Full backward compatibility maintained
2026-05-20 20:51:01 -04:00
c63b390625
Add comprehensive Event System documentation
...
Complete reference for GlyphOS Event System:
- Architecture and design principles
- Event type definitions and payloads
- EventBus class API
- Functional API (emit, on, get_event_bus)
- Usage examples and patterns
- Integration with Cognitive Kernel
- Test coverage and results
- Performance metrics
- Future enhancements
Status: Complete and ready for deployment
2026-05-20 18:12:08 -04:00
9792449157
Implement GlyphOS Event System
...
Add lightweight, in-process event bus with Cognitive Kernel integration:
New Components:
- glyphos/events.py: EventBus class + functional API
* EventBus: publish/subscribe pattern with history
* Event type definitions (EventType literal)
* Singleton: get_event_bus(), emit(), on()
* History filtering and limits
* Graceful handler error handling
- tests/test_events.py: Comprehensive test suite (16 tests, 100% pass)
* EventBus subscription/publishing/history
* Global singleton behavior
* Functional API (on, emit, get_event_bus)
* Kernel integration tests
* Cognition event emission tests
Modified:
- glyphos/cognitive_kernel.py: Event emissions at key points
* kernel.warmup.completed: After warmup() completes
* cognition.started: At start of execute_gx()
* cognition.completed: After execute_gx() completes
* glyph.resonance.updated: When glyph resonance present
- glyphos/__init__.py: Export events module
Test Results:
- Registry tests: 12/12 ✅
- Bridge tests: 10/10 ✅
- Kernel tests: 8/8 ✅
- Event system tests: 16/16 ✅ (NEW)
- Integration tests: 6/6 ✅
- Total: 52/52 ✅
No breaking changes - all 36 existing tests still pass.
2026-05-20 18:11:25 -04:00
9f4f31e2a3
Add comprehensive deliverables documentation
...
Complete summary of GlyphOS Cognitive Kernel implementation:
- All deliverables listed and verified
- Test results (36/36 passing)
- Performance metrics
- API usage examples
- Design principles
- Production readiness checklist
Total implementation:
- 268 lines: cognitive_kernel.py
- 18 lines: __init__.py
- 420 lines: test_cognitive_kernel.py
- 360 lines: COGNITIVE_KERNEL.md
- ~1,100 total new lines of code
No breaking changes, full backwards compatibility verified.
2026-05-20 18:04:55 -04:00
5c4bfb2dc1
Implement GlyphOS Cognitive Kernel
...
Add a system service layer on top of LAIN cognition and Supercharged Glyph Registry:
Components:
- glyphos/cognitive_kernel.py: CognitiveKernel class + functional API
* CognitiveKernel: Main orchestrator with execute_gx(), execute_symbolic()
* Result accessors: get_last_result(), get_last_trace(), get_last_fused_symbol()
* get_kernel(): Singleton kernel instance
* run_gx(): Convenience function for global kernel
* kernel_status(): Status introspection
- glyphos/__init__.py: Package initialization
- tests/test_cognitive_kernel.py: Comprehensive test suite (8 tests, 100% pass)
* Kernel initialization and warmup
* GX execution and result validation
* Result accessor methods
* Singleton pattern
* Functional API
- COGNITIVE_KERNEL.md: Complete documentation
Test Results:
- 12 registry tests ✅
- 10 glyph bridge tests ✅
- 6 integration suites ✅
- 8 cognitive kernel tests ✅
- Total: 36 tests, 0 failures
No breaking changes - all existing tests pass.
2026-05-20 18:03:25 -04:00
02a298f44c
Fix typo in super_registry and add system documentation
...
- Fixed function name typo in super_registry.py:303 (load_all_superchattracted → load_all_supercharged)
- Added SYSTEM_STATUS.md with complete feature list and test results
- Added ARCHITECTURE.md with detailed system design and component documentation
- All 28 tests passing (12 registry, 10 bridge, 6 integration suites)
- Full pipeline verified end-to-end
2026-05-20 17:57:38 -04:00
4bc49c90b3
Implement LAIN ↔ Supercharged Glyph Bridge
...
New module:
- gx_lain/lain_glyph_bridge.py: Bridge connecting LedoGlyph600 to LAIN cognition
Functions:
- load_glyph_context(manifest, context): Load relevant glyph from registry
- inject_glyph_metadata_into_lane(lane_result, glyph_context): Add glyph fields to lane
- compute_glyph_resonance(glyph_context): Calculate glyph resonance metrics
- augment_fused_symbol_with_glyphs(fused_symbol, glyph_context): Add glyph to final output
Modified:
- gx_lain/runtime.py: Integrate glyph bridge into execute_with_lain()
* Load glyph context as step 1 of cognition
* Inject glyph metadata into each lane result
* Augment fused symbol with glyph context
* Add glyph_resonance to diagnostics
* Track glyph loading in cognition_trace
Tests:
- tests/test_lain_glyph_bridge.py: 10 comprehensive tests
* Context loading (with/without glyph)
* Metadata injection (preserves existing fields)
* Resonance computation (4-component metric)
* Symbol augmentation
* Full integration test
Features:
- Glyph metadata: id, name, category, score, period, band
- Frequency signatures: praw (P, R, A, W)
- Activation envelopes: mode, score
- Lineage: signature, inheritance weight
- Symbolic anatomy: power, complexity, resonance, stability, connectivity, affinity
- Resonance profile: activation + frequency + symbolic metrics (0.0-1.0)
All 18 integration tests still passing (no regressions).
2026-05-20 17:41:47 -04:00
f5dba41cf2
Implement Supercharged Glyph Registry (LedoGlyph600)
...
New modules:
- glyphs/super_registry.py: Registry for 600 supercharged glyphs
- tests/test_supercharged_registry.py: Comprehensive test suite
Features:
- load_all_supercharged(): Lazy-load 600 glyphs from LedoGlyph600.json
- get_super(): Retrieve glyph by ID with all supercharged fields
- list_super_ids(): List all 600 glyph IDs (sorted)
- search_super(): Search by query across specified fields
- super_stats(): Registry metadata and statistics
- get_super_field(): Nested field access via dot-notation
- list_super_by_category(): Filter by category
- get_super_by_band(): Filter by frequency band
- get_glyphs_by_score_range(): Filter by score range
Data source: /mnt/d/users/dave/Downloads/LEDONOVA/LedoGlyph600.json
Supercharged fields:
- Symbolic anatomy (originalMetrics: power, complexity, resonance, stability, connectivity, affinity)
- Frequency signatures (praw: P, R, A, W)
- Contributor inheritance (lineage: predecessors, siblings, descendants, signature)
- Activation envelopes (activation: vector, score, signature, modes)
- Resonance profiles (activation modes: dormant, present, resonant, overdrive)
- Routing & governance metadata
All 12 tests passing.
2026-05-20 17:12:30 -04:00
93ac2003b3
Implement real LAIN cognition engine with 8 lane processors
...
New modules:
- gx_lain/lane_processors.py: 8 symbolic lane processors
* Lane 0: structural_logic (control flow, constraints)
* Lane 1: semantic_flow (core meaning, narrative)
* Lane 2: compression_residue (artifacts, hints)
* Lane 3: symbolic_metadata (tags, annotations)
* Lane 4: execution_hints (runtime guards, priorities)
* Lane 5: predictive_scaffolding (hypotheses, priors)
* Lane 6: contributor_imprint (author style, bias)
* Lane 7: epoch_resonance (temporal context)
- gx_lain/runtime.py (updated): Real cognition loop
* execute_with_lain(): Process all 8 lanes, capture timings
* fuse_lanes(): Merge lane results into final symbol
* compute_resonance(): Per-lane resonance metrics
* render_output_text(): Mode-based output formatting
Features:
- Structured lane processing with error recovery
- Cognition trace with per-lane timing
- Resonance metrics (1.0 if lane has content)
- Fused symbol with deduplication
- Mode-aware output (ANALYZE vs SYNTHESIZE)
- No mutations, deterministic execution
All 18 integration tests pass unchanged.
2026-05-20 14:54:56 -04:00
4e11cd990d
Wire GX→LAIN runtime into CLI as 'lain' command
...
Add new command: gx lain <path.gx> [-m/--mode MODE]
Features:
- Execute .gx files through GX→LAIN runtime
- Display fused symbol, output text, diagnostics
- Configurable cognitive mode (default: analyze)
- Structured error reporting
Usage:
gx lain sample_code.gx
gx lain sample_code.gx -m synthesize
All integration tests still passing (18/18).
2026-05-20 13:56:49 -04:00
af1265d2b2
Implement GX→LAIN runtime interface v1.0
...
Core pipeline: load_gx() → normalize_segments() → map_lanes() → build_envelope() → execute_with_lain()
Features:
- Load .gx files and extract manifest, segments, payload
- Normalize raw segments into canonical schema (id, start_line, end_line, text, symbolic_lane, semantic_role)
- Map segments into 8 symbolic lanes (structural_logic, semantic_flow, compression_residue, symbolic_metadata, execution_hints, predictive_scaffolding, contributor_imprint, epoch_resonance)
- Build ExecutionEnvelope with manifest, lanes, payload, context
- Stub LAIN execution with cognition_trace, fused_symbol, output_text, diagnostics
- Structured error handling via make_error()
- Interface versioning and deterministic execution
All integration tests still pass (18/18).
Main entry point: execute_gx_path(gx_path, context=None)
Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com >
2026-05-20 13:54:33 -04:00
e02d8fdeae
Rewrite gx_cli/commands.py to use load_gx fallback format
...
Replace codex_lineage.inspector integration with direct load_gx() calls.
Inspect and summary commands now output consistent, test-expected formats:
- [Manifest], [Segments], [Payload] sections for inspect
- GX File, Source, Type, Segments, Compressed, Version for summary
All integration tests pass (17/17).
Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com >
2026-05-20 13:32:08 -04:00
43887931cc
Complete GlyphRunner Implementation: All Subsystems & Integration Tests
...
This commit includes the complete implementation of the GlyphRunner system:
SUBSYSTEMS CREATED:
1. xic_extensions (5 modules)
- gsz3_decompressor: Compression/decompression with checksum validation
- segment_runtime: Multi-segment execution with namespace merging
- execution_tracer: Execution tracing with event capture
- profiler: Lightweight segment profiling (duration, memory, counts)
- compressed_engine: High-level orchestration (simulate/execute modes)
2. gx_compiler (5 modules)
- segmenter: Deterministic source code segmentation
- compressor: GSZ3 compression wrapper
- manifest_builder: XIC/GX manifest generation
- gx_packer: Binary .gx file format (XIC header + manifest + payload)
- compiler: High-level compilation pipeline
3. runtime_executor (6 modules)
- gx_loader: .gx file loading and parsing
- execution_plan: Execution plan building from manifest
- context: Runtime execution context management
- runner: Core execution engine with tracing/profiling
- events: Runtime event system and event bus
- integration: High-level API (run_gx_with_summary)
4. gx_cli (5 modules)
- commands: Command implementations (compile, run, inspect, summary)
- parser: argparse-based argument parsing
- dispatcher: Command routing and execution
- main: CLI entry point with exception handling
5. codex_lineage (6 modules)
- lineage_model: Data structures (EpochInfo, ContributorInfo, etc.)
- epoch_mapper: Version string parsing (v1, v2.5-beta, etc.)
- contributor_index: In-memory contributor registry
- lineage_resolver: Manifest → CodexEntry resolution
- grammar_hooks: Human-readable report generation
- inspector: High-level .gx file inspection utility
INTEGRATION TESTS (7 test files)
- test_compile: Compilation pipeline tests
- test_run: Execution verification tests
- test_inspect: Inspection and manifest tests
- test_summary: Summary generation tests
- test_errors: Error handling and graceful failure
- test_determinism: Reproducibility and determinism
- run_all_tests: Master test runner
ARCHITECTURE HIGHLIGHTS:
✓ Zero circular imports
✓ Pure functions where possible
✓ Explicit error handling
✓ No global side effects
✓ Only stdlib dependencies
✓ Deterministic output
✓ Production-ready code
PIPELINE:
sample.py → [gx_compiler] → sample.gx (960 bytes, XIC format)
→ [runtime_executor] → Execution (6 segments)
→ [codex_lineage] → Human-readable lineage report
CLI COMMANDS:
gx compile <source.py> [-o output.gx]
gx run <file.gx>
gx inspect <file.gx>
gx summary <file.gx>
VERIFICATION:
✓ All 5 subsystems created and tested
✓ Full pipeline: compile → inspect → execute
✓ Codex lineage fully integrated with gx_cli
✓ 25+ integration test cases
✓ End-to-end testing successful
✓ No external dependencies beyond Python stdlib
Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com >
2026-05-20 10:54:44 -04:00
GlyphRunner System