@compass-ai/nova 1.0.72 → 1.0.74

package/dist/services/agent-spawner.js

@@ -0,0 +1,748 @@
+/**
+ * Agent Spawner Service
+ *
+ * Manages spawning, tracking, and resuming agent processes with isolated
+ * context windows and per-agent budget enforcement.
+ *
+ * This service brings Claude Code Task tool-style sub-agent execution to Kore CLI.
+ */
+import { randomUUID } from 'crypto';
+import path from 'path';
+import fs from 'fs/promises';
+import { logger } from '../utils/logger.js';
+import { formatTimestamp } from '../utils/format.js';
+import { getGlobalCompassDir } from '../utils/path.js';
+import { ensureDir } from '../utils/file-system.js';
+import { getAgentBudgetAllocator } from './agent-budget-allocator.js';
+import { getAgentByName } from './agent-manager.js';
+import { runSDKQuery } from './sdk-runner.js';
+import { getEventEmitter } from '../core/event-emitter.js';
+import { isBudgetExceeded, isTerminalStatus, formatDuration, } from '../types/agent-process.js';
+// =============================================================================
+// Constants
+// =============================================================================
+/** Directory for storing process state files */
+const PROCESSES_DIR = 'processes';
+/** Directory for background task output files */
+const BACKGROUND_OUTPUT_DIR = 'background-output';
+/** Maximum nesting depth for spawned agents */
+const MAX_SPAWN_DEPTH = 5;
+// =============================================================================
+// Agent Spawner Class
+// =============================================================================
+/**
+ * Service for spawning and managing agent processes.
+ */
+class AgentSpawnerService {
+    processes = new Map();
+    executionPromises = new Map();
+    eventListeners = new Map();
+    processesDir = null;
+    backgroundOutputDir = null;
+    /** Mutable status message targets keyed by processId — allows poll_task to redirect activity */
+    statusTargets = new Map();
+    /**
+     * Initializes the spawner service.
+     */
+    async initialize() {
+        const globalDir = getGlobalCompassDir();
+        this.processesDir = path.join(globalDir, PROCESSES_DIR);
+        this.backgroundOutputDir = path.join(globalDir, BACKGROUND_OUTPUT_DIR);
+        await ensureDir(this.processesDir);
+        await ensureDir(this.backgroundOutputDir);
+        // Load any persisted processes
+        await this.loadPersistedProcesses();
+    }
+    /**
+     * Spawns a new agent process.
+     *
+     * @param options - Spawn options
+     * @returns The spawned agent process
+     */
+    async spawn(options) {
+        await this.ensureInitialized();
+        const processId = randomUUID();
+        const allocator = getAgentBudgetAllocator();
+        // Resolve agent configuration
+        const agentName = options.agentName ?? 'default';
+        const agentConfig = await getAgentByName(agentName);
+        // Check nesting depth
+        const parentProcess = options.parentProcessId
+            ? this.processes.get(options.parentProcessId)
+            : undefined;
+        const depth = parentProcess ? parentProcess.depth + 1 : 0;
+        const parentChain = parentProcess
+            ? [...parentProcess.parentChain, parentProcess.processId]
+            : [];
+        if (depth >= MAX_SPAWN_DEPTH) {
+            throw new Error(`Maximum agent nesting depth (${MAX_SPAWN_DEPTH}) exceeded`);
+        }
+        // Cycle detection
+        if (parentChain.includes(processId)) {
+            throw new Error('Cycle detected in agent spawning chain');
+        }
+        // Allocate budget
+        const budgetOptions = options.budget ?? {
+            strategy: 'fixed',
+        };
+        // If parent has budget, use percentage strategy by default for child
+        if (parentProcess && !options.budget) {
+            budgetOptions.strategy = 'percentage';
+            budgetOptions.percentageOfParent = 50;
+            budgetOptions.parentBudget = parentProcess.budget;
+        }
+        const budget = allocator.allocateBudget(agentName, budgetOptions);
+        // Create agent process object
+        const agentProcess = {
+            processId,
+            agentId: agentConfig?.id ?? `dynamic-${agentName}`,
+            agentName,
+            status: 'pending',
+            budget,
+            task: options.task,
+            context: options.context,
+            createdAt: formatTimestamp(),
+            messages: [],
+            turnNumber: 0,
+            parentProcessId: options.parentProcessId,
+            parentChain,
+            depth,
+            isBackground: options.runInBackground ?? false,
+            projectRoot: options.projectRoot ?? globalThis.process.cwd(),
+            parentToolCallId: options.parentToolCallId,
+            teamId: options.teamId,
+            teamRole: options.teamRole,
+        };
+        // Set up background output file if needed
+        if (agentProcess.isBackground && this.backgroundOutputDir) {
+            agentProcess.outputFile = path.join(this.backgroundOutputDir, `${processId}.txt`);
+            await fs.writeFile(agentProcess.outputFile, `[${formatTimestamp()}] Agent process started\n`);
+        }
+        // Store process
+        this.processes.set(processId, agentProcess);
+        await this.persistProcess(agentProcess);
+        // Emit creation event
+        this.emitEvent({
+            type: 'process_created',
+            processId,
+            agentName,
+            timestamp: formatTimestamp(),
+            data: { budget },
+        });
+        logger.info(`Spawned agent process ${processId} (${agentName})`, {
+            task: options.task.substring(0, 100),
+            budget: allocator.formatBudgetStatus(budget),
+            isBackground: agentProcess.isBackground,
+        });
+        // Execute the process
+        if (agentProcess.isBackground) {
+            // Run in background but store the promise so it can be awaited via waitForCompletion
+            const executionPromise = this.executeProcess(agentProcess).catch((error) => {
+                logger.error(`Background process ${processId} failed:`, error);
+                return agentProcess;
+            });
+            this.executionPromises.set(processId, executionPromise);
+            return agentProcess;
+        }
+        else {
+            // Wait for completion
+            return await this.executeProcess(agentProcess);
+        }
+    }
+    /**
+     * Executes an agent process.
+     */
+    async executeProcess(process) {
+        const startTime = Date.now();
+        try {
+            // Update status to running
+            process.status = 'running';
+            process.startedAt = formatTimestamp();
+            await this.persistProcess(process);
+            this.emitEvent({
+                type: 'process_started',
+                processId: process.processId,
+                agentName: process.agentName,
+                timestamp: formatTimestamp(),
+            });
+            // Build the full query with context
+            let fullQuery = process.task;
+            if (process.context) {
+                fullQuery = `Context:\n${process.context}\n\nTask:\n${process.task}`;
+            }
+            // Get agent configuration
+            const agentConfig = await getAgentByName(process.agentName);
+            // Execute via SDK runner with budget tracking
+            const sdkOptions = {
+                query: fullQuery,
+                projectRoot: process.projectRoot,
+                continueSession: false, // Each agent gets fresh context
+                autoApprove: agentConfig?.permissionMode === 'bypassPermissions' || true,
+                agentConfig,
+                silent: true, // Suppress stdout/stderr to prevent console output leakage
+                isSubagent: true, // Skip singleton re-initialization to avoid corrupting parent state
+            };
+            // Track tools used
+            const toolsUsed = new Set();
+            let toolCallCount = 0;
+            // Execute with budget enforcement
+            const result = await this.executeWithBudget(process, sdkOptions, (toolName) => {
+                toolsUsed.add(toolName);
+                toolCallCount++;
+            }, process.parentToolCallId);
+            const duration = Date.now() - startTime;
+            // Build result
+            const processResult = {
+                success: result.success,
+                content: result.content,
+                error: result.error,
+                agentName: process.agentName,
+                agentModel: agentConfig?.model ?? 'sonnet',
+                processId: process.processId,
+                tokensUsed: process.budget.tokensUsed,
+                turnsUsed: process.budget.turnsUsed,
+                durationMs: duration,
+                toolsUsed: Array.from(toolsUsed),
+                toolCallCount,
+                budgetExceeded: isBudgetExceeded(process.budget).exceeded,
+                budgetExceededReason: isBudgetExceeded(process.budget).reason,
+            };
+            // Update process
+            process.result = processResult;
+            process.status = result.success ? 'completed' : 'failed';
+            process.completedAt = formatTimestamp();
+            if (processResult.budgetExceeded) {
+                process.status = 'budget_exceeded';
+                process.terminationReason = processResult.budgetExceededReason === 'tokens'
+                    ? 'token_budget_exceeded'
+                    : 'turn_budget_exceeded';
+            }
+            await this.persistProcess(process);
+            // Write to background output file if applicable
+            if (process.isBackground && process.outputFile) {
+                await fs.appendFile(process.outputFile, `\n[${formatTimestamp()}] Process completed\n` +
+                    `Status: ${process.status}\n` +
+                    `Duration: ${formatDuration(duration)}\n` +
+                    `Tokens used: ${process.budget.tokensUsed}/${process.budget.maxTokens}\n` +
+                    `Turns used: ${process.budget.turnsUsed}/${process.budget.maxTurns}\n` +
+                    `\n--- Result ---\n${result.content}\n`);
+            }
+            // Emit completion event
+            this.emitEvent({
+                type: result.success ? 'process_completed' : 'process_failed',
+                processId: process.processId,
+                agentName: process.agentName,
+                timestamp: formatTimestamp(),
+                data: {
+                    result: processResult,
+                    budget: process.budget,
+                },
+            });
+            // Clean up status target
+            this.statusTargets.delete(process.processId);
+            logger.info(`Agent process ${process.processId} ${process.status}`, {
+                duration: formatDuration(duration),
+                tokensUsed: process.budget.tokensUsed,
+                turnsUsed: process.budget.turnsUsed,
+            });
+            return process;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            process.status = 'failed';
+            process.error = errorMessage;
+            process.completedAt = formatTimestamp();
+            process.result = {
+                success: false,
+                content: '',
+                error: errorMessage,
+                agentName: process.agentName,
+                agentModel: 'unknown',
+                processId: process.processId,
+                tokensUsed: process.budget.tokensUsed,
+                turnsUsed: process.budget.turnsUsed,
+                durationMs: duration,
+                toolsUsed: [],
+                toolCallCount: 0,
+                budgetExceeded: false,
+            };
+            await this.persistProcess(process);
+            if (process.isBackground && process.outputFile) {
+                await fs.appendFile(process.outputFile, `\n[${formatTimestamp()}] Process failed: ${errorMessage}\n`);
+            }
+            this.emitEvent({
+                type: 'process_failed',
+                processId: process.processId,
+                agentName: process.agentName,
+                timestamp: formatTimestamp(),
+                data: { error: errorMessage },
+            });
+            // Clean up status target
+            this.statusTargets.delete(process.processId);
+            logger.error(`Agent process ${process.processId} failed:`, error);
+            return process;
+        }
+    }
+    /**
+     * Executes SDK query with budget enforcement.
+     */
+    async executeWithBudget(agentProcess, options, _onToolCall, parentToolCallId) {
+        // Build callbacks that pipe subagent activity to the parent UI
+        let callbacks;
+        if (parentToolCallId) {
+            const eventEmitter = getEventEmitter();
+            const activityLines = [];
+            const MAX_ACTIVITY_LINES = 4; // Reserve 1 line for the footer
+            let toolCount = 0;
+            // Use a mutable target so poll_task can redirect status messages
+            // to its own tool block for background agents.
+            const statusTarget = { toolId: parentToolCallId };
+            this.statusTargets.set(agentProcess.processId, statusTarget);
+            const emitActivity = () => {
+                const footer = `Tools: ${toolCount} (Ctrl+o to expand)`;
+                eventEmitter.emit('tool-status-message', {
+                    toolId: statusTarget.toolId,
+                    message: [...activityLines, footer].join('\n'),
+                });
+            };
+            const pushActivity = (line) => {
+                activityLines.push(line);
+                if (activityLines.length > MAX_ACTIVITY_LINES)
+                    activityLines.shift();
+                emitActivity();
+            };
+            // Map of toolId -> index in activityLines + original input for display on completion
+            const pendingTools = new Map();
+            callbacks = {
+                onToolStart: (toolName, toolId, input) => {
+                    const display = formatSubAgentTool(toolName, input);
+                    const line = `○ ${display}`;
+                    pushActivity(line);
+                    pendingTools.set(toolId, { idx: activityLines.length - 1, input });
+                },
+                onToolComplete: (toolName, toolId, _result, success) => {
+                    toolCount++;
+                    const pending = pendingTools.get(toolId);
+                    if (pending !== undefined && pending.idx < activityLines.length) {
+                        const display = formatSubAgentTool(toolName, pending.input);
+                        activityLines[pending.idx] = success ? `● ${display}` : `● ${display} → failed`;
+                        pendingTools.delete(toolId);
+                    }
+                    emitActivity();
+                },
+                onIterationStart: () => {
+                    // Turns are not displayed in sub-agent output
+                },
+            };
+        }
+        // Run the SDK query with budget enforcement
+        // Budget is tracked and enforced in the SDK runner's agentic loop
+        const result = await runSDKQuery({
+            ...options,
+            budget: agentProcess.budget,
+            processId: agentProcess.processId,
+            callbacks,
+        });
+        return result;
+    }
+    /**
+     * Resumes a paused agent process.
+     *
+     * @param processId - ID of the process to resume
+     * @returns The resumed process
+     */
+    async resume(processId) {
+        const process = this.processes.get(processId);
+        if (!process) {
+            throw new Error(`Process ${processId} not found`);
+        }
+        if (process.status !== 'paused') {
+            throw new Error(`Process ${processId} is not paused (status: ${process.status})`);
+        }
+        if (process.messages.length === 0) {
+            throw new Error(`Process ${processId} has no saved state to resume from`);
+        }
+        logger.info(`Resuming agent process ${processId}`);
+        this.emitEvent({
+            type: 'process_resumed',
+            processId,
+            agentName: process.agentName,
+            timestamp: formatTimestamp(),
+            data: { turnNumber: process.turnNumber },
+        });
+        return await this.executeProcess(process);
+    }
+    /**
+     * Cancels a running or pending process.
+     *
+     * @param processId - ID of the process to cancel
+     */
+    async cancel(processId) {
+        const process = this.processes.get(processId);
+        if (!process) {
+            throw new Error(`Process ${processId} not found`);
+        }
+        if (isTerminalStatus(process.status)) {
+            throw new Error(`Process ${processId} is already in terminal state: ${process.status}`);
+        }
+        process.status = 'cancelled';
+        process.terminationReason = 'user_cancelled';
+        process.completedAt = formatTimestamp();
+        await this.persistProcess(process);
+        if (process.isBackground && process.outputFile) {
+            await fs.appendFile(process.outputFile, `\n[${formatTimestamp()}] Process cancelled by user\n`);
+        }
+        this.emitEvent({
+            type: 'process_cancelled',
+            processId,
+            agentName: process.agentName,
+            timestamp: formatTimestamp(),
+        });
+        logger.info(`Cancelled agent process ${processId}`);
+    }
+    /**
+     * Gets a process by ID.
+     *
+     * @param processId - Process ID
+     * @returns The process or undefined
+     */
+    getProcess(processId) {
+        return this.processes.get(processId);
+    }
+    /**
+     * Lists all processes, optionally filtered by status.
+     *
+     * @param filter - Optional filter criteria
+     * @returns List of matching processes
+     */
+    listProcesses(filter) {
+        const all = Array.from(this.processes.values());
+        if (filter?.status) {
+            return all.filter((p) => p.status === filter.status);
+        }
+        return all;
+    }
+    /**
+     * Polls output from a background process.
+     *
+     * @param processId - Process ID
+     * @returns Current output and completion status
+     */
+    async pollOutput(processId) {
+        const process = this.processes.get(processId);
+        if (!process) {
+            throw new Error(`Process ${processId} not found`);
+        }
+        if (!process.isBackground || !process.outputFile) {
+            throw new Error(`Process ${processId} is not a background process`);
+        }
+        try {
+            const output = await fs.readFile(process.outputFile, 'utf-8');
+            return {
+                output,
+                isComplete: isTerminalStatus(process.status),
+            };
+        }
+        catch {
+            return {
+                output: '',
+                isComplete: isTerminalStatus(process.status),
+            };
+        }
+    }
+    /**
+     * Waits for a background process to complete and returns the final process state.
+     * If the process is already complete, returns immediately.
+     *
+     * @param processId - Process ID
+     * @returns The completed process
+     */
+    /**
+     * Redirects a background agent's status messages to a different tool block.
+     * Used by poll_task to show agent activity on its own tool block.
+     */
+    redirectStatusTarget(processId, newToolCallId) {
+        const target = this.statusTargets.get(processId);
+        if (target) {
+            target.toolId = newToolCallId;
+        }
+    }
+    async waitForCompletion(processId) {
+        const process = this.processes.get(processId);
+        if (!process) {
+            throw new Error(`Process ${processId} not found`);
+        }
+        // Already in terminal state - return immediately
+        if (isTerminalStatus(process.status)) {
+            return process;
+        }
+        // Await the stored execution promise if available
+        const executionPromise = this.executionPromises.get(processId);
+        if (executionPromise) {
+            const completed = await executionPromise;
+            this.executionPromises.delete(processId);
+            return completed;
+        }
+        // No promise stored (shouldn't happen for background processes) - return current state
+        return process;
+    }
+    /**
+     * Registers an event listener.
+     *
+     * @param eventType - Type of event to listen for
+     * @param listener - Callback function
+     */
+    on(eventType, listener) {
+        const listeners = this.eventListeners.get(eventType) ?? [];
+        listeners.push(listener);
+        this.eventListeners.set(eventType, listeners);
+    }
+    /**
+     * Removes an event listener.
+     *
+     * @param eventType - Type of event
+     * @param listener - Callback to remove
+     */
+    off(eventType, listener) {
+        const listeners = this.eventListeners.get(eventType) ?? [];
+        const index = listeners.indexOf(listener);
+        if (index >= 0) {
+            listeners.splice(index, 1);
+        }
+    }
+    /**
+     * Emits an event to all registered listeners.
+     */
+    emitEvent(event) {
+        const listeners = this.eventListeners.get(event.type) ?? [];
+        for (const listener of listeners) {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                logger.error(`Error in event listener for ${event.type}:`, error);
+            }
+        }
+    }
+    /**
+     * Ensures the spawner is initialized.
+     */
+    async ensureInitialized() {
+        if (!this.processesDir) {
+            await this.initialize();
+        }
+    }
+    /**
+     * Persists a process to disk for recovery.
+     */
+    async persistProcess(process) {
+        if (!this.processesDir)
+            return;
+        const filePath = path.join(this.processesDir, `${process.processId}.json`);
+        await fs.writeFile(filePath, JSON.stringify(process, null, 2));
+    }
+    /**
+     * Loads persisted processes from disk.
+     */
+    async loadPersistedProcesses() {
+        if (!this.processesDir)
+            return;
+        try {
+            const files = await fs.readdir(this.processesDir);
+            for (const file of files) {
+                if (!file.endsWith('.json'))
+                    continue;
+                try {
+                    const filePath = path.join(this.processesDir, file);
+                    const content = await fs.readFile(filePath, 'utf-8');
+                    const process = JSON.parse(content);
+                    // Only load non-terminal processes for potential resumption
+                    if (!isTerminalStatus(process.status)) {
+                        this.processes.set(process.processId, process);
+                        logger.debug(`Loaded persisted process ${process.processId}`);
+                    }
+                }
+                catch (error) {
+                    logger.warn(`Failed to load process from ${file}:`, error);
+                }
+            }
+        }
+        catch (error) {
+            logger.debug('No persisted processes to load');
+        }
+    }
+    /**
+     * Cleans up old completed processes.
+     *
+     * @param maxAgeMs - Maximum age in milliseconds (default: 24 hours)
+     */
+    async cleanup(maxAgeMs = 24 * 60 * 60 * 1000) {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [processId, process] of this.processes) {
+            if (!isTerminalStatus(process.status))
+                continue;
+            const completedAt = process.completedAt ? new Date(process.completedAt).getTime() : 0;
+            if (now - completedAt > maxAgeMs) {
+                this.processes.delete(processId);
+                // Delete persisted file
+                if (this.processesDir) {
+                    const filePath = path.join(this.processesDir, `${processId}.json`);
+                    try {
+                        await fs.unlink(filePath);
+                    }
+                    catch {
+                        // Ignore
+                    }
+                }
+                // Delete background output file
+                if (process.outputFile) {
+                    try {
+                        await fs.unlink(process.outputFile);
+                    }
+                    catch {
+                        // Ignore
+                    }
+                }
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            logger.info(`Cleaned up ${cleaned} old agent processes`);
+        }
+        return cleaned;
+    }
+}
+// =============================================================================
+// Singleton Instance
+// =============================================================================
+let spawnerInstance = null;
+/**
+ * Gets the singleton AgentSpawner instance.
+ */
+export function getAgentSpawner() {
+    if (!spawnerInstance) {
+        spawnerInstance = new AgentSpawnerService();
+    }
+    return spawnerInstance;
+}
+/**
+ * Resets the spawner instance (for testing).
+ */
+export function resetAgentSpawner() {
+    spawnerInstance = null;
+}
+// =============================================================================
+// Helper Functions for Activity Formatting
+// =============================================================================
+/** Truncate a string to maxLen, appending '...' if truncated */
+function truncate(str, maxLen) {
+    if (str.length <= maxLen)
+        return str;
+    return str.slice(0, maxLen - 3) + '...';
+}
+/**
+ * Format a sub-agent tool call for display, mirroring the parent UI style.
+ * e.g. read_file → "Read (src/foo.ts)", search_code → "Search Code (pattern)"
+ */
+function formatSubAgentTool(toolName, input) {
+    const displayName = getSubAgentToolDisplayName(toolName);
+    const param = getSubAgentToolParam(toolName, input);
+    return param ? `${displayName} (${truncate(param, 60)})` : displayName;
+}
+/** Convert tool_name to a human-friendly display name */
+function getSubAgentToolDisplayName(toolName) {
+    // Map common tools to their parent-UI display names
+    const DISPLAY_NAMES = {
+        read_file: 'Read',
+        read_multiple_files: 'Read',
+        write_file: 'Write',
+        edit_file: 'Edit',
+        create_directory: 'Create Dir',
+        list_directory: 'List',
+        list_directory_with_sizes: 'List',
+        list_files: 'List',
+        get_file_info: 'File Info',
+        search_code: 'Search Code',
+        find_files: 'Find Files',
+        execute_command: 'Execute',
+        execute_background: 'Execute (bg)',
+        execute_and_verify: 'Execute (verify)',
+        git_status: 'Git Status',
+        git_diff: 'Git Diff',
+        git_log: 'Git Log',
+        git_stage: 'Git Stage',
+        git_commit: 'Git Commit',
+        git_push: 'Git Push',
+        spawn_task: 'Agent',
+        poll_task: 'Poll Agent',
+        spawn_team: 'Swarm',
+        get_team_status: 'Team Status',
+        list_teams: 'List Teams',
+        cancel_team: 'Cancel Team',
+        team_message: 'Team Message',
+        directory_tree: 'Tree',
+        move_file: 'Move',
+        delete_file: 'Delete',
+        image_to_text: 'Image OCR',
+        transcribe_audio: 'Transcribe',
+        ask_user: 'Ask User',
+        enter_plan_mode: 'Plan',
+        update_plan: 'Update Plan',
+        complete_plan_task: 'Complete Task',
+    };
+    if (DISPLAY_NAMES[toolName])
+        return DISPLAY_NAMES[toolName];
+    // MCP tools: strip mcp_ prefix and format
+    if (toolName.startsWith('mcp_')) {
+        const clean = toolName.slice(4);
+        return clean.split('_').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+    }
+    // Fallback: snake_case to Title Case
+    return toolName.split('_').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+}
+/** Extract the most relevant parameter value for display */
+function getSubAgentToolParam(toolName, input) {
+    // File tools → path
+    if (typeof input.file_path === 'string')
+        return makeRelative(input.file_path);
+    if (typeof input.path === 'string')
+        return makeRelative(input.path);
+    // Search tools → pattern
+    if (typeof input.pattern === 'string')
+        return input.pattern;
+    // Shell tools → description or command
+    if (toolName === 'execute_command' || toolName === 'execute_background') {
+        if (typeof input.description === 'string')
+            return input.description;
+        if (typeof input.command === 'string')
+            return input.command;
+    }
+    if (typeof input.command === 'string')
+        return input.command;
+    if (typeof input.query === 'string')
+        return input.query;
+    if (typeof input.task === 'string')
+        return input.task;
+    // read_multiple_files → count
+    if (Array.isArray(input.paths))
+        return `${input.paths.length} files`;
+    // Fallback: first short string value
+    for (const val of Object.values(input)) {
+        if (typeof val === 'string' && val.length > 0 && val.length < 100)
+            return val;
+    }
+    return '';
+}
+/** Strip the project root from an absolute path for cleaner display */
+function makeRelative(filePath) {
+    const cwd = process.cwd();
+    const normalized = filePath.replace(/\\/g, '/');
+    const normalizedCwd = cwd.replace(/\\/g, '/');
+    if (normalized.startsWith(normalizedCwd + '/')) {
+        return normalized.slice(normalizedCwd.length + 1);
+    }
+    return filePath;
+}
+//# sourceMappingURL=agent-spawner.js.map