ghocentric-ghost-engine 0.2.0__tar.gz → 0.2.2__tar.gz

ghocentric_ghost_engine-0.2.2/PKG-INFO

@@ -0,0 +1,186 @@
+Metadata-Version: 2.4
+Name: ghocentric-ghost-engine
+Version: 0.2.2
+Summary: Ghost cognitive engine
+Author: Shane Heckathorn
+License: MIT
+Keywords: ai,engine,cognition,simulation
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# ghocentric-ghost-engine
+
+A lightweight, deterministic internal state engine for experimenting with persistent state, temporal dynamics, and emergent behavior in interactive systems.
+
+Ghost is **NOT** a language model and **NOT** a decision-maker.  
+It is a minimal, stateful core designed to accumulate interaction signals over time and expose them in a clean, predictable, and serialization-safe way.
+
+This project is intentionally focused on architecture and correctness first. Surface features, integrations, and higher-level reasoning systems are expected to be layered on top of the core.
+
+---
+
+## Installation
+
+```bash
+pip install ghocentric-ghost-engine
+```
+
+---
+
+## Basic Usage
+
+```python
+from ghost.engine import GhostEngine
+
+engine = GhostEngine()
+
+engine.step({
+    "source": "npc_engine",
+    "intent": "threat",
+    "actor": "player",
+    "target": "guard",
+    "intensity": 0.5,
+})
+
+state = engine.state()
+print(state["npc"]["threat_level"])
+```
+
+Ghost mutates state only through explicit `step()` calls.  
+All public-facing state is exposed as dictionaries and is safe to serialize.
+
+---
+
+## Core Design Principles
+
+- Deterministic, persistent state core  
+- Explicit state transitions via `step()`  
+- No hidden execution or side effects  
+- Public API remains dict-based and serialization-safe  
+- Internal typed representations may exist but never leak  
+- Designed to be expanded around a stable core  
+
+### Ghost does NOT:
+
+- Choose actions  
+- Generate dialogue  
+- Interpret semantics  
+- Store memory implicitly  
+
+These responsibilities belong to external systems that consume Ghost’s state.
+
+---
+
+## Stability & Guarantees (v0.2.2)
+
+Ghost Engine v0.2.2 strengthens runtime correctness and serialization guarantees across public engine state.
+
+The engine guarantees:
+
+- Deterministic runtime behavior (same inputs → same outputs)  
+- Explicit, bounded state mutation per step  
+- Actor state updates across interactions  
+- Actor-level threat accumulation tracking  
+- Pairwise relationship mutation with symmetric consistency  
+- Bounded cascade propagation across interaction networks  
+- Deterministic nonlinear modulation of global system tension  
+- Passive decay behavior during idle cycles  
+- Fully JSON-safe public state and immutable snapshots  
+
+These guarantees hold under repeated execution, long-run simulation, and adversarial input streams.
+
+---
+
+## Architectural Expansion (v0.2.x)
+
+Recent releases introduce the first fully operational multi-agent interaction model on top of Ghost’s deterministic state core.
+
+### Key Capabilities
+
+**Agent State Mutation**  
+Agents maintain evolving internal state (mood, tension, last intent) and react deterministically to interaction signals.
+
+**Relationship Graph**  
+Pairwise relationships evolve through explicit interaction deltas, supporting long-term system memory without hidden state.
+
+**Bounded Cascade Propagation**  
+Signals propagate deterministically through local interaction networks with strict bounds to prevent runaway behavior.
+
+**Global System Tension**  
+The engine tracks shared system pressure across interactions using deterministic nonlinear modulation.
+
+**Actor Threat Memory**  
+Agents maintain explicit per-actor threat accumulation history for structured introspection.
+
+**Idle-State Decay Dynamics**  
+Bounded passive decay improves long-run stability and prevents runaway system pressure.
+
+---
+
+## Testing Philosophy
+
+Ghost uses property-based testing and invariant validation rather than relying solely on example-driven tests.
+
+Core validation includes:
+
+- determinism verification  
+- bounded-state guarantees  
+- serialization safety validation  
+
+This ensures the engine remains correct and predictable as new systems are layered on top.
+
+---
+
+## Project Structure
+
+```
+ghost/        core engine modules  
+tests/        invariant and runtime tests  
+npc_demo.py   experimental sandbox  
+pyproject.toml build configuration  
+```
+
+Demos are intentionally minimal and act as experimental sandboxes.  
+They are not representative of Ghost’s final scope.
+
+---
+
+## Status
+
+Ghost Engine remains in early development.
+
+As of v0.2.x:
+
+- The deterministic interaction core is stable  
+- APIs may still evolve  
+- Higher-level systems remain intentionally external  
+
+This project is intended as a foundation for experimentation, research, and future system design rather than a finished product.
+
+---
+
+## Release History
+
+**v0.2.2**
+- Fixed public state serialization issue in relationship subsystem  
+- Replaced set-based storage with JSON-safe structures  
+- Strengthened invariant coverage across runtime state  
+
+**v0.2.1**
+- Added actor-level threat accumulation tracking  
+- Introduced deterministic nonlinear system modulation  
+- Implemented passive idle-cycle decay  
+- Added immutable JSON-safe snapshots  
+
+**v0.2.0**
+- Introduced multi-agent state mutation  
+- Added relationship mutation logic  
+- Implemented bounded cascade propagation  
+- Achieved deterministic runtime guarantees  
+
+**v0.1.x**
+- Foundational architecture releases

