build(agent): molt-x#ed374b iteration

AGENTS.md

@@ -1 +1,23 @@
 # SignalCanvas Agents
+
+Architecture & Testing Guide
+- Language: Python (package name: signalcanvas_graph_based_market_signal_s)
+- Core tech: Python 3.8+, dataclasses, simple cryptographic hashes for attestations
+- Tests: pytest-based test suite located in tests/
+- Build: python3 -m build to create wheels; test.sh runs tests and build to verify packaging
+- Run locally: bash test.sh
+
+Conventions
+- All code lives under signalcanvas_graph_based_market_signal_s/ with a lightweight delta-sync extension in delta_sync.py
+- Readable, minimal APIs: Graph primitives (SignalNode, Link, Scenario, HedgePlan), backtester, privacy, NLP
+- Adapters live in adapters.py and are designed to be extended for FIX/WebSocket and simulated venues
+
+Phases (as per MVP plan)
+- Phase 0: Graph core, 2 adapters, local replay engine
+- Phase 1: Delta-sync protocol + narrative templates
+- Phase 2: Cross-venue demo with governance ledger scaffolding
+
+How to contribute
+- Follow the repository’s existing Python packaging and test commands
+- Add new adapters or primitives with corresponding tests under tests/
+- Update README with usage and examples

README.md

@@ -1 +1,27 @@
 # SignalCanvas Graph-Based Market Signal Studio (MVP)
+
+Overview
+- A graph-based approach to model, visualize, replay, and audit cross-venue market signals.
+- Primitives include SignalNode, Link, Scenario, and HedgePlan with a Graph-of-Contracts registry for adapters to data feeds and risk engines.
+- Lightweight offline-first backtester and a delta-sync protocol to reconcile runs when streams reconnect.
+- Privacy-preserving signal sharing, narrative generation, and governance-ready provenance.
+
+What’s implemented now (MVP, 6–12 weeks plan):
+- Core graph primitives: SignalNode, Link, Scenario, HedgePlan are implemented in the graph module.
+- Adapters: two starter adapters provided (FIX feed and a simulated venue) for interoperability.
+- Local replay engine: backtester.replay_deltas provides a deterministic delta replay capability.
+- Delta-sync scaffolding: delta_sync module demonstrates a compact, testable delta-sync protocol (PlanDelta, signing, and reconciliation).
+- Privacy & governance: aggregate_signals provides DP-friendly privacy budgets; ledger provides tamper-evident logging for governance-like provenance.
+- NLP narrative: generate_narrative offers plain-language summaries anchored to plan deltas.
+- Registry and extensibility: Graph registry-like structure exists to map adapters to canonical primitives.
+
+Roadmap highlights (aligned with your MVP plan):
+- Phase 0 (done-ish): Graph core (SignalNode/Link/Scenario/HedgePlan) + 2 adapters + local replay engine.
+- Phase 1 (in progress): delta-sync protocol (signatures and reconcilable run histories) + NLP narrative templates.
+- Phase 2 (next): 1 cross-venue demo with 2 assets; governance ledger scaffolding.
+
+How to run tests and build (local verification):
+- Run unit tests: ./test.sh
+- Build wheel: python3 -m build --wheel --no-isolation
+
+If you want to dive in, check the delta_sync module for a compact API around PlanDelta creation, signing, and reconciliation.

signalcanvas_graph_based_market_signal_s/delta_sync.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List
+import time
+import hashlib
+
+
+@dataclass
+class PlanDelta:
+    plan_id: str
+    delta: Dict[str, float]
+    timestamp: float
+    version: int
+    signature: str = ""
+
+
+def sign_delta(plan_id: str, delta: Dict[str, float], timestamp: float, version: int, signer_key: str) -> str:
+    """Produce a simple deterministic signature for a PlanDelta.
+
+    This is a lightweight stand-in for cryptographic attestations used in a real system.
+    """
+    data = f"{plan_id}:{timestamp}:{version}:{delta}"
+    return hashlib.sha256((data + signer_key).encode()).hexdigest()
+
+
+def create_plan_delta(plan_id: str, delta: Dict[str, float], version: int, signer_key: str) -> PlanDelta:
+    ts = time.time()
+    sig = sign_delta(plan_id, delta, ts, version, signer_key)
+    return PlanDelta(plan_id=plan_id, delta=delta, timestamp=ts, version=version, signature=sig)
+
+
+def reconcile_runs(run_a: List[PlanDelta], run_b: List[PlanDelta]) -> Dict[str, float]:
+    """Naive reconciliation: apply deltas from both runs in order to obtain a merged state.
+
+    This demonstrates the concept of delta-sync across partitions. In a real system this would
+    include robust conflict resolution, versioning checks, and cryptographic attestations.
+    """
+    state: Dict[str, float] = {}
+
+    def apply(deltas: List[PlanDelta]) -> None:
+        for pd in deltas:
+            for k, v in pd.delta.items():
+                state[k] = state.get(k, 0.0) + v
+
+    apply(run_a)
+    apply(run_b)
+    return state