@christianmaf80/agentic-workflow 1.2.0-beta.1

package/dist/workflows/tasklifecycle-long/phase-0-acceptance-criteria.md

@@ -0,0 +1,161 @@
+---
+id: workflow.tasklifecycle.phase-0-acceptance-criteria
+description: Converts the task candidate into a final task. The architect defines acceptance criteria through 5 mandatory questions based on the task and its objective, and creates the current task needed to start the lifecycle.
+owner: architect-agent
+version: 1.3.0
+severity: PERMANENT
+trigger:
+  commands: ["phase0", "phase-0", "acceptance", "acceptance-criteria"]
+blocking: true
+---
+
+# WORKFLOW: tasklifecycle.phase-0-acceptance-criteria
+
+## Input (REQUIRED)
+- Task candidate created by `workflow.tasklifecycle-long`:
+  - `artifacts.candidate.task`
+- The candidate `task.md` **MUST** include:
+  - Task description
+  - Task objective
+
+> [!IMPORTANT]
+> **Active Constitution (MANDATORY)**:
+> - Load `constitution.project_architecture` before starting
+> - Load `constitution.agents_behavior` (Section 7: Gates, Section 8: Constitution)
+
+## Output (REQUIRED)
+- Current task (final) with complete acceptance criteria:
+  - `.agent/artifacts/<taskId>-<taskTitle>/task.md`
+
+## Template (MANDATORY)
+- The current task **MUST** be created using the template:
+  - `templates.task`
+- If the template doesn't exist or cannot be loaded → **FAIL**.
+
+## Objective (ONLY)
+- Move from **task candidate** to **current task** (final).
+- **Calculate the final `taskId`**.
+- Define **mandatory** acceptance criteria based on 5 clarifying questions to the developer.
+- Record acceptance criteria within the current task file.
+
+## Reasoning (MANDATORY)
+- Before executing, the responsible agent must explain to the developer what will be done and why.
+- No document is required for this step.
+
+## Mandatory Steps
+0. **Role Activation and Prefix (MANDATORY)**
+   - The `architect-agent` **MUST** begin its intervention by identifying itself.
+   - Message: `🏛️ **architect-agent**: Starting Phase 0 - Acceptance Criteria.`
+
+1. Load and read task candidate:
+   - `artifacts.candidate.task`
+   - Extract:
+     - Task description
+     - Task objective
+   - If missing → go to **Step 10 (FAIL)**.
+
+2. Load task contractual template:
+   - Load `templates.task`
+   - If it doesn't exist or cannot be loaded → go to **Step 10 (FAIL)**.
+
+3. **Calculate `taskId` (MANDATORY – Architect)**
+   - The `architect-agent` **MUST** execute the following command:
+     ```bash
+     ls .agent/artifacts/ | grep -E "^[0-9]" | sort -n | tail -1 | cut -d'-' -f1
+     ```
+   - The output shows the last taskId (e.g., "8").
+   - New `taskId = output + 1` (e.g., if output is "8", new taskId is "9").
+   - If no output (no previous tasks) → `taskId = 1`.
+   - The final value of `taskId` is **mandatory** to continue.
+
+4. Define `taskTitle` (Architect)
+   - Derive `taskTitle` from the developer's request (candidate).
+   - Normalize for filesystem:
+     - Lowercase
+     - Spaces → `-`
+     - No special characters
+
+5. Formulate clarifying questions (MANDATORY, task-adaptive)
+   - The `architect-agent` **MUST** analyze:
+     - `task.description`
+     - `task.goal`
+   - Based on that analysis, it **MUST formulate exactly 5 questions** aimed at:
+     - Eliminating ambiguities
+     - Completing missing information
+     - Allowing the definition of verifiable acceptance criteria
+   - The questions:
+     - **MUST NOT** duplicate information already explicit
+     - **MUST** be directly related to the specific task
+     - **MAY** vary according to task context
+
+6. Validate responses and close definition (MANDATORY)
+   - Confirm that the 5 formulated questions have explicit answers.
+   - Based on the answers, the `architect-agent` **MUST**:
+     - Consolidate a complete definition of the task
+     - Derive verifiable acceptance criteria
+   - If any answer is missing or ambiguity persists → go to **Step 10 (FAIL)**.
+
+7. Create current task (MANDATORY)
+   - Create the task directory (if missing):
+     - `.agent/artifacts/<taskId>-<taskTitle>/`
+   - Create status file:
+     - `.agent/artifacts/<taskId>-<taskTitle>/task.md` (using `templates.task`)
+   - Create acceptance file:
+     - `.agent/artifacts/<taskId>-<taskTitle>/acceptance.md` (using `templates.acceptance`)
+   - The `task.md` **will only contain**:
+     - Metadata (id, title, owner, strategy)
+     - Phase history
+     - `task.acceptance` alias pointing to the new file
+   - The `acceptance.md` **will contain**:
+     - Consolidated definition
+     - Detailed 5 answers
+     - Checklist of verifiable criteria (AC)
+   - If creation/writing fails → go to **Step 10 (FAIL)**.
+
+8. Request developer approval (MANDATORY, via console)
+   - The developer **MUST** explicitly approve:
+     - Acceptance criteria
+     - Created current task
+   - Record the decision in `acceptance.md`:
+     ```yaml
+     approval:
+       developer:
+         decision: YES | NO
+         date: <ISO-8601>
+         comments: <optional>
+     ```
+   - If `decision != YES` → go to **Step 10 (FAIL)**.
+
+9. PASS
+   - Inform that Phase 0 is completed successfully.
+   - The `architect-agent` **MUST explicitly perform** the following actions (using prefix):
+     - Mark Phase 0 as completed in `task.md`.
+     - Set `task.lifecycle.phases.phase-0-acceptance-criteria.validated_at = <ISO-8601>`.
+     - Update `task.phase.updated_at = <ISO-8601>`.
+     - Update status:
+       - `task.phase.current = aliases.taskcycle-long.phases.phase_1.id`
+
+10. FAIL (mandatory)
+    - Declare Phase 0 as **NOT completed**.
+    - Specify exactly what failed.
+    - End blocked: do not advance the phase.
+
+## Pass
+- All required artifacts are created from templates.
+- Developer approval is recorded where required.
+
+## Gate (REQUIRED)
+Requirements (all mandatory):
+1. `.agent/artifacts/<taskId>-<taskTitle>/task.md` and `acceptance.md` exist.
+2. The current task includes complete and verifiable acceptance criteria.
+3. Explicit developer approval is recorded in `acceptance.md`:
+   - `approval.developer.decision == YES`
+4. The `architect-agent` has explicitly marked:
+   - Phase 0 as completed
+   - `task.lifecycle.phases.phase-0-acceptance-criteria.completed == true`
+   - `task.lifecycle.phases.phase-0-acceptance-criteria.validated_at` not null
+   - `task.phase.updated_at` not null
+   - `task.phase.current == aliases.taskcycle-long.phases.phase_1.id`
+
+If Gate FAIL:
+- Execute **FAIL**.

