@ekkos/cli 1.2.18 → 1.3.0

package/templates/cursor-hooks/lib/contract.sh

@@ -1,320 +0,0 @@
-#!/bin/bash
-# ═══════════════════════════════════════════════════════════════════════════
-# ekkOS_ Turn Contract Library
-#
-# Shared functions for Golden Loop compliance enforcement.
-# Used by BOTH Claude Code (.claude/) and Cursor (.cursor/) hooks.
-#
-# TURN CONTRACT: Evidence that retrieval occurred before answering.
-# This is the SINGLE SOURCE OF TRUTH for compliance auditing.
-# ═══════════════════════════════════════════════════════════════════════════
-
-# Get contract directory based on environment
-get_contract_dir() {
-  local source="${1:-claude-code}"
-  local project_root="${2:-$PROJECT_ROOT}"
-
-  if [ "$source" = "cursor" ]; then
-    echo "$project_root/.cursor/state/ekkos"
-  else
-    echo "$project_root/.claude/state/ekkos"
-  fi
-}
-
-# Generate stable hash of user prompt (for deduplication)
-generate_query_hash() {
-  local query="$1"
-  # Use md5 on macOS, md5sum on Linux
-  if command -v md5 >/dev/null 2>&1; then
-    echo -n "$query" | md5 | cut -c1-16
-  elif command -v md5sum >/dev/null 2>&1; then
-    echo -n "$query" | md5sum | cut -c1-16
-  else
-    # Fallback: simple hash using cksum
-    echo -n "$query" | cksum | cut -d' ' -f1
-  fi
-}
-
-# Write turn contract at RETRIEVAL time
-# This is the EVIDENCE that retrieval happened before answering
-write_turn_contract() {
-  local session_id="$1"
-  local retrieval_ok="$2"
-  local retrieval_source="$3"
-  local pattern_ids="$4"      # Comma-separated list
-  local directive_ids="$5"    # Comma-separated list
-  local query_hash="$6"
-  local project_root="${7:-$PROJECT_ROOT}"
-
-  local contract_dir
-  contract_dir=$(get_contract_dir "$retrieval_source" "$project_root")
-  mkdir -p "$contract_dir" 2>/dev/null || return 1
-
-  local contract_file="$contract_dir/turn-contract-${session_id}.json"
-  local timestamp
-  timestamp=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-
-  # Convert comma-separated IDs to JSON array
-  local pattern_array
-  local directive_array
-  if [ -n "$pattern_ids" ]; then
-    pattern_array=$(echo "$pattern_ids" | tr ',' '\n' | grep -v '^$' | jq -R . | jq -s .)
-  else
-    pattern_array="[]"
-  fi
-  if [ -n "$directive_ids" ]; then
-    directive_array=$(echo "$directive_ids" | tr ',' '\n' | grep -v '^$' | jq -R . | jq -s .)
-  else
-    directive_array="[]"
-  fi
-
-  # Write contract
-  cat > "$contract_file" << EOF
-{
-  "session_id": "$session_id",
-  "retrieval_ok": $retrieval_ok,
-  "retrieval_source": "$retrieval_source",
-  "retrieved_pattern_ids": $pattern_array,
-  "retrieved_directive_ids": $directive_array,
-  "timestamp": "$timestamp",
-  "query_hash": "$query_hash",
-  "ekkos_strict": ${EKKOS_STRICT:-0}
-}
-EOF
-
-  return 0
-}
-
-# Read turn contract
-read_turn_contract() {
-  local session_id="$1"
-  local retrieval_source="$2"
-  local project_root="${3:-$PROJECT_ROOT}"
-
-  local contract_dir
-  contract_dir=$(get_contract_dir "$retrieval_source" "$project_root")
-  local contract_file="$contract_dir/turn-contract-${session_id}.json"
-
-  if [ -f "$contract_file" ]; then
-    cat "$contract_file"
-    return 0
-  else
-    return 1
-  fi
-}
-
-# Extract field from contract JSON
-get_contract_field() {
-  local contract_json="$1"
-  local field="$2"
-
-  echo "$contract_json" | jq -r ".$field // \"\"" 2>/dev/null
-}
-
-# Get array field as comma-separated string
-get_contract_array() {
-  local contract_json="$1"
-  local field="$2"
-
-  echo "$contract_json" | jq -r ".$field // [] | join(\",\")" 2>/dev/null
-}
-
-# Cleanup turn contract (only after successful capture)
-cleanup_turn_contract() {
-  local session_id="$1"
-  local retrieval_source="$2"
-  local project_root="${3:-$PROJECT_ROOT}"
-
-  local contract_dir
-  contract_dir=$(get_contract_dir "$retrieval_source" "$project_root")
-  local contract_file="$contract_dir/turn-contract-${session_id}.json"
-
-  rm -f "$contract_file" 2>/dev/null
-}
-
-# Check if strict mode is enabled
-is_strict_mode() {
-  [ "${EKKOS_STRICT:-0}" = "1" ]
-}
-
-# Generate strict mode blocker message for Claude Code
-get_strict_blocker_message() {
-  cat << 'EOF'
-════════════════════════════════════════════════════════════════════════════
-⛔ EKKOS_STRICT MODE: RETRIEVAL FAILED — DO NOT ANSWER
-
-ekkOS memory retrieval failed or was not authenticated.
-In STRICT mode, you MUST NOT answer technical questions without memory context.
-
-ACTION REQUIRED:
-1. Check if ekkOS is connected: Run `ekkOS: Connect` in VS Code
-2. Verify auth token exists: ~/.ekkos/config.json
-3. Retry the request after connecting
-
-DO NOT proceed with answering. The Golden Loop requires retrieval FIRST.
-════════════════════════════════════════════════════════════════════════════
-EOF
-}
-
-# Validate PatternGuard coverage (returns 0-100)
-calculate_pattern_guard_coverage() {
-  local assistant_response="$1"
-  local pattern_ids="$2"  # Comma-separated
-
-  # Count total patterns
-  local total_count
-  total_count=$(echo "$pattern_ids" | tr ',' '\n' | grep -c '.' || echo 0)
-
-  if [ "$total_count" -eq 0 ]; then
-    echo "100"  # No patterns = 100% coverage by definition
-    return 0
-  fi
-
-  # Extract acknowledged IDs from [ekkOS_SELECT] and [ekkOS_SKIP] blocks
-  local acknowledged_count=0
-
-  # Check SELECT block
-  local select_block
-  select_block=$(echo "$assistant_response" | grep -ozP '\[ekkOS_SELECT\][\s\S]*?\[/ekkOS_SELECT\]' 2>/dev/null | tr '\0' '\n' || true)
-  if [ -n "$select_block" ]; then
-    local select_count
-    select_count=$(echo "$select_block" | grep -oE 'id:\s*[a-f0-9-]+' | wc -l | tr -d ' ')
-    acknowledged_count=$((acknowledged_count + select_count))
-  fi
-
-  # Check SKIP block
-  local skip_block
-  skip_block=$(echo "$assistant_response" | grep -ozP '\[ekkOS_SKIP\][\s\S]*?\[/ekkOS_SKIP\]' 2>/dev/null | tr '\0' '\n' || true)
-  if [ -n "$skip_block" ]; then
-    local skip_count
-    skip_count=$(echo "$skip_block" | grep -oE 'id:\s*[a-f0-9-]+' | wc -l | tr -d ' ')
-    acknowledged_count=$((acknowledged_count + skip_count))
-  fi
-
-  # Legacy: Check for [ekkOS_APPLY] markers (fallback)
-  if [ "$acknowledged_count" -eq 0 ]; then
-    local apply_count
-    apply_count=$(echo "$assistant_response" | grep -c '\[ekkOS_APPLY\]' || echo 0)
-    acknowledged_count=$apply_count
-  fi
-
-  # Calculate coverage percentage
-  local coverage
-  coverage=$((acknowledged_count * 100 / total_count))
-
-  # Cap at 100%
-  if [ "$coverage" -gt 100 ]; then
-    coverage=100
-  fi
-
-  echo "$coverage"
-}
-
-# Check for ekkOS footer presence
-check_footer_present() {
-  local assistant_response="$1"
-
-  # Look for the mandatory footer format:
-  # 🧠 **ekkOS_™** · 📅 YYYY-MM-DD
-  # OR
-  # {IDE} ({Model}) · 🧠 **ekkOS_™** · 📅 {Timestamp}
-
-  if echo "$assistant_response" | grep -qE '🧠.*ekkOS.*📅.*[0-9]{4}-[0-9]{2}-[0-9]{2}'; then
-    echo "true"
-    return 0
-  else
-    echo "false"
-    return 1
-  fi
-}
-
-# Build compliance metadata for capture
-build_compliance_metadata() {
-  local retrieval_ok="$1"
-  local pattern_guard_coverage="$2"
-  local footer_present="$3"
-  local ekkos_strict="$4"
-  local retrieved_count="$5"
-
-  local pattern_guard_required="false"
-  if [ "$retrieved_count" -gt 0 ]; then
-    pattern_guard_required="true"
-  fi
-
-  cat << EOF
-{
-  "retrieval_ok": $retrieval_ok,
-  "pattern_guard_required": $pattern_guard_required,
-  "pattern_guard_coverage_pct": $pattern_guard_coverage,
-  "footer_present": $footer_present,
-  "ekkos_strict": $ekkos_strict,
-  "retrieved_count": $retrieved_count,
-  "compliance_version": "1.0"
-}
-EOF
-}
-
-# Determine if turn is compliant
-is_turn_compliant() {
-  local retrieval_ok="$1"
-  local pattern_guard_coverage="$2"
-  local footer_present="$3"
-  local pattern_count="$4"
-
-  # Retrieval must have succeeded
-  if [ "$retrieval_ok" != "true" ]; then
-    echo "false"
-    return 1
-  fi
-
-  # If patterns were retrieved, PatternGuard must be 100%
-  if [ "$pattern_count" -gt 0 ] && [ "$pattern_guard_coverage" -lt 100 ]; then
-    echo "false"
-    return 1
-  fi
-
-  # Footer must be present
-  if [ "$footer_present" != "true" ]; then
-    echo "false"
-    return 1
-  fi
-
-  echo "true"
-  return 0
-}
-
-# Generate violation reason
-get_violation_reason() {
-  local retrieval_ok="$1"
-  local pattern_guard_coverage="$2"
-  local footer_present="$3"
-  local pattern_count="$4"
-
-  local reasons=""
-
-  if [ "$retrieval_ok" != "true" ]; then
-    reasons="retrieval_failed"
-  fi
-
-  if [ "$pattern_count" -gt 0 ] && [ "$pattern_guard_coverage" -lt 100 ]; then
-    if [ -n "$reasons" ]; then
-      reasons="$reasons,pattern_guard_incomplete"
-    else
-      reasons="pattern_guard_incomplete"
-    fi
-  fi
-
-  if [ "$footer_present" != "true" ]; then
-    if [ -n "$reasons" ]; then
-      reasons="$reasons,footer_missing"
-    else
-      reasons="footer_missing"
-    fi
-  fi
-
-  if [ -z "$reasons" ]; then
-    reasons="none"
-  fi
-
-  echo "$reasons"
-}

