@chuckssmith/agentloom 0.2.0 → 0.3.0

package/dist/cli.js

@@ -2,15 +2,19 @@
 import { setup } from './commands/setup.js';
 import { crew } from './commands/crew.js';
 import { status } from './commands/status.js';
+import { logs } from './commands/logs.js';
 const [, , command, ...args] = process.argv;
 const usage = `
 agentloom (loom) — workflow layer for Claude Code
 
 Usage:
-  loom setup                       Install skills and initialize state dir
-  loom crew [N] "<task>"           Spawn N parallel workers on a task
-  loom crew 2:explore "<task>"     Spawn typed workers (explore/plan/code-reviewer)
-  loom status                      Show active crew session
+  loom setup                            Install skills and initialize state dir
+  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 status                           Show active crew session
+  loom logs                             Show worker output summary
+  loom logs <workerId>                  Show full log for a specific worker
 
 Modes (use $grind or $crew inside a Claude Code session):
   $grind   Persistence loop — keeps working until verified complete
@@ -21,6 +25,9 @@ Examples:
   loom crew "refactor the auth module"
   loom crew 3 "audit every API endpoint for security issues"
   loom crew 2:explore+1:code-reviewer "review the payment flow"
+  loom crew --dry-run 3 "migrate the database schema"
+  loom logs
+  loom logs w00
 `;
 switch (command) {
     case 'setup':
@@ -32,6 +39,9 @@ switch (command) {
     case 'status':
         await status();
         break;
+    case 'logs':
+        await logs(args);
+        break;
     default:
         console.log(usage);
         process.exit(command ? 1 : 0);

package/dist/commands/crew.js

@@ -1,5 +1,5 @@
 import { execSync, spawn } from 'child_process';
-import { writeFile, mkdir } from 'fs/promises';
+import { writeFile, mkdir, open } from 'fs/promises';
 import { join } from 'path';
 import { parseWorkerSpec, initSession, writeContextSnapshot, decomposeTasks, } from '../team/orchestrator.js';
 import { STATE_DIR } from '../state/session.js';
@@ -15,15 +15,32 @@ const hasTmux = () => {
 const isWSL = () => process.platform === 'linux' && !!process.env.WSL_DISTRO_NAME;
 export async function crew(args) {
     if (args.length === 0) {
-        console.error('Usage: loom crew [N] "<task>"');
+        console.error('Usage: loom crew [--dry-run] [N] "<task>"');
         process.exit(1);
     }
-    const { specs, task } = parseWorkerSpec(args);
+    const dryRun = args.includes('--dry-run');
+    const filteredArgs = args.filter(a => a !== '--dry-run');
+    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, '');
     console.log(`\nagentloom crew`);
     console.log(`Task:    ${task}`);
     console.log(`Workers: ${totalWorkers}`);
+    if (dryRun) {
+        console.log(`Mode:    dry-run\n`);
+        console.log('Decomposing task...\n');
+        const tasks = await decomposeTasks(task, specs, true);
+        let idx = 0;
+        for (const spec of specs) {
+            for (let i = 0; i < spec.count; i++) {
+                const t = tasks[idx++];
+                console.log(`  [w${String(idx - 1).padStart(2, '0')}] (${spec.agentType})`);
+                console.log(`       ${t?.description ?? task}\n`);
+            }
+        }
+        console.log('Run without --dry-run to launch workers.');
+        return;
+    }
     console.log(`Mode:    ${hasTmux() && !isWSL() ? 'tmux' : 'background processes'}\n`);
     const session = await initSession(task, totalWorkers);
     const contextPath = await writeContextSnapshot(slug, task);
@@ -31,65 +48,71 @@ export async function crew(args) {
     console.log(`Session: ${session.id}`);
     console.log(`Tasks:   ${tasks.length} created`);
     console.log(`Context: ${contextPath}\n`);
-    const workerPrompt = buildWorkerPrompt(task, contextPath, session.id);
     if (hasTmux() && !isWSL()) {
-        await launchTmux(session.id, totalWorkers, specs, workerPrompt);
+        await launchTmux(session.id, totalWorkers, specs, tasks.map(t => t.description), contextPath);
     }
     else {
-        await launchBackground(session.id, totalWorkers, specs, workerPrompt);
+        await launchBackground(session.id, specs, tasks.map(t => t.description), contextPath);
     }
-    console.log(`\nWorkers launched. Monitor with: loom status`);
+    console.log(`\nWorkers launched. Monitor with:`);
+    console.log(`  loom status`);
+    console.log(`  loom logs`);
     console.log(`State dir: ${STATE_DIR}/`);
 }
-function buildWorkerPrompt(task, contextPath, sessionId) {
-    return `You are a worker agent in an agentloom crew session (${sessionId}).
+function buildWorkerPrompt(subtask, contextPath, sessionId, workerId) {
+    const resultFile = join(STATE_DIR, 'workers', `${workerId}-result.md`);
+    return `You are worker ${workerId} in an agentloom crew session (${sessionId}).
 
-Your job: help complete this task: "${task}"
+Your assigned subtask: "${subtask}"
 
-## Your protocol
+## Protocol
 
-1. Read the shared context at: ${contextPath}
-2. Check ${STATE_DIR}/tasks/ for unclaimed work (files ending in -pending.json)
-3. Claim a task by reading it and noting the task ID
-4. Do the work thoroughly using all tools available to you
-5. Write your result back to ${STATE_DIR}/workers/
-6. Repeat until no pending tasks remain
+1. Read the shared context: ${contextPath}
+2. Do the work thoroughly using all tools available to you
+3. When done, write a result summary to: ${resultFile}
+   Format: brief markdown — what you did, what you found, any blockers
 
 ## Rules
-- Claim only one task at a time
-- Write your findings to the context file so other workers can see them
-- Do not stop until you have completed at least one task
-- If all tasks are claimed, do exploratory work relevant to the main task
+- Focus only on your assigned subtask
+- Write findings to the context file (${contextPath}) so other workers can see them
+- Do not stop until your subtask is complete or you have hit a genuine blocker
 
-Begin now. Check for pending tasks and start working.`;
+Begin now.`;
 }
-async function launchBackground(sessionId, count, specs, prompt) {
+async function launchBackground(sessionId, specs, subtasks, 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 = subtasks[workerIdx] ?? subtasks[0] ?? '';
             workerIdx++;
-            const promptFile = join(STATE_DIR, 'workers', `${workerId}-prompt.md`);
-            await writeFile(promptFile, prompt);
+            const prompt = buildWorkerPrompt(subtask, contextPath, sessionId, workerId);
+            const logFile = join(STATE_DIR, 'workers', `${workerId}.log`);
+            // Write prompt to disk for inspection
+            await writeFile(join(STATE_DIR, 'workers', `${workerId}-prompt.md`), prompt);
+            const log = await open(logFile, 'w');
             const child = spawn('claude', ['--print', '--dangerously-skip-permissions', '-p', prompt], {
                 detached: true,
-                stdio: ['ignore', 'ignore', 'ignore'],
+                stdio: ['ignore', log.fd, log.fd],
                 env: { ...process.env, AGENTLOOM_WORKER_ID: workerId, AGENTLOOM_SESSION: sessionId },
             });
+            child.on('close', () => log.close());
             child.unref();
-            console.log(`  ✓ Worker ${workerId} (${spec.agentType}) launched [pid ${child.pid}]`);
+            console.log(`  ✓ Worker ${workerId} (${spec.agentType}) launched [pid ${child.pid}] → ${logFile}`);
         }
     }
 }
-async function launchTmux(sessionId, count, specs, prompt) {
+async function launchTmux(sessionId, count, specs, subtasks, contextPath) {
     const tmuxSession = `loom-${sessionId}`;
     execSync(`tmux new-session -d -s ${tmuxSession} -x 220 -y 50`);
     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 = subtasks[workerIdx] ?? subtasks[0] ?? '';
             workerIdx++;
+            const prompt = buildWorkerPrompt(subtask, contextPath, sessionId, workerId);
             if (workerIdx > 1) {
                 execSync(`tmux split-window -h -t ${tmuxSession}`);
                 execSync(`tmux select-layout -t ${tmuxSession} tiled`);

package/dist/commands/logs.d.ts

@@ -0,0 +1 @@
+export declare function logs(args: string[]): Promise<void>;

package/dist/commands/logs.js

@@ -0,0 +1,53 @@
+import { readFile, readdir } from 'fs/promises';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { STATE_DIR } from '../state/session.js';
+const WORKERS_DIR = join(STATE_DIR, 'workers');
+export async function logs(args) {
+    if (!existsSync(WORKERS_DIR)) {
+        console.log('No worker logs found. Run: loom crew "<task>"');
+        return;
+    }
+    const workerId = args[0];
+    if (workerId) {
+        // Show log for a specific worker
+        const logFile = join(WORKERS_DIR, `${workerId}.log`);
+        const resultFile = join(WORKERS_DIR, `${workerId}-result.md`);
+        if (existsSync(logFile)) {
+            console.log(`\n── ${workerId} log ──────────────────────────────`);
+            console.log(await readFile(logFile, 'utf8'));
+        }
+        if (existsSync(resultFile)) {
+            console.log(`\n── ${workerId} result ─────────────────────────`);
+            console.log(await readFile(resultFile, 'utf8'));
+        }
+        if (!existsSync(logFile) && !existsSync(resultFile)) {
+            console.log(`No logs found for worker: ${workerId}`);
+        }
+        return;
+    }
+    // List all workers with status summary
+    const files = await readdir(WORKERS_DIR);
+    const logFiles = files.filter(f => f.endsWith('.log')).sort();
+    if (logFiles.length === 0) {
+        console.log('No worker logs yet.');
+        return;
+    }
+    for (const logFile of logFiles) {
+        const id = logFile.replace('.log', '');
+        const content = await readFile(join(WORKERS_DIR, logFile), 'utf8');
+        const lines = content.trim().split('\n');
+        const hasResult = existsSync(join(WORKERS_DIR, `${id}-result.md`));
+        const status = hasResult ? 'done' : lines.length > 0 ? 'running/stopped' : 'empty';
+        const lastLine = lines.filter(l => l.trim()).at(-1)?.slice(0, 80) ?? '';
+        console.log(`\n[${id}] ${status}`);
+        if (lastLine)
+            console.log(`  ${lastLine}`);
+        if (hasResult) {
+            const result = await readFile(join(WORKERS_DIR, `${id}-result.md`), 'utf8');
+            const firstLine = result.trim().split('\n')[0] ?? '';
+            console.log(`  result: ${firstLine}`);
+        }
+    }
+    console.log(`\nFull log: loom logs <workerId>`);
+}

package/dist/team/orchestrator.d.ts

@@ -9,4 +9,4 @@ export declare function parseWorkerSpec(args: string[]): {
 };
 export declare function initSession(description: string, workerCount: number): Promise<Session>;
 export declare function writeContextSnapshot(slug: string, task: string): Promise<string>;
-export declare function decomposeTasks(task: string, specs: WorkerSpec[]): Promise<Task[]>;
+export declare function decomposeTasks(task: string, specs: WorkerSpec[], dryRun?: boolean): Promise<Task[]>;

package/dist/team/orchestrator.js

@@ -1,7 +1,7 @@
 import { writeFile } from 'fs/promises';
 import { join } from 'path';
 import { randomUUID } from 'crypto';
-import { execSync } from 'child_process';
+import { spawnSync } from 'child_process';
 import { STATE_DIR, ensureStateDir, writeSession, writeTask } from '../state/session.js';
 export function parseWorkerSpec(args) {
     // Formats:
@@ -47,9 +47,9 @@ export async function writeContextSnapshot(slug, task) {
     await writeFile(path, content);
     return path;
 }
-export async function decomposeTasks(task, specs) {
+export async function decomposeTasks(task, specs, dryRun = false) {
     const totalWorkers = specs.reduce((sum, s) => sum + s.count, 0);
-    const subtasks = await callClaudeDecompose(task, totalWorkers);
+    const subtasks = callClaudeDecompose(task, totalWorkers);
     const tasks = [];
     let idx = 0;
     for (const spec of specs) {
@@ -62,7 +62,8 @@ export async function decomposeTasks(task, specs) {
                 createdAt: new Date().toISOString(),
             };
             tasks.push(t);
-            await writeTask(t);
+            if (!dryRun)
+                await writeTask(t);
             idx++;
         }
     }
@@ -75,14 +76,14 @@ function callClaudeDecompose(task, n) {
 
 Task: "${task}"`;
     try {
-        const escaped = prompt.replace(/'/g, `'"'"'`);
-        const raw = execSync(`claude --print -p '${escaped}'`, {
+        const result = spawnSync('claude', ['--print', '-p', prompt], {
             encoding: 'utf8',
             timeout: 30_000,
-            stdio: ['ignore', 'pipe', 'ignore'],
-        }).trim();
+        });
+        if (result.status !== 0 || !result.stdout)
+            throw new Error(result.stderr ?? 'no output');
         // Extract JSON array from the response (strip any surrounding prose)
-        const match = raw.match(/\[[\s\S]*\]/);
+        const match = result.stdout.match(/\[[\s\S]*\]/);
         if (!match)
             throw new Error('No JSON array in response');
         const parsed = JSON.parse(match[0]);

package/package.json

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