@foldrun/core 9.0.0 → 9.1.0

package/dist/src/triggers.js

@@ -14,7 +14,7 @@
 import crypto from "node:crypto";
 import { platform } from "./platform.js";
 import { listFlows, readRun, runVerdict } from "./store.js";
-import { getSecret } from "./secrets.js";
+import { getSecret, signingSecretShown } from "./secrets.js";
 /** The last step's result — the same reading runner.ts makes, kept local so
  *  this module never imports the runner (the queue imports both). */
 function runResult(run) {
@@ -251,7 +251,7 @@ export function verifyWebhookSignature(tenant, workspace, flow, rawBody, header,
         return { ok: false, reason: `signature: ${flow.signature} needs signing_secret: \${NAME}` };
     const secret = getSecret(tenant, flow.signingSecret, workspace);
     if (!secret)
-        return { ok: false, reason: `signing secret ${flow.signingSecret} is not set` };
+        return { ok: false, reason: `signing secret ${signingSecretShown(flow.signingSecret)} is not set` };
     const hmac = (data) => crypto.createHmac("sha256", secret.value).update(data).digest("hex");
     const fresh = (ts) => Math.abs(now / 1000 - ts) <= 300;
     switch (flow.signature) {

package/dist/src/webhook.d.ts

@@ -27,14 +27,30 @@ export declare function webhookPath(tenant: string, workspace: string, flow: str
  * working hook token.
  */
 export declare function approveToken(tenant: string, workspace: string, runId: string): string;
+/** One parked `wait: event` gate: the step's index in the run record and
+ *  the moment it parked (the `t` of its "waiting for an external event"
+ *  trace line). */
+export interface EventGate {
+    step: number;
+    at: string;
+}
 /**
  * The token that releases a run parked on `wait: event`. Its own HMAC
  * family, so an approval link cannot double as an event URL or the reverse.
+ *
+ * With `gate`, the token is for that one park of that one step (30 Oct
+ * 2026). The per-run token released every later `wait: event` of the run,
+ * so a URL handed to a third party for the first gate also opened the
+ * second, and never expired. A gate's token dies with its park: the step
+ * released is no longer waiting, and parking again (a loop) stamps a new
+ * `at`. The per-run form, without `gate`, is what URLs printed before then
+ * carry — the events route still takes it for a step parked under it.
  */
-export declare function eventToken(tenant: string, workspace: string, runId: string): string;
+export declare function eventToken(tenant: string, workspace: string, runId: string, gate?: EventGate): string;
 /** The URL a `wait: event` step is released at — absolute when the install
- *  knows its origin, a path otherwise. */
-export declare function eventUrl(tenant: string, workspace: string, runId: string): string;
+ *  knows its origin, a path otherwise. With `gate`, that step's own URL
+ *  (`&step=<index>`); the route finds the park's moment on the record. */
+export declare function eventUrl(tenant: string, workspace: string, runId: string, gate?: EventGate): string;
 /**
  * Where this install can be reached from outside, or null. The platform has
  * never needed to know its own address — every URL it hands out has been a

package/dist/src/webhook.js

@@ -80,18 +80,27 @@ export function approveToken(tenant, workspace, runId) {
 /**
  * The token that releases a run parked on `wait: event`. Its own HMAC
  * family, so an approval link cannot double as an event URL or the reverse.
+ *
+ * With `gate`, the token is for that one park of that one step (30 Oct
+ * 2026). The per-run token released every later `wait: event` of the run,
+ * so a URL handed to a third party for the first gate also opened the
+ * second, and never expired. A gate's token dies with its park: the step
+ * released is no longer waiting, and parking again (a loop) stamps a new
+ * `at`. The per-run form, without `gate`, is what URLs printed before then
+ * carry — the events route still takes it for a step parked under it.
  */
-export function eventToken(tenant, workspace, runId) {
+export function eventToken(tenant, workspace, runId, gate) {
     return crypto
         .createHmac("sha256", installKey())
-        .update(`event:${tenant}/${workspace}/${runId}`)
+        .update(gate ? `event:${tenant}/${workspace}/${runId}#${gate.step}@${gate.at}` : `event:${tenant}/${workspace}/${runId}`)
         .digest("hex")
         .slice(0, 32);
 }
 /** The URL a `wait: event` step is released at — absolute when the install
- *  knows its origin, a path otherwise. */
-export function eventUrl(tenant, workspace, runId) {
-    const p = `/api/events/${tenant}/${workspace}/${runId}?token=${eventToken(tenant, workspace, runId)}`;
+ *  knows its origin, a path otherwise. With `gate`, that step's own URL
+ *  (`&step=<index>`); the route finds the park's moment on the record. */
+export function eventUrl(tenant, workspace, runId, gate) {
+    const p = `/api/events/${tenant}/${workspace}/${runId}?token=${eventToken(tenant, workspace, runId, gate)}${gate ? `&step=${gate.step}` : ""}`;
     const base = publicUrl();
     return base ? `${base}${p}` : p;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foldrun/core",
-  "version": "9.0.0",
+  "version": "9.1.0",
   "description": "Agents are just folders. The format, the runner, the checks.",
   "license": "FSL-1.1-ALv2",
   "type": "module",

package/src/approvals.ts

@@ -13,7 +13,7 @@
 import crypto from "node:crypto";
 import { readRun, writeRun, readFlow, mayApprove, type FlowInfo, type RunRecord } from "./store.ts";
 import { platform } from "./platform.ts";
-import { approveToken, installKey } from "./webhook.ts";
+import { approveToken, eventToken, installKey } from "./webhook.ts";
 
 export interface ApprovalDecision {
   decision: "approve" | "reject";
@@ -361,6 +361,60 @@ export async function expireStaleGate(
  * key through the dashboard's approve route — and `step` releases one
  * waiting step rather than all of them.
  */
+const EVENT_WAIT_LINE = "waiting for an external event — release it with POST ";
+
+/**
+ * What a presented event token opens on a run (30 Oct 2026): `known` when
+ * it is a real token of this run — one of its parks, or the old per-run
+ * form — and `steps`, the waiting steps it releases now (none: a 409, the
+ * gate it was for is no longer waiting).
+ *
+ * With `step` (the `&step=` every URL printed since carries), the token is
+ * that step's, bound to the moment it parked: the `t` of its "waiting for an
+ * external event" line. It releases that step only while that park is the
+ * step's current one — a released step is no longer waiting, and a step
+ * parked again (a loop) has a new `t` — so a URL handed out for one gate
+ * opens neither a later gate nor a later park.
+ *
+ * Without `step`, the per-run token URLs carried before then. It releases
+ * only a step still waiting under such a URL — its park line has no
+ * `step=` — so a run parked when this shipped can still be released, and
+ * nothing parked since can be released by the old form.
+ */
+export function eventGatesFor(
+  tenant: string,
+  workspace: string,
+  run: RunRecord,
+  presented: string,
+  step: number | null,
+): { known: boolean; steps: number[] } {
+  const none = { known: false, steps: [] as number[] };
+  if (!presented) return none;
+  const same = (want: string) => {
+    const a = Buffer.from(presented), b = Buffer.from(want);
+    return a.length === b.length && crypto.timingSafeEqual(a, b);
+  };
+  const parks = (i: number) => (run.steps[i]?.events ?? []).filter((e) => e?.text?.startsWith(EVENT_WAIT_LINE));
+  const waiting = (i: number) => {
+    const s = run.steps[i];
+    return !!s && s.status === "awaiting-approval" && s.waitFor === "event";
+  };
+  if (step !== null) {
+    const lines = parks(step);
+    const hit = lines.findIndex((e) => same(eventToken(tenant, workspace, run.id, { step, at: e.t })));
+    if (hit < 0) return none;
+    // Only the step's latest park is open, and only while it waits.
+    return { known: true, steps: hit === lines.length - 1 && waiting(step) ? [step] : [] };
+  }
+  if (!same(eventToken(tenant, workspace, run.id))) return none;
+  const legacy: number[] = [];
+  for (let i = 0; i < run.steps.length; i++) {
+    const last = parks(i).at(-1);
+    if (last && waiting(i) && !/[?&]step=\d/.test(last.text)) legacy.push(i);
+  }
+  return { known: true, steps: legacy };
+}
+
 export async function deliverEvent(
   tenant: string,
   workspace: string,

package/src/catalog.ts

@@ -155,6 +155,33 @@ export async function loadCatalog(baseUrl: string): Promise<Catalog | null> {
   }
 }
 
+/** How long after an attempt a background refresh of the same gateway is
+ *  not tried again, whether it worked or not. */
+export const CATALOG_RETRY_MS = 5 * 60_000;
+const lastTried = new Map<string, number>();
+
+/**
+ * Refresh a gateway's catalogue behind the caller, at most once per
+ * CATALOG_RETRY_MS per gateway (30 Oct 2026). For the editor's completions and
+ * the flows page, which ask on every request: a stale or missing catalogue
+ * used to start a fresh outbound fetch each time — a 10 s one per keystroke
+ * against an unreachable gateway, nothing remembering that it had just
+ * failed. The attempt is noted before it starts, so callers arriving while
+ * one is in flight do not start another. True when one was started. A run's
+ * own read (loadCatalog) is untouched.
+ */
+export function refreshCatalogSoon(baseUrl: string, load: (baseUrl: string) => Promise<unknown> = loadCatalog, now = Date.now()): boolean {
+  const cached = readCatalog(baseUrl);
+  if (cached && now - Date.parse(cached.fetchedAt) < TTL_MS) return false; // fresh: nothing to fetch
+  const last = lastTried.get(baseUrl);
+  if (last !== undefined && now - last < CATALOG_RETRY_MS) return false;
+  lastTried.delete(baseUrl);
+  lastTried.set(baseUrl, now);
+  if (lastTried.size > 1000) lastTried.delete(lastTried.keys().next().value as string);
+  void load(baseUrl).catch(() => null);
+  return true;
+}
+
 /** A preset reference — settings live in the gateway's dashboard, opaque to
  *  us on purpose. The catalogue offers no opinion on one. */
 export const isPresetRef = (model: string) => model.startsWith("@preset/");

package/src/cron.ts

@@ -118,3 +118,22 @@ export function cronProblem(expr: unknown): string | null {
     ? `schedule: "${expr}" has ${fields} field${fields === 1 ? "" : "s"}; cron has five — minute hour day-of-month month day-of-week ("0 9 * * MON"), or @hourly, @daily, @weekly, @monthly. As written the flow never fires`
     : `schedule: "${expr}" is not a cron the scheduler can read — a field is out of range or not a number (minute 0-59, hour 0-23, day 1-31, month 1-12, weekday 0-7 or sun-sat). As written the flow never fires`;
 }
+
+/** Days in each month, February at its leap-year 29: a cron naming the 29th
+ *  of February does fire, every fourth year. */
+const MONTH_DAYS = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
+/**
+ * Whether the calendar has any day this cron names (30 Oct 2026). `0 0 30 2 *`
+ * parses — every field is in range — yet no February has a 30th, so a search
+ * for its next fire walked the whole window every time it was asked (the
+ * schedule page did, 57,600 minutes per flow per request). Answered from the
+ * fields alone: only a day of the month with no weekday beside it can miss,
+ * since with a weekday either may match and every month has every weekday.
+ */
+export function cronCanFire(cron: Cron): boolean {
+  if (!cron.domRestricted || cron.dowRestricted) return true;
+  const firstDay = Math.min(...cron.dom);
+  for (const m of cron.month) if (firstDay <= MONTH_DAYS[m - 1]!) return true;
+  return false;
+}

package/src/frontmatter-fields.ts

@@ -156,7 +156,7 @@ const FLOW: FieldSpec[] = [
   { key: "catchup", type: "string", validated: true, help: "last | none" },
   { key: "on", type: "string", validated: true, help: "trigger: flow — completed | failed | blocked | any" },
   { key: "signature", type: "string", validated: true, help: "github | stripe | slack | hmac" },
-  { key: "signing_secret", type: "string", help: "the secret a webhook's signature is checked with" },
+  { key: "signing_secret", type: "string", help: "the NAME of the vault secret a webhook's signature is checked with — never the value" },
   { key: "after", type: ["string", "list"], help: "trigger: flow — the flow this one follows" },
   { key: "at", type: "string", help: "trigger: once — when" },
   { key: "url", type: "string", help: "trigger: watch — the page watched" },

package/src/frontmatter-schema.ts

@@ -6,7 +6,8 @@ import { FRONTMATTER, JOBS, type FieldType, type SchemaKind } from "./frontmatte
 import { jobFold } from "./matter.ts";
 import { resolveEffort, parseDuration, parseInstant, parseRate, STEP_OPTION_KEYS } from "./store.ts";
 import { budgetProblem } from "./budget.ts";
-import { cronProblem } from "./cron.ts";
+import { cronProblem, parseCron, cronCanFire } from "./cron.ts";
+import { SECRET_NAME } from "./secrets.ts";
 import { modelSecretCollision } from "./model-credential.ts";
 import { resourcesProblem, computeProblem } from "./resources.ts";
 
@@ -70,7 +71,7 @@ const CHECKS: Partial<Record<SchemaKind, Record<string, (value: unknown) => stri
 
 export interface FieldProblem {
   key: string;
-  rule: "config/unknown-field" | "config/wrong-type" | "config/invalid-value" | "config/missing-field" | "config/conflict" | "config/misplaced";
+  rule: "config/unknown-field" | "config/wrong-type" | "config/invalid-value" | "config/missing-field" | "config/conflict" | "config/misplaced" | "config/cron-never-fires" | "secret/signing-secret-value";
   level: "error" | "warn" | "info";
   message: string;
 }
@@ -172,12 +173,47 @@ export function frontmatterProblems(
         : null;
     if (why) out.push({ key, rule: "config/invalid-value", level: "warn", message: `\`${key}:\` ${why.replace(/^\w+: /, "")}` });
   }
+  // A cron every field of which is in range, on a day no month has —
+  // `0 0 30 2 *`. The scheduler's own cronCanFire decides (30 Oct 2026), so
+  // check and the scheduler say the same about it: it never fires.
+  if (kind === "flow" && typeof data.schedule === "string") {
+    const cron = parseCron(data.schedule);
+    if (cron && !cronCanFire(cron)) {
+      out.push({ key: "schedule", rule: "config/cron-never-fires", level: "warn", message: `\`schedule: "${data.schedule}"\` names a day no month it allows has — the flow never fires. Pick a day every named month has, or add a weekday` });
+    }
+  }
+  // A signing secret is the NAME of a vault entry (30 Oct 2026): a flow's
+  // `signing_secret:` and notify's `signing_secret:` are looked up with
+  // getSecret, so a literal value there is a secret written into a
+  // versioned, deployed file — and never matches anything in the vault.
+  // The message never repeats the value.
+  if (kind === "flow" && data.signing_secret !== undefined) {
+    const why = signingSecretProblem(data.signing_secret);
+    if (why) out.push({ key: "signing_secret", rule: "secret/signing-secret-value", level: "warn", message: `\`signing_secret:\` ${why}` });
+  }
+  if (kind === "agents-md" && data.notify && typeof data.notify === "object" && !Array.isArray(data.notify)) {
+    const raw = (data.notify as { signing_secret?: unknown }).signing_secret;
+    const why = raw === undefined ? null : signingSecretProblem(raw);
+    if (why) out.push({ key: "notify", rule: "secret/signing-secret-value", level: "warn", message: `\`notify: signing_secret:\` ${why}` });
+  }
   if (kind === "skill" && !(typeof data.description === "string" && data.description.trim())) {
     out.push({ key: "description", rule: "config/missing-field", level: "warn", message: "no `description:` — a skill without one is never loaded; the model chooses a skill by it" });
   }
   return out;
 }
 
+/** Why a `signing_secret:` value is not a vault secret's name, or null. The
+ *  runtime reads `NAME` and `${NAME}` alike (notify.ts, store.ts). Never
+ *  says what the value is: it may be the secret itself. */
+export function signingSecretProblem(v: unknown): string | null {
+  if (typeof v !== "string") return null; // config/wrong-type says so
+  const name = v.trim().replace(/^\$\{|\}$/g, "");
+  if (!name) return null;
+  return SECRET_NAME.test(name)
+    ? null
+    : "holds something that is not a secret's name (UPPER_SNAKE_CASE, like WEBHOOK_SIGNING_KEY) — it is looked up in the vault by name, so a value written here is never found, and is deployed and versioned in plain text. Put the value in the vault (`foldrun secrets set NAME`), write the name here, and rotate it";
+}
+
 function askProblem(v: unknown): string | null {
   const t = (v as { timeout?: unknown } | null)?.timeout;
   return t === undefined ? null : DURATION(30, 86400, "30s to 24h")(t);

package/src/notify.ts

@@ -34,7 +34,7 @@
 import crypto from "node:crypto";
 import { readAgentsMd } from "./runner.ts";
 import { accountDir, workspaceDir, runCost, readFlow, runVerdict, type RunRecord } from "./store.ts";
-import { getSecret, secretSites } from "./secrets.ts";
+import { getSecret, secretSites, signingSecretShown, accountSecretUsableIn } from "./secrets.ts";
 import { siteCovers } from "./network.ts";
 import { publicUrl } from "./webhook.ts";
 import { approveLinkPath, approveLinkTtlMs } from "./approvals.ts";
@@ -63,11 +63,15 @@ export function platformMail(tenant: string): { key: string; from: string } | nu
   return own;
 }
 
-/** The account's own Resend key and sender, or null when it has none. */
-export function accountMail(tenant: string): { key: string; from: string } | null {
-  const own = getSecret(tenant, "RESEND_API_KEY");
+/** The account's own Resend key and sender, or null when it has none.
+ *  With a workspace — mail a workspace's run causes — an account key or
+ *  sender limited to other workspaces is not used (30 Oct 2026); the
+ *  account's own mail (resets, invites) names none and is not limited. */
+export function accountMail(tenant: string, workspace?: string): { key: string; from: string } | null {
+  const usable = (name: string) => !workspace || accountSecretUsableIn(tenant, name, workspace);
+  const own = usable("RESEND_API_KEY") ? getSecret(tenant, "RESEND_API_KEY") : null;
   if (!own) return null;
-  const from = getSecret(tenant, "EMAIL_FROM")?.value?.trim() || "foldrun <onboarding@resend.dev>";
+  const from = (usable("EMAIL_FROM") ? getSecret(tenant, "EMAIL_FROM")?.value?.trim() : "") || "foldrun <onboarding@resend.dev>";
   return { key: own.value, from };
 }
 
@@ -81,8 +85,15 @@ export function accountMail(tenant: string): { key: string; from: string } | nul
  * owner's bin. The platform's key is the fallback for an account that set
  * none, so `notify:` works before anyone has configured mail at all.
  */
-export function notifyMail(tenant: string): { key: string; from: string } | null {
-  return accountMail(tenant) ?? platformMail(tenant);
+export function notifyMail(tenant: string, workspace?: string): { key: string; from: string } | null {
+  if (!workspace) return accountMail(tenant) ?? platformMail(tenant);
+  // A workspace's notification: the account's sender only where it may be
+  // used, else the platform's — never platformMail's fall back to the
+  // account's own key, which would walk around the limit.
+  const own = accountMail(tenant, workspace);
+  if (own) return own;
+  const key = process.env.FOLDRUN_RESEND_API_KEY;
+  return key ? { key, from: platform.setting("FOLDRUN_EMAIL_FROM") || "foldrun <hello@foldrun.io>" } : null;
 }
 
 /** Was the mail sent on the account's own key? Only then is a refusal from
@@ -169,7 +180,7 @@ export function signatureHeaders(
   const secret = getSecret(tenant, config.signingSecret, workspace);
   if (!secret) {
     console.error(
-      `[foldrun] notify: signing_secret names ${config.signingSecret}, which is not in the vault for ${tenant}/${workspace} — sending unsigned`,
+      `[foldrun] notify: signing_secret names ${signingSecretShown(config.signingSecret)}, which is not in the vault for ${tenant}/${workspace} — sending unsigned`,
     );
     return {};
   }
@@ -475,7 +486,7 @@ export async function sendPlainNotificationOutcome(
   };
   try {
     if (config.email) {
-      const mail = notifyMail(tenant);
+      const mail = notifyMail(tenant, workspace);
       if (!mail) return no;
       const r = await sendMail({
         tenant,
@@ -529,7 +540,7 @@ export async function sendTestNotification(
   const detail = `Sent from ${workspace} at ${sent}. If you are reading this, failures and approval gates will reach you here too.`;
 
   if (config.email) {
-    const mail = notifyMail(tenant);
+    const mail = notifyMail(tenant, workspace);
     if (!mail) {
       return {
         ok: false,
@@ -568,7 +579,7 @@ export async function sendTestNotification(
     ? {
         ok: true,
         destination: shown,
-        detail: `${config.signingSecret ? "accepted, signed with " + config.signingSecret : "accepted"} (delivery ${r.deliveryId})`,
+        detail: `${config.signingSecret ? "accepted, signed with " + signingSecretShown(config.signingSecret) : "accepted"} (delivery ${r.deliveryId})`,
       }
     : { ok: false, destination: shown, detail: `${r.statusCode ? `HTTP ${r.statusCode} — ` : ""}${r.detail.replace(/\s+/g, " ").slice(0, 400)}` };
 }
@@ -659,7 +670,7 @@ export async function sendRunNotification(
 
   try {
     if (config.email) {
-      const mail = notifyMail(tenant);
+      const mail = notifyMail(tenant, workspace);
       if (!mail) {
         console.error(`[foldrun] notify: email configured but no mail credential — set RESEND_API_KEY (and EMAIL_FROM) on the account ${tenant}, or FOLDRUN_RESEND_API_KEY on the platform`);
         return false;

package/src/package.ts

@@ -74,8 +74,10 @@ export interface Package {
 /** An error the API layer turns into a status rather than a 500. */
 export class PackageError extends Error {
   readonly status: number;
-  constructor(message: string, status: number) {
-    super(message);
+  /** `cause`: the error underneath a 500, so an HTTP caller can log it and
+   *  answer without it — a Node error names the server's paths (30 Oct 2026). */
+  constructor(message: string, status: number, opts?: { cause?: unknown }) {
+    super(message, opts);
     this.status = status;
   }
 }
@@ -437,7 +439,7 @@ export function applyImport(
         // best effort — the error below is the one to report
       }
     }
-    throw new PackageError(`the import could not be written, and nothing was kept: ${err instanceof Error ? err.message : String(err)}`, 500);
+    throw new PackageError(`the import could not be written, and nothing was kept: ${err instanceof Error ? err.message : String(err)}`, 500, { cause: err });
   }
   for (const c of changes) {
     const abs = path.join(dir, c.path);

package/src/runner.ts

@@ -5040,15 +5040,18 @@ function driveRunInner(
         if (needsApproval.length) {
           for (const step of needsApproval) {
             step.status = "awaiting-approval";
+            const t = new Date().toISOString();
             step.events.push({
-              t: new Date().toISOString(),
+              t,
               type: "info",
               // ask: is the same gate carrying a question — the answer
               // arrives as the approval note and rides into the prompt.
+              // An event URL is this step's and this park's alone (30 Oct
+              // 2026): the index and this line's `t` are in its token.
               text: step.ask
                 ? `waiting for an answer: ${step.ask}`
                 : step.waitFor === "event"
-                  ? `waiting for an external event — release it with POST ${eventUrl(tenant, workspace, run.id)}`
+                  ? `waiting for an external event — release it with POST ${eventUrl(tenant, workspace, run.id, { step: run.steps.indexOf(step), at: t })}`
                   : "waiting for approval before running",
             });
           }

package/src/scan.ts

@@ -270,6 +270,29 @@ export const SCAN_RULES: readonly ScanRule[] = [
     title: "A required frontmatter field is missing",
     help: "A skill with no description is never loaded: the model chooses skills by their descriptions.",
   },
+  {
+    // 30 Oct 2026: check and the scheduler read a schedule with the same
+    // cronCanFire (core cron.ts), so check says what the scheduler does.
+    id: "config/cron-never-fires",
+    category: "config",
+    level: "warn",
+    title: "A schedule that names a day no month has",
+    help:
+      "`0 0 30 2 *` is a valid cron — every field is in range — but no February has a 30th, so the flow never runs and the " +
+      "scheduler never lists a next run for it. Pick a day every named month has, or add a weekday (either then matches).",
+  },
+  {
+    // 30 Oct 2026: a signing secret is looked up in the vault by name.
+    id: "secret/signing-secret-value",
+    category: "secret",
+    level: "warn",
+    title: "A signing_secret: that holds a value, not a secret's name",
+    help:
+      "A flow's `signing_secret:` and `notify: signing_secret:` name a vault entry (`WEBHOOK_SIGNING_KEY`, or `${WEBHOOK_SIGNING_KEY}`). " +
+      "Anything else is looked up as a name and never found — every signed delivery is refused, every notification goes unsigned — " +
+      "and the value itself is deployed and versioned in plain text. Put it in the vault (`foldrun secrets set NAME`), write the name, and rotate it.",
+    owasp: ["ASI03"],
+  },
   {
     id: "check/ignore-needs-reason",
     category: "config",