@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/src/utils/runtime-model-catalog.ts

@@ -0,0 +1,152 @@
+/**
+ * Process-wide model catalog for code that runs on BOTH sides of the
+ * API/worker boundary (provider adapters, context-window math, reasoning
+ * gating). Model-catalog phase 4: this replaces the hand-maintained per-model
+ * tables (codex allowlist/windows/pricing, claude-managed allowlist/pricing,
+ * per-model context windows, the slim reasoning snapshot).
+ *
+ * Sources, highest first:
+ *   1. the live catalog: the API server's `model_catalog` + overlay rows.
+ *      Workers pull it over HTTP (`GET /api/models-catalog`, see
+ *      `refreshRuntimeModelCatalog`); the API process sets it directly after
+ *      every catalog reload.
+ *   2. the vendored models.dev snapshot (`src/be/modelsdev-cache.json`) —
+ *      offline fallback, and the only source for ids the live catalog has
+ *      dropped (legacy models still named by old tasks and pricing rows).
+ *
+ * NO database imports (worker-safe). Every lookup is synchronous; the HTTP
+ * refresh is TTL-cached and never throws, so hot paths stay cheap.
+ */
+import modelsDevSnapshot from "../be/modelsdev-cache.json";
+
+export interface RuntimeCatalogModel {
+  id?: string;
+  name?: string;
+  cost?: { input?: number; output?: number; cache_read?: number; cache_write?: number };
+  limit?: { context?: number };
+  release_date?: string;
+  status?: string;
+  reasoning?: boolean;
+  reasoning_options?: { type?: string; values?: string[] }[];
+}
+
+export interface RuntimeCatalogProvider {
+  id?: string;
+  name?: string;
+  models?: Record<string, RuntimeCatalogModel>;
+}
+
+export type RuntimeCatalog = Record<string, RuntimeCatalogProvider | undefined>;
+
+const SNAPSHOT = modelsDevSnapshot as unknown as RuntimeCatalog;
+
+/** Default freshness window for the worker-side HTTP pull. */
+export const RUNTIME_CATALOG_TTL_MS = 10 * 60_000;
+const FETCH_TIMEOUT_MS = 5_000;
+
+let live: RuntimeCatalog | null = null;
+let liveAt = 0;
+let liveSource: "live" | "snapshot" | null = null;
+const mergedSections = new Map<string, Record<string, RuntimeCatalogModel>>();
+let inFlight: Promise<boolean> | null = null;
+
+/** Replace the live layer (API process after a reload; worker after a pull). */
+export function setRuntimeModelCatalog(
+  providers: RuntimeCatalog,
+  at: number = Date.now(),
+  source: "live" | "snapshot" = "live",
+): void {
+  live = providers;
+  liveAt = at;
+  liveSource = source;
+  mergedSections.clear();
+}
+
+export function resetRuntimeModelCatalogForTests(): void {
+  live = null;
+  liveAt = 0;
+  liveSource = null;
+  mergedSections.clear();
+  inFlight = null;
+}
+
+/** Where the current live layer came from; null = snapshot only. */
+export function runtimeModelCatalogSource(): "live" | "snapshot" | null {
+  return liveSource;
+}
+
+/** One provider section: snapshot models overlaid by the live catalog (live wins per id). */
+export function runtimeCatalogSection(provider: string): Record<string, RuntimeCatalogModel> {
+  const cached = mergedSections.get(provider);
+  if (cached) return cached;
+  const merged: Record<string, RuntimeCatalogModel> = {
+    ...(SNAPSHOT[provider]?.models ?? {}),
+    ...(live?.[provider]?.models ?? {}),
+  };
+  mergedSections.set(provider, merged);
+  return merged;
+}
+
+/**
+ * The sections the harness-compatibility guard (`harnessModelMismatch`) reads: the two
+ * sections the pinned harnesses talk to. Sync, so worker spawn and config validation
+ * can judge a model without a round trip.
+ */
+export function runtimeHarnessSections(): Record<
+  "anthropic" | "openai",
+  { models: Record<string, RuntimeCatalogModel> }
+> {
+  return {
+    anthropic: { models: runtimeCatalogSection("anthropic") },
+    openai: { models: runtimeCatalogSection("openai") },
+  };
+}
+
+export function runtimeCatalogModel(
+  provider: string,
+  modelId: string,
+): RuntimeCatalogModel | undefined {
+  return runtimeCatalogSection(provider)[modelId];
+}
+
+/**
+ * Pull the live catalog from the API server. TTL-cached (`maxAgeMs`),
+ * single-flight, never throws: returns false and keeps the previous layer
+ * when the server is unreachable or answers non-2xx.
+ */
+export async function refreshRuntimeModelCatalog(opts: {
+  apiUrl: string;
+  apiKey?: string;
+  agentId?: string;
+  maxAgeMs?: number;
+  fetchImpl?: typeof fetch;
+}): Promise<boolean> {
+  const maxAge = opts.maxAgeMs ?? RUNTIME_CATALOG_TTL_MS;
+  if (live && Date.now() - liveAt < maxAge) return true;
+  if (inFlight) return inFlight;
+  const doFetch = opts.fetchImpl ?? fetch;
+  inFlight = (async () => {
+    try {
+      const headers: Record<string, string> = {};
+      if (opts.apiKey) headers.Authorization = `Bearer ${opts.apiKey}`;
+      if (opts.agentId) headers["X-Agent-ID"] = opts.agentId;
+      const res = await doFetch(`${opts.apiUrl}/api/models-catalog`, {
+        headers,
+        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+      });
+      if (!res.ok) return false;
+      const body = (await res.json()) as {
+        source?: "live" | "snapshot";
+        providers?: RuntimeCatalog;
+      };
+      if (!body || typeof body.providers !== "object" || body.providers === null) return false;
+      setRuntimeModelCatalog(body.providers, Date.now(), body.source ?? "live");
+      return true;
+    } catch {
+      return false;
+    } finally {
+      inFlight = null;
+    }
+  })();
+  return inFlight;
+}

