---

name: develop description: Development implementation phase detailed rules; read when entering development implementation; includes execution flow, code specifications, consistency audit, solution package migration

Development Implementation - Detailed Rules

Goal: Execute code changes per task list in solution package, synchronize knowledge base updates, migrate to history/

Prerequisites: Solution package exists in plan/ directory awaiting execution

Backup Protection: Recommend creating Git backup branch or manually backing up code directory before execution

---

Mandatory Pre-entry Check

<p3_entry_gate> Description: Even if routing determines entering development implementation, this check still verifies legitimacy (double insurance)

Sole Legal Conditions for Development Implementation (meet any):

CopyCondition A - Confirmation after solution design complete:
  Verification method: Previous AI output in conversation history was solution design complete AND current user input is explicit confirmation

Condition B - Full authorization command:
  Verification method: MODE_FULL_AUTH status=true

Condition C - Execution command:
  Verification method: MODE_EXECUTION status=true

Verification Failure Handling:

CopyIF doesn't meet any condition:
  Output: "❌ Routing Error: Entering development implementation requires meeting prerequisites. Current conditions not met, re-routed."
  Execute: Re-determine current user message per routing priority
  Terminate: Development implementation flow

</p3_entry_gate>

---

Execution Steps

Important: All file operations follow G5 silent execution specification

Step 1: Determine Solution Package to Execute

CopyFull authorization command (MODE_FULL_AUTH=true):
  - Read CREATED_PACKAGE variable (solution package path set during solution design phase)
  - Check if solution package exists and is complete
    - Exists and complete → Use this solution package, set CURRENT_PACKAGE = CREATED_PACKAGE
    - Doesn't exist or incomplete → Output error format per G6.2 and stop
  - Ignore other legacy solution packages in plan/

Interactive confirmation mode/Execution command (MODE_EXECUTION=true):
  - Scan all solution packages under plan/ directory
  - No solution package exists → Output error format per G6.2 and stop
  - Solution package incomplete → Output error format per G6.2 and stop
  - Single complete solution package → Set CURRENT_PACKAGE, continue execution
  - Multiple solution packages → List inventory, wait for user selection
    - User enters valid number (1-N) → Set CURRENT_PACKAGE, continue execution
    - User enters cancel/refuse → Output cancellation format per G6.2, flow terminates
    - Invalid input → Ask again

Exception output examples:
  Solution package doesn't exist:
    ```
    ❌【HelloAGENTS】- Execution Error

    Error: No executable solution package found
    - Cause: plan/ directory is empty or doesn't exist

    ────
    🔄 Next Steps: Please create solution using ~plan command first, or enter solution design phase
    ```

  Solution package incomplete:
    ```
    ❌【HelloAGENTS】- Execution Error

    Error: Solution package incomplete
    - Solution package: [solution package name]
    - Missing files: [why.md/how.md/task.md]

    ────
    🔄 Next Steps: Please supplement missing files or recreate solution package
    ```

Step 2: Check Knowledge Base Status and Handle

Execution method:

• Determine per G10 quick decision tree
• If need to create/rebuild knowledge base → Read kb Skill to execute complete flow

Step 3: Read Knowledge Base and Acquire Project Context

Execution method:

• Execute per G10 quick flow (check knowledge base first → scan codebase if insufficient)
• If need detailed rules → Read kb Skill

Step 4: Read Current Solution Package

Read plan/YYYYMMDDHHMM_<feature>/task.md and why.md

Step 5: Execute Code Changes Per Task List

CopyExecution rules:
  - Strictly execute item by item per task.md

Task success handling:
  - After each task executes successfully, immediately update status from [ ] to [√]

Task skip handling (status update to [-]):
  - Prerequisite tasks this task depends on failed
  - Task conditions not met
  - Task already covered by other task implementations

Task failure handling (status update to [X]):
  - Record error information (for adding notes before migration)
  - Continue executing subsequent tasks
  - After all tasks complete, if failures exist:
    - Interactive confirmation mode/Execution command: List failure inventory, ask user decision
      - User chooses continue → Continue subsequent steps
      - User chooses terminate → Output "Terminated development implementation", flow terminates
    - Full authorization command: List failed tasks in summary, clear MODE_FULL_AUTH status

Code editing techniques:
  - Large file handling (≥2000 lines): Grep locate → Read(offset,limit) → Edit precise modification
  - Each Edit only modifies single function/class

Step 6: Code Security Check

Check content:

• Unsafe patterns (eval, exec, SQL concatenation, etc.)
• Hardcoded sensitive information
• EHRB risk avoidance

Step 7: Quality Check and Testing

CopyTest execution: Run test tasks defined in task.md, or project's existing test suite

Test failure handling rules (strictly enforce):
  ⛔ Blocking tests (core functionality):
    - Failure MUST immediately stop execution
    - Output critical error format
    - Wait for user explicit decision (fix/skip/terminate)
    - Prohibit auto-skip

  ⚠️ Warning tests (important functionality):
    - Mark in summary when failed
    - Continue executing subsequent steps

  ℹ️ Informational tests (secondary functionality):
    - Record in summary when failed
    - Continue executing subsequent steps

⛔Blocking Test Failure Output Format:

Copy❌【HelloAGENTS】- Blocking Test Failure

⛔ Core functionality test failed, must handle before continuing:
- Failed test: [test name]
- Error message: [error summary]

[1] Fix and retry - Attempt to fix issue then retest
[2] Skip and continue - At your own risk, ignore this error and continue execution
[3] Terminate execution - Stop development implementation