ghocentric_ghost_engine-0.2.2/README.md

@@ -0,0 +1,172 @@
+# ghocentric-ghost-engine
+
+A lightweight, deterministic internal state engine for experimenting with persistent state, temporal dynamics, and emergent behavior in interactive systems.
+
+Ghost is **NOT** a language model and **NOT** a decision-maker.  
+It is a minimal, stateful core designed to accumulate interaction signals over time and expose them in a clean, predictable, and serialization-safe way.
+
+This project is intentionally focused on architecture and correctness first. Surface features, integrations, and higher-level reasoning systems are expected to be layered on top of the core.
+
+---
+
+## Installation
+
+```bash
+pip install ghocentric-ghost-engine
+```
+
+---
+
+## Basic Usage
+
+```python
+from ghost.engine import GhostEngine
+
+engine = GhostEngine()
+
+engine.step({
+    "source": "npc_engine",
+    "intent": "threat",
+    "actor": "player",
+    "target": "guard",
+    "intensity": 0.5,
+})
+
+state = engine.state()
+print(state["npc"]["threat_level"])
+```
+
+Ghost mutates state only through explicit `step()` calls.  
+All public-facing state is exposed as dictionaries and is safe to serialize.
+
+---
+
+## Core Design Principles
+
+- Deterministic, persistent state core  
+- Explicit state transitions via `step()`  
+- No hidden execution or side effects  
+- Public API remains dict-based and serialization-safe  
+- Internal typed representations may exist but never leak  
+- Designed to be expanded around a stable core  
+
+### Ghost does NOT:
+
+- Choose actions  
+- Generate dialogue  
+- Interpret semantics  
+- Store memory implicitly  
+
+These responsibilities belong to external systems that consume Ghost’s state.
+
+---
+
+## Stability & Guarantees (v0.2.2)
+
+Ghost Engine v0.2.2 strengthens runtime correctness and serialization guarantees across public engine state.
+
+The engine guarantees:
+
+- Deterministic runtime behavior (same inputs → same outputs)  
+- Explicit, bounded state mutation per step  
+- Actor state updates across interactions  
+- Actor-level threat accumulation tracking  
+- Pairwise relationship mutation with symmetric consistency  
+- Bounded cascade propagation across interaction networks  
+- Deterministic nonlinear modulation of global system tension  
+- Passive decay behavior during idle cycles  
+- Fully JSON-safe public state and immutable snapshots  
+
+These guarantees hold under repeated execution, long-run simulation, and adversarial input streams.
+
+---
+
+## Architectural Expansion (v0.2.x)
+
+Recent releases introduce the first fully operational multi-agent interaction model on top of Ghost’s deterministic state core.
+
+### Key Capabilities
+
+**Agent State Mutation**  
+Agents maintain evolving internal state (mood, tension, last intent) and react deterministically to interaction signals.
+
+**Relationship Graph**  
+Pairwise relationships evolve through explicit interaction deltas, supporting long-term system memory without hidden state.
+
+**Bounded Cascade Propagation**  
+Signals propagate deterministically through local interaction networks with strict bounds to prevent runaway behavior.
+
+**Global System Tension**  
+The engine tracks shared system pressure across interactions using deterministic nonlinear modulation.
+
+**Actor Threat Memory**  
+Agents maintain explicit per-actor threat accumulation history for structured introspection.
+
+**Idle-State Decay Dynamics**  
+Bounded passive decay improves long-run stability and prevents runaway system pressure.
+
+---
+
+## Testing Philosophy
+
+Ghost uses property-based testing and invariant validation rather than relying solely on example-driven tests.
+
+Core validation includes:
+
+- determinism verification  
+- bounded-state guarantees  
+- serialization safety validation  
+
+This ensures the engine remains correct and predictable as new systems are layered on top.
+
+---
+
+## Project Structure
+
+```
+ghost/        core engine modules  
+tests/        invariant and runtime tests  
+npc_demo.py   experimental sandbox  
+pyproject.toml build configuration  
+```
+
+Demos are intentionally minimal and act as experimental sandboxes.  
+They are not representative of Ghost’s final scope.
+
+---
+
+## Status
+
+Ghost Engine remains in early development.
+
+As of v0.2.x:
+
+- The deterministic interaction core is stable  
+- APIs may still evolve  
+- Higher-level systems remain intentionally external  
+
+This project is intended as a foundation for experimentation, research, and future system design rather than a finished product.
+
+---
+
+## Release History
+
+**v0.2.2**
+- Fixed public state serialization issue in relationship subsystem  
+- Replaced set-based storage with JSON-safe structures  
+- Strengthened invariant coverage across runtime state  
+
+**v0.2.1**
+- Added actor-level threat accumulation tracking  
+- Introduced deterministic nonlinear system modulation  
+- Implemented passive idle-cycle decay  
+- Added immutable JSON-safe snapshots  
+
+**v0.2.0**
+- Introduced multi-agent state mutation  
+- Added relationship mutation logic  
+- Implemented bounded cascade propagation  
+- Achieved deterministic runtime guarantees  
+
+**v0.1.x**
+- Foundational architecture releases