package/src/utils/spawn-model-guard.ts

@@ -0,0 +1,43 @@
+/**
+ * Worker-side harness guard, run right before a provider CLI starts. The server
+ * already refuses cross-harness models at create and at claim; this is the last
+ * line for what the server cannot see: the agent-scope `MODEL_OVERRIDE` fallback
+ * (a worker whose harness changed while the override still names the old family),
+ * and a task model from an API that predates the claim-time backstop.
+ *
+ * Worker-safe: no `src/be` imports; judges against the runtime catalog.
+ */
+import { harnessModelMismatch } from "@desplega/model-catalog";
+import { runtimeHarnessSections } from "./runtime-model-catalog";
+
+export type SpawnModelDecision =
+  | { kind: "ok"; model: string; warning?: string }
+  | { kind: "mismatch"; reason: string };
+
+/** Same literal as the server's claim-time reason (`harnessMismatchReason`). */
+export function spawnHarnessMismatchReason(model: string, harness: string): string {
+  return `[model-harness-mismatch] Model "${model}" does not run on the ${harness} harness of this worker. The task pinned a model from another harness family. Re-create the task with modelTier or with a ${harness} model.`;
+}
+
+export function guardSpawnModel(input: {
+  taskModel: string;
+  configModel: string;
+  harness: string;
+  role: string;
+}): SpawnModelDecision {
+  const { taskModel, configModel, harness, role } = input;
+  const sections = runtimeHarnessSections();
+  if (taskModel) {
+    return harnessModelMismatch(taskModel, harness, sections)
+      ? { kind: "mismatch", reason: spawnHarnessMismatchReason(taskModel, harness) }
+      : { kind: "ok", model: taskModel };
+  }
+  if (configModel && harnessModelMismatch(configModel, harness, sections)) {
+    return {
+      kind: "ok",
+      model: "",
+      warning: `[${role}] MODEL_OVERRIDE ${configModel} does not run on the ${harness} harness; using the adapter default`,
+    };
+  }
+  return { kind: "ok", model: configModel };
+}

package/src/utils/subscription-plans.ts

@@ -11,6 +11,8 @@
  * the operator can always pick it on the dashboard.
  */
 
