openhorse 0.2.19 → 0.2.22

package/dist/runtime/chat-controller.js

@@ -51,6 +51,7 @@ const tool_serializer_1 = require("../framework/tool-serializer");
 const tool_artifacts_1 = require("../core/tool-artifacts");
 const checkpoint_1 = require("../core/checkpoint");
 const skills_1 = require("../skills");
+const subagents_1 = require("./subagents");
 const file_context_1 = require("../services/file-context");
 const prompt_context_1 = require("../services/prompt-context");
 const format_1 = require("../services/format");
@@ -120,7 +121,18 @@ function compactMiddle(text, maxLength) {
     return `${compact.slice(0, headLength)}...${compact.slice(-tailLength)}`;
 }
 function compactToolArgs(args, maxLength = 160) {
-    for (const key of ['path', 'file_path', 'file', 'cwd', 'command', 'pattern', 'query', 'url', 'target', 'sessionId']) {
+    for (const key of [
+        'path',
+        'file_path',
+        'file',
+        'cwd',
+        'command',
+        'pattern',
+        'query',
+        'url',
+        'target',
+        'sessionId',
+    ]) {
         const value = args[key];
         if (typeof value === 'string') {
             return compactMiddle(value, maxLength);
@@ -147,16 +159,14 @@ function buildTraceArgsDetails(projectPath, name, args) {
     const argsSummary = compactToolArgs(args);
     const fullArgs = (0, session_storage_1.redactTraceText)(fullToolArgsForTrace(name, args)).trim();
     const argsBytes = byteLength(fullArgs);
-    if (!projectPath
-        || !fullArgs
-        || fullArgs === (0, session_storage_1.redactTraceText)(argsSummary)
-        || argsBytes <= TRACE_ARGS_ARTIFACT_THRESHOLD_BYTES) {
+    if (!projectPath ||
+        !fullArgs ||
+        fullArgs === (0, session_storage_1.redactTraceText)(argsSummary) ||
+        argsBytes <= TRACE_ARGS_ARTIFACT_THRESHOLD_BYTES) {
         return { argsSummary };
     }
     const artifact = (0, tool_artifacts_1.storeArtifact)(projectPath, `${name}-args`, fullArgs, argsBytes);
-    return artifact
-        ? { argsSummary, argsArtifactId: artifact.id, argsBytes }
-        : { argsSummary };
+    return artifact ? { argsSummary, argsArtifactId: artifact.id, argsBytes } : { argsSummary };
 }
 function parseToolCallArgsForRuntime(toolCall) {
     try {
@@ -210,7 +220,9 @@ function createPreToolCheckpoint(events, sessionId, turnId, checkpointId, cwd, t
         checkpointFiles: checkpoint?.files.map(file => file.path) ?? [],
         workspaceFiles: relativeTargets,
         note: checkpoint
-            ? (risky ? 'risky_multi_file_checkpoint' : 'pre_edit_checkpoint')
+            ? risky
+                ? 'risky_multi_file_checkpoint'
+                : 'pre_edit_checkpoint'
             : 'pre_edit_checkpoint_skipped',
     });
     return { created: true, targetCount: targets.length, risky };
@@ -238,7 +250,9 @@ function formatWorkspaceFileForTrace(file) {
     const metadata = [
         typeof file.sizeBytes === 'number' ? `${file.sizeBytes}B` : '',
         typeof file.mtimeMs === 'number' ? `mtime=${file.mtimeMs}` : '',
-    ].filter(Boolean).join(' ');
+    ]
+        .filter(Boolean)
+        .join(' ');
     return `${file.status} ${file.path}${metadata ? ` (${metadata})` : ''}`;
 }
 function appendWorkspaceSnapshotTrace(events, sessionId, turnId, phase, snapshot) {
@@ -274,19 +288,13 @@ function appendWorkspaceDeltaTrace(events, sessionId, turnId, before, after) {
     return delta;
 }
 function workspaceDeltaHasTurnChanges(delta) {
-    return delta.newFilesByTurn.length > 0
-        || delta.changedByTurn.length > 0
-        || delta.resolvedByTurn.length > 0;
+    return (delta.newFilesByTurn.length > 0 ||
+        delta.changedByTurn.length > 0 ||
+        delta.resolvedByTurn.length > 0);
 }
 function formatFailureRecoveryNotice(turnId, delta, checkpointIds) {
-    const files = compactPathList([
-        ...delta.newFilesByTurn,
-        ...delta.changedByTurn,
-        ...delta.resolvedByTurn,
-    ], 8);
-    const fileText = files.length > 0
-        ? files.join(', ')
-        : 'workspace changes recorded';
+    const files = compactPathList([...delta.newFilesByTurn, ...delta.changedByTurn, ...delta.resolvedByTurn], 8);
+    const fileText = files.length > 0 ? files.join(', ') : 'workspace changes recorded';
     const checkpointText = checkpointIds.length > 0
         ? ` Checkpoints: ${checkpointIds.join(', ')}. Preview rollback with /checkpoint restore <id>; restore each listed checkpoint if multiple.`
         : '';
@@ -347,15 +355,17 @@ function withVerificationLoopStats(stats, summary) {
         verificationPassedCommands: compactVerificationCommands(summary.passedCommands),
         verificationFailedCommands: compactVerificationCommands(summary.failedCommands),
         verificationMissingCommands: compactVerificationCommands(summary.missingCommands),
-        verificationSkippedReason: summary.skippedReason ? (0, session_storage_1.redactTraceText)(summary.skippedReason) : undefined,
+        verificationSkippedReason: summary.skippedReason
+            ? (0, session_storage_1.redactTraceText)(summary.skippedReason)
+            : undefined,
     };
 }
 function shouldRecordVerificationLoopStats(profile, summary) {
-    return profile.changedFiles.length > 0
-        || summary.commandsRun.length > 0
-        || summary.passedCommands.length > 0
-        || summary.failedCommands.length > 0
-        || summary.missingCommands.length > 0;
+    return (profile.changedFiles.length > 0 ||
+        summary.commandsRun.length > 0 ||
+        summary.passedCommands.length > 0 ||
+        summary.failedCommands.length > 0 ||
+        summary.missingCommands.length > 0);
 }
 function appendPostWorkspaceTrace(events, sessionId, turnId, cwd, before, verificationResults = []) {
     const postWorkspace = (0, workspace_state_1.captureWorkspaceSnapshot)(cwd);
@@ -450,11 +460,43 @@ function toolStartContent(event) {
 function toolFinishContent(event) {
     return (0, ui_view_model_1.formatToolActivityTranscript)((0, ui_view_model_1.toolActivityFromFinished)(event, compactToolArgs(event.args, TOOL_TRANSCRIPT_ARG_BUDGET)));
 }
+function structuredToolStartActivity(event, seq) {
+    const command = event.name === 'exec_command' && typeof event.args.command === 'string'
+        ? event.args.command
+        : undefined;
+    return {
+        state: 'running',
+        name: event.name,
+        detail: command ? '' : compactToolArgs(event.args, TOOL_TRANSCRIPT_ARG_BUDGET),
+        command,
+        body: '',
+        seq,
+    };
+}
+function structuredToolFinishActivity(event, seq) {
+    const modelVisible = (0, tool_serializer_1.parseToolResultEnvelope)(event.modelVisibleResult);
+    const command = event.name === 'exec_command' && typeof event.args.command === 'string'
+        ? event.args.command
+        : undefined;
+    return {
+        state: event.success ? 'success' : 'error',
+        name: event.name,
+        detail: command ? '' : compactToolArgs(event.args, TOOL_TRANSCRIPT_ARG_BUDGET),
+        command,
+        duration: `${event.duration}ms`,
+        summary: event.summary?.split(/\r?\n/u, 1)[0],
+        outputBytes: event.outputBytes,
+        body: modelVisible.output,
+        error: event.error,
+        seq,
+        artifactHint: event.artifactRef ? `/artifacts show ${event.artifactRef.id} --full` : undefined,
+    };
+}
 function isSyntheticCompactContext(content) {
-    return content.startsWith('[OpenHorse Context State v2]')
-        || content.startsWith('[Context Summary]')
-        || content.startsWith('I will continue from this OpenHorse Context State')
-        || content.startsWith('I understand the context. I will continue the conversation with this background information.');
+    return (content.startsWith('[OpenHorse Context State v2]') ||
+        content.startsWith('[Context Summary]') ||
+        content.startsWith('I will continue from this OpenHorse Context State') ||
+        content.startsWith('I understand the context. I will continue the conversation with this background information.'));
 }
 function sessionToolCallSummaries(message) {
     return (message.tool_calls ?? []).map(call => {
@@ -505,13 +547,12 @@ function sessionToolResultSummary(message, toolCallsById) {
     const args = parseToolCallArgs(call.function.arguments);
     const detail = compactToolArgs(args);
     const parsed = parseSessionToolResult(message.content);
-    const firstLine = parsed.summary || `${parsed.success ? '✓' : '✗'} ${call.function.name}${detail ? ` ${detail}` : ''}`;
+    const firstLine = parsed.summary ||
+        `${parsed.success ? '✓' : '✗'} ${call.function.name}${detail ? ` ${detail}` : ''}`;
     return parsed.error ? `${firstLine}\nError: ${parsed.error}` : firstLine;
 }
 function sessionMessagesToTranscriptEntries(sessionId) {
-    const session = (0, session_storage_1.loadSessionMeta)(sessionId);
-    const displayStartTime = session?.transcriptDisplayStartTime;
-    const messages = (0, session_storage_1.readSessionMessages)(sessionId).filter(message => typeof displayStartTime !== 'number' || (message.timestamp ?? 0) >= displayStartTime);
+    const messages = (0, session_storage_1.loadSessionTranscriptMessages)(sessionId);
     const entries = [];
     const toolCallsById = new Map();
     const completedToolCallIds = new Set();
@@ -532,12 +573,16 @@ function sessionMessagesToTranscriptEntries(sessionId) {
             return;
         }
         if (message.role === 'assistant') {
-            if (message.content.trim()) {
+            if (message.content?.trim()) {
                 entries.push({ id: `${idBase}-assistant`, role: 'assistant', content: message.content });
             }
             for (const summary of sessionToolCallSummaries(message)) {
                 if (!completedToolCallIds.has(summary.id)) {
-                    entries.push({ id: `${idBase}-tool-call-${entries.length}`, role: 'tool', content: summary.content });
+                    entries.push({
+                        id: `${idBase}-tool-call-${entries.length}`,
+                        role: 'tool',
+                        content: summary.content,
+                    });
                 }
             }
             return;
@@ -547,7 +592,10 @@ function sessionMessagesToTranscriptEntries(sessionId) {
             entries.push({
                 id: `${idBase}-tool`,
                 role: 'tool',
-                content: summary ?? (message.toolCallId ? `Tool result ${message.toolCallId}\n${message.content}` : message.content),
+                content: summary ??
+                    (message.toolCallId
+                        ? `Tool result ${message.toolCallId}\n${message.content}`
+                        : message.content),
             });
             return;
         }
@@ -632,19 +680,27 @@ function parseLocalFastPath(input) {
     }
     const readMatch = /^(?:read|读取)\s+(.+)$/i.exec(text);
     const readTarget = readMatch?.[1]?.trim();
-    const looksLikePath = Boolean(readTarget)
-        && !/\s/.test(readTarget)
-        && (/[/\\.]/.test(readTarget) || readTarget.startsWith('~'));
+    const looksLikePath = Boolean(readTarget) &&
+        !/\s/.test(readTarget) &&
+        (/[/\\.]/.test(readTarget) || readTarget.startsWith('~'));
     if (readTarget && looksLikePath) {
         return { tool: 'read_file', args: { path: readTarget }, label: `read ${readTarget}` };
     }
     const grepMatch = /^(?:grep|搜索)\s+(.+)$/i.exec(text);
     if (grepMatch?.[1]?.trim()) {
-        return { tool: 'grep', args: { pattern: grepMatch[1].trim() }, label: `grep ${grepMatch[1].trim()}` };
+        return {
+            tool: 'grep',
+            args: { pattern: grepMatch[1].trim() },
+            label: `grep ${grepMatch[1].trim()}`,
+        };
     }
     const runTestMatch = /^(?:run\s+test|运行测试)\s*[:：]\s*(.+)$/i.exec(text);
     if (runTestMatch?.[1]?.trim()) {
-        return { tool: 'exec_command', args: { command: runTestMatch[1].trim() }, label: `run test: ${runTestMatch[1].trim()}` };
+        return {
+            tool: 'exec_command',
+            args: { command: runTestMatch[1].trim() },
+            label: `run test: ${runTestMatch[1].trim()}`,
+        };
     }
     return null;
 }
@@ -692,12 +748,7 @@ function createToolEventPresenter(events) {
                 role: 'tool',
                 title: 'tool',
                 content: toolStartContent(event),
-                toolActivity: {
-                    state: 'running',
-                    name: event.name,
-                    detail: '',
-                    seq,
-                },
+                toolActivity: structuredToolStartActivity(event, seq),
             });
             runningToolEntries.set(event.callId, {
                 entryId,
@@ -720,15 +771,7 @@ function createToolEventPresenter(events) {
             const content = toolFinishContent(event);
             const stored = runningToolEntries.get(event.callId);
             const seq = stored?.sequence ?? ++toolSequenceCounter;
-            const state = event.success ? 'success' : 'error';
-            const toolActivity = {
-                state,
-                name: event.name,
-                detail: '',
-                duration: `${event.duration}ms`,
-                error: event.error,
-                seq,
-            };
+            const toolActivity = structuredToolFinishActivity(event, seq);
             if (stored) {
                 events.finalize(stored.entryId, {
                     role: event.success ? 'tool' : 'error',
@@ -772,6 +815,7 @@ function createToolEventPresenter(events) {
                         state: 'skipped',
                         name: entry.name,
                         detail: '',
+                        body: '',
                         error: reason,
                         seq: entry.sequence,
                     },
@@ -799,7 +843,7 @@ async function captureConsoleOutput(fn) {
     const originalError = console.error;
     const originalWarn = console.warn;
     const capture = (...args) => {
-        lines.push(stripAnsi(args.map(arg => typeof arg === 'string' ? arg : JSON.stringify(arg)).join(' ')));
+        lines.push(stripAnsi(args.map(arg => (typeof arg === 'string' ? arg : JSON.stringify(arg))).join(' ')));
     };
     console.log = capture;
     console.error = capture;
@@ -849,7 +893,7 @@ class AgentChatController {
         }
         const command = (0, commands_1.findCommand)(parsed.name);
         if (!command) {
-            if ((0, skills_1.hasMatchingSkill)(text)) {
+            if ((0, skills_1.hasMatchingSkill)(text, this.runtime.cwd)) {
                 await this.runChat(text, options);
                 return;
             }
@@ -901,7 +945,9 @@ class AgentChatController {
         }
     }
     async runLocalFastPath(input, action, options = {}) {
-        const activeSession = this.runtime.getSession() ?? this.runtime.ensureSession() ?? (0, session_storage_1.loadSessionMeta)(this.runtime.getSession()?.id ?? '');
+        const activeSession = this.runtime.getSession() ??
+            this.runtime.ensureSession() ??
+            (0, session_storage_1.loadSessionMeta)(this.runtime.getSession()?.id ?? '');
         const sessionId = activeSession?.id;
         const turnId = traceTurnId(options.turnId);
         const localCallId = `local-${turnId}`;
@@ -980,23 +1026,25 @@ class AgentChatController {
                 modelVisibleToolBytes: 0,
                 summarizedBytes: outputBytes,
             });
+            const localToolResultEvent = {
+                type: 'tool_result',
+                name: action.tool,
+                args: action.args,
+                callId: localCallId,
+                result,
+                modelVisibleResult: result,
+                duration,
+                success: envelope.success,
+                error: envelope.error,
+                summary: envelope.summary,
+                outputBytes,
+                artifactRef: formattedLocalResult.artifactRef,
+            };
             this.events.append({
                 role: envelope.success ? 'tool' : 'error',
                 title: 'local',
-                content: toolFinishContent({
-                    type: 'tool_result',
-                    name: action.tool,
-                    args: action.args,
-                    callId: localCallId,
-                    result,
-                    modelVisibleResult: result,
-                    duration,
-                    success: envelope.success,
-                    error: envelope.error,
-                    summary: envelope.summary,
-                    outputBytes,
-                    artifactRef: formattedLocalResult.artifactRef,
-                }),
+                content: toolFinishContent(localToolResultEvent),
+                toolActivity: structuredToolFinishActivity(localToolResultEvent, 1),
             });
             this.runtime.store.addMessage({ role: 'assistant', content: assistantContent });
             this.setLoopStats(stats);
@@ -1082,6 +1130,7 @@ class AgentChatController {
             config: this.runtime.config,
             store: this.runtime.store,
             llm: this.runtime.llm,
+            compactCoordinator: this.runtime.compactCoordinator,
             runtime: this.runtime.runtime,
             sessionId: this.runtime.getSession()?.id,
             turnId,
@@ -1109,9 +1158,86 @@ class AgentChatController {
             uiCapabilities: (0, ui_events_1.resolveUiRendererCapabilities)(this.controllerOptions.uiCapabilities, this.controllerOptions.uiRenderer ?? this.runtime.config.ui?.renderer),
         };
     }
+    /**
+     * Forward a subagent lifecycle event to the runtime event sink and session
+     * trace. Renderers consume the same event across terminal/Ink/TUI; this is
+     * the only place a subtask event touches the root loop.
+     */
+    handleSubtaskEvent(event, sessionId, turnId) {
+        // Emit the renderer-independent runtime event first so all renderers
+        // (terminal/Ink/TUI) consume the same lifecycle through one protocol.
+        this.events.subtaskEvent?.(event);
+        const stateToTraceType = {
+            queued: 'subtask_requested',
+            running: 'subtask_started',
+            completed: 'subtask_completed',
+            failed: 'subtask_failed',
+            cancelled: 'subtask_cancelled',
+            rejected: 'subtask_rejected',
+            timed_out: 'subtask_timed_out',
+        };
+        if (sessionId) {
+            const traceType = stateToTraceType[event.state];
+            if (traceType) {
+                recordTraceEvent(this.events, sessionId, {
+                    turnId: String(turnId),
+                    type: traceType,
+                    name: `${event.role}:${event.taskId}`,
+                    argsSummary: event.objective.slice(0, 160),
+                });
+            }
+        }
+        // Surface start/complete/fail/cancel summaries in the transcript so all
+        // renderers show subtask progress without renderer-local logic.
+        if (event.state === 'running') {
+            this.events.append({
+                role: 'system',
+                content: `▸ subtask ${event.role} started: ${event.objective.slice(0, 120)}`,
+            });
+        }
+        else if (event.state === 'completed' ||
+            event.state === 'failed' ||
+            event.state === 'cancelled' ||
+            event.state === 'timed_out' ||
+            event.state === 'rejected') {
+            const summary = event.summary ? ` — ${event.summary.slice(0, 200)}` : '';
+            this.events.append({
+                role: 'system',
+                content: `◂ subtask ${event.role} ${event.state}${summary}`,
+            });
+        }
+    }
+    /**
+     * Fold reconciled child aggregate usage into the root turn's loop stats so
+     * `/cost` and loop-budget accounting reflect subagent cost. Child model
+     * requests and tool calls are added to the root counters; a note records the
+     * subagent contribution so it is distinguishable from root work.
+     */
+    foldSubagentUsage(stats, bundle) {
+        if (!bundle)
+            return stats;
+        const usage = bundle.getAggregateUsage();
+        if (usage.modelRequests === 0 && usage.toolCalls === 0)
+            return stats;
+        const subtaskCount = bundle.getSubtaskCount();
+        const subagentSuffix = `subagents: ${usage.modelRequests} req/${usage.toolCalls} calls across ${subtaskCount} task(s)`;
+        return {
+            ...stats,
+            llmRequests: (stats.llmRequests ?? 0) + usage.modelRequests,
+            toolCalls: (stats.toolCalls ?? 0) + usage.toolCalls,
+            readOnlyToolCalls: (stats.readOnlyToolCalls ?? 0) + usage.toolCalls,
+            continuationHint: stats.continuationHint
+                ? `${stats.continuationHint} (${subagentSuffix})`
+                : subagentSuffix,
+        };
+    }
     async runChat(input, options = {}) {
         if (!input) {
-            this.events.append({ role: 'error', content: 'Usage: /chat <message>', errorLayer: 'runtime' });
+            this.events.append({
+                role: 'error',
+                content: 'Usage: /chat <message>',
+                errorLayer: 'runtime',
+            });
             return;
         }
         if (!this.runtime.llm || !(0, config_1.isConfigured)(this.runtime.config)) {
@@ -1124,7 +1250,9 @@ class AgentChatController {
         }
         const abortSignal = options.abortSignal;
         const turnId = traceTurnId(options.turnId);
-        const activeSession = this.runtime.getSession() ?? this.runtime.ensureSession() ?? (0, session_storage_1.loadSessionMeta)(this.runtime.getSession()?.id ?? '');
+        const activeSession = this.runtime.getSession() ??
+            this.runtime.ensureSession() ??
+            (0, session_storage_1.loadSessionMeta)(this.runtime.getSession()?.id ?? '');
         const sessionId = activeSession?.id;
         const preWorkspace = (0, workspace_state_1.captureWorkspaceSnapshot)(this.runtime.cwd);
         const runtimeTools = (0, tools_1.getRuntimeTools)();
@@ -1167,14 +1295,67 @@ class AgentChatController {
         const intent = harness.updateContractFromUserInput(input);
         harness.recordAppliedSkills(skillResolution.skills);
         // Reconcile diagnostic: when harness state is present but objective may be incomplete
-        if (snapshot.harnessState && !snapshot.harnessState.rootObjective && !snapshot.harnessState.contract?.objective) {
+        if (snapshot.harnessState &&
+            !snapshot.harnessState.rootObjective &&
+            !snapshot.harnessState.contract?.objective) {
             this.events.setStatus('Resume diagnostic: harness state restored but objective may be incomplete. Run /harness explain to review.');
         }
+        const subagentConfig = this.runtime.config.subagents;
+        // The subtask capability is a root-level tool. It is exposed on normal
+        // turns, but respects an active skill scope: when a skill restricts the
+        // tool set, subtask is not appended (the skill owns the scope).
+        const projectPath = activeSession?.projectPath;
+        const subagentBundle = subagentConfig &&
+            subagentConfig.mode !== 'off' &&
+            this.runtime.llm &&
+            !skillResolution.toolScopeActive
+            ? (0, subagents_1.createSubagentBundleForTurn)({
+                config: subagentConfig,
+                cwd: this.runtime.cwd,
+                rootLlmConfig: (0, subagents_1.deriveRootLlmConfig)(this.runtime.config),
+                modelLabel: this.runtime.llm.getModel(),
+                rootObjectiveSummary: harness.toJSON()?.rootObjective ?? input,
+                abortSignal,
+                onSubtaskEvent: event => {
+                    this.handleSubtaskEvent(event, sessionId, turnId);
+                },
+                onSubtaskResult: (result, _batchId) => {
+                    if (!projectPath || result.status !== 'completed')
+                        return;
+                    const json = JSON.stringify(result);
+                    const artifact = (0, tool_artifacts_1.storeArtifact)(projectPath, `subtask_${result.role}`, json, Buffer.byteLength(json, 'utf8'));
+                    if (artifact) {
+                        // Record a trace event for artifact discoverability only.
+                        // The subtask state transition (subtask_completed) is already
+                        // emitted by handleSubtaskEvent above.
+                        if (sessionId) {
+                            recordTraceEvent(this.events, sessionId, {
+                                turnId: String(turnId),
+                                type: 'subtask_artifact_stored',
+                                name: `${result.role}:${result.id}`,
+                                argsSummary: result.summary.slice(0, 200),
+                                argsArtifactId: artifact.id,
+                                argsBytes: artifact.outputBytes,
+                            });
+                        }
+                    }
+                },
+                // R6: wire live permission state so the subagent policy gate can
+                // prevent background delegation while the user is deciding a tool
+                // permission. Injected by AgentRuntimeController via chatOptions.
+                hasPendingPermission: this.controllerOptions.hasPendingPermission,
+                // R6: wire child usage callback so CostTracker records subagent
+                // token consumption. Injected by AgentRuntimeController via chatOptions.
+                onChildUsage: this.controllerOptions.onChildUsage,
+            })
+            : null;
+        const subtaskTool = subagentBundle?.tool ?? null;
+        const turnTools = subtaskTool ? [...skillResolution.tools, subtaskTool] : skillResolution.tools;
         const promptCtx = {
             cwd: this.runtime.cwd,
             platform: process.platform,
             nodeVersion: process.version,
-            tools: skillResolution.tools,
+            tools: turnTools,
             memoryContent: snapshot.memoryContent,
             skillsContent: snapshot.skillsContent,
             projectInstructionsContent: snapshot.projectInstructionsContent,
@@ -1192,6 +1373,7 @@ class AgentChatController {
         let finalModel = '';
         let pendingCompleteTrace = null;
         let pendingCompleteStats;
+        let pendingCompact;
         const verificationResults = [];
         const sessionMessagesToRecord = [];
         const assistantStream = createAssistantStreamPresenter(this.events, abortSignal);
@@ -1204,7 +1386,19 @@ class AgentChatController {
             },
         };
         const toolExecutor = async (name, args, signal) => {
-            if (!skillResolution.tools.some(tool => tool.name === name)) {
+            // The runtime-bound `subtask` tool is not in the global TOOLS registry;
+            // dispatch it directly so it reaches the Supervisor closure.
+            if (name === 'subtask' && subtaskTool) {
+                const result = await subtaskTool.execute(args, {
+                    cwd: this.runtime.cwd,
+                    config: { name: this.runtime.config.name, mode: this.runtime.config.mode },
+                    abortSignal: signal,
+                    sessionId,
+                    turnId,
+                });
+                return JSON.stringify(result);
+            }
+            if (!turnTools.some(tool => tool.name === name)) {
                 return JSON.stringify({
                     success: false,
                     error: skillResolution.toolScopeActive
@@ -1233,7 +1427,7 @@ class AgentChatController {
         try {
             for await (const event of (0, framework_1.query)({
                 messages,
-                tools: skillResolution.tools,
+                tools: turnTools,
                 toolExecutor,
                 llm: this.runtime.llm,
                 streamCallbacks,
@@ -1254,6 +1448,10 @@ class AgentChatController {
                 harness,
                 input,
                 loopBudget,
+                onContextUsage: usage => {
+                    this.runtime.store.setContextUsage(usage);
+                },
+                compactCoordinator: this.runtime.compactCoordinator,
             })) {
                 switch (event.type) {
                     case 'request_start':
@@ -1304,9 +1502,7 @@ class AgentChatController {
                                 this.events.append({ role: 'status', content: suggestion });
                             }
                         }
-                        const checkpointId = checkpointSequence === 0
-                            ? turnId
-                            : `${turnId}-checkpoint-${checkpointSequence + 1}`;
+                        const checkpointId = checkpointSequence === 0 ? turnId : `${turnId}-checkpoint-${checkpointSequence + 1}`;
                         const checkpointResult = createPreToolCheckpoint(this.events, sessionId, turnId, checkpointId, this.runtime.cwd, event.toolCalls);
                         if (checkpointResult.created) {
                             checkpointIds.push(checkpointId);
@@ -1316,6 +1512,7 @@ class AgentChatController {
                             this.events.append({
                                 role: 'status',
                                 title: 'checkpoint',
+                                statusTone: 'warning',
                                 content: `Risky edit: ${checkpointResult.targetCount} files in one turn. Checkpoint ${checkpointId} created for rollback (/checkpoints restore ${checkpointId}).`,
                             });
                         }
@@ -1323,6 +1520,7 @@ class AgentChatController {
                             this.events.append({
                                 role: 'status',
                                 title: 'checkpoint',
+                                statusTone: 'warning',
                                 content: `Risky edit: ${checkpointResult.targetCount} files in one turn, but checkpoint creation failed. Restore any pre-existing checkpoint manually or revert via git.`,
                             });
                         }
@@ -1476,6 +1674,7 @@ class AgentChatController {
                         finalContent = event.content;
                         finalUsage = event.usage;
                         finalModel = event.model;
+                        pendingCompact = event.compact;
                         if (event.stats) {
                             pendingCompleteStats = event.stats;
                             recordProviderTraceEvents(this.events, sessionId, turnId, event.stats);
@@ -1532,11 +1731,17 @@ class AgentChatController {
                         this.events.append({
                             role: 'status',
                             title: 'recovery',
+                            statusTone: 'warning',
                             content: recoveryNotice,
                         });
                     }
                     (0, session_storage_1.removeLastIncompleteAssistantMessage)(sessionId);
                 }
+                // Persist any accumulated session messages before returning,
+                // so tool results from the interrupted turn are not lost.
+                if (sessionId && sessionMessagesToRecord.length > 0) {
+                    (0, session_storage_1.appendSessionMessages)(sessionId, sessionMessagesToRecord);
+                }
                 return;
             }
             assistantStream.closeSegment();
@@ -1559,6 +1764,7 @@ class AgentChatController {
                     this.events.append({
                         role: 'status',
                         title: 'verification',
+                        statusTone: 'warning',
                         content: notice,
                     });
                     finalContent = finalContent ? `${finalContent}\n\n${notice}` : notice;
@@ -1603,12 +1809,17 @@ class AgentChatController {
                     lines.push(`Next: ${stats.continuationHint}`);
                 }
                 const notice = lines.join('\n');
-                this.events.append({ role: 'status', title: 'budget', content: notice });
+                this.events.append({
+                    role: 'status',
+                    title: 'budget',
+                    statusTone: 'warning',
+                    content: notice,
+                });
                 finalContent = finalContent ? `${finalContent}\n\n${notice}` : notice;
                 appendAssistantNotice(sessionMessagesToRecord, notice);
             }
             if (pendingCompleteStats) {
-                this.setLoopStats(pendingCompleteStats);
+                this.setLoopStats(this.foldSubagentUsage(pendingCompleteStats, subagentBundle));
             }
             if (finalContent) {
                 this.runtime.store.addMessage({ role: 'assistant', content: finalContent });
@@ -1616,7 +1827,74 @@ class AgentChatController {
             if (sessionId && sessionMessagesToRecord.length > 0) {
                 (0, session_storage_1.appendSessionMessages)(sessionId, sessionMessagesToRecord);
             }
+            if (pendingCompact) {
+                try {
+                    let committedCheckpointId;
+                    if (sessionId) {
+                        const sourceMessageCount = (0, session_storage_1.readSessionMessages)(sessionId).length;
+                        const checkpoint = (0, session_storage_1.commitSessionCompactCheckpoint)({
+                            sessionId,
+                            mode: pendingCompact.mode,
+                            modelId: finalModel || this.runtime.llm.getModel(),
+                            sourceMessageCount,
+                            transcriptStartMessageIndex: Math.max(0, sourceMessageCount - 20),
+                            modelHistory: pendingCompact.modelHistory,
+                            summary: pendingCompact.summary,
+                            beforeUsage: pendingCompact.before,
+                            afterUsage: pendingCompact.after,
+                        });
+                        committedCheckpointId = checkpoint.checkpointId;
+                        this.runtime.store.setState({ conversationHistory: checkpoint.modelHistory });
+                    }
+                    else {
+                        this.runtime.store.setState({
+                            conversationHistory: pendingCompact.modelHistory.filter(message => message.role !== 'system'),
+                        });
+                    }
+                    this.runtime.store.setContextUsage(pendingCompact.after);
+                    if (sessionId) {
+                        recordTraceEvent(this.events, sessionId, {
+                            turnId,
+                            type: 'compact_completed',
+                            checkpointId: committedCheckpointId,
+                            model: finalModel || this.runtime.llm.getModel(),
+                            note: pendingCompact.mode,
+                        });
+                    }
+                    this.events.append({
+                        role: 'status',
+                        title: 'auto-compact',
+                        statusTone: 'neutral',
+                        content: `Context reached ${pendingCompact.before.percent}% of the safe input budget. Agent core committed a ${pendingCompact.mode} compact checkpoint; current context is ${pendingCompact.after.percent}%.`,
+                    });
+                }
+                catch (error) {
+                    if (sessionId) {
+                        recordTraceEvent(this.events, sessionId, {
+                            turnId,
+                            type: 'compact_failed',
+                            model: finalModel || this.runtime.llm.getModel(),
+                            error: compactTraceError(error),
+                            note: pendingCompact.mode,
+                        });
+                    }
+                    this.events.append({
+                        role: 'error',
+                        title: 'compact-failed',
+                        content: `Compact checkpoint failed; the previous model context remains active. ${error instanceof Error ? error.message : String(error)}`,
+                        errorLayer: 'runtime',
+                    });
+                }
+            }
             if (finalUsage) {
+                // Fold subagent token usage into /cost accounting.
+                if (subagentBundle) {
+                    const subUsage = subagentBundle.getAggregateUsage();
+                    finalUsage = {
+                        promptTokens: finalUsage.promptTokens + subUsage.promptTokens,
+                        completionTokens: finalUsage.completionTokens + subUsage.completionTokens,
+                    };
+                }
                 this.runtime.store.setTokenUsage(finalUsage);
             }
             harness.ingestTurn({
@@ -1660,6 +1938,7 @@ class AgentChatController {
                         this.events.append({
                             role: 'status',
                             title: 'recovery',
+                            statusTone: 'warning',
                             content: recoveryNotice,
                         });
                     }
@@ -1668,7 +1947,11 @@ class AgentChatController {
                 return;
             }
             assistantStream.discardSegment();
-            this.events.append({ role: 'error', content: formatChatError(error), errorLayer: errorLayerForChatError(error) });
+            this.events.append({
+                role: 'error',
+                content: formatChatError(error),
+                errorLayer: errorLayerForChatError(error),
+            });
             this.events.setStatus('Turn failed. Ready for the next input.');
             const failedStats = error instanceof framework_1.QueryLoopError
                 ? error.stats
@@ -1694,6 +1977,7 @@ class AgentChatController {
                     this.events.append({
                         role: 'status',
                         title: 'recovery',
+                        statusTone: 'warning',
                         content: recoveryNotice,
                     });
                 }
@@ -1736,7 +2020,9 @@ exports.InkChatController = AgentChatController;
 function loadSessionIntoRuntime(runtime, sessionId) {
     const history = (0, session_storage_1.loadSessionHistory)(sessionId);
     runtime.store.setState({ conversationHistory: history });
-    runtime.store.setState({ harnessState: (0, session_storage_1.loadSessionHarnessState)(sessionId) ?? (0, session_storage_1.loadSessionMeta)(sessionId)?.harnessState });
+    runtime.store.setState({
+        harnessState: (0, session_storage_1.loadSessionHarnessState)(sessionId) ?? (0, session_storage_1.loadSessionMeta)(sessionId)?.harnessState,
+    });
     return `Restored ${history.length} messages`;
 }
 function closeSession(runtime) {