package/templates/cursor-hooks/stop.sh

@@ -1,75 +0,0 @@
-#!/bin/bash
-# ═══════════════════════════════════════════════════════════════════════════
-# ekkOS_ Hook: Stop (Cursor Agent Mode)
-#
-# Fires when agent iteration completes. Can:
-# 1. Clear Time Machine consumed flag (allow new requests)
-# 2. Capture session summary
-# 3. Optionally submit follow-up message
-# ═══════════════════════════════════════════════════════════════════════════
-
-set +e
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(dirname "$(dirname "$SCRIPT_DIR")")"
-STATE_DIR="$PROJECT_ROOT/.cursor/state"
-
-# Read JSON input
-INPUT=$(cat)
-
-# Extract status
-STATUS=$(echo "$INPUT" | jq -r '.status // "unknown"' 2>/dev/null || echo "unknown")
-LOOP_COUNT=$(echo "$INPUT" | jq -r '.loop_count // 0' 2>/dev/null || echo "0")
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Clear Time Machine flag on session end (allow new requests next session)
-# ═══════════════════════════════════════════════════════════════════════════
-if [ "$STATUS" = "completed" ] || [ "$STATUS" = "aborted" ]; then
-  rm -f "$STATE_DIR/time-machine-consumed.flag" 2>/dev/null || true
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Optional: Load auth for session summary
-# ═══════════════════════════════════════════════════════════════════════════
-EKKOS_CONFIG="$HOME/.ekkos/config.json"
-AUTH_TOKEN=""
-USER_ID=""
-
-if [ -f "$EKKOS_CONFIG" ]; then
-  AUTH_TOKEN=$(jq -r '.hookApiKey // .apiKey // ""' "$EKKOS_CONFIG" 2>/dev/null || echo "")
-  USER_ID=$(jq -r '.userId // ""' "$EKKOS_CONFIG" 2>/dev/null || echo "")
-fi
-
-if [ -z "$AUTH_TOKEN" ] && [ -f "$PROJECT_ROOT/.env.local" ]; then
-  AUTH_TOKEN=$(grep -E "^SUPABASE_SECRET_KEY=" "$PROJECT_ROOT/.env.local" | cut -d'=' -f2- | tr -d '"' | tr -d "'" | tr -d '\r')
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Log session end (fire and forget)
-# ═══════════════════════════════════════════════════════════════════════════
-if [ -n "$AUTH_TOKEN" ]; then
-  SESSION_ID=""
-  if [ -f "$STATE_DIR/current_session_id.txt" ]; then
-    SESSION_ID=$(cat "$STATE_DIR/current_session_id.txt" 2>/dev/null || echo "")
-  fi
-
-  TURN_COUNT=0
-  TURN_FILE="$STATE_DIR/turn_${SESSION_ID}.txt"
-  if [ -f "$TURN_FILE" ]; then
-    TURN_COUNT=$(cat "$TURN_FILE" 2>/dev/null || echo "0")
-  fi
-
-  # Could capture session end event here
-  # For now, just clean up
-
-  # Clean up turn counter for next session
-  # (commented out - might want to persist across agent runs)
-  # rm -f "$TURN_FILE" 2>/dev/null || true
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Return empty response (no follow-up)
-# ═══════════════════════════════════════════════════════════════════════════
-echo '{}'
-
-exit 0

