@chuckssmith/agentloom 0.6.0 → 0.8.0

package/dist/cli.js

@@ -16,6 +16,7 @@ Usage:
   loom crew [N] "<task>"                Spawn N parallel workers on a task
   loom crew 2:explore "<task>"          Spawn typed workers (explore/plan/code-reviewer)
   loom crew --dry-run [N] "<task>"      Preview decomposed subtasks without launching
+  loom crew --serial [N] "<task>"       Run workers sequentially (each sees prior results)
   loom watch                            Live tail all worker logs (Ctrl+C to stop)
   loom stop                             Kill all background workers (SIGTERM)
   loom stop <workerId>                  Kill one worker

package/dist/commands/crew.js

@@ -1,6 +1,7 @@
 import { execSync, spawn, spawnSync } from 'child_process';
 import { writeFile, mkdir, open } from 'fs/promises';
 import { join } from 'path';
+import { existsSync } from 'fs';
 import { parseWorkerSpec, initSession, writeContextSnapshot, decomposeTasks, } from '../team/orchestrator.js';
 import { STATE_DIR } from '../state/session.js';
 const hasTmux = () => {
@@ -67,7 +68,8 @@ export async function crew(args) {
         process.exit(1);
     }
     const dryRun = args.includes('--dry-run');
-    const filteredArgs = args.filter(a => a !== '--dry-run');
+    const serial = args.includes('--serial');
+    const filteredArgs = args.filter(a => a !== '--dry-run' && a !== '--serial');
     const { specs, task } = parseWorkerSpec(filteredArgs);
     const totalWorkers = specs.reduce((sum, s) => sum + s.count, 0);
     const slug = task.slice(0, 30).toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
@@ -90,25 +92,78 @@ export async function crew(args) {
         return;
     }
     const useTmux = hasTmux() && !isWSL() && process.stdout.isTTY;
-    console.log(`Mode:    ${useTmux ? 'tmux' : 'background processes'}\n`);
+    const mode = serial ? 'serial' : useTmux ? 'tmux' : 'background processes';
+    console.log(`Mode:    ${mode}\n`);
     const session = await initSession(task, totalWorkers);
     const contextPath = await writeContextSnapshot(slug, task);
     const tasks = await decomposeTasks(task, specs);
     console.log(`Session: ${session.id}`);
     console.log(`Tasks:   ${tasks.length} created`);
     console.log(`Context: ${contextPath}\n`);
-    if (useTmux) {
+    if (serial) {
+        await launchSerial(session.id, specs, tasks, contextPath);
+        console.log(`\nAll workers finished. Run: loom collect`);
+    }
+    else if (useTmux) {
         await launchTmux(session.id, specs, tasks, contextPath);
+        console.log(`\nWorkers launched. Monitor with:`);
+        console.log(`  loom status`);
+        console.log(`  loom stop    (kill all workers)`);
     }
     else {
         await launchBackground(session.id, specs, tasks, contextPath);
+        console.log(`\nWorkers launched. Monitor with:`);
+        console.log(`  loom status`);
+        console.log(`  loom watch`);
+        console.log(`  loom stop    (kill all workers)`);
     }
-    console.log(`\nWorkers launched. Monitor with:`);
-    console.log(`  loom status`);
-    console.log(`  loom watch`);
-    console.log(`  loom stop    (kill all workers)`);
     console.log(`State dir: ${STATE_DIR}/`);
 }
+async function launchSerial(sessionId, specs, tasks, contextPath) {
+    await mkdir(join(STATE_DIR, 'workers'), { recursive: true });
+    let workerIdx = 0;
+    for (const spec of specs) {
+        for (let i = 0; i < spec.count; i++) {
+            const workerId = `w${String(workerIdx).padStart(2, '0')}`;
+            const subtask = tasks[workerIdx]?.description ?? tasks[0]?.description ?? '';
+            const agentType = tasks[workerIdx]?.agentType ?? spec.agentType;
+            workerIdx++;
+            // Each worker receives results from all previous workers via the context file
+            const prompt = buildWorkerPrompt(subtask, contextPath, sessionId, workerId, agentType);
+            const logFile = join(STATE_DIR, 'workers', `${workerId}.log`);
+            await writeFile(join(STATE_DIR, 'workers', `${workerId}-prompt.md`), prompt);
+            console.log(`  → Worker ${workerId} (${agentType}) starting...`);
+            const claudeArgs = [
+                '--print',
+                ...(!READ_ONLY_ROLES.has(agentType) ? ['--dangerously-skip-permissions'] : []),
+                '-p',
+                prompt,
+            ];
+            // Run synchronously — block until this worker is done before starting the next
+            const result = spawnSync('claude', claudeArgs, {
+                encoding: 'utf8',
+                timeout: 30 * 60 * 1000, // 30 min max per worker
+                env: { ...process.env, AGENTLOOM_WORKER_ID: workerId, AGENTLOOM_SESSION: sessionId },
+            });
+            const output = (result.stdout ?? '') + (result.stderr ?? '');
+            await writeFile(logFile, output);
+            if (result.status !== 0) {
+                const resultFile = join(STATE_DIR, 'workers', `${workerId}-result.md`);
+                await writeFile(resultFile, `# Error\n\nWorker exited with code ${result.status ?? 'unknown'}\n\n${output.slice(-500)}`);
+                console.log(`  ✗ Worker ${workerId} failed (exit ${result.status ?? '?'})`);
+            }
+            else {
+                // If worker didn't write its own result file, write a placeholder
+                const resultFile = join(STATE_DIR, 'workers', `${workerId}-result.md`);
+                if (!existsSync(resultFile)) {
+                    const lastLines = output.trim().split('\n').slice(-20).join('\n');
+                    await writeFile(resultFile, `# Result\n\n${lastLines}`);
+                }
+                console.log(`  ✓ Worker ${workerId} done`);
+            }
+        }
+    }
+}
 async function launchBackground(sessionId, specs, tasks, contextPath) {
     await mkdir(join(STATE_DIR, 'workers'), { recursive: true });
     let workerIdx = 0;
@@ -122,11 +177,13 @@ async function launchBackground(sessionId, specs, tasks, contextPath) {
             const logFile = join(STATE_DIR, 'workers', `${workerId}.log`);
             const pidFile = join(STATE_DIR, 'workers', `${workerId}.pid`);
             await writeFile(join(STATE_DIR, 'workers', `${workerId}-prompt.md`), prompt);
-            const claudeArgs = ['--print', '-p', prompt];
-            // Only pass --dangerously-skip-permissions to roles that write files
-            if (!READ_ONLY_ROLES.has(agentType)) {
-                claudeArgs.splice(2, 0, '--dangerously-skip-permissions');
-            }
+            // Build args declaratively — no positional splicing
+            const claudeArgs = [
+                '--print',
+                ...(!READ_ONLY_ROLES.has(agentType) ? ['--dangerously-skip-permissions'] : []),
+                '-p',
+                prompt,
+            ];
             const log = await open(logFile, 'w');
             const child = spawn('claude', claudeArgs, {
                 detached: true,
@@ -170,17 +227,20 @@ async function launchTmux(sessionId, specs, tasks, contextPath) {
             const agentType = tasks[workerIdx]?.agentType ?? spec.agentType;
             workerIdx++;
             const prompt = buildWorkerPrompt(subtask, contextPath, sessionId, workerId, agentType);
-            // Write prompt and a runner script to disk — avoids ALL shell escaping issues
-            const scriptFile = join(STATE_DIR, 'workers', `${workerId}-run.sh`);
-            const permFlag = READ_ONLY_ROLES.has(agentType) ? '' : '--dangerously-skip-permissions ';
-            await writeFile(join(STATE_DIR, 'workers', `${workerId}-prompt.md`), prompt);
+            const promptFile = join(STATE_DIR, 'workers', `${workerId}-prompt.md`);
+            const scriptFile = join(STATE_DIR, 'workers', `${workerId}-run.mjs`);
+            await writeFile(promptFile, prompt);
+            // Node.js runner — JSON.stringify safely encodes all values, no shell expansion possible
             await writeFile(scriptFile, [
-                '#!/bin/sh',
-                `export AGENTLOOM_WORKER_ID=${workerId}`,
-                `export AGENTLOOM_SESSION=${sessionId}`,
-                `claude --print ${permFlag}-p "$(cat '${join(STATE_DIR, 'workers', `${workerId}-prompt.md`)}')"`,
-                `echo '[worker done]'`,
-                `read`,
+                `import { readFileSync } from 'fs'`,
+                `import { spawnSync } from 'child_process'`,
+                `process.env.AGENTLOOM_WORKER_ID = ${JSON.stringify(workerId)}`,
+                `process.env.AGENTLOOM_SESSION = ${JSON.stringify(sessionId)}`,
+                `const prompt = readFileSync(${JSON.stringify(promptFile)}, 'utf8')`,
+                `const args = ['--print', ${!READ_ONLY_ROLES.has(agentType) ? `'--dangerously-skip-permissions', ` : ``}'${'-p'}', prompt]`,
+                `const r = spawnSync('claude', args, { stdio: 'inherit' })`,
+                `console.log('[worker done]')`,
+                `process.exit(r.status ?? 0)`,
             ].join('\n'));
             if (workerIdx > 1) {
                 try {
@@ -191,11 +251,12 @@ async function launchTmux(sessionId, specs, tasks, contextPath) {
                     // Non-fatal — continue with remaining workers even if layout fails
                 }
             }
-            try {
-                execSync(`tmux send-keys -t ${tmuxSession} "sh '${scriptFile}'" Enter`);
-            }
-            catch (err) {
-                console.error(`  ✗ Worker ${workerId}: failed to send tmux keys: ${err instanceof Error ? err.message : err}`);
+            // Use spawnSync (no shell) so the scriptFile path is passed as a literal argument.
+            // Escape single quotes in the path for the shell inside the tmux pane.
+            const shellSafePath = scriptFile.replace(/'/g, "'\\''");
+            const sendResult = spawnSync('tmux', ['send-keys', '-t', tmuxSession, `node '${shellSafePath}'`, 'Enter'], { stdio: 'ignore' });
+            if (sendResult.status !== 0) {
+                console.error(`  ✗ Worker ${workerId}: failed to send tmux keys`);
                 continue;
             }
             console.log(`  ✓ Worker ${workerId} (${agentType})${READ_ONLY_ROLES.has(agentType) ? ' [read-only]' : ''} launched in tmux pane`);

package/dist/commands/status.js

@@ -1,8 +1,17 @@
 import { readSession, readTasks, STATE_DIR } from '../state/session.js';
 import { existsSync, statSync } from 'fs';
 import { join } from 'path';
-import { readdir } from 'fs/promises';
-const STALE_THRESHOLD_MS = 10 * 60 * 1000; // 10 minutes with no log growth = stale
+import { readdir, readFile } from 'fs/promises';
+const STALE_THRESHOLD_MS = 10 * 60 * 1000; // 10 min with no log growth AND no live PID = stale
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export async function status() {
     if (!existsSync(STATE_DIR)) {
         console.log('No active session. Run: loom crew "<task>"');
@@ -42,21 +51,34 @@ export async function status() {
             console.log(`  [${workerId}] done ✓`);
             continue;
         }
-        // Check if log is growing (worker is alive) or stale
+        // Check PID liveness first — a quiet log doesn't mean a dead worker
+        const pidPath = join(workersDir, `${workerId}.pid`);
+        let pidAlive = false;
+        if (existsSync(pidPath)) {
+            const pid = parseInt(await readFile(pidPath, 'utf8').catch(() => ''), 10);
+            if (!isNaN(pid))
+                pidAlive = isProcessAlive(pid);
+        }
         const logStat = statSync(logPath);
         const msSinceWrite = now - logStat.mtimeMs;
-        const isStale = msSinceWrite > STALE_THRESHOLD_MS;
         const logSize = logStat.size;
-        if (logSize === 0) {
+        if (logSize === 0 && pidAlive) {
+            console.log(`  [${workerId}] starting... (pid alive)`);
+        }
+        else if (logSize === 0) {
             console.log(`  [${workerId}] starting...`);
         }
-        else if (isStale) {
+        else if (pidAlive) {
+            const secs = Math.round(msSinceWrite / 1000);
+            console.log(`  [${workerId}] running  (pid alive, last log ${secs}s ago)`);
+        }
+        else if (msSinceWrite > STALE_THRESHOLD_MS) {
             const mins = Math.round(msSinceWrite / 60000);
-            console.log(`  [${workerId}] STALE — no activity for ${mins}m (log: ${logPath})`);
+            console.log(`  [${workerId}] STALE — pid dead, no log activity for ${mins}m`);
         }
         else {
             const secs = Math.round(msSinceWrite / 1000);
-            console.log(`  [${workerId}] running  (last activity ${secs}s ago)`);
+            console.log(`  [${workerId}] stopped? — pid dead, last log ${secs}s ago`);
         }
     }
     const allDone = logFiles.every(f => existsSync(join(workersDir, f.replace('.log', '-result.md'))));

package/dist/team/queue.js

@@ -1,10 +1,10 @@
-import { readdir, readFile, rename, writeFile } from 'fs/promises';
+import { readdir, readFile, rename, writeFile, stat, unlink } from 'fs/promises';
 import { join } from 'path';
 import { STATE_DIR } from '../state/session.js';
 const TASKS_DIR = join(STATE_DIR, 'tasks');
-const CLAIM_TTL_MS = 30 * 60 * 1000; // 30 minutes — claimed tasks older than this are re-queued
+const CLAIM_TTL_MS = 30 * 60 * 1000; // 30 minutes
 // Recover tasks whose worker crashed before completing.
-// Finds -claimed- files older than CLAIM_TTL_MS and renames them back to -pending.json.
+// Finds -claimed- files older than CLAIM_TTL_MS and re-queues them as -pending.
 export async function recoverStaleClaims() {
     let recovered = 0;
     let files;
@@ -19,24 +19,21 @@ export async function recoverStaleClaims() {
     for (const file of claimed) {
         const filePath = join(TASKS_DIR, file);
         try {
-            const { mtimeMs } = await import('fs/promises').then(m => m.stat(filePath));
+            const { mtimeMs } = await stat(filePath);
             if (now - mtimeMs < CLAIM_TTL_MS)
                 continue;
-            // Parse task id from filename: {id}-claimed-{workerId}.json
             const taskId = file.split('-claimed-')[0];
             if (!taskId)
                 continue;
-            const pendingPath = join(TASKS_DIR, `${taskId}-pending.json`);
-            // Re-read the file and reset status before writing back as pending
             const task = JSON.parse(await readFile(filePath, 'utf8'));
             task.status = 'pending';
             delete task.workerId;
             delete task.claimedAt;
+            const pendingPath = join(TASKS_DIR, `${taskId}-pending.json`);
+            // Write the reset task to the pending path, then remove the stale claimed file.
+            // (Do NOT rename claimed→pending: that would overwrite our fresh write with stale data.)
             await writeFile(pendingPath, JSON.stringify(task, null, 2));
-            await rename(filePath, pendingPath).catch(() => {
-                // If the write succeeded but rename fails (e.g. destination now exists from another
-                // recovery run), leave it — the pending file was already written
-            });
+            await unlink(filePath).catch(() => { });
             recovered++;
         }
         catch {
@@ -61,11 +58,8 @@ export async function claimTask(workerId) {
         const newFile = file.replace('-pending.json', `-claimed-${workerId}.json`);
         const newPath = join(TASKS_DIR, newFile);
         try {
-            // Prepare the updated task object BEFORE the rename.
-            // If writeFile fails after a successful rename, we rename back so the task
-            // re-enters the pending pool rather than being stuck as claimed with stale data.
-            const raw = await readFile(oldPath, 'utf8');
-            const task = JSON.parse(raw);
+            // Prepare updated task object BEFORE the rename.
+            const task = JSON.parse(await readFile(oldPath, 'utf8'));
             task.status = 'claimed';
             task.workerId = workerId;
             task.claimedAt = new Date().toISOString();
@@ -78,12 +72,20 @@ export async function claimTask(workerId) {
             catch (writeErr) {
                 // Rename succeeded but write failed — roll back so the task isn't orphaned
                 await rename(newPath, oldPath).catch(() => { });
-                throw writeErr;
+                // Log genuine I/O errors (disk full, permissions) — these are not race conditions
+                process.stderr.write(`[agentloom] claimTask writeFile failed for ${file}: ${writeErr}\n`);
+                // Continue to next task rather than crashing — another task may succeed
+                continue;
             }
             return task;
         }
-        catch {
-            // Another worker claimed it first (ENOENT/EPERM), or rollback — try next
+        catch (err) {
+            // ENOENT/EPERM = another worker claimed it first — expected, try next file
+            // Any other error is unexpected; log and skip
+            const code = err.code;
+            if (code !== 'ENOENT' && code !== 'EPERM' && code !== 'EACCES') {
+                process.stderr.write(`[agentloom] claimTask unexpected error for ${file}: ${err}\n`);
+            }
             continue;
         }
     }
@@ -101,7 +103,7 @@ export async function completeTask(task, result) {
         await rename(claimedFile, doneFile);
     }
     catch {
-        // If the claimed file is already gone (double-complete), write directly to done path
+        // Double-complete or missing claimed file — write directly to done path
         await writeFile(doneFile, JSON.stringify(task, null, 2)).catch(() => { });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chuckssmith/agentloom",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "A workflow layer for Claude Code — reusable roles, persistence loops, and multi-agent crew coordination",
   "keywords": [
     "ai",