@poolzin/pool-bot 2026.2.21 → 2026.2.23

package/dist/agents/pi-embedded-runner/tool-result-context-guard.js

@@ -0,0 +1,262 @@
+const CHARS_PER_TOKEN_ESTIMATE = 4;
+// Keep a conservative input budget to absorb tokenizer variance and provider framing overhead.
+const CONTEXT_INPUT_HEADROOM_RATIO = 0.75;
+const SINGLE_TOOL_RESULT_CONTEXT_SHARE = 0.5;
+const TOOL_RESULT_CHARS_PER_TOKEN_ESTIMATE = 2;
+const IMAGE_CHAR_ESTIMATE = 8_000;
+export const CONTEXT_LIMIT_TRUNCATION_NOTICE = "[truncated: output exceeded context limit]";
+const CONTEXT_LIMIT_TRUNCATION_SUFFIX = `\n${CONTEXT_LIMIT_TRUNCATION_NOTICE}`;
+export const PREEMPTIVE_TOOL_RESULT_COMPACTION_PLACEHOLDER = "[compacted: tool output removed to free context]";
+function isTextBlock(block) {
+    return !!block && typeof block === "object" && block.type === "text";
+}
+function isImageBlock(block) {
+    return !!block && typeof block === "object" && block.type === "image";
+}
+function estimateUnknownChars(value) {
+    if (typeof value === "string") {
+        return value.length;
+    }
+    if (value === undefined) {
+        return 0;
+    }
+    try {
+        const serialized = JSON.stringify(value);
+        return typeof serialized === "string" ? serialized.length : 0;
+    }
+    catch {
+        return 256;
+    }
+}
+function isToolResultMessage(msg) {
+    const role = msg.role;
+    const type = msg.type;
+    return role === "toolResult" || role === "tool" || type === "toolResult";
+}
+function getToolResultContent(msg) {
+    if (!isToolResultMessage(msg)) {
+        return [];
+    }
+    const content = msg.content;
+    if (typeof content === "string") {
+        return [{ type: "text", text: content }];
+    }
+    return Array.isArray(content) ? content : [];
+}
+function getToolResultText(msg) {
+    const content = getToolResultContent(msg);
+    const chunks = [];
+    for (const block of content) {
+        if (isTextBlock(block)) {
+            chunks.push(block.text);
+        }
+    }
+    return chunks.join("\n");
+}
+function estimateMessageChars(msg) {
+    if (!msg || typeof msg !== "object") {
+        return 0;
+    }
+    if (msg.role === "user") {
+        const content = msg.content;
+        if (typeof content === "string") {
+            return content.length;
+        }
+        let chars = 0;
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                if (isTextBlock(block)) {
+                    chars += block.text.length;
+                }
+                else if (isImageBlock(block)) {
+                    chars += IMAGE_CHAR_ESTIMATE;
+                }
+                else {
+                    chars += estimateUnknownChars(block);
+                }
+            }
+        }
+        return chars;
+    }
+    if (msg.role === "assistant") {
+        let chars = 0;
+        const content = msg.content;
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                if (!block || typeof block !== "object") {
+                    continue;
+                }
+                const typed = block;
+                if (typed.type === "text" && typeof typed.text === "string") {
+                    chars += typed.text.length;
+                }
+                else if (typed.type === "thinking" && typeof typed.thinking === "string") {
+                    chars += typed.thinking.length;
+                }
+                else if (typed.type === "toolCall") {
+                    try {
+                        chars += JSON.stringify(typed.arguments ?? {}).length;
+                    }
+                    catch {
+                        chars += 128;
+                    }
+                }
+                else {
+                    chars += estimateUnknownChars(block);
+                }
+            }
+        }
+        return chars;
+    }
+    if (isToolResultMessage(msg)) {
+        let chars = 0;
+        const content = getToolResultContent(msg);
+        for (const block of content) {
+            if (isTextBlock(block)) {
+                chars += block.text.length;
+            }
+            else if (isImageBlock(block)) {
+                chars += IMAGE_CHAR_ESTIMATE;
+            }
+            else {
+                chars += estimateUnknownChars(block);
+            }
+        }
+        const details = msg.details;
+        chars += estimateUnknownChars(details);
+        const weightedChars = Math.ceil(chars * (CHARS_PER_TOKEN_ESTIMATE / TOOL_RESULT_CHARS_PER_TOKEN_ESTIMATE));
+        return Math.max(chars, weightedChars);
+    }
+    return 256;
+}
+function estimateContextChars(messages) {
+    return messages.reduce((sum, msg) => sum + estimateMessageChars(msg), 0);
+}
+function truncateTextToBudget(text, maxChars) {
+    if (text.length <= maxChars) {
+        return text;
+    }
+    if (maxChars <= 0) {
+        return CONTEXT_LIMIT_TRUNCATION_NOTICE;
+    }
+    const bodyBudget = Math.max(0, maxChars - CONTEXT_LIMIT_TRUNCATION_SUFFIX.length);
+    if (bodyBudget <= 0) {
+        return CONTEXT_LIMIT_TRUNCATION_NOTICE;
+    }
+    let cutPoint = bodyBudget;
+    const newline = text.lastIndexOf("\n", bodyBudget);
+    if (newline > bodyBudget * 0.7) {
+        cutPoint = newline;
+    }
+    return text.slice(0, cutPoint) + CONTEXT_LIMIT_TRUNCATION_SUFFIX;
+}
+function replaceToolResultText(msg, text) {
+    const content = msg.content;
+    const replacementContent = typeof content === "string" || content === undefined ? text : [{ type: "text", text }];
+    const sourceRecord = msg;
+    const { details: _details, ...rest } = sourceRecord;
+    return {
+        ...rest,
+        content: replacementContent,
+    };
+}
+function truncateToolResultToChars(msg, maxChars) {
+    if (!isToolResultMessage(msg)) {
+        return msg;
+    }
+    const estimatedChars = estimateMessageChars(msg);
+    if (estimatedChars <= maxChars) {
+        return msg;
+    }
+    const rawText = getToolResultText(msg);
+    if (!rawText) {
+        return replaceToolResultText(msg, CONTEXT_LIMIT_TRUNCATION_NOTICE);
+    }
+    const truncatedText = truncateTextToBudget(rawText, maxChars);
+    return replaceToolResultText(msg, truncatedText);
+}
+function compactExistingToolResultsInPlace(params) {
+    const { messages, charsNeeded } = params;
+    if (charsNeeded <= 0) {
+        return 0;
+    }
+    let reduced = 0;
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (!isToolResultMessage(msg)) {
+            continue;
+        }
+        const before = estimateMessageChars(msg);
+        if (before <= PREEMPTIVE_TOOL_RESULT_COMPACTION_PLACEHOLDER.length) {
+            continue;
+        }
+        const compacted = replaceToolResultText(msg, PREEMPTIVE_TOOL_RESULT_COMPACTION_PLACEHOLDER);
+        applyMessageMutationInPlace(msg, compacted);
+        const after = estimateMessageChars(msg);
+        if (after >= before) {
+            continue;
+        }
+        reduced += before - after;
+        if (reduced >= charsNeeded) {
+            break;
+        }
+    }
+    return reduced;
+}
+function applyMessageMutationInPlace(target, source) {
+    if (target === source) {
+        return;
+    }
+    const targetRecord = target;
+    const sourceRecord = source;
+    for (const key of Object.keys(targetRecord)) {
+        if (!(key in sourceRecord)) {
+            delete targetRecord[key];
+        }
+    }
+    Object.assign(targetRecord, sourceRecord);
+}
+function enforceToolResultContextBudgetInPlace(params) {
+    const { messages, contextBudgetChars, maxSingleToolResultChars } = params;
+    // Ensure each tool result has an upper bound before considering total context usage.
+    for (const message of messages) {
+        if (!isToolResultMessage(message)) {
+            continue;
+        }
+        const truncated = truncateToolResultToChars(message, maxSingleToolResultChars);
+        applyMessageMutationInPlace(message, truncated);
+    }
+    let currentChars = estimateContextChars(messages);
+    if (currentChars <= contextBudgetChars) {
+        return;
+    }
+    // Compact oldest tool outputs first until the context is back under budget.
+    compactExistingToolResultsInPlace({
+        messages,
+        charsNeeded: currentChars - contextBudgetChars,
+    });
+}
+export function installToolResultContextGuard(params) {
+    const contextWindowTokens = Math.max(1, Math.floor(params.contextWindowTokens));
+    const contextBudgetChars = Math.max(1_024, Math.floor(contextWindowTokens * CHARS_PER_TOKEN_ESTIMATE * CONTEXT_INPUT_HEADROOM_RATIO));
+    const maxSingleToolResultChars = Math.max(1_024, Math.floor(contextWindowTokens * TOOL_RESULT_CHARS_PER_TOKEN_ESTIMATE * SINGLE_TOOL_RESULT_CONTEXT_SHARE));
+    // Agent.transformContext is private in pi-coding-agent, so access it via a
+    // narrow runtime view to keep callsites type-safe while preserving behavior.
+    const mutableAgent = params.agent;
+    const originalTransformContext = mutableAgent.transformContext;
+    mutableAgent.transformContext = (async (messages, signal) => {
+        const transformed = originalTransformContext
+            ? await originalTransformContext.call(mutableAgent, messages, signal)
+            : messages;
+        const contextMessages = Array.isArray(transformed) ? transformed : messages;
+        enforceToolResultContextBudgetInPlace({
+            messages: contextMessages,
+            contextBudgetChars,
+            maxSingleToolResultChars,
+        });
+        return contextMessages;
+    });
+    return () => {
+        mutableAgent.transformContext = originalTransformContext;
+    };
+}

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

