@liriraid/agentflow-ai 1.0.14 → 1.0.15

package/scripts/auto-trigger.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+// ============================================================================
+// Auto-trigger script - Ejecutar cada 60 segundos desde Windows Task Scheduler
+// Detecta nuevo contenido en INBOX.md y dispara Claude headless para procesarlo
+// ============================================================================
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const WORKSPACE = process.env.ORCHESTRATOR_WORKSPACE || process.cwd();
+const INBOX_FILE = path.join(WORKSPACE, 'INBOX.md');
+const QUEUE_FILE = path.join(WORKSPACE, 'QUEUE.md');
+const LAST_CHECK_FILE = path.join(WORKSPACE, 'logs', 'last-auto-check.json');
+
+function timestamp() {
+  return new Date().toISOString().replace('T', ' ').slice(0, 19);
+}
+
+function detectLanguage() {
+  if (!fs.existsSync(QUEUE_FILE)) return 'en';
+  try {
+    const content = fs.readFileSync(QUEUE_FILE, 'utf-8');
+    return (content.includes('## Pendientes') || content.includes('## Completadas')) ? 'es' : 'en';
+  } catch { return 'en'; }
+}
+
+const lang = detectLanguage();
+
+// Leer último hash guardado
+let lastCheck = { time: 0, inboxHash: '' };
+try {
+  if (fs.existsSync(LAST_CHECK_FILE)) {
+    lastCheck = JSON.parse(fs.readFileSync(LAST_CHECK_FILE, 'utf-8'));
+  }
+} catch {}
+
+// Leer INBOX actual
+let inboxContent = '';
+let currentHash = '';
+try {
+  if (fs.existsSync(INBOX_FILE)) {
+    inboxContent = fs.readFileSync(INBOX_FILE, 'utf-8');
+    currentHash = inboxContent.slice(0, 500);
+  }
+} catch {}
+
+// Si no hay contenido o no cambió, salir
+if (!inboxContent.trim() || currentHash === lastCheck.inboxHash) {
+  console.log(`[${timestamp()}] Sin cambios en INBOX. Nada que procesar.`);
+  process.exit(0);
+}
+
+console.log(`[${timestamp()}] Nuevo contenido en INBOX detectado — disparando Claude...`);
+
+// Guardar hash para no relanzar en el próximo ciclo de 60s
+lastCheck = { time: Date.now(), inboxHash: currentHash };
+fs.mkdirSync(path.dirname(LAST_CHECK_FILE), { recursive: true });
+fs.writeFileSync(LAST_CHECK_FILE, JSON.stringify(lastCheck), 'utf-8');
+
+// Prompt para Claude headless — lee INBOX y crea la task de implementación si aplica
+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 claude = spawn('claude', [
+  '-p', prompt,
+  '--add-dir', WORKSPACE,
+  '--dangerously-skip-permissions'
+], {
+  cwd: WORKSPACE,
+  stdio: ['ignore', 'pipe', 'pipe'],
+  shell: true
+});
+
+let output = '';
+claude.stdout.on('data', d => { output += d.toString(); });
+claude.stderr.on('data', d => { process.stderr.write(d); });
+
+claude.on('close', code => {
+  const result = output.trim().slice(0, 300);
+  console.log(`[${timestamp()}] Claude completó (exit ${code}): ${result}`);
+});
+
+claude.on('error', err => {
+  console.error(`[${timestamp()}] Error al lanzar Claude: ${err.message}`);
+  process.exit(1);
+});

