@orchestrator-claude/definitions 3.8.2 → 3.9.0

package/hooks/post-phase-checkpoint.sh

@@ -1,14 +1,10 @@
 #!/bin/bash
-# Post-Phase Checkpoint Hook
-# Automatically creates git checkpoints when workflow phases complete
+# Post-Phase Checkpoint Hook (v2 — REST API)
+# Defense-in-depth: agents create checkpoints via MCP, this is a safety net.
+# Creates git checkpoints when workflow phases complete.
 #
 # Triggered by: PostToolUse on Task tool (after agent completes)
-# Behavior: Detects phase transitions and creates git commits
-#
-# Requirements:
-#   - jq (for JSON parsing)
-#   - git (for checkpoint commits)
-#
+# Requirements: git
 # Debug mode: ORCH_CHECKPOINT_DEBUG=1 to enable verbose logging
 
 set -e
@@ -16,18 +12,20 @@ set -e
 # Configuration
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-INDEX_FILE="$PROJECT_ROOT/.orchestrator/orchestrator-index.json"
 STATE_DIR="$PROJECT_ROOT/.orchestrator/.state"
 LOG_FILE="$STATE_DIR/checkpoint-hook.log"
 LAST_PHASE_FILE="$STATE_DIR/last-checkpointed-phase"
 
-# Ensure state directory exists
+# API Configuration
+API_URL="${ORCHESTRATOR_API_URL:-http://localhost:3001}"
+AUTH_EMAIL="${ORCHESTRATOR_AUTH_EMAIL:-admin@orchestrator.local}"
+AUTH_PASSWORD="${ORCHESTRATOR_AUTH_PASSWORD:-admin123}"
+PROJECT_ID="${ORCHESTRATOR_PROJECT_ID:-d001d65d-25f5-4d13-b1dc-d006873e949c}"
+
 mkdir -p "$STATE_DIR"
 
-# Debug mode
 DEBUG="${ORCH_CHECKPOINT_DEBUG:-0}"
 
-# Logging functions
 log_debug() {
   if [ "$DEBUG" = "1" ]; then
     echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] [DEBUG] $1" >> "$LOG_FILE"
@@ -42,120 +40,57 @@ log_info() {
   fi
 }
 
-log_warn() {
-  echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] [WARN] $1" >> "$LOG_FILE"
-  echo "[WARN] $1" >&2
-}
-
 log_error() {
   echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] [ERROR] $1" >> "$LOG_FILE"
   echo "[ERROR] $1" >&2
 }
 
