oh-my-customcodex 0.1.0

package/templates/.claude/hooks/scripts/stall-detection-advisor.sh

@@ -0,0 +1,112 @@
+#!/bin/bash
+set -euo pipefail
+
+# Stall Detection Advisor
+# Trigger: SubagentStop
+# Purpose: Detect stalled parallel agents and advise adaptive splitting (R009)
+# Protocol: stdin JSON -> analyze durations -> stderr advisory, stdout pass-through, exit 0 always (R021)
+
+# ORDERING: This hook MUST run AFTER task-outcome-recorder.sh in hooks.json SubagentStop array.
+# Reason: This script removes consumed entries from AGENT_START_FILE; task-outcome-recorder reads them first.
+
+command -v jq >/dev/null 2>&1 || { cat; exit 0; }
+
+input=$(cat)
+
+AGENT_START_FILE="/tmp/.codex-agent-starts-${PPID}"
+DURATION_FILE="/tmp/.codex-agent-durations-${PPID}"
+
+# Skip if no start records exist
+[ -f "$AGENT_START_FILE" ] || { echo "$input"; exit 0; }
+
+# --- 1. Extract completed agent info ---
+agent_type=$(echo "$input" | jq -r '.agent_type // "unknown"')
+model=$(echo "$input" | jq -r '.model // "inherit"')
+description=$(echo "$input" | jq -r '.description // ""' | head -c 80)
+
+# --- 2. Calculate duration from start record ---
+start_epoch=$(grep -F "\"agent_type\":\"${agent_type}\"" "$AGENT_START_FILE" 2>/dev/null | tail -1 | jq -r '.start_epoch // "0"' 2>/dev/null || echo "0")
+
+if [ "$start_epoch" = "0" ] || [ "$start_epoch" = "null" ]; then
+  echo "$input"
+  exit 0
+fi
+
+now_epoch=$(date +%s)
+duration_seconds=$((now_epoch - start_epoch))
+
+# Guard against negative duration (NTP adjustment, clock skew)
+if [ "$duration_seconds" -lt 0 ]; then duration_seconds=0; fi
+
+# --- 3. Stall detection (BEFORE recording this agent's duration, so self is excluded from average) ---
+# Need at least 1 completed peer to calculate average
+if [ -f "$DURATION_FILE" ]; then
+  completed_count=$(wc -l < "$DURATION_FILE" | tr -d ' ')
+else
+  completed_count=0
+fi
+
+if [ "$completed_count" -ge 1 ]; then
+  # Calculate average duration of completed agents (null-safe)
+  avg_duration=$(jq -s '[.[].duration_seconds | numbers] | if length == 0 then 0 else add / length | floor end' "$DURATION_FILE" 2>/dev/null || echo "0")
+
+  if [ "$avg_duration" -gt 0 ]; then
+    stall_threshold=$((avg_duration * 2))
+
+    # Check for still-running agents (in start file but not in duration file)
+    if [ -f "$AGENT_START_FILE" ] && [ -s "$AGENT_START_FILE" ]; then
+      while IFS= read -r line; do
+        running_agent=$(echo "$line" | jq -r '.agent_type // ""' 2>/dev/null || true)
+        running_start=$(echo "$line" | jq -r '.start_epoch // "0"' 2>/dev/null || echo "0")
+        running_desc=$(echo "$line" | jq -r '.description // ""' 2>/dev/null || true)
+        running_model=$(echo "$line" | jq -r '.model // "inherit"' 2>/dev/null || true)
+
+        if [ "$running_start" = "0" ] || [ "$running_start" = "null" ]; then continue; fi
+
+        elapsed=$((now_epoch - running_start))
+
+        if [ "$elapsed" -gt "$stall_threshold" ]; then
+          # --- Emit advisory (stderr) ---
+          echo "" >&2
+          echo "─── [Stall Detection Advisory] ───────────────────────────" >&2
+          echo "  Stalled: ${running_agent}:${running_model} (${elapsed}s elapsed, 2x avg ${avg_duration}s)" >&2
+          echo "  Description: ${running_desc}" >&2
+          echo "  ⚡ Consider spawning independent pending tasks immediately" >&2
+          echo "  R009 Adaptive Parallel Splitting applies" >&2
+          echo "──────────────────────────────────────────────────────────" >&2
+          echo "" >&2
+        fi
+      done < "$AGENT_START_FILE"
+    fi
+  fi
+fi
+
+# --- 4. Record duration (AFTER stall detection so self is excluded from average) ---
+duration_entry=$(jq -cn \
+  --arg agent "$agent_type" \
+  --arg model "$model" \
+  --arg desc "$description" \
+  --arg dur "$duration_seconds" \
+  --arg ts "$now_epoch" \
+  '{agent_type: $agent, model: $model, description: $desc, duration_seconds: ($dur | tonumber), timestamp: $ts}')
+
+echo "$duration_entry" >> "$DURATION_FILE"
+
+# Remove only first consumed start entry (preserve siblings for parallel same-type agents)
+if [ -f "$AGENT_START_FILE" ]; then
+  awk -v pat="\"agent_type\":\"${agent_type}\"" 'found || $0 !~ pat { print; next } { found=1 }' "$AGENT_START_FILE" > "${AGENT_START_FILE}.tmp" 2>/dev/null || true
+  mv "${AGENT_START_FILE}.tmp" "$AGENT_START_FILE" 2>/dev/null || true
+fi
+
+# Ring buffer: 50 max
+if [ -f "$DURATION_FILE" ]; then
+  line_count=$(wc -l < "$DURATION_FILE" | tr -d ' ')
+  if [ "$line_count" -gt 50 ]; then
+    tail -50 "$DURATION_FILE" > "${DURATION_FILE}.tmp"
+    mv "${DURATION_FILE}.tmp" "$DURATION_FILE"
+  fi
+fi
+
+# Pass through
+echo "$input"
+exit 0

