skimpyclaw 0.3.6 → 0.3.9

package/dist/code-agents/orchestrator.js

@@ -1,9 +1,15 @@
 // Code Agent Orchestrator - Team coordination logic
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
 import { getNextCodeAgentId, storeCodeAgentTask, writeCodeAgentTask, getCodeAgent } from './registry.js';
 import { runCodeAgentBackground, runValidation } from './executor.js';
 import { notifyCodeAgentResult } from './utils.js';
+import { parseAgentOutput, formatStructuredContext } from './structured-context.js';
 import { runAgentTurn } from '../agent.js';
 import { startTrace, addEvent, endTrace } from '../audit.js';
+import { toErrorMessage } from '../utils.js';
+import { isGitRepo, commitPendingChanges, createWorktree, mergeWorktree, removeWorktree, cleanupAllWorktrees, } from './worktree.js';
 /**
  * Compute execution waves from dependency info.
  * Returns an array of waves, where each wave is an array of subtask indices that can run in parallel.
@@ -44,14 +50,62 @@ export function computeWaves(subtasks) {
     }
     return waves;
 }
+/**
+ * Gather lightweight codebase context to improve task decomposition.
+ * Returns a short summary of the project structure (file tree, package.json scripts).
+ * Capped at ~2000 chars to keep the decomposition prompt small.
+ */
+export function gatherCodebaseContext(workdir) {
+    const parts = [];
+    // Package.json scripts
+    try {
+        const pkgPath = join(workdir, 'package.json');
+        if (existsSync(pkgPath)) {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            if (pkg.scripts) {
+                const scriptNames = Object.keys(pkg.scripts).slice(0, 15).join(', ');
+                parts.push(`Scripts: ${scriptNames}`);
+            }
+            if (pkg.dependencies || pkg.devDependencies) {
+                const deps = Object.keys({ ...pkg.dependencies, ...pkg.devDependencies }).slice(0, 20).join(', ');
+                parts.push(`Key deps: ${deps}`);
+            }
+        }
+    }
+    catch { /* ignore */ }
+    // Source file tree (top-level structure)
+    try {
+        const tree = execSync('find . -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.jsx" | grep -v node_modules | grep -v dist | grep -v .test. | sort | head -60', { cwd: workdir, timeout: 5000, encoding: 'utf-8' }).trim();
+        if (tree)
+            parts.push(`Source files:\n${tree}`);
+    }
+    catch { /* ignore */ }
+    const context = parts.join('\n\n');
+    return context.slice(0, 2000);
+}
 /**
  * Use a quick model call to decompose a complex task into N subtasks with optional dependency info.
  * Falls back to numbered subtask splitting on parse error.
  * Falls back to all-independent if dependency info is missing or invalid.
  */
