arkaos 2.17.1 → 2.17.4

package/core/memory/rehydrator.py

@@ -0,0 +1,204 @@
+"""Context Rehydrator — rebuild context from persisted session.
+
+Restores:
+- Workflow position (current phase, completed phases)
+- Active violations
+- Pending deliverables
+- Agent handoff state
+- Previous outputs for context
+
+Called automatically on session start to restore state.
+"""
+
+import json
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+
+from core.memory.session_store import SessionStore, load_session, SessionMeta, WorkflowSnapshot
+
+
+@dataclass
+class RehydratedContext:
+    """Context rebuilt from a persisted session."""
+
+    session_id: str
+    project: str
+    workflow_snapshot: WorkflowSnapshot | None = None
+    recent_outputs: list[dict] = field(default_factory=list)
+    pending_items: list[str] = field(default_factory=list)
+    violations: list[dict] = field(default_factory=list)
+    metadata: dict = field(default_factory=dict)
+
+
+@dataclass
+class HandoffState:
+    """Agent handoff state for rehydration."""
+
+    from_agent: str
+    to_agent: str
+    task: str
+    context_summary: str
+    relevant_files: list[str] = field(default_factory=list)
+    at: str = ""
+
+
+class ContextRehydrator:
+    """Reconstruct context from persisted session data."""
+
+    def __init__(self, session_store: SessionStore):
+        self.store = session_store
+
+    def rehydrate(self) -> RehydratedContext:
+        """Rebuild complete context from session.
+
+        Returns:
+            RehydratedContext with all restored state
+        """
+        meta = self.store.load_meta()
+        workflow = self.store.load_workflow_snapshot()
+
+        if meta is None:
+            return RehydratedContext(
+                session_id=self.store.session_id,
+                project="unknown",
+            )
+
+        outputs = self._load_recent_outputs(limit=10)
+
+        return RehydratedContext(
+            session_id=meta.session_id,
+            project=meta.project,
+            workflow_snapshot=workflow,
+            recent_outputs=outputs,
+            pending_items=self._extract_pending_items(workflow),
+            violations=workflow.violations if workflow else [],
+            metadata=meta.metadata,
+        )
+
+    def _load_recent_outputs(self, limit: int = 10) -> list[dict]:
+        """Load recent agent outputs."""
+        outputs_dir = self.store._outputs_dir
+        if not outputs_dir.exists():
+            return []
+
+        all_outputs = []
+        for output_file in outputs_dir.glob("*.json"):
+            try:
+                data = json.loads(output_file.read_text(encoding="utf-8"))
+                if isinstance(data, list):
+                    all_outputs.extend(data[-limit:])
+                elif isinstance(data, dict):
+                    all_outputs.append(data)
+            except (json.JSONDecodeError, OSError):
+                pass
+
+        all_outputs.sort(key=lambda x: x.get("at", ""), reverse=True)
+        return all_outputs[-limit:]
+
+    def _extract_pending_items(self, workflow: WorkflowSnapshot | None) -> list[str]:
+        """Extract pending items from workflow snapshot."""
+        if workflow is None:
+            return []
+
+        pending = []
+        for phase_id, status in workflow.phases.items():
+            if status in ("pending", "in_progress"):
+                pending.append(phase_id)
+        return pending
+
+    def build_context_string(self) -> str:
+        """Build a context string for injection.
+
+        Returns:
+            Human-readable context summary
+        """
+        ctx = self.rehydrate()
+
+        lines = [
+            f"[SESSION] Resuming session: {ctx.session_id[:8]}",
+            f"[SESSION] Project: {ctx.project}",
+            "",
+        ]
+
+        if ctx.workflow_snapshot:
+            wf = ctx.workflow_snapshot
+            lines.append(f"[WORKFLOW] {wf.workflow_name}")
+            lines.append(f"[WORKFLOW] Current phase: {wf.current_phase}")
+            if ctx.pending_items:
+                lines.append(f"[WORKFLOW] Pending: {', '.join(ctx.pending_items)}")
+
+        if ctx.violations:
+            lines.append(f"[WORKFLOW] Violations: {len(ctx.violations)}")
+            for v in ctx.violations[-3:]:
+                lines.append(f"  - [{v.get('rule', '?')}] {v.get('detail', '')[:50]}")
+
+        if ctx.recent_outputs:
+            lines.append(f"[CONTEXT] {len(ctx.recent_outputs)} recent outputs available")
+
+        lines.append("")
+        lines.append("[SESSION] Type /session resume to continue from last state.")
+
+        return "\n".join(lines)
+
+    def get_handoff_state(self, from_agent: str, to_agent: str) -> HandoffState | None:
+        """Get handoff state between two agents.
+
+        Args:
+            from_agent: Source agent ID
+            to_agent: Target agent ID
+
+        Returns:
+            HandoffState if found, None otherwise
+        """
+        outputs = self.store.load_agent_outputs(from_agent)
+        if not outputs:
+            return None
+
+        last_output = outputs[-1]
+        context_summary = last_output.output[:500] if last_output.output else ""
+
+        return HandoffState(
+            from_agent=from_agent,
+            to_agent=to_agent,
+            task="continued from previous session",
+            context_summary=context_summary,
+            relevant_files=[],
+            at=last_output.at,
+        )
+
+
+def rehydrate_session(session_id: str) -> RehydratedContext | None:
+    """Convenience function to rehydrate a session.
+
+    Args:
+        session_id: Session UUID to rehydrate
+
+    Returns:
+        RehydratedContext or None if session not found
+    """
+    store = load_session(session_id)
+    if store is None:
+        return None
+    return ContextRehydrator(store).rehydrate()
+
+
+def build_resume_context() -> str:
+    """Build context string for session resume.
+
+    Returns:
+        Context string for injection
+    """
+    from core.memory.session_store import SessionStore
+
+    store = SessionStore()
+    active_id = store.get_active_session()
+    if not active_id:
+        return ""
+
+    session_store = load_session(active_id)
+    if session_store is None:
+        return ""
+
+    rehydrator = ContextRehydrator(session_store)
+    return rehydrator.build_context_string()

