@poolzin/pool-bot 2026.2.20 → 2026.2.22

package/dist/agents/pi-embedded-runner/run/attempt.js

@@ -3,41 +3,53 @@ import os from "node:os";
 import { streamSimple } from "@mariozechner/pi-ai";
 import { createAgentSession, SessionManager, SettingsManager } from "@mariozechner/pi-coding-agent";
 import { resolveHeartbeatPrompt } from "../../../auto-reply/heartbeat.js";
-import { listChannelSupportedActions, resolveChannelMessageToolHints, } from "../../channel-tools.js";
 import { resolveChannelCapabilities } from "../../../config/channel-capabilities.js";
 import { getMachineDisplayName } from "../../../infra/machine-name.js";
+import { MAX_IMAGE_BYTES } from "../../../media/constants.js";
+import { getGlobalHookRunner } from "../../../plugins/hook-runner-global.js";
+import { isCronSessionKey, isSubagentSessionKey, normalizeAgentId, } from "../../../routing/session-key.js";
+import { resolveSignalReactionLevel } from "../../../signal/reaction-level.js";
 import { resolveTelegramInlineButtonsScope } from "../../../telegram/inline-buttons.js";
 import { resolveTelegramReactionLevel } from "../../../telegram/reaction-level.js";
-import { resolveSignalReactionLevel } from "../../../signal/reaction-level.js";
+import { buildTtsSystemPromptHint } from "../../../tts/tts.js";
+import { resolveUserPath } from "../../../utils.js";
 import { normalizeMessageChannel } from "../../../utils/message-channel.js";
 import { isReasoningTagProvider } from "../../../utils/provider-utils.js";
-import { isSubagentSessionKey } from "../../../routing/session-key.js";
-import { resolveUserPath } from "../../../utils.js";
-import { createCacheTrace } from "../../cache-trace.js";
-import { createAnthropicPayloadLogger } from "../../anthropic-payload-log.js";
 import { resolvePoolbotAgentDir } from "../../agent-paths.js";
 import { resolveSessionAgentIds } from "../../agent-scope.js";
+import { createAnthropicPayloadLogger } from "../../anthropic-payload-log.js";
 import { makeBootstrapWarn, resolveBootstrapContextForRun } from "../../bootstrap-files.js";
+import { createCacheTrace } from "../../cache-trace.js";
+import { listChannelSupportedActions, resolveChannelMessageToolHints, } from "../../channel-tools.js";
+import { DEFAULT_CONTEXT_TOKENS } from "../../defaults.js";
 import { resolvePoolbotDocsPath } from "../../docs-path.js";
+import { isTimeoutError } from "../../failover-error.js";
+import { resolveImageSanitizationLimits } from "../../image-sanitization.js";
 import { resolveModelAuthMode } from "../../model-auth.js";
-import { isCloudCodeAssistFormatError, resolveBootstrapMaxChars, validateAnthropicTurns, validateGeminiTurns, } from "../../pi-embedded-helpers.js";
+import { resolveDefaultModelForAgent } from "../../model-selection.js";
+import { createOllamaStreamFn, OLLAMA_NATIVE_BASE_URL } from "../../ollama-stream.js";
+import { isCloudCodeAssistFormatError, resolveBootstrapMaxChars, resolveBootstrapTotalMaxChars, validateAnthropicTurns, validateGeminiTurns, } from "../../pi-embedded-helpers.js";
 import { subscribeEmbeddedPiSession } from "../../pi-embedded-subscribe.js";
 import { ensurePiCompactionReserveTokens, resolveCompactionReserveTokensFloor, } from "../../pi-settings.js";
-import { createPoolbotCodingTools } from "../../pi-tools.js";
-import { repairSessionFileIfNeeded } from "../../session-file-repair.js";
+import { toClientToolDefinitions } from "../../pi-tool-definition-adapter.js";
+import { createPoolbotCodingTools, resolveToolLoopDetectionConfig } from "../../pi-tools.js";
 import { resolveSandboxContext } from "../../sandbox.js";
+import { resolveSandboxRuntimeStatus } from "../../sandbox/runtime-status.js";
+import { repairSessionFileIfNeeded } from "../../session-file-repair.js";
 import { guardSessionManager } from "../../session-tool-result-guard-wrapper.js";
-import { resolveTranscriptPolicy } from "../../transcript-policy.js";
-import { acquireSessionWriteLock } from "../../session-write-lock.js";
+import { sanitizeToolUseResultPairing } from "../../session-transcript-repair.js";
+import { acquireSessionWriteLock, resolveSessionLockMaxHoldFromTimeout, } from "../../session-write-lock.js";
+import { detectRuntimeShell } from "../../shell-utils.js";
 import { applySkillEnvOverrides, applySkillEnvOverridesFromSnapshot, loadWorkspaceSkillEntries, resolveSkillsPromptForRun, } from "../../skills.js";
-import { DEFAULT_BOOTSTRAP_FILENAME } from "../../workspace.js";
+import { buildSystemPromptParams } from "../../system-prompt-params.js";
 import { buildSystemPromptReport } from "../../system-prompt-report.js";
