@liriraid/agentflow-ai 1.0.19 → 1.0.21

package/templates/en/AGENT-CONFIG.md

@@ -52,7 +52,8 @@ Default routing should put executable work on Codex or OpenCode first when they
 ## Initial Convention
 
 - `claude` is the primary profile.
-- `codex` and `opencode` are support profiles.
+- `codex` is the primary implementation profile
+- `opencode` is a support profile that **can implement code when using advanced models** (e.g., Mistral Medium 3.5 128B)
 - Other profiles can exist while remaining disabled by default.
 
 ## Suggested Local Folders
@@ -71,5 +72,5 @@ If both global and local agent configuration exist, the local project config sho
 
 - Claude uses `.claude/skills/` as the main project skill base.
 - Codex and OpenCode can have their own local config even if they do not use the same skill model today.
-- OpenCode can explore, audit, and implement when the TASK is clear.
+- OpenCode can explore, audit, and **implement code when using advanced models** like Mistral Medium 3.5 128B.
 - The design should allow richer local layers for additional agents later.

package/templates/en/ORCHESTRATOR.md

@@ -36,12 +36,14 @@ When the user requests work after startup:
 
 1. Do not implement the work in the interactive Claude session.
 2. Convert the request into one or more TASKs in `QUEUE.md`.
-3. Always assign first to `OpenCode` (exploration) and `Codex` (implementation).
+3. Assign by role:
+   - `OpenCode` → **analysis only** (exploration, audits, reports — does NOT modify code)
+   - `Codex` → **primary implementation** (code changes, tests, docs)
 4. Assign a Claude-Worker (`Frontend` or `Backend`) **only** when:
-   - **Multiple independent tasks exist** AND Codex + OpenCode are both already occupied, OR
-   - A task has **permanently failed** in Codex AND OpenCode — then Claude-Worker takes it as last resort.
+   - **Multiple independent tasks exist** AND Codex is already occupied, OR
+   - A task has **permanently failed** in Codex — then Claude-Worker takes it as last resort.
 
-The TUI handles automatic fallback: Codex fails → tries OpenCode → tries Claude-Worker. You only need to manually assign Claude-Workers for load balancing (case a) or when the TUI marks a task as permanently `failed` (case b).
+The TUI handles automatic fallback: Codex fails → Claude-Worker directly. You only need to manually assign Claude-Workers for load balancing (case a) or when the TUI marks a task as permanently `failed` (case b).
 
 The `repo` field determines the working directory: `frontend` for UI/client work, `backend` for API/server work. Codex and OpenCode can work in either repo depending on the task.
 