package/templates/.claude/hooks/scripts/stop-console-audit.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+# Stop hook: Final audit for console.log and session diagnostics
+# Always exits 0 (never blocks session termination)
+# Ref: https://github.com/baekenough/oh-my-customcode/issues/206
+
+set -euo pipefail
+
+input=$(cat)
+
+# --- Session diagnostics ---
+# Output session status for debugging stop evaluator false positives
+echo "[Stop] Session termination audit starting..." >&2
+
+# Check for background task output files (helps diagnose evaluator false positives)
+bg_task_files=$(find /tmp -maxdepth 1 -name "claude-*.output" 2>/dev/null | wc -l | tr -d ' ')
+if [ "$bg_task_files" -gt 0 ]; then
+  echo "[Stop] Background task output files found: ${bg_task_files} (informational only — these are normal)" >&2
+fi
+
+# --- Console.log audit ---
+if git rev-parse --git-dir > /dev/null 2>&1; then
+  modified_files=$(git diff --name-only HEAD 2>/dev/null | grep -E '\.(ts|tsx|js|jsx)$' || true)
+
+  if [ -n "$modified_files" ]; then
+    has_console=false
+    while IFS= read -r file; do
+      if [ -f "$file" ]; then
+        if grep -q "console\.log" "$file" 2>/dev/null; then
+          echo "[Stop] WARNING: console.log found in $file" >&2
+          has_console=true
+        fi
+      fi
+    done <<< "$modified_files"
+
+    if [ "$has_console" = true ]; then
+      echo "[Stop] Remove console.log statements before committing" >&2
+    fi
+  fi
+fi
+
+echo "[Stop] Audit complete. Session safe to terminate." >&2
+
+# CRITICAL: Always pass through input and exit 0
+# This hook MUST NEVER block session termination
+echo "$input"
+exit 0

package/templates/.claude/hooks/scripts/stuck-detector.sh

