@su-record/vibe 2.8.49 → 2.8.50

package/skills/event-planning/templates/event-plan.md

@@ -1,91 +1,91 @@
-# Event Plan: {{EVENT_NAME}} {{EDITION}}회
-
-| Field | Value |
-|-------|-------|
-| Event type | {{TYPE}} (MDC / Webinar / DWK / Other) |
-| Date & time | {{DATE}} {{TIME}} |
-| Venue | {{VENUE}} |
-| Format | {{OFFLINE / ONLINE / HYBRID}} |
-| Expected attendees | {{EXPECTED_COUNT}} |
-| Registration URL | {{REG_URL}} |
-| Participation fee | {{FEE}} |
-
-## Topic & Theme
-
-**Main theme**: {{THEME}}
-
-**Session topics:**
-
-| # | Topic | Speaker | Duration |
-|---|-------|---------|----------|
-| 1 | {{TOPIC_1}} | {{SPEAKER_1}} | {{DURATION}} |
-| 2 | {{TOPIC_2}} | {{SPEAKER_2}} | {{DURATION}} |
-| 3 | {{TOPIC_3}} | {{SPEAKER_3}} | {{DURATION}} |
-
-## Timetable
-
-| Time | Item |
-|------|------|
-| {{TIME_1}} | {{ITEM_1}} |
-| {{TIME_2}} | {{ITEM_2}} |
-| {{TIME_3}} | {{ITEM_3}} |
-| {{TIME_4}} | Q&A + Networking |
-
-## Speakers
-
-### Speaker 1: {{SPEAKER_1_NAME}}
-
-- Role: {{ROLE}}
-- Company: {{COMPANY}}
-- Topic: {{TOPIC}}
-- Contact: {{EMAIL_OR_DM}}
-- Confirmation status: {{PENDING / CONFIRMED}}
-
-### Speaker 2: {{SPEAKER_2_NAME}}
-
-- Role: {{ROLE}}
-- Company: {{COMPANY}}
-- Topic: {{TOPIC}}
-- Contact: {{EMAIL_OR_DM}}
-- Confirmation status: {{PENDING / CONFIRMED}}
-
-## D-Day Timeline
-
-| D-Day | Task | Owner | Status |
-|-------|------|-------|--------|
-| D-{{N}} | {{TASK_1}} | {{OWNER}} | Not started |
-| D-{{N}} | {{TASK_2}} | {{OWNER}} | Not started |
-| D-3 | Confirmation email + SMS | {{OWNER}} | Not started |
-| D-1 | Nametags + checklist + slides | {{OWNER}} | Not started |
-| D-Day | Day-of operations | {{OWNER}} | Not started |
-| D+1 | Review post + settlement | {{OWNER}} | Not started |
-
-## Budget
-
-| Item | Estimated Cost | Actual Cost |
-|------|---------------|-------------|
-| Venue | {{AMOUNT}} | — |
-| Snacks / Refreshments | {{AMOUNT}} | — |
-| Speaker gifts | {{AMOUNT}} | — |
-| Printing (nametags, etc.) | {{AMOUNT}} | — |
-| **Total** | {{TOTAL}} | — |
-
-Revenue: {{EXPECTED_ATTENDEES}} × {{FEE}} = {{EXPECTED_REVENUE}}
-
-## State File Reference
-
-Save progress to `.event_state.json` after each step completion.
-
-```json
-{
-  "event_id": "{{TYPE}}-{{EDITION}}",
-  "type": "{{TYPE}}",
-  "date": "{{DATE}}",
-  "title": "{{EVENT_NAME}} {{EDITION}}회",
-  "topic": "{{THEME}}",
-  "speakers": [],
-  "current_step": "{{CURRENT_STEP}}",
-  "completed_steps": [],
-  "outputs": {}
-}
-```
+# Event Plan: {{EVENT_NAME}} {{EDITION}}회
+
+| Field | Value |
+|-------|-------|
+| Event type | {{TYPE}} (MDC / Webinar / DWK / Other) |
+| Date & time | {{DATE}} {{TIME}} |
+| Venue | {{VENUE}} |
+| Format | {{OFFLINE / ONLINE / HYBRID}} |
+| Expected attendees | {{EXPECTED_COUNT}} |
+| Registration URL | {{REG_URL}} |
+| Participation fee | {{FEE}} |
+
+## Topic & Theme
+
+**Main theme**: {{THEME}}
+
+**Session topics:**
+
+| # | Topic | Speaker | Duration |
+|---|-------|---------|----------|
+| 1 | {{TOPIC_1}} | {{SPEAKER_1}} | {{DURATION}} |
+| 2 | {{TOPIC_2}} | {{SPEAKER_2}} | {{DURATION}} |
+| 3 | {{TOPIC_3}} | {{SPEAKER_3}} | {{DURATION}} |
+
+## Timetable
+
+| Time | Item |
+|------|------|
+| {{TIME_1}} | {{ITEM_1}} |
+| {{TIME_2}} | {{ITEM_2}} |
+| {{TIME_3}} | {{ITEM_3}} |
+| {{TIME_4}} | Q&A + Networking |
+
+## Speakers
+
+### Speaker 1: {{SPEAKER_1_NAME}}
+
+- Role: {{ROLE}}
+- Company: {{COMPANY}}
+- Topic: {{TOPIC}}
+- Contact: {{EMAIL_OR_DM}}
+- Confirmation status: {{PENDING / CONFIRMED}}
+
+### Speaker 2: {{SPEAKER_2_NAME}}
+
+- Role: {{ROLE}}
+- Company: {{COMPANY}}
+- Topic: {{TOPIC}}
+- Contact: {{EMAIL_OR_DM}}
+- Confirmation status: {{PENDING / CONFIRMED}}
+
+## D-Day Timeline
+
+| D-Day | Task | Owner | Status |
+|-------|------|-------|--------|
+| D-{{N}} | {{TASK_1}} | {{OWNER}} | Not started |
+| D-{{N}} | {{TASK_2}} | {{OWNER}} | Not started |
+| D-3 | Confirmation email + SMS | {{OWNER}} | Not started |
+| D-1 | Nametags + checklist + slides | {{OWNER}} | Not started |
+| D-Day | Day-of operations | {{OWNER}} | Not started |
+| D+1 | Review post + settlement | {{OWNER}} | Not started |
+
+## Budget
+
+| Item | Estimated Cost | Actual Cost |
+|------|---------------|-------------|
+| Venue | {{AMOUNT}} | — |
+| Snacks / Refreshments | {{AMOUNT}} | — |
+| Speaker gifts | {{AMOUNT}} | — |
+| Printing (nametags, etc.) | {{AMOUNT}} | — |
+| **Total** | {{TOTAL}} | — |
+
+Revenue: {{EXPECTED_ATTENDEES}} × {{FEE}} = {{EXPECTED_REVENUE}}
+
+## State File Reference
+
+Save progress to `.event_state.json` after each step completion.
+
+```json
+{
+  "event_id": "{{TYPE}}-{{EDITION}}",
+  "type": "{{TYPE}}",
+  "date": "{{DATE}}",
+  "title": "{{EVENT_NAME}} {{EDITION}}회",
+  "topic": "{{THEME}}",
+  "speakers": [],
+  "current_step": "{{CURRENT_STEP}}",
+  "completed_steps": [],
+  "outputs": {}
+}
+```

