planflow-ai 1.3.2 → 1.3.4

package/.claude/commands/discovery-plan.md

@@ -278,6 +278,7 @@ This command uses hierarchical context loading to reduce context consumption. In
 | SKL-DIS-1 | Discovery skill workflow | Understanding full process |
 | TLS-IQ-2 | How to switch to Plan mode | Before asking questions |
 | TLS-IQ-3 | How to ask questions | When gathering requirements |
+| COR-CG-1 | Compaction guide | Load when compacting mid-discovery |
 
 ### Expansion Instructions
 
@@ -389,6 +390,16 @@ Only save if the user approves. Do not re-ask if declined.
 
 ---
 
+## Discovery Sub-Agents
+
+After reading referenced documents (Step 1), three parallel Agent sub-agents explore the codebase simultaneously: **Similar Features** (finds related existing code), **API/Data Patterns** (maps endpoints and service patterns), and **Schema/Types** (explores type definitions and schemas). All use haiku model.
+
+Each sub-agent returns condensed JSON findings (under 2K tokens) that the coordinator merges into a `## Codebase Analysis` section in the discovery document. Findings also inform the clarifying questions in Step 2.
+
+Always-on — no configuration needed. See `.claude/resources/core/discovery-sub-agents.md` for full rules.
+
+---
+
 ## Design Awareness
 
 During discovery, always ask whether the feature involves UI work. If confirmed, follow the design question flow to capture structured design tokens (colors, typography, spacing, component patterns) into a `## Design Context` section in the discovery document.

package/.claude/commands/execute-plan.md

@@ -328,11 +328,25 @@ This command uses hierarchical context loading to reduce context consumption. In
 
 | Code | Description | When to Expand |
 |------|-------------|----------------|
-| SKL-EXEC-1 | Execution workflow | Understanding full process |
-| SKL-EXEC-2 | Complexity-based grouping | Determining execution strategy |
+| SKL-EXEC-2 | Critical rules (build, DB) | Need build/DB command restrictions |
+| SKL-EXEC-4 | Analyze complexity | Determining execution strategy |
+| SKL-EXEC-6 | Execute phase with Plan mode | Running a specific phase |
+| SKL-EXEC-8 | Phase-boundary compaction | Compacting between phases |
+| SKL-EXEC-9 | Handle tests phase | Executing the tests phase |
+| SKL-EXEC-10 | Build and test verification | Final verification step |
+| SKL-EXEC-11 | Complexity-based behavior | Need low/medium/high behavior details |
+| SKL-EXEC-12 | Error handling | Build/test failure or cancellation |
 | COR-CS-1 | Complexity scoring table | Interpreting phase complexity |
 | TLS-PLN-1 | Plan mode switching | Before each phase |
 | TLS-PLN-2 | Plan mode workflow | Presenting phase details |
+| COR-CG-1 | Compaction guide purpose | When compacting at phase boundaries |
+| COR-CG-2 | Preserve rules | Crafting compact summary — what to keep |
+| COR-CG-3 | Discard rules | Crafting compact summary — what to drop |
+| COR-CG-4 | Compact summary template | Structuring compact instructions |
+| COR-PI-1 | Phase isolation architecture | Understanding isolated sub-agent flow |
+| COR-PI-2 | Sub-agent context template | Preparing focused prompt for sub-agent |
+| COR-PI-3 | Return format schema | Parsing sub-agent JSON response |
+| COR-PI-4 | Coordinator processing rules | Handling success/failure/partial returns |
 
 ### Expansion Instructions
 
@@ -465,3 +479,13 @@ Routing happens at Step 4 of the execution skill — the phase implementation is
 
 Disable with `/flow model_routing=false`. See `.claude/resources/core/model-routing.md` for full tier table, platform mappings, and aggregation rules.
 
