pulseed 0.6.3 → 0.6.5

package/dist/orchestrator/execution/agent-loop/bounded-agent-loop-runner.js

@@ -1,9 +1,37 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
 import { execFileNoThrow } from "../../../base/utils/execFileNoThrow.js";
 import { createAgentLoopHistory } from "./agent-loop-history.js";
 import { formatAgentLoopModelRef } from "./agent-loop-model.js";
 import { ExtractiveAgentLoopCompactor } from "./agent-loop-compactor.js";
+import { cloneAgentLoopCompactionRecords } from "./agent-loop-compaction-record.js";
 import { classifyAgentLoopCommandResult } from "./agent-loop-command-classifier.js";
+import { assistantTextResponseItem, functionToolCallResponseItem, } from "./response-item.js";
+function readToolResultCheckOnly(result) {
+    const data = result.rawResult?.data;
+    if (result.toolName === "apply_patch" &&
+        data &&
+        typeof data === "object" &&
+        "checkOnly" in data &&
+        typeof data.checkOnly === "boolean") {
+        return data.checkOnly;
+    }
+    return undefined;
+}
+const FILESYSTEM_SNAPSHOT_EXCLUDED_DIRS = new Set([
+    ".git",
+    "node_modules",
+    ".venv",
+    "venv",
+    "__pycache__",
+    ".cache",
+    "dist",
+    "build",
+]);
+const FILESYSTEM_SNAPSHOT_MAX_FILES = 5_000;
+const FILESYSTEM_SNAPSHOT_HASH_MAX_BYTES = 1_000_000;
+const MIN_MUTATING_TOOL_BATCH_REMAINING_MS = 1_000;
 export class BoundedAgentLoopRunner {
     deps;
     compactor;
@@ -22,12 +50,16 @@ export class BoundedAgentLoopRunner {
         let completionValidationAttempts = resumed?.completionValidationAttempts ?? 0;
         let finalText = resumed?.finalText ?? "";
         let compactions = resumed?.compactions ?? 0;
+        let compactionRecords = cloneAgentLoopCompactionRecords(resumed?.compactionRecords);
         const calledTools = new Set(resumed?.calledTools ?? []);
         let lastToolLoopSignature = resumed?.lastToolLoopSignature ?? null;
         let repeatedToolLoopCount = resumed?.repeatedToolLoopCount ?? 0;
         const commandResults = [];
         const toolResultSummaries = [];
         const initialWorkspaceSnapshot = await this.captureWorkspaceSnapshot(turn.cwd);
+        let finalizationReserveUsed = false;
+        let forceFinalAnswerOnly = false;
+        const stop = (reason, startedAt, modelTurns, toolCalls, finalText, output, success = false, compactions = 0, changedFiles = [], toolResults = [], commandResults = [], messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts, reasonDetail, failureReason) => this.stop(turn, reason, startedAt, modelTurns, toolCalls, finalText, output, success, compactions, changedFiles, toolResults, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts, reasonDetail, failureReason, compactionRecords);
         await this.record(turn, {
             type: "started",
             ...this.baseEvent(turn),
@@ -41,27 +73,39 @@ export class BoundedAgentLoopRunner {
             });
         }
         let messages = resumed?.messages ? [...resumed.messages] : [...turn.messages];
-        const preTurnCompaction = await this.compactIfNeeded(turn, messages, "pre_turn", "context_limit", undefined, compactions);
+        const preTurnCompaction = await this.compactIfNeeded(turn, messages, "pre_turn", "context_limit", undefined, compactions, compactionRecords);
         if (preTurnCompaction.error) {
-            return this.stop(turn, "fatal_error", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, [], toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+            return stop("fatal_error", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, [], toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
         }
         messages = preTurnCompaction.messages;
+        compactionRecords = preTurnCompaction.compactionRecords;
         compactions += preTurnCompaction.compacted ? 1 : 0;
-        await this.saveState(turn, messages, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
+        await this.saveState(turn, messages, compactionRecords, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
         while (true) {
             if (Date.now() - startedAt > turn.budget.maxWallClockMs) {
-                return this.stop(turn, "timeout", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                return stop("timeout", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
             }
             if (modelTurns >= turn.budget.maxModelTurns) {
-                return this.stop(turn, "max_model_turns", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                if (!finalizationReserveUsed && this.shouldUseFinalizationReserve(turn, messages, toolResultSummaries, finalText)) {
+                    finalizationReserveUsed = true;
+                    forceFinalAnswerOnly = true;
+                    messages.push({
+                        role: "user",
+                        content: this.buildFinalizationReservePrompt(turn),
+                    });
+                    await this.saveState(turn, messages, compactionRecords, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
+                }
+                else {
+                    return stop("max_model_turns", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                }
             }
             if (toolCalls >= turn.budget.maxToolCalls) {
-                return this.stop(turn, "max_tool_calls", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                return stop("max_tool_calls", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
             }
             if (turn.abortSignal?.aborted) {
-                return this.stop(turn, "cancelled", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                return stop("cancelled", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
             }
-            const tools = this.deps.toolRouter.modelVisibleTools(turn);
+            const tools = forceFinalAnswerOnly ? [] : this.deps.toolRouter.modelVisibleTools(turn);
             if (modelTurns === 0) {
                 await this.record(turn, {
                     type: "turn_context",
@@ -83,20 +127,22 @@ export class BoundedAgentLoopRunner {
             }
             catch (err) {
                 if (turn.abortSignal?.aborted) {
-                    return this.stop(turn, "cancelled", startedAt, modelTurns, toolCalls, "Agent loop stopped: operator stop aborted active model work.", null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts, err instanceof Error ? err.message : String(err));
+                    return stop("cancelled", startedAt, modelTurns, toolCalls, "Agent loop stopped: operator stop aborted active model work.", null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts, err instanceof Error ? err.message : String(err));
                 }
                 const failure = this.classifyRunFailure(err);
-                return this.stop(turn, failure.reason, startedAt, modelTurns, toolCalls, failure.message, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts, failure.detail);
+                return stop(failure.reason, startedAt, modelTurns, toolCalls, failure.message, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts, failure.detail, failure.failureReason);
             }
             if (!protocol.responseCompleted) {
-                return this.stop(turn, "protocol_incomplete", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                return stop("protocol_incomplete", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
             }
             if (turn.abortSignal?.aborted) {
-                return this.stop(turn, "cancelled", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                return stop("cancelled", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
             }
             const response = this.protocolToResponse(protocol);
             modelTurns++;
             finalText = response.content;
+            const wasFinalAnswerOnly = forceFinalAnswerOnly;
+            forceFinalAnswerOnly = false;
             for (const assistant of protocol.assistant) {
                 await this.record(turn, {
                     type: "assistant_message",
@@ -111,20 +157,21 @@ export class BoundedAgentLoopRunner {
                     if (response.content.trim().length === 0) {
                         schemaRepairAttempts++;
                         if (schemaRepairAttempts > turn.budget.maxSchemaRepairAttempts) {
-                            return this.stop(turn, "schema_error", startedAt, modelTurns, toolCalls, response.content, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                            return stop("schema_error", startedAt, modelTurns, toolCalls, response.content, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
                         }
                         messages.push({ role: "assistant", content: response.content, phase: "final_answer" });
                         messages.push({
                             role: "user",
                             content: "Your final answer was empty. Return a user-visible Markdown or plain text answer for the user.",
                         });
-                        const compacted = await this.compactIfNeeded(turn, messages, "mid_turn", "context_limit", this.responseUsageTokens(protocol), compactions);
+                        const compacted = await this.compactIfNeeded(turn, messages, "mid_turn", "context_limit", this.responseUsageTokens(protocol), compactions, compactionRecords);
                         if (compacted.error) {
-                            return this.stop(turn, "fatal_error", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                            return stop("fatal_error", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
                         }
                         messages = compacted.messages;
+                        compactionRecords = compacted.compactionRecords;
                         compactions += compacted.compacted ? 1 : 0;
-                        await this.saveState(turn, messages, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
+                        await this.saveState(turn, messages, compactionRecords, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
                         continue;
                     }
                     const missingRequiredTools = this.missingRequiredTools(turn, calledTools);
@@ -134,13 +181,14 @@ export class BoundedAgentLoopRunner {
                             role: "user",
                             content: `Before the final answer, call these required tool(s) at least once: ${missingRequiredTools.join(", ")}.`,
                         });
-                        const compacted = await this.compactIfNeeded(turn, messages, "mid_turn", "context_limit", this.responseUsageTokens(protocol), compactions);
+                        const compacted = await this.compactIfNeeded(turn, messages, "mid_turn", "context_limit", this.responseUsageTokens(protocol), compactions, compactionRecords);
                         if (compacted.error) {
-                            return this.stop(turn, "fatal_error", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                            return stop("fatal_error", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
                         }
                         messages = compacted.messages;
+                        compactionRecords = compacted.compactionRecords;
                         compactions += compacted.compacted ? 1 : 0;
-                        await this.saveState(turn, messages, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
+                        await this.saveState(turn, messages, compactionRecords, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
                         continue;
                     }
                     const changedFiles = await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot);
@@ -150,7 +198,7 @@ export class BoundedAgentLoopRunner {
                         success: true,
                         outputPreview: this.preview(response.content),
                     });
-                    return this.stop(turn, "completed", startedAt, modelTurns, toolCalls, response.content, null, true, compactions, changedFiles, toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts);
+                    return stop("completed", startedAt, modelTurns, toolCalls, response.content, null, true, compactions, changedFiles, toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts);
                 }
                 const parsed = this.parseFinal(response.content, turn.outputSchema);
                 if (parsed.success) {
@@ -161,41 +209,45 @@ export class BoundedAgentLoopRunner {
                             role: "user",
                             content: `Before the final answer, call these required tool(s) at least once: ${missingRequiredTools.join(", ")}.`,
                         });
-                        const compacted = await this.compactIfNeeded(turn, messages, "mid_turn", "context_limit", this.responseUsageTokens(protocol), compactions);
+                        const compacted = await this.compactIfNeeded(turn, messages, "mid_turn", "context_limit", this.responseUsageTokens(protocol), compactions, compactionRecords);
                         if (compacted.error) {
-                            return this.stop(turn, "fatal_error", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                            return stop("fatal_error", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
                         }
                         messages = compacted.messages;
+                        compactionRecords = compacted.compactionRecords;
                         compactions += compacted.compacted ? 1 : 0;
-                        await this.saveState(turn, messages, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
+                        await this.saveState(turn, messages, compactionRecords, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
                         continue;
                     }
                     const changedFiles = await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot);
-                    const completionValidation = turn.completionValidator?.({
-                        output: parsed.output,
-                        changedFiles,
-                        commandResults,
-                        calledTools: [...calledTools],
-                        modelTurns,
-                        toolCalls,
-                    });
+                    const completionValidation = turn.completionValidator
+                        ? await turn.completionValidator({
+                            output: parsed.output,
+                            changedFiles,
+                            commandResults,
+                            calledTools: [...calledTools],
+                            modelTurns,
+                            toolCalls,
+                        })
+                        : undefined;
                     if (completionValidation && !completionValidation.ok) {
                         completionValidationAttempts++;
                         if (completionValidationAttempts > turn.budget.maxCompletionValidationAttempts) {
-                            return this.stop(turn, "completion_gate_failed", startedAt, modelTurns, toolCalls, response.content, null, false, compactions, changedFiles, toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts);
+                            return stop("completion_gate_failed", startedAt, modelTurns, toolCalls, response.content, null, false, compactions, changedFiles, toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts);
                         }
                         messages.push({ role: "assistant", content: response.content, phase: "final_answer" });
                         messages.push({
                             role: "user",
                             content: this.buildCompletionRepairPrompt(completionValidation.reasons),
                         });
-                        const compacted = await this.compactIfNeeded(turn, messages, "mid_turn", "context_limit", this.responseUsageTokens(protocol), compactions);
+                        const compacted = await this.compactIfNeeded(turn, messages, "mid_turn", "context_limit", this.responseUsageTokens(protocol), compactions, compactionRecords);
                         if (compacted.error) {
-                            return this.stop(turn, "fatal_error", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, changedFiles, toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts);
+                            return stop("fatal_error", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, changedFiles, toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts);
                         }
                         messages = compacted.messages;
+                        compactionRecords = compacted.compactionRecords;
                         compactions += compacted.compacted ? 1 : 0;
-                        await this.saveState(turn, messages, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
+                        await this.saveState(turn, messages, compactionRecords, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
                         continue;
                     }
                     await this.record(turn, {
@@ -204,26 +256,35 @@ export class BoundedAgentLoopRunner {
                         success: true,
                         outputPreview: this.preview(response.content),
                     });
-                    return this.stop(turn, "completed", startedAt, modelTurns, toolCalls, response.content, parsed.output, true, compactions, changedFiles, toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts);
+                    return stop("completed", startedAt, modelTurns, toolCalls, response.content, parsed.output, true, compactions, changedFiles, toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts);
                 }
                 schemaRepairAttempts++;
                 if (schemaRepairAttempts > turn.budget.maxSchemaRepairAttempts) {
-                    return this.stop(turn, "schema_error", startedAt, modelTurns, toolCalls, response.content, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                    return stop("schema_error", startedAt, modelTurns, toolCalls, response.content, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
                 }
                 messages.push({ role: "assistant", content: response.content, phase: "final_answer" });
                 messages.push({
                     role: "user",
                     content: `Your final answer did not match the required JSON schema. Return only valid JSON. Parse error: ${parsed.error}`,
                 });
-                const compacted = await this.compactIfNeeded(turn, messages, "mid_turn", "context_limit", this.responseUsageTokens(protocol), compactions);
+                const compacted = await this.compactIfNeeded(turn, messages, "mid_turn", "context_limit", this.responseUsageTokens(protocol), compactions, compactionRecords);
                 if (compacted.error) {
-                    return this.stop(turn, "fatal_error", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                    return stop("fatal_error", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
                 }
                 messages = compacted.messages;
+                compactionRecords = compacted.compactionRecords;
                 compactions += compacted.compacted ? 1 : 0;
-                await this.saveState(turn, messages, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
+                await this.saveState(turn, messages, compactionRecords, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
                 continue;
             }
+            if (wasFinalAnswerOnly) {
+                const detail = "Agent loop reached the finalization reserve, but the model attempted another tool call instead of returning final output.";
+                return stop("max_model_turns", startedAt, modelTurns, toolCalls, response.content || detail, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts, detail, "max_model_turns");
+            }
+            const toolBatchBudgetRefusal = this.toolBatchBudgetRefusalReason(response.toolCalls, turn, startedAt);
+            if (toolBatchBudgetRefusal) {
+                return stop("timeout", startedAt, modelTurns, toolCalls, toolBatchBudgetRefusal, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts, toolBatchBudgetRefusal, "tool_batch_deadline_exceeded");
+            }
             messages.push({
                 role: "assistant",
                 content: response.content || `Calling ${response.toolCalls.map((call) => call.name).join(", ")}`,
@@ -238,10 +299,10 @@ export class BoundedAgentLoopRunner {
                 repeatedToolLoopCount = 1;
             }
             if (repeatedToolLoopCount > turn.budget.maxRepeatedToolCalls) {
-                return this.stop(turn, "stalled_tool_loop", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                return stop("stalled_tool_loop", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, undefined, undefined, "repeated_tool_calls");
             }
             if (turn.abortSignal?.aborted) {
-                return this.stop(turn, "cancelled", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                return stop("cancelled", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
             }
             for (const call of response.toolCalls) {
                 const activityCategory = this.deps.toolRouter.resolveTool(call.name)?.metadata.activityCategory;
@@ -254,18 +315,40 @@ export class BoundedAgentLoopRunner {
                     ...(activityCategory ? { activityCategory } : {}),
                 });
             }
-            const { results: toolResults, timedOut: toolBatchTimedOut } = await this.executeToolBatchWithinBudget(response.toolCalls, turn, startedAt);
+            let toolBatch;
+            try {
+                toolBatch = await this.executeToolBatchWithinBudget(response.toolCalls, turn, startedAt);
+            }
+            catch (err) {
+                const detail = this.errorDetail(err);
+                const message = `Agent loop stopped: tool runtime failed. ${detail ? `Detail: ${detail}. ` : ""}Inspect the tool execution trace.`;
+                return stop("fatal_error", startedAt, modelTurns, toolCalls, message, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts, detail, "tool_runtime_failure");
+            }
+            const { results: toolResults, timedOut: toolBatchTimedOut } = toolBatch;
+            if (toolBatchTimedOut && toolResults.length === 0) {
+                const timeoutReason = this.formatToolBatchWallClockExhaustedReason(response.toolCalls, turn.budget.maxWallClockMs);
+                return stop("timeout", startedAt, modelTurns, toolCalls, timeoutReason, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts, timeoutReason, "tool_batch_timed_out");
+            }
             for (const result of toolResults) {
-                calledTools.add(result.toolName);
+                const sourceCall = response.toolCalls.find((call) => call.id === result.callId);
+                const observation = this.createToolObservation(result, sourceCall, toolBatchTimedOut);
+                if (result.execution?.status !== "not_executed") {
+                    calledTools.add(result.toolName);
+                }
                 toolCalls++;
+                const toolResultSequence = toolCalls;
                 if (result.success)
                     consecutiveToolErrors = 0;
                 else
                     consecutiveToolErrors++;
+                const checkOnly = readToolResultCheckOnly(result);
                 toolResultSummaries.push({
+                    sequence: toolResultSequence,
                     toolName: result.toolName,
                     success: result.success,
                     ...(result.execution ? { execution: result.execution } : {}),
+                    ...(result.artifacts ? { artifacts: result.artifacts } : {}),
+                    ...(checkOnly !== undefined ? { checkOnly } : {}),
                     outputSummary: this.preview(result.content),
                     durationMs: result.durationMs,
                 });
@@ -274,6 +357,7 @@ export class BoundedAgentLoopRunner {
                     toolCallId: result.callId,
                     toolName: result.toolName,
                     content: result.content,
+                    observation,
                 });
                 await this.record(turn, {
                     type: "tool_call_finished",
@@ -289,6 +373,11 @@ export class BoundedAgentLoopRunner {
                     ...(result.truncated ? { truncated: result.truncated } : {}),
                     ...(result.activityCategory ? { activityCategory: result.activityCategory } : {}),
                 });
+                await this.record(turn, {
+                    type: "tool_observation",
+                    ...this.baseEvent(turn),
+                    observation,
+                });
                 if (result.disposition === "approval_denied") {
                     await this.record(turn, {
                         type: "approval",
@@ -309,38 +398,64 @@ export class BoundedAgentLoopRunner {
                     const commandClassification = classifyAgentLoopCommandResult({
                         toolName: result.toolName,
                         command: result.command,
+                        activityCategory: result.activityCategory,
+                        verificationPlan: turn.verificationPlan,
                     });
                     commandResults.push({
+                        sequence: toolResultSequence,
                         toolName: result.toolName,
                         command: result.command,
                         cwd: result.cwd,
                         success: result.success,
                         ...(result.execution ? { execution: result.execution } : {}),
+                        ...(result.activityCategory ? { activityCategory: result.activityCategory } : {}),
                         category: commandClassification.category,
                         evidenceEligible: commandClassification.evidenceEligible,
+                        ...(commandClassification.evidenceSource ? { evidenceSource: commandClassification.evidenceSource } : {}),
                         outputSummary: this.preview(result.content),
                         durationMs: result.durationMs,
                     });
                 }
                 if (result.disposition === "fatal" || result.fatal) {
-                    return this.stop(turn, "fatal_error", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                    return stop("fatal_error", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, undefined, undefined, "tool_fatal");
                 }
                 if (result.disposition === "cancelled") {
-                    return this.stop(turn, toolBatchTimedOut ? "timeout" : "cancelled", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                    return stop(toolBatchTimedOut ? "timeout" : "cancelled", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, undefined, undefined, toolBatchTimedOut ? "tool_batch_timed_out" : "tool_cancelled");
                 }
                 if (consecutiveToolErrors >= turn.budget.maxConsecutiveToolErrors) {
-                    return this.stop(turn, "consecutive_tool_errors", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                    return stop("consecutive_tool_errors", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, undefined, undefined, "consecutive_tool_errors");
                 }
             }
-            const compacted = await this.compactIfNeeded(turn, messages, "mid_turn", "context_limit", this.responseUsageTokens(protocol), compactions);
+            const compacted = await this.compactIfNeeded(turn, messages, "mid_turn", "context_limit", this.responseUsageTokens(protocol), compactions, compactionRecords);
             if (compacted.error) {
-                return this.stop(turn, "fatal_error", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
+                return stop("fatal_error", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
             }
             messages = compacted.messages;
+            compactionRecords = compacted.compactionRecords;
             compactions += compacted.compacted ? 1 : 0;
-            await this.saveState(turn, messages, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
+            await this.saveState(turn, messages, compactionRecords, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
         }
     }
+    shouldUseFinalizationReserve(turn, messages, toolResults, finalText) {
+        if (turn.finalOutputMode === "display_text")
+            return false;
+        if (toolResults.length === 0 && !messages.some((message) => message.role === "tool"))
+            return false;
+        const trimmed = finalText.trim();
+        return trimmed.length === 0 || trimmed.startsWith("Calling ");
+    }
+    buildFinalizationReservePrompt(turn) {
+        const requiredTools = turn.toolPolicy.requiredTools?.length
+            ? `Required tools already visible for this turn: ${turn.toolPolicy.requiredTools.join(", ")}.`
+            : "";
+        return [
+            "You have reached the tool/model turn budget. Do not call any more tools.",
+            "Return the final output now as JSON matching the required schema.",
+            "Use status=done only if the completed work and verification evidence satisfy the task; otherwise use partial or failed with blockers.",
+            "Include concrete completionEvidence and filesChanged from the work already performed.",
+            requiredTools,
+        ].filter(Boolean).join("\n");
+    }
     parseFinal(content, schema) {
         try {
             const json = this.extractJson(content);
@@ -354,12 +469,14 @@ export class BoundedAgentLoopRunner {
         const fence = content.match(/```json\s*([\s\S]*?)\s*```/);
         return fence?.[1] ?? content;
     }
-    async stop(turn, reason, startedAt, modelTurns, toolCalls, finalText, output, success = false, compactions = 0, changedFiles = [], toolResults = [], commandResults = [], messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts, reasonDetail) {
-        await this.saveState(turn, messages ?? turn.messages, modelTurns, toolCalls, compactions, completionValidationAttempts ?? 0, calledTools ?? new Set(), lastToolLoopSignature ?? null, repeatedToolLoopCount ?? 0, finalText, success ? "completed" : "failed", reason, reasonDetail);
+    async stop(turn, reason, startedAt, modelTurns, toolCalls, finalText, output, success = false, compactions = 0, changedFiles = [], toolResults = [], commandResults = [], messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount, completionValidationAttempts, reasonDetail, failureReason, compactionRecords = []) {
+        const resolvedFailureReason = success ? undefined : failureReason ?? this.defaultFailureReason(reason);
+        await this.saveState(turn, messages ?? turn.messages, compactionRecords, modelTurns, toolCalls, compactions, completionValidationAttempts ?? 0, calledTools ?? new Set(), lastToolLoopSignature ?? null, repeatedToolLoopCount ?? 0, finalText, success ? "completed" : "failed", reason, reasonDetail, resolvedFailureReason);
         await this.record(turn, {
             type: "stopped",
             ...this.baseEvent(turn),
             reason,
+            ...(resolvedFailureReason ? { failureReason: resolvedFailureReason } : {}),
             ...(reasonDetail ? { reasonDetail } : {}),
         });
         return {
@@ -367,6 +484,8 @@ export class BoundedAgentLoopRunner {
             output,
             finalText,
             stopReason: reason,
+            ...(resolvedFailureReason ? { failureReason: resolvedFailureReason } : {}),
+            ...(reasonDetail ? { failureDetail: reasonDetail } : {}),
             elapsedMs: Date.now() - startedAt,
             modelTurns,
             toolCalls,
@@ -378,6 +497,9 @@ export class BoundedAgentLoopRunner {
             traceId: turn.session.traceId,
             sessionId: turn.session.sessionId,
             turnId: turn.turnId,
+            ...(turn.profileName ? { profileName: turn.profileName } : {}),
+            ...(turn.reasoningEffort ? { reasoningEffort: turn.reasoningEffort } : {}),
+            ...(turn.executionPolicy ? { executionPolicy: turn.executionPolicy } : {}),
         };
     }
     buildCompletionRepairPrompt(reasons) {
@@ -419,47 +541,101 @@ export class BoundedAgentLoopRunner {
             return String(value);
         }
     }
+    defaultFailureReason(reason) {
+        switch (reason) {
+            case "timeout":
+                return "wall_clock_timeout";
+            case "max_model_turns":
+                return "max_model_turns";
+            case "max_tool_calls":
+                return "max_tool_calls";
+            case "consecutive_tool_errors":
+                return "consecutive_tool_errors";
+            case "stalled_tool_loop":
+                return "repeated_tool_calls";
+            case "schema_error":
+                return "schema_validation_failed";
+            case "cancelled":
+                return "operator_cancelled";
+            case "protocol_incomplete":
+                return "protocol_incomplete";
+            case "completion_gate_failed":
+                return "completion_gate_failed";
+            case "fatal_error":
+            default:
+                return "provider_failure";
+        }
+    }
     classifyRunFailure(error) {
-        const detail = error instanceof Error
-            ? [error.name !== "Error" ? error.name : null, error.message]
-                .filter((part) => typeof part === "string" && part.length > 0)
-                .join(": ")
-            : String(error);
-        const lowered = detail.toLowerCase();
-        if (lowered.includes("timeout")
-            || lowered.includes("timed out")
-            || lowered.includes("aborterror")
-            || lowered.includes("aborted")) {
+        const detail = this.errorDetail(error);
+        const structured = this.structuredRunFailureReason(error);
+        if (structured === "model_request_timeout") {
             return {
                 reason: "timeout",
+                failureReason: "model_request_timeout",
                 detail,
                 message: "Agent loop stopped: model request timed out. Narrow broad repo-wide searches or increase `codex_timeout_ms` if this workload is expected.",
             };
         }
+        if (structured === "model_request_aborted") {
+            return {
+                reason: "fatal_error",
+                failureReason: "model_request_aborted",
+                detail,
+                message: "Agent loop stopped: model request was aborted by the provider or transport. Retry the turn or inspect the provider connection.",
+            };
+        }
         return {
             reason: "fatal_error",
+            failureReason: "provider_failure",
             detail,
             message: `Agent loop stopped: model request failed. ${detail ? `Detail: ${detail}. ` : ""}Retry the turn or inspect the provider connection.`,
         };
     }
-    async compactIfNeeded(turn, messages, phase, reason, usageTokens, compactions) {
+    structuredRunFailureReason(error) {
+        if (!error || typeof error !== "object")
+            return null;
+        const value = error;
+        if (value.agentLoopFailureReason === "model_request_timeout" || value.agentLoopFailureReason === "model_request_aborted") {
+            return value.agentLoopFailureReason;
+        }
+        if (value.name === "TimeoutError" || value.code === "ETIMEDOUT" || value.code === "UND_ERR_HEADERS_TIMEOUT" || value.code === "UND_ERR_BODY_TIMEOUT") {
+            return "model_request_timeout";
+        }
+        if (value.name === "AbortError" || value.code === "ABORT_ERR") {
+            return "model_request_aborted";
+        }
+        return this.structuredRunFailureReason(value.cause);
+    }
+    errorDetail(error) {
+        return error instanceof Error
+            ? [error.name !== "Error" ? error.name : null, error.message]
+                .filter((part) => typeof part === "string" && part.length > 0)
+                .join(": ")
+            : String(error);
+    }
+    async compactIfNeeded(turn, messages, phase, reason, usageTokens, compactions, compactionRecords) {
         const limit = this.autoCompactLimit(turn);
         if (!limit || compactions >= turn.budget.maxCompactions) {
-            return { messages, compacted: false };
+            return { messages, compactionRecords: cloneAgentLoopCompactionRecords(compactionRecords), compacted: false };
         }
         const tokens = usageTokens && usageTokens > 0 ? usageTokens : this.estimateTokens(messages);
         if (tokens < limit) {
-            return { messages, compacted: false };
+            return { messages, compactionRecords: cloneAgentLoopCompactionRecords(compactionRecords), compacted: false };
         }
         try {
             const result = await this.compactor.compact({
-                history: createAgentLoopHistory(messages),
+                history: createAgentLoopHistory(messages, compactionRecords),
                 maxMessages: turn.budget.compactionMaxMessages,
                 phase,
                 reason,
             });
             if (!result.compacted) {
-                return { messages: result.history.messages, compacted: false };
+                return {
+                    messages: result.history.messages,
+                    compactionRecords: cloneAgentLoopCompactionRecords(result.history.compactionRecords),
+                    compacted: false,
+                };
             }
             await this.record(turn, {
                 type: "context_compaction",
@@ -470,10 +646,19 @@ export class BoundedAgentLoopRunner {
                 outputMessages: result.history.messages.length,
                 summaryPreview: this.preview(result.summary ?? ""),
             });
-            return { messages: result.history.messages, compacted: true };
+            return {
+                messages: result.history.messages,
+                compactionRecords: cloneAgentLoopCompactionRecords(result.history.compactionRecords),
+                compacted: true,
+            };
         }
         catch (err) {
-            return { messages, compacted: false, error: err instanceof Error ? err.message : String(err) };
+            return {
+                messages,
+                compactionRecords: cloneAgentLoopCompactionRecords(compactionRecords),
+                compacted: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
         }
     }
     autoCompactLimit(turn) {
@@ -484,7 +669,10 @@ export class BoundedAgentLoopRunner {
         return contextLimit && contextLimit > 0 ? Math.floor(contextLimit * 0.9) : undefined;
     }
     async executeToolBatchWithinBudget(calls, turn, startedAt) {
-        const remainingMs = Math.max(1, turn.budget.maxWallClockMs - (Date.now() - startedAt));
+        const remainingMs = turn.budget.maxWallClockMs - (Date.now() - startedAt);
+        if (remainingMs <= 0) {
+            return { results: [], timedOut: true };
+        }
         const controller = new AbortController();
         const parentSignal = turn.abortSignal;
         let timedOut = false;
@@ -517,6 +705,34 @@ export class BoundedAgentLoopRunner {
             parentSignal?.removeEventListener("abort", abortFromParent);
         }
     }
+    toolBatchBudgetRefusalReason(calls, turn, startedAt) {
+        const remainingMs = turn.budget.maxWallClockMs - (Date.now() - startedAt);
+        if (remainingMs <= 0) {
+            return this.formatToolBatchWallClockExhaustedReason(calls, turn.budget.maxWallClockMs);
+        }
+        const mutatingToolNames = calls
+            .filter((call) => this.isMutatingToolCall(call))
+            .map((call) => call.name);
+        if (mutatingToolNames.length === 0 || remainingMs >= MIN_MUTATING_TOOL_BATCH_REMAINING_MS) {
+            return null;
+        }
+        return [
+            "Tool batch was not started because the remaining wall-clock budget",
+            `(${Math.floor(remainingMs)}ms) is below the ${MIN_MUTATING_TOOL_BATCH_REMAINING_MS}ms minimum`,
+            `for mutating tools: ${[...new Set(mutatingToolNames)].join(", ")}.`,
+        ].join(" ");
+    }
+    formatToolBatchWallClockExhaustedReason(calls, maxWallClockMs) {
+        return [
+            "Tool batch was not started because the agent loop wall-clock budget is exhausted",
+            `(0ms remaining; limit ${maxWallClockMs}ms).`,
+            `Requested tools: ${calls.map((call) => call.name).join(", ")}.`,
+        ].join(" ");
+    }
+    isMutatingToolCall(call) {
+        const metadata = this.deps.toolRouter.resolveTool(call.name)?.metadata;
+        return metadata?.isReadOnly !== true;
+    }
     responseUsageTokens(response) {
         if (!response.usage)
             return undefined;
@@ -529,6 +745,56 @@ export class BoundedAgentLoopRunner {
     missingRequiredTools(turn, calledTools) {
         return [...(turn.toolPolicy.requiredTools ?? [])].filter((toolName) => !calledTools.has(toolName));
     }
+    createToolObservation(result, sourceCall, toolBatchTimedOut) {
+        const state = this.toolObservationState(result, toolBatchTimedOut);
+        const execution = this.toolObservationExecution(result, state);
+        const rawResult = result.rawResult;
+        return {
+            type: "tool_observation",
+            callId: result.callId,
+            toolName: result.toolName,
+            arguments: sourceCall?.input ?? {},
+            state,
+            success: result.success,
+            execution,
+            durationMs: result.durationMs,
+            output: {
+                content: result.content,
+                ...(rawResult?.summary ? { summary: rawResult.summary } : {}),
+                ...(rawResult && Object.prototype.hasOwnProperty.call(rawResult, "data") ? { data: rawResult.data } : {}),
+                ...(rawResult?.error ? { error: rawResult.error } : {}),
+            },
+            ...(result.command ? { command: result.command } : {}),
+            ...(result.cwd ? { cwd: result.cwd } : {}),
+            ...(result.artifacts ? { artifacts: result.artifacts } : {}),
+            ...(result.truncated ? { truncated: result.truncated } : {}),
+            ...(result.activityCategory ? { activityCategory: result.activityCategory } : {}),
+        };
+    }
+    toolObservationState(result, toolBatchTimedOut) {
+        const reason = result.execution?.reason;
+        if (reason === "timed_out" || (toolBatchTimedOut && result.disposition === "cancelled"))
+            return "timed_out";
+        if (reason === "interrupted" || result.disposition === "cancelled")
+            return "interrupted";
+        if (reason === "approval_denied" || reason === "permission_denied")
+            return "denied";
+        if (reason === "policy_blocked" || reason === "dry_run")
+            return "blocked";
+        return result.success ? "success" : "failure";
+    }
+    toolObservationExecution(result, state) {
+        if (result.execution)
+            return result.execution;
+        if (state === "timed_out" || state === "interrupted") {
+            return {
+                status: "executed",
+                reason: state === "timed_out" ? "timed_out" : "interrupted",
+                message: result.content,
+            };
+        }
+        return { status: "executed" };
+    }
     async createTurnProtocol(turn, messages, tools) {
         if (this.deps.modelClient.createTurnProtocol) {
             return this.deps.modelClient.createTurnProtocol({
@@ -550,18 +816,36 @@ export class BoundedAgentLoopRunner {
                     phase: response.toolCalls.length > 0 ? "commentary" : "final_answer",
                 }] : [],
             toolCalls: response.toolCalls,
+            responseItems: [
+                ...(response.content || response.toolCalls.length > 0
+                    ? [assistantTextResponseItem(response.content || `Calling ${response.toolCalls.map((call) => call.name).join(", ")}`, response.toolCalls.length > 0 ? "commentary" : "final_answer")]
+                    : []),
+                ...response.toolCalls.map((call) => functionToolCallResponseItem(call)),
+            ],
             stopReason: response.stopReason,
             responseCompleted: true,
             usage: response.usage,
         };
     }
     protocolToResponse(protocol) {
+        const responseItemText = protocol.responseItems
+            ?.filter((item) => item.type === "assistant_text")
+            .map((item) => item.content)
+            .filter(Boolean)
+            .join("\n");
+        const responseItemToolCalls = protocol.responseItems
+            ?.filter((item) => item.type === "function_tool_call")
+            .map((item) => ({
+            id: item.id,
+            name: item.name,
+            input: item.arguments,
+        }));
         return {
-            content: protocol.assistant.map((item) => item.content).filter(Boolean).join("\n"),
-            toolCalls: protocol.toolCalls,
+            content: protocol.assistant.map((item) => item.content).filter(Boolean).join("\n") || responseItemText || "",
+            toolCalls: protocol.responseItems ? responseItemToolCalls ?? [] : protocol.toolCalls,
         };
     }
-    async saveState(turn, messages, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, status, stopReason, stopDetail) {
+    async saveState(turn, messages, compactionRecords, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, status, stopReason, stopDetail, failureReason) {
         const state = {
             sessionId: turn.session.sessionId,
             traceId: turn.session.traceId,
@@ -571,6 +855,7 @@ export class BoundedAgentLoopRunner {
             cwd: turn.cwd,
             modelRef: formatAgentLoopModelRef(turn.model),
             messages,
+            compactionRecords: cloneAgentLoopCompactionRecords(compactionRecords),
             modelTurns,
             toolCalls,
             compactions,
@@ -581,6 +866,7 @@ export class BoundedAgentLoopRunner {
             finalText,
             status,
             ...(stopReason ? { stopReason } : {}),
+            ...(failureReason ? { failureReason } : {}),
             ...(stopDetail ? { stopDetail } : {}),
             updatedAt: new Date().toISOString(),
         };
@@ -588,18 +874,22 @@ export class BoundedAgentLoopRunner {
     }
     async captureWorkspaceSnapshot(cwd) {
         const result = await execFileNoThrow("git", ["status", "--porcelain", "--untracked-files=all"], { cwd, timeoutMs: 10_000 });
-        if ((result.exitCode ?? 1) !== 0)
-            return null;
-        return new Set(this.parseGitStatusPaths(result.stdout));
+        if ((result.exitCode ?? 1) === 0) {
+            return { kind: "git", paths: new Set(this.parseGitStatusPaths(result.stdout)) };
+        }
+        return { kind: "filesystem", files: await this.captureFilesystemSnapshot(cwd) };
     }
     async collectChangedFiles(cwd, before) {
         const afterResult = await execFileNoThrow("git", ["status", "--porcelain", "--untracked-files=all"], { cwd, timeoutMs: 10_000 });
-        if ((afterResult.exitCode ?? 1) !== 0)
-            return [];
+        if ((afterResult.exitCode ?? 1) !== 0) {
+            if (before?.kind !== "filesystem")
+                return [];
+            return this.collectFilesystemChangedPaths(before.files, await this.captureFilesystemSnapshot(cwd));
+        }
         const after = new Set(this.parseGitStatusPaths(afterResult.stdout));
-        if (!before)
+        if (!before || before.kind !== "git")
             return [...after];
-        return [...after].filter((file) => !before.has(file));
+        return [...after].filter((file) => !before.paths.has(file));
     }
     parseGitStatusPaths(stdout) {
         return stdout
@@ -609,5 +899,74 @@ export class BoundedAgentLoopRunner {
             .map((line) => line.slice(3).trim())
             .map((filePath) => filePath.includes(" -> ") ? filePath.split(" -> ").at(-1) ?? filePath : filePath);
     }
+    async captureFilesystemSnapshot(cwd) {
+        const files = new Map();
+        const root = path.resolve(cwd);
+        const visit = async (dir) => {
+            if (files.size >= FILESYSTEM_SNAPSHOT_MAX_FILES)
+                return;
+            let entries;
+            try {
+                entries = await fsp.readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (files.size >= FILESYSTEM_SNAPSHOT_MAX_FILES)
+                    return;
+                if (entry.name.startsWith(".pulseed-"))
+                    continue;
+                const absolutePath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (!FILESYSTEM_SNAPSHOT_EXCLUDED_DIRS.has(entry.name)) {
+                        await visit(absolutePath);
+                    }
+                    continue;
+                }
+                if (!entry.isFile())
+                    continue;
+                const relativePath = path.relative(root, absolutePath).replace(/\\/g, "/");
+                try {
+                    const stat = await fsp.stat(absolutePath);
+                    const snapshotEntry = {
+                        size: stat.size,
+                        mtimeMs: stat.mtimeMs,
+                    };
+                    if (stat.size <= FILESYSTEM_SNAPSHOT_HASH_MAX_BYTES) {
+                        snapshotEntry.hash = createHash("sha256")
+                            .update(await fsp.readFile(absolutePath))
+                            .digest("hex");
+                    }
+                    files.set(relativePath, snapshotEntry);
+                }
+                catch {
+                    // File may have changed while scanning; skip and let the next scan observe it.
+                }
+            }
+        };
+        await visit(root);
+        return files;
+    }
+    collectFilesystemChangedPaths(before, after) {
+        const changed = new Set();
+        for (const [filePath, afterEntry] of after) {
+            const beforeEntry = before.get(filePath);
+            if (!beforeEntry || !this.sameFilesystemEntry(beforeEntry, afterEntry)) {
+                changed.add(filePath);
+            }
+        }
+        for (const filePath of before.keys()) {
+            if (!after.has(filePath)) {
+                changed.add(filePath);
+            }
+        }
+        return [...changed].sort();
+    }
+    sameFilesystemEntry(left, right) {
+        if (left.hash && right.hash)
+            return left.hash === right.hash;
+        return left.size === right.size && left.mtimeMs === right.mtimeMs;
+    }
 }
 //# sourceMappingURL=bounded-agent-loop-runner.js.map