@poolzin/pool-bot 2026.2.21 → 2026.2.23

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

@@ -1,4 +1,5 @@
 import fs from "node:fs/promises";
+import { getGlobalHookRunner } from "../../plugins/hook-runner-global.js";
 import { enqueueCommandInLane } from "../../process/command-queue.js";
 import { isMarkdownCapableMessageChannel } from "../../utils/message-channel.js";
 import { resolvePoolbotAgentDir } from "../agent-paths.js";
@@ -9,8 +10,8 @@ import { FailoverError, resolveFailoverStatus } from "../failover-error.js";
 import { ensureAuthProfileStore, getApiKeyForModel, resolveAuthProfileOrder, } from "../model-auth.js";
 import { normalizeProviderId } from "../model-selection.js";
 import { ensurePoolbotModelsJson } from "../models-config.js";
-import { BILLING_ERROR_USER_MESSAGE, classifyFailoverReason, formatAssistantErrorText, isAuthAssistantError, isBillingAssistantError, isCompactionFailureError, isContextOverflowError, isFailoverAssistantError, isFailoverErrorMessage, parseImageSizeError, parseImageDimensionError, isRateLimitAssistantError, isTimeoutErrorMessage, pickFallbackThinkingLevel, } from "../pi-embedded-helpers.js";
-import { normalizeUsage } from "../usage.js";
+import { formatBillingErrorMessage, classifyFailoverReason, formatAssistantErrorText, isAuthAssistantError, isBillingAssistantError, isCompactionFailureError, isLikelyContextOverflowError, isFailoverAssistantError, isFailoverErrorMessage, parseImageSizeError, parseImageDimensionError, isRateLimitAssistantError, isTimeoutErrorMessage, pickFallbackThinkingLevel, } from "../pi-embedded-helpers.js";
+import { derivePromptTokens, normalizeUsage } from "../usage.js";
 import { redactRunIdentifier, resolveRunWorkspaceDir } from "../workspace-run.js";
 import { compactEmbeddedPiSessionDirect } from "./compact.js";
 import { resolveGlobalLane, resolveSessionLane } from "./lanes.js";
