@compass-ai/nova 1.0.74 → 1.0.76

package/dist/services/agent-spawner.js

@@ -1,748 +0,0 @@
-/**
- * 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