package/templates/hooks/assistant-response.ps1

@@ -1,256 +0,0 @@
-# ═══════════════════════════════════════════════════════════════════════════
-# ekkOS_ Hook: AssistantResponse - Process Claude's response (Windows)
-# MANAGED BY ekkos-connect - DO NOT EDIT DIRECTLY
-# EKKOS_MANAGED=1
-# EKKOS_MANIFEST_SHA256=<computed-at-build>
-# EKKOS_TEMPLATE_VERSION=1.0.0
-#
-# Per ekkOS Onboarding Spec v1.2 FINAL + ADDENDUM:
-# - All persisted records MUST include: instanceId, sessionId, sessionName
-# - Uses EKKOS_INSTANCE_ID env var for multi-session isolation
-# ═══════════════════════════════════════════════════════════════════════════
-
-$ErrorActionPreference = "SilentlyContinue"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# CONFIG PATHS - No hardcoded word arrays per spec v1.2 Addendum
-# ═══════════════════════════════════════════════════════════════════════════
-$EkkosConfigDir = if ($env:EKKOS_CONFIG_DIR) { $env:EKKOS_CONFIG_DIR } else { "$env:USERPROFILE\.ekkos" }
-$HooksEnabledJson = "$EkkosConfigDir\hooks-enabled.json"
-$HooksEnabledDefault = "$EkkosConfigDir\.defaults\hooks-enabled.json"
-$SessionWordsJson = "$EkkosConfigDir\session-words.json"
-$SessionWordsDefault = "$EkkosConfigDir\.defaults\session-words.json"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# INSTANCE ID - Multi-session isolation per v1.2 ADDENDUM
-# ═══════════════════════════════════════════════════════════════════════════
-$EkkosInstanceId = if ($env:EKKOS_INSTANCE_ID) { $env:EKKOS_INSTANCE_ID } else { "default" }
-
-# ═══════════════════════════════════════════════════════════════════════════
-# CHECK ENABLEMENT - Respect hooks-enabled.json
-# ═══════════════════════════════════════════════════════════════════════════
-function Test-HookEnabled {
-    param([string]$HookName)
-
-    $enabledFile = $HooksEnabledJson
-    if (-not (Test-Path $enabledFile)) {
-        $enabledFile = $HooksEnabledDefault
-    }
-
-    if (-not (Test-Path $enabledFile)) {
-        # No enablement file = all enabled by default
-        return $true
-    }
-
-    try {
-        $config = Get-Content $enabledFile -Raw | ConvertFrom-Json
-
-        # Check claude.enabled array
-        if ($config.claude -and $config.claude.enabled) {
-            $enabledHooks = $config.claude.enabled
-            if ($enabledHooks -contains $HookName -or $enabledHooks -contains "assistant-response") {
-                return $true
-            }
-            return $false
-        }
-
-        return $true  # Default to enabled if no config
-    } catch {
-        return $true  # Default to enabled on error
-    }
-}
-
-# Check if this hook is enabled
-if (-not (Test-HookEnabled "assistant-response")) {
-    exit 0
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Load session words from JSON file - NO HARDCODED ARRAYS
-# ═══════════════════════════════════════════════════════════════════════════
-$script:SessionWords = $null
-
-function Load-SessionWords {
-    $wordsFile = $SessionWordsJson
-
-    # Fallback to managed defaults if user file missing/invalid
-    if (-not (Test-Path $wordsFile)) {
-        $wordsFile = $SessionWordsDefault
-    }
-
-    if (-not (Test-Path $wordsFile)) {
-        return $null
-    }
-
-    try {
-        $script:SessionWords = Get-Content $wordsFile -Raw | ConvertFrom-Json
-    } catch {
-        return $null
-    }
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# SESSION NAME (UUID to words) - Uses external session-words.json
-# ═══════════════════════════════════════════════════════════════════════════
-function Convert-UuidToWords {
-    param([string]$uuid)
-
-    # Load session words if not already loaded
-    if (-not $script:SessionWords) {
-        Load-SessionWords
-    }
-
-    # Handle missing session words gracefully
-    if (-not $script:SessionWords) {
-        return "unknown-session"
-    }
-
-    $adjectives = $script:SessionWords.adjectives
-    $nouns = $script:SessionWords.nouns
-    $verbs = $script:SessionWords.verbs
-
-    if (-not $adjectives -or -not $nouns -or -not $verbs) {
-        return "unknown-session"
-    }
-
-    if (-not $uuid -or $uuid -eq "unknown") { return "unknown-session" }
-
-    $clean = $uuid -replace "-", ""
-    if ($clean.Length -lt 12) { return "unknown-session" }
-
-    try {
-        $a = [Convert]::ToInt32($clean.Substring(0,4), 16) % $adjectives.Length
-        $n = [Convert]::ToInt32($clean.Substring(4,4), 16) % $nouns.Length
-        $an = [Convert]::ToInt32($clean.Substring(8,4), 16) % $verbs.Length
-
-        return "$($adjectives[$a])-$($nouns[$n])-$($verbs[$an])"
-    } catch {
-        return "unknown-session"
-    }
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# READ INPUT
-# ═══════════════════════════════════════════════════════════════════════════
-$inputJson = [Console]::In.ReadToEnd()
-if (-not $inputJson) { exit 0 }
-
-try {
-    $input = $inputJson | ConvertFrom-Json
-} catch {
-    exit 0
-}
-
-# Extract response content
-$assistantResponse = $input.response
-if (-not $assistantResponse) { $assistantResponse = $input.message }
-if (-not $assistantResponse) { $assistantResponse = $input.content }
-if (-not $assistantResponse) { exit 0 }
-
-# Get session ID
-$rawSessionId = $input.session_id
-if (-not $rawSessionId -or $rawSessionId -eq "null") { $rawSessionId = "unknown" }
-
-# Fallback: read session_id from saved state
-if ($rawSessionId -eq "unknown") {
-    $stateFile = Join-Path $env:USERPROFILE ".claude\state\current-session.json"
-    if (Test-Path $stateFile) {
-        try {
-            $state = Get-Content $stateFile -Raw | ConvertFrom-Json
-            $rawSessionId = $state.session_id
-        } catch {}
-    }
-}
-
-$sessionName = Convert-UuidToWords $rawSessionId
-
-# ═══════════════════════════════════════════════════════════════════════════
-# READ TURN STATE
-# ═══════════════════════════════════════════════════════════════════════════
-$stateFile = Join-Path $env:USERPROFILE ".claude\state\hook-state.json"
-$turn = 0
-
-if (Test-Path $stateFile) {
-    try {
-        $hookState = Get-Content $stateFile -Raw | ConvertFrom-Json
-        $turn = [int]$hookState.turn
-    } catch {
-        $turn = 0
-    }
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# PATTERN TRACKING (detect [ekkOS_SELECT] blocks)
-# ═══════════════════════════════════════════════════════════════════════════
-$patternIds = @()
-if ($assistantResponse -match '\[ekkOS_SELECT\]') {
-    # Extract pattern IDs from SELECT blocks
-    $selectMatches = [regex]::Matches($assistantResponse, 'id:\s*([a-zA-Z0-9\-_]+)')
-    foreach ($match in $selectMatches) {
-        $patternIds += $match.Groups[1].Value
-    }
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# LOCAL CACHE: Tier 0 capture (async, non-blocking)
-# Per v1.2 ADDENDUM: Pass instanceId for namespacing
-# ═══════════════════════════════════════════════════════════════════════════
-$captureCmd = Get-Command "ekkos-capture" -ErrorAction SilentlyContinue
-if ($captureCmd -and $rawSessionId -ne "unknown") {
-    try {
-        # NEW format: ekkos-capture response <instance_id> <session_id> <turn_id> <response> [tools] [files]
-        $responseBase64 = [Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($assistantResponse))
-        $toolsJson = "[]"
-        $filesJson = "[]"
-
-        # Extract tools used from response
-        $toolMatches = [regex]::Matches($assistantResponse, '\[TOOL:\s*([^\]]+)\]')
-        if ($toolMatches.Count -gt 0) {
-            $tools = $toolMatches | ForEach-Object { $_.Groups[1].Value } | Select-Object -Unique
-            $toolsJson = $tools | ConvertTo-Json -Depth 10 -Compress
-        }
-
-        Start-Job -ScriptBlock {
-            param($instanceId, $sessionId, $turnNum, $responseB64, $tools, $files)
-            try {
-                $decoded = [System.Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($responseB64))
-                & ekkos-capture response $instanceId $sessionId $turnNum $decoded $tools $files 2>&1 | Out-Null
-            } catch {}
-        } -ArgumentList $EkkosInstanceId, $rawSessionId, $turn, $responseBase64, $toolsJson, $filesJson | Out-Null
-    } catch {}
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# WORKING MEMORY: Fast capture to API (async, non-blocking)
-# ═══════════════════════════════════════════════════════════════════════════
-$configFile = Join-Path $EkkosConfigDir "config.json"
-if (Test-Path $configFile) {
-    try {
-        $config = Get-Content $configFile -Raw | ConvertFrom-Json
-        $captureToken = $config.hookApiKey
-        if (-not $captureToken) { $captureToken = $config.apiKey }
-
-        if ($captureToken) {
-            Start-Job -ScriptBlock {
-                param($token, $instanceId, $sessionId, $sessionName, $turnNum, $response, $patterns)
-                $body = @{
-                    session_id = $sessionId
-                    session_name = $sessionName
-                    instance_id = $instanceId
-                    turn = $turnNum
-                    response = $response.Substring(0, [Math]::Min(5000, $response.Length))
-                    pattern_ids = $patterns
-                } | ConvertTo-Json -Depth 10
-
-                Invoke-RestMethod -Uri "https://mcp.ekkos.dev/api/v1/working/turn" `
-                    -Method POST `
-                    -Headers @{ Authorization = "Bearer $token" } `
-                    -ContentType "application/json" `
-                    -Body ([System.Text.Encoding]::UTF8.GetBytes($body)) -ErrorAction SilentlyContinue
-            } -ArgumentList $captureToken, $EkkosInstanceId, $rawSessionId, $sessionName, $turn, $assistantResponse, $patternIds | Out-Null
-        }
-    } catch {}
-}
-
-# Silent exit - assistant-response hook should not produce output
-exit 0