@@ -1,7 +1,7 @@
 export { compactEmbeddedPiSession } from "./pi-embedded-runner/compact.js";
 export { applyExtraParamsToAgent, resolveExtraParams } from "./pi-embedded-runner/extra-params.js";
 export { applyGoogleTurnOrderingFix } from "./pi-embedded-runner/google.js";
-export { getDmHistoryLimitFromSessionKey, limitHistoryTurns, } from "./pi-embedded-runner/history.js";
+export { getDmHistoryLimitFromSessionKey, getHistoryLimitFromSessionKey, limitHistoryTurns, } from "./pi-embedded-runner/history.js";
 export { resolveEmbeddedSessionLane } from "./pi-embedded-runner/lanes.js";
 export { runEmbeddedPiAgent } from "./pi-embedded-runner/run.js";
 export { abortEmbeddedPiRun, isEmbeddedPiRunActive, isEmbeddedPiRunStreaming, queueEmbeddedPiMessage, waitForEmbeddedPiRunEnd, } from "./pi-embedded-runner/runs.js";

package/dist/agents/pi-embedded-subscribe.handlers.tools.js

@@ -1,26 +1,107 @@
 import { emitAgentEvent } from "../infra/agent-events.js";
+import { getGlobalHookRunner } from "../plugins/hook-runner-global.js";
 import { normalizeTextForComparison } from "./pi-embedded-helpers.js";
 import { isMessagingTool, isMessagingToolSendAction } from "./pi-embedded-messaging.js";
