Production lessons: atomic writes, idempotency, dependsOn DAG, log[], crash recovery

README.md

@@ -98,15 +98,21 @@ The only communication channel between Planner and Executor is a JSON file that
       "status": "pending",
       "threadId": "18f3a2b...",
       "from": "kikocisneros@gmail.com",
-      "createdAt": "2026-05-31T09:12:00.000Z"
+      "createdAt": "2026-05-31T09:12:00.000Z",
+      "retries": 0,
+      "log": [],
+      "dependsOn": []
     }
   ],
   "updatedAt": "2026-05-31T09:12:05.123Z"
 }
 ```
 
-**Task statuses**: `pending` → `in-progress` → `done` | `failed`  
-**Priority**: `1` = urgent, `2` = normal, `3` = low
+**Task statuses**: `pending` → `in-progress` → `done` | `failed` | `skipped`  
+**Priority**: `1` = urgent, `2` = normal, `3` = low  
+**`retries`**: auto-incremented on failure and recovery  
+**`log[]`**: timestamped progress entries written by the Executor during execution  
+**`dependsOn[]`**: IDs of tasks that must be `done` before this one is eligible
 
 This file is readable by humans, inspectable at any time, and survives process crashes.
 
@@ -114,7 +120,7 @@ This file is readable by humans, inspectable at any time, and survives process c
 
 ### The Planner Prompt
 
-The Scheduler (Planner) receives a tightly scoped prompt:
+The Scheduler receives a tightly scoped prompt that constrains it to planning only:
 
 ```
 ROL: PLANIFICADOR
@@ -127,12 +133,18 @@ Nueva comunicación recibida:
 Tu tarea (sé rápido y concreto):
 1. Lee el email: python3 mail_client.py get-thread "18f3a2b..."
 2. Lee el fichero de tareas actual: cat agent-tasks.json
-3. Añade las tareas necesarias en formato JSON:
-   { "id": "<uuid4>", "title": "...", "description": "...",
-     "priority": 1, "status": "pending", "threadId": "...",
-     "from": "...", "createdAt": "<iso>" }
-   - priority 1=urgente, 2=normal, 3=baja
-   - No dupliques tareas ya existentes para el mismo threadId
+3. Decide qué tareas hay que hacer. Por cada tarea, añádela con esta forma:
+   {
+     "id": "<uuid4>", "title": "...", "description": "...",
+     "priority": 1, "status": "pending",
+     "threadId": "...", "from": "...", "createdAt": "<iso>",
+     "retries": 0, "log": [],
+     "dependsOn": []   ← IDs of other tasks that must be done first
+   }
+   - priority: 1=urgent, 2=normal, 3=low
+   - dependsOn: list task IDs in this file that must be "done" before this one runs
+   - Do NOT add tasks if threadId already exists with any status other than "failed"
+   - If threadId exists with status "failed", add nothing — the Executor will retry automatically
 4. Actualiza el campo "plan" con tu análisis breve
 5. Escribe el fichero actualizado
 6. Sal cuando hayas terminado de planificar.
@@ -141,34 +153,196 @@ Tu tarea (sé rápido y concreto):
 Key constraints on the Planner:
 - **It never executes**. It only reads and writes `agent-tasks.json`
 - **It deduplicates**: checks existing tasks by `threadId` before adding new ones
+- **It models dependencies**: can express "deploy after tests pass" with `dependsOn`
 - **It exits immediately** after writing the plan
 
 ---
 
 ### The Executor Prompt
 