+---
+
+## Phase Isolation
+
+When `phase_isolation: true` in `flow/.flowconfig` (default), each phase implementation runs in an **isolated Agent sub-agent** with a clean context window. The sub-agent receives only: phase spec, files modified so far, pattern file paths, and design context (if UI phase). It returns a structured JSON summary (1-2K tokens) with status, files changed, decisions, errors, and captured patterns.
+
+This eliminates context rot — phase 7 has the same quality as phase 1. Planning/approval stays in the main session; only the implementation step is isolated.
+
+Disable with `/flow phase_isolation=false`. See `.claude/resources/core/phase-isolation.md` for the full context template, return format schema, and coordinator processing rules.
+

package/.claude/commands/flow.md

@@ -40,6 +40,7 @@ SETTINGS:
   push=true|false        Auto-push after all phases + build/test pass (default: false)
   branch=<name>          Target branch for git operations (default: current branch)
   model_routing=true|false  Auto-select model per phase based on complexity (default: true)
+  phase_isolation=true|false  Run each phase in isolated sub-agent with clean context (default: true)
 
 COST REPORTING:
   /flow cost                             Last 7 days summary (default)
@@ -57,6 +58,7 @@ EXAMPLES:
   /flow branch=development                # Set target branch
   /flow commit=false push=false           # Disable git control
   /flow model_routing=false               # Disable model routing (use session model for all phases)
+  /flow phase_isolation=false             # Disable phase isolation (inline execution, for debugging)
   /flow cost                              # Show cost report (last 7 days)
   /flow cost --today --detail             # Today's costs with model breakdown
   /flow -status                           # Show current config
@@ -110,6 +112,7 @@ Parse the user input to determine what action to take:
 | `push` | `true`, `false` | `false` | Auto-push after completion |
 | `branch` | any string | current branch | Target branch for git ops |
 | `model_routing` | `true`, `false` | `true` | Auto-select model per phase based on complexity |
+| `phase_isolation` | `true`, `false` | `true` | Run each phase in isolated sub-agent with clean context |
 
 ---
 
@@ -239,6 +242,8 @@ autopilot: false
 commit: false
 push: false
 branch: ""
