@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/src/tools/send-task.ts

@@ -17,6 +17,7 @@ import {
   isExtensionAgent,
 } from "@/be/db";
 import { repointTrackerSyncBySwarmId } from "@/be/db-queries/tracker";
+import { explicitModelErrorForAgent } from "@/be/model-validation";
 import { applyPreTaskCreate } from "@/extensions/apply-task-create";
 import { checkSlackRoutingCoherence } from "@/tasks/slack-routing";
 import { findDuplicateTask } from "@/tools/task-dedup";
@@ -131,11 +132,17 @@ export const sendTaskInputSchema = z
       .min(1)
       .optional()
       .describe(
-        "Concrete model override for this task, interpreted by the assignee's harness/provider. This does not switch providers. Prefer modelTier for portable intent.",
+        "Concrete model override for this task, interpreted by the assignee's harness/provider. This does not switch providers. Prefer modelTier for portable intent. The model must run on the assignee's harness (an Anthropic model on a Claude agent, an OpenAI model on a Codex agent); a mismatch is rejected.",
       ),
     modelTier: ModelTierSchema.optional().describe(
       "Portable model tier for this task: 'smol', 'regular', 'smart', or 'ultra'. Resolved at claim/run time using the assignee's harness/provider. Legacy model shortnames map as haiku→smol, sonnet→regular, opus→smart, fable→ultra.",
     ),
+    allowCustomModel: z
+      .boolean()
+      .optional()
+      .describe(
+        "Accept a `model` the model catalog does not list. Without it an unknown model id is rejected. Only for ids the catalog cannot know yet (a fresh launch, a private deployment).",
+      ),
     effort: ReasoningEffortSchema.optional().describe(
       "Reasoning effort for this task: 'off', 'low', 'medium', 'high', 'xhigh', or 'max'. If omitted, the assignee's REASONING_EFFORT_OVERRIDE/default applies.",
     ),
@@ -268,6 +275,7 @@ export async function sendTaskHandler(
     vcsRepo,
     model,
     modelTier,
+    allowCustomModel,
     effort,
     allowDuplicate,
     slackChannelId,
@@ -380,6 +388,14 @@ export async function sendTaskHandler(
       effectiveAgentId = effectiveParentTask.agentId;
     }
   }
+  // Judge the model against the harness that will actually run it, including the
+  // parent auto-route target.
+  const modelError = await explicitModelErrorForAgent({
+    model: normalizedModel.model,
+    allowCustomModel,
+    agentId: effectiveAgentId,
+  });
+  if (modelError) return toolErr(modelError, { data: { yourAgentId: creatorAgentId } });
   const effectiveRoutingReason =
     agentId !== undefined ? routingReason : effectiveAgentId ? "continuity" : undefined;
   const effectiveRoutingNote = effectiveRoutingReason ? routingNote : undefined;