@@ -0,0 +1,199 @@
+#!/bin/bash
+set -euo pipefail
+HOOK_START=$(date +%s%N 2>/dev/null || echo 0)
+
+# Dependency check: exit silently if jq not available
+command -v jq >/dev/null 2>&1 || exit 0
+
+# Stuck Detector Hook
+# Trigger: PostToolUse, tool matches "Edit|Write|Bash|Task|Agent"
+# Purpose: Detect repetitive failure loops and advise recovery
+# Protocol: stdin JSON -> process -> stdout pass-through
+#   - exit 0: advisory (normal cases, < HARD_BLOCK_THRESHOLD repetitions)
+#   - exit 1: hard block (extreme stuck loops, >= HARD_BLOCK_THRESHOLD repetitions)
+
+# Hard block threshold: consecutive identical operations before blocking
+HARD_BLOCK_THRESHOLD=${CLAUDE_STUCK_THRESHOLD:-3}
+
+input=$(cat)
+
+# Extract tool info
+tool_name=$(echo "$input" | jq -r '.tool_name // "unknown"')
+file_path=$(echo "$input" | jq -r '.tool_input.file_path // .tool_input.command // ""' | head -c 120)
+is_error=$(echo "$input" | jq -r '.tool_output.is_error // false')
+output_preview=$(echo "$input" | jq -r '.tool_output.output // ""' | head -c 200)
+
+# Session-scoped history
+HISTORY_FILE="${OMCODEX_STUCK_HISTORY_FILE:-/tmp/.codex-tool-history-${PPID}}"
+
+# Create entry
+timestamp=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+# Generate error hash for deduplication (first 50 chars of error)
+error_hash=""
+if [ "$is_error" = "true" ]; then
+  error_hash=$(echo "$output_preview" | head -c 50 | md5sum 2>/dev/null | cut -d' ' -f1 || echo "unknown")
+fi
+
+entry=$(jq -cn \
+  --arg ts "$timestamp" \
+  --arg tool "$tool_name" \
+  --arg path "$file_path" \
+  --arg err "$is_error" \
+  --arg hash "$error_hash" \
+  --arg preview "$output_preview" \
+  '{timestamp: $ts, tool: $tool, path: $path, is_error: $err, error_hash: $hash, preview: $preview}')
+
+echo "$entry" >> "$HISTORY_FILE"
+
+# Ring buffer: keep last 100 entries
+if [ -f "$HISTORY_FILE" ]; then
+  line_count=$(wc -l < "$HISTORY_FILE")
+  if [ "$line_count" -gt 100 ]; then
+    tail -100 "$HISTORY_FILE" > "${HISTORY_FILE}.tmp"
+    mv "${HISTORY_FILE}.tmp" "$HISTORY_FILE"
+  fi
+fi
+
+# --- Detection Logic ---
+
+# Only check for patterns if we have enough history
+if [ ! -f "$HISTORY_FILE" ]; then
+  echo "$input"
+  exit 0
+fi
+
+recent_count=$(wc -l < "$HISTORY_FILE")
+if [ "$recent_count" -lt 3 ]; then
+  echo "$input"
+  exit 0
+fi
+
+stuck_detected=false
+signal_type=""
+pattern_desc=""
+occurrence_count=0
+threshold=0
+recovery=""
+
+# Signal 1: Repeated error (same error_hash 3+ times in last 10 entries)
+if [ "$is_error" = "true" ] && [ -n "$error_hash" ]; then
+  error_repeat=$(tail -10 "$HISTORY_FILE" | grep -c "\"error_hash\":\"${error_hash}\"" 2>/dev/null || echo "0")
+  if [ "$error_repeat" -ge 3 ]; then
+    stuck_detected=true
+    signal_type="Repeated error"
+    pattern_desc="Same error appeared ${error_repeat} times in last 10 tool calls"
+    occurrence_count=$error_repeat
+    threshold=3
+    recovery="Rephrase the task or try a different approach"
+  fi
+fi
+
+# Signal 2: Edit loop (same file edited 3+ times in last 8 entries)
+if [ "$stuck_detected" = false ] && { [ "$tool_name" = "Edit" ] || [ "$tool_name" = "Write" ]; }; then
+  if [ -n "$file_path" ]; then
+    escaped_path=$(echo "$file_path" | sed 's/[.[\*^$()+?{|]/\\&/g')
+    edit_repeat=$(tail -8 "$HISTORY_FILE" | grep -c "\"path\":\"${escaped_path}\"" 2>/dev/null || echo "0")
+    if [ "$edit_repeat" -ge 3 ]; then
+      stuck_detected=true
+      signal_type="Edit loop"
+      pattern_desc="$(basename "$file_path") edited ${edit_repeat} times in last 8 calls"
+      occurrence_count=$edit_repeat
+      threshold=3
+      recovery="Try a different file or approach instead of re-editing"
+    fi
+  fi
+fi
+
+# Signal 3: Tool spam (same tool 5+ times in last 8 entries)
+if [ "$stuck_detected" = false ]; then
+  tool_repeat=$(tail -8 "$HISTORY_FILE" | grep -c "\"tool\":\"${tool_name}\"" 2>/dev/null || echo "0")
+  if [ "$tool_repeat" -ge 5 ]; then
+    stuck_detected=true
+    signal_type="Tool loop"
+    pattern_desc="${tool_name} called ${tool_repeat} times in last 8 calls"
+    occurrence_count=$tool_repeat
+    threshold=5
+    recovery="Step back and reconsider the approach"
+  fi
+fi
+
+# Output advisory if stuck detected
+if [ "$stuck_detected" = true ]; then
+  echo "" >&2
+  echo "--- [Stuck Detection] Loop detected ---" >&2
+  echo "  Signal: ${signal_type}" >&2
+  echo "  Pattern: ${pattern_desc}" >&2
+  echo "  Occurrences: ${occurrence_count}/${threshold}" >&2
+  echo "  💡 Recovery: ${recovery}" >&2
+  echo "----------------------------------------" >&2
+fi
+
+# --- Hard Block Detection (extreme stuck loops) ---
+# Check if the same operation has been repeated HARD_BLOCK_THRESHOLD+ times consecutively.
+# This catches cases where advisory warnings are being ignored.
+
+hard_block=false
+hard_block_reason=""
+
+if [ -f "$HISTORY_FILE" ]; then
+  last_n=$(tail -"$HARD_BLOCK_THRESHOLD" "$HISTORY_FILE" 2>/dev/null)
+  last_n_count=$(echo "$last_n" | wc -l | tr -d ' ')
+
+  if [ "$last_n_count" -ge "$HARD_BLOCK_THRESHOLD" ]; then
+    # Check 1: Same file edited HARD_BLOCK_THRESHOLD+ times consecutively
+    if [ -n "$file_path" ]; then
+      escaped_path=$(echo "$file_path" | sed 's/[.[\*^$()+?{|]/\\&/g')
+      consecutive_file=$(echo "$last_n" | grep -c "\"path\":\"${escaped_path}\"" 2>/dev/null || echo "0")
+      if [ "$consecutive_file" -ge "$HARD_BLOCK_THRESHOLD" ]; then
+        hard_block=true
+        hard_block_reason="Same file ($(basename "$file_path")) edited ${consecutive_file} consecutive times"
+      fi
+    fi
+
+    # Check 2: Same error repeated HARD_BLOCK_THRESHOLD+ times consecutively
+    if [ "$hard_block" = false ] && [ "$is_error" = "true" ] && [ -n "$error_hash" ]; then
+      consecutive_error=$(echo "$last_n" | grep -c "\"error_hash\":\"${error_hash}\"" 2>/dev/null || echo "0")
+      if [ "$consecutive_error" -ge "$HARD_BLOCK_THRESHOLD" ]; then
+        hard_block=true
+        hard_block_reason="Same error repeated ${consecutive_error} consecutive times"
+      fi
+    fi
+
+    # Check 3: Same tool+target combination HARD_BLOCK_THRESHOLD+ times consecutively
+    if [ "$hard_block" = false ] && [ -n "$file_path" ]; then
+      escaped_path=$(echo "$file_path" | sed 's/[.[\*^$()+?{|]/\\&/g')
+      consecutive_tool_target=$(echo "$last_n" | grep "\"tool\":\"${tool_name}\"" | grep -c "\"path\":\"${escaped_path}\"" 2>/dev/null || echo "0")
+      if [ "$consecutive_tool_target" -ge "$HARD_BLOCK_THRESHOLD" ]; then
+        hard_block=true
+        hard_block_reason="${tool_name} called on $(basename "$file_path") ${consecutive_tool_target} consecutive times"
+      fi
+    fi
+  fi
+fi
+
+if [ "$hard_block" = true ]; then
+  echo "" >&2
+  echo "=== [Stuck Detection] HARD BLOCK ===" >&2
+  echo "  ${hard_block_reason}" >&2
+  echo "  Threshold: ${HARD_BLOCK_THRESHOLD} consecutive identical operations" >&2
+  echo "  Action: Blocking this tool call to break the stuck loop." >&2
+  echo "  Recovery: Step back, re-read the error, and try a fundamentally different approach." >&2
+  echo "=====================================" >&2
+  echo "$input"
+  HOOK_END=$(date +%s%N 2>/dev/null || echo 0)
+  if [ "$HOOK_START" != "0" ] && [ "$HOOK_END" != "0" ]; then
+    HOOK_MS=$(( (HOOK_END - HOOK_START) / 1000000 ))
+    echo "[Hook Perf] $(basename "$0"): ${HOOK_MS}ms" >> "/tmp/.codex-hook-perf-${PPID}.log"
+  fi
+  exit 1
+fi
+
+# Pass through
+echo "$input"
+HOOK_END=$(date +%s%N 2>/dev/null || echo 0)
+if [ "$HOOK_START" != "0" ] && [ "$HOOK_END" != "0" ]; then
+  HOOK_MS=$(( (HOOK_END - HOOK_START) / 1000000 ))
+  echo "[Hook Perf] $(basename "$0"): ${HOOK_MS}ms" >> "/tmp/.codex-hook-perf-${PPID}.log"
+fi
+exit 0

