architext 0.0.4 → 0.0.5

package/dist/templates/en/docs/prompts/code.md

@@ -1,153 +1,151 @@
 <protocol_code>
-  **Trigger**: `/archi.code <id>`
-  **Goal**: Based on the `tasks/<id>_<Slug>/plan.json` task list, complete task implementation; follow `02_tech_stack.md` ([?UI] also follow `design_tokens.json`); pass build, type check, lint, formatting, test and audit.
+  **Trigger**: `/archi.code <id>` | Auto-loaded by Workflow Dispatch on natural language trigger
+  **Goal**: Complete feature development per `tasks/<id>_<Slug>/plan.json` task list; follow `02_tech_stack.md` (UI projects only: also follow `design_tokens.json`); pass build, types, Lint, format, tests and audit.
 
 <meta>
     <style>Deterministic, Type-Safe, SOTA-First</style>
     <language>English</language>
     <principles>
-      1.  **Frontmatter Preservation**: Prohibited from modifying existing files' YAML Frontmatter.
-      2.  **Follow Conventions**: Use only existing repo libraries and patterns; read before modify.
-      3.  **Security First**: Prohibit introducing/printing secrets; sensitive info must not be written to disk.
-      4.  **SOTA Pattern Check**: Reject outdated practices; adopt best practices defined in tech_stack.
+      1.  **Frontmatter Preservation**: Do not change existing files' YAML Frontmatter.
+      2.  **Follow Conventions**: Use only repo-existing libs and patterns; read before modify.
+      3.  **Security First**: Do not introduce/print secrets; sensitive info must not be persisted.
+      4.  **SOTA Pattern Check**: Reject outdated patterns; use tech_stack defined best practices.
       5.  **No Commit Policy**: Do not commit without authorization; present changes as patches.
-      6.  **Static Check First**: Must pass all static checks (Type/Lint/Format).
-      7.  **Plan Completion Gate**: Verify Plan completion before signing off. All AI-completable tasks must be finished; only "Human Intervention" and "Force Majeure" are exempt.
+      6.  **Static Check First**: Must pass all static checks (types/Lint/format).
+      7.  **Plan Completion Gate**: Verify Plan completion before finish. All tasks AI can complete must be done; only exempt "manual intervention" and "force majeure".
+      8.  **IDE-Native First**: Leverage IDE native capabilities to drive execution rhythm; this protocol defines quality standards and checkpoints, not fight IDE planning/execution mechanisms.
     </principles>
 </meta>
 
 <step_1_resolve>
-    **Role**: System Analyst
     **Action**:
-    1.  **Resolve ID**: Parse `<id>` → Task Name, Slug, phase/status from `[[__DOCS_DIR__]]/global/roadmap.json`.
-    2.  **Status Gate** — Only `active` can enter code workflow:
+    1.  **Resolve ID**: Parse `<id>` from roadmap.json → Task Name, Slug, phase/status.
+    2.  **Status Gate** — only `active` may enter code flow:
 
         | Status | Handling |
         |:---|:---|
         | `active` | Pass, continue |
         | `pending` | Reject — prompt to run `/archi.plan <ID>` first |
-        | `blocked` | Reject — prerequisites not completed |
-        | `done` | Reject — already completed, use `/archi.edit <ID>` for modifications |
-
-    3.  **Load Context** (Use Roadmap `📁 Slug` to locate):
-        - `[[__DOCS_DIR__]]/tasks/<id>_<Slug>/spec.md` — Logic & Scenarios
-        - `[[__DOCS_DIR__]]/tasks/<id>_<Slug>/ui.md` — task UI scope declaration (if exists)
-        - [?Complex] `[[__DOCS_DIR__]]/tasks/<id>_<Slug>/design.md` — Technical design (if exists): state machine/pipeline/protocol definitions, parameter table, invariants
-        - [?UI] `[[__DOCS_DIR__]]/global/ui_context.md` — AI screen index (screen IDs / routes / states / navigation graph / shared components)
-        - [?UI] `[[__DOCS_DIR__]]/global/ui_concept.html` — read-only visual reference (calibrate layout against this during implementation; do not redesign — design is already locked in ui.md)
-        - `[[__DOCS_DIR__]]/tasks/<id>_<Slug>/plan.json` — Task breakdown (contains `notes` shorthand; must reference during execution)
-        - `02_tech_stack.md` — Technical Red Lines
-        - [?UI] `[[__DOCS_DIR__]]/global/design_tokens.json`
-        - [?Data] `[[__DOCS_DIR__]]/global/data_snapshot.json`
-        - **Read Refs** (if any): Read `[[__DOCS_DIR__]]/refs/index.json` (if exists); match by tags and spec.md tech domain semantics; load only matched ref files as supplementary context; skip if `refs/` missing or empty.
-
-    **Output**: Atomic list of tasks to implement, marking dependencies and order.
+        | `blocked` | Reject — upstream deps incomplete |
+        | `done` | Reject — already done; use `/archi.edit <ID>` for changes |
+
+    3.  **Load**: task docs (spec/ui/design/plan) + project context (tech_stack/design_tokens/data_snapshot/ui_context/ui_concept) + refs (match by tags; load only matched files).
+
+    **Output**: Atomic task list to implement with dependencies and order.
 </step_1_resolve>
 
 <step_2_plan>