@@ -427,6 +443,7 @@ export async function sendTaskHandler(
     options: requestedTaskOptions,
     origin: "mcp",
     requestInfo: ctx.kind === "owner" ? ctx.requestInfo : undefined,
+    allowCustomModel,
   });
   if (preCreate.kind === "blocked") {
     return toolErr(preCreate.reason, {

package/src/tools/store-progress.ts

@@ -6,6 +6,7 @@ import {
   createLogEntry,
   failTask,
   getAgentById,
+  getAgentCurrentTask,
   getDbClient,
   getResolvedConfig,
   getTaskById,
@@ -21,6 +22,7 @@ import {
   upsertTaskCitations,
 } from "@/be/task-citations";
 import { AgentFsProvider } from "@/fs/agent-fs-provider";
+import { can } from "@/rbac";
 import { runTaskTerminalEffects } from "@/tasks/task-terminal-effects";
 import {
   getTaskOutputValidationError,
@@ -49,6 +51,36 @@ const BLOCKED_WAITING_PATTERN =
 // noise and calling defer-task buys nothing over checking in again shortly.
 const BLOCKED_WAITING_MIN_ELAPSED_MS = 3 * 60 * 1000;
 
+/**
+ * Only the assigned agent may write a task's progress, status, or artifacts
+ * (`task.progress.write`). Workflow siblings see each other's task ids in
+ * their prompt, and a worker once completed a sibling's task with its own
+ * report. Leads keep cross-task writes (the task-citations suite pins lead
+ * completion of a worker task); unassigned tasks stay writable, matching
+ * `POST /api/tasks/:id/finish`. Returns the refusal message, naming the
+ * caller's own task so it can retry.
+ */
+async function foreignTaskWriteError(
+  caller: { id: string; isLead?: boolean },
+  task: { id: string; agentId?: string | null },
+  sourceTaskId: string | undefined,
+): Promise<string | undefined> {
+  const decision = can({
+    principal: { kind: "agent", agentId: caller.id, isLead: caller.isLead === true },
+    verb: "task.progress.write",
+    resource: { kind: "task", taskId: task.id, agentId: task.agentId },
+    source: "mcp",
+  });
+  if (decision.allow) return undefined;
+  const sourceTask = sourceTaskId ? await getTaskById(sourceTaskId) : null;
+  const ownTask =
+    sourceTask?.agentId === caller.id ? sourceTask : await getAgentCurrentTask(caller.id);
+  const retry = ownTask
+    ? ` Your own task is "${ownTask.id}"; call store-progress with that taskId.`
+    : " You have no in-progress task.";
+  return `Task "${task.id}" is assigned to another agent; only its assignee may store progress on it. Nothing was written.${retry}`;
+}
+
 export const storeProgressOutputSchema = swarmToolOutputSchema({
   // Bounded confirmation only. The handler keeps the full task row internally
   // for completion memory, raters, and follow-up creation, but never echoes it
@@ -227,14 +259,18 @@ export const registerStoreProgressTool = (server: McpServer) => {
         // Validate the caller and target before an agent-fs lookup. Otherwise a
         // forged X-Agent-ID or unknown task could use this tool as a file-existence
         // oracle through the API-owned agent-fs credential fallback.
-        if (!(await getAgentById(requestInfo.agentId))) {
+        const caller = await getAgentById(requestInfo.agentId);
+        if (!caller) {
           return toolErr(
             `Agent with ID "${requestInfo.agentId}" not found in the swarm, register before storing task progress.`,
           );
         }
-        if (!(await getTaskById(taskId))) {
+        const target = await getTaskById(taskId);
+        if (!target) {
           return toolErr(`Task with ID "${taskId}" not found.`);
         }
+        const foreignError = await foreignTaskWriteError(caller, target, requestInfo.sourceTaskId);
+        if (foreignError) return toolErr(foreignError);
 
         const configs = await getResolvedConfig(requestInfo.agentId ?? undefined);
         const configValue = (key: string) => configs.find((c) => c.key === key)?.value?.trim();
@@ -315,6 +351,15 @@ export const registerStoreProgressTool = (server: McpServer) => {
           };
         }
 
+        const foreignError = await foreignTaskWriteError(
+          agent,
+          existingTask,
+          requestInfo.sourceTaskId,
+        );
+        if (foreignError) {
+          return { success: false, message: foreignError };
+        }
+
         let updatedTask = existingTask;
         const isTerminal = isTerminalTaskStatus(existingTask.status);
         // This call's own status can finish the task even though existingTask
@@ -382,8 +427,8 @@ export const registerStoreProgressTool = (server: McpServer) => {
           }
         }
 
-        // Explicit task IDs retain the existing progress-update policy, but
-        // only the assigned agent may author sources. Check under the same
+        // A lead may update another agent's task (see foreignTaskWriteError),
+        // but only the assigned agent may author sources. Check under the same
         // transaction as the upsert, including for terminal tasks. Ignore an
         // unauthorized batch so citations never block the task update itself.
         if (citations?.length && existingTask.agentId === agent.id) {

package/src/tools/task-action.ts

@@ -27,6 +27,7 @@ import {
   releaseTask,
   updateTaskClaudeSessionId,
 } from "@/be/db";
+import { explicitModelErrorForAgent } from "@/be/model-validation";
 import { touchRuntimeInstance } from "@/be/multi-runtime";
 import { applyPreTaskCreate } from "@/extensions/apply-task-create";
 import { assertOwnsTask, ownerCtx, type ToolCtx } from "@/tools/task-tool-ctx";
@@ -93,11 +94,17 @@ export const taskActionInputSchema = z.object({
     .min(1)
     .optional()
     .describe(
-      "Concrete model override for the created task, interpreted by the claiming worker's harness/provider. This does not switch providers. Only used with 'create' action.",
+      "Concrete model override for the created task, interpreted by the claiming worker's harness/provider. This does not switch providers. Only used with 'create' action. The model must run on the assignee's harness (an Anthropic model on a Claude agent, an OpenAI model on a Codex agent); a mismatch is rejected.",
     ),
   modelTier: ModelTierSchema.optional().describe(
     "Portable model tier for the created task: 'smol', 'regular', 'smart', or 'ultra'. Resolved when a worker claims/runs the task. Only used with 'create' action.",
   ),
+  allowCustomModel: z
+    .boolean()
+    .optional()
+    .describe(
+      "Accept a `model` the model catalog does not list. Without it an unknown model id is rejected. Only used with 'create' action.",
+    ),
   effort: ReasoningEffortSchema.optional().describe(
     "Reasoning effort for the created task: 'off', 'low', 'medium', 'high', 'xhigh', or 'max'. Only used with 'create' action.",
   ),
@@ -275,6 +282,11 @@ export async function taskActionHandler(
         agentId,
       );
     }
+    const modelError = await explicitModelErrorForAgent({
+      model: normalizedModel.model,
+      allowCustomModel: input.allowCustomModel,
+    });
+    if (modelError) return taskActionResult({ success: false, message: modelError }, agentId);
     try {
       assetKey = key
         ? await authorizeAssetKeyWrite(key, await resolveTaskAuditUserId(ctx.sourceTaskId, agentId))
@@ -310,6 +322,7 @@ export async function taskActionHandler(
       },
       origin: "mcp",
       requestInfo: ctx.requestInfo,
+      allowCustomModel: input.allowCustomModel,
     });
     if (preCreate.kind === "blocked") {
       return taskActionResult({ success: false, message: preCreate.reason }, agentId);

package/src/tools/tool-config.ts

@@ -78,12 +78,14 @@ export const DEFERRED_TOOLS = new Set([
   "list-services",
   "update-service-status",
 
-  // Config (5)
+  // Config (7)
   "set-config",
   "list-config",
   "delete-config",
   "credential-bindings",
   "script-connections",
+  "model-catalog-refresh",
+  "model-catalog-overlay-upsert",
 
   // Repos (1)
   "update-repo",

package/src/tools/workflows/create-workflow.ts

@@ -19,6 +19,8 @@ import {
 } from "@/types";
 import { getExecutorRegistry } from "@/workflows";
 import { validateDefinition } from "@/workflows/definition";
+import { workflowModelErrors } from "@/workflows/model-validation";
+import { withSaveWarnings, workflowSaveWarnings } from "@/workflows/readiness";
 
 export const registerCreateWorkflowTool = (server: McpServer) => {
   createToolRegistrar(server)(
@@ -49,7 +51,8 @@ export const registerCreateWorkflowTool = (server: McpServer) => {
         "- WEBHOOK VERIFICATION: Webhook triggers use hmacSecret for all verification formats. " +
         "Omit verification for legacy HMAC-SHA256 over the raw body with fallback header scanning; " +
         "or set verification to { format: 'hmac-sha256', header }, { format: 'timestamped-hmac-sha256', header, toleranceSeconds? }, " +
-        "or { format: 'token-equality', header }. Example: { type: 'webhook', hmacSecret: 'secret.SUPERAGENT_WEBHOOK_SECRET', " +
+        "{ format: 'token-equality', header }, or { format: 'standard-webhooks', toleranceSeconds? } " +
+        "(standardwebhooks.com: webhook-id/webhook-timestamp/webhook-signature headers, hmacSecret is the whsec_ signing secret). Example: { type: 'webhook', hmacSecret: 'secret.SUPERAGENT_WEBHOOK_SECRET', " +
         "verification: { format: 'timestamped-hmac-sha256', header: 'X-Superagent-Signature', toleranceSeconds: 300 } }.\n" +
         "- WAIT NODE: type 'wait' pauses a workflow for a duration or until a named workflowEventBus event arrives. " +
         "See runbooks/workflows.md#wait-nodes for config shapes, ordering caveats, and built-in event names.",
@@ -66,7 +69,7 @@ export const registerCreateWorkflowTool = (server: McpServer) => {
           .array(TriggerConfigSchema)
           .optional()
           .describe(
-            "Optional trigger configurations (webhook, schedule, event). Webhook verification formats: legacy omitted verification, hmac-sha256, timestamped-hmac-sha256, token-equality.",
+            "Optional trigger configurations (webhook, schedule, event). Webhook verification formats: legacy omitted verification, hmac-sha256, timestamped-hmac-sha256, token-equality, standard-webhooks.",
           ),
         cooldown: CooldownConfigSchema.optional().describe(
           "Optional cooldown configuration to prevent re-triggering too frequently",
@@ -102,6 +105,7 @@ export const registerCreateWorkflowTool = (server: McpServer) => {
       outputSchema: swarmToolOutputSchema({
         yourAgentId: z.string().optional(),
         workflow: z.unknown().optional(),
+        warnings: z.array(z.string()).optional(),
       }),
     },
     async (
@@ -128,6 +132,10 @@ export const registerCreateWorkflowTool = (server: McpServer) => {
         if (!validation.valid) {
           return toolErr(`Invalid definition: ${validation.errors.join("; ")}`);
         }
+        const modelErrors = await workflowModelErrors(definition);
+        if (modelErrors.length > 0) {
+          return toolErr(`Invalid definition: ${modelErrors.join("; ")}`);
+        }
 
         const createdBy =
           (await resolveTaskAuditUserId(requestInfo.sourceTaskId, requestInfo.agentId)) ??
@@ -152,11 +160,16 @@ export const registerCreateWorkflowTool = (server: McpServer) => {
           "mcp",
         );
         const longScriptTimeoutHint = findLongScriptTimeoutHint(definition.nodes);
-        return toolOk(`Created workflow "${workflow.name}".`, {
-          details: `Created workflow "${workflow.name}" (${workflow.id}).`,
+        const warnings = await workflowSaveWarnings(workflow.definition, getExecutorRegistry());
+        return toolOk(withSaveWarnings(`Created workflow "${workflow.name}".`, warnings), {
+          details: withSaveWarnings(
+            `Created workflow "${workflow.name}" (${workflow.id}).`,
+            warnings,
+          ),
           data: {
             yourAgentId: requestInfo.agentId,
             workflow,
+            ...(warnings.length > 0 ? { warnings } : {}),
             ...(longScriptTimeoutHint ? { longScriptTimeoutHint } : {}),
           },
         });

package/src/tools/workflows/patch-workflow-node.ts

@@ -11,6 +11,7 @@ import {
 import { WorkflowNodePatchSchema } from "@/types";
 import { getExecutorRegistry } from "@/workflows";
 import { patchWorkflowDefinition } from "@/workflows/patch-definition";
+import { withSaveWarnings, workflowSaveWarnings } from "@/workflows/readiness";
 
 export const registerPatchWorkflowNodeTool = (server: McpServer) => {
   createToolRegistrar(server)(
@@ -30,6 +31,7 @@ export const registerPatchWorkflowNodeTool = (server: McpServer) => {
       outputSchema: swarmToolOutputSchema({
         workflow: z.unknown().optional(),
         versionCreated: z.number().optional(),
+        warnings: z.array(z.string()).optional(),
       }),
     },
     async ({ id, nodeId, ...nodeFields }, requestInfo) => {
@@ -59,14 +61,22 @@ export const registerPatchWorkflowNodeTool = (server: McpServer) => {
           { id: nodeId, type: patchedNode?.type, config: nodeFields.config },
         ]);
 
-        return toolOk(`Patched node "${nodeId}" in workflow "${workflow.name}".`, {
-          details: `Patched node "${nodeId}" in workflow "${workflow.name}" (${id}). Version ${version} snapshot created.`,
-          data: {
-            workflow,
-            versionCreated: version ?? undefined,
-            ...(longScriptTimeoutHint ? { longScriptTimeoutHint } : {}),
+        const warnings = await workflowSaveWarnings(result.definition, getExecutorRegistry());
+        return toolOk(
+          withSaveWarnings(`Patched node "${nodeId}" in workflow "${workflow.name}".`, warnings),
+          {
+            details: withSaveWarnings(
+              `Patched node "${nodeId}" in workflow "${workflow.name}" (${id}). Version ${version} snapshot created.`,
+              warnings,
+            ),
+            data: {
+              workflow,
+              versionCreated: version ?? undefined,
+              ...(warnings.length > 0 ? { warnings } : {}),
+              ...(longScriptTimeoutHint ? { longScriptTimeoutHint } : {}),
+            },
           },
-        });
+        );
       } catch (err) {
         return toolErr(String(err));
       }

package/src/tools/workflows/patch-workflow.ts

@@ -14,6 +14,7 @@ import type { WorkflowPatch } from "@/types";
 import { AssetKeySchema, WorkflowNodePatchSchema } from "@/types";
 import { getExecutorRegistry } from "@/workflows";
 import { patchWorkflowDefinition } from "@/workflows/patch-definition";
+import { withSaveWarnings, workflowSaveWarnings } from "@/workflows/readiness";
 
 export const registerPatchWorkflowTool = (server: McpServer) => {
   createToolRegistrar(server)(
@@ -78,6 +79,7 @@ export const registerPatchWorkflowTool = (server: McpServer) => {
         nodesCreated: z.number().optional(),
         nodesUpdated: z.number().optional(),
         nodesDeleted: z.number().optional(),
+        warnings: z.array(z.string()).optional(),
       }),
     },
     async ({ id, key, update, delete: del, create, onNodeFailure, triggerSchema }, requestInfo) => {
@@ -133,14 +135,19 @@ export const registerPatchWorkflowTool = (server: McpServer) => {
         );
         const longScriptTimeoutHint = findLongScriptTimeoutHint(authoredFinalNodes);
 
-        return toolOk(`Patched workflow "${workflow.name}".`, {
-          details: `Patched workflow "${workflow.name}" (${id}). Version ${version} snapshot created.`,
+        const warnings = await workflowSaveWarnings(result.definition, getExecutorRegistry());
+        return toolOk(withSaveWarnings(`Patched workflow "${workflow.name}".`, warnings), {
+          details: withSaveWarnings(
+            `Patched workflow "${workflow.name}" (${id}). Version ${version} snapshot created.`,
+            warnings,
+          ),
           data: {
             workflow,
             versionCreated: version ?? undefined,
             nodesCreated: create?.length ?? 0,
             nodesUpdated: update?.length ?? 0,
             nodesDeleted: del?.length ?? 0,
+            ...(warnings.length > 0 ? { warnings } : {}),
             ...(longScriptTimeoutHint ? { longScriptTimeoutHint } : {}),
           },
         });

package/src/tools/workflows/update-workflow.ts

@@ -19,6 +19,8 @@ import {
 } from "@/types";
 import { getExecutorRegistry } from "@/workflows";
 import { definitionNodeIds, validateDefinition } from "@/workflows/definition";
+import { workflowModelErrors } from "@/workflows/model-validation";
+import { withSaveWarnings, workflowSaveWarnings } from "@/workflows/readiness";
 import { snapshotAndUpdateWorkflow } from "@/workflows/version";
 
 export const registerUpdateWorkflowTool = (server: McpServer) => {
@@ -36,7 +38,8 @@ export const registerUpdateWorkflowTool = (server: McpServer) => {
         "WEBHOOK VERIFICATION: webhook triggers use hmacSecret for all verification formats. " +
         "Omit verification for legacy HMAC-SHA256 over the raw body with fallback header scanning; " +
         "or set verification to { format: 'hmac-sha256', header }, { format: 'timestamped-hmac-sha256', header, toleranceSeconds? }, " +
-        "or { format: 'token-equality', header }.",
+        "{ format: 'token-equality', header }, or { format: 'standard-webhooks', toleranceSeconds? } " +
+        "(standardwebhooks.com: webhook-id/webhook-timestamp/webhook-signature headers, hmacSecret is the whsec_ signing secret).",
       inputSchema: z.object({
         id: z.string().uuid().describe("Workflow ID to update"),
         key: AssetKeySchema.optional().describe("Move to a logical namespace."),
@@ -47,7 +50,7 @@ export const registerUpdateWorkflowTool = (server: McpServer) => {
           .array(TriggerConfigSchema)
           .optional()
           .describe(
-            "New trigger configurations. Webhook verification formats: legacy omitted verification, hmac-sha256, timestamped-hmac-sha256, token-equality.",
+            "New trigger configurations. Webhook verification formats: legacy omitted verification, hmac-sha256, timestamped-hmac-sha256, token-equality, standard-webhooks.",
           ),
         cooldown: CooldownConfigSchema.optional()
           .nullable()
@@ -84,6 +87,7 @@ export const registerUpdateWorkflowTool = (server: McpServer) => {
       outputSchema: swarmToolOutputSchema({
         workflow: z.unknown().optional(),
         versionCreated: z.number().optional(),
+        warnings: z.array(z.string()).optional(),
       }),
     },
     async (
@@ -118,6 +122,10 @@ export const registerUpdateWorkflowTool = (server: McpServer) => {
           if (!validation.valid) {
             return toolErr(`Invalid definition: ${validation.errors.join("; ")}`);
           }
+          const modelErrors = await workflowModelErrors(definition);
+          if (modelErrors.length > 0) {
+            return toolErr(`Invalid definition: ${modelErrors.join("; ")}`);
+          }
         }
 
         const updatedBy =
@@ -152,11 +160,16 @@ export const registerUpdateWorkflowTool = (server: McpServer) => {
         const longScriptTimeoutHint = definition
           ? findLongScriptTimeoutHint(definition.nodes)
           : undefined;
-        return toolOk(`Updated workflow "${workflow.name}".`, {
-          details: `Updated workflow "${workflow.name}" (${id}). Version ${version.version} snapshot created.`,
+        const warnings = await workflowSaveWarnings(workflow.definition, getExecutorRegistry());
+        return toolOk(withSaveWarnings(`Updated workflow "${workflow.name}".`, warnings), {
+          details: withSaveWarnings(
+            `Updated workflow "${workflow.name}" (${id}). Version ${version.version} snapshot created.`,
+            warnings,
+          ),
           data: {
             workflow,
             versionCreated: version.version,
+            ...(warnings.length > 0 ? { warnings } : {}),
             ...(longScriptTimeoutHint ? { longScriptTimeoutHint } : {}),
           },
         });

package/src/types.ts

@@ -231,6 +231,25 @@ export function resolveModelTier(opts: {
   return DEFAULT_MODEL_TIER_MAP[opts.harnessProvider]?.[tier];
 }
 
+export type ModelTierOverrides = Partial<Record<string, Partial<Record<ModelTier, string>>>>;
+
+/**
+ * The worker's own MODEL_TIER_<TIER> / MODEL_TIER_MAP overrides, keyed by its
+ * harness provider, in the shape the worker sends on register and poll so the
+ * server can apply them at claim time. Values only (model ids), never secrets.
+ */
+export function parseWorkerModelTierOverrides(
+  env: Record<string, string | undefined>,
+  harnessProvider: ProviderName,
+): ModelTierOverrides {
+  const tiers: Partial<Record<ModelTier, string>> = { ...parseTierMapJson(env.MODEL_TIER_MAP) };
+  for (const tier of MODEL_TIERS) {
+    const direct = env[`MODEL_TIER_${tier.toUpperCase()}`]?.trim();
+    if (direct) tiers[tier] = direct;
+  }
+  return Object.keys(tiers).length > 0 ? { [harnessProvider]: tiers } : {};
+}
+
 export function resolveTaskModelSelection(opts: {
   model?: string | null;
   modelTier?: string | null;
@@ -612,6 +631,12 @@ export const AgentTaskSchema = z
     model: z.string().optional(),
     modelTier: ModelTierSchema.optional(),
     effort: ReasoningEffortSchema.optional(),
+    // Claim-time model resolution (server-side, see runbooks/model-tiers.md).
+    // resolvedModel is what the worker runs; modelSource says which layer won;
+    // modelAlias is the `latest:` alias the value came from, when any.
+    resolvedModel: z.string().optional(),
+    modelSource: z.string().optional(),
+    modelAlias: z.string().optional(),
 
     // Schedule linking (optional — set when task was created by a schedule).
     // z.string(): also reachable verbatim from the create-task query param.
@@ -1996,7 +2021,7 @@ export const WorkflowNodeSchema = z
     type: z
       .string()
       .describe(
-        "Executor type: 'agent-task', 'script', 'swarm-script', 'raw-llm', 'validate', 'property-match'",
+        "Executor type: 'agent-task', 'script', 'swarm-script', 'raw-llm', 'system-one-decision', 'validate', 'property-match'",
       ),
     label: z.string().optional().describe("Human-readable label for UI display"),
     config: z
@@ -2005,6 +2030,7 @@ export const WorkflowNodeSchema = z
         "Executor-specific config. For agent-task: { template, outputSchema?, agentId?, routingReason?, routingNote?, tags?, priority?, dir?, vcsRepo?, model? }; configured agentId defaults routingReason to human_pinned. " +
           "For script: { runtime, script, args?, timeout? }. " +
           "For swarm-script: { scriptName, scope?, pinHash?, args?, fsMode?, timeoutMs? (1000-300000) }. " +
+          "For system-one-decision (typed decisions, Jev by default): { provider? ('typesafe' default | 'openrouter' | 'laya'; a literal, never a {{token}}), state, questions: { <id>: { type: 'noul'|'choice'|'score', instructions, criteria? } }, returns: { <id>: { type } }, model? (provider-specific; unset = the provider's default, and laya has none so it sends no model and picks its own checkpoint), timeoutMs?, maxRetries? (0-3), humanReview? { band: { min, max } (0-1, inclusive), approvers: { users?, roles?, policy }, title?, timeout?, notifications? } }; each provider needs its own global secret (TYPESAFE_API_KEY, OPENROUTER_API_KEY, or LAYA_API_KEY; laya also needs the global config LAYA_URL), and a save warns and a run fails before any node executes when one is missing; system-one-decision nodes must not set retry or validation.retry. With humanReview, an answer whose confidence is inside the band waits for a person (human-in-the-loop approval), and next must map ports { approved, rejected?, timeout? }. " +
           "Agent-task templates and ordinary config values support {{interpolation}} from the node's inputs context, including trigger and declared upstream aliases. " +
           "SECURITY: executable source for script/swarm-script nodes does not interpolate trigger.* or upstream node outputs; only input/workflow/swarm/run values are allowed in inline script source, and named swarm-script source is not workflow-interpolated. " +
           "Pass dynamic values through config.args instead (inline script receives them as argv; swarm-script receives its args object). " +
@@ -2127,6 +2153,8 @@ export interface PatchResult {
 
 // Presets only: Slack-style separate timestamp headers, asymmetric signatures,
 // and generic signature-template DSLs are intentionally out of scope for v1.
+// `standard-webhooks` follows https://www.standardwebhooks.com/ (symmetric v1 only):
+// fixed webhook-id / webhook-timestamp / webhook-signature headers, so no `header`.
 export const WebhookVerificationSchema = z.discriminatedUnion("format", [
   z.object({
     format: z.literal("hmac-sha256"),
@@ -2161,6 +2189,15 @@ export const WebhookVerificationSchema = z.discriminatedUnion("format", [
     format: z.literal("token-equality"),
     header: z.string().min(1).describe("Header containing the shared token to compare"),
   }),
+  z.object({
+    format: z.literal("standard-webhooks"),
+    toleranceSeconds: z
+      .number()
+      .int()
+      .positive()
+      .default(300)
+      .describe("Maximum allowed clock skew, in seconds, for the webhook-timestamp header"),
+  }),
 ]);
 export type WebhookVerification = z.infer<typeof WebhookVerificationSchema>;
 
@@ -2412,6 +2449,9 @@ export type AgentTaskSummary = Pick<
   | "scheduleId"
   | "model"
   | "modelTier"
+  | "resolvedModel"
+  | "modelSource"
+  | "modelAlias"
   | "effort"
   | "provider"
   | "requestedByUserId"

package/src/utils/codex-auth-failure.ts

@@ -0,0 +1,34 @@
+/**
+ * Codex pool auth-failure benching: shared by the runner (classifies and
+ * reports failures) and the API (counts them and benches the login).
+ *
+ * Worker-side code imports this file, so it must never import `src/be/db`
+ * or `bun:sqlite`.
+ */
+
+/** Consecutive auth failures that bench a Codex pool login. */
+export const CODEX_AUTH_FAILURE_BENCH_THRESHOLD = 2;
+/** Bench length. Matches the codex-auth-expiry-watch bench (benchDays = 365). */
+export const CODEX_AUTH_FAILURE_BENCH_MS = 365 * 24 * 60 * 60 * 1000;
+/** KV namespace and key shared with codex-auth-expiry-watch and keep-warm. */
+export const CODEX_AUTH_WATCH_NAMESPACE = "codex-auth-watch";
+export const codexAuthBenchMarkerKey = (keySuffix: string) => `bench:${keySuffix}`;
+
+/** Transient `[auth-error]` texts that must not count. */
+const TRANSIENT_AUTH_ERROR_MARKERS = [
+  "waiting for the refresh lock",
+  "refresh rejected (429",
+  "refresh rejected (5",
+  "refresh rejected (unknown status",
+  "out of credits",
+  "no credentials found in config store",
+  // Revalidation threw something other than a refresh rejection (lock HTTP,
+  // network, or persistence failure). See buildPoolRevalidationFailureReason.
+  "not a confirmed auth rejection",
+];
+
+export function isCodexAuthFailureReason(failureReason: string | undefined | null): boolean {
+  if (!failureReason || !failureReason.includes("[auth-error]")) return false;
+  const lower = failureReason.toLowerCase();
+  return !TRANSIENT_AUTH_ERROR_MARKERS.some((m) => lower.includes(m));
+}