package/dist/workflows/tasklifecycle-long/phase-1-research.md

@@ -0,0 +1,151 @@
+---
+id: workflow.tasklifecycle.phase-1-research
+description: Task cycle Phase 1. Exhaustive technical research of needs and alternatives. Requires explicit developer approval.
+owner: researcher-agent
+version: 1.1.0
+severity: PERMANENT
+trigger:
+  commands: ["phase1", "phase-1", "research"]
+blocking: true
+---
+
+# WORKFLOW: tasklifecycle.phase-1-research
+
+## Input (REQUIRED)
+- Current task exists:
+  - `.agent/artifacts/<taskId>-<taskTitle>/task.md`
+- `task.md` **MUST** reflect:
+  - `task.phase.current == aliases.taskcycle-long.phases.phase_1.id`
+- `task.md` **MUST** include:
+  - Description
+  - Objective
+  - Defined acceptance criteria
+
+> [!IMPORTANT]
+> **Active Constitution (MANDATORY)**:
+> - Load `constitution.project_architecture` before starting
+> - Load `constitution.agents_behavior` (Section 7: Gates, Section 8: Constitution)
+
+## Output (REQUIRED)
+- Research report (mandatory, generated by researcher-agent):
+  - `.agent/artifacts/<taskId>-<taskTitle>/researcher/research.md`
+- Status update in current task:
+  - `.agent/artifacts/<taskId>-<taskTitle>/task.md`
+
+## Objective (ONLY)
+- Investigate technical needs detected for the task.
+- Explore relevant alternatives and APIs.
+- Document multi-browser compatibility and risks.
+- Deliver a rigorous and verifiable report to the architect-agent.
+
+> This phase **DOES NOT implement code**.
+> This phase **REQUIRES explicit developer approval**.
+
+> [!CAUTION]
+> **PERMANENT RULE**: Research DOCUMENTS, it DOES NOT analyze.
+> The researcher-agent gathers information from official sources.
+> **FORBIDDEN**: Proposing solutions, evaluating trade-offs, recommending alternatives.
+> Analysis belongs to Phase 2.
+
+## Template (MANDATORY)
+- The report **MUST** be created using the template:
+  - `templates.research`
+- If the template doesn't exist or cannot be loaded → **FAIL**.
+
+---
+
+## Reasoning (MANDATORY)
+- Before executing, the responsible agent must explain to the developer what will be done and why.
+- No document is required for this step.
+
+## Mandatory Steps
+
+0. **Role Activation and Prefix (MANDATORY)**
+   - The `architect-agent` **MUST** begin its intervention by identifying itself.
+   - Message: `🏛️ **architect-agent**: Starting Phase 1 - Research.`
+
+1. Verify inputs (architect-agent)
+   - `task.md` exists
+   - `task.phase.current == aliases.taskcycle-long.phases.phase_1.id`
+   - `task.md` contains acceptance criteria
+   - If fails → go to **Step 8 (FAIL)**.
+
+2. Load research template (architect-agent)
+   - Load `templates.research`
+   - If it doesn't exist or cannot be read → go to **Step 8 (FAIL)**.
+
+3. **Delegate to researcher-agent (MANDATORY)**
+   > ⚠️ **PERMANENT RULE**: The `architect-agent` **CANNOT** create the research report.
+   > The `researcher-agent` is the **only authorized agent** to create `research.md`.
+
+   The `architect-agent` **MUST**:
+   a) Activate the `researcher-agent` with the task context:
+      - Task description and objective
+      - Acceptance criteria
+      - Template to use (`templates.research`)
+   b) The `researcher-agent` **MUST** identify itself: `🔬 **researcher-agent**: Starting technical research for <taskName>...`
+   c) Wait for the `researcher-agent` to complete its report
+   d) Verify that the report exists and complies with the template
+
+   The `researcher-agent` **MUST**:
+   - Create directory: `.agent/artifacts/<taskId>-<taskTitle>/researcher/`
+   - Create report: `.agent/artifacts/<taskId>-<taskTitle>/researcher/research.md` (using `templates.research`)
+   - Cover all mandatory points:
+     - Technical alternatives and relevant APIs
+     - Multi-browser compatibility
+     - Risks and trade-offs
+     - AI-first recommendations
+     - Official or prestigious sources
+   - Hand back control to the `architect-agent` upon completion
+
+4. Request developer approval (MANDATORY, via console)
+   - The developer **MUST** issue a binary decision:
+     - **YES** → Approved
+     - **NO** → Rejected
+   - Record the decision in `research.md` with format:
+     ```yaml
+     approval:
+       developer:
+         decision: YES | NO
+         date: <ISO-8601>
+         comments: <optional>
+     ```
+   - If `decision != YES` → go to **Step 8 (FAIL)**.
+
+5. PASS
+   - Update `.agent/artifacts/<taskId>-<taskTitle>/task.md` (using prefix):
+     - Mark Phase 1 as completed
+     - Set `task.lifecycle.phases.phase-1-research.validated_at = <ISO-8601>`
+     - Update `task.phase.updated_at = <ISO-8601>`
+     - Advance `task.phase.current = aliases.taskcycle-long.phases.phase_2.id`
+
+---
+
+## FAIL (MANDATORY)
+
+8. Declare Phase 1 as **NOT completed**.
+   - Specify exactly what failed.
+   - End blocked: do not advance phase.
+
+---
+
+## Pass
+- All required artifacts are created from templates.
+- Developer approval is recorded where required.
+
+## Gate (REQUIRED)
+
+Requirements (all mandatory):
+1. `.agent/artifacts/<taskId>-<taskTitle>/researcher/research.md` exists.
+2. The report follows the `templates.research` template structure.
+3. The report was created by the `researcher-agent`.
+4. Explicit developer approval is recorded in `research.md`:
+   - `approval.developer.decision == YES`
+5. `task.md` reflects timestamps and state:
+   - `task.phase.current == aliases.taskcycle-long.phases.phase_2.id`
+   - `task.lifecycle.phases.phase-1-research.completed == true`
+   - `task.lifecycle.phases.phase-1-research.validated_at` not null
+   - `task.phase.updated_at` not null
+
+If Gate FAIL:
+- Execute **Step 8 (FAIL)**.