package/skills/exec-plan/SKILL.md

@@ -1,149 +1,149 @@
----
-name: exec-plan
-tier: core
-description: "Convert SPEC into a self-contained execution plan that agents can run autonomously for hours. Use when a SPEC has 3+ phases, multiple files to change, or complex dependencies between tasks. Produces a plan with explicit file paths, interface extracts, and acceptance criteria so agents never need to 'figure out' context. Must use this skill when launching long-running autonomous work, parallelizing implementation across agents, or when user says 'execute this spec' or 'run this plan'."
-triggers: [exec plan, execution plan, autonomous plan, self-contained plan, long-running]
-priority: 70
-chain-next: [commit-push-pr]
----
-
-# ExecPlan — Self-Contained Execution Plan Generator
-
-> **Principle**: "If the agent can't see it, it doesn't exist." Every decision, file path, pattern, and verification step must be explicit in the plan — no implicit knowledge allowed.
-
-## When to Use
-
-Before `/vibe.run`, generate an ExecPlan to make execution deterministic:
-
-| Scenario | Signal |
-|----------|--------|
-| Complex SPEC (3+ phases) | Agent needs long autonomous execution |
-| Team/multi-agent execution | Multiple agents need shared understanding |
-| Context window pressure | Plan survives `/new` session handoff |
-| Unfamiliar codebase | Agent can't rely on implicit knowledge |
-
-## Core Flow
-
-```
-SPEC + Feature → ANALYZE → RESOLVE → GENERATE → PERSIST
-```
-
-### Step 1: ANALYZE — Extract Everything Needed
-
-Read the SPEC and Feature files, then extract:
-
-```
-For each Phase → For each Scenario:
-  1. Requirements (REQ-* IDs)
-  2. Given/When/Then conditions
-  3. Affected files (MUST exist — verify with Glob)
-  4. Dependencies (imports, packages)
-  5. Existing patterns to follow (read actual code, don't assume)
-```
-
-**Parallel exploration** (3+ agents):
-- Agent 1: Map all file paths mentioned/implied in SPEC → verify they exist
-- Agent 2: For each affected file, extract current interfaces/types/exports
-- Agent 3: Find existing patterns (naming conventions, error handling, test structure)
-
-### Step 2: RESOLVE — Eliminate All Ambiguity
-
-For every decision point in the SPEC, resolve it NOW:
-
-| Ambiguity | Resolution |
-|-----------|------------|
-| "Add validation" | → Which fields? What rules? What error messages? |
-| "Handle errors" | → Which error codes? What response format? |
-| "Follow existing pattern" | → Copy the ACTUAL pattern code into the plan |
-| "Update tests" | → Which test file? What test framework? What assertions? |
-
-**Rule**: If you'd need to "figure it out later", resolve it now. The plan must be executable by an agent with ZERO codebase knowledge.
-
-### Step 3: GENERATE — Write the ExecPlan
-
-Output format: `.claude/vibe/specs/{feature-name}-execplan.md`
-
-```markdown
-# ExecPlan: {feature-name}
-
-## Meta
-- SPEC: .claude/vibe/specs/{name}.md
-- Feature: .claude/vibe/features/{name}.feature
-- Generated: {timestamp}
-- Phases: {count}
-- Scenarios: {count}
-
-## Pre-flight Checks
-- [ ] `npm run build` passes
-- [ ] `npx vitest run` passes (baseline)
-- [ ] Required files exist: {list}
-
-## Phase {N}: {phase-name}
-
-### Environment
-- Files to modify: {exact paths}
-- Files to create: {exact paths}
-- Dependencies to add: {package@version}
-- Patterns to follow: (inline code snippets from codebase)
-
-### Scenario {N}.{M}: {scenario-name}
-
-**Given**: {precondition}
-→ Setup: {exact code/commands to establish precondition}
-
-**When**: {action}
-→ Implement: {step-by-step implementation instructions}
-  - File: {path}
-  - Location: after line containing `{anchor text}`
-  - Code: (inline snippet)
-  - Imports needed: {list}
-
-**Then**: {expected result}
-→ Verify:
-  - Command: `{test command}`
-  - Expected: {output/behavior}
-  - Fallback: {what to do if verification fails}
-
-### Phase {N} Gate
-- [ ] Build: `npm run build`
-- [ ] Tests: `npx vitest run {relevant-test-files}`
-- [ ] Type check: `npx tsc --noEmit`
-
-## Completion Criteria
-- Coverage threshold: ≥95%
-- All scenarios passing
-- No regressions in existing tests
-- RTM: `generateTraceabilityMatrix("{feature-name}")`
-```
-
-### Step 4: PERSIST — Save and Link
-
-1. Save ExecPlan to `.claude/vibe/specs/{feature-name}-execplan.md`
-2. Save session context: `save_memory("execplan-{feature}", {summary})`
-3. Output execution command:
-
-```
-Ready to execute:
-  /vibe.run "{feature-name}" ultrawork
-
-Or hand off to new session:
-  /vibe.utils --continue
-  → Load: .claude/vibe/specs/{feature-name}-execplan.md
-```
-
-## Quality Checks
-
-| Check | Criteria |
-|-------|----------|
-| No implicit knowledge | Every file path verified with Glob |
-| No "figure it out" | Every decision resolved with actual code |
-| Survives handoff | Plan readable without any prior context |
-| Inline patterns | Actual code snippets, not "follow existing pattern" |
-| Verification steps | Every scenario has a concrete verification command |
-
-## Anti-patterns
-
-- "See the existing implementation" → Copy the relevant code inline
-- "Follow the pattern in X" → Show the actual pattern
-- "Standard error handling" → Specify exact error codes and messages
-- "Update tests accordingly" → Name the test file, framework, and assertions
+---
+name: exec-plan
+tier: core
+description: "Convert SPEC into a self-contained execution plan that agents can run autonomously for hours. Use when a SPEC has 3+ phases, multiple files to change, or complex dependencies between tasks. Produces a plan with explicit file paths, interface extracts, and acceptance criteria so agents never need to 'figure out' context. Must use this skill when launching long-running autonomous work, parallelizing implementation across agents, or when user says 'execute this spec' or 'run this plan'."
+triggers: [exec plan, execution plan, autonomous plan, self-contained plan, long-running]
+priority: 70
+chain-next: [commit-push-pr]
+---
+
+# ExecPlan — Self-Contained Execution Plan Generator
+
+> **Principle**: "If the agent can't see it, it doesn't exist." Every decision, file path, pattern, and verification step must be explicit in the plan — no implicit knowledge allowed.
+
+## When to Use
+
+Before `/vibe.run`, generate an ExecPlan to make execution deterministic:
+
+| Scenario | Signal |
+|----------|--------|
+| Complex SPEC (3+ phases) | Agent needs long autonomous execution |
+| Team/multi-agent execution | Multiple agents need shared understanding |
+| Context window pressure | Plan survives `/new` session handoff |
+| Unfamiliar codebase | Agent can't rely on implicit knowledge |
+
+## Core Flow
+
+```
+SPEC + Feature → ANALYZE → RESOLVE → GENERATE → PERSIST
+```
+
+### Step 1: ANALYZE — Extract Everything Needed
+
+Read the SPEC and Feature files, then extract:
+
+```
+For each Phase → For each Scenario:
+  1. Requirements (REQ-* IDs)
+  2. Given/When/Then conditions
+  3. Affected files (MUST exist — verify with Glob)
+  4. Dependencies (imports, packages)
+  5. Existing patterns to follow (read actual code, don't assume)
+```
+
+**Parallel exploration** (3+ agents):
+- Agent 1: Map all file paths mentioned/implied in SPEC → verify they exist
+- Agent 2: For each affected file, extract current interfaces/types/exports
+- Agent 3: Find existing patterns (naming conventions, error handling, test structure)
+
+### Step 2: RESOLVE — Eliminate All Ambiguity
+
+For every decision point in the SPEC, resolve it NOW:
+
+| Ambiguity | Resolution |
+|-----------|------------|
+| "Add validation" | → Which fields? What rules? What error messages? |
+| "Handle errors" | → Which error codes? What response format? |
+| "Follow existing pattern" | → Copy the ACTUAL pattern code into the plan |
+| "Update tests" | → Which test file? What test framework? What assertions? |
+
+**Rule**: If you'd need to "figure it out later", resolve it now. The plan must be executable by an agent with ZERO codebase knowledge.
+
+### Step 3: GENERATE — Write the ExecPlan
+
+Output format: `.claude/vibe/specs/{feature-name}-execplan.md`
+
+```markdown
+# ExecPlan: {feature-name}
+
+## Meta
+- SPEC: .claude/vibe/specs/{name}.md
+- Feature: .claude/vibe/features/{name}.feature
+- Generated: {timestamp}
+- Phases: {count}
+- Scenarios: {count}
+
+## Pre-flight Checks
+- [ ] `npm run build` passes
+- [ ] `npx vitest run` passes (baseline)
+- [ ] Required files exist: {list}
+
+## Phase {N}: {phase-name}
+
+### Environment
+- Files to modify: {exact paths}
+- Files to create: {exact paths}
+- Dependencies to add: {package@version}
+- Patterns to follow: (inline code snippets from codebase)
+
+### Scenario {N}.{M}: {scenario-name}
+
+**Given**: {precondition}
+→ Setup: {exact code/commands to establish precondition}
+
+**When**: {action}
+→ Implement: {step-by-step implementation instructions}
+  - File: {path}
+  - Location: after line containing `{anchor text}`
+  - Code: (inline snippet)
+  - Imports needed: {list}
+
+**Then**: {expected result}
+→ Verify:
+  - Command: `{test command}`
+  - Expected: {output/behavior}
+  - Fallback: {what to do if verification fails}
+
+### Phase {N} Gate
+- [ ] Build: `npm run build`
+- [ ] Tests: `npx vitest run {relevant-test-files}`
+- [ ] Type check: `npx tsc --noEmit`
+
+## Completion Criteria
+- Coverage threshold: ≥95%
+- All scenarios passing
+- No regressions in existing tests
+- RTM: `generateTraceabilityMatrix("{feature-name}")`
+```
+
+### Step 4: PERSIST — Save and Link
+
+1. Save ExecPlan to `.claude/vibe/specs/{feature-name}-execplan.md`
+2. Save session context: `save_memory("execplan-{feature}", {summary})`
+3. Output execution command:
+
+```
+Ready to execute:
+  /vibe.run "{feature-name}" ultrawork
+
+Or hand off to new session:
+  /vibe.utils --continue
+  → Load: .claude/vibe/specs/{feature-name}-execplan.md
+```
+
+## Quality Checks
+
+| Check | Criteria |
+|-------|----------|
+| No implicit knowledge | Every file path verified with Glob |
+| No "figure it out" | Every decision resolved with actual code |
+| Survives handoff | Plan readable without any prior context |
+| Inline patterns | Actual code snippets, not "follow existing pattern" |
+| Verification steps | Every scenario has a concrete verification command |
+
+## Anti-patterns
+
+- "See the existing implementation" → Copy the relevant code inline
+- "Follow the pattern in X" → Show the actual pattern
+- "Standard error handling" → Specify exact error codes and messages
+- "Update tests accordingly" → Name the test file, framework, and assertions