-export async function decomposeTask(task, teamSize, config) {
+export async function decomposeTask(task, teamSize, config, workdir) {
     try {
-        const prompt = `Split into exactly ${teamSize} subtasks. Return JSON only: {"subtasks":[{"description":"...","dependsOn":[]},...]}. Use 0-based indices for dependsOn.\n\nTask: ${task}`;
+        // Gather codebase context for smarter decomposition
+        const codebaseContext = workdir ? gatherCodebaseContext(workdir) : '';
+        const contextBlock = codebaseContext
+            ? `\n\nProject structure:\n${codebaseContext}\n`
+            : '';
+        const prompt = `You are a task decomposition expert. Split the following coding task into exactly ${teamSize} independent or dependent subtasks that can be assigned to separate coding agents.
+
+Rules:
+- Each subtask should be self-contained with clear file scope
+- Each parallel agent gets its own git worktree (branch), so file overlap is OK but be aware changes are merged after
+- Use dependsOn to order subtasks that must run sequentially (e.g. create interface before implementation)
+- Be specific: mention exact files, functions, and expected changes
+- Return JSON only: {"subtasks":[{"description":"...","dependsOn":[]},...]}
+- Use 0-based indices for dependsOn
+${contextBlock}
+Task: ${task}`;
         const result = await runAgentTurn('main', prompt, config);
         const match = result.match(/\{[\s\S]*"subtasks"[\s\S]*\}/);
         if (match) {
@@ -96,15 +150,36 @@ export async function decomposeTask(task, teamSize, config) {
 /**
  * Use a quick model call to synthesize results from multiple subtask completions.
  */
-export async function synthesizeResults(originalTask, results, config) {
+export async function synthesizeResults(originalTask, results, config, workdir) {
     try {
-        const resultSummary = results.map((r, i) => `### Subtask ${i + 1}: ${r.subtask}\nStatus: ${r.status}\n${r.output ? `Output: ${r.output.slice(0, 300)}` : ''}${r.error ? `Error: ${r.error}` : ''}`).join('\n\n');
+        const resultSummary = results.map((r, i) => {
+            const context = r.output
+                ? formatStructuredContext(parseAgentOutput(r.output))
+                : '';
+            return `### Subtask ${i + 1}: ${r.subtask}\nStatus: ${r.status}\n${context}${r.error ? `\nError: ${r.error}` : ''}`;
+        }).join('\n\n');
+        // Include actual file changes from git for accuracy
+        let diffBlock = '';
+        if (workdir) {
+            try {
+                const diffStat = execSync('git diff --stat HEAD 2>/dev/null || git diff --stat 2>/dev/null', {
+                    cwd: workdir,
+                    timeout: 5000,
+                    encoding: 'utf-8',
+                }).trim();
+                if (diffStat)
+                    diffBlock = `\n\nActual file changes (git diff --stat):\n${diffStat.slice(0, 2000)}`;
+            }
+            catch { /* not a git repo or no changes */ }
+        }
+        const succeeded = results.filter(r => r.status === 'completed').length;
+        const failed = results.filter(r => r.status !== 'completed').length;
         const prompt = `You are a results synthesizer. Summarize the results of a multi-agent coding task.
 
 Original task: ${originalTask}
 
-Results from each agent:
-${resultSummary}
+Results from each agent (${succeeded} succeeded, ${failed} failed):
+${resultSummary}${diffBlock}
 
 Provide a concise markdown summary of what was accomplished, what succeeded, and what failed (if anything). Be specific about files changed and outcomes.`;
         return await runAgentTurn('main', prompt, config);
@@ -131,9 +206,15 @@ export async function runTeamOrchestrator(parentId, task, teamSize, workdir, val
         durationMs: 0,
         detail: { teamSize, workdir, agent, model, validate },
     });
-    const timeoutMinutes = Math.min(context?.fullConfig?.subagents?.maxConcurrent ? 60 : 20, 60);
-    const perChildTimeout = Math.max(5, Math.floor(timeoutMinutes / teamSize));
+    const configTeamTimeout = context?.fullConfig?.codeAgents?.teamTimeoutMinutes ?? 60;
+    const timeoutMinutes = Math.min(configTeamTimeout, 120);
+    // Reserve budget for overhead (decompose, synthesize, validation) and distribute rest across waves
+    const overheadMinutes = 5;
+    const availableForChildren = Math.max(timeoutMinutes - overheadMinutes, timeoutMinutes * 0.7);
     const CANCELLED_MESSAGE = 'Cancelled by user';
+    // Worktree state — declared outside try so catch can clean up
+    const _useWorktrees = isGitRepo(workdir);
+    const _activeWorktrees = new Map();
     try {
         if (getCodeAgent(parentId)?.status === 'cancelled')
             throw new Error(CANCELLED_MESSAGE);
@@ -143,8 +224,10 @@ export async function runTeamOrchestrator(parentId, task, teamSize, workdir, val
         const fullConfig = context?.fullConfig;
         if (!fullConfig)
             throw new Error('No config available for task decomposition');
-        const subtasks = await decomposeTask(task, teamSize, fullConfig);
+        const subtasks = await decomposeTask(task, teamSize, fullConfig, workdir);
         const waves = computeWaves(subtasks);
+        // Distribute timeout across waves (not team size) for better budgeting
+        const perChildTimeout = Math.max(5, Math.floor(availableForChildren / waves.length));
         addEvent(traceId, {
             type: 'decompose',
             summary: `Decomposed into ${subtasks.length} subtasks in ${waves.length} wave(s)`,
@@ -181,6 +264,20 @@ export async function runTeamOrchestrator(parentId, task, teamSize, workdir, val
         }
         parentTask.childTaskIds = childIds;
         writeCodeAgentTask(parentTask);
+        // Helper: get git diff summary for context passing between waves
+        function getGitDiffSummary() {
+            try {
+                const diff = execSync('git diff --stat HEAD 2>/dev/null || git diff --stat 2>/dev/null', {
+                    cwd: workdir,
+                    timeout: 5000,
+                    encoding: 'utf-8',
+                }).trim();
+                return diff ? diff.slice(0, 1500) : '';
+            }
+            catch {
+                return '';
+            }
+        }
         // Helper: build task prompt with predecessor context for dependent subtasks
         function buildChildPrompt(subtaskIdx) {
             const sub = subtasks[subtaskIdx];
@@ -190,12 +287,34 @@ export async function runTeamOrchestrator(parentId, task, teamSize, workdir, val
             for (const depIdx of sub.dependsOn) {
                 const depChild = getCodeAgent(childIdByIndex[depIdx]);
                 if (depChild && depChild.outputPreview) {
-                    contextParts.push(`- Task "${subtasks[depIdx].description}": ${depChild.outputPreview.slice(0, 1000)}`);
+                    // Use the full outputPreview (up to 5000 chars) not just the 500-char summary
+                    const structured = formatStructuredContext(parseAgentOutput(depChild.outputPreview));
+                    contextParts.push(`- Task "${subtasks[depIdx].description}" [${depChild.status}]:\n${structured}`);
                 }
             }
-            if (contextParts.length === 0)
+            // Include git diff to show what predecessor waves actually changed on disk
+            const diffSummary = getGitDiffSummary();
+            const diffBlock = diffSummary ? `\nFiles changed so far:\n${diffSummary}\n` : '';
+            if (contextParts.length === 0 && !diffBlock)
                 return sub.description;
-            return `Context from completed prerequisite tasks:\n${contextParts.join('\n')}\n\nYour task: ${sub.description}`;
+            return `Context from completed prerequisite tasks:\n${contextParts.join('\n')}${diffBlock}\nYour task: ${sub.description}`;
+        }
+        // Worktree isolation: parallel agents in the same wave get their own worktree
+        // so they can't overwrite each other's files. After the wave, branches are
+        // merged back sequentially. Falls back to shared workdir if not a git repo.
+        const useWorktrees = _useWorktrees;
+        const activeWorktrees = _activeWorktrees;
+        if (useWorktrees) {
+            // Clean up any stale worktrees from previous crashed runs
+            cleanupAllWorktrees(workdir);
+            addEvent(traceId, {
+                type: 'worktree',
+                summary: 'Git worktree isolation enabled',
+                durationMs: Date.now() - startedAt.getTime(),
+            });
+        }
+        else {
+            console.warn('[code-team] Not a git repo — agents will share workdir (risk of file conflicts)');
         }
         // Phase 3: Execute waves sequentially, tasks within each wave in parallel
         const POLL_INTERVAL = 3000;
@@ -210,29 +329,55 @@ export async function runTeamOrchestrator(parentId, task, teamSize, workdir, val
                 summary: `Starting wave ${waveIdx + 1}/${totalWaves} (${waveIndices.length} tasks)`,
                 durationMs: Date.now() - startedAt.getTime(),
             });
-            // Spawn all tasks in this wave
-            for (const subtaskIdx of waveIndices) {
-                const childId = childIdByIndex[subtaskIdx];
-                const child = getCodeAgent(childId);
-                const prompt = buildChildPrompt(subtaskIdx);
-                child.status = 'running';
-                child.task = prompt;
-                child.startedAt = new Date().toISOString();
-                writeCodeAgentTask(child);
-                runCodeAgentBackground(childId, agent, prompt, workdir, false, // children don't validate individually
-                { task: prompt, model, timeout_minutes: perChildTimeout }, new Date(), { skipNotification: true, defaultTimeoutMinutes: perChildTimeout, maxTimeoutMinutes: perChildTimeout }).catch((err) => {
+            // Helper: spawn a single child task in the given workdir
+            function spawnChild(childId, prompt, childWorkdir) {
+                runCodeAgentBackground(childId, agent, prompt, childWorkdir, false, // per-child validation is handled by the orchestrator below
+                { task: prompt, model, timeout_minutes: perChildTimeout }, new Date(), { skipNotification: true, defaultTimeoutMinutes: perChildTimeout, maxTimeoutMinutes: perChildTimeout, validationCommands: fullConfig?.codeAgents?.validationCommands }).catch((err) => {
                     const child = getCodeAgent(childId);
                     if (child && child.status === 'running') {
                         Object.assign(child, {
                             status: 'failed',
                             endedAt: new Date().toISOString(),
-                            error: err instanceof Error ? err.message : String(err),
+                            error: toErrorMessage(err),
                         });
                         writeCodeAgentTask(child);
                     }
                     console.error(`[code-team] Child ${childId} background error:`, err);
                 });
             }
+            // Create worktrees for parallel tasks (waves with >1 child)
+            const useWorktreeForWave = useWorktrees && waveIndices.length > 1;
+            if (useWorktreeForWave) {
+                // Commit any pending changes so worktrees branch from a clean state
+                commitPendingChanges(workdir, `[skimpyclaw] pre-wave-${waveIdx + 1}`);
+                parentTask.liveOutput = `Phase: Creating worktrees for wave ${waveIdx + 1}...`;
+                writeCodeAgentTask(parentTask);
+            }
+            // Spawn all tasks in this wave
+            for (const subtaskIdx of waveIndices) {
+                const childId = childIdByIndex[subtaskIdx];
+                const child = getCodeAgent(childId);
+                const prompt = buildChildPrompt(subtaskIdx);
+                // Determine workdir for this child
+                let childWorkdir = workdir;
+                if (useWorktreeForWave) {
+                    try {
+                        const wt = createWorktree(workdir, childId);
+                        activeWorktrees.set(childId, wt);
+                        childWorkdir = wt.path;
+                        console.log(`[code-team] Created worktree for ${childId}: ${wt.path} (branch ${wt.branch})`);
+                    }
+                    catch (err) {
+                        console.error(`[code-team] Failed to create worktree for ${childId}, using shared workdir:`, err);
+                    }
+                }
+                child.status = 'running';
+                child.task = prompt;
+                child.workdir = childWorkdir;
+                child.startedAt = new Date().toISOString();
+                writeCodeAgentTask(child);
+                spawnChild(childId, prompt, childWorkdir);
+            }
             // Poll until all tasks in this wave complete
             const waveChildIds = waveIndices.map(i => childIdByIndex[i]);
             // Check cancellation after spawning
@@ -303,6 +448,117 @@ export async function runTeamOrchestrator(parentId, task, teamSize, workdir, val
                     break;
                 }
             }
+            // Per-wave validation: run build after each wave to catch breakage early
+            if (validate && Date.now() - startedAt.getTime() < totalTimeoutMs) {
+                const waveCompleted = waveChildIds.every(id => getCodeAgent(id)?.status === 'completed');
+                if (waveCompleted) {
+                    parentTask.liveOutput = `Phase: Validating wave ${waveIdx + 1}/${totalWaves}...`;
+                    writeCodeAgentTask(parentTask);
+                    const { passed, output: valOutput } = await runValidation(workdir, fullConfig?.codeAgents?.validationCommands);
+                    if (!passed) {
+                        addEvent(traceId, {
+                            type: 'wave_validation',
+                            summary: `Wave ${waveIdx + 1} validation failed — retrying failed children`,
+                            durationMs: Date.now() - startedAt.getTime(),
+                        });
+                        // Retry each child in this wave once with the validation error context
+                        const retryChildIds = [];
+                        for (const subtaskIdx of waveIndices) {
+                            const childId = childIdByIndex[subtaskIdx];
+                            const child = getCodeAgent(childId);
+                            if (child.retryCount)
+                                continue; // already retried
+                            child.retryCount = 1;
+                            child.status = 'running';
+                            child.validationOutput = valOutput.slice(0, 4000);
+                            child.startedAt = new Date().toISOString();
+                            writeCodeAgentTask(child);
+                            const retryPrompt = `Fix build/test errors. Your original task: ${subtasks[subtaskIdx].description}\n\nValidation errors:\n${valOutput.slice(0, 4000)}`;
+                            child.task = retryPrompt;
+                            writeCodeAgentTask(child);
+                            spawnChild(childId, retryPrompt, workdir);
+                            retryChildIds.push(childId);
+                        }
+                        // Poll until retries complete
+                        if (retryChildIds.length > 0) {
+                            while (true) {
+                                await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL));
+                                if (getCodeAgent(parentId)?.status === 'cancelled')
+                                    throw new Error(CANCELLED_MESSAGE);
+                                const retryDone = retryChildIds.every(id => {
+                                    const c = getCodeAgent(id);
+                                    return c.status !== 'running' && c.status !== 'validating';
+                                });
+                                if (retryDone)
+                                    break;
+                                if (Date.now() - startedAt.getTime() > totalTimeoutMs)
+                                    break;
+                            }
+                            addEvent(traceId, {
+                                type: 'wave_retry_complete',
+                                summary: `Wave ${waveIdx + 1} retry complete`,
+                                durationMs: Date.now() - startedAt.getTime(),
+                            });
+                        }
+                    }
+                    else {
+                        addEvent(traceId, {
+                            type: 'wave_validation',
+                            summary: `Wave ${waveIdx + 1} validation passed`,
+                            durationMs: Date.now() - startedAt.getTime(),
+                        });
+                    }
+                }
+            }
+            // Merge worktree branches back into main branch sequentially
+            if (useWorktreeForWave && Date.now() - startedAt.getTime() < totalTimeoutMs) {
+                parentTask.liveOutput = `Phase: Merging wave ${waveIdx + 1} results...`;
+                writeCodeAgentTask(parentTask);
+                const mergeErrors = [];
+                for (const subtaskIdx of waveIndices) {
+                    const childId = childIdByIndex[subtaskIdx];
+                    const wt = activeWorktrees.get(childId);
+                    if (!wt)
+                        continue;
+                    const child = getCodeAgent(childId);
+                    if (!child || child.status !== 'completed') {
+                        // Don't merge failed/timed-out children
+                        console.log(`[code-team] Skipping merge for ${childId} (status: ${child?.status})`);
+                        removeWorktree(workdir, childId, wt.branch);
+                        activeWorktrees.delete(childId);
+                        continue;
+                    }
+                    // Commit any uncommitted changes in the worktree before merging
+                    commitPendingChanges(wt.path, `[skimpyclaw] ${childId}: ${subtasks[subtaskIdx].description.slice(0, 60)}`);
+                    const { merged, conflict } = mergeWorktree(workdir, wt.branch, childId);
+                    if (merged) {
+                        console.log(`[code-team] Merged ${childId} (branch ${wt.branch}) successfully`);
+                        addEvent(traceId, {
+                            type: 'merge',
+                            summary: `Merged ${childId} successfully`,
+                            durationMs: Date.now() - startedAt.getTime(),
+                        });
+                    }
+                    else {
+                        const conflictMsg = `Merge conflict for ${childId}: ${conflict}`;
+                        console.error(`[code-team] ${conflictMsg}`);
+                        mergeErrors.push(conflictMsg);
+                        addEvent(traceId, {
+                            type: 'merge_conflict',
+                            summary: conflictMsg.slice(0, 200),
+                            durationMs: Date.now() - startedAt.getTime(),
+                        });
+                    }
+                    // Clean up worktree regardless of merge result
+                    removeWorktree(workdir, childId, wt.branch);
+                    activeWorktrees.delete(childId);
+                }
+                if (mergeErrors.length > 0) {
+                    const errorMsg = `Merge conflicts in wave ${waveIdx + 1}:\n${mergeErrors.join('\n')}`;
+                    parentTask.error = (parentTask.error ? parentTask.error + '\n' : '') + errorMsg;
+                    writeCodeAgentTask(parentTask);
+                }
+            }
             // If we timed out, don't start more waves
             if (Date.now() - startedAt.getTime() > totalTimeoutMs)
                 break;
@@ -311,6 +567,27 @@ export async function runTeamOrchestrator(parentId, task, teamSize, workdir, val
         if (getCodeAgent(parentId)?.status === 'cancelled')
             throw new Error(CANCELLED_MESSAGE);
         parentTask.liveOutput = 'Phase: Synthesizing results...';
+        // Aggregate cost/tokens from all children into parent
+        let totalCost = 0;
+        let totalInput = 0;
+        let totalOutput = 0;
+        let hasCostData = false;
+        for (const cid of childIds) {
+            const child = getCodeAgent(cid);
+            if (child?.totalCost != null) {
+                totalCost += child.totalCost;
+                hasCostData = true;
+            }
+            if (child?.inputTokens != null)
+                totalInput += child.inputTokens;
+            if (child?.outputTokens != null)
+                totalOutput += child.outputTokens;
+        }
+        if (hasCostData) {
+            parentTask.totalCost = totalCost;
+            parentTask.inputTokens = totalInput;
+            parentTask.outputTokens = totalOutput;
+        }
         writeCodeAgentTask(parentTask);
         const childResults = childIds.map(id => {
             const child = getCodeAgent(id);
@@ -326,14 +603,14 @@ export async function runTeamOrchestrator(parentId, task, teamSize, workdir, val
             summary: `Synthesizing ${childResults.length} results`,
             durationMs: Date.now() - startedAt.getTime(),
         });
-        const synthesis = await synthesizeResults(task, childResults, fullConfig);
+        const synthesis = await synthesizeResults(task, childResults, fullConfig, workdir);
         parentTask.synthesisResult = synthesis;
         // Phase 5: Validation (once, on the combined result)
         if (validate) {
             parentTask.liveOutput = 'Phase: Validating...';
             parentTask.status = 'validating';
             writeCodeAgentTask(parentTask);
-            const { passed, output } = await runValidation(workdir);
+            const { passed, output } = await runValidation(workdir, fullConfig?.codeAgents?.validationCommands);
             const endedAt = new Date();
             const duration = Math.round((endedAt.getTime() - startedAt.getTime()) / 1000);
             if (!passed) {
@@ -382,7 +659,21 @@ export async function runTeamOrchestrator(parentId, task, teamSize, workdir, val
         await notifyCodeAgentResult(parentTask, getCodeAgent);
     }
     catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
+        // Clean up any remaining worktrees
+        for (const [childId, wt] of _activeWorktrees) {
+            try {
+                removeWorktree(workdir, childId, wt.branch);
+            }
+            catch { /* best effort */ }
+        }
+        _activeWorktrees.clear();
+        if (_useWorktrees) {
+            try {
+                cleanupAllWorktrees(workdir);
+            }
+            catch { /* best effort */ }
+        }
+        const errMsg = toErrorMessage(err);
         addEvent(traceId, { type: 'error', summary: errMsg.slice(0, 200), durationMs: Date.now() - startedAt.getTime() });
         await endTrace(traceId, 'error');
         Object.assign(parentTask, {

package/dist/code-agents/structured-context.d.ts

@@ -0,0 +1,7 @@
+export interface StructuredAgentOutput {
+    summary: string;
+    files: string[];
+    errors: string[];
+}
+export declare function parseAgentOutput(raw: string): StructuredAgentOutput;
+export declare function formatStructuredContext(parsed: StructuredAgentOutput): string;

package/dist/code-agents/structured-context.js

@@ -0,0 +1,54 @@
+// Structured context extraction for team agent inter-communication.
+// Replaces raw string truncation with a token-efficient structured summary
+// that preserves the most useful signal: what files changed and what went wrong.
+// Matches backtick-quoted paths like `src/foo.ts`
+const BACKTICK_PATH_RE = /`([^`\n]{3,200})`/g;
+// Matches absolute paths like /Users/katre/Sites/skimpyclaw/src/foo.ts
+const ABS_PATH_RE = /(?:^|\s)(\/[^\s,;'"()\n]{3,300})/gm;
+// Matches error-like lines
+const ERROR_LINE_RE = /^.{0,20}(?:error|failed|failure|exception)[^\n]{0,200}$/gim;
+export function parseAgentOutput(raw) {
+    const files = new Set();
+    // Extract backtick-quoted paths (e.g. `src/agent.ts`, `/abs/path.ts`)
+    BACKTICK_PATH_RE.lastIndex = 0;
+    let m;
+    while ((m = BACKTICK_PATH_RE.exec(raw)) !== null) {
+        const p = m[1].trim();
+        // Must look like a file path: contains a dot and no spaces
+        if (p.includes('.') && !p.includes(' ')) {
+            files.add(p.replace(/[.,;]$/, ''));
+        }
+    }
+    // Extract absolute paths
+    ABS_PATH_RE.lastIndex = 0;
+    while ((m = ABS_PATH_RE.exec(raw)) !== null) {
+        const p = m[1].trim().replace(/[.,;]$/, '');
+        if (p.includes('.')) {
+            files.add(p);
+        }
+    }
+    // Extract error lines
+    const errors = [];
+    ERROR_LINE_RE.lastIndex = 0;
+    while ((m = ERROR_LINE_RE.exec(raw)) !== null) {
+        const err = m[0].trim().slice(0, 200);
+        if (errors.length < 5 && !errors.includes(err)) {
+            errors.push(err);
+        }
+    }
+    return {
+        summary: raw.slice(0, 500),
+        files: [...files].slice(0, 15),
+        errors,
+    };
+}
+export function formatStructuredContext(parsed) {
+    const parts = [`Summary: ${parsed.summary}`];
+    if (parsed.files.length > 0) {
+        parts.push(`Files: ${parsed.files.join(', ')}`);
+    }
+    if (parsed.errors.length > 0) {
+        parts.push(`Errors: ${parsed.errors.join(' | ')}`);
+    }
+    return parts.join('\n');
+}

package/dist/code-agents/types.d.ts

@@ -45,6 +45,8 @@ export interface CodeAgentBackgroundOptions {
     maxTimeoutMinutes?: number;
     /** Skip sending notification on completion (parent handles it) */
     skipNotification?: boolean;
+    /** Per-project validation command overrides from config */
+    validationCommands?: Record<string, string>;
     /** Sandbox configuration — when enabled, run CLI inside container */
     sandboxConfig?: SandboxConfig;
     /** Paths to mount into the sandbox container */

package/dist/code-agents/utils.d.ts

@@ -1,5 +1,9 @@
 import type { BuildCodeAgentArgsInput, CodeAgentTask } from './types.js';
 import type { Config } from '../types.js';
+/** Return supported coding CLIs currently available on PATH. */
+export declare function getAvailableCodingCliTools(commandChecker?: (name: string) => boolean): Array<'codex' | 'claude' | 'kimi'>;
+/** Return preflight error when no supported coding CLI is installed. */
+export declare function getCodingCliPreflightError(commandChecker?: (name: string) => boolean): string | null;
 /**
  * Normalize legacy/default agent values to supported CLI agent IDs.
  * Accepts strict IDs and older alias-like values (e.g. "claude-think").

package/dist/code-agents/utils.js

@@ -12,9 +12,35 @@ function resolveCliPath(name) {
         return name;
     }
 }
+function isCommandAvailable(name) {
+    try {
+        execSync(`command -v ${name}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 const CLAUDE_CLI_PATH = resolveCliPath('claude');
 const CODEX_CLI_PATH = resolveCliPath('codex');
 const KIMI_CLI_PATH = resolveCliPath('kimi');
+/** Return supported coding CLIs currently available on PATH. */
+export function getAvailableCodingCliTools(commandChecker = isCommandAvailable) {
+    const available = [];
+    if (commandChecker('codex'))
+        available.push('codex');
+    if (commandChecker('claude') || commandChecker('claude-code'))
+        available.push('claude');
+    if (commandChecker('kimi'))
+        available.push('kimi');
+    return available;
+}
+/** Return preflight error when no supported coding CLI is installed. */
+export function getCodingCliPreflightError(commandChecker = isCommandAvailable) {
+    if (getAvailableCodingCliTools(commandChecker).length > 0)
+        return null;
+    return 'Error: No supported coding CLI found on PATH. Install Codex CLI (`codex`), Claude Code CLI (`claude` or `claude-code`), or Kimi CLI (`kimi`).';
+}
 /**
  * Normalize legacy/default agent values to supported CLI agent IDs.
  * Accepts strict IDs and older alias-like values (e.g. "claude-think").
@@ -201,11 +227,21 @@ export async function notifyCodeAgentResult(task, getChildTask) {
     // Team coordinator gets a structured notification
     if (task.agent === 'team-coordinator') {
         message = buildTeamNotification(task, getChildTask);
-        await sendActiveChannelProactiveMessage(_codeAgentConfig, message).catch(() => { });
+        const sent = await sendActiveChannelProactiveMessage(_codeAgentConfig, message).catch((err) => {
+            console.error(`[code-agent] Failed to send team notification for ${task.id}:`, err);
+            return false;
+        });
+        if (!sent)
+            console.warn(`[code-agent] Team notification not delivered for ${task.id} (no active channel or target)`);
         return;
     }
     message = buildSoloNotification(task);
-    await sendActiveChannelProactiveMessage(_codeAgentConfig, message).catch(() => { });
+    const sent = await sendActiveChannelProactiveMessage(_codeAgentConfig, message).catch((err) => {
+        console.error(`[code-agent] Failed to send notification for ${task.id}:`, err);
+        return false;
+    });
+    if (!sent)
+        console.warn(`[code-agent] Notification not delivered for ${task.id} (no active channel or target)`);
 }
 /** Check workdir against allowed paths. */
 export function resolveWorkdir(rawWorkdir, projects, skimpyclawRoot) {

package/dist/code-agents/worktree.d.ts

@@ -0,0 +1,40 @@
+export interface WorktreeInfo {
+    /** Absolute path to the worktree directory */
+    path: string;
+    /** Branch name created for this worktree */
+    branch: string;
+}
+/**
+ * Check if a directory is inside a git repo.
+ */
+export declare function isGitRepo(workdir: string): boolean;
+/**
+ * Get the git repo root directory.
+ */
+export declare function getGitRoot(workdir: string): string;
+/**
+ * Stage and commit all current changes so worktrees branch from a clean state.
+ * Returns the commit hash, or null if nothing to commit.
+ */
+export declare function commitPendingChanges(workdir: string, message: string): string | null;
+/**
+ * Create a git worktree for a child agent.
+ * Creates a new branch and worktree directory under .skimpyclaw-worktrees/.
+ */
+export declare function createWorktree(workdir: string, childId: string): WorktreeInfo;
+/**
+ * Merge a child's worktree branch back into the current branch.
+ * Returns { merged: true } on success, { merged: false, conflict: string } on conflict.
+ */
+export declare function mergeWorktree(workdir: string, branch: string, childId: string): {
+    merged: boolean;
+    conflict?: string;
+};
+/**
+ * Remove a worktree and its branch.
+ */
+export declare function removeWorktree(workdir: string, childId: string, branch: string): void;
+/**
+ * Clean up all skimpyclaw worktrees in a repo (e.g. on crash recovery).
+ */
+export declare function cleanupAllWorktrees(workdir: string): void;