package/dist/workflows/tasklifecycle-long/phase-2-analysis.md

@@ -0,0 +1,136 @@
+---
+id: workflow.tasklifecycle.phase-2-analysis
+description: Task cycle Phase 2. Deep analysis based on previous research, covers acceptance criteria and defines agents, responsibilities, and impact. Requires developer approval.
+owner: architect-agent
+version: 1.1.0
+severity: PERMANENT
+trigger:
+  commands: ["phase2", "phase-2", "analysis"]
+blocking: true
+---
+
+# WORKFLOW: tasklifecycle.phase-2-analysis
+
+## Input (REQUIRED)
+- Current task created in Phase 0 exists:
+  - `.agent/artifacts/<taskId>-<taskTitle>/task.md`
+- Approved research report exists:
+  - `.agent/artifacts/<taskId>-<taskTitle>/researcher/research.md`
+- `task.md` **MUST** include:
+  - Description
+  - Objective
+  - Defined acceptance criteria
+  - `task.phase.current == aliases.taskcycle-long.phases.phase_2.id`
+
+> [!IMPORTANT]
+> **Active Constitution (MANDATORY)**:
+> - Load `constitution.project_architecture` before starting
+> - Load `constitution.agents_behavior` (Section 7: Gates, Section 8: Constitution)
+
+## Output (REQUIRED)
+- Create analysis artifact **based on template**:
+  - `.agent/artifacts/<taskId>-<taskTitle>/analysis.md`
+- Status update in current task:
+  - `.agent/artifacts/<taskId>-<taskTitle>/task.md`
+
+## Objective (ONLY)
+Create a deep **analysis** report that:
+- Covers **all** acceptance criteria from `task.md`
+- Respects project architecture and rules
+- Defines agents, sub-areas, and task impact
+- Identifies if the task requires creating, modifying, or deleting system components
+- Serves as **contractual input** for Phase 3 (Planning)
+
+> This phase **DOES NOT implement code**.
+> This phase **DOES NOT plan detailed execution**.
+> This phase **REQUIRES explicit developer approval**.
+
+## Template (MANDATORY)
+- The report **MUST** be created using the template:
+  - `templates.analysis`
+- If the template doesn't exist or cannot be loaded → **FAIL**.
+
+## Reasoning (MANDATORY)
+- Before executing, the responsible agent must explain to the developer what will be done and why.
+- No document is required for this step.
+
+## Mandatory Steps
+0. **Role Activation and Prefix (MANDATORY)**
+   - The `architect-agent` **MUST** begin its intervention by identifying itself.
+   - Message: `🏛️ **architect-agent**: Starting Phase 2 - Analysis.`
+
+1. Verify inputs
+   - `.agent/artifacts/<taskId>-<taskTitle>/task.md` exists
+   - `.agent/artifacts/<taskId>-<taskTitle>/researcher/research.md` exists
+   - `task.phase.current == aliases.taskcycle-long.phases.phase_2.id`
+   - Research is developer-approved (YES)
+   - If fails → go to **Step 10 (FAIL)**.
+
+2. Load analysis template
+   - Load `templates.analysis`
+   - If it doesn't exist or cannot be read → go to **Step 10 (FAIL)**.
+
+3. Create analysis instance
+   - Copy template to:
+     - `.agent/artifacts/<taskId>-<taskTitle>/analysis.md`
+   - Fill sections according to the specific task.
+
+4. Analyze project state
+   - Review structure, drivers, modules, and previous tasks if applicable.
+   - Document findings in `analysis.md`.
+
+5. Integrate approved research
+   - Base alternatives, risks, and compatibility on `research.md`.
+
+6. Acceptance criteria coverage
+   - Map **every acceptance criteria** to its analysis, verification, and risks.
+
+7. Define agents and sub-areas
+   - List required agents.
+   - Define responsibilities and handoffs.
+
+8. Request developer approval (MANDATORY, via console)
+   - The developer **MUST** issue a binary decision:
+     - **YES** (Approved)
+     - **NO** (Rejected)
+   - Record in `analysis.md`:
+     ```yaml
+     approval:
+       developer:
+         decision: YES | NO
+         date: <ISO-8601>
+         comments: <optional>
+     ```
+   - If `decision != YES` → go to **Step 10 (FAIL)**.
+
+9. PASS
+   - Update `.agent/artifacts/<taskId>-<taskTitle>/task.md` (using prefix):
+     - Mark Phase 2 as completed
+     - Set `task.lifecycle.phases.phase-2-analysis.validated_at = <ISO-8601>`
+     - Update `task.phase.updated_at = <ISO-8601>`
+     - Advance `task.phase.current = aliases.taskcycle-long.phases.phase_3.id`
+
+## FAIL (MANDATORY)
+10. Declare Phase 2 as **NOT completed**.
+    - Specify exactly what failed.
+    - End blocked: do not advance phase.
+
+## Pass
+- All required artifacts are created from templates.
+- Developer approval is recorded where required.
+
+## Gate (REQUIRED)
+Requirements (all mandatory):
+1. `.agent/artifacts/<taskId>-<taskTitle>/analysis.md` exists.
+2. The file follows the `templates.analysis` template structure.
+3. Covers all acceptance criteria from `task.md`.
+4. Explicit developer approval is recorded in `analysis.md`:
+   - `approval.developer.decision == YES`
+5. `task.md` reflects timestamps and state:
+   - `task.phase.current == aliases.taskcycle-long.phases.phase_3.id`
+   - `task.lifecycle.phases.phase-2-analysis.completed == true`
+   - `task.lifecycle.phases.phase-2-analysis.validated_at` not null
+   - `task.phase.updated_at` not null
+
+If Gate FAIL:
+- Execute **Step 10 (FAIL)**.

