architext 0.0.2

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

@@ -0,0 +1,162 @@
+<protocol_remove>
+  **Trigger**: `/archi.remove <id>`
+  **Goal**: Fully decommission the specified Task — delete docs, code, and global references with zero residue.
+
+<meta>
+    <style>Surgical, Cautious, Thorough</style>
+    <language>English</language>
+    <principles>
+      1.  **Dependency Safety**: If other tasks depend on this Task, dependencies must be resolved before proceeding.
+      2.  **Confirmation Gate**: Deletion is irreversible; must present full impact and obtain explicit confirmation.
+      3.  **Zero Residue**: Cleanup must cover all associated layers (docs/code/global data/glue entries).
+      4.  **No Side Effects**: Only remove content related to the target Task; forbidden to touch unrelated files.
+    </principles>
+</meta>
+
+<step_1_resolve>
+    **Role**: System Analyst
+    **Action**:
+    1.  **Resolve ID**: Parse `<id>` from `[[__DOCS_DIR__]]/global/roadmap.json` → Task Name, Slug, status.
+    2.  **ID Not Found** → Error with list of available task IDs.
+    3.  **Load Context**:
+        - `[[__DOCS_DIR__]]/tasks/<id>_<Slug>/` — All docs (spec.md, ui.md, plan.json, etc.)
+        - `[[__DOCS_DIR__]]/global/roadmap.json` — Task dependency graph
+        - `[[__DOCS_DIR__]]/global/map.json` — Architecture registry
+        - `99_context_glue.md` — Code↔doc associations
+
+    **Output**: Target Task info (ID, name, status, associated file count).
+</step_1_resolve>
+
+<step_2_impact>
+    **Role**: Impact Assessor
+    **Action**: Scan each layer to produce an impact manifest.
+
+    ### 2.1 Dependency Check (Blocking)
+
+    Scan all tasks' `deps` in `roadmap.json` for references to `<id>`.
+
+    | Situation | Handling |
+    |:---|:---|
+    | No downstream deps | Pass, continue |
+    | Has downstream deps with `pending`/`blocked` status | List affected tasks; ask user: remove dependency and continue, or abort |
+    | Has downstream deps with `active`/`done` status | **Block** — these tasks may use this Task's interfaces/components. Must `/archi.edit` to decouple first |
+
+    ### 2.2 Code File Identification
+
+    Locate code files belonging to this Task via:
+    1.  `99_context_glue.md` code paths associated with `<id>`.
+    2.  `map.json` modules/directories registered for this Task.
+    3.  `plan.json` file paths mentioned in tasks.
+    4.  Scan code directories for files named with Slug or clearly scoped to this Task.
+
+    ### 2.3 Global Reference Scan
+
+    | File | Scan Target |
+    |:---|:---|
+    | `roadmap.json` | Task entry + `deps` references in other tasks |
+    | `map.json` | Module registry entries + `featureRelations` entries where the deleted Task is the aggregator |
+    | `99_context_glue.md` | Association entries |
+    | `dictionary.json` | Terms exclusive to this Task (flag only, no auto-delete) |
+    | `error_codes.json` | Error codes exclusive to this Task (flag only, no auto-delete) |
+
+    ### 2.4 Aggregation Linkage Check
+
+    Read `map.json.featureRelations`; determine whether the deleted Task falls within any aggregator's `sources` coverage.
+
+    | Situation | Handling |
+    |:---|:---|
+    | Not in any aggregator's sources range | No special handling |
+    | In an aggregator's sources range | List in impact report; prompt to check if aggregator content needs to be cleaned up after deletion |
+    | Deleted Task is itself an aggregator | Also remove its entry from `featureRelations` |
+
+    ### 2.5 Cross-Task References
+
+    Scan other Tasks' `spec.md` for references to the target Task's interfaces, components, or data. Flag as `[Breaking]`.
+
+    **Output**: Impact report to user:
+    ```
+    ### Decommission Impact Report: <ID> <Name>
+
+    **Task Status**: [status]
+
+    **Docs to delete**:
+    - [[__DOCS_DIR__]]/tasks/<id>_<slug>/  (N files)
+
+    **Code to delete**:
+    | File/Directory | Source |
+    |:---|:---|
+    | src/xxx/xxx.ts | context_glue |
+    | src/xxx/ | map.json |
+
+    **Global reference cleanup**:
+    - roadmap.json: remove task <id>, clean N deps references
+    - map.json: remove N module entries
+    - context_glue: remove N associations
+
+    **[?present] Terms/error codes residue** (manual confirmation needed):
+    - dictionary.json: [term1], [term2]
+    - error_codes.json: [ERR_XXX]
+
+    **[?present] Aggregation linkage** (check needed):
+    | Aggregator | checkNote |
+    |:---|:---|
+    | [aggregator ID/path] | [checkNote content] |
+
+    **[?present] Cross-Task references [Breaking]**:
+    | Referencing Task | Reference Content | Suggestion |
+    |:---|:---|:---|
+    | FEAT-005 spec.md | Calls <id>'s UserAPI | /archi.edit FEAT-005 to decouple first |
+
+    ---
+    > Reply **OK** to confirm; reply **abort** to cancel.
+    ```
+
+    **Gate**: Proceed to step_3 after user replies OK. Re-warn if `[Breaking]` cross-Task refs exist.
+</step_2_impact>
+
+<step_3_execute>
+    **Role**: Surgeon
+    **Action**: Execute in this order (order is mandatory).
+
+    | # | Operation | Target |
+    |:---|:---|:---|
+    | 1 | Delete code files/directories | Code paths from step_2 |
+    | 2 | Delete Task doc directory | `[[__DOCS_DIR__]]/tasks/<id>_<slug>/` |
+    | 3 | Update `roadmap.json` | Remove task entry; clean `deps` refs to `<id>` in other tasks |
+    | 4 | Update `map.json` | Remove module entries; if this Task is an aggregator, also remove its `featureRelations` entry |
+    | 5 | Update `99_context_glue.md` | Remove association entries for this Task |
+    | 6 | [?exclusive terms] Update `dictionary.json` | Remove or mark deprecated |
+    | 7 | [?exclusive codes] Update `error_codes.json` | Remove or mark deprecated |
+    | 8 | [?aggregation linkage] Check aggregator code | Verify aggregator no longer references the deleted Task |
+
+    Log each operation (file path + operation type) as it completes.
+</step_3_execute>
+
+<step_4_verify>
+    **Role**: Verification Engineer
+    **Terminal Gate** (Do not skip; must complete before step_5 output):
+    | Step | Command | Pass Condition |
+    |:---|:---|:---|
+    | 1 | `npx archi task --check` | No ERROR-level issues, no dangling deps |
+    | 2 | `npx archi render` | `.md` views generated |
+    | 3 | Run project build command | Zero compilation errors |
+
+    | Check | Pass Criteria |
+    |:---|:---|
+    | Roadmap consistency | `--check` passes, no dangling deps |
+    | Build | Zero compilation errors |
+    | Residual refs | No import/require of deleted modules in codebase |
+
+    Build failure or residual refs found → locate, fix, and recheck.
+</step_4_verify>
+
+<step_5_summary>
+    **Output**: Decommission summary:
+    - **Deleted**: N doc files, N code files
+    - **Cleaned**: roadmap / map / context_glue references
+    - **Build status**: pass/fail
+    - **[?present] Manual follow-up needed**: terms/error codes/cross-Task ref residue
+    - **Git Commit Suggestion**: `feat(remove): decommission <ID> <Name>`
+</step_5_summary>
+
+</protocol_remove>

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

