@poolzin/pool-bot 2026.2.0 → 2026.2.1

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

@@ -24,6 +24,7 @@ import { isCloudCodeAssistFormatError, resolveBootstrapMaxChars, validateAnthrop
 import { subscribeEmbeddedPiSession } from "../../pi-embedded-subscribe.js";
 import { ensurePiCompactionReserveTokens, resolveCompactionReserveTokensFloor, } from "../../pi-settings.js";
 import { createPoolbotCodingTools } from "../../pi-tools.js";
+import { repairSessionFileIfNeeded } from "../../session-file-repair.js";
 import { resolveSandboxContext } from "../../sandbox.js";
 import { guardSessionManager } from "../../session-tool-result-guard-wrapper.js";
 import { resolveTranscriptPolicy } from "../../transcript-policy.js";
@@ -44,10 +45,11 @@ import { clearActiveEmbeddedRun, setActiveEmbeddedRun, } from "../runs.js";
 import { buildEmbeddedSandboxInfo } from "../sandbox-info.js";
 import { prewarmSessionFile, trackSessionManagerAccess } from "../session-manager-cache.js";
 import { prepareSessionManagerForRun } from "../session-manager-init.js";
-import { buildEmbeddedSystemPrompt, createSystemPromptOverride } from "../system-prompt.js";
+import { applySystemPromptOverrideToSession, buildEmbeddedSystemPrompt, createSystemPromptOverride, } from "../system-prompt.js";
 import { splitSdkTools } from "../tool-split.js";
 import { toClientToolDefinitions } from "../../pi-tool-definition-adapter.js";
 import { buildSystemPromptParams } from "../../system-prompt-params.js";
+import { detectRuntimeShell } from "../../shell-utils.js";
 import { describeUnknownError, mapThinkingLevel } from "../utils.js";
 import { resolveSandboxRuntimeStatus } from "../../sandbox/runtime-status.js";
 import { buildTtsSystemPromptHint } from "../../../tts/tts.js";
@@ -164,6 +166,7 @@ export async function runEmbeddedAttempt(params) {
                 senderName: params.senderName,
                 senderUsername: params.senderUsername,
                 senderE164: params.senderE164,
+                senderIsOwner: params.senderIsOwner,
                 sessionKey: params.sessionKey ?? params.sessionId,
                 agentDir,
                 workspaceDir: effectiveWorkspace,
@@ -177,6 +180,8 @@ export async function runEmbeddedAttempt(params) {
                 replyToMode: params.replyToMode,
                 hasRepliedRef: params.hasRepliedRef,
                 modelHasVision,
+                requireExplicitMessageTarget: params.requireExplicitMessageTarget ?? isSubagentSessionKey(params.sessionKey),
+                disableMessageTool: params.disableMessageTool,
             });
         const tools = sanitizeToolsForGoogle({ tools: toolsRaw, provider: params.provider });
         logToolSchemasForGoogle({ tools, provider: params.provider });
@@ -263,6 +268,7 @@ export async function runEmbeddedAttempt(params) {
                 channel: runtimeChannel,
                 capabilities: runtimeCapabilities,
                 channelActions,
+                shell: detectRuntimeShell(),
             },
         });
         const isDefaultAgent = sessionAgentId === defaultAgentId;
