shortcutxl 0.2.0

package/dist/custom/tools/task/render.js

@@ -0,0 +1,348 @@
+/**
+ * TUI rendering for the task tool.
+ *
+ * Pure display functions — no I/O, no subprocess knowledge.
+ * Takes typed data, returns pi-tui Components.
+ */
+import { ABORT_UI_LABEL_INLINE } from '../../../core/abort.js';
+import { Text } from '../../../tui/index.js';
+// ---------------------------------------------------------------------------
+// Formatting helpers (pure functions, exported for testing)
+// ---------------------------------------------------------------------------
+export function formatTokens(count) {
+    if (count < 1_000)
+        return count.toString();
+    // Upper bound is 9_950 so that toFixed(1) never rounds up to "10.0k"
+    // (9_949 → "9.9k", 9_950 would → "10.0k" which collides with the rounded tier).
+    if (count < 9_950)
+        return `${(count / 1_000).toFixed(1)}k`;
+    if (count < 1_000_000)
+        return `${Math.round(count / 1_000)}k`;
+    return `${(count / 1_000_000).toFixed(1)}M`;
+}
+/**
+ * Format usage stats for display.
+ *
+ * When contextWindow is provided, shows "X% context used" instead of $cost
+ * (appropriate for credit-based models like shortcut-opus where cost is meaningless).
+ */
+export function formatUsage(usage, model, contextWindow, toolCallCount) {
+    const parts = [];
+    if (toolCallCount)
+        parts.push(`${toolCallCount} step${toolCallCount > 1 ? 's' : ''}`);
+    if (usage.input)
+        parts.push(`↑${formatTokens(usage.input)}`);
+    if (usage.output)
+        parts.push(`↓${formatTokens(usage.output)}`);
+    // Show context % instead of cost when we have a context window
+    if (contextWindow && contextWindow > 0 && usage.lastTurnInput > 0) {
+        const percent = (usage.lastTurnInput / contextWindow) * 100;
+        parts.push(`${percent.toFixed(1)}% context used`);
+    }
+    else if (!contextWindow && usage.cost) {
+        // Fallback: show cost only when no context window info
+        parts.push(`$${usage.cost.toFixed(4)}`);
+    }
+    if (model)
+        parts.push(model);
+    return parts.join(' ');
+}
+const MAX_TOOL_DESC = 50;
+function truncate(s, max) {
+    return s.length > max ? s.slice(0, max) + '...' : s;
+}
+/**
+ * Format a tool call for display in the task result.
+ *
+ * bash and excel_exec show a short description (up to 50 chars).
+ * read/write/edit are omitted (returns null) — not useful in task context.
+ */
+export function formatToolCall(tc) {
+    switch (tc.name) {
+        case 'bash': {
+            const desc = tc.args.description;
+            if (desc)
+                return `$ ${truncate(desc, MAX_TOOL_DESC)}`;
+            const cmd = tc.args.command ?? '...';
+            return `$ ${truncate(cmd, MAX_TOOL_DESC)}`;
+        }
+        case 'excel_exec': {
+            const desc = tc.args.description ?? '';
+            return `𝕏 ${truncate(desc || '(code)', MAX_TOOL_DESC)}`;
+        }
+        case 'read':
+        case 'write':
+        case 'edit':
+            return null;
+        default: {
+            const argsStr = JSON.stringify(tc.args);
+            return `${tc.name} ${truncate(argsStr, MAX_TOOL_DESC)}`;
+        }
+    }
+}
+/** Resolve the icon, label, and color for a completed (non-running) task state. */
+function taskStatus(isError, isAborted, theme) {
+    if (isError)
+        return { icon: theme.fg('error', '✗'), word: 'failed', color: 'error' };
+    if (isAborted)
+        return { icon: theme.fg('warning', '⊘'), word: ABORT_UI_LABEL_INLINE, color: 'warning' };
+    return { icon: theme.fg('success', '✓'), word: 'done', color: 'success' };
+}
+/** Max length for the query preview in the header */
+const MAX_QUERY_PREVIEW = 120;
+/**
+ * Render the task tool call header (shown while running / before result).
+ *
+ * Collapsed: name + truncated single-line query
+ * Expanded: name + full query
+ */
+export function renderTaskCall(data, expanded, theme) {
+    const title = theme.fg('toolTitle', theme.bold(data.name || 'task'));
+    if (data.query) {
+        if (expanded) {
+            return new Text(`${title}\n${theme.fg('text', data.query)}`, 0, 0);
+        }
+        // Collapsed: first line, truncated
+        const firstLine = data.query.split('\n')[0] ?? '';
+        const preview = firstLine.length > MAX_QUERY_PREVIEW
+            ? firstLine.slice(0, MAX_QUERY_PREVIEW) + '...'
+            : firstLine;
+        return new Text(`${title}\n${theme.fg('text', preview)}`, 0, 0);
+    }
+    return new Text(title, 0, 0);
+}
+/**
+ * Get the "currently doing" description from the latest tool call.
+ * Walks backwards to find the last displayable tool call.
+ */
+export function getCurrentActivity(toolCalls) {
+    for (let i = toolCalls.length - 1; i >= 0; i--) {
+        const formatted = formatToolCall(toolCalls[i]);
+        if (formatted)
+            return formatted;
+    }
+    return null;
+}
+/**
+ * Render the task tool result.
+ *
+ * Collapsed: compact 1-line status — "currently doing: X" or "✓ done"
+ * Expanded: full details — all tool calls, output text, usage stats
+ */
+export function renderTaskResult(data, expanded, theme) {
+    const icon = data.isRunning
+        ? ' '
+        : data.isError
+            ? theme.fg('error', '✗')
+            : theme.fg('success', '✓');
+    // ── Collapsed view: compact single-line status ──────────────────────
+    if (!expanded) {
+        if (data.isRunning) {
+            const activity = getCurrentActivity(data.toolCalls);
+            const activityStr = activity
+                ? `${theme.fg('muted', 'currently doing:')} ${theme.fg('toolOutput', activity)}`
+                : theme.fg('muted', 'starting...');
+            const tcCount = data.toolCalls.length;
+            const usageStr = formatUsage(data.usage, undefined, data.contextWindow, tcCount);
+            const footer = usageStr ? `\n${theme.fg('dim', usageStr)}` : '';
+            return new Text(`${activityStr}${footer}`, 0, 0);
+        }
+        // Completed (error, aborted, or done)
+        const s = taskStatus(data.isError, data.isAborted, theme);
+        const errMsg = data.isError && data.errorMessage
+            ? ` ${theme.fg('error', truncate(data.errorMessage, 80))}`
+            : '';
+        const tcCount = data.toolCalls.length;
+        const usageStr = formatUsage(data.usage, undefined, data.contextWindow, tcCount);
+        const usageSuffix = usageStr ? `  ${theme.fg('dim', usageStr)}` : '';
+        return new Text(`${icon} ${theme.fg(s.color, s.word)}${errMsg}${usageSuffix}`, 0, 0);
+    }
+    // ── Expanded view: full details ─────────────────────────────────────
+    const s = data.isRunning ? undefined : taskStatus(data.isError, data.isAborted, theme);
+    const statusWord = data.isRunning ? 'running...' : s.word;
+    let text = `${icon} ${theme.fg('accent', statusWord)}`;
+    // Error message
+    if (data.isError && data.errorMessage) {
+        text += `\n${theme.fg('error', data.errorMessage)}`;
+    }
+    // All tool calls
+    const calls = data.toolCalls;
+    if (calls.length > 0) {
+        for (const tc of calls) {
+            const formatted = formatToolCall(tc);
+            if (formatted) {
+                text += `\n${theme.fg('muted', '→ ')}${theme.fg('toolOutput', formatted)}`;
+            }
+        }
+    }
+    // Final output text
+    if (data.text) {
+        text += `\n\n${theme.fg('toolOutput', data.text)}`;
+    }
+    else if (!data.isRunning && !data.isError) {
+        text += `\n${theme.fg('muted', '(no output)')}`;
+    }
+    // Usage
+    const tcCount = data.toolCalls.length;
+    const usageStr = formatUsage(data.usage, data.model, data.contextWindow, tcCount);
+    if (usageStr) {
+        text += `\n${theme.fg('dim', usageStr)}`;
+    }
+    return new Text(text, 0, 0);
+}
+// ---------------------------------------------------------------------------
+// Grouped rendering (for renderGroup — multiple concurrent tasks as one tree)
+// ---------------------------------------------------------------------------
+// Tree drawing characters — all prefixes are 3 chars wide for alignment
+const BRANCH_MID = '├─ ';
+const BRANCH_END = '└─ ';
+const PIPE_MID = '│  ';
+const PIPE_END = '   ';
+const MAX_GROUP_QUERY_PREVIEW = 100;
+const MAX_EXPANDED_TOOL_CALLS = 15;
+/**
+ * Render a group of concurrent task calls as a single tree.
+ *
+ * Pure function — takes member snapshots from the framework, returns a Component.
+ *
+ *   ✓ General Subagent
+ *   ├─ Revenue Sheet: Analyze Q3 revenue data...
+ *   │     ✓ done  18 steps  claude-opus-4-6
+ *   ├─ Income Statement: Build income statement...
+ *   │     Step 3: >_ Running calculations  claude-opus-4-6
+ *   └─ Format Summary: Apply formatting...
+ *         ⏳ starting...
+ */
+export function renderTaskGroup(members, options, theme) {
+    const { expanded } = options;
+    const lines = [];
+    // Determine agent type from first member's args
+    const firstArgs = members[0]?.args;
+    const agentType = firstArgs?.subagent_type ?? 'general';
+    const agentLabel = formatAgentGroupLabel(agentType, members.length);
+    // Header icon: all done or any error; no icon when still running
+    const allDone = members.every((m) => !m.isPartial);
+    const headerIcon = groupHeaderIcon(members, theme);
+    const header = allDone
+        ? `${headerIcon} ${theme.fg('toolTitle', theme.bold(agentLabel))}`
+        : theme.fg('toolTitle', theme.bold(agentLabel));
+    lines.push(header);
+    // Tree entries
+    for (let i = 0; i < members.length; i++) {
+        const member = members[i];
+        const isLast = i === members.length - 1;
+        const branch = isLast ? BRANCH_END : BRANCH_MID;
+        const cont = isLast ? PIPE_END : PIPE_MID;
+        const name = member.args?.name || `Agent ${i + 1}`;
+        const query = member.args?.query;
+        const details = member.result?.details;
+        const isRunning = member.isPartial;
+        const isError = member.result?.isError ?? false;
+        if (expanded) {
+            lines.push(...renderGroupEntryExpanded(name, query, details, isRunning, isError, branch, cont, theme));
+        }
+        else {
+            lines.push(...renderGroupEntryCollapsed(name, query, details, isRunning, isError, branch, cont, theme));
+        }
+    }
+    return new Text(lines.join('\n'), 0, 0);
+}
+function groupHeaderIcon(members, theme) {
+    const allDone = members.every((m) => !m.isPartial);
+    if (!allDone)
+        return ' ';
+    if (members.some((m) => m.result?.isError))
+        return theme.fg('error', '✗');
+    return theme.fg('success', '✓');
+}
+function renderGroupEntryCollapsed(name, query, details, isRunning, isError, branch, cont, theme) {
+    const line1 = `${theme.fg('dim', branch)}${theme.fg('accent', name)}`;
+    const prefix = theme.fg('dim', cont);
+    const queryLine = query ? `${prefix}${groupQueryPreview(query, theme)}` : undefined;
+    if (isRunning) {
+        const stepCount = details?.toolCalls.length ?? 0;
+        const activity = details ? getCurrentActivity(details.toolCalls) : null;
+        let status;
+        if (activity) {
+            status = `${theme.fg('muted', `Step ${stepCount}:`)} ${theme.fg('toolOutput', activity)}`;
+        }
+        else if (stepCount > 0) {
+            status = `${theme.fg('muted', `Step ${stepCount}: thinking...`)}`;
+        }
+        else {
+            status = theme.fg('muted', 'starting...');
+        }
+        const lines = [line1];
+        if (queryLine)
+            lines.push(queryLine);
+        lines.push(`${prefix}  ${status}`);
+        return lines;
+    }
+    const s = taskStatus(isError, details?.isAborted, theme);
+    const steps = details?.toolCalls.length ?? 0;
+    const stepStr = steps > 0 ? `  ${theme.fg('dim', `${steps} step${steps > 1 ? 's' : ''}`)}` : '';
+    const lines = [line1];
+    if (queryLine)
+        lines.push(queryLine);
+    lines.push(`${prefix}${s.icon} ${theme.fg(s.color, s.word)}${stepStr}`);
+    return lines;
+}
+function renderGroupEntryExpanded(name, query, details, isRunning, isError, branch, cont, theme) {
+    const c = theme.fg('dim', cont);
+    const lines = [];
+    lines.push(`${theme.fg('dim', branch)}${theme.fg('accent', name)}`);
+    if (query)
+        lines.push(`${c}${groupQueryPreview(query, theme)}`);
+    const usageStr = details
+        ? formatUsage(details.usage, details.model, details.contextWindow, details.toolCalls.length)
+        : '';
+    const usageSuffix = usageStr ? `  ${theme.fg('dim', usageStr)}` : '';
+    if (isRunning) {
+        lines.push(`${c}${theme.fg('accent', 'running...')}${usageSuffix}`);
+    }
+    else {
+        const s = taskStatus(isError, details?.isAborted, theme);
+        lines.push(`${c}${s.icon} ${theme.fg('accent', s.word)}${usageSuffix}`);
+    }
+    if (details) {
+        if (isError && details.errorMessage) {
+            lines.push(`${c}${theme.fg('error', details.errorMessage)}`);
+        }
+        const displayCalls = details.toolCalls.slice(-MAX_EXPANDED_TOOL_CALLS);
+        if (details.toolCalls.length > MAX_EXPANDED_TOOL_CALLS) {
+            lines.push(`${c}${theme.fg('muted', `... (${details.toolCalls.length - MAX_EXPANDED_TOOL_CALLS} earlier steps)`)}`);
+        }
+        for (const tc of displayCalls) {
+            const formatted = formatToolCall(tc);
+            if (formatted) {
+                lines.push(`${c}${theme.fg('muted', '→ ')}${theme.fg('toolOutput', formatted)}`);
+            }
+        }
+        if (details.text && !isRunning) {
+            const outputLines = details.text.split('\n');
+            const maxLines = 5;
+            for (const line of outputLines.slice(0, maxLines)) {
+                lines.push(`${c}${theme.fg('toolOutput', line)}`);
+            }
+            if (outputLines.length > maxLines) {
+                lines.push(`${c}${theme.fg('muted', `... (${outputLines.length - maxLines} more lines)`)}`);
+            }
+        }
+    }
+    return lines;
+}
+function groupQueryPreview(query, theme) {
+    const firstLine = query.split('\n')[0] ?? '';
+    const preview = firstLine.length > MAX_GROUP_QUERY_PREVIEW
+        ? firstLine.slice(0, MAX_GROUP_QUERY_PREVIEW) + '...'
+        : firstLine;
+    return theme.fg('text', preview);
+}
+export function formatAgentTypeLabel(agentType) {
+    return agentType.replace(/_/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase()) + ' Subagent';
+}
+export function formatAgentGroupLabel(agentType, count) {
+    const name = agentType.replace(/_/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+    return `${count} ${name} Agent${count > 1 ? 's' : ''}`;
+}
+//# sourceMappingURL=render.js.map

package/dist/custom/tools/task/subprocess.js

@@ -0,0 +1,320 @@
+/**
+ * Spawn a child agent process in JSON mode and collect structured results.
+ *
+ * This module is the only place that knows about child_process.
+ * It emits a stream of typed events and resolves to a SubagentResult.
+ *
+ * Zero UI knowledge — callers decide what to do with progress callbacks.
+ */
+import { spawn } from 'node:child_process';
+import { mkdtempSync, readdirSync, readFileSync, rmdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+function emptyUsage() {
+    return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0, lastTurnInput: 0 };
+}
+/**
+ * Parse a single JSON event line from the agent's --mode json output.
+ * Returns extracted data or null if the line is not relevant.
+ */
+export function parseJsonEvent(line) {
+    if (!line.trim())
+        return null;
+    let event;
+    try {
+        event = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    // Assistant message completed
+    if (event.type === 'message_end' && event.message?.role === 'assistant') {
+        const msg = event.message;
+        const textParts = [];
+        for (const part of msg.content ?? []) {
+            if (part.type === 'text')
+                textParts.push(part.text);
+        }
+        const u = msg.usage ?? {};
+        return {
+            type: 'assistant_message',
+            text: textParts.join(''),
+            usage: {
+                input: u.input ?? 0,
+                output: u.output ?? 0,
+                cacheRead: u.cacheRead ?? 0,
+                cacheWrite: u.cacheWrite ?? 0,
+                cost: u.cost?.total ?? 0
+            },
+            model: msg.model,
+            stopReason: msg.stopReason,
+            errorMessage: msg.errorMessage
+        };
+    }
+    // Tool call started (we grab the name + args for display)
+    if (event.type === 'tool_execution_start') {
+        return {
+            type: 'tool_call',
+            name: event.toolName ?? 'unknown',
+            args: event.args ?? {}
+        };
+    }
+    return null;
+}
+/**
+ * Write a system prompt to a temp file. Returns the file path.
+ * The caller is responsible for cleanup via cleanupTempFile().
+ */
+export function writeSystemPromptFile(prompt) {
+    const dir = mkdtempSync(join(tmpdir(), 'shortcut-subagent-'));
+    const filePath = join(dir, 'system-prompt.md');
+    writeFileSync(filePath, prompt, { encoding: 'utf-8', mode: 0o600 });
+    return filePath;
+}
+/**
+ * Clean up a temp file created by writeSystemPromptFile.
+ */
+export function cleanupTempFile(filePath) {
+    try {
+        unlinkSync(filePath);
+    }
+    catch {
+        /* ignore */
+    }
+    try {
+        rmdirSync(dirname(filePath));
+    }
+    catch {
+        /* ignore */
+    }
+}
+/**
+ * Spawn a child agent process in JSON mode and collect results.
+ *
+ * The child runs: <command> --mode json [agentArgs...] "Task: <task>"
+ *
+ * Each subagent persists its own session JSONL to a temp directory.
+ * The session ID is returned in SubagentResult.sessionId for trace linking.
+ *
+ * JSON events are parsed line-by-line. Progress callbacks fire on each
+ * assistant message and tool call.
+ */
+export function spawnSubagent(options) {
+    const { task, cwd, command, agentArgs = [], signal, onProgress } = options;
+    // Each subagent gets its own temp session dir to avoid file lock contention
+    const sessionDir = mkdtempSync(join(tmpdir(), 'shortcut-subtrace-'));
+    // Write the query to a file to avoid cmd.exe argument splitting on Windows.
+    // With shell: true, cmd.exe splits positional args on spaces and mangles
+    // special characters (&, |, ^, etc.). Passing a .txt file path (no spaces)
+    // as the positional arg sidesteps this entirely. The subagent entry resolves
+    // .txt paths to their contents (same pattern as the backend task tool).
+    // If the query is already a .txt file path, pass it through directly.
+    const trimmedTask = task.trim();
+    let taskArg;
+    if (trimmedTask.endsWith('.txt') && !trimmedTask.includes(' ')) {
+        taskArg = trimmedTask;
+    }
+    else {
+        const taskFile = join(sessionDir, 'query.txt');
+        writeFileSync(taskFile, `Task: ${task}`, { encoding: 'utf-8', mode: 0o600 });
+        taskArg = taskFile;
+    }
+    const [bin, ...binPrefixArgs] = command;
+    const args = [
+        ...binPrefixArgs,
+        '--subagent',
+        '--mode',
+        'json',
+        '--session-dir',
+        sessionDir,
+        ...agentArgs,
+        taskArg
+    ];
+    return new Promise((resolve) => {
+        const proc = spawn(bin, args, {
+            cwd,
+            shell: process.platform === 'win32',
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        const usage = emptyUsage();
+        const toolCalls = [];
+        let lastText = '';
+        let model;
+        let stopReason;
+        let errorMessage;
+        let stderr = '';
+        let buffer = '';
+        let wasAborted = false;
+        const emitProgress = () => {
+            onProgress?.({
+                text: lastText,
+                toolCalls: [...toolCalls],
+                usage: { ...usage },
+                model
+            });
+        };
+        const processLine = (line) => {
+            const parsed = parseJsonEvent(line);
+            if (!parsed)
+                return;
+            if (parsed.type === 'assistant_message') {
+                lastText = parsed.text;
+                usage.turns++;
+                usage.input += parsed.usage.input ?? 0;
+                usage.output += parsed.usage.output ?? 0;
+                usage.cacheRead += parsed.usage.cacheRead ?? 0;
+                usage.cacheWrite += parsed.usage.cacheWrite ?? 0;
+                usage.cost += parsed.usage.cost ?? 0;
+                usage.lastTurnInput = parsed.usage.input ?? 0;
+                if (parsed.model)
+                    model = parsed.model;
+                if (parsed.stopReason)
+                    stopReason = parsed.stopReason;
+                if (parsed.errorMessage)
+                    errorMessage = parsed.errorMessage;
+                emitProgress();
+            }
+            if (parsed.type === 'tool_call') {
+                toolCalls.push({ name: parsed.name, args: parsed.args });
+                emitProgress();
+            }
+        };
+        proc.stdout.on('data', (data) => {
+            buffer += data.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines)
+                processLine(line);
+        });
+        proc.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            if (buffer.trim())
+                processLine(buffer);
+            // Read subagent session ID and file path from the persisted JSONL
+            let sessionId;
+            let sessionFile;
+            try {
+                const files = readdirSync(sessionDir).filter((f) => f.endsWith('.jsonl'));
+                if (files.length > 0) {
+                    sessionFile = join(sessionDir, files[0]);
+                    const firstLine = readFileSync(sessionFile, 'utf-8').split('\n')[0];
+                    const header = JSON.parse(firstLine);
+                    if (header.type === 'session')
+                        sessionId = header.id;
+                }
+            }
+            catch {
+                /* ignore — session may not have been written */
+            }
+            resolve({
+                text: lastText,
+                toolCalls,
+                usage,
+                model,
+                exitCode: code ?? (wasAborted ? 130 : 1),
+                stderr,
+                stopReason,
+                errorMessage,
+                aborted: wasAborted,
+                sessionId,
+                sessionFile
+            });
+        });
+        proc.on('error', (err) => {
+            resolve({
+                text: lastText,
+                toolCalls,
+                usage,
+                model,
+                exitCode: 1,
+                stderr: stderr || `Failed to spawn process: ${err.message}`,
+                stopReason: 'error',
+                errorMessage: `Failed to spawn process: ${err.message}`
+            });
+        });
+        // Cancellation
+        if (signal) {
+            const killProc = () => {
+                wasAborted = true;
+                if (process.platform === 'win32' && proc.pid) {
+                    // On Windows, shell: true means proc is cmd.exe — SIGTERM only kills
+                    // the shell, not the child node process. Use taskkill /T to kill the
+                    // entire process tree.
+                    spawn('taskkill', ['/T', '/F', '/PID', String(proc.pid)], {
+                        stdio: 'ignore'
+                    });
+                }
+                else {
+                    proc.kill('SIGTERM');
+                    setTimeout(() => {
+                        if (!proc.killed)
+                            proc.kill('SIGKILL');
+                    }, 5000);
+                }
+            };
+            if (signal.aborted)
+                killProc();
+            else
+                signal.addEventListener('abort', killProc, { once: true });
+        }
+    });
+}
+// ---------------------------------------------------------------------------
+// CLI args builder — translates AgentDefinition into child process args
+// ---------------------------------------------------------------------------
+import { CORE_TOOL_NAMES } from '../../../tool-names.js';
+/**
+ * Build CLI args for spawning a child process from an AgentDefinition.
+ *
+ * The agent's flat tools array is split into --tools (core) and
+ * --custom-tools (everything else) for the CLI flags.
+ *
+ * System prompt is written to a temp file to avoid shell escaping issues.
+ * The caller MUST clean up the temp file after the subprocess exits.
+ */
+export function buildAgentArgs(config) {
+    const args = [];
+    let promptFile;
+    // Model + thinking level
+    if (config.model) {
+        args.push('--model', config.model);
+    }
+    if (config.thinkingLevel) {
+        args.push('--thinking', config.thinkingLevel);
+    }
+    // Split flat tools list into core vs custom for CLI flags
+    const coreTools = [];
+    const customTools = [];
+    for (const t of config.tools) {
+        if (CORE_TOOL_NAMES.has(t)) {
+            coreTools.push(t);
+        }
+        else {
+            customTools.push(t);
+        }
+    }
+    if (coreTools.length > 0) {
+        args.push('--tools', coreTools.join(','));
+    }
+    else {
+        args.push('--no-tools');
+    }
+    if (customTools.length > 0) {
+        args.push('--custom-tools', customTools.join(','));
+    }
+    else {
+        args.push('--no-custom-tools');
+    }
+    // System prompt — replace entirely via temp file
+    if (config.systemPrompt) {
+        promptFile = writeSystemPromptFile(config.systemPrompt);
+        args.push('--system-prompt', promptFile);
+    }
+    return { args, promptFile };
+}
+//# sourceMappingURL=subprocess.js.map