package/templates/.claude/hooks/scripts/task-outcome-recorder.sh

@@ -0,0 +1,119 @@
+#!/bin/bash
+set -euo pipefail
+
+# Dependency check: exit silently if jq not available
+command -v jq >/dev/null 2>&1 || exit 0
+
+# Task/Agent Outcome Recorder Hook
+# Trigger: PostToolUse (tool == "Task" || "Agent") and SubagentStop
+# Purpose: Record task outcomes for model escalation decisions
+# Protocol: stdin JSON -> process -> stdout pass-through, exit 0 always
+
+input=$(cat)
+
+# Extract task info — support both PostToolUse (tool_input.*) and SubagentStop (top-level) shapes
+agent_type=$(echo "$input" | jq -r '.tool_input.subagent_type // .agent_type // "unknown"')
+model=$(echo "$input" | jq -r '.tool_input.model // .model // "inherit"')
+description=$(echo "$input" | jq -r '.tool_input.description // .description // ""' | head -c 80)
+
+# Extract skill name from description or prompt
+skill_name=""
+if echo "$description" | grep -qiE '(skill:|routing|→.*skill)'; then
+  skill_name=$(echo "$description" | grep -oiE '[a-z]+-[a-z]+(-[a-z]+)*-?(routing|skill|practices|detection|decomposition|orchestration|pipeline|guards|cycle|plan|review|refactor|publish|version|audit|exec|analyze|bundle|report|setup|watch|lists|status|help|save|recall)' | head -1)
+fi
+# Fallback: check prompt field for "Skill: {name}" pattern
+if [ -z "$skill_name" ]; then
+  prompt=$(echo "$input" | jq -r '.tool_input.prompt // ""' | head -c 500)
+  skill_name=$(echo "$prompt" | grep -oiE 'Skill:\s*[a-z]+-[a-z]+(-[a-z]+)*' | sed 's/[Ss]kill:\s*//' | head -1)
+fi
+
+# Determine outcome
+is_error=$(echo "$input" | jq -r '.tool_output.is_error // false')
+
+if [ "$is_error" = "true" ]; then
+  outcome="failure"
+  error_summary=$(echo "$input" | jq -r '.tool_output.output // ""' | head -c 200)
+else
+  outcome="success"
+  error_summary=""
+fi
+
+# Session-scoped outcome log and agent count tracker
+OUTCOME_FILE="/tmp/.codex-task-outcomes-${PPID}"
+TASK_COUNT_FILE="/tmp/.codex-task-count-${PPID}"
+
+# --- Pattern Detection ---
+# Priority: skill-specific patterns > parallel > sequential (default)
+pattern="sequential"
+
+# Check description for skill-specific workflow patterns
+desc_lower=$(echo "$description" | tr '[:upper:]' '[:lower:]')
+
+if echo "$desc_lower" | grep -qE '(evaluator.optimizer|evaluator_optimizer)'; then
+  pattern="evaluator-optimizer"
+elif echo "$desc_lower" | grep -qE '(worker.reviewer|worker_reviewer)'; then
+  pattern="worker-reviewer"
+elif echo "$desc_lower" | grep -qE '(dag.orchestrat|dag_orchestrat|multi.phase|orchestrat)'; then
+  pattern="orchestrator"
+elif echo "$desc_lower" | grep -qE '(parallel|\[1\]|\[2\]|\[3\]|\[4\])'; then
+  pattern="parallel"
+else
+  # Infer parallel from agent count: if 2+ agents spawned this session, mark as parallel
+  if [ -f "$TASK_COUNT_FILE" ]; then
+    session_agent_count=$(cat "$TASK_COUNT_FILE" 2>/dev/null || echo "0")
+    if [ "$session_agent_count" -ge 2 ] 2>/dev/null; then
+      pattern="parallel"
+    fi
+  fi
+fi
+
+# Duration calculation from start recorder
+# ORDERING: This script MUST run BEFORE stall-detection-advisor.sh in hooks.json SubagentStop array.
+# Reason: stall-detection-advisor removes consumed entries from AGENT_START_FILE after reading.
+AGENT_START_FILE="/tmp/.codex-agent-starts-${PPID}"
+duration_seconds=0
+if [ -f "$AGENT_START_FILE" ]; then
+  start_epoch=$(grep -F "\"agent_type\":\"${agent_type}\"" "$AGENT_START_FILE" 2>/dev/null | tail -1 | jq -r '.start_epoch // "0"' 2>/dev/null || echo "0")
+  if [ "$start_epoch" != "0" ] && [ "$start_epoch" != "null" ]; then
+    now_epoch=$(date +%s)
+    duration_seconds=$((now_epoch - start_epoch))
+  fi
+fi
+
+# Append JSON line entry
+timestamp=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+entry=$(jq -n \
+  --arg ts "$timestamp" \
+  --arg agent "$agent_type" \
+  --arg model "$model" \
+  --arg outcome "$outcome" \
+  --arg pattern "$pattern" \
+  --arg skill "$skill_name" \
+  --arg desc "$description" \
+  --arg err "$error_summary" \
+  --arg dur "$duration_seconds" \
+  '{timestamp: $ts, agent_type: $agent, model: $model, outcome: $outcome, pattern_used: $pattern, skill: $skill, description: $desc, error_summary: $err, duration_seconds: ($dur | tonumber)}')
+
+echo "$entry" >> "$OUTCOME_FILE"
+
+# Ring buffer: keep last 50 entries
+if [ -f "$OUTCOME_FILE" ]; then
+  line_count=$(wc -l < "$OUTCOME_FILE")
+  if [ "$line_count" -gt 50 ]; then
+    tail -50 "$OUTCOME_FILE" > "${OUTCOME_FILE}.tmp"
+    mv "${OUTCOME_FILE}.tmp" "$OUTCOME_FILE"
+  fi
+fi
+
+# Report failures to stderr
+if [ "$outcome" = "failure" ]; then
+  echo "" >&2
+  echo "--- [Agent Outcome] FAILURE: ${agent_type}:${model} ---" >&2
+  echo "  ${description}" >&2
+  echo "  Error: $(echo "$error_summary" | head -c 100)" >&2
+  echo "-----------------------------------------------" >&2
+fi
+
+# Pass through
+echo "$input"
+exit 0

