openhorse 0.2.12 → 0.2.13

package/dist/runtime/chat-controller.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InkChatController = exports.AgentChatController = void 0;
 exports.sessionMessagesToTranscriptEntries = sessionMessagesToTranscriptEntries;
@@ -8,17 +41,26 @@ exports.loadSessionIntoRuntime = loadSessionIntoRuntime;
 exports.closeSession = closeSession;
 const commands_1 = require("../commands");
 const parser_1 = require("../commands/parser");
+const path = __importStar(require("path"));
 const session_storage_1 = require("../services/session-storage");
 const config_1 = require("../services/config");
 const framework_1 = require("../framework");
 const harness_1 = require("../harness");
 const tools_1 = require("../tools");
+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 file_context_1 = require("../services/file-context");
 const prompt_context_1 = require("../services/prompt-context");
+const workspace_state_1 = require("../services/workspace-state");
+const verification_profile_1 = require("../services/verification-profile");
 const ui_events_1 = require("./ui-events");
 const agent_status_1 = require("./agent-status");
+const loop_budget_1 = require("./loop-budget");
 const ANSI_PATTERN = /\x1b\[[0-9;?]*[A-Za-z]/g;
+const LOCAL_FAST_PATH_INLINE_OUTPUT_BYTES = 2048;
+const TRACE_ARGS_ARTIFACT_THRESHOLD_BYTES = 160;
 function stripAnsi(text) {
     return text.replace(ANSI_PATTERN, '');
 }
@@ -64,6 +106,316 @@ function compactToolArgs(args, maxLength = 160) {
     }
     return '';
 }