+import type { ModelFamily } from "./model-rate-limit-windows";
+
 export interface SubscriptionPlan {
   id: string;
   label: string;
@@ -18,6 +20,8 @@ export interface SubscriptionPlan {
   keyType: "CLAUDE_CODE_OAUTH_TOKEN" | "CODEX_OAUTH";
   /** Monthly list price in USD, billed monthly. */
   monthlyUsd: number;
+  /** Model families the plan cannot run. Absent means the plan runs every family. */
+  excludedModelFamilies?: readonly ModelFamily[];
 }
 
 /** List prices from claude.com/pricing and chatgpt.com/pricing, checked 2026-09-25. */
@@ -42,6 +46,9 @@ export const SUBSCRIPTION_PLANS: readonly SubscriptionPlan[] = [
     label: "Claude Team, standard seat",
     keyType: "CLAUDE_CODE_OAUTH_TOKEN",
     monthlyUsd: 25,
+    // The CLI rejects Fable on this seat with `errorCode: "credits_required"`
+    // ("Fable 5.1 requires usage credits"), observed 2026-09-30.
+    excludedModelFamilies: ["fable"],
   },
   {
     id: "claude_team_premium",
@@ -74,6 +81,21 @@ export function isSubscriptionPlanId(id: string): boolean {
   return SUBSCRIPTION_PLANS.some((plan) => plan.id === id);
 }
 
+/**
+ * Whether a key on `plan` can run `family`. Fails open: a null plan, a plan
+ * id the map does not know, or an undefined family returns true. Returns
+ * false only when the plan record lists the family in `excludedModelFamilies`.
+ */
+export function planAllowsModelFamily(
+  plan: string | null | undefined,
+  family: ModelFamily | undefined,
+): boolean {
+  if (!plan || !family) return true;
+  const record = SUBSCRIPTION_PLANS.find((p) => p.id === plan);
+  if (!record?.excludedModelFamilies) return true;
+  return !record.excludedModelFamilies.includes(family);
+}
+
 /**
  * Map the `chatgpt_plan_type` JWT claim to a plan id. The claim says `pro`
  * for both Pro tiers, so `pro` maps to the 20x plan (the operator can change

package/src/workflows/approval-resolution.ts

@@ -0,0 +1,39 @@
+import type { WorkflowDefinition } from "../types";
+import type { ApprovalOutcome, ResolvedApproval } from "./executors/base";
+import type { ExecutorRegistry } from "./executors/registry";
+
+/**
+ * Step output and output port for a step whose approval request resolved.
+ *
+ * Both resume paths (the live `approval.resolved` event and the recovery sweep)
+ * go through here so they cannot disagree. A `human-in-the-loop` step gets its
+ * own output on the port named after the status. An executor that parked on the
+ * same approval machinery (`system-one-decision` with `humanReview`) shapes its
+ * own output from what it stored before it parked.
+ */
+export function shapeApprovalResolution(
+  registry: ExecutorRegistry,
+  definition: Pick<WorkflowDefinition, "nodes">,
+  nodeId: string,
+  parkedOutput: unknown,
+  approval: ResolvedApproval,
+): ApprovalOutcome {
+  const node = definition.nodes.find((candidate) => candidate.id === nodeId);
+  if (node && registry.has(node.type)) {
+    const shaped = registry.get(node.type).resolveApproval(parkedOutput, approval);
+    if (shaped) return shaped;
+  }
+  return {
+    output: {
+      requestId: approval.requestId,
+      status: approval.status,
+      responses: approval.responses,
+    },
+    nextPort:
+      approval.status === "timeout"
+        ? "timeout"
+        : approval.status === "rejected"
+          ? "rejected"
+          : "approved",
+  };
+}

package/src/workflows/definition.ts

@@ -6,6 +6,10 @@ import type {
   WorkflowPatch,
 } from "../types";
 import type { ExecutorRegistry } from "./executors/registry";
+import {
+  systemOneRetryViolations,
+  systemOneStaticShapeViolations,
+} from "./executors/system-one-decision";
 
 /** Extract all target node IDs from a node's `next` field */
 export function getNextTargets(next: string | string[] | Record<string, string>): string[] {
@@ -206,6 +210,9 @@ export function validateDefinition(
         `Node "${node.id}" human-in-the-loop config.questions must be an array or one exact {{interpolation}} token`,
       );
     }
+    // A system-one-decision node's question ids and return types are static, and it never carries
+    // an engine retry policy (it retries transient transport errors itself).
+    errors.push(...systemOneStaticShapeViolations(node), ...systemOneRetryViolations(node));
     if (node.type === "foreach") {
       validateForeachNode(node, errors);
       // A legacy `#` id may stay editable as a NORMAL node, but never as a foreach

package/src/workflows/engine.ts

@@ -28,10 +28,16 @@ import { shouldSkipCooldown } from "./cooldown";
 import { findEntryNodes, getNextTargets, getSuccessors, resolveValidationPort } from "./definition";
 import type { AsyncExecutorResult } from "./executors/base";
 import type { ExecutorRegistry } from "./executors/registry";
+import {
+  SYSTEM_ONE_DECISION_NODE_TYPE,
+  systemOneRetryViolations,
+  systemOneUnresolvedError,
+} from "./executors/system-one-decision";
 import { FOREACH_TERMINAL_STEP_STATUSES, resolveForeachParent } from "./foreach-join";
 import { getSecretInputKeys, redactSecretsForStorage, resolveInputs } from "./input";
 import { validateJsonSchema } from "./json-schema-validator";
 import { getMaxWorkflowStepsPerRun } from "./limits";
+import { findWorkflowReadinessProblems, formatReadinessRunError } from "./readiness";
 import { deepInterpolate } from "./template";
 import { runStepValidation, type ValidationRunResult } from "./validation";
 
@@ -149,6 +155,18 @@ export async function startWorkflowExecution(
     triggerType: options.triggerType ?? "manual",
   });
 
+  // An executor that cannot run (for example a system-one-decision node with no API key) fails
+  // the run here, before any node has side effects, instead of partway through.
+  const notReady = await findWorkflowReadinessProblems(workflow.definition, registry);
+  if (notReady.length > 0) {
+    await updateWorkflowRun(runId, {
+      status: "failed",
+      error: formatReadinessRunError(notReady),
+      finishedAt: new Date().toISOString(),
+    });
+    return runId;
+  }
+
   // Resolve inputs and merge into initial context
   const ctx: Record<string, unknown> = { trigger: triggerData };
   if (options.requestedByUserId) {
@@ -744,6 +762,15 @@ async function runClaimedStep(
   // 3. Get executor
   const executor = registry.get(node.type);
 
+  // 3a. A system-one-decision node retries transient transport errors itself (config.maxRetries).
+  // Engine retries are not status-aware, so a policy here would re-send rejected
+  // requests and multiply paid attempts. Fail before any request is built.
+  const systemOneRetryProblems = systemOneRetryViolations(node);
+  if (systemOneRetryProblems.length > 0) {
+    await checkpointStepFailure(runId, stepId, systemOneRetryProblems.join("; "), 0);
+    return { outcome: "failed", successors: [] };
+  }
+
   // 3b. Build local interpolation context from explicit inputs mapping
   const interpolationCtx = buildNodeInterpolationCtx(node, ctx);
 
@@ -765,6 +792,7 @@ async function runClaimedStep(
     value: interpolatedValue,
     unresolved,
     scriptBodyUnresolved,
+    strictUnresolved,
   } = interpolateNodeConfig(node, interpolationCtx);
   const interpolatedConfig = interpolatedValue as Record<string, unknown>;
   const executionCtx: Record<string, unknown> = { ...ctx, ...interpolationCtx };
@@ -775,6 +803,17 @@ async function runClaimedStep(
     return { outcome: "failed", successors: [] };
   }
 
+  // A paid, non-idempotent call must not go out with a blanked field.
+  if (strictUnresolved && strictUnresolved.length > 0) {
+    await checkpointStepFailure(
+      runId,
+      stepId,
+      systemOneUnresolvedError(node.id, strictUnresolved),
+      0,
+    );
+    return { outcome: "failed", successors: [] };
+  }
+
   if (unresolved.length > 0) {
     console.warn(
       `[workflow] Step ${node.id}: unresolved interpolation tokens: ${unresolved.join(", ")}`,
@@ -1063,7 +1102,36 @@ function buildScriptBodyCtx(
 export function interpolateNodeConfig(
   node: Pick<WorkflowNode, "type" | "config" | "inputs">,
   interpolationCtx: Record<string, unknown>,
-): { value: unknown; unresolved: string[]; scriptBodyUnresolved?: string[] } {
+): {
+  value: unknown;
+  unresolved: string[];
+  scriptBodyUnresolved?: string[];
+  /** Tokens that must resolve before dispatch; the caller fails the step when non-empty. */
+  strictUnresolved?: string[];
+} {
+  if (node.type === SYSTEM_ONE_DECISION_NODE_TYPE) {
+    // `state` and `questions` keep a whole-token reference's JSON type (an object
+    // stays an object; string interpolation would flatten it to JSON text). The
+    // resolved value is data, never re-interpolated, so a literal `{{` inside a
+    // lead's text is not read as another template. Every other field, and every
+    // unresolved token anywhere in the config, is strict: no blank reaches the API.
+    const { state, questions, ...rest } = node.config;
+    const restResult = deepInterpolate(rest, interpolationCtx);
+    const dynamic: Record<string, unknown> = {};
+    if (Object.hasOwn(node.config, "state")) dynamic.state = state;
+    if (Object.hasOwn(node.config, "questions")) dynamic.questions = questions;
+    const dynamicResult = deepInterpolate(dynamic, interpolationCtx, { preserveRawTokens: true });
+    const unresolved = [...restResult.unresolved, ...dynamicResult.unresolved];
+    return {
+      value: {
+        ...(restResult.value as Record<string, unknown>),
+        ...(dynamicResult.value as Record<string, unknown>),
+      },
+      unresolved,
+      strictUnresolved: unresolved,
+    };
+  }
+
   if (node.type === "foreach" && Object.hasOwn(node.config, "over")) {
     const { over, body, ...configWithoutOverAndBody } = node.config;
     const configResult = deepInterpolate(configWithoutOverAndBody, interpolationCtx);

package/src/workflows/executors/agent-task.ts

@@ -1,8 +1,8 @@
 import { z } from "zod";
+import { explicitModelErrorForAgent } from "../../be/model-validation";
 import { applyPreTaskCreate } from "../../extensions/apply-task-create";
 import { workflowContextKey } from "../../tasks/context-key";
 import { TaskCreationBlockedError } from "../../tasks/errors";
-import { withSiblingAwareness } from "../../tasks/sibling-awareness";
 import type { ExecutorMeta } from "../../types";
 import {
   FollowUpConfigSchema,
@@ -30,6 +30,8 @@ export const AgentTaskConfigSchema = z.object({
   vcsRepo: z.string().min(1).optional(),
   model: z.string().min(1).optional(),
   modelTier: ModelTierSchema.optional(),
+  /** Accept a `model` the catalog does not list (a custom id). Without it an unknown id fails the node. */
+  allowCustomModel: z.boolean().optional(),
   effort: ReasoningEffortSchema.optional(),
   parentTaskId: z.string().uuid().optional(),
   requestedByUserId: z.string().optional(),
@@ -98,6 +100,12 @@ export class AgentTaskExecutor extends BaseExecutor<
     }
 
     // 3. Create the task (config is already deep-interpolated by the engine)
+    const modelError = await explicitModelErrorForAgent({
+      model: splitLegacyModelAlias({ model: config.model, modelTier: config.modelTier }).model,
+      allowCustomModel: config.allowCustomModel,
+      agentId: config.agentId,
+    });
+    if (modelError) return { status: "failed", error: modelError };
     const preCreate = await applyPreTaskCreate({
       description: config.template,
       options: {
@@ -128,15 +136,17 @@ export class AgentTaskExecutor extends BaseExecutor<
         contextKey: workflowContextKey({ workflowRunId: meta.runId }),
       },
       origin: "workflow",
+      allowCustomModel: config.allowCustomModel,
     });
     if (preCreate.kind === "blocked") {
       throw new TaskCreationBlockedError(preCreate.reason, preCreate.extension);
     }
-    const { description: taskDescription, options: taskOptions } = await withSiblingAwareness(
-      preCreate.description,
-      preCreate.options,
-    );
-    const task = await db.createTaskExtended(taskDescription, taskOptions);
+    // No sibling awareness: every task of a run shares this contextKey, so its
+    // siblings are the engine's own parallel steps, not new user input. The
+    // block handed each child its siblings' task ids, and one child completed
+    // a sibling's task with its own report. It would also wire parentTaskId to
+    // a concurrent same-agent sibling's session.
+    const task = await db.createTaskExtended(preCreate.description, preCreate.options);
 
     // 4. Return async result — engine will pause the workflow
     return {

package/src/workflows/executors/base.ts

@@ -10,6 +10,34 @@ export interface ExecutorDependencies {
   interpolate: (template: string, ctx: Record<string, unknown>) => string;
 }
 
+// ─── Readiness ─────────────────────────────────────────────
+
+export interface ExecutorReadinessNode {
+  id: string;
+  config: Record<string, unknown>;
+}
+
+export interface ExecutorReadinessProblem {
+  /** Nodes that hit this problem. */
+  nodeIds: string[];
+  message: string;
+}
+
+// ─── Approval resolution ───────────────────────────────────
+
+/** A resolved approval request, as the resume and recovery paths see it. */
+export interface ResolvedApproval {
+  requestId: string;
+  status: "approved" | "rejected" | "timeout";
+  responses: Record<string, unknown> | null;
+}
+
+/** The step output and output port an executor chooses once its approval resolves. */
+export interface ApprovalOutcome {
+  output: unknown;
+  nextPort: string;
+}
+
 // ─── Input / Result Types ──────────────────────────────────
 
 export interface ExecutorInput {
@@ -47,6 +75,31 @@ export abstract class BaseExecutor<
 
   constructor(protected readonly deps: ExecutorDependencies) {}
 
+  /**
+   * Can this executor run the given nodes right now? Return one problem per
+   * distinct missing prerequisite (for example a credential), or an empty array.
+   * The engine asks before a run starts, and authoring surfaces ask after a
+   * save, so a missing prerequisite surfaces before any node has side effects.
+   * Reads raw (pre-interpolation) node config. Must not call external services
+   * and must not put secret values in a message.
+   */
+  async checkReadiness(
+    _nodes: readonly ExecutorReadinessNode[],
+  ): Promise<ExecutorReadinessProblem[]> {
+    return [];
+  }
+
+  /**
+   * An executor that parks its step on a human-in-the-loop approval decides the
+   * step's output and port once a person answers. `parkedOutput` is the step
+   * output it stored before it parked. Return null to keep the default: the
+   * human-in-the-loop output (`{ requestId, status, responses }`) on the port
+   * named after the status.
+   */
+  resolveApproval(_parkedOutput: unknown, _approval: ResolvedApproval): ApprovalOutcome | null {
+    return null;
+  }
+
   /**
    * Validate config, execute, validate output.
    * Catches Zod validation errors at both boundaries.

package/src/workflows/executors/human-in-the-loop.ts

@@ -59,17 +59,22 @@ const QuestionSchema = z.discriminatedUnion("type", [
   }),
 ]);
 
-const ApproverConfigSchema = z.object({
+export const ApproverConfigSchema = z.object({
   users: z.array(z.string()).optional(),
   roles: z.array(z.string()).optional(),
   policy: z.union([z.literal("any"), z.literal("all"), z.object({ min: z.number().int().min(1) })]),
 });
 
-const NotificationConfigSchema = z.object({
+export const NotificationConfigSchema = z.object({
   channel: z.enum(["slack", "email"]),
   target: z.string(),
 });
 
+export const HITLTimeoutSchema = z.object({
+  seconds: z.number().int().min(1),
+  action: z.literal("reject"),
+});
+
 type HITLQuestion = z.infer<typeof QuestionSchema>;
 
 /** Exactly one `{{path}}` token: the dynamic-questions form. */
@@ -103,12 +108,7 @@ const HITLConfigSchema = z.object({
       ),
   ]),
   approvers: ApproverConfigSchema,
-  timeout: z
-    .object({
-      seconds: z.number().int().min(1),
-      action: z.literal("reject"),
-    })
-    .optional(),
+  timeout: HITLTimeoutSchema.optional(),
   notifications: z.array(NotificationConfigSchema).optional(),
 });
 

package/src/workflows/executors/index.ts

@@ -13,6 +13,7 @@ export { RawLlmExecutor } from "./raw-llm";
 export { createExecutorRegistry, ExecutorRegistry } from "./registry";
 export { ScriptExecutor } from "./script";
 export { SwarmScriptExecutor } from "./swarm-script";
+export { SystemOneDecisionExecutor } from "./system-one-decision";
 export { ValidateExecutor } from "./validate";
 export { VcsExecutor } from "./vcs";
 export { WaitExecutor } from "./wait";

package/src/workflows/executors/registry.ts

@@ -9,6 +9,7 @@ import { PropertyMatchExecutor } from "./property-match";
 import { RawLlmExecutor } from "./raw-llm";
 import { ScriptExecutor } from "./script";
 import { SwarmScriptExecutor } from "./swarm-script";
+import { SystemOneDecisionExecutor } from "./system-one-decision";
 import { ValidateExecutor } from "./validate";
 import { VcsExecutor } from "./vcs";
 import { WaitExecutor } from "./wait";
@@ -69,6 +70,7 @@ export function createExecutorRegistry(deps: ExecutorDependencies): ExecutorRegi
   registry.register(new CodeMatchExecutor(deps));
   registry.register(new NotifyExecutor(deps));
   registry.register(new RawLlmExecutor(deps));
+  registry.register(new SystemOneDecisionExecutor(deps));
   registry.register(new ScriptExecutor(deps));
   registry.register(new SwarmScriptExecutor(deps));
   registry.register(new VcsExecutor(deps));