**目的**：检测并行路径、不完整替代、死保底。从 `reviewing-architecture` skill 吸收。

**前置条件**：dispatch prompt 包含 `Crystal file:` 路径且非 "none"。如果无 crystal 文件引用，跳过本策略。

Use this agent to analyze design prototypes from Stitch, Figma, or other design tools. Performs dual-channel analysis (image + code simultaneously), extracts design tokens, translates to target platform, and validates against UX assertions when in pipeline mode. Examples: <example> Context: User created a Stitch prototype and wants AI analysis. user: "Analyze this Stitch design" assistant: "I'll use the design-analyzer agent for dual-channel analysis." </example> <example> Context: Pipeline mode, validating prototype against design doc. user: "Check if this prototype matches our design" assistant: "I'll use the design-analyzer agent to validate against the design doc." </example>

Use this agent to audit codebase alignment against structured design documents. Extracts assertions from documents mechanically based on known template structures and verifies each assertion against the actual code. Examples: <example> Context: Project has been through several dev-guide phases and docs may be stale. user: "Check if the code still matches the design docs" assistant: "I'll use the design-drift-auditor agent to audit alignment." </example> <example> Context: User suspects feature scope has drifted from project-brief. user: "Run a design drift check focusing on scope" assistant: "I'll use the design-drift-auditor agent to check scope assertions." </example>

**目的**：验证计划完整且忠实地覆盖设计文档的所有要求，在执行前捕获 Gap A-E。

Use this agent to verify a development guide after write-dev-guide produces it and before presenting to the user. Checks feature coverage, dependency graph semantics, cross-phase data flow, existing code overlap, term definitions, acceptance criteria quality, and structural integrity. Examples: <example> Context: write-dev-guide just produced a development guide. user: "Verify the dev guide before I review it" assistant: "I'll use the dev-guide-verifier agent to validate the development guide." </example> <example> Context: User suspects the dev guide has dependency or coverage issues. user: "Check the dev guide for issues" assistant: "I'll use the dev-guide-verifier agent to run quality verification." </example>

Reads a single discussion file and classifies it by conclusion type. Returns structured extraction (crystal fields, lesson fields, or skip reason). Used by the distill-discussion skill for large files (>100KB) that need context isolation. Examples: <example> Context: Large discussion file needs classification. user: "Classify this 60KB discussion file" assistant: "I'll dispatch the distill-discussion-reader agent to classify the file." </example> <example> Context: Batch processing discussions, one file exceeds 100KB. user: "Extract decisions from the WWDC discussion export" assistant: "I'll use the distill-discussion-reader agent to analyze this large file." </example>

Use this agent to execute a verified implementation plan. Follows plan tasks sequentially, writes code, and returns a completion report. Does not fix failures; reports them for the orchestrator to handle. Examples: <example> Context: A verified plan needs to be executed. user: "Execute the plan at docs/06-plans/2026-03-26-sync-plan.md" assistant: "I'll use the execute-plan agent to implement the plan." </example>

Use this agent to generate feature specs comparing design intent against implementation. Produces docs/05-features/ documents for use by /feature-review. Examples: <example> Context: A feature is complete and needs documentation before review. user: "Write a feature spec for the sync feature" assistant: "I'll use the feature-spec-writer agent to generate the spec." </example> <example> Context: Phase completed, features need specs before review. user: "Document the completed features" assistant: "I'll use the feature-spec-writer agent to create feature specs." </example>

Use this agent to trace a call chain end-to-end through the codebase given a natural language flow description. Identifies each hop with file:line and reports breaks (signal with no consumer, call to nonexistent target, field written but never read). Can be dispatched by the design-drift skill for deep verification, or directly by a user for diagnostic purposes. Optimized for Swift/iOS codebases; search patterns and terminal node definitions reflect Apple platform conventions. Examples: <example> Context: Design drift auditor flagged a data flow that needs verification. user: "Trace the data flow from user tap on save button to persistence" assistant: "I'll use the flow-tracer agent to trace this call chain." </example> <example> Context: User debugging a feature that should work but does not. user: "Trace the sync flow starting from SyncService.trigger()" assistant: "I'll use the flow-tracer agent to trace the sync flow end-to-end." </example> <example> Context: Architecture review, checking if a signal has consumers. user: "Trace what happens after NotificationCenter posts .userDidLogin" assistant: "I'll use the flow-tracer agent to find all consumers of that notification." </example>

Use this agent after completing all tasks in an implementation plan, or when the user says 'review implementation', 'review changes', 'review and validate', 'execution review', 'audit implementation'. Requires an implementation plan in the current session or a plan file to audit against. Do NOT use for general code quality review without a plan — that is a different reviewer's job. Performs comprehensive plan-vs-code verification and optional design-vs-code fidelity audit. Examples: <example> Context: User finished executing a multi-task plan. user: "All plan tasks are done, review the implementation" assistant: "I'll use the implementation-reviewer agent to audit the implementation against the plan." </example> <example> Context: User wants to check implementation fidelity against a design doc. user: "Check if the implementation matches the design" assistant: "I'll use the implementation-reviewer agent to perform a design fidelity audit." </example> <example> Context: No plan exists in the session, user just wants a code review. user: "Review this code" assistant: DO NOT use implementation-reviewer — no plan to audit against. Use a code quality reviewer instead. </example>