-# Check prerequisites
-check_prerequisites() {
-  # Check jq
-  if ! command -v jq &> /dev/null; then
-    log_error "jq is not installed. Checkpoints disabled."
-    return 1
-  fi
-
-  # Check git
-  if ! command -v git &> /dev/null; then
-    log_error "git is not installed. Checkpoints disabled."
-    return 1
-  fi
-
-  # Check if we're in a git repo
-  if ! git -C "$PROJECT_ROOT" rev-parse --is-inside-work-tree &> /dev/null; then
-    log_warn "Not a git repository. Checkpoints disabled."
-    return 1
-  fi
-
-  # Check index file
-  if [ ! -f "$INDEX_FILE" ]; then
-    log_debug "No orchestrator-index.json found. Skipping."
-    return 1
+# Auth (shared with other hooks — cached JWT)
+get_token() {
+  local cached="$STATE_DIR/jwt-token"
+  if [ -f "$cached" ]; then
+    local age=$(( $(date +%s) - $(stat -c%Y "$cached" 2>/dev/null || stat -f%m "$cached" 2>/dev/null || echo 0) ))
+    if [ "$age" -lt 3500 ]; then
+      cat "$cached"; return
+    fi
   fi
-
-  return 0
-}
-
-# Get current phase from orchestrator-index.json
-get_current_phase() {
-  local phase
-  phase=$(jq -r '.activeWorkflow.currentPhase // empty' "$INDEX_FILE" 2>/dev/null)
-  echo "$phase"
-}
-
-# Get workflow ID
-get_workflow_id() {
-  local wf_id
-  wf_id=$(jq -r '.activeWorkflow.id // empty' "$INDEX_FILE" 2>/dev/null)
-  echo "$wf_id"
+  local resp
+  resp=$(curl -s -f -X POST "${API_URL}/api/v1/auth/login" \
+    -H "Content-Type: application/json" \
+    -d "{\"email\":\"${AUTH_EMAIL}\",\"password\":\"${AUTH_PASSWORD}\"}" 2>/dev/null) || return 1
+  local token
+  token=$(echo "$resp" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{try{const j=JSON.parse(d);console.log(j.data?.accessToken||j.accessToken||j.token||'')}catch{console.log('')}})" 2>/dev/null)
+  [ -n "$token" ] && { echo "$token" > "$cached"; echo "$token"; }
 }
 
-# Get workflow status
-get_workflow_status() {
-  local status
-  status=$(jq -r '.activeWorkflow.status // empty' "$INDEX_FILE" 2>/dev/null)
-  echo "$status"
+# Get workflow info from REST API
+get_workflow_info() {
+  local token
+  token=$(get_token) || return 1
+  curl -s -f "${API_URL}/api/v1/workflows?status=in_progress" \
+    -H "Authorization: Bearer $token" \
+    -H "X-Project-ID: $PROJECT_ID" 2>/dev/null
 }
 
-# Get last checkpointed phase from checkpoints array (one with commitHash)
-get_last_checkpointed_phase() {
-  local phase
-  # Find the most recent checkpoint that has a commitHash (indicating it was git-committed)
-  phase=$(jq -r '
-    [.checkpoints[] | select(.commitHash != null and .commitHash != "")]
-    | sort_by(.createdAt)
-    | last
-    | .phase // empty
-  ' "$INDEX_FILE" 2>/dev/null)
-  echo "$phase"
-}
-
-# Determine completed phase based on current phase
-# When we see currentPhase = PLAN, it means SPECIFY just completed
+# Determine completed phase from current phase
+# When currentPhase = PLAN, SPECIFY just completed; etc.
 get_completed_phase() {
-  local current_phase="$1"
-  local workflow_status="$2"
-
-  case "$workflow_status" in
-    "completed")
-      echo "IMPLEMENT"
-      return
-      ;;
-  esac
-
-  case "$current_phase" in
-    "PLAN")
-      echo "SPECIFY"
-      ;;
-    "TASKS")
-      echo "PLAN"
-      ;;
-    "IMPLEMENT")
-      echo "TASKS"
-      ;;
-    *)
-      echo ""
-      ;;
+  case "$1" in
+    plan|PLAN) echo "specify" ;;
+    tasks|TASKS) echo "plan" ;;
+    implement|IMPLEMENT) echo "tasks" ;;
+    completed) echo "implement" ;;
+    *) echo "" ;;
   esac
 }
 
 # Create git checkpoint
 create_git_checkpoint() {
   local phase="$1"
-  local commit_hash=""
 
   log_info "Creating git checkpoint for phase: $phase"
 
-  # Stage all changes
-  git -C "$PROJECT_ROOT" add -A 2>/dev/null || {
-    log_warn "Failed to stage changes"
-    return 1
-  }
+  git -C "$PROJECT_ROOT" add -A 2>/dev/null || return 1
 
   # Check if there are staged changes
   if git -C "$PROJECT_ROOT" diff --cached --quiet 2>/dev/null; then
@@ -164,159 +99,83 @@ create_git_checkpoint() {
     return 0
   fi
 
-  # Create commit with standard message
   local commit_msg="[orchestrator] ${phase}: Auto-checkpoint after ${phase} phase"
 
   if git -C "$PROJECT_ROOT" commit -m "$commit_msg" --no-verify 2>/dev/null; then
+    local commit_hash
     commit_hash=$(git -C "$PROJECT_ROOT" rev-parse HEAD 2>/dev/null)
     log_info "Checkpoint commit created: $commit_hash"
     echo "$commit_hash"
   else
-    log_warn "Failed to create commit"
+    log_error "Failed to create commit"
     echo ""
     return 1
   fi
 }
 
-# Update orchestrator-index.json with checkpoint
-update_orchestrator_index() {
-  local workflow_id="$1"
+# Register checkpoint via REST API
+register_checkpoint() {
+  local wf_id="$1"
   local phase="$2"
   local commit_hash="$3"
-  local created_at
-
-  created_at=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-  local checkpoint_id="cp_${workflow_id}_$(date +%s)"
-  local description="Auto-checkpoint after ${phase} phase"
-
-  log_debug "Updating index with checkpoint: $checkpoint_id"
-
-  # Create temp file for atomic update
-  local temp_file="${INDEX_FILE}.tmp.$$"
-
-  # Use jq to add checkpoint and update statistics
-  if jq --arg id "$checkpoint_id" \
-       --arg wfId "$workflow_id" \
-       --arg phase "$phase" \
-       --arg hash "$commit_hash" \
-       --arg date "$created_at" \
-       --arg desc "$description" '
-    # Add checkpoint to array
-    .checkpoints += [{
-      id: $id,
-      workflowId: $wfId,
-      phase: $phase,
-      commitHash: $hash,
-      createdAt: $date,
-      description: $desc
-    }] |
-    # Update statistics
-    .statistics.totalCheckpoints = (.checkpoints | length) |
-    .statistics.lastActivity = $date
-  ' "$INDEX_FILE" > "$temp_file" 2>/dev/null; then
-
-    # Validate JSON
-    if jq empty "$temp_file" 2>/dev/null; then
-      mv "$temp_file" "$INDEX_FILE"
-      log_info "Index updated with checkpoint: $checkpoint_id"
-      return 0
-    else
-      log_error "Generated invalid JSON"
-      rm -f "$temp_file"
-      return 1
-    fi
-  else
-    log_error "Failed to update index with jq"
-    rm -f "$temp_file"
-    return 1
-  fi
-}
-
-# Save last checkpointed phase
-save_last_phase() {
-  local phase="$1"
-  echo "$phase" > "$LAST_PHASE_FILE"
-}
-
-# Get saved last phase (from state file, not index)
-get_saved_last_phase() {
-  if [ -f "$LAST_PHASE_FILE" ]; then
-    cat "$LAST_PHASE_FILE"
-  else
-    echo ""
-  fi
+  local description="$4"
+  local token
+  token=$(get_token) || return 1
+  curl -s -f -X POST "${API_URL}/api/v1/checkpoints" \
+    -H "Content-Type: application/json" \
+    -H "Authorization: Bearer $token" \
+    -H "X-Project-ID: $PROJECT_ID" \
+    -d "{\"workflowId\":\"${wf_id}\",\"description\":\"${description}\",\"commitHash\":\"${commit_hash}\"}" >> "$LOG_FILE" 2>&1 || true
 }
 
-# Main execution
 main() {
   log_debug "Hook triggered"
 
-  # Check prerequisites
-  if ! check_prerequisites; then
-    log_debug "Prerequisites not met, exiting"
-    exit 0  # Don't fail the hook
-  fi
+  # Prerequisites
+  command -v git &>/dev/null || { log_error "git not found"; exit 0; }
+  git -C "$PROJECT_ROOT" rev-parse --is-inside-work-tree &>/dev/null || { exit 0; }
 
-  # Get current state
-  local current_phase
-  current_phase=$(get_current_phase)
+  # Get workflow from API
+  WORKFLOW_RESP=$(get_workflow_info) || { log_debug "No API access"; exit 0; }
 
-  if [ -z "$current_phase" ]; then
-    log_debug "No active workflow phase found"
-    exit 0
-  fi
+  WORKFLOW_DATA=$(echo "$WORKFLOW_RESP" | node -e "
+    let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{
+      try{
+        const j=JSON.parse(d);
+        const wfs=j.data||j;
+        const wf=Array.isArray(wfs)?wfs[0]:wfs;
+        if(!wf){console.log('{}');return;}
+        console.log(JSON.stringify({id:wf.id||'',phase:wf.currentPhase||wf.phase||'',status:wf.status||''}));
+      }catch{console.log('{}')}
+    });
+  " 2>/dev/null)
 
-  local workflow_id
-  workflow_id=$(get_workflow_id)
+  WF_ID=$(echo "$WORKFLOW_DATA" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{try{console.log(JSON.parse(d).id||'')}catch{console.log('')}})" 2>/dev/null)
+  CURRENT_PHASE=$(echo "$WORKFLOW_DATA" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{try{console.log(JSON.parse(d).phase||'')}catch{console.log('')}})" 2>/dev/null)
 
-  local workflow_status
-  workflow_status=$(get_workflow_status)
+  [ -z "$CURRENT_PHASE" ] && { log_debug "No active phase"; exit 0; }
 
-  log_debug "Current phase: $current_phase, Status: $workflow_status, Workflow: $workflow_id"
+  COMPLETED_PHASE=$(get_completed_phase "$CURRENT_PHASE")
+  [ -z "$COMPLETED_PHASE" ] && { log_debug "No completed phase from: $CURRENT_PHASE"; exit 0; }
 
-  # Determine which phase just completed
-  local completed_phase
-  completed_phase=$(get_completed_phase "$current_phase" "$workflow_status")
+  # Check if already checkpointed
+  SAVED=$(cat "$LAST_PHASE_FILE" 2>/dev/null || echo "")
+  [ "$COMPLETED_PHASE" = "$SAVED" ] && { log_debug "Already checkpointed: $COMPLETED_PHASE"; exit 0; }
 
-  if [ -z "$completed_phase" ]; then
-    log_debug "No completed phase detected from current phase: $current_phase"
-    exit 0
-  fi
+  log_debug "Current phase: $CURRENT_PHASE, Completed phase: $COMPLETED_PHASE, WF: $WF_ID"
 
-  # Check if we already checkpointed this phase
-  local last_checkpointed
-  last_checkpointed=$(get_last_checkpointed_phase)
+  # Create git checkpoint
+  COMMIT_HASH=$(create_git_checkpoint "$COMPLETED_PHASE")
 
-  local saved_last_phase
-  saved_last_phase=$(get_saved_last_phase)
-
-  log_debug "Completed phase: $completed_phase, Last checkpointed: $last_checkpointed, Saved: $saved_last_phase"
-
-  # Skip if already checkpointed
-  if [ "$completed_phase" = "$last_checkpointed" ] || [ "$completed_phase" = "$saved_last_phase" ]; then
-    log_debug "Phase $completed_phase already checkpointed, skipping"
-    exit 0
-  fi
-
-  # Create checkpoint
-  local commit_hash
-  commit_hash=$(create_git_checkpoint "$completed_phase")
-
-  # Update index (even if no commit, to track the checkpoint)
-  if [ -n "$commit_hash" ]; then
-    if update_orchestrator_index "$workflow_id" "$completed_phase" "$commit_hash"; then
-      save_last_phase "$completed_phase"
-      log_info "Checkpoint complete for phase: $completed_phase (commit: $commit_hash)"
-    else
-      log_error "Failed to update index for phase: $completed_phase"
-    fi
+  if [ -n "$COMMIT_HASH" ]; then
+    register_checkpoint "$WF_ID" "$COMPLETED_PHASE" "$COMMIT_HASH" "Auto-checkpoint after ${COMPLETED_PHASE} phase"
+    log_info "Checkpoint: phase=$COMPLETED_PHASE commit=$COMMIT_HASH"
   else
-    log_info "No changes to checkpoint for phase: $completed_phase"
-    save_last_phase "$completed_phase"
+    log_info "No changes for phase: $COMPLETED_PHASE"
   fi
 
+  echo "$COMPLETED_PHASE" > "$LAST_PHASE_FILE"
   exit 0
 }
 
-# Run main function
 main "$@"

package/hooks/track-agent-invocation.sh

@@ -1,6 +1,7 @@
 #!/bin/bash
-# Track Agent Invocation Hook
-# Registers agent invocations in orchestrator-index.json
+# Track Agent Invocation Hook (v2 — REST API)
+# Defense-in-depth: agents self-report via MCP, this hook is a safety net.
+# Registers agent invocations via REST API (PostgreSQL).
 #
 # Usage (called by Claude Code hooks):
 #   track-agent-invocation.sh start    (reads stdin JSON)
@@ -13,11 +14,16 @@ set -e
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-INDEX_FILE="$PROJECT_ROOT/.orchestrator/orchestrator-index.json"
 STATE_DIR="$PROJECT_ROOT/.orchestrator/.state"
 INVOCATION_FILE="$STATE_DIR/current-invocation"
 DEBUG_LOG="$STATE_DIR/hook-debug.log"
 
+# API Configuration
+API_URL="${ORCHESTRATOR_API_URL:-http://localhost:3001}"
+AUTH_EMAIL="${ORCHESTRATOR_AUTH_EMAIL:-admin@orchestrator.local}"
+AUTH_PASSWORD="${ORCHESTRATOR_AUTH_PASSWORD:-admin123}"
+PROJECT_ID="${ORCHESTRATOR_PROJECT_ID:-d001d65d-25f5-4d13-b1dc-d006873e949c}"
+
 # Ensure state directory exists
 mkdir -p "$STATE_DIR"
 
@@ -32,6 +38,43 @@ if [ -f "$DEBUG_LOG" ]; then
   fi
 fi
 
+log() {
+  echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] $*" >> "$DEBUG_LOG"
+}
+
+# Auth function: login and cache JWT
+get_token() {
+  local cached="$STATE_DIR/jwt-token"
+  if [ -f "$cached" ]; then
+    local age=$(( $(date +%s) - $(stat -c%Y "$cached" 2>/dev/null || stat -f%m "$cached" 2>/dev/null || echo 0) ))
+    if [ "$age" -lt 3500 ]; then  # Refresh if > ~58 min
+      cat "$cached"
+      return
+    fi
+  fi
+  local resp
+  resp=$(curl -s -f -X POST "${API_URL}/api/v1/auth/login" \
+    -H "Content-Type: application/json" \
+    -d "{\"email\":\"${AUTH_EMAIL}\",\"password\":\"${AUTH_PASSWORD}\"}" 2>/dev/null) || return 1
+  local token
+  token=$(echo "$resp" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{try{const j=JSON.parse(d);console.log(j.data?.accessToken||j.accessToken||j.token||'')}catch{console.log('')}})" 2>/dev/null)
+  if [ -n "$token" ]; then
+    echo "$token" > "$cached"
+    echo "$token"
+  fi
+}
+
+# Get active workflow ID from REST API
+get_workflow_id() {
+  local token
+  token=$(get_token) || return 1
+  local resp
+  resp=$(curl -s -f "${API_URL}/api/v1/workflows?status=in_progress" \
+    -H "Authorization: Bearer $token" \
+    -H "X-Project-ID: $PROJECT_ID" 2>/dev/null) || return 1
+  echo "$resp" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{try{const j=JSON.parse(d);const wfs=j.data||j;const wf=Array.isArray(wfs)?wfs[0]:wfs;console.log(wf?.id||'')}catch{console.log('')}})" 2>/dev/null
+}
+
 ACTION="${1:-}"
 
 # Read stdin into variable (Claude Code passes JSON via stdin)
