@sema-agent/core 2.11.0 → 2.13.0

package/dist/core/skill-tool-specifier.js

@@ -0,0 +1,58 @@
+import { parsePermissionRule, wildcardMatch } from "./permission-rules.js";
+import { canonicalToolName } from "./tool-name-aliases.js";
+import { COARSE_SHELL_TOOLS } from "./tool-policy.js";
+import { parseLeadingCommandName } from "../tools/fs/bash-readonly-classifier.js";
+const SPECIFIER_ENFORCED_TOOLS = new Set(COARSE_SHELL_TOOLS.map(canonicalToolName));
+export function parseSkillToolEntry(entry) {
+    const parsed = parsePermissionRule(entry);
+    const name = canonicalToolName(parsed.toolName);
+    return parsed.ruleContent === undefined ? { raw: entry, name } : { raw: entry, name, specifier: parsed.ruleContent };
+}
+export function isSkillSpecifierEnforced(canonicalName) {
+    return SPECIFIER_ENFORCED_TOOLS.has(canonicalName);
+}
+function normalizeSpacing(s) {
+    return s.trim().replace(/[ \t]+/g, " ");
+}
+function hasUnescapedStar(content) {
+    for (let i = 0; i < content.length; i++) {
+        if (content[i] !== "*")
+            continue;
+        let backslashes = 0;
+        for (let j = i - 1; j >= 0 && content[j] === "\\"; j--)
+            backslashes++;
+        if (backslashes % 2 === 0)
+            return true;
+    }
+    return false;
+}
+function specifierMatchesCommand(specifier, command) {
+    const spec = normalizeSpacing(specifier);
+    const prefix = /^(.+):\*$/.exec(spec)?.[1];
+    if (prefix !== undefined) {
+        return command === prefix || command.startsWith(prefix + " ");
+    }
+    if (hasUnescapedStar(spec))
+        return wildcardMatch(spec, command);
+    return command === spec;
+}
+export function skillSpecifierRejection(entry, args) {
+    const { specifier } = entry;
+    if (specifier === undefined)
+        return undefined;
+    if (!isSkillSpecifierEnforced(entry.name)) {
+        return `entry "${entry.raw}" narrows a tool whose calls this gate cannot match against a command pattern — only the shell tools (${[...SPECIFIER_ENFORCED_TOOLS].join(", ")}) carry a command string, so the entry admits nothing`;
+    }
+    const command = args?.command;
+    if (typeof command !== "string") {
+        return `entry "${entry.raw}" requires a command string to match against, and this call has none`;
+    }
+    const parsedCommand = parseLeadingCommandName(command);
+    if ("reject" in parsedCommand) {
+        return `entry "${entry.raw}" only admits a single simple command (${parsedCommand.reject})`;
+    }
+    if (!specifierMatchesCommand(specifier, normalizeSpacing(command))) {
+        return `command "${command.trim()}" is not admitted by entry "${entry.raw}"`;
+    }
+    return undefined;
+}

package/dist/core/skills-directory.d.ts

@@ -1,5 +1,5 @@
 import type { SkillSpec } from "./types.js";