-The Executor picks up `agent-tasks.json` and works through it:
+The Executor picks up `agent-tasks.json` and works through it, respecting dependencies and logging progress:
 
 ```
 ROL: EJECUTOR
 
 Ejecuta las tareas pendientes de agent-tasks.json.
 
-Proceso (repite hasta que no haya más tareas pendientes):
+Proceso (repite hasta que no haya más tareas ejecutables):
 1. Lee agent-tasks.json
 2. Toma la tarea con status="pending" de mayor prioridad (1=urgente)
-3. Actualiza su status a "in-progress" en el fichero
-4. Ejecuta la tarea
-5. Actualiza: status="done" o "failed", result="descripción", updatedAt=<iso>
-6. Si quedan más tareas pending, vuelve al paso 1
-7. Cuando no haya ninguna tarea pending, sal
+   cuyo dependsOn[] esté vacío o todas sus deps estén "done".
+   Si ninguna cumple esto, sal.
+3. Actualiza status a "in-progress"; añade al log[]: { "ts": "<iso>", "msg": "Iniciando: <título>" }
+4. Ejecuta la tarea; añade entradas al log[] con progreso real durante la ejecución
+5. Al terminar:
+   - status: "done" o "failed"
+   - result: descripción breve del resultado
+   - updatedAt: <iso>
+   - Si retries >= 3: status="failed", result="Max retries reached: <reason>"
+6. Si quedan tareas pending ejecutables, vuelve al paso 1
+7. Cuando no haya ninguna tarea pending ejecutable, sal
 
 Reglas:
 - Marca "failed" (no crashees) si algo falla, continúa con la siguiente
+- El campo log[] es visible al usuario — úsalo para reflejar progreso real
 - Usa mail_client.py para enviar respuestas de email
 ```
 