-import { extractToolErrorMessage, extractToolResultText, extractMessagingToolSend, isToolResultError, sanitizeToolResult, } from "./pi-embedded-subscribe.tools.js";
+import { extractToolErrorMessage, extractToolResultMediaPaths, extractToolResultText, extractMessagingToolSend, isToolResultError, sanitizeToolResult, } from "./pi-embedded-subscribe.tools.js";
 import { inferToolMetaFromArgs } from "./pi-embedded-utils.js";
+import { buildToolMutationState, isSameToolMutationAction } from "./tool-mutation.js";
 import { normalizeToolName } from "./tool-policy.js";
+/** Track tool execution start times and args for after_tool_call hook */
+const toolStartData = new Map();
+function isCronAddAction(args) {
+    if (!args || typeof args !== "object") {
+        return false;
+    }
+    const action = args.action;
+    return typeof action === "string" && action.trim().toLowerCase() === "add";
+}
+function buildToolCallSummary(toolName, args, meta) {
+    const mutation = buildToolMutationState(toolName, args, meta);
+    return {
+        meta,
+        mutatingAction: mutation.mutatingAction,
+        actionFingerprint: mutation.actionFingerprint,
+    };
+}
 function extendExecMeta(toolName, args, meta) {
     const normalized = toolName.trim().toLowerCase();
-    if (normalized !== "exec" && normalized !== "bash")
+    if (normalized !== "exec" && normalized !== "bash") {
         return meta;
-    if (!args || typeof args !== "object")
+    }
+    if (!args || typeof args !== "object") {
         return meta;
+    }
     const record = args;
     const flags = [];
-    if (record.pty === true)
+    if (record.pty === true) {
         flags.push("pty");
-    if (record.elevated === true)
+    }
+    if (record.elevated === true) {
         flags.push("elevated");
-    if (flags.length === 0)
+    }
+    if (flags.length === 0) {
         return meta;
+    }
     const suffix = flags.join(" · ");
     return meta ? `${meta} · ${suffix}` : suffix;
 }