package/dist/workflows/tasklifecycle-long/phase-3-planning.md

@@ -0,0 +1,121 @@
+---
+id: workflow.tasklifecycle.phase-3-planning
+description: Task cycle Phase 3. Defines the implementation plan based on previous analysis, assigns responsibilities per agent, details testing, demo, estimations, and critical points. Requires explicit developer approval.
+owner: architect-agent
+version: 1.1.0
+severity: PERMANENT
+trigger:
+  commands: ["phase3", "phase-3", "planning", "plan"]
+blocking: true
+---
+
+# WORKFLOW: tasklifecycle.phase-3-planning
+
+## Input (REQUIRED)
+- Analysis artifact created in Phase 2 exists:
+  - `.agent/artifacts/<taskId>-<taskTitle>/analysis.md`
+- Current task exists:
+  - `.agent/artifacts/<taskId>-<taskTitle>/task.md`
+- `task.md` **MUST** reflect:
+  - `task.phase.current == aliases.taskcycle-long.phases.phase_3.id`
+
+> [!IMPORTANT]
+> **Active Constitution (MANDATORY)**:
+> - Load `constitution.project_architecture` before starting
+> - Load `constitution.agents_behavior` (Section 7: Gates, Section 8: Constitution)
+
+## Output (REQUIRED)
+- Create implementation plan:
+  - `.agent/artifacts/<taskId>-<taskTitle>/plan.md`
+- Status update in current task:
+  - `.agent/artifacts/<taskId>-<taskTitle>/task.md`
+
+## Objective (ONLY)
+Create a **detailed implementation plan** to execute the design defined in Phase 2, which:
+- Translates analysis into executable steps
+- Assigns clear responsibilities per agent and rule injection
+- Defines how the task will be validated (tests and verifications)
+
+> This phase **DOES NOT implement code**.
+> This phase **REQUIRES explicit and strict developer approval (YES / NO)**.
+
+## Template (MANDATORY)
+- The plan **MUST** be created using the template:
+  - `templates.planning`
+- If the template doesn't exist or cannot be loaded → **FAIL**.
+
+---
+
+## Reasoning (MANDATORY)
+- Before executing, the responsible agent must explain to the developer what will be done and why.
+- No document is required for this step.
+
+## Mandatory Steps
+
+0. **Role Activation and Prefix (MANDATORY)**
+   - The `architect-agent` **MUST** begin its intervention by identifying itself.
+   - Message: `🏛️ **architect-agent**: Starting Phase 3 - Planning.`
+
+1. Verify inputs
+   - `.agent/artifacts/<taskId>-<taskTitle>/analysis.md` exists
+   - `.agent/artifacts/<taskId>-<taskTitle>/task.md` exists
+   - `task.phase.current == aliases.taskcycle-long.phases.phase_3.id`
+   - If fails → go to **Step 11 (FAIL)**.
+
+2. Load planning template
+   - Load `templates.planning`
+   - If it doesn't exist or cannot be read → go to **Step 11 (FAIL)**.
+
+3. Create plan instance
+   - Copy template to:
+     - `.agent/artifacts/<taskId>-<taskTitle>/plan.md`
+   - Fill all sections using `analysis.md` as a contract.
+
+4. Decompress tasks
+   - Identify every necessary sub-task.
+   - Define responsible agent.
+
+5. Request developer approval (MANDATORY, via console)
+   - The developer **MUST** issue a binary decision:
+     - **YES** (Approved)
+     - **NO** (Rejected)
+   - Record the decision in `plan.md`:
+     ```yaml
+     approval:
+       developer:
+         decision: YES | NO
+         date: <ISO-8601>
+         comments: <optional>
+     ```
+   - If `decision != YES` → go to **Step 11 (FAIL)**.
+
+6. PASS
+   - Update `.agent/artifacts/<taskId>-<taskTitle>/task.md` (using prefix):
+     - Mark Phase 3 as completed
+     - Set `task.lifecycle.phases.phase-3-planning.validated_at = <ISO-8601>`
+     - Update `task.phase.updated_at = <ISO-8601>`
+     - Advance `task.phase.current = aliases.taskcycle-long.phases.phase_4.id`
+
+## FAIL (MANDATORY)
+10. Declare Phase 3 as **NOT completed**.
+    - Specify exactly what failed.
+    - End blocked: do not advance phase.
+
+## Pass
+- All required artifacts are created from templates.
+- Developer approval is recorded where required.
+
+## Gate (REQUIRED)
+Requirements (all mandatory):
+1. `.agent/artifacts/<taskId>-<taskTitle>/plan.md` exists.
+2. The plan follows the `templates.planning` template structure.
+3. Explicit developer approval is recorded in `plan.md`:
+   - `approval.developer.decision == YES`
+4. `task.md` reflects timestamps and state:
+   - `task.phase.current == aliases.taskcycle-long.phases.phase_4.id`
+   - `task.lifecycle.phases.phase-3-planning.completed == true`
+   - `task.lifecycle.phases.phase-3-planning.validated_at` not null
+   - `task.phase.updated_at` not null
+
+If Gate FAIL:
+- Execute **Step 10 (FAIL)**.