-The Executor's loop is explicit in the prompt: it keeps going until the queue is empty. This means one Executor session can drain multiple tasks that accumulated while it was sleeping.
+---
+
+## Task Dependencies: Basic DAG
+
+The `dependsOn` field turns `agent-tasks.json` into a minimal DAG (directed acyclic graph) without any external scheduler:
+
+```json
+[
+  { "id": "task-run-tests",  "title": "Run test suite",    "status": "pending", "dependsOn": [] },
+  { "id": "task-deploy-prod","title": "Deploy to prod",    "status": "pending", "dependsOn": ["task-run-tests"] },
+  { "id": "task-notify",     "title": "Reply with result", "status": "pending", "dependsOn": ["task-deploy-prod"] }
+]
+```
+
+The Executor resolves this automatically:
+
+```javascript
+function getNextTask(agentId) {
+  const queue = read(agentId);
+  const { tasks } = queue;
+  let dirty = false;
+
+  const pending = tasks
+    .filter(t => t.status === 'pending')
+    .sort((a, b) => (a.priority || 2) - (b.priority || 2));
+
+  let result = null;
+  for (const task of pending) {
+    if (!task.dependsOn?.length) { result = task; break; }
+
+    const deps = task.dependsOn.map(id => tasks.find(t => t.id === id));
+    const failedDep = deps.find(d => d?.status === 'failed');
+
+    if (failedDep) {
+      // Auto-skip tasks whose dependency failed — no manual intervention needed
+      task.status = 'skipped';
+      task.result = `Skipped: dependency "${failedDep.title}" failed`;
+      task.log.push({ ts: new Date().toISOString(), msg: task.result });
+      dirty = true;
+      continue;
+    }
+
+    if (deps.every(d => d?.status === 'done')) { result = task; break; }
+  }
+
+  if (dirty) write(agentId, queue);
+  return result;
+}
+```
+
+If `task-run-tests` fails, `task-deploy-prod` and `task-notify` are automatically skipped. No cascade failure, no stuck queue.
+
+---
+
+## Idempotency: Handling Re-delivered Emails
+
+Email systems re-deliver. Networks retry. The Planner must be idempotent:
+
+```javascript
+function addTask(agentId, newTask) {
+  const queue = read(agentId);
+  const existing = queue.tasks.find(t => t.threadId === newTask.threadId);
+
+  if (existing) {
+    if (existing.status === 'failed') {
+      // Explicit retry: reset to pending, increment retries counter
+      existing.status = 'pending';
+      existing.retries = (existing.retries || 0) + 1;
+      existing.log.push({ ts: new Date().toISOString(), msg: `Retry #${existing.retries}` });
+      write(agentId, queue);
+    }
+    // For any other status: silent no-op (dedup)
+    return queue;
+  }
+
+  queue.tasks.push({ retries: 0, log: [], dependsOn: [], ...newTask });
+  write(agentId, queue);
+  return queue;
+}
+```
+
+The same `threadId` arriving twice results in one task. A `failed` task arriving again resets to `pending` with `retries++`. The `retries` field lets the Executor apply exponential backoff or hard-stop after N attempts.
+
+---
+
+## Per-Task Progress Logging
+
+The `log[]` array makes task execution fully observable without any external logging infrastructure:
+
+```json
+{
+  "id": "task-deploy-prod",
+  "status": "done",
+  "log": [
+    { "ts": "2026-05-31T10:00:01Z", "msg": "Iniciando: Deploy to prod" },
+    { "ts": "2026-05-31T10:00:08Z", "msg": "SSH connected to 145.239.65.26" },
+    { "ts": "2026-05-31T10:00:31Z", "msg": "docker pull done (847MB)" },
+    { "ts": "2026-05-31T10:00:38Z", "msg": "Containers restarted, health check passed" }
+  ],
+  "result": "Deployed v2.1.4 successfully"
+}
+```
+
+Live monitoring: `watch -n1 'cat agent-tasks.json | jq ".tasks[0].log[-3:]"'`
+
+No Grafana. No Datadog. The file is the dashboard.
+
+---
+
+## Crash Recovery
+
+When the server restarts, tasks that were `in-progress` (mid-execution) need to be reset. A one-time recovery pass runs at startup:
+
+```javascript
+function recoverStaleTasks(agentId) {
+  const queue = read(agentId);
+  let recovered = 0;
+  for (const task of queue.tasks) {
+    if (task.status !== 'in-progress') continue;
+    task.status = 'pending';
+    task.retries = (task.retries || 0) + 1;
+    task.log.push({ ts: new Date().toISOString(), msg: 'Recovered from stale in-progress (server restart)' });
+    recovered++;
+  }
+  if (recovered > 0) write(agentId, queue);
+  return recovered;
+}
+
+// In startPoller():
+function startPoller() {
+  const agents = listAgents().filter(a => a.enabled && a.ready);
+  for (const a of agents) taskQueue.recoverStaleTasks(a.id);
+  // ... start cron jobs
+}
+```
+
+A crash mid-deploy becomes a retried deploy, not a lost task.
+
+---
+
+## Atomic Writes
+
+The JSON file is the single source of truth. Corruption on a mid-write crash would break everything. The fix: write to a `.tmp` file, then `rename`:
+
+```javascript
+function write(agentId, data) {
+  const f = filePath(agentId);
+  const tmp = f + '.tmp';
+  fs.mkdirSync(path.dirname(f), { recursive: true });
+  fs.writeFileSync(tmp, JSON.stringify({ ...data, updatedAt: new Date().toISOString() }, null, 2));
+  fs.renameSync(tmp, f); // atomic on POSIX
+}
+```
+
+`fs.renameSync` is atomic on POSIX filesystems: readers either see the old file or the new one, never a partial write.
 
 ---
 
@@ -183,26 +357,17 @@ T+180s  Executor completes tasks, replies to email → exits
 T+240s  Executor tick fires → no pending tasks → skips (noop)
 ```
 
-Concurrency is controlled by boolean flags:
+Concurrency is controlled by in-memory flags that survive the process lifetime:
 
 ```javascript
-let schedulerRunning = false;
-let executorRunning  = false;
-
 // Only one Scheduler active per agent at a time
-if (agentSessions.isActive(skillId, 'scheduler')) {
-  console.log(`scheduler already active, skipping`);
-  return null;
-}
+if (agentSessions.isActive(skillId, 'scheduler')) return null;
 
 // Only one Executor active per agent at a time  
-if (agentSessions.isActive(skillId, 'executor')) {
-  console.log(`executor already active, skipping`);
-  return null;
-}
+if (agentSessions.isActive(skillId, 'executor')) return null;
 ```
 
-Crucially: **the Scheduler and Executor can run simultaneously**. While the Executor is working on task #1, the Scheduler can plan tasks #2 and #3. They only share the file — they never block each other.
+Crucially: **the Scheduler and Executor can run simultaneously**. While the Executor is working on task #1, the Scheduler can plan tasks #2 and #3.
 
 ---
 
