@liriraid/agentflow-ai 1.0.25 → 1.0.26

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
 // ============================================================================
@@ -1178,6 +1183,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 +1230,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 +1289,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 +1297,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 {
@@ -2062,92 +2085,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liriraid/agentflow-ai",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "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",

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/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:
@@ -160,11 +177,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 +220,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/ORCHESTRATOR.md

@@ -180,11 +180,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 +199,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
@@ -218,10 +223,11 @@ Revisa `orchestrator.config.json` → `agents`. Cada entrada tiene:
 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`.
 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.