-    **Role**: Tech Lead
     **Action**:
-    Generate execution blueprint (dynamically adjusted by project type):
-    - **Phase A (Domain/Data/API)**: Data models/interfaces/validation
-    - **Phase B (UI/Presentation)**: Component structure/styling (use Design Tokens only); non-UI projects adjust to corresponding presentation layer
-    - **Phase C (Integration)**: End-to-end wiring (state management, routing, data flow, error handling)
+    Generate execution blueprint (adjust by project type):
+    - **Phase A (Domain/Data/API)**: Data models / interfaces / validation
+    - **Phase B (UI/Presentation)**: Component structure / styles (Design Tokens only); non-UI projects adjust to corresponding presentation layer
+    - **Phase C (Integration)**: End-to-end wiring (state, routing, data flow, error handling)
 
-    Write completion criteria for each task: static checks passed, tests passed, compliant with tech_stack specs.
+    Each task must have completion criteria: static checks pass, tests pass, comply with tech_stack.
 
-    **Output**: Implementation-oriented atomic task list (Checkbox).
+    **Output**: Atomic task list for implementation (Checkbox).
 </step_2_plan>
 
 <step_3_implement>
-    **Role**: Senior Engineer
     **Protocol**:
-    - **Read First**: Must read target file before modification; follow existing code style.
-    - **Use Existing Stack**: Use only technologies and libraries declared in `02_tech_stack.md`.
-    - [?UI] **Design Tokens Only**: Styles strictly use visual patterns defined by Tokens/Presets; prohibited hardcoding magic values (colors, sizes, spacing, etc.).
-    - **Type-Safe**: Complete type definitions; use the project tech stack's type system to guard boundaries.
-    - **Code Organization**: Follow the architecture pattern and file placement strategy defined in `02_tech_stack.md`.
-    - **Comments**: Explain Why, not What; reject nonsense comments.
-    - **Naming**: Self-documenting names; reject `a`, `b`, `tmp` etc. (except loop variable `i`).
-    - [?Complex] **Design Adherence**: When `design.md` exists, implementation must strictly follow its state machine/pipeline/protocol definitions; parameters must reference design.md § 3 values (no hardcoding other values); must satisfy all § 4 Invariants (use assert or runtime checks).
-    - **Error Handling**: Prohibit swallowing errors/silent failures; must properly propagate errors and provide observable feedback to callers (UI: Toast; CLI: Exit Code; API: Status Code + Body).
-    - **Robustness**: Explicitly handle edge cases (Loading/Error/Empty/Timeout); prohibit writing only Happy Path.
+    - **Read First**: Must read target file before modify; follow existing project code style.
+    - **Use Existing Stack**: Use only tech and libs declared in `02_tech_stack.md`.
+    - (When this task involves UI) **Design Tokens Only**: Styles strictly use Token/Preset; no hardcoded magic values.
+    - **Type-Safe**: Complete type definitions; use project type system to guard boundaries.
+    - **Code Organization**: Follow `02_tech_stack.md` architecture and file placement.
+    - **Comments**: Explain Why, not What.
+    - **Naming**: Self-explanatory names; no meaningless names.
+    - Complex tasks only: **Design Adherence**: When `design.md` exists, implementation must strictly follow its state machine/pipeline/protocol; params reference § 3 values; must satisfy all § 4 Invariants.
+    - **Error Handling**: No swallowing/silent failure; propagate and give callers observable feedback.
+    - **Robustness**: Explicitly handle boundaries (Loading/Error/Empty/Timeout); no Happy Path only.
     - **SOTA**: Follow tech_stack best practices; reject explicitly forbidden outdated patterns.
-    - **Scaffold Safety**: Scaffolds in non-empty directories may overwrite files — must generate in new directory and protect `[[__DOCS_DIR__]]/`; delete/overwrite operations must list manifest and confirm first.
-    - **.gitkeep Cleanup**: Empty dirs may use `.gitkeep` for Git tracking; when adding other files to a dir, must remove that dir's `.gitkeep`.
-    - **Patch Output**: Output changes as patches, with Code References.
-    - **Progress Tracking**: After completing each task, immediately update the corresponding task's `done: true` in `plan.json`; prohibited from batch-updating at signoff (progress will be lost if session is interrupted).
+    - **Scaffold Safety**: Non-empty dirs must protect `[[__DOCS_DIR__]]/`.
+    - **.gitkeep Cleanup**: Remove `.gitkeep` when adding files to dir.
+    - **Patch Output**: Output changes as patches with Code Reference.
+    - **Progress Tracking**: After each task, update `plan.json` corresponding `done: true` immediately; do not batch at signoff.
 