+function pushUniqueMediaUrl(urls, seen, value) {
+    if (typeof value !== "string") {
+        return;
+    }
+    const normalized = value.trim();
+    if (!normalized || seen.has(normalized)) {
+        return;
+    }
+    seen.add(normalized);
+    urls.push(normalized);
+}
+function collectMessagingMediaUrlsFromRecord(record) {
+    const urls = [];
+    const seen = new Set();
+    pushUniqueMediaUrl(urls, seen, record.media);
+    pushUniqueMediaUrl(urls, seen, record.mediaUrl);
+    pushUniqueMediaUrl(urls, seen, record.path);
+    pushUniqueMediaUrl(urls, seen, record.filePath);
+    const mediaUrls = record.mediaUrls;
+    if (Array.isArray(mediaUrls)) {
+        for (const mediaUrl of mediaUrls) {
+            pushUniqueMediaUrl(urls, seen, mediaUrl);
+        }
+    }
+    return urls;
+}
+function collectMessagingMediaUrlsFromToolResult(result) {
+    const urls = [];
+    const seen = new Set();
+    const appendFromRecord = (value) => {
+        if (!value || typeof value !== "object") {
+            return;
+        }
+        const extracted = collectMessagingMediaUrlsFromRecord(value);
+        for (const url of extracted) {
+            if (seen.has(url)) {
+                continue;
+            }
+            seen.add(url);
+            urls.push(url);
+        }
+    };
+    appendFromRecord(result);
+    if (result && typeof result === "object") {
+        appendFromRecord(result.details);
+    }
+    const outputText = extractToolResultText(result);
+    if (outputText) {
+        try {
+            appendFromRecord(JSON.parse(outputText));
+        }
+        catch {
+            // Ignore non-JSON tool output.
+        }
+    }
+    return urls;
+}
 export async function handleToolExecutionStart(ctx, evt) {
     // Flush pending block replies to preserve message boundaries before tool execution.
     ctx.flushBlockReplyBuffer();
@@ -31,16 +112,23 @@ export async function handleToolExecutionStart(ctx, evt) {
     const toolName = normalizeToolName(rawToolName);
     const toolCallId = String(evt.toolCallId);
     const args = evt.args;
+    // Track start time and args for after_tool_call hook
+    toolStartData.set(toolCallId, { startTime: Date.now(), args });
     if (toolName === "read") {
         const record = args && typeof args === "object" ? args : {};
-        const filePath = typeof record.path === "string" ? record.path.trim() : "";
+        const filePathValue = typeof record.path === "string"
+            ? record.path
+            : typeof record.file_path === "string"
+                ? record.file_path
+                : "";
+        const filePath = filePathValue.trim();
         if (!filePath) {
             const argsPreview = typeof args === "string" ? args.slice(0, 200) : undefined;
             ctx.log.warn(`read tool called without path: toolCallId=${toolCallId} argsType=${typeof args}${argsPreview ? ` argsPreview=${argsPreview}` : ""}`);
         }
     }
     const meta = extendExecMeta(toolName, args, inferToolMetaFromArgs(toolName, args));
-    ctx.state.toolMetaById.set(toolCallId, meta);
+    ctx.state.toolMetaById.set(toolCallId, buildToolCallSummary(toolName, args, meta));
     ctx.log.debug(`embedded run tool start: runId=${ctx.params.runId} tool=${toolName} toolCallId=${toolCallId}`);
     const shouldEmitToolEvents = ctx.shouldEmitToolResult();
     emitAgentEvent({
@@ -79,6 +167,11 @@ export async function handleToolExecutionStart(ctx, evt) {
                 ctx.state.pendingMessagingTexts.set(toolCallId, text);
                 ctx.log.debug(`Tracking pending messaging text: tool=${toolName} len=${text.length}`);
             }
+            // Track media URLs from messaging tool args (pending until tool_execution_end).
+            const mediaUrls = collectMessagingMediaUrlsFromRecord(argsRecord);
+            if (mediaUrls.length > 0) {
+                ctx.state.pendingMessagingMediaUrls.set(toolCallId, mediaUrls);
+            }
         }
     }
 }
@@ -106,14 +199,17 @@ export function handleToolExecutionUpdate(ctx, evt) {
         },
     });
 }
