@orion-agents/orion-code 0.1.4 → 0.1.6

package/dist/commands/core-command-handlers.js

@@ -0,0 +1,805 @@
+"use strict";
+/** Handler implementations for the core-command-handlers boundary. */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showHelp = showHelp;
+exports.showStatus = showStatus;
+exports.handleExit = handleExit;
+exports.handleTask = handleTask;
+exports.handleRun = handleRun;
+exports.handleChat = handleChat;
+exports.sortCommands = sortCommands;
+exports.getCommandCategoryLabel = getCommandCategoryLabel;
+const chalk_1 = __importDefault(require("chalk"));
+const ui_view_model_1 = require("../runtime/ui-view-model");
+const task_manager_1 = require("../services/task-manager");
+const agent_runner_1 = require("../services/agent-runner");
+const config_1 = require("../services/config");
+const errors_1 = require("../utils/errors");
+const tool_allowlist_1 = require("../services/tool-allowlist");
+const box_1 = require("../ui/box");
+const stream_markdown_1 = require("../ui/stream-markdown");
+const progress_1 = require("../ui/progress");
+const format_1 = require("../services/format");
+const framework_1 = require("../framework");
+const tools_1 = require("../tools");
+const session_storage_1 = require("../services/session-storage");
+const auto_compact_1 = require("../services/compact/auto-compact");
+const harness_1 = require("../harness");
+const skills_1 = require("../skills");
+const file_context_1 = require("../services/file-context");
+const project_instructions_1 = require("../services/project-instructions");
+const prompt_context_1 = require("../services/prompt-context");
+const model_context_1 = require("../services/model-context");
+const agent_status_1 = require("../runtime/agent-status");
+const loop_budget_1 = require("../runtime/loop-budget");
+// ============================================================================
+// 颜色常量
+// ============================================================================
+const BRAND = chalk_1.default.hex('#FF6B35');
+const ACCENT = chalk_1.default.hex('#00D4AA');
+const DIM = chalk_1.default.dim;
+const ERROR = chalk_1.default.red;
+const WARN = chalk_1.default.yellow;
+const SUCCESS = chalk_1.default.green;
+const HEADER = chalk_1.default.cyan.bold;
+const CATEGORY_ORDER = [
+    'workflow',
+    'session',
+    'context',
+    'tools',
+    'model',
+    'system',
+    'diagnostics',
+    'legacy',
+];
+function commandUICapabilities(ctx) {
+    return (0, ui_view_model_1.createStatusSnapshot)({
+        renderer: ctx.uiRenderer ?? ctx.config.ui?.renderer ?? 'terminal',
+        capabilities: ctx.uiCapabilities,
+    }).renderer.capabilities;
+}
+function formatTokenCount(tokens) {
+    if (tokens >= 1000000)
+        return `${(tokens / 1000000).toFixed(1)}M`;
+    if (tokens >= 1000)
+        return `${Math.round(tokens / 1000)}K`;
+    return String(tokens);
+}
+function formatThreshold(value) {
+    return `${Math.round(value * 100)}%`;
+}
+function formatDurationMs(ms) {
+    if (ms >= 1000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    return `${Math.round(ms)}ms`;
+}
+function formatRendererStatus(ctx) {
+    const snapshot = (0, ui_view_model_1.createStatusSnapshot)({
+        renderer: ctx.uiRenderer ?? ctx.config.ui?.renderer ?? 'terminal',
+        capabilities: ctx.uiCapabilities,
+    });
+    const status = snapshot.renderer.status === 'deprecated'
+        ? WARN('deprecated')
+        : snapshot.renderer.status === 'product'
+            ? SUCCESS('product')
+            : snapshot.renderer.status === 'technical'
+                ? DIM('technical')
+                : snapshot.renderer.status === 'non-interactive'
+                    ? DIM('non-interactive')
+                    : DIM('custom');
+    return `${BRAND(snapshot.renderer.name)} ${status} ${DIM(snapshot.renderer.capabilityLabels.join(', '))}`;
+}
+function formatLoopBudgetSource(stats) {
+    const source = stats.loopBudgetSource ?? 'unknown';
+    if (source === 'config' && stats.loopBudgetBaseProfile) {
+        return `config over ${stats.loopBudgetBaseProfile}`;
+    }
+    return source;
+}
+function formatLoopStatsLines(stats, detail = false) {
+    const lines = [
+        `Finish     ${stats.finishReason}`,
+        `Requests   ${stats.llmRequests} LLM / ${stats.turnsStarted} turns`,
+        `Tools      ${stats.toolCalls} total (${stats.readOnlyToolCalls} read-only, ${stats.unsafeToolCalls} unsafe)`,
+        `Tool bytes ${(0, format_1.formatBytes)(stats.modelVisibleToolBytes)} model-visible / ${(0, format_1.formatBytes)(stats.toolResultBytes)} total`,
+    ];
+    if (stats.summarizedBytes > 0) {
+        lines.push(`Saved      ${(0, format_1.formatBytes)(stats.summarizedBytes)} from model context`);
+    }
+    if (stats.compactTrigger) {
+        lines.push(`Compact    ${stats.compactTrigger}`);
+    }
+    if (stats.localFastPathUsed) {
+        lines.push('Fast path  yes');
+    }
+    if (stats.budgetExceededReason) {
+        lines.push(`Budget     ${stats.budgetExceededReason}`);
+    }
+    if (stats.continuationActions && stats.continuationActions.length > 0) {
+        lines.push(`Next       ${stats.continuationActions.join(', ')}`);
+    }
+    if ((stats.providerRetryCount ?? 0) > 0) {
+        const retryParts = [
+            `${stats.providerRetryCount} retries`,
+            `delay ${formatDurationMs(stats.providerRetryDelayMs ?? 0)}`,
+            stats.providerLastRetryErrorType
+                ? `last ${stats.providerLastRetryErrorType}${stats.providerLastRetryStatus ? `/${stats.providerLastRetryStatus}` : ''}`
+                : undefined,
+        ].filter(Boolean);
+        lines.push(`Provider   ${retryParts.join(', ')}`);
+    }
+    if ((stats.providerFallbackCount ?? 0) > 0 || stats.providerUsingFallback) {
+        const fallbackPath = stats.providerFallbackFromModel && stats.providerFallbackToModel
+            ? `${stats.providerFallbackFromModel} -> ${stats.providerFallbackToModel}`
+            : stats.providerFinalModel
+                ? `final ${stats.providerFinalModel}`
+                : 'active';
+        lines.push(`Fallback   ${fallbackPath}`);
+    }
+    if (typeof stats.verificationClaimAllowed === 'boolean') {
+        const verificationParts = [
+            stats.verificationProfile ?? 'unknown',
+            `required=${stats.verificationRequired ? 'yes' : 'no'}`,
+            `passed=${stats.verificationPassedCommands?.length ?? 0}`,
+            `failed=${stats.verificationFailedCommands?.length ?? 0}`,
+            `missing=${stats.verificationMissingCommands?.length ?? 0}`,
+            `claim=${stats.verificationClaimAllowed ? 'yes' : 'no'}`,
+        ];
+        lines.push(`Verify     ${verificationParts.join(' ')}`);
+    }
+    if (typeof stats.loopBudgetMaxLlmRequests === 'number' ||
+        typeof stats.loopBudgetMaxToolCalls === 'number' ||
+        typeof stats.loopBudgetMaxModelVisibleBytes === 'number') {
+        const caps = [
+            typeof stats.loopBudgetMaxLlmRequests === 'number'
+                ? `${stats.llmRequests}/${stats.loopBudgetMaxLlmRequests} LLM`
+                : undefined,
+            typeof stats.loopBudgetMaxToolCalls === 'number'
+                ? `${stats.toolCalls}/${stats.loopBudgetMaxToolCalls} tools`
+                : undefined,
+            typeof stats.loopBudgetMaxModelVisibleBytes === 'number'
+                ? `${(0, format_1.formatBytes)(stats.modelVisibleToolBytes)}/${(0, format_1.formatBytes)(stats.loopBudgetMaxModelVisibleBytes)} visible`
+                : undefined,
+            typeof stats.loopBudgetMaxReadOnlyFragmentation === 'number'
+                ? `fragment ${stats.singleReadOnlyStreak}/${stats.loopBudgetMaxReadOnlyFragmentation}`
+                : undefined,
+        ].filter(Boolean);
+        lines.push(`Budget cap ${caps.join(', ')} (${formatLoopBudgetSource(stats)})`);
+    }
+    if (stats.singleReadOnlyStreak > 0 || stats.batchReadSuggestionCount > 0) {
+        lines.push(`Read-only  streak ${stats.singleReadOnlyStreak}, batch_read hints ${stats.batchReadSuggestionCount}`);
+    }
+    if (detail) {
+        lines.push(`Unsafe     ${stats.unsafeToolCalls}`);
+        if (stats.providerRetryErrorTypes && stats.providerRetryErrorTypes.length > 0) {
+            lines.push(`Retry type ${stats.providerRetryErrorTypes.join(', ')}`);
+        }
+        if (stats.verificationFailedCommands && stats.verificationFailedCommands.length > 0) {
+            lines.push(`Failed     ${stats.verificationFailedCommands.join(' && ')}`);
+        }
+        if (stats.verificationMissingCommands && stats.verificationMissingCommands.length > 0) {
+            lines.push(`Missing    ${stats.verificationMissingCommands.join(' && ')}`);
+        }
+        if (stats.verificationSkippedReason) {
+            lines.push(`Verify why ${stats.verificationSkippedReason}`);
+        }
+        if (stats.continuationHint) {
+            lines.push(`Next why   ${stats.continuationHint}`);
+        }
+        lines.push(`Budget hit ${stats.finishReason === 'budget_exceeded' ? 'yes' : 'no'}`);
+    }
+    return lines;
+}
+const CATEGORY_LABELS = {
+    workflow: 'Workflow',
+    session: 'Session',
+    context: 'Context',
+    tools: 'Tools',
+    model: 'Model',
+    system: 'System',
+    diagnostics: 'Diagnostics',
+    legacy: 'Legacy',
+};
+function commandCategory(command) {
+    return command.category ?? 'system';
+}
+function getCommandCategoryLabel(category) {
+    return CATEGORY_LABELS[category ?? 'system'];
+}
+function sortCommands(commands) {
+    return [...commands].sort((a, b) => {
+        const categoryDelta = CATEGORY_ORDER.indexOf(commandCategory(a)) - CATEGORY_ORDER.indexOf(commandCategory(b));
+        if (categoryDelta !== 0)
+            return categoryDelta;
+        const priorityDelta = (a.priority ?? 100) - (b.priority ?? 100);
+        if (priorityDelta !== 0)
+            return priorityDelta;
+        return a.name.localeCompare(b.name);
+    });
+}
+function isAbortError(error, abortSignal) {
+    if (abortSignal?.aborted)
+        return true;
+    if (error instanceof Error) {
+        return error.name === 'AbortError' || error.message.toLowerCase().includes('aborted');
+    }
+    return false;
+}
+// ============================================================================
+// 工具参数摘要
+// ============================================================================
+// ============================================================================
+// 命令实现
+// ============================================================================
+let taskManager = null;
+function showHelp(ctx, visible, includeAdvanced = false) {
+    const lines = ['', HEADER('Commands:'), ''];
+    const write = (line = '') => {
+        lines.push(line);
+    };
+    for (const category of CATEGORY_ORDER) {
+        const items = visible.filter(cmd => commandCategory(cmd) === category &&
+            (includeAdvanced || (cmd.audience ?? 'primary') === 'primary'));
+        if (items.length === 0)
+            continue;
+        write(DIM(getCommandCategoryLabel(category)));
+        for (const cmd of items) {
+            const aliases = cmd.aliases ? ` (${cmd.aliases.join(', ')})` : '';
+            const params = cmd.argumentHint || cmd.params?.map(p => `<${p.name}>`).join(' ') || '';
+            const lifecycle = cmd.lifecycle?.status === 'deprecated'
+                ? ` deprecated since ${cmd.lifecycle.since ?? 'unknown'}${cmd.lifecycle.replacement ? `; use ${cmd.lifecycle.replacement}` : ''}${cmd.lifecycle.removeIn ? `; remove in ${cmd.lifecycle.removeIn}` : ''}`
+                : cmd.deprecated
+                    ? ` deprecated since ${cmd.deprecated.since}${cmd.deprecated.replacement ? `; use ${cmd.deprecated.replacement}` : ''}`
+                    : '';
+            const risk = cmd.risk === 'destructive' ? ' destructive' : '';
+            const availability = cmd.availability?.(ctx);
+            const unavailable = availability && !availability.available
+                ? ` unavailable: ${availability.reason ?? 'requirements not met'}`
+                : '';
+            write(`  ${ACCENT(`/${cmd.name}`)}${aliases} ${DIM(params)}`);
+            write(`    ${DIM(`${cmd.description}${lifecycle}${risk}${unavailable}`)}`);
+        }
+        write();
+    }
+    write(DIM('Type any text without / prefix to chat with the LLM.'));
+    write();
+    return { success: true, output: lines.join('\n') };
+}
+function showStatus(ctx) {
+    const lines = ['', HEADER('System Status'), DIM('─'.repeat(40))];
+    const write = (line = '') => {
+        lines.push(line);
+    };
+    const brainStatus = ctx.runtime.brain.getStatus();
+    const memStatus = ctx.runtime.memory.getStatus();
+    const storeStats = ctx.runtime.store.getStats();
+    write(`  Mode       ${BRAND(ctx.config.mode)}`);
+    write(`  Log level  ${DIM(ctx.config.logLevel)}`);
+    const modelId = ctx.llm?.getModel() ?? snapshotCurrentModel(ctx);
+    const modelContext = (0, model_context_1.resolveModelContext)(modelId);
+    const compactStats = getCommandAutoCompact(ctx, modelId).getStats();
+    write(`  Model      ${BRAND(modelId)}`);
+    const effort = ctx.store.getSnapshot().resolvedEffort;
+    write(`  Effort     ${DIM(effort ? `${effort.requested}/${effort.effective ?? 'provider-default'}` : 'auto/provider-default')}`);
+    write(`  Context    ${DIM(`${formatTokenCount(modelContext.contextWindow)} tokens (${modelContext.source}${modelContext.source === 'fuzzy' ? `:${modelContext.matchedId}` : ''})`)}`);
+    write(`  Compact    ${compactStats.enabled ? SUCCESS('auto') : WARN('off')} ${DIM(`predict ${formatThreshold(compactStats.predictiveCompactThreshold)}, hard ${formatThreshold(compactStats.threshold)}, used ${compactStats.ctxPercent}%`)}`);
+    write(`  Renderer   ${formatRendererStatus(ctx)}`);
+    write();
+    write(`  Agents     ${SUCCESS(brainStatus.agents.length)} registered`);
+    write(`  Tasks      ${brainStatus.pendingTasks} pending (${brainStatus.strategy} strategy)`);
+    write();
+    write('  Memory (inline):');
+    write(`    Working    ${memStatus.working} entries`);
+    write(`    Short-term ${memStatus['short-term']} entries`);
+    write(`    Long-term  ${memStatus['long-term']} entries`);
+    write();
+    write('  Memory (store):');
+    write(`    Working    ${storeStats.working} entries`);
+    write(`    Short-term ${storeStats['short-term']} entries`);
+    write(`    Long-term  ${storeStats['long-term']} entries`);
+    (0, prompt_context_1.refreshProjectInstructions)(ctx.store, ctx.cwd);
+    const snapshot = ctx.store.getSnapshot();
+    const instructionFiles = (0, project_instructions_1.loadProjectInstructionFiles)(ctx.cwd);
+    write();
+    write('  Context:');
+    write(`    Project rules ${instructionFiles.length > 0 ? SUCCESS(`${instructionFiles.length} files`) : DIM('none')}`);
+    for (const file of instructionFiles.slice(0, 8)) {
+        write(`      ${DIM(file.path)}${file.truncated ? ` ${WARN('(truncated)')}` : ''}`);
+    }
+    if (instructionFiles.length > 8) {
+        write(`      ${DIM(`... ${instructionFiles.length - 8} more`)}`);
+    }
+    write(`    Prompt rules  ${snapshot.projectInstructionsContent ? SUCCESS(`${snapshot.projectInstructionsContent.length} chars`) : DIM('none')}`);
+    write(`    Project memory ${snapshot.memoryContent ? SUCCESS(`${snapshot.memoryContent.length} chars`) : DIM('none')}`);
+    write(`    Skills index   ${snapshot.skillsContent ? SUCCESS(`${snapshot.skillsContent.length} chars`) : DIM('none')}`);
+    if (snapshot.lastLoopStats) {
+        const stats = snapshot.lastLoopStats;
+        write();
+        write('  Last loop:');
+        for (const line of formatLoopStatsLines(stats)) {
+            write(`    ${line}`);
+        }
+    }
+    const harnessState = snapshot.harnessState;
+    if (harnessState?.contract || harnessState?.capsule) {
+        write();
+        write('  Harness:');
+        if (harnessState.contract) {
+            write(`    Objective  ${ACCENT(harnessState.contract.objective)}`);
+        }
+        write(`    Ledger     ${DIM(`${harnessState.ledger.length} entries`)}`);
+        if (harnessState.capsule) {
+            write(`    Next       ${DIM(harnessState.capsule.nextAction)}`);
+            const passed = harnessState.capsule.verification.passed.length;
+            const failed = harnessState.capsule.verification.failed.length;
+            write(`    Verify     ${SUCCESS(`${passed} passed`)} / ${failed > 0 ? ERROR(`${failed} failed`) : DIM('0 failed')}`);
+        }
+    }
+    write();
+    return { success: true, output: lines.join('\n') };
+}
+function snapshotCurrentModel(ctx) {
+    return ctx.store.getSnapshot().currentModel || ctx.config.model;
+}
+function getCommandAutoCompact(ctx, modelId) {
+    if (ctx.compactCoordinator) {
+        ctx.compactCoordinator.configure({
+            modelId,
+            llm: ctx.llm,
+            outputReserveTokens: ctx.llm?.getMaxTokens?.(),
+        });
+        return ctx.compactCoordinator.getAutomatic();
+    }
+    return (0, auto_compact_1.getAutoCompact)({ modelId });
+}
+function handleTask(ctx, args) {
+    const [sub] = args.trim().split(/\s+/);
+    if (sub === 'list' || sub === 'ls') {
+        if (!taskManager) {
+            taskManager = new task_manager_1.TaskManager();
+        }
+        console.log();
+        console.log(HEADER('Task List'));
+        console.log(DIM('─'.repeat(40)));
+        const stats = taskManager.getStats();
+        console.log(`  Total      ${stats.total}`);
+        console.log(`  Pending    ${stats.pending}`);
+        console.log(`  Running    ${stats.running}`);
+        console.log(`  Completed  ${SUCCESS(stats.completed)}`);
+        console.log(`  Failed     ${ERROR(stats.failed)}`);
+        console.log(`  Cancelled  ${DIM(stats.cancelled)}`);
+        const tasks = taskManager.list();
+        if (tasks.length > 0) {
+            console.log();
+            for (const t of tasks) {
+                const statusIcon = t.status === 'completed'
+                    ? SUCCESS('✓')
+                    : t.status === 'failed'
+                        ? ERROR('✗')
+                        : t.status === 'running'
+                            ? WARN('◌')
+                            : t.status === 'cancelled'
+                                ? DIM('⊘')
+                                : DIM('○');
+                console.log(`  ${statusIcon} ${ACCENT(t.name)} ${DIM(`(${t.id.slice(0, 8)})`)}`);
+                console.log(`    ${DIM(`[${t.priority}]`)} ${t.description.slice(0, 60)}`);
+            }
+        }
+        console.log();
+        return { success: true };
+    }
+    // 默认行为: 作为任务名提交
+    const taskName = args.trim() || 'demo-task';
+    const task = {
+        id: `cli-${Date.now()}`,
+        name: taskName,
+        description: `Task submitted from CLI: ${taskName}`,
+        priority: 'P1',
+        assignedTo: 'leader',
+        status: 'pending',
+    };
+    console.log();
+    ctx.runtime.brain.submitTask(task);
+    console.log(SUCCESS(`✔ Task "${taskName}" submitted`));
+    console.log();
+    return { success: true };
+}
+async function handleRun(ctx, args) {
+    if (!args.trim()) {
+        console.log(ERROR('Usage: /run <task description>'));
+        console.log(DIM('  Creates a task and executes it through the Agent + LLM pipeline.'));
+        console.log();
+        return { success: false };
+    }
+    if (!ctx.llm || !(0, config_1.isConfigured)(ctx.config)) {
+        console.log(WARN('⚠ LLM not configured. Set ORION_CODE_API_KEY in .env to enable run mode.'));
+        console.log();
+        return { success: false };
+    }
+    if (!taskManager) {
+        taskManager = new task_manager_1.TaskManager();
+    }
+    const taskOptions = {
+        name: args.slice(0, 80),
+        description: args,
+        priority: 'P1',
+        assignedTo: 'leader',
+        tags: ['cli', 'interactive'],
+    };
+    let record;
+    try {
+        record = taskManager.create(taskOptions);
+    }
+    catch (error) {
+        if (error instanceof task_manager_1.TaskCapacityError) {
+            console.log(ERROR(`✗ ${error.message}`));
+            console.log();
+            return { success: false };
+        }
+        throw error;
+    }
+    console.log();
+    console.log(SUCCESS(`✔ Task created: ${ACCENT(record.name)}`));
+    console.log(DIM(`  ID: ${record.id} | Tags: ${record.tags.join(', ')}`));
+    taskManager.start(record.id);
+    console.log(WARN('◌ Running task through Agent + LLM...'));
+    try {
+        const agent = ctx.runtime.agents[0];
+        if (!agent) {
+            throw new Error('No agents registered');
+        }
+        const runner = new agent_runner_1.AgentRunner(agent, ctx.llm);
+        const task = taskManager.toTask(record);
+        const result = await runner.run(task);
+        if (result.success) {
+            taskManager.complete(record.id, result);
+            console.log(SUCCESS(`✓ Task completed in ${result.duration}ms`));
+            if (result.tokenUsage) {
+                console.log(DIM(`  Tokens: ${result.tokenUsage.promptTokens} in / ${result.tokenUsage.completionTokens} out`));
+            }
+            if (result.data?.summary) {
+                console.log();
+                console.log(ACCENT('  Summary:'));
+                console.log(`  ${result.data.summary}`);
+            }
+        }
+        else {
+            taskManager.fail(record.id, result.error, result);
+            console.log(ERROR(`✗ Task failed: ${result.error}`));
+        }
+    }
+    catch (error) {
+        const message = (0, errors_1.errorMessage)(error);
+        taskManager.fail(record.id, message);
+        console.log(ERROR(`✗ Task error: ${message}`));
+    }
+    console.log();
+    return { success: true };
+}
+async function handleChat(ctx, input) {
+    const ui = commandUICapabilities(ctx);
+    const writeOutput = ctx.writeOutput ?? ((text) => process.stdout.write(text));
+    const writeLine = ctx.writeLine ?? ((text = '') => console.log(text));
+    if (!input) {
+        console.log(ERROR('Usage: /chat <message>'));
+        console.log();
+        return { success: false };
+    }
+    if (!ctx.llm || !(0, config_1.isConfigured)(ctx.config)) {
+        console.log(WARN('⚠ LLM not configured. Set ORION_CODE_API_KEY in .env to enable chat.'));
+        console.log();
+        return { success: false };
+    }
+    const activeSession = ctx.getSession?.() ??
+        ctx.ensureSession?.() ??
+        (ctx.sessionId ? (0, session_storage_1.loadSessionMeta)(ctx.sessionId) : null);
+    const sessionId = activeSession?.id ?? ctx.sessionId;
+    const runtimeTools = (0, tools_1.getRuntimeTools)();
+    const skillResolution = (0, skills_1.resolveSkillsForTurn)({
+        cwd: ctx.cwd,
+        input,
+        tools: runtimeTools,
+        projectPath: activeSession?.projectPath,
+        sessionId,
+    });
+    const appliedSkillNames = skillResolution.skills.map(skill => skill.name);
+    // Record user message to session
+    if (sessionId) {
+        (0, session_storage_1.appendSessionMessage)(sessionId, {
+            role: 'user',
+            content: input,
+            timestamp: Date.now(),
+            appliedSkills: appliedSkillNames.length > 0 ? appliedSkillNames : undefined,
+        });
+    }
+    ctx.store.addMessage({ role: 'user', content: input });
+    (0, prompt_context_1.refreshProjectInstructions)(ctx.store, ctx.cwd);
+    const snapshot = ctx.store.getSnapshot();
+    const harness = (0, harness_1.createContextHarness)({
+        cwd: ctx.cwd,
+        modelId: ctx.llm.getModel(),
+        state: snapshot.harnessState,
+        config: {
+            enabled: true,
+            driftGuard: 'warn',
+            completionGate: true,
+        },
+    });
+    const intent = harness.updateContractFromUserInput(input);
+    harness.recordAppliedSkills(skillResolution.skills);
+    const promptCtx = {
+        cwd: ctx.cwd,
+        platform: process.platform,
+        nodeVersion: process.version,
+        tools: skillResolution.tools,
+        memoryContent: snapshot.memoryContent,
+        skillsContent: snapshot.skillsContent,
+        projectInstructionsContent: snapshot.projectInstructionsContent,
+        activeSkillsContent: skillResolution.promptInjection,
+        referencedFilesContent: (0, file_context_1.buildReferencedFilesPrompt)(input, ctx.cwd),
+    };
+    const systemPrompt = (0, framework_1.getSystemPrompt)(promptCtx);
+    const spinner = (0, box_1.createSpinner)();
+    const useSpinner = !ui.inlineProgress;
+    if (useSpinner) {
+        spinner.start('Thinking');
+    }
+    let finalContent = '';
+    let finalModel = '';
+    let finalUsage;
+    let responseStarted = false;
+    const sessionMessagesToRecord = [];
+    // Issue #22: 批量工具调用进度显示
+    let toolCallCount = 0;
+    let lastProgressUpdate = 0;
+    // 流式 Markdown 渲染器
+    let streamRenderer = null;
+    // Issue #32 #3.2: toolExecutor 支持 abortSignal
+    const toolExecutor = async (name, args, abortSignal) => {
+        if (!skillResolution.tools.some(tool => tool.name === name)) {
+            return JSON.stringify({
+                success: false,
+                error: skillResolution.toolScopeActive
+                    ? `Tool ${name} is not available for the active skill scope. Available tools: ${skillResolution.tools.map(tool => tool.name).join(', ') || 'none'}`
+                    : `Tool ${name} is not available.`,
+            });
+        }
+        const result = await (0, tools_1.executeTool)(name, args, abortSignal, {
+            cwd: ctx.cwd,
+            config: {
+                name: ctx.config.name,
+                mode: ctx.config.mode,
+            },
+            sessionId,
+            turnId: ctx.turnId,
+            // Tools that fan out to other tools (batch_read) have to re-run the
+            // permission gate per sub-step; they need the mode and the allowlist.
+            permissionMode: ctx.store.getEffectivePermissionMode(),
+            toolAllowlist: (0, tool_allowlist_1.resolveProjectToolAllowlist)(ctx.cwd).evaluator,
+        });
+        // 不在这里打印，让 tool_result 事件处理
+        return result;
+    };
+    const streamCallbacks = {
+        onChunk: (chunk) => {
+            if (ctx.abortSignal?.aborted) {
+                return;
+            }
+            if (!responseStarted) {
+                responseStarted = true;
+                spinner.stop();
+                // 打印换行，让流式输出在新行开始
+                writeLine();
+                // 初始化流式渲染器
+                streamRenderer = (0, stream_markdown_1.createStreamRenderer)();
+            }
+            // 使用流式渲染器处理 chunk
+            if (streamRenderer) {
+                const rendered = streamRenderer.feed(chunk);
+                if (rendered) {
+                    writeOutput(rendered);
+                }
+            }
+            else {
+                writeOutput(chunk);
+            }
+        },
+    };
+    try {
+        const messages = [
+            { role: 'system', content: systemPrompt },
+            ...snapshot.conversationHistory,
+        ];
+        for await (const event of (0, framework_1.query)({
+            messages,
+            tools: skillResolution.tools,
+            toolExecutor,
+            llm: ctx.llm,
+            streamCallbacks,
+            costTracker: snapshot.costTracker,
+            permissionMode: ctx.store.getEffectivePermissionMode(),
+            toolConfirmation: ctx.config.toolConfirmation,
+            toolAllowlist: (0, tool_allowlist_1.resolveProjectToolAllowlist)(ctx.cwd).evaluator,
+            toolContext: {
+                cwd: ctx.cwd,
+                config: {
+                    name: ctx.config.name,
+                    mode: ctx.config.mode,
+                },
+                sessionId,
+                turnId: ctx.turnId,
+            },
+            abortSignal: ctx.abortSignal,
+            harness,
+            input,
+            loopBudget: (0, loop_budget_1.resolveRuntimeLoopBudget)(input, ctx.config, harness.toJSON()),
+        })) {
+            switch (event.type) {
+                case 'request_start':
+                    // 停止 spinner，等待 LLM 响应
+                    spinner.stop();
+                    writeLine();
+                    writeLine(DIM((0, agent_status_1.agentStepStatus)(event.turn)));
+                    // 重置流式渲染器
+                    streamRenderer = (0, stream_markdown_1.createStreamRenderer)();
+                    // Issue #22: 重置工具调用计数器
+                    toolCallCount = 0;
+                    lastProgressUpdate = 0;
+                    break;
+                case 'assistant_tool_calls':
+                    if (event.toolCalls.length > 1) {
+                        writeLine(DIM((0, agent_status_1.runningToolsStatus)(event.toolCalls.length)));
+                    }
+                    sessionMessagesToRecord.push({
+                        role: 'assistant',
+                        content: event.content || '',
+                        timestamp: Date.now(),
+                        tool_calls: event.toolCalls,
+                    });
+                    break;
+                case 'tool_call':
+                    // Issue #22: 批量工具调用进度显示
+                    toolCallCount++;
+                    if (toolCallCount >= 3 && Date.now() - lastProgressUpdate > 1000) {
+                        (0, progress_1.showToolProgress)(toolCallCount, event.name);
+                        lastProgressUpdate = Date.now();
+                    }
+                    break;
+                case 'tool_result':
+                    // Issue #22: 隐藏进度指示
+                    (0, progress_1.hideProgress)();
+                    // 显示工具结果后，准备下一轮（不启动 spinner）
+                    writeLine(event.summary || (0, box_1.toolLine)(event.name, event.args, event.success, event.duration));
+                    // 显示错误详情
+                    if (!event.success && event.error) {
+                        writeLine(ERROR(`    Error: ${event.error}`));
+                    }
+                    // Debug: 显示接收到的参数
+                    if (!event.success && Object.keys(event.args).length === 0) {
+                        writeLine(WARN(`    ⚠ Tool received empty arguments - LLM may not be providing parameters correctly`));
+                        writeLine(DIM(`    Try using /model qwen or /model gpt4o for better tool calling support`));
+                    }
+                    // Record tool result for session
+                    sessionMessagesToRecord.push({
+                        role: 'tool',
+                        content: event.result,
+                        modelVisibleContent: event.modelVisibleResult,
+                        timestamp: Date.now(),
+                        toolCallId: event.callId,
+                    });
+                    break;
+                case 'message':
+                    if (event.content) {
+                        sessionMessagesToRecord.push({
+                            role: 'assistant',
+                            content: event.content,
+                            timestamp: Date.now(),
+                        });
+                    }
+                    break;
+                case 'strategy_exhausted':
+                    writeLine(WARN(`⚠ ${event.suggestion}`));
+                    break;
+                case 'complete':
+                    finalContent = event.content;
+                    finalModel = event.model;
+                    finalUsage = event.usage;
+                    if (event.stats) {
+                        ctx.store.setLastLoopStats(event.stats);
+                    }
+                    break;
+            }
+        }
+        // 刷新流式渲染器，输出剩余内容
+        if (streamRenderer) {
+            const remaining = streamRenderer.flush();
+            if (remaining) {
+                writeOutput(remaining);
+            }
+            streamRenderer = null;
+        }
+        const wasAborted = ctx.abortSignal?.aborted === true;
+        if (finalContent && !wasAborted) {
+            ctx.store.addMessage({ role: 'assistant', content: finalContent });
+        }
+        if (sessionId && sessionMessagesToRecord.length > 0 && !wasAborted) {
+            (0, session_storage_1.appendSessionMessages)(sessionId, sessionMessagesToRecord);
+        }
+        if (finalUsage && !wasAborted) {
+            ctx.store.setTokenUsage(finalUsage);
+        }
+        if (!wasAborted) {
+            harness.ingestTurn({
+                userInput: input,
+                assistantContent: finalContent,
+                sessionMessages: sessionMessagesToRecord,
+                intent,
+            });
+            const harnessState = harness.toJSON();
+            ctx.store.setState({ harnessState });
+            if (sessionId) {
+                (0, session_storage_1.updateSessionSkills)(sessionId, appliedSkillNames);
+                (0, session_storage_1.updateSessionHarnessState)(sessionId, harnessState);
+                const recordedMessages = (0, session_storage_1.readSessionMessages)(sessionId);
+                if (recordedMessages.length > 0) {
+                    (0, session_storage_1.updateSessionSummary)(sessionId, recordedMessages);
+                }
+            }
+        }
+        if (responseStarted) {
+            writeLine();
+            if (ui.extraAssistantSpacing) {
+                writeLine();
+            }
+        }
+        if (!ui.suppressLegacyTokenMeta) {
+            const stats = [
+                finalUsage ? `tokens: ${finalUsage.promptTokens}+${finalUsage.completionTokens}` : '',
+                finalModel ? finalModel : '',
+            ]
+                .filter(Boolean)
+                .join('  ');
+            if (stats) {
+                writeLine(DIM(stats));
+            }
+        }
+    }
+    catch (error) {
+        spinner.stop();
+        writeLine();
+        if (isAbortError(error, ctx.abortSignal)) {
+            (0, progress_1.hideProgress)();
+            if (!ui.suppressAbortNotice) {
+                writeLine(DIM('Interrupted.'));
+            }
+        }
+        else {
+            writeLine(ERROR(`✗ ${(0, errors_1.errorMessage)(error)}`));
+            const hist = ctx.store.getSnapshot().conversationHistory;
+            if (hist.length > 0) {
+                ctx.store.setState({ conversationHistory: hist.slice(0, -1) });
+            }
+        }
+    }
+    return { success: true };
+}
+async function handleExit(ctx) {
+    console.log();
+    console.log(DIM('Shutting down...'));
+    // Update session summary before exit
+    if (ctx.sessionId) {
+        const messages = (0, session_storage_1.readSessionMessages)(ctx.sessionId);
+        if (messages.length > 0) {
+            (0, session_storage_1.updateSessionSummary)(ctx.sessionId, messages);
+        }
+        (0, session_storage_1.endSession)(ctx.sessionId);
+    }
+    ctx.requestShutdown?.('user request');
+    await ctx.runtime.shutdown();
+    console.log(SUCCESS('Goodbye.'));
+    return { success: true };
+}
+//# sourceMappingURL=core-command-handlers.js.map