@poolzin/pool-bot 2026.1.39 → 2026.2.1

package/dist/cron/isolated-agent/run.js

@@ -2,6 +2,7 @@ import { resolveAgentConfig, resolveAgentDir, resolveAgentModelFallbacksOverride
 import { runCliAgent } from "../../agents/cli-runner.js";
 import { getCliSessionId, setCliSessionId } from "../../agents/cli-session.js";
 import { lookupContextTokens } from "../../agents/context.js";
+import { formatUserTime, resolveUserTimeFormat, resolveUserTimezone, } from "../../agents/date-time.js";
 import { DEFAULT_CONTEXT_TOKENS, DEFAULT_MODEL, DEFAULT_PROVIDER } from "../../agents/defaults.js";
 import { loadModelCatalog } from "../../agents/model-catalog.js";
 import { runWithModelFallback } from "../../agents/model-fallback.js";
@@ -9,34 +10,46 @@ import { getModelRefStatus, isCliProvider, resolveAllowedModelRef, resolveConfig
 import { runEmbeddedPiAgent } from "../../agents/pi-embedded.js";
 import { buildWorkspaceSkillSnapshot } from "../../agents/skills.js";
 import { getSkillsSnapshotVersion } from "../../agents/skills/refresh.js";
+import { runSubagentAnnounceFlow } from "../../agents/subagent-announce.js";
 import { resolveAgentTimeoutMs } from "../../agents/timeout.js";
-import { hasNonzeroUsage } from "../../agents/usage.js";
+import { deriveSessionTotalTokens, hasNonzeroUsage } from "../../agents/usage.js";
 import { ensureAgentWorkspace } from "../../agents/workspace.js";
-import { formatUserTime, resolveUserTimeFormat, resolveUserTimezone, } from "../../agents/date-time.js";
-import { formatXHighModelHint, normalizeThinkLevel, normalizeVerboseLevel, supportsXHighThinking, } from "../../auto-reply/thinking.js";
+import { normalizeThinkLevel, normalizeVerboseLevel, supportsXHighThinking, } from "../../auto-reply/thinking.js";
 import { createOutboundSendDeps } from "../../cli/outbound-send-deps.js";
-import { resolveSessionTranscriptPath, updateSessionStore } from "../../config/sessions.js";
+import { resolveAgentMainSessionKey, resolveSessionTranscriptPath, updateSessionStore, } from "../../config/sessions.js";
 import { registerAgentRunContext } from "../../infra/agent-events.js";
 import { deliverOutboundPayloads } from "../../infra/outbound/deliver.js";
 import { getRemoteSkillEligibility } from "../../infra/skills-remote.js";
+import { logWarn } from "../../logger.js";
 import { buildAgentMainSessionKey, normalizeAgentId } from "../../routing/session-key.js";
 import { buildSafeExternalPrompt, detectSuspiciousPatterns, getHookType, isExternalHookSession, } from "../../security/external-content.js";
-import { logWarn } from "../../logger.js";
+import { resolveCronDeliveryPlan } from "../delivery.js";
 import { resolveDeliveryTarget } from "./delivery-target.js";
-import { isHeartbeatOnlyResponse, pickLastNonEmptyTextFromPayloads, pickSummaryFromOutput, pickSummaryFromPayloads, resolveHeartbeatAckMaxChars, } from "./helpers.js";
+import { isHeartbeatOnlyResponse, pickLastDeliverablePayload, pickLastNonEmptyTextFromPayloads, pickSummaryFromOutput, pickSummaryFromPayloads, resolveHeartbeatAckMaxChars, } from "./helpers.js";
 import { resolveCronSession } from "./session.js";
 function matchesMessagingToolDeliveryTarget(target, delivery) {
-    if (!delivery.to || !target.to)
+    if (!delivery.to || !target.to) {
         return false;
+    }
     const channel = delivery.channel.trim().toLowerCase();
     const provider = target.provider?.trim().toLowerCase();
-    if (provider && provider !== "message" && provider !== channel)
+    if (provider && provider !== "message" && provider !== channel) {
         return false;
+    }
     if (target.accountId && delivery.accountId && target.accountId !== delivery.accountId) {
         return false;
     }
     return target.to === delivery.to;
 }
+function resolveCronDeliveryBestEffort(job) {
+    if (typeof job.delivery?.bestEffort === "boolean") {
+        return job.delivery.bestEffort;
+    }
+    if (job.payload.kind === "agentTurn" && typeof job.payload.bestEffortDeliver === "boolean") {
+        return job.payload.bestEffortDeliver;
+    }
+    return false;
+}
 export async function runCronIsolatedAgentTurn(params) {
     const defaultAgentId = resolveDefaultAgentId(params.cfg);
     const requestedAgentId = typeof params.agentId === "string" && params.agentId.trim()
@@ -109,14 +122,12 @@ export async function runCronIsolatedAgentTurn(params) {
         }
     }
     const modelOverrideRaw = params.job.payload.kind === "agentTurn" ? params.job.payload.model : undefined;
-    if (modelOverrideRaw !== undefined) {
-        if (typeof modelOverrideRaw !== "string") {
-            return { status: "error", error: "invalid model: expected string" };
-        }
+    const modelOverride = typeof modelOverrideRaw === "string" ? modelOverrideRaw.trim() : undefined;
+    if (modelOverride !== undefined && modelOverride.length > 0) {
         const resolvedOverride = resolveAllowedModelRef({
             cfg: cfgWithAgentDefaults,
             catalog: await loadCatalog(),
-            raw: modelOverrideRaw,
+            raw: modelOverride,
             defaultProvider: resolvedDefault.provider,
             defaultModel: resolvedDefault.model,
         });
@@ -133,6 +144,33 @@ export async function runCronIsolatedAgentTurn(params) {
         agentId,
         nowMs: now,
     });
+    const runSessionId = cronSession.sessionEntry.sessionId;
+    const runSessionKey = baseSessionKey.startsWith("cron:")
+        ? `${agentSessionKey}:run:${runSessionId}`
+        : agentSessionKey;
+    const persistSessionEntry = async () => {
+        cronSession.store[agentSessionKey] = cronSession.sessionEntry;
+        if (runSessionKey !== agentSessionKey) {
+            cronSession.store[runSessionKey] = cronSession.sessionEntry;
+        }
+        await updateSessionStore(cronSession.storePath, (store) => {
+            store[agentSessionKey] = cronSession.sessionEntry;
+            if (runSessionKey !== agentSessionKey) {
+                store[runSessionKey] = cronSession.sessionEntry;
+            }
+        });
+    };
+    const withRunSession = (result) => ({
+        ...result,
+        sessionId: runSessionId,
+        sessionKey: runSessionKey,
+    });
+    if (!cronSession.sessionEntry.label?.trim() && baseSessionKey.startsWith("cron:")) {
+        const labelSuffix = typeof params.job.name === "string" && params.job.name.trim()
+            ? params.job.name.trim()
+            : params.job.id;
+        cronSession.sessionEntry.label = `Cron: ${labelSuffix}`;
+    }
     // Resolve thinking level - job thinking > hooks.gmail.thinking > agent default
     const hooksGmailThinking = isGmailHook
         ? normalizeThinkLevel(params.cfg.hooks?.gmail?.thinking)
@@ -150,20 +188,19 @@ export async function runCronIsolatedAgentTurn(params) {
         });
     }
     if (thinkLevel === "xhigh" && !supportsXHighThinking(provider, model)) {
-        throw new Error(`Thinking level "xhigh" is only supported for ${formatXHighModelHint()}.`);
+        logWarn(`[cron:${params.job.id}] Thinking level "xhigh" is not supported for ${provider}/${model}; downgrading to "high".`);
+        thinkLevel = "high";
     }
     const timeoutMs = resolveAgentTimeoutMs({
         cfg: cfgWithAgentDefaults,
         overrideSeconds: params.job.payload.kind === "agentTurn" ? params.job.payload.timeoutSeconds : undefined,
     });
     const agentPayload = params.job.payload.kind === "agentTurn" ? params.job.payload : null;
-    const deliveryMode = agentPayload?.deliver === true ? "explicit" : agentPayload?.deliver === false ? "off" : "auto";
-    const hasExplicitTarget = Boolean(agentPayload?.to && agentPayload.to.trim());
-    const deliveryRequested = deliveryMode === "explicit" || (deliveryMode === "auto" && hasExplicitTarget);
-    const bestEffortDeliver = agentPayload?.bestEffortDeliver === true;
+    const deliveryPlan = resolveCronDeliveryPlan(params.job);
+    const deliveryRequested = deliveryPlan.requested;
     const resolvedDelivery = await resolveDeliveryTarget(cfgWithAgentDefaults, agentId, {
-        channel: agentPayload?.channel ?? "last",
-        to: agentPayload?.to,
+        channel: deliveryPlan.channel ?? "last",
+        to: deliveryPlan.to,
     });
     const userTimezone = resolveUserTimezone(params.cfg.agents?.defaults?.userTimezone);
     const userTimeFormat = resolveUserTimeFormat(params.cfg.agents?.defaults?.timeFormat);
@@ -182,8 +219,7 @@ export async function runCronIsolatedAgentTurn(params) {
         const suspiciousPatterns = detectSuspiciousPatterns(params.message);
         if (suspiciousPatterns.length > 0) {
             logWarn(`[security] Suspicious patterns detected in external hook content ` +
-                `(session=${baseSessionKey}, patterns=${suspiciousPatterns.length}): ` +
-                `${suspiciousPatterns.slice(0, 3).join(", ")}`);
+                `(session=${baseSessionKey}, patterns=${suspiciousPatterns.length}): ${suspiciousPatterns.slice(0, 3).join(", ")}`);
         }
     }
     if (shouldWrapExternal) {
@@ -202,6 +238,10 @@ export async function runCronIsolatedAgentTurn(params) {
         // Internal/trusted source - use original format
         commandBody = `${base}\n${timeLine}`.trim();
     }
+    if (deliveryRequested) {
+        commandBody =
+            `${commandBody}\n\nReturn your summary as plain text; it will be delivered automatically. If the task explicitly calls for messaging a specific external recipient, note who/where it should go instead of sending it yourself.`.trim();
+    }
     const existingSnapshot = cronSession.sessionEntry.skillsSnapshot;
     const skillsSnapshotVersion = getSkillsSnapshotVersion(workspaceDir);
     const needsSkillsSnapshot = !existingSnapshot || existingSnapshot.version !== skillsSnapshotVersion;
@@ -218,20 +258,16 @@ export async function runCronIsolatedAgentTurn(params) {
             updatedAt: Date.now(),
             skillsSnapshot,
         };
-        cronSession.store[agentSessionKey] = cronSession.sessionEntry;
-        await updateSessionStore(cronSession.storePath, (store) => {
-            store[agentSessionKey] = cronSession.sessionEntry;
-        });
+        await persistSessionEntry();
     }
     // Persist systemSent before the run, mirroring the inbound auto-reply behavior.
     cronSession.sessionEntry.systemSent = true;