ghocentric_ghost_engine-0.2.2/ghocentric_ghost_engine.egg-info/PKG-INFO

@@ -0,0 +1,186 @@
+Metadata-Version: 2.4
+Name: ghocentric-ghost-engine
+Version: 0.2.2
+Summary: Ghost cognitive engine
+Author: Shane Heckathorn
+License: MIT
+Keywords: ai,engine,cognition,simulation
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# ghocentric-ghost-engine
+
+A lightweight, deterministic internal state engine for experimenting with persistent state, temporal dynamics, and emergent behavior in interactive systems.
+
+Ghost is **NOT** a language model and **NOT** a decision-maker.  
+It is a minimal, stateful core designed to accumulate interaction signals over time and expose them in a clean, predictable, and serialization-safe way.
+
+This project is intentionally focused on architecture and correctness first. Surface features, integrations, and higher-level reasoning systems are expected to be layered on top of the core.
+
+---
+
+## Installation
+
+```bash
+pip install ghocentric-ghost-engine
+```
+
+---
+
+## Basic Usage
+
+```python
+from ghost.engine import GhostEngine
+
+engine = GhostEngine()
+
+engine.step({
+    "source": "npc_engine",
+    "intent": "threat",
+    "actor": "player",
+    "target": "guard",
+    "intensity": 0.5,
+})
+
+state = engine.state()
+print(state["npc"]["threat_level"])
+```
+
+Ghost mutates state only through explicit `step()` calls.  
+All public-facing state is exposed as dictionaries and is safe to serialize.
+
+---
+
+## Core Design Principles
+
+- Deterministic, persistent state core  
+- Explicit state transitions via `step()`  
+- No hidden execution or side effects  
+- Public API remains dict-based and serialization-safe  
+- Internal typed representations may exist but never leak  
+- Designed to be expanded around a stable core  
+
+### Ghost does NOT:
+
+- Choose actions  
+- Generate dialogue  
+- Interpret semantics  
+- Store memory implicitly  
+
+These responsibilities belong to external systems that consume Ghost’s state.
+
+---
+
+## Stability & Guarantees (v0.2.2)
+
+Ghost Engine v0.2.2 strengthens runtime correctness and serialization guarantees across public engine state.
+
+The engine guarantees:
+
+- Deterministic runtime behavior (same inputs → same outputs)  
+- Explicit, bounded state mutation per step  
+- Actor state updates across interactions  
+- Actor-level threat accumulation tracking  
+- Pairwise relationship mutation with symmetric consistency  
+- Bounded cascade propagation across interaction networks  
+- Deterministic nonlinear modulation of global system tension  
+- Passive decay behavior during idle cycles  
+- Fully JSON-safe public state and immutable snapshots  
+
+These guarantees hold under repeated execution, long-run simulation, and adversarial input streams.
+
+---
+
+## Architectural Expansion (v0.2.x)
+
+Recent releases introduce the first fully operational multi-agent interaction model on top of Ghost’s deterministic state core.
+
+### Key Capabilities
+
+**Agent State Mutation**  
+Agents maintain evolving internal state (mood, tension, last intent) and react deterministically to interaction signals.
+
+**Relationship Graph**  
+Pairwise relationships evolve through explicit interaction deltas, supporting long-term system memory without hidden state.
+
+**Bounded Cascade Propagation**  
+Signals propagate deterministically through local interaction networks with strict bounds to prevent runaway behavior.
+
+**Global System Tension**  
+The engine tracks shared system pressure across interactions using deterministic nonlinear modulation.
+
+**Actor Threat Memory**  
+Agents maintain explicit per-actor threat accumulation history for structured introspection.
+
+**Idle-State Decay Dynamics**  
+Bounded passive decay improves long-run stability and prevents runaway system pressure.
+
+---
+
+## Testing Philosophy
+
+Ghost uses property-based testing and invariant validation rather than relying solely on example-driven tests.
+
+Core validation includes:
+
+- determinism verification  
+- bounded-state guarantees  
+- serialization safety validation  
+
+This ensures the engine remains correct and predictable as new systems are layered on top.
+
+---
+
+## Project Structure
+
+```
+ghost/        core engine modules  
+tests/        invariant and runtime tests  
+npc_demo.py   experimental sandbox  
+pyproject.toml build configuration  
+```
+
+Demos are intentionally minimal and act as experimental sandboxes.  
+They are not representative of Ghost’s final scope.
+
+---
+
+## Status
+
+Ghost Engine remains in early development.
+
+As of v0.2.x:
+
+- The deterministic interaction core is stable  
+- APIs may still evolve  
+- Higher-level systems remain intentionally external  
+
+This project is intended as a foundation for experimentation, research, and future system design rather than a finished product.
+
+---
+
+## Release History
+
+**v0.2.2**
+- Fixed public state serialization issue in relationship subsystem  
+- Replaced set-based storage with JSON-safe structures  
+- Strengthened invariant coverage across runtime state  
+
+**v0.2.1**
+- Added actor-level threat accumulation tracking  
+- Introduced deterministic nonlinear system modulation  
+- Implemented passive idle-cycle decay  
+- Added immutable JSON-safe snapshots  
+
+**v0.2.0**
+- Introduced multi-agent state mutation  
+- Added relationship mutation logic  
+- Implemented bounded cascade propagation  
+- Achieved deterministic runtime guarantees  
+
+**v0.1.x**
+- Foundational architecture releases

