@chuckssmith/agentloom 0.6.0 → 0.7.0

package/dist/commands/crew.js

@@ -122,11 +122,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 +172,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 +196,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/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.7.0",
   "description": "A workflow layer for Claude Code — reusable roles, persistence loops, and multi-agent crew coordination",
   "keywords": [
     "ai",