-    cronSession.store[agentSessionKey] = cronSession.sessionEntry;
-    await updateSessionStore(cronSession.storePath, (store) => {
-        store[agentSessionKey] = cronSession.sessionEntry;
-    });
+    await persistSessionEntry();
     let runResult;
     let fallbackProvider = provider;
     let fallbackModel = model;
+    const runStartedAt = Date.now();
+    let runEndedAt = runStartedAt;
     try {
         const sessionFile = resolveSessionTranscriptPath(cronSession.sessionEntry.sessionId, agentId);
         const resolvedVerboseLevel = normalizeVerboseLevel(cronSession.sessionEntry.verboseLevel) ??
@@ -289,9 +325,10 @@ export async function runCronIsolatedAgentTurn(params) {
         runResult = fallbackResult.result;
         fallbackProvider = fallbackResult.provider;
         fallbackModel = fallbackResult.model;
+        runEndedAt = Date.now();
     }
     catch (err) {
-        return { status: "error", error: String(err) };
+        return withRunSession({ status: "error", error: String(err) });
     }
     const payloads = runResult.payloads ?? [];
     // Update token+model fields in the session store.
@@ -312,25 +349,34 @@ export async function runCronIsolatedAgentTurn(params) {
         if (hasNonzeroUsage(usage)) {
             const input = usage.input ?? 0;
             const output = usage.output ?? 0;
-            const promptTokens = input + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
             cronSession.sessionEntry.inputTokens = input;
             cronSession.sessionEntry.outputTokens = output;
             cronSession.sessionEntry.totalTokens =
-                promptTokens > 0 ? promptTokens : (usage.total ?? input);
+                deriveSessionTotalTokens({
+                    usage,
+                    contextTokens,
+                }) ?? input;
         }
-        cronSession.store[agentSessionKey] = cronSession.sessionEntry;
-        await updateSessionStore(cronSession.storePath, (store) => {
-            store[agentSessionKey] = cronSession.sessionEntry;
-        });
+        await persistSessionEntry();
     }
     const firstText = payloads[0]?.text ?? "";
     const summary = pickSummaryFromPayloads(payloads) ?? pickSummaryFromOutput(firstText);
     const outputText = pickLastNonEmptyTextFromPayloads(payloads);
+    const synthesizedText = outputText?.trim() || summary?.trim() || undefined;
+    const deliveryPayload = pickLastDeliverablePayload(payloads);
+    const deliveryPayloads = deliveryPayload !== undefined
+        ? [deliveryPayload]
+        : synthesizedText
+            ? [{ text: synthesizedText }]
+            : [];
+    const deliveryPayloadHasStructuredContent = Boolean(deliveryPayload?.mediaUrl) ||
+        (deliveryPayload?.mediaUrls?.length ?? 0) > 0 ||
+        Object.keys(deliveryPayload?.channelData ?? {}).length > 0;
+    const deliveryBestEffort = resolveCronDeliveryBestEffort(params.job);
     // Skip delivery for heartbeat-only responses (HEARTBEAT_OK with no real content).
     const ackMaxChars = resolveHeartbeatAckMaxChars(agentCfg);
     const skipHeartbeatDelivery = deliveryRequested && isHeartbeatOnlyResponse(payloads, ackMaxChars);
     const skipMessagingToolDelivery = deliveryRequested &&
-        deliveryMode === "auto" &&
         runResult.didSendViaMessagingTool === true &&
         (runResult.messagingToolSentTargets ?? []).some((target) => matchesMessagingToolDeliveryTarget(target, {
             channel: resolvedDelivery.channel,
@@ -338,39 +384,101 @@ export async function runCronIsolatedAgentTurn(params) {
             accountId: resolvedDelivery.accountId,
         }));
     if (deliveryRequested && !skipHeartbeatDelivery && !skipMessagingToolDelivery) {
+        if (resolvedDelivery.error) {
+            if (!deliveryBestEffort) {
+                return withRunSession({
+                    status: "error",
+                    error: resolvedDelivery.error.message,
+                    summary,
+                    outputText,
+                });
+            }
+            logWarn(`[cron:${params.job.id}] ${resolvedDelivery.error.message}`);
+            return withRunSession({ status: "ok", summary, outputText });
+        }
         if (!resolvedDelivery.to) {
-            const reason = resolvedDelivery.error?.message ?? "Cron delivery requires a recipient (--to).";
-            if (!bestEffortDeliver) {
-                return {
+            const message = "cron delivery target is missing";
+            if (!deliveryBestEffort) {
+                return withRunSession({
                     status: "error",
+                    error: message,
                     summary,
                     outputText,
-                    error: reason,
-                };
+                });
             }
-            return {
-                status: "skipped",
-                summary: `Delivery skipped (${reason}).`,
-                outputText,
-            };
+            logWarn(`[cron:${params.job.id}] ${message}`);
+            return withRunSession({ status: "ok", summary, outputText });
         }
-        try {
-            await deliverOutboundPayloads({
-                cfg: cfgWithAgentDefaults,
-                channel: resolvedDelivery.channel,
-                to: resolvedDelivery.to,
-                accountId: resolvedDelivery.accountId,
-                payloads,
-                bestEffort: bestEffortDeliver,
-                deps: createOutboundSendDeps(params.deps),
-            });
+        // Shared subagent announce flow is text-based; keep direct outbound delivery
+        // for media/channel payloads so structured content is preserved.
+        if (deliveryPayloadHasStructuredContent) {
+            try {
+                await deliverOutboundPayloads({
+                    cfg: cfgWithAgentDefaults,
+                    channel: resolvedDelivery.channel,
+                    to: resolvedDelivery.to,
+                    accountId: resolvedDelivery.accountId,
+                    threadId: resolvedDelivery.threadId,
+                    payloads: deliveryPayloads,
+                    bestEffort: deliveryBestEffort,
+                    deps: createOutboundSendDeps(params.deps),
+                });
+            }
+            catch (err) {
+                if (!deliveryBestEffort) {
+                    return withRunSession({ status: "error", summary, outputText, error: String(err) });
+                }
+            }
         }
-        catch (err) {
-            if (!bestEffortDeliver) {
-                return { status: "error", summary, outputText, error: String(err) };
+        else if (synthesizedText) {
+            const announceSessionKey = resolveAgentMainSessionKey({
+                cfg: params.cfg,
+                agentId,
+            });
+            const taskLabel = typeof params.job.name === "string" && params.job.name.trim()
+                ? params.job.name.trim()
+                : `cron:${params.job.id}`;
+            try {
+                const didAnnounce = await runSubagentAnnounceFlow({
+                    childSessionKey: runSessionKey,
+                    childRunId: `${params.job.id}:${runSessionId}`,
+                    requesterSessionKey: announceSessionKey,
+                    requesterOrigin: {
+                        channel: resolvedDelivery.channel,
+                        to: resolvedDelivery.to,
+                        accountId: resolvedDelivery.accountId,
+                        threadId: resolvedDelivery.threadId,
+                    },
+                    requesterDisplayKey: announceSessionKey,
+                    task: taskLabel,
+                    timeoutMs,
+                    cleanup: "keep",
+                    roundOneReply: synthesizedText,
+                    waitForCompletion: false,
+                    startedAt: runStartedAt,
+                    endedAt: runEndedAt,
+                    outcome: { status: "ok" },
+                });
+                if (!didAnnounce) {
+                    const message = "cron announce delivery failed";
+                    if (!deliveryBestEffort) {
+                        return withRunSession({
+                            status: "error",
+                            summary,
+                            outputText,
+                            error: message,
+                        });
+                    }
+                    logWarn(`[cron:${params.job.id}] ${message}`);
+                }
+            }
+            catch (err) {
+                if (!deliveryBestEffort) {
+                    return withRunSession({ status: "error", summary, outputText, error: String(err) });
+                }
+                logWarn(`[cron:${params.job.id}] ${String(err)}`);
             }
-            return { status: "ok", summary, outputText };
         }
     }
-    return { status: "ok", summary, outputText };
+    return withRunSession({ status: "ok", summary, outputText });
 }

package/dist/cron/isolated-agent/session.js

@@ -21,6 +21,8 @@ export function resolveCronSession(params) {
         lastChannel: entry?.lastChannel,
         lastTo: entry?.lastTo,
         lastAccountId: entry?.lastAccountId,
+        label: entry?.label,
+        displayName: entry?.displayName,
         skillsSnapshot: entry?.skillsSnapshot,
     };
     return { storePath, store, sessionEntry, systemSent, isNewSession: true };