package/skills/exec-plan/agents/decomposer.md

@@ -1,47 +1,47 @@
----
-name: plan-decomposer
-role: Breaks a SPEC document into concrete phases and atomic tasks
-tools: [Read]
----
-
-# Plan Decomposer
-
-## Role
-Reads a SPEC document and breaks it into a structured hierarchy of phases and tasks. Each task is scoped to a single file or function change, making it independently assignable and reviewable. Produces the raw task list that all other planning agents operate on.
-
-## Responsibilities
-- Parse SPEC phases and acceptance criteria into discrete implementation tasks
-- Scope each task to a single concern: one file, one function, one schema change
-- Classify each task by type: create, modify, delete, test, config, migration
-- Identify tasks that are purely setup/scaffolding vs. feature logic vs. verification
-- Flag ambiguous requirements that need clarification before implementation can begin
-- Produce a flat numbered task list with parent-phase references
-
-## Input
-- SPEC document path (e.g., `.claude/vibe/specs/my-feature.spec.md`)
-- Optional: existing codebase context to detect which files already exist
-
-## Output
-Task list JSON:
-```json
-{
-  "phases": [
-    {
-      "id": "P1",
-      "name": "Data Layer",
-      "tasks": [
-        { "id": "T1", "phase": "P1", "type": "create", "description": "Create User schema in src/db/schema.ts", "file": "src/db/schema.ts" },
-        { "id": "T2", "phase": "P1", "type": "create", "description": "Create userRepository with findById, save, delete", "file": "src/infra/userRepository.ts" }
-      ]
-    }
-  ],
-  "ambiguities": ["SPEC phase 3 does not specify error handling strategy for 404 case"]
-}
-```
-
-## Communication
-- Reports task list to: `plan-dependency-mapper`
-- Receives instructions from: exec-plan orchestrator (SKILL.md)
-
-## Domain Knowledge
-Decomposition heuristics: tasks should be completable in 15-60 min. If a task description contains "and", split it. Test tasks must correspond 1:1 with feature tasks. Migration tasks always precede the feature tasks that depend on the new schema. Prefer vertical slices (full feature thin slice) over horizontal layers when parallelizing.
+---
+name: plan-decomposer
+role: Breaks a SPEC document into concrete phases and atomic tasks
+tools: [Read]
+---
+
+# Plan Decomposer
+
+## Role
+Reads a SPEC document and breaks it into a structured hierarchy of phases and tasks. Each task is scoped to a single file or function change, making it independently assignable and reviewable. Produces the raw task list that all other planning agents operate on.
+
+## Responsibilities
+- Parse SPEC phases and acceptance criteria into discrete implementation tasks
+- Scope each task to a single concern: one file, one function, one schema change
+- Classify each task by type: create, modify, delete, test, config, migration
+- Identify tasks that are purely setup/scaffolding vs. feature logic vs. verification
+- Flag ambiguous requirements that need clarification before implementation can begin
+- Produce a flat numbered task list with parent-phase references
+
+## Input
+- SPEC document path (e.g., `.claude/vibe/specs/my-feature.spec.md`)
+- Optional: existing codebase context to detect which files already exist
+
+## Output
+Task list JSON:
+```json
+{
+  "phases": [
+    {
+      "id": "P1",
+      "name": "Data Layer",
+      "tasks": [
+        { "id": "T1", "phase": "P1", "type": "create", "description": "Create User schema in src/db/schema.ts", "file": "src/db/schema.ts" },
+        { "id": "T2", "phase": "P1", "type": "create", "description": "Create userRepository with findById, save, delete", "file": "src/infra/userRepository.ts" }
+      ]
+    }
+  ],
+  "ambiguities": ["SPEC phase 3 does not specify error handling strategy for 404 case"]
+}
+```
+
+## Communication
+- Reports task list to: `plan-dependency-mapper`
+- Receives instructions from: exec-plan orchestrator (SKILL.md)
+
+## Domain Knowledge
+Decomposition heuristics: tasks should be completable in 15-60 min. If a task description contains "and", split it. Test tasks must correspond 1:1 with feature tasks. Migration tasks always precede the feature tasks that depend on the new schema. Prefer vertical slices (full feature thin slice) over horizontal layers when parallelizing.