@@ -120,9 +122,9 @@ del .away-mode
 The TUI handles fallback automatically following this chain:
 
 ```
-Codex fails  →  tries OpenCode (if idle and not rate-limited)
-                    ↓ (if OpenCode also fails or is blocked)
-             →  Frontend (frontend repo) or Backend (backend repo) as last resort
+Codex fails → OpenCode (with Mistral Medium 3.5 128B) → Frontend (frontend repo) or Backend (backend repo)
+```
+Codex fails  →  Frontend (frontend repo) or Backend (backend repo) directly
 ```
 
 As Orchestrator you do **not** need to manually reassign on failure — the TUI does it. Your role is:
@@ -146,19 +148,24 @@ Default agent summary:
 | --- | --- | --- |
 | Backend | claude | Backend code through Claude-Worker |
 | Frontend | claude | Broad frontend work through Claude-Worker |
-| Codex | codex | Structured implementation, tests, docs, narrow frontend support |
-| OpenCode | opencode | Exploration, audits, structured reports, scoped implementation |
+| Codex | codex | **First choice for implementation**; structured implementation, tests, docs, narrow frontend support |
+| OpenCode | opencode | **Second choice for implementation** (with Mistral Medium 3.5 128B); exploration, audits, structured reports |
 | Gemini | gemini | Optional audits and reviews only when explicitly enabled |
 | Cursor | cursor | Optional mechanical bulk edits only when explicitly enabled |
 | Abacus | abacusai | Optional small focused tasks only when explicitly enabled |
 
+**Notes about OpenCode:**
+- When OpenCode uses **Mistral Medium 3.5 128B or equivalent models**, it can implement code.
+- If the model is not suitable for implementation, OpenCode will only perform analysis and report as `blocked`.
+
 ## How To Assign Work
 
 1. **When the user asks for a change or new task** → **NEVER analyze directly yourself**
-   - **First**: Create a TASK in `QUEUE.md` assigned to **OpenCode** to analyze the context
-   - **Second**: Wait for OpenCode to finish its analysis (check INBOX.md or progress/)
-   - **Third**: You receive the analysis → create new TASK to implement (Codex or OpenCode)
-   - **Never analyze the project code yourself** - that's OpenCode's job
+- **If prior analysis is needed**: Create a TASK in `QUEUE.md` assigned **EXCLUSIVELY** to **OpenCode** to explore the context
+- **Wait for the report**: OpenCode writes findings to `progress/PROGRESS-OpenCode.md` and notifies in `INBOX.md`
+- **Then implement**: **READ OPENCODE'S REPORT** in `progress/PROGRESS-OpenCode.md` or `INBOX.md` and create new TASK assigned to **Codex** (or Claude-Worker if Codex is unavailable)
+- **OpenCode DOES NOT implement** — its TASKs are **ONLY for analysis**; implementation **ALWAYS** goes to Codex or Claude-Worker
+- **NEVER, under any circumstances, analyze the project code yourself (Claude-Orchestrator)** — **THIS IS OPENCODE'S EXCLUSIVE JOB**. If a report from OpenCode already exists, **USE THAT CONTEXT** to create implementation tasks.
 
 2. Write TASKs in `QUEUE.md` with this format:
 
@@ -177,11 +184,12 @@ Rules:
 
 Routing preferences:
 
-1. Start with Codex/OpenCode when a task is clear enough for them.
-2. Keep Claude-Worker available as fallback or extra capacity.
-3. For frontend, use Codex for narrow tasks and Frontend/Claude-Worker for broad UI or complex interaction work.
-4. Use OpenCode for exploration, audits, and scoped implementation.
-5. Do not assign all tasks to Claude just because Claude is the orchestrator.
+1. Use OpenCode for exploration, audits, and **implementation (with Mistral Medium 3.5 128B or advanced models)**.
+2. Use Codex as the **primary implementation agent** when the spec is clear.
+3. Use OpenCode as the **secondary implementation agent** (when using advanced models).
+4. Keep Claude-Worker available as automatic fallback for Codex/OpenCode and for overflow tasks.
+5. For frontend, use Codex for narrow tasks and Frontend/Claude-Worker for broad UI work.
+6. Do not assign all tasks to Claude just because Claude is the orchestrator.
 
 ## Hard Rules
 
@@ -195,6 +203,10 @@ Routing preferences:
 8. Use Engram for durable decisions, bugs, discoveries, and session summaries.
 9. Use `openspec/changes/<change-name>/` for large changes.
 10. Claude remains the final reviewer before work is considered accepted.
+11. **MANDATORY VERIFICATION:** Before creating any implementation TASK, **READ AND CONFIRM THAT:**
+   - There is an OpenCode report in `INBOX.md` or `progress/PROGRESS-OpenCode.md` for the requested analysis.
+   - The implementation TASK is based **EXCLUSIVELY** on OpenCode's report.
+   - **YOU (Claude-Orchestrator) HAVE NOT** analyzed the code yourself.
 
 ## TUI Controls
 

package/templates/en/README.md

@@ -1,83 +1,89 @@
-# agentflow
+# agentflow-ai
 
-A reusable multi-agent workspace for coordinating coding agents around a real project without placing orchestrator files inside the product repository.
+**Multi-Agent Orchestration System for AI-Powered Development**
 
-The orchestrator lives next to the real project:
+A reusable workspace orchestrator that coordinates multiple AI coding agents to work **in parallel** on real projects, while keeping the project repository **completely clean** of orchestrator files.
 
 ```text
 project-workspace/
