skimpyclaw 0.3.6 → 0.3.9

package/dist/api.js

@@ -1,14 +1,13 @@
 // Dashboard API endpoints
 import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, mkdirSync, rmSync } from 'fs';
-import { timingSafeEqual } from 'crypto';
+import { validateBearerToken } from './utils.js';
 import { join, basename, resolve } from 'path';
 import { homedir } from 'os';
-import { loadConfig, loadRawConfig, saveConfig, getSessionsDir, getLogsDir, getAgentDir, listMemoryFiles, readMemoryFile, } from './config.js';
+import { loadConfig, loadRawConfig, saveConfig, getSessionsDir, getLogsDir, getAgentDir, isValidAgentId, listMemoryFiles, readMemoryFile, } from './config.js';
 import { TEMPLATE_FILES, getAgentTemplateContent, saveAgentTemplate, } from './agent.js';
 import { getCronJobs, getCronJobDetails, runCronJob } from './cron.js';
 import { getCurrentModel, setCurrentModel, getLastMessage, setGatewayConfig } from './gateway.js';
 import { redactSecrets } from './security.js';
-import { getActiveTasks, getRecentTasks } from './subagent.js';
 import { readAuditTraces } from './audit.js';
 import { getUsageSummary, readUsageRecords } from './usage.js';
 import { getAllCodeAgents, getCodeAgent, cancelCodeAgent } from './tools.js';
