@foldrun/core 9.0.0 → 9.1.0

package/dist/src/approvals.d.ts

@@ -127,19 +127,27 @@ export declare function decideApproval(tenant: string, workspace: string, runId:
  */
 export declare function expireStaleGate(tenant: string, workspace: string, run: RunRecord, now?: number): Promise<boolean>;
 /**
- * Release a run parked on `wait: event` with what arrived. The payload is
- * stored on the step — not as an approval note, which is a person's
- * guidance and capped as such — and the release itself is an approval
- * "by an external event", so the record reads the same way whichever door
- * a park was opened through.
+ * 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).
  *
- * Only steps waiting on an event are released: a run that is also asking a
- * person a question keeps asking.
+ * 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.
  *
- * `by` names who delivered it when that is known — a signed-in person or a
- * key through the dashboard's approve route — and `step` releases one
- * waiting step rather than all of them.
+ * 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 declare function eventGatesFor(tenant: string, workspace: string, run: RunRecord, presented: string, step: number | null): {
+    known: boolean;
+    steps: number[];
+};
 export declare function deliverEvent(tenant: string, workspace: string, runId: string, payload: string, opts?: {
     by?: string;
     step?: number;

package/dist/src/approvals.js

@@ -12,7 +12,7 @@
 import crypto from "node:crypto";
 import { readRun, writeRun, readFlow, mayApprove } from "./store.js";
 import { platform } from "./platform.js";
-import { approveToken, installKey } from "./webhook.js";
+import { approveToken, eventToken, installKey } from "./webhook.js";
 // ----------------------------------------------------------------- links
 /** How long an emailed link decides for when the flow does not say. */
 export const APPROVE_LINK_DEFAULT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
@@ -276,6 +276,56 @@ export async function expireStaleGate(tenant, workspace, run, now = Date.now())
  * 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, workspace, run, presented, step) {
+    const none = { known: false, steps: [] };
+    if (!presented)
+        return none;
+    const same = (want) => {
+        const a = Buffer.from(presented), b = Buffer.from(want);
+        return a.length === b.length && crypto.timingSafeEqual(a, b);
+    };
+    const parks = (i) => (run.steps[i]?.events ?? []).filter((e) => e?.text?.startsWith(EVENT_WAIT_LINE));
+    const waiting = (i) => {
+        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 = [];
+    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, workspace, runId, payload, opts = {}) {
     const run = readRun(tenant, workspace, runId);
     if (!run)

package/dist/src/catalog.d.ts

@@ -45,6 +45,20 @@ export declare const CATALOG_MAX_BYTES: number;
  * there is nothing at all to fall back on.
  */
 export declare 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 declare const CATALOG_RETRY_MS: 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 declare function refreshCatalogSoon(baseUrl: string, load?: (baseUrl: string) => Promise<unknown>, now?: number): boolean;
 /** A preset reference — settings live in the gateway's dashboard, opaque to
  *  us on purpose. The catalogue offers no opinion on one. */
 export declare const isPresetRef: (model: string) => boolean;

package/dist/src/catalog.js

@@ -118,6 +118,34 @@ export async function loadCatalog(baseUrl) {
         return cached; // stale beats nothing; null when there is no nothing
     }
 }
+/** 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();
+/**
+ * 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, load = loadCatalog, now = Date.now()) {
+    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);
+    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) => model.startsWith("@preset/");

package/dist/src/cron.d.ts

@@ -15,3 +15,12 @@ export interface Cron {
 export declare function parseCron(expr: string): Cron | null;
 /** Why `schedule:` is not a cron the scheduler can run, or null when it is. */
 export declare function cronProblem(expr: unknown): string | null;
+/**
+ * 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 declare function cronCanFire(cron: Cron): boolean;

package/dist/src/cron.js

@@ -105,3 +105,23 @@ export function cronProblem(expr) {
         ? `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) {
+    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/dist/src/frontmatter-fields.js

@@ -109,7 +109,7 @@ const FLOW = [
     { 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/dist/src/frontmatter-schema.d.ts

@@ -2,7 +2,7 @@ import { type SchemaKind } from "./frontmatter-fields.ts";
 export { FRONTMATTER, schemaKindOf, type FieldSpec, type FieldType, type SchemaKind } from "./frontmatter-fields.ts";
 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;
 }
@@ -13,3 +13,7 @@ export interface FieldProblem {
  * `near` is the typo matcher; scan.ts passes its own.
  */
 export declare function frontmatterProblems(kind: SchemaKind, data: Record<string, unknown>, near: (key: string, known: readonly string[]) => string | null): FieldProblem[];
+/** 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 declare function signingSecretProblem(v: unknown): string | null;

package/dist/src/frontmatter-schema.js

@@ -5,7 +5,8 @@ import { FRONTMATTER, JOBS } from "./frontmatter-fields.js";
 import { jobFold } from "./matter.js";
 import { resolveEffort, parseDuration, parseInstant, parseRate, STEP_OPTION_KEYS } from "./store.js";
 import { budgetProblem } from "./budget.js";
-import { cronProblem } from "./cron.js";
+import { cronProblem, parseCron, cronCanFire } from "./cron.js";
+import { SECRET_NAME } from "./secrets.js";
 import { modelSecretCollision } from "./model-credential.js";
 import { resourcesProblem, computeProblem } from "./resources.js";
 export { FRONTMATTER, schemaKindOf } from "./frontmatter-fields.js";
@@ -163,11 +164,49 @@ export function frontmatterProblems(kind, data, near) {
         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.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) {
+    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) {
     const t = v?.timeout;
     return t === undefined ? null : DURATION(30, 86400, "30s to 24h")(t);

package/dist/src/notify.d.ts

@@ -15,8 +15,11 @@ export declare function platformMail(tenant: string): {
     key: string;
     from: string;
 } | null;
-/** The account's own Resend key and sender, or null when it has none. */
-export declare function accountMail(tenant: string): {
+/** 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 declare function accountMail(tenant: string, workspace?: string): {
     key: string;
     from: string;
 } | null;
@@ -30,7 +33,7 @@ export declare function accountMail(tenant: string): {
  * 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 declare function notifyMail(tenant: string): {
+export declare function notifyMail(tenant: string, workspace?: string): {
     key: string;
     from: string;
 } | null;

package/dist/src/notify.js

@@ -33,7 +33,7 @@
 import crypto from "node:crypto";
 import { readAgentsMd } from "./runner.js";
 import { accountDir, workspaceDir, runCost, readFlow, runVerdict } from "./store.js";
-import { getSecret, secretSites } from "./secrets.js";
+import { getSecret, secretSites, signingSecretShown, accountSecretUsableIn } from "./secrets.js";
 import { siteCovers } from "./network.js";
 import { publicUrl } from "./webhook.js";
 import { approveLinkPath, approveLinkTtlMs } from "./approvals.js";
@@ -62,12 +62,16 @@ export function platformMail(tenant) {
         return { key, from: platform.setting("FOLDRUN_EMAIL_FROM") || "foldrun <hello@foldrun.io>" };
     return own;
 }
-/** The account's own Resend key and sender, or null when it has none. */
-export function accountMail(tenant) {
-    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, workspace) {
+    const usable = (name) => !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 };
 }
 /**
@@ -80,8 +84,17 @@ export function accountMail(tenant) {
  * 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) {
-    return accountMail(tenant) ?? platformMail(tenant);
+export function notifyMail(tenant, workspace) {
+    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
  *  Resend a fact about a secret the account holds. Recording a platform-key
@@ -146,7 +159,7 @@ export function signatureHeaders(tenant, workspace, config, body) {
         return {};
     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`);
+        console.error(`[foldrun] notify: signing_secret names ${signingSecretShown(config.signingSecret)}, which is not in the vault for ${tenant}/${workspace} — sending unsigned`);
         return {};
     }
     const timestamp = Math.floor(Date.now() / 1000).toString();
@@ -404,7 +417,7 @@ export async function sendPlainNotificationOutcome(tenant, workspace, msg) {
     };
     try {
         if (config.email) {
-            const mail = notifyMail(tenant);
+            const mail = notifyMail(tenant, workspace);
             if (!mail)
                 return no;
             const r = await sendMail({
@@ -455,7 +468,7 @@ export async function sendTestNotification(tenant, workspace) {
     const headline = "\u2713 test notification";
     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,
@@ -493,7 +506,7 @@ export async function sendTestNotification(tenant, workspace) {
         ? {
             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)}` };
 }
@@ -579,7 +592,7 @@ export async function sendRunNotification(tenant, workspace, run) {
     };
     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/dist/src/package.d.ts

@@ -20,7 +20,11 @@ export interface Package {
 /** An error the API layer turns into a status rather than a 500. */
 export declare class PackageError extends Error {
     readonly status: number;
-    constructor(message: string, status: number);
+    /** `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;
+    });
 }
 export declare const MANIFEST_FILE = "foldrun-package.json";
 export declare function isPackagedPath(rel: string): boolean;

package/dist/src/package.js

@@ -37,8 +37,10 @@ import { zip, unzip, ZipError } from "./zip.js";
 /** An error the API layer turns into a status rather than a 500. */
 export class PackageError extends Error {
     status;
-    constructor(message, status) {
-        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, status, opts) {
+        super(message, opts);
         this.status = status;
     }
 }
@@ -371,7 +373,7 @@ export function applyImport(tenant, workspace, pkg, opts = {}) {
                 // 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/dist/src/runner.js

@@ -4804,15 +4804,18 @@ function driveRunInner(tenant, workspace, run, modelOverride, tags, opts) {
                 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/dist/src/scan.js

@@ -202,6 +202,27 @@ export const SCAN_RULES = [
         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",