@pome-sh/cli 0.5.0 → 0.8.0

package/dist/src/runner/{runScenario.js → runTask.js}

@@ -4,7 +4,7 @@ import { randomBytes, randomUUID } from "node:crypto";
 import { mkdir, writeFile } from "node:fs/promises";
 import { join, resolve as resolvePath, sep as pathSep } from "node:path";
 import { sign } from "hono/jwt";
-import { parseScenarioFile, seedStateForTwin } from "../scenario/parseScenario.js";
+import { parseTaskFile, seedStateForTwin } from "../task/parseTask.js";
 import { bootTwin } from "../twin/twinHarness.js";
 import { createRecorder } from "../recorder/recorder.js";
 import { redactSecrets } from "../recorder/redaction.js";
@@ -13,7 +13,7 @@ import { runAgentCommand } from "./agentRunner.js";
 import { egressArgs, spawnCaptureServerChild } from "./captureServerChild.js";
 import { buildEgressAllowlist, readBlockedEgress } from "../capture-server/egress.js";
 import { mergeAdapterSignalsIntoEvents } from "./mergeAdapterSignals.js";
-import { writeRunNoScore } from "./runScenarioCore.js";
+import { writeRunNoScore } from "./runTaskCore.js";
 // Promisify a Hono/node server `close()` so teardown can await in-flight
 // handlers draining before the twin's DB handle is released.
 function closeServer(server) {
@@ -21,8 +21,8 @@ function closeServer(server) {
         server.close((err) => (err ? reject(err) : resolvePromise()));
     });
 }
