cook-hard（努力做饭）

[IMPORTANT] Use TaskCreate to break ALL work into small tasks BEFORE starting — including tasks for each file read. This prevents context loss from long files. For simple tasks, AI MUST ATTENTION ask user whether to skip.

Critical Thinking Mindset — Apply critical thinking, sequential thinking. Every claim needs traced proof, confidence >80% to act. Anti-hallucination: Never present guess as fact — cite sources for every claim, admit uncertainty freely, self-check output for errors, cross-reference independently, stay skeptical of own confidence — certainty without evidence root of all hallucination.

AI Mistake Prevention — Failure modes to avoid on every task: - Check downstream references before deleting. Deleting components causes documentation and code staleness cascades. Map all referencing files before removal. - Verify AI-generated content against actual code. AI hallucinates APIs, class names, and method signatures. Always grep to confirm existence before documenting or referencing. - Trace full dependency chain after edits. Changing a definition misses downstream variables and consumers derived from it. Always trace the full chain. - Trace ALL code paths when verifying correctness. Confirming code exists is not confirming it executes. Always trace early exits, error branches, and conditional skips — not just happy path. - When debugging, ask "whose responsibility?" before fixing. Trace whether bug is in caller (wrong data) or callee (wrong handling). Fix at responsible layer — never patch symptom site. - Assume existing values are intentional — ask WHY before changing. Before changing any constant, limit, flag, or pattern: read comments, check git blame, examine surrounding code. - Verify ALL affected outputs, not just the first. Changes touching multiple stacks require verifying EVERY output. One green check is not all green checks. - Holistic-first debugging — resist nearest-attention trap. When investigating any failure, list EVERY precondition first (config, env vars, DB names, endpoints, DI registrations, data preconditions), then verify each against evidence before forming any code-layer hypothesis. - Surgical changes — apply the diff test. Bug fix: every changed line must trace directly to the bug. Don't restyle or improve adjacent code. Enhancement task: implement improvements AND announce them explicitly. - Surface ambiguity before coding — don't pick silently. If request has multiple interpretations, present each with effort estimate and ask. Never assume all-records, file-based, or more complex path.

Understand Code First — HARD-GATE: Do NOT write, plan, or fix until you READ existing code. 1. Search 3+ similar patterns (grep/glob) — cite file:line evidence 2. Read existing files in target area — understand structure, base classes, conventions 3. Run python.claude/scripts/code_graph trace <file> --direction both --json when .code-graph/graph.db exists 4. Map dependencies via connections or callers_of — know what depends on your target 5. Write investigation to .ai/workspace/analysis/ for non-trivial tasks (3+ files) 6. Re-read analysis file before implementing — never work from memory alone 7. NEVER invent new patterns when existing ones work — match exactly or document deviation BLOCKED until: - [] Read target files - [] Grep 3+ patterns - [] Graph trace (if graph.db exists) - [] Assumptions verified with evidence

• docs/project-reference/domain-entities-reference.md — Domain entity catalog, relationships, cross-service sync (read when task involves business entities/models) (content auto-injected by hook — check for [Injected:...] header before reading)
• docs/specs/ — Test specifications by module (read existing TCs; generate/update test specs via /tdd-spec after implementation)

Plan Quality — Every plan phase MUST ATTENTION include test specifications. 1. Add ## Test Specifications section with TC-{FEAT}-{NNN} IDs to every phase file 2. Map every functional requirement to ≥1 TC (or explicit TBD with rationale) 3. TC IDs follow TC-{FEATURE}-{NNN} format — reference by ID, never embed full content 4. Before any new workflow step: call TaskList and re-read the phase file 5. On context compaction: call TaskList FIRST — never create duplicate tasks 6. Verify TC satisfaction per phase before marking complete (evidence must be file:line, not TBD) Mode: TDD-first → reference existing TCs with Evidence: TBD. Implement-first → use TBD → /tdd-spec fills after.

Skill Variant: Variant of /cook — thorough implementation with maximum verification.

Quick Summary

Goal: Implement features with deep research, comprehensive planning, and maximum quality verification.

Workflow:

1. Research — Deep investigation with multiple researcher subagents
2. Plan — Detailed plan with /plan-hard, user approval required
3. Implement — Execute with full code review and SRE review
4. Verify — Run all tests, review changes, update docs

Key Rules:

• Maximum thoroughness: research → plan → implement → review → test → docs
• User approval required at plan stage
• Break work into todo tasks; add final self-review task

Frontend/UI Context (if applicable)

When this task involves frontend or UI changes,

UI System Context — For ANY task touching .ts, .html, .scss, or .css files: MUST ATTENTION READ before implementing: 1. docs/project-reference/frontend-patterns-reference.md — component base classes, stores, forms 2. docs/project-reference/scss-styling-guide.md — BEM methodology, SCSS variables, mixins, responsive 3. docs/project-reference/design-system/README.md — design tokens, component inventory, icons Reference docs/project-config.json for project-specific paths.

• Component patterns: docs/project-reference/frontend-patterns-reference.md
• Styling/BEM guide: docs/project-reference/scss-styling-guide.md
• Design system tokens: docs/project-reference/design-system/README.md

Ultrathink to plan and implement these tasks with maximum verification:

Be skeptical. Apply critical thinking, sequential thinking. Every claim needs traced proof, confidence percentages (Idea should be more than 80%).

$ARGUMENTS

Mode: HARD - Extra research, detailed planning, mandatory reviews.

Workflow

1. Deep Research Phase

