@poolzin/pool-bot 2026.2.21 → 2026.2.22

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

@@ -2,24 +2,25 @@ 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 { resolveCronStyleNow } from "../../agents/current-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";
 import { getModelRefStatus, isCliProvider, resolveAllowedModelRef, resolveConfiguredModelRef, resolveHooksGmailModel, resolveThinkingDefault, } from "../../agents/model-selection.js";
 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 { countActiveDescendantRuns } from "../../agents/subagent-registry.js";
 import { resolveAgentTimeoutMs } from "../../agents/timeout.js";
 import { deriveSessionTotalTokens, hasNonzeroUsage } from "../../agents/usage.js";
 import { ensureAgentWorkspace } from "../../agents/workspace.js";
 import { normalizeThinkLevel, normalizeVerboseLevel, supportsXHighThinking, } from "../../auto-reply/thinking.js";
+import { SILENT_REPLY_TOKEN } from "../../auto-reply/tokens.js";
 import { createOutboundSendDeps } from "../../cli/outbound-send-deps.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 { resolveAgentOutboundIdentity } from "../../infra/outbound/identity.js";
+import { resolveOutboundSessionRoute } from "../../infra/outbound/outbound-session.js";
 import { logWarn } from "../../logger.js";
 import { buildAgentMainSessionKey, normalizeAgentId } from "../../routing/session-key.js";
 import { buildSafeExternalPrompt, detectSuspiciousPatterns, getHookType, isExternalHookSession, } from "../../security/external-content.js";
@@ -27,6 +28,8 @@ import { resolveCronDeliveryPlan } from "../delivery.js";
 import { resolveDeliveryTarget } from "./delivery-target.js";
 import { isHeartbeatOnlyResponse, pickLastDeliverablePayload, pickLastNonEmptyTextFromPayloads, pickSummaryFromOutput, pickSummaryFromPayloads, resolveHeartbeatAckMaxChars, } from "./helpers.js";
 import { resolveCronSession } from "./session.js";