@@ -36,10 +35,7 @@ const DEFAULT_MODEL_ALIASES = {
 function validateFilename(filename) {
     return !filename.includes('..') && filename === basename(filename);
 }
-function validateAgentId(agentId) {
-    // Agent IDs should be simple identifiers: alphanumeric, hyphens, underscores
-    return /^[a-zA-Z0-9_-]+$/.test(agentId);
-}
+// Use isValidAgentId from config.ts
 function validateSkillName(name) {
     return /^[a-zA-Z0-9-]+$/.test(name) && name.length <= 100;
 }
@@ -98,30 +94,14 @@ export function registerDashboardAPI(fastify, config) {
         if (!token) {
             return; // No token configured, allow access
         }
-        const authHeader = request.headers.authorization;
-        if (!authHeader || !authHeader.startsWith('Bearer ')) {
-            return reply.code(401).send({ error: 'Unauthorized: Bearer token required' });
-        }
-        const providedToken = authHeader.slice(7);
-        // Timing-safe comparison to prevent token extraction via timing attacks
-        const tokenBuf = Buffer.from(token, 'utf8');
-        const providedBuf = Buffer.from(providedToken, 'utf8');
-        if (tokenBuf.length !== providedBuf.length || !timingSafeEqual(tokenBuf, providedBuf)) {
-            return reply.code(401).send({ error: 'Unauthorized: Invalid token' });
+        if (!validateBearerToken(token, request.headers.authorization)) {
+            return reply.code(401).send({ error: 'Unauthorized: Invalid or missing token' });
         }
     });
     // --- Status ---
     fastify.get('/api/dashboard/status', async () => {
         const jobs = getCronJobs();
         const uptime = process.uptime();
-        const activeTasks = getActiveTasks();
-        const recentTasks = getRecentTasks(20);
-        const pendingCount = activeTasks.filter(t => t.status === 'pending').length;
-        const runningCount = activeTasks.filter(t => t.status === 'running').length;
-        const recentCompleted = recentTasks.filter(t => t.status === 'completed').length;
-        const recentFailed = recentTasks.filter(t => t.status === 'failed').length;
-        const recentCancelled = recentTasks.filter(t => t.status === 'cancelled').length;
-        const maxConcurrent = runtimeConfig.subagents?.maxConcurrent ?? 5;
         return {
             uptime,
             model: getCurrentModel(),
@@ -129,34 +109,6 @@ export function registerDashboardAPI(fastify, config) {
             lastMessage: getLastMessage(),
             activeChannel: getActiveChannelId() ?? runtimeConfig.channels.active ?? null,
             cronJobs: jobs,
-            subagents: {
-                maxConcurrent,
-                active: activeTasks.length,
-                running: runningCount,
-                pending: pendingCount,
-                recentTotal: recentTasks.length,
-                recentCompleted,
-                recentFailed,
-                recentCancelled,
-            },
-            activeSubagents: activeTasks
-                .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
-                .map(task => {
-                const started = task.startedAt || task.createdAt;
-                return {
-                    id: task.id,
-                    type: task.type,
-                    status: task.status,
-                    model: task.model,
-                    label: task.label,
-                    promptPreview: task.prompt.slice(0, 120),
-                    retryCount: task.retryCount ?? 0,
-                    maxRetries: task.maxRetries ?? 2,
-                    createdAt: task.createdAt,
-                    startedAt: task.startedAt,
-                    elapsedSeconds: Math.max(0, Math.round((Date.now() - started.getTime()) / 1000)),
-                };
-            }),
         };
     });
     // --- Sessions ---
@@ -306,7 +258,7 @@ export function registerDashboardAPI(fastify, config) {
     // --- Memory ---
     fastify.get('/api/dashboard/memory/:agentId', async (request, reply) => {
         const { agentId } = request.params;
-        if (!validateAgentId(agentId)) {
+        if (!isValidAgentId(agentId)) {
             return reply.code(400).send({ error: 'Invalid agent ID' });
         }
         const files = listMemoryFiles(agentId);
@@ -314,7 +266,7 @@ export function registerDashboardAPI(fastify, config) {
     });
     fastify.get('/api/dashboard/memory/:agentId/:filename', async (request, reply) => {
         const { agentId, filename } = request.params;
-        if (!validateAgentId(agentId)) {
+        if (!isValidAgentId(agentId)) {
             return reply.code(400).send({ error: 'Invalid agent ID' });
         }
         // Special case: "curated" reads MEMORY.md from the agent root
@@ -455,7 +407,7 @@ export function registerDashboardAPI(fastify, config) {
     // --- Templates ---
     fastify.get('/api/dashboard/templates/:agentId', async (request, reply) => {
         const { agentId } = request.params;
-        if (!validateAgentId(agentId)) {
+        if (!isValidAgentId(agentId)) {
             return reply.code(400).send({ error: 'Invalid agent ID' });
         }
         const agentDir = getAgentDir(agentId);
@@ -472,7 +424,7 @@ export function registerDashboardAPI(fastify, config) {
     });
     fastify.get('/api/dashboard/templates/:agentId/:name', async (request, reply) => {
         const { agentId, name } = request.params;
-        if (!validateAgentId(agentId)) {
+        if (!isValidAgentId(agentId)) {
             return reply.code(400).send({ error: 'Invalid agent ID' });
         }
         const content = getAgentTemplateContent(agentId, name);
@@ -483,7 +435,7 @@ export function registerDashboardAPI(fastify, config) {
     });
     fastify.put('/api/dashboard/templates/:agentId/:name', async (request, reply) => {
         const { agentId, name } = request.params;
-        if (!validateAgentId(agentId)) {
+        if (!isValidAgentId(agentId)) {
             return reply.code(400).send({ error: 'Invalid agent ID' });
         }
         const { content } = request.body;

package/dist/audit.js

@@ -1,15 +1,10 @@
 // Audit log reader/writer for ~/.skimpyclaw/logs/audit/YYYY-MM-DD.jsonl
 import { randomUUID } from 'crypto';
-import { readFileSync, appendFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
+import { appendFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
+import { formatDate, readJsonlDir } from './utils.js';
 const AUDIT_DIR = join(homedir(), '.skimpyclaw', 'logs', 'audit');
-function formatDate(date) {
-    const y = date.getFullYear();
-    const m = String(date.getMonth() + 1).padStart(2, '0');
-    const d = String(date.getDate()).padStart(2, '0');
-    return `${y}-${m}-${d}`;
-}
 // --- In-memory trace lifecycle ---
 /** Active traces keyed by traceId */
 const activeTraces = new Map();
@@ -60,52 +55,11 @@ export async function readAuditTraces(options = {}) {
     const limit = options.limit ?? 50;
     const offset = options.offset ?? 0;
     const triggerFilter = options.trigger;
-    // Determine date range
     const endDate = options.endDate ?? new Date();
-    const startDate = options.startDate ?? new Date(endDate.getTime() - 90 * 24 * 60 * 60 * 1000); // 90 days back
-    // Get all audit JSONL files in the directory
-    if (!existsSync(AUDIT_DIR)) {
-        return { traces: [], total: 0 };
-    }
-    const files = readdirSync(AUDIT_DIR)
-        .filter(f => f.endsWith('.jsonl'))
-        .sort()
-        .reverse(); // Newest first
-    const startStr = formatDate(startDate);
-    const endStr = formatDate(endDate);
-    // Collect all matching traces
-    const allTraces = [];
-    for (const file of files) {
-        const dateStr = file.replace('.jsonl', '');
-        if (dateStr < startStr || dateStr > endStr)
-            continue;
-        const filePath = join(AUDIT_DIR, file);
-        try {
-            const content = readFileSync(filePath, 'utf-8');
-            const lines = content.trim().split('\n').filter(Boolean);
-            // Parse lines in reverse (newest first within file)
-            for (let i = lines.length - 1; i >= 0; i--) {
-                try {
-                    const trace = JSON.parse(lines[i]);
-                    if (triggerFilter && trace.trigger !== triggerFilter)
-                        continue;
-                    allTraces.push(trace);
-                }
-                catch {
-                    // Skip malformed lines
-                }
-            }
-        }
-        catch {
-            // Skip unreadable files
-        }
-    }
+    const startDate = options.startDate ?? new Date(endDate.getTime() - 90 * 24 * 60 * 60 * 1000);
+    const allTraces = readJsonlDir(AUDIT_DIR, formatDate(startDate), formatDate(endDate), triggerFilter ? (t) => t.trigger === triggerFilter : undefined);
     // Sort newest first by startedAt
-    allTraces.sort((a, b) => {
-        const dateA = new Date(b.startedAt || b.endedAt).getTime();
-        const dateB = new Date(a.startedAt || a.endedAt).getTime();
-        return dateA - dateB;
-    });
+    allTraces.sort((a, b) => Date.parse(b.startedAt || b.endedAt) - Date.parse(a.startedAt || a.endedAt));
     const total = allTraces.length;
     const paged = allTraces.slice(offset, offset + limit);
     return { traces: paged, total };

package/dist/channels/telegram/handlers.js

@@ -4,7 +4,6 @@ import { spawnSync } from 'child_process';
 import { getCurrentModel, setCurrentModel, getLastMessage } from '../../gateway.js';
 import { getCronJobs, runCronJob } from '../../cron.js';
 import { runHeartbeatCheck } from '../../heartbeat.js';
-import { cancelTask, getActiveTasks, getRecentTasks } from '../../subagent.js';
 import { getActiveCodeAgents, getRecentCodeAgents } from '../../code-agents/index.js';
 import { listApprovals, approveRequest, denyRequest, getApproval, onApprovalEvent } from '../../exec-approval.js';
 import { loadSkills } from '../../skills.js';
@@ -47,28 +46,9 @@ export async function handleStatus(ctx, cfg) {
     const model = getCurrentModel();
     const last = getLastMessage();
     const jobs = getCronJobs();
-    const activeTasks = getActiveTasks();
-    const recentTasks = getRecentTasks(20);
     const jobList = jobs
         .map((j) => `  - ${j.name}: ${j.nextRun?.toLocaleString() || 'unknown'}`)
         .join('\n');
-    const pendingCount = activeTasks.filter((t) => t.status === 'pending').length;
-    const runningCount = activeTasks.filter((t) => t.status === 'running').length;
-    const maxConcurrent = cfg.subagents?.maxConcurrent ?? 5;
-    const recentCompleted = recentTasks.filter((t) => t.status === 'completed').length;
-    const recentFailed = recentTasks.filter((t) => t.status === 'failed').length;
-    const recentCancelled = recentTasks.filter((t) => t.status === 'cancelled').length;
-    const activePreview = activeTasks
-        .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
-        .slice(0, 3)
-        .map((task) => {
-        const started = task.startedAt || task.createdAt;
-        const elapsedSeconds = Math.max(0, Math.round((Date.now() - started.getTime()) / 1000));
-        const elapsed = elapsedSeconds < 60 ? `${elapsedSeconds}s` : `${Math.round(elapsedSeconds / 60)}m`;
-        const label = task.label ? ` (${task.label})` : '';
-        return `  - ${task.id} [${task.type}] ${task.status}${label} • ${elapsed}`;
-    })
-        .join('\n');
     // Coding agents status (multi-agent)
     const caActive = getActiveCodeAgents();
     const caRecent = getRecentCodeAgents(20);
@@ -109,9 +89,6 @@ export async function handleStatus(ctx, cfg) {
         `Last message: ${last?.toLocaleString() || 'never'}\n` +
         `Silence until: ${state.silenceUntil?.toLocaleTimeString() || 'not silenced'}\n\n` +
         `${caLine}\n\n` +
-        `Subagents: ${activeTasks.length}/${maxConcurrent} active (running: ${runningCount}, pending: ${pendingCount})\n` +
-        `Recent (last ${recentTasks.length}): ✅ ${recentCompleted} • ❌ ${recentFailed} • 🚫 ${recentCancelled}\n` +
-        `${activePreview ? `Active now:\n${activePreview}\n\n` : '\n'}` +
         `Scheduled jobs:\n${jobList || '  (none)'}`);
 }
 export async function handleCron(ctx, cfg) {
@@ -182,45 +159,10 @@ export async function handleRestart(ctx, cfg) {
     }
 }
 export async function handleTasks(ctx, cfg) {
-    const active = getActiveTasks();
-    const recent = getRecentTasks(5);
-    if (recent.length === 0) {
-        await ctx.reply('No agent tasks yet. Subagents spawn automatically for complex requests.');
-        return;
-    }
-    const formatTask = (t) => {
-        const elapsed = ((t.completedAt || new Date()).getTime() - t.createdAt.getTime()) / 1000;
-        const elapsedStr = elapsed < 60 ? `${Math.round(elapsed)}s` : `${Math.round(elapsed / 60)}m`;
-        const status = {
-            pending: '⏳ Pending',
-            running: `🔄 Running (${elapsedStr})`,
-            completed: `✅ Done (${elapsedStr})`,
-            failed: `❌ Failed (${elapsedStr})`,
-            cancelled: '🚫 Cancelled'
-        };
-        const promptPreview = t.prompt.slice(0, 60) + (t.prompt.length > 60 ? '...' : '');
-        return `${t.id}: ${status[t.status] || t.status} [${t.type}] ${promptPreview}`;
-    };
-    const lines = [...active, ...recent].slice(0, 10).map(formatTask).join('\n');
-    await ctx.reply(`Agent tasks:\n\n${lines}`);
+    await ctx.reply('Use /agents to list active coding agents, or /cron to manage scheduled tasks.');
 }
 export async function handleCancel(ctx, cfg) {
-    const id = String(ctx.match || '').trim();
-    if (!id) {
-        await ctx.reply('Usage: /cancel <task-id>\nExample: /cancel t1');
-        return;
-    }
-    const task = cancelTask(id);
-    if (!task) {
-        await ctx.reply(`No task found: ${id}`);
-        return;
-    }
-    if (task.status === 'cancelled') {
-        await ctx.reply(`Cancelled ${id}.`);
-    }
-    else {
-        await ctx.reply(`Task ${id} is already ${task.status}.`);
-    }
+    await ctx.reply('Use the dashboard to cancel coding agents, or /cron to manage scheduled tasks.');
 }
 export async function handleSkills(ctx, cfg) {
     const skillConfig = cfg.skills;

package/dist/channels/telegram/index.js

@@ -3,7 +3,6 @@ import { Bot, GrammyError, HttpError, InputFile } from 'grammy';
 import { run } from '@grammyjs/runner';
 import { isAllowed, isRateLimited } from '../../security.js';
 import { runAgentTurn } from '../../agent.js';
-import { initSubagentSystem } from '../../subagent.js';
 import { getCurrentModel } from '../../gateway.js';
 import { getApproval, approveRequest, denyRequest } from '../../exec-approval.js';
 import { transcribeAudio, synthesizeSpeech } from '../../voice.js';
@@ -93,12 +92,6 @@ export async function initTelegram(cfg) {
     }
     const bot = new Bot(cfg.channels.telegram.token);
     activeBot = bot;
-    // Initialize subagent system with message delivery callback
-    initSubagentSystem(async (chatId, message) => {
-        if (!activeBot)
-            return;
-        await sendLongMessage({ reply: (text) => activeBot.api.sendMessage(chatId, text) }, message);
-    });
     // Register commands with Telegram for the / menu
     bot.api.setMyCommands(BOT_COMMANDS).catch((err) => {
         console.error('[telegram] Failed to set bot commands:', err);

package/dist/channels.js

@@ -27,7 +27,7 @@ function resolveChannelPreference(config) {
 }
 async function loadAdapter(channel) {
     if (channel === 'telegram') {
-        const telegram = await import('./telegram.js');
+        const telegram = await import('./channels/telegram/index.js');
         return {
             init: async (config) => (await telegram.initTelegram(config)) !== null,
             start: telegram.startTelegram,

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>;