Auto-Delegation Trigger (CRITICAL)

Reference:

.claude/skills/shared/auto-delegation.md

Behavior: When

agent_delegation.enabled: true

AND

default_mode: true

, skill automatically operates as Sub-Orchestrator.

// AUTO-DELEGATION CHECK - Execute at skill invocation
// If complex task detected, triggers: analyze → delegate → collect
const delegationDecision = checkAutoDelegation(SKILL_CONFIG, userRequest)
if (delegationDecision.shouldDelegate) {
  const complexity = analyzeTaskComplexity(taskDescription, SKILL_CONFIG)
  return executeDelegation(taskDescription, complexity, SKILL_CONFIG)
}
// Simple tasks execute directly without delegation overhead

Build Research Skill - Phase 1 Research Dispatcher

Version: 3.0.0 | Context: fork | Model: opus Parent: /build command | Phase: 1 of 3

Purpose

Execute Phase 1 (RESEARCH) of the enhanced /build workflow:

1. Parse concept name from user input (

   $ARGUMENTS

   )
2. Delegate research to claude-code-guide subagent
3. Generate capability inventory
4. Save results with resume support
5. Return L1 summary to Main Agent

1. Input Parsing

Supported Input Patterns

Pattern 1: /build "Progressive-Disclosure"     → concept = "Progressive-Disclosure"
Pattern 2: /build concept-name                 → concept = "concept-name"
Pattern 3: /build --research "concept-name"    → concept = "concept-name"
Pattern 4: $ARGUMENTS directly                 → concept = $ARGUMENTS.strip()

Build ID Generation (표준 Workload 시스템)

# Source centralized slug generator
source "${WORKSPACE_ROOT:-.}/.claude/skills/shared/slug-generator.sh"
source "${WORKSPACE_ROOT:-.}/.claude/skills/shared/workload-files.sh"

# 기본 동작: 항상 새 workload 생성 (독립 스킬)
CONCEPT="$1"
TOPIC="build-${CONCEPT:-research}"

# Workload ID 생성
WORKLOAD_ID=$(generate_workload_id "$TOPIC")
SLUG=$(generate_slug_from_workload "$WORKLOAD_ID")

# Short ID for display (레거시 호환)
BUILD_ID="${CONCEPT:0:3}-$(echo "$WORKLOAD_ID" | md5sum | cut -c1-4)"

# 디렉토리 구조 초기화
BUILD_DIR=".agent/builds/${SLUG}"
mkdir -p "${BUILD_DIR}"

# Workload 활성화
set_active_workload "$WORKLOAD_ID"

echo "🔬 Build research initialized: $SLUG (ID: $BUILD_ID)"

레거시 호환:

Format: {concept_slug[:3]}-{hash[:4]}
Example: "pro-a1b2" for "Progressive-Disclosure"

2. Research Delegation

Claude-Code-Guide Prompt

## Context
User wants to build a "{concept}" implementation using Claude Code native capabilities.

## Task
Research ALL relevant Claude Code native capabilities that could implement "{concept}".

## Required Output Format (JSON)
{
  "concept": "{concept}",
  "capabilities": [
    {
      "id": "S1",
      "name": "capability name",
      "category": "skill|agent|hook|pattern",
      "complexity": "basic|intermediate|advanced",
      "level": 0|50|100,
      "description": "1-2 sentence description",
      "fields": ["field1", "field2"],
      "dependencies": ["other_capability_id"]
    }
  ],
  "levels": {
    "0": {
      "name": "Basic",
      "capabilities": ["S1", "H1"],
      "capabilityCount": 2,
      "description": "Core functionality only"
    },
    "50": {
      "name": "Recommended",
      "capabilities": ["S1", "S2", "H1", "H2", "A1"],
      "capabilityCount": 5,
      "description": "Standard implementation with error handling"
    },
    "100": {
      "name": "Full",
      "capabilities": ["S1", "S2", "S3", "H1", "H2", "H3", "A1", "A2"],
      "capabilityCount": 8,
      "description": "Complete implementation with all features"
    }
  },
  "summary": {
    "total_capabilities": 8,
    "by_category": {"skill": 3, "agent": 2, "hook": 3, "pattern": 0},
    "recommended_level": 50,
    "estimated_complexity": "medium"
  }
}

## Research Areas
1. **Skills**: .claude/skills/ patterns, frontmatter fields, execution modes
2. **Agents**: .claude/agents/ patterns, tool restrictions, delegation
3. **Hooks**: Hook event types (13 events), input/output schemas
4. **Patterns**: Orchestration patterns, runtime chaining
5. **Task Tool**: Subagent delegation options

## Constraints
- Only include capabilities directly relevant to "{concept}"
- Categorize by complexity (basic/intermediate/advanced)
- Group into 3 implementation levels (0/50/100)
- Include dependencies between capabilities

3. Directory Structure

.agent/builds/
├── master/
│   ├── capability_index.json    # Master capability reference
│   └── complexity_levels.json   # Level 0/50/100 definitions
└── {build_id}/
    ├── research.json            # Raw capability inventory (Phase 1)
    ├── selection.json           # User selections (Phase 2/3)
    └── artifacts.json           # Generated file paths (Phase 3)

4. L1 Output Format (MAX 500 tokens)

Return this format to Main Agent:

taskId: {build_id}
agentType: claude-code-guide
summary: "Researched {total} capabilities for '{concept}' across {categories} categories"
status: success