-    **Action**: Implement Phase A/B/C step by step; produce complete, production-quality code (with necessary tests); new files/directories must align with tech_stack.
+    **Action**: Implement phase A/B/C item by item; produce complete, production-ready code (including necessary tests).
 </step_3_implement>
 
 <step_4_validate>
-    **Role**: Validation Engineer
-    **Action** (Fix and re-run on failure; commands subject to `02_tech_stack.md` Section 5):
+    **Action** (on failure fix and re-run; commands per `02_tech_stack.md` Section 5):
 
-    **Automated Check**: Run `[[__DOCS_DIR__]]/scripts/validate` (if exists); otherwise execute the checklist below manually.
+    **Automated Check**: Run `[[__DOCS_DIR__]]/scripts/validate` (if exists); otherwise execute checklist:
 
-    | Phase | Check Item | Requirement |
+    | Phase | Check | Requirement |
     |:---|:---|:---|
-    | **Static** | Build | Zero compilation errors |
+    | **Static** | Build | Zero compile errors |
     | | Type Check | Zero type errors |
-    | | Lint | Zero lint errors (warnings must explain reason) |
-    | | Format | Compliant with format rules (if failed, auto-fix then re-check) |
-    | **Test** | Existing Tests | Run existing test suite, all pass; must not break existing tests |
-    | | New Coverage | Add tests for newly added/modified critical logic; pure styling exempt |
+    | | Lint | Zero Lint errors (warnings require reason) |
+    | | Format | Compliant (auto-fix then re-check if fail) |
+    | **Test** | Existing Tests | All pass; do not break old tests |
+    | | New Coverage | Add tests for new/modified critical logic |
 
-    **Task Verification (Mandatory)**
+    **Task Verification (mandatory)**
 
-    > Prohibited from marking complete via code review or automated tests alone; must actually run and verify the target task.
-    > If dev server is not running, execute `[[__DOCS_DIR__]]/scripts/dev-up` first.
-    > **Read `notes.Verify` first**: Read the `Verify: [...]` portion at the end of the current task's `notes` field and use that operation as the concrete e2e step. Fall back to the table below only if the `notes` field has no `Verify` entry.
+    > Do not mark complete by code review only; must actually run target feature and verify.
+    > **Prefer `notes.验证`**: First read current task `notes` end `Verify: [...]` and run e2e; fallback to table by type when no verify field.
 
     | Project Type | Verification Action | Pass Criteria |
     |:---|:---|:---|
-    | [?Web] | Browser-navigate target task path | Renders correctly, no interaction errors, clean console |
-    | [?API] | Call new/modified endpoints | Status code and body match spec |
-    | [?CLI] | Execute target command (normal args + edge cases) | stdout as expected, correct exit code |
-    | [?Lib] | Run example code or playground to verify exported API | No runtime errors, correct return values |
-    | [?Mobile] | Emulator/device operate target task | UI renders, interactions respond |
-    | [?Desktop] | Launch app operate target task | Window renders, task functional |
+    | When this task involves UI | Browser: operate target feature path | Render OK, interaction no errors |
+    | When this task involves API | Call new/modified endpoint | Status and Body match spec |
+    | When this task involves CLI | Execute target command (normal + edge params) | stdout expected, exit code correct |
+    | When this task involves lib | Run sample code to verify exported API | No runtime error, return correct |
+    | When this task involves mobile | Simulator/device: operate | UI OK, interaction responsive |
+    | When this task involves desktop | Launch app and operate | Window OK, feature works |
 
-    **Evidence**: Output must include verification results (command output summary / screenshot / error log).
-    **Fallback**: If verification keeps failing and environment issues suspected → `[[__DOCS_DIR__]]/scripts/dev-reset` → `[[__DOCS_DIR__]]/scripts/dev-up` → retry.
+    **Evidence**: Attach verification result (command output summary / screenshot / error log).
+    **Fallback**: If verification keeps failing → `scripts/dev-reset` → `scripts/dev-up` → retry.
 
-    **Output**: ✅/❌ status and reason for each check; Task Verification evidence.
+    **Output**: Each check ✅/❌ status and reason; Task Verification evidence.
 </step_4_validate>
 
 <step_5_verify>
     **Role**: Independent Reviewer
 
     **5A. Code quality review**:
-    [[SUBAGENT: archi-silent-audit|mode: code-impl, context: Review step_3 implemented code (Tech/SOTA/Security/Performance + conditional dimensions)]][[NO-SKILL: (Skill not installed: read `[[__DOCS_DIR__]]/skills/archi-silent-audit/SKILL.md`, follow mode: code-impl review dimension table item by item)]]
+    [[SUBAGENT: archi-silent-audit|mode: code-impl, context: Review step_3 implemented code (Tech/SOTA/Security/Performance + conditional dimensions)]][[NO-SKILL: (Skill not installed: read `[[__DOCS_DIR__]]/skills/archi-silent-audit/SKILL.md`, follow mode: code-impl review dimension table)]]
 
     **5B. Linkage check**:
-    [[SUBAGENT: archi-feature-relations|mode: check, context: Semantically compare this implementation with featureRelations sources]][[NO-SKILL: (Skill not installed: read `[[__DOCS_DIR__]]/skills/archi-feature-relations/SKILL.md`, follow mode: check logic)]]
+    [[SUBAGENT: archi-feature-relations|mode: check, context: Compare implemented feature with featureRelations sources semantically]][[NO-SKILL: (Skill not installed: read `[[__DOCS_DIR__]]/skills/archi-feature-relations/SKILL.md`, follow mode: check logic)]]
 
     **5C. Data governance sync**:
-    [[SUBAGENT: archi-data-sync|context: Scan this implementation for new business entities/error codes/Schema; incremental sync per 03_data_governance.md rules]][[NO-SKILL: (Skill not installed: read `[[__DOCS_DIR__]]/skills/archi-data-sync/SKILL.md`, follow its execution protocol)]]
+    [[SUBAGENT: archi-data-sync|context: Scan new business entities/error codes/Schema from implementation; incrementally sync per 03_data_governance.md]][[NO-SKILL: (Skill not installed: read `[[__DOCS_DIR__]]/skills/archi-data-sync/SKILL.md` and follow its protocol)]]
 
     [[INCLUDE: shared/verify-result-handling.md]]
 </step_5_verify>
 
 <step_6_signoff>
-    **Terminal Gate** (Do not skip; must complete before output summary):
+    **Terminal Gate** (do not skip):
     | Step | Command | Pass Condition |
     |:---|:---|:---|
-    | 1 | `npx archi plan <ID>` | All done or exempt only; not passed → return to step_3 |
+    | 1 | `npx archi plan <ID>` | All complete or exempt only; if fail do not sign off, return to step_3 |
     | 2 | `npx archi task <ID> --status done` | Task status updated |
-    | 3 | `npx archi task --check` | No ERROR-level issues |
-    | 4 | `npx archi render` | `.md` views generated |
-
-    **Action** (After Gate passes):
-    1.  Confirm all task `done` marks in `plan.json` are updated (should be done in real-time during step_3; this is a final check).
-    2.  **Drift Warning**: Compare code changes against `spec.md`'s key checkpoints (interface signatures, return types, key operations in Gherkin scenarios). If code exceeds spec coverage → mark `⚠️ Spec Drift`, suggest running `/archi.edit <ID>` to sync docs.
-    3.  Output completed task list with patch links (Code Reference).
-    4.  Provide next step suggestions and Git Commit Suggestion (Conventional Commits).
-
-    **Checkpoint** (Confirm before Output): □ Terminal Gate all executed
-
-    **Output**: Completion summary with completed tasks, exempt items (if any), Git Commit suggestion, Next Steps table.
+    | 3 | Standard check (task --check + render) | No ERROR + views generated |
+
+    **Action** (after Gate passes):
+    1.  Confirm `plan.json` each task `done` flag updated.
+    2.  **Drift Warning**: Compare code changes with `spec.md` key points. If beyond spec coverage → mark `⚠️ Spec drift`, suggest `/archi.edit <ID>`.
+    3.  Output completed task list and patch links.
+    4.  Provide next steps and Git Commit Suggestion (Conventional Commits).
+
+    **Pre-signoff Checklist** (confirm each item before Output):
+    □ plan.json — every task done flag updated in real-time (not batch-updated at signoff)
+    □ Step 4 — Build / type check / Lint / format all passed
+    □ Step 4 — Task Verification executed for each project type with Evidence attached
+    □ Step 5A Silent Audit — executed, all CRITICAL issues resolved
+    □ Step 5B featureRelations check — executed
+    □ Step 5C data governance sync — executed
+    □ Terminal Gate — npx archi plan <ID> all complete (exempt items only)
+
+    **Output**: Completion summary with completed tasks, exempt items (if any), Git Commit suggestion, Next Steps:
+
+    | Priority | Action | Notes |
+    |:---|:---|:---|
+    | Recommended | `/archi.audit <ID>` | Independent review of implementation |
+    | (If Spec drift) | `/archi.edit <ID>` | Update docs before continuing |
+    | (If next pending task) | `/archi.plan <next pending ID>` | Plan the next task |
 </step_6_signoff>
 
 </protocol_code>

