@caupulican/pi-adaptative 0.86.2 → 0.86.5

package/dist/core/delegation/worker-attempt-executor.js

@@ -1,25 +1,114 @@
 import path from "node:path";
+import { isDeepStrictEqual } from "node:util";
 import { compact } from "@caupulican/pi-agent-core/compaction/compaction";
+import { classifyFailure, computeRetryDelayMs, sleepAbortable, } from "@caupulican/pi-agent-core/reliability";
 import { sanitizeToolFailureContext } from "@caupulican/pi-agent-core/tool-failure-memory";
 import { addUsage, createEmptyUsage } from "@caupulican/pi-agent-core/usage";
 import { safeRealpathSync } from "../autonomy/path-scope.js";
 import { composeSubagentSystemPrompt } from "../autonomy/subagent-prompt.js";
 import { attemptUsageFromGatewayUsage, EMPTY_ATTEMPT_USAGE } from "../orchestration/attempt-usage.js";
+import { CapabilityGatewayDeniedError } from "../orchestration/capability-gateway.js";
 import { WorkerActionJournal } from "./worker-action-journal.js";
+import { WorkerConversationOwnershipError } from "./worker-conversation-revision.js";
+import { WorkerCompletionProtocolError, WorkerProviderTurnProtocol } from "./worker-provider-turn-protocol.js";
 import { runWorker } from "./worker-runner.js";
-function recordAssistantUsage(surface, message) {
-    surface.gateway?.recordUsage({
-        inputTokens: message.usage.input,
-        outputTokens: message.usage.output,
-        cacheReadTokens: message.usage.cacheRead,
-        cacheWriteTokens: message.usage.cacheWrite,
-        totalTokens: message.usage.totalTokens,
-        costUsd: message.usage.cost.total,
-    });
+import { WorkerTreeBudgetExceededError } from "./worker-tree-budget-coordinator.js";
+/**
+ * Backoff policy for transient worker provider failures. Without it, a dropped provider socket
+ * kills the attempt instantly at $0 spend and an immediate re-dispatch hits the same dead
+ * connection (field session 019fd4dc: paired $0 `completion_error` lanes ~10s apart). Jitter
+ * de-synchronizes sibling workers that all lost the same connection at once.
+ */
+const WORKER_PROVIDER_RETRY_POLICY = {
+    maxAttempts: 3,
+    baseDelayMs: 2_000,
+    maxDelayMs: 30_000,
+    jitterRatio: 0.2,
+};
+export async function runProviderCompletionWithBackoff(args) {
+    for (let attempt = 1;; attempt++) {
+        try {
+            return await args.attempt();
+        }
+        catch (error) {
+            args.onAttemptFailure();
+            if (args.signal?.aborted)
+                throw error;
+            if (error instanceof WorkerCompletionProtocolError ||
+                error instanceof WorkerConversationOwnershipError ||
+                error instanceof CapabilityGatewayDeniedError ||
+                error instanceof WorkerTreeBudgetExceededError) {
+                throw error;
+            }
+            const classified = classifyFailure({
+                message: error instanceof Error ? error.message : String(error),
+                provider: args.provider,
+            });
+            if (!classified.retryable || attempt >= WORKER_PROVIDER_RETRY_POLICY.maxAttempts)
+                throw error;
+            const delayMs = computeRetryDelayMs(WORKER_PROVIDER_RETRY_POLICY, attempt, {
+                ...(classified.retryAfterMs !== undefined ? { retryAfterMs: classified.retryAfterMs } : {}),
+            });
+            args.warn(`Worker ${args.laneId} provider request failed (${classified.reason}); retrying in ${Math.ceil(delayMs / 1000)}s (attempt ${attempt + 1}/${WORKER_PROVIDER_RETRY_POLICY.maxAttempts}).`);
+            await sleepAbortable(delayMs, args.signal);
+        }
+    }
 }
 function isToolRequest(message) {
     return message.role === "assistant" && message.content.some((content) => content.type === "toolCall");
 }
+function workerCompletionCallbackFailure(error) {
+    if (error instanceof WorkerCompletionProtocolError ||
+        error instanceof WorkerConversationOwnershipError ||
+        error instanceof CapabilityGatewayDeniedError ||
+        error instanceof WorkerTreeBudgetExceededError) {
+        return error;
+    }
+    return new WorkerCompletionProtocolError("Worker completion callback failed before its authority and durable transcript were verified.");
+}
+function callbackEvidencedCompletion(result, historyLength, emittedMessages) {
+    if (result.messages !== undefined && result.messages.length < historyLength) {
+        throw new WorkerCompletionProtocolError("Worker completion protocol returned fewer messages than its input history.");
+    }
+    let suffix;
+    if (result.messages !== undefined) {
+        suffix = result.messages.slice(historyLength);
+        if (!isDeepStrictEqual(suffix, emittedMessages)) {
+            throw new WorkerCompletionProtocolError("Worker completion protocol returned a suffix without exact callback evidence.");
+        }
+    }
+    else {
+        suffix = [...emittedMessages];
+    }
+    if (suffix.length === 0) {
+        throw new WorkerCompletionProtocolError("Worker completion protocol returned no durable message suffix.");
+    }
+    if (!suffix.some((message) => message.role === "assistant")) {
+        throw new WorkerCompletionProtocolError("Worker completion protocol returned no assistant in its durable suffix.");
+    }
+    const assistants = emittedMessages.filter((message) => message.role === "assistant");
+    const finalMessage = emittedMessages.at(-1);
+    if (!finalMessage || finalMessage.role !== "assistant") {
+        throw new WorkerCompletionProtocolError("Worker completion protocol did not durably emit an assistant as its terminal message.");
+    }
+    const usage = createEmptyUsage();
+    for (const assistant of assistants)
+        addUsage(usage, assistant.usage);
+    const text = finalMessage.content.flatMap((content) => (content.type === "text" ? [content.text] : [])).join("");
+    if (result.text !== text ||
+        result.stopReason !== finalMessage.stopReason ||
+        !isDeepStrictEqual(result.usage, usage)) {
+        throw new WorkerCompletionProtocolError("Worker completion result disagrees with its durable callback-evidenced terminal assistant.");
+    }
+    return {
+        suffix,
+        completion: {
+            text,
+            usage,
+            stopReason: finalMessage.stopReason,
+        },
+    };
+}
 /**
  * Constructs one execution exactly once. The caller registers {@link ledger} before calling
  * {@link run}, allowing synchronous disposal to observe mutations and cumulative usage while the
@@ -47,7 +136,6 @@ export function createWorkerAttemptExecutor(options) {
             fencingToken: options.durableHandle.fencingToken,
         })
         : undefined;
-    let providerContextCompacted = options.conversation.hasProviderCompaction();
     let retentionWarningEmitted = false;
     let firstMailboxPoll = true;
     let ran = false;
@@ -69,74 +157,122 @@ export function createWorkerAttemptExecutor(options) {
             throw signal.reason;
         return { maxTokens: requestedMaxTokens, release: () => undefined };
     };
-    let failedCompactionUsage;
-    const retentionPolicy = options.retentionPolicy && {
-        ...options.retentionPolicy,
-        generateVerifiedCompaction: async (preparation) => {
-            const compactionUsage = createEmptyUsage();
-            failedCompactionUsage = compactionUsage;
-            return compact(preparation, options.model, undefined, undefined, undefined, options.signal, options.thinkingLevel, undefined, undefined, {
-                completion: async (model, context, requestOptions) => {
-                    if (model.provider !== options.model.provider || model.id !== options.model.id) {
-                        throw new Error("Worker compaction attempted to select a model outside the lane binding.");
-                    }
-                    options.toolSurface.gateway?.assertBudgetAvailable("worker_compaction_provider_completion");
-                    const availableTokens = remainingAttemptTokens();
-                    if (availableTokens !== undefined && availableTokens <= 0) {
-                        throw new Error("Worker token budget exhausted before compaction provider completion.");
-                    }
-                    const requestedMaxTokens = requestOptions.maxTokens;
-                    const configuredMaxTokens = typeof requestedMaxTokens === "number" &&
-                        Number.isSafeInteger(requestedMaxTokens) &&
-                        requestedMaxTokens > 0
-                        ? requestedMaxTokens
-                        : options.laneCapability.laneMaxOutputTokens;
-                    const maxTokens = Math.min(configuredMaxTokens, availableTokens ?? configuredMaxTokens);
-                    if (!Number.isSafeInteger(maxTokens) || maxTokens <= 0) {
-                        throw new Error("Worker compaction provider completion has no valid remaining token budget.");
-                    }
-                    let reservation;
-                    try {
-                        const completion = await options.runIsolatedCompletion({
-                            systemPrompt: context.systemPrompt ?? "",
-                            messages: context.messages,
-                            model: options.model,
-                            thinkingLevel: options.thinkingLevel,
-                            maxTokens,
-                            requestPreflight: async () => {
-                                reservation?.release();
-                                reservation = await reserveProviderBudget(maxTokens, "worker_compaction_provider_completion", requestOptions.signal ?? options.signal);
-                                return { maxTokens: reservation.maxTokens };
+    const createRetentionPolicy = (completeSignal) => {
+        if (!options.retentionPolicy)
+            return undefined;
+        let failedCompactionUsage;
+        return {
+            ...options.retentionPolicy,
+            generateVerifiedCompaction: async (preparation) => {
+                const compactionUsage = createEmptyUsage();
+                failedCompactionUsage = compactionUsage;
+                return compact(preparation, options.model, undefined, undefined, undefined, completeSignal, options.thinkingLevel, undefined, undefined, {
+                    completion: async (model, context, requestOptions) => {
+                        const requestSignal = requestOptions.signal ?? completeSignal;
+                        requestSignal.throwIfAborted();
+                        if (model.provider !== options.model.provider || model.id !== options.model.id) {
+                            throw new Error("Worker compaction attempted to select a model outside the lane binding.");
+                        }
+                        options.toolSurface.gateway?.assertBudgetAvailable("worker_compaction_provider_completion");
+                        const availableTokens = remainingAttemptTokens();
+                        if (availableTokens !== undefined && availableTokens <= 0) {
+                            throw new Error("Worker token budget exhausted before compaction provider completion.");
+                        }
+                        const requestedMaxTokens = requestOptions.maxTokens;
+                        const configuredMaxTokens = typeof requestedMaxTokens === "number" &&
+                            Number.isSafeInteger(requestedMaxTokens) &&
+                            requestedMaxTokens > 0
+                            ? requestedMaxTokens
+                            : options.laneCapability.laneMaxOutputTokens;
+                        const maxTokens = Math.min(configuredMaxTokens, availableTokens ?? configuredMaxTokens);
+                        if (!Number.isSafeInteger(maxTokens) || maxTokens <= 0) {
+                            throw new Error("Worker compaction provider completion has no valid remaining token budget.");
+                        }
+                        let preflightFailed = false;
+                        let preflightFailure;
+                        const providerTurn = new WorkerProviderTurnProtocol({
+                            acquireReservation: () => reserveProviderBudget(maxTokens, "worker_compaction_provider_completion", requestSignal),
+                            signal: requestSignal,
+                            onFailure: (error) => {
+                                if (preflightFailed)
+                                    return;
+                                preflightFailed = true;
+                                preflightFailure = error;
                             },
-                            signal: requestOptions.signal ?? options.signal,
-                            cacheRetention: "none",
-                            laneKind: "worker-compaction",
-                        });
-                        addUsage(compactionUsage, completion.usage);
-                        const response = {
-                            role: "assistant",
-                            content: completion.text ? [{ type: "text", text: completion.text }] : [],
-                            api: options.model.api,
-                            provider: options.model.provider,
-                            model: options.model.id,
-                            usage: completion.usage,
-                            stopReason: completion.stopReason,
-                            timestamp: Date.now(),
-                            ...(completion.stopReason === "error"
-                                ? { errorMessage: completion.text || "Worker compaction provider request failed." }
+                            ...(options.toolSurface.gateway
+                                ? { recordUsage: (delta) => options.toolSurface.gateway?.recordUsage(delta) }
                                 : {}),
-                        };
-                        recordAssistantUsage(options.toolSurface, response);
-                        checkpointUsage("Persisted worker compaction provider usage before verification.");
-                        return response;
-                    }
-                    finally {
-                        reservation?.release();
-                    }
-                },
-            });
-        },
-        getFailedCompactionUsage: () => failedCompactionUsage,
+                        });
+                        try {
+                            let completion;
+                            try {
+                                completion = await options.runIsolatedCompletion({
+                                    systemPrompt: context.systemPrompt ?? "",
+                                    messages: context.messages,
+                                    model: options.model,
+                                    thinkingLevel: options.thinkingLevel,
+                                    maxTokens,
+                                    requestPreflight: () => providerTurn.requestPreflight(),
+                                    signal: requestSignal,
+                                    cacheRetention: "none",
+                                    laneKind: "worker-compaction",
+                                });
+                            }
+                            catch (error) {
+                                providerTurn.close();
+                                requestSignal.throwIfAborted();
+                                if (preflightFailed)
+                                    throw workerCompletionCallbackFailure(preflightFailure);
+                                throw error;
+                            }
+                            requestSignal.throwIfAborted();
+                            const response = {
+                                role: "assistant",
+                                content: completion.text ? [{ type: "text", text: completion.text }] : [],
+                                api: options.model.api,
+                                provider: options.model.provider,
+                                model: options.model.id,
+                                usage: completion.usage,
+                                stopReason: completion.stopReason,
+                                timestamp: Date.now(),
+                                ...(completion.stopReason === "error"
+                                    ? { errorMessage: completion.text || "Worker compaction provider request failed." }
+                                    : {}),
+                            };
+                            addUsage(compactionUsage, completion.usage);
+                            if (providerTurn.hasOutstandingAssistantReservation()) {
+                                providerTurn.accountAssistantUsage(completion.usage);
+                            }
+                            else {
+                                providerTurn.accountUnverifiedResultUsageDelta(completion.usage);
+                            }
+                            checkpointUsage("Persisted worker compaction provider usage before verification.");
+                            if (providerTurn.hasSuccessfulPreflight()) {
+                                try {
+                                    providerTurn.consumeTerminalAssistantAndHold();
+                                }
+                                catch (error) {
+                                    if (!preflightFailed) {
+                                        preflightFailed = true;
+                                        preflightFailure = error;
+                                    }
+                                }
+                            }
+                            providerTurn.close();
+                            requestSignal.throwIfAborted();
+                            if (preflightFailed)
+                                throw workerCompletionCallbackFailure(preflightFailure);
+                            providerTurn.assertProviderOutputPreflight("compaction");
+                            return response;
+                        }
+                        finally {
+                            providerTurn.close();
+                        }
+                    },
+                });
+            },
+            getFailedCompactionUsage: () => failedCompactionUsage,
+        };
     };
     const ledger = {
         changedFiles,
@@ -149,6 +285,7 @@ export function createWorkerAttemptExecutor(options) {
             if (ran)
                 throw new Error("A worker attempt executor may run only once.");
             ran = true;
+            options.conversation.beginAttemptUsage(options.durableHandle.attemptId);
             if (!options.hasPersistedUsageCheckpoint) {
                 checkpointUsage("Persisted deterministic cumulative usage baseline for the durable worker transcript.");
             }
@@ -184,171 +321,299 @@ export function createWorkerAttemptExecutor(options) {
                             stopReason: options.recoveredTerminal.stopReason,
                         };
                     }
+                    const retentionPolicy = createRetentionPolicy(signal);
                     const persistedToolAssistantIds = new Set();
                     const pendingToolAssistants = new Map();
-                    let providerReservation;
-                    const releaseProviderReservation = () => {
-                        providerReservation?.release();
-                        providerReservation = undefined;
-                    };
-                    const persistToolRequest = (message) => {
-                        const toolCallIds = message.content.flatMap((content) => content.type === "toolCall" ? [content.id] : []);
-                        if (toolCallIds.length === 0 || toolCallIds.every((id) => persistedToolAssistantIds.has(id)))
-                            return;
-                        recordAssistantUsage(options.toolSurface, message);
-                        options.conversation.appendMessage(message);
-                        for (const id of toolCallIds) {
-                            persistedToolAssistantIds.add(id);
-                            pendingToolAssistants.delete(id);
-                        }
-                        checkpointUsage("Persisted worker assistant tool request and its cumulative provider usage.");
-                        releaseProviderReservation();
+                    let activeProviderTurn;
+                    const closeActiveProviderTurn = () => {
+                        const active = activeProviderTurn;
+                        activeProviderTurn = undefined;
+                        active?.close();
                     };
                     options.toolSurface.gateway?.assertBudgetAvailable("worker_provider_completion");
                     const availableTokens = remainingAttemptTokens();
                     if (availableTokens !== undefined && availableTokens <= 0) {
                         throw new Error("Worker token budget exhausted before provider completion.");
                     }
-                    let history = options.conversation.getProviderMessages();
-                    if (history.length === 0) {
-                        options.conversation.appendMessage({
-                            role: "user",
-                            content: [{ type: "text", text: userPrompt }],
-                            timestamp: Date.now(),
-                        });
-                        history = options.conversation.getProviderMessages();
-                    }
+                    options.conversation.ensureAttemptUserPrompt(options.durableHandle.attemptId, userPrompt);
+                    let history = [];
                     let completion;
-                    try {
-                        completion = await options.runIsolatedCompletion({
-                            systemPrompt: composeSubagentSystemPrompt({
-                                soul: options.soul,
-                                rolePrompt: [systemPrompt, options.workerResourceSystemPrompt].filter(Boolean).join("\n\n"),
-                            }),
-                            history,
-                            messages: [],
-                            model: options.model,
-                            thinkingLevel: options.thinkingLevel,
-                            maxTokens: Math.min(options.laneCapability.laneMaxOutputTokens, availableTokens ?? Number.POSITIVE_INFINITY),
-                            tools: options.toolSurface.tools,
-                            requestPreflight: async () => {
-                                releaseProviderReservation();
-                                providerReservation = await reserveProviderBudget(options.laneCapability.laneMaxOutputTokens, "worker_provider_completion", signal);
-                                return { maxTokens: providerReservation.maxTokens };
-                            },
-                            beforeToolCall: async (context, toolSignal) => {
-                                persistToolRequest(context.assistantMessage);
-                                const decision = await options.toolSurface.beforeToolCall(context, toolSignal);
-                                if (decision?.block) {
-                                    toolIssues.add(`${context.toolCall.name} blocked: ${decision.reason ?? "capability denied"}`);
-                                }
-                                else {
-                                    checkpointUsage(`Authorized worker tool '${context.toolCall.name}' under its durable grant.`);
-                                }
-                                return decision;
-                            },
-                            afterToolCall: async ({ toolCall, args, isError }) => {
-                                if ((toolCall.name === "write" || toolCall.name === "edit") &&
-                                    args &&
-                                    typeof args === "object" &&
-                                    !Array.isArray(args)) {
-                                    const rawPath = args.path;
-                                    if (typeof rawPath === "string" && rawPath.length > 0) {
-                                        const absolutePath = path.isAbsolute(rawPath)
-                                            ? path.resolve(rawPath)
-                                            : path.resolve(options.cwd, rawPath);
-                                        let canonicalPath = absolutePath;
+                    const attemptProviderCompletion = async () => {
+                        // Later attempts resume from the durably persisted transcript, not a stale snapshot.
+                        const transcriptCommit = options.conversation.beginTranscriptCommit();
+                        history = transcriptCommit.history;
+                        const historyLength = history.length;
+                        const transcriptCursor = transcriptCommit.cursor;
+                        const durableCallbackMessages = [];
+                        let callbackFailed = false;
+                        let callbackFailure;
+                        const retainCallbackFailure = (error) => {
+                            if (callbackFailed)
+                                return;
+                            callbackFailed = true;
+                            callbackFailure = error;
+                        };
+                        const providerTurn = new WorkerProviderTurnProtocol({
+                            acquireReservation: () => reserveProviderBudget(options.laneCapability.laneMaxOutputTokens, "worker_provider_completion", signal),
+                            signal,
+                            onFailure: retainCallbackFailure,
+                            ...(options.toolSurface.gateway
+                                ? { recordUsage: (delta) => options.toolSurface.gateway?.recordUsage(delta) }
+                                : {}),
+                        });
+                        activeProviderTurn = providerTurn;
+                        const persistToolRequest = (message) => {
+                            signal.throwIfAborted();
+                            const toolCallIds = message.content.flatMap((content) => content.type === "toolCall" ? [content.id] : []);
+                            if (toolCallIds.length === 0 || toolCallIds.every((id) => persistedToolAssistantIds.has(id)))
+                                return;
+                            providerTurn.accountAssistantUsage(message.usage);
+                            options.conversation.appendMessage(message);
+                            for (const id of toolCallIds) {
+                                persistedToolAssistantIds.add(id);
+                                pendingToolAssistants.delete(id);
+                            }
+                            checkpointUsage("Persisted worker assistant tool request and its cumulative provider usage.");
+                            providerTurn.consumeToolAssistantAndRelease();
+                            durableCallbackMessages.push(message);
+                        };
+                        let committed = false;
+                        const abortTranscriptCursor = () => {
+                            providerTurn.close();
+                            options.conversation.abortTranscriptCommit(transcriptCursor);
+                        };
+                        signal.addEventListener("abort", abortTranscriptCursor, { once: true });
+                        try {
+                            signal.throwIfAborted();
+                            let result;
+                            try {
+                                result = await options.runIsolatedCompletion({
+                                    systemPrompt: composeSubagentSystemPrompt({
+                                        soul: options.soul,
+                                        rolePrompt: [systemPrompt, options.workerResourceSystemPrompt]
+                                            .filter(Boolean)
+                                            .join("\n\n"),
+                                    }),
+                                    history,
+                                    messages: [],
+                                    model: options.model,
+                                    thinkingLevel: options.thinkingLevel,
+                                    maxTokens: Math.min(options.laneCapability.laneMaxOutputTokens, availableTokens ?? Number.POSITIVE_INFINITY),
+                                    tools: options.toolSurface.tools,
+                                    requestPreflight: () => providerTurn.requestPreflight(),
+                                    beforeToolCall: async (context, toolSignal) => {
                                         try {
-                                            canonicalPath = safeRealpathSync(absolutePath);
+                                            signal.throwIfAborted();
+                                            persistToolRequest(context.assistantMessage);
+                                            const decision = await options.toolSurface.beforeToolCall(context, toolSignal);
+                                            signal.throwIfAborted();
+                                            if (decision?.block) {
+                                                toolIssues.add(`${context.toolCall.name} blocked: ${decision.reason ?? "capability denied"}`);
+                                            }
+                                            else {
+                                                checkpointUsage(`Authorized worker tool '${context.toolCall.name}' under its durable grant.`);
+                                            }
+                                            return decision;
                                         }
-                                        catch {
-                                            // The operation entered execution; retain its lexical target if canonicalization failed.
+                                        catch (error) {
+                                            retainCallbackFailure(error);
+                                            throw error;
                                         }
-                                        recordChangedFile(path.relative(options.cwd, canonicalPath).split(path.sep).join("/"));
-                                    }
-                                }
-                                if (isError)
-                                    toolIssues.add(`${toolCall.name} failed during isolated execution`);
-                                return undefined;
-                            },
-                            onMessage: (message) => {
-                                if (message.role === "assistant" && isToolRequest(message)) {
-                                    // Known calls are normalized before beforeToolCall and persist from that hook.
-                                    // Retain the request only so immediate unknown/malformed results can close the
-                                    // transcript without freezing pre-repair arguments into durable history.
-                                    for (const content of message.content) {
-                                        if (content.type === "toolCall")
-                                            pendingToolAssistants.set(content.id, message);
-                                    }
-                                    return;
-                                }
-                                if (message.role === "toolResult" && !persistedToolAssistantIds.has(message.toolCallId)) {
-                                    const pending = pendingToolAssistants.get(message.toolCallId);
-                                    if (pending)
-                                        persistToolRequest(pending);
-                                }
-                                if (message.role === "assistant")
-                                    recordAssistantUsage(options.toolSurface, message);
-                                options.conversation.appendMessage(message);
-                                options.agentControl.acknowledgeMailboxMessage(options.agentId, message);
-                                if (message.role === "assistant") {
-                                    checkpointUsage("Persisted worker assistant response and its cumulative provider usage.");
-                                    releaseProviderReservation();
-                                }
-                                if (message.role === "toolResult")
-                                    checkpointUsage(`Persisted worker tool result '${message.toolCallId}'.`);
-                            },
-                            getSteeringMessages: async () => {
-                                const includeFollowUp = firstMailboxPoll;
-                                firstMailboxPoll = false;
-                                return options.agentControl.mailboxMessagesForConversation(options.agentId, options.conversation, includeFollowUp);
-                            },
-                            getFollowUpMessages: async () => options.agentControl.mailboxMessagesForConversation(options.agentId, options.conversation, true),
-                            ...(retentionPolicy
-                                ? {
-                                    transformContext: async (messages) => {
+                                    },
+                                    afterToolCall: async ({ toolCall, args, isError }) => {
                                         try {
-                                            const retained = await options.conversation.compactProviderContext(retentionPolicy, options.signal);
-                                            if (retained.status === "compacted_verified" ||
-                                                retained.status === "compacted_deterministic") {
-                                                providerContextCompacted = true;
+                                            if ((toolCall.name === "write" || toolCall.name === "edit") &&
+                                                args &&
+                                                typeof args === "object" &&
+                                                !Array.isArray(args)) {
+                                                const rawPath = args.path;
+                                                if (typeof rawPath === "string" && rawPath.length > 0) {
+                                                    const absolutePath = path.isAbsolute(rawPath)
+                                                        ? path.resolve(rawPath)
+                                                        : path.resolve(options.cwd, rawPath);
+                                                    let canonicalPath = absolutePath;
+                                                    try {
+                                                        canonicalPath = safeRealpathSync(absolutePath);
+                                                    }
+                                                    catch {
+                                                        // The operation entered execution; retain its lexical target if canonicalization failed.
+                                                    }
+                                                    recordChangedFile(path.relative(options.cwd, canonicalPath).split(path.sep).join("/"));
+                                                }
                                             }
-                                            if (retained.contextUsage.tokens > retentionPolicy.maxContextTokens &&
-                                                !retentionWarningEmitted) {
-                                                retentionWarningEmitted = true;
-                                                options.warn(`Worker ${options.laneId} has one retained turn larger than its context policy; provider overflow recovery may be required.`);
+                                            if (isError)
+                                                toolIssues.add(`${toolCall.name} failed during isolated execution`);
+                                            signal.throwIfAborted();
+                                            return undefined;
+                                        }
+                                        catch (error) {
+                                            retainCallbackFailure(error);
+                                            throw error;
+                                        }
+                                    },
+                                    onMessage: (message) => {
+                                        try {
+                                            signal.throwIfAborted();
+                                            if (message.role === "assistant" && isToolRequest(message)) {
+                                                // Known calls are normalized before beforeToolCall and persist from that hook.
+                                                // Retain the request only so immediate unknown/malformed results can close the
+                                                // transcript without freezing pre-repair arguments into durable history.
+                                                for (const content of message.content) {
+                                                    if (content.type === "toolCall")
+                                                        pendingToolAssistants.set(content.id, message);
+                                                }
+                                                return;
                                             }
-                                            if (retained.status !== "compacted_verified" &&
-                                                retained.status !== "compacted_deterministic") {
-                                                return messages;
+                                            if (message.role === "toolResult" &&
+                                                !persistedToolAssistantIds.has(message.toolCallId)) {
+                                                const pending = pendingToolAssistants.get(message.toolCallId);
+                                                if (pending)
+                                                    persistToolRequest(pending);
                                             }
-                                            return sanitizeToolFailureContext(retained.context.messages, "").messages;
+                                            if (message.role === "assistant") {
+                                                providerTurn.accountAssistantUsage(message.usage);
+                                            }
+                                            options.conversation.appendMessage(message);
+                                            options.agentControl.acknowledgeMailboxMessage(options.agentId, message);
+                                            if (message.role === "assistant") {
+                                                checkpointUsage("Persisted worker assistant response and its cumulative provider usage.");
+                                                providerTurn.consumeTerminalAssistantAndHold();
+                                            }
+                                            if (message.role === "toolResult")
+                                                checkpointUsage(`Persisted worker tool result '${message.toolCallId}'.`);
+                                            durableCallbackMessages.push(message);
                                         }
                                         catch (error) {
-                                            if (!retentionWarningEmitted) {
-                                                retentionWarningEmitted = true;
-                                                options.warn(`Worker context retention failed: ${error instanceof Error ? error.message : String(error)}`);
-                                            }
+                                            retainCallbackFailure(error);
+                                            throw error;
+                                        }
+                                    },
+                                    getSteeringMessages: async () => {
+                                        try {
+                                            signal.throwIfAborted();
+                                            const includeFollowUp = firstMailboxPoll;
+                                            firstMailboxPoll = false;
+                                            const messages = options.agentControl.mailboxMessagesForConversation(options.agentId, options.conversation, includeFollowUp);
+                                            signal.throwIfAborted();
                                             return messages;
                                         }
+                                        catch (error) {
+                                            retainCallbackFailure(error);
+                                            throw error;
+                                        }
                                     },
-                                }
-                                : {}),
-                            signal,
-                            cacheRetention: "short",
-                            laneKind: "worker",
+                                    getFollowUpMessages: async () => {
+                                        try {
+                                            signal.throwIfAborted();
+                                            const messages = options.agentControl.mailboxMessagesForConversation(options.agentId, options.conversation, true);
+                                            signal.throwIfAborted();
+                                            return messages;
+                                        }
+                                        catch (error) {
+                                            retainCallbackFailure(error);
+                                            throw error;
+                                        }
+                                    },
+                                    ...(retentionPolicy
+                                        ? {
+                                            transformContext: async (messages) => {
+                                                try {
+                                                    signal.throwIfAborted();
+                                                    const retained = await options.conversation.compactProviderContext(retentionPolicy, signal);
+                                                    signal.throwIfAborted();
+                                                    if (retained.contextUsage.tokens > retentionPolicy.maxContextTokens &&
+                                                        !retentionWarningEmitted) {
+                                                        retentionWarningEmitted = true;
+                                                        options.warn(`Worker ${options.laneId} has one retained turn larger than its context policy; provider overflow recovery may be required.`);
+                                                    }
+                                                    if (retained.status !== "compacted_verified" &&
+                                                        retained.status !== "compacted_deterministic") {
+                                                        return messages;
+                                                    }
+                                                    return sanitizeToolFailureContext(retained.context.messages, "").messages;
+                                                }
+                                                catch (error) {
+                                                    if (signal.aborted) {
+                                                        retainCallbackFailure(error);
+                                                        signal.throwIfAborted();
+                                                    }
+                                                    if (error instanceof WorkerConversationOwnershipError) {
+                                                        retainCallbackFailure(error);
+                                                        throw error;
+                                                    }
+                                                    if (!retentionWarningEmitted) {
+                                                        retentionWarningEmitted = true;
+                                                        options.warn(`Worker context retention failed: ${error instanceof Error ? error.message : String(error)}`);
+                                                    }
+                                                    return messages;
+                                                }
+                                            },
+                                        }
+                                        : {}),
+                                    signal,
+                                    cacheRetention: "short",
+                                    laneKind: "worker",
+                                });
+                            }
+                            catch (error) {
+                                providerTurn.close();
+                                if (signal.aborted)
+                                    throw error;
+                                if (callbackFailed)
+                                    throw workerCompletionCallbackFailure(callbackFailure);
+                                throw error;
+                            }
+                            try {
+                                providerTurn.assertEverySuccessfulPreflightConsumed();
+                            }
+                            catch (error) {
+                                retainCallbackFailure(error);
+                            }
+                            signal.throwIfAborted();
+                            if (providerTurn.accountUnverifiedResultUsageDelta(result.usage)) {
+                                checkpointUsage("Persisted supplemental provider result usage before rejecting unverified completion evidence.");
+                            }
+                            providerTurn.close();
+                            if (callbackFailed)
+                                throw workerCompletionCallbackFailure(callbackFailure);
+                            providerTurn.assertProviderOutputPreflight();
+                            const evidenced = callbackEvidencedCompletion(result, historyLength, durableCallbackMessages);
+                            signal.throwIfAborted();
+                            const appended = options.conversation.commitTranscript(transcriptCursor, evidenced.suffix, {
+                                appendMissing: false,
+                            });
+                            if (appended !== 0) {
+                                throw new WorkerConversationOwnershipError("Worker callback transcript verification unexpectedly appended missing messages.");
+                            }
+                            committed = true;
+                            return evidenced.completion;
+                        }
+                        finally {
+                            signal.removeEventListener("abort", abortTranscriptCursor);
+                            providerTurn.close();
+                            if (activeProviderTurn === providerTurn)
+                                activeProviderTurn = undefined;
+                            if (!committed)
+                                options.conversation.abortTranscriptCommit(transcriptCursor);
+                        }
+                    };
+                    try {
+                        completion = await runProviderCompletionWithBackoff({
+                            attempt: attemptProviderCompletion,
+                            onAttemptFailure: closeActiveProviderTurn,
+                            provider: options.model.provider,
+                            laneId: options.laneId,
+                            warn: options.warn,
+                            ...(signal ? { signal } : {}),
                         });
                     }
                     finally {
-                        releaseProviderReservation();
-                    }
-                    if (!providerContextCompacted) {
-                        options.conversation.commitTranscript(completion.messages ?? options.conversation.getProviderMessages());
+                        closeActiveProviderTurn();
                     }
-                    checkpointUsage(`Persisted worker conversation through ${options.conversation.getProviderContext().messages.length} messages.`);
+                    const cumulativeUsage = checkpointUsage("Verified the callback-persisted worker conversation terminal suffix.");
                     return {
                         text: completion.text,
-                        costUsd: completion.usage.cost.total,
+                        costUsd: cumulativeUsage.costUsd,
                         stopReason: String(completion.stopReason),
                         changedFiles: [...changedFiles],
                         blockers: [...toolIssues],