pulseed 0.6.5 → 0.7.0

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

@@ -1,972 +0,0 @@
-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;
-    constructor(deps) {
-        this.deps = deps;
-        this.compactor = deps.compactor ?? new ExtractiveAgentLoopCompactor();
-    }
-    async run(turn) {
-        const startedAt = Date.now();
-        const resumed = turn.resumeState
-            ?? (turn.loadPersistedState === false ? null : await turn.session.stateStore.load());
-        let modelTurns = resumed?.modelTurns ?? 0;
-        let toolCalls = resumed?.toolCalls ?? 0;
-        let consecutiveToolErrors = 0;
-        let schemaRepairAttempts = 0;
-        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),
-        });
-        if (resumed) {
-            await this.record(turn, {
-                type: "resumed",
-                ...this.baseEvent(turn),
-                fromUpdatedAt: resumed.updatedAt,
-                restoredMessages: resumed.messages.length,
-            });
-        }
-        let messages = resumed?.messages ? [...resumed.messages] : [...turn.messages];
-        const preTurnCompaction = await this.compactIfNeeded(turn, messages, "pre_turn", "context_limit", undefined, compactions, compactionRecords);
-        if (preTurnCompaction.error) {
-            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, compactionRecords, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
-        while (true) {
-            if (Date.now() - startedAt > turn.budget.maxWallClockMs) {
-                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) {
-                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 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 stop("cancelled", startedAt, modelTurns, toolCalls, finalText, null, false, compactions, await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot), toolResultSummaries, commandResults, messages, calledTools, lastToolLoopSignature, repeatedToolLoopCount);
-            }
-            const tools = forceFinalAnswerOnly ? [] : this.deps.toolRouter.modelVisibleTools(turn);
-            if (modelTurns === 0) {
-                await this.record(turn, {
-                    type: "turn_context",
-                    ...this.baseEvent(turn),
-                    cwd: turn.cwd,
-                    model: formatAgentLoopModelRef(turn.model),
-                    visibleTools: tools.map((tool) => tool.function.name),
-                });
-            }
-            await this.record(turn, {
-                type: "model_request",
-                ...this.baseEvent(turn),
-                model: formatAgentLoopModelRef(turn.model),
-                toolCount: tools.length,
-            });
-            let protocol;
-            try {
-                protocol = await this.createTurnProtocol(turn, messages, tools);
-            }
-            catch (err) {
-                if (turn.abortSignal?.aborted) {
-                    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 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 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 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",
-                    ...this.baseEvent(turn),
-                    phase: assistant.phase === "final_answer" ? "final_candidate" : "commentary",
-                    contentPreview: this.preview(assistant.content),
-                    toolCallCount: response.toolCalls.length,
-                });
-            }
-            if (response.toolCalls.length === 0) {
-                if (turn.finalOutputMode === "display_text") {
-                    if (response.content.trim().length === 0) {
-                        schemaRepairAttempts++;
-                        if (schemaRepairAttempts > turn.budget.maxSchemaRepairAttempts) {
-                            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, compactionRecords);
-                        if (compacted.error) {
-                            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, compactionRecords, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
-                        continue;
-                    }
-                    const missingRequiredTools = this.missingRequiredTools(turn, calledTools);
-                    if (missingRequiredTools.length > 0) {
-                        messages.push({ role: "assistant", content: response.content, phase: "final_answer" });
-                        messages.push({
-                            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, compactionRecords);
-                        if (compacted.error) {
-                            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, compactionRecords, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
-                        continue;
-                    }
-                    const changedFiles = await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot);
-                    await this.record(turn, {
-                        type: "final",
-                        ...this.baseEvent(turn),
-                        success: true,
-                        outputPreview: this.preview(response.content),
-                    });
-                    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) {
-                    const missingRequiredTools = this.missingRequiredTools(turn, calledTools);
-                    if (missingRequiredTools.length > 0) {
-                        messages.push({ role: "assistant", content: response.content, phase: "final_answer" });
-                        messages.push({
-                            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, compactionRecords);
-                        if (compacted.error) {
-                            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, compactionRecords, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
-                        continue;
-                    }
-                    const changedFiles = await this.collectChangedFiles(turn.cwd, initialWorkspaceSnapshot);
-                    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 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, compactionRecords);
-                        if (compacted.error) {
-                            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, compactionRecords, modelTurns, toolCalls, compactions, completionValidationAttempts, calledTools, lastToolLoopSignature, repeatedToolLoopCount, finalText, "running");
-                        continue;
-                    }
-                    await this.record(turn, {
-                        type: "final",
-                        ...this.baseEvent(turn),
-                        success: true,
-                        outputPreview: this.preview(response.content),
-                    });
-                    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 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, compactionRecords);
-                if (compacted.error) {
-                    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, 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(", ")}`,
-                phase: "commentary",
-                ...(response.toolCalls.length > 0 ? { toolCalls: response.toolCalls } : {}),
-            });
-            const toolLoopSignature = JSON.stringify(response.toolCalls.map((call) => ({ name: call.name, input: call.input })));
-            if (toolLoopSignature === lastToolLoopSignature)
-                repeatedToolLoopCount++;
-            else {
-                lastToolLoopSignature = toolLoopSignature;
-                repeatedToolLoopCount = 1;
-            }
-            if (repeatedToolLoopCount > turn.budget.maxRepeatedToolCalls) {
-                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 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;
-                await this.record(turn, {
-                    type: "tool_call_started",
-                    ...this.baseEvent(turn),
-                    callId: call.id,
-                    toolName: call.name,
-                    inputPreview: this.preview(this.stringify(call.input)),
-                    ...(activityCategory ? { activityCategory } : {}),
-                });
-            }
-            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) {
-                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,
-                });
-                messages.push({
-                    role: "tool",
-                    toolCallId: result.callId,
-                    toolName: result.toolName,
-                    content: result.content,
-                    observation,
-                });
-                await this.record(turn, {
-                    type: "tool_call_finished",
-                    ...this.baseEvent(turn),
-                    callId: result.callId,
-                    toolName: result.toolName,
-                    inputPreview: this.preview(this.stringify(response.toolCalls.find((call) => call.id === result.callId)?.input ?? {})),
-                    success: result.success,
-                    disposition: result.disposition,
-                    outputPreview: this.preview(result.content),
-                    durationMs: result.durationMs,
-                    ...(result.artifacts ? { artifacts: result.artifacts } : {}),
-                    ...(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",
-                        ...this.baseEvent(turn),
-                        toolName: result.toolName,
-                        status: "denied",
-                        reason: result.content,
-                    });
-                }
-                if (result.toolName === "update_plan" && result.contextModifier) {
-                    await this.record(turn, {
-                        type: "plan_update",
-                        ...this.baseEvent(turn),
-                        summary: this.preview(result.contextModifier),
-                    });
-                }
-                if (result.command && result.cwd) {
-                    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 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 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 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, compactionRecords);
-            if (compacted.error) {
-                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, 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);
-            return { success: true, output: schema.parse(JSON.parse(json)) };
-        }
-        catch (err) {
-            return { success: false, error: err instanceof Error ? err.message : String(err) };
-        }
-    }
-    extractJson(content) {
-        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, 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 {
-            success,
-            output,
-            finalText,
-            stopReason: reason,
-            ...(resolvedFailureReason ? { failureReason: resolvedFailureReason } : {}),
-            ...(reasonDetail ? { failureDetail: reasonDetail } : {}),
-            elapsedMs: Date.now() - startedAt,
-            modelTurns,
-            toolCalls,
-            compactions,
-            filesChanged: changedFiles.length > 0,
-            changedFiles,
-            toolResults,
-            commandResults,
-            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) {
-        const bullets = reasons.map((reason) => `- ${reason}`).join("\n");
-        return [
-            "Your final answer is premature. Do not finish yet.",
-            "Before returning the final JSON again, continue the task and gather stronger completion evidence.",
-            bullets,
-            "Use tools to verify the claimed result, then return fresh final JSON only when these gaps are resolved.",
-        ].join("\n");
-    }
-    baseEvent(turn) {
-        return {
-            eventId: randomUUID(),
-            sessionId: turn.session.sessionId,
-            traceId: turn.session.traceId,
-            turnId: turn.turnId,
-            goalId: turn.goalId,
-            ...(turn.taskId ? { taskId: turn.taskId } : {}),
-            createdAt: new Date().toISOString(),
-        };
-    }
-    async record(turn, event) {
-        await turn.session.traceStore.append(event);
-        await turn.session.eventSink.emit(event);
-    }
-    preview(value) {
-        return value.length > 500 ? `${value.slice(0, 500)}...` : value;
-    }
-    stringify(value) {
-        if (typeof value === "string")
-            return value;
-        if (value === undefined)
-            return "";
-        try {
-            return JSON.stringify(value);
-        }
-        catch {
-            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 = 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.`,
-        };
-    }
-    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, compactionRecords: cloneAgentLoopCompactionRecords(compactionRecords), compacted: false };
-        }
-        const tokens = usageTokens && usageTokens > 0 ? usageTokens : this.estimateTokens(messages);
-        if (tokens < limit) {
-            return { messages, compactionRecords: cloneAgentLoopCompactionRecords(compactionRecords), compacted: false };
-        }
-        try {
-            const result = await this.compactor.compact({
-                history: createAgentLoopHistory(messages, compactionRecords),
-                maxMessages: turn.budget.compactionMaxMessages,
-                phase,
-                reason,
-            });
-            if (!result.compacted) {
-                return {
-                    messages: result.history.messages,
-                    compactionRecords: cloneAgentLoopCompactionRecords(result.history.compactionRecords),
-                    compacted: false,
-                };
-            }
-            await this.record(turn, {
-                type: "context_compaction",
-                ...this.baseEvent(turn),
-                phase,
-                reason,
-                inputMessages: messages.length,
-                outputMessages: result.history.messages.length,
-                summaryPreview: this.preview(result.summary ?? ""),
-            });
-            return {
-                messages: result.history.messages,
-                compactionRecords: cloneAgentLoopCompactionRecords(result.history.compactionRecords),
-                compacted: true,
-            };
-        }
-        catch (err) {
-            return {
-                messages,
-                compactionRecords: cloneAgentLoopCompactionRecords(compactionRecords),
-                compacted: false,
-                error: err instanceof Error ? err.message : String(err),
-            };
-        }
-    }
-    autoCompactLimit(turn) {
-        if (turn.budget.autoCompactTokenLimit && turn.budget.autoCompactTokenLimit > 0) {
-            return turn.budget.autoCompactTokenLimit;
-        }
-        const contextLimit = turn.modelInfo.capabilities.contextLimitTokens;
-        return contextLimit && contextLimit > 0 ? Math.floor(contextLimit * 0.9) : undefined;
-    }
-    async executeToolBatchWithinBudget(calls, turn, 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;
-        const abortFromParent = () => controller.abort();
-        if (parentSignal?.aborted) {
-            controller.abort();
-        }
-        else {
-            parentSignal?.addEventListener("abort", abortFromParent, { once: true });
-        }
-        const timer = setTimeout(() => {
-            timedOut = true;
-            controller.abort();
-        }, remainingMs);
-        const timeoutMs = Math.min(turn.toolCallContext.timeoutMs ?? remainingMs, remainingMs);
-        const boundedTurn = {
-            ...turn,
-            abortSignal: controller.signal,
-            toolCallContext: {
-                ...turn.toolCallContext,
-                abortSignal: controller.signal,
-                timeoutMs,
-            },
-        };
-        try {
-            return { results: await this.deps.toolRuntime.executeBatch(calls, boundedTurn), timedOut };
-        }
-        finally {
-            clearTimeout(timer);
-            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;
-        return response.usage.inputTokens + response.usage.outputTokens;
-    }
-    estimateTokens(messages) {
-        const chars = messages.reduce((total, message) => total + message.content.length, 0);
-        return Math.ceil(chars / 4);
-    }
-    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({
-                model: turn.model,
-                messages,
-                tools,
-                abortSignal: turn.abortSignal,
-            });
-        }
-        const response = await this.deps.modelClient.createTurn({
-            model: turn.model,
-            messages,
-            tools,
-            abortSignal: turn.abortSignal,
-        });
-        return {
-            assistant: response.content || response.toolCalls.length > 0 ? [{
-                    content: response.content || `Calling ${response.toolCalls.map((call) => call.name).join(", ")}`,
-                    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") || responseItemText || "",
-            toolCalls: protocol.responseItems ? responseItemToolCalls ?? [] : protocol.toolCalls,
-        };
-    }
-    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,
-            turnId: turn.turnId,
-            goalId: turn.goalId,
-            ...(turn.taskId ? { taskId: turn.taskId } : {}),
-            cwd: turn.cwd,
-            modelRef: formatAgentLoopModelRef(turn.model),
-            messages,
-            compactionRecords: cloneAgentLoopCompactionRecords(compactionRecords),
-            modelTurns,
-            toolCalls,
-            compactions,
-            completionValidationAttempts,
-            calledTools: [...calledTools],
-            lastToolLoopSignature,
-            repeatedToolLoopCount,
-            finalText,
-            status,
-            ...(stopReason ? { stopReason } : {}),
-            ...(failureReason ? { failureReason } : {}),
-            ...(stopDetail ? { stopDetail } : {}),
-            updatedAt: new Date().toISOString(),
-        };
-        await turn.session.stateStore.save(state);
-    }
-    async captureWorkspaceSnapshot(cwd) {
-        const result = await execFileNoThrow("git", ["status", "--porcelain", "--untracked-files=all"], { cwd, timeoutMs: 10_000 });
-        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) {
-            if (before?.kind !== "filesystem")
-                return [];
-            return this.collectFilesystemChangedPaths(before.files, await this.captureFilesystemSnapshot(cwd));
-        }
-        const after = new Set(this.parseGitStatusPaths(afterResult.stdout));
-        if (!before || before.kind !== "git")
-            return [...after];
-        return [...after].filter((file) => !before.paths.has(file));
-    }
-    parseGitStatusPaths(stdout) {
-        return stdout
-            .split("\n")
-            .map((line) => line.trimEnd())
-            .filter((line) => line.length >= 4)
-            .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