package/dist/templates/en/docs/prompts/edit.md

@@ -1,96 +1,92 @@
 <protocol_edit>
-  **Trigger**: `/archi.edit <id> [context]`
-  **Goal**: Based on new requirements/feedback, update Spec/UI docs of an already managed module and append development plans.
+  **Trigger**: `/archi.edit <id> [context]` | Auto-loaded by Workflow Dispatch on natural language trigger
+  **Goal**: Update managed module's Spec/UI docs per new requirements/feedback, and append development plan.
 
 <meta>
     <style>Collaborative, Iterative, Traceable</style>
     <language>English</language>
     <principles>
-      1.  **Doc First**: Must modify docs (Spec/UI) first, then generate Plan. Prohibited from skipping docs to change code plans directly.
-      2.  **Incremental**: Only append new Tasks to Plan, keep completed history (unless rollback needed).
+      1.  **Doc First**: Must modify docs (Spec/UI) first, then generate Plan. Do not skip docs to change code plan.
+      2.  **Incremental**: Only append new Tasks to Plan; keep completed history (unless rollback needed).
       3.  **Conflict Check**: Check if new requirements conflict with tech_stack / design_tokens.
-      4.  **Frontmatter Preservation**: Prohibited from destroying existing document Metadata.
+      4.  **Frontmatter Preservation**: Do not break existing document Metadata.
+      5.  **IDE-Native First**: Leverage IDE native capabilities to drive execution rhythm; this protocol defines quality standards and checkpoints, not fight IDE planning/execution mechanisms.
     </principles>
 </meta>
 
 <step_1_load>
-    **Role**: Product Manager
     **Action**:
-    - Read `[[__DOCS_DIR__]]/tasks/<ID>_<Slug>/` spec.md, ui.md, plan.json.
-    - [?UI] Read `[[__DOCS_DIR__]]/global/ui_context.md` (locate the screen scope and navigation graph for this task).
-    - Check `Spec-Status` field in spec.md:
-      - `Full` → Normal flow, proceed to step_2.
-      - `Stub` → Proceed to step_1_5_enrich.
-    - [?Major UX Change] Quick search for similar product best practices.
+    - Read spec.md, ui.md, plan.json under `[[__DOCS_DIR__]]/tasks/<ID>_<Slug>/`.
+    - (UI projects only) Read ui_context.md (locate screen scope and navigation for this feature).
+    - Check `Spec-Status` in spec.md: `Full` → normal flow step_2 | `Stub` → step_1_5_enrich.
+    - (Major UX change) Quick search for similar product best practices.
 </step_1_load>
 
 <step_1_5_enrich>
-    **Role**: Reverse Engineer
-    **Trigger**: spec.md contains `Spec-Status: Stub` (lightweight snapshot generated by `/archi.inherit`).
+    **Trigger**: spec.md contains `Spec-Status: Stub` (lightweight snapshot from `/archi.inherit`).
 
     **Action**:
-    1. Inform user: "This task only has a lightweight snapshot. A full spec must be generated before modifications can proceed."
-    2. Extract source file paths from the stub's "Associated Files" section.
-    3. Read each associated file with medium-depth scan (entry point + core logic).
-    4. Enrich the stub into a full spec based on code analysis:
-       - Preserve existing overview and key flows
-       - Add Gherkin Scenarios (covering normal flows + exception paths)
-       - Add interface/type definitions (if this task is upstream of others)
-    5. Update `Spec-Status: Stub → Full`.
-    6. [?UI] If module has UI → generate or update `ui.md` (scope declaration); if new screens are needed, [[SKILL: archi-ui-wireframe|invoke skill or notify user to run]][[NO-SKILL: (Skill not installed: read `[[__DOCS_DIR__]]/skills/archi-ui-wireframe/SKILL.md` and prompt user to follow the document)]] (Skill syncs both `ui_concept.html` + `ui_context.md`).
-    7. Generate `plan.json` (all tasks as done, recording implemented content).
-    8. Present enriched spec summary to user.
-
-    **Gate**: User confirms enriched content is correct before proceeding to step_2_refine_docs.
+    1. Inform user: "This task has only a lightweight snapshot; must complete full spec before modification."
+    2. Extract source paths from stub "Associated Files"; read each (entry + core logic).
+    3. Enrich into full spec from code analysis: keep existing overview and flows; add Gherkin Scenarios + interface/type definitions.
+    4. Update `Spec-Status: Stub → Full`.
+    5. (UI projects only) If module has UI → generate `ui.md`; if new screens needed, [[SKILL: archi-ui-wireframe|invoke skill]][[NO-SKILL: (Skill not installed: read `[[__DOCS_DIR__]]/skills/archi-ui-wireframe/SKILL.md`)]].
+    6. Generate `plan.json` (all tasks done).
+    7. Output enriched spec summary to user.
+
+    **Gate**: Proceed to step_2_refine_docs after user confirms.
     **Exception**: Associated files missing/moved → prompt user to update paths.
 </step_1_5_enrich>
 
 <step_2_refine_docs>
