@liriraid/agentflow-ai 1.0.25 → 1.0.27

package/orchestrator.js

@@ -9,12 +9,17 @@
 const blessed = require("blessed");
 const { spawn } = require("child_process");
 const fs = require("fs");
+const os = require("os");
 const path = require("path");
 
 const WORKSPACE = process.env.ORCHESTRATOR_WORKSPACE
   ? path.resolve(process.env.ORCHESTRATOR_WORKSPACE)
   : path.resolve(process.cwd());
 
+// Global supply chain — the user's ~/.claude dir (rules, skills, CLAUDE.md, etc.)
+// Worker agents are given access to this dir so they follow the same standards as Claude.
+const GLOBAL_CLAUDE_DIR = path.join(os.homedir(), ".claude");
+
 // ============================================================================
 // CONFIGURATION — loaded from orchestrator.config.json
 // ============================================================================
@@ -1008,35 +1013,6 @@ function parseCompletedFromFile() {
 }
 
 const loggedUnknownAgents = new Set();
-let queueWatcher = null;
-
-function setupQueueWatcher() {
-  if (!fs.existsSync(QUEUE_FILE)) return;
-  
-  if (queueWatcher) {
-    try { queueWatcher.close(); } catch {}
-    queueWatcher = null;
-  }
-  
-  try {
-    queueWatcher = fs.watch(QUEUE_FILE, { persistent: false }, (eventType, filename) => {
-      if (eventType === 'change' && filename === path.basename(QUEUE_FILE)) {
-        log('DEBUG', `QUEUE.md changed, reloading queue immediately`);
-        reloadQueue();
-        scheduleNext();
-        renderDashboard();
-      }
-    });
-    queueWatcher.on('error', (err) => {
-      log('WARN', `fs.watch failed for QUEUE.md: ${err.message}, falling back to polling`);
-      queueWatcher = null;
-    });
-    log('INFO', 'Realtime QUEUE.md watcher enabled');
-  } catch (err) {
-    log('WARN', `Failed to setup QUEUE.md watcher: ${err.message}, using polling`);
-    queueWatcher = null;
-  }
-}
 
 function reloadQueue() {
   state.queue = parseQueue();
@@ -1178,6 +1154,14 @@ function generateBrief(task) {
     if (taskMatch) taskEntry = taskMatch[0];
   }
 
+  // Global developer standards — read the user's ~/.claude/CLAUDE.md verbatim.
+  // Each developer has their own standards there; we don't parse specific sections.
+  let globalStandards = "";
+  const globalClaude = path.join(GLOBAL_CLAUDE_DIR, "CLAUDE.md");
+  if (fs.existsSync(globalClaude)) {
+    globalStandards = fs.readFileSync(globalClaude, "utf-8").trim();
+  }
+
   // Project plan — if `<projectName>-plan.md` or `PLAN.md` exists in the workspace,
   // inject it as shared context so every agent sees the big-picture plan.
   let projectPlan = "";
@@ -1217,7 +1201,9 @@ function generateBrief(task) {
 # Priority: ${task.priority}
 # Workspace: ${WORKSPACE}
 # Progress file: ${progressFile}
+# Global supply chain: ${GLOBAL_CLAUDE_DIR}
 
+${globalStandards ? `## Global Developer Standards\n> Extracted from ${globalClaude} — apply these rules to ALL code in this task.\n\n${globalStandards}\n` : ""}
 ${projectPlan ? `## Project Plan (big picture — use as context, don't try to do everything)\n${projectPlan}\n` : ""}
 ${agentInstructions ? `## Agent Instructions\n${agentInstructions}` : ""}
 ${protocolRules ? `## Protocol Rules\n${protocolRules}` : ""}
@@ -1274,6 +1260,7 @@ function buildCliCommand(agentCfg, task, prompt) {
           ...(agentCfg.model ? ["--model", agentCfg.model] : []),
           "--add-dir",
           WORKSPACE,
+          ...(fs.existsSync(GLOBAL_CLAUDE_DIR) ? ["--add-dir", GLOBAL_CLAUDE_DIR] : []),
           "--name",
           `${task.agent}-${task.id}`,
         ],
@@ -1281,7 +1268,14 @@ function buildCliCommand(agentCfg, task, prompt) {
     case "codex":
       return {
         cmd: "codex",
-        args: ["exec", "--yolo", "--add-dir", WORKSPACE, "-"],
+        args: [
+          "exec",
+          "--yolo",
+          "--add-dir",
+          WORKSPACE,
+          ...(fs.existsSync(GLOBAL_CLAUDE_DIR) ? ["--add-dir", GLOBAL_CLAUDE_DIR] : []),
+          "-",
+        ],
       };
     case "opencode":
       return {
@@ -1421,7 +1415,7 @@ function launchAgent(task) {
                 if (txt) {
                   for (const l of txt.split("\n").slice(-3))
                     appendToAgent(agentName, l.slice(0, 120));
-                  ag.lastLine = txt.split("\n").pop().slice(0, 80);
+                  ag.lastLine = (txt.split("\n").pop() || "").slice(0, 80);
                 }
               }
               if (block.type === "tool_use") {
@@ -1685,6 +1679,7 @@ function failTask(task, agentName, code) {
     task.status = "failed";
     ag.lastLine = L.lastFailed(task.id);
     log("ERROR", L.logPermanentFail(task.id, retries));
+    updateQueueFile(task);
     writeNotifyFile(L.notifyPermanentFail(timestamp(), task.id, agentName));
   } else {
     task.status = "pending";
@@ -1870,6 +1865,7 @@ function getClaudeFallbackAgent(task) {
 
 function getAlternativeSupportAgent(failedAgentName) {
   if (failedAgentName === "OpenCode") return "Codex";
+  if (failedAgentName === "Codex") return "OpenCode";
   return null;
 }
 
@@ -1907,45 +1903,9 @@ function tryFallbackToAlternative(task, failedAgentName, reason) {
     log("WARN", L.logReassignWarn(task.id, targetAgent));
   }
 
-  // Notificar a Claude (sesión principal) cuando hay fallback
-  notifyClaudeOfFallback(task, failedAgentName, targetAgent, reason);
   return true;
 }
 
-// ============================================================================
-// CLAUDE FALLBACK NOTIFIER — avisa a Claude principal cuando hay reasignación
-// ============================================================================
-function notifyClaudeOfFallback(task, fromAgent, toAgent, reason) {
-  const lang = WORKSPACE_LANGUAGE;
-  const prompt = lang === 'es'
-    ? `⚠️ FALLBACK: La tarea "${task.id}: ${task.title}" falló en ${fromAgent} (${reason}) y fue reasignada a ${toAgent}.
-
-Estado actual:
-- QUEUE.md tiene ahora la tarea asignada a ${toAgent}
-- El agente ${toAgent} está procediendo automáticamente
-
- Acción: No necesitas hacer nada — solo toma nota del cambio. El orquestador将继续 automáticamente.
-Si quieres revisar el progreso, lee INBOX.md o STATUS.md.`
-    : `⚠️ FALLBACK: Task "${task.id}: ${task.title}" failed on ${fromAgent} (${reason}) and was reassigned to ${toAgent}.
-
-Current state:
-- QUEUE.md now has the task assigned to ${toAgent}
-- Agent ${toAgent} is proceeding automatically
-
-Action: You don't need to do anything — just take note of the change. The orchestrator will continue automatically.
-If you want to check progress, read INBOX.md or STATUS.md.`;
-
-  const logPath = path.join(LOG_DIR, `fallback-notify-${Date.now()}.log`);
-  try {
-    const logFd = fs.openSync(logPath, 'a');
-    const child = spawn('claude', ['-p', prompt, '--add-dir', WORKSPACE, '--dangerously-skip-permissions'], {
-      cwd: WORKSPACE, stdio: ['ignore', logFd, logFd], shell: true, windowsHide: true, detached: true
-    });
-    fs.closeSync(logFd);
-    child.unref();
-  } catch {}
-}
-
 // ============================================================================
 // KEYBOARD
 // ============================================================================
@@ -2050,7 +2010,6 @@ function setupFallbackQueueWatcher() {
 }
 
 startQueueWatcher();
-setupQueueWatcher();
 
 // Slow fallback (5 min) — only runs if there is actually pending work or busy agents
 // fs.watch handles real-time; this is just a safety net
@@ -2062,92 +2021,12 @@ setInterval(() => {
   renderDashboard();
 }, 5 * 60 * 1000);
 
-// ============================================================================
-// INBOX WATCHER — reacts immediately when a task completion is written to INBOX.md
-// Spawns headless Claude to check if a new implementation task needs to be created
-// ============================================================================
-let _inboxDebounce = null;
-let _lastInboxContent = '';
-let _inboxDispatching = false;
-
-function dispatchInboxClaude() {
-  if (_inboxDispatching) return;
-  let content = '';
-  try { content = fs.existsSync(INBOX_FILE) ? fs.readFileSync(INBOX_FILE, 'utf-8') : ''; } catch {}
-  if (!content.trim() || content === _lastInboxContent) return;
-
-  _lastInboxContent = content;
-  _inboxDispatching = true;
-
-  const lang = WORKSPACE_LANGUAGE;
-  const prompt = lang === 'es'
-    ? `Eres el orquestador de este workspace. Tu única misión ahora es procesar el INBOX.
-
-Pasos:
-1. Lee INBOX.md en ${WORKSPACE}
-2. Lee QUEUE.md en ${WORKSPACE} para ver las tareas existentes (secciones Pendientes, En progreso, Completadas)
-
-Si en INBOX.md hay análisis completados de un agente (especialmente OpenCode) que aún NO tienen su tarea de implementación en la sección ## Pendientes de QUEUE.md:
-- Determina el siguiente TASK ID disponible leyendo QUEUE.md
-- Crea la nueva TASK en QUEUE.md con el formato exacto:
-  TASK-NNN | título corto | Codex | P1 | repo | descripción basada en el análisis
-
-Si ya existe la tarea correspondiente, o el análisis no está completo, responde solo: "Sin acción necesaria."
-
-Reglas: No hagas commit ni push. No analices código del proyecto. Solo lee INBOX.md y QUEUE.md, y edita QUEUE.md si hace falta.`
-    : `You are the orchestrator for this workspace. Your only mission now is to process the INBOX.
-
-Steps:
-1. Read INBOX.md in ${WORKSPACE}
-2. Read QUEUE.md in ${WORKSPACE} to see existing tasks (sections Pending, In Progress, Completed)
-
-If INBOX.md contains completed analyses from an agent (especially OpenCode) that do NOT yet have a corresponding implementation task in the ## Pending section of QUEUE.md:
-- Determine the next available TASK ID by reading QUEUE.md
-- Create the new TASK in QUEUE.md with the exact format:
-  TASK-NNN | short title | Codex | P1 | repo | description based on the analysis
-
-If the corresponding task already exists, or the analysis is not complete, reply only: "No action needed."
-
-Rules: Do not commit or push. Do not analyze project code. Only read INBOX.md and QUEUE.md, and edit QUEUE.md if necessary.`;
-
-  const logPath = path.join(LOG_DIR, `inbox-trigger-${Date.now()}.log`);
-  try {
-    const logFd = fs.openSync(logPath, 'a');
-    const child = spawn('claude', [
-      '-p', prompt,
-      '--add-dir', WORKSPACE,
-      '--dangerously-skip-permissions'
-    ], {
-      cwd: WORKSPACE,
-      stdio: ['ignore', logFd, logFd],
-      shell: true,
-      windowsHide: true,
-      detached: true
-    });
-    fs.closeSync(logFd);
-    child.unref();
-    log('INFO', lang === 'es'
-      ? 'INBOX: Claude despachado para procesar notificación'
-      : 'INBOX: Claude dispatched to process notification');
-  } catch {}
-  setTimeout(() => { _inboxDispatching = false; }, 3 * 60 * 1000);
-}
-
-function startInboxWatcher() {
-  if (!fs.existsSync(INBOX_FILE)) {
-    try { fs.writeFileSync(INBOX_FILE, '', 'utf-8'); } catch {}
-  }
-  try {
-    const watchName = path.basename(INBOX_FILE);
-    const watcher = fs.watch(WORKSPACE, {persistent: false}, (eventType, filename) => {
-      if (filename !== watchName) return;
-      if (_inboxDebounce) clearTimeout(_inboxDebounce);
-      _inboxDebounce = setTimeout(dispatchInboxClaude, 100);
-    });
-    watcher.on('error', () => {});
-  } catch {}
+// INBOX.md initialization — create empty file if it doesn't exist so the
+// Claude session can watch it. Notifications are delivered via NOTIFY.md +
+// the asyncRewake hook in .claude/settings.json (watch-notify.js).
+if (!fs.existsSync(INBOX_FILE)) {
+  try { fs.writeFileSync(INBOX_FILE, '', 'utf-8'); } catch {}
 }
-startInboxWatcher();
 
 // ============================================================================
 // AWAY MODE WATCHER — monitors .away-mode file; when active runs periodic
@@ -2169,7 +2048,7 @@ function runAwayModeCheck() {
   const completedCount = (state.completed || []).length;
   const hasWork = pendingTasks.length > 0 || inProgressTasks.length > 0 || busy;
 
-  if (!hasWork && completedCount > 0) {
+  if (!hasWork) {
     try { fs.unlinkSync(AWAY_MODE_FILE); } catch {}
     deactivateAwayMode();
 

package/package.json

@@ -1,65 +1,64 @@
-{
-  "name": "@liriraid/agentflow-ai",
-  "version": "1.0.25",
-  "description": "Multi-agent workspace orchestrator with TUI. Coordinates AI coding agents over your real frontend and backend projects.",
-  "author": "LiriRaid",
-  "homepage": "https://github.com/LiriRaid/agentflow-ai#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/LiriRaid/agentflow-ai.git"
-  },
-  "bugs": {
-    "url": "https://github.com/LiriRaid/agentflow-ai/issues"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "main": "orchestrator.js",
-  "bin": {
-    "agentflow": "bin/agentflow.mjs"
-  },
-  "files": [
-    "bin",
-    "src",
-    "templates",
-    "orchestrator.js",
-    "LICENSE",
-    "README.md"
-  ],
-  "packageManager": "pnpm@11.6.0",
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "scripts": {
-    "start": "node orchestrator.js",
-    "start:paused": "node orchestrator.js --paused",
-    "start:ink": "node src/ink/index.mjs",
-    "start:ink:paused": "node src/ink/index.mjs --paused",
-    "cli:help": "node bin/agentflow.mjs --help"
-  },
-  "keywords": [
-    "ai",
-    "agents",
-    "orchestrator",
-    "agentflow-ai",
-    "claude",
-    "codex",
-    "gemini",
-    "cursor",
-    "opencode",
-    "abacus",
-    "tui",
-    "multi-agent",
-    "coding-assistant",
-    "openspec",
-    "engram",
-    "skills",
-    "agent-config"
-  ],
-  "license": "MIT",
-  "dependencies": {
-    "blessed": "^0.1.81",
-    "ink": "^5.2.1",
-    "react": "^18.3.1"
-  }
-}
+{
+  "name": "@liriraid/agentflow-ai",
+  "version": "1.0.27",
+  "description": "Multi-agent workspace orchestrator with TUI. Coordinates AI coding agents over your real frontend and backend projects.",
+  "author": "LiriRaid",
+  "homepage": "https://github.com/LiriRaid/agentflow-ai#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LiriRaid/agentflow-ai.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LiriRaid/agentflow-ai/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "orchestrator.js",
+  "bin": {
+    "agentflow": "bin/agentflow.mjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "templates",
+    "orchestrator.js",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "orchestrator",
+    "agentflow-ai",
+    "claude",
+    "codex",
+    "gemini",
+    "cursor",
+    "opencode",
+    "abacus",
+    "tui",
+    "multi-agent",
+    "coding-assistant",
+    "openspec",
+    "engram",
+    "skills",
+    "agent-config"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "blessed": "^0.1.81",
+    "ink": "^5.2.1",
+    "react": "^18.3.1"
+  },
+  "scripts": {
+    "start": "node orchestrator.js",
+    "start:paused": "node orchestrator.js --paused",
+    "start:ink": "node src/ink/index.mjs",
+    "start:ink:paused": "node src/ink/index.mjs --paused",
+    "cli:help": "node bin/agentflow.mjs --help"
+  }
+}

package/templates/en/.claude/hooks/watch-notify.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+'use strict';
+// Background watcher for NOTIFY.md (asyncRewake hook).
+// Launched on every Stop event. Polls until NOTIFY.md appears, then
+// exits with code 2 to wake the Claude session with the notification.
+// If .away-mode exists, exits immediately — Away Mode handles monitoring.
+const fs = require('fs');
+const path = require('path');
+
+const cwd = process.cwd();
+const notifyFile = path.join(cwd, 'NOTIFY.md');
+const awayFile = path.join(cwd, '.away-mode');
+
+if (fs.existsSync(awayFile)) process.exit(0);
+if (fs.existsSync(notifyFile)) deliver();
+
+const POLL_MS = 10_000;
+const MAX_MS  = 30 * 60_000;
+const start   = Date.now();
+
+const timer = setInterval(() => {
+  if (fs.existsSync(awayFile)) { clearInterval(timer); process.exit(0); }
+  if (Date.now() - start > MAX_MS) { clearInterval(timer); process.exit(0); }
+  if (fs.existsSync(notifyFile)) { clearInterval(timer); deliver(); }
+}, POLL_MS);
+
+function deliver() {
+  const content = fs.readFileSync(notifyFile, 'utf8').trim();
+  try { fs.unlinkSync(notifyFile); } catch {}
+  if (!content) process.exit(0);
+  process.stdout.write('\n' + content + '\n');
+  process.exit(2);
+}

package/templates/en/.claude/settings.json

@@ -6,6 +6,11 @@
           {
             "type": "command",
             "command": "node .claude/hooks/notify-check.js"
+          },
+          {
+            "type": "command",
+            "command": "node .claude/hooks/watch-notify.js",
+            "asyncRewake": true
           }
         ]
       }

package/templates/en/.claude/skills/orchestrator-explore/SKILL.md

@@ -16,7 +16,7 @@ Gather useful context before creating TASKs or OpenSpec artifacts.
 
 ## Critical Rules
 
-- Understand the user's exact scope first.
+- Understand the user's exact scope first — clarify by asking the user directly, **NOT by reading project files yourself**.
 - Prefer exploration before implementation when context is unclear.
 - Use **ONLY OpenCode** as the exploration agent when deep codebase analysis is needed — its role is **EXCLUSIVELY analysis**, **NEVER implementation**.
 - When delegating exploration to OpenCode, include in the brief exactly what it must report: flows, dependencies, architecture findings, inconsistencies, etc.

package/templates/en/ORCHESTRATOR.md

@@ -47,6 +47,23 @@ The TUI handles automatic fallback: Codex fails → Claude-Worker directly. You
 
 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.
 
+### Parallel Execution Rule
+
+**Never queue all tasks behind one OpenCode analysis if context already exists.**
+
+When multiple tasks arrive:
+
+- **Check context first**: Are there existing OpenCode reports in `progress/PROGRESS-OpenCode.md` or `INBOX.md` for the area being touched? Is this a long session where the codebase is already well understood?
+- **If context is sufficient** → assign all implementation tasks directly to Codex (and Claude-Worker for overflow) in parallel. Do NOT send them to OpenCode first.
+- **If context is missing for a specific area** → send ONE task to OpenCode for that area. Assign all other independent tasks to Codex in parallel — do not make them wait.
+- **Never serialize work that can run in parallel.** If 5 tasks are independent and context is clear, all 5 go out at once to available agents.
+
+**When is context "sufficient"?**
+- OpenCode already reported on this area in the current session.
+- The task is a direct follow-up to a completed task (same files, same pattern).
+- The user explicitly defined what to change (specific files, keys, values) — no exploration needed.
+- Similar tasks were already completed successfully in this session.
+
 ## This Workspace Is NOT the Real Project
 
 This directory (`orchestrator-<name>`) exists **only** for work management:
@@ -57,7 +74,7 @@ This directory (`orchestrator-<name>`) exists **only** for work management:
 - `logs/` — agent output
 
 The real project code lives at the paths defined in `orchestrator.config.json → repos`.
-When you need to understand the project in order to plan tasks, **read files from those paths**.
+**Do NOT read real project code files to understand the project.** If codebase analysis is needed to plan tasks, delegate it to OpenCode via a TASK in `QUEUE.md` — that is what OpenCode is for.
 **Never modify real project files directly** — that is exclusively the workers' job.
 
 ## Startup Checklist
@@ -119,14 +136,16 @@ del .away-mode
 
 ## Fallback Policy
 
-The TUI handles fallback automatically following this chain:
+The TUI handles fallback automatically following these chains:
 
+**By failure:**
 ```
-Codex fails → OpenCode → Frontend (frontend repo) or Backend (backend repo)
-```
-Codex fails  →  Frontend (frontend repo) or Backend (backend repo) directly
+OpenCode fails → Codex → Claude-Worker (Frontend/Backend)
+Codex fails    → OpenCode → Claude-Worker (Frontend/Backend)
 ```
 
+**By availability (when assigning new tasks):** Claude-Orchestrator should check `STATUS.md` before writing to `QUEUE.md`. If the primary agent for a task is already busy or rate-limited, assign directly to the next available idle agent in the chain rather than queuing behind a busy one.
+
 As Orchestrator you do **not** need to manually reassign on failure — the TUI does it. Your role is:
 
 1. Check `INBOX.md` or `QUEUE.md` to confirm the fallback ran correctly.
@@ -160,11 +179,12 @@ Default agent summary:
 ## How To Assign Work
 
 1. **When the user asks for a change or new task** → **NEVER analyze directly yourself**
-- **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)
+- **If context already exists** (OpenCode reports from this session, completed similar tasks, user-specified exact changes): **skip OpenCode** and create implementation TASKs directly assigned to **Codex** or **Claude-Worker**. Assign all independent tasks in parallel.
+- **If prior analysis is needed** (new area, unknown structure, no prior report): Create ONE TASK in `QUEUE.md` assigned to **OpenCode** for that area. Assign all other independent tasks to Codex in parallel — do not make them wait for OpenCode.
+- **Wait for the OpenCode report only for the tasks that depend on it**: OpenCode writes findings to `progress/PROGRESS-OpenCode.md` and notifies in `INBOX.md`
+- **Then implement the dependent task**: **READ OPENCODE'S REPORT** and create the implementation TASK assigned to **Codex**
 - **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.
+- **NEVER analyze the project code yourself (Claude-Orchestrator)** — use OpenCode for that. If a report already exists, **USE THAT CONTEXT** directly.
 
 2. Write TASKs in `QUEUE.md` with this format:
 
@@ -202,10 +222,11 @@ 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.
+11. **MANDATORY VERIFICATION:** Before creating implementation TASKs, confirm one of:
+   - There is an OpenCode report in `INBOX.md` or `progress/PROGRESS-OpenCode.md` covering the area, OR
+   - The user provided explicit enough detail (exact files, values, changes) that no exploration is needed, OR
+   - Similar work was already completed this session (context is already established).
+   - **YOU (Claude-Orchestrator) HAVE NOT** analyzed the code yourself in any case.
 
 ## TUI Controls
 

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

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+'use strict';
+// Watcher en background para NOTIFY.md (hook asyncRewake).
+// Se lanza en cada evento Stop. Espera hasta que aparezca NOTIFY.md y
+// sale con código 2 para despertar la sesión de Claude con la notificación.
+// Si existe .away-mode, sale inmediatamente — el Away Mode maneja el monitoreo.
+const fs = require('fs');
+const path = require('path');
+
+const cwd = process.cwd();
+const notifyFile = path.join(cwd, 'NOTIFY.md');
+const awayFile = path.join(cwd, '.away-mode');
+
+if (fs.existsSync(awayFile)) process.exit(0);
+if (fs.existsSync(notifyFile)) deliver();
+
+const POLL_MS = 10_000;
+const MAX_MS  = 30 * 60_000;
+const start   = Date.now();
+
+const timer = setInterval(() => {
+  if (fs.existsSync(awayFile)) { clearInterval(timer); process.exit(0); }
+  if (Date.now() - start > MAX_MS) { clearInterval(timer); process.exit(0); }
+  if (fs.existsSync(notifyFile)) { clearInterval(timer); deliver(); }
+}, POLL_MS);
+
+function deliver() {
+  const content = fs.readFileSync(notifyFile, 'utf8').trim();
+  try { fs.unlinkSync(notifyFile); } catch {}
+  if (!content) process.exit(0);
+  process.stdout.write('\n' + content + '\n');
+  process.exit(2);
+}

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

@@ -6,6 +6,11 @@
           {
             "type": "command",
             "command": "node .claude/hooks/notify-check.js"
+          },
+          {
+            "type": "command",
+            "command": "node .claude/hooks/watch-notify.js",
+            "asyncRewake": true
           }
         ]
       }

package/templates/es/.claude/skills/orchestrator-explore/SKILL.md

@@ -17,7 +17,7 @@ Guiar la fase de exploración del orquestador para reunir contexto útil antes d
 
 ## Reglas críticas
 
-- Empieza por entender el alcance exacto del pedido del usuario.
+- Empieza por entender el alcance exacto del pedido del usuario — acláralo preguntándole directamente, **NO leyendo archivos del proyecto tú mismo**.
 - Si hace falta lectura amplia, prioriza exploración y análisis antes de planear implementación.
 - Usa **SOLO OpenCode** como agente de exploración cuando necesites análisis profundo del codebase — su rol es **EXCLUSIVAMENTE análisis**, **NUNCA implementación**.
 - Al delegar exploración a OpenCode, incluye en el brief exactamente qué debe reportar: flujos, dependencias, hallazgos de arquitectura, inconsistencias, etc.

package/templates/es/ORCHESTRATOR.md

@@ -38,7 +38,7 @@ Este directorio (`orchestrator-<nombre>`) existe **únicamente** para gestión d
 - `logs/` — salida de los agentes
 
 El código real del proyecto vive en las rutas definidas en `orchestrator.config.json → repos`.
-Cuando necesites entender el proyecto para planificar tareas, **lee archivos desde esas rutas**.
+**NO leas archivos de código del proyecto real para planificar tareas.** Si necesitas análisis del codebase para crear TASKs, delégalo a OpenCode mediante una TASK en `QUEUE.md` — para eso existe OpenCode.
 **Nunca modifiques archivos del proyecto real directamente** — eso es trabajo exclusivo de los agentes workers.
 
 ## Al iniciar la sesión — OBLIGATORIO
@@ -132,14 +132,16 @@ del .away-mode
 
 ### Fallback por cuota o indisponibilidad
 
-La TUI gestiona el fallback automáticamente siguiendo esta cadena:
+La TUI gestiona el fallback automáticamente siguiendo estas cadenas:
 
+**Por fallo:**
 ```
-Codex falla → OpenCode → Frontend (repo FE) o Backend (repo BE)
-```
-Codex falla  →  Frontend (repo FE) o Backend (repo BE) directamente
+OpenCode falla → Codex → Claude-Worker (Frontend/Backend)
+Codex falla    → OpenCode → Claude-Worker (Frontend/Backend)
 ```
 
+**Por disponibilidad (al asignar tareas nuevas):** Claude-Orquestador debe revisar `STATUS.md` antes de escribir en `QUEUE.md`. Si el agente primario para una tarea ya está ocupado o tiene rate limit, asigna directamente al siguiente agente idle en la cadena en lugar de dejar la tarea esperando detrás de uno ocupado.
+
 Como Orquestador, **no necesitas reasignar manualmente** cuando hay un fallo — la TUI lo hace sola. Tu rol en este caso es:
 
 1. Verificar en `INBOX.md` o `QUEUE.md` que el fallback se ejecutó correctamente.
@@ -180,11 +182,12 @@ Revisa `orchestrator.config.json` → `agents`. Cada entrada tiene:
 ## Cómo asignar trabajo
 
 1. **Cuando el usuario pide un cambio o nueva tarea** → **NUNCA analices directamente**
-- **Si necesita análisis previo**: Crea una TASK en `QUEUE.md` asignada **EXCLUSIVAMENTE** a **OpenCode** para que explore el contexto
-- **Espera el reporte**: OpenCode escribe hallazgos en `progress/PROGRESS-OpenCode.md` y notifica en `INBOX.md`
-- **Luego implementa**: **LEE EL REPORTE DE OPENCODE** en `progress/PROGRESS-OpenCode.md` o `INBOX.md` y crea nueva TASK asignada a **Codex** (o Claude-Worker si Codex no está disponible)
+- **Si ya existe contexto suficiente** (reportes de OpenCode de esta sesión, tareas similares ya completadas, cambios que el usuario especificó exactamente): **omite OpenCode** y crea TASKs de implementación directamente asignadas a **Codex** o **Claude-Worker**. Asigna todas las tareas independientes en paralelo.
+- **Si se necesita análisis previo** (área nueva, estructura desconocida, sin reporte previo): Crea UNA TASK asignada a **OpenCode** para esa área. Asigna todas las demás tareas independientes a Codex en paralelo — no las hagas esperar a OpenCode.
+- **Espera el reporte de OpenCode solo para las tareas que dependen de él**: OpenCode escribe hallazgos en `progress/PROGRESS-OpenCode.md` y notifica en `INBOX.md`
+- **Luego implementa la tarea dependiente**: **LEE EL REPORTE DE OPENCODE** y crea la TASK de implementación asignada a **Codex**
 - **OpenCode NO implementa** — sus TASKs son **SOLO de análisis**; la implementación **SIEMPRE** va a Codex o Claude-Worker
-- **NUNCA, bajo ninguna circunstancia, analices el código del proyecto directamente tú mismo (Claude-Orquestador)** — **ESO ES TRABAJO EXCLUSIVO DE OPENCODE**. Si ya existe un reporte de OpenCode, **USA ESE CONTEXTO** para crear tareas de implementación.
+- **NUNCA analices el código del proyecto tú mismo (Claude-Orquestador)** — usa OpenCode para eso. Si ya existe un reporte, **USA ESE CONTEXTO** directamente.
 
 2. Escribe TASKs en `QUEUE.md` (formato pipe; la TUI lo lee):
     ```
@@ -198,12 +201,16 @@ Revisa `orchestrator.config.json` → `agents`. Cada entrada tiene:
 6. **La TUI inicia automáticamente** - NO necesitas presionar R ni S. La TUI detecta nuevas tasks y las lanza.
 7. **Codex es la primera opción para implementación; OpenCode es la segunda opción.** Claude-Worker es el fallback automático de Codex/OpenCode y también toma trabajo cuando hay más tareas que agentes disponibles.
 8. **REGLA CRÍTICA SOBRE ANÁLISIS:** Si OpenCode ya analizó algo y escribió su reporte en `INBOX.md` o `progress/PROGRESS-OpenCode.md`, **TÚ (Claude-Orquestador) NO DEBES VOLVER A ANALIZAR EL MISMO CÓDIGO**. Usa el reporte existente para crear tareas de implementación. Si necesitas más detalles, pide a OpenCode que haga un análisis adicional con una nueva TASK, pero **NUNCA lo hagas tú directamente**.
-9. Distribución según cantidad de TASKs independientes:
-   - **1 tarea de análisis**: OpenCode.
-   - **1 tarea de implementación**: Codex. Nunca Claude-Worker en primera instancia.
-   - **2 tareas paralelas**: OpenCode (análisis) + Codex (implementación si la spec está clara).
-   - **3+ tareas** y Codex ocupado: el excedente va a `Frontend` (repo FE) o `Backend` (repo BE) según corresponda.
-8. Si hay más TASKs que agentes disponibles, deja el resto en cola con dependencias claras o prioridad menor; no uses Gemini, Cursor ni Abacus salvo permiso explícito.
+9. **Regla de ejecución en paralelo — nunca serialices lo que puede correr en paralelo:**
+   - **Si el contexto ya existe**: asigna todas las tareas independientes en paralelo a Codex y Claude-Worker a la vez. No las pongas en cola una por una.
+   - **Si falta contexto para un área**: manda UNA TASK a OpenCode para esa área. Las demás tareas independientes van a Codex en paralelo — no esperan a OpenCode.
+   - **Distribución por volumen:**
+     - 1 tarea de análisis → OpenCode
+     - 1 tarea de implementación → Codex
+     - 2 tareas paralelas → OpenCode (análisis) + Codex (implementación con spec clara)
+     - 3+ tareas independientes con contexto claro → Codex + Frontend/Backend en paralelo
+   - **¿Cuándo el contexto es suficiente?** OpenCode ya reportó sobre esa área en esta sesión / el usuario especificó exactamente qué cambiar / tareas similares ya se completaron esta sesión.
+10. Si hay más TASKs que agentes disponibles, deja el resto en cola con dependencias claras o prioridad menor; no uses Gemini, Cursor ni Abacus salvo permiso explícito.
 9. El campo `repo` determina en qué directorio trabaja el agente. Usa siempre el valor correcto: `frontend` para trabajo de UI/cliente, `backend` para trabajo de API/servidor. Codex y OpenCode pueden trabajar en ambos repos según lo que indique la task.
 
 ## Reglas
@@ -216,12 +223,13 @@ Revisa `orchestrator.config.json` → `agents`. Cada entrada tiene:
 6. Al terminar la sesión, escribe un `handoffs/HANDOFF-<fecha>.md` resumiendo qué se hizo y qué sigue.
 7. **Por defecto solo usa Claude, Codex y OpenCode**. No uses Gemini, Cursor ni Abacus salvo instrucción explícita del usuario.
 8. Si el usuario activa **Modo Ausencia**, revisa progreso cada 5 minutos y reasigna nuevas TASKs razonables dentro del alcance actual sin esperar confirmación intermedia.
-9. La TUI gestiona el fallback automáticamente: Codex falla → OpenCode → Claude-Worker (Frontend/Backend según repo). Solo intervén manualmente si la tarea queda marcada `failed`.
+9. La TUI gestiona el fallback automáticamente: OpenCode falla → Codex → Claude-Worker; Codex falla → OpenCode → Claude-Worker. Solo intervén manualmente si la tarea queda marcada `failed`.
 10. Usa Engram para guardar decisiones, hallazgos, bugs y resúmenes de sesión; no dependas solo del contexto corto de la conversación.
-11. **VERIFICACIÓN OBLIGATORIA:** Antes de crear cualquier TASK de implementación, **LEE Y CONFIRMA QUE:**
-   - Existe un reporte de OpenCode en `INBOX.md` o `progress/PROGRESS-OpenCode.md` para el análisis solicitado.
-   - La TASK de implementación se basa **EXCLUSIVAMENTE** en el reporte de OpenCode.
-   - **NO** has analizado el código tú mismo (Claude-Orquestador).
+11. **VERIFICACIÓN OBLIGATORIA:** Antes de crear TASKs de implementación, confirma una de estas condiciones:
+   - Existe un reporte de OpenCode en `INBOX.md` o `progress/PROGRESS-OpenCode.md` que cubre el área, O
+   - El usuario especificó con suficiente detalle qué cambiar (archivos exactos, valores, cambios concretos), O
+   - Trabajo similar ya se completó esta sesión (el contexto ya está establecido).
+   - **NO** has analizado el código tú mismo (Claude-Orquestador) en ningún caso.
 11. Para cambios grandes, usa `openspec/changes/<change-name>/` para proposal, spec, design, tasks y verify; no dejes todo solo en la conversación.
 12. No asumas bypass total o autoaceptación de cambios en los agentes. Claude debe seguir siendo la autoridad final para validar el resultado esperado antes de que el usuario dé la aprobación definitiva.