@@ -0,0 +1,160 @@
+<protocol_revise>
+  **Trigger**: `/archi.revise [context]`
+  **Goal**: Execute project-wide global changes (tech stack, architecture, vision, etc.), analyze impact scope, modify global assets after user confirmation, and cascade updates to affected Task documents.
+
+<constraints_cursor>
+    **Mode Lock**: This protocol must run in **Agent Mode (Normal Mode)**. Prohibited from switching to Plan Mode or other read-only modes.
+</constraints_cursor>
+
+<meta>
+    <style>Strategic, Analytical, Cautious, Traceable</style>
+    <language>English</language>
+    <principles>
+      1.  **User Gate**: Global changes require item-by-item user confirmation before execution. Prohibited from modifying without approval.
+      2.  **Impact First**: Output complete impact analysis before making any changes.
+      3.  **Doc Cascade**: After global asset changes, must update affected Task docs following edit protocol standards.
+      4.  **Traceability**: Every change must be traceable — state rationale and impact scope.
+    </principles>
+</meta>
+
+<step_1_load>
+    **Role**: Systems Analyst
+    **Action**:
+    1.  **Read Global Assets**:
+        - `[[__DOCS_DIR__]]/global/vision.md`
+        - `[[__DOCS_DIR__]]/global/roadmap.json`
+        - `[[__DOCS_DIR__]]/global/map.json`
+        - `[[__DOCS_DIR__]]/global/dictionary.json`
+        - `[[__DOCS_DIR__]]/global/error_codes.json`
+        - `02_tech_stack.md`
+        - [?UI] `[[__DOCS_DIR__]]/global/design_tokens.json`
+        - [?Data] `[[__DOCS_DIR__]]/global/data_snapshot.json`
+    2.  **Scan Task Index**: Scan `[[__DOCS_DIR__]]/tasks/` directory, build Task index (ID, name, status).
+    3.  **Intent Analysis**: Based on user `[context]`, identify which global asset categories are affected.
+
+    **Output**: Change intent summary — list of initially identified global files. Proceed to step_2.
+</step_1_load>
+
+<step_2_interview>
+    **Role**: Chief Architect
+    **Action**:
+    Clarify change boundaries based on user description and loaded context:
+
+    | Dimension | Description |
+    |:---|:---|
+    | Change Scope | Precisely identify which global files and rules are affected |
+    | Change Motivation | Why this change is needed, what outcome is expected |
+    | Exclusion List | Any Tasks that should not be affected |
+
+    - Context is clear enough → merge into step_3 and output impact analysis directly.
+    - Ambiguity or multiple viable directions → ask user to confirm (A/B/C/D options).
+</step_2_interview>
+
+<step_3_impact>
+    **Role**: Impact Analyst
+    **Constraint**: **Output only, prohibited from modifying any files**. This step produces the "Change Impact Assessment".
+
+    **Output Format**:
+    ```
+    ## Change Impact Assessment: [Change Topic]
+
+    ### 1. Global Asset Change List
+    | File | Change Content | Type |
+    |:---|:---|:---|
+    | vision.md | [what specifically changes, or "no change needed"] | modify/no change |
+    | 02_tech_stack.md | [...] | ... |
+    | roadmap.json | [...] | ... |
+    | map.json | [...] | ... |
+    | dictionary.json | [...] | ... |
+    | data_snapshot.json | [...] | ... |
+    | design_tokens.json | [...] | ... |
+    | error_codes.json | [...] | ... |
+
+    ### 2. Affected Tasks List
+    | Task ID | Name | Impact Points | Severity |
+    |:---|:---|:---|:---|
+    | INF-001 | [name] | [which parts of spec/ui/plan are affected] | High/Med/Low |
+
+    ### 3. Items Requiring User Decision (if any)
+    - [?] [uncertain item description + options]
+    - [?] ...
+
+    ---
+    > Reply **OK** to confirm all; or annotate items that need adjustment.
+    ```
+
+    **Gate**: Wait for user confirmation. Prohibited from entering step_4 without confirmation.
+</step_3_impact>
+
+<step_3_5_refinement>
+    **Role**: Consultant
+    **Trigger**: User replies non-OK, contains corrections, rejections, or additional input.
+    **Action**: Do not execute changes. Incorporate user feedback, refresh and re-output the impact assessment. Wait for re-confirmation.
+</step_3_5_refinement>
+
+<step_4_execute>
+    **Role**: Execution Engineer
+    **Action**:
+
+    **Safety Checkpoint** (required before execution):
+    1. Check Git working directory status (run `git status`).
+    2. If uncommitted changes exist → prompt user to commit or stash first, then continue.
+    3. Once working directory is clean, inform user: to roll back, run `git checkout -- .` to restore pre-change state.
+
+    **Phase 1 — Modify Global Assets**:
+    Modify global files per the user-confirmed list. Output change summary for each file.
+
+    **[?UI] Phase 1.5 — Design System Change Check**:
+    If `design_tokens.json` has any of the following changes, notify the user after Phase 2:
+
+    | Change scope | Impact | Action |
+    |:---|:---|:---|
+    | `primitivePalette.brand` / `semanticTokens.colors` | Brand/semantic color change | Notify user: re-run `archi-ui-wireframe` Phase 2 (full re-coloring) |
+    | `semanticTokens.typography` | Font change | Notify user: re-run Phase 2 |
+    | `motion.preference` / `motion.patterns` | Motion change | Notify user: re-run Phase 2 |
+    | `illustration.iconLibrary` | Icon library change | Notify user: re-run Phase 2 |
+    | `layout` (radius/spacing/shadow) | Component size/radius change | Notify user: re-run Phase 2 |
+
+    > If none of the above fields changed (e.g., only `mode.default` changed), Phase 2 re-run is not needed.
+
+    **Phase 2 — Cascade Update Task Docs**:
+    For each affected Task, follow `/archi.edit` standards:
+    1.  Update `spec.md` (logic/rules that need adjustment due to global changes).
+    2.  [?UI] Update `ui.md` (scope/interaction adjustments due to global changes); if screen structure is affected, run `archi-ui-wireframe` Skill (incremental update mode) to sync both `ui_concept.html` + `ui_context.md`.
+    3.  Append new Phase to `plan.json` `phases`: `Phase X: Global Revision — [Change Topic] (<Date>)`, listing implementation tasks.
+
+    **Output**: Change summary for each file (global + Task).
+</step_4_execute>
+
+<step_5_summary>
+    **Role**: Auditor
+    **Checklist**:
+    1.  Cross-consistency between global assets (vision ↔ tech_stack ↔ roadmap ↔ map).
+    2.  Task docs aligned with updated global assets.
+    3.  No orphaned references (stale terms/paths in dictionary/map cleaned up).
+
+    **Terminal Gate** (Do not skip; must complete before output summary):
+    | Step | Command | Pass Condition |
+    |:---|:---|:---|
+    | 1 | `npx archi task --check` | No ERROR-level issues |
+    | 2 | `npx archi render` | `.md` views generated |
+
+    **Action** (After Gate passes):
+    1.  Output change summary.
+
+    **Output**:
+    ```
+    ## Global Revision Summary: [Change Topic]
+
+    **Global Assets Modified**: [list of modified files]
+    **Tasks Updated**: [list of updated Tasks + impact summary each]
+    **Audit Result**: [pass/risk items]
+
+    ### Next Steps
+    | Priority | Action | Description |
+    |:---|:---|:---|
+    | ... | ... | ... |
+    ```
+</step_5_summary>
+
+</protocol_revise>

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