-    **Role**: Requirements Analyst & Designer
     **Action**:
-    - Modify spec.md (logic/rule changes) and ui.md (structure/interaction changes) based on `[context]`.
-    - [?UI Modification] [[SKILL: archi-ui-wireframe|Follow the skill protocol to sync `ui_concept.html` + `ui_context.md` (Skill is the sole writer of both files)]][[NO-SKILL: (Skill not installed: read `[[__DOCS_DIR__]]/skills/archi-ui-wireframe/SKILL.md` and follow its protocol)]]:
+    - Modify spec.md and ui.md per `[context]`.
+    - (UI modified) [[SKILL: archi-ui-wireframe|Follow the skill protocol to sync `ui_concept.html` + `ui_context.md`]][[NO-SKILL: (Skill not installed: read `[[__DOCS_DIR__]]/skills/archi-ui-wireframe/SKILL.md`)]]:
 
-      | Change Type | Criteria | Action |
+      | Change Type | Criteria | Handling |
       |:---|:---|:---|
-      | No screen impact | Logic/data only, no visual diff | Update spec.md only; `ui_concept.html` / `ui_context.md` unchanged |
-      | Minor UI tweak | New/modified state, popup, or local area; overall layout unchanged | Call skill (Modify screens mode) to update both files; output `MODIFIED: S-XX` |
-      | Screen structure change | Layout refactor, new standalone screen, navigation path change | Call skill (Modify screens mode) to update both files; output `MODIFIED: S-XX`; if Phase 2 coloring is done, re-color only the modified screen |
-      | Task reduction | Screen/region removed entirely | Call skill (Remove screens mode) to update both files; output `REMOVED: S-XX` |
+      | No screen impact | Logic/data change only | Update spec.md only |
+      | Minor UI tweak | New/modified state, popup, local area | Call skill to update; output `MODIFIED: S-XX` |
+      | Screen structure change | Layout refactor, new screen, navigation change | Call skill to update |
+      | Task reduction | Screen/region removed entirely | Call skill to remove; output `REMOVED: S-XX` |
 
-    - Ask user questions (A/B/C/D options) to confirm details when requirements are vague.
+    - Ask user when requirements are vague.
 
-    **Output**: Updated Spec, UI documents, and `ui_concept.html` / `ui_context.md` change summary.
+    **Output**: Updated docs and change summary.
 </step_2_refine_docs>
 
 <step_3_update_plan>
-    **Role**: Tech Lead
     **Action**:
-    - Append new Phase object to `plan.json` phases array.
-    - List specific Tasks (API update, UI tweak, Test update); each must be verifiable.
-    - **Status Transition**: If current task status=`done`, reset to `active` after appending the Phase (otherwise `/archi.code` will be rejected by the Status Gate).
+    - Append new Phase to `plan.json` with specific Tasks; each must be verifiable.
+    - **Status transition**: When status=`done`, after appending Phase must reset to `active`.
 
-    **Terminal Gate** (Do not skip; must complete before step_3_5 starts):
+    **Terminal Gate** (do not skip): Standard check (task --check + render).
     | Step | Command | Pass Condition |
     |:---|:---|:---|
-    | 1 | `npx archi task --check` | No ERROR-level issues |
-    | 2 | `npx archi render` | `.md` views generated |
-    | 3 | [if current status=done] `npx archi task <ID> --status active` | Task status reset to active |
+    | 3 | [when status=done] `npx archi task <ID> --status active` | Status reset |
 
-    **Output**: plan.json with new tasks appended; if status transition was performed, output `MODIFIED: roadmap.json <ID>.status done→active`.
+    **Output**: plan.json with new tasks appended; if status transition performed, output `MODIFIED: roadmap.json <ID>.status done→active`. Enter step_4_verify.
 </step_3_update_plan>
 
-<step_3_5_verify>
+<step_4_verify>
     **Role**: Independent Reviewer
 