@@ -299,6 +305,7 @@ export async function runEmbeddedAttempt(params) {
             userTime,
             userTimeFormat,
             contextFiles,
+            memoryCitationsMode: params.config?.memory?.citations,
         });
         const systemPromptReport = buildSystemPromptReport({
             source: "run",
@@ -322,13 +329,18 @@ export async function runEmbeddedAttempt(params) {
             skillsPrompt,
             tools,
         });
-        const systemPrompt = createSystemPromptOverride(appendPrompt);
+        const systemPromptOverride = createSystemPromptOverride(appendPrompt);
+        const systemPromptText = systemPromptOverride();
         const sessionLock = await acquireSessionWriteLock({
             sessionFile: params.sessionFile,
         });
         let sessionManager;
         let session;
         try {
+            await repairSessionFileIfNeeded({
+                sessionFile: params.sessionFile,
+                warn: (message) => log.warn(message),
+            });
             const hadSessionFile = await fs
                 .stat(params.sessionFile)
                 .then(() => true)
@@ -357,7 +369,7 @@ export async function runEmbeddedAttempt(params) {
                 settingsManager,
                 minReserveTokens: resolveCompactionReserveTokensFloor(params.config),
             });
-            const additionalExtensionPaths = buildEmbeddedExtensionPaths({
+            buildEmbeddedExtensionPaths({
                 cfg: params.config,
                 sessionManager,
                 provider: params.provider,
@@ -373,7 +385,7 @@ export async function runEmbeddedAttempt(params) {
             const clientToolDefs = params.clientTools
                 ? toClientToolDefinitions(params.clientTools, (toolName, toolParams) => {
                     clientToolCallDetected = { name: toolName, params: toolParams };
-                })
+                }, { agentId: sessionAgentId, sessionKey: params.sessionKey })
                 : [];
             const allCustomTools = [...customTools, ...clientToolDefs];
             ({ session } = await createAgentSession({
@@ -383,15 +395,12 @@ export async function runEmbeddedAttempt(params) {
                 modelRegistry: params.modelRegistry,
                 model: params.model,
                 thinkingLevel: mapThinkingLevel(params.thinkLevel),
-                systemPrompt,
                 tools: builtInTools,
                 customTools: allCustomTools,
                 sessionManager,
                 settingsManager,
-                skills: [],
-                contextFiles: [],
-                additionalExtensionPaths,
             }));
+            applySystemPromptOverrideToSession(session, systemPromptText);
             if (!session) {
                 throw new Error("Embedded agent session missing");
             }
@@ -423,7 +432,7 @@ export async function runEmbeddedAttempt(params) {
             if (cacheTrace) {
                 cacheTrace.recordStage("session:loaded", {
                     messages: activeSession.messages,
-                    system: systemPrompt,
+                    system: systemPromptText,
                     note: "after session create",
                 });
                 activeSession.agent.streamFn = cacheTrace.wrapStreamFn(activeSession.agent.streamFn);
@@ -570,6 +579,7 @@ export async function runEmbeddedAttempt(params) {
             }
             // Get hook runner once for both before_agent_start and agent_end hooks
             const hookRunner = getGlobalHookRunner();
+            const hookAgentId = sessionAgentId;
             let promptError = null;
             try {
                 const promptStartedAt = Date.now();
@@ -581,7 +591,7 @@ export async function runEmbeddedAttempt(params) {
                             prompt: params.prompt,
                             messages: activeSession.messages,
                         }, {
-                            agentId: params.sessionKey?.split(":")[0] ?? "main",
+                            agentId: hookAgentId,
                             sessionKey: params.sessionKey,
                             workspaceDir: params.workspaceDir,
                             messageProvider: params.messageProvider ?? undefined,
@@ -694,7 +704,7 @@ export async function runEmbeddedAttempt(params) {
                         error: promptError ? describeUnknownError(promptError) : undefined,
                         durationMs: Date.now() - promptStartedAt,
                     }, {
-                        agentId: params.sessionKey?.split(":")[0] ?? "main",
+                        agentId: hookAgentId,
                         sessionKey: params.sessionKey,
                         workspaceDir: params.workspaceDir,
                         messageProvider: params.messageProvider ?? undefined,

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

@@ -1,6 +1,5 @@
 import fs from "node:fs/promises";
 import { enqueueCommandInLane } from "../../process/command-queue.js";
-import { resolveUserPath } from "../../utils.js";
 import { isMarkdownCapableMessageChannel } from "../../utils/message-channel.js";
 import { resolvePoolbotAgentDir } from "../agent-paths.js";
 import { isProfileInCooldown, markAuthProfileFailure, markAuthProfileGood, markAuthProfileUsed, } from "../auth-profiles.js";
@@ -10,14 +9,16 @@ 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 { classifyFailoverReason, formatAssistantErrorText, isAuthAssistantError, isCompactionFailureError, isContextOverflowError, isFailoverAssistantError, isFailoverErrorMessage, parseImageDimensionError, isRateLimitAssistantError, isTimeoutErrorMessage, pickFallbackThinkingLevel, } from "../pi-embedded-helpers.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 { redactRunIdentifier, resolveRunWorkspaceDir } from "../workspace-run.js";
 import { compactEmbeddedPiSessionDirect } from "./compact.js";
 import { resolveGlobalLane, resolveSessionLane } from "./lanes.js";
 import { log } from "./logger.js";
 import { resolveModel } from "./model.js";
 import { runEmbeddedAttempt } from "./run/attempt.js";
 import { buildEmbeddedRunPayloads } from "./run/payloads.js";
+import { truncateOversizedToolResultsInSession, sessionLikelyHasOversizedToolResults, } from "./tool-result-truncation.js";
 import { describeUnknownError } from "./utils.js";
 // Avoid Anthropic's refusal test token poisoning session transcripts.
 const ANTHROPIC_MAGIC_STRING_TRIGGER_REFUSAL = "ANTHROPIC_MAGIC_STRING_TRIGGER_REFUSAL";
@@ -27,6 +28,45 @@ function scrubAnthropicRefusalMagic(prompt) {
         return prompt;
     return prompt.replaceAll(ANTHROPIC_MAGIC_STRING_TRIGGER_REFUSAL, ANTHROPIC_MAGIC_STRING_REPLACEMENT);
 }
+const createUsageAccumulator = () => ({
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    total: 0,
+});
+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) => {
+    if (!hasUsageValues(usage)) {
+        return;
+    }
+    target.input += usage.input ?? 0;
+    target.output += usage.output ?? 0;
+    target.cacheRead += usage.cacheRead ?? 0;
+    target.cacheWrite += usage.cacheWrite ?? 0;
+    target.total +=
+        usage.total ??
+            (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+};
+const toNormalizedUsage = (usage) => {
+    const hasUsage = usage.input > 0 ||
+        usage.output > 0 ||
+        usage.cacheRead > 0 ||
+        usage.cacheWrite > 0 ||
+        usage.total > 0;
+    if (!hasUsage) {
+        return undefined;
+    }
+    const derivedTotal = usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+    return {
+        input: usage.input || undefined,
+        output: usage.output || undefined,
+        cacheRead: usage.cacheRead || undefined,
+        cacheWrite: usage.cacheWrite || undefined,
+        total: usage.total || derivedTotal || undefined,
+    };
+};
 export async function runEmbeddedPiAgent(params) {
     const sessionLane = resolveSessionLane(params.sessionKey?.trim() || params.sessionId);
     const globalLane = resolveGlobalLane(params.lane);
@@ -42,7 +82,18 @@ export async function runEmbeddedPiAgent(params) {
     const isProbeSession = params.sessionId?.startsWith("probe-") ?? false;
     return enqueueSession(() => enqueueGlobal(async () => {
         const started = Date.now();
-        const resolvedWorkspace = resolveUserPath(params.workspaceDir);
+        const workspaceResolution = resolveRunWorkspaceDir({
+            workspaceDir: params.workspaceDir,
+            sessionKey: params.sessionKey,
+            config: params.config,
+        });
+        const resolvedWorkspace = workspaceResolution.workspaceDir;
+        const redactedSessionId = redactRunIdentifier(params.sessionId);
+        const redactedSessionKey = redactRunIdentifier(params.sessionKey);
+        const redactedWorkspace = redactRunIdentifier(resolvedWorkspace);
+        if (workspaceResolution.usedFallback) {
+            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;
@@ -213,7 +264,11 @@ export async function runEmbeddedPiAgent(params) {
                 throwAuthProfileFailover({ allInCooldown: false, error: err });
             }
         }
-        let overflowCompactionAttempted = false;
+        const MAX_OVERFLOW_COMPACTION_ATTEMPTS = 3;
+        let overflowCompactionAttempts = 0;
+        let toolResultTruncationAttempted = false;
+        const usageAccumulator = createUsageAccumulator();
+        let autoCompactionCount = 0;
         try {
             while (true) {
                 attemptedThinking.add(thinkLevel);
@@ -231,12 +286,13 @@ export async function runEmbeddedPiAgent(params) {
                     groupChannel: params.groupChannel,
                     groupSpace: params.groupSpace,
                     spawnedBy: params.spawnedBy,
+                    senderIsOwner: params.senderIsOwner,
                     currentChannelId: params.currentChannelId,
                     currentThreadTs: params.currentThreadTs,
                     replyToMode: params.replyToMode,
                     hasRepliedRef: params.hasRepliedRef,
                     sessionFile: params.sessionFile,
-                    workspaceDir: params.workspaceDir,
+                    workspaceDir: resolvedWorkspace,
                     agentDir,
                     config: params.config,
                     skillsSnapshot: params.skillsSnapshot,
@@ -274,46 +330,135 @@ export async function runEmbeddedPiAgent(params) {
                     enforceFinalTag: params.enforceFinalTag,
                 });
                 const { aborted, promptError, timedOut, sessionIdUsed, lastAssistant } = attempt;
-                if (promptError && !aborted) {
-                    const errorText = describeUnknownError(promptError);
-                    if (isContextOverflowError(errorText)) {
-                        const isCompactionFailure = isCompactionFailureError(errorText);
-                        // Attempt auto-compaction on context overflow (not compaction_failure)
-                        if (!isCompactionFailure && !overflowCompactionAttempted) {
-                            log.warn(`context overflow detected; attempting auto-compaction for ${provider}/${modelId}`);
-                            overflowCompactionAttempted = true;
-                            const compactResult = await compactEmbeddedPiSessionDirect({
+                mergeUsageIntoAccumulator(usageAccumulator, attempt.attemptUsage ?? normalizeUsage(lastAssistant?.usage));
+                autoCompactionCount += Math.max(0, attempt.compactionCount ?? 0);
+                const formattedAssistantErrorText = lastAssistant
+                    ? formatAssistantErrorText(lastAssistant, {
+                        cfg: params.config,
+                        sessionKey: params.sessionKey ?? params.sessionId,
+                    })
+                    : undefined;
+                const assistantErrorText = lastAssistant?.stopReason === "error"
+                    ? lastAssistant.errorMessage?.trim() || formattedAssistantErrorText
+                    : undefined;
+                const contextOverflowError = !aborted
+                    ? (() => {
+                        if (promptError) {
+                            const errorText = describeUnknownError(promptError);
+                            if (isContextOverflowError(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)) {
+                            return { text: assistantErrorText, source: "assistantError" };
+                        }
+                        return null;
+                    })()
+                    : null;
+                if (contextOverflowError) {
+                    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)}`);
+                    const isCompactionFailure = isCompactionFailureError(errorText);
+                    // Attempt auto-compaction on context overflow (not compaction_failure)
+                    if (!isCompactionFailure &&
+                        overflowCompactionAttempts < 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({
+                            sessionId: params.sessionId,
+                            sessionKey: params.sessionKey,
+                            messageChannel: params.messageChannel,
+                            messageProvider: params.messageProvider,
+                            agentAccountId: params.agentAccountId,
+                            authProfileId: lastProfileId,
+                            sessionFile: params.sessionFile,
+                            workspaceDir: resolvedWorkspace,
+                            agentDir,
+                            config: params.config,
+                            skillsSnapshot: params.skillsSnapshot,
+                            senderIsOwner: params.senderIsOwner,
+                            provider,
+                            model: modelId,
+                            thinkLevel,
+                            reasoningLevel: params.reasoningLevel,
+                            bashElevated: params.bashElevated,
+                            extraSystemPrompt: params.extraSystemPrompt,
+                            ownerNumbers: params.ownerNumbers,
+                        });
+                        if (compactResult.compacted) {
+                            autoCompactionCount += 1;
+                            log.info(`auto-compaction succeeded for ${provider}/${modelId}; retrying prompt`);
+                            continue;
+                        }
+                        log.warn(`auto-compaction failed for ${provider}/${modelId}: ${compactResult.reason ?? "nothing to compact"}`);
+                    }
+                    // Fallback: try truncating oversized tool results in the session.
+                    // This handles the case where a single tool result exceeds the
+                    // context window and compaction cannot reduce it further.
+                    if (!toolResultTruncationAttempted) {
+                        const contextWindowTokens = ctxInfo.tokens;
+                        const hasOversized = attempt.messagesSnapshot
+                            ? sessionLikelyHasOversizedToolResults({
+                                messages: attempt.messagesSnapshot,
+                                contextWindowTokens,
+                            })
+                            : false;
+                        if (hasOversized) {
+                            toolResultTruncationAttempted = true;
+                            log.warn(`[context-overflow-recovery] Attempting tool result truncation for ${provider}/${modelId} ` +
+                                `(contextWindow=${contextWindowTokens} tokens)`);
+                            const truncResult = await truncateOversizedToolResultsInSession({
+                                sessionFile: params.sessionFile,
+                                contextWindowTokens,
                                 sessionId: params.sessionId,
                                 sessionKey: params.sessionKey,
-                                messageChannel: params.messageChannel,
-                                messageProvider: params.messageProvider,
-                                agentAccountId: params.agentAccountId,
-                                authProfileId: lastProfileId,
-                                sessionFile: params.sessionFile,
-                                workspaceDir: params.workspaceDir,
-                                agentDir,
-                                config: params.config,
-                                skillsSnapshot: params.skillsSnapshot,
-                                provider,
-                                model: modelId,
-                                thinkLevel,
-                                reasoningLevel: params.reasoningLevel,
-                                bashElevated: params.bashElevated,
-                                extraSystemPrompt: params.extraSystemPrompt,
-                                ownerNumbers: params.ownerNumbers,
                             });
-                            if (compactResult.compacted) {
-                                log.info(`auto-compaction succeeded for ${provider}/${modelId}; retrying prompt`);
+                            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;
                                 continue;
                             }
-                            log.warn(`auto-compaction failed for ${provider}/${modelId}: ${compactResult.reason ?? "nothing to compact"}`);
+                            log.warn(`[context-overflow-recovery] Tool result truncation did not help: ${truncResult.reason ?? "unknown"}`);
                         }
-                        const kind = isCompactionFailure ? "compaction_failure" : "context_overflow";
+                    }
+                    const kind = isCompactionFailure ? "compaction_failure" : "context_overflow";
+                    return {
+                        payloads: [
+                            {
+                                text: "Context overflow: prompt too large for the model. " +
+                                    "Try /reset (or /new) to start a fresh session, or use a larger-context model.",
+                                isError: true,
+                            },
+                        ],
+                        meta: {
+                            durationMs: Date.now() - started,
+                            agentMeta: {
+                                sessionId: sessionIdUsed,
+                                provider,
+                                model: model.id,
+                            },
+                            systemPromptReport: attempt.systemPromptReport,
+                            error: { kind, message: errorText },
+                        },
+                    };
+                }
+                if (promptError && !aborted) {
+                    const errorText = describeUnknownError(promptError);
+                    // Handle role ordering errors with a user-friendly message
+                    if (/incorrect role information|roles must alternate/i.test(errorText)) {
                         return {
                             payloads: [
                                 {
-                                    text: "Context overflow: prompt too large for the model. " +
-                                        "Try again with less input or a larger-context model.",
+                                    text: "Message ordering conflict - please try again. " +
+                                        "If this persists, use /new to start a fresh session.",
                                     isError: true,
                                 },
                             ],
@@ -325,17 +470,21 @@ export async function runEmbeddedPiAgent(params) {
                                     model: model.id,
                                 },
                                 systemPromptReport: attempt.systemPromptReport,
-                                error: { kind, message: errorText },
+                                error: { kind: "role_ordering", message: errorText },
                             },
                         };
                     }
-                    // Handle role ordering errors with a user-friendly message
-                    if (/incorrect role information|roles must alternate/i.test(errorText)) {
+                    // Handle image size errors with a user-friendly message (no retry needed)
+                    const imageSizeError = parseImageSizeError(errorText);
+                    if (imageSizeError) {
+                        const maxMb = imageSizeError.maxMb;
+                        const maxMbLabel = typeof maxMb === "number" && Number.isFinite(maxMb) ? `${maxMb}` : null;
+                        const maxBytesHint = maxMbLabel ? ` (max ${maxMbLabel}MB)` : "";
                         return {
                             payloads: [
                                 {
-                                    text: "Message ordering conflict - please try again. " +
-                                        "If this persists, use /new to start a fresh session.",
+                                    text: `Image too large for the model${maxBytesHint}. ` +
+                                        "Please compress or resize the image and try again.",
                                     isError: true,
                                 },
                             ],
@@ -347,7 +496,7 @@ export async function runEmbeddedPiAgent(params) {
                                     model: model.id,
                                 },
                                 systemPromptReport: attempt.systemPromptReport,
-                                error: { kind: "role_ordering", message: errorText },
+                                error: { kind: "image_size", message: errorText },
                             },
                         };
                     }
@@ -399,6 +548,7 @@ export async function runEmbeddedPiAgent(params) {
                 }
                 const authFailure = isAuthAssistantError(lastAssistant);
                 const rateLimitFailure = isRateLimitAssistantError(lastAssistant);
+                const billingFailure = isBillingAssistantError(lastAssistant);
                 const failoverFailure = isFailoverAssistantError(lastAssistant);
                 const assistantFailoverReason = classifyFailoverReason(lastAssistant?.errorMessage ?? "");
                 const cloudCodeAssistFormatError = attempt.cloudCodeAssistFormatError;
@@ -456,9 +606,11 @@ export async function runEmbeddedPiAgent(params) {
                                 ? "LLM request timed out."
                                 : rateLimitFailure
                                     ? "LLM request rate limited."
-                                    : authFailure
-                                        ? "LLM request unauthorized."
-                                        : "LLM request failed.");
+                                    : billingFailure
+                                        ? BILLING_ERROR_USER_MESSAGE
+                                        : authFailure
+                                            ? "LLM request unauthorized."
+                                            : "LLM request failed.");
                         const status = resolveFailoverStatus(assistantFailoverReason ?? "unknown") ??
                             (isTimeoutErrorMessage(message) ? 408 : undefined);
                         throw new FailoverError(message, {
@@ -470,12 +622,13 @@ export async function runEmbeddedPiAgent(params) {
                         });
                     }
                 }
-                const usage = normalizeUsage(lastAssistant?.usage);
+                const usage = toNormalizedUsage(usageAccumulator);
                 const agentMeta = {
                     sessionId: sessionIdUsed,
                     provider: lastAssistant?.provider ?? provider,
                     model: lastAssistant?.model ?? model.id,
                     usage,
+                    compactionCount: autoCompactionCount > 0 ? autoCompactionCount : undefined,
                 };
                 const payloads = buildEmbeddedRunPayloads({
                     assistantTexts: attempt.assistantTexts,

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

@@ -25,9 +25,17 @@ export function buildEmbeddedSystemPrompt(params) {
         userTime: params.userTime,
         userTimeFormat: params.userTimeFormat,
         contextFiles: params.contextFiles,
+        memoryCitationsMode: params.memoryCitationsMode,
     });
 }
 export function createSystemPromptOverride(systemPrompt) {
-    const trimmed = systemPrompt.trim();
-    return () => trimmed;
+    const override = systemPrompt.trim();
+    return (_defaultPrompt) => override;
+}
+export function applySystemPromptOverrideToSession(session, override) {
+    const prompt = typeof override === "function" ? override() : override.trim();
+    session.agent.setSystemPrompt(prompt);
+    const mutableSession = session;
+    mutableSession._baseSystemPrompt = prompt;
+    mutableSession._rebuildSystemPrompt = () => prompt;
 }