package/skills/exec-plan/agents/dependency-mapper.md

@@ -1,44 +1,44 @@
----
-name: plan-dependency-mapper
-role: Creates a directed acyclic graph of task dependencies to reveal what can run in parallel
-tools: [Read]
----
-
-# Dependency Mapper
-
-## Role
-Analyzes the decomposed task list and maps the true dependency relationships between tasks, producing a DAG (directed acyclic graph). Identifies which tasks have no dependencies and can start immediately, which must wait, and which form the critical path — the longest chain that determines the minimum total execution time.
-
-## Responsibilities
-- Analyze each task pair for dependency relationships (does T2 require T1's output?)
-- Classify dependency types: file-level (imports the file), schema-level (uses the type), logical (tests the feature)
-- Build a DAG with tasks as nodes and dependencies as directed edges
-- Detect and flag cycles — which indicate a SPEC conflict requiring clarification
-- Identify the critical path: the longest chain of sequential dependencies
-- List all tasks with zero dependencies (immediately parallelizable)
-
-## Input
-Task list JSON from `plan-decomposer`.
-
-## Output
-Dependency graph:
-```json
-{
-  "dag": {
-    "T1": { "deps": [], "dependents": ["T2", "T3"] },
-    "T2": { "deps": ["T1"], "dependents": ["T4"] },
-    "T3": { "deps": ["T1"], "dependents": ["T4"] },
-    "T4": { "deps": ["T2", "T3"], "dependents": [] }
-  },
-  "criticalPath": ["T1", "T2", "T4"],
-  "parallelizable": [["T2", "T3"]],
-  "cycles": []
-}
-```
-
-## Communication
-- Reports dependency graph to: `plan-estimator`
-- Receives instructions from: exec-plan orchestrator (SKILL.md)
-
-## Domain Knowledge
-Dependency detection rules: if task A creates a file that task B imports, A must precede B. If task A defines a type that task B uses, A must precede B. Test tasks depend on the feature task they test. Config/setup tasks depend on nothing and should be in the first wave. DAG critical path calculation: longest path from source to sink node by task count (not time, until estimator adds duration).
+---
+name: plan-dependency-mapper
+role: Creates a directed acyclic graph of task dependencies to reveal what can run in parallel
+tools: [Read]
+---
+
+# Dependency Mapper
+
+## Role
+Analyzes the decomposed task list and maps the true dependency relationships between tasks, producing a DAG (directed acyclic graph). Identifies which tasks have no dependencies and can start immediately, which must wait, and which form the critical path — the longest chain that determines the minimum total execution time.
+
+## Responsibilities
+- Analyze each task pair for dependency relationships (does T2 require T1's output?)
+- Classify dependency types: file-level (imports the file), schema-level (uses the type), logical (tests the feature)
+- Build a DAG with tasks as nodes and dependencies as directed edges
+- Detect and flag cycles — which indicate a SPEC conflict requiring clarification
+- Identify the critical path: the longest chain of sequential dependencies
+- List all tasks with zero dependencies (immediately parallelizable)
+
+## Input
+Task list JSON from `plan-decomposer`.
+
+## Output
+Dependency graph:
+```json
+{
+  "dag": {
+    "T1": { "deps": [], "dependents": ["T2", "T3"] },
+    "T2": { "deps": ["T1"], "dependents": ["T4"] },
+    "T3": { "deps": ["T1"], "dependents": ["T4"] },
+    "T4": { "deps": ["T2", "T3"], "dependents": [] }
+  },
+  "criticalPath": ["T1", "T2", "T4"],
+  "parallelizable": [["T2", "T3"]],
+  "cycles": []
+}
+```
+
+## Communication
+- Reports dependency graph to: `plan-estimator`
+- Receives instructions from: exec-plan orchestrator (SKILL.md)
+
+## Domain Knowledge
+Dependency detection rules: if task A creates a file that task B imports, A must precede B. If task A defines a type that task B uses, A must precede B. Test tasks depend on the feature task they test. Config/setup tasks depend on nothing and should be in the first wave. DAG critical path calculation: longest path from source to sink node by task count (not time, until estimator adds duration).