package/dist/workflows/tasklifecycle-long/phase-4-implementation.md

@@ -0,0 +1,104 @@
+---
+id: workflow.tasklifecycle.phase-4-implementation
+description: Task cycle Phase 4. Executes implementation through granular task delegation to agents with developer approval Gate for each task. Only proceeds if all tasks are approved.
+owner: architect-agent
+version: 3.1.0
+severity: PERMANENT
+trigger:
+  commands: ["phase4", "phase-4", "implementation", "implement"]
+blocking: true
+---
+
+# WORKFLOW: tasklifecycle.phase-4-implementation
+
+## Input (REQUIRED)
+- Approved implementation plan exists:
+  - `.agent/artifacts/<taskId>-<taskTitle>/plan.md`
+- Current task exists:
+  - `.agent/artifacts/<taskId>-<taskTitle>/task.md`
+- `task.md` **MUST** reflect:
+  - `task.phase.current == aliases.taskcycle-long.phases.phase_4.id`
+
+> [!IMPORTANT]
+> **Active Constitution (MANDATORY)**:
+> - Load `constitution.project_architecture` before starting
+> - Load `constitution.agents_behavior` (Section 7: Gates, Section 8: Constitution)
+
+## Output (REQUIRED)
+- For **each agent task**:
+  - `.agent/artifacts/<taskId>-<taskTitle>/agent-tasks/<N>-<agent>-<taskName>.md`
+- Architect review report:
+  - `.agent/artifacts/<taskId>-<taskTitle>/architect/review.md`
+- Status update in:
+  - `.agent/artifacts/<taskId>-<taskTitle>/task.md`
+
+## Objective (ONLY)
+- Execute **all implementation tasks** defined in the approved plan through **granular delegation**.
+- Each task requires **explicit developer approval** (YES).
+
+---
+
+## Reasoning (MANDATORY)
+- Before executing, the responsible agent must explain to the developer what will be done and why.
+- No document is required for this step.
+
+## Mandatory Steps
+
+0. **Role Activation and Prefix (MANDATORY)**
+   - The `architect-agent` **MUST** begin its intervention by identifying itself.
+   - Message: `🏛️ **architect-agent**: Starting Phase 4 - Implementation.`
+
+1. Verify inputs
+   - Approved `plan.md` exists.
+   - `task.phase.current == aliases.taskcycle-long.phases.phase_4.id`.
+
+2. Extract tasks from plan
+   - Read `plan.md`.
+   - Create directory: `.agent/artifacts/<taskId>-<taskTitle>/agent-tasks/`
+
+3. Delegation Loop (SYNCHRONOUS - AHRP Protocol)
+   For each task `N`:
+   3.1 **Preparation**: Create task file using `templates.agent_task`. Initial status is `blocked`.
+   3.2 **Assignment**: The `architect-agent` presents the task.
+   3.3 **Gate A (Activation)**: The assigned agent must wait for the developer to sign with `decision: YES` in the activation block.
+       - **FORBIDDEN**: The agent cannot use tools until Gate A PASS.
+   3.4 **Gate B (Reasoning)**: Once activated, the agent must present its `Reasoning`.
+       - The developer must sign the reasoning with `decision: YES`.
+       - **FORBIDDEN**: The agent cannot modify code until Gate B PASS.
+   3.5 **Execution**: The agent develops the task following the approved plan.
+   3.6 **Gate C (Results)**: The developer validates the final result with `decision: YES`.
+   3.7 **Closure**: If all gates are PASS, mark as `completed` and update `task.md`.
+
+4. Implementation Consolidation
+   - Verify that all tasks have complied with the AHRP protocol (A, B, and C).
+
+5. Create Architectural Review Report (MANDATORY)
+   - Create: `.agent/artifacts/<taskId>-<taskTitle>/architect/review.md` (using `templates.review`).
+
+6. Final Developer Gate (MANDATORY, via console)
+   - Global confirmation with **YES**.
+   - Record in `architect/review.md`: `decision: YES`.
+
+7. PASS
+   - Update `.agent/artifacts/<taskId>-<taskTitle>/task.md` (using prefix):
+     - Mark Phase 4 as completed
+     - Set `task.lifecycle.phases.phase-4-implementation.validated_at = <ISO-8601>`
+     - Update `task.phase.updated_at = <ISO-8601>`
+     - Advance to Phase 5.
+
+## Pass
+- All required artifacts are created from templates.
+- Developer approval is recorded where required.
+
+## Gate (REQUIRED)
+Requirements (all mandatory):
+1. All tasks have Gate PASS (`approval.developer.decision == YES`).
+2. `architect/review.md` exists with final Gate PASS (YES).
+3. `task.md` reflects timestamps and state:
+   - `task.phase.current == aliases.taskcycle-long.phases.phase_5.id`
+   - `task.lifecycle.phases.phase-4-implementation.completed == true`
+   - `task.lifecycle.phases.phase-4-implementation.validated_at` not null
+   - `task.phase.updated_at` not null
+
+If Gate FAIL:
+- Execute **FAIL**.