-export function handleToolExecutionEnd(ctx, evt) {
+export async function handleToolExecutionEnd(ctx, evt) {
     const toolName = normalizeToolName(String(evt.toolName));
     const toolCallId = String(evt.toolCallId);
     const isError = Boolean(evt.isError);
     const result = evt.result;
     const isToolError = isError || isToolResultError(result);
     const sanitizedResult = sanitizeToolResult(result);
-    const meta = ctx.state.toolMetaById.get(toolCallId);
+    const startData = toolStartData.get(toolCallId);
+    toolStartData.delete(toolCallId);
+    const callSummary = ctx.state.toolMetaById.get(toolCallId);
+    const meta = callSummary?.meta;
     ctx.state.toolMetas.push({ toolName, meta });
     ctx.state.toolMetaById.delete(toolCallId);
     ctx.state.toolSummaryById.delete(toolCallId);
@@ -123,8 +219,25 @@ export function handleToolExecutionEnd(ctx, evt) {
             toolName,
             meta,
             error: errorMessage,
+            mutatingAction: callSummary?.mutatingAction,
+            actionFingerprint: callSummary?.actionFingerprint,
         };
     }
+    else if (ctx.state.lastToolError) {
+        // Keep unresolved mutating failures until the same action succeeds.
+        if (ctx.state.lastToolError.mutatingAction) {
+            if (isSameToolMutationAction(ctx.state.lastToolError, {
+                toolName,
+                meta,
+                actionFingerprint: callSummary?.actionFingerprint,
+            })) {
+                ctx.state.lastToolError = undefined;
+            }
+        }
+        else {
+            ctx.state.lastToolError = undefined;
+        }
+    }
     // Commit messaging tool text on success, discard on error.
     const pendingText = ctx.state.pendingMessagingTexts.get(toolCallId);
     const pendingTarget = ctx.state.pendingMessagingTargets.get(toolCallId);
@@ -144,6 +257,27 @@ export function handleToolExecutionEnd(ctx, evt) {
             ctx.trimMessagingToolSent();
         }
     }