Use this agent to verify an implementation plan before execution. Applies falsifiable error candidates, failure reverse reasoning, design faithfulness checks, and architecture review. Examples: <example> Context: A plan has been written and needs validation before execution. user: "Verify the plan before we start executing" assistant: "I'll use the plan-verifier agent to validate the plan." </example> <example> Context: User wants to check plan quality after writing it. user: "Check the plan for issues" assistant: "I'll use the plan-verifier agent to run verification strategies." </example>

Use this agent to audit CLAUDE.md rules for conflicts, loopholes, gaps, and redundancies from the AI execution perspective. Examples: <example> Context: Claude exhibited unexpected behavior. user: "Review the rules, Claude ignored a constraint" assistant: "I'll use the rules-auditor agent to audit the rules." </example> <example> Context: User added new rules and wants consistency check. user: "Check the CLAUDE.md rules for conflicts" assistant: "I'll use the rules-auditor agent to check for conflicts and loopholes." </example>

Use when Claude exhibited unexpected behavior, for periodic rule health checks, or after adding new rules. Audits CLAUDE.md rules from the AI execution perspective for conflicts, loopholes, gaps, and redundancies.

Use before any creative work — creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.

Use after resolving a bug, completing a task with notable pitfalls, or discovering an important architecture constraint. Extracts a structured entry from the session and saves it to the knowledge base.

Use when the user says 'commit' or wants to save progress after completing a task. Analyzes uncommitted changes, groups them logically, and commits with conventional format messages.

Use before /write-plan or when the session has settled significant design decisions. Extracts the decision history from the current conversation into a persistent crystal file that /write-plan and plan-verifier consume.

Use when facing multiple design or product options, the user is stuck between approaches, or asks 'how should I design this'. Analyzes trade-offs by separating essential from accidental complexity.

Use when you need to check whether the codebase has drifted from its design documents, or the user says 'check drift', 'design drift', 'audit docs vs code'. Targets projects with standardized docs from project-kickoff. Supports full scan or focused mode.

Use when you have raw discussion files (AI conversation exports, exploratory notes) and want to extract structured outputs. Routes each file to: crystal (decisions), lesson (failures/pitfalls), or skip (no conclusion).

Use when the user says 'execute the plan', 'run the plan', 'implement the plan', or has a verified plan file ready for execution. Executes plan tasks mechanically without judgment calls; reports blocked/failed tasks for the user to fix. Not needed when run-phase is active — run-phase calls this internally at Step 4.

Use after all phases of a dev-guide are complete, or when the user says 'finalize', 'final check', 'cross-phase validation'. Runs full test suite, verifies acceptance criteria across all phases, audits cumulative test coverage, and produces a final validation report.

Use when implementation is complete and you need to decide how to integrate the work. Verifies tests, presents structured options, handles cleanup.

Use when the user reports an error with stack trace or screenshot, describes unexpected behavior, or build/test failures occur. Systematically diagnoses through reproduction, hypothesis, value domain tracing, and parallel path detection.

Generate Obsidian Bases (.base) views for structured querying of crystals, lessons, and vault notes. Use when the user says 'generate views', 'create base files', 'make queryable', or after crystallize/collect-lesson.

Use when the user needs a design tool prompt (for Stitch, Figma, or similar) based on actual project functionality. Generates initial prompts from design docs/code, or refinement prompts from design analysis feedback.

Use when you need to create a verification prompt with falsifiable assertions for a plan, code change, or session response. Generates structured prompts that enable rigorous verification.

Use when handing off work to a new session (next day, different person), the user says 'handoff', or a complex task needs to continue in a new session. Generates a cold-start prompt for session transfer.

Use when the user says 'issue', wants to list/read/create GitHub Issues, or needs to record a bug/idea/question discovered during development. Unified GitHub Issue entry point.

Use when you need to search the cross-project knowledge base manually. Accepts a query, searches ~/.claude/knowledge/ for past lessons, API gotchas, architecture decisions, and learning notes.

Use when facing 2+ independent tasks that can be worked on concurrently without shared state or sequential dependencies.

Use when the user says 'run phase', 'start phase N', 'next phase', '继续开发', '跑下一阶段', '开始第N阶段', or when continuing development guided by a dev-guide. Orchestrates the plan-execute-review cycle for one phase of a development guide.

Use when the user has a design prototype (from Stitch, Figma, or any tool) and wants AI to analyze it. Works standalone for daily development or in pipeline mode with a design doc. Handles images, HTML/CSS, or both.

Use when starting feature work that needs isolation from current workspace. Optional tool — not required for every development task.

Use when a plan has been written and needs validation before execution, or the user says 'verify plan', 'check the plan', 'review the plan', 'validate plan', '检查计划', '验证计划'. Applies Verification-First method with falsifiable error candidates, failure reverse reasoning, optional Design Token consistency checks, Design Faithfulness anchoring, and Architecture Review.

Use when starting a new project's development after design is approved, or the user says 'write dev guide', 'break down this project into phases', or '写开发指南'. Creates a phased, project-level development guide that serves as the cornerstone document for all subsequent /write-plan and /run-phase cycles. Not for single-feature plans (use write-plan) or design exploration (use brainstorm).

Generate feature spec (docs/05-features/) capturing what was built, design decisions made, and user journeys completed. Use for cross-session context recovery, publication notes, or as input for external review. Not a prerequisite for self-review.

Use when the user says 'write a plan', 'plan this', 'break this into tasks', or has requirements/specs for a multi-step task before touching code. Creates structured implementation plans with self-contained, verifiable tasks. Not for single-step changes. For phase-driven development, run-phase calls this internally.

3 hooks across 3 events