{ghocentric_ghost_engine-0.2.0 → ghocentric_ghost_engine-0.2.2}/ghost/engine.py

@@ -3,6 +3,21 @@ from ghost.step import GhostStep
 from ghost.agents import AgentRegistry
 from ghost.relationships import RelationshipGraph
 
+def _json_safe(x):
+
+    if isinstance(x, dict):
+        return {str(k): _json_safe(v) for k, v in x.items()}
+
+    if isinstance(x, list):
+        return [_json_safe(v) for v in x]
+
+    if isinstance(x, tuple):
+        return [_json_safe(v) for v in x]
+
+    if isinstance(x, set):
+        return sorted(_json_safe(v) for v in x)
+
+    return x
 
 def clamp(value: float, low: float, high: float) -> float:
     return max(low, min(high, value))
@@ -51,9 +66,15 @@ class GhostEngine:
         ctx["cycles"] += 1
 
         npc = ctx["npc"]
+        
+        # passive decay (only if no threat this step)
+        if step_data is None:
+            npc["threat_level"] = clamp(npc["threat_level"] - 0.02, 0.0, 999999.0)
 
         step: GhostStep | None = None
         public_input: dict | None = None
+        
+        
 
         # ---- Normalize input at boundary ----
         if step_data is not None:
@@ -125,6 +146,12 @@ class GhostEngine:
 
         elif step.intent == "threat":
             actor_state["mood"] = clamp(actor_state["mood"] - (0.05 * intensity), 0.0, 1.0)
+            
+            # actor memory invariant (public-facing)
+            actors_mem = npc.setdefault("actors", {})
+            entry = actors_mem.setdefault(step.actor, {})
+            entry["threat_count"] = entry.get("threat_count", 0) + 1
+            
             actor_state["tension"] = clamp(actor_state["tension"] + (0.06 * intensity), 0.0, 1.0)
 
             if target_state is not None:
@@ -149,7 +176,12 @@ class GhostEngine:
                     neighbor_state["mood"] = clamp(neighbor_state["mood"] - (0.03 * spread), 0.0, 1.0)
                     neighbor_state["tension"] = clamp(neighbor_state["tension"] + (0.08 * spread), 0.0, 1.0)
 