@@ -0,0 +1,198 @@
+<protocol_scope>
+  **Trigger**: `/archi.scope [file_path]`
+  **Phase**: Requirement Decomposition
+  **Goal**: Read Scope Brief, decompose large requirements into multiple Roadmap tasks with dependency relationships.
+
+<meta>
+    <style>Strategic, Analytical, Structured</style>
+    <language>English</language>
+    <principles>
+      1.  **Brief-Driven**: Use user-provided Scope Brief as primary input; never brainstorm tasks from scratch.
+      2.  **Incremental**: Append to existing Roadmap; never rewrite existing tasks.
+      3.  **User Agency First**: Adopt user-specified choices from Brief as-is; never question or replace.
+      4.  **Minimal Questions**: Only ask about information gaps; skip questioning if Brief is sufficient.
+      5.  **Option Z Everywhere**: All supplementary questions must include `[Z] Custom`.
+    </principles>
+</meta>
+
+<step_0_ingest>
+    **Role**: Intelligence Analyst
+    **Action**:
+    1. Parse `[file_path]` from trigger command:
+       - If path provided → read that file
+       - If no path → look for `scope-brief.md` (project root), then `[[__DOCS_DIR__]]/scope-brief.md`
+       - If none found or empty → jump to `<fallback_interview>`
+
+    2. Parse Brief sections and extract:
+       - Initiative name and description
+       - Task list
+       - Existing design decisions
+       - Boundaries & constraints (out of scope, timeline, dependencies, technical limits)
+       - Affected existing tasks
+       - References
+
+    > Brief is a one-time input file; user may delete it after processing.
+
+    **Output**: Internal summary (not shown to user), proceed to `<step_1_load>`.
+</step_0_ingest>
+
+<step_1_load>
+    **Role**: System Analyst
+    **Action**:
+    1.  **Read Vision**: `[[__DOCS_DIR__]]/global/vision.md` — read North Star Metric and Boundaries sections only; skip remaining chapters.
+    2.  **Read Roadmap**: `[[__DOCS_DIR__]]/global/roadmap.json` — extract only `id/title/status/deps/tag` fields per task (skip `goal/notes`; requirement decomposition does not need these); read current max ID watermark for new task numbering.
+    3.  **Read Tech Stack**: `02_tech_stack.md` — technical constraints.
+    4.  **Read Map**: `[[__DOCS_DIR__]]/global/map.json` — read `directoryMapping` and `featureRelations` only; skip `logicalTopology` and `criticalUserJourneys`.
+    5.  **Scan Tasks**: Scan `[[__DOCS_DIR__]]/tasks/` directory — understand existing task summaries (title + key flows, no full read needed).
+
+    **Output**: Internal context summary, proceed to `<step_2_analysis>`.
+</step_1_load>
+
+<step_2_analysis>
+    **Role**: Chief Product Strategist (CPO)
+    **Input**: Step 0 Brief parsing result + Step 1 project context.
+
+    **Action**:
+
+    1. **Vision Alignment Check**: Does the Brief align with vision.md north star metrics? If deviation → flag `[Vision Deviation Warning]`.
+    2. **Task List Completeness**: Does the task list sufficiently support the initiative goal?
+    3. **Impact Assessment**: Brief "Affected Existing Tasks" → verify against roadmap/tasks for existence and status.
+    4. **Gap Identification**: Check Brief for critical missing information.
+    5. **Linkage Check**: Read `map.json.featureRelations`; semantically compare the new task's description against each `sources` field to determine if it falls within any aggregator's coverage. Surface a linkage reminder in the summary if matched.
+
+    **Gap Levels**:
+    - **Required**: Missing prevents reasonable decomposition (e.g., empty task list)
+    - **Recommended**: AI can infer but should confirm (e.g., unclear dependencies)
+    - **Optional**: AI can decide autonomously (e.g., task grouping approach)
+
+    **Decision**:
+    - No "Required" or "Recommended" gaps → skip Step 2.5, proceed to Step 3
+    - Has gaps → proceed to Step 2.5
+
+    **Output**: Display Brief analysis summary to user:
+    ```
+    ### SCOPE BRIEF Analysis Report
+    > **Initiative**: [Name] | **Scale**: Estimated [N] tasks
+
+    **Vision Alignment**: [Aligned / ⚠️ Deviation — reason]
+
+    **Confirmed Information**:
+    - [list]
+
+    **Affected Existing Tasks**:
+    | Task | Status | Estimated Impact |
+    |:---|:---|:---|
+    | [ID: Name] | [done/active/stub] | [needs modification/extension/no impact] |
+
+    **[?matched] Linkage Reminder**:
+    | Aggregator | checkNote |
+    |:---|:---|
+    | [aggregator ID/path] | [checkNote content] |
+
+    **Information Gaps** (to be addressed):
+    - [gap list]
+
+    **AI Will Auto-Decide** (no action needed):
+    - [list]
+    ```
+</step_2_analysis>
+
+<step_2_5_supplementary>
+    **Role**: Product Consultant
+    **Trigger**: Only when Step 2 identifies "Required" or "Recommended" gaps.
+    **Input**: Step 2 gap list. Max 3 questions.
+
+    [[SKILL: Follow `archi-interview-protocol` Skill's core rules and standard output format.]][[NO-SKILL: (Skill not installed: read `[[__DOCS_DIR__]]/skills/archi-interview-protocol/SKILL.md` and follow its rules)]]
+</step_2_5_supplementary>
+
+<step_3_decompose>
+    **Role**: Chief Architect
+    **Input**: Full Brief + project context + supplementary answers (if any).
+
+    **Action**: [[SKILL: Follow the `archi-decompose-roadmap` Skill protocol to generate incremental task data from the Scope Brief task list]][[NO-SKILL: (Skill not installed: read `[[__DOCS_DIR__]]/skills/archi-decompose-roadmap/SKILL.md` and follow its protocol)]]
+
+    **Display format** (convert Skill output into the following format, present to user and await confirmation):
+
+    ```
+    #### Phase 1: Infrastructure
+    | ID | Title | Description Summary | Tag |
+
+    #### Phase 2: Core Features
+    | ID | Title | Description Summary | Deps | Tag |
+
+    #### Execution Batches (Parallel Groups)
+    (Derived from deps via topological sort)
+    Batch 1 (ready immediately): ...
+    Batch 2 (after Batch 1): ...
+
+    #### NFR Cross-Cutting Concerns (merged, not in Roadmap)
+    (From Skill's NFR merge list)
+    - [NFR name] → injected into [task ID] | affects: [other task IDs]
+    ```
+
+    **Gate**: Proceed to step_4 only after user replies **OK**. Do not write to Roadmap without confirmation. User may refine the plan before confirming (merge/split/adjust deps).
+</step_3_decompose>
+
+<step_3_5_refinement>
+    **Role**: Consultant
+    **Trigger**: User replies non-OK, with merge/split/add/remove/dependency adjustments.
+    **Action**: Incorporate user feedback, refresh decomposition plan and re-output, await re-confirmation.
+</step_3_5_refinement>
+
+<step_4_roadmap_update>
+    **Role**: System Administrator
+    **Input**: User-confirmed decomposition plan.
+
+    **Action**:
+    1.  Append new tasks to corresponding Phase's `tasks` array in `[[__DOCS_DIR__]]/global/roadmap.json`.
+    2.  If new Phase needed → append to `phases` array.
+    3.  Update `lastUpdated` field.
+    4.  [?New modules] Update `directoryMapping` in `[[__DOCS_DIR__]]/global/map.json`: pre-register inferred module paths for new tasks (based on tech_stack architecture pattern and task descriptions; directory-level only — details to be filled during `/archi.plan`).
+
+    **Terminal Gate** (Do not skip; must complete before output summary):
+    | Step | Command | Pass Condition |
+    |:---|:---|:---|
+    | 1 | `npx archi task --check` | No ERROR-level issues |
+    | 2 | `npx archi render` | `.md` views generated |
+
+    **Output**: Write confirmation.
+</step_4_roadmap_update>
+
+<step_5_signoff>
+    **Action** (Gate must complete in step_4):
+    1.  Run `npx archi task` to display task progress overview.
+    2.  Output summary.
+
+    **Output**: Requirement decomposition summary, including:
+    - **Brief Source Confirmation**: Initiative name and core objective
+    - **New Tasks**: Count and phase distribution
+    - **Impact on Existing Tasks**: Impact list (if any)
+    - **Next Steps**:
+
+    | Priority | Action | Description |
+    |:---|:---|:---|
+    | [?UI] Recommended | Run `archi-ui-wireframe` Skill (append mode) | Append screens for new tasks to `ui_concept.html`, sync `ui_context.md` |
+    | 1 | `/archi.plan <first pending task ID>` | Deep planning for the first actionable task |
+    | 2 | Review roadmap | Confirm dependency relationships and priorities |
+</step_5_signoff>
+
+<fallback_interview>
+    **Trigger**: Brief file does not exist or is empty.
+    **Role**: Product Consultant
+
+    **Action**:
+    1. Inform user that `scope-brief.md` was not found. Suggest:
+       - Run `npx archi template scope-brief` to fetch template to project root
+       - Fill in and re-run `/archi.scope scope-brief.md`
+       - Or continue conversation to provide information via interview
+    2. If user chooses to continue conversation, guide in this order:
+       a. What do you want to build? (Initiative name, one-line description, motivation)
+       b. What tasks does it include? (Specific task list)
+       c. What constraints exist? (Out of scope, dependencies, technical limits)
+       d. Which existing tasks will be affected?
+    3. After collection, write information to `scope-brief.md` (project root), then jump to `<step_1_load>`.
+
+    > This mode is for backward compatibility; core flow remains Brief-driven.
+</fallback_interview>
+
+</protocol_scope>