+import { resolveCronSkillsSnapshot } from "./skills-snapshot.js";
+import { expectsSubagentFollowup, isLikelyInterimCronMessage, readDescendantSubagentFallbackReply, waitForDescendantSubagentSummary, } from "./subagent-followup.js";
 function matchesMessagingToolDeliveryTarget(target, delivery) {
     if (!delivery.to || !target.to) {
         return false;
@@ -50,7 +53,32 @@ function resolveCronDeliveryBestEffort(job) {
     }
     return false;
 }
+async function resolveCronAnnounceSessionKey(params) {
+    const to = params.delivery.to?.trim();
+    if (!to) {
+        return params.fallbackSessionKey;
+    }
+    try {
+        const route = await resolveOutboundSessionRoute({
+            cfg: params.cfg,
+            channel: params.delivery.channel,
+            agentId: params.agentId,
+            accountId: params.delivery.accountId,
+            target: to,
+            threadId: params.delivery.threadId,
+        });
+        const resolved = route?.sessionKey?.trim();
+        if (resolved) {
+            return resolved;
+        }
+    }
+    catch {
+        // Fall back to main session routing if announce session resolution fails.
+    }
+    return params.fallbackSessionKey;
+}
 export async function runCronIsolatedAgentTurn(params) {
+    const isFastTestEnv = process.env.POOLBOT_TEST_FAST === "1";
     const defaultAgentId = resolveDefaultAgentId(params.cfg);
     const requestedAgentId = typeof params.agentId === "string" && params.agentId.trim()
         ? params.agentId
@@ -62,13 +90,20 @@ export async function runCronIsolatedAgentTurn(params) {
         ? resolveAgentConfig(params.cfg, normalizedRequested)
         : undefined;
     const { model: overrideModel, ...agentOverrideRest } = agentConfigOverride ?? {};
-    const agentId = agentConfigOverride ? (normalizedRequested ?? defaultAgentId) : defaultAgentId;
+    // Use the requested agentId even when there is no explicit agent config entry.
+    // This ensures auth-profiles, workspace, and agentDir all resolve to the
+    // correct per-agent paths (e.g. ~/.poolbot/agents/<agentId>/agent/).
+    const agentId = normalizedRequested ?? defaultAgentId;
     const agentCfg = Object.assign({}, params.cfg.agents?.defaults, agentOverrideRest);
+    // Merge agent model override with defaults instead of replacing, so that
+    // `fallbacks` from `agents.defaults.model` are preserved when the agent
+    // (or its per-cron model pin) only specifies `primary`.
+    const existingModel = agentCfg.model && typeof agentCfg.model === "object" ? agentCfg.model : {};
     if (typeof overrideModel === "string") {
-        agentCfg.model = { primary: overrideModel };
+        agentCfg.model = { ...existingModel, primary: overrideModel };
     }
     else if (overrideModel) {
-        agentCfg.model = overrideModel;
+        agentCfg.model = { ...existingModel, ...overrideModel };
     }
     const cfgWithAgentDefaults = {
         ...params.cfg,
@@ -83,7 +118,7 @@ export async function runCronIsolatedAgentTurn(params) {
     const agentDir = resolveAgentDir(params.cfg, agentId);
     const workspace = await ensureAgentWorkspace({
         dir: workspaceDirRaw,
-        ensureBootstrapFiles: !agentCfg?.skipBootstrap,
+        ensureBootstrapFiles: !agentCfg?.skipBootstrap && !isFastTestEnv,
     });
     const workspaceDir = workspace.dir;
     const resolvedDefault = resolveConfiguredModelRef({
@@ -102,6 +137,7 @@ export async function runCronIsolatedAgentTurn(params) {
     };
     // Resolve model - prefer hooks.gmail.model for Gmail hooks.
     const isGmailHook = baseSessionKey.startsWith("hook:gmail:");
+    let hooksGmailModelApplied = false;
     const hooksGmailModelRef = isGmailHook
         ? resolveHooksGmailModel({
             cfg: params.cfg,
@@ -119,6 +155,7 @@ export async function runCronIsolatedAgentTurn(params) {
         if (status.allowed) {
             provider = hooksGmailModelRef.provider;
             model = hooksGmailModelRef.model;
+            hooksGmailModelApplied = true;
         }
     }
     const modelOverrideRaw = params.job.payload.kind === "agentTurn" ? params.job.payload.model : undefined;
@@ -149,6 +186,9 @@ export async function runCronIsolatedAgentTurn(params) {
         ? `${agentSessionKey}:run:${runSessionId}`
         : agentSessionKey;
     const persistSessionEntry = async () => {
+        if (isFastTestEnv) {
+            return;
+        }
         cronSession.store[agentSessionKey] = cronSession.sessionEntry;
         if (runSessionKey !== agentSessionKey) {
             cronSession.store[runSessionKey] = cronSession.sessionEntry;
@@ -171,6 +211,26 @@ export async function runCronIsolatedAgentTurn(params) {
             : params.job.id;
         cronSession.sessionEntry.label = `Cron: ${labelSuffix}`;
     }
+    // Respect session model override — check session.modelOverride before falling
+    // back to the default config model. This ensures /model changes are honoured
+    // by cron and isolated agent runs.
+    if (!modelOverride && !hooksGmailModelApplied) {
+        const sessionModelOverride = cronSession.sessionEntry.modelOverride?.trim();
+        if (sessionModelOverride) {
+            const sessionProviderOverride = cronSession.sessionEntry.providerOverride?.trim() || resolvedDefault.provider;
+            const resolvedSessionOverride = resolveAllowedModelRef({
+                cfg: cfgWithAgentDefaults,
+                catalog: await loadCatalog(),
+                raw: `${sessionProviderOverride}/${sessionModelOverride}`,
+                defaultProvider: resolvedDefault.provider,
+                defaultModel: resolvedDefault.model,
+            });
+            if (!("error" in resolvedSessionOverride)) {
+                provider = resolvedSessionOverride.ref.provider;
+                model = resolvedSessionOverride.ref.model;
+            }
+        }
+    }
     // Resolve thinking level - job thinking > hooks.gmail.thinking > agent default
     const hooksGmailThinking = isGmailHook
         ? normalizeThinkLevel(params.cfg.hooks?.gmail?.thinking)
@@ -202,10 +262,7 @@ export async function runCronIsolatedAgentTurn(params) {
         channel: deliveryPlan.channel ?? "last",
         to: deliveryPlan.to,
     });
-    const userTimezone = resolveUserTimezone(params.cfg.agents?.defaults?.userTimezone);
-    const userTimeFormat = resolveUserTimeFormat(params.cfg.agents?.defaults?.timeFormat);
-    const formattedTime = formatUserTime(new Date(now), userTimezone, userTimeFormat) ?? new Date(now).toISOString();
-    const timeLine = `Current time: ${formattedTime} (${userTimezone})`;
+    const { formattedTime, timeLine } = resolveCronStyleNow(params.cfg, now);
     const base = `[cron:${params.job.id} ${params.job.name}] ${params.message}`.trim();
     // SECURITY: Wrap external hook content with security boundaries to prevent prompt injection
     // unless explicitly allowed via a dangerous config override.
@@ -242,17 +299,15 @@ export async function runCronIsolatedAgentTurn(params) {
         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;
-    const skillsSnapshot = needsSkillsSnapshot
-        ? buildWorkspaceSkillSnapshot(workspaceDir, {
-            config: cfgWithAgentDefaults,
-            eligibility: { remote: getRemoteSkillEligibility() },
-            snapshotVersion: skillsSnapshotVersion,
-        })
-        : cronSession.sessionEntry.skillsSnapshot;
-    if (needsSkillsSnapshot && skillsSnapshot) {
+    const existingSkillsSnapshot = cronSession.sessionEntry.skillsSnapshot;
+    const skillsSnapshot = resolveCronSkillsSnapshot({
+        workspaceDir,
+        config: cfgWithAgentDefaults,
+        agentId,
+        existingSnapshot: existingSkillsSnapshot,
+        isFastTestEnv,
+    });
+    if (!isFastTestEnv && skillsSnapshot !== existingSkillsSnapshot) {
         cronSession.sessionEntry = {
             ...cronSession.sessionEntry,
             updatedAt: Date.now(),
@@ -290,6 +345,7 @@ export async function runCronIsolatedAgentTurn(params) {
                     return runCliAgent({
                         sessionId: cronSession.sessionEntry.sessionId,
                         sessionKey: agentSessionKey,
+                        agentId,
                         sessionFile,
                         workspaceDir,
                         config: cfgWithAgentDefaults,
@@ -305,6 +361,7 @@ export async function runCronIsolatedAgentTurn(params) {
                 return runEmbeddedPiAgent({
                     sessionId: cronSession.sessionEntry.sessionId,
                     sessionKey: agentSessionKey,
+                    agentId,
                     messageChannel,
                     agentAccountId: resolvedDelivery.accountId,
                     sessionFile,
@@ -319,6 +376,8 @@ export async function runCronIsolatedAgentTurn(params) {
                     verboseLevel: resolvedVerboseLevel,
                     timeoutMs,
                     runId: cronSession.sessionEntry.sessionId,
+                    requireExplicitMessageTarget: true,
+                    disableMessageTool: deliveryRequested,
                 });
             },
         });
@@ -332,16 +391,19 @@ export async function runCronIsolatedAgentTurn(params) {
     }
     const payloads = runResult.payloads ?? [];
     // Update token+model fields in the session store.
+    // Also collect best-effort telemetry for the cron run log.
+    let telemetry;
     {
-        const usage = runResult.meta.agentMeta?.usage;
-        const modelUsed = runResult.meta.agentMeta?.model ?? fallbackModel ?? model;
-        const providerUsed = runResult.meta.agentMeta?.provider ?? fallbackProvider ?? provider;
+        const usage = runResult.meta?.agentMeta?.usage;
+        const promptTokens = runResult.meta?.agentMeta?.promptTokens;
+        const modelUsed = runResult.meta?.agentMeta?.model ?? fallbackModel ?? model;
+        const providerUsed = runResult.meta?.agentMeta?.provider ?? fallbackProvider ?? provider;
         const contextTokens = agentCfg?.contextTokens ?? lookupContextTokens(modelUsed) ?? DEFAULT_CONTEXT_TOKENS;
         cronSession.sessionEntry.modelProvider = providerUsed;
         cronSession.sessionEntry.model = modelUsed;
         cronSession.sessionEntry.contextTokens = contextTokens;
         if (isCliProvider(providerUsed, cfgWithAgentDefaults)) {
-            const cliSessionId = runResult.meta.agentMeta?.sessionId?.trim();
+            const cliSessionId = runResult.meta?.agentMeta?.sessionId?.trim();
             if (cliSessionId) {
                 setCliSessionId(cronSession.sessionEntry, providerUsed, cliSessionId);
             }
@@ -349,22 +411,39 @@ export async function runCronIsolatedAgentTurn(params) {
         if (hasNonzeroUsage(usage)) {
             const input = usage.input ?? 0;
             const output = usage.output ?? 0;
+            const totalTokens = deriveSessionTotalTokens({
+                usage,
+                contextTokens,
+                promptTokens,
+            }) ?? input;
             cronSession.sessionEntry.inputTokens = input;
             cronSession.sessionEntry.outputTokens = output;
-            cronSession.sessionEntry.totalTokens =
-                deriveSessionTotalTokens({
-                    usage,
-                    contextTokens,
-                }) ?? input;
+            cronSession.sessionEntry.totalTokens = totalTokens;
+            cronSession.sessionEntry.totalTokensFresh = true;
+            telemetry = {
+                model: modelUsed,
+                provider: providerUsed,
+                usage: {
+                    input_tokens: input,
+                    output_tokens: output,
+                    total_tokens: totalTokens,
+                },
+            };
+        }
+        else {
+            telemetry = {
+                model: modelUsed,
+                provider: providerUsed,
+            };
         }
         await persistSessionEntry();
     }
     const firstText = payloads[0]?.text ?? "";
-    const summary = pickSummaryFromPayloads(payloads) ?? pickSummaryFromOutput(firstText);
-    const outputText = pickLastNonEmptyTextFromPayloads(payloads);
-    const synthesizedText = outputText?.trim() || summary?.trim() || undefined;
+    let summary = pickSummaryFromPayloads(payloads) ?? pickSummaryFromOutput(firstText);
+    let outputText = pickLastNonEmptyTextFromPayloads(payloads);
+    let synthesizedText = outputText?.trim() || summary?.trim() || undefined;
     const deliveryPayload = pickLastDeliverablePayload(payloads);
-    const deliveryPayloads = deliveryPayload !== undefined
+    let deliveryPayloads = deliveryPayload !== undefined
         ? [deliveryPayload]
         : synthesizedText
             ? [{ text: synthesizedText }]
@@ -383,6 +462,9 @@ export async function runCronIsolatedAgentTurn(params) {
             to: resolvedDelivery.to,
             accountId: resolvedDelivery.accountId,
         }));
+    // `true` means we confirmed at least one outbound send reached the target.
+    // Keep this strict so timer fallback can safely decide whether to wake main.
+    let delivered = skipMessagingToolDelivery;
     if (deliveryRequested && !skipHeartbeatDelivery && !skipMessagingToolDelivery) {
         if (resolvedDelivery.error) {
             if (!deliveryBestEffort) {
@@ -391,10 +473,11 @@ export async function runCronIsolatedAgentTurn(params) {
                     error: resolvedDelivery.error.message,
                     summary,
                     outputText,
+                    ...telemetry,
                 });
             }
             logWarn(`[cron:${params.job.id}] ${resolvedDelivery.error.message}`);
-            return withRunSession({ status: "ok", summary, outputText });
+            return withRunSession({ status: "ok", summary, outputText, ...telemetry });
         }
         if (!resolvedDelivery.to) {
             const message = "cron delivery target is missing";
@@ -404,43 +487,117 @@ export async function runCronIsolatedAgentTurn(params) {
                     error: message,
                     summary,
                     outputText,
+                    ...telemetry,
                 });
             }
             logWarn(`[cron:${params.job.id}] ${message}`);
-            return withRunSession({ status: "ok", summary, outputText });
+            return withRunSession({ status: "ok", summary, outputText, ...telemetry });
         }
-        // Shared subagent announce flow is text-based; keep direct outbound delivery
-        // for media/channel payloads so structured content is preserved.
+        const identity = resolveAgentOutboundIdentity(cfgWithAgentDefaults, agentId);
+        // Route text-only cron announce output back through the main session so it
+        // follows the same system-message injection path as subagent completions.
+        // Keep direct outbound delivery only for structured payloads (media/channel
+        // data), which cannot be represented by the shared announce flow.
         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),
-                });
+                const payloadsForDelivery = deliveryPayloads.length > 0
+                    ? deliveryPayloads
+                    : synthesizedText
+                        ? [{ text: synthesizedText }]
+                        : [];
+                if (payloadsForDelivery.length > 0) {
+                    const deliveryResults = await deliverOutboundPayloads({
+                        cfg: cfgWithAgentDefaults,
+                        channel: resolvedDelivery.channel,
+                        to: resolvedDelivery.to,
+                        accountId: resolvedDelivery.accountId,
+                        threadId: resolvedDelivery.threadId,
+                        payloads: payloadsForDelivery,
+                        agentId,
+                        identity,
+                        bestEffort: deliveryBestEffort,
+                        deps: createOutboundSendDeps(params.deps),
+                    });
+                    delivered = deliveryResults.length > 0;
+                }
             }
             catch (err) {
                 if (!deliveryBestEffort) {
-                    return withRunSession({ status: "error", summary, outputText, error: String(err) });
+                    return withRunSession({
+                        status: "error",
+                        summary,
+                        outputText,
+                        error: String(err),
+                        ...telemetry,
+                    });
                 }
             }
         }
         else if (synthesizedText) {
-            const announceSessionKey = resolveAgentMainSessionKey({
+            const announceMainSessionKey = resolveAgentMainSessionKey({
                 cfg: params.cfg,
                 agentId,
             });
+            const announceSessionKey = await resolveCronAnnounceSessionKey({
+                cfg: cfgWithAgentDefaults,
+                agentId,
+                fallbackSessionKey: announceMainSessionKey,
+                delivery: {
+                    channel: resolvedDelivery.channel,
+                    to: resolvedDelivery.to,
+                    accountId: resolvedDelivery.accountId,
+                    threadId: resolvedDelivery.threadId,
+                },
+            });
             const taskLabel = typeof params.job.name === "string" && params.job.name.trim()
                 ? params.job.name.trim()
                 : `cron:${params.job.id}`;
+            const initialSynthesizedText = synthesizedText.trim();
+            let activeSubagentRuns = countActiveDescendantRuns(agentSessionKey);
+            const expectedSubagentFollowup = expectsSubagentFollowup(initialSynthesizedText);
+            const hadActiveDescendants = activeSubagentRuns > 0;
+            if (activeSubagentRuns > 0 || expectedSubagentFollowup) {
+                let finalReply = await waitForDescendantSubagentSummary({
+                    sessionKey: agentSessionKey,
+                    initialReply: initialSynthesizedText,
+                    timeoutMs,
+                    observedActiveDescendants: activeSubagentRuns > 0 || expectedSubagentFollowup,
+                });
+                activeSubagentRuns = countActiveDescendantRuns(agentSessionKey);
+                if (!finalReply &&
+                    activeSubagentRuns === 0 &&
+                    (hadActiveDescendants || expectedSubagentFollowup)) {
+                    finalReply = await readDescendantSubagentFallbackReply({
+                        sessionKey: agentSessionKey,
+                        runStartedAt,
+                    });
+                }
+                if (finalReply && activeSubagentRuns === 0) {
+                    outputText = finalReply;
+                    summary = pickSummaryFromOutput(finalReply) ?? summary;
+                    synthesizedText = finalReply;
+                    deliveryPayloads = [{ text: finalReply }];
+                }
+            }
+            if (activeSubagentRuns > 0) {
+                // Parent orchestration is still in progress; avoid announcing a partial
+                // update to the main requester.
+                return withRunSession({ status: "ok", summary, outputText, ...telemetry });
+            }
+            if ((hadActiveDescendants || expectedSubagentFollowup) &&
+                synthesizedText.trim() === initialSynthesizedText &&
+                isLikelyInterimCronMessage(initialSynthesizedText) &&
+                initialSynthesizedText.toUpperCase() !== SILENT_REPLY_TOKEN.toUpperCase()) {
+                // Descendants existed but no post-orchestration synthesis arrived, so
+                // suppress stale parent text like "on it, pulling everything together".
+                return withRunSession({ status: "ok", summary, outputText, ...telemetry });
+            }
+            if (synthesizedText.toUpperCase() === SILENT_REPLY_TOKEN.toUpperCase()) {
+                return withRunSession({ status: "ok", summary, outputText, ...telemetry });
+            }
             try {
                 const didAnnounce = await runSubagentAnnounceFlow({
-                    childSessionKey: runSessionKey,
+                    childSessionKey: agentSessionKey,
                     childRunId: `${params.job.id}:${runSessionId}`,
                     requesterSessionKey: announceSessionKey,
                     requesterOrigin: {
@@ -452,7 +609,7 @@ export async function runCronIsolatedAgentTurn(params) {
                     requesterDisplayKey: announceSessionKey,
                     task: taskLabel,
                     timeoutMs,
-                    cleanup: "keep",
+                    cleanup: params.job.deleteAfterRun ? "delete" : "keep",
                     roundOneReply: synthesizedText,
                     waitForCompletion: false,
                     startedAt: runStartedAt,
@@ -460,7 +617,10 @@ export async function runCronIsolatedAgentTurn(params) {
                     outcome: { status: "ok" },
                     announceType: "cron job",
                 });
-                if (!didAnnounce) {
+                if (didAnnounce) {
+                    delivered = true;
+                }
+                else {
                     const message = "cron announce delivery failed";
                     if (!deliveryBestEffort) {
                         return withRunSession({
@@ -468,6 +628,7 @@ export async function runCronIsolatedAgentTurn(params) {
                             summary,
                             outputText,
                             error: message,
+                            ...telemetry,
                         });
                     }
                     logWarn(`[cron:${params.job.id}] ${message}`);
@@ -475,11 +636,17 @@ export async function runCronIsolatedAgentTurn(params) {
             }
             catch (err) {
                 if (!deliveryBestEffort) {
-                    return withRunSession({ status: "error", summary, outputText, error: String(err) });
+                    return withRunSession({
+                        status: "error",
+                        summary,
+                        outputText,
+                        error: String(err),
+                        ...telemetry,
+                    });
                 }
                 logWarn(`[cron:${params.job.id}] ${String(err)}`);
             }
         }
     }
-    return withRunSession({ status: "ok", summary, outputText });
+    return withRunSession({ status: "ok", summary, outputText, delivered, ...telemetry });
 }

package/dist/cron/normalize.js

@@ -1,8 +1,10 @@
 import { sanitizeAgentId } from "../routing/session-key.js";
 import { isRecord } from "../utils.js";
+import { buildDeliveryFromLegacyPayload, hasLegacyDeliveryHints, stripLegacyDeliveryFields, } from "./legacy-delivery.js";
 import { parseAbsoluteTimeMs } from "./parse.js";
 import { migrateLegacyCronPayload } from "./payload-migration.js";
 import { inferLegacyName } from "./service/normalize.js";
+import { normalizeCronStaggerMs, resolveDefaultCronStaggerMs } from "./stagger.js";
 const DEFAULT_OPTIONS = {
     applyDefaults: false,
 };
@@ -45,6 +47,13 @@ function coerceSchedule(schedule) {
     if ("atMs" in next) {
         delete next.atMs;
     }
+    const staggerMs = normalizeCronStaggerMs(schedule.staggerMs);
+    if (staggerMs !== undefined) {
+        next.staggerMs = staggerMs;
+    }
+    else if ("staggerMs" in next) {
+        delete next.staggerMs;
+    }
     return next;
 }
 function coercePayload(payload) {
@@ -64,12 +73,20 @@ function coercePayload(payload) {
     if (!next.kind) {
         const hasMessage = typeof next.message === "string" && next.message.trim().length > 0;
         const hasText = typeof next.text === "string" && next.text.trim().length > 0;
+        const hasAgentTurnHint = typeof next.model === "string" ||
+            typeof next.thinking === "string" ||
+            typeof next.timeoutSeconds === "number" ||
+            typeof next.allowUnsafeExternalContent === "boolean";
         if (hasMessage) {
             next.kind = "agentTurn";
         }
         else if (hasText) {
             next.kind = "systemEvent";
         }
+        else if (hasAgentTurnHint) {
+            // Accept partial agentTurn payload patches that only tweak agent-turn-only fields.
+            next.kind = "agentTurn";
+        }
     }
     if (typeof next.message === "string") {
         const trimmed = next.message.trim();
@@ -113,7 +130,7 @@ function coercePayload(payload) {
     }
     if ("timeoutSeconds" in next) {
         if (typeof next.timeoutSeconds === "number" && Number.isFinite(next.timeoutSeconds)) {
-            next.timeoutSeconds = Math.max(1, Math.floor(next.timeoutSeconds));
+            next.timeoutSeconds = Math.max(0, Math.floor(next.timeoutSeconds));
         }
         else {
             delete next.timeoutSeconds;
@@ -132,7 +149,7 @@ function coerceDelivery(delivery) {
         if (mode === "deliver") {
             next.mode = "announce";
         }
-        else if (mode === "announce" || mode === "none") {
+        else if (mode === "announce" || mode === "none" || mode === "webhook") {
             next.mode = mode;
         }
         else {
@@ -162,49 +179,6 @@ function coerceDelivery(delivery) {
     }
     return next;
 }
-function hasLegacyDeliveryHints(payload) {
-    if (typeof payload.deliver === "boolean") {
-        return true;
-    }
-    if (typeof payload.bestEffortDeliver === "boolean") {
-        return true;
-    }
-    if (typeof payload.to === "string" && payload.to.trim()) {
-        return true;
-    }
-    return false;
-}
-function buildDeliveryFromLegacyPayload(payload) {
-    const deliver = payload.deliver;
-    const mode = deliver === false ? "none" : "announce";
-    const channelRaw = typeof payload.channel === "string" ? payload.channel.trim().toLowerCase() : "";
-    const toRaw = typeof payload.to === "string" ? payload.to.trim() : "";
-    const next = { mode };
-    if (channelRaw) {
-        next.channel = channelRaw;
-    }
-    if (toRaw) {
-        next.to = toRaw;
-    }
-    if (typeof payload.bestEffortDeliver === "boolean") {
-        next.bestEffort = payload.bestEffortDeliver;
-    }
-    return next;
-}
-function stripLegacyDeliveryFields(payload) {
-    if ("deliver" in payload) {
-        delete payload.deliver;
-    }
-    if ("channel" in payload) {
-        delete payload.channel;
-    }
-    if ("to" in payload) {
-        delete payload.to;
-    }
-    if ("bestEffortDeliver" in payload) {
-        delete payload.bestEffortDeliver;
-    }
-}
 function unwrapJob(raw) {
     if (isRecord(raw.data)) {
         return raw.data;
@@ -310,6 +284,21 @@ export function normalizeCronJobInput(raw, options = DEFAULT_OPTIONS) {
             }
         }
     }
+    if ("sessionKey" in base) {
+        const sessionKey = base.sessionKey;
+        if (sessionKey === null) {
+            next.sessionKey = null;
+        }
+        else if (typeof sessionKey === "string") {
+            const trimmed = sessionKey.trim();
+            if (trimmed) {
+                next.sessionKey = trimmed;
+            }
+            else {
+                delete next.sessionKey;
+            }
+        }
+    }
     if ("enabled" in base) {
         const enabled = base.enabled;
         if (typeof enabled === "boolean") {
@@ -407,6 +396,20 @@ export function normalizeCronJobInput(raw, options = DEFAULT_OPTIONS) {
             !("deleteAfterRun" in next)) {
             next.deleteAfterRun = true;
         }
+        if ("schedule" in next && isRecord(next.schedule) && next.schedule.kind === "cron") {
+            const schedule = next.schedule;
+            const explicit = normalizeCronStaggerMs(schedule.staggerMs);
+            if (explicit !== undefined) {
+                schedule.staggerMs = explicit;
+            }
+            else {
+                const expr = typeof schedule.expr === "string" ? schedule.expr : "";
+                const defaultStaggerMs = resolveDefaultCronStaggerMs(expr);
+                if (defaultStaggerMs !== undefined) {
+                    schedule.staggerMs = defaultStaggerMs;
+                }
+            }
+        }
         const payload = isRecord(next.payload) ? next.payload : null;
         const payloadKind = payload && typeof payload.kind === "string" ? payload.kind : "";
         const sessionTarget = typeof next.sessionTarget === "string" ? next.sessionTarget : "";