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