-  RealProject/
-  orchestrator-realproject/
+  my-project/          # Real project (stays clean)
+  orchestrator-my-project/  # Orchestrator workspace (generated)
 ```
 
-The real project stays clean. The orchestrator workspace keeps queue, docs, skills, OpenSpec artifacts, memory conventions, logs, and handoffs.
-
-## What It Does
-
-- Starts a TUI dashboard for live agent execution.
-- Uses `QUEUE.md` as the executable task queue.
-- Lets Claude act as orchestrator and final reviewer.
-- Runs Codex, OpenCode, and Claude-Workers as implementation agents.
-- Keeps project memory and handoffs outside the deliverable repo.
-- Supports OpenSpec-style proposal, spec, design, tasks, verify, and archive artifacts.
-- Allows one orchestrator workspace per client or product.
-
-## Core Rule
-
-Claude-Orchestrator must not implement project work directly.
-
-When the user asks for work, Claude should:
-
-1. Read context.
-2. Split the request into TASKs.
-3. Write those TASKs to `QUEUE.md`.
-4. Let the TUI launch the workers.
-5. Review the results.
-
-Implementation should go through worker agents unless the user explicitly overrides this rule.
-
-## Default Agents
-
-| Agent | CLI | Default Role |
-| --- | --- | --- |
-| Codex | `codex` | Structured implementation, tests, docs, narrow frontend support |
-| OpenCode | `opencode` | Exploration, audits, reports, scoped implementation |
-| Backend | `claude` | Claude-Worker for backend work, fallback, and extra capacity |
-| Frontend | `claude` | Claude-Worker for broad frontend work, fallback, and extra capacity |
-
-Gemini, Cursor, and Abacus can remain configured but are disabled operationally unless the user enables them for a session.
-
-## Install
-
+## 🎯 What It Does
+
+- **Coordinates multiple AI agents** (Claude, Codex, OpenCode, etc.) to work simultaneously on your project.
+- **Real-time monitoring** with a modern TUI (Terminal User Interface) that shows live agent status, queue, and progress.
+- **Automatic task delegation** based on agent specialization (analysis, implementation, code review).
+- **Persistent memory** using Engram to maintain context across sessions.
+- **Spec-Driven Development (SDD)** support with OpenSpec for large, multi-phase changes.
+- **Fallback system** that automatically reassigns tasks when an agent fails or reaches rate limits.
+- **Multi-language support** (English and Spanish) for all templates and documentation.
+
+## ✨ Key Features
+
+### 1. **Sibling Workspace Model**
+- The orchestrator creates a **separate workspace** next to your real project.
+- Your project repository **stays completely clean** (no `QUEUE.md`, `logs/`, or orchestrator files).
+- Agents work on the real project files via absolute paths configured in `orchestrator.config.json`.
+
+### 2. **Multi-Agent Coordination**
+| Agent | CLI | Default Model | Implementation? | Notes |
+|-------|-----|----------------|----------------|-------|
+| **Claude-Orchestrator** | - | - | ❌ No | Session coordinator only |
+| **Codex** | `codex` | gpt-5.5 | ✅ Yes | Primary implementation |
+| **OpenCode** | `opencode` | auto | ✅ **Yes** (with Mistral Medium 3.5 128B) | Secondary implementation |
+| **Claude-Worker** (Backend/Frontend) | `claude` | sonnet | ✅ Yes | Fallback implementation |
+| **Gemini** | `gemini` | auto | ❌ No | Audits/reviews only |
+| **Cursor** | `cursor` | auto | ❌ No | Bulk edits only |
+| **Abacus** | `abacusai` | auto | ❌ No | Small focused tasks |
+
+### 3. **Real-Time Operation**
+- **fs.watch on QUEUE.md**: Detects changes in **~1-2 seconds** (Linux/macOS: direct file watch; Windows: directory watch fallback).
+- **Live TUI updates**: The dashboard refreshes automatically when tasks are added, started, or completed.
+- **Instant notifications**: Claude-Orchestrator receives alerts in `INBOX.md` and `NOTIFY.md` when tasks finish.
+
+### 4. **Smart Task Delegation**
+- **Analysis tasks** → Always assigned to **OpenCode**.
+- **Implementation tasks** → Assigned to **Codex** (1st) → **OpenCode** (2nd, if using Mistral Medium 3.5 128B) → **Claude-Worker** (3rd).
+- **Fallback chain**: `Codex → OpenCode → Claude-Worker` (automatic).
+
+### 5. **Persistent Memory & SDD**
+- **Engram**: Stores decisions, bugs, and findings across sessions.
+- **OpenSpec**: Supports `proposal.md`, `spec.md`, `design.md`, `tasks.md`, and `verify-report.md` for large changes.
+- **Handoffs**: Session summaries for continuity.
+
+## 🚀 Installation
+
+### Global CLI (Recommended)
 ```bash
 npm i -g @liriraid/agentflow-ai
 ```
 
-## Create A Workspace
-
+### Local Development
 ```bash