-export async function runScenario(options) {
-    const scenario = await parseScenarioFile(options.scenarioPath);
+export async function runTask(options) {
+    const scenario = await parseTaskFile(options.taskPath);
     const runId = `run_${randomUUID()}`;
     const artifactsDir = options.artifactsDir ?? "runs";
     const startedAt = new Date().toISOString();

package/dist/src/runner/{runScenarioCore.d.ts → runTaskCore.d.ts}

@@ -1,10 +1,10 @@
-import type { Scenario } from "../scenario/scenarioSchema.js";
+import type { Task } from "../task/taskSchema.js";
 import { writeRunArtifactsCore } from "../recorder/artifacts.js";
 import type { RecorderEvent } from "@pome-sh/shared-types";
 export interface WriteRunInput {
     artifactsDir: string;
     runId: string;
-    scenario: Scenario;
+    scenario: Task;
     startedAt: string;
     completedAt: string;
     agentStdout: string;

package/dist/src/runner/{runScenarioHosted.d.ts → runTaskHosted.d.ts}

@@ -1,10 +1,10 @@
 import { type HostedClient } from "../hosted/client.js";
 import type { CreateSessionResponse } from "../types/shared.js";
-import type { Scenario } from "../scenario/scenarioSchema.js";
+import type { Task } from "../task/taskSchema.js";
 import type { Score } from "../hosted/evalResultView.js";
 import type { RunArtifacts } from "../recorder/artifacts.js";
-export interface RunScenarioHostedOptions {
-    scenarioPath: string;
+export interface RunTaskHostedOptions {
+    taskPath: string;
     agentCommand: string;
     artifactsDir?: string;
     hosted: {
@@ -37,8 +37,8 @@ export interface RunScenarioHostedOptions {
      *  local artifacts. Absent on single runs (verdict.json gets null). */
     groupId?: string;
 }
-export interface RunScenarioHostedResult {
-    scenario: Scenario;
+export interface RunTaskHostedResult {
+    scenario: Task;
     runId: string;
     cloudRunId: string;
     cloudDashboardUrl: string;
@@ -87,4 +87,4 @@ export declare function buildAgentEnv(params: {
     slug: string;
     signalsPath: string;
 }): Record<string, string>;
-export declare function runScenarioHosted(options: RunScenarioHostedOptions): Promise<RunScenarioHostedResult>;
+export declare function runTaskHosted(options: RunTaskHostedOptions): Promise<RunTaskHostedResult>;

package/dist/src/runner/{runScenarioHosted.js → runTaskHosted.js}

@@ -7,7 +7,7 @@ import { runAgentCommand } from "./agentRunner.js";
 import { toTwinHttpEvent, writeRunArtifactsCore } from "../recorder/artifacts.js";
 import { VERDICT_ARTIFACT_VERSION, writeVerdictArtifact, } from "../hosted/evalResultCache.js";
 import { redactEvent, redactSecrets } from "../recorder/redaction.js";
-import { parseScenarioFile } from "../scenario/parseScenario.js";
+import { parseTaskFile } from "../task/parseTask.js";
 import { createHostedClient, perTwinReturnedByCloud, } from "../hosted/client.js";
 import { ensureMcpSuffix } from "../cli/session.js";
 import { redactJsonl, scoreFromFinalizeResponse, uploadRunBlobs, } from "../hosted/uploadAndFinalize.js";
@@ -105,10 +105,10 @@ export function buildAgentEnv(params) {
     }
     return env;
 }
-export async function runScenarioHosted(options) {
-    const scenario = await parseScenarioFile(options.scenarioPath);
-    const scenarioSource = await readFile(options.scenarioPath, "utf8");
-    const scenarioHash = createHash("sha256").update(scenarioSource).digest("hex");
+export async function runTaskHosted(options) {
+    const scenario = await parseTaskFile(options.taskPath);
+    const taskSource = await readFile(options.taskPath, "utf8");
+    const taskHash = createHash("sha256").update(taskSource).digest("hex");
     const artifactsDir = options.artifactsDir ?? "runs";
     const startedAt = new Date().toISOString();
     const client = options.client ??
@@ -119,7 +119,7 @@ export async function runScenarioHosted(options) {
     // `agent_version` stamps the session; `--agent-version` overrides it. All are
     // optional during rollout — a manifest-less repo runs unattributed.
     const identity = await resolveRunAgentIdentity({
-        startDir: dirname(options.scenarioPath),
+        startDir: dirname(options.taskPath),
         apiBaseUrl: options.hosted.baseUrl,
         agentVersionOverride: options.agentVersion,
     });
@@ -138,11 +138,11 @@ export async function runScenarioHosted(options) {
     // groups mint all k sessions upfront (one shared group_id) and pass each
     // one in as `premintedSession`; the single-run path mints its own here.
     // Forward the resolved seed (sidecar -> inline JSON -> twin defaults, in that
-    // precedence; see parseScenario.resolveSeedState) so the cloud doesn't need
+    // precedence; see parseTask.resolveSeedState) so the cloud doesn't need
     // to re-extract it from the markdown. Prose `## Seed State` sections have no
     // fenced JSON to extract — cloud would 422 with "no fenced code block".
     const session = await createSessionOrExplain(client, options.premintedSession, {
-        scenarioSource,
+        taskSource,
         twins: scenario.config.twins,
         agentId,
         agentVersion,
@@ -450,9 +450,9 @@ export async function runScenarioHosted(options) {
             agentModel: options.agentModel ?? "unknown",
             agentSdk,
             criteria: criteriaDefs,
-            scenarioName: scenario.slug,
-            scenarioHash,
-            scenarioPrompt: scenario.prompt,
+            taskName: scenario.slug,
+            taskHash,
+            taskPrompt: scenario.prompt,
             expectedBehavior: scenario.expectedBehavior,
             // Explicit overrides when uploads succeeded; otherwise let cloud fall
             // back. For events.jsonl the conventional `team-<>/session-<>/events.jsonl`
@@ -504,7 +504,7 @@ export async function runScenarioHosted(options) {
                 version: VERDICT_ARTIFACT_VERSION,
                 source: "cloud-finalize",
                 task_name: scenario.slug,
-                scenario_path: options.scenarioPath,
+                scenario_path: options.taskPath,
                 group_id: options.groupId ?? null,
                 session_id: session.session_id,
                 cloud_run_id: finalized.run_id,

package/dist/src/runner/runTrialGroup.d.ts

@@ -1,5 +1,5 @@
 import { type HostedClient } from "../hosted/client.js";
-import { runScenarioHosted } from "./runScenarioHosted.js";
+import { runTaskHosted } from "./runTaskHosted.js";
 import { type TrialRow } from "./groupRender.js";
 /** Per-request transport timeout. Durable evaluation has a separate budget. */
 export declare const GROUP_FINALIZE_TIMEOUT_MS = 60000;
@@ -9,7 +9,7 @@ export declare const GROUP_FINALIZE_TIMEOUT_MS = 60000;
 export declare const LAZY_MINT_RETRY_MS = 2000;
 export declare const LAZY_MINT_MAX_ATTEMPTS = 5;
 export interface RunTrialGroupOptions {
-    scenarioPath: string;
+    taskPath: string;
     agentCommand: string;
     /** Where the agent command came from, for the header copy
      *  ("pome.json" | "--agent" | "built-in default"). */
@@ -31,11 +31,11 @@ export interface RunTrialGroupOptions {
     /** FDRS-644 — the literal command the fix handoff tells the user to
      *  re-run after their coding agent applies a fix. The caller knows the
      *  invocation shape (bare `pome run` vs an explicit path + -n); default
-     *  reconstructs it from scenarioPath + trials. */
+     *  reconstructs it from taskPath + trials. */
     rerunCommand?: string;
     out?: (line: string) => void;
     client?: HostedClient;
-    runScenarioHostedFn?: typeof runScenarioHosted;
+    runTaskHostedFn?: typeof runTaskHosted;
     groupId?: string;
     /** FDRS-663 — lazy-mint retry pause; defaults to a real setTimeout. */
     sleepFn?: (ms: number) => Promise<void>;

package/dist/src/runner/runTrialGroup.js

@@ -16,7 +16,7 @@
 //      half-group back (best-effort DELETEs) and aborts before any agent
 //      spawns.
 //   2. Run the k trials with concurrency = the number of upfront mints
-//      (= k when quota never pushed back). runScenarioHosted stays the
+//      (= k when quota never pushed back). runTaskHosted stays the
 //      isolation unit: each trial gets its session via the
 //      `premintedSession` seam, `abandonOnFailure` on, and still DELETEs
 //      its own session in its `finally` — that delete frees the quota slot
@@ -40,10 +40,10 @@ import { createHostedClient } from "../hosted/client.js";
 import { HostedQuotaError, HostedTrialError } from "../hosted/errors.js";
 import { newGroupId } from "../demo/ids.js";
 import { criterionPhrase } from "../demo/render.js";
-import { parseScenarioFile } from "../scenario/parseScenario.js";
+import { parseTaskFile } from "../task/parseTask.js";
 import { outcomeOf } from "../hosted/evalResultView.js";
 import { resolveRunAgentIdentity } from "../cli/agent-identity.js";
-import { runScenarioHosted } from "./runScenarioHosted.js";
+import { runTaskHosted } from "./runTaskHosted.js";
 import { fixHandoffLines, flagHintLine, groupExitCode, groupSummaryLines, mostCommonFailedCriterion, provisioningLine, shortReason, spawningAgentLine, trialRowLine, } from "./groupRender.js";
 /** Per-request transport timeout. Durable evaluation has a separate budget. */
 export const GROUP_FINALIZE_TIMEOUT_MS = 60_000;
@@ -57,7 +57,7 @@ export async function runTrialGroup(options) {
         throw new Error(`runTrialGroup requires k>1 (got ${options.trials}); k=1 takes the single-run path so no group is stamped.`);
     }
     const out = options.out ?? ((line) => console.error(line));
-    const runFn = options.runScenarioHostedFn ?? runScenarioHosted;
+    const runFn = options.runTaskHostedFn ?? runTaskHosted;
     const client = options.client ??
         createHostedClient({
             baseUrl: options.hosted.baseUrl,
@@ -66,12 +66,12 @@ export async function runTrialGroup(options) {
         });
     const groupId = options.groupId ?? newGroupId();
     const agentCommandSource = options.agentCommandSource ?? "pome.json";
-    const scenario = await parseScenarioFile(options.scenarioPath);
-    const scenarioSource = await readFile(options.scenarioPath, "utf8");
+    const scenario = await parseTaskFile(options.taskPath);
+    const taskSource = await readFile(options.taskPath, "utf8");
     // Same agent resolution as the single-run path (F-819): the group's trials
     // are recorded under the agent the manifest's `agent.slug` resolves to.
     const identity = await resolveRunAgentIdentity({
-        startDir: dirname(options.scenarioPath),
+        startDir: dirname(options.taskPath),
         apiBaseUrl: options.hosted.baseUrl,
         agentVersionOverride: options.agentVersion,
     });
@@ -83,7 +83,7 @@ export async function runTrialGroup(options) {
     const sleep = options.sleepFn ??
         ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
     const mintOne = () => client.createSession({
-        scenarioSource,
+        taskSource,
         twins: scenario.config.twins,
         agentId,
         agentVersion,
@@ -158,7 +158,7 @@ export async function runTrialGroup(options) {
         try {
             const session = index < sessions.length ? sessions[index] : await mintLazily();
             const result = await runFn({
-                scenarioPath: options.scenarioPath,
+                taskPath: options.taskPath,
                 agentCommand: options.agentCommand,
                 artifactsDir: options.artifactsDir,
                 hosted: options.hosted,
@@ -239,7 +239,7 @@ export async function runTrialGroup(options) {
             ? "pome fix-prompt"
             : `pome fix-prompt ${artifactsDir}`;
         const rerunCommand = options.rerunCommand ??
-            `pome run ${options.scenarioPath} -n ${options.trials}`;
+            `pome run ${options.taskPath} -n ${options.trials}`;
         for (const line of fixHandoffLines({ fixPromptCommand, rerunCommand })) {
             out(line);
         }

package/dist/src/runner/trialCount.js

@@ -2,7 +2,7 @@
 // FDRS-636 — trial-count resolution for `pome run -n k`.
 //
 // [DECISION 2026-07-05]: -n is an integer 1..20 on the hosted run path. The
-// DEFAULT is the scenario config's `runs` field (scenarioConfigSchema parses
+// DEFAULT is the scenario config's `runs` field (taskConfigSchema parses
 // it, defaulting 1; nothing consumed it before this ticket) — -n overrides;
 // both are capped at 20. k=1 keeps EXACTLY today's single-run behavior (no
 // group is ever stamped — a group of 1 would flip the reliability page off

package/dist/src/task/parseTask.d.ts

@@ -0,0 +1,9 @@
+import { type Task } from "./taskSchema.js";
+export declare function parseTaskFile(path: string): Promise<Task>;
+export declare function parseTask(markdown: string, slug?: string, sidecarSeed?: unknown, taskPath?: string): Task;
+/** The flat seed a single twin boots from. Single-twin scenarios return the
+ *  flat `seedState` as-is; multi-twin scenarios return that twin's slice of the
+ *  per-twin envelope (decided from `config.twins`, per the envelope-iff-multi-twin
+ *  rule). Used by the local runner to seed each twin harness. */
+export declare function seedStateForTwin(scenario: Task, twin: string): unknown;
+export declare function formatTaskError(error: unknown, filePath: string): string;

package/dist/src/{scenario/parseScenario.js → task/parseTask.js}

@@ -8,23 +8,23 @@ import { defaultSeedState, seedSchema } from "@pome-sh/twin-github";
 import { defaultSeedState as defaultGmailSeedState, gmailSeedSchema, } from "@pome-sh/twin-gmail";
 import { defaultSeedState as defaultLinearSeedState, linearSeedSchema as linearSeedStateSchema, } from "@pome-sh/twin-linear";
 import { parseGitHubSeedState } from "./githubSeedCompat.js";
-import { criterionSchema, scenarioConfigSchema, scenarioSchema, slackSeedStateSchema, stripeSeedStateSchema } from "./scenarioSchema.js";
-export async function parseScenarioFile(path) {
+import { criterionSchema, taskConfigSchema, taskSchema, slackSeedStateSchema, stripeSeedStateSchema } from "./taskSchema.js";
+export async function parseTaskFile(path) {
     const markdown = await readFile(path, "utf8");
     const sidecarSeed = await readSidecarSeed(path);
-    return parseScenario(markdown, slugFromPath(path), sidecarSeed, path);
+    return parseTask(markdown, slugFromPath(path), sidecarSeed, path);
 }
-export function parseScenario(markdown, slug = "scenario", sidecarSeed, scenarioPath) {
+export function parseTask(markdown, slug = "scenario", sidecarSeed, taskPath) {
     const title = markdown.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? slug;
     const sections = splitSections(markdown);
     const prompt = sections.get("prompt") ?? sections.get("task") ?? "";
     const criteriaText = sections.get("success criteria") ?? sections.get("checks") ?? "";
     const configText = sections.get("config") ?? "";
     const seedText = sections.get("seed state") ?? "";
-    const config = configText.trim() ? scenarioConfigSchema.parse(parseFencedYaml(configText)) : scenarioConfigSchema.parse({});
+    const config = configText.trim() ? taskConfigSchema.parse(parseFencedYaml(configText)) : taskConfigSchema.parse({});
     const criteria = parseCriteria(criteriaText, config.twins);
-    const seedState = resolveSeedState({ sidecarSeed, seedText, config, scenarioPath });
-    return scenarioSchema.parse({
+    const seedState = resolveSeedState({ sidecarSeed, seedText, config, taskPath });
+    return taskSchema.parse({
         slug,
         title,
         setup: sections.get("setup") ?? "",
@@ -46,7 +46,7 @@ function resolveSeedState(args) {
     // validated against the in-memory twin. The `_meta` key (source hash,
     // model, etc.) is stripped before schema parsing.
     if (args.sidecarSeed !== undefined) {
-        return parseSeedStateForScenario(stripSidecarMeta(args.sidecarSeed), args.config);
+        return parseSeedStateForTask(stripSidecarMeta(args.sidecarSeed), args.config);
     }
     if (args.seedText.trim()) {
         const raw = stripFence(args.seedText);
@@ -55,10 +55,10 @@ function resolveSeedState(args) {
         // got here, the sidecar is missing — tell the user what to do instead of
         // letting JSON.parse surface "Unexpected token 'A'".
         if (!/^[\[{]/.test(raw)) {
-            throw new Error(missingSidecarMessage(args.scenarioPath));
+            throw new Error(missingSidecarMessage(args.taskPath));
         }
         try {
-            return parseSeedStateForScenario(JSON.parse(raw), args.config);
+            return parseSeedStateForTask(JSON.parse(raw), args.config);
         }
         catch (err) {
             if (err instanceof SyntaxError) {
@@ -84,7 +84,7 @@ function resolveMultiTwinSeedState(args) {
     else if (args.seedText.trim()) {
         const text = stripFence(args.seedText);
         if (!/^[\[{]/.test(text)) {
-            throw new Error(missingSidecarMessage(args.scenarioPath));
+            throw new Error(missingSidecarMessage(args.taskPath));
         }
         try {
             raw = JSON.parse(text);
@@ -155,10 +155,10 @@ function defaultSeedForTwin(twin) {
     }
     return seedSchema.parse(defaultSeedState());
 }
-function missingSidecarMessage(scenarioPath) {
-    const pathLabel = scenarioPath ?? "<task>.md";
-    const sidecarLabel = scenarioPath
-        ? scenarioPath.replace(/\.md$/i, ".seed.json")
+function missingSidecarMessage(taskPath) {
+    const pathLabel = taskPath ?? "<task>.md";
+    const sidecarLabel = taskPath
+        ? taskPath.replace(/\.md$/i, ".seed.json")
         : "<task>.seed.json";
     return [
         `Task has a prose ## Seed State section but no compiled sidecar (${sidecarLabel}). Run:`,
@@ -175,9 +175,9 @@ function stripSidecarMeta(seed) {
     }
     return seed;
 }
-async function readSidecarSeed(scenarioPath) {
-    const sidecarPath = scenarioPath.replace(/\.md$/i, ".seed.json");
-    if (sidecarPath === scenarioPath || !existsSync(sidecarPath))
+async function readSidecarSeed(taskPath) {
+    const sidecarPath = taskPath.replace(/\.md$/i, ".seed.json");
+    if (sidecarPath === taskPath || !existsSync(sidecarPath))
         return undefined;
     const raw = await readFile(sidecarPath, "utf8");
     try {
@@ -276,7 +276,7 @@ function parseFencedYaml(input) {
 // FDRS-365: scenario seed shape is FLAT per twin, disambiguated by config.twins.
 // Stripe-only scenarios parse with the Stripe schema; everything else (default
 // `["github"]`, or explicit github) parses with the GitHub schema.
-function parseSeedStateForScenario(input, config) {
+function parseSeedStateForTask(input, config) {
     if (isStripeOnly(config.twins))
         return stripeSeedStateSchema.parse(input);
     if (isSlackOnly(config.twins))
@@ -295,7 +295,7 @@ function defaultSeedStateForConfig(twins) {
     }
     if (isSlackOnly(twins)) {
         // Empty Slack seed — the twin's own `parseSeed`/`defaultSeedState` fills the
-        // world at boot. Scenarios always ship a sidecar, so this is just the
+        // world at boot. Tasks always ship a sidecar, so this is just the
         // schema-valid floor.
         return slackSeedStateSchema.parse({});
     }
@@ -329,7 +329,7 @@ function slugFromPath(path) {
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-|-$/g, "");
 }
-export function formatScenarioError(error, filePath) {
+export function formatTaskError(error, filePath) {
     if (error instanceof z.ZodError) {
         return `Invalid task ${filePath}: ${error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`;
     }

package/dist/src/{scenario → task}/seed-compiler-hosted.d.ts

@@ -2,7 +2,7 @@ import type { CompileResult } from "./seed-compiler.js";
 export interface CompileSeedHostedOptions {
     apiBaseUrl: string;
     twin?: "github";
-    scenarioPath?: string;
+    taskPath?: string;
     timeoutMs?: number;
 }
 export declare function compileSeedHosted(prose: string, opts: CompileSeedHostedOptions): Promise<CompileResult>;

package/dist/src/{scenario → task}/seed-compiler-hosted.js

@@ -59,7 +59,7 @@ export async function compileSeedHosted(prose, opts) {
             body: JSON.stringify({
                 prose,
                 twin: opts.twin ?? "github",
-                scenario_path: opts.scenarioPath
+                scenario_path: opts.taskPath
             }),
             signal: controller.signal
         });

package/dist/src/{scenario/scenarioSchema.d.ts → task/taskSchema.d.ts}

@@ -4,7 +4,7 @@ import { linearSeedSchema as linearSeedStateSchema } from "@pome-sh/twin-linear"
 import { criterionSchema } from "@pome-sh/shared-types";
 import { z } from "zod";
 export { criterionSchema };
-export declare const scenarioConfigSchema: z.ZodObject<{
+export declare const taskConfigSchema: z.ZodObject<{
     twins: z.ZodDefault<z.ZodArray<z.ZodString>>;
     timeout: z.ZodDefault<z.ZodNumber>;
     runs: z.ZodDefault<z.ZodNumber>;
@@ -141,8 +141,8 @@ export declare const seedStateSchema: z.ZodUnion<readonly [z.ZodObject<{
         forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
             forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                pending: "pending";
                 accepted: "accepted";
+                pending: "pending";
             }>>;
         }, z.core.$strict>>>;
         sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -152,8 +152,8 @@ export declare const seedStateSchema: z.ZodUnion<readonly [z.ZodObject<{
             isPrimary: z.ZodDefault<z.ZodBoolean>;
             isDefault: z.ZodDefault<z.ZodBoolean>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                pending: "pending";
                 accepted: "accepted";
+                pending: "pending";
             }>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>;
@@ -246,8 +246,8 @@ export declare const seedStateSchema: z.ZodUnion<readonly [z.ZodObject<{
         forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
             forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                pending: "pending";
                 accepted: "accepted";
+                pending: "pending";
             }>>;
         }, z.core.$strict>>>;
         sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -257,8 +257,8 @@ export declare const seedStateSchema: z.ZodUnion<readonly [z.ZodObject<{
             isPrimary: z.ZodDefault<z.ZodBoolean>;
             isDefault: z.ZodDefault<z.ZodBoolean>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                pending: "pending";
                 accepted: "accepted";
+                pending: "pending";
             }>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>>;
@@ -267,6 +267,15 @@ export declare const seedStateSchema: z.ZodUnion<readonly [z.ZodObject<{
         "seeded-mailboxes": "seeded-mailboxes";
     }>>;
     clock: z.ZodDefault<z.ZodString>;
+    faults: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodEnum<{
+            "rate-limited": "rate-limited";
+        }>;
+        target: z.ZodDefault<z.ZodString>;
+        succeedFirst: z.ZodDefault<z.ZodNumber>;
+        throttleFor: z.ZodDefault<z.ZodNumber>;
+        retryAfterSeconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>, z.ZodObject<{
     team: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     users: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
@@ -605,8 +614,8 @@ export declare const seedEnvelopeSchema: z.ZodRecord<z.ZodString, z.ZodUnion<rea
         forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
             forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                pending: "pending";
                 accepted: "accepted";
+                pending: "pending";
             }>>;
         }, z.core.$strict>>>;
         sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -616,8 +625,8 @@ export declare const seedEnvelopeSchema: z.ZodRecord<z.ZodString, z.ZodUnion<rea
             isPrimary: z.ZodDefault<z.ZodBoolean>;
             isDefault: z.ZodDefault<z.ZodBoolean>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                pending: "pending";
                 accepted: "accepted";
+                pending: "pending";
             }>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>;
@@ -710,8 +719,8 @@ export declare const seedEnvelopeSchema: z.ZodRecord<z.ZodString, z.ZodUnion<rea
         forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
             forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                pending: "pending";
                 accepted: "accepted";
+                pending: "pending";
             }>>;
         }, z.core.$strict>>>;
         sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -721,8 +730,8 @@ export declare const seedEnvelopeSchema: z.ZodRecord<z.ZodString, z.ZodUnion<rea
             isPrimary: z.ZodDefault<z.ZodBoolean>;
             isDefault: z.ZodDefault<z.ZodBoolean>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                pending: "pending";
                 accepted: "accepted";
+                pending: "pending";
             }>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>>;
@@ -731,6 +740,15 @@ export declare const seedEnvelopeSchema: z.ZodRecord<z.ZodString, z.ZodUnion<rea
         "seeded-mailboxes": "seeded-mailboxes";
     }>>;
     clock: z.ZodDefault<z.ZodString>;
+    faults: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodEnum<{
+            "rate-limited": "rate-limited";
+        }>;
+        target: z.ZodDefault<z.ZodString>;
+        succeedFirst: z.ZodDefault<z.ZodNumber>;
+        throttleFor: z.ZodDefault<z.ZodNumber>;
+        retryAfterSeconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>, z.ZodObject<{
     team: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     users: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
@@ -979,7 +997,7 @@ export declare const seedEnvelopeSchema: z.ZodRecord<z.ZodString, z.ZodUnion<rea
         body: z.ZodUnknown;
     }, z.core.$strip>>>;
 }, z.core.$strict>]>>;
-export declare const scenarioSchema: z.ZodObject<{
+export declare const taskSchema: z.ZodObject<{
     slug: z.ZodString;
     title: z.ZodString;
     setup: z.ZodDefault<z.ZodString>;
@@ -1091,8 +1109,8 @@ export declare const scenarioSchema: z.ZodObject<{
             forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                 verificationStatus: z.ZodDefault<z.ZodEnum<{
-                    pending: "pending";
                     accepted: "accepted";
+                    pending: "pending";
                 }>>;
             }, z.core.$strict>>>;
             sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -1102,8 +1120,8 @@ export declare const scenarioSchema: z.ZodObject<{
                 isPrimary: z.ZodDefault<z.ZodBoolean>;
                 isDefault: z.ZodDefault<z.ZodBoolean>;
                 verificationStatus: z.ZodDefault<z.ZodEnum<{
-                    pending: "pending";
                     accepted: "accepted";
+                    pending: "pending";
                 }>>;
             }, z.core.$strict>>>;
         }, z.core.$strict>;
@@ -1196,8 +1214,8 @@ export declare const scenarioSchema: z.ZodObject<{
             forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                 verificationStatus: z.ZodDefault<z.ZodEnum<{
-                    pending: "pending";
                     accepted: "accepted";
+                    pending: "pending";
                 }>>;
             }, z.core.$strict>>>;
             sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -1207,8 +1225,8 @@ export declare const scenarioSchema: z.ZodObject<{
                 isPrimary: z.ZodDefault<z.ZodBoolean>;
                 isDefault: z.ZodDefault<z.ZodBoolean>;
                 verificationStatus: z.ZodDefault<z.ZodEnum<{
-                    pending: "pending";
                     accepted: "accepted";
+                    pending: "pending";
                 }>>;
             }, z.core.$strict>>>;
         }, z.core.$strict>>>;
@@ -1217,6 +1235,15 @@ export declare const scenarioSchema: z.ZodObject<{
             "seeded-mailboxes": "seeded-mailboxes";
         }>>;
         clock: z.ZodDefault<z.ZodString>;
+        faults: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodEnum<{
+                "rate-limited": "rate-limited";
+            }>;
+            target: z.ZodDefault<z.ZodString>;
+            succeedFirst: z.ZodDefault<z.ZodNumber>;
+            throttleFor: z.ZodDefault<z.ZodNumber>;
+            retryAfterSeconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>, z.ZodObject<{
         team: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         users: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
@@ -1554,8 +1581,8 @@ export declare const scenarioSchema: z.ZodObject<{
             forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                 verificationStatus: z.ZodDefault<z.ZodEnum<{
-                    pending: "pending";
                     accepted: "accepted";
+                    pending: "pending";
                 }>>;
             }, z.core.$strict>>>;
             sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -1565,8 +1592,8 @@ export declare const scenarioSchema: z.ZodObject<{
                 isPrimary: z.ZodDefault<z.ZodBoolean>;
                 isDefault: z.ZodDefault<z.ZodBoolean>;
                 verificationStatus: z.ZodDefault<z.ZodEnum<{
-                    pending: "pending";
                     accepted: "accepted";
+                    pending: "pending";
                 }>>;
             }, z.core.$strict>>>;
         }, z.core.$strict>;
@@ -1659,8 +1686,8 @@ export declare const scenarioSchema: z.ZodObject<{
             forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                 verificationStatus: z.ZodDefault<z.ZodEnum<{
-                    pending: "pending";
                     accepted: "accepted";
+                    pending: "pending";
                 }>>;
             }, z.core.$strict>>>;
             sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -1670,8 +1697,8 @@ export declare const scenarioSchema: z.ZodObject<{
                 isPrimary: z.ZodDefault<z.ZodBoolean>;
                 isDefault: z.ZodDefault<z.ZodBoolean>;
                 verificationStatus: z.ZodDefault<z.ZodEnum<{
-                    pending: "pending";
                     accepted: "accepted";
+                    pending: "pending";
                 }>>;
             }, z.core.$strict>>>;
         }, z.core.$strict>>>;
@@ -1680,6 +1707,15 @@ export declare const scenarioSchema: z.ZodObject<{
             "seeded-mailboxes": "seeded-mailboxes";
         }>>;
         clock: z.ZodDefault<z.ZodString>;
+        faults: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodEnum<{
+                "rate-limited": "rate-limited";
+            }>;
+            target: z.ZodDefault<z.ZodString>;
+            succeedFirst: z.ZodDefault<z.ZodNumber>;
+            throttleFor: z.ZodDefault<z.ZodNumber>;
+            retryAfterSeconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>, z.ZodObject<{
         team: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         users: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
@@ -1930,7 +1966,7 @@ export declare const scenarioSchema: z.ZodObject<{
     }, z.core.$strict>]>>]>;
 }, z.core.$strip>;
 export type Criterion = z.infer<typeof criterionSchema>;
-export type ScenarioConfig = z.infer<typeof scenarioConfigSchema>;
+export type TaskConfig = z.infer<typeof taskConfigSchema>;
 export type GithubSeedState = z.infer<typeof githubSeedStateSchema>;
 export type StripeSeedState = z.infer<typeof stripeSeedStateSchema>;
 export type SlackSeedState = z.infer<typeof slackSeedStateSchema>;
@@ -1939,4 +1975,4 @@ export type LinearSeedState = z.infer<typeof linearSeedStateSchema>;
 export type StripeFailureInjectionRule = z.infer<typeof stripeFailureInjectionRuleSchema>;
 export type SeedState = z.infer<typeof seedStateSchema>;
 export type SeedEnvelope = z.infer<typeof seedEnvelopeSchema>;
-export type Scenario = z.infer<typeof scenarioSchema>;
+export type Task = z.infer<typeof taskSchema>;