-import { resolveDefaultModelForAgent } from "../../model-selection.js";
-import { isAbortError } from "../abort.js";
+import { resolveTranscriptPolicy } from "../../transcript-policy.js";
+import { DEFAULT_BOOTSTRAP_FILENAME } from "../../workspace.js";
+import { isRunnerAbortError } from "../abort.js";
+import { appendCacheTtlTimestamp, isCacheTtlEligibleProvider } from "../cache-ttl.js";
 import { buildEmbeddedExtensionPaths } from "../extensions.js";
 import { applyExtraParamsToAgent } from "../extra-params.js";
-import { appendCacheTtlTimestamp, isCacheTtlEligibleProvider } from "../cache-ttl.js";
-import { logToolSchemasForGoogle, sanitizeSessionHistory, sanitizeToolsForGoogle, } from "../google.js";
+import { logToolSchemasForGoogle, sanitizeAntigravityThinkingBlocks, sanitizeSessionHistory, sanitizeToolsForGoogle, } from "../google.js";
 import { getDmHistoryLimitFromSessionKey, limitHistoryTurns } from "../history.js";
 import { log } from "../logger.js";
 import { buildModelAliasLines } from "../model.js";
@@ -46,25 +58,22 @@ import { buildEmbeddedSandboxInfo } from "../sandbox-info.js";
 import { prewarmSessionFile, trackSessionManagerAccess } from "../session-manager-cache.js";
 import { prepareSessionManagerForRun } from "../session-manager-init.js";
 import { applySystemPromptOverrideToSession, buildEmbeddedSystemPrompt, createSystemPromptOverride, } from "../system-prompt.js";
+import { installToolResultContextGuard } from "../tool-result-context-guard.js";
 import { splitSdkTools } from "../tool-split.js";
-import { toClientToolDefinitions } from "../../pi-tool-definition-adapter.js";
-import { buildSystemPromptParams } from "../../system-prompt-params.js";
-import { detectRuntimeShell } from "../../shell-utils.js";
 import { describeUnknownError, mapThinkingLevel } from "../utils.js";