-export type SkillsDirectoryWarningCode = "no_skill_file" | "no_frontmatter" | "missing_name" | "invalid_name" | "name_mismatch" | "missing_description" | "description_too_long" | "allowed_tool_not_mounted" | "disallowed_tools_unenforced" | "attachment_skipped" | "read_failed";
+export type SkillsDirectoryWarningCode = "no_skill_file" | "no_frontmatter" | "missing_name" | "invalid_name" | "name_mismatch" | "missing_description" | "allowed_tool_pattern_unsupported" | "description_too_long" | "allowed_tool_not_mounted" | "disallowed_tools_unenforced" | "attachment_skipped" | "read_failed";
 export interface SkillsDirectoryWarning {
     code: SkillsDirectoryWarningCode;
     skill: string;

package/dist/core/skills-directory.js

@@ -1,6 +1,7 @@
 import { readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
 import { isAbsolute, join, relative } from "node:path";
 import { canonicalToolName } from "./tool-name-aliases.js";
+import { isSkillSpecifierEnforced, parseSkillToolEntry } from "./skill-tool-specifier.js";
 const SKILL_FILE = "SKILL.md";
 const RESOURCE_DIRS = ["assets", "references", "scripts"];
 const NAME_MAX_CHARS = 64;
@@ -316,12 +317,23 @@ function manifestFromAllowedTools(declared, disallowed, skillName, deployedTools
     const names = [];
     const seen = new Set();
     for (const n of splitToolNames(declared)) {
-        const key = canonicalToolName(n);
+        const entry = parseSkillToolEntry(n);
+        const key = entry.specifier === undefined ? entry.name : `${entry.name}(${entry.specifier})`;
         if (seen.has(key))
             continue;
         seen.add(key);
         names.push(n);
     }
+    for (const n of names) {
+        const entry = parseSkillToolEntry(n);
+        if (entry.specifier !== undefined && !isSkillSpecifierEnforced(entry.name)) {
+            warn({
+                code: "allowed_tool_pattern_unsupported",
+                skill: skillName,
+                detail: `allowed-tools entry "${n}" narrows a tool whose calls cannot be matched against a command pattern — only shell tools carry one, so the entry is not enforced and the tool is DISABLED inside this skill frame. Use the bare tool name to allow it fully.`,
+            });
+        }
+    }
     if (names.length === 0)
         return undefined;
     if (names.some((n) => n === ALL_TOOLS_WILDCARD))
@@ -329,9 +341,9 @@ function manifestFromAllowedTools(declared, disallowed, skillName, deployedTools
     let allowTools = names;
     if (deployedTools !== undefined) {
         const mounted = new Set(deployedTools.map(canonicalToolName));
-        allowTools = names.filter((n) => mounted.has(canonicalToolName(n)));
+        allowTools = names.filter((n) => mounted.has(parseSkillToolEntry(n).name));
         for (const n of names) {
-            if (!mounted.has(canonicalToolName(n))) {
+            if (!mounted.has(parseSkillToolEntry(n).name)) {
                 warn({
                     code: "allowed_tool_not_mounted",
                     skill: skillName,
@@ -342,7 +354,7 @@ function manifestFromAllowedTools(declared, disallowed, skillName, deployedTools
     }
     if (disallowed.length > 0) {
         const denied = new Set(disallowed.map(canonicalToolName));
-        allowTools = allowTools.filter((n) => !denied.has(canonicalToolName(n)));
+        allowTools = allowTools.filter((n) => !denied.has(parseSkillToolEntry(n).name));
     }
     return { allowTools, lineageId: `skill:${skillName}` };
 }

package/dist/core/types.d.ts

@@ -1,6 +1,6 @@
 import type { TSchema } from "typebox";
 import type { AgentTool, ThinkingLevel } from "../internal/harness.js";
-import type { DocumentContent, ImageContent, Model, ResilienceOptions, StreamFn, TextContent } from "../internal/llm.js";
+import type { CompleteSimpleFn, DocumentContent, ImageContent, Model, ResilienceOptions, StreamFn, TextContent } from "../internal/llm.js";
 import type { TaskNotificationPayload } from "./task-notification.js";
 export type ModelRef = string | Model;
 export type ModelRole = "default" | "summarize" | "subagent" | "team" | "synthesize" | "advisor" | "verifier" | "classifier";
@@ -13,10 +13,7 @@ export type RoleSpec = ModelRef | {
 export type ModelRoles = Partial<Record<ModelRole, RoleSpec>>;
 export interface Brain {
     stream: StreamFn;
-    complete?: (model: Model, context: {
-        systemPrompt?: string;
-        messages: unknown[];
-    }, options?: unknown) => Promise<unknown>;
+    complete?: CompleteSimpleFn;
 }
 export type ToolEffect = "read" | "write" | "idempotent";
 export interface ToolSpec<TParams extends TSchema = TSchema> {
@@ -370,6 +367,13 @@ export interface TaskSpec {
     signal?: AbortSignal;
 }
 export type TaskStatus = "completed" | "blocked" | "failed" | "timeout" | "suspended" | "needs_review";
+export interface RemoteEnvFailureNote {
+    op: "suspendVM" | "resumeVM" | "postResumeInit";
+    code: import("./remote-env.js").RemoteExecutionErrorCode;
+    retryable: boolean;
+    attempts: number;
+    message: string;
+}
 export interface TaskResult {
     taskId: string;
     sessionId: string;
@@ -380,6 +384,8 @@ export interface TaskResult {
     blockedReason?: string;
     checkpointToken?: import("./checkpoint-store.js").CheckpointToken;
     checkpointGate?: import("./checkpoint-store.js").CheckpointGate;
+    workspaceRestoreMode?: "snapshot" | "park_only";
+    remoteEnvFailures?: RemoteEnvFailureNote[];
     errorMessage?: string;
     errorCode?: string;
     degraded?: {

package/dist/core/with-retry.js

@@ -13,7 +13,6 @@ export async function withRetry(op, policy, opts = {}) {
                 opts.signal?.removeEventListener("abort", onAbort);
                 resolve();
             }, ms);
-            timer.unref?.();
             opts.signal?.addEventListener("abort", onAbort, { once: true });
         }));
     let last = await op(1);

package/dist/engine/harness/types.d.ts

@@ -47,7 +47,7 @@ export declare class FileError extends Error {
     path?: string;
     constructor(code: FileErrorCode, message: string, path?: string, cause?: Error);
 }
-export type ExecutionErrorCode = "aborted" | "timeout" | "shell_unavailable" | "spawn_error" | "callback_error" | "transport_lost" | "unknown";
+export type ExecutionErrorCode = "aborted" | "timeout" | "shell_unavailable" | "spawn_error" | "callback_error" | "transport_lost" | "suspended" | "auth_failed" | "unknown";
 export declare class ExecutionError extends Error {
     code: ExecutionErrorCode;
     partialStdout?: string;

package/dist/index.d.ts

@@ -56,7 +56,7 @@ export { getShellConfig, isWslBashLauncher } from "./engine/execution-env/node-e
 export { isSecretEnvKey, scrubSecretEnv } from "./core/secret-env.js";
 export { MAX_EXEC_OUTPUT_BYTES, RollingTailBuffer, markTruncated } from "./core/exec-output-tail.js";
 export type { ExecutionEnv, FileInfo, Result, FileErrorCode, ExecutionErrorCode } from "./internal/harness.js";
-export { RemoteExecutionError, hasDestroy, isRemoteExecutionEnv, isSuspendable, isIsolated, } from "./core/remote-env.js";
+export { RemoteExecutionError, hasDestroy, isRemoteExecutionEnv, isSuspendable, isIsolated, missingRestoreSurface, isRetryableRemoteErrorCode, RETRYABLE_REMOTE_ERROR_CODES, } from "./core/remote-env.js";
 export { withRetry } from "./core/with-retry.js";
 export type { RetryPolicy, RetryResult } from "./core/with-retry.js";
 export type { RemoteExecutionEnv, WorkspaceHandle, SnapshotId, SessionToken, SandboxTier, OutputChunk, ExecStreamOptions, RemoteConnectConfig, VmLifecycleOptions, SecretRef, RemoteExecutionErrorCode, ExecutionEnvFactory, ExecutionEnvFactoryContext, } from "./core/remote-env.js";
@@ -188,8 +188,8 @@ export { createDegradingBrain, readDegradation, DEGRADED_DIAGNOSTIC_TYPE, type D
 export { retryBackoffMs, parseRetryAfter } from "./brain/retry.js";
 export { type BrainTimeoutConfig } from "./brain/timeout.js";
 export { createAssistantMessageEventStream } from "./internal/llm.js";
-export type { AssistantMessage, AssistantMessageEvent, Context, DocumentContent, ImageContent, Message, StopReason, StreamFn, TextContent, ThinkingContent, ToolCall, ToolResultMessage, Usage, UserMessage, } from "./internal/llm.js";
-export type { AgentDefinition, BeforeWriteHook, BeforeWriteRequest, BeforeWriteResult, HandsBandOptions, Brain, BrainStatus, BrainStatusPhase, ImageInput, McpElicitRequest, McpElicitResponse, McpServerSpec, OnElicit, Model, ModelRef, ProjectMemoryLoad, RunnerDeps, RuntimeCaps, BackgroundChildEvent, SkillManifest, SkillSpec, TaskEvent, TaskEventIdentity, ToolActivity, TaskResult, TaskSpec, TaskStatus, TaskStream, CompactOutcome, ThinkingLevel, ToolExecuteContext, ToolReturn, ToolSpec, ToolEffect, WorkflowGovernanceBaseline, } from "./core/types.js";
+export type { AssistantMessage, AssistantMessageEvent, CompleteSimpleFn, Context, DocumentContent, ImageContent, Message, StopReason, StreamFn, TextContent, ThinkingContent, ToolCall, ToolResultMessage, Usage, UserMessage, } from "./internal/llm.js";
+export type { AgentDefinition, BeforeWriteHook, BeforeWriteRequest, BeforeWriteResult, HandsBandOptions, Brain, BrainStatus, BrainStatusPhase, ImageInput, McpElicitRequest, McpElicitResponse, McpServerSpec, OnElicit, Model, ModelRef, ProjectMemoryLoad, RunnerDeps, RuntimeCaps, BackgroundChildEvent, SkillManifest, SkillSpec, TaskEvent, TaskEventIdentity, ToolActivity, TaskResult, RemoteEnvFailureNote, TaskSpec, TaskStatus, TaskStream, CompactOutcome, ThinkingLevel, ToolExecuteContext, ToolReturn, ToolSpec, ToolEffect, WorkflowGovernanceBaseline, } from "./core/types.js";
 export { Type } from "typebox";
 export type { TSchema, Static } from "typebox";
 export { explainPromptAssembly, describeDefaultPack, type DefaultPackDescription, type ExplainInput } from "./prompt-assembly/explain.js";

package/dist/index.js

@@ -51,7 +51,7 @@ export { killProcessTree, signalProcessTree } from "./engine/execution-env/kill-
 export { getShellConfig, isWslBashLauncher } from "./engine/execution-env/node-execution-env.js";
 export { isSecretEnvKey, scrubSecretEnv } from "./core/secret-env.js";
 export { MAX_EXEC_OUTPUT_BYTES, RollingTailBuffer, markTruncated } from "./core/exec-output-tail.js";
-export { RemoteExecutionError, hasDestroy, isRemoteExecutionEnv, isSuspendable, isIsolated, } from "./core/remote-env.js";
+export { RemoteExecutionError, hasDestroy, isRemoteExecutionEnv, isSuspendable, isIsolated, missingRestoreSurface, isRetryableRemoteErrorCode, RETRYABLE_REMOTE_ERROR_CODES, } from "./core/remote-env.js";
 export { withRetry } from "./core/with-retry.js";
 export { addWorktree, pruneWorktrees, WORKTREE_PARENT } from "./core/git-worktree-env.js";
 export { runExecGate } from "./core/exec-gate.js";

package/dist/internal/llm.d.ts

@@ -1,2 +1,2 @@
 export { createAssistantMessageEventStream, stripEngineMetadata } from "../engine/llm/index.js";
-export type { AnthropicMessagesCompat, AssistantMessage, AssistantMessageDiagnostic, AssistantMessageEvent, Context, DocumentContent, ImageContent, Message, Model, ResilienceOptions, SimpleStreamOptions, StallTimeouts, StopReason, StreamFn, TextContent, ThinkingContent, Tool, ToolCall, ToolResultMessage, Usage, UserMessage, } from "../engine/llm/index.js";
+export type { AnthropicMessagesCompat, AssistantMessage, AssistantMessageDiagnostic, AssistantMessageEvent, CompleteSimpleFn, Context, DocumentContent, ImageContent, Message, Model, ResilienceOptions, SimpleStreamOptions, StallTimeouts, StopReason, StreamFn, TextContent, ThinkingContent, Tool, ToolCall, ToolResultMessage, Usage, UserMessage, } from "../engine/llm/index.js";

package/dist/orchestration/workflow.js

@@ -480,13 +480,15 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         if (row !== undefined)
             row.sessionId = sessionId;
     };
-    const bceTick = (callKey, e) => {
+    const bceTick = (callKey, e, fromSessionId) => {
         if (!bceSink)
             return;
         const id = waIdOf(callKey);
         const row = bceLive.get(id);
         if (row === undefined)
             return;
+        if (fromSessionId !== undefined && row.sessionId !== undefined && fromSessionId !== row.sessionId)
+            return;
         bceEmit({
             kind: "tick",
             taskId: id,
@@ -507,8 +509,10 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         if (!bceSink)
             return;
         const id = waIdOf(callKey);
+        const row = bceLive.get(id);
         if (!bceLive.delete(id))
             return;
+        const coord = sessionId ?? row?.sessionId;
         bceEmit({
             kind: "terminal",
             taskId: id,
@@ -516,7 +520,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             owner: runId,
             workflowRunId: runId,
             ...(scope !== undefined ? { scope } : {}),
-            ...(sessionId !== undefined ? { sessionId, transcriptId: sessionId } : {}),
+            ...(coord !== undefined ? { sessionId: coord, transcriptId: coord } : {}),
             status,
             summary: boundedRedactedSummary(summary, 300),
             ...(stats !== undefined ? { usage: { tokens: stats.tokens, turns: stats.turns, ...(stats.costMicroUsd !== undefined ? { costMicroUsd: stats.costMicroUsd } : {}) } } : {}),
@@ -873,7 +877,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                             ? {
                                 onForwardEvent: (e) => {
                                     if (e.type === "task_progress")
-                                        bceTick(callKey, e);
+                                        bceTick(callKey, e, attemptSessionId);
                                     try {
                                         baseInternals.onForwardEvent?.(e);
                                     }
@@ -1181,7 +1185,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                         ? {
                             onForwardEvent: (e) => {
                                 if (e.type === "task_progress")
-                                    bceTick(callKey, e);
+                                    bceTick(callKey, e, childSessionId);
                                 try {
                                     enrichedForwardS?.(e);
                                 }

package/dist/tools/fs/bash-readonly-classifier.js

@@ -107,10 +107,42 @@ function hasUnquotedExpansionMetachar(rawToken) {
     }
     return false;
 }
+function longOptionNameOf(tok) {
+    if (!tok.startsWith("--") || tok.length === 2)
+        return undefined;
+    const body = tok.slice(2);
+    const eq = body.indexOf("=");
+    const name = eq >= 0 ? body.slice(0, eq) : body;
+    return name.length > 0 ? name : undefined;
+}
+function isLongOptionAbbrevOf(name, full) {
+    return full.startsWith(name);
+}
 function isGrepPatternFlagToken(tok) {
-    if (tok.startsWith("--"))
-        return tok.startsWith("--regexp") || tok.startsWith("--file");
-    return /^-[A-Za-z]*[ef]/.test(tok);
+    if (tok.startsWith("--")) {
+        const long = longOptionNameOf(tok);
+        return long !== undefined && (isLongOptionAbbrevOf(long, "regexp") || isLongOptionAbbrevOf(long, "file"));
+    }
+    return /^-[A-Za-z0-9]*[ef]/.test(tok);
+}
+function isGrepPatternPayloadLongOption(tok) {
+    if (!tok.includes("="))
+        return false;
+    const name = longOptionNameOf(tok);
+    return name !== undefined && isLongOptionAbbrevOf(name, "regexp");
+}
+function isCutDelimiterPayloadLongOption(tok) {
+    if (!tok.includes("="))
+        return false;
+    const name = longOptionNameOf(tok);
+    return name !== undefined && (isLongOptionAbbrevOf(name, "delimiter") || isLongOptionAbbrevOf(name, "output-delimiter"));
+}
+function isGrepFileStdinLongOption(tok) {
+    const eq = tok.indexOf("=");
+    if (eq < 0 || tok.slice(eq + 1) !== "-")
+        return false;
+    const name = longOptionNameOf(tok);
+    return name !== undefined && isLongOptionAbbrevOf(name, "file");
 }
 function grepClusterValueOwner(tok) {
     if (!/^-[A-Za-z]/.test(tok) || tok.startsWith("--"))
@@ -176,9 +208,9 @@ function collectSegmentBoundaryFindings(tokens, boundary) {
                 k++;
                 continue;
             }
-            if (name === "cut" && (/^-d./.test(t) || /^--(output-)?delimiter=/.test(t)))
+            if (name === "cut" && (/^-d./.test(t) || isCutDelimiterPayloadLongOption(t)))
                 continue;
-            if (name === "grep" && (grepClusterValueOwner(t) === "e" || /^--regexp=/.test(t)))
+            if (name === "grep" && (grepClusterValueOwner(t) === "e" || isGrepPatternPayloadLongOption(t)))
                 continue;
             if (t.startsWith("-") && t !== "-") {
                 for (const payload of attachedOptionPayloads(t)) {
@@ -312,7 +344,7 @@ export function classifyCompoundReadonlyDetailed(command, allow, boundary) {
                         k++;
                         continue;
                     }
-                    if (name === "grep" && (t === "-f-" || t === "--file=-")) {
+                    if (name === "grep" && (t === "-f-" || isGrepFileStdinLongOption(t))) {
                         hasStdinDash = true;
                         break;
                     }

package/dist/tools/fs/fs-bash.js

@@ -229,6 +229,20 @@ async function runShell(env, cwd, toolName, command, timeoutSec, caps, signal, c
                 isError: true,
             };
         }
+        if (res.error.code === "suspended") {
+            return {
+                content: `Error (${toolName}): the execution environment is suspended (its workspace VM is paused), so the command did NOT run and no command can run in this leg. Do not retry it here — the task must be resumed first; report that the workspace is suspended. (${res.error.message})`,
+                details: { type: "bash", envSuspended: true },
+                isError: true,
+            };
+        }
+        if (res.error.code === "auth_failed") {
+            return {
+                content: `Error (${toolName}): authentication to the execution environment was rejected, so the command did NOT run. Do NOT retry — this is a permanent credential failure that an operator must fix; report it instead of trying other commands. (${res.error.message})`,
+                details: { type: "bash", authFailed: true },
+                isError: true,
+            };
+        }
         if (res.error.code === "timeout" || res.error.code === "aborted" || res.error.code === "callback_error") {
             const rawStdout = res.error.partialStdout ?? "";
             const rawStderr = res.error.partialStderr ?? "";

package/dist/tools/scheduler-tools.js

@@ -83,16 +83,13 @@ function expandCronField(field, { min, max }) {
     return out.size > 0 ? [...out].sort((a, b) => a - b) : null;
 }
 export function cronScheduleError(expr) {
-    const parts = expr.trim().split(/\s+/);
-    let std = parts;
-    if (parts.length === 6) {
-        if (!expandCronField(parts[0] ?? "", { min: 0, max: 59 })) {
-            return `invalid seconds field "${parts[0]}" — allowed 0-59 (syntax: N, N-M, */N, comma lists).`;
-        }
-        std = parts.slice(1);
+    const std = expr.trim().split(/\s+/);
+    if (std.length === 6) {
+        return (`its leading seconds field is not supported — the resident scheduler fires on 5-field cron, so one ` +
+            `minute is the finest granularity available. Pass "${std.slice(1).join(" ")}" if that cadence works.`);
     }
-    else if (parts.length !== 5) {
-        return `expected 5 fields (minute hour day-of-month month day-of-week) or 6 with leading seconds, got ${parts.length}.`;
+    if (std.length !== 5) {
+        return `expected 5 fields (minute hour day-of-month month day-of-week), got ${std.length}.`;
     }
     const expanded = [];
     for (let i = 0; i < 5; i++) {
@@ -117,9 +114,12 @@ export function cronScheduleError(expr) {
     return null;
 }
 const DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+function cronExprFromSummary(when) {
+    const trimmed = when.trim();
+    return trimmed.startsWith("cron ") ? trimmed.slice("cron ".length).trim() : trimmed;
+}
 export function cronToHuman(expr) {
-    const parts = expr.trim().split(/\s+/);
-    const std = parts.length === 6 ? parts.slice(1) : parts;
+    const std = cronExprFromSummary(expr).split(/\s+/);
     if (std.length !== 5)
         return expr;
     const [minute = "", hour = "", dom = "", month = "", dow = ""] = std;
@@ -158,6 +158,12 @@ export function createSchedulerTools(env, ctx) {
         return [];
     const sched = env;
     const schedCtx = toSchedulerContext(ctx);
+    let cronCreateChain = Promise.resolve();
+    const serializedCronCreateOp = (fn) => {
+        const next = cronCreateChain.then(fn, fn);
+        cronCreateChain = next.then(() => undefined, () => undefined);
+        return next;
+    };
     const cronCreateDescription = `Schedule a prompt to be enqueued at a future time. Use for both recurring schedules and one-shot reminders. The task runs UNATTENDED when it fires, so write a fully self-contained \`prompt\` (it will not see this conversation). Use CronList to see what you've scheduled, CronDelete to remove one.
 
 ## One-shot tasks (schedule kind "delay" or "at")
@@ -191,7 +197,10 @@ Only use minute 0 or 30 when the user names that exact time and clearly means it
         parameters: Type.Object({
             prompt: Type.String({ description: "Self-contained instructions for the future task (it runs unattended)." }),
             schedule: Type.Optional(Type.Union([
-                Type.Object({ kind: Type.Literal("cron"), expr: Type.String({ description: "5- or 6-field cron expression." }) }),
+                Type.Object({
+                    kind: Type.Literal("cron"),
+                    expr: Type.String({ description: "5-field cron expression (minute hour day-of-month month day-of-week)." }),
+                }),
                 Type.Object({ kind: Type.Literal("at"), atMs: Type.Number({ description: "Absolute epoch ms to fire once." }) }),
                 Type.Object({ kind: Type.Literal("delay"), delaySec: Type.Number({ description: "Seconds from now to fire once." }) }),
             ], { description: 'When to fire. Pass exactly one of `schedule` or `cron`. Defaults to `durable: true`.' })),
@@ -207,7 +216,7 @@ Only use minute 0 or 30 when the user names that exact time and clearly means it
             label: Type.Optional(Type.String({ description: "Short label (also a dedup key with the schedule)." })),
         }),
         effect: "write",
-        execute: async (args) => {
+        execute: async (args) => serializedCronCreateOp(async () => {
             const a = args;
             if (a.schedule !== undefined && a.cron !== undefined) {
                 return errorResult("Error (CronCreate): pass exactly one of `schedule` (object form) or `cron` (string form), not both.");
@@ -221,7 +230,7 @@ Only use minute 0 or 30 when the user names that exact time and clearly means it
             const when = a.schedule ?? { kind: "cron", expr: a.cron };
             if (when.kind === "cron") {
                 if (!isValidCronExpr(when.expr)) {
-                    return errorResult(`Error (CronCreate): invalid cron expression "${when.expr}" — only 5/6 space-separated cron fields (digits and * / , -) are allowed.`);
+                    return errorResult(`Error (CronCreate): invalid cron expression "${when.expr}" — only 5 space-separated cron fields (digits and * / , -) are allowed (a 6th leading seconds field is parsed but always rejected next — this scheduler has no seconds hand).`);
                 }
                 const deepErr = cronScheduleError(when.expr);
                 if (deepErr)
@@ -246,25 +255,35 @@ Only use minute 0 or 30 when the user names that exact time and clearly means it
                 ...(!durable ? { lifetime: "session" } : {}),
                 ...(a.recurring !== undefined ? { recurring: a.recurring } : {}),
             };
+            const before = await sched.list(schedCtx);
+            const knownIds = before.ok ? new Set(before.value.map((s) => s.id)) : undefined;
             const r = await sched.schedule(intent, schedCtx);
             if (!r.ok)
                 return errorResult(`Error (CronCreate): ${r.error.message}`);
+            const replaced = knownIds?.has(r.value.id);
             const humanSchedule = when.kind === "cron"
                 ? cronToHuman(when.expr)
                 : when.kind === "delay"
                     ? `once in ${when.delaySec}s`
                     : `once at ${new Date(when.atMs).toISOString()}`;
+            const named = `${r.value.id}${a.label ? ` (${a.label})` : ""}`;
+            const content = replaced === true
+                ? `Updated scheduled task ${named} — it replaced an existing job with the same schedule and label, whose prompt is now gone.`
+                : replaced === false
+                    ? `Scheduled task ${named}.`
+                    : `Scheduled (or updated) task ${named} — the scheduler's listing was unavailable, so whether this replaced an existing job with the same schedule and label is unknown.`;
             return {
-                content: `Scheduled task ${r.value.id}${a.label ? ` (${a.label})` : ""}.`,
+                content,
                 details: {
                     type: "cron-create",
                     id: r.value.id,
                     humanSchedule,
                     recurring: when.kind === "cron" && a.recurring !== false,
                     durable,
+                    ...(replaced !== undefined ? { replaced } : {}),
                 },
             };
-        },
+        }),
     });
     const cronCancel = defineTool({
         name: "CronDelete",
@@ -298,17 +317,18 @@ Only use minute 0 or 30 when the user names that exact time and clearly means it
             }
             const content = r.value
                 .map((s) => {
+                const shown = cronExprFromSummary(s.when);
                 const human = cronToHuman(s.when);
                 const tier = s.lifetime === "session" ? " [session]" : "";
                 const once = s.recurring === false ? " [once]" : "";
-                return `- ${s.id}: ${s.when}${human !== s.when ? ` — ${human}` : ""}${s.label ? ` (${s.label})` : ""}${tier}${once}`;
+                return `- ${s.id}: ${shown}${human !== s.when ? ` — ${human}` : ""}${s.label ? ` (${s.label})` : ""}${tier}${once}`;
             })
                 .join("\n");
             const jobs = r.value.map((s) => {
                 const human = cronToHuman(s.when);
                 return {
                     id: s.id,
-                    cron: s.when,
+                    cron: cronExprFromSummary(s.when),
                     humanSchedule: human !== s.when ? human : s.when,
                     ...(s.label !== undefined ? { label: s.label } : {}),
                     ...(s.recurring !== undefined ? { recurring: s.recurring } : {}),

package/dist/tools/web.d.ts

@@ -6,7 +6,10 @@ export interface WebFetchConfig {
     fetchImpl?: typeof fetch;
     maxBytes?: number;
     timeoutMs?: number;
-    summarize?: (content: string, prompt: string, signal?: AbortSignal) => Promise<string>;
+    summarize?: (content: string, prompt: string, signal?: AbortSignal) => Promise<string | {
+        text: string;
+        truncated?: boolean;
+    }>;
     userAgent?: string;
 }
 export declare function htmlToText(html: string): string;
@@ -14,7 +17,10 @@ export declare function webFetchToolSpec(config?: WebFetchConfig): ToolSpec;
 export declare function createWebFetchTool(config?: WebFetchConfig): AgentTool;
 export declare const WEBFETCH_SUMMARY_MAX_CONTENT = 100000;
 export declare const WEBFETCH_SUMMARY_GUIDELINES: string;
-export declare function createWebFetchSummarizer(brain: Brain, model: Model): (content: string, prompt: string, signal?: AbortSignal) => Promise<string>;
+export declare function createWebFetchSummarizer(brain: Brain, model: Model): (content: string, prompt: string, signal?: AbortSignal) => Promise<string | {
+    text: string;
+    truncated?: boolean;
+}>;
 export interface WebSearchConfig {
     search: (query: string, signal?: AbortSignal, opts?: {
         allowedDomains?: string[];