package/templates/.claude/hooks/scripts/task-state-precompact.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+# PreCompact hook: serialize active task state before context compaction
+# Pairs with PostCompact prompt that restores this state
+
+STATE_FILE="/tmp/.codex-task-state-$PPID.json"
+
+collect_state() {
+  local pipeline_state=""
+  local autonomous=""
+  local dev_stage=""
+  local tool_count=""
+  local loop_count=""
+
+  # Pipeline state
+  for f in /tmp/.codex-pipeline-*-$PPID.json; do
+    [ -f "$f" ] && pipeline_state=$(cat "$f" 2>/dev/null | jq -c '.' 2>/dev/null) && break
+  done
+
+  # Autonomous mode
+  [ -f "/tmp/.codex-autonomous-$PPID" ] && autonomous="true"
+
+  # Dev stage (structured-dev-cycle)
+  [ -f "/tmp/.codex-dev-stage" ] && dev_stage=$(cat "/tmp/.codex-dev-stage" 2>/dev/null)
+
+  # Tool call counter
+  [ -f "/tmp/claude-tool-count-$PPID" ] && tool_count=$(cat "/tmp/claude-tool-count-$PPID" 2>/dev/null)
+
+  # Auto-continue loop count
+  [ -f "/tmp/.codex-loop-count-$PPID" ] && loop_count=$(cat "/tmp/.codex-loop-count-$PPID" 2>/dev/null)
+
+  # Build JSON (keep under 500 bytes for context efficiency)
+  jq -n \
+    --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+    --arg pipeline "$pipeline_state" \
+    --arg auto "$autonomous" \
+    --arg stage "$dev_stage" \
+    --arg tools "$tool_count" \
+    --arg loops "$loop_count" \
+    '{
+      captured_at: $ts,
+      pipeline: (if $pipeline != "" then ($pipeline | fromjson? // null) else null end),
+      autonomous_mode: ($auto == "true"),
+      dev_stage: (if $stage != "" then $stage else null end),
+      tool_calls: (if $tools != "" then ($tools | tonumber? // null) else null end),
+      loop_count: (if $loops != "" then ($loops | tonumber? // null) else null end)
+    } | del(.[] | nulls)'
+}
+
+state=$(collect_state 2>/dev/null)
+
+if [ -n "$state" ] && [ "$state" != "{}" ]; then
+  echo "$state" > "$STATE_FILE"
+  echo "[PreCompact] Task state saved to $STATE_FILE" >&2
+else
+  echo "[PreCompact] No active task state to save" >&2
+fi
+
+cat

package/templates/.claude/hooks/scripts/user-prompt-preprocessor.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+# UserPromptSubmit hook — advisory pre-processing of user input
+# Provides skill matching hints based on user input patterns
+# Advisory only — never blocks user prompt submission
+
+input=$(cat)
+user_input=$(echo "$input" | jq -r '.user_input // ""' 2>/dev/null)
+
+if [ -z "$user_input" ]; then
+  echo "$input"
+  exit 0
+fi
+
+# Detect common patterns and provide advisory hints
+hints=""
+
+# Korean session-end signals
+if echo "$user_input" | grep -qiE '(끝|종료|마무리|done|wrap up|end session)'; then
+  hints="${hints}[Hook] Session-end signal detected — R011 memory saves will be triggered\n"
+fi
+
+# Workflow invocation
+if echo "$user_input" | grep -qE '^/'; then
+  hints="${hints}[Hook] Slash command detected\n"
+fi
+
+# Output hints to stderr (advisory)
+if [ -n "$hints" ]; then
+  printf "%b" "$hints" >&2
+fi
+
+echo "$input"

package/templates/.claude/hooks/skill-count-reminder.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+# skill-count-reminder.sh — Advisory reminder when skills are created/modified
+# Triggered by PostToolUse on Write/Edit targeting .codex/skills/*/SKILL.md
+# R021: Advisory-only, never blocks (always exit 0)
+
+set -euo pipefail
+
+# Read tool input from stdin
+INPUT=$(cat)
+
+# Extract the file path from the tool input
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // .tool_input.path // ""' 2>/dev/null)
+
+# Only trigger for .codex/skills/ paths with SKILL.md
+if [[ "$FILE_PATH" == *".codex/skills/"*"SKILL.md"* ]]; then
+    SKILL_NAME=$(echo "$FILE_PATH" | sed 's|.*\.codex/skills/||' | sed 's|/SKILL.md||')
+    ACTUAL_COUNT=$(find .codex/skills -name 'SKILL.md' 2>/dev/null | wc -l | tr -d ' ')
+
+    cat >&2 << EOF
+─── [Skill Sync Reminder] New/modified skill: ${SKILL_NAME} ───
+Current skill count: ${ACTUAL_COUNT}
+
+Update these 6 locations before committing:
+  1. AGENTS.md           → 스킬 (${ACTUAL_COUNT} 디렉토리)
+  2. README.md line ~16  → ${ACTUAL_COUNT} skills
+  3. README.md line ~135 → ### Skills (${ACTUAL_COUNT})
+  4. README.md line ~275 → # ${ACTUAL_COUNT} skill modules
+  5. templates/AGENTS.md → 스킬 (${ACTUAL_COUNT} 디렉토리)
+  6. templates/.codex/skills/${SKILL_NAME}/SKILL.md → copy file
+───────────────────────────────────────────────────────
+EOF
+fi
+
+exit 0