-agentflow init-workspace C:/code/my-project
+git clone https://github.com/LiriRaid/agentflow-ai.git
+cd agentflow-ai
+npm install
 ```
 
-If no language is passed, the CLI asks whether to generate the workspace in **EN** or **ES**. You can also pass it directly:
+## 🛠️ Quick Start
 
+### 1. Create an Orchestrator Workspace
 ```bash
-agentflow init-workspace C:/code/my-project --lang en
-agentflow init-workspace C:/code/my-project --lang es
-```
+# Interactive (asks for language)
+agentflow init-workspace C:/code/my-project
 
-This creates a sibling workspace:
+# Direct (English)
+agentflow init-workspace C:/code/my-project --lang en
 
-```text
-C:/code/
-  my-project/
-  orchestrator-my-project/
+# Direct (Spanish)
+agentflow init-workspace C:/code/my-project --lang es
 ```
+This creates a sibling workspace (e.g., `orchestrator-my-project/`) with all configuration files.
 
-## Configure Repos
-
-Edit `orchestrator.config.json`:
-
+### 2. Configure Repositories
+Edit `orchestrator.config.json` in the generated workspace:
 ```json
 {
   "repos": {
@@ -87,102 +93,141 @@ Edit `orchestrator.config.json`:
 }
 ```
 
-If the project only has frontend for now, both keys can temporarily point to the same repo. Update `backend` later when the backend exists.
-
-## Start The System
-
-Open one terminal in the orchestrator workspace:
-
+### 3. Start the TUI
 ```bash
-cd C:/code/orchestrator-my-project
-agentflow ink
+cd orchestrator-my-project
+agentflow ink --paused
 ```
-
-Open another terminal in the same orchestrator workspace:
-
+**Controls:**
+- `S`: Start/Resume
+- `P`: Pause
+- `R`: Reload queue
+- `Q`: Quit (stops all agents)
+
+### 4. Launch Claude Code
+Open a second terminal in the **orchestrator workspace** (not the real project):
 ```bash
-cd C:/code/orchestrator-my-project
+cd orchestrator-my-project
 claude
 ```
-
-Tell Claude:
-
-```text
+Then run:
+```
 Read ORCHESTRATOR.md and start.
 ```
 
-Claude should read the workspace context and become the orchestrator. It should not implement the first user request directly.
-
-## Normal Workflow
+### 5. Request Work
+Examples:
+- `"Explore this project"` → OpenCode analyzes and reports.
+- `"Add JWT authentication"` → OpenCode analyzes, then Codex/OpenCode implement.
+- `"Refactor the API layer"` → OpenCode explores, then workers implement in parallel.
 
-1. User asks Claude-Orchestrator for a change.
-2. Claude reads the relevant project context.
-3. Claude creates TASKs in `QUEUE.md`.
-4. User presses `R` in the TUI to reload the queue.
-5. User presses `S` if the TUI is paused.
-6. The TUI launches workers.
-7. Workers report `TASK_REPORT`.
-8. Claude-Orchestrator reviews the output and plans the next batch.
-
-## Queue Format
-
-```text
-TASK-NNN | short title | Agent | P1 | repo | detailed description
-```
+## 📁 Workspace Structure
 
-Example:
+The generated workspace includes:
 
 ```text
-TASK-004 | Audit current frontend routing | OpenCode | P1 | frontend | Inspect route structure and report risks
-TASK-005 | Add inbox empty-state test | Codex | P1 | frontend | Add a narrow test for the empty inbox state
-TASK-006 | Implement inbox layout polish | Frontend | P1 | frontend | Update the main inbox layout after TASK-004 findings > after:TASK-004
+orchestrator-my-project/
+├── ORCHESTRATOR.md      # Core rules for the orchestrator session
+├── CLAUDE.md            # Routing rules for Claude
+├── QUEUE.md             # Active task queue (TASK-NNN | title | agent | ...)
+├── ENGRAM.md            # Persistent memory conventions
+├── orchestrator.config.json  # Repos, agents, models, and profiles
+├── agents/              # Agent-specific instructions
+│   ├── BACKEND.md
+│   ├── FRONTEND.md
+│   ├── CODEX.md
+│   └── OPENCODE.md
+├── .claude/             # Local Claude skills and config
+│   └── skills/          # Orchestrator skills (init, explore, etc.)
+├── .codex/              # Codex config
+├── .opencode/           # OpenCode config
+├── openspec/            # SDD artifacts
+│   ├── changes/
+│   └── templates/
+├── docs/                # Documentation
+├── logs/                # Execution logs
+├── handoffs/            # Session handoffs
+└── progress/            # Agent progress reports
 ```
 
-## Routing Policy
-
-- Start executable work with Codex or OpenCode when suitable.
-- Use Claude-Worker for fallback, extra capacity, broad implementation, or sensitive tasks.
-- For frontend, Codex should handle narrow and verifiable tasks; Frontend/Claude-Worker should own broad UI work.
-- OpenCode can audit, explore, and implement scoped tasks.
-- Do not send all work to Claude just because Claude is the orchestrator.
-
-## Models
-
-The default config can specify models per agent:
+## 🎛️ Configuration
 
+### Agent Configuration (`orchestrator.config.json`)
 ```json
 {
+  "projectName": "My Project",
+  "workspaceLanguage": "en",
+  "maxConcurrent": 5,
+  "pollIntervalSeconds": 5,  // Fallback polling (realtime uses fs.watch)
+  "taskTimeoutMinutes": 30,
+  "repos": {
+    "backend": "C:/code/my-backend",
+    "frontend": "C:/code/my-frontend"
+  },
+  "agentProfiles": {
+    "claude": { "enabled": true, "localConfigDir": ".claude" },
+    "codex": { "enabled": true, "localConfigDir": ".codex" },
+    "opencode": { "enabled": true, "localConfigDir": ".opencode" }
+  },
   "agents": {
-    "Backend": { "cli": "claude", "model": "sonnet" },
-    "Frontend": { "cli": "claude", "model": "sonnet" },
-    "Codex": { "cli": "codex", "model": "gpt-5.5" },
-    "OpenCode": { "cli": "opencode", "model": "opencode/glm-5-free" }
+    "Backend": { "cli": "claude", "defaultRepo": "backend", "model": "sonnet" },
+    "Frontend": { "cli": "claude", "defaultRepo": "frontend", "model": "sonnet" },
+    "Codex": { "cli": "codex", "defaultRepo": "backend", "model": "gpt-5.5" },
+    "OpenCode": { "cli": "opencode", "defaultRepo": "frontend", "model": "auto" }
   }
 }
 ```
 
-## TUI Controls
-
-- `R`: reload `QUEUE.md`
-- `S`: start or resume
-- `P`: pause
-- `Q`: quit and stop agents
-
-## Local Files
-
-- `ORCHESTRATOR.md`: core session rules
-- `CLAUDE.md`: Claude routing
-- `QUEUE.md`: active queue
-- `orchestrator.config.json`: repos, agents, models
-- `agents/*.md`: worker instructions
-- `.claude/skills/`: local skills
-- `openspec/`: durable change artifacts
-- `ENGRAM.md`: memory conventions
-- `docs/`: reusable documentation
-
-## Safety
-
-- No worker commits or pushes by default.
-- No bypass or YOLO mode unless the user starts the TUI with that intent.
-- Claude remains the final reviewer before work is accepted.
-- Customer/product repos stay clean because the orchestrator workspace is separate.
+### Model Selection
+- Use `"model": "auto"` to let the agent use your default configured model (e.g., Mistral Medium 3.5 128B for OpenCode).
+- Specify a model explicitly (e.g., `"model": "gpt-5.5"`) to override.
+
+## 🔄 Workflow Example
+
+1. **User Request**: `"Add JWT authentication to the backend."`
+2. **Claude-Orchestrator**:
+   - Creates `TASK-001` (OpenCode): `"Analyze current auth system"`
+   - Waits for OpenCode's report in `progress/PROGRESS-OpenCode.md`
+3. **OpenCode**:
+   - Analyzes the codebase.
+   - Writes findings to `progress/PROGRESS-OpenCode.md` and `INBOX.md`.
+4. **Claude-Orchestrator**:
+   - Reads OpenCode's report.
+   - Creates `TASK-002` (Codex): `"Implement JWT auth"` (depends on TASK-001).
+5. **Codex/OpenCode**:
+   - Implements the feature (Codex first, OpenCode second if using Mistral Medium 3.5 128B).
+   - Reports completion in `progress/PROGRESS-*.md`.
+6. **TUI**:
+   - Shows real-time updates (task status, agent activity, costs).
+
+## 📊 Supported Agents & Models
+
+| Agent | CLI | Default Model | Implementation? | Notes |
+|-------|-----|----------------|----------------|-------|
+| Backend | `claude` | sonnet | ✅ Yes | Claude-Worker for backend tasks |
+| Frontend | `claude` | sonnet | ✅ Yes | Claude-Worker for frontend tasks |
+| Codex | `codex` | gpt-5.5 | ✅ Yes | Primary implementation |
+| OpenCode | `opencode` | auto | ✅ **Yes** (with Mistral Medium 3.5 128B) | Secondary implementation |
+| Gemini | `gemini` | auto | ❌ No | Audits/reviews only |
+| Cursor | `cursor` | auto | ❌ No | Bulk edits only |
+| Abacus | `abacusai` | auto | ❌ No | Small focused tasks |
+
+## 🛡️ Safety & Best Practices
+
+- **No auto-commits**: Agents never run `git commit` or `git push`.
+- **No YOLO by default**: Safe permissions mode is enabled unless `--yolo` is used.
+- **Claude as reviewer**: Claude-Orchestrator validates all work before user approval.
+- **Clean repos**: Project files stay untouched; orchestrator files live in the sibling workspace.
+- **Fallback safety**: Tasks are automatically reassigned if an agent fails.
+
+## 📚 Documentation
+
+- **Core Rules**: See `ORCHESTRATOR.md` in the generated workspace.
+- **Agent Routing**: See `CLAUDE.md`.
+- **Architecture**: See `docs/architecture.md`.
+- **OpenSpec**: See `openspec/FLOW.md`.
+
+## 🤝 Acknowledgements
+
+Inspired by [Orquestador-AI](https://github.com/ariellontero/Orquestador-AI) by Ariel Lontero (MIT). 
+Built from scratch with a modern architecture: **Ink TUI + React, npm package, real-time fs.watch, multi-language templates, and multi-agent coordination**.

package/templates/en/agents/OPENCODE.md

@@ -2,40 +2,85 @@
 
 ## Role
 
-OpenCode is used for exploration, context reading, audits, structured reports, and scoped implementation.
-
-It is not only an auditor. If the TASK asks for implementation and the scope is clear, make concrete code changes.
+OpenCode is a **multi-purpose agent** that can perform **analysis, exploration AND CODE IMPLEMENTATION**. 
+When using powerful models like **Mistral Medium 3.5 128B**, OpenCode is capable of:
+- Analyzing existing code
+- Implementing new features
+- Fixing complex bugs
+- Refactoring code
 
 ## Scope
 
-- codebase audits
-- context exploration
-- smoke tests
-- endpoint verification
-- structured Markdown reports
-- scoped implementation
-- small or medium refactors
-- tests and technical docs
+### Analysis (Always available)
+- Codebase audits
+- Flow and architecture exploration
+- Context reading before implementation
+- Read-only smoke tests
+- Structured Markdown reports
+- Identifying dead code, missing dependencies, inconsistencies
+
+### Implementation (With advanced models like Mistral Medium 3.5 128B)
+- Implementing new features
+- Modifying project files
+- Writing new tests
+- Refactoring code
+- Fixing bugs
 
-## Rules
+## General Rules
 
 1. Do not commit or push.
-2. Keep findings structured and actionable.
-3. Use Markdown tables for audit findings when useful.
-4. If implementing, leave the result ready for Claude-Orchestrator review.
-5. Do not stay in analysis mode when the TASK explicitly asks for implementation.
+2. If the task is **analysis**: deliver findings in Markdown tables and write the report in `progress/PROGRESS-OpenCode.md`
+3. If the task is **implementation**: modify the necessary files and document the changes
+4. Always deliver a TASK_REPORT at the end
+
+## Assignment Priority
+
+- **First choice for implementation**: Codex (when available)
+- **Second choice for implementation**: OpenCode (with Mistral Medium 3.5 128B or equivalent models)
+- **Third choice**: Claude-Worker (Backend/Frontend)
+
+## Model-Specific Behavior
 
-## Completion Report
+### With analysis models (e.g., small models or low-context):
+- **Analysis only**: Do not implement code
+- Report in TASK_REPORT: `status: blocked`, `issues: "Model not suitable for implementation — reassign to Codex or Claude-Worker"`
 
-Always finish with:
+### With implementation models (e.g., Mistral Medium 3.5 128B, GPT-4, etc.):
+- **You CAN implement code** when the task is clearly defined
+- Ensure that any required prior analysis is already complete
+- Follow the same quality rules as Codex
 
-```text
+## Completion Report (REQUIRED)
+
+### For analysis tasks:
+```
+TASK_REPORT
+status: completed | failed | blocked
+files_modified: none
+files_created: none
+files_deleted: none
+summary: 1-3 sentences describing findings
+issues: problems or "none"
+TASK_REPORT_END
+```
+
+### For implementation tasks:
+```
+TASK_REPORT
+status: completed | failed | blocked
+files_modified: ["src/file1.js", "src/file2.ts"]
+files_created: ["src/new-file.js"]
+files_deleted: ["src/old-file.js"]
+summary: 1-3 sentences describing the changes made
+issues: problems or "none"
+TASK_REPORT_END
+```
 TASK_REPORT
 status: completed | failed | blocked
-files_modified: list or "none"
-files_created: list or "none"
-files_deleted: list or "none"
-summary: 1-3 sentences
+files_modified: none
+files_created: none
+files_deleted: none
+summary: 1-3 sentences describing findings
 issues: problems or "none"
 TASK_REPORT_END
 ```

package/templates/es/.claude/hooks/notify-check.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+'use strict';
+// Lee NOTIFY.md del workspace y vuelca el contenido a stdout para que
+// el hook de Claude Code lo inyecte en la sesión interactiva.
+// El archivo se elimina después de leerse para no repetir la notificación.
+const fs = require('fs');
+const path = require('path');
+
+const notifyFile = path.join(process.cwd(), 'NOTIFY.md');
+if (!fs.existsSync(notifyFile)) process.exit(0);
+
+const content = fs.readFileSync(notifyFile, 'utf8').trim();
+if (!content) {
+  try { fs.unlinkSync(notifyFile); } catch {}
+  process.exit(0);
+}
+
+try { fs.unlinkSync(notifyFile); } catch {}
+
+process.stdout.write('\n' + content + '\n');

package/templates/es/.claude/settings.json

@@ -0,0 +1,24 @@
+{
+  "hooks": {
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/notify-check.js"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/notify-check.js"
+          }
+        ]
+      }
+    ]
+  }
+}