arkaos 4.0.2 → 4.1.1

package/scripts/synapse-bridge.py

@@ -14,14 +14,61 @@ Exit codes: 0 = success, 1 = degraded (partial layers), 2 = error
 import argparse
 import json
 import os
+import re
 import sys
 import time
 from pathlib import Path
+from typing import Any
 
 # Resolve ArkaOS root from environment or script location
 ARKAOS_ROOT = Path(os.environ.get("ARKAOS_ROOT", Path(__file__).resolve().parent.parent))
 sys.path.insert(0, str(ARKAOS_ROOT))
 
+# Layer tags carrying the actually-injected KB counts (ground truth for
+# reconciling the model's self-reported `[arka:meta] kb=N`). The optional
+# ` degraded=keyword` suffix (RAG honesty, PR-3 v4.1) must still count.
+_KB_CONTEXT_TAG_RE = re.compile(r"\[kb-context:(\d+)[^\]]*\]")
+_KNOWLEDGE_TAG_RE = re.compile(r"\[knowledge:(\d+) chunks?[^\]]*\]")
+_KB_INJECTED_DIR = Path("/tmp/arkaos-kb-injected")
+
+
+def _count_injected_kb(result: Any) -> tuple[int, int]:
+    """Count KB notes (L2.5) and knowledge chunks (L3.5) actually injected."""
+    kb_notes = 0
+    chunks = 0
+    for lr in result.layers:
+        tag = lr.tag or ""
+        if lr.layer_id == "L2.5":
+            match = _KB_CONTEXT_TAG_RE.search(tag)
+            kb_notes = int(match.group(1)) if match else 0
+        elif lr.layer_id == "L3.5":
+            match = _KNOWLEDGE_TAG_RE.search(tag)
+            chunks = int(match.group(1)) if match else 0
+    return kb_notes, chunks
+
+
+def write_kb_injected_state(result: Any, session_id: str) -> None:
+    """Persist injected KB counts so the Stop hook can reconcile kb=N.
+
+    Skips silently when no real session id is available (a pid-derived
+    fallback id would never match the runtime's session id at Stop time).
+    """
+    from core.shared.safe_session_id import safe_session_id
+
+    sid = safe_session_id(session_id)
+    if not sid:
+        return
+    kb_notes, chunks = _count_injected_kb(result)
+    prev_umask = os.umask(0o077)
+    try:
+        _KB_INJECTED_DIR.mkdir(parents=True, exist_ok=True)
+        payload = {"kb_injected": kb_notes, "l35_chunks": chunks, "ts": time.time()}
+        (_KB_INJECTED_DIR / f"{sid}.json").write_text(
+            json.dumps(payload), encoding="utf-8"
+        )
+    finally:
+        os.umask(prev_umask)
+
 
 def load_constitution(root: Path) -> str:
     """Load and compress constitution rules."""
@@ -73,26 +120,21 @@ def load_commands_registry(root: Path) -> list:
         return []
 
 
-def main() -> int:
-    parser = argparse.ArgumentParser(description="Synapse Bridge — context injection for hooks")
-    parser.add_argument(
-        "--layers-only",
-        action="store_true",
-        help="Output layer breakdown instead of context string",
-    )
-    parser.add_argument("--root", type=str, default=str(ARKAOS_ROOT), help="ArkaOS root directory")
-    args = parser.parse_args()
+def run_bridge(
+    input_data: dict,
+    root: Path,
+    layers_only: bool = False,
+    raw: str = "",
+) -> tuple[dict, int]:
+    """Run the Synapse engine for a hook payload. Returns (output, exit_code).
 
-    root = Path(args.root)
+    Extracted from ``main()`` (PR-6 hook consolidation) so
+    ``core.hooks.user_prompt_submit`` can call the bridge in-process
+    instead of spawning a second python3. Exit codes match the script:
+    0 = success, 1 = degraded (import error), 2 = error.
+    """
     start = time.time()
 
-    # Read input from stdin
-    try:
-        raw = sys.stdin.read().strip()
-        input_data = json.loads(raw) if raw else {}
-    except (json.JSONDecodeError, Exception):
-        input_data = {}
-
     # Extract context fields
     user_input = input_data.get("user_input", "")
     if not user_input:
@@ -141,12 +183,15 @@ def main() -> int:
         except Exception:
             branch = ""
 
-        session_id = (
+        # Real runtime session id (used for kb=N reconciliation); the
+        # pid-derived fallback below is only for cache scoping and is
+        # deliberately excluded from reconciliation state.
+        runtime_session_id = (
             input_data.get("session_id")
             or os.environ.get("ARKAOS_SESSION_ID", "")
             or os.environ.get("CLAUDE_SESSION_ID", "")
-            or f"bridge-{os.getpid()}"
         )
+        session_id = runtime_session_id or f"bridge-{os.getpid()}"
 
         ctx = PromptContext(
             user_input=user_input,
@@ -162,6 +207,15 @@ def main() -> int:
         result = engine.inject(ctx)
         total_ms = int((time.time() - start) * 1000)
 
+        # Structural honesty: record how many KB notes L2.5 actually
+        # injected. Never raise — reconciliation is telemetry-only and
+        # must not degrade context injection itself.
+        try:
+            if runtime_session_id:
+                write_kb_injected_state(result, runtime_session_id)
+        except Exception:
+            pass
+
         # Record token usage in budget tracker
         try:
             from core.budget.manager import BudgetManager
@@ -183,7 +237,7 @@ def main() -> int:
         except Exception:
             pass  # Never block on budget tracking
 
-        if args.layers_only:
+        if layers_only:
             output = {
                 "context_string": result.context_string,
                 "layers": [
@@ -204,19 +258,41 @@ def main() -> int:
         else:
             output = {"context_string": result.context_string, "total_ms": total_ms}
 
-        print(json.dumps(output))
-        return 0
+        return output, 0
 
     except ImportError as e:
         # Python dependencies not available — output minimal context
         sys.stderr.write(f"synapse-bridge: import error: {e}\n")
-        print(json.dumps({"context_string": "", "error": str(e)}))
-        return 1
+        return {"context_string": "", "error": str(e)}, 1
 
     except Exception as e:
         sys.stderr.write(f"synapse-bridge: error: {e}\n")
-        print(json.dumps({"context_string": "", "error": str(e)}))
-        return 2
+        return {"context_string": "", "error": str(e)}, 2
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Synapse Bridge — context injection for hooks")
+    parser.add_argument(
+        "--layers-only",
+        action="store_true",
+        help="Output layer breakdown instead of context string",
+    )
+    parser.add_argument("--root", type=str, default=str(ARKAOS_ROOT), help="ArkaOS root directory")
+    args = parser.parse_args()
+
+    # Read input from stdin
+    try:
+        raw = sys.stdin.read().strip()
+        input_data = json.loads(raw) if raw else {}
+    except (json.JSONDecodeError, Exception):
+        input_data = {}
+        raw = ""
+
+    output, code = run_bridge(
+        input_data, Path(args.root), layers_only=args.layers_only, raw=raw
+    )
+    print(json.dumps(output))
+    return code
 
 
 if __name__ == "__main__":