@desplega.ai/agent-swarm 2.4.4 → 2.4.5

package/src/tools/system-one-decide.ts

@@ -10,7 +10,7 @@ import {
 import { SYSTEM_ONE_PROVIDER_IDS } from "@/workflows/executors/system-one-providers";
 
 /**
- * One typed decision (Jev and the other SystemOne hosts) made in the API
+ * One typed decision (Jev, Clef and the other SystemOne hosts) made in the API
  * process, the same way a `system-one-decision` workflow node makes it. The
  * provider credential is read and sent here and never reaches the caller, so a
  * script can ask for a decision without a credential binding in its own realm.
@@ -22,14 +22,16 @@ export const registerSystemOneDecideTool = (server: McpServer) => {
       title: "Ask a SystemOne decision model",
       annotations: { destructiveHint: false, openWorldHint: true },
       description:
-        "Send a state and typed questions (noul, choice, score) to a SystemOne decision host such as Jev, and return the validated answers. " +
+        "Send a state and typed questions (noul, choice, score) to a SystemOne decision host such as Jev or Clef, and return the validated answers. " +
         "Same request, provider list, credentials and validation as the `system-one-decision` workflow node, without its human review band. " +
         "The provider credential is a global secret that stays on the server; this tool never returns it.",
       inputSchema: z.object({
         provider: z
           .enum(SYSTEM_ONE_PROVIDER_IDS)
           .optional()
-          .describe("Decision host (default typesafe)"),
+          .describe(
+            "Decision host (default: the SYSTEM_ONE_DEFAULT_PROVIDER global config, typesafe when unset)",
+          ),
         model: z.string().min(1).optional().describe("Provider model id (default: the provider's)"),
         state: z
           .union([z.string(), z.array(z.string()), z.record(z.string(), z.unknown())])
@@ -55,6 +57,12 @@ export const registerSystemOneDecideTool = (server: McpServer) => {
         answers: z.record(z.string(), z.unknown()).optional(),
         usage: z.record(z.string(), z.unknown()).optional(),
         requestId: z.string().optional(),
+        providerUnavailable: z
+          .boolean()
+          .optional()
+          .describe(
+            "On an error: true when this deployment refuses the provider (e.g. OpenRouter behind a gateway) and no request was sent, so a caller choosing automatically can try its next provider",
+          ),
       }),
     },
     async ({ provider, model, state, questions, timeoutMs, maxRetries }, requestInfo) => {
@@ -88,7 +96,12 @@ export const registerSystemOneDecideTool = (server: McpServer) => {
         return toolErr("The system-one-decision executor is not available");
       }
       const decided = await executor.decide(parsed.data);
-      if (!decided.ok) return toolErr(decided.error);
+      if (!decided.ok) {
+        return toolErr(
+          decided.error,
+          decided.deploymentRefused ? { data: { providerUnavailable: true } } : {},
+        );
+      }
 
       const { output } = decided;
       return toolOk(`Decision from ${output.model}`, {

package/src/types.ts

@@ -905,6 +905,12 @@ export const CreateTaskOptionsSchema = z.object({
    * contract on completion (which would block the control task — DES-523).
    */
   inheritParentOutputSchema: z.boolean().optional(),
+  /**
+   * When a `parentTaskId` is set and `requestedByUserId` is not, the child
+   * inherits the parent's requester by default. Set this to `false` when the
+   * child answers a different person (a chat message whose sender is unknown).
+   */
+  inheritParentRequester: z.boolean().optional(),
   /**
    * Skip parent routing requirements only for a child with its own explicit
    * Lead-only control-plane authorization.

package/src/utils/config-env-export.ts

@@ -8,7 +8,8 @@
  * binding instead.
  *
  * Keys below are read only by the API server (integration signing secrets, app
- * private keys, OAuth client secrets, the API's own agent-fs key). They can
+ * private keys, OAuth client secrets, the API's own agent-fs and
+ * speech-to-text keys). They can
  * never be exported: the config API rejects `exportToEnv: true` for them and
  * every reader treats a stored true as false.
  */
@@ -25,6 +26,7 @@ export const ENV_EXPORT_RESTRICTED_KEYS: ReadonlySet<string> = new Set([
   "AZURE_DEVOPS_WEBHOOK_SECRET",
   "AGENTMAIL_WEBHOOK_SECRET",
   "API_AGENT_FS_API_KEY",
+  "TRANSCRIPTION_API_KEY",
 ]);
 
 /**

package/src/utils/page-session.ts

@@ -246,23 +246,83 @@ export function parseCookieHeader(
 }
 
 /**
- * One-shot helper: pull `page_session` out of a request's `Cookie` header and
- * verify it. Returns the parsed payload on success, `null` on any failure
- * (no cookie, malformed, bad signature, expired, etc.).
- *
- * Shared by `/@swarm/api/*` (`src/http/page-proxy.ts`) and the authed `/p/:id`
- * branch (`src/http/pages-public.ts`) so both call sites converge on the same
- * verification semantics.
+ * The single shared cookie name used before sessions became per-page. Every
+ * launch overwrote it, so only the newest page in a browser had a session.
+ * Still read for back-compat, but only for the page its payload names.
+ */
+export const LEGACY_PAGE_SESSION_COOKIE = "page_session";
+
+/** Page ids are 32 hex chars today; anything outside the cookie-name-safe set is refused. */
+const COOKIE_SAFE_PAGE_ID = /^[A-Za-z0-9_-]{1,64}$/;
+
+export function isCookieSafePageId(pageId: string): boolean {
+  return COOKIE_SAFE_PAGE_ID.test(pageId);
+}
+
+/** Per-page cookie name, so sessions for different pages coexist in one browser. */
+export function pageSessionCookieName(pageId: string): string {
+  return `${LEGACY_PAGE_SESSION_COOKIE}_${pageId}`;
+}
+
+export interface VerifiedPageSession {
+  /** The raw signed token, forwarded upstream by the page proxy. */
+  token: string;
+  payload: PageSessionPayload;
+}
+
+type CookieRequest = { headers: { cookie?: string | string[] | undefined } };
+
+async function verifyNamedCookie(
+  req: CookieRequest,
+  name: string,
+): Promise<VerifiedPageSession | null> {
+  const token = parseCookieHeader(req.headers.cookie, name);
+  const payload = await verifyPageSession(token);
+  return payload && token ? { token, payload } : null;
+}
+
+/**
+ * Find and verify the session for `pageId`: `page_session_<pageId>` first,
+ * then the legacy `page_session`. A cookie whose signed payload names a
+ * different page is ignored, so the result always satisfies
+ * `payload.pageId === pageId`. Returns `null` on any failure (no cookie,
+ * malformed, bad signature, expired, wrong page).
+ */
+export async function extractPageSession(
+  req: CookieRequest,
+  pageId: string,
+): Promise<VerifiedPageSession | null> {
+  if (!isCookieSafePageId(pageId)) return null;
+  for (const name of [pageSessionCookieName(pageId), LEGACY_PAGE_SESSION_COOKIE]) {
+    const session = await verifyNamedCookie(req, name);
+    if (session?.payload.pageId === pageId) return session;
+  }
+  return null;
+}
+
+/**
+ * Verify the legacy `page_session` cookie for whatever page it names. Only for
+ * callers that send no page id (clients predating per-page cookies).
+ */
+export async function extractLegacyPageSession(
+  req: CookieRequest,
+): Promise<VerifiedPageSession | null> {
+  return verifyNamedCookie(req, LEGACY_PAGE_SESSION_COOKIE);
+}
+
+/**
+ * Payload-only form of `extractPageSession`. Shared by the `/p/:id` handler
+ * (`src/http/pages-public.ts`) and the realtime upgrade
+ * (`src/realtime/transport.ts`) so they converge on the same semantics.
  *
  * Accepts an object with a `headers.cookie` field — duck-typed to keep this
  * helper test-friendly without dragging `node:http` types into the utility.
  */
-export async function extractAndVerifyCookie(req: {
-  headers: { cookie?: string | string[] | undefined };
-}): Promise<PageSessionPayload | null> {
-  const token = parseCookieHeader(req.headers.cookie, "page_session");
-  if (!token) return null;
-  return verifyPageSession(token);
+export async function extractAndVerifyCookie(
+  req: CookieRequest,
+  pageId: string,
+): Promise<PageSessionPayload | null> {
+  return (await extractPageSession(req, pageId))?.payload ?? null;
 }
 
 // ───────────────────────────────────────────────────────────────────────────
@@ -284,6 +344,10 @@ const PAGE_SESSION_TTL_SECONDS = 3600;
  * - `dev=true` → `SameSite=Lax` without `Secure` (works on http://localhost).
  * - `dev=false` → `SameSite=None; Secure` (cross-site iframe embedding in prod).
  *
+ * The cookie is named `page_session_<pageId>`, so launching page B leaves
+ * page A's session intact. Responses should go through `pageSessionSetCookies`,
+ * which also bounds how many of these a browser keeps.
+ *
  * The caller is responsible for setting `Set-Cookie` on the response — this
  * helper only builds the string. TTL is 1 hour; renewed on every issuance.
  */
@@ -299,13 +363,12 @@ export async function issuePageSessionCookie(
     ...(opts.name ? { name: opts.name } : {}),
     ...(opts.op ? { op: true as const } : {}),
   });
-  const attrs = [
-    `page_session=${token}`,
-    "HttpOnly",
-    "Path=/",
-    `Max-Age=${PAGE_SESSION_TTL_SECONDS}`,
-  ];
-  if (opts.dev) {
+  return buildCookie(pageSessionCookieName(pageId), token, PAGE_SESSION_TTL_SECONDS, opts.dev);
+}
+
+function buildCookie(name: string, value: string, maxAge: number, dev: boolean): string {
+  const attrs = [`${name}=${value}`, "HttpOnly", "Path=/", `Max-Age=${maxAge}`];
+  if (dev) {
     attrs.push("SameSite=Lax");
   } else {
     attrs.push("SameSite=None");
@@ -313,3 +376,53 @@ export async function issuePageSessionCookie(
   }
   return attrs.join("; ");
 }
+
+/**
+ * Most per-page session cookies one browser keeps, counting the one being
+ * issued. Each is ~220 bytes on the wire, and `Path=/` sends all of them on
+ * every request to this host, so an unbounded jar grows past the server's
+ * 16 KB header limit (431 on every route, `/health` included) after ~75
+ * launches within the hour. 20 keeps the jar near 4.5 KB.
+ */
+export const MAX_PAGE_SESSION_COOKIES = 20;
+
+const PAGE_SESSION_COOKIE_RE = new RegExp(
+  `(?:^|;\\s*)(${LEGACY_PAGE_SESSION_COOKIE}_[A-Za-z0-9_-]{1,64})=([^;]*)`,
+  "g",
+);
+
+/**
+ * `Set-Cookie` values for a launch of `pageId`: the new session, plus an
+ * expiring cookie for every other per-page session in the request's jar that
+ * is invalid or expired, or falls outside the `MAX_PAGE_SESSION_COOKIES - 1`
+ * newest. The browser then holds at most `MAX_PAGE_SESSION_COOKIES` of them.
+ * An evicted page's open tab loses its session, the same as after expiry.
+ */
+export async function pageSessionSetCookies(
+  req: CookieRequest,
+  pageId: string,
+  opts: { dev: boolean; uid?: string; name?: string; op?: true },
+): Promise<string[]> {
+  const issued = await issuePageSessionCookie(pageId, opts);
+  const header = Array.isArray(req.headers.cookie)
+    ? req.headers.cookie.join("; ")
+    : (req.headers.cookie ?? "");
+  const keep: { name: string; exp: number; order: number }[] = [];
+  const evict = new Set<string>();
+  const seen = new Set([pageSessionCookieName(pageId)]);
+  for (const [, name, token] of header.matchAll(PAGE_SESSION_COOKIE_RE)) {
+    if (!name || seen.has(name)) continue;
+    seen.add(name);
+    const payload = await verifyPageSession(token);
+    if (payload && name === pageSessionCookieName(payload.pageId)) {
+      keep.push({ name, exp: payload.exp, order: keep.length });
+    } else {
+      evict.add(name);
+    }
+  }
+  // `exp` has one-second granularity. Browsers list older cookies first, so a
+  // later position breaks ties toward the more recent launch.
+  keep.sort((a, b) => b.exp - a.exp || b.order - a.order);
+  for (const { name } of keep.slice(MAX_PAGE_SESSION_COOKIES - 1)) evict.add(name);
+  return [issued, ...[...evict].map((name) => buildCookie(name, "", 0, opts.dev))];
+}

package/src/utils/transcription.ts

@@ -0,0 +1,246 @@
+/**
+ * Speech-to-text for inbound audio. `TRANSCRIPTION_PROVIDER` picks the request
+ * shape:
+ *
+ * - `openai`: `POST <base>/audio/transcriptions`, `Authorization: Bearer`, form
+ *   field `model`. OpenAI Whisper and self-hosted whisper servers speak this
+ *   shape.
+ * - `groq`: the `openai` shape against Groq's OpenAI-compatible endpoint.
+ * - `elevenlabs`: `POST <base>/speech-to-text`, `xi-api-key` header, form
+ *   field `model_id`.
+ *
+ * The key: an explicit `TRANSCRIPTION_API_KEY` wins, with `TRANSCRIPTION_PROVIDER`
+ * (default `openai`). Without it, transcription reuses a provider key the
+ * swarm already has: the pinned provider's key when `TRANSCRIPTION_PROVIDER` is
+ * set, else the first of `ELEVENLABS_API_KEY`, `OPENAI_API_KEY`, `GROQ_API_KEY`.
+ * Off when none is set.
+ *
+ * `TRANSCRIPTION_MODEL` overrides the provider's default model.
+ * `TRANSCRIPTION_BASE_URL` overrides its base URL for an explicit key only: an
+ * auto-detected key always goes to its provider's own endpoint. Deepgram and AssemblyAI use other request shapes and are not
+ * supported. Read at call time, so a config reload applies without a restart.
+ */
+import { createValueScrubber, scrubSecrets } from "./secret-scrubber";
+
+const TRANSCRIPTION_TIMEOUT_MS = 60_000;
+
+/** The config key that switches transcription on explicitly. */
+export const TRANSCRIPTION_API_KEY_ENV = "TRANSCRIPTION_API_KEY";
+
+type ProviderSpec = {
+  /** The provider's own key, reused when `TRANSCRIPTION_API_KEY` is unset. */
+  keyEnv: string;
+  defaultBaseUrl: string;
+  defaultModel: string;
+  path: string;
+  modelField: string;
+  authHeaders: (apiKey: string) => Record<string, string>;
+};
+
+const openAIShape = {
+  path: "/audio/transcriptions",
+  modelField: "model",
+  authHeaders: (apiKey: string) => ({ authorization: `Bearer ${apiKey}` }),
+};
+
+const PROVIDERS = {
+  openai: {
+    keyEnv: "OPENAI_API_KEY",
+    defaultBaseUrl: "https://api.openai.com/v1",
+    defaultModel: "whisper-1",
+    ...openAIShape,
+  },
+  groq: {
+    keyEnv: "GROQ_API_KEY",
+    defaultBaseUrl: "https://api.groq.com/openai/v1",
+    defaultModel: "whisper-large-v3-turbo",
+    ...openAIShape,
+  },
+  elevenlabs: {
+    keyEnv: "ELEVENLABS_API_KEY",
+    defaultBaseUrl: "https://api.elevenlabs.io/v1",
+    defaultModel: "scribe_v2",
+    path: "/speech-to-text",
+    modelField: "model_id",
+    authHeaders: (apiKey) => ({ "xi-api-key": apiKey }),
+  },
+} satisfies Record<string, ProviderSpec>;
+
+export type TranscriptionProvider = keyof typeof PROVIDERS;
+
+/** Order in which an existing provider key is picked when nothing is pinned. */
+const AUTO_DETECT_ORDER: TranscriptionProvider[] = ["elevenlabs", "openai", "groq"];
+
+/** Every env key the provider and key resolution reads. */
+export const TRANSCRIPTION_ENV_KEYS = [
+  TRANSCRIPTION_API_KEY_ENV,
+  "TRANSCRIPTION_PROVIDER",
+  "TRANSCRIPTION_BASE_URL",
+  "TRANSCRIPTION_MODEL",
+  ...AUTO_DETECT_ORDER.map((name) => PROVIDERS[name].keyEnv),
+];
+
+export class TranscriptionError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "TranscriptionError";
+  }
+}
+
+/** The provider and key a transcription call uses. */
+export type TranscriptionConfig = {
+  provider: string;
+  apiKey: string;
+  /** The env key the API key came from. */
+  keyEnv: string;
+  /** `explicit`: `TRANSCRIPTION_API_KEY`. `auto`: a provider key the swarm already had. */
+  source: "explicit" | "auto";
+};
+
+function envValue(key: string): string | undefined {
+  return process.env[key]?.trim() || undefined;
+}
+
+/** Resolve provider and key, or null when no key is set. Unsupported provider names pass through. */
+export function resolveTranscriptionConfig(): TranscriptionConfig | null {
+  const pinned = envValue("TRANSCRIPTION_PROVIDER")?.toLowerCase();
+  const explicitKey = envValue(TRANSCRIPTION_API_KEY_ENV);
+  if (explicitKey) {
+    return {
+      provider: pinned ?? "openai",
+      apiKey: explicitKey,
+      keyEnv: TRANSCRIPTION_API_KEY_ENV,
+      source: "explicit",
+    };
+  }
+  // A pinned provider only uses its own key, never another provider's.
+  const candidates = pinned
+    ? AUTO_DETECT_ORDER.filter((name) => name === pinned)
+    : AUTO_DETECT_ORDER;
+  for (const name of candidates) {
+    const { keyEnv } = PROVIDERS[name];
+    const apiKey = envValue(keyEnv);
+    if (apiKey) return { provider: name, apiKey, keyEnv, source: "auto" };
+  }
+  return null;
+}
+
+export function isTranscriptionConfigured(): boolean {
+  return resolveTranscriptionConfig() !== null;
+}
+
+function providerSpec(name: string): ProviderSpec {
+  if (!Object.hasOwn(PROVIDERS, name)) {
+    throw new TranscriptionError(
+      `TRANSCRIPTION_PROVIDER "${name}" is not supported (use ${Object.keys(PROVIDERS).join(", ")})`,
+    );
+  }
+  return PROVIDERS[name as TranscriptionProvider];
+}
+
+/** OpenAI puts the reason in `error.message`; ElevenLabs in `detail.message` or `detail`. */
+function errorDetail(payload: Record<string, unknown> | null, status: number): string {
+  const error = payload?.error as { message?: unknown } | undefined;
+  if (typeof error?.message === "string") return error.message;
+  const detail = payload?.detail as { message?: unknown } | string | undefined;
+  if (typeof detail === "string") return detail;
+  if (typeof detail?.message === "string") return detail.message;
+  return `HTTP ${status}`;
+}
+
+/** Transcribe one audio file. Throws `TranscriptionError` when unconfigured or when the call fails. */
+export async function transcribeAudio(input: {
+  data: Blob;
+  filename: string;
+  mimeType?: string;
+}): Promise<string> {
+  const config = resolveTranscriptionConfig();
+  if (!config) throw new TranscriptionError("no transcription provider key is set");
+  const { apiKey } = config;
+  const provider = providerSpec(config.provider);
+  // An auto-detected key only goes to its own provider: a base URL set in
+  // config must not receive a key that was stored for another purpose.
+  const baseUrlOverride =
+    config.source === "explicit" ? process.env.TRANSCRIPTION_BASE_URL?.trim() : undefined;
+  const baseUrl = (baseUrlOverride || provider.defaultBaseUrl).replace(/\/+$/, "");
+  // scrubSecrets skips known values under 12 chars, and a self-hosted key can
+  // be shorter, so the submitted key is scrubbed by value from every error.
+  const keyScrubber = createValueScrubber([{ value: apiKey, name: config.keyEnv }]);
+  const scrub = (text: string) => scrubSecrets(keyScrubber.text(text));
+  const form = new FormData();
+  const type = input.mimeType ?? input.data.type;
+  form.append("file", type ? new Blob([input.data], { type }) : input.data, input.filename);
+  form.append(
+    provider.modelField,
+    process.env.TRANSCRIPTION_MODEL?.trim() || provider.defaultModel,
+  );
+
+  let response: Response;
+  try {
+    response = await fetch(`${baseUrl}${provider.path}`, {
+      method: "POST",
+      headers: provider.authHeaders(apiKey),
+      body: form,
+      signal: AbortSignal.timeout(TRANSCRIPTION_TIMEOUT_MS),
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "TimeoutError") {
+      throw new TranscriptionError(`no answer within ${TRANSCRIPTION_TIMEOUT_MS / 1000} s`);
+    }
+    throw new TranscriptionError(scrub(error instanceof Error ? error.message : String(error)));
+  }
+  const payload = (await response.json().catch(() => null)) as Record<string, unknown> | null;
+  if (!response.ok || typeof payload?.text !== "string") {
+    throw new TranscriptionError(scrub(errorDetail(payload, response.status)));
+  }
+  return payload.text.trim();
+}
+
+/** The task-text note for an audio file when no provider is configured. */
+export const NOT_TRANSCRIBED_NOTE = `(not transcribed: no transcription provider configured, set ${TRANSCRIPTION_API_KEY_ENV} or one of ${AUTO_DETECT_ORDER.map((name) => PROVIDERS[name].keyEnv).join(", ")})`;
+
+const AUDIO_EXTENSIONS: Record<string, string> = {
+  "audio/ogg": "ogg",
+  "audio/opus": "ogg",
+  "audio/mpeg": "mp3",
+  "audio/mp4": "m4a",
+  "audio/x-m4a": "m4a",
+  "audio/wav": "wav",
+  "audio/x-wav": "wav",
+  "audio/webm": "webm",
+};
+
+/** One audio file to transcribe. `key` names its note in the returned map. */
+export type AudioFile = { key: string; name: string; data: Blob; mimeType?: string };
+
+/**
+ * Transcribe audio files into task-text notes, one per file: `[Transcript of
+ * <name>]` and the text, `(transcription failed: <reason>)`, or (when no
+ * provider is configured) `NOT_TRANSCRIBED_NOTE`. Never throws, so a failed
+ * call never blocks the task it belongs to. `logPrefix` tags the warning.
+ */
+export async function transcribeAudioNotes(
+  files: AudioFile[],
+  logPrefix: string,
+): Promise<Map<string, string>> {
+  const notes = new Map<string, string>();
+  if (files.length === 0) return notes;
+  if (!isTranscriptionConfigured()) {
+    for (const file of files) notes.set(file.key, NOT_TRANSCRIBED_NOTE);
+    return notes;
+  }
+  for (const file of files) {
+    // Voice notes can carry no file name; the endpoint reads the format from the extension.
+    const extension = AUDIO_EXTENSIONS[file.mimeType ?? ""] ?? "ogg";
+    const filename = /\.\w+$/.test(file.name) ? file.name : `${file.name}.${extension}`;
+    try {
+      const text = await transcribeAudio({ data: file.data, filename, mimeType: file.mimeType });
+      notes.set(file.key, `[Transcript of ${file.name}]\n${text || "(no speech recognized)"}`);
+    } catch (error) {
+      const reason = scrubSecrets(error instanceof Error ? error.message : String(error));
+      console.warn(`${logPrefix} could not transcribe file ${file.key}: ${reason}`);
+      notes.set(file.key, `(transcription failed: ${reason})`);
+    }
+  }
+  return notes;
+}

package/src/workflows/executors/system-one-decision.ts

@@ -18,8 +18,8 @@ import {
 } from "./human-in-the-loop";
 import { SYSTEM_ONE_EXTRACTION_NODE_TYPE } from "./system-one-extraction";
 import {
+  resolveSystemOneDefaultProvider,
   resolveSystemOneTarget,
-  SYSTEM_ONE_DEFAULT_PROVIDER,
   SYSTEM_ONE_PROVIDER_IDS,
   SYSTEM_ONE_PROVIDERS,
   type SystemOneProvider,
@@ -164,7 +164,11 @@ export type SystemOneHumanReview = z.infer<typeof HumanReviewSchema>;
 
 export const SystemOneDecisionConfigSchema = z
   .strictObject({
-    provider: z.enum(SYSTEM_ONE_PROVIDER_IDS).default(SYSTEM_ONE_DEFAULT_PROVIDER),
+    /**
+     * Decision host. Unset means the `SYSTEM_ONE_DEFAULT_PROVIDER` global config
+     * value, read at run time (`typesafe` when that is unset too).
+     */
+    provider: z.enum(SYSTEM_ONE_PROVIDER_IDS).optional(),
     /** Provider-specific model id. Unset means the provider's default. */
     model: z.string().min(1).optional(),
     state: SystemOneStateSchema,
@@ -235,7 +239,9 @@ export const SystemOneDecisionConfigSchema = z
       }
     }
     // Provider limits. A {{token}} model is skipped at save and checked again at run,
-    // where the interpolated config is parsed by this same schema.
+    // where the interpolated config is parsed by this same schema. With no provider
+    // the default is read at run time, so `decide` checks the limits there.
+    if (config.provider === undefined) return;
     const modelProblem = systemOneModelProblem(
       config.provider,
       config.model ?? (SYSTEM_ONE_PROVIDERS[config.provider] as SystemOneProvider).defaultModel,
@@ -847,6 +853,11 @@ export class SystemOneDecisionExecutor extends BaseExecutor<
     return { db: this.deps.db, env: this.options.env ?? process.env };
   }
 
+  /** The provider a config without `provider` uses, read now so a settings change applies at once. */
+  private defaultProvider(): Promise<SystemOneProviderId> {
+    return resolveSystemOneDefaultProvider(this.providerContext());
+  }
+
   private resolveTarget(id: SystemOneProviderId, model?: string) {
     return resolveSystemOneTarget(id, this.providerContext(), {
       apiKey: this.options.getApiKey,
@@ -863,9 +874,10 @@ export class SystemOneDecisionExecutor extends BaseExecutor<
     nodes: readonly ExecutorReadinessNode[],
   ): Promise<ExecutorReadinessProblem[]> {
     const nodeIdsByProvider = new Map<SystemOneProviderId, string[]>();
+    const defaultId = await this.defaultProvider();
     for (const node of nodes) {
       // An unknown provider is a config error the schema reports; it names no credential.
-      const id = systemOneProviderOf(node.config);
+      const id = systemOneProviderOf(node.config, defaultId);
       if (id) nodeIdsByProvider.set(id, [...(nodeIdsByProvider.get(id) ?? []), node.id]);
     }
     const problems: ExecutorReadinessProblem[] = [];
@@ -903,16 +915,25 @@ export class SystemOneDecisionExecutor extends BaseExecutor<
    */
   async decide(
     config: SystemOneDecisionConfig,
-  ): Promise<{ ok: true; output: SystemOneDecisionOutput } | { ok: false; error: string }> {
-    const providerId = config.provider;
+  ): Promise<
+    | { ok: true; output: SystemOneDecisionOutput }
+    | { ok: false; error: string; deploymentRefused?: true }
+  > {
+    const providerId = config.provider ?? (await this.defaultProvider());
     const provider: SystemOneProvider = SYSTEM_ONE_PROVIDERS[providerId];
 
     // A provider with no default sends no `model` when the node sets none.
     const model = config.model ?? provider.defaultModel;
     const modelProblem = systemOneModelProblem(providerId, model);
     if (modelProblem) return { ok: false, error: modelProblem };
+    // Checked at save only for a named provider; a defaulted one is checked here.
+    const limitProblem = systemOneQuestionLimitProblem(
+      providerId,
+      Object.keys(config.questions).length,
+    );
+    if (limitProblem) return { ok: false, error: limitProblem };
     const target = await this.resolveTarget(providerId, model);
-    if (!target.ok) return { ok: false, error: target.error };
+    if (!target.ok) return target;
     const { apiKey, endpoint, keyName } = target;
 
     const wire = provider.wire ?? SYSTEM_ONE_WIRE;