@chuckssmith/agentloom 0.9.0 → 1.0.0

package/dist/commands/collect.js

@@ -2,7 +2,7 @@ import { readFile, readdir, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { existsSync } from 'fs';
 import { spawnSync } from 'child_process';
-import { STATE_DIR, readSession, readTasks } from '../state/session.js';
+import { STATE_DIR, readSession } from '../state/session.js';
 const WORKERS_DIR = join(STATE_DIR, 'workers');
 export async function collect(args) {
     if (!existsSync(WORKERS_DIR)) {
@@ -10,7 +10,6 @@ export async function collect(args) {
         return;
     }
     const session = await readSession();
-    const tasks = await readTasks();
     const files = await readdir(WORKERS_DIR);
     const resultFiles = files.filter(f => f.endsWith('-result.md')).sort();
     if (resultFiles.length === 0) {
@@ -34,7 +33,7 @@ export async function collect(args) {
     const synthesize = !args.includes('--no-ai');
     let synthesis = '';
     if (synthesize) {
-        console.log('\nSynthesizing with Claude...');
+        console.log('\nSynthesizing with Claude... (may take up to 60s)');
         const prompt = `You are summarizing the results of a multi-agent crew that worked on this task:
 
 "${taskDesc}"

package/dist/commands/crew.js

@@ -74,6 +74,7 @@ export async function crew(args) {
     const watchAfter = args.includes('--watch');
     const filteredArgs = args.filter(a => !['--dry-run', '--serial', '--watch'].includes(a));
     const config = await loadConfig();
+    const forcePermissions = config.dangerouslySkipPermissions === true;
     const { specs, task } = parseWorkerSpec(filteredArgs, config.workers, config.agentType);
     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, '');
@@ -99,23 +100,23 @@ export async function crew(args) {
     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 contextPath = await writeContextSnapshot(slug, session.id, task);
     const tasks = await decomposeTasks(task, specs);
     console.log(`Session: ${session.id}`);
     console.log(`Tasks:   ${tasks.length} created`);
     console.log(`Context: ${contextPath}\n`);
     if (serial) {
-        await launchSerial(session.id, specs, tasks, contextPath);
+        await launchSerial(session.id, specs, tasks, contextPath, forcePermissions);
         console.log(`\nAll workers finished. Run: loom collect`);
     }
     else if (useTmux) {
-        await launchTmux(session.id, specs, tasks, contextPath);
+        await launchTmux(session.id, specs, tasks, contextPath, forcePermissions);
         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);
+        await launchBackground(session.id, specs, tasks, contextPath, forcePermissions);
         if (watchAfter) {
             console.log();
             await watch([]);
@@ -128,7 +129,7 @@ export async function crew(args) {
     }
     console.log(`State dir: ${STATE_DIR}/`);
 }
-async function launchSerial(sessionId, specs, tasks, contextPath) {
+async function launchSerial(sessionId, specs, tasks, contextPath, forcePermissions = false) {
     await mkdir(join(STATE_DIR, 'workers'), { recursive: true });
     let workerIdx = 0;
     for (const spec of specs) {
@@ -144,7 +145,7 @@ async function launchSerial(sessionId, specs, tasks, contextPath) {
             console.log(`  → Worker ${workerId} (${agentType}) starting...`);
             const claudeArgs = [
                 '--print',
-                ...(!READ_ONLY_ROLES.has(agentType) ? ['--dangerously-skip-permissions'] : []),
+                ...(forcePermissions || !READ_ONLY_ROLES.has(agentType) ? ['--dangerously-skip-permissions'] : []),
                 '-p',
                 prompt,
             ];
@@ -173,7 +174,7 @@ async function launchSerial(sessionId, specs, tasks, contextPath) {
         }
     }
 }
-async function launchBackground(sessionId, specs, tasks, contextPath) {
+async function launchBackground(sessionId, specs, tasks, contextPath, forcePermissions = false) {
     await mkdir(join(STATE_DIR, 'workers'), { recursive: true });
     let workerIdx = 0;
     for (const spec of specs) {
@@ -189,7 +190,7 @@ async function launchBackground(sessionId, specs, tasks, contextPath) {
             // Build args declaratively — no positional splicing
             const claudeArgs = [
                 '--print',
-                ...(!READ_ONLY_ROLES.has(agentType) ? ['--dangerously-skip-permissions'] : []),
+                ...(forcePermissions || !READ_ONLY_ROLES.has(agentType) ? ['--dangerously-skip-permissions'] : []),
                 '-p',
                 prompt,
             ];
@@ -212,7 +213,7 @@ async function launchBackground(sessionId, specs, tasks, contextPath) {
         }
     }
 }
-async function launchTmux(sessionId, specs, tasks, contextPath) {
+async function launchTmux(sessionId, specs, tasks, contextPath, forcePermissions = false) {
     const tmuxSession = `loom-${sessionId}`;
     // Check for session name collision
     const existing = spawnSync('tmux', ['has-session', '-t', tmuxSession], { stdio: 'ignore' });
@@ -246,7 +247,7 @@ async function launchTmux(sessionId, specs, tasks, contextPath) {
                 `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 args = ['--print', ${(forcePermissions || !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)`,

package/dist/commands/logs.js

@@ -1,5 +1,5 @@
 import { readFile, readdir } from 'fs/promises';
-import { join } from 'path';
+import { join, basename } from 'path';
 import { existsSync } from 'fs';
 import { STATE_DIR } from '../state/session.js';
 const WORKERS_DIR = join(STATE_DIR, 'workers');
@@ -8,7 +8,9 @@ export async function logs(args) {
         console.log('No worker logs found. Run: loom crew "<task>"');
         return;
     }
-    const workerId = args[0];
+    // Sanitize workerId to prevent path traversal
+    const rawId = args[0];
+    const workerId = rawId ? basename(rawId) : undefined;
     if (workerId) {
         // Show log for a specific worker
         const logFile = join(WORKERS_DIR, `${workerId}.log`);

package/dist/commands/reset.js

@@ -1,6 +1,8 @@
-import { rm } from 'fs/promises';
+import { rm, readdir, readFile } from 'fs/promises';
 import { existsSync } from 'fs';
+import { join } from 'path';
 import { STATE_DIR } from '../state/session.js';
+const WORKERS_DIR = join(STATE_DIR, 'workers');
 export async function reset(args) {
     if (!existsSync(STATE_DIR)) {
         console.log('Nothing to reset.');
@@ -8,10 +10,33 @@ export async function reset(args) {
     }
     const force = args.includes('--force') || args.includes('-f');
     if (!force) {
-        console.log(`This will delete all session state in ${STATE_DIR}/`);
+        console.log(`This will kill running workers and delete all session state in ${STATE_DIR}/`);
         console.log('Run with --force to confirm: loom reset --force');
         return;
     }
+    // Kill any live workers before deleting their PID files
+    if (existsSync(WORKERS_DIR)) {
+        try {
+            const files = await readdir(WORKERS_DIR);
+            const pidFiles = files.filter(f => f.endsWith('.pid'));
+            for (const pidFile of pidFiles) {
+                const pid = parseInt(await readFile(join(WORKERS_DIR, pidFile), 'utf8').catch(() => ''), 10);
+                if (!isNaN(pid)) {
+                    try {
+                        process.kill(pid, 'SIGTERM');
+                        const workerId = pidFile.replace('.pid', '');
+                        console.log(`  killed worker ${workerId} (pid ${pid})`);
+                    }
+                    catch {
+                        // Process already dead — ignore
+                    }
+                }
+            }
+        }
+        catch {
+            // Workers dir unreadable — proceed with delete anyway
+        }
+    }
     await rm(STATE_DIR, { recursive: true, force: true });
     console.log(`✓ Session state cleared (${STATE_DIR}/)`);
 }

package/dist/commands/setup.js

@@ -19,7 +19,14 @@ export async function setup() {
     }
     // 2. Install skills
     await mkdir(SKILLS_DEST, { recursive: true });
-    const skills = await readdir(SKILLS_SRC);
+    let skills;
+    try {
+        skills = await readdir(SKILLS_SRC);
+    }
+    catch {
+        console.error('✗ Could not find skills directory — package may be misconfigured');
+        process.exit(1);
+    }
     for (const skill of skills.filter(f => f.endsWith('.md'))) {
         const dest = join(SKILLS_DEST, skill);
         await copyFile(join(SKILLS_SRC, skill), dest);

package/dist/commands/stop.js

@@ -45,6 +45,9 @@ export async function stop(args) {
     }
     console.log(`\n${killed} killed, ${notFound} already stopped.`);
     if (killed > 0) {
+        if (process.platform === 'win32') {
+            console.log('  note: SIGTERM on Windows is a force kill (TerminateProcess)');
+        }
         console.log('State preserved. Run: loom reset --force  to clear it.');
     }
 }

package/dist/commands/watch.js

@@ -4,24 +4,39 @@ import { existsSync } from 'fs';
 import { STATE_DIR } from '../state/session.js';
 const WORKERS_DIR = join(STATE_DIR, 'workers');
 const POLL_MS = 800;
-// A rotating set of ANSI colors for worker prefixes
+const STALE_TIMEOUT_MS = 15 * 60 * 1000; // 15 min no log growth + dead PID = give up
 const COLORS = ['\x1b[36m', '\x1b[33m', '\x1b[35m', '\x1b[32m', '\x1b[34m', '\x1b[31m'];
 const RESET = '\x1b[0m';
 const DIM = '\x1b[2m';
+const YELLOW = '\x1b[33m';
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export async function watch(_args) {
     if (!existsSync(WORKERS_DIR)) {
         console.log('No active session. Run: loom crew "<task>"');
         process.exit(1);
     }
     console.log(`${DIM}Watching worker logs. Ctrl+C to stop.${RESET}\n`);
-    // Track how many bytes we've read from each log file
     const offsets = {};
+    const lastGrowth = {};
     const seen = new Set();
-    // eslint-disable-next-line no-constant-condition
     while (true) {
         if (!existsSync(WORKERS_DIR))
             break;
-        const files = await readdir(WORKERS_DIR);
+        let files;
+        try {
+            files = await readdir(WORKERS_DIR);
+        }
+        catch {
+            break;
+        }
         const logFiles = files.filter(f => f.endsWith('.log')).sort();
         for (const logFile of logFiles) {
             const workerId = logFile.replace('.log', '');
@@ -32,20 +47,27 @@ export async function watch(_args) {
                 const resultExists = existsSync(join(WORKERS_DIR, `${workerId}-result.md`));
                 console.log(`${color}[${workerId}]${RESET} ${DIM}started${resultExists ? ' (already done)' : ''}${RESET}`);
             }
-            const currentSize = (await stat(filePath)).size;
+            // Guard stat — file may be deleted mid-poll (e.g. loom reset)
+            let currentSize;
+            try {
+                currentSize = (await stat(filePath)).size;
+            }
+            catch {
+                continue;
+            }
             const offset = offsets[workerId] ?? 0;
             if (currentSize > offset) {
-                const buf = await readFile(filePath);
-                const newContent = buf.slice(offset).toString('utf8');
-                offsets[workerId] = currentSize;
-                const lines = newContent.split('\n');
-                for (const line of lines) {
-                    if (line.trim()) {
-                        process.stdout.write(`${color}[${workerId}]${RESET} ${line}\n`);
+                lastGrowth[workerId] = Date.now();
+                const buf = await readFile(filePath).catch(() => null);
+                if (buf) {
+                    const newContent = buf.slice(offset).toString('utf8');
+                    offsets[workerId] = currentSize;
+                    for (const line of newContent.split('\n')) {
+                        if (line.trim())
+                            process.stdout.write(`${color}[${workerId}]${RESET} ${line}\n`);
                     }
                 }
             }
-            // Check if worker just finished (result file appeared)
             const resultPath = join(WORKERS_DIR, `${workerId}-result.md`);
             const doneKey = `${workerId}-done`;
             if (existsSync(resultPath) && !seen.has(doneKey)) {
@@ -55,14 +77,35 @@ export async function watch(_args) {
         }
         // Exit when all known workers have results
         if (logFiles.length > 0) {
-            const allDone = logFiles.every(f => {
-                const id = f.replace('.log', '');
-                return existsSync(join(WORKERS_DIR, `${id}-result.md`));
-            });
-            if (allDone) {
+            const workersDone = logFiles.map(f => f.replace('.log', '')).filter(id => existsSync(join(WORKERS_DIR, `${id}-result.md`)));
+            if (workersDone.length === logFiles.length) {
                 console.log(`\n${DIM}All workers done. Run: loom collect${RESET}`);
                 break;
             }
+            // Stale detection: workers with no result, dead PID, and log silent for >15min
+            const now = Date.now();
+            const staleWorkers = [];
+            for (const logFile of logFiles) {
+                const id = logFile.replace('.log', '');
+                if (existsSync(join(WORKERS_DIR, `${id}-result.md`)))
+                    continue;
+                const pidPath = join(WORKERS_DIR, `${id}.pid`);
+                let pidAlive = false;
+                if (existsSync(pidPath)) {
+                    const pid = parseInt(await readFile(pidPath, 'utf8').catch(() => ''), 10);
+                    if (!isNaN(pid))
+                        pidAlive = isProcessAlive(pid);
+                }
+                const sinceGrowth = now - (lastGrowth[id] ?? now);
+                if (!pidAlive && sinceGrowth > STALE_TIMEOUT_MS) {
+                    staleWorkers.push(id);
+                }
+            }
+            if (staleWorkers.length > 0 && staleWorkers.length + workersDone.length === logFiles.length) {
+                console.log(`\n${YELLOW}Workers stalled (dead PID, no output for 15min): ${staleWorkers.join(', ')}${RESET}`);
+                console.log(`${DIM}Run: loom logs <workerId>  to inspect. loom collect to gather what's available.${RESET}`);
+                break;
+            }
         }
         await new Promise(resolve => setTimeout(resolve, POLL_MS));
     }

package/dist/state/session.d.ts

@@ -12,14 +12,6 @@ export type Task = {
     claimedAt?: string;
     completedAt?: string;
 };
-export type Worker = {
-    id: string;
-    agentType: string;
-    status: 'idle' | 'working' | 'done';
-    currentTaskId?: string;
-    startedAt: string;
-    completedAt?: string;
-};
 export type Session = {
     id: string;
     description: string;
@@ -34,6 +26,4 @@ export declare function ensureStateDir(): Promise<void>;
 export declare function writeSession(session: Session): Promise<void>;
 export declare function readSession(): Promise<Session | null>;
 export declare function writeTask(task: Task): Promise<void>;
-export declare function writeWorker(worker: Worker): Promise<void>;
-export declare function readWorkers(): Promise<Worker[]>;
 export declare function readTasks(): Promise<Task[]>;

package/dist/state/session.js

@@ -1,6 +1,5 @@
-import { readFile, writeFile, mkdir } from 'fs/promises';
+import { readFile, writeFile, mkdir, readdir } from 'fs/promises';
 import { join } from 'path';
-import { existsSync } from 'fs';
 export const STATE_DIR = '.claude-team';
 export async function ensureStateDir() {
     await mkdir(join(STATE_DIR, 'tasks'), { recursive: true });
@@ -11,30 +10,23 @@ export async function writeSession(session) {
     await writeFile(join(STATE_DIR, 'session.json'), JSON.stringify(session, null, 2));
 }
 export async function readSession() {
-    const path = join(STATE_DIR, 'session.json');
-    if (!existsSync(path))
+    try {
+        return JSON.parse(await readFile(join(STATE_DIR, 'session.json'), 'utf8'));
+    }
+    catch {
         return null;
-    return JSON.parse(await readFile(path, 'utf8'));
+    }
 }
 export async function writeTask(task) {
     await writeFile(join(STATE_DIR, 'tasks', `${task.id}-${task.status}.json`), JSON.stringify(task, null, 2));
 }
-export async function writeWorker(worker) {
-    await writeFile(join(STATE_DIR, 'workers', `${worker.id}.json`), JSON.stringify(worker, null, 2));
-}
-export async function readWorkers() {
-    const { readdir } = await import('fs/promises');
-    const dir = join(STATE_DIR, 'workers');
-    if (!existsSync(dir))
-        return [];
-    const files = await readdir(dir);
-    return Promise.all(files.filter(f => f.endsWith('.json')).map(async (f) => JSON.parse(await readFile(join(dir, f), 'utf8'))));
-}
 export async function readTasks() {
-    const { readdir } = await import('fs/promises');
     const dir = join(STATE_DIR, 'tasks');
-    if (!existsSync(dir))
+    try {
+        const files = await readdir(dir);
+        return Promise.all(files.filter(f => f.endsWith('.json')).map(async (f) => JSON.parse(await readFile(join(dir, f), 'utf8'))));
+    }
+    catch {
         return [];
-    const files = await readdir(dir);
-    return Promise.all(files.filter(f => f.endsWith('.json')).map(async (f) => JSON.parse(await readFile(join(dir, f), 'utf8'))));
+    }
 }

package/dist/team/orchestrator.d.ts

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

package/dist/team/orchestrator.js

@@ -17,10 +17,11 @@ export function parseWorkerSpec(args, defaultWorkers = 2, defaultAgentType = 'ge
     const parts = specArg.split('+');
     const specs = parts.map(part => {
         const [countStr, agentType] = part.split(':');
-        return {
-            count: parseInt(countStr ?? '1'),
-            agentType: agentType ?? defaultAgentType,
-        };
+        const count = parseInt(countStr ?? '1');
+        if (isNaN(count) || count < 1) {
+            throw new Error(`Invalid worker spec "${part}" — count must be a positive integer`);
+        }
+        return { count, agentType: agentType ?? defaultAgentType };
     });
     return { specs, task };
 }
@@ -36,9 +37,10 @@ export async function initSession(description, workerCount) {
     await writeSession(session);
     return session;
 }
-export async function writeContextSnapshot(slug, task) {
-    const path = join(STATE_DIR, 'context', `${slug}.md`);
-    const content = `# Task Context\n\n**Task:** ${task}\n\n**Started:** ${new Date().toISOString()}\n\n## Notes\n\n_Workers will append findings here._\n`;
+export async function writeContextSnapshot(slug, sessionId, task) {
+    // Include session ID so concurrent runs with similar task names don't clobber each other
+    const path = join(STATE_DIR, 'context', `${slug}-${sessionId.slice(0, 6)}.md`);
+    const content = `# Task Context\n\n**Task:** ${task}\n\n**Session:** ${sessionId}\n\n**Started:** ${new Date().toISOString()}\n\n## Notes\n\n_Workers will append findings here._\n`;
     await writeFile(path, content);
     return path;
 }
@@ -75,9 +77,9 @@ Task: "${task}"`;
             encoding: 'utf8',
             timeout: 30_000,
         });
-        if (result.status !== 0 || !result.stdout)
+        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 = result.stdout.match(/\[[\s\S]*\]/);
         if (!match)
             throw new Error('No JSON array in response');
@@ -85,13 +87,12 @@ Task: "${task}"`;
         if (!Array.isArray(parsed) || parsed.length === 0)
             throw new Error('Empty array');
         const subtasks = parsed.map(String);
-        // Pad or trim to exactly n
         while (subtasks.length < n)
             subtasks.push(task);
         return subtasks.slice(0, n);
     }
-    catch {
-        // Fallback: every worker gets the same task description
+    catch (err) {
+        process.stderr.write(`[agentloom] Task decomposition failed (${err instanceof Error ? err.message : err}) — all workers will receive the same task description\n`);
         return Array(n).fill(task);
     }
 }

package/package.json

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