skimpyclaw 0.3.6 → 0.3.8

package/dist/cli.js

@@ -43,6 +43,9 @@ Commands:
   tools list              List available tools (built-in + MCP)
   tools install <name>    Add MCP server (--command <cmd> [--args ...] or --url <url>)
   tools remove <name>     Remove MCP server
+  agents                  List coding agents (active + recent)
+  agents <id>             Show details for a coding agent (with live output)
+  agents <id> --follow    Follow live output for an agent
   sandbox status          Show active sandbox containers
   sandbox prune           Force-prune all sandbox containers
   sandbox init            Auto-setup sandbox runtime/image/config (supports --profile)
@@ -154,21 +157,44 @@ function startDaemon() {
     console.log(`Daemon started: ${LAUNCHD_LABEL}`);
     return 0;
 }
+// All launchd labels that may be running (current + legacy)
+const ALL_LAUNCHD_LABELS = [LAUNCHD_LABEL, 'com.katre.skimpyclaw'];
 function stopDaemon() {
-    if (!launchctlAvailable()) {
-        console.error('Daemon control is only supported on macOS with launchctl.');
-        return 1;
-    }
-    if (!existsSync(LAUNCHD_PLIST)) {
-        console.error(`Launchd plist not found: ${LAUNCHD_PLIST}`);
-        return 1;
+    const launchAgentsDir = join(homedir(), 'Library', 'LaunchAgents');
+    const uid = process.getuid?.();
+    // 1. Unload and remove plists for all known labels
+    if (launchctlAvailable()) {
+        for (const label of ALL_LAUNCHD_LABELS) {
+            const plist = join(launchAgentsDir, `${label}.plist`);
+            if (existsSync(plist)) {
+                runLaunchctl(['unload', plist]);
+                rmSync(plist, { force: true });
+                console.log(`Unloaded and removed: ${label}`);
+            }
+            // Also try bootout in case the service is loaded without a plist
+            if (uid !== undefined) {
+                runLaunchctl(['bootout', `gui/${uid}/${label}`]);
+            }
+        }
     }
-    const result = runLaunchctl(['unload', LAUNCHD_PLIST]);
-    if (!result.ok && !result.output.includes('Could not find specified service')) {
-        console.error(result.output || 'Failed to unload daemon');
-        return 1;
+    // 2. Kill anything still listening on the gateway port
+    const lsofResult = spawnSync('lsof', ['-ti', `:${DEFAULT_PORT}`], { encoding: 'utf-8' });
+    const pids = (lsofResult.stdout || '')
+        .split('\n')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    if (pids.length > 0) {
+        for (const pid of pids) {
+            try {
+                process.kill(Number(pid), 'SIGTERM');
+                console.log(`Killed process ${pid} on port ${DEFAULT_PORT}`);
+            }
+            catch {
+                // already dead
+            }
+        }
     }
-    console.log(`Daemon stopped: ${LAUNCHD_LABEL}`);
+    console.log('Daemon stopped.');
     return 0;
 }
 function commandUninstall(args) {
@@ -795,10 +821,7 @@ function resolveSandboxDir() {
     return null;
 }
 function parseSandboxOption(args, flag) {
-    const idx = args.indexOf(flag);
-    if (idx === -1 || idx + 1 >= args.length)
-        return undefined;
-    return args[idx + 1];
+    return parseOption(args, flag, '') || undefined;
 }
 function runSandboxImageCheck(runtime, image, network, cmd) {
     const result = spawnSync(runtime, ['run', '--rm', '--network', network, image, 'sh', '-lc', cmd], { encoding: 'utf-8' });
@@ -815,6 +838,115 @@ function printSandboxCheck(ok, name, detail, hint) {
         console.log(`  → ${hint}`);
     }
 }
+async function commandAgents(args) {
+    const { getAllCodeAgents, getCodeAgent, restoreCodeAgentTasks } = await import('./code-agents/index.js');
+    // Restore tasks from disk so we can see them
+    restoreCodeAgentTasks();
+    const id = args.find(a => !a.startsWith('-'));
+    const follow = args.includes('--follow') || args.includes('-f');
+    if (id) {
+        // Show details for a specific agent
+        const showAgent = () => {
+            const agent = getCodeAgent(id);
+            if (!agent) {
+                console.error(`No coding agent found with ID "${id}".`);
+                return false;
+            }
+            // Clear screen in follow mode
+            if (follow)
+                process.stdout.write('\x1b[2J\x1b[H');
+            const elapsed = agent.durationSeconds != null
+                ? agent.durationSeconds
+                : Math.round((Date.now() - new Date(agent.startedAt).getTime()) / 1000);
+            const elapsedStr = elapsed < 60 ? `${elapsed}s` : `${Math.floor(elapsed / 60)}m${elapsed % 60}s`;
+            console.log(`\x1b[1m${agent.id}\x1b[0m  ${agent.agent}  \x1b[33m${agent.status}\x1b[0m  (${elapsedStr})`);
+            if (agent.model)
+                console.log(`Model: ${agent.model}`);
+            console.log(`Workdir: ${agent.workdir}`);
+            console.log(`Task: ${agent.task.slice(0, 200)}${agent.task.length > 200 ? '...' : ''}`);
+            // Show children for team coordinator
+            if (agent.childTaskIds && agent.childTaskIds.length > 0) {
+                console.log(`\n\x1b[1mChildren:\x1b[0m`);
+                for (const childId of agent.childTaskIds) {
+                    const child = getCodeAgent(childId);
+                    if (!child)
+                        continue;
+                    const cElapsed = child.durationSeconds != null
+                        ? child.durationSeconds
+                        : Math.round((Date.now() - new Date(child.startedAt).getTime()) / 1000);
+                    const cStr = cElapsed < 60 ? `${cElapsed}s` : `${Math.floor(cElapsed / 60)}m${cElapsed % 60}s`;
+                    const waveLabel = child.wave != null ? ` [wave ${child.wave + 1}]` : '';
+                    const icon = child.status === 'completed' ? '✅' : child.status === 'failed' ? '❌' : child.status === 'running' ? '🔄' : child.status === 'pending' ? '⏳' : '❓';
+                    console.log(`  ${icon} ${child.id} ${child.status} (${cStr})${waveLabel}`);
+                    const subtask = (child.subtask || child.task).slice(0, 120);
+                    console.log(`     ${subtask}${(child.subtask || child.task).length > 120 ? '...' : ''}`);
+                }
+            }
+            // Show live output
+            if (agent.liveOutput) {
+                console.log(`\n\x1b[1mLive Output:\x1b[0m`);
+                console.log(agent.liveOutput.slice(-3000));
+            }
+            // Show result
+            if (agent.outputPreview) {
+                console.log(`\n\x1b[1mResult:\x1b[0m`);
+                console.log(agent.outputPreview.slice(0, 2000));
+            }
+            if (agent.error) {
+                console.log(`\n\x1b[31mError: ${agent.error}\x1b[0m`);
+            }
+            if (agent.validationOutput) {
+                console.log(`\n\x1b[1mValidation:\x1b[0m`);
+                console.log(agent.validationOutput.slice(0, 1000));
+            }
+            return agent.status === 'running' || agent.status === 'validating' || agent.status === 'pending';
+        };
+        if (follow) {
+            let stillRunning = showAgent();
+            while (stillRunning) {
+                await new Promise(r => setTimeout(r, 3000));
+                restoreCodeAgentTasks();
+                stillRunning = showAgent();
+            }
+            // Show final state
+            showAgent();
+            return 0;
+        }
+        showAgent();
+        return 0;
+    }
+    // List all agents
+    const all = getAllCodeAgents();
+    if (all.length === 0) {
+        console.log('No coding agents have run yet.');
+        return 0;
+    }
+    // Group: active first, then recent
+    const active = all.filter(a => a.status === 'running' || a.status === 'validating' || a.status === 'pending');
+    const finished = all.filter(a => a.status !== 'running' && a.status !== 'validating' && a.status !== 'pending');
+    if (active.length > 0) {
+        console.log('\x1b[1mActive:\x1b[0m');
+        for (const a of active) {
+            const elapsed = Math.round((Date.now() - new Date(a.startedAt).getTime()) / 1000);
+            const elapsedStr = elapsed < 60 ? `${elapsed}s` : `${Math.floor(elapsed / 60)}m${elapsed % 60}s`;
+            const taskPreview = a.task.slice(0, 80) + (a.task.length > 80 ? '...' : '');
+            const children = a.childTaskIds ? ` (${a.childTaskIds.length} children)` : '';
+            console.log(`  ${a.id}: \x1b[33m${a.status}\x1b[0m ${a.agent} (${elapsedStr})${children} — ${taskPreview}`);
+        }
+    }
+    if (finished.length > 0) {
+        console.log(active.length > 0 ? '\n\x1b[1mRecent:\x1b[0m' : '\x1b[1mRecent:\x1b[0m');
+        for (const a of finished.slice(-15)) {
+            const dur = a.durationSeconds != null
+                ? (a.durationSeconds < 60 ? `${a.durationSeconds}s` : `${Math.floor(a.durationSeconds / 60)}m`)
+                : '?';
+            const icon = a.status === 'completed' ? '✅' : a.status === 'failed' ? '❌' : a.status === 'timeout' ? '⏰' : a.status === 'cancelled' ? '🚫' : '❓';
+            const taskPreview = a.task.slice(0, 80) + (a.task.length > 80 ? '...' : '');
+            console.log(`  ${icon} ${a.id}: ${a.status} ${a.agent} (${dur}) — ${taskPreview}`);
+        }
+    }
+    return 0;
+}
 async function commandSandbox(args) {
     const sub = args[0];
     if (sub === 'status') {
@@ -1050,6 +1182,9 @@ export async function runCli(argv = process.argv.slice(2)) {
         if (command === 'tools') {
             return await commandTools(args);
         }
+        if (command === 'agents') {
+            return await commandAgents(args);
+        }
         if (command === 'sandbox') {
             return await commandSandbox(args);
         }

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

@@ -11,11 +11,16 @@ export type PackageManager = 'pnpm' | 'yarn' | 'npm' | 'bun';
 export declare function detectPackageManager(workdir: string): PackageManager;
 /**
  * Build the validation command for a project directory.
- * Checks for `build` and `test` scripts in package.json, then runs them
- * with the detected package manager. Falls back to `<pm> build && <pm> test`.
+ *
+ * Resolution order:
+ * 1. Per-project override from config `codeAgents.validationCommands`
+ * 2. Monorepo auto-detection: scope to changed packages only
+ *    - Works both when workdir is the repo root AND when it's a package subdir
+ * 3. Auto-detect from package.json scripts (build + test)
+ * 4. Empty string (skip validation) if no scripts found
  */
-export declare function buildValidationCommand(workdir: string): string;
+export declare function buildValidationCommand(workdir: string, validationCommands?: Record<string, string>): string;
 /** Run build/test validation. Shared by solo agents and team orchestrator. */
-export declare function runValidation(workdir: string): Promise<ValidationResult>;
+export declare function runValidation(workdir: string, validationCommands?: Record<string, string>): Promise<ValidationResult>;
 /** Background execution of a coding agent. Updates task status throughout. */
 export declare function runCodeAgentBackground(id: string, agent: string, task: string, workdir: string, validate: boolean, input: Record<string, any>, startedAt: Date, options?: CodeAgentBackgroundOptions): Promise<void>;

package/dist/code-agents/executor.js

@@ -1,9 +1,10 @@
 // Code Agent Executor - Background execution logic
-import { spawn, exec } from 'child_process';
+import { spawn, exec, execSync } from 'child_process';
 import { createWriteStream, existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 // SKIMPYCLAW_ROOT for log paths
 const SKIMPYCLAW_ROOT = join(import.meta.dirname || process.cwd(), '..', '..');
+import { toErrorMessage } from '../utils.js';
 import { VALIDATE_TIMEOUT_MS } from './types.js';
 import { getCodeAgentsDir, ensureCodeAgentsDir, writeCodeAgentTask, setCodeAgentCanceller, deleteCodeAgentCanceller, getCodeAgent, } from './registry.js';
 import { buildCodeAgentArgs, notifyCodeAgentResult } from './utils.js';
@@ -51,15 +52,184 @@ export function detectPackageManager(workdir) {
     // 3. Fallback
     return 'pnpm';
 }
+/**
+ * Detect monorepo workspaces from package.json.
+ * Returns workspace glob patterns or null if not a monorepo.
+ */
+function getWorkspacePatterns(workdir) {
+    try {
+        const pkgPath = join(workdir, 'package.json');
+        if (!existsSync(pkgPath))
+            return null;
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        // yarn/npm: "workspaces": ["packages/*"] or "workspaces": { "packages": [...] }
+        const ws = pkg.workspaces;
+        if (Array.isArray(ws))
+            return ws;
+        if (ws && Array.isArray(ws.packages))
+            return ws.packages;
+        // pnpm: check pnpm-workspace.yaml
+        const pnpmWsPath = join(workdir, 'pnpm-workspace.yaml');
+        if (existsSync(pnpmWsPath)) {
+            const content = readFileSync(pnpmWsPath, 'utf-8');
+            const matches = content.match(/- ['"]?([^'"\n]+)['"]?/g);
+            if (matches)
+                return matches.map(m => m.replace(/^- ['"]?|['"]?$/g, ''));
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Find which monorepo packages have changed files (git diff).
+ * Returns package directories relative to workdir.
+ */
+function getChangedPackageDirs(workdir) {
+    try {
+        // Get changed files vs HEAD (staged + unstaged + untracked)
+        const diff = execSync('git diff --name-only HEAD 2>/dev/null; git diff --name-only --cached 2>/dev/null; git ls-files --others --exclude-standard 2>/dev/null', { cwd: workdir, timeout: 5000, encoding: 'utf-8' }).trim();
+        if (!diff)
+            return [];
+        const files = [...new Set(diff.split('\n').filter(Boolean))];
+        // Extract unique top-level package directories (e.g. "packages/image-studio/src/foo.ts" → "packages/image-studio")
+        const pkgDirs = new Set();
+        for (const f of files) {
+            const parts = f.split('/');
+            // Look for package.json at each depth to find package boundary
+            for (let depth = 1; depth <= Math.min(parts.length - 1, 4); depth++) {
+                const candidate = parts.slice(0, depth).join('/');
+                if (existsSync(join(workdir, candidate, 'package.json'))) {
+                    pkgDirs.add(candidate);
+                    break;
+                }
+            }
+        }
+        return [...pkgDirs];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Build scoped validation commands for a monorepo by detecting changed packages.
+ * Returns a combined command that builds/tests only affected packages, or null
+ * if this doesn't look like a monorepo or no packages were changed.
+ */
+function buildMonorepoValidationCommand(workdir) {
+    const wsPatterns = getWorkspacePatterns(workdir);
+    if (!wsPatterns)
+        return null;
+    const changedDirs = getChangedPackageDirs(workdir);
+    if (changedDirs.length === 0)
+        return null;
+    const pm = detectPackageManager(workdir);
+    const parts = [];
+    for (const dir of changedDirs) {
+        const pkgJsonPath = join(workdir, dir, 'package.json');
+        if (!existsSync(pkgJsonPath))
+            continue;
+        try {
+            const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+            const pkgName = pkg.name;
+            const scripts = pkg.scripts || {};
+            if (!pkgName)
+                continue;
+            // Build with workspace command
+            if (scripts.build) {
+                if (pm === 'pnpm')
+                    parts.push(`pnpm --filter ${pkgName} run build`);
+                else if (pm === 'yarn')
+                    parts.push(`yarn workspace ${pkgName} build`);
+                else if (pm === 'bun')
+                    parts.push(`bun --filter ${pkgName} run build`);
+                else
+                    parts.push(`npm -w ${pkgName} run build`);
+            }
+            // Test: prefer package-scoped test, fall back to root test runner scoped to path
+            if (scripts.test) {
+                if (pm === 'pnpm')
+                    parts.push(`pnpm --filter ${pkgName} run test`);
+                else if (pm === 'yarn')
+                    parts.push(`yarn workspace ${pkgName} test`);
+                else if (pm === 'bun')
+                    parts.push(`bun --filter ${pkgName} run test`);
+                else
+                    parts.push(`npm -w ${pkgName} run test`);
+            }
+            else {
+                // No package-level test script — try running root test scoped to the package path
+                // This handles monorepos like wp-calypso with `jest --testPathPattern`
+                const rootPkg = JSON.parse(readFileSync(join(workdir, 'package.json'), 'utf-8'));
+                const rootScripts = rootPkg.scripts || {};
+                // Check for common monorepo test patterns
+                if (rootScripts['test-packages']) {
+                    if (pm === 'yarn')
+                        parts.push(`yarn test-packages ${dir}`);
+                    else
+                        parts.push(`${pm} run test-packages ${dir}`);
+                }
+            }
+        }
+        catch { /* skip this package */ }
+    }
+    if (parts.length === 0)
+        return null;
+    console.log(`[validation] Monorepo: scoped to ${changedDirs.length} package(s): ${changedDirs.join(', ')}`);
+    return parts.join(' && ');
+}
+/**
+ * Walk up from a directory to find a monorepo root (directory with workspaces).
+ * Returns the root path or null if not inside a monorepo.
+ */
+function findMonorepoRoot(startDir) {
+    let dir = startDir;
+    const root = '/';
+    while (dir !== root) {
+        if (getWorkspacePatterns(dir))
+            return dir;
+        const parent = join(dir, '..');
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
 /**
  * Build the validation command for a project directory.
- * Checks for `build` and `test` scripts in package.json, then runs them
- * with the detected package manager. Falls back to `<pm> build && <pm> test`.
+ *
+ * Resolution order:
+ * 1. Per-project override from config `codeAgents.validationCommands`
+ * 2. Monorepo auto-detection: scope to changed packages only
+ *    - Works both when workdir is the repo root AND when it's a package subdir
+ * 3. Auto-detect from package.json scripts (build + test)
+ * 4. Empty string (skip validation) if no scripts found
  */
-export function buildValidationCommand(workdir) {
+export function buildValidationCommand(workdir, validationCommands) {
+    // 1. Check per-project overrides
+    if (validationCommands) {
+        const dirName = workdir.split('/').pop() || '';
+        for (const [key, cmd] of Object.entries(validationCommands)) {
+            if (key === dirName || workdir === key || workdir.endsWith(`/${key}`)) {
+                return cmd;
+            }
+        }
+    }
+    // 2. Monorepo auto-detection — check workdir and parent dirs
+    const monorepoCmd = buildMonorepoValidationCommand(workdir);
+    if (monorepoCmd)
+        return monorepoCmd;
+    // Also check if workdir is a subpackage inside a monorepo
+    const monorepoRoot = findMonorepoRoot(workdir);
+    if (monorepoRoot && monorepoRoot !== workdir) {
+        const rootCmd = buildMonorepoValidationCommand(monorepoRoot);
+        if (rootCmd)
+            return rootCmd;
+    }
+    // 3. Simple project — use root package.json scripts
     const pm = detectPackageManager(workdir);
     const run = pm === 'npm' ? 'npm run' : pm;
-    // Check which scripts exist in package.json
     let hasBuild = false;
     let hasTest = false;
     try {
@@ -77,19 +247,23 @@ export function buildValidationCommand(workdir) {
         parts.push(`${run} build`);
     if (hasTest)
         parts.push(`${run} test`);
-    // If neither build nor test scripts exist, still try — the scripts
-    // might be defined in a workspace root or the commands may work anyway
     if (parts.length === 0) {
-        parts.push(`${run} build`, `${run} test`);
+        return '';
     }
     return parts.join(' && ');
 }
 /** Run build/test validation. Shared by solo agents and team orchestrator. */
-export function runValidation(workdir) {
-    const cmd = buildValidationCommand(workdir);
+export function runValidation(workdir, validationCommands) {
+    const cmd = buildValidationCommand(workdir, validationCommands);
+    if (!cmd) {
+        // No build/test scripts found — nothing to validate, pass by default
+        return Promise.resolve({ passed: true, output: 'PASS (no build/test scripts found)' });
+    }
+    // If workdir is inside a monorepo, run from the repo root so workspace commands work
+    const execDir = findMonorepoRoot(workdir) || workdir;
     return new Promise((resolve) => {
         exec(cmd, {
-            cwd: workdir,
+            cwd: execDir,
             timeout: VALIDATE_TIMEOUT_MS,
             maxBuffer: 5 * 1024 * 1024,
         }, (error, vStdout, vStderr) => {
@@ -315,7 +489,7 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
             caTask.outputPreview = agentOutput.slice(0, 500);
             caTask.liveOutput = undefined;
             writeCodeAgentTask(caTask);
-            const validationCmd = buildValidationCommand(workdir);
+            const validationCmd = buildValidationCommand(workdir, options?.validationCommands);
             const runValidationPromise = () => new Promise((res) => {
                 const validationProc = exec(validationCmd, {
                     cwd: workdir,
@@ -521,7 +695,7 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
             await notifyCodeAgentResult(caTask, (id) => getCodeAgent(id) ?? null);
     }
     catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
+        const errMsg = toErrorMessage(err);
         addEvent(traceId, { type: 'error', summary: errMsg.slice(0, 200), durationMs: Date.now() - startedAt.getTime() });
         await endTrace(traceId, 'error');
         Object.assign(caTask, {

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

@@ -4,7 +4,7 @@ export type { CodeAgentTask, DecomposedSubtask, CodeAgentBackgroundOptions, Buil
 export { CODE_AGENT_TIMEOUT_MS, VALIDATE_TIMEOUT_MS } from './types.js';
 export { getActiveCodeAgents, getRecentCodeAgents, getAllCodeAgents, getCodeAgent, cancelCodeAgent, restoreCodeAgentTasks, getCodeAgentsDir, } from './registry.js';
 export { runCodeAgentBackground, runValidation } from './executor.js';
-export { runTeamOrchestrator, computeWaves, decomposeTask, synthesizeResults, } from './orchestrator.js';
+export { runTeamOrchestrator, computeWaves, decomposeTask, synthesizeResults, gatherCodebaseContext, } from './orchestrator.js';
 export { setCodeAgentConfig, getCodeAgentConfig, buildCodeAgentArgs, resolveSelectedCodeAgent, resolveWorkdir, resolveModelAlias, readTeamState, } from './utils.js';
 export { parseStreamJsonForLive, parseClaudeOutput, parseCodexOutput } from './parser.js';
 export type { ClaudeOutputResult } from './parser.js';

package/dist/code-agents/index.js

@@ -13,7 +13,7 @@ export { getActiveCodeAgents, getRecentCodeAgents, getAllCodeAgents, getCodeAgen
 // Re-export executor functions
 export { runCodeAgentBackground, runValidation } from './executor.js';
 // Re-export orchestrator functions
-export { runTeamOrchestrator, computeWaves, decomposeTask, synthesizeResults, } from './orchestrator.js';
+export { runTeamOrchestrator, computeWaves, decomposeTask, synthesizeResults, gatherCodebaseContext, } from './orchestrator.js';
 // Re-export utility functions
 export { setCodeAgentConfig, getCodeAgentConfig, buildCodeAgentArgs, resolveSelectedCodeAgent, resolveWorkdir, resolveModelAlias, readTeamState, } from './utils.js';
 // Re-export parser functions
@@ -80,7 +80,7 @@ export async function executeCodeWithAgent(input, config, context) {
         catch { /* gateway not running */ }
     }
     const resolvedModel = resolveModelAlias(rawModel, context?.fullConfig?.models?.aliases);
-    const configDefault = context?.fullConfig?.subagents?.defaultCodeAgent || 'claude';
+    const configDefault = context?.fullConfig?.codeAgents?.defaultAgent || 'claude';
     const requestedAgent = input.agent;
     const agent = resolveSelectedCodeAgent(requestedAgent, configDefault, resolvedModel);
     if (!agent) {
@@ -99,11 +99,11 @@ export async function executeCodeWithAgent(input, config, context) {
             : '';
         return `Error: Working directory not allowed. Permitted: ${config.allowedPaths.join(', ')}${projectNames}`;
     }
-    // Concurrency check — share limit with subagents
-    const maxConcurrent = context?.fullConfig?.subagents?.maxConcurrent ?? 5;
+    // Concurrency check
+    const maxConcurrent = context?.fullConfig?.codeAgents?.maxConcurrent ?? 5;
     const activeCount = getActiveCodeAgents().length;
     if (activeCount >= maxConcurrent) {
-        return `Error: Concurrency limit reached (${activeCount}/${maxConcurrent} coding agents running). Wait for one to finish or increase subagents.maxConcurrent.`;
+        return `Error: Concurrency limit reached (${activeCount}/${maxConcurrent} coding agents running). Wait for one to finish or increase codeAgents.maxConcurrent.`;
     }
     const validate = input.validate !== false; // default true
     // Create task with unique ID
@@ -122,8 +122,14 @@ export async function executeCodeWithAgent(input, config, context) {
     storeCodeAgentTask(caTask);
     writeCodeAgentTask(caTask);
     // Fire-and-forget: spawn background process
-    const resolvedInput = { ...input, model: resolvedModel };
-    runCodeAgentBackground(id, agent, task, workdir, validate, resolvedInput, startedAt).catch((err) => {
+    const configTimeout = context?.fullConfig?.codeAgents?.timeoutMinutes ?? 30;
+    const soloTimeout = Math.min(input.timeout_minutes || configTimeout, 60);
+    const resolvedInput = { ...input, model: resolvedModel, timeout_minutes: soloTimeout };
+    runCodeAgentBackground(id, agent, task, workdir, validate, resolvedInput, startedAt, {
+        defaultTimeoutMinutes: soloTimeout,
+        maxTimeoutMinutes: 60,
+        validationCommands: context?.fullConfig?.codeAgents?.validationCommands,
+    }).catch((err) => {
         console.error(`[code-agent] Background error for ${id}:`, err);
     });
     const taskPreview = task.length > 100 ? task.slice(0, 100) + '...' : task;
@@ -136,18 +142,14 @@ export async function executeCodeWithTeam(input, config, context) {
     const task = input.task;
     if (!task)
         return 'Error: task is required';
-    // Resolve model alias first so agent auto-selection can inspect it.
-    // Fall back to current session model so codex/kimi models auto-select the right CLI.
-    let rawTeamModel = input.model;
-    if (!rawTeamModel) {
-        try {
-            const { getCurrentModel } = await import('../gateway.js');
-            rawTeamModel = getCurrentModel();
-        }
-        catch { /* gateway not running */ }
-    }
-    const resolvedModel = resolveModelAlias(rawTeamModel, context?.fullConfig?.models?.aliases);
-    const configDefault = context?.fullConfig?.subagents?.defaultCodeAgent || 'claude';
+    // Resolve model alias. Only fall back to session model when an explicit model
+    // was requested — otherwise the session model (e.g. gpt-5.3-codex) would
+    // override agent selection even when the user wants claude.
+    const rawTeamModel = input.model;
+    const resolvedModel = rawTeamModel
+        ? resolveModelAlias(rawTeamModel, context?.fullConfig?.models?.aliases)
+        : undefined;
+    const configDefault = context?.fullConfig?.codeAgents?.defaultAgent || 'claude';
     const requestedAgent = input.agent;
     const agent = resolveSelectedCodeAgent(requestedAgent, configDefault, resolvedModel);
     if (!agent) {
@@ -167,13 +169,13 @@ export async function executeCodeWithTeam(input, config, context) {
             : '';
         return `Error: Working directory not allowed. Permitted: ${config.allowedPaths.join(', ')}${projectNames}`;
     }
+    const validate = input.validate !== false;
     // Concurrency check — need room for teamSize children
-    const maxConcurrent = context?.fullConfig?.subagents?.maxConcurrent ?? 5;
+    const maxConcurrent = context?.fullConfig?.codeAgents?.maxConcurrent ?? 5;
     const activeCount = getActiveCodeAgents().length;
     if (activeCount + teamSize > maxConcurrent) {
         return `Error: Concurrency limit — need ${teamSize} slots but only ${maxConcurrent - activeCount} available (${activeCount}/${maxConcurrent} running). Wait for agents to finish.`;
     }
-    const validate = input.validate !== false;
     // Create parent task
     const id = getNextCodeAgentId();
     const startedAt = new Date();

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

@@ -7,16 +7,22 @@ import type { DecomposedSubtask, ChildResult } from './types.js';
  * Throws if there's a cycle in the dependency graph.
  */
 export declare function computeWaves(subtasks: DecomposedSubtask[]): number[][];
+/**
+ * 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 declare function gatherCodebaseContext(workdir: string): string;
 /**
  * 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 declare function decomposeTask(task: string, teamSize: number, config: Config): Promise<DecomposedSubtask[]>;
+export declare function decomposeTask(task: string, teamSize: number, config: Config, workdir?: string): Promise<DecomposedSubtask[]>;
 /**
  * Use a quick model call to synthesize results from multiple subtask completions.
  */
-export declare function synthesizeResults(originalTask: string, results: ChildResult[], config: Config): Promise<string>;
+export declare function synthesizeResults(originalTask: string, results: ChildResult[], config: Config, workdir?: string): Promise<string>;
 /**
  * Team orchestrator — decomposes task, spawns parallel agents, monitors, synthesizes.
  */