@@ -45,7 +88,6 @@ case "$ACTION" in
     # Extract agent info from stdin JSON
     # Structure: { "tool_name": "Task", "tool_input": { "subagent_type": "...", ... } }
     if [ -n "$STDIN_DATA" ]; then
-      # Debug: log received data
       echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] START stdin: $STDIN_DATA" >> "$DEBUG_LOG"
 
       AGENT_NAME=$(echo "$STDIN_DATA" | node -e "
@@ -54,7 +96,6 @@ case "$ACTION" in
         process.stdin.on('end', () => {
           try {
             const json = JSON.parse(data);
-            // Try different structures
             const type = json.tool_input?.subagent_type
                       || json.subagent_type
                       || json.tool_input?.type
@@ -87,7 +128,6 @@ case "$ACTION" in
         });
       ")
     elif [ -n "$CLAUDE_TOOL_INPUT" ]; then
-      # Fallback to environment variable
       echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] START env: $CLAUDE_TOOL_INPUT" >> "$DEBUG_LOG"
 
       AGENT_NAME=$(echo "$CLAUDE_TOOL_INPUT" | node -e "
@@ -108,124 +148,35 @@ case "$ACTION" in
       PHASE="unknown"
     fi
 
-    # Generate invocation ID
-    INVOCATION_ID="inv-$(date +%s)-$(head -c 4 /dev/urandom | xxd -p)"
-    STARTED_AT=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-
-    # Get workflow ID from index
-    WORKFLOW_ID=""
-    if [ -f "$INDEX_FILE" ]; then
-      WORKFLOW_ID=$(node -e "
-        const fs = require('fs');
-        try {
-          const idx = JSON.parse(fs.readFileSync('$INDEX_FILE', 'utf8'));
-          console.log(idx.activeWorkflow?.id || 'wf-standalone-' + Date.now());
-        } catch { console.log('wf-standalone-' + Date.now()); }
-      ")
-    fi
+    TOKEN=$(get_token) || { log "ERROR: Auth failed"; exit 0; }
+    WORKFLOW_ID=$(get_workflow_id) || { log "SKIP: No active workflow"; exit 0; }
 
-    # Save invocation state
+    STARTED_AT=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+    INVOCATION_ID="inv-$(date +%s)-$(head -c 4 /dev/urandom | xxd -p)"
     echo "$INVOCATION_ID" > "$INVOCATION_FILE"
 
-    # Update orchestrator-index.json
-    if [ -f "$INDEX_FILE" ]; then
-      node -e "
-        const fs = require('fs');
-        const indexPath = '$INDEX_FILE';
-        const idx = JSON.parse(fs.readFileSync(indexPath, 'utf8'));
-
-        if (!idx.agentInvocations) idx.agentInvocations = [];
-
-        idx.agentInvocations.push({
-          id: '$INVOCATION_ID',
-          agentName: '$AGENT_NAME',
-          phase: '$PHASE',
-          workflowId: '$WORKFLOW_ID',
-          startedAt: '$STARTED_AT',
-          completedAt: null,
-          status: 'running',
-          durationMs: 0
-        });
+    # Register via REST API
+    curl -s -f -X POST "${API_URL}/api/v1/agent-invocations" \
+      -H "Content-Type: application/json" \
+      -H "Authorization: Bearer $TOKEN" \
+      -H "X-Project-ID: $PROJECT_ID" \
+      -d "{\"agentType\":\"${AGENT_NAME}\",\"workflowId\":\"${WORKFLOW_ID}\",\"phase\":\"${PHASE}\",\"startedAt\":\"${STARTED_AT}\"}" >> "$DEBUG_LOG" 2>&1 || true
 
-        fs.writeFileSync(indexPath, JSON.stringify(idx, null, 2));
-        console.log(JSON.stringify({ invocationId: '$INVOCATION_ID', startedAt: '$STARTED_AT' }));
-      "
-    else
-      echo '{"invocationId": "'$INVOCATION_ID'", "startedAt": "'$STARTED_AT'", "warning": "No index file found"}'
-    fi
+    log "START: agent=$AGENT_NAME phase=$PHASE workflow=$WORKFLOW_ID"
     ;;
 
   complete)
-    # Get invocation ID from state file
     INVOCATION_ID=""
     if [ -f "$INVOCATION_FILE" ]; then
       INVOCATION_ID=$(cat "$INVOCATION_FILE")
+      rm -f "$INVOCATION_FILE"
     fi
 
-    if [ -z "$INVOCATION_ID" ]; then
-      echo '{"success": false, "error": "No invocation ID found"}'
-      exit 0  # Don't fail the hook
-    fi
-
-    # Debug log
     if [ -n "$STDIN_DATA" ]; then
       echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] COMPLETE stdin: $STDIN_DATA" >> "$DEBUG_LOG"
     fi
 
-    # Determine status - default to success
-    STATUS="success"
-    SUMMARY="Completed"
-
-    COMPLETED_AT=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-
-    # Update orchestrator-index.json
-    if [ -f "$INDEX_FILE" ]; then
-      node -e "
-        const fs = require('fs');
-        const indexPath = '$INDEX_FILE';
-        const idx = JSON.parse(fs.readFileSync(indexPath, 'utf8'));
-
-        const invocations = idx.agentInvocations || [];
-        const invIdx = invocations.findIndex(i => i.id === '$INVOCATION_ID');
-
-        if (invIdx === -1) {
-          console.log(JSON.stringify({ success: false, error: 'Invocation not found' }));
-          process.exit(0);
-        }
-
-        const inv = invocations[invIdx];
-        const startTime = new Date(inv.startedAt).getTime();
-        const endTime = new Date('$COMPLETED_AT').getTime();
-        const durationMs = endTime - startTime;
-
-        invocations[invIdx] = {
-          ...inv,
-          completedAt: '$COMPLETED_AT',
-          status: '$STATUS' === 'success' ? 'completed' : 'failed',
-          durationMs,
-          result: {
-            status: '$STATUS',
-            summary: '$SUMMARY'
-          }
-        };
-
-        idx.agentInvocations = invocations;
-
-        // Update statistics
-        if (idx.statistics) {
-          idx.statistics.totalInvocations = invocations.length;
-          idx.statistics.lastActivity = '$COMPLETED_AT';
-        }
-
-        fs.writeFileSync(indexPath, JSON.stringify(idx, null, 2));
-        console.log(JSON.stringify({ success: true, durationMs }));
-      "
-    else
-      echo '{"success": false, "error": "No index file found"}'
-    fi
-
-    # Clean up state file
-    rm -f "$INVOCATION_FILE"
+    log "COMPLETE: invocation=$INVOCATION_ID (agent self-reports via MCP; hook is safety net)"
     ;;
 
   *)