# Progressive Disclosure Fields
priority: HIGH
recommendedRead:
  - anchor: "#capability-details"
    reason: "Full capability inventory with fields and dependencies"
  - anchor: "#level-definitions"
    reason: "Detailed breakdown of 0/50/100 complexity levels"

l2Index:
  - anchor: "#summary"
    tokens: 150
    priority: CRITICAL
    description: "Capability counts and recommended level"
  - anchor: "#levels"
    tokens: 300
    priority: HIGH
    description: "Level 0/50/100 definitions and capability mapping"
  - anchor: "#capability-details"
    tokens: 800
    priority: MEDIUM
    description: "Full capability inventory with schemas"

l2Path: .agent/builds/{build_id}/research.json
requiresL2Read: false
nextActionHint: "Select complexity level (0/50/100) to proceed to Phase 2"

# Build-specific fields
buildId: {build_id}
concept: "{concept}"
researchPath: .agent/builds/{build_id}/research.json
complexityOptions:
  - level: 0
    name: "Basic"
    capabilities: {count}
  - level: 50
    name: "Recommended"
    capabilities: {count}
  - level: 100
    name: "Full"
    capabilities: {count}

5. Execution Flow

┌─────────────────────────────────────────────────────┐
│ 1. Parse Concept                                    │
│    concept, error = parse_concept($ARGUMENTS)       │
│    if error: return error message                   │
└──────────────────────┬──────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────┐
│ 2. Generate Build ID                                │
│    build_id = generate_build_id(concept)            │
│    e.g., "pro-a1b2"                                 │
└──────────────────────┬──────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────┐
│ 3. Delegate Research                                │
│    Task(                                            │
│      subagent_type="claude-code-guide",             │
│      prompt=RESEARCH_PROMPT.format(concept),        │
│      model="haiku"                                  │
│    )                                                │
└──────────────────────┬──────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────┐
│ 4. Save Results                                     │
│    .agent/builds/{build_id}/research.json           │
│    Initialize: selection.json, artifacts.json      │
└──────────────────────┬──────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────┐
│ 5. Return L1 Summary                                │
│    MAX 500 tokens → Main Agent                      │
│    Includes: complexity options, l2Index            │
└─────────────────────────────────────────────────────┘

6. Resume Support

Check Existing Build

# If .agent/builds/{build_id}/research.json exists
# → Return existing L1 summary instead of re-running research

Resume Command

/build --resume {build_id}

7. Error Handling

/build "concept-name"

8. Integration Points

Phase Transition

Phase 1 (This Skill)          Phase 2 (build.md)           Phase 3 (build.md)
┌─────────────────────┐      ┌─────────────────────┐      ┌─────────────────────┐
│ build-research.md   │──────│ L1/L2/L3 Roadmap    │──────│ Multi-round Q&A     │
│                     │      │ Presentation        │      │ + File Generation   │
│ - Parse concept     │      │                     │      │                     │
│ - Research caps     │      │ - Display levels    │      │ - Select features   │
│ - Save research.json│      │ - User selects 0/50 │      │ - Generate files    │
│ - Return L1 summary │      │   /100              │      │ - Save artifacts    │
└─────────────────────┘      └─────────────────────┘      └─────────────────────┘

Called By

• .claude/commands/build.md

  (Phase 1 invocation)

• .claude/skills/build.md

  (delegated execution)

9. Master Reference Files

capability_index.json

Location:

.agent/builds/master/capability_index.json

Contains comprehensive capability inventory from claude-code-guide research.

complexity_levels.json

Location:

.agent/builds/master/complexity_levels.json

Defines Level 0/50/100 with capability counts and examples.

Instructions

When invoked with $ARGUMENTS containing a concept name:

1. Parse the concept from $ARGUMENTS (remove quotes if present)
2. Generate build_id using format

   {slug[:3]}-{hash[:4]}

3. Check for existing build at

   .agent/builds/{build_id}/research.json

   • If exists, return existing L1 summary
4. Delegate to claude-code-guide with the research prompt above
5. Parse the JSON response and validate structure
6. Create directory

   .agent/builds/{build_id}/

7. Save research.json with capability inventory
8. Initialize selection.json and artifacts.json (empty, for Phase 2/3)
9. Return L1 summary (max 500 tokens) with:
   • Build ID
   • Concept name
   • Complexity level options (0/50/100 with capability counts)
   • l2Path pointing to research.json
   • nextActionHint for Phase 2

Parameter Module Compatibility (V2.1.0)

/build/parameters/

모듈과의 호환성 체크리스트

model-selection.md

model: haiku

context-mode.md

context: fork

tool-config.md

hook-config.md

permission-mode.md

task-params.md

Version History

EFL Pattern Implementation (V3.0.0)

P1: Skill as Sub-Orchestrator

Single-agent delegation to claude-code-guide:

/build-research (Main)
    │
    └─► claude-code-guide (Research Agent)
        └─► Capability inventory generation

P6: Agent Internal Feedback Loop

Research agent includes self-validation:

const researchPrompt = `
## Internal Feedback Loop (P6 - REQUIRED)
1. Generate capability inventory
2. Self-validate JSON structure:
   - All required fields present
   - Level 0/50/100 properly defined
   - Dependencies are valid references
3. If validation fails, retry (max 3 times)
4. Output valid JSON after validation passes
`

Created by Plan Agent (a576fce) | 2026-01-23 Updated for EFL V3.0.0 | 2026-01-29