• Launch 2-3 researcher subagents in parallel covering:

- Technical approach validation - Edge cases and failure modes - Security implications - Performance considerations

• Use /scout-ext for comprehensive codebase analysis
• Generate research reports (max 150 lines each)
• External Memory: Write all research to .ai/workspace/analysis/{task-name}.analysis.md. Re-read ENTIRE file before planning.

Graph-Assisted Investigation — MANDATORY when .code-graph/graph.db exists. HARD-GATE: MUST ATTENTION run at least ONE graph command on key files before concluding any investigation. Pattern: Grep finds files → trace --direction both reveals full system flow → Grep verifies details | Task | Minimum Graph Action | | --- | --- | | Investigation/Scout | trace --direction both on 2-3 entry files | | Fix/Debug | callers_of on buggy function + tests_for | | Feature/Enhancement | connections on files to be modified | | Code Review | tests_for on changed functions | | Blast Radius | trace --direction downstream | CLI: python.claude/scripts/code_graph {command} --json. Use --node-mode file first (10-30x less noise), then --node-mode function for detail.

After implementing, run python.claude/scripts/code_graph connections <file> --json on modified files to verify no related files need updates.

Graph-Trace Before Implementation

When graph DB is available, BEFORE writing code, trace to understand the blast radius:

• python.claude/scripts/code_graph trace <file-to-modify> --direction both --json — see what calls this code AND what it triggers
• python.claude/scripts/code_graph trace <file-to-modify> --direction downstream --json — see all downstream consumers
• This prevents breaking implicit dependencies (bus message consumers, event handlers)

2. Comprehensive Planning

• Use planner subagent with all research reports
• Create full plan directory with:

- plan.md - Overview with risk assessment - phase-XX-*.md - Detailed phase files - Success criteria for each phase - Rollback strategy

3. Verified Implementation

• Implement one phase at a time
• After each phase:

- Run type-check and compile - Run relevant tests - Self-review before proceeding

Batch Checkpoint (Large Plans)

For plans with 10+ tasks, execute in batches with human review:

1. Execute batch — Complete next 3 tasks (or user-specified batch size)
2. Report — Show what was implemented, verification output, any concerns
3. Wait — Say "Ready for feedback" and STOP. Do NOT continue automatically.
4. Apply feedback — Incorporate changes, then execute next batch
5. Repeat until all tasks complete

4. Mandatory Testing

• Use tester subagent for full test coverage
• Write tests for:

- Happy path scenarios - Edge cases from research - Error handling paths

• NO mocks or fake data allowed
• Repeat until all tests pass

5. Mandatory Code Review

• Use code-reviewer subagent
• Address all critical and major findings
• Re-run tests after fixes
• Repeat until approved

6. Documentation Update

• Use docs-manager to update relevant docs
• Use project-manager to update project status
• Record any architectural decisions

7. Final Report

• Summary of all changes
• Test coverage metrics
• Security considerations addressed
• Unresolved questions (if any)
• Ask user to review and approve

When to Use

• Critical production features
• Security-sensitive changes
• Public API modifications
• Database schema changes
• Cross-service integrations

Quality Gates

Next Steps (Standalone: MUST ATTENTION ask user via AskUserQuestion. Skip if inside workflow.)

MANDATORY IMPORTANT MUST ATTENTION — NO EXCEPTIONS: If this skill was called outside a workflow, you MUST ATTENTION use AskUserQuestion to present these options. Do NOT skip because the task seems "simple" or "obvious" — the user decides:

• "Proceed with full workflow (Recommended)" — I'll detect the best workflow to continue from here (feature implemented). This ensures review, testing, and docs steps aren't skipped.
• "/code-simplifier" — Simplify and clean up implementation
• "/workflow-review-changes" — Review changes before commit
• "Skip, continue manually" — user decides

If already inside a workflow, skip — the workflow handles sequencing.

Closing Reminders

• MANDATORY IMPORTANT MUST ATTENTION break work into small todo tasks using TaskCreate BEFORE starting
• MANDATORY IMPORTANT MUST ATTENTION search codebase for 3+ similar patterns before creating new code
• MANDATORY IMPORTANT MUST ATTENTION cite file:line evidence for every claim (confidence >80% to act)
• MANDATORY IMPORTANT MUST ATTENTION add a final review todo task to verify work quality
• MANDATORY IMPORTANT MUST ATTENTION validate decisions with user via AskUserQuestion — never auto-decide MANDATORY IMPORTANT MUST ATTENTION READ the following files before starting:
• MANDATORY IMPORTANT MUST ATTENTION search 3+ existing patterns and read code BEFORE any modification. Run graph trace when graph.db exists.
• MANDATORY IMPORTANT MUST ATTENTION include ## Test Specifications with TC IDs per phase. Call TaskList before creating new tasks.
• MANDATORY IMPORTANT MUST ATTENTION read frontend-patterns-reference, scss-styling-guide, design-system/README before any UI change.
• MANDATORY IMPORTANT MUST ATTENTION run at least ONE graph command on key files when graph.db exists. Pattern: grep → graph trace → grep verify.
• MUST ATTENTION apply critical thinking — every claim needs traced proof, confidence >80% to act. Anti-hallucination: never present guess as fact.
• MUST ATTENTION apply AI mistake prevention — holistic-first debugging, fix at responsible layer, surface ambiguity before coding, re-read files after compaction.

[TASK-PLANNING] Before acting, analyze task scope and systematically break it into small todo tasks and sub-tasks using TaskCreate.