+function fullToolArgsForTrace(name, args) {
+    if (name === 'exec_command' && typeof args.command === 'string') {
+        return `$ ${args.command}`;
+    }
+    try {
+        return JSON.stringify(args, null, 2);
+    }
+    catch {
+        return compactToolArgs(args, 2048);
+    }
+}
+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) {
+        return { argsSummary };
+    }
+    const artifact = (0, tool_artifacts_1.storeArtifact)(projectPath, `${name}-args`, fullArgs, argsBytes);
+    return artifact
+        ? { argsSummary, argsArtifactId: artifact.id, argsBytes }
+        : { argsSummary };
+}
+function parseToolCallArgsForRuntime(toolCall) {
+    try {
+        const parsed = JSON.parse(toolCall.function.arguments || '{}');
+        return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveProjectScopedPath(cwd, filePath) {
+    const absolute = path.resolve(cwd, filePath);
+    const relative = path.relative(cwd, absolute);
+    if (relative.startsWith('..') || path.isAbsolute(relative))
+        return null;
+    return absolute;
+}
+function checkpointTargetsFromToolCalls(cwd, toolCalls) {
+    const targets = new Set();
+    for (const toolCall of toolCalls) {
+        const name = toolCall.function.name;
+        if (name !== 'write_file' && name !== 'edit_file')
+            continue;
+        const args = parseToolCallArgsForRuntime(toolCall);
+        if (!args || typeof args.path !== 'string')
+            continue;
+        if (name === 'edit_file' && args.preview === true)
+            continue;
+        const target = resolveProjectScopedPath(cwd, args.path);
+        if (target)
+            targets.add(target);
+    }
+    return Array.from(targets);
+}
+function createPreToolCheckpoint(events, sessionId, turnId, checkpointId, cwd, toolCalls) {
+    const targets = checkpointTargetsFromToolCalls(cwd, toolCalls);
+    if (targets.length === 0)
+        return false;
+    const checkpoint = (0, checkpoint_1.createCheckpoint)(cwd, checkpointId, targets);
+    if (!sessionId)
+        return true;
+    const relativeTargets = targets.map(target => path.relative(cwd, target));
+    recordTraceEvent(events, sessionId, {
+        turnId,
+        type: 'checkpoint',
+        checkpointId,
+        checkpointFileCount: checkpoint?.files.length ?? 0,
+        checkpointFiles: checkpoint?.files.map(file => file.path) ?? [],
+        workspaceFiles: relativeTargets,
+        note: checkpoint
+            ? 'pre_edit_checkpoint'
+            : 'pre_edit_checkpoint_skipped',
+    });
+    return true;
+}
+function byteLength(text) {
+    return Buffer.byteLength(text, 'utf8');
+}
+function traceTurnId(turnId) {
+    return turnId == null ? `turn-${Date.now()}` : String(turnId);
+}
+function compactTraceError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return compactMiddle(message, 240);
+}
+function getLastRequestDiagnostics(llm) {
+    if (!llm)
+        return undefined;
+    const reader = llm.getLastRequestDiagnostics;
+    return typeof reader === 'function' ? reader.call(llm) : undefined;
+}
+function compactPathList(paths, maxItems = 40) {
+    return paths.slice(0, maxItems);
+}
+function formatWorkspaceFileForTrace(file) {
+    const metadata = [
+        typeof file.sizeBytes === 'number' ? `${file.sizeBytes}B` : '',
+        typeof file.mtimeMs === 'number' ? `mtime=${file.mtimeMs}` : '',
+    ].filter(Boolean).join(' ');
+    return `${file.status} ${file.path}${metadata ? ` (${metadata})` : ''}`;
+}
+function appendWorkspaceSnapshotTrace(events, sessionId, turnId, phase, snapshot) {
+    if (!sessionId)
+        return;
+    recordTraceEvent(events, sessionId, {
+        turnId,
+        type: 'workspace_snapshot',
+        workspacePhase: phase,
+        workspaceGitAvailable: snapshot.gitAvailable,
+        workspaceDirty: snapshot.dirty,
+        workspaceBranch: snapshot.branch,
+        workspaceFileCount: snapshot.fileCount,
+        workspaceFiles: compactPathList(snapshot.files.map(formatWorkspaceFileForTrace)),
+        error: snapshot.error ? compactMiddle(snapshot.error, 240) : undefined,
+    });
+}
+function appendWorkspaceDeltaTrace(events, sessionId, turnId, before, after) {
+    const delta = (0, workspace_state_1.diffWorkspaceSnapshots)(before, after);
+    if (sessionId) {
+        recordTraceEvent(events, sessionId, {
+            turnId,
+            type: 'workspace_delta',
+            workspaceFileCount: delta.filesAfterTurn.length,
+            workspaceFiles: compactPathList(delta.filesAfterTurn),
+            workspaceNewByTurn: compactPathList(delta.newFilesByTurn),
+            workspaceChangedByTurn: compactPathList(delta.changedByTurn),
+            workspaceModifiedPreExistingByTurn: compactPathList(delta.modifiedPreExistingByTurn),
+            workspaceResolvedByTurn: compactPathList(delta.resolvedByTurn),
+            note: `pre_existing=${delta.preExistingFiles.length}`,
+        });
+    }
+    return delta;
+}
+function workspaceDeltaHasTurnChanges(delta) {
+    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 checkpointText = checkpointIds.length > 0
+        ? ` Checkpoints: ${checkpointIds.join(', ')}. Preview rollback with /checkpoint restore <id>; restore each listed checkpoint if multiple.`
+        : '';
+    return `Turn failed after modifying files: ${fileText}. Inspect /trace ${turnId}.${checkpointText}`;
+}
+function appendVerificationProfileTrace(events, sessionId, turnId, profile) {
+    if (!sessionId || profile.changedFiles.length === 0)
+        return;
+    recordTraceEvent(events, sessionId, {
+        turnId,
+        type: 'verification_profile',
+        verificationProfile: profile.profile,
+        verificationRequired: profile.required,
+        verificationCommands: compactPathList(profile.commands, 8),
+        verificationChangedFiles: compactPathList(profile.changedFiles),
+        note: profile.reason,
+    });
+}
+function appendVerificationResultTrace(events, sessionId, turnId, result) {
+    if (!sessionId)
+        return;
+    recordTraceEvent(events, sessionId, {
+        turnId,
+        type: 'verification_result',
+        verificationCommand: result.command,
+        verificationPassed: result.success,
+        outputBytes: result.outputBytes,
+        error: result.error ? compactMiddle(result.error, 240) : undefined,
+    });
+}
+function appendVerificationSummaryTrace(events, sessionId, turnId, summary, changedFiles) {
+    if (!sessionId || changedFiles.length === 0)
+        return;
+    recordTraceEvent(events, sessionId, {
+        turnId,
+        type: 'verification_summary',
+        verificationProfile: summary.profile,
+        verificationRequired: summary.required,
+        verificationCommands: compactPathList(summary.commandsRun, 12),
+        verificationPassedCommands: compactPathList(summary.passedCommands, 12),
+        verificationFailedCommands: compactPathList(summary.failedCommands, 12),
+        verificationMissingCommands: compactPathList(summary.missingCommands, 12),
+        verificationChangedFiles: compactPathList(changedFiles),
+        verificationClaimAllowed: summary.claimAllowed,
+        note: summary.skippedReason,
+    });
+}
+function compactVerificationCommands(commands, maxItems = 12) {
+    return commands.slice(0, maxItems).map(session_storage_1.redactTraceText);
+}
+function withVerificationLoopStats(stats, summary) {
+    return {
+        ...stats,
+        verificationProfile: summary.profile,
+        verificationRequired: summary.required,
+        verificationClaimAllowed: summary.claimAllowed,
+        verificationPassedCommands: compactVerificationCommands(summary.passedCommands),
+        verificationFailedCommands: compactVerificationCommands(summary.failedCommands),
+        verificationMissingCommands: compactVerificationCommands(summary.missingCommands),
+        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;
+}
+function appendPostWorkspaceTrace(events, sessionId, turnId, cwd, before, verificationResults = []) {
+    const postWorkspace = (0, workspace_state_1.captureWorkspaceSnapshot)(cwd);
+    appendWorkspaceSnapshotTrace(events, sessionId, turnId, 'post_turn', postWorkspace);
+    const delta = appendWorkspaceDeltaTrace(events, sessionId, turnId, before, postWorkspace);
+    const profile = (0, verification_profile_1.selectVerificationProfile)(cwd, delta.changedByTurn);
+    const summary = (0, verification_profile_1.summarizeVerificationState)(profile, verificationResults);
+    appendVerificationProfileTrace(events, sessionId, turnId, profile);
+    appendVerificationSummaryTrace(events, sessionId, turnId, summary, profile.changedFiles);
+    return { delta, profile, summary };
+}
+function appendAssistantNotice(messages, notice) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message.role === 'assistant' && !message.tool_calls) {
+            message.content = message.content ? `${message.content}\n\n${notice}` : notice;
+            return;
+        }
+    }
+    messages.push({
+        role: 'assistant',
+        content: notice,
+        timestamp: Date.now(),
+    });
+}
+function recordTraceEvent(events, sessionId, event) {
+    if (!sessionId)
+        return null;
+    const traceEvent = (0, session_storage_1.appendSessionTraceEvent)(sessionId, event);
+    if (traceEvent) {
+        events.traceEventRecorded?.(traceEvent);
+    }
+    return traceEvent;
+}
+function recordProviderTraceEvents(events, sessionId, turnId, stats) {
+    if ((stats.providerRetryCount ?? 0) > 0) {
+        recordTraceEvent(events, sessionId, {
+            turnId,
+            type: 'provider_retry',
+            providerRetryCount: stats.providerRetryCount,
+            providerRetryDelayMs: stats.providerRetryDelayMs,
+            providerRetryErrorTypes: stats.providerRetryErrorTypes,
+            providerLastRetryErrorType: stats.providerLastRetryErrorType,
+            providerLastRetryStatus: stats.providerLastRetryStatus,
+            providerFinalModel: stats.providerFinalModel,
+            providerUsingFallback: stats.providerUsingFallback,
+        });
+    }
+    if ((stats.providerFallbackCount ?? 0) > 0 || stats.providerUsingFallback) {
+        recordTraceEvent(events, sessionId, {
+            turnId,
+            type: 'provider_fallback',
+            providerFallbackCount: stats.providerFallbackCount,
+            providerFallbackFromModel: stats.providerFallbackFromModel,
+            providerFallbackToModel: stats.providerFallbackToModel,
+            providerFinalModel: stats.providerFinalModel,
+            providerUsingFallback: stats.providerUsingFallback,
+        });
+    }
+}
+function toHarnessDiagnostics(state) {
+    const stats = state.promptAssemblyStats;
+    const redactOptional = (value) => typeof value === 'string' ? (0, session_storage_1.redactTraceText)(value) : undefined;
+    const redactList = (values) => values?.slice(0, 6).map(session_storage_1.redactTraceText);
+    return {
+        taskEpoch: state.taskEpoch,
+        rootObjective: redactOptional(state.rootObjective ?? state.contract?.objective),
+        activeInstruction: redactOptional(state.activeInstruction ?? state.contract?.userIntent),
+        openQuestions: redactList(state.openQuestions),
+        diagnostics: redactList(state.diagnostics?.slice(-6)),
+        ledgerSize: state.ledger?.length ?? 0,
+        evidenceSize: state.evidenceIndex?.length ?? 0,
+        turnSummaryCount: state.turnSummaries?.length ?? 0,
+        promptAssembly: stats
+            ? {
+                modelId: stats.modelId,
+                estimatedTokens: stats.estimatedTokens,
+                budgetTokens: stats.budgetTokens,
+                sections: stats.sections.slice(0, 12),
+                includedEvidence: stats.includedEvidence.length,
+                omittedEvidence: stats.omittedEvidence.length,
+            }
+            : undefined,
+    };
+}
+function emitHarnessDiagnostics(events, state) {
+    events.harnessDiagnosticsUpdated?.(toHarnessDiagnostics(state));
+}
 function toolStartContent(name, args) {
     if (name === 'exec_command' && typeof args.command === 'string') {
         return `Running ${name}\n  $ ${args.command}`;
@@ -254,8 +606,76 @@ function createAssistantStreamPresenter(events, abortSignal) {
             activeSegmentText = content;
             ensureLiveEntry();
         },
+        replaceMessage(content) {
+            if (abortSignal?.aborted || !content)
+                return;
+            activeSegmentText = content;
+            ensureLiveEntry();
+        },
     };
 }
