@chuckssmith/agentloom 0.7.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;

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/package.json

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