package/scripts/monitor-check.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+// ============================================================================
+// Monitor script - Ejecutar cada 5 minutos desde Windows Task Scheduler
+// SOLO corre cuando Modo Ausencia está activado (.away-mode existe)
+// En cada revisión manda un prompt a Claude para que monitoree y tome decisiones
+// ============================================================================
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const WORKSPACE = process.env.ORCHESTRATOR_WORKSPACE || process.cwd();
+const QUEUE_FILE = path.join(WORKSPACE, 'QUEUE.md');
+const INBOX_FILE = path.join(WORKSPACE, 'INBOX.md');
+const STATE_FILE = path.join(WORKSPACE, 'logs', 'orchestrator-state.json');
+const ACTIONS_FILE = path.join(WORKSPACE, 'ACTIONS.md');
+const AWAY_MODE_FILE = path.join(WORKSPACE, '.away-mode');
+
+// Si Away Mode no está activado, salir inmediatamente
+if (!fs.existsSync(AWAY_MODE_FILE)) {
+  console.log('Monitor: Away Mode no activado. Saltando.');
+  process.exit(0);
+}
+
+function timestamp() {
+  return new Date().toISOString().replace('T', ' ').slice(0, 19);
+}
+
+function detectLanguage() {
+  if (!fs.existsSync(QUEUE_FILE)) return 'en';
+  try {
+    const content = fs.readFileSync(QUEUE_FILE, 'utf-8');
+    return (content.includes('## Pendientes') || content.includes('## Completadas')) ? 'es' : 'en';
+  } catch { return 'en'; }
+}
+
+const lang = detectLanguage();
+
+function readQueue() {
+  if (!fs.existsSync(QUEUE_FILE)) return { pending: [], inProgress: [], completed: [] };
+  const result = { pending: [], inProgress: [], completed: [] };
+  let section = '';
+  for (const line of fs.readFileSync(QUEUE_FILE, 'utf-8').split('\n')) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('## Pending') || trimmed.startsWith('## Pendientes')) { section = 'pending'; continue; }
+    if (trimmed.startsWith('## In Progress') || trimmed.startsWith('## En progreso')) { section = 'inProgress'; continue; }
+    if (trimmed.startsWith('## Completed') || trimmed.startsWith('## Completadas')) { section = 'completed'; continue; }
+    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('>')) continue;
+    if (section && trimmed.includes('|')) result[section].push(trimmed);
+  }
+  return result;
+}
+
+function readState() {
+  if (!fs.existsSync(STATE_FILE)) return null;
+  try { return JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8')); }
+  catch { return null; }
+}
+
+function launchClaude(prompt) {
+  const claude = spawn('claude', [
+    '-p', prompt,
+    '--add-dir', WORKSPACE,
+    '--dangerously-skip-permissions'
+  ], {
+    cwd: WORKSPACE,
+    stdio: 'inherit',
+    shell: true
+  });
+  claude.on('error', err => console.error(`[${timestamp()}] Error lanzando Claude: ${err.message}`));
+  return claude;
+}
+
+// ============================================================================
+// RECOPILAR ESTADO ACTUAL
+// ============================================================================
+const queue = readQueue();
+const state = readState();
+
+const busyAgents = Object.values(state?.agents || {}).filter(a => a.status === 'busy').length;
+const failedAgents = Object.entries(state?.agents || {})
+  .filter(([, ag]) => (ag.lastLine || '').startsWith('FALLÓ:') || (ag.lastLine || '').startsWith('FAILED:'))
+  .map(([name, ag]) => `${name}: ${ag.lastLine}`);
+const retryingAgents = Object.entries(state?.agents || {})
+  .filter(([, ag]) => {
+    const ll = ag.lastLine || '';
+    return ll.startsWith('REINTENTO:') || ll.startsWith('LÍMITE:') || ll.startsWith('RETRY:');
+  })
+  .map(([name, ag]) => `${name}: ${ag.lastLine}`);
+
+const hasWork = queue.pending.length > 0 || (state?.inProgress?.length || 0) > 0 || busyAgents > 0;
+
+console.log(`[${timestamp()}] Monitor Modo Ausencia:`);
+console.log(`  Pendientes: ${queue.pending.length} | En progreso: ${state?.inProgress?.length || 0} | Completadas: ${queue.completed.length}`);
+console.log(`  Agentes ocupados: ${busyAgents} | Fallidos: ${failedAgents.length} | Reintentando: ${retryingAgents.length}`);
+
+// ============================================================================
+// SI NO HAY TRABAJO → DESACTIVAR Y DAR RESUMEN FINAL
+// ============================================================================
+if (!hasWork && queue.completed.length > 0) {
+  console.log(`  -> Sin trabajo pendiente. Desactivando Modo Ausencia.`);
+
+  try { fs.unlinkSync(AWAY_MODE_FILE); } catch {}
+  try { if (fs.existsSync(ACTIONS_FILE)) fs.unlinkSync(ACTIONS_FILE); } catch {}
+
+  const donePrompt = lang === 'es'
+    ? `Modo Ausencia terminado. Todas las tareas se completaron mientras estabas ausente.
+
+Lee QUEUE.md en ${WORKSPACE} y dame un resumen de todo lo que se logró durante la sesión.
+Luego dime si hay algo que podamos continuar o integrar a partir de lo que ya se hizo, o pregúntame qué quiero priorizar a continuación.`
+    : `Away Mode ended. All tasks were completed while you were away.
+
+Read QUEUE.md in ${WORKSPACE} and give me a summary of everything accomplished during the session.
+Then tell me if there is anything we can continue or integrate from what was done, or ask me what I want to prioritize next.`;
+
+  launchClaude(donePrompt);
+  process.exit(0);
+}
+
+// ============================================================================
+// HAY TRABAJO → MANDAR PROMPT A CLAUDE PARA QUE MONITOREE Y TOME DECISIONES
+// ============================================================================
+
+// Construir contexto de estado para incluir en el prompt
+const stateLines = [];
+if (queue.pending.length > 0) {
+  stateLines.push(`Tareas pendientes en cola: ${queue.pending.length}`);
+  queue.pending.slice(0, 5).forEach(t => stateLines.push(`  - ${t.split('|').slice(0, 3).join('|').trim()}`));
+}
+if (state?.inProgress?.length > 0) {
+  stateLines.push(`Tareas en progreso: ${state.inProgress.map(t => `${t.id} (${t.agent})`).join(', ')}`);
+}
+if (failedAgents.length > 0) {
+  stateLines.push(`Agentes con fallo: ${failedAgents.join(' | ')}`);
+}
+if (retryingAgents.length > 0) {
+  stateLines.push(`Agentes reintentando: ${retryingAgents.join(' | ')}`);
+}
+if (queue.completed.length > 0) {
+  stateLines.push(`Tareas completadas hasta ahora: ${queue.completed.length}`);
+}
+
+const stateContext = stateLines.join('\n');
+
+const monitorPrompt = lang === 'es'
+  ? `Modo Ausencia activo — revisión automática cada 5 minutos.
+
+Estado actual del orquestador:
+${stateContext}
+
+Instrucciones:
+1. Lee INBOX.md en ${WORKSPACE} — si hay análisis completados de agentes que aún no tienen su tarea de implementación en QUEUE.md, crea la TASK correspondiente
+2. Lee QUEUE.md en ${WORKSPACE} — si hay tareas fallidas que la TUI no pudo reasignar automáticamente (marcadas como failed), reasígnalas manualmente al siguiente agente disponible
+3. Si hay agentes idle y tareas pendientes que no se están procesando, revisa si hay un problema de dependencias o bloqueo y resuélvelo
+4. Si detectas que el trabajo avanza normalmente, no hagas nada y responde brevemente el estado
+
+No hagas commit ni push. No inventes tareas nuevas fuera del alcance actual.`
+  : `Away Mode active — automatic check every 5 minutes.
+
+Current orchestrator state:
+${stateContext}
+
+Instructions:
+1. Read INBOX.md in ${WORKSPACE} — if there are completed agent analyses without a corresponding implementation task in QUEUE.md, create the TASK
+2. Read QUEUE.md in ${WORKSPACE} — if there are failed tasks that the TUI could not auto-reassign (marked as failed), manually reassign to the next available agent
+3. If there are idle agents and pending tasks not being processed, check for dependency or blocking issues and resolve them
+4. If work is progressing normally, do nothing and briefly report the status
+
+Do not commit or push. Do not invent new tasks outside the current scope.`;
+
+console.log(`  -> Disparando prompt a Claude para monitoreo...`);
+launchClaude(monitorPrompt);

package/src/ink/app.mjs

@@ -19,6 +19,8 @@ const TEXT = {
 	es: {
 		busy: 'Ocupado',
 		idle: 'En espera',
+		failed: 'Falló',
+		retrying: 'Reintentando',
 		noTask: 'Sin tarea activa',
 		ready: 'Listo para trabajar',
 		project: 'Proyecto',
@@ -31,9 +33,7 @@ const TEXT = {
 		paused: 'Pausado',
 		preview: 'Explorando Ink',
 		shortcuts: 'Atajos',
-		start: 'iniciar/reanudar',
 		pause: 'pausar',
-		reload: 'recargar QUEUE.md',
 		quit: 'salir y matar agentes',
 		summary: 'Resumen',
 		activeQueue: 'Cola activa',
@@ -43,6 +43,8 @@ const TEXT = {
 	en: {
 		busy: 'Busy',
 		idle: 'Idle',
+		failed: 'Failed',
+		retrying: 'Retrying',
 		noTask: 'No active task',
 		ready: 'Ready to work',
 		project: 'Project',
@@ -55,9 +57,7 @@ const TEXT = {
 		paused: 'Paused',
 		preview: 'Exploring Ink',
 		shortcuts: 'Shortcuts',
-		start: 'start/resume',
 		pause: 'pause',
-		reload: 'reload QUEUE.md',
 		quit: 'quit and stop agents',
 		summary: 'Summary',
 		activeQueue: 'Active Queue',
@@ -82,7 +82,20 @@ const Panel = ({title, width, children}) =>
 	);
 
 const AgentCard = ({agent, text}) => {
-	const statusColor = agent.status === 'busy' ? COLORS.success : COLORS.muted;
+	const statusColor =
+		agent.status === 'busy' ? COLORS.success :
+		agent.status === 'failed' ? 'red' :
+		agent.status === 'retrying' ? COLORS.warning :
+		COLORS.muted;
+
+	const statusLabel =
+		agent.status === 'busy' ? text.busy :
+		agent.status === 'failed' ? text.failed :
+		agent.status === 'retrying' ? text.retrying :
+		text.idle;
+
+	const costLine = agent.totalCost > 0 ? `${text.cost}: $${agent.totalCost.toFixed(2)}` : null;
+
 	return h(
 		Box,
 		{
@@ -94,13 +107,14 @@ const AgentCard = ({agent, text}) => {
 			flexDirection: 'column'
 		},
 		h(Text, {bold: true, wrap: 'wrap'}, agent.name),
-		h(Text, {color: statusColor}, agent.status === 'busy' ? text.busy : text.idle),
+		h(Text, {color: statusColor, bold: agent.status === 'failed' || agent.status === 'retrying'}, statusLabel),
 		h(
 			Text,
 			{color: COLORS.muted, wrap: 'wrap'},
 			agent.task || text.noTask
 		),
-		h(Text, {color: COLORS.muted, wrap: 'wrap'}, agent.detail || text.ready)
+		h(Text, {color: COLORS.muted, wrap: 'wrap'}, agent.detail || text.ready),
+		...(costLine ? [h(Text, {color: COLORS.success, wrap: 'wrap'}, costLine)] : [])
 	);
 };
 
@@ -123,8 +137,6 @@ export function App({snapshot, paused = false, onAction}) {
 		}
 
 		const normalized = input.toLowerCase();
-		if (normalized === 'r') onAction?.('reload');
-		if (normalized === 's') onAction?.('start');
 		if (normalized === 'p') onAction?.('pause');
 		if (normalized === 'q') onAction?.('quit');
 	});
@@ -173,14 +185,10 @@ export function App({snapshot, paused = false, onAction}) {
 			Box,
 			{marginBottom: 1},
 			h(Text, {color: COLORS.warning}, `${text.shortcuts}: `),
-			h(Text, {bold: true}, 'S'),
-			h(Text, {color: COLORS.muted}, truncate(` ${text.start}  `, Math.max(0, shortcutWidth - 40))),
 			h(Text, {bold: true}, 'P'),
 			h(Text, {color: COLORS.muted}, truncate(` ${text.pause}  `, Math.max(0, shortcutWidth - 55))),
-			h(Text, {bold: true}, 'R'),
-			h(Text, {color: COLORS.muted}, truncate(` ${text.reload}  `, Math.max(0, shortcutWidth - 70))),
 			h(Text, {bold: true}, 'Q'),
-			h(Text, {color: COLORS.muted}, truncate(` ${text.quit}`, Math.max(0, shortcutWidth - 90)))
+			h(Text, {color: COLORS.muted}, truncate(` ${text.quit}`, Math.max(0, shortcutWidth - 70)))
 		),
 		h(
 			Box,

package/src/ink/index.mjs

@@ -219,14 +219,33 @@ function buildSnapshot() {
 
 	const agents = Object.entries(config.agents || {}).map(([name]) => {
 		const agent = engineState.agents?.[name];
+		const lastLine = agent?.lastLine || '';
+
+		let status;
+		if (agent?.status === 'busy') {
+			status = 'busy';
+		} else if (lastLine.startsWith('FALLÓ:') || lastLine.startsWith('FAILED:')) {
+			status = 'failed';
+		} else if (
+			lastLine.startsWith('REINTENTO:') ||
+			lastLine.startsWith('LÍMITE:') ||
+			lastLine.startsWith('RETRY:') ||
+			lastLine.startsWith('LIMIT:')
+		) {
+			status = 'retrying';
+		} else {
+			status = 'idle';
+		}
+
 		return {
 			name,
-			status: agent?.status === 'busy' ? 'busy' : 'idle',
+			status,
 			task: agent?.task ? `${agent.task.id} · ${agent.task.title}` : null,
 			detail:
 				agent?.status === 'busy'
 					? `${agent.task?.priority || 'P?'} · ${agent.task?.repo || 'repo'}`
-					: agent?.lastLine || text.ready
+					: lastLine || text.ready,
+			totalCost: agent?.totalCost || 0
 		};
 	});
 

package/templates/en/ORCHESTRATOR.md

@@ -64,44 +64,63 @@ When the user says something like `Read ORCHESTRATOR.md and start`, do this:
 
 1. Read this file completely.
 2. Read `orchestrator.config.json` — identify the real project paths in `repos` (frontend, backend). Those are the paths where the worker agents operate.
-3. Read `<projectName>-plan.md`, `PLAN.md`, or `plan.md` if present.
-4. Read the newest `handoffs/HANDOFF-*.md` if the folder exists.
-5. **Read `INBOX.md` if it exists** — it contains automatic TUI notifications of completed tasks that require your attention (creating next TASKs, reading agent reports, etc.).
-6. Read `QUEUE.md` to understand pending, active, and completed work.
-7. Read all `progress/PROGRESS-*.md` files if present.
-8. Read `ENGRAM.md` and follow the memory rules.
-9. Use `openspec/` for large or multi-phase changes.
-10. Tell the user the orchestrator is ready and ask what to prioritize.
+3. **Verify script automation:** check if `logs/schedule-configured.json` exists.
+   - If it does **NOT exist**: run `agentflow schedule` in the workspace directory to register `auto-trigger.js` (every 1 min) and `monitor-check.js` (every 5 min) in the task scheduler. Then create `logs/schedule-configured.json` with `{"configuredAt": "<date>"}`. Inform the user that automation is ready.
+   - If it **already exists**: continue without doing anything.
+4. Read `<projectName>-plan.md`, `PLAN.md`, or `plan.md` if present.
+5. Read the newest `handoffs/HANDOFF-*.md` if the folder exists.
+6. **Read `INBOX.md` if it exists** — it contains automatic TUI notifications of completed tasks that require your attention (creating next TASKs, reading agent reports, etc.).
+7. Read `QUEUE.md` to understand pending, active, and completed work.
+8. Read all `progress/PROGRESS-*.md` files if present.
+9. Read `ENGRAM.md` and follow the memory rules.
+10. Use `openspec/` for large or multi-phase changes.
+11. Tell the user the orchestrator is ready and ask what to prioritize.
 
 **INBOX rule:** At the start of EACH response, if `INBOX.md` has new entries since your last read, check it first. This is how you know when an agent finished and what to create next — without Away Mode active.
 
+**STATUS rule:** Also read `STATUS.md` at the start of each response to get current context of agents and queue. This file updates automatically every 60 seconds.
+
+**ACTIONS rule:** If `ACTIONS.md` exists, read it too — it contains automatic monitoring actions (completed tasks needing follow-up, failed tasks, stuck tasks, etc).
+
 Startup is context loading only. Do not create project code changes during startup.
 
 ## Away Mode
 
 If the user says something like:
 
+- `I will be away for 1 hour`
 - `I will be away for 2 hours`
-- `monitor while I am gone`
-- `keep checking`
-- `continue while I am away`
-
-enter **Away Mode** for that session.
-
-In Away Mode:
-
-1. Check work state every 5 minutes.
-2. Read `QUEUE.md`, completed tasks, active tasks, idle agents, progress files, and blocked tasks.
-3. Assign new useful TASKs when agents become idle, as long as the work stays within the user's stated goal.
-4. Update `QUEUE.md` and `TASKS.md` when work needs splitting, dependency cleanup, or a next batch.
-5. Keep progress moving without inventing new product scope.
+- `going out for a while`
+- `activate monitoring`
 
-Away Mode limits:
+**Activate Away Mode:**
+```bash
+echo away > .away-mode
+```
 
-- Do not change the user's objective.
-- Do not open unrelated work streams.
-- Do not use Gemini, Cursor, or Abacus without explicit permission.
-- If a decision is risky or ambiguous, leave a note in `QUEUE.md` or a handoff instead of guessing.
+**The monitor-check.js script will run every 5 minutes** and check:
+- Completed tasks without follow-up
+- Failed tasks
+- Stuck tasks (>10 min)
+- And write to ACTIONS.md
+
+**Auto-deactivate:**
+When there are NO pending tasks AND NO agents working AND all tasks are completed:
+- The script removes .away-mode automatically
+- Away Mode deactivates by itself
+- When you return and say "I'm back" → Clayde responds normally
+
+**The monitor-check.js script will run every 5 minutes** and check:
+- Completed tasks without follow-up
+- Failed tasks
+- Stuck tasks (>10 min)
+- And write to ACTIONS.md so when you return, Claude reads it automatically
+
+**Deactivate Away Mode:**
+```bash
+# Delete indicator file
+del .away-mode
+```
 
 ## Fallback Policy
 
@@ -142,7 +161,13 @@ Default agent summary:
 
 ## How To Assign Work
 
-Write TASKs in `QUEUE.md` with this format:
+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
+
+2. Write TASKs in `QUEUE.md` with this format:
 
 ```text
 TASK-NNN | short title | Agent | P1 | repo | detailed description
@@ -155,7 +180,7 @@ Rules:
 3. Add `> after:TASK-NNN` at the end of the description for dependencies.
 4. Use `TASKS.md` under `### TASK-NNN` for longer task specs when needed.
 5. Use `briefs/TASK-NNN-BRIEF.md` for very detailed briefs when needed.
-6. After changing `QUEUE.md`, tell the user to press `R` in the TUI, and `S` if the TUI is paused.
+6. **The TUI starts automatically** - you don't need to press R or S. The TUI detects new tasks and launches them.
 
 Routing preferences:
 

package/templates/es/ORCHESTRATOR.md

@@ -44,17 +44,24 @@ Cuando necesites entender el proyecto para planificar tareas, **lee archivos des
 
 1. Lee este archivo completo.
 2. Lee `orchestrator.config.json` — identifica las rutas reales en `repos` (frontend, backend). Esas son las rutas del proyecto real donde trabajan los agentes.
-3. Lee `<projectName>-plan.md` (o `PLAN.md` / `plan.md`) si existe; ese es el plan general.
-4. Lee el handoff más reciente en `handoffs/HANDOFF-*.md` si existe la carpeta.
-5. **Lee `INBOX.md` si existe** — contiene notificaciones automáticas del TUI de tasks completadas que requieren tu atención (crear siguientes TASKs, leer reportes de agentes, etc.).
-6. Lee `QUEUE.md` para ver trabajo activo y pendiente.
-7. Lee todos los archivos `progress/PROGRESS-*.md` que existan para entender el estado actual de cada agente.
-8. Lee `ENGRAM.md` para respetar la convención de memoria persistente del proyecto.
-9. Si existe `openspec/`, úsalo como capa de artefactos para cambios grandes o de varias fases.
-10. Pregunta al usuario qué quiere priorizar; no planifiques toda la sesión automáticamente.
+3. **Verifica la automatización de scripts:** revisa si existe `logs/schedule-configured.json`.
+   - Si **NO existe**: ejecuta `agentflow schedule` en el directorio del workspace para registrar `auto-trigger.js` (cada 1 min) y `monitor-check.js` (cada 5 min) en el programador de tareas. Luego crea `logs/schedule-configured.json` con `{"configuredAt": "<fecha>"}`. Informa al usuario que la automatización quedó lista.
+   - Si **ya existe**: continúa sin hacer nada.
+4. Lee `<projectName>-plan.md` (o `PLAN.md` / `plan.md`) si existe; ese es el plan general.
+5. Lee el handoff más reciente en `handoffs/HANDOFF-*.md` si existe la carpeta.
+6. **Lee `INBOX.md` si existe** — contiene notificaciones automáticas del TUI de tasks completadas que requieren tu atención (crear siguientes TASKs, leer reportes de agentes, etc.).
+7. Lee `QUEUE.md` para ver trabajo activo y pendiente.
+8. Lee todos los archivos `progress/PROGRESS-*.md` que existan para entender el estado actual de cada agente.
+9. Lee `ENGRAM.md` para respetar la convención de memoria persistente del proyecto.
+10. Si existe `openspec/`, úsalo como capa de artefactos para cambios grandes o de varias fases.
+11. Pregunta al usuario qué quiere priorizar; no planifiques toda la sesión automáticamente.
 
 **Regla de INBOX:** Al inicio de CADA respuesta, si `INBOX.md` tiene entradas nuevas desde tu última lectura, léelo primero antes de responder al usuario. Así sabrás qué agentes terminaron y qué falta crear.
 
+**Regla de STATUS:** También lee `STATUS.md` al inicio de cada respuesta para tener contexto del estado actual de los agentes y la cola. Este archivo se actualiza automáticamente cada 60 segundos.
+
+**Regla de ACTIONS:** Si existe `ACTIONS.md`, léelo también - contiene acciones automáticas del monitoreo (tareas completadas que necesitan seguimiento, tareas fallidas, etc).
+
 ## Restricción operativa por defecto
 
 Aunque esta plantilla soporte múltiples agentes, en este proyecto debes operar **solo con estas 3 IA por defecto**:
@@ -71,13 +78,39 @@ Los demás agentes pueden permanecer configurados en `orchestrator.config.json`,
 
 Si el usuario dice explícitamente algo como:
 
+- `estaré ausente 1 hora`
 - `estaré ausente 2 horas`
 - `me voy un rato`
 - `activa monitoreo`
-- `quédate revisando`
-- `monitorea mientras no estoy`
 
-entonces debes entrar en **Modo Ausencia** durante esa sesión.
+**Activar Modo Ausencia:**
+```bash
+echo away > .away-mode
+```
+
+**El script monitor-check.js se ejecutará cada 5 minutos** y revisará:
+- Tareas completadas sin seguimiento
+- Tareas fallidas
+- Tareas atascadas (>10 min)
+- Y escribirá en ACTIONS.md
+
+**Auto-desactivación:**
+Cuando NO hay tareas pendientes Y NO hay agentes trabajando Y todas las tareas están completadas:
+- El script elimina .away-mode automáticamente
+- Modo Ausencia se desactiva solo
+- Cuando vuelvas y le digas "ya volví" → Claade responde normalmente
+
+**El script monitor-check.js se ejecutará cada 5 minutos** y revisará:
+- Tareas completadas sin seguimiento
+- Tareas fallidas
+- Tareas atascadas (>10 min)
+- Y escribirá en ACTIONS.md para que cuando vuelvas, Claude lo lea automáticamente
+
+**Desactivar Modo Ausencia:**
+```bash
+# Eliminar archivo indicador
+del .away-mode
+```
 
 ### Qué significa Modo Ausencia
 
@@ -149,17 +182,23 @@ Revisa `orchestrator.config.json` → `agents`. Cada entrada tiene:
 
 ## Cómo asignar trabajo
 
-1. Escribe TASKs en `QUEUE.md` (formato pipe; la TUI lo lee):
-   ```
-   TASK-NNN | titulo corto | Agent | P1 | repo | descripcion larga
-   ```
-   Valores válidos de `Agent`: exactamente las keys de `orchestrator.config.json.agents`.
-   Valores válidos de `repo`: exactamente las keys de `orchestrator.config.json.repos`.
-2. (Opcional) También escribe una spec larga en `TASKS.md` bajo un heading `### TASK-NNN`; se inyecta al brief.
-3. (Opcional) Para un brief muy detallado, crea `briefs/TASK-NNN-BRIEF.md`; también se inyecta.
-4. Dependencias: agrega `> after:TASK-NNN` al final de la descripción para bloquear la tarea.
-5. Dile al usuario que presione **R** en la TUI para recargar la cola, o **S** si está pausada.
-6. **Prioriza Codex y OpenCode** para toda implementación y exploración. Claude-Workers solo cuando hay saturación o fallo total de agentes de soporte.
+1. **Cuando el usuario pide un cambio o nueva tarea** → **NUNCA analices directamente**
+   - **Primero**: Crea una TASK en `QUEUE.md` asignada a **OpenCode** para que analice el contexto
+   - **Segundo**: Espera a que OpenCode termine su análisis (revisa INBOX.md o progress/)
+   - **Tercero**: Recibes el análisis → creas nueva TASK para implementar (Codex o OpenCode)
+   - **Nunca analices el código del proyecto directamente tu mismo** - eso lo hace OpenCode
+
+2. Escribe TASKs en `QUEUE.md` (formato pipe; la TUI lo lee):
+    ```
+    TASK-NNN | titulo corto | Agent | P1 | repo | descripcion larga
+    ```
+    Valores válidos de `Agent`: exactamente las keys de `orchestrator.config.json.agents`.
+    Valores válidos de `repo`: exactamente las keys de `orchestrator.config.json.repos`.
+3. (Opcional) También escribe una spec larga en `TASKS.md` bajo un heading `### TASK-NNN`; se inyecta al brief.
+4. (Opcional) Para un brief muy detallado, crea `briefs/TASK-NNN-BRIEF.md`; también se inyecta.
+5. Dependencias: agrega `> after:TASK-NNN` al final de la descripción para bloquear la tarea.
+6. **La TUI inicia automáticamente** - NO necesitas presionar R ni S. La TUI detecta nuevas tasks y las lanza.
+7. **Prioriza Codex y OpenCode** para toda implementación y exploración. Claude-Workers solo cuando hay saturación o fallo total de agentes de soporte.
 7. Distribución según cantidad de TASKs independientes:
    - **1 tarea**: OpenCode (exploración) o Codex (implementación). Nunca Claude-Worker en primera instancia.
    - **2 tareas**: OpenCode + Codex, una cada uno.