+class LocalFastPathBlockedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'LocalFastPathBlockedError';
+    }
+}
+function parseLocalFastPath(input) {
+    const text = input.trim();
+    if (/^git\s+status$/i.test(text)) {
+        return { tool: 'git_status', args: {}, label: 'git status' };
+    }
+    const readMatch = /^(?:read|读取)\s+(.+)$/i.exec(text);
+    const readTarget = readMatch?.[1]?.trim();
+    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()}` };
+    }
+    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 null;
+}
+function formatLocalFastPathAssistantContent(action, rawResult, projectPath) {
+    const envelope = (0, tool_serializer_1.parseToolResultEnvelope)(rawResult);
+    const output = typeof envelope.output === 'string' ? envelope.output.trim() : '';
+    const summary = envelope.summary || `${action.tool} ${envelope.success ? 'completed' : 'failed'}`;
+    const lines = [
+        envelope.success
+            ? `Local fast path completed ${action.label}.`
+            : `Local fast path failed ${action.label}.`,
+        '',
+        summary,
+    ];
+    if (!envelope.success && envelope.error) {
+        lines.push(`Error: ${envelope.error}`);
+    }
+    if (!output) {
+        return lines.join('\n');
+    }
+    let artifactRef = envelope.artifactRef;
+    let preview = output;
+    const outputBytes = envelope.outputBytes ?? byteLength(output);
+    if (byteLength(output) > LOCAL_FAST_PATH_INLINE_OUTPUT_BYTES) {
+        if (!artifactRef) {
+            const artifact = (0, tool_artifacts_1.storeArtifact)(projectPath, action.tool, output, outputBytes);
+            artifactRef = artifact ? { id: artifact.id, outputBytes: artifact.outputBytes } : undefined;
+        }
+        preview = (0, tool_artifacts_1.truncateForContext)(output, LOCAL_FAST_PATH_INLINE_OUTPUT_BYTES);
+    }
+    if (artifactRef) {
+        lines.push('', `Full output: /artifacts show ${artifactRef.id} --full (${artifactRef.outputBytes}B)`);
+    }
+    lines.push('', 'Preview:', preview);
+    return lines.join('\n');
+}
 function createToolEventPresenter(events) {
     const runningToolEntries = new Map();
     return {
@@ -331,12 +751,21 @@ class AgentChatController {
         this.events = events;
         this.controllerOptions = controllerOptions;
     }
+    setLoopStats(stats) {
+        this.runtime.store.setLastLoopStats(stats);
+        this.events.loopStatsUpdated?.(stats);
+    }
     async runInput(input, options = {}) {
         const text = input.trim();
         if (!text)
             return;
         const parsed = (0, parser_1.parseInput)(text);
         if (!parsed.isCommand) {
+            const localFastPath = parseLocalFastPath(text);
+            if (localFastPath) {
+                await this.runLocalFastPath(text, localFastPath, options);
+                return;
+            }
             await this.runChat(text, options);
             return;
         }
@@ -400,6 +829,179 @@ class AgentChatController {
             await this.runChat(result.chatInput ?? parsed.args, options);
         }
     }
+    async runLocalFastPath(input, action, options = {}) {
+        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}`;
+        const start = Date.now();
+        const preWorkspace = (0, workspace_state_1.captureWorkspaceSnapshot)(this.runtime.cwd);
+        const traceArgs = buildTraceArgsDetails(this.runtime.cwd, action.tool, action.args);
+        if (sessionId) {
+            (0, session_storage_1.appendSessionMessage)(sessionId, {
+                role: 'user',
+                content: input,
+                timestamp: Date.now(),
+            });
+            recordTraceEvent(this.events, sessionId, {
+                turnId,
+                type: 'turn_start',
+                inputBytes: byteLength(input),
+                localFastPathUsed: true,
+            });
+            appendWorkspaceSnapshotTrace(this.events, sessionId, turnId, 'pre_turn', preWorkspace);
+            recordTraceEvent(this.events, sessionId, {
+                turnId,
+                type: 'local_fast_path',
+                name: action.tool,
+                ...traceArgs,
+                note: compactMiddle(action.label, 160),
+            });
+        }
+        this.runtime.store.addMessage({ role: 'user', content: input });
+        this.events.setStatus(`Running local ${action.label}...`);
+        try {
+            const tool = (0, tools_1.getRuntimeTools)().find(candidate => candidate.name === action.tool);
+            const toolContext = {
+                cwd: this.runtime.cwd,
+                config: {
+                    name: this.runtime.config.name,
+                    mode: this.runtime.config.mode,
+                },
+                sessionId,
+                turnId,
+            };
+            const permission = tool?.checkPermissions?.(action.args, toolContext);
+            if (permission?.behavior === 'deny' || tool?.isDestructive?.(action.args) === true) {
+                const reason = permission?.reason || 'Local fast path blocked a destructive tool request.';
+                throw new LocalFastPathBlockedError(reason);
+            }
+            if (permission?.behavior === 'ask') {
+                throw new LocalFastPathBlockedError(permission.reason || 'Local fast path requires an allow-safe command.');
+            }
+            if (sessionId) {
+                recordTraceEvent(this.events, sessionId, {
+                    turnId,
+                    type: 'tool_call',
+                    name: action.tool,
+                    callId: localCallId,
+                    ...traceArgs,
+                });
+            }
+            const result = await (0, tools_1.executeTool)(action.tool, action.args, options.abortSignal, {
+                ...toolContext,
+                sessionId,
+                turnId,
+            });
+            const duration = Date.now() - start;
+            const envelope = (0, tool_serializer_1.parseToolResultEnvelope)(result);
+            const outputBytes = typeof envelope.outputBytes === 'number'
+                ? envelope.outputBytes
+                : Buffer.byteLength(result, 'utf8');
+            const assistantContent = formatLocalFastPathAssistantContent(action, result, this.runtime.cwd);
+            const stats = (0, framework_1.createLocalFastPathLoopStats)({
+                finishReason: envelope.success ? 'completed' : 'failed',
+                toolCalls: 1,
+                readOnlyToolCalls: action.tool === 'exec_command' ? 0 : 1,
+                unsafeToolCalls: action.tool === 'exec_command' ? 1 : 0,
+                toolResultBytes: outputBytes,
+                modelVisibleToolBytes: 0,
+                summarizedBytes: outputBytes,
+            });
+            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,
+                }),
+            });
+            this.runtime.store.addMessage({ role: 'assistant', content: assistantContent });
+            this.setLoopStats(stats);
+            if (sessionId) {
+                recordTraceEvent(this.events, sessionId, {
+                    turnId,
+                    type: 'tool_result',
+                    name: action.tool,
+                    callId: localCallId,
+                    argsSummary: traceArgs.argsSummary,
+                    argsArtifactId: traceArgs.argsArtifactId,
+                    argsBytes: traceArgs.argsBytes,
+                    success: envelope.success,
+                    duration,
+                    outputBytes,
+                    modelVisibleBytes: 0,
+                    error: envelope.error ? compactMiddle(envelope.error, 240) : undefined,
+                });
+                appendPostWorkspaceTrace(this.events, sessionId, turnId, this.runtime.cwd, preWorkspace);
+                recordTraceEvent(this.events, sessionId, {
+                    turnId,
+                    type: 'complete',
+                    finishReason: stats.finishReason,
+                    llmRequests: stats.llmRequests,
+                    toolCalls: stats.toolCalls,
+                    readOnlyToolCalls: stats.readOnlyToolCalls,
+                    unsafeToolCalls: stats.unsafeToolCalls,
+                    localFastPathUsed: true,
+                });
+                (0, session_storage_1.appendSessionMessage)(sessionId, {
+                    role: 'assistant',
+                    content: assistantContent,
+                    timestamp: Date.now(),
+                });
+                const recordedMessages = (0, session_storage_1.readSessionMessages)(sessionId);
+                if (recordedMessages.length > 0) {
+                    (0, session_storage_1.updateSessionSummary)(sessionId, recordedMessages);
+                }
+            }
+            this.events.setStatus(envelope.success ? `Completed local ${action.label}` : `Failed local ${action.label}`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.events.append({ role: 'error', title: 'local', content: message });
+            this.events.setStatus('Local command failed. Ready for the next input.');
+            const assistantContent = `Local fast path failed for ${action.label}.\n\n${message}`;
+            this.runtime.store.addMessage({ role: 'assistant', content: assistantContent });
+            const finishReason = error instanceof LocalFastPathBlockedError ? 'blocked' : 'failed';
+            const stats = (0, framework_1.createLocalFastPathLoopStats)({
+                finishReason,
+                toolCalls: 0,
+            });
+            this.setLoopStats(stats);
+            if (sessionId) {
+                recordTraceEvent(this.events, sessionId, {
+                    turnId,
+                    type: 'error',
+                    name: action.tool,
+                    error: compactTraceError(error),
+                });
+                appendPostWorkspaceTrace(this.events, sessionId, turnId, this.runtime.cwd, preWorkspace);
+                recordTraceEvent(this.events, sessionId, {
+                    turnId,
+                    type: 'complete',
+                    finishReason: stats.finishReason,
+                    llmRequests: stats.llmRequests,
+                    toolCalls: stats.toolCalls,
+                    localFastPathUsed: true,
+                    note: 'local_fast_path_failed',
+                });
+                (0, session_storage_1.appendSessionMessage)(sessionId, {
+                    role: 'assistant',
+                    content: assistantContent,
+                    timestamp: Date.now(),
+                });
+            }
+        }
+    }
     createCommandContext(abortSignal, turnId) {
         return {
             cwd: this.runtime.cwd,
@@ -414,6 +1016,9 @@ class AgentChatController {
                 this.runtime.setSession(session);
                 this.events.replaceTranscript(sessionMessagesToTranscriptEntries(session.id));
             },
+            sessionRestored: event => {
+                this.events.sessionRestored?.(event);
+            },
             getSession: this.runtime.getSession,
             abortSignal,
             writeOutput: text => {
@@ -442,9 +1047,10 @@ class AgentChatController {
             return;
         }
         const abortSignal = options.abortSignal;
-        const turnId = options.turnId;
+        const turnId = traceTurnId(options.turnId);
         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)();
         const skillResolution = (0, skills_1.resolveSkillsForTurn)({
             cwd: this.runtime.cwd,
@@ -461,6 +1067,13 @@ class AgentChatController {
                 timestamp: Date.now(),
                 appliedSkills: appliedSkillNames.length > 0 ? appliedSkillNames : undefined,
             });
+            recordTraceEvent(this.events, sessionId, {
+                turnId,
+                type: 'turn_start',
+                inputBytes: byteLength(input),
+                note: appliedSkillNames.length > 0 ? `skills=${appliedSkillNames.join(',')}` : undefined,
+            });
+            appendWorkspaceSnapshotTrace(this.events, sessionId, turnId, 'pre_turn', preWorkspace);
         }
         this.runtime.store.addMessage({ role: 'user', content: input });
         (0, prompt_context_1.refreshProjectInstructions)(this.runtime.store, this.runtime.cwd);
@@ -497,9 +1110,14 @@ class AgentChatController {
         let finalContent = '';
         let finalUsage;
         let finalModel = '';
+        let pendingCompleteTrace = null;
+        let pendingCompleteStats;
+        const verificationResults = [];
         const sessionMessagesToRecord = [];
         const assistantStream = createAssistantStreamPresenter(this.events, abortSignal);
         const toolEvents = createToolEventPresenter(this.events);
+        let checkpointSequence = 0;
+        const checkpointIds = [];
         const streamCallbacks = {
             onChunk: chunk => {
                 assistantStream.appendChunk(chunk);
@@ -524,6 +1142,14 @@ class AgentChatController {
                 turnId,
             });
         };
+        const loopBudget = (0, loop_budget_1.resolveRuntimeLoopBudget)(input, this.runtime.config, harness.toJSON());
+        let observedTurnsStarted = 0;
+        let observedLlmRequests = 0;
+        let observedToolCalls = 0;
+        let observedReadOnlyToolCalls = 0;
+        let observedUnsafeToolCalls = 0;
+        let observedToolResultBytes = 0;
+        let observedModelVisibleToolBytes = 0;
         try {
             for await (const event of (0, framework_1.query)({
                 messages,
@@ -547,11 +1173,41 @@ class AgentChatController {
                 abortSignal,
                 harness,
                 input,
+                loopBudget,
             })) {
                 switch (event.type) {
                     case 'request_start':
+                        observedTurnsStarted = Math.max(observedTurnsStarted, event.turn);
+                        observedLlmRequests++;
                         assistantStream.discardSegment();
                         this.events.setStatus((0, agent_status_1.agentStepStatus)(event.turn));
+                        if (sessionId) {
+                            recordTraceEvent(this.events, sessionId, {
+                                turnId,
+                                type: 'request_start',
+                                model: event.model,
+                                turn: event.turn,
+                            });
+                        }
+                        break;
+                    case 'prompt_assembly':
+                        if (sessionId) {
+                            recordTraceEvent(this.events, sessionId, {
+                                turnId,
+                                type: 'prompt_assembly',
+                                promptModelId: event.modelId,
+                                promptEstimatedTokens: event.estimatedTokens,
+                                promptBudgetTokens: event.budgetTokens,
+                                promptCoreTokens: event.coreTokens,
+                                promptEvidenceBudgetTokens: event.evidenceBudgetTokens,
+                                promptRecentTurnBudgetTokens: event.recentTurnBudgetTokens,
+                                promptSections: event.sections,
+                                promptIncludedEvidence: event.includedEvidence,
+                                promptOmittedEvidence: event.omittedEvidence,
+                                promptIncludedEvidenceCount: event.includedEvidenceCount,
+                                promptOmittedEvidenceCount: event.omittedEvidenceCount,
+                            });
+                        }
                         break;
                     case 'assistant_tool_calls':
                         assistantStream.ensureMessage(event.content || '');
@@ -559,6 +1215,21 @@ class AgentChatController {
                         if (event.toolCalls.length > 1) {
                             this.events.setStatus((0, agent_status_1.runningToolsStatus)(event.toolCalls.length));
                         }
+                        const checkpointId = checkpointSequence === 0
+                            ? turnId
+                            : `${turnId}-checkpoint-${checkpointSequence + 1}`;
+                        if (createPreToolCheckpoint(this.events, sessionId, turnId, checkpointId, this.runtime.cwd, event.toolCalls)) {
+                            checkpointIds.push(checkpointId);
+                            checkpointSequence++;
+                        }
+                        if (sessionId) {
+                            recordTraceEvent(this.events, sessionId, {
+                                turnId,
+                                type: 'assistant_tool_calls',
+                                toolCallCount: event.toolCalls.length,
+                                contentBytes: byteLength(event.content || ''),
+                            });
+                        }
                         sessionMessagesToRecord.push({
                             role: 'assistant',
                             content: event.content || '',
@@ -567,11 +1238,83 @@ class AgentChatController {
                         });
                         break;
                     case 'tool_call':
+                        observedToolCalls++;
+                        {
+                            const toolDefinition = skillResolution.tools.find(tool => tool.name === event.name);
+                            if (toolDefinition?.isReadOnly?.(event.args) === true) {
+                                observedReadOnlyToolCalls++;
+                            }
+                            else {
+                                observedUnsafeToolCalls++;
+                            }
+                        }
                         assistantStream.closeSegment();
                         toolEvents.start(event);
+                        if (sessionId) {
+                            const traceArgs = buildTraceArgsDetails(this.runtime.cwd, event.name, event.args);
+                            recordTraceEvent(this.events, sessionId, {
+                                turnId,
+                                type: 'tool_call',
+                                name: event.name,
+                                callId: event.callId,
+                                ...traceArgs,
+                                batchCount: event.batchCount,
+                                batchIndex: event.batchIndex,
+                            });
+                        }
+                        break;
+                    case 'permission_decision':
+                        if (sessionId) {
+                            recordTraceEvent(this.events, sessionId, {
+                                turnId,
+                                type: 'permission_decision',
+                                name: event.name,
+                                callId: event.callId,
+                                argsSummary: compactToolArgs(event.args),
+                                permissionBehavior: event.decision.behavior,
+                                permissionApproved: event.decision.approved,
+                                permissionSource: event.decision.source,
+                                permissionReason: event.decision.reason
+                                    ? compactMiddle(event.decision.reason, 240)
+                                    : undefined,
+                                permissionDuration: event.decision.duration,
+                                batchCount: event.batchCount,
+                                batchIndex: event.batchIndex,
+                            });
+                        }
                         break;
                     case 'tool_result': {
+                        observedToolResultBytes += event.outputBytes ?? byteLength(event.result);
+                        observedModelVisibleToolBytes += byteLength(event.modelVisibleResult);
                         toolEvents.finish(event);
+                        if (sessionId) {
+                            recordTraceEvent(this.events, sessionId, {
+                                turnId,
+                                type: 'tool_result',
+                                name: event.name,
+                                callId: event.callId,
+                                argsSummary: compactToolArgs(event.args),
+                                success: event.success,
+                                duration: event.duration,
+                                outputBytes: event.outputBytes,
+                                modelVisibleBytes: byteLength(event.modelVisibleResult),
+                                artifactId: event.artifactRef?.id,
+                                error: event.error ? compactMiddle(event.error, 240) : undefined,
+                                batchCount: event.batchCount,
+                                batchIndex: event.batchIndex,
+                            });
+                        }
+                        const verificationResult = (0, verification_profile_1.collectVerificationCommandResult)({
+                            toolName: event.name,
+                            args: event.args,
+                            success: event.success,
+                            outputBytes: event.outputBytes,
+                            error: event.error,
+                        });
+                        if (verificationResult) {
+                            verificationResults.push(verificationResult);
+                            appendVerificationResultTrace(this.events, sessionId, turnId, verificationResult);
+                        }
                         sessionMessagesToRecord.push({
                             role: 'tool',
                             content: event.result,
@@ -583,10 +1326,24 @@ class AgentChatController {
                     }
                     case 'strategy_exhausted':
                         this.events.append({ role: 'status', content: event.suggestion });
+                        if (sessionId) {
+                            recordTraceEvent(this.events, sessionId, {
+                                turnId,
+                                type: 'strategy_exhausted',
+                                note: compactMiddle(event.suggestion, 240),
+                            });
+                        }
                         break;
                     case 'message':
                         finalContent = event.content;
                         assistantStream.ensureMessage(event.content);
+                        if (sessionId) {
+                            recordTraceEvent(this.events, sessionId, {
+                                turnId,
+                                type: 'message',
+                                contentBytes: byteLength(event.content),
+                            });
+                        }
                         if (event.content) {
                             sessionMessagesToRecord.push({
                                 role: 'assistant',
@@ -596,11 +1353,55 @@ class AgentChatController {
                         }
                         break;
                     case 'complete':
+                        if (event.content && !finalContent) {
+                            if (event.stats?.finishReason === 'budget_exceeded') {
+                                assistantStream.replaceMessage(event.content);
+                            }
+                            else {
+                                assistantStream.ensureMessage(event.content);
+                            }
+                            sessionMessagesToRecord.push({
+                                role: 'assistant',
+                                content: event.content,
+                                timestamp: Date.now(),
+                            });
+                        }
                         finalContent = event.content;
                         finalUsage = event.usage;
                         finalModel = event.model;
                         if (event.stats) {
-                            this.runtime.store.setLastLoopStats(event.stats);
+                            pendingCompleteStats = event.stats;
+                            recordProviderTraceEvents(this.events, sessionId, turnId, event.stats);
+                            pendingCompleteTrace = {
+                                turnId,
+                                type: 'complete',
+                                model: event.model,
+                                contentBytes: byteLength(event.content || ''),
+                                finishReason: event.stats.finishReason,
+                                llmRequests: event.stats.llmRequests,
+                                toolCalls: event.stats.toolCalls,
+                                readOnlyToolCalls: event.stats.readOnlyToolCalls,
+                                unsafeToolCalls: event.stats.unsafeToolCalls,
+                                loopBudgetSource: event.stats.loopBudgetSource,
+                                loopBudgetBaseProfile: event.stats.loopBudgetBaseProfile,
+                                loopBudgetMaxLlmRequests: event.stats.loopBudgetMaxLlmRequests,
+                                loopBudgetMaxToolCalls: event.stats.loopBudgetMaxToolCalls,
+                                loopBudgetMaxReadOnlyFragmentation: event.stats.loopBudgetMaxReadOnlyFragmentation,
+                                loopBudgetMaxModelVisibleBytes: event.stats.loopBudgetMaxModelVisibleBytes,
+                                loopBudgetConfigOverride: event.stats.loopBudgetConfigOverride,
+                                budgetExceededReason: event.stats.budgetExceededReason,
+                                continuationActions: event.stats.continuationActions,
+                                continuationHint: event.stats.continuationHint,
+                                localFastPathUsed: event.stats.localFastPathUsed,
+                            };
+                        }
+                        else {
+                            pendingCompleteTrace = {
+                                turnId,
+                                type: 'complete',
+                                model: event.model,
+                                contentBytes: byteLength(event.content || ''),
+                            };
                         }
                         break;
                 }
@@ -611,11 +1412,51 @@ class AgentChatController {
                 this.events.setStatus('Interrupted.');
                 removeTrailingUserMessage(this.runtime);
                 if (sessionId) {
+                    appendPostWorkspaceTrace(this.events, sessionId, turnId, this.runtime.cwd, preWorkspace, verificationResults);
+                    recordTraceEvent(this.events, sessionId, {
+                        turnId,
+                        type: 'aborted',
+                        note: 'aborted_after_query',
+                    });
                     (0, session_storage_1.removeLastIncompleteAssistantMessage)(sessionId);
                 }
                 return;
             }
             assistantStream.closeSegment();
+            if (sessionId) {
+                const { profile, summary } = appendPostWorkspaceTrace(this.events, sessionId, turnId, this.runtime.cwd, preWorkspace, verificationResults);
+                if (shouldRecordVerificationLoopStats(profile, summary)) {
+                    const stats = pendingCompleteStats ?? this.runtime.store.getSnapshot().lastLoopStats;
+                    if (stats) {
+                        pendingCompleteStats = withVerificationLoopStats(stats, summary);
+                    }
+                }
+                if ((0, verification_profile_1.shouldGateCompletion)(summary)) {
+                    const notice = (0, verification_profile_1.formatVerificationGateNotice)(summary);
+                    this.events.append({
+                        role: 'status',
+                        title: 'verification',
+                        content: notice,
+                    });
+                    finalContent = finalContent ? `${finalContent}\n\n${notice}` : notice;
+                    appendAssistantNotice(sessionMessagesToRecord, notice);
+                    if (pendingCompleteTrace) {
+                        pendingCompleteTrace.finishReason = 'completion_gate';
+                        pendingCompleteTrace.contentBytes = byteLength(finalContent);
+                        pendingCompleteTrace.note = 'verification_incomplete';
+                    }
+                    const stats = pendingCompleteStats ?? this.runtime.store.getSnapshot().lastLoopStats;
+                    if (stats) {
+                        pendingCompleteStats = {
+                            ...withVerificationLoopStats(stats, summary),
+                            finishReason: 'completion_gate',
+                        };
+                    }
+                }
+            }
+            if (pendingCompleteStats) {
+                this.setLoopStats(pendingCompleteStats);
+            }
             if (finalContent) {
                 this.runtime.store.addMessage({ role: 'assistant', content: finalContent });
             }
@@ -633,7 +1474,11 @@ class AgentChatController {
             });
             const harnessState = harness.toJSON();
             this.runtime.store.setState({ harnessState });
+            emitHarnessDiagnostics(this.events, harnessState);
             if (sessionId) {
+                if (pendingCompleteTrace) {
+                    recordTraceEvent(this.events, sessionId, pendingCompleteTrace);
+                }
                 (0, session_storage_1.updateSessionSkills)(sessionId, appliedSkillNames);
                 (0, session_storage_1.updateSessionHarnessState)(sessionId, harnessState);
                 const recordedMessages = (0, session_storage_1.readSessionMessages)(sessionId);
@@ -649,6 +1494,12 @@ class AgentChatController {
                 this.events.setStatus('Interrupted.');
                 removeTrailingUserMessage(this.runtime);
                 if (sessionId) {
+                    appendPostWorkspaceTrace(this.events, sessionId, turnId, this.runtime.cwd, preWorkspace, verificationResults);
+                    recordTraceEvent(this.events, sessionId, {
+                        turnId,
+                        type: 'aborted',
+                        note: 'abort_error',
+                    });
                     (0, session_storage_1.removeLastIncompleteAssistantMessage)(sessionId);
                 }
                 return;
@@ -656,6 +1507,60 @@ class AgentChatController {
             assistantStream.discardSegment();
             this.events.append({ role: 'error', content: formatChatError(error) });
             this.events.setStatus('Turn failed. Ready for the next input.');
+            const failedStats = error instanceof framework_1.QueryLoopError
+                ? error.stats
+                : (0, framework_1.createFailedLoopStats)({
+                    loopBudget,
+                    diagnostics: observedLlmRequests > 0 ? getLastRequestDiagnostics(this.runtime.llm) : undefined,
+                    turnsStarted: observedTurnsStarted,
+                    llmRequests: observedLlmRequests,
+                    toolCalls: observedToolCalls,
+                    readOnlyToolCalls: observedReadOnlyToolCalls,
+                    unsafeToolCalls: observedUnsafeToolCalls,
+                    toolResultBytes: observedToolResultBytes,
+                    modelVisibleToolBytes: observedModelVisibleToolBytes,
+                });
+            this.setLoopStats(failedStats);
+            if (sessionId) {
+                recordProviderTraceEvents(this.events, sessionId, turnId, failedStats);
+                const { delta } = appendPostWorkspaceTrace(this.events, sessionId, turnId, this.runtime.cwd, preWorkspace, verificationResults);
+                const recoveryNotice = workspaceDeltaHasTurnChanges(delta)
+                    ? formatFailureRecoveryNotice(turnId, delta, checkpointIds)
+                    : undefined;
+                if (recoveryNotice) {
+                    this.events.append({
+                        role: 'status',
+                        title: 'recovery',
+                        content: recoveryNotice,
+                    });
+                }
+                recordTraceEvent(this.events, sessionId, {
+                    turnId,
+                    type: 'error',
+                    error: compactTraceError(error),
+                    note: recoveryNotice,
+                });
+                recordTraceEvent(this.events, sessionId, {
+                    turnId,
+                    type: 'complete',
+                    model: failedStats.providerFinalModel ?? this.runtime.llm.getModel(),
+                    contentBytes: 0,
+                    finishReason: failedStats.finishReason,
+                    llmRequests: failedStats.llmRequests,
+                    toolCalls: failedStats.toolCalls,
+                    readOnlyToolCalls: failedStats.readOnlyToolCalls,
+                    unsafeToolCalls: failedStats.unsafeToolCalls,
+                    loopBudgetSource: failedStats.loopBudgetSource,
+                    loopBudgetBaseProfile: failedStats.loopBudgetBaseProfile,
+                    loopBudgetMaxLlmRequests: failedStats.loopBudgetMaxLlmRequests,
+                    loopBudgetMaxToolCalls: failedStats.loopBudgetMaxToolCalls,
+                    loopBudgetMaxReadOnlyFragmentation: failedStats.loopBudgetMaxReadOnlyFragmentation,
+                    loopBudgetMaxModelVisibleBytes: failedStats.loopBudgetMaxModelVisibleBytes,
+                    loopBudgetConfigOverride: failedStats.loopBudgetConfigOverride,
+                    localFastPathUsed: failedStats.localFastPathUsed,
+                });
+                (0, session_storage_1.removeLastIncompleteAssistantMessage)(sessionId);
+            }
             const history = this.runtime.store.getSnapshot().conversationHistory;
             if (history.length > 0) {
                 this.runtime.store.setState({ conversationHistory: history.slice(0, -1) });