package/core/memory/session_store.py

@@ -0,0 +1,256 @@
+"""Session Memory Store — persist session state across restarts.
+
+Stores session data to ~/.arkaos/sessions/:
+- workflow-state.json: Current workflow phase, violations
+- agent-outputs/: Per-agent outputs from this session
+- session-meta.json: Session metadata (start time, project, etc.)
+
+Auto-saved on every state change. Loads automatically on session start.
+"""
+
+import json
+import uuid
+from dataclasses import dataclass, field, asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+def _sessions_dir() -> Path:
+    return Path.home() / ".arkaos" / "sessions"
+
+
+def _ensure_sessions_dir() -> Path:
+    sessions = _sessions_dir()
+    sessions.mkdir(parents=True, exist_ok=True)
+    return sessions
+
+
+@dataclass
+class SessionMeta:
+    """Metadata about a session."""
+
+    session_id: str
+    project: str
+    started_at: str
+    ended_at: str = ""
+    workflow_id: str = ""
+    agent_id: str = ""
+    metadata: dict = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class WorkflowSnapshot:
+    """Snapshot of workflow state at a point in time."""
+
+    workflow_id: str
+    workflow_name: str
+    current_phase: str
+    phases: dict[str, str]
+    violations: list[dict] = field(default_factory=list)
+    artifacts: list[str] = field(default_factory=list)
+    at: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class AgentOutput:
+    """Output from an agent during the session."""
+
+    agent_id: str
+    phase_id: str
+    output: str
+    at: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+class SessionStore:
+    """Persistent session memory store."""
+
+    def __init__(self, session_id: str | None = None):
+        self.session_id = session_id or str(uuid.uuid4())
+        self._sessions_dir = _ensure_sessions_dir()
+        self._session_dir = self._sessions_dir / self.session_id
+        self._session_dir.mkdir(parents=True, exist_ok=True)
+
+        self._meta_file = self._session_dir / "session-meta.json"
+        self._workflow_file = self._session_dir / "workflow-state.json"
+        self._outputs_dir = self._session_dir / "agent-outputs"
+        self._outputs_dir.mkdir(exist_ok=True)
+
+    def save_meta(self, meta: SessionMeta) -> None:
+        """Save session metadata."""
+        self._meta_file.write_text(json.dumps(meta.to_dict(), indent=2), encoding="utf-8")
+
+    def load_meta(self) -> SessionMeta | None:
+        """Load session metadata."""
+        if not self._meta_file.exists():
+            return None
+        try:
+            data = json.loads(self._meta_file.read_text(encoding="utf-8"))
+            return SessionMeta(**data)
+        except (json.JSONDecodeError, KeyError, OSError):
+            return None
+
+    def save_workflow_snapshot(self, snapshot: WorkflowSnapshot) -> None:
+        """Save workflow state snapshot."""
+        if not snapshot.at:
+            snapshot.at = datetime.now(timezone.utc).isoformat()
+        self._workflow_file.write_text(json.dumps(snapshot.to_dict(), indent=2), encoding="utf-8")
+
+    def load_workflow_snapshot(self) -> WorkflowSnapshot | None:
+        """Load workflow state snapshot."""
+        if not self._workflow_file.exists():
+            return None
+        try:
+            data = json.loads(self._workflow_file.read_text(encoding="utf-8"))
+            return WorkflowSnapshot(**data)
+        except (json.JSONDecodeError, KeyError, OSError):
+            return None
+
+    def save_agent_output(self, output: AgentOutput) -> None:
+        """Save an agent's output."""
+        if not output.at:
+            output.at = datetime.now(timezone.utc).isoformat()
+
+        file_path = self._outputs_dir / f"{output.agent_id}.json"
+        outputs = []
+        if file_path.exists():
+            try:
+                outputs = json.loads(file_path.read_text(encoding="utf-8"))
+            except json.JSONDecodeError:
+                outputs = []
+
+        outputs.append(output.to_dict())
+        file_path.write_text(json.dumps(outputs, indent=2), encoding="utf-8")
+
+    def load_agent_outputs(self, agent_id: str) -> list[AgentOutput]:
+        """Load all outputs for a specific agent."""
+        file_path = self._outputs_dir / f"{agent_id}.json"
+        if not file_path.exists():
+            return []
+
+        try:
+            data = json.loads(file_path.read_text(encoding="utf-8"))
+            return [AgentOutput(**o) for o in data]
+        except (json.JSONDecodeError, KeyError, OSError):
+            return []
+
+    def list_sessions(self, limit: int = 10) -> list[SessionMeta]:
+        """List recent sessions."""
+        sessions = []
+        for session_dir in sorted(
+            self._sessions_dir.iterdir(),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )[:limit]:
+            if session_dir.is_dir():
+                meta_file = session_dir / "session-meta.json"
+                if meta_file.exists():
+                    try:
+                        data = json.loads(meta_file.read_text(encoding="utf-8"))
+                        sessions.append(SessionMeta(**data))
+                    except (json.JSONDecodeError, KeyError):
+                        pass
+        return sessions
+
+    def get_active_session(self) -> str | None:
+        """Get the most recent active session ID."""
+        sessions = self.list_sessions(limit=1)
+        if sessions:
+            return sessions[0].session_id
+        return None
+
+    def end_session(self) -> None:
+        """Mark session as ended."""
+        meta = self.load_meta()
+        if meta:
+            meta.ended_at = datetime.now(timezone.utc).isoformat()
+            self.save_meta(meta)
+
+
+def create_session(project: str, agent_id: str = "", metadata: dict | None = None) -> SessionStore:
+    """Create a new session store.
+
+    Args:
+        project: Project name
+        agent_id: Agent ID creating the session
+        metadata: Additional metadata
+
+    Returns:
+        New SessionStore instance
+    """
+    store = SessionStore()
+    meta = SessionMeta(
+        session_id=store.session_id,
+        project=project,
+        started_at=datetime.now(timezone.utc).isoformat(),
+        agent_id=agent_id,
+        metadata=metadata or {},
+    )
+    store.save_meta(meta)
+    return store
+
+
+def load_session(session_id: str) -> SessionStore | None:
+    """Load an existing session by ID.
+
+    Args:
+        session_id: The session UUID
+
+    Returns:
+        SessionStore instance or None if not found
+    """
+    session_dir = _sessions_dir() / session_id
+    if not session_dir.exists():
+        return None
+
+    store = SessionStore(session_id=session_id)
+    if store.load_meta() is None:
+        return None
+    return store
+
+
+def load_or_create_session(project: str, agent_id: str = "") -> SessionStore:
+    """Load the most recent session or create a new one.
+
+    Args:
+        project: Project name
+        agent_id: Agent ID
+
+    Returns:
+        SessionStore for the session
+    """
+    sessions_dir = _sessions_dir()
+    if not sessions_dir.exists():
+        return create_session(project, agent_id)
+
+    sessions = []
+    for session_dir in sorted(
+        sessions_dir.iterdir(),
+        key=lambda p: p.stat().st_mtime,
+        reverse=True,
+    ):
+        if session_dir.is_dir():
+            meta_file = session_dir / "session-meta.json"
+            if meta_file.exists():
+                try:
+                    data = json.loads(meta_file.read_text(encoding="utf-8"))
+                    sessions.append(SessionMeta(**data))
+                except (json.JSONDecodeError, KeyError):
+                    pass
+
+    for session in sessions:
+        if not session.ended_at:
+            existing = load_session(session.session_id)
+            if existing:
+                return existing
+
+    return create_session(project, agent_id)

