arkaos 2.17.0 → 2.17.4

package/config/hooks/post-tool-use.sh

@@ -229,6 +229,78 @@ add_violation('sequential-validation', 'Code written before implementation phase
   fi
 fi
 
+# ─── ArkaOS Enforcement Engine (All 14 Rules) ─────────────────────────────────
+# Uses core/workflow/enforcer.py to check ALL 14 NON-NEGOTIABLE rules
+# BLOCK violations halt operation; ESCALATE violations alert Tier 0
+# Gotchas auto-recovery is ALWAYS active (SIM per Sprint 3 decision)
+
+if [ -z "${ARKAOS_PY:-}" ]; then
+  [ -f "$HOME/.arkaos/venv/bin/python3" ] && ARKAOS_PY="$HOME/.arkaos/venv/bin/python3"
+  [ -z "${ARKAOS_PY:-}" ] && [ -f "$HOME/.arkaos/.venv/bin/python3" ] && ARKAOS_PY="$HOME/.arkaos/.venv/bin/python3"
+  [ -z "${ARKAOS_PY:-}" ] && ARKAOS_PY=$(command -v python3 2>/dev/null)
+fi
+[ -z "${ARKAOS_ROOT:-}" ] && ARKAOS_ROOT=$(cat "$HOME/.arkaos/.repo-path" 2>/dev/null)
+
+if [ -n "$ARKAOS_PY" ] && [ -n "$ARKAOS_ROOT" ] && [ -f "$ARKAOS_ROOT/core/workflow/enforcer.py" ]; then
+  ENFORCER_OUTPUT=$(PYTHONPATH="$ARKAOS_ROOT" $ARKAOS_PY -c "
+import json, sys
+from core.workflow.enforcer import enforce_tool
+from core.workflow.state import add_violation
+
+input_data = json.loads(sys.stdin.read())
+tool_name = input_data.get('tool_name', '')
+command = input_data.get('command', '')
+file_path = input_data.get('file_path', '')
+user_input = input_data.get('user_input', '')
+
+extra = {}
+if tool_name == 'Bash':
+    import subprocess
+    try:
+        branch = subprocess.check_output(['git', 'branch', '--show-current'], text=True, stderr=subprocess.DEVNULL).strip()
+        extra['git_branch'] = branch
+    except:
+        extra['git_branch'] = ''
+
+result = enforce_tool(
+    tool_name=tool_name,
+    command=command,
+    file_path=file_path,
+    user_input=user_input,
+    **extra
+)
+
+if result.violations:
+    for v in result.violations:
+        try:
+            add_violation(v.rule_id, v.message, v.tool, v.file_path, v.severity)
+        except:
+            pass
+
+    print(json.dumps({
+        'violations': [v.to_dict() for v in result.violations],
+        'blocked': result.blocked,
+        'escalated': result.escalated,
+        'messages': result.messages
+    }))
+else:
+    print(json.dumps({'violations': [], 'blocked': False, 'escalated': False, 'messages': []}))
+" <<< "$input" 2>/dev/null)
+
+  if [ -n "$ENFORCER_OUTPUT" ] && echo "$ENFORCER_OUTPUT" | jq -e '.violations | length > 0' &>/dev/null; then
+    ENFORCER_BLOCKED=$(echo "$ENFORCER_OUTPUT" | jq -r '.blocked')
+    ENFORCER_MESSAGES=$(echo "$ENFORCER_OUTPUT" | jq -r '.messages | join("|")')
+
+    for msg in $(echo "$ENFORCER_MESSAGES" | tr '|' '\n'); do
+      [ -n "$msg" ] && VIOLATION_MSG="${VIOLATION_MSG}${VIOLATION_MSG:+$'\n'}${msg}"
+    done
+
+    if [ "$ENFORCER_BLOCKED" = "true" ]; then
+      VIOLATION_MSG="🔴 BLOCK: ${VIOLATION_MSG}"
+    fi
+  fi
+fi
+
 # --- Forge Violation Detection ---
 _FORGE_ACTIVE="$HOME/.arkaos/plans/active.yaml"
 

package/config/hooks/session-start.sh

@@ -89,6 +89,22 @@ MSG+="ArkaOS v${VERSION} | 65 agents | 17 departments | 244+ skills"
 [ -n "$_FORGE_LINE" ] && MSG+="\\n${_FORGE_LINE}"
 MSG+="${DRIFT}"
 
+# --- Session Memory Resume Context ---
+if command -v python3 &>/dev/null && [ -n "$REPO" ]; then
+  _SESSION_CTX=$(cd "$REPO" && python3 -c "
+import sys
+sys.path.insert(0, '$REPO')
+try:
+    from core.memory.rehydrator import build_resume_context
+    ctx = build_resume_context()
+    if ctx:
+        print('\\n[SESSION] ' + ctx.replace('\\n', '\\n[SESSION] '))
+except Exception:
+    pass
+" 2>/dev/null)
+  [ -n "$_SESSION_CTX" ] && MSG+="\\n${_SESSION_CTX}"
+fi
+
 # ─── Output as systemMessage (same protocol as claude-mem) ─────────────
 python3 -c "
 import json

package/config/hooks/user-prompt-submit.ps1

@@ -199,9 +199,9 @@ if ($python -and (Test-Path -LiteralPath $bridgeScript)) {
         $proc = [System.Diagnostics.Process]::Start($psi)
         $proc.StandardInput.Write($bridgeInput)
         $proc.StandardInput.Close()
-        # Cap the bridge call at 3 seconds so a stuck bridge cannot burn the
+        # Cap the bridge call at 8 seconds so a stuck bridge cannot burn the
         # full 10-second hook budget.
-        if (-not $proc.WaitForExit(3000)) {
+        if (-not $proc.WaitForExit(8000)) {
             try { $proc.Kill() } catch { }
         } else {
             $bridgeOutput = $proc.StandardOutput.ReadToEnd()
@@ -263,8 +263,14 @@ if (-not $pythonResult) {
     $pythonResult = (@($l0, $l4, $l7) | Where-Object { $_ }) -join ' '
 }
 
+# --- Persistent Routing Reminder -------------------------------------------
+# High-salience tag - ensures squad routing persists across conversation turns,
+# and enforces visible KB citation when chunks are present.
+# See: docs/superpowers/specs/2026-04-14-persistent-routing-reminder-design.md
+$routeReminder = '[arka:route] Every response MUST route through a department squad. No generic assistant replies. Announce the squad before responding. When [knowledge:N chunks] is present in this context, you MUST cite at least one source and acknowledge KB was consulted; if absent on a non-trivial ArkaOS topic, query Obsidian before responding.'
+
 # --- Output ----------------------------------------------------------------
-$additionalContext = "$syncNotice$pythonResult"
+$additionalContext = "$syncNotice$routeReminder $pythonResult"
 [pscustomobject]@{ additionalContext = $additionalContext } | ConvertTo-Json -Compress
 
 # --- Metrics (JSONL append) ------------------------------------------------

package/config/hooks/user-prompt-submit.sh

@@ -40,6 +40,9 @@ if [ -f "$ARKAOS_VERSION_FILE" ]; then
     if [ "$_CURRENT_VERSION" != "$_SYNCED_VERSION" ]; then
       _SYNC_NOTICE="[arka:update-available] ArkaOS v${_CURRENT_VERSION} installed (synced: ${_SYNCED_VERSION}). Run /arka update to sync all projects. "
     fi
+    if [ -n "${ARKAOS_DEBUG:-}" ]; then
+      echo "[DEBUG] Detected version: ${_CURRENT_VERSION:-unknown}, synced: ${_SYNCED_VERSION:-none}" >&2
+    fi
   fi
 fi
 
@@ -92,42 +95,110 @@ fi
 python_result=""
 BRIDGE_SCRIPT="${ARKAOS_ROOT}/scripts/synapse-bridge.py"
 
+# Determine which path we're using for debug output
+if [ -n "${ARKAOS_DEBUG:-}" ]; then
+  echo "[DEBUG] ARKAOS_ROOT=${ARKAOS_ROOT}" >&2
+  echo "[DEBUG] BRIDGE_SCRIPT=${BRIDGE_SCRIPT}" >&2
+fi
+
 if command -v python3 &>/dev/null && [ -f "$BRIDGE_SCRIPT" ]; then
-  bridge_output=$(echo "{\"user_input\":$(echo "$user_input" | python3 -c "import sys,json; print(json.dumps(sys.stdin.read()))" 2>/dev/null || echo '""')}" \
-    | ARKAOS_ROOT="$ARKAOS_ROOT" python3 "$BRIDGE_SCRIPT" --root "$ARKAOS_ROOT" 2>/dev/null)
+  # Validate ARKAOS_ROOT before calling bridge
+  if [ ! -d "$ARKAOS_ROOT" ]; then
+    if [ -n "${ARKAOS_DEBUG:-}" ]; then
+      echo "[DEBUG] ARKAOS_ROOT is not a valid directory, skipping Python bridge" >&2
+    fi
+  else
+    _bridge_start=$(date +%s%N 2>/dev/null || echo "0")
+    bridge_output=$(echo "{\"user_input\":$(echo "$user_input" | python3 -c "import sys,json; print(json.dumps(sys.stdin.read()))" 2>/dev/null || echo '""')}" \
+      | ARKAOS_ROOT="$ARKAOS_ROOT" python3 "$BRIDGE_SCRIPT" --root "$ARKAOS_ROOT" 2>/dev/null)
+    _bridge_status=$?
 
-  if [ -n "$bridge_output" ]; then
-    python_result=$(echo "$bridge_output" | python3 -c "import sys,json; print(json.loads(sys.stdin.read()).get('context_string',''))" 2>/dev/null)
-  fi
+    if [ -n "${ARKAOS_DEBUG:-}" ]; then
+      if [ "$_bridge_start" != "0" ] && [ $(date +%s%N 2>/dev/null || echo "0") != "0" ]; then
+        _bridge_ms=$(( ($(date +%s%N) - _bridge_start) / 1000000 ))
+        echo "[DEBUG] bridge completed in ${_bridge_ms}ms, exit=$_bridge_status" >&2
+      fi
+      echo "[DEBUG] bridge_output length=${#bridge_output}" >&2
+    fi
 
-  # Append workflow state to synapse context
-  _WF_READER="$ARKAOS_ROOT/core/workflow/state_reader.sh"
-  if [ -f "$_WF_READER" ] && bash "$_WF_READER" active 2>/dev/null; then
-    _WF_SUM=$(bash "$_WF_READER" summary 2>/dev/null)
-    _WF_N=$(echo "$_WF_SUM" | cut -d'|' -f1)
-    _WF_P=$(echo "$_WF_SUM" | cut -d'|' -f2)
-    _WF_B=$(echo "$_WF_SUM" | cut -d'|' -f4)
-    _WF_V=$(echo "$_WF_SUM" | cut -d'|' -f5)
-    _WF_TAG="[workflow:${_WF_N}] [phase:${_WF_P}] [branch:${_WF_B}] [violations:${_WF_V}]"
-    [ "$_WF_V" != "0" ] && _WF_TAG="WARNING: ${_WF_V} workflow violation(s). $_WF_TAG"
-    python_result="${python_result} ${_WF_TAG}"
+    if [ -n "$bridge_output" ] && [ $_bridge_status -eq 0 ]; then
+      python_result=$(echo "$bridge_output" | python3 -c "import sys,json; print(json.loads(sys.stdin.read()).get('context_string',''))" 2>/dev/null)
+      if [ -n "${ARKAOS_DEBUG:-}" ]; then
+        echo "[DEBUG] python_result length=${#python_result}" >&2
+      fi
+    elif [ -n "${ARKAOS_DEBUG:-}" ]; then
+      echo "[DEBUG] bridge failed or returned empty, exit=$_bridge_status" >&2
+    fi
   fi
 
-  # --- Forge Context Injection ---
-  _FORGE_ACTIVE="$HOME/.arkaos/plans/active.yaml"
-  if [ -f "$_FORGE_ACTIVE" ]; then
-    _FORGE_ID=$(cat "$_FORGE_ACTIVE" 2>/dev/null)
-    _FORGE_FILE="$HOME/.arkaos/plans/${_FORGE_ID}.yaml"
-    if [ -f "$_FORGE_FILE" ] && command -v python3 &>/dev/null; then
-      _FORGE_STATUS=$(FORGE_FILE="$_FORGE_FILE" python3 -c "import yaml,os; d=yaml.safe_load(open(os.environ['FORGE_FILE'])); print(d.get('status',''))" 2>/dev/null)
-      _FORGE_TAG="[forge:${_FORGE_ID}] [forge-status:${_FORGE_STATUS}]"
-      python_result="${python_result} ${_FORGE_TAG}"
+  # Append workflow state to synapse context (always, if python result was set)
+  if [ -n "$python_result" ]; then
+    _WF_READER="$ARKAOS_ROOT/core/workflow/state_reader.sh"
+    if [ -f "$_WF_READER" ] && bash "$_WF_READER" active 2>/dev/null; then
+      _WF_SUM=$(bash "$_WF_READER" summary 2>/dev/null)
+      _WF_N=$(echo "$_WF_SUM" | cut -d'|' -f1)
+      _WF_P=$(echo "$_WF_SUM" | cut -d'|' -f2)
+      _WF_B=$(echo "$_WF_SUM" | cut -d'|' -f4)
+      _WF_V=$(echo "$_WF_SUM" | cut -d'|' -f5)
+      _WF_TAG="[workflow:${_WF_N}] [phase:${_WF_P}] [branch:${_WF_B}] [violations:${_WF_V}]"
+      [ "$_WF_V" != "0" ] && _WF_TAG="WARNING: ${_WF_V} workflow violation(s). $_WF_TAG"
+      python_result="${python_result} ${_WF_TAG}"
+    fi
+
+    # --- Forge Context Injection ---
+    _FORGE_ACTIVE="$HOME/.arkaos/plans/active.yaml"
+    if [ -f "$_FORGE_ACTIVE" ]; then
+      _FORGE_ID=$(cat "$_FORGE_ACTIVE" 2>/dev/null)
+      _FORGE_FILE="$HOME/.arkaos/plans/${_FORGE_ID}.yaml"
+      if [ -f "$_FORGE_FILE" ] && command -v python3 &>/dev/null; then
+        _FORGE_STATUS=$(FORGE_FILE="$_FORGE_FILE" python3 -c "import yaml,os; d=yaml.safe_load(open(os.environ['FORGE_FILE'])); print(d.get('status',''))" 2>/dev/null)
+        _FORGE_TAG="[forge:${_FORGE_ID}] [forge-status:${_FORGE_STATUS}]"
+        python_result="${python_result} ${_FORGE_TAG}"
+      fi
+    fi
+
+    # --- Knowledge Auto-Inject (On-Demand via Session Cache) ---
+    if [ -n "$python_result" ] && [[ "$python_result" == *"[knowledge:"* ]]; then
+      _KB_SESSION_ID="${ARKAOS_SESSION_ID:-${CLAUDE_SESSION_ID:-bridge-$$}}"
+      _KB_PROJECT_HASH=$(echo "$ARKAOS_ROOT" | md5sum 2>/dev/null | cut -c1-12 || echo "default")
+      _KB_CACHE_DIR="/tmp/arkaos-kb-${_KB_PROJECT_HASH}"
+
+      if [ -n "${ARKAOS_DEBUG:-}" ]; then
+        echo "[DEBUG] KB session_id=${_KB_SESSION_ID}, project_hash=${_KB_PROJECT_HASH}" >&2
+      fi
+
+      if [ -d "$_KB_CACHE_DIR" ] && command -v python3 &>/dev/null; then
+        _KB_CONTENT=$(python3 -c "
+import sys
+sys.path.insert(0, '$ARKAOS_ROOT')
+from core.synapse.kb_cache import KBSessionCache
+cache = KBSessionCache(session_id='$_KB_SESSION_ID', project_path='$ARKAOS_ROOT')
+results = cache.get_overlap('''$user_input''', threshold=0.3)
+if results:
+    snippets = []
+    for r in results[:3]:
+        src = r.get('source', '').split('/')[-1] if r.get('source') else ''
+        txt = r.get('text', '')[:200].replace('\n', ' ')
+        snippets.append(f'{src}: {txt}' if src else txt)
+    print(' | '.join(snippets))
+" 2>/dev/null)
+
+        if [ -n "$_KB_CONTENT" ]; then
+          if [ -n "${ARKAOS_DEBUG:-}" ]; then
+            echo "[DEBUG] KB auto-inject: ${#_KB_CONTENT} chars of knowledge" >&2
+          fi
+          python_result="${_KB_CONTENT} ${python_result}"
+        fi
+      fi
     fi
   fi
 fi
 
 # ─── Fallback: Bash-only context (if Python unavailable) ────────────────
 if [ -z "$python_result" ]; then
+  if [ -n "${ARKAOS_DEBUG:-}" ]; then
+    echo "[DEBUG] Using bash fallback (python_result was empty)" >&2
+  fi
   # L0: Constitution (cached)
   L0=""
   L0_CACHE="$CACHE_DIR/l0-constitution"
@@ -193,8 +264,19 @@ if [ -f "$_HYGIENE_SCRIPT" ]; then
              bash "$_HYGIENE_SCRIPT" 2>/dev/null)
 fi
 
+# ─── Persistent Routing Reminder ────────────────────────────────────────
+# High-salience tag — ensures squad routing persists across conversation turns,
+# not just on turn 1 when /arka skill content is fresh. See spec:
+# docs/superpowers/specs/2026-04-14-persistent-routing-reminder-design.md
+_ROUTE_REMINDER="
+[ARKA:ROUTE]
+EVERY response MUST route through a department squad.
+NO generic assistant replies. Announce the squad before responding.
+When [knowledge:N chunks] is present, cite at least one source.
+If [knowledge:N chunks] is absent on a non-trivial ArkaOS topic, query Obsidian first."
+
 # ─── Output ──────────────────────────────────────────────────────────────
-_OUT_CONTEXT="${_ARKA_GREETING:-}${_SYNC_NOTICE:-}$python_result"
+_OUT_CONTEXT="${_ARKA_GREETING:-}${_SYNC_NOTICE:-}${_ROUTE_REMINDER} $python_result"
 [ -n "$_HYGIENE" ] && _OUT_CONTEXT="$_OUT_CONTEXT $_HYGIENE"
 # Escape for JSON
 _OUT_JSON=$(python3 -c "import json,sys; print(json.dumps(sys.stdin.read()))" <<< "$_OUT_CONTEXT" 2>/dev/null)

package/core/agents/adapters/disc_adapter.py

@@ -0,0 +1,149 @@
+"""DISC Communication Adapter — adapt messages based on recipient's DISC profile.
+
+When sending a message to another agent, this adapter modifies the message
+tone and structure to match the recipient's preferred communication style.
+"""
+
+from core.agents.dna_registry import DNARegistry, get_registry
+from core.agents.schema import Agent, DISCType
+
+
+TONE_ADAPTERS = {
+    DISCType.D: {
+        "prefix": "",
+        "suffix": "",
+        "structure": "bullet_summary_first",
+        "urgency_words": ["critical", "key", "essential", "must", "need"],
+        "peace_words": [],
+        "opening": "Direct.",
+    },
+    DISCType.I: {
+        "prefix": "",
+        "suffix": "",
+        "structure": "friendly_narrative",
+        "urgency_words": ["exciting", "great", "amazing", "fantastic"],
+        "peace_words": [],
+        "opening": "Hey!",
+    },
+    DISCType.S: {
+        "prefix": "",
+        "suffix": "",
+        "structure": "supportive_explanation",
+        "urgency_words": [],
+        "peace_words": ["steady", "reliable", "together", "support", "help"],
+        "opening": "",
+    },
+    DISCType.C: {
+        "prefix": "",
+        "suffix": "",
+        "structure": "structured_data_first",
+        "urgency_words": [],
+        "peace_words": ["thorough", "precise", "accurate", "detailed"],
+        "opening": "Analysis:",
+    },
+}
+
+
+class DISCAdapter:
+    """Adapt messages for recipients based on their DISC profile."""
+
+    def __init__(self, registry: DNARegistry | None = None):
+        self.registry = registry or get_registry()
+
+    def adapt_message(
+        self,
+        message: str,
+        sender_id: str,
+        recipient_id: str,
+    ) -> str:
+        """Adapt a message for the recipient's DISC profile.
+
+        Args:
+            message: The original message to adapt
+            sender_id: ID of the sending agent
+            recipient_id: ID of the receiving agent
+
+        Returns:
+            Adapted message optimized for the recipient
+        """
+        sender = self.registry.get(sender_id)
+        recipient = self.registry.get(recipient_id)
+
+        if not sender or not recipient:
+            return message
+
+        recipient_disc = recipient.behavioral_dna.disc.primary
+        adapter = TONE_ADAPTERS.get(recipient_disc)
+
+        if not adapter:
+            return message
+
+        adapted = message
+
+        if adapter["opening"]:
+            if not adapted.startswith(adapter["opening"]):
+                adapted = f"{adapter['opening']} {adapted}"
+
+        return adapted
+
+    def get_opening(self, recipient_id: str) -> str:
+        """Get the appropriate opening for a recipient."""
+        recipient = self.registry.get(recipient_id)
+        if not recipient:
+            return ""
+
+        disc = recipient.behavioral_dna.disc.primary
+        return TONE_ADAPTERS.get(disc, {}).get("opening", "")
+
+    def get_structure_hint(self, recipient_id: str) -> str:
+        """Get the recommended message structure for a recipient."""
+        recipient = self.registry.get(recipient_id)
+        if not recipient:
+            return "standard"
+
+        disc = recipient.behavioral_dna.disc.primary
+        return TONE_ADAPTERS.get(disc, {}).get("structure", "standard")
+
+    def adapt_for_disc(
+        self,
+        message: str,
+        target_disc: DISCType,
+    ) -> str:
+        """Adapt a message directly for a DISC type.
+
+        Args:
+            message: Original message
+            target_disc: Target DISC type
+
+        Returns:
+            Adapted message
+        """
+        adapter = TONE_ADAPTERS.get(target_disc, {})
+        if not adapter:
+            return message
+
+        adapted = message
+        if adapter["opening"]:
+            if not adapted.startswith(adapter["opening"]):
+                adapted = f"{adapter['opening']} {adapted}"
+
+        return adapted
+
+
+def adapt_message(
+    message: str,
+    sender_id: str,
+    recipient_id: str,
+) -> str:
+    """Convenience function to adapt a message between two agents.
+
+    Args:
+        message: Original message
+        sender_id: ID of the sender
+        recipient_id: ID of the recipient
+
+    Returns:
+        Adapted message
+    """
+    adapter = DISCAdapter()
+    return adapter.adapt_message(message, sender_id, recipient_id)