-    [[SUBAGENT: archi-silent-audit|mode: plan-docs, context: Review step_2 updated spec.md/ui.md and step_3 appended plan.json new Phase; ensure doc logic is consistent and new Phase tasks are verifiable]][[NO-SKILL: (Skill not installed: read `[[__DOCS_DIR__]]/skills/archi-silent-audit/SKILL.md`, follow mode: plan-docs review dimension table item by item)]]
+    [[SUBAGENT: archi-silent-audit|mode: plan-docs, context: Review step_2 updated spec.md/ui.md and step_3 appended plan.json new Phase]][[NO-SKILL: (Skill not installed: read `[[__DOCS_DIR__]]/skills/archi-silent-audit/SKILL.md`, follow mode: plan-docs review)]]
 
     [[INCLUDE: shared/verify-result-handling.md]]
-</step_3_5_verify>
+</step_4_verify>
+
+<step_5_summary>
+    **Pre-signoff Checklist** (confirm each item before Output):
+    □ spec.md — updated per context, changes tracked
+    □ (if UI changed) ui.md + ui_concept.html + ui_context.md — synced
+    □ plan.json — new Phase appended (history tasks fully preserved)
+    □ (if original status=done) roadmap.json — status reset to active
+    □ Step 4 Silent Audit — executed, all CRITICAL issues resolved
+    □ Terminal Gate — task --check no ERROR (executed in step_3)
 
-<step_4_summary>
     **Action** (Gate must complete in step_3):
     **Output**: Task update summary with Spec/UI/Plan change overview and Next Steps table. Recommend running `/archi.code <ID>`.
-</step_4_summary>
+</step_5_summary>
 
 </protocol_edit>

package/dist/templates/en/docs/prompts/fix.md

@@ -1,86 +1,93 @@
 <protocol_fix>
-  **Trigger**: `/archi.fix [id] <context>`
-  **Goal**: Diagnose Bug and execute fix directly. If `[id]` not provided, auto-locate relevant task module.
+  **Trigger**: `/archi.fix [id] <context>` | Auto-loaded by Workflow Dispatch on natural language trigger
+  **Goal**: Diagnose and fix bugs. If `[id]` not provided, auto-locate related feature module by context.
 
 <meta>
     <style>Diagnostic, Surgical, Spec-Compliant</style>
     <language>English</language>
     <principles>
-      1.  **Spec Immutable**: Prohibited from modifying `spec.md` / `ui.md` (unless Bug itself is a documentation error).
-      2.  **Reproduction**: Must conceive reproduction steps or test cases first.
-      3.  **Root Cause**: Must analyze root cause, not patch the surface.
+      1.  **Spec Immutable**: Do not modify `spec.md` / `ui.md` (unless the bug is a doc error).
+      2.  **Reproduction**: Must have reproduction steps or test case first.
+      3.  **Root Cause**: Must analyze root cause, not patch surface.
       4.  **Test-Driven**: Fix plan must include new test cases.
-      5.  **Auto-Discovery**: If ID not specified, locate Task via Context semantic search.
+      5.  **Auto-Discovery**: If ID not specified, locate Task via context semantic search.
+      6.  **IDE-Native First**: Leverage IDE native capabilities to drive execution rhythm; this protocol defines quality standards and checkpoints, not fight IDE planning/execution mechanisms.
     </principles>
 </meta>
 
 <step_1_diagnose>
-    **Role**: Fault Analyst
+    **Role**: Failure Analyst
     **Action**:
     1.  **Resolve Target**:
-        - Has `<id>`: Lock target `tasks/<ID>_<Slug>/`.
-        - No `<id>`: Analyze `[context]` to search most relevant module.
-          Unique match → Auto lock | Multiple matches → List candidates and ask | Cannot locate → Report error requesting ID.
-    2.  Read all docs under target directory (`spec.md`, `ui.md`, `plan.json`) and related code.
-    3.  Read `02_tech_stack.md` (ensure fix does not violate tech red lines) and `[[__DOCS_DIR__]]/global/vision.md` (ensure fix direction stays aligned with project vision).
-    4.  Analyze `[context]`, combine with code logic to locate potential failure points.
-    5.  **Hypothesis**: Propose 1-3 root cause hypotheses.
-
-    **Output**: Root Cause Analysis report.
+        - With `<id>`: Lock `tasks/<ID>_<Slug>/`.
+        - Without `<id>`: Analyze `[context]` to find most relevant module.
+          Single match → auto lock | Multiple matches → list candidates and ask | Cannot locate → error, request ID.
+    2.  Read all docs and related code in target directory.
+    3.  Read 02_tech_stack.md (tech red lines) and vision.md (direction anchor).
+    4.  Analyze `[context]` with code logic to locate potential fault points.
+    5.  **Hypothesis**: Propose 1–3 root cause hypotheses.
+
+    **Output**: Fault diagnosis report (Root Cause Analysis).
 </step_1_diagnose>
 
 <step_2_plan_fix>
-    **Role**: Tech Lead
     **Action**:
-    - Update `[[__DOCS_DIR__]]/tasks/<ID>_<Slug>/plan.json`, append to `phases` array a phase object with `name`: `Bugfix: <Bug Title>`.
-    - Tasks: 1) Create reproduction test (Red) 2) Apply fix (Green) 3) Regression test.
+    - Update plan.json; append phase `Bugfix: <Bug Title>`.
+    - Tasks: 1) Create reproduction test (Red) 2) Fix (Green) 3) Regression test.
 
-    **Terminal Gate** (Do not skip; must complete before step_5 output):
-    | Step | Command | Pass Condition |
-    |:---|:---|:---|
-    | 1 | `npx archi render` | `.md` views generated |
+    **Terminal Gate** (do not skip): Standard check (task --check + render).
 
     **Output**: plan.json with fix tasks appended.
 </step_2_plan_fix>
 
 <step_3_execute_fix>
-    **Role**: Senior Engineer (Surgical Fix — bug only, no scope creep)
     **Action**:
-    - Modify code directly according to Plan.
-    - Fix Bug only; prohibited from opportunistic refactoring or modifying unrelated code.
-    - Error handling follows `code.md` specs (no swallowing errors/no silent failures).
+    - Modify code per Plan. Fix bug only; do not refactor.
+    - Error handling follows `code.md` protocol.
 </step_3_execute_fix>
 
 <step_4_verify>
-    **Role**: QA Engineer
-    **Terminal Gate** (Do not skip; must complete before step_5 output):
+    **Terminal Gate** (do not skip):
     | Step | Command | Pass Condition |
     |:---|:---|:---|
-    | 1 | Run build command | Build succeeds |
+    | 1 | Run build command | Build success |
     | 2 | Run type check | Zero type errors |
     | 3 | Run Lint/Format | Pass |
-    | 4 | Run tests | Reproduction + regression tests pass |
+    | 4 | Run tests | Reproduction test + regression test pass |
 
-    Any failure must be fixed until passed.
+    Fix any failure until pass.
+
+    **Code quality review**:
+    [[SUBAGENT: archi-silent-audit|mode: code-impl, context: Review fix code; focus Tech/Security/Performance + Spec Immutable]][[NO-SKILL: (Skill not installed: read `[[__DOCS_DIR__]]/skills/archi-silent-audit/SKILL.md`, follow mode: code-impl check)]]
+
+    [[INCLUDE: shared/verify-result-handling.md]]
 </step_4_verify>
 
-<step_4_5_plan_update>
-    **Role**: Tech Lead
+<step_5_plan_update>
     **Action**:
-    1. Update `plan.json`: set `done: true` for completed tasks in the Bugfix Phase.
-    2. [current status=`done` and all Bugfix Phase tasks passed] → Keep status as `done`.
-    3. [Bugfix Phase has unresolved tasks] → Run `npx archi task <ID> --status active`; note in signoff that `/archi.code` is needed to complete remaining fixes.
+    1. Update plan.json Bugfix Phase completed tasks `done: true`.
+    2. [status=`done` and Bugfix all pass] → keep `done`.
+    3. [Bugfix has incomplete items] → `npx archi task <ID> --status active`; signoff note to re-run `/archi.code`.
+
+    **Output**: `MODIFIED: plan.json Bugfix Phase done flags`. Enter step_6_summary.
+</step_5_plan_update>
 
-    **Output**: `MODIFIED: plan.json Bugfix Phase done marks` (if status changed, append `MODIFIED: roadmap.json <ID>.status`).
-</step_4_5_plan_update>
+<step_6_summary>
+    **Pre-signoff Checklist** (confirm each item before Output):
+    □ Root cause analyzed (not surface patch), Hypothesis output in step_1
+    □ plan.json — Bugfix Phase appended (step_2)
+    □ Reproduction test created and verified (Red → Green)
+    □ Code fix targets Bug only, no opportunistic refactoring
+    □ Step 4 Terminal Gate — Build / type check / Lint / tests all passed
+    □ Step 4 Silent Audit — executed, all CRITICAL issues resolved
+    □ plan.json Bugfix Phase — done flags updated (step_5)
 
-<step_5_summary>
     **Output**: Bug fix summary with Root Cause analysis, fix content, new tests, and Next Steps table:
 
     | Priority | Action | Notes |
     |:---|:---|:---|
-    | Recommended | `/archi.audit <ID>` | Re-audit to confirm fix is complete and no new issues introduced |
-    | Optional | `/archi.code <ID>` | If Bugfix Phase has remaining incomplete tasks |
+    | Recommended | `/archi.audit <ID>` | Re-audit to confirm fix complete |
+    | Optional | `/archi.code <ID>` | If incomplete items, continue implementation |
 </step_5_summary>
 
 </protocol_fix>