+model_routing: true
+phase_isolation: true
 ```
 
 **Location**: `flow/.flowconfig`

package/.claude/commands/learn.md

@@ -26,11 +26,10 @@ This command has two modes:
 | User Input | Mode | What To Do |
 |------------|------|------------|
 | `/learn` (no arguments) | **Pattern Extraction** | Scan session for reusable patterns (Steps 1-4 below) |
-| `/learn about <topic>` | **Teaching Mode** | Create a step-by-step curriculum to TEACH the user about `<topic>` |
-| `/learn <topic>` (any text after /learn) | **Teaching Mode** | Same as above — treat any argument as a topic to teach |
+| `/learn <topic>` (any text after /learn) | **Teaching Mode** | Create a step-by-step curriculum to TEACH the user about `<topic>` |
 | `/learn -help` | Help | Show help and stop |
 
-**Rule**: If the user provides ANY topic after `/learn`, you are in **Teaching Mode**. The ONLY way to trigger Pattern Extraction is `/learn` with no arguments.
+**Rule**: If the user provides ANY text after `/learn`, you are in **Teaching Mode**. The ONLY way to trigger Pattern Extraction is `/learn` with no arguments.
 
 **Teaching Mode means**: You are a TEACHER. You create a structured curriculum and teach the user step by step. You do NOT extract patterns from the session. You do NOT create `learned-*.md` files. You CREATE a curriculum and TEACH.
 
@@ -49,8 +48,7 @@ DESCRIPTION:
 
 USAGE:
   /learn                  Analyze session and suggest patterns to extract
-  /learn about <topic>    Teach me about <topic> step by step
-  /learn <topic>          Same as above — teach me about <topic>
+  /learn <topic>          Teach me about <topic> step by step
   /learn -help            Show this help
 
 PATTERN EXTRACTION MODE (/learn):

package/.claude/commands/review-code.md

@@ -150,7 +150,13 @@ This command uses hierarchical context loading to reduce context consumption. In
 
 | Code | Description | When to Expand |
 |------|-------------|----------------|
-| SKL-REV-1 | Review code skill workflow | Understanding full process |
+| SKL-REV-1 | Purpose and restrictions | Understanding allowed actions |
+| SKL-REV-2 | Identify changed files | Starting the review |
+| SKL-REV-3 | Determine review depth | Adaptive depth selection |
+| SKL-REV-5 | Find similar implementations | Searching for comparable code |
+| SKL-REV-7 | Pattern conflicts + verify + re-rank | Processing findings |
+| SKL-REV-8 | Generate review document | Creating the output file |
+| SKL-REV-9 | Severity and conflict resolution | Severity levels and resolution options |
 | PTN-REV-1 | Review document structure | Creating review output |
 | COR-AP-1 | Allowed patterns overview | Checking pattern compliance |
 | COR-FP-1 | Forbidden patterns overview | Identifying anti-patterns |
@@ -161,6 +167,7 @@ This command uses hierarchical context loading to reduce context consumption. In
 | COR-AD-1 | Adaptive depth size detection | Determining review mode |
 | COR-AD-2 | Lightweight review mode | Changeset < 50 lines |
 | COR-AD-3 | Deep review mode | Changeset 500+ lines |
+| COR-CG-1 | Compaction guide | Load when compacting mid-review |
 
 ### Expansion Instructions
 

package/.claude/commands/review-pr.md

@@ -145,7 +145,14 @@ This command uses hierarchical context loading to reduce context consumption. In
 
 | Code | Description | When to Expand |
 |------|-------------|----------------|
-| SKL-PR-1 | Review PR skill workflow | Understanding full process |
+| SKL-PR-1 | Purpose and restrictions | Understanding allowed actions |
+| SKL-PR-2 | Authenticate for PR access | Setting up authentication |
+| SKL-PR-3 | Fetch PR info + determine depth | Getting PR data and review mode |
+| SKL-PR-5 | Analyze + verify + re-rank | Processing findings |
+| SKL-PR-6 | Generate review document | Creating the output file |
+| SKL-PR-7 | Output template | Review document structure |
+| SKL-PR-8 | Fix complexity scoring | Severity and complexity details |
+| SKL-PR-9 | Link format (GitHub/Azure DevOps) | Platform-specific link formats |
 | TLS-AUTH-1 | Auth tool configuration | Setting up authentication |
 | TLS-AUTH-2 | Authentication workflow | Authenticating to platform |
 | PTN-PR-1 | PR review patterns | Creating review output |

package/.claude/commands/setup.md

@@ -673,7 +673,17 @@ This command uses hierarchical context loading to reduce context consumption. In
 
 | Code | Description | When to Expand |
 |------|-------------|----------------|
-| SKL-SETUP-1 | Setup skill workflow | Understanding full process |
+| SKL-SETUP-1 | Purpose and critical approach | Understanding setup goals |
+| SKL-SETUP-2 | Scan project structure | Scanning files and directories |
+| SKL-SETUP-3 | Deep dependency analysis | Analyzing package dependencies |
+| SKL-SETUP-4 | Deep code analysis | Sampling files and extracting patterns |
+| SKL-SETUP-7 | Ask confirming questions | Presenting questions via Plan mode |
+| SKL-SETUP-8 | Generate pattern files | Creating framework/library pattern files |
+| SKL-SETUP-9 | Update core pattern files | Updating allowed/forbidden patterns |
+| SKL-SETUP-11 | Create analysis document | Generating project analysis doc |
+| SKL-SETUP-12 | Index documentation | Indexing project docs with reference codes |
+| SKL-SETUP-13 | Create flow folder | Setting up flow/ directory structure |
+| SKL-SETUP-14 | Present summary | Final setup summary output |
 | TLS-IQ-1 | Interactive questions overview | Before asking questions |
 | TLS-IQ-2 | Switch to Plan mode | Starting question session |
 | TLS-IQ-3 | Ask questions format | Asking confirmation questions |

package/.claude/resources/core/_index.md

@@ -5,8 +5,8 @@
 
 Core rules define the foundational coding standards that apply across the entire project. These include best practices to follow (allowed patterns), anti-patterns to avoid (forbidden patterns), and complexity scoring for implementation planning.
 
-**Total Files**: 18 files, ~3020 lines
-**Reference Codes**: COR-AP-1 through COR-AD-4
+**Total Files**: 22 files, ~3580 lines
+**Reference Codes**: COR-AP-1 through COR-DSA-3
 
 ---
 
@@ -143,6 +143,40 @@ Core rules define the foundational coding standards that apply across the entire
 | COR-SR-3 | Executive summary trigger and risk level derivation | review-severity-ranking.md | 90-120 |
 | COR-SR-4 | Output structure and insertion points | review-severity-ranking.md | 122-150 |
 
+### Compaction Guide (`compaction-guide.md`)
+
+| Code | Description | Source | Lines |
+|------|-------------|--------|-------|
+| COR-CG-1 | Purpose, core principle, and when to compact | compaction-guide.md | 3-20 |
+| COR-CG-2 | Preserve rules — what to keep during compaction | compaction-guide.md | 22-38 |
+| COR-CG-3 | Discard rules — what to drop during compaction | compaction-guide.md | 40-55 |
+| COR-CG-4 | Compact summary template and skill-specific examples | compaction-guide.md | 57-110 |
+
+### Session Scratchpad (`session-scratchpad.md`)
+
+| Code | Description | Source | Lines |
+|------|-------------|--------|-------|
+| COR-SS-1 | Purpose, session start behavior, and write triggers | session-scratchpad.md | 3-45 |
+| COR-SS-2 | File format and 50-line limit | session-scratchpad.md | 47-68 |
+| COR-SS-3 | Promotion rules, targets, and compaction integration | session-scratchpad.md | 70-95 |
+
+### Phase Isolation (`phase-isolation.md`)
+
+| Code | Description | Source | Lines |
+|------|-------------|--------|-------|
+| COR-PI-1 | Purpose, architecture overview, and coordinator flow | phase-isolation.md | 3-40 |
+| COR-PI-2 | Context template — what to include in sub-agent prompt | phase-isolation.md | 42-85 |
+| COR-PI-3 | Return format schema (JSON), field descriptions, failure example | phase-isolation.md | 87-140 |
+| COR-PI-4 | Coordinator processing (success/failure/partial), config, and rules | phase-isolation.md | 142-180 |
+
+### Discovery Sub-Agents (`discovery-sub-agents.md`)
+
+| Code | Description | Source | Lines |
+|------|-------------|--------|-------|
+| COR-DSA-1 | Agent definitions with prompt templates (Similar Features, API/Data, Schema/Types) | discovery-sub-agents.md | 30-130 |
+| COR-DSA-2 | Return format schema and Codebase Analysis section template | discovery-sub-agents.md | 132-190 |
+| COR-DSA-3 | Coordinator behavior (spawn, collect, merge, error handling) | discovery-sub-agents.md | 192-240 |
+
 ### Review Adaptive Depth (`review-adaptive-depth.md`)
 
 | Code | Description | Source | Lines |
@@ -204,10 +238,24 @@ Core rules define the foundational coding standards that apply across the entire
 | COR-SR-2 | Need grouping rules for related findings |
 | COR-SR-3 | Need executive summary trigger conditions |
 | COR-SR-4 | Need severity re-ranking output structure or insertion points |
+| COR-CG-1 | Need to understand when and why to compact |
+| COR-CG-2 | Need preserve rules for crafting compact summaries |
+| COR-CG-3 | Need discard rules for dropping low-signal tokens |
+| COR-CG-4 | Need compact summary template or skill-specific examples |
 | COR-AD-1 | Need size detection thresholds or line counting rules |
 | COR-AD-2 | Need lightweight review mode behavior |
 | COR-AD-3 | Need deep review mode behavior (categorization, passes, executive summary) |
 | COR-AD-4 | Need insertion points for adaptive depth in review skills |
+| COR-SS-1 | Need scratchpad purpose, session start behavior, or write triggers |
+| COR-SS-2 | Need scratchpad file format or size limit |
+| COR-SS-3 | Need scratchpad promotion rules or compaction integration |
+| COR-PI-1 | Need phase isolation architecture or coordinator flow |
+| COR-PI-2 | Need sub-agent context template (what to include in prompt) |
+| COR-PI-3 | Need return format schema or field descriptions |
+| COR-PI-4 | Need coordinator processing rules or config settings |
+| COR-DSA-1 | Need discovery sub-agent definitions or prompt templates |
+| COR-DSA-2 | Need return format schema or Codebase Analysis section template |
+| COR-DSA-3 | Need coordinator spawn/collect/merge behavior or error handling |
 
 ---
 
@@ -248,5 +296,9 @@ Core rules define the foundational coding standards that apply across the entire
 - `pattern-capture.md` is loaded on-demand - silently captures patterns during skill execution and presents for approval
 - `model-routing.md` is loaded on-demand - automatic model selection per phase based on complexity scores during `/execute-plan`
 - `project-tasklist.md` is loaded on-demand - session start tasklist behavior
+- `compaction-guide.md` is loaded on-demand - preserve/discard rules and summary template for `/compact`
+- `session-scratchpad.md` is loaded on-demand - ephemeral per-session notes with promotion to permanent storage
+- `phase-isolation.md` is loaded on-demand - isolated sub-agent execution per phase during `/execute-plan`
 - `project-memory.md` is loaded on-demand - artifact tracking and 7-day session loading
 - `heartbeat.md` is loaded on-demand - scheduled task daemon configuration
+- `discovery-sub-agents.md` is loaded on-demand - parallel codebase exploration sub-agents during `/discovery-plan`

package/.claude/resources/core/compaction-guide.md

@@ -0,0 +1,111 @@
+
+# Compaction Guide
+
+## Purpose
+
+When a plan-flow session runs `/compact`, the compaction model summarizes the conversation history. Without guidance, it may discard critical state (phase progress, decisions) or keep low-value tokens (old file reads, resolved searches).
+
+**Core principle**: Preserve decisions, discard outputs.
+
+### When to Compact
+
+- At **phase boundaries** during `/execute-plan` (between phases, never mid-phase)
+- When context feels heavy (many tool calls, large file reads accumulated)
+- Before starting a complex phase (complexity >= 6)
+- During long `/review-code` or `/discovery-plan` sessions with many file reads
+
+---
+
+## Preserve Rules (High-Signal Tokens)
+
+Always include these in the compact summary:
+
+| Category | What to Keep | Examples |
+|----------|-------------|----------|
+| **Execution state** | Current skill, phase number, plan slug, completed vs pending phases | "Executing plan_user_auth_v1.md, phase 3 of 5 complete" |
+| **Decision log** | Architecture choices, pattern selections, user preferences, rejected alternatives | "Chose JWT over sessions (discovery DR-4). User rejected Redis caching." |
+| **Error context** | Unresolved errors, failed attempts, workarounds in progress, retry count | "Build fails on type mismatch in auth.ts:42 — tried 2 approaches" |
+| **User requirements** | Original request, clarified constraints, acceptance criteria | "User wants OAuth2 with Google only, no email/password" |
+| **Tasklist state** | Current in-progress items from `flow/tasklist.md` | "In progress: Execute user-auth" |
+| **Pattern buffer** | Pending pattern captures not yet saved | "Buffered: async error handling pattern for approval" |
+| **Active file list** | Files created or modified during the session | "Modified: src/auth/middleware.ts, src/auth/types.ts" |
+| **Scratchpad notes** | Contents of `flow/.scratchpad.md` — ephemeral session notes not yet promoted | "Scratchpad: 3 notes, 1 open question" |
+
+---
+
+## Discard Rules (Low-Signal Tokens)
+
+Safe to drop from the compact summary:
+
+| Category | What to Drop | Why |
+|----------|-------------|-----|
+| **Completed tool results** | File reads from resolved steps, grep results already acted on | Can be re-read if needed |
+| **Superseded content** | Earlier versions of files that were subsequently edited | Only the final state matters |
+| **Verbose output** | Full build logs, test output — keep only pass/fail + error messages | Details can be regenerated |
+| **Exploration dead-ends** | Files read but found irrelevant, abandoned approaches | No future value |
+| **Redundant context** | Content repeated across multiple tool calls | One copy is enough |
+| **Index file contents** | `_index.md` files read for navigation | Re-read on demand |
+
+---
+
+## Compact Summary Template
+
+When crafting `/compact` instructions, use this structure:
+
+```
+## Session State
+- **Active skill**: {skill name — e.g., execute-plan, review-code, discovery}
+- **Active plan**: {plan file path or "none"}
+- **Current phase**: {N of M} — {phase name}
+- **Completed phases**: {list with brief outcomes}
+
+## Decisions Made
+- {decision}: {choice} (reason: {why})
+
+## Unresolved Issues
+- {error/issue}: {status, what was tried}
+
+## Files Modified
+- {file path}: {what changed}
+
+## Next Action
+{What to do immediately after compaction}
+```
+
+---
+
+## Skill-Specific Examples
+
+### Execute-Plan Compaction
+
+```
+/compact Executing plan_user_auth_v1.md. Completed: Phase 1 (types — done),
+Phase 2 (API endpoints — done). Next: Phase 3 of 5 (Frontend UI, complexity 6).
+Decisions: JWT auth (not sessions), Zod validation. Files modified:
+src/auth/types.ts, src/api/auth.ts. Resume from Phase 3.
+```
+
+### Review-Code Compaction
+
+```
+/compact Reviewing 47 changed files. Completed: file categorization, security scan
+(2 findings), logic analysis (3 findings). Next: performance scan. Findings so far:
+1 critical (SQL injection in query.ts), 4 minor. Resume with performance analysis.
+```
+
+### Discovery Compaction
+
+```
+/compact Discovery for payment-integration. Questions answered: 5 of 8.
+Key requirements: Stripe only, webhook verification required, idempotency keys.
+Open questions: retry policy, refund flow. Resume with remaining questions.
+```
+
+---
+
+## Rules
+
+1. **Never compact mid-phase** — only at phase boundaries
+2. **Always include enough context to resume** — the model after compaction should know exactly what to do next
+3. **After compaction, re-read the plan file** — don't rely on memory of plan contents
+4. **Default to preserving** — when in doubt, keep it. It's better to preserve something unnecessary than lose something critical.

package/.claude/resources/core/discovery-sub-agents.md

@@ -0,0 +1,266 @@
+
+# Discovery Sub-Agents
+
+## Purpose
+
+During `/discovery-plan`, three parallel Agent sub-agents explore the codebase simultaneously. Each focuses on a specific aspect (similar features, API/data patterns, schema/types) and returns condensed JSON findings. The coordinator merges these into a **Codebase Analysis** section in the discovery document, enabling better-informed clarifying questions.
+
+**Core principle**: Parallel exploration, condensed returns, cleaner context.
+
+---
+
+## Architecture
+
+```
+Discovery Skill (main session)
+    │
+    ├─ Step 1: Read referenced documents (unchanged)
+    │
+    ├─ Step 1b: Spawn exploration sub-agents in parallel
+    │   ├─► Agent: Similar Features     (model: haiku)
+    │   ├─► Agent: API/Data Patterns   (model: haiku)
+    │   └─► Agent: Schema/Types        (model: haiku)
+    │
+    ├─ Step 1c: Collect and merge findings into Codebase Analysis
+    │
+    ├─ Step 2: Ask clarifying questions (informed by findings)
+    │   ... (rest of discovery unchanged)
+```
+
+All three sub-agents use **haiku** — exploration is search-heavy (Glob, Grep, Read) with lightweight summarization.
+
+---
+
+## Agent Definitions
+
+### 1. Similar Features Agent
+
+**Focus**: Find existing features or code that does something similar to the proposed feature.
+
+**Prompt template**:
+```
+You are a codebase explorer. Your task is to find existing code that is similar to a proposed feature.
+
+Feature: {feature_name}
+Context: {context_summary_from_step_1}
+
+Search for:
+- Components, modules, or services that handle related functionality
+- Route handlers or endpoints with similar purpose
+- Existing UI patterns that address similar use cases
+- Utility functions that could be reused
+
+Use Glob and Grep to search the codebase. Read relevant files to understand their purpose.
+
+Return your findings as JSON:
+{
+  "agent": "similar-features",
+  "status": "success",
+  "findings": [
+    {
+      "file": "path/to/file.ts",
+      "description": "Brief description of what this file does and how it relates",
+      "relevance": "high" | "medium" | "low"
+    }
+  ],
+  "summary": "2-3 sentence overview of similar features found",
+  "patterns_noticed": ["List of coding conventions or patterns observed"]
+}
+
+Rules:
+- Only READ files (Glob, Grep, Read) — never write or edit
+- Return at most 10 findings, sorted by relevance
+- Keep the summary under 200 words
+- Focus on HIGH relevance findings
+```
+
+### 2. API/Data Patterns Agent
+
+**Focus**: Scan for existing API endpoints, data models, service patterns, and integration points.
+
+**Prompt template**:
+```
+You are a codebase explorer. Your task is to map the API and data patterns in this project.
+
+Feature: {feature_name}
+Context: {context_summary_from_step_1}
+
+Search for:
+- API route definitions and endpoint patterns (REST, GraphQL, tRPC)
+- Controller/handler organization and naming conventions
+- Service layer patterns (repository pattern, direct DB access, etc.)
+- Data flow: how requests are processed from route → handler → service → response
+- Middleware patterns (auth, validation, error handling)
+- API response shapes and error formats
+
+Use Glob and Grep to search the codebase. Read relevant files to understand patterns.
+
+Return your findings as JSON:
+{
+  "agent": "api-data-patterns",
+  "status": "success",
+  "findings": [
+    {
+      "file": "path/to/file.ts",
+      "description": "Brief description of the API/data pattern found",
+      "relevance": "high" | "medium" | "low"
+    }
+  ],
+  "summary": "2-3 sentence overview of API architecture and data flow patterns",
+  "patterns_noticed": ["List of API/data conventions observed"]
+}
+
+Rules:
+- Only READ files (Glob, Grep, Read) — never write or edit
+- Return at most 10 findings, sorted by relevance
+- Keep the summary under 200 words
+- Focus on patterns the new feature would need to follow
+```
+
+### 3. Schema/Types Agent
+
+**Focus**: Explore type definitions, database schemas, shared interfaces, and data structures.
+
+**Prompt template**:
+```
+You are a codebase explorer. Your task is to map the type system and data schemas in this project.
+
+Feature: {feature_name}
+Context: {context_summary_from_step_1}
+
+Search for:
+- TypeScript interfaces and type definitions relevant to the feature
+- Database schemas (Prisma, TypeORM, Drizzle, raw SQL migrations)
+- Shared types and enums used across the codebase
+- Zod/Yup/Joi validation schemas
+- API request/response type definitions
+
+Use Glob and Grep to search the codebase. Read relevant files to understand the type system.
+
+Return your findings as JSON:
+{
+  "agent": "schema-types",
+  "status": "success",
+  "findings": [
+    {
+      "file": "path/to/file.ts",
+      "description": "Brief description of the type/schema and its relevance",
+      "relevance": "high" | "medium" | "low"
+    }
+  ],
+  "summary": "2-3 sentence overview of relevant type system and schemas",
+  "patterns_noticed": ["List of type/schema conventions observed"]
+}
+
+Rules:
+- Only READ files (Glob, Grep, Read) — never write or edit
+- Return at most 10 findings, sorted by relevance
+- Keep the summary under 200 words
+- Focus on types the new feature would interact with
+```
+
+---
+
+## Return Format
+
+Each sub-agent returns structured JSON:
+
+```json
+{
+  "agent": "similar-features" | "api-data-patterns" | "schema-types",
+  "status": "success" | "failure",
+  "findings": [
+    {
+      "file": "string — relative file path",
+      "description": "string — what this file does and how it relates to the feature",
+      "relevance": "high" | "medium" | "low"
+    }
+  ],
+  "summary": "string — 2-3 sentence overview (under 200 words)",
+  "patterns_noticed": ["string — coding conventions or patterns observed"]
+}
+```
+
+**Size target**: Each return should be under 2K tokens.
+
+---
+
+## Coordinator Behavior
+
+### Step 1b: Spawn Sub-Agents
+
+Launch all 3 sub-agents in parallel using the Agent tool:
+
+```
+Launch in parallel:
+- Agent(model: "haiku", subagent_type: "Explore", prompt: similar_features_prompt)
+- Agent(model: "haiku", subagent_type: "Explore", prompt: api_data_prompt)
+- Agent(model: "haiku", subagent_type: "Explore", prompt: schema_types_prompt)
+```
+
+Each sub-agent receives:
+1. **Feature name** — from the user's input
+2. **Context summary** — brief summary of what Step 1 found in referenced documents
+3. **Exploration instructions** — the agent-specific prompt template above
+
+### Step 1c: Collect and Merge Findings
+
+1. **Parse returns**: Extract JSON from each sub-agent response
+2. **Handle failures**: If a sub-agent returns `status: "failure"` or fails to return valid JSON, skip its findings and continue. Log the failure but do not block discovery.
+3. **Filter**: Remove findings with `relevance: "low"` if there are more than 15 total findings
+4. **Merge patterns**: Collect all `patterns_noticed` entries across agents, deduplicate, and append to `flow/resources/pending-patterns.md`
+5. **Format Codebase Analysis**: Build the section for the discovery document
+
+### Codebase Analysis Section Format
+
+```markdown
+## Codebase Analysis
+
+### Similar Features
+{summary from similar-features agent}
+
+| File | Description | Relevance |
+|------|-------------|-----------|
+| `path/to/file.ts` | Description | High |
+| ... | ... | ... |
+
+### API & Data Patterns
+{summary from api-data-patterns agent}
+
+| File | Description | Relevance |
+|------|-------------|-----------|
+| ... | ... | ... |
+
+### Schema & Types
+{summary from schema-types agent}
+
+| File | Description | Relevance |
+|------|-------------|-----------|
+| ... | ... | ... |
+```
+
+If a sub-agent returned no findings or failed, omit its subsection entirely.
+
+---
+
+## Error Handling
+
+| Scenario | Behavior |
+|----------|----------|
+| Sub-agent fails (timeout, error) | Skip its findings, continue with other agents' results |
+| Sub-agent returns invalid JSON | Skip its findings, log warning |
+| All sub-agents fail | Continue discovery without Codebase Analysis section |
+| No relevant findings | Omit Codebase Analysis section — discovery proceeds normally |
+
+Discovery must never be blocked by sub-agent failures. Findings are supplementary.
+
+---
+
+## Related Files
+
+| File | Purpose |
+|------|---------|
+| `.claude/resources/skills/discovery-skill.md` | Discovery skill (Steps 1b + 1c added) |
+| `.claude/resources/core/review-multi-agent.md` | Similar pattern: parallel specialized subagents |
+| `.claude/resources/core/phase-isolation.md` | Similar pattern: sub-agent with focused prompt → JSON return |
+| `.claude/resources/core/pattern-capture.md` | patterns_noticed entries routed to pending-patterns.md |