@@ -219,10 +384,9 @@ const args = [
   '--model', resolvedModel,
 ];
 if (resumeClaudeId) args.push('--resume', resumeClaudeId);
-args.push('-p', `/${skillId}\n\n${prompt}`);
 ```
 
-This means the Executor doesn't start cold each time. It already knows the agent's project structure, coding conventions, and recent context from the previous session. The more emails processed, the more efficient it becomes.
+The Executor doesn't start cold. It already knows the project structure, conventions, and recent decisions. The more emails processed, the more efficient it becomes — without a database.
 
 ---
 
@@ -232,10 +396,13 @@ This means the Executor doesn't start cold each time. It already knows the agent
 |---------|-------------|-----------------|
 | New email while executing | Missed until session ends | Scheduler handles it immediately |
 | Task priority | FIFO only | Explicit priority 1-2-3 |
-| Partial failure | Whole session fails | Task marked "failed", next task continues |
+| Task dependencies | None | `dependsOn[]` with auto-skip on failure |
+| Partial failure | Whole session fails | Task marked `failed`, next task continues |
+| Crash mid-task | Task lost silently | Reset to `pending` on restart, `retries++` |
 | Long-running tasks | Blocks everything | Executor runs async, Scheduler stays free |
-| Debugging | One long session, hard to inspect | `agent-tasks.json` is human-readable at all times |
-| Cost control | Hard to limit mid-session | Per-task granularity, monthly spend limit enforced before each launch |
+| Debugging | One long session, hard to inspect | `agent-tasks.json` + `log[]` per task |
+| Cost control | Hard to limit mid-session | Monthly spend limit checked before each launch |
+| Re-delivered emails | May process twice | Dedup by `threadId`, idempotent |
 
 ---
 
@@ -245,7 +412,7 @@ Before launching either agent, the system checks monthly spend:
 
 ```javascript
 if (agent.spendingLimitMonthly != null) {
-  const spent = await getMonthlySpend(skillId);
+  const spent = await getMonthlySpend(skillId);  // async — must be awaited
   if (spent >= agent.spendingLimitMonthly) {
     console.warn(`monthly limit $${agent.spendingLimitMonthly} reached — launch blocked`);
     return null;
@@ -253,27 +420,14 @@ if (agent.spendingLimitMonthly != null) {
 }
 ```
 
-This means you can run agents with hard cost caps. The Planner is cheap (reads email, writes JSON). The Executor is where the real work — and cost — happens.
-
----
-
-## The `agent-tasks.json` as a Coordination Protocol
-
-The file acts as a simple, durable message queue. It is:
-
-- **Persistent**: survives process restarts
-- **Inspectable**: `cat agent-tasks.json` shows exactly what the agent is doing
-- **Editable by hand**: add a task manually and the Executor will pick it up
-- **Self-documenting**: the `plan` field explains the agent's current understanding
-
-This replaces Redis, RabbitMQ, or any external queue system with a 30-line module.
+The Planner is cheap (reads email, writes JSON — a few cents). The Executor is where real work — and cost — happens. Checking before each launch gives per-session cost granularity.
 
 ---
 
 ## Complete Flow Diagram
 
 ```
-Inbox (IMAP)
+Inbox (IMAP/Gmail)
      │
      │  (polled every 60s)
      ▼
@@ -289,15 +443,16 @@ gmail-poller.js
           │  (Claude CLI, ROL: PLANIFICADOR)
           │  reads email thread via mail_client.py
           │  reads agent-tasks.json
-          │  appends new tasks with priority
-          │  writes agent-tasks.json
+          │  deduplicates by threadId
+          │  appends tasks with priority + dependsOn
+          │  writes agent-tasks.json (atomic)
           └─ exits
           
      (2 min later...)
      
 tickExecutor()
      │
-     ├─ hasPending(agentId)? → no → skip
+     ├─ hasPendingReady(agentId)? → no → skip
      │
      └─ yes
           │
@@ -306,37 +461,25 @@ tickExecutor()
           │
           │  (Claude CLI, ROL: EJECUTOR)
           │  reads agent-tasks.json
-          │  picks highest-priority pending task
-          │  marks in-progress
+          │  picks highest-priority pending task with deps satisfied
+          │  marks in-progress, appends to log[]
           │  executes (code, email reply, API call, deploy...)
-          │  marks done/failed with result
-          │  loops until queue empty
+          │  marks done/failed with result + final log entry
+          │  loops until queue empty or no more executable tasks
           └─ exits
 ```
 
 ---
 
-## What This Enables in Practice
-
-An agent built on this pattern can:
-
-1. **Handle multiple simultaneous email threads** — each gets planned independently, executed in priority order
-2. **Survive long-running tasks** — a deploy that takes 3 minutes doesn't block other planning
-3. **Recover from failures gracefully** — failed tasks are logged, not lost
-4. **Learn across sessions** — `--resume` means the Executor accumulates context over time
-5. **Be audited** — `agent-tasks.json` is the full audit log of what was planned and what happened
-
----
-
 ## Implementation in ClonAgent
 
 The full implementation is open source:
 
 | File | Role |
 |------|------|
-| [`server/lib/gmail-poller.js`](https://github.com/KikoCisBot/clonagent/blob/main/server/lib/gmail-poller.js) | Orchestrator: poller ticks, triggers Scheduler and Executor |
-| [`server/lib/relay-client.js`](https://github.com/KikoCisBot/clonagent/blob/main/server/lib/relay-client.js) | Launches Scheduler and Executor via Claude CLI |
-| [`server/lib/task-queue.js`](https://github.com/KikoCisBot/clonagent/blob/main/server/lib/task-queue.js) | Reads/writes `agent-tasks.json` |
+| [`server/lib/gmail-poller.js`](https://github.com/KikoCisBot/clonagent/blob/main/server/lib/gmail-poller.js) | Orchestrator: poller ticks, triggers Scheduler and Executor, crash recovery on startup |
+| [`server/lib/relay-client.js`](https://github.com/KikoCisBot/clonagent/blob/main/server/lib/relay-client.js) | Launches Scheduler and Executor via Claude CLI with role-specific prompts |
+| [`server/lib/task-queue.js`](https://github.com/KikoCisBot/clonagent/blob/main/server/lib/task-queue.js) | Atomic reads/writes of `agent-tasks.json`, idempotent `addTask`, dependency-aware `getNextTask`, crash recovery |
 | [`server/lib/agent-sessions.js`](https://github.com/KikoCisBot/clonagent/blob/main/server/lib/agent-sessions.js) | Tracks active Scheduler/Executor sessions, prevents overlaps |
 
 ---
@@ -347,9 +490,18 @@ The Planner-Executor pattern is a practical approach to building reliable AI age
 
 The key insight is that **planning and execution are different cognitive tasks** that benefit from separation — not just conceptually, but as separate model invocations with different prompts, different time horizons, and different failure modes.
 
-A shared JSON file replaces complex message queue infrastructure. Claude CLI's `--resume` flag provides session continuity without a database. And explicit priority fields give the agent the ability to triage, just like a human would.
+Production use has taught us additional lessons:
+
+- **Atomic writes** (temp + rename) prevent file corruption that would break the whole agent
+- **Idempotency by `threadId`** is mandatory — email systems re-deliver, networks retry
+- **`log[]` per task** makes debugging possible without any external infrastructure
+- **`dependsOn[]`** enables multi-step workflows without Airflow or Temporal
+- **Crash recovery** at startup means a server restart doesn't lose work in progress
+- **`await` the spend check** — async bugs here mean spending limits silently don't apply
+
+A shared JSON file replaces complex message queue infrastructure. Claude CLI's `--resume` flag provides session continuity without a database. Explicit priority and dependency fields give the agent the ability to triage and sequence, just like a human would.
 
-The result is an agent that feels less like a script and more like a colleague: it reads your email, decides what matters, and gets to work — without blocking, without crashing, and without forgetting what it learned yesterday.
+The result is an agent that feels less like a script and more like a colleague: it reads your email, decides what matters, plans the work, and executes — without blocking, without crashing, and without forgetting what it learned yesterday.
 
 ---