-            npc["threat_level"] = clamp(npc["threat_level"] + (0.50 * intensity), 0.0, 999999.0)
+            # emotional modulation (public invariant)
+            mood = ctx.get("state", {}).get("mood", 0.5)
+
+            gain = 0.50 * intensity * (0.5 + mood)
+
+            npc["threat_level"] = clamp(npc["threat_level"] + gain, 0.0, 999999.0)
 
         else:
             # Unknown or neutral intent -> mild decay only
@@ -168,4 +200,4 @@ class GhostEngine:
     def snapshot(self):
         """Return an immutable snapshot of engine state."""
         import copy
-        return copy.deepcopy(self._ctx)
+        return _json_safe(copy.deepcopy(self._ctx))

{ghocentric_ghost_engine-0.2.0 → ghocentric_ghost_engine-0.2.2}/ghost/relationships.py

@@ -4,7 +4,7 @@ class RelationshipGraph:
 
     Relationships are stored as:
 
-    ("A","B") → { trust, attachment }
+    ("A","B") -> { trust, attachment }
     """
 
     def __init__(self, ctx: dict):
@@ -13,10 +13,11 @@ class RelationshipGraph:
         self._neighbors = ctx.setdefault("neighbors", {})
 
     def _key(self, a: str, b: str):
-        return tuple(sorted((a, b)))
+        # JSON-safe key
+        a, b = sorted((a, b))
+        return f"{a}|{b}"
 
     def ensure_pair(self, a: str, b: str):
-
         key = self._key(a, b)
 
         rel = self._rels.setdefault(
@@ -27,9 +28,15 @@ class RelationshipGraph:
             },
         )
 
-        # Maintain neighbor index
-        self._neighbors.setdefault(a, set()).add(b)
-        self._neighbors.setdefault(b, set()).add(a)
+        # Maintain neighbor index as LISTS, not sets
+        self._neighbors.setdefault(a, [])
+        self._neighbors.setdefault(b, [])
+
+        if b not in self._neighbors[a]:
+            self._neighbors[a].append(b)
+
+        if a not in self._neighbors[b]:
+            self._neighbors[b].append(a)
 
         return rel
 
@@ -50,6 +57,6 @@ class RelationshipGraph:
 
     def all(self):
         return self._rels
-        
+
     def neighbors(self, agent_id: str):
-        return self._neighbors.get(agent_id, set())
+        return self._neighbors.get(agent_id, [])

{ghocentric_ghost_engine-0.2.0 → ghocentric_ghost_engine-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ghocentric-ghost-engine"
-version = "0.2.0"
+version = "0.2.2"
 description = "Ghost cognitive engine"
 readme = "README.md"
 requires-python = ">=3.9"

ghocentric_ghost_engine-0.2.0/PKG-INFO

@@ -1,174 +0,0 @@
-Metadata-Version: 2.4
-Name: ghocentric-ghost-engine
-Version: 0.2.0
-Summary: Ghost cognitive engine
-Author: Shane Heckathorn
-License: MIT
-Keywords: ai,engine,cognition,simulation
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-
-ghocentric-ghost-engine
-
-A lightweight, deterministic internal state engine for experimenting with persistent state, temporal dynamics, and emergent behavior in interactive systems.
-
-Ghost is NOT a language model and NOT a decision-maker. It is a minimal, stateful core designed to accumulate interaction signals over time and expose them in a clean, predictable, and serialization-safe way.
-
-This project is intentionally focused on architecture and correctness first. Surface features, integrations, and higher-level reasoning systems are expected to be layered on top of the core in later versions.
-
-
-INSTALLATION
-
-pip install ghocentric-ghost-engine
-
-
-BASIC USAGE
-
-from ghost.engine import GhostEngine
-
-engine = GhostEngine()
-
-engine.step({
-    "source": "npc_engine",
-    "intent": "threat",
-    "actor": "player",
-    "target": "guard",
-    "intensity": 0.5,
-})
-
-state = engine.state()
-print(state["npc"]["threat_level"])
-
-Ghost mutates state only via explicit step() calls.  
-All public-facing state is exposed as dictionaries and is safe to serialize.
-
-
-CORE DESIGN PRINCIPLES
-
-• Deterministic, persistent state core  
-• Explicit state transitions via step()  
-• No hidden execution or side effects  
-• Public API remains dict-based and serialization-safe  
-• Internal typed representations may exist but never leak  
-• Designed to be expanded around a stable core, not bloated prematurely  
-
-
-Ghost does NOT:
-
-• Choose actions  
-• Generate dialogue  
-• Interpret semantics  
-• Store memory implicitly  
-
-Those behaviors belong to external systems that consume Ghost’s state.
-
-
-STABILITY & GUARANTEES (v0.2.0)
-
-Ghost Engine v0.2.0 establishes the first fully functional deterministic interaction core.
-
-The engine now guarantees:
-
-• Deterministic runtime behavior (same inputs → same outputs)  
-• Explicit, bounded state mutation per step  
-• Actor state updates across interactions  
-• Pairwise relationship mutation with symmetric consistency  
-• Bounded cascade propagation across interaction networks  
-• Global tension tracking across the system  
-• Full JSON-safe serialization of engine state  
-
-These guarantees hold under repeated execution and adversarial input.
-
-
-ARCHITECTURAL EXPANSION (v0.2.0)
-
-Version 0.2.0 introduces the first fully operational multi-agent interaction model on top of Ghost’s deterministic state core.
-
-New capabilities include:
-
-Agent State Mutation  
-Agents now maintain evolving internal state (mood, tension, last intent) and react deterministically to interaction signals.
-
-Relationship Graph  
-Pairwise relationships now evolve through explicit interaction deltas, supporting long-term system memory without hidden state.
-
-Bounded Cascade Propagation  
-Signals propagate deterministically through an agent’s local interaction network with strict bounds to prevent runaway behavior.
-
-Global System Tension  
-The engine now tracks a shared global tension signal representing aggregate interaction pressure across the system.
-
-
-Why This Matters
-
-These changes allow Ghost-based systems to scale toward:
-
-• large multi-agent simulations  
-• social interaction modeling  
-• emergent behavioral systems  
-• game-world simulation engines  
-
-while preserving the deterministic, explicit-state philosophy of the core.
-
-
-TESTING PHILOSOPHY
-
-Ghost uses property-based testing and invariant validation rather than relying solely on example-driven tests.
-
-Core validation includes:
-
-• determinism verification  
-• clamping and bounded-state guarantees  
-• serialization safety validation  
-
-This ensures the engine remains correct and predictable as new systems and features are layered on top in future versions.
-
-
-PROJECT STRUCTURE
-
-ghost/        core engine modules  
-tests/        invariant and runtime tests  
-npc_demo.py   experimental sandbox for new ideas  
-pyproject.toml build and packaging configuration  
-
-Demos are intentionally minimal and act as experimental sandboxes.  
-They are not representative of Ghost’s final scope.
-
-
-STATUS
-
-Ghost Engine remains in early development.
-
-As of v0.2.0:
-
-• The deterministic interaction core is stable  
-• APIs may still evolve  
-• Higher-level systems remain intentionally external  
-
-This project is intended as a foundation for experimentation, research, and future system design rather than a finished product.
-
-
-RELEASE HISTORY
-
-v0.2.0  
-• Introduced real agent state mutation  
-• Added relationship mutation logic  
-• Implemented bounded cascade propagation  
-• Achieved deterministic runtime guarantees  
-• Achieved JSON-safe serialization baseline  
-
-v0.1.3  
-• AgentRegistry and neighbor indexing for scalable interaction graphs  
-
-v0.1.2  
-• Formal invariant verification using property-based testing  
-
-v0.1.1  
-• Core threat accumulation improvements  
-
-v0.1.0  
-• Initial public architecture release

ghocentric_ghost_engine-0.2.0/README.md

@@ -1,160 +0,0 @@
-ghocentric-ghost-engine
-
-A lightweight, deterministic internal state engine for experimenting with persistent state, temporal dynamics, and emergent behavior in interactive systems.
-
-Ghost is NOT a language model and NOT a decision-maker. It is a minimal, stateful core designed to accumulate interaction signals over time and expose them in a clean, predictable, and serialization-safe way.
-
-This project is intentionally focused on architecture and correctness first. Surface features, integrations, and higher-level reasoning systems are expected to be layered on top of the core in later versions.
-
-
-INSTALLATION
-
-pip install ghocentric-ghost-engine
-
-
-BASIC USAGE
-
-from ghost.engine import GhostEngine
-
-engine = GhostEngine()
-
-engine.step({
-    "source": "npc_engine",
-    "intent": "threat",
-    "actor": "player",
-    "target": "guard",
-    "intensity": 0.5,
-})
-
-state = engine.state()
-print(state["npc"]["threat_level"])
-
-Ghost mutates state only via explicit step() calls.  
-All public-facing state is exposed as dictionaries and is safe to serialize.
-
-
-CORE DESIGN PRINCIPLES
-
-• Deterministic, persistent state core  
-• Explicit state transitions via step()  
-• No hidden execution or side effects  
-• Public API remains dict-based and serialization-safe  
-• Internal typed representations may exist but never leak  
-• Designed to be expanded around a stable core, not bloated prematurely  
-
-
-Ghost does NOT:
-
-• Choose actions  
-• Generate dialogue  
-• Interpret semantics  
-• Store memory implicitly  
-
-Those behaviors belong to external systems that consume Ghost’s state.
-
-
-STABILITY & GUARANTEES (v0.2.0)
-
-Ghost Engine v0.2.0 establishes the first fully functional deterministic interaction core.
-
-The engine now guarantees:
-
-• Deterministic runtime behavior (same inputs → same outputs)  
-• Explicit, bounded state mutation per step  
-• Actor state updates across interactions  
-• Pairwise relationship mutation with symmetric consistency  
-• Bounded cascade propagation across interaction networks  
-• Global tension tracking across the system  
-• Full JSON-safe serialization of engine state  
-
-These guarantees hold under repeated execution and adversarial input.
-
-
-ARCHITECTURAL EXPANSION (v0.2.0)
-
-Version 0.2.0 introduces the first fully operational multi-agent interaction model on top of Ghost’s deterministic state core.
-
-New capabilities include:
-
-Agent State Mutation  
-Agents now maintain evolving internal state (mood, tension, last intent) and react deterministically to interaction signals.
-
-Relationship Graph  
-Pairwise relationships now evolve through explicit interaction deltas, supporting long-term system memory without hidden state.
-
-Bounded Cascade Propagation  
-Signals propagate deterministically through an agent’s local interaction network with strict bounds to prevent runaway behavior.
-
-Global System Tension  
-The engine now tracks a shared global tension signal representing aggregate interaction pressure across the system.
-
-
-Why This Matters
-
-These changes allow Ghost-based systems to scale toward:
-
-• large multi-agent simulations  
-• social interaction modeling  
-• emergent behavioral systems  
-• game-world simulation engines  
-
-while preserving the deterministic, explicit-state philosophy of the core.
-
-
-TESTING PHILOSOPHY
-
-Ghost uses property-based testing and invariant validation rather than relying solely on example-driven tests.
-
-Core validation includes:
-
-• determinism verification  
-• clamping and bounded-state guarantees  
-• serialization safety validation  
-
-This ensures the engine remains correct and predictable as new systems and features are layered on top in future versions.
-
-
-PROJECT STRUCTURE
-
-ghost/        core engine modules  
-tests/        invariant and runtime tests  
-npc_demo.py   experimental sandbox for new ideas  
-pyproject.toml build and packaging configuration  
-
-Demos are intentionally minimal and act as experimental sandboxes.  
-They are not representative of Ghost’s final scope.
-
-
-STATUS
-
-Ghost Engine remains in early development.
-
-As of v0.2.0:
-
-• The deterministic interaction core is stable  
-• APIs may still evolve  
-• Higher-level systems remain intentionally external  
-
-This project is intended as a foundation for experimentation, research, and future system design rather than a finished product.
-
-
-RELEASE HISTORY
-
-v0.2.0  
-• Introduced real agent state mutation  
-• Added relationship mutation logic  
-• Implemented bounded cascade propagation  
-• Achieved deterministic runtime guarantees  
-• Achieved JSON-safe serialization baseline  
-
-v0.1.3  
-• AgentRegistry and neighbor indexing for scalable interaction graphs  
-
-v0.1.2  
-• Formal invariant verification using property-based testing  
-
-v0.1.1  
-• Core threat accumulation improvements  
-
-v0.1.0  
-• Initial public architecture release

ghocentric_ghost_engine-0.2.0/ghocentric_ghost_engine.egg-info/PKG-INFO

@@ -1,174 +0,0 @@
-Metadata-Version: 2.4
-Name: ghocentric-ghost-engine
-Version: 0.2.0
-Summary: Ghost cognitive engine
-Author: Shane Heckathorn
-License: MIT
-Keywords: ai,engine,cognition,simulation
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-
-ghocentric-ghost-engine
-
-A lightweight, deterministic internal state engine for experimenting with persistent state, temporal dynamics, and emergent behavior in interactive systems.
-
-Ghost is NOT a language model and NOT a decision-maker. It is a minimal, stateful core designed to accumulate interaction signals over time and expose them in a clean, predictable, and serialization-safe way.
-
-This project is intentionally focused on architecture and correctness first. Surface features, integrations, and higher-level reasoning systems are expected to be layered on top of the core in later versions.
-
-
-INSTALLATION
-
-pip install ghocentric-ghost-engine
-
-
-BASIC USAGE
-
-from ghost.engine import GhostEngine
-
-engine = GhostEngine()
-
-engine.step({
-    "source": "npc_engine",
-    "intent": "threat",
-    "actor": "player",
-    "target": "guard",
-    "intensity": 0.5,
-})
-
-state = engine.state()
-print(state["npc"]["threat_level"])
-
-Ghost mutates state only via explicit step() calls.  
-All public-facing state is exposed as dictionaries and is safe to serialize.
-
-
-CORE DESIGN PRINCIPLES
-
-• Deterministic, persistent state core  
-• Explicit state transitions via step()  
-• No hidden execution or side effects  
-• Public API remains dict-based and serialization-safe  
-• Internal typed representations may exist but never leak  
-• Designed to be expanded around a stable core, not bloated prematurely  
-
-
-Ghost does NOT:
-
-• Choose actions  
-• Generate dialogue  
-• Interpret semantics  
-• Store memory implicitly  
-
-Those behaviors belong to external systems that consume Ghost’s state.
-
-
-STABILITY & GUARANTEES (v0.2.0)
-
-Ghost Engine v0.2.0 establishes the first fully functional deterministic interaction core.
-
-The engine now guarantees:
-
-• Deterministic runtime behavior (same inputs → same outputs)  
-• Explicit, bounded state mutation per step  
-• Actor state updates across interactions  
-• Pairwise relationship mutation with symmetric consistency  
-• Bounded cascade propagation across interaction networks  
-• Global tension tracking across the system  
-• Full JSON-safe serialization of engine state  
-
-These guarantees hold under repeated execution and adversarial input.
-
-
-ARCHITECTURAL EXPANSION (v0.2.0)
-
-Version 0.2.0 introduces the first fully operational multi-agent interaction model on top of Ghost’s deterministic state core.
-
-New capabilities include:
-
-Agent State Mutation  
-Agents now maintain evolving internal state (mood, tension, last intent) and react deterministically to interaction signals.
-
-Relationship Graph  
-Pairwise relationships now evolve through explicit interaction deltas, supporting long-term system memory without hidden state.
-
-Bounded Cascade Propagation  
-Signals propagate deterministically through an agent’s local interaction network with strict bounds to prevent runaway behavior.
-
-Global System Tension  
-The engine now tracks a shared global tension signal representing aggregate interaction pressure across the system.
-
-
-Why This Matters
-
-These changes allow Ghost-based systems to scale toward:
-
-• large multi-agent simulations  
-• social interaction modeling  
-• emergent behavioral systems  
-• game-world simulation engines  
-
-while preserving the deterministic, explicit-state philosophy of the core.
-
-
-TESTING PHILOSOPHY
-
-Ghost uses property-based testing and invariant validation rather than relying solely on example-driven tests.
-
-Core validation includes:
-
-• determinism verification  
-• clamping and bounded-state guarantees  
-• serialization safety validation  
-
-This ensures the engine remains correct and predictable as new systems and features are layered on top in future versions.
-
-
-PROJECT STRUCTURE
-
-ghost/        core engine modules  
-tests/        invariant and runtime tests  
-npc_demo.py   experimental sandbox for new ideas  
-pyproject.toml build and packaging configuration  
-
-Demos are intentionally minimal and act as experimental sandboxes.  
-They are not representative of Ghost’s final scope.
-
-
-STATUS
-
-Ghost Engine remains in early development.
-
-As of v0.2.0:
-
-• The deterministic interaction core is stable  
-• APIs may still evolve  
-• Higher-level systems remain intentionally external  
-
-This project is intended as a foundation for experimentation, research, and future system design rather than a finished product.
-
-
-RELEASE HISTORY
-
-v0.2.0  
-• Introduced real agent state mutation  
-• Added relationship mutation logic  
-• Implemented bounded cascade propagation  
-• Achieved deterministic runtime guarantees  
-• Achieved JSON-safe serialization baseline  
-
-v0.1.3  
-• AgentRegistry and neighbor indexing for scalable interaction graphs  
-
-v0.1.2  
-• Formal invariant verification using property-based testing  
-
-v0.1.1  
-• Core threat accumulation improvements  
-
-v0.1.0  
-• Initial public architecture release