oh-my-customcode 0.34.0 → 0.35.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-customcode",
-  "version": "0.34.0",
+  "version": "0.35.1",
   "description": "Batteries-included agent harness for Claude Code",
   "type": "module",
   "bin": {

package/templates/.claude/hooks/hooks.json

@@ -221,6 +221,16 @@
           }
         ],
         "description": "Detect repetitive failure loops and advise recovery strategies"
+      },
+      {
+        "matcher": "tool == \"Edit\" || tool == \"Write\" || tool == \"Bash\" || tool == \"Task\" || tool == \"Agent\"",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash .claude/hooks/scripts/cost-cap-advisor.sh"
+          }
+        ],
+        "description": "Advisory cost cap monitoring — warn when session cost approaches configurable limit"
       }
     ],
     "Stop": [

package/templates/.claude/hooks/scripts/cost-cap-advisor.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+# cost-cap-advisor.sh — Advisory hook for session cost monitoring
+# Trigger: PostToolUse (Agent/Task)
+# Purpose: Warn when session cost approaches configurable cap
+# Protocol: stdin JSON -> stdout pass-through, exit 0 always (advisory only, R010)
+
+input=$(cat)
+
+# Cost bridge file written by statusline.sh
+COST_FILE="/tmp/.claude-cost-${PPID}"
+ADVISORY_FILE="/tmp/.claude-cost-advisory-${PPID}"
+
+# Configurable cap (default $5.00, override via CLAUDE_COST_CAP env var)
+COST_CAP="${CLAUDE_COST_CAP:-5.00}"
+
+# Check if cost data is available
+if [ ! -f "$COST_FILE" ]; then
+  echo "$input"
+  exit 0
+fi
+
+# Read cost data (TSV: cost_usd, ctx_pct, timestamp)
+IFS=$'\t' read -r cost_usd ctx_pct timestamp < "$COST_FILE" 2>/dev/null || {
+  echo "$input"
+  exit 0
+}
+
+# Validate cost_usd is a number
+if ! printf '%f' "$cost_usd" >/dev/null 2>&1; then
+  echo "$input"
+  exit 0
+fi
+
+# Calculate percentage of cap used
+# Use bc for float arithmetic
+cost_pct=$(echo "scale=0; $cost_usd * 100 / $COST_CAP" | bc 2>/dev/null || echo "0")
+
+# Staleness check — skip if data is older than 60 seconds
+now=$(date +%s)
+age=$((now - ${timestamp:-0}))
+if [ "$age" -gt 60 ]; then
+  echo "$input"
+  exit 0
+fi
+
+# Read last advisory level to avoid repeating the same warning
+last_level=""
+if [ -f "$ADVISORY_FILE" ]; then
+  last_level=$(cat "$ADVISORY_FILE" 2>/dev/null || echo "")
+fi
+
+# Determine advisory level and emit warning (only once per level)
+if [ "$cost_pct" -ge 100 ] && [ "$last_level" != "100" ]; then
+  echo "[Cost Cap] Session cost \$${cost_usd} has reached cap \$${COST_CAP} (${cost_pct}%)" >&2
+  echo "[Cost Cap] Consider wrapping up or increasing CLAUDE_COST_CAP" >&2
+  echo "100" > "$ADVISORY_FILE"
+elif [ "$cost_pct" -ge 90 ] && [ "$last_level" != "90" ] && [ "$last_level" != "100" ]; then
+  echo "[Cost Cap] Session cost \$${cost_usd} at 90% of cap \$${COST_CAP}" >&2
+  echo "[Cost Cap] Ecomode recommended — consider /compact" >&2
+  echo "90" > "$ADVISORY_FILE"
+elif [ "$cost_pct" -ge 75 ] && [ "$last_level" != "75" ] && [ "$last_level" != "90" ] && [ "$last_level" != "100" ]; then
+  echo "[Cost Cap] Session cost \$${cost_usd} at 75% of cap \$${COST_CAP}" >&2
+  echo "75" > "$ADVISORY_FILE"
+elif [ "$cost_pct" -ge 50 ] && [ -z "$last_level" ]; then
+  echo "[Cost Cap] Session cost \$${cost_usd} at 50% of cap \$${COST_CAP}" >&2
+  echo "50" > "$ADVISORY_FILE"
+fi
+
+# Pass through — advisory only
+echo "$input"
+exit 0

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

@@ -31,7 +31,7 @@ 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 -n \
+entry=$(jq -cn \
   --arg ts "$timestamp" \
   --arg tool "$tool_name" \
   --arg path "$file_path" \

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

@@ -2,16 +2,16 @@
 set -euo pipefail
 
 # Task/Agent Outcome Recorder Hook
-# Trigger: PostToolUse, tool == "Task" || tool == "Agent"
+# 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
-agent_type=$(echo "$input" | jq -r '.tool_input.subagent_type // "unknown"')
-model=$(echo "$input" | jq -r '.tool_input.model // "inherit"')
-description=$(echo "$input" | jq -r '.tool_input.description // ""' | head -c 80)
+# 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)
 
 # Determine outcome
 is_error=$(echo "$input" | jq -r '.tool_output.is_error // false')
@@ -24,8 +24,34 @@ else
   error_summary=""
 fi
 
-# Session-scoped outcome log
+# Session-scoped outcome log and agent count tracker
 OUTCOME_FILE="/tmp/.claude-task-outcomes-${PPID}"
+TASK_COUNT_FILE="/tmp/.claude-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
 
 # Append JSON line entry
 timestamp=$(date -u +%Y-%m-%dT%H:%M:%SZ)
@@ -34,7 +60,7 @@ entry=$(jq -n \
   --arg agent "$agent_type" \
   --arg model "$model" \
   --arg outcome "$outcome" \
-  --arg pattern "unknown" \
+  --arg pattern "$pattern" \
   --arg desc "$description" \
   --arg err "$error_summary" \
   '{timestamp: $ts, agent_type: $agent, model: $model, outcome: $outcome, pattern_used: $pattern, description: $desc, error_summary: $err}')

package/templates/.claude/skills/dev-refactor/SKILL.md

@@ -20,6 +20,70 @@ Refactor code for better structure, naming, and patterns using language-specific
 
 **Pre-execution check**: Verify test coverage exists for the refactoring target. Refactoring without tests risks silent regressions.
 
+## Pre-flight Guards
+
+Before executing the refactoring workflow, the agent MUST run these checks:
+
+### Guard 1: Test Coverage Check
+**Level**: WARN
+**Check**: Verify test files exist for the refactoring target
+```bash
+# For target file src/module/foo.ts, check for:
+# - src/module/foo.test.ts
+# - src/module/foo.spec.ts
+# - tests/module/foo.test.ts
+# - test/module/foo.test.ts
+# - __tests__/module/foo.test.ts
+# For Go: foo_test.go in same package
+# For Python: test_foo.py or foo_test.py
+```
+**Action**: `[Pre-flight] WARN: No test file found for {target}. Refactoring without tests risks silent regressions. Consider writing tests first (/structured-dev-cycle).`
+
+### Guard 2: Rename-Only Detection
+**Level**: INFO
+**Check**: If the user request is purely about renaming (no structural change)
+```
+# Keyword detection in user request
+keywords: rename, 이름 변경, 이름 바꿔, rename variable, rename function
+# AND no structural keywords
+structural_keywords: extract, split, merge, restructure, reorganize, decompose
+```
+**Action**: `[Pre-flight] INFO: For rename-only refactoring, IDE rename (F2) or sed is faster and safer (handles all references). Proceeding with full refactoring.`
+
+### Guard 3: Formatting-Only Request Detection
+**Level**: INFO
+**Check**: If the request is about formatting or style cleanup
+```
+# Keyword detection
+keywords: format, formatting, indent, indentation, 포맷, 스타일, whitespace, spacing
+```
+**Action**: `[Pre-flight] INFO: For formatting cleanup, run the appropriate formatter (prettier, gofmt, black, rustfmt). Proceeding with full refactoring.`
+
+### Guard 4: File Move Detection
+**Level**: INFO
+**Check**: If the request is about moving files between directories
+```
+# Keyword detection
+keywords: move file, move to, 파일 이동, 옮겨, relocate, reorganize files
+# AND no code-level changes mentioned
+```
+**Action**: `[Pre-flight] INFO: For file moves without code changes, use git mv via mgr-gitnerd to preserve git history.`
+
+### Display Format
+
+```
+[Pre-flight] dev-refactor
+├── Test coverage: WARN — no test file for src/utils.ts
+├── Rename-only: PASS
+├── Formatting-only: PASS
+└── File move: PASS
+Result: PROCEED WITH CAUTION (0 GATE, 1 WARN, 0 INFO)
+```
+
+If any GATE: block and suggest prerequisite.
+If any WARN: show warning, ask user to confirm.
+If only PASS/INFO: proceed automatically.
+
 ## Parameters
 
 | Name | Type | Required | Description |
@@ -39,6 +103,7 @@ Refactor code for better structure, naming, and patterns using language-specific
 ## Workflow
 
 ```
+0. Run pre-flight guards (MUST complete before proceeding)
 1. Detect language (or use --lang)
 2. Select appropriate expert agent
 3. Load language-specific skill

package/templates/.claude/skills/dev-review/SKILL.md

@@ -20,6 +20,70 @@ Review code for best practices using language-specific expert agents.
 
 **Pre-execution check**: If the issue is purely formatting, run the appropriate formatter first.
 
+## Pre-flight Guards
+
+Before executing the review workflow, the agent MUST run these checks:
+
+### Guard 1: Auto-generated Code Detection
+**Level**: WARN
+**Check**: Scan target files for auto-generation markers
+```bash
+# Detection patterns (any match = WARN)
+grep -rl "DO NOT EDIT" {target} 2>/dev/null
+grep -rl "auto-generated" {target} 2>/dev/null
+grep -rl "@generated" {target} 2>/dev/null
+# File pattern detection
+# *.gen.*, *.pb.go, */generated/*, */proto/*, *_generated.*, *.g.dart
+```
+**Action**: `[Pre-flight] WARN: Auto-generated code detected in {file}. Generated code follows its own conventions — review may produce false positives. Continue? [Y/n]`
+
+### Guard 2: Formatting-Only Changes Detection
+**Level**: INFO
+**Check**: If reviewing changed files (not full codebase), check if changes are formatting-only
+```bash
+# If git diff is available for the target
+git diff --stat {target} | grep -E '^\s+\d+ files? changed'
+# Compare with whitespace-ignored diff
+git diff -w {target}
+# If -w diff is empty but regular diff has changes → formatting only
+```
+**Action**: `[Pre-flight] INFO: Changes in {file} appear to be formatting-only. Consider running the appropriate formatter instead (prettier, gofmt, black).`
+
+### Guard 3: Single Syntax Error Detection
+**Level**: INFO
+**Check**: If target is a single file and the request mentions "error", "syntax", or "broken"
+```
+# Keyword detection in user request
+keywords: error, syntax, broken, doesn't compile, won't build
+# Single file check
+target is exactly 1 file (not a directory)
+```
+**Action**: `[Pre-flight] INFO: For single syntax errors, IDE/LSP diagnostics are faster. Proceeding with full review.`
+
+### Guard 4: Linter/Formatter Available Detection
+**Level**: INFO
+**Check**: Detect if a project-appropriate linter exists
+```bash
+# Check for linter configs in project root
+ls .eslintrc* .prettierrc* biome.json .golangci.yml pyproject.toml .rubocop.yml 2>/dev/null
+```
+**Action**: `[Pre-flight] INFO: Linter config found ({config}). For style-only issues, run the linter directly.`
+
+### Display Format
+
+```
+[Pre-flight] dev-review
+├── Auto-generated code: PASS
+├── Formatting-only changes: INFO — whitespace changes in src/util.ts
+├── Single syntax error: PASS
+└── Linter available: INFO — .eslintrc.json found
+Result: PROCEED (0 GATE, 0 WARN, 2 INFO)
+```
+
+If any GATE: block and suggest alternative.
+If any WARN: show warning, ask user to confirm.
+If only PASS/INFO: proceed automatically.
+
 ## Parameters
 
 | Name | Type | Required | Description |
@@ -38,6 +102,7 @@ Review code for best practices using language-specific expert agents.
 ## Workflow
 
 ```
+0. Run pre-flight guards (see ## Pre-flight Guards)
 1. Detect language (or use --lang)
 2. Select appropriate expert agent
 3. Load language-specific skill

package/templates/.claude/skills/research/SKILL.md

@@ -31,10 +31,113 @@ Orchestrates 10 parallel research teams for comprehensive deep analysis of any t
 
 **Pre-execution check**: If the query can be answered with < 3 sources, skip 10-team research.
 
+## Pre-flight Guards
+
+Before executing the 10-team research workflow, the agent MUST run these checks. Research is a high-cost operation (~$8-15) — these guards prevent wasteful execution.
+
+### Guard Levels
+
+| Level | Meaning | Action |
+|-------|---------|--------|
+| PASS | No issues detected | Proceed with research |
+| INFO | Minor suggestion | Log note, proceed |
+| WARN | Potentially wasteful | Show warning with cost estimate, ask confirmation |
+| GATE | Wrong tool — use simpler alternative | Block execution, suggest alternative |
+
+### Guard 1: Query Complexity Assessment
+
+**Level**: GATE or PASS
+
+**Check**: Assess if the query requires multi-team research
+
+```
+# Simple factual questions → GATE
+indicators_simple:
+  - Query is < 10 words
+  - Query asks "what is", "how to", "when was" (factual)
+  - Query has a single definitive answer
+  - Can be answered from a single documentation source
+
+# Complex research questions → PASS
+indicators_complex:
+  - Query involves comparison of 3+ alternatives
+  - Query requires analysis across multiple dimensions
+  - Query mentions "compare", "evaluate", "analyze", "research"
+  - Query references a repository or ecosystem for deep analysis
+```
+
+**Action (GATE)**: `[Pre-flight] GATE: Query appears to be a simple factual question. Use direct answer or single WebSearch instead. 10-team research (~$8-15) would be wasteful. Override with /research --force if intended.`
+
+### Guard 2: Single-File Review Detection
+
+**Level**: GATE
+
+**Check**: If the query references a single file for review
+
+```
+# Detection
+- Query mentions a specific file path (e.g., src/main.go)
+- Query asks to "review" or "analyze" a single file
+- No broader context requested
+```
+
+**Action**: `[Pre-flight] GATE: For single-file review, use /dev-review {file} instead. Research is for multi-source analysis.`
+
+### Guard 3: Known Solution Detection
+
+**Level**: INFO
+
+**Check**: If the query is about implementing a known solution
+
+```
+# Detection
+keywords: implement, build, create, add feature, 구현, 만들어
+# AND the solution approach is well-known (not requiring research)
+```
+
+**Action**: `[Pre-flight] INFO: If the implementation approach is already known, consider /structured-dev-cycle instead of research. Proceeding with research.`
+
+### Guard 4: Context Budget Check
+
+**Level**: WARN
+
+**Check**: Estimate context impact of 10-team research
+
+```bash
+# Check current context usage from statusline data
+CONTEXT_FILE="/tmp/.claude-context-$PPID"
+if [ -f "$CONTEXT_FILE" ]; then
+  context_pct=$(cat "$CONTEXT_FILE")
+  if [ "$context_pct" -gt 40 ]; then
+    # WARN — research will consume significant additional context
+  fi
+fi
+```
+
+**Action**: `[Pre-flight] WARN: Context usage at {pct}%. 10-team research typically adds 30-40% context. Consider /compact before proceeding, or results may be truncated.`
+
+### Display Format
+
+```
+[Pre-flight] research
+├── Query complexity: PASS — multi-dimensional comparison detected
+├── Single-file review: PASS
+├── Known solution: PASS
+└── Context budget: WARN — context at 45%, research adds ~35%
+Result: PROCEED WITH CAUTION (0 GATE, 1 WARN, 0 INFO)
+Cost estimate: ~$8-15 for 10-team parallel research
+```
+
+If any GATE: block and suggest alternative. User can override with `--force`.
+If any WARN: show warning with cost context, ask user to confirm.
+If only PASS/INFO: proceed automatically.
+
 ## Architecture — 4 Phases
 
 ### Phase 1: Parallel Research (10 teams, batched per R009)
 
+**Step 0**: Pre-flight guards pass (see Pre-flight Guards section)
+
 Teams operate in breadth/depth pairs across 5 domains:
 
 | Pair | Domain | Team | Role | Focus |

package/templates/.claude/statusline.sh

@@ -69,6 +69,12 @@ IFS=$'\t' read -r model_name project_dir ctx_pct ctx_size cost_usd <<< "$(
     ] | @tsv'
 )"
 
+# ---------------------------------------------------------------------------
+# 4b. Cost & context data bridge — write to temp file for hooks
+# ---------------------------------------------------------------------------
+COST_BRIDGE_FILE="/tmp/.claude-cost-${PPID}"
+printf '%s\t%s\t%s\n' "$cost_usd" "$ctx_pct" "$(date +%s)" > "$COST_BRIDGE_FILE" 2>/dev/null || true
+
 # ---------------------------------------------------------------------------
 # 5. Model display name + color (bash 3.2 compatible case pattern matching)
 #    Model detection (kept for internal reference, not displayed in statusline)

package/templates/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.34.0",
+  "version": "0.35.1",
   "lastUpdated": "2026-03-14T00:00:00.000Z",
   "components": [
     {