@@ -24,8 +25,9 @@ import { describeUnknownError } from "./utils.js";
 const ANTHROPIC_MAGIC_STRING_TRIGGER_REFUSAL = "ANTHROPIC_MAGIC_STRING_TRIGGER_REFUSAL";
 const ANTHROPIC_MAGIC_STRING_REPLACEMENT = "ANTHROPIC MAGIC STRING TRIGGER REFUSAL (redacted)";
 function scrubAnthropicRefusalMagic(prompt) {
-    if (!prompt.includes(ANTHROPIC_MAGIC_STRING_TRIGGER_REFUSAL))
+    if (!prompt.includes(ANTHROPIC_MAGIC_STRING_TRIGGER_REFUSAL)) {
         return prompt;
+    }
     return prompt.replaceAll(ANTHROPIC_MAGIC_STRING_TRIGGER_REFUSAL, ANTHROPIC_MAGIC_STRING_REPLACEMENT);
 }
 const createUsageAccumulator = () => ({
@@ -34,7 +36,13 @@ const createUsageAccumulator = () => ({
     cacheRead: 0,
     cacheWrite: 0,
     total: 0,
+    lastCacheRead: 0,
+    lastCacheWrite: 0,
+    lastInput: 0,
 });
+function createCompactionDiagId() {
+    return `ovf-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
 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) => {
@@ -48,6 +56,12 @@ const mergeUsageIntoAccumulator = (target, usage) => {
     target.total +=
         usage.total ??
             (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+    // Track the most recent API call's cache fields for accurate context-size reporting.
+    // Accumulated cache totals inflate context size when there are multiple tool-call round-trips,
+    // since each call reports cacheRead ≈ current_context_size.
+    target.lastCacheRead = usage.cacheRead ?? 0;
+    target.lastCacheWrite = usage.cacheWrite ?? 0;
+    target.lastInput = usage.input ?? 0;
 };
 const toNormalizedUsage = (usage) => {
     const hasUsage = usage.input > 0 ||
@@ -58,13 +72,21 @@ const toNormalizedUsage = (usage) => {
     if (!hasUsage) {
         return undefined;
     }
-    const derivedTotal = usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+    // Use the LAST API call's cache fields for context-size calculation.
+    // The accumulated cacheRead/cacheWrite inflate context size because each tool-call
+    // round-trip reports cacheRead ≈ current_context_size, and summing N calls gives
+    // N × context_size which gets clamped to contextWindow (e.g. 200k).
+    // See: https://github.com/poolbot/poolbot/issues/13698
+    //
+    // We use lastInput/lastCacheRead/lastCacheWrite (from the most recent API call) for
+    // cache-related fields, but keep accumulated output (total generated text this turn).
+    const lastPromptTokens = usage.lastInput + usage.lastCacheRead + usage.lastCacheWrite;
     return {
-        input: usage.input || undefined,
+        input: usage.lastInput || undefined,
         output: usage.output || undefined,
-        cacheRead: usage.cacheRead || undefined,
-        cacheWrite: usage.cacheWrite || undefined,
-        total: usage.total || derivedTotal || undefined,
+        cacheRead: usage.lastCacheRead || undefined,
+        cacheWrite: usage.lastCacheWrite || undefined,
+        total: lastPromptTokens + usage.output || undefined,
     };
 };
 export async function runEmbeddedPiAgent(params) {
@@ -85,6 +107,7 @@ export async function runEmbeddedPiAgent(params) {
         const workspaceResolution = resolveRunWorkspaceDir({
             workspaceDir: params.workspaceDir,
             sessionKey: params.sessionKey,
+            agentId: params.agentId,
             config: params.config,
         });
         const resolvedWorkspace = workspaceResolution.workspaceDir;
@@ -95,11 +118,53 @@ export async function runEmbeddedPiAgent(params) {
             log.warn(`[workspace-fallback] caller=runEmbeddedPiAgent reason=${workspaceResolution.fallbackReason} run=${params.runId} session=${redactedSessionId} sessionKey=${redactedSessionKey} agent=${workspaceResolution.agentId} workspace=${redactedWorkspace}`);
         }
         const prevCwd = process.cwd();
-        const provider = (params.provider ?? DEFAULT_PROVIDER).trim() || DEFAULT_PROVIDER;
-        const modelId = (params.model ?? DEFAULT_MODEL).trim() || DEFAULT_MODEL;
+        let provider = (params.provider ?? DEFAULT_PROVIDER).trim() || DEFAULT_PROVIDER;
+        let modelId = (params.model ?? DEFAULT_MODEL).trim() || DEFAULT_MODEL;
         const agentDir = params.agentDir ?? resolvePoolbotAgentDir();
         const fallbackConfigured = (params.config?.agents?.defaults?.model?.fallbacks?.length ?? 0) > 0;
         await ensurePoolbotModelsJson(params.config, agentDir);
+        // Run before_model_resolve hooks early so plugins can override the
+        // provider/model before resolveModel().
+        //
+        // Legacy compatibility: before_agent_start is also checked for override
+        // fields if present. New hook takes precedence when both are set.
+        let modelResolveOverride;
+        const hookRunner = getGlobalHookRunner();
+        const hookCtx = {
+            agentId: workspaceResolution.agentId,
+            sessionKey: params.sessionKey,
+            sessionId: params.sessionId,
+            workspaceDir: resolvedWorkspace,
+            messageProvider: params.messageProvider ?? undefined,
+        };
+        if (hookRunner?.hasHooks("before_model_resolve")) {
+            try {
+                modelResolveOverride = await hookRunner.runBeforeModelResolve({ prompt: params.prompt }, hookCtx);
+            }
+            catch (hookErr) {
+                log.warn(`before_model_resolve hook failed: ${String(hookErr)}`);
+            }
+        }
+        if (hookRunner?.hasHooks("before_agent_start")) {
+            try {
+                const legacyResult = await hookRunner.runBeforeAgentStart({ prompt: params.prompt }, hookCtx);
+                modelResolveOverride = {
+                    providerOverride: modelResolveOverride?.providerOverride ?? legacyResult?.providerOverride,
+                    modelOverride: modelResolveOverride?.modelOverride ?? legacyResult?.modelOverride,
+                };
+            }
+            catch (hookErr) {
+                log.warn(`before_agent_start hook (legacy model resolve path) failed: ${String(hookErr)}`);
+            }
+        }
+        if (modelResolveOverride?.providerOverride) {
+            provider = modelResolveOverride.providerOverride;
+            log.info(`[hooks] provider overridden to ${provider}`);
+        }
+        if (modelResolveOverride?.modelOverride) {
+            modelId = modelResolveOverride.modelOverride;
+            log.info(`[hooks] model overridden to ${modelId}`);
+        }
         const { model, error, authStorage, modelRegistry } = resolveModel(provider, modelId, agentDir, params.config);
         if (!model) {
             throw new Error(error ?? `Unknown model: ${provider}/${modelId}`);
@@ -154,8 +219,9 @@ export async function runEmbeddedPiAgent(params) {
         let apiKeyInfo = null;
         let lastProfileId;
         const resolveAuthProfileFailoverReason = (params) => {
-            if (params.allInCooldown)
+            if (params.allInCooldown) {
                 return "rate_limit";
+            }
             const classified = classifyFailoverReason(params.message);
             return classified ?? "auth";
         };
@@ -177,8 +243,9 @@ export async function runEmbeddedPiAgent(params) {
                     cause: params.error,
                 });
             }
-            if (params.error instanceof Error)
+            if (params.error instanceof Error) {
                 throw params.error;
+            }
             throw new Error(message);
         };
         const resolveApiKeyForCandidate = async (candidate) => {
@@ -213,8 +280,9 @@ export async function runEmbeddedPiAgent(params) {
             lastProfileId = apiKeyInfo.profileId;
         };
         const advanceAuthProfile = async () => {
-            if (lockedProfileId)
+            if (lockedProfileId) {
                 return false;
+            }
             let nextIndex = profileIndex + 1;
             while (nextIndex < profileCandidates.length) {
                 const candidate = profileCandidates[nextIndex];
@@ -230,8 +298,9 @@ export async function runEmbeddedPiAgent(params) {
                     return true;
                 }
                 catch (err) {
-                    if (candidate && candidate === lockedProfileId)
+                    if (candidate && candidate === lockedProfileId) {
                         throw err;
+                    }
                     nextIndex += 1;
                 }
             }
@@ -254,8 +323,9 @@ export async function runEmbeddedPiAgent(params) {
             }
         }
         catch (err) {
-            if (err instanceof FailoverError)
+            if (err instanceof FailoverError) {
                 throw err;
+            }
             if (profileCandidates[profileIndex] === lockedProfileId) {
                 throwAuthProfileFailover({ allInCooldown: false, error: err });
             }
@@ -268,6 +338,7 @@ export async function runEmbeddedPiAgent(params) {
         let overflowCompactionAttempts = 0;
         let toolResultTruncationAttempted = false;
         const usageAccumulator = createUsageAccumulator();
+        let lastRunPromptUsage;
         let autoCompactionCount = 0;
         try {
             while (true) {
@@ -304,6 +375,7 @@ export async function runEmbeddedPiAgent(params) {
                     model,
                     authStorage,
                     modelRegistry,
+                    agentId: workspaceResolution.agentId,
                     thinkLevel,
                     verboseLevel: params.verboseLevel,
                     reasoningLevel: params.reasoningLevel,
@@ -322,20 +394,30 @@ export async function runEmbeddedPiAgent(params) {
                     blockReplyBreak: params.blockReplyBreak,
                     blockReplyChunking: params.blockReplyChunking,
                     onReasoningStream: params.onReasoningStream,
+                    onReasoningEnd: params.onReasoningEnd,
                     onToolResult: params.onToolResult,
                     onAgentEvent: params.onAgentEvent,
                     extraSystemPrompt: params.extraSystemPrompt,
+                    inputProvenance: params.inputProvenance,
                     streamParams: params.streamParams,
                     ownerNumbers: params.ownerNumbers,
                     enforceFinalTag: params.enforceFinalTag,
                 });
-                const { aborted, promptError, timedOut, sessionIdUsed, lastAssistant } = attempt;
-                mergeUsageIntoAccumulator(usageAccumulator, attempt.attemptUsage ?? normalizeUsage(lastAssistant?.usage));
-                autoCompactionCount += Math.max(0, attempt.compactionCount ?? 0);
+                const { aborted, promptError, timedOut, timedOutDuringCompaction, sessionIdUsed, lastAssistant, } = attempt;
+                const lastAssistantUsage = normalizeUsage(lastAssistant?.usage);
+                const attemptUsage = attempt.attemptUsage ?? lastAssistantUsage;
+                mergeUsageIntoAccumulator(usageAccumulator, attemptUsage);
+                // Keep prompt size from the latest model call so session totalTokens
+                // reflects current context usage, not accumulated tool-loop usage.
+                lastRunPromptUsage = lastAssistantUsage ?? attemptUsage;
+                const lastTurnTotal = lastAssistantUsage?.total ?? attemptUsage?.total;
+                const attemptCompactionCount = Math.max(0, attempt.compactionCount ?? 0);
+                autoCompactionCount += attemptCompactionCount;
                 const formattedAssistantErrorText = lastAssistant
                     ? formatAssistantErrorText(lastAssistant, {
                         cfg: params.config,
                         sessionKey: params.sessionKey ?? params.sessionId,
+                        provider,
                     })
                     : undefined;
                 const assistantErrorText = lastAssistant?.stopReason === "error"
@@ -345,30 +427,49 @@ export async function runEmbeddedPiAgent(params) {
                     ? (() => {
                         if (promptError) {
                             const errorText = describeUnknownError(promptError);
-                            if (isContextOverflowError(errorText)) {
+                            if (isLikelyContextOverflowError(errorText)) {
                                 return { text: errorText, source: "promptError" };
                             }
                             // Prompt submission failed with a non-overflow error. Do not
                             // inspect prior assistant errors from history for this attempt.
                             return null;
                         }
-                        if (assistantErrorText && isContextOverflowError(assistantErrorText)) {
+                        if (assistantErrorText && isLikelyContextOverflowError(assistantErrorText)) {
                             return { text: assistantErrorText, source: "assistantError" };
                         }
                         return null;
                     })()
                     : null;
                 if (contextOverflowError) {
+                    const overflowDiagId = createCompactionDiagId();
                     const errorText = contextOverflowError.text;
                     const msgCount = attempt.messagesSnapshot?.length ?? 0;
                     log.warn(`[context-overflow-diag] sessionKey=${params.sessionKey ?? params.sessionId} ` +
                         `provider=${provider}/${modelId} source=${contextOverflowError.source} ` +
                         `messages=${msgCount} sessionFile=${params.sessionFile} ` +
-                        `compactionAttempts=${overflowCompactionAttempts} error=${errorText.slice(0, 200)}`);
+                        `diagId=${overflowDiagId} compactionAttempts=${overflowCompactionAttempts} ` +
+                        `error=${errorText.slice(0, 200)}`);
                     const isCompactionFailure = isCompactionFailureError(errorText);
-                    // Attempt auto-compaction on context overflow (not compaction_failure)
+                    const hadAttemptLevelCompaction = attemptCompactionCount > 0;
+                    // If this attempt already compacted (SDK auto-compaction), avoid immediately
+                    // running another explicit compaction for the same overflow trigger.
+                    if (!isCompactionFailure &&
+                        hadAttemptLevelCompaction &&
+                        overflowCompactionAttempts < MAX_OVERFLOW_COMPACTION_ATTEMPTS) {
+                        overflowCompactionAttempts++;
+                        log.warn(`context overflow persisted after in-attempt compaction (attempt ${overflowCompactionAttempts}/${MAX_OVERFLOW_COMPACTION_ATTEMPTS}); retrying prompt without additional compaction for ${provider}/${modelId}`);
+                        continue;
+                    }
+                    // Attempt explicit overflow compaction only when this attempt did not
+                    // already auto-compact.
                     if (!isCompactionFailure &&
+                        !hadAttemptLevelCompaction &&
                         overflowCompactionAttempts < MAX_OVERFLOW_COMPACTION_ATTEMPTS) {
+                        if (log.isEnabled("debug")) {
+                            log.debug(`[compaction-diag] decision diagId=${overflowDiagId} branch=compact ` +
+                                `isCompactionFailure=${isCompactionFailure} hasOversizedToolResults=unknown ` +
+                                `attempt=${overflowCompactionAttempts + 1} maxAttempts=${MAX_OVERFLOW_COMPACTION_ATTEMPTS}`);
+                        }
                         overflowCompactionAttempts++;
                         log.warn(`context overflow detected (attempt ${overflowCompactionAttempts}/${MAX_OVERFLOW_COMPACTION_ATTEMPTS}); attempting auto-compaction for ${provider}/${modelId}`);
                         const compactResult = await compactEmbeddedPiSessionDirect({
@@ -386,11 +487,16 @@ export async function runEmbeddedPiAgent(params) {
                             senderIsOwner: params.senderIsOwner,
                             provider,
                             model: modelId,
+                            runId: params.runId,
                             thinkLevel,
                             reasoningLevel: params.reasoningLevel,
                             bashElevated: params.bashElevated,
                             extraSystemPrompt: params.extraSystemPrompt,
                             ownerNumbers: params.ownerNumbers,
+                            trigger: "overflow",
+                            diagId: overflowDiagId,
+                            attempt: overflowCompactionAttempts,
+                            maxAttempts: MAX_OVERFLOW_COMPACTION_ATTEMPTS,
                         });
                         if (compactResult.compacted) {
                             autoCompactionCount += 1;
@@ -411,6 +517,11 @@ export async function runEmbeddedPiAgent(params) {
                             })
                             : false;
                         if (hasOversized) {
+                            if (log.isEnabled("debug")) {
+                                log.debug(`[compaction-diag] decision diagId=${overflowDiagId} branch=truncate_tool_results ` +
+                                    `isCompactionFailure=${isCompactionFailure} hasOversizedToolResults=${hasOversized} ` +
+                                    `attempt=${overflowCompactionAttempts} maxAttempts=${MAX_OVERFLOW_COMPACTION_ATTEMPTS}`);
+                            }
                             toolResultTruncationAttempted = true;
                             log.warn(`[context-overflow-recovery] Attempting tool result truncation for ${provider}/${modelId} ` +
                                 `(contextWindow=${contextWindowTokens} tokens)`);
@@ -428,6 +539,19 @@ export async function runEmbeddedPiAgent(params) {
                             }
                             log.warn(`[context-overflow-recovery] Tool result truncation did not help: ${truncResult.reason ?? "unknown"}`);
                         }
+                        else if (log.isEnabled("debug")) {
+                            log.debug(`[compaction-diag] decision diagId=${overflowDiagId} branch=give_up ` +
+                                `isCompactionFailure=${isCompactionFailure} hasOversizedToolResults=${hasOversized} ` +
+                                `attempt=${overflowCompactionAttempts} maxAttempts=${MAX_OVERFLOW_COMPACTION_ATTEMPTS}`);
+                        }
+                    }
+                    if ((isCompactionFailure ||
+                        overflowCompactionAttempts >= MAX_OVERFLOW_COMPACTION_ATTEMPTS ||
+                        toolResultTruncationAttempted) &&
+                        log.isEnabled("debug")) {
+                        log.debug(`[compaction-diag] decision diagId=${overflowDiagId} branch=give_up ` +
+                            `isCompactionFailure=${isCompactionFailure} hasOversizedToolResults=unknown ` +
+                            `attempt=${overflowCompactionAttempts} maxAttempts=${MAX_OVERFLOW_COMPACTION_ATTEMPTS}`);
                     }
                     const kind = isCompactionFailure ? "compaction_failure" : "context_overflow";
                     return {
@@ -570,7 +694,8 @@ export async function runEmbeddedPiAgent(params) {
                     log.warn(`Profile ${lastProfileId} rejected image payload${details ? ` (${details})` : ""}.`);
                 }
                 // Treat timeout as potential rate limit (Antigravity hangs on rate limit)
-                const shouldRotate = (!aborted && failoverFailure) || timedOut;
+                // But exclude post-prompt compaction timeouts (model succeeded; no profile issue)
+                const shouldRotate = (!aborted && failoverFailure) || (timedOut && !timedOutDuringCompaction);
                 if (shouldRotate) {
                     if (lastProfileId) {
                         const reason = timedOut || assistantFailoverReason === "timeout"
@@ -591,14 +716,16 @@ export async function runEmbeddedPiAgent(params) {
                         }
                     }
                     const rotated = await advanceAuthProfile();
-                    if (rotated)
+                    if (rotated) {
                         continue;
+                    }
                     if (fallbackConfigured) {
                         // Prefer formatted error message (user-friendly) over raw errorMessage
                         const message = (lastAssistant
                             ? formatAssistantErrorText(lastAssistant, {
                                 cfg: params.config,
                                 sessionKey: params.sessionKey ?? params.sessionId,
+                                provider,
                             })
                             : undefined) ||
                             lastAssistant?.errorMessage?.trim() ||
@@ -607,7 +734,7 @@ export async function runEmbeddedPiAgent(params) {
                                 : rateLimitFailure
                                     ? "LLM request rate limited."
                                     : billingFailure
-                                        ? BILLING_ERROR_USER_MESSAGE
+                                        ? formatBillingErrorMessage(provider)
                                         : authFailure
                                             ? "LLM request unauthorized."
                                             : "LLM request failed.");
@@ -623,11 +750,23 @@ export async function runEmbeddedPiAgent(params) {
                     }
                 }
                 const usage = toNormalizedUsage(usageAccumulator);
+                if (usage && lastTurnTotal && lastTurnTotal > 0) {
+                    usage.total = lastTurnTotal;
+                }
+                // Extract the last individual API call's usage for context-window
+                // utilization display. The accumulated `usage` sums input tokens
+                // across all calls (tool-use loops, compaction retries), which
+                // overstates the actual context size. `lastCallUsage` reflects only
+                // the final call, giving an accurate snapshot of current context.
+                const lastCallUsage = normalizeUsage(lastAssistant?.usage);
+                const promptTokens = derivePromptTokens(lastRunPromptUsage);
                 const agentMeta = {
                     sessionId: sessionIdUsed,
                     provider: lastAssistant?.provider ?? provider,
                     model: lastAssistant?.model ?? model.id,
                     usage,
+                    lastCallUsage: lastCallUsage ?? undefined,
+                    promptTokens,
                     compactionCount: autoCompactionCount > 0 ? autoCompactionCount : undefined,
                 };
                 const payloads = buildEmbeddedRunPayloads({
@@ -637,11 +776,38 @@ export async function runEmbeddedPiAgent(params) {
                     lastToolError: attempt.lastToolError,
                     config: params.config,
                     sessionKey: params.sessionKey ?? params.sessionId,
+                    provider,
                     verboseLevel: params.verboseLevel,
                     reasoningLevel: params.reasoningLevel,
                     toolResultFormat: resolvedToolResultFormat,
+                    suppressToolErrorWarnings: params.suppressToolErrorWarnings,
                     inlineToolResultsAllowed: false,
                 });
+                // Timeout aborts can leave the run without any assistant payloads.
+                // Emit an explicit timeout error instead of silently completing, so
+                // callers do not lose the turn as an orphaned user message.
+                if (timedOut && !timedOutDuringCompaction && payloads.length === 0) {
+                    return {
+                        payloads: [
+                            {
+                                text: "Request timed out before a response was generated. " +
+                                    "Please try again, or increase `agents.defaults.timeoutSeconds` in your config.",
+                                isError: true,
+                            },
+                        ],
+                        meta: {
+                            durationMs: Date.now() - started,
+                            agentMeta,
+                            aborted,
+                            systemPromptReport: attempt.systemPromptReport,
+                        },
+                        didSendViaMessagingTool: attempt.didSendViaMessagingTool,
+                        messagingToolSentTexts: attempt.messagingToolSentTexts,
+                        messagingToolSentMediaUrls: attempt.messagingToolSentMediaUrls,
+                        messagingToolSentTargets: attempt.messagingToolSentTargets,
+                        successfulCronAdds: attempt.successfulCronAdds,
+                    };
+                }
                 log.debug(`embedded run done: runId=${params.runId} sessionId=${params.sessionId} durationMs=${Date.now() - started} aborted=${aborted}`);
                 if (lastProfileId) {
                     await markAuthProfileGood({
@@ -677,7 +843,9 @@ export async function runEmbeddedPiAgent(params) {
                     },
                     didSendViaMessagingTool: attempt.didSendViaMessagingTool,
                     messagingToolSentTexts: attempt.messagingToolSentTexts,
+                    messagingToolSentMediaUrls: attempt.messagingToolSentMediaUrls,
                     messagingToolSentTargets: attempt.messagingToolSentTargets,
+                    successfulCronAdds: attempt.successfulCronAdds,
                 };
             }
         }

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

@@ -78,7 +78,7 @@ vi.mock("../model-auth.js", () => ({
     resolveAuthProfileOrder: vi.fn(() => []),
 }));
 vi.mock("../models-config.js", () => ({
-    ensureOpenClawModelsJson: vi.fn(async () => { }),
+    ensurePoolbotModelsJson: vi.fn(async () => { }),
 }));
 vi.mock("../context-window-guard.js", () => ({
     CONTEXT_WINDOW_HARD_MIN_TOKENS: 1000,
@@ -101,7 +101,7 @@ vi.mock("../../utils/message-channel.js", () => ({
     isMarkdownCapableMessageChannel: vi.fn(() => true),
 }));
 vi.mock("../agent-paths.js", () => ({
-    resolveOpenClawAgentDir: vi.fn(() => "/tmp/agent-dir"),
+    resolvePoolbotAgentDir: vi.fn(() => "/tmp/agent-dir"),
 }));
 vi.mock("../defaults.js", () => ({
     DEFAULT_CONTEXT_TOKENS: 200000,

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

@@ -38,13 +38,18 @@ export function isEmbeddedPiRunActive(sessionId) {
 }
 export function isEmbeddedPiRunStreaming(sessionId) {
     const handle = ACTIVE_EMBEDDED_RUNS.get(sessionId);
-    if (!handle)
+    if (!handle) {
         return false;
+    }
     return handle.isStreaming();
 }
+export function getActiveEmbeddedRunCount() {
+    return ACTIVE_EMBEDDED_RUNS.size;
+}
 export function waitForEmbeddedPiRunEnd(sessionId, timeoutMs = 15_000) {
-    if (!sessionId || !ACTIVE_EMBEDDED_RUNS.has(sessionId))
+    if (!sessionId || !ACTIVE_EMBEDDED_RUNS.has(sessionId)) {
         return Promise.resolve(true);
+    }
     diag.debug(`waiting for run end: sessionId=${sessionId} timeoutMs=${timeoutMs}`);
     return new Promise((resolve) => {
         const waiters = EMBEDDED_RUN_WAITERS.get(sessionId) ?? new Set();
@@ -52,8 +57,9 @@ export function waitForEmbeddedPiRunEnd(sessionId, timeoutMs = 15_000) {
             resolve,
             timer: setTimeout(() => {
                 waiters.delete(waiter);
-                if (waiters.size === 0)
+                if (waiters.size === 0) {
                     EMBEDDED_RUN_WAITERS.delete(sessionId);
+                }
                 diag.warn(`wait timeout: sessionId=${sessionId} timeoutMs=${timeoutMs}`);
                 resolve(false);
             }, Math.max(100, timeoutMs)),
@@ -62,8 +68,9 @@ export function waitForEmbeddedPiRunEnd(sessionId, timeoutMs = 15_000) {
         EMBEDDED_RUN_WAITERS.set(sessionId, waiters);
         if (!ACTIVE_EMBEDDED_RUNS.has(sessionId)) {
             waiters.delete(waiter);
-            if (waiters.size === 0)
+            if (waiters.size === 0) {
                 EMBEDDED_RUN_WAITERS.delete(sessionId);
+            }
             clearTimeout(waiter.timer);
             resolve(true);
         }
@@ -71,8 +78,9 @@ export function waitForEmbeddedPiRunEnd(sessionId, timeoutMs = 15_000) {
 }
 function notifyEmbeddedRunEnded(sessionId) {
     const waiters = EMBEDDED_RUN_WAITERS.get(sessionId);
-    if (!waiters || waiters.size === 0)
+    if (!waiters || waiters.size === 0) {
         return;
+    }
     EMBEDDED_RUN_WAITERS.delete(sessionId);
     diag.debug(`notifying waiters: sessionId=${sessionId} waiterCount=${waiters.size}`);
     for (const waiter of waiters) {
@@ -80,11 +88,12 @@ function notifyEmbeddedRunEnded(sessionId) {
         waiter.resolve(true);
     }
 }
-export function setActiveEmbeddedRun(sessionId, handle) {
+export function setActiveEmbeddedRun(sessionId, handle, sessionKey) {
     const wasActive = ACTIVE_EMBEDDED_RUNS.has(sessionId);
     ACTIVE_EMBEDDED_RUNS.set(sessionId, handle);
     logSessionStateChange({
         sessionId,
+        sessionKey,
         state: "processing",
         reason: wasActive ? "run_replaced" : "run_started",
     });
@@ -92,10 +101,10 @@ export function setActiveEmbeddedRun(sessionId, handle) {
         diag.debug(`run registered: sessionId=${sessionId} totalActive=${ACTIVE_EMBEDDED_RUNS.size}`);
     }
 }
-export function clearActiveEmbeddedRun(sessionId, handle) {
+export function clearActiveEmbeddedRun(sessionId, handle, sessionKey) {
     if (ACTIVE_EMBEDDED_RUNS.get(sessionId) === handle) {
         ACTIVE_EMBEDDED_RUNS.delete(sessionId);
-        logSessionStateChange({ sessionId, state: "idle", reason: "run_completed" });
+        logSessionStateChange({ sessionId, sessionKey, state: "idle", reason: "run_completed" });
         if (!sessionId.startsWith("probe-")) {
             diag.debug(`run cleared: sessionId=${sessionId} totalActive=${ACTIVE_EMBEDDED_RUNS.size}`);
         }