+    const pendingMediaUrls = ctx.state.pendingMessagingMediaUrls.get(toolCallId) ?? [];
+    ctx.state.pendingMessagingMediaUrls.delete(toolCallId);
+    const startArgs = startData?.args && typeof startData.args === "object"
+        ? startData.args
+        : {};
+    const isMessagingSend = pendingMediaUrls.length > 0 ||
+        (isMessagingTool(toolName) && isMessagingToolSendAction(toolName, startArgs));
+    if (!isToolError && isMessagingSend) {
+        const committedMediaUrls = [
+            ...pendingMediaUrls,
+            ...collectMessagingMediaUrlsFromToolResult(result),
+        ];
+        if (committedMediaUrls.length > 0) {
+            ctx.state.messagingToolSentMediaUrls.push(...committedMediaUrls);
+            ctx.trimMessagingToolSent();
+        }
+    }
+    // Track committed reminders only when cron.add completed successfully.
+    if (!isToolError && toolName === "cron" && isCronAddAction(startData?.args)) {
+        ctx.state.successfulCronAdds += 1;
+    }
     emitAgentEvent({
         runId: ctx.params.runId,
         stream: "tool",
@@ -173,4 +307,40 @@ export function handleToolExecutionEnd(ctx, evt) {
             ctx.emitToolOutput(toolName, meta, outputText);
         }
     }
+    // Deliver media from tool results when the verbose emitToolOutput path is off.
+    // When shouldEmitToolOutput() is true, emitToolOutput already delivers media
+    // via parseReplyDirectives (MEDIA: text extraction), so skip to avoid duplicates.
+    if (ctx.params.onToolResult && !isToolError && !ctx.shouldEmitToolOutput()) {
+        const mediaPaths = extractToolResultMediaPaths(result);
+        if (mediaPaths.length > 0) {
+            try {
+                void ctx.params.onToolResult({ mediaUrls: mediaPaths });
+            }
+            catch {
+                // ignore delivery failures
+            }
+        }
+    }
+    // Run after_tool_call plugin hook (fire-and-forget)
+    const hookRunnerAfter = ctx.hookRunner ?? getGlobalHookRunner();
+    if (hookRunnerAfter?.hasHooks("after_tool_call")) {
+        const durationMs = startData?.startTime != null ? Date.now() - startData.startTime : undefined;
+        const toolArgs = startData?.args;
+        const hookEvent = {
+            toolName,
+            params: (toolArgs && typeof toolArgs === "object" ? toolArgs : {}),
+            result: sanitizedResult,
+            error: isToolError ? extractToolErrorMessage(sanitizedResult) : undefined,
+            durationMs,
+        };
+        void hookRunnerAfter
+            .runAfterToolCall(hookEvent, {
+            toolName,
+            agentId: undefined,
+            sessionKey: undefined,
+        })
+            .catch((err) => {
+            ctx.log.warn(`after_tool_call hook failed: tool=${toolName} error=${String(err)}`);
+        });
+    }
 }

package/dist/agents/pi-embedded-subscribe.js

