@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/agents/pi-embedded-runner/extensions.js

@@ -1,20 +1,13 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { resolveContextWindowInfo } from "../context-window-guard.js";
 import { DEFAULT_CONTEXT_TOKENS } from "../defaults.js";
 import { setCompactionSafeguardRuntime } from "../pi-extensions/compaction-safeguard-runtime.js";
+import compactionSafeguardExtension from "../pi-extensions/compaction-safeguard.js";
+import contextPruningExtension from "../pi-extensions/context-pruning.js";
 import { setContextPruningRuntime } from "../pi-extensions/context-pruning/runtime.js";
 import { computeEffectiveSettings } from "../pi-extensions/context-pruning/settings.js";
 import { makeToolPrunablePredicate } from "../pi-extensions/context-pruning/tools.js";
 import { ensurePiCompactionReserveTokens } from "../pi-settings.js";
 import { isCacheTtlEligibleProvider, readLastCacheTtlTimestamp } from "./cache-ttl.js";
-function resolvePiExtensionPath(id) {
-    const self = fileURLToPath(import.meta.url);
-    const dir = path.dirname(self);
-    // In dev this file is `.ts` (tsx), in production it's `.js`.
-    const ext = path.extname(self) === ".ts" ? "ts" : "js";
-    return path.join(dir, "..", "pi-extensions", `${id}.${ext}`);
-}
 function resolveContextWindowTokens(params) {
     return resolveContextWindowInfo({
         cfg: params.cfg,
@@ -24,41 +17,50 @@ function resolveContextWindowTokens(params) {
         defaultTokens: DEFAULT_CONTEXT_TOKENS,
     }).tokens;
 }
-function buildContextPruningExtension(params) {
+function buildContextPruningFactory(params) {
     const raw = params.cfg?.agents?.defaults?.contextPruning;
-    if (raw?.mode !== "cache-ttl")
-        return {};
-    if (!isCacheTtlEligibleProvider(params.provider, params.modelId))
-        return {};
+    if (raw?.mode !== "cache-ttl") {
+        return undefined;
+    }
+    if (!isCacheTtlEligibleProvider(params.provider, params.modelId)) {
+        return undefined;
+    }
     const settings = computeEffectiveSettings(raw);
-    if (!settings)
-        return {};
+    if (!settings) {
+        return undefined;
+    }
     setContextPruningRuntime(params.sessionManager, {
         settings,
         contextWindowTokens: resolveContextWindowTokens(params),
         isToolPrunable: makeToolPrunablePredicate(settings.tools),
         lastCacheTouchAt: readLastCacheTtlTimestamp(params.sessionManager),
     });
-    return {
-        additionalExtensionPaths: [resolvePiExtensionPath("context-pruning")],
-    };
+    return contextPruningExtension;
 }
 function resolveCompactionMode(cfg) {
     return cfg?.agents?.defaults?.compaction?.mode === "safeguard" ? "safeguard" : "default";
 }
-export function buildEmbeddedExtensionPaths(params) {
-    const paths = [];
+export function buildEmbeddedExtensionFactories(params) {
+    const factories = [];
     if (resolveCompactionMode(params.cfg) === "safeguard") {
         const compactionCfg = params.cfg?.agents?.defaults?.compaction;
+        const contextWindowInfo = resolveContextWindowInfo({
+            cfg: params.cfg,
+            provider: params.provider,
+            modelId: params.modelId,
+            modelContextWindow: params.model?.contextWindow,
+            defaultTokens: DEFAULT_CONTEXT_TOKENS,
+        });
         setCompactionSafeguardRuntime(params.sessionManager, {
             maxHistoryShare: compactionCfg?.maxHistoryShare,
+            contextWindowTokens: contextWindowInfo.tokens,
         });
-        paths.push(resolvePiExtensionPath("compaction-safeguard"));
+        factories.push(compactionSafeguardExtension);
     }
-    const pruning = buildContextPruningExtension(params);
-    if (pruning.additionalExtensionPaths) {
-        paths.push(...pruning.additionalExtensionPaths);
+    const pruningFactory = buildContextPruningFactory(params);
+    if (pruningFactory) {
+        factories.push(pruningFactory);
     }
-    return paths;
+    return factories;
 }
 export { ensurePiCompactionReserveTokens };

package/dist/agents/pi-embedded-runner/google.js

@@ -7,6 +7,7 @@ import { cleanToolSchemaForGemini } from "../pi-tools.schema.js";
 import { sanitizeToolCallInputs, stripToolResultDetails, sanitizeToolUseResultPairing, } from "../session-transcript-repair.js";
 import { resolveTranscriptPolicy } from "../transcript-policy.js";
 import { log } from "./logger.js";
+import { dropThinkingBlocks } from "./thinking.js";
 import { describeUnknownError } from "./utils.js";
 const GOOGLE_TURN_ORDERING_CUSTOM_TYPE = "google-turn-ordering-bootstrap";
 const GOOGLE_SCHEMA_UNSUPPORTED_KEYWORDS = new Set([
@@ -71,6 +72,12 @@ export function sanitizeAntigravityThinkingBlocks(messages) {
             const rec = block;
             const candidate = rec.thinkingSignature ?? rec.signature ?? rec.thought_signature ?? rec.thoughtSignature;
             if (!isValidAntigravitySignature(candidate)) {
+                // Preserve reasoning content as plain text when signatures are invalid/missing.
+                // Antigravity Claude rejects unsigned thinking blocks, but dropping them loses context.
+                const thinkingText = block.thinking;
+                if (typeof thinkingText === "string" && thinkingText.trim()) {
+                    nextContent.push({ type: "text", text: thinkingText });
+                }
                 contentChanged = true;
                 continue;
             }
@@ -199,11 +206,11 @@ function findUnsupportedSchemaKeywords(schema, path) {
     return violations;
 }
 export function sanitizeToolsForGoogle(params) {
-    // google-antigravity serves Anthropic models (e.g. claude-opus-4-6-thinking),
-    // NOT Gemini. Applying Gemini schema cleaning strips JSON Schema keywords
-    // (minimum, maximum, format, etc.) that Anthropic's API requires for
-    // draft 2020-12 compliance. Only clean for actual Gemini providers.
-    if (params.provider !== "google-gemini-cli") {
+    // Cloud Code Assist uses the OpenAPI 3.03 `parameters` field for both Gemini
+    // AND Claude models.  This field does not support JSON Schema keywords such as
+    // patternProperties, additionalProperties, $ref, etc.  We must clean schemas
+    // for every provider that routes through this path.
+    if (params.provider !== "google-gemini-cli" && params.provider !== "google-antigravity") {
         return params.tools;
     }
     return params.tools.map((tool) => {
@@ -350,10 +357,15 @@ export async function sanitizeSessionHistory(params) {
         sanitizeThoughtSignatures: policy.sanitizeThoughtSignatures,
         ...resolveImageSanitizationLimits(params.config),
     });
-    const sanitizedThinking = policy.normalizeAntigravityThinkingBlocks
-        ? sanitizeAntigravityThinkingBlocks(sanitizedImages)
+    const droppedThinking = policy.dropThinkingBlocks
+        ? dropThinkingBlocks(sanitizedImages)
         : sanitizedImages;
-    const sanitizedToolCalls = sanitizeToolCallInputs(sanitizedThinking);
+    const sanitizedThinking = policy.sanitizeThinkingSignatures
+        ? sanitizeAntigravityThinkingBlocks(droppedThinking)
+        : droppedThinking;
+    const sanitizedToolCalls = sanitizeToolCallInputs(sanitizedThinking, {
+        allowedToolNames: params.allowedToolNames,
+    });
     const repairedTools = policy.repairToolUseResultPairing
         ? sanitizeToolUseResultPairing(sanitizedToolCalls)
         : sanitizedToolCalls;

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

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import { streamSimple } from "@mariozechner/pi-ai";
-import { createAgentSession, SessionManager, SettingsManager } from "@mariozechner/pi-coding-agent";
+import { createAgentSession, DefaultResourceLoader, SessionManager, SettingsManager, } from "@mariozechner/pi-coding-agent";
 import { resolveHeartbeatPrompt } from "../../../auto-reply/heartbeat.js";
 import { resolveChannelCapabilities } from "../../../config/channel-capabilities.js";
 import { getMachineDisplayName } from "../../../infra/machine-name.js";
@@ -30,7 +30,7 @@ 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 { applyPiCompactionSettingsFromConfig } from "../../pi-settings.js";
 import { toClientToolDefinitions } from "../../pi-tool-definition-adapter.js";
 import { createPoolbotCodingTools, resolveToolLoopDetectionConfig } from "../../pi-tools.js";
 import { resolveSandboxContext } from "../../sandbox.js";
@@ -47,7 +47,7 @@ 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 { buildEmbeddedExtensionFactories } from "../extensions.js";
 import { applyExtraParamsToAgent } from "../extra-params.js";
 import { logToolSchemasForGoogle, sanitizeAntigravityThinkingBlocks, sanitizeSessionHistory, sanitizeToolsForGoogle, } from "../google.js";
 import { getDmHistoryLimitFromSessionKey, limitHistoryTurns } from "../history.js";
@@ -58,6 +58,8 @@ 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 { dropThinkingBlocks } from "../thinking.js";
+import { collectAllowedToolNames } from "../tool-name-allowlist.js";
 import { installToolResultContextGuard } from "../tool-result-context-guard.js";
 import { splitSdkTools } from "../tool-split.js";
 import { describeUnknownError, mapThinkingLevel } from "../utils.js";
@@ -101,6 +103,37 @@ export function injectHistoryImagesIntoMessages(messages, historyImagesByIndex)
     }
     return didMutate;
 }
+export async function resolvePromptBuildHookResult(params) {
+    const promptBuildResult = params.hookRunner?.hasHooks("before_prompt_build")
+        ? await params.hookRunner
+            .runBeforePromptBuild({
+            prompt: params.prompt,
+            messages: params.messages,
+        }, params.hookCtx)
+            .catch((hookErr) => {
+            log.warn(`before_prompt_build hook failed: ${String(hookErr)}`);
+            return undefined;
+        })
+        : undefined;
+    const legacyResult = params.legacyBeforeAgentStartResult ??
+        (params.hookRunner?.hasHooks("before_agent_start")
+            ? await params.hookRunner
+                .runBeforeAgentStart({
+                prompt: params.prompt,
+                messages: params.messages,
+            }, params.hookCtx)
+                .catch((hookErr) => {
+                log.warn(`before_agent_start hook (legacy prompt build path) failed: ${String(hookErr)}`);
+                return undefined;
+            })
+            : undefined);
+    return {
+        systemPrompt: promptBuildResult?.systemPrompt ?? legacyResult?.systemPrompt,
+        prependContext: [promptBuildResult?.prependContext, legacyResult?.prependContext]
+            .filter((value) => Boolean(value))
+            .join("\n\n"),
+    };
+}
 function summarizeMessagePayload(msg) {
     const content = msg.content;
     if (typeof content === "string") {
@@ -244,6 +277,10 @@ export async function runEmbeddedAttempt(params) {
                 disableMessageTool: params.disableMessageTool,
             });
         const tools = sanitizeToolsForGoogle({ tools: toolsRaw, provider: params.provider });
+        const allowedToolNames = collectAllowedToolNames({
+            tools,
+            clientTools: params.clientTools,
+        });
         logToolSchemasForGoogle({ tools, provider: params.provider });
         const machineName = await getMachineDisplayName();
         const runtimeChannel = normalizeMessageChannel(params.messageChannel ?? params.messageProvider);
@@ -349,6 +386,10 @@ export async function runEmbeddedAttempt(params) {
             reasoningLevel: params.reasoningLevel ?? "off",
             extraSystemPrompt: params.extraSystemPrompt,
             ownerNumbers: params.ownerNumbers,
+            ownerDisplay: params.config?.commands?.ownerDisplay,
+            ownerDisplaySecret: params.config?.commands?.ownerDisplaySecret ??
+                params.config?.gateway?.auth?.token ??
+                params.config?.gateway?.remote?.token,
             reasoningTagHint,
             heartbeatPrompt: isDefaultAgent
                 ? resolveHeartbeatPrompt(params.config?.agents?.defaults?.heartbeat?.prompt)
@@ -424,6 +465,7 @@ export async function runEmbeddedAttempt(params) {
                 sessionKey: params.sessionKey,
                 inputProvenance: params.inputProvenance,
                 allowSyntheticToolResults: transcriptPolicy.allowSyntheticToolResults,
+                allowedToolNames,
             });
             trackSessionManagerAccess(params.sessionFile);
             await prepareSessionManagerForRun({
@@ -434,18 +476,31 @@ export async function runEmbeddedAttempt(params) {
                 cwd: effectiveWorkspace,
             });
             const settingsManager = SettingsManager.create(effectiveWorkspace, agentDir);
-            ensurePiCompactionReserveTokens({
+            applyPiCompactionSettingsFromConfig({
                 settingsManager,
-                minReserveTokens: resolveCompactionReserveTokensFloor(params.config),
+                cfg: params.config,
             });
-            // Call for side effects (sets compaction/pruning runtime state)
-            buildEmbeddedExtensionPaths({
+            // Sets compaction/pruning runtime state and returns extension factories
+            // that must be passed to the resource loader for the safeguard to be active.
+            const extensionFactories = buildEmbeddedExtensionFactories({
                 cfg: params.config,
                 sessionManager,
                 provider: params.provider,
                 modelId: params.modelId,
                 model: params.model,
             });
+            // Only create an explicit resource loader when there are extension factories
+            // to register; otherwise let createAgentSession use its built-in default.
+            let resourceLoader;
+            if (extensionFactories.length > 0) {
+                resourceLoader = new DefaultResourceLoader({
+                    cwd: resolvedWorkspace,
+                    agentDir,
+                    settingsManager,
+                    extensionFactories,
+                });
+                await resourceLoader.reload();
+            }
             // Get hook runner early so it's available when creating tools
             const hookRunner = getGlobalHookRunner();
             const { builtInTools, customTools } = splitSdkTools({
@@ -479,6 +534,7 @@ export async function runEmbeddedAttempt(params) {
                 customTools: allCustomTools,
                 sessionManager,
                 settingsManager,
+                resourceLoader,
             }));
             applySystemPromptOverrideToSession(session, systemPromptText);
             if (!session) {
@@ -533,6 +589,28 @@ export async function runEmbeddedAttempt(params) {
                 });
                 activeSession.agent.streamFn = cacheTrace.wrapStreamFn(activeSession.agent.streamFn);
             }
+            // Copilot/Claude can reject persisted `thinking` blocks (e.g. thinkingSignature:"reasoning_text")
+            // on *any* follow-up provider call (including tool continuations). Wrap the stream function
+            // so every outbound request sees sanitized messages.
+            if (transcriptPolicy.dropThinkingBlocks) {
+                const inner = activeSession.agent.streamFn;
+                activeSession.agent.streamFn = (model, context, options) => {
+                    const ctx = context;
+                    const messages = ctx?.messages;
+                    if (!Array.isArray(messages)) {
+                        return inner(model, context, options);
+                    }
+                    const sanitized = dropThinkingBlocks(messages);
+                    if (sanitized === messages) {
+                        return inner(model, context, options);
+                    }
+                    const nextContext = {
+                        ...context,
+                        messages: sanitized,
+                    };
+                    return inner(model, nextContext, options);
+                };
+            }
             if (anthropicPayloadLogger) {
                 activeSession.agent.streamFn = anthropicPayloadLogger.wrapStreamFn(activeSession.agent.streamFn);
             }
@@ -542,6 +620,7 @@ export async function runEmbeddedAttempt(params) {
                     modelApi: params.model.api,
                     modelId: params.modelId,
                     provider: params.provider,
+                    allowedToolNames,
                     config: params.config,
                     sessionManager,
                     sessionId: params.sessionId,
@@ -725,34 +804,13 @@ export async function runEmbeddedAttempt(params) {
                     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"),
-                };
+                const hookResult = await resolvePromptBuildHookResult({
+                    prompt: params.prompt,
+                    messages: activeSession.messages,
+                    hookCtx,
+                    hookRunner,
+                    legacyBeforeAgentStartResult: params.legacyBeforeAgentStartResult,
+                });
                 {
                     if (hookResult?.prependContext) {
                         effectivePrompt = `${hookResult.prependContext}\n\n${params.prompt}`;
@@ -774,7 +832,8 @@ export async function runEmbeddedAttempt(params) {
                         sessionManager.resetLeaf();
                     }
                     const sessionContext = sessionManager.buildSessionContext();
-                    const sanitizedOrphan = transcriptPolicy.normalizeAntigravityThinkingBlocks
+                    const sanitizedOrphan = transcriptPolicy.sanitizeThinkingSignatures ||
+                        transcriptPolicy.normalizeAntigravityThinkingBlocks
                         ? sanitizeAntigravityThinkingBlocks(sessionContext.messages)
                         : sessionContext.messages;
                     activeSession.agent.replaceMessages(sanitizedOrphan);

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

@@ -43,6 +43,16 @@ const createUsageAccumulator = () => ({
 function createCompactionDiagId() {
     return `ovf-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
+// Defensive guard for the outer run loop across all retry branches.
+const BASE_RUN_RETRY_ITERATIONS = 24;
+const RUN_RETRY_ITERATIONS_PER_PROFILE = 8;
+const MIN_RUN_RETRY_ITERATIONS = 32;
+const MAX_RUN_RETRY_ITERATIONS = 160;
+function resolveMaxRunRetryIterations(profileCandidateCount) {
+    const scaled = BASE_RUN_RETRY_ITERATIONS +
+        Math.max(1, profileCandidateCount) * RUN_RETRY_ITERATIONS_PER_PROFILE;
+    return Math.min(MAX_RUN_RETRY_ITERATIONS, Math.max(MIN_RUN_RETRY_ITERATIONS, scaled));
+}
 const hasUsageValues = (usage) => !!usage &&
     [usage.input, usage.output, usage.cacheRead, usage.cacheWrite, usage.total].some((value) => typeof value === "number" && Number.isFinite(value) && value > 0);
 const mergeUsageIntoAccumulator = (target, usage) => {
@@ -89,6 +99,12 @@ const toNormalizedUsage = (usage) => {
         total: lastPromptTokens + usage.output || undefined,
     };
 };
+function resolveActiveErrorContext(params) {
+    return {
+        provider: params.lastAssistant?.provider ?? params.provider,
+        model: params.lastAssistant?.model ?? params.model,
+    };
+}
 export async function runEmbeddedPiAgent(params) {
     const sessionLane = resolveSessionLane(params.sessionKey?.trim() || params.sessionId);
     const globalLane = resolveGlobalLane(params.lane);
@@ -129,6 +145,7 @@ export async function runEmbeddedPiAgent(params) {
         // Legacy compatibility: before_agent_start is also checked for override
         // fields if present. New hook takes precedence when both are set.
         let modelResolveOverride;
+        let legacyBeforeAgentStartResult;
         const hookRunner = getGlobalHookRunner();
         const hookCtx = {
             agentId: workspaceResolution.agentId,
@@ -147,10 +164,11 @@ export async function runEmbeddedPiAgent(params) {
         }
         if (hookRunner?.hasHooks("before_agent_start")) {
             try {
-                const legacyResult = await hookRunner.runBeforeAgentStart({ prompt: params.prompt }, hookCtx);
+                legacyBeforeAgentStartResult = await hookRunner.runBeforeAgentStart({ prompt: params.prompt }, hookCtx);
                 modelResolveOverride = {
-                    providerOverride: modelResolveOverride?.providerOverride ?? legacyResult?.providerOverride,
-                    modelOverride: modelResolveOverride?.modelOverride ?? legacyResult?.modelOverride,
+                    providerOverride: modelResolveOverride?.providerOverride ??
+                        legacyBeforeAgentStartResult?.providerOverride,
+                    modelOverride: modelResolveOverride?.modelOverride ?? legacyBeforeAgentStartResult?.modelOverride,
                 };
             }
             catch (hookErr) {
@@ -167,7 +185,11 @@ export async function runEmbeddedPiAgent(params) {
         }
         const { model, error, authStorage, modelRegistry } = resolveModel(provider, modelId, agentDir, params.config);
         if (!model) {
-            throw new Error(error ?? `Unknown model: ${provider}/${modelId}`);
+            throw new FailoverError(error ?? `Unknown model: ${provider}/${modelId}`, {
+                reason: "model_not_found",
+                provider,
+                model: modelId,
+            });
         }
         const ctxInfo = resolveContextWindowInfo({
             cfg: params.config,
@@ -335,13 +357,41 @@ export async function runEmbeddedPiAgent(params) {
             }
         }
         const MAX_OVERFLOW_COMPACTION_ATTEMPTS = 3;
+        const MAX_RUN_LOOP_ITERATIONS = resolveMaxRunRetryIterations(profileCandidates.length);
         let overflowCompactionAttempts = 0;
         let toolResultTruncationAttempted = false;
         const usageAccumulator = createUsageAccumulator();
         let lastRunPromptUsage;
         let autoCompactionCount = 0;
+        let runLoopIterations = 0;
         try {
             while (true) {
+                if (runLoopIterations >= MAX_RUN_LOOP_ITERATIONS) {
+                    const message = `Exceeded retry limit after ${runLoopIterations} attempts ` +
+                        `(max=${MAX_RUN_LOOP_ITERATIONS}).`;
+                    log.error(`[run-retry-limit] sessionKey=${params.sessionKey ?? params.sessionId} ` +
+                        `provider=${provider}/${modelId} attempts=${runLoopIterations} ` +
+                        `maxAttempts=${MAX_RUN_LOOP_ITERATIONS}`);
+                    return {
+                        payloads: [
+                            {
+                                text: "Request failed after repeated internal retries. " +
+                                    "Please try again, or use /new to start a fresh session.",
+                                isError: true,
+                            },
+                        ],
+                        meta: {
+                            durationMs: Date.now() - started,
+                            agentMeta: {
+                                sessionId: params.sessionId,
+                                provider,
+                                model: model.id,
+                            },
+                            error: { kind: "retry_limit", message },
+                        },
+                    };
+                }
+                runLoopIterations += 1;
                 attemptedThinking.add(thinkLevel);
                 await fs.mkdir(resolvedWorkspace, { recursive: true });
                 const prompt = provider === "anthropic" ? scrubAnthropicRefusalMagic(params.prompt) : params.prompt;
@@ -376,6 +426,7 @@ export async function runEmbeddedPiAgent(params) {
                     authStorage,
                     modelRegistry,
                     agentId: workspaceResolution.agentId,
+                    legacyBeforeAgentStartResult,
                     thinkLevel,
                     verboseLevel: params.verboseLevel,
                     reasoningLevel: params.reasoningLevel,
@@ -413,11 +464,17 @@ export async function runEmbeddedPiAgent(params) {
                 const lastTurnTotal = lastAssistantUsage?.total ?? attemptUsage?.total;
                 const attemptCompactionCount = Math.max(0, attempt.compactionCount ?? 0);
                 autoCompactionCount += attemptCompactionCount;
+                const activeErrorContext = resolveActiveErrorContext({
+                    lastAssistant,
+                    provider,
+                    model: modelId,
+                });
                 const formattedAssistantErrorText = lastAssistant
                     ? formatAssistantErrorText(lastAssistant, {
                         cfg: params.config,
                         sessionKey: params.sessionKey ?? params.sessionId,
-                        provider,
+                        provider: activeErrorContext.provider,
+                        model: activeErrorContext.model,
                     })
                     : undefined;
                 const assistantErrorText = lastAssistant?.stopReason === "error"
@@ -533,8 +590,8 @@ export async function runEmbeddedPiAgent(params) {
                             });
                             if (truncResult.truncated) {
                                 log.info(`[context-overflow-recovery] Truncated ${truncResult.truncatedCount} tool result(s); retrying prompt`);
-                                // Session is now smaller; allow compaction retries again.
-                                overflowCompactionAttempts = 0;
+                                // Do NOT reset overflowCompactionAttempts here — the global cap must remain
+                                // enforced across all iterations to prevent unbounded compaction cycles (OC-65).
                                 continue;
                             }
                             log.warn(`[context-overflow-recovery] Tool result truncation did not help: ${truncResult.reason ?? "unknown"}`);
@@ -725,7 +782,8 @@ export async function runEmbeddedPiAgent(params) {
                             ? formatAssistantErrorText(lastAssistant, {
                                 cfg: params.config,
                                 sessionKey: params.sessionKey ?? params.sessionId,
-                                provider,
+                                provider: activeErrorContext.provider,
+                                model: activeErrorContext.model,
                             })
                             : undefined) ||
                             lastAssistant?.errorMessage?.trim() ||
@@ -734,7 +792,7 @@ export async function runEmbeddedPiAgent(params) {
                                 : rateLimitFailure
                                     ? "LLM request rate limited."
                                     : billingFailure
-                                        ? formatBillingErrorMessage(provider)
+                                        ? formatBillingErrorMessage(activeErrorContext.provider, activeErrorContext.model)
                                         : authFailure
                                             ? "LLM request unauthorized."
                                             : "LLM request failed.");
@@ -742,8 +800,8 @@ export async function runEmbeddedPiAgent(params) {
                             (isTimeoutErrorMessage(message) ? 408 : undefined);
                         throw new FailoverError(message, {
                             reason: assistantFailoverReason ?? "unknown",
-                            provider,
-                            model: modelId,
+                            provider: activeErrorContext.provider,
+                            model: activeErrorContext.model,
                             profileId: lastProfileId,
                             status,
                         });
@@ -776,7 +834,8 @@ export async function runEmbeddedPiAgent(params) {
                     lastToolError: attempt.lastToolError,
                     config: params.config,
                     sessionKey: params.sessionKey ?? params.sessionId,
-                    provider,
+                    provider: activeErrorContext.provider,
+                    model: activeErrorContext.model,
                     verboseLevel: params.verboseLevel,
                     reasoningLevel: params.reasoningLevel,
                     toolResultFormat: resolvedToolResultFormat,

package/dist/agents/pi-embedded-runner/run.overflow-compaction.fixture.js

@@ -0,0 +1,34 @@
+export function makeAttemptResult(overrides = {}) {
+    return {
+        aborted: false,
+        timedOut: false,
+        timedOutDuringCompaction: false,
+        promptError: null,
+        sessionIdUsed: "test-session",
+        assistantTexts: ["Hello!"],
+        toolMetas: [],
+        lastAssistant: undefined,
+        messagesSnapshot: [],
+        didSendViaMessagingTool: false,
+        messagingToolSentTexts: [],
+        messagingToolSentMediaUrls: [],
+        messagingToolSentTargets: [],
+        cloudCodeAssistFormatError: false,
+        ...overrides,
+    };
+}
+export function mockOverflowRetrySuccess(params) {
+    const overflowError = new Error(params.overflowMessage ?? "request_too_large: Request size exceeds model context window");
+    params.runEmbeddedAttempt.mockResolvedValueOnce(makeAttemptResult({ promptError: overflowError }));
+    params.runEmbeddedAttempt.mockResolvedValueOnce(makeAttemptResult({ promptError: null }));
+    params.compactDirect.mockResolvedValueOnce({
+        ok: true,
+        compacted: true,
+        result: {
+            summary: "Compacted session",
+            firstKeptEntryId: "entry-5",
+            tokensBefore: 150000,
+        },
+    });
+    return overflowError;
+}

package/dist/agents/pi-embedded-runner/run.overflow-compaction.mocks.shared.js

@@ -1,4 +1,13 @@
 import { vi } from "vitest";
+export const mockedGlobalHookRunner = {
+    hasHooks: vi.fn((_hookName) => false),
+    runBeforeAgentStart: vi.fn(async (_event, _ctx) => undefined),
+    runBeforePromptBuild: vi.fn(async (_event, _ctx) => undefined),
+    runBeforeModelResolve: vi.fn(async (_event, _ctx) => undefined),
+};
+vi.mock("../../plugins/hook-runner-global.js", () => ({
+    getGlobalHookRunner: vi.fn(() => mockedGlobalHookRunner),
+}));
 vi.mock("../auth-profiles.js", () => ({
     isProfileInCooldown: vi.fn(() => false),
     markAuthProfileFailure: vi.fn(async () => { }),
@@ -78,7 +87,7 @@ vi.mock("../model-auth.js", () => ({
     resolveAuthProfileOrder: vi.fn(() => []),
 }));
 vi.mock("../models-config.js", () => ({
-    ensurePoolbotModelsJson: vi.fn(async () => { }),
+    ensurePoolBotModelsJson: vi.fn(async () => { }),
 }));
 vi.mock("../context-window-guard.js", () => ({
     CONTEXT_WINDOW_HARD_MIN_TOKENS: 1000,
@@ -101,7 +110,7 @@ vi.mock("../../utils/message-channel.js", () => ({
     isMarkdownCapableMessageChannel: vi.fn(() => true),
 }));
 vi.mock("../agent-paths.js", () => ({
-    resolvePoolbotAgentDir: vi.fn(() => "/tmp/agent-dir"),
+    resolvePoolBotAgentDir: vi.fn(() => "/tmp/agent-dir"),
 }));
 vi.mock("../defaults.js", () => ({
     DEFAULT_CONTEXT_TOKENS: 200000,