package/core/synapse/__init__.py

@@ -1,11 +1,18 @@
-"""Synapse v2 — 8-layer context injection engine.
+"""Synapse v2 — 10-layer context injection engine.
 
 Injects relevant context into every prompt with <100ms target latency
 and 65% context reduction through intelligent filtering.
 """
 
 from core.synapse.engine import SynapseEngine
-from core.synapse.layers import Layer, LayerResult, ForgeContextLayer
+from core.synapse.layers import Layer, LayerResult, ForgeContextLayer, SessionContextLayer
 from core.synapse.cache import LayerCache
 
-__all__ = ["SynapseEngine", "Layer", "LayerResult", "LayerCache", "ForgeContextLayer"]
+__all__ = [
+    "SynapseEngine",
+    "Layer",
+    "LayerResult",
+    "LayerCache",
+    "ForgeContextLayer",
+    "SessionContextLayer",
+]

package/core/synapse/engine.py

@@ -19,12 +19,13 @@ from core.synapse.cache import LayerCache
 @dataclass
 class SynapseResult:
     """Complete result of Synapse context injection."""
-    context_string: str          # The combined context to inject
-    layers: list[LayerResult]    # Individual layer results
-    total_ms: int                # Total computation time
-    total_tokens_est: int        # Estimated total tokens injected
-    cache_stats: dict            # Cache hit/miss statistics
-    layers_skipped: int          # Layers that returned empty results
+
+    context_string: str  # The combined context to inject
+    layers: list[LayerResult]  # Individual layer results
+    total_ms: int  # Total computation time
+    total_tokens_est: int  # Estimated total tokens injected
+    cache_stats: dict  # Cache hit/miss statistics
+    layers_skipped: int  # Layers that returned empty results
 
 
 class SynapseEngine:
@@ -83,13 +84,15 @@ class SynapseEngine:
         total_ms = int((time.time() - start) * 1000)
 
         # Record metrics
-        self._metrics.append({
-            "timestamp": time.time(),
-            "total_ms": total_ms,
-            "layers_computed": len(results),
-            "layers_skipped": skipped,
-            "tokens_injected": total_tokens,
-        })
+        self._metrics.append(
+            {
+                "timestamp": time.time(),
+                "total_ms": total_ms,
+                "layers_computed": len(results),
+                "layers_skipped": skipped,
+                "tokens_injected": total_tokens,
+            }
+        )
         # Keep only last 500 metrics
         if len(self._metrics) > 500:
             self._metrics = self._metrics[-500:]
@@ -166,10 +169,17 @@ def create_default_engine(
         Configured SynapseEngine ready to use.
     """
     from core.synapse.layers import (
-        ConstitutionLayer, DepartmentLayer, AgentLayer,
-        ProjectLayer, BranchLayer, CommandHintsLayer,
-        QualityGateLayer, TimeLayer, KnowledgeRetrievalLayer,
+        ConstitutionLayer,
+        DepartmentLayer,
+        AgentLayer,
+        ProjectLayer,
+        BranchLayer,
+        CommandHintsLayer,
+        QualityGateLayer,
+        TimeLayer,
+        KnowledgeRetrievalLayer,
         ForgeContextLayer,
+        SessionContextLayer,
     )
 
     engine = SynapseEngine()
@@ -186,5 +196,6 @@ def create_default_engine(
     engine.register_layer(QualityGateLayer())
     engine.register_layer(TimeLayer())
     engine.register_layer(ForgeContextLayer())
+    engine.register_layer(SessionContextLayer())
 
     return engine