@@ -53,8 +53,11 @@ export function subscribeEmbeddedPiSession(params) {
         messagingToolSentTexts: [],
         messagingToolSentTextsNormalized: [],
         messagingToolSentTargets: [],
+        messagingToolSentMediaUrls: [],
         pendingMessagingTexts: new Map(),
         pendingMessagingTargets: new Map(),
+        successfulCronAdds: 0,
+        pendingMessagingMediaUrls: new Map(),
     };
     const usageTotals = {
         input: 0,
@@ -71,6 +74,7 @@ export function subscribeEmbeddedPiSession(params) {
     const messagingToolSentTexts = state.messagingToolSentTexts;
     const messagingToolSentTextsNormalized = state.messagingToolSentTextsNormalized;
     const messagingToolSentTargets = state.messagingToolSentTargets;
+    const messagingToolSentMediaUrls = state.messagingToolSentMediaUrls;
     const pendingMessagingTexts = state.pendingMessagingTexts;
     const pendingMessagingTargets = state.pendingMessagingTargets;
     const replyDirectiveAccumulator = createStreamingDirectiveAccumulator();
@@ -158,6 +162,7 @@ export function subscribeEmbeddedPiSession(params) {
     // These tools can send messages via sendMessage/threadReply actions (or sessions_send with message).
     const MAX_MESSAGING_SENT_TEXTS = 200;
     const MAX_MESSAGING_SENT_TARGETS = 200;
+    const MAX_MESSAGING_SENT_MEDIA_URLS = 200;
     const trimMessagingToolSent = () => {
         if (messagingToolSentTexts.length > MAX_MESSAGING_SENT_TEXTS) {
             const overflow = messagingToolSentTexts.length - MAX_MESSAGING_SENT_TEXTS;
@@ -168,13 +173,20 @@ export function subscribeEmbeddedPiSession(params) {
             const overflow = messagingToolSentTargets.length - MAX_MESSAGING_SENT_TARGETS;
             messagingToolSentTargets.splice(0, overflow);
         }
+        if (messagingToolSentMediaUrls.length > MAX_MESSAGING_SENT_MEDIA_URLS) {
+            const overflow = messagingToolSentMediaUrls.length - MAX_MESSAGING_SENT_MEDIA_URLS;
+            messagingToolSentMediaUrls.splice(0, overflow);
+        }
     };
     const ensureCompactionPromise = () => {
         if (!state.compactionRetryPromise) {
+            // Create a single promise that resolves when ALL pending compactions complete
+            // (tracked by pendingCompactionRetry counter, decremented in resolveCompactionRetry)
             state.compactionRetryPromise = new Promise((resolve, reject) => {
                 state.compactionRetryResolve = resolve;
                 state.compactionRetryReject = reject;
             });
+            // Prevent unhandled rejection if rejected after all consumers have resolved
             state.compactionRetryPromise.catch((err) => {
                 log.debug(`compaction promise rejected (no waiter): ${String(err)}`);
             });
@@ -469,9 +481,12 @@ export function subscribeEmbeddedPiSession(params) {
         if (formatted === state.lastStreamedReasoning) {
             return;
         }
+        // Compute delta: new text since the last emitted reasoning.
+        // Guard against non-prefix changes (e.g. trim/format altering earlier content).
         const prior = state.lastStreamedReasoning ?? "";
         const delta = formatted.startsWith(prior) ? formatted.slice(prior.length) : formatted;
         state.lastStreamedReasoning = formatted;
+        // Broadcast thinking event to WebSocket clients in real-time
         emitAgentEvent({
             runId: params.runId,
             stream: "thinking",
@@ -493,8 +508,11 @@ export function subscribeEmbeddedPiSession(params) {
         messagingToolSentTexts.length = 0;
         messagingToolSentTextsNormalized.length = 0;
         messagingToolSentTargets.length = 0;
+        messagingToolSentMediaUrls.length = 0;
         pendingMessagingTexts.clear();
         pendingMessagingTargets.clear();
+        state.successfulCronAdds = 0;
+        state.pendingMessagingMediaUrls.clear();
         resetAssistantMessageState(0);
     };
     const noteLastAssistant = (msg) => {
@@ -538,17 +556,33 @@ export function subscribeEmbeddedPiSession(params) {
         if (state.unsubscribed) {
             return;
         }
+        // Mark as unsubscribed FIRST to prevent waitForCompactionRetry from creating
+        // new un-resolvable promises during teardown.
         state.unsubscribed = true;
+        // Reject pending compaction wait to unblock awaiting code.
+        // Don't resolve, as that would incorrectly signal "compaction complete" when it's still in-flight.
         if (state.compactionRetryPromise) {
             log.debug(`unsubscribe: rejecting compaction wait runId=${params.runId}`);
             const reject = state.compactionRetryReject;
             state.compactionRetryResolve = undefined;
             state.compactionRetryReject = undefined;
             state.compactionRetryPromise = null;
+            // Reject with AbortError so it's caught by isAbortError() check in cleanup paths
             const abortErr = new Error("Unsubscribed during compaction");
             abortErr.name = "AbortError";
             reject?.(abortErr);
         }
+        // Cancel any in-flight compaction to prevent resource leaks when unsubscribing.
+        // Only abort if compaction is actually running to avoid unnecessary work.
+        if (params.session.isCompacting) {
+            log.debug(`unsubscribe: aborting in-flight compaction runId=${params.runId}`);
+            try {
+                params.session.abortCompaction();
+            }
+            catch (err) {
+                log.warn(`unsubscribe: compaction abort failed runId=${params.runId} err=${String(err)}`);
+            }
+        }
         sessionUnsubscribe();
     };
     return {
@@ -558,7 +592,9 @@ export function subscribeEmbeddedPiSession(params) {
         isCompacting: () => state.compactionInFlight || state.pendingCompactionRetry > 0,
         isCompactionInFlight: () => state.compactionInFlight,
         getMessagingToolSentTexts: () => messagingToolSentTexts.slice(),
+        getMessagingToolSentMediaUrls: () => messagingToolSentMediaUrls.slice(),
         getMessagingToolSentTargets: () => messagingToolSentTargets.slice(),
+        getSuccessfulCronAdds: () => state.successfulCronAdds,
         // Returns true if any messaging tool successfully sent a message.
         // Used to suppress agent's confirmation text (e.g., "Respondi no Telegram!")
         // which is generated AFTER the tool sends the actual answer.
@@ -567,6 +603,7 @@ export function subscribeEmbeddedPiSession(params) {
         getUsageTotals,
         getCompactionCount: () => compactionCount,
         waitForCompactionRetry: () => {
+            // Reject after unsubscribe so callers treat it as cancellation, not success
             if (state.unsubscribed) {
                 const err = new Error("Unsubscribed during compaction wait");
                 err.name = "AbortError";