────
🔄 Next Steps: Please enter number to choose

Step 8: Synchronize Update Knowledge Base

Important: MUST complete solution package content reading before step 12 migrates solution package

Execution method: Read kb Skill to execute complete knowledge base synchronization rules

Step 9: Update CHANGELOG.md

Determine version number per G7 version management rules

Step 10: Consistency Audit

<consistency_audit> Audit Timing: Execute immediately after P3 phase completes knowledge base operations

Audit Content:

1. Completeness: Documentation covers all modules, essential files and charts complete
2. Consistency: APIs/data models consistent with code, no omissions, duplicates, dead links

Reality Priority (conflict resolution mechanism):

Copy1. Code is sole source of execution reality (Ground Truth)
   → Runtime behavior, API signatures, data structures based on code

2. Default correction direction: Correct knowledge base to conform to code
   → When inconsistency discovered, MUST update documentation to reflect code's objective facts

3. Exceptions (correct code):
   - Knowledge base is recent P2/P3 solution package (just designed solution)
   - Code has obvious errors (Bug)
   - Error information points to code issue

4. When in doubt: Bidirectional verification, prioritize trusting most recent code changes

</consistency_audit>

Step 11: Code Quality Check (Optional)

CopyExecution content: Analyze code files, identify quality issues

If issues found:
  Interactive confirmation mode:
    - Output optimization suggestion inquiry format
    - User confirms → Execute optimization, update documentation, retest
    - User refuses → Skip optimization, continue subsequent steps
  Full authorization command/Execution command:
    - List suggestions in summary (don't execute)

Commit association: Execute per project specifications if commit needed

Code Quality Optimization Suggestion Inquiry Format:

Copy❓【HelloAGENTS】- Code Quality

Found following optimizable items:
1. [Optimization suggestion 1] - [Impact scope/files]
2. [Optimization suggestion 2] - [Impact scope/files]

[1] Execute optimization - Apply above optimization suggestions
[2] Skip - Keep current state, continue subsequent steps

────
🔄 Next Steps: Please enter number to choose

Step 12: Migrate Executed Solution Package to history/

<plan_migration>

⚠️ CRITICAL - Mandatory Enforcement Rules:

Cannot skip: This step is atomic operation at end of this phase

Execution Rules:

1. Update task.md task status and notes:

   • All tasks update to actual execution results ([√]/[X]/[-]/[?])
   • Add notes below non-[√] status tasks (format: > Note: [reason])
   • If multiple failed/skipped tasks, can add execution summary section at end

2. Migrate to history directory:

   • Move solution package directory from plan/ to under history/YYYY-MM/
   • YYYY-MM extracted from solution package directory name (e.g., 202511201200_xxx → 2025-11)
   • Complete path after migration: history/YYYY-MM/YYYYMMDDHHMM_/
   • Migration operation automatically deletes source directory under plan/
   • Name conflict handling: Force overwrite old solution package in history/

3. Update history index: history/index.md

Warning: This operation will invalidate source file paths under plan/, ensure step 8 has completed content reading Cannot skip: This step is atomic operation at end of this phase </plan_migration>

---

Code Specification Requirements

<code_standards> Applicable Scope: All code changes in P3 phase

Specification Requirements:

• File top comments: Before import statements, project's existing comment style, 1-3 sentences explaining module purpose
• All code comments: MUST be generated in {OUTPUT_LANGUAGE}
• Code style: Follow project's existing naming conventions and format specifications </code_standards>

---

Development Implementation Output Format

⚠️ CRITICAL - Mandatory Requirements:

• ALWAYS use G6.1 unified output format
• NEVER use free text to replace standard format
• MUST verify format completeness before output

When Waiting for User to Select Solution Package (step 1 multiple solution packages)

Copy❓【HelloAGENTS】- Development Implementation

Detected multiple solution packages, please select execution target:

[1] YYYYMMDDHHMM_<feature1> - [Overview description]
[2] YYYYMMDDHHMM_<feature2> - [Overview description]
[3] YYYYMMDDHHMM_<feature3> - [Overview description]

────
🔄 Next Steps: Please enter solution package number (1/2/3)

When Phase Complete

Strictly call G6.1 unified output format, fill following data:

1. Phase Name: Development Implementation
2. Phase Specific Content (≤5 key points):
   • 📚 Knowledge base status
   • ✅ Execution result: Task count and status statistics
   • 🔍 Quality verification: Consistency audit, test results
   • 💡 Code quality optimization suggestions (if any)
   • 📦 Migration info: Migrated to history/YYYY-MM/YYYYMMDDHHMM_<feature>/
3. File Change List:

   Copy📁 Changes:
     - {code files}
     - {knowledge base files}
     - helloagents/CHANGELOG.md
     - helloagents/history/index.md
     ...
   

4. Next Step Suggestions: "Please confirm if implementation results meet expectations?"
5. Legacy Solution Reminder: Scan plan/ directory per G11, display if legacy solution packages exist

---

Phase Transition Rules

CopyAfter completing all actions:
  Interactive confirmation mode: Output summary → Development implementation ends
  Full authorization command: Output overall summary → Flow ends
  Execution command: Output overall summary → Flow ends
  Variable cleanup: CURRENT_PACKAGE will automatically clean during legacy solution scan (per G11 rules)

Exceptional situations (test failures/user raises issues):
  Interactive confirmation mode: Mark in output, wait for user decision
  Full authorization command/Execution command: Mark test failure in summary, flow ends normally
  Subsequent user messages handled per routing priority