-import { resolveSandboxRuntimeStatus } from "../../sandbox/runtime-status.js";
-import { buildTtsSystemPromptHint } from "../../../tts/tts.js";
-import { isTimeoutError } from "../../failover-error.js";
-import { getGlobalHookRunner } from "../../../plugins/hook-runner-global.js";
-import { MAX_IMAGE_BYTES } from "../../../media/constants.js";
+import { flushPendingToolResultsAfterIdle } from "../wait-for-idle-before-flush.js";
+import { selectCompactionTimeoutSnapshot, shouldFlagCompactionTimeout, } from "./compaction-timeout.js";
 import { detectAndLoadPromptImages } from "./images.js";
 export function injectHistoryImagesIntoMessages(messages, historyImagesByIndex) {
-    if (historyImagesByIndex.size === 0)
+    if (historyImagesByIndex.size === 0) {
         return false;
+    }
     let didMutate = false;
     for (const [msgIndex, images] of historyImagesByIndex) {
         // Bounds check: ensure index is valid before accessing
-        if (msgIndex < 0 || msgIndex >= messages.length)
+        if (msgIndex < 0 || msgIndex >= messages.length) {
             continue;
+        }
         const msg = messages[msgIndex];
         if (msg && msg.role === "user") {
             // Convert string content to array format if needed
@@ -92,6 +101,56 @@ export function injectHistoryImagesIntoMessages(messages, historyImagesByIndex)
     }
     return didMutate;
 }
+function summarizeMessagePayload(msg) {
+    const content = msg.content;
+    if (typeof content === "string") {
+        return { textChars: content.length, imageBlocks: 0 };
+    }
+    if (!Array.isArray(content)) {
+        return { textChars: 0, imageBlocks: 0 };
+    }
+    let textChars = 0;
+    let imageBlocks = 0;
+    for (const block of content) {
+        if (!block || typeof block !== "object") {
+            continue;
+        }
+        const typedBlock = block;
+        if (typedBlock.type === "image") {
+            imageBlocks++;
+            continue;
+        }
+        if (typeof typedBlock.text === "string") {
+            textChars += typedBlock.text.length;
+        }
+    }
+    return { textChars, imageBlocks };
+}
+function summarizeSessionContext(messages) {
+    const roleCounts = new Map();
+    let totalTextChars = 0;
+    let totalImageBlocks = 0;
+    let maxMessageTextChars = 0;
+    for (const msg of messages) {
+        const role = typeof msg.role === "string" ? msg.role : "unknown";
+        roleCounts.set(role, (roleCounts.get(role) ?? 0) + 1);
+        const payload = summarizeMessagePayload(msg);
+        totalTextChars += payload.textChars;
+        totalImageBlocks += payload.imageBlocks;
+        if (payload.textChars > maxMessageTextChars) {
+            maxMessageTextChars = payload.textChars;
+        }
+    }
+    return {
+        roleCounts: [...roleCounts.entries()]
+            .toSorted((a, b) => a[0].localeCompare(b[0]))
+            .map(([role, count]) => `${role}:${count}`)
+            .join(",") || "none",
+        totalTextChars,
+        totalImageBlocks,
+        maxMessageTextChars,
+    };
+}
 export async function runEmbeddedAttempt(params) {
     const resolvedWorkspace = resolveUserPath(params.workspaceDir);
     const prevCwd = process.cwd();
@@ -174,6 +233,7 @@ export async function runEmbeddedAttempt(params) {
                 abortSignal: runAbortController.signal,
                 modelProvider: params.model.provider,
                 modelId: params.modelId,
+                modelContextWindowTokens: params.model.contextWindow,
                 modelAuthMode: resolveModelAuthMode(params.model.provider, params.config),
                 currentChannelId: params.currentChannelId,
                 currentThreadTs: params.currentThreadTs,
@@ -200,8 +260,9 @@ export async function runEmbeddedAttempt(params) {
                 accountId: params.agentAccountId ?? undefined,
             });
             if (inlineButtonsScope !== "off") {
-                if (!runtimeCapabilities)
+                if (!runtimeCapabilities) {
                     runtimeCapabilities = [];
+                }
                 if (!runtimeCapabilities.some((cap) => String(cap).trim().toLowerCase() === "inlinebuttons")) {
                     runtimeCapabilities.push("inlineButtons");
                 }
@@ -265,14 +326,16 @@ export async function runEmbeddedAttempt(params) {
                 node: process.version,
                 model: `${params.provider}/${params.modelId}`,
                 defaultModel: defaultModelLabel,
+                shell: detectRuntimeShell(),
                 channel: runtimeChannel,
                 capabilities: runtimeCapabilities,
                 channelActions,
-                shell: detectRuntimeShell(),
             },
         });
         const isDefaultAgent = sessionAgentId === defaultAgentId;
-        const promptMode = isSubagentSessionKey(params.sessionKey) ? "minimal" : "full";
+        const promptMode = isSubagentSessionKey(params.sessionKey) || isCronSessionKey(params.sessionKey)
+            ? "minimal"
+            : "full";
         const docsPath = await resolvePoolbotDocsPath({
             workspaceDir: effectiveWorkspace,
             argv1: process.argv[1],
@@ -316,6 +379,7 @@ export async function runEmbeddedAttempt(params) {
             model: params.modelId,
             workspaceDir: effectiveWorkspace,
             bootstrapMaxChars: resolveBootstrapMaxChars(params.config),
+            bootstrapTotalMaxChars: resolveBootstrapTotalMaxChars(params.config),
             sandbox: (() => {
                 const runtime = resolveSandboxRuntimeStatus({
                     cfg: params.config,
@@ -333,9 +397,13 @@ export async function runEmbeddedAttempt(params) {
         const systemPromptText = systemPromptOverride();
         const sessionLock = await acquireSessionWriteLock({
             sessionFile: params.sessionFile,
+            maxHoldMs: resolveSessionLockMaxHoldFromTimeout({
+                timeoutMs: params.timeoutMs,
+            }),
         });
         let sessionManager;
         let session;
+        let removeToolResultContextGuard;
         try {
             await repairSessionFileIfNeeded({
                 sessionFile: params.sessionFile,
@@ -354,6 +422,7 @@ export async function runEmbeddedAttempt(params) {
             sessionManager = guardSessionManager(SessionManager.open(params.sessionFile), {
                 agentId: sessionAgentId,
                 sessionKey: params.sessionKey,
+                inputProvenance: params.inputProvenance,
                 allowSyntheticToolResults: transcriptPolicy.allowSyntheticToolResults,
             });
             trackSessionManagerAccess(params.sessionFile);
@@ -369,6 +438,7 @@ export async function runEmbeddedAttempt(params) {
                 settingsManager,
                 minReserveTokens: resolveCompactionReserveTokensFloor(params.config),
             });
+            // Call for side effects (sets compaction/pruning runtime state)
             buildEmbeddedExtensionPaths({
                 cfg: params.config,
                 sessionManager,
@@ -376,16 +446,26 @@ export async function runEmbeddedAttempt(params) {
                 modelId: params.modelId,
                 model: params.model,
             });
+            // Get hook runner early so it's available when creating tools
+            const hookRunner = getGlobalHookRunner();
             const { builtInTools, customTools } = splitSdkTools({
                 tools,
                 sandboxEnabled: !!sandbox?.enabled,
             });
             // Add client tools (OpenResponses hosted tools) to customTools
             let clientToolCallDetected = null;
+            const clientToolLoopDetection = resolveToolLoopDetectionConfig({
+                cfg: params.config,
+                agentId: sessionAgentId,
+            });
             const clientToolDefs = params.clientTools
                 ? toClientToolDefinitions(params.clientTools, (toolName, toolParams) => {
                     clientToolCallDetected = { name: toolName, params: toolParams };
-                }, { agentId: sessionAgentId, sessionKey: params.sessionKey })
+                }, {
+                    agentId: sessionAgentId,
+                    sessionKey: params.sessionKey,
+                    loopDetection: clientToolLoopDetection,
+                })
                 : [];
             const allCustomTools = [...customTools, ...clientToolDefs];
             ({ session } = await createAgentSession({
@@ -405,6 +485,10 @@ export async function runEmbeddedAttempt(params) {
                 throw new Error("Embedded agent session missing");
             }
             const activeSession = session;
+            removeToolResultContextGuard = installToolResultContextGuard({
+                agent: activeSession.agent,
+                contextWindowTokens: Math.max(1, Math.floor(params.model.contextWindow ?? params.model.maxTokens ?? DEFAULT_CONTEXT_TOKENS)),
+            });
             const cacheTrace = createCacheTrace({
                 cfg: params.config,
                 env: process.env,
@@ -426,8 +510,20 @@ export async function runEmbeddedAttempt(params) {
                 modelApi: params.model.api,
                 workspaceDir: params.workspaceDir,
             });
-            // Force a stable streamFn reference so vitest can reliably mock @mariozechner/pi-ai.
-            activeSession.agent.streamFn = streamSimple;
+            // Ollama native API: bypass SDK's streamSimple and use direct /api/chat calls
+            // for reliable streaming + tool calling support (#11828).
+            if (params.model.api === "ollama") {
+                // Use the resolved model baseUrl first so custom provider aliases work.
+                const providerConfig = params.config?.models?.providers?.[params.model.provider];
+                const modelBaseUrl = typeof params.model.baseUrl === "string" ? params.model.baseUrl.trim() : "";
+                const providerBaseUrl = typeof providerConfig?.baseUrl === "string" ? providerConfig.baseUrl.trim() : "";
+                const ollamaBaseUrl = modelBaseUrl || providerBaseUrl || OLLAMA_NATIVE_BASE_URL;
+                activeSession.agent.streamFn = createOllamaStreamFn(ollamaBaseUrl);
+            }
+            else {
+                // Force a stable streamFn reference so vitest can reliably mock @mariozechner/pi-ai.
+                activeSession.agent.streamFn = streamSimple;
+            }
             applyExtraParamsToAgent(activeSession.agent, params.config, params.provider, params.modelId, params.streamParams);
             if (cacheTrace) {
                 cacheTrace.recordStage("session:loaded", {
@@ -446,6 +542,7 @@ export async function runEmbeddedAttempt(params) {
                     modelApi: params.model.api,
                     modelId: params.modelId,
                     provider: params.provider,
+                    config: params.config,
                     sessionManager,
                     sessionId: params.sessionId,
                     policy: transcriptPolicy,
@@ -457,19 +554,29 @@ export async function runEmbeddedAttempt(params) {
                 const validated = transcriptPolicy.validateAnthropicTurns
                     ? validateAnthropicTurns(validatedGemini)
                     : validatedGemini;
-                const limited = limitHistoryTurns(validated, getDmHistoryLimitFromSessionKey(params.sessionKey, params.config));
+                const truncated = limitHistoryTurns(validated, getDmHistoryLimitFromSessionKey(params.sessionKey, params.config));
+                // Re-run tool_use/tool_result pairing repair after truncation, since
+                // limitHistoryTurns can orphan tool_result blocks by removing the
+                // assistant message that contained the matching tool_use.
+                const limited = transcriptPolicy.repairToolUseResultPairing
+                    ? sanitizeToolUseResultPairing(truncated)
+                    : truncated;
                 cacheTrace?.recordStage("session:limited", { messages: limited });
                 if (limited.length > 0) {
                     activeSession.agent.replaceMessages(limited);
                 }
             }
             catch (err) {
-                sessionManager.flushPendingToolResults?.();
+                await flushPendingToolResultsAfterIdle({
+                    agent: activeSession?.agent,
+                    sessionManager,
+                });
                 activeSession.dispose();
                 throw err;
             }
             let aborted = Boolean(params.abortSignal?.aborted);
             let timedOut = false;
+            let timedOutDuringCompaction = false;
             const getAbortReason = (signal) => "reason" in signal ? signal.reason : undefined;
             const makeTimeoutAbortReason = () => {
                 const err = new Error("request timed out");
@@ -484,8 +591,9 @@ export async function runEmbeddedAttempt(params) {
             };
             const abortRun = (isTimeout = false, reason) => {
                 aborted = true;
-                if (isTimeout)
+                if (isTimeout) {
                     timedOut = true;
+                }
                 if (isTimeout) {
                     runAbortController.abort(reason ?? makeTimeoutAbortReason());
                 }
@@ -517,6 +625,7 @@ export async function runEmbeddedAttempt(params) {
             const subscription = subscribeEmbeddedPiSession({
                 session: activeSession,
                 runId: params.runId,
+                hookRunner: getGlobalHookRunner() ?? undefined,
                 verboseLevel: params.verboseLevel,
                 reasoningMode: params.reasoningLevel ?? "off",
                 toolResultFormat: params.toolResultFormat,
@@ -524,6 +633,7 @@ export async function runEmbeddedAttempt(params) {
                 shouldEmitToolOutput: params.shouldEmitToolOutput,
                 onToolResult: params.onToolResult,
                 onReasoningStream: params.onReasoningStream,
+                onReasoningEnd: params.onReasoningEnd,
                 onBlockReply: params.onBlockReply,
                 onBlockReplyFlush: params.onBlockReplyFlush,
                 blockReplyBreak: params.blockReplyBreak,
@@ -532,8 +642,10 @@ export async function runEmbeddedAttempt(params) {
                 onAssistantMessageStart: params.onAssistantMessageStart,
                 onAgentEvent: params.onAgentEvent,
                 enforceFinalTag: params.enforceFinalTag,
+                config: params.config,
+                sessionKey: params.sessionKey ?? params.sessionId,
             });
-            const { assistantTexts, toolMetas, unsubscribe, waitForCompactionRetry, getMessagingToolSentTexts, getMessagingToolSentTargets, didSendViaMessagingTool, getLastToolError, } = subscription;
+            const { assistantTexts, toolMetas, unsubscribe, waitForCompactionRetry, getMessagingToolSentTexts, getMessagingToolSentMediaUrls, getMessagingToolSentTargets, getSuccessfulCronAdds, didSendViaMessagingTool, getLastToolError, getUsageTotals, getCompactionCount, } = subscription;
             const queueHandle = {
                 queueMessage: async (text) => {
                     await activeSession.steer(text);
@@ -542,18 +654,26 @@ export async function runEmbeddedAttempt(params) {
                 isCompacting: () => subscription.isCompacting(),
                 abort: abortRun,
             };
-            setActiveEmbeddedRun(params.sessionId, queueHandle);
+            setActiveEmbeddedRun(params.sessionId, queueHandle, params.sessionKey);
             let abortWarnTimer;
             const isProbeSession = params.sessionId?.startsWith("probe-") ?? false;
             const abortTimer = setTimeout(() => {
                 if (!isProbeSession) {
                     log.warn(`embedded run timeout: runId=${params.runId} sessionId=${params.sessionId} timeoutMs=${params.timeoutMs}`);
                 }
+                if (shouldFlagCompactionTimeout({
+                    isTimeout: true,
+                    isCompactionPendingOrRetrying: subscription.isCompacting(),
+                    isCompactionInFlight: activeSession.isCompacting,
+                })) {
+                    timedOutDuringCompaction = true;
+                }
                 abortRun(true);
                 if (!abortWarnTimer) {
                     abortWarnTimer = setTimeout(() => {
-                        if (!activeSession.isStreaming)
+                        if (!activeSession.isStreaming) {
                             return;
+                        }
                         if (!isProbeSession) {
                             log.warn(`embedded run abort still streaming: runId=${params.runId} sessionId=${params.sessionId}`);
                         }
@@ -565,6 +685,13 @@ export async function runEmbeddedAttempt(params) {
             const onAbort = () => {
                 const reason = params.abortSignal ? getAbortReason(params.abortSignal) : undefined;
                 const timeout = reason ? isTimeoutError(reason) : false;
+                if (shouldFlagCompactionTimeout({
+                    isTimeout: timeout,
+                    isCompactionPendingOrRetrying: subscription.isCompacting(),
+                    isCompactionInFlight: activeSession.isCompacting,
+                })) {
+                    timedOutDuringCompaction = true;
+                }
                 abortRun(timeout, reason);
             };
             if (params.abortSignal) {
@@ -577,32 +704,59 @@ export async function runEmbeddedAttempt(params) {
                     });
                 }
             }
-            // Get hook runner once for both before_agent_start and agent_end hooks
-            const hookRunner = getGlobalHookRunner();
-            const hookAgentId = sessionAgentId;
+            // Hook runner was already obtained earlier before tool creation
+            const hookAgentId = typeof params.agentId === "string" && params.agentId.trim()
+                ? normalizeAgentId(params.agentId)
+                : resolveSessionAgentIds({
+                    sessionKey: params.sessionKey,
+                    config: params.config,
+                }).sessionAgentId;
             let promptError = null;
+            let promptErrorSource = null;
             try {
                 const promptStartedAt = Date.now();
-                // Run before_agent_start hooks to allow plugins to inject context
+                // Run before_prompt_build hooks to allow plugins to inject prompt context.
+                // Legacy compatibility: before_agent_start is also checked for context fields.
                 let effectivePrompt = params.prompt;
-                if (hookRunner?.hasHooks("before_agent_start")) {
-                    try {
-                        const hookResult = await hookRunner.runBeforeAgentStart({
-                            prompt: params.prompt,
-                            messages: activeSession.messages,
-                        }, {
-                            agentId: hookAgentId,
-                            sessionKey: params.sessionKey,
-                            workspaceDir: params.workspaceDir,
-                            messageProvider: params.messageProvider ?? undefined,
-                        });
-                        if (hookResult?.prependContext) {
-                            effectivePrompt = `${hookResult.prependContext}\n\n${params.prompt}`;
-                            log.debug(`hooks: prepended context to prompt (${hookResult.prependContext.length} chars)`);
-                        }
-                    }
-                    catch (hookErr) {
-                        log.warn(`before_agent_start hook failed: ${String(hookErr)}`);
+                const hookCtx = {
+                    agentId: hookAgentId,
+                    sessionKey: params.sessionKey,
+                    sessionId: params.sessionId,
+                    workspaceDir: params.workspaceDir,
+                    messageProvider: params.messageProvider ?? undefined,
+                };
+                const promptBuildResult = hookRunner?.hasHooks("before_prompt_build")
+                    ? await hookRunner
+                        .runBeforePromptBuild({
+                        prompt: params.prompt,
+                        messages: activeSession.messages,
+                    }, hookCtx)
+                        .catch((hookErr) => {
+                        log.warn(`before_prompt_build hook failed: ${String(hookErr)}`);
+                        return undefined;
+                    })
+                    : undefined;
+                const legacyResult = hookRunner?.hasHooks("before_agent_start")
+                    ? await hookRunner
+                        .runBeforeAgentStart({
+                        prompt: params.prompt,
+                        messages: activeSession.messages,
+                    }, hookCtx)
+                        .catch((hookErr) => {
+                        log.warn(`before_agent_start hook (legacy prompt build path) failed: ${String(hookErr)}`);
+                        return undefined;
+                    })
+                    : undefined;
+                const hookResult = {
+                    systemPrompt: promptBuildResult?.systemPrompt ?? legacyResult?.systemPrompt,
+                    prependContext: [promptBuildResult?.prependContext, legacyResult?.prependContext]
+                        .filter((value) => Boolean(value))
+                        .join("\n\n"),
+                };
+                {
+                    if (hookResult?.prependContext) {
+                        effectivePrompt = `${hookResult.prependContext}\n\n${params.prompt}`;
+                        log.debug(`hooks: prepended context to prompt (${hookResult.prependContext.length} chars)`);
                     }
                 }
                 log.debug(`embedded run prompt start: runId=${params.runId} sessionId=${params.sessionId}`);
@@ -620,7 +774,10 @@ export async function runEmbeddedAttempt(params) {
                         sessionManager.resetLeaf();
                     }
                     const sessionContext = sessionManager.buildSessionContext();
-                    activeSession.agent.replaceMessages(sessionContext.messages);
+                    const sanitizedOrphan = transcriptPolicy.normalizeAntigravityThinkingBlocks
+                        ? sanitizeAntigravityThinkingBlocks(sessionContext.messages)
+                        : sessionContext.messages;
+                    activeSession.agent.replaceMessages(sanitizedOrphan);
                     log.warn(`Removed orphaned user message to prevent consecutive user turns. ` +
                         `runId=${params.runId} sessionId=${params.sessionId}`);
                 }
@@ -636,8 +793,11 @@ export async function runEmbeddedAttempt(params) {
                         existingImages: params.images,
                         historyMessages: activeSession.messages,
                         maxBytes: MAX_IMAGE_BYTES,
+                        maxDimensionPx: resolveImageSanitizationLimits(params.config).maxDimensionPx,
                         // Enforce sandbox path restrictions when sandbox is enabled
-                        sandboxRoot: sandbox?.enabled ? sandbox.workspaceDir : undefined,
+                        sandbox: sandbox?.enabled && sandbox?.fsBridge
+                            ? { root: sandbox.workspaceDir, bridge: sandbox.fsBridge }
+                            : undefined,
                     });
                     // Inject history images into their original message positions.
                     // This ensures the model sees images in context (e.g., "compare to the first image").
@@ -651,13 +811,42 @@ export async function runEmbeddedAttempt(params) {
                         messages: activeSession.messages,
                         note: `images: prompt=${imageResult.images.length} history=${imageResult.historyImagesByIndex.size}`,
                     });
-                    const shouldTrackCacheTtl = params.config?.agents?.defaults?.contextPruning?.mode === "cache-ttl" &&
-                        isCacheTtlEligibleProvider(params.provider, params.modelId);
-                    if (shouldTrackCacheTtl) {
-                        appendCacheTtlTimestamp(sessionManager, {
-                            timestamp: Date.now(),
+                    // Diagnostic: log context sizes before prompt to help debug early overflow errors.
+                    if (log.isEnabled("debug")) {
+                        const msgCount = activeSession.messages.length;
+                        const systemLen = systemPromptText?.length ?? 0;
+                        const promptLen = effectivePrompt.length;
+                        const sessionSummary = summarizeSessionContext(activeSession.messages);
+                        log.debug(`[context-diag] pre-prompt: sessionKey=${params.sessionKey ?? params.sessionId} ` +
+                            `messages=${msgCount} roleCounts=${sessionSummary.roleCounts} ` +
+                            `historyTextChars=${sessionSummary.totalTextChars} ` +
+                            `maxMessageTextChars=${sessionSummary.maxMessageTextChars} ` +
+                            `historyImageBlocks=${sessionSummary.totalImageBlocks} ` +
+                            `systemPromptChars=${systemLen} promptChars=${promptLen} ` +
+                            `promptImages=${imageResult.images.length} ` +
+                            `historyImageMessages=${imageResult.historyImagesByIndex.size} ` +
+                            `provider=${params.provider}/${params.modelId} sessionFile=${params.sessionFile}`);
+                    }
+                    if (hookRunner?.hasHooks("llm_input")) {
+                        hookRunner
+                            .runLlmInput({
+                            runId: params.runId,
+                            sessionId: params.sessionId,
                             provider: params.provider,
-                            modelId: params.modelId,
+                            model: params.modelId,
+                            systemPrompt: systemPromptText,
+                            prompt: effectivePrompt,
+                            historyMessages: activeSession.messages,
+                            imagesCount: imageResult.images.length,
+                        }, {
+                            agentId: hookAgentId,
+                            sessionKey: params.sessionKey,
+                            sessionId: params.sessionId,
+                            workspaceDir: params.workspaceDir,
+                            messageProvider: params.messageProvider ?? undefined,
+                        })
+                            .catch((err) => {
+                            log.warn(`llm_input hook failed: ${String(err)}`);
                         });
                     }
                     // Only pass images option if there are actually images to pass
@@ -671,31 +860,98 @@ export async function runEmbeddedAttempt(params) {
                 }
                 catch (err) {
                     promptError = err;
+                    promptErrorSource = "prompt";
                 }
                 finally {
                     log.debug(`embedded run prompt end: runId=${params.runId} sessionId=${params.sessionId} durationMs=${Date.now() - promptStartedAt}`);
                 }
+                // Capture snapshot before compaction wait so we have complete messages if timeout occurs
+                // Check compaction state before and after to avoid race condition where compaction starts during capture
+                // Use session state (not subscription) for snapshot decisions - need instantaneous compaction status
+                const wasCompactingBefore = activeSession.isCompacting;
+                const snapshot = activeSession.messages.slice();
+                const wasCompactingAfter = activeSession.isCompacting;
+                // Only trust snapshot if compaction wasn't running before or after capture
+                const preCompactionSnapshot = wasCompactingBefore || wasCompactingAfter ? null : snapshot;
+                const preCompactionSessionId = activeSession.sessionId;
                 try {
-                    await waitForCompactionRetry();
+                    await abortable(waitForCompactionRetry());
                 }
                 catch (err) {
-                    if (isAbortError(err)) {
-                        if (!promptError)
+                    if (isRunnerAbortError(err)) {
+                        if (!promptError) {
                             promptError = err;
+                            promptErrorSource = "compaction";
+                        }
+                        if (!isProbeSession) {
+                            log.debug(`compaction wait aborted: runId=${params.runId} sessionId=${params.sessionId}`);
+                        }
                     }
                     else {
                         throw err;
                     }
                 }
-                messagesSnapshot = activeSession.messages.slice();
-                sessionIdUsed = activeSession.sessionId;
+                // Append cache-TTL timestamp AFTER prompt + compaction retry completes.
+                // Previously this was before the prompt, which caused a custom entry to be
+                // inserted between compaction and the next prompt — breaking the
+                // prepareCompaction() guard that checks the last entry type, leading to
+                // double-compaction. See: https://github.com/poolbot/poolbot/issues/9282
+                // Skip when timed out during compaction — session state may be inconsistent.
+                if (!timedOutDuringCompaction) {
+                    const shouldTrackCacheTtl = params.config?.agents?.defaults?.contextPruning?.mode === "cache-ttl" &&
+                        isCacheTtlEligibleProvider(params.provider, params.modelId);
+                    if (shouldTrackCacheTtl) {
+                        appendCacheTtlTimestamp(sessionManager, {
+                            timestamp: Date.now(),
+                            provider: params.provider,
+                            modelId: params.modelId,
+                        });
+                    }
+                }
+                // If timeout occurred during compaction, use pre-compaction snapshot when available
+                // (compaction restructures messages but does not add user/assistant turns).
+                const snapshotSelection = selectCompactionTimeoutSnapshot({
+                    timedOutDuringCompaction,
+                    preCompactionSnapshot,
+                    preCompactionSessionId,
+                    currentSnapshot: activeSession.messages.slice(),
+                    currentSessionId: activeSession.sessionId,
+                });
+                if (timedOutDuringCompaction) {
+                    if (!isProbeSession) {
+                        log.warn(`using ${snapshotSelection.source} snapshot: timed out during compaction runId=${params.runId} sessionId=${params.sessionId}`);
+                    }
+                }
+                messagesSnapshot = snapshotSelection.messagesSnapshot;
+                sessionIdUsed = snapshotSelection.sessionIdUsed;
+                if (promptError && promptErrorSource === "prompt") {
+                    try {
+                        sessionManager.appendCustomEntry("poolbot:prompt-error", {
+                            timestamp: Date.now(),
+                            runId: params.runId,
+                            sessionId: params.sessionId,
+                            provider: params.provider,
+                            model: params.modelId,
+                            api: params.model.api,
+                            error: describeUnknownError(promptError),
+                        });
+                    }
+                    catch (entryErr) {
+                        log.warn(`failed to persist prompt error entry: ${String(entryErr)}`);
+                    }
+                }
                 cacheTrace?.recordStage("session:after", {
                     messages: messagesSnapshot,
-                    note: promptError ? "prompt error" : undefined,
+                    note: timedOutDuringCompaction
+                        ? "compaction timeout"
+                        : promptError
+                            ? "prompt error"
+                            : undefined,
                 });
                 anthropicPayloadLogger?.recordUsage(messagesSnapshot, promptError);
                 // Run agent_end hooks to allow plugins to analyze the conversation
                 // This is fire-and-forget, so we don't await
+                // Run even on compaction timeout so plugins can log/cleanup
                 if (hookRunner?.hasHooks("agent_end")) {
                     hookRunner
                         .runAgentEnd({
@@ -706,6 +962,7 @@ export async function runEmbeddedAttempt(params) {
                     }, {
                         agentId: hookAgentId,
                         sessionKey: params.sessionKey,
+                        sessionId: params.sessionId,
                         workspaceDir: params.workspaceDir,
                         messageProvider: params.messageProvider ?? undefined,
                     })
@@ -716,22 +973,56 @@ export async function runEmbeddedAttempt(params) {
             }
             finally {
                 clearTimeout(abortTimer);
-                if (abortWarnTimer)
+                if (abortWarnTimer) {
                     clearTimeout(abortWarnTimer);
-                unsubscribe();
-                clearActiveEmbeddedRun(params.sessionId, queueHandle);
+                }
+                if (!isProbeSession && (aborted || timedOut) && !timedOutDuringCompaction) {
+                    log.debug(`run cleanup: runId=${params.runId} sessionId=${params.sessionId} aborted=${aborted} timedOut=${timedOut}`);
+                }
+                try {
+                    unsubscribe();
+                }
+                catch (err) {
+                    // unsubscribe() should never throw; if it does, it indicates a serious bug.
+                    // Log at error level to ensure visibility, but don't rethrow in finally block
+                    // as it would mask any exception from the try block above.
+                    log.error(`CRITICAL: unsubscribe failed, possible resource leak: runId=${params.runId} ${String(err)}`);
+                }
+                clearActiveEmbeddedRun(params.sessionId, queueHandle, params.sessionKey);
                 params.abortSignal?.removeEventListener?.("abort", onAbort);
             }
             const lastAssistant = messagesSnapshot
                 .slice()
-                .reverse()
-                .find((m) => m?.role === "assistant");
+                .toReversed()
+                .find((m) => m.role === "assistant");
             const toolMetasNormalized = toolMetas
                 .filter((entry) => typeof entry.toolName === "string" && entry.toolName.trim().length > 0)
                 .map((entry) => ({ toolName: entry.toolName, meta: entry.meta }));
+            if (hookRunner?.hasHooks("llm_output")) {
+                hookRunner
+                    .runLlmOutput({
+                    runId: params.runId,
+                    sessionId: params.sessionId,
+                    provider: params.provider,
+                    model: params.modelId,
+                    assistantTexts,
+                    lastAssistant,
+                    usage: getUsageTotals(),
+                }, {
+                    agentId: hookAgentId,
+                    sessionKey: params.sessionKey,
+                    sessionId: params.sessionId,
+                    workspaceDir: params.workspaceDir,
+                    messageProvider: params.messageProvider ?? undefined,
+                })
+                    .catch((err) => {
+                    log.warn(`llm_output hook failed: ${String(err)}`);
+                });
+            }
             return {
                 aborted,
                 timedOut,
+                timedOutDuringCompaction,
                 promptError,
                 sessionIdUsed,
                 systemPromptReport,
@@ -742,15 +1033,30 @@ export async function runEmbeddedAttempt(params) {
                 lastToolError: getLastToolError?.(),
                 didSendViaMessagingTool: didSendViaMessagingTool(),
                 messagingToolSentTexts: getMessagingToolSentTexts(),
+                messagingToolSentMediaUrls: getMessagingToolSentMediaUrls(),
                 messagingToolSentTargets: getMessagingToolSentTargets(),
+                successfulCronAdds: getSuccessfulCronAdds(),
                 cloudCodeAssistFormatError: Boolean(lastAssistant?.errorMessage && isCloudCodeAssistFormatError(lastAssistant.errorMessage)),
+                attemptUsage: getUsageTotals(),
+                compactionCount: getCompactionCount(),
                 // Client tool call detected (OpenResponses hosted tools)
                 clientToolCall: clientToolCallDetected ?? undefined,
             };
         }
         finally {
             // Always tear down the session (and release the lock) before we leave this attempt.
-            sessionManager?.flushPendingToolResults?.();
+            //
+            // BUGFIX: Wait for the agent to be truly idle before flushing pending tool results.
+            // pi-agent-core's auto-retry resolves waitForRetry() on assistant message receipt,
+            // *before* tool execution completes in the retried agent loop. Without this wait,
+            // flushPendingToolResults() fires while tools are still executing, inserting
+            // synthetic "missing tool result" errors and causing silent agent failures.
+            // See: https://github.com/poolbot/poolbot/issues/8643
+            removeToolResultContextGuard?.();
+            await flushPendingToolResultsAfterIdle({
+                agent: session?.agent,
+                sessionManager,
+            });
             session?.dispose();
             await sessionLock.release();
         }