@pome-sh/cli 0.7.0 → 0.9.0

package/dist/src/hosted/client.js

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 import { createEvalSessionResponseSchema, createSessionResponseSchema, finalizeResponseSchema, sessionPublicSchema, submitResultResponseSchema, } from "../types/shared.js";
 import { z } from "zod";
-import { HostedAuthError, HostedOrchError, HostedQuotaError, } from "./errors.js";
+import { HostedAuthError, HostedOrchError, HostedQuotaError, HostedDiscardRefusedError, } from "./errors.js";
 // Multi-twin (M3): provenance marker for `per_twin`. A single-twin OLD cloud
 // ships NO `per_twin` key; `createSessionResponseSchema` then SYNTHESIZES one
 // (host-rewrites api.pome.sh→mcp.pome.sh with no `/mcp` suffix). Consumers that
@@ -98,6 +98,46 @@ class RetryableFinalizeStatusError extends HostedOrchError {
         this.name = "RetryableFinalizeStatusError";
     }
 }
+/** Read a 409 body as an F-983 discard refusal. Only ever called for status
+ *  409 — a non-409 that happens to echo `details.reason` is a server error,
+ *  not a refusal, and must keep its own status-based handling. */
+async function readDiscardRefusal(res) {
+    let body;
+    try {
+        body = await res.clone().json();
+    }
+    catch {
+        return { kind: "none" };
+    }
+    const error = body?.error;
+    const details = error?.details;
+    if (!details || details.reason !== "ungraded_session")
+        return { kind: "none" };
+    const discardToken = details.discard_token;
+    if (typeof discardToken !== "string" || discardToken.length === 0) {
+        return { kind: "unusable" };
+    }
+    return {
+        kind: "refusal",
+        refusal: {
+            message: typeof error?.message === "string" ? error.message : "",
+            sessionId: typeof details.session_id === "string" ? details.session_id : "",
+            state: typeof details.state === "string" ? details.state : "open",
+            taskName: typeof details.task_name === "string" ? details.task_name : null,
+            openSeconds: typeof details.open_seconds === "number" ? details.open_seconds : 0,
+            discardToken,
+        },
+    };
+}
+/** The delete was refused but the refusal is unreplayable. Say plainly that
+ *  the session is still running: a best-effort caller would otherwise read
+ *  silence as success. NOT HostedDiscardRefusedError — with no token to
+ *  replay, that type would be a lie. */
+function unusableRefusalError(sessionId) {
+    return new HostedOrchError(`DELETE /v1/sessions/${sessionId} → 409: the server refused to delete this ` +
+        `session but sent no usable discard_token, so the session was NOT ` +
+        `stopped. Retry, or stop it from the dashboard.`, undefined, 409);
+}
 export function createHostedClient(config) {
     const timeoutMs = config.timeoutMs ?? 30_000;
     const finalizeTimeoutMs = config.finalizeTimeoutMs ?? 5 * 60_000;
@@ -590,33 +630,75 @@ export function createHostedClient(config) {
                 state_final_json_b64: Buffer.from(input.stateFinalJson, "utf8").toString("base64"),
             }, (raw) => submitResultResponseSchema.parse(raw));
         },
-        async deleteSession(sessionId, bestEffort = true) {
-            const ctrl = new AbortController();
-            const timer = setTimeout(() => ctrl.abort(), timeoutMs);
-            let res;
-            try {
-                res = await fetch(`${config.baseUrl}/v1/sessions/${encodeURIComponent(sessionId)}`, {
-                    method: "DELETE",
-                    // authHeaders, not a hardcoded x-api-key: demo teardown carries a
-                    // bearer demo_token (FDRS-643 live-run finding — the hardcoded
-                    // header made every demo DELETE an opaque 404, silently swallowed
-                    // by best-effort).
-                    headers: authHeaders,
-                    signal: ctrl.signal,
-                });
-            }
-            catch (err) {
-                if (bestEffort)
+        async deleteSession(sessionId, bestEffort = true, opts = {}) {
+            // One DELETE attempt, including the read of a 409 body. `confirmDiscard`
+            // replays the token the control plane hands back with an F-983 refusal.
+            const attempt = async (confirmDiscard) => {
+                const ctrl = new AbortController();
+                const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+                const qs = confirmDiscard
+                    ? `?confirm_discard=${encodeURIComponent(confirmDiscard)}`
+                    : "";
+                try {
+                    const res = await fetch(`${config.baseUrl}/v1/sessions/${encodeURIComponent(sessionId)}${qs}`, {
+                        method: "DELETE",
+                        // authHeaders, not a hardcoded x-api-key: demo teardown carries a
+                        // bearer demo_token (FDRS-643 live-run finding — the hardcoded
+                        // header made every demo DELETE an opaque 404, silently swallowed
+                        // by best-effort).
+                        headers: authHeaders,
+                        signal: ctrl.signal,
+                    });
+                    // Keep the timeout active while consuming a 409 body — fetch()
+                    // resolves after headers, before the body finishes (same hazard,
+                    // same fix, as postJson's readResponse above).
+                    const read = res.status === 409
+                        ? await readDiscardRefusal(res)
+                        : { kind: "none" };
+                    return { res, read };
+                }
+                catch (err) {
+                    if (bestEffort)
+                        return null;
+                    throw new HostedOrchError(err instanceof Error ? err.message : "network error");
+                }
+                finally {
+                    clearTimeout(timer);
+                }
+            };
+            let first = await attempt();
+            if (!first)
+                return; // bestEffort transport failure
+            let res = first.res;
+            // F-983: a 409 carrying reason=ungraded_session is a REFUSAL, not the
+            // already-closed race. Never fold it into the idempotent-success branch
+            // below — that swallow is exactly what made the CLI lie about stopping.
+            // Scoped to 409: a 5xx that echoes the same `details` is a server
+            // error and keeps its status-based handling.
+            if (first.read.kind === "unusable")
+                throw unusableRefusalError(sessionId);
+            if (first.read.kind === "refusal") {
+                const { refusal } = first.read;
+                if (!opts.discard) {
+                    throw new HostedDiscardRefusedError(refusal.message, refusal.sessionId || sessionId, refusal.state, refusal.taskName, refusal.openSeconds, refusal.discardToken);
+                }
+                const confirmed = await attempt(refusal.discardToken);
+                if (!confirmed)
                     return;
-                throw new HostedOrchError(err instanceof Error ? err.message : "network error");
-            }
-            finally {
-                clearTimeout(timer);
+                res = confirmed.res;
+                // No third attempt either way: the token was already spent.
+                if (confirmed.read.kind === "unusable") {
+                    throw unusableRefusalError(sessionId);
+                }
+                if (confirmed.read.kind === "refusal") {
+                    const stillRefused = confirmed.read.refusal;
+                    throw new HostedDiscardRefusedError(stillRefused.message, stillRefused.sessionId || sessionId, stillRefused.state, stillRefused.taskName, stillRefused.openSeconds, stillRefused.discardToken);
+                }
             }
             // Cloud spec (pome-cloud docs/05-api-spec.md): 204 on success. Accept
-            // 200 too in case a future control-plane returns a body. 409 keeps
-            // best-effort teardown idempotent when a concurrent reaper already
-            // closed the row.
+            // 200 too in case a future control-plane returns a body. A 409 that is
+            // NOT an F-983 refusal keeps best-effort teardown idempotent when a
+            // concurrent reaper already closed the row.
             if (res.status === 204 || res.status === 200 || res.status === 409)
                 return;
             if (res.status === 404) {
@@ -627,7 +709,7 @@ export function createHostedClient(config) {
             if (res.status === 401 || res.status === 403) {
                 throw new HostedAuthError(`DELETE /v1/sessions/${sessionId} → ${res.status}`);
             }
-            // 404 / 5xx — log via thrown but caller can swallow if mid-teardown.
+            // 5xx — thrown, but caller can swallow if mid-teardown.
             throw new HostedOrchError(`DELETE /v1/sessions/${sessionId} → ${res.status}`);
         },
     };

package/dist/src/hosted/errors.d.ts

@@ -43,4 +43,18 @@ export declare class HostedTrialError extends Error {
     readonly errorCode: string;
     constructor(message: string, errorCode: string);
 }
+/** F-983 — `DELETE /v1/sessions/:id` refused to destroy a session whose run
+ *  has not been graded. Pome creates the `runs` row at finalize, so an open
+ *  session holds an ungraded run and deleting it discards the evidence. The
+ *  control plane issues `discardToken`; replaying it confirms the discard.
+ *  Deliberately NOT swallowed by `bestEffort` — that flag covers transport
+ *  noise and already-closed races, not a deliberate server refusal. */
+export declare class HostedDiscardRefusedError extends Error {
+    readonly sessionId: string;
+    readonly state: string;
+    readonly taskName: string | null;
+    readonly openSeconds: number;
+    readonly discardToken: string;
+    constructor(message: string, sessionId: string, state: string, taskName: string | null, openSeconds: number, discardToken: string);
+}
 export declare function exitCodeFor(err: unknown): number;

package/dist/src/hosted/errors.js

@@ -87,6 +87,28 @@ export class HostedTrialError extends Error {
         this.name = "HostedTrialError";
     }
 }
+/** F-983 — `DELETE /v1/sessions/:id` refused to destroy a session whose run
+ *  has not been graded. Pome creates the `runs` row at finalize, so an open
+ *  session holds an ungraded run and deleting it discards the evidence. The
+ *  control plane issues `discardToken`; replaying it confirms the discard.
+ *  Deliberately NOT swallowed by `bestEffort` — that flag covers transport
+ *  noise and already-closed races, not a deliberate server refusal. */
+export class HostedDiscardRefusedError extends Error {
+    sessionId;
+    state;
+    taskName;
+    openSeconds;
+    discardToken;
+    constructor(message, sessionId, state, taskName, openSeconds, discardToken) {
+        super(message);
+        this.sessionId = sessionId;
+        this.state = state;
+        this.taskName = taskName;
+        this.openSeconds = openSeconds;
+        this.discardToken = discardToken;
+        this.name = "HostedDiscardRefusedError";
+    }
+}
 export function exitCodeFor(err) {
     if (err instanceof HostedAuthError)
         return 3;

package/dist/src/hosted/evalResultCache.d.ts

@@ -6,9 +6,9 @@ export interface VerdictArtifact {
     /** Provenance: the only writer is the /finalize response path. */
     source: "cloud-finalize";
     task_name: string;
-    /** The scenario path as the run invocation saw it (may move later —
-     *  readers must tolerate a dangling path). */
-    scenario_path: string;
+    /** The task path as the run invocation saw it (may move later — readers
+     *  must tolerate a dangling path). */
+    task_path: string;
     /** Shared trial-group id (`grp_` + nanoid21); null on single runs. */
     group_id: string | null;
     session_id: string;
@@ -37,7 +37,7 @@ export interface RunSet {
     /** null = a single run that never had a group. */
     groupId: string | null;
     taskName: string;
-    /** The scenario path recorded at run time (first trial's). */
+    /** The task path recorded at run time (first trial's). */
     taskPath: string;
     /** Trials sorted by finalized_at ascending. */
     trials: TrialVerdict[];

package/dist/src/hosted/evalResultCache.js

@@ -44,7 +44,7 @@ function isVerdictArtifact(parsed) {
         return false;
     if (typeof v.task_name !== "string")
         return false;
-    if (typeof v.scenario_path !== "string")
+    if (typeof v.task_path !== "string" && typeof v.scenario_path !== "string")
         return false;
     if (v.group_id !== null && typeof v.group_id !== "string")
         return false;
@@ -69,6 +69,13 @@ function isVerdictArtifact(parsed) {
             typeof result.skipped === "boolean");
     });
 }
+/** F-933 — collapse the legacy `scenario_path` onto `task_path` so callers
+ *  only ever deal with one spelling. Validation ran first, so at least one of
+ *  the two is a string. */
+function normalizeVerdictArtifact(parsed) {
+    const { scenario_path: legacyPath, task_path: taskPath, ...rest } = parsed;
+    return { ...rest, task_path: taskPath ?? legacyPath };
+}
 export async function readVerdictArtifact(runDir) {
     const path = join(runDir, VERDICT_FILENAME);
     let raw;
@@ -82,7 +89,7 @@ export async function readVerdictArtifact(runDir) {
         const parsed = JSON.parse(raw);
         if (!isVerdictArtifact(parsed))
             return null;
-        return { runDir, verdict: parsed };
+        return { runDir, verdict: normalizeVerdictArtifact(parsed) };
     }
     catch {
         return null;
@@ -136,7 +143,7 @@ export function groupRunSets(trials) {
         sets.push({
             groupId: bucket[0].verdict.group_id,
             taskName: bucket[0].verdict.task_name,
-            taskPath: bucket[0].verdict.scenario_path,
+            taskPath: bucket[0].verdict.task_path,
             trials: bucket,
             latestFinalizedAt: last.verdict.finalized_at,
             anyFailed: bucket.some((t) => !t.verdict.passed),

package/dist/src/recorder/artifacts.d.ts

@@ -22,7 +22,7 @@ export type RunArtifactCoreInput = {
 export declare function writeRunArtifactsCore(input: RunArtifactCoreInput): Promise<RunArtifacts>;
 export declare function readLatestRun(artifactsDir: string): Promise<{
     run_id: string;
-    scenario: string;
+    task: string;
     run_dir: string;
 } | undefined>;
 export type RunMetaSummary = {

package/dist/src/recorder/artifacts.js

@@ -78,9 +78,16 @@ export async function writeRunArtifactsCore(input) {
     await writeJson(join(runDir, "state_final.json"), input.stateFinal);
     await writeFile(join(runDir, "stdout.txt"), redactText(input.stdout));
     await writeFile(join(runDir, "stderr.log"), redactText(input.stderr));
+    // F-933 — `task`, not `scenario`. latest.json is a purely local pointer:
+    // every run overwrites it and its only readers are `pome eval` / `pome
+    // inspect`, which dereference `run_dir`/`run_id`. Nothing on the wire and
+    // nothing in the cloud parses it, so the rename needs no compat window.
+    // meta.json's `scenario` key is deliberately NOT renamed here — that one is
+    // uploaded to cloud finalize and read back out of older run dirs (see
+    // AGENTS.md's sanctioned-survivor list).
     await writeJson(join(input.artifactsDir, "latest.json"), {
         run_id: input.runId,
-        scenario: input.scenario.slug,
+        task: input.scenario.slug,
         run_dir: runDir
     });
     return { runId: input.runId, runDir };

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

@@ -290,6 +290,13 @@ export declare function runTask(options: RunTaskOptions): Promise<{
             }[];
             deliveryMode: "sender-only" | "seeded-mailboxes";
             clock: string;
+            faults: {
+                name: "rate-limited";
+                target: string;
+                succeedFirst: number;
+                throttleFor: number;
+                retryAfterSeconds: number;
+            }[];
         } | {
             clock: string;
             defaultSid: string;
@@ -678,6 +685,13 @@ export declare function runTask(options: RunTaskOptions): Promise<{
             }[];
             deliveryMode: "sender-only" | "seeded-mailboxes";
             clock: string;
+            faults: {
+                name: "rate-limited";
+                target: string;
+                succeedFirst: number;
+                throttleFor: number;
+                retryAfterSeconds: number;
+            }[];
         } | {
             clock: string;
             defaultSid: string;

package/dist/src/runner/runTaskHosted.js

@@ -504,7 +504,7 @@ export async function runTaskHosted(options) {
                 version: VERDICT_ARTIFACT_VERSION,
                 source: "cloud-finalize",
                 task_name: scenario.slug,
-                scenario_path: options.taskPath,
+                task_path: options.taskPath,
                 group_id: options.groupId ?? null,
                 session_id: session.session_id,
                 cloud_run_id: finalized.run_id,
@@ -548,7 +548,14 @@ export async function runTaskHosted(options) {
     finally {
         // Best-effort teardown. TTL would reap anyway; explicit delete keeps
         // the dashboard sessions list tidy.
-        await client.deleteSession(session.session_id).catch(() => undefined);
+        // F-983: this teardown deliberately discards. On the success path the
+        // session is already `done` (finalize closed it) and the DELETE is a
+        // no-op; on the failure path we accept losing an ungraded tape rather
+        // than leaving open sessions to linger to TTL and pollute the
+        // reliability view. Flagged as known residue in the F-983 spec.
+        await client
+            .deleteSession(session.session_id, true, { discard: true })
+            .catch(() => undefined);
         await rm(signalsDir, { recursive: true, force: true }).catch(() => undefined);
     }
 }

package/dist/src/runner/runTrialGroup.js

@@ -115,7 +115,10 @@ export async function runTrialGroup(options) {
         // Roll the half-group back so abandoned mints never linger as open
         // sessions polluting the reliability view; then let the caller map the
         // error to the documented exit code.
-        await Promise.all(sessions.map((s) => client.deleteSession(s.session_id).catch(() => undefined)));
+        await Promise.all(
+        // F-983: these sessions were minted and never launched, so there is no
+        // tape to lose — an explicit discard is honest here.
+        sessions.map((s) => client.deleteSession(s.session_id, true, { discard: true }).catch(() => undefined)));
         throw err;
     }
     const concurrency = sessions.length;

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

@@ -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>>>;
@@ -1091,8 +1109,8 @@ export declare const taskSchema: 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 taskSchema: 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 taskSchema: 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 taskSchema: 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 taskSchema: 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 taskSchema: 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 taskSchema: 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 taskSchema: 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 taskSchema: 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 taskSchema: 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>>>;

package/node_modules/@pome-sh/shared-types/dist/seed-state.d.ts

@@ -310,6 +310,15 @@ export declare const gmailSeedStateSchema: 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.$strip>;
 export type GmailSeedState = z.infer<typeof gmailSeedStateSchema>;
 export declare const linearSeedStateSchema: z.ZodObject<{
@@ -780,6 +789,15 @@ export declare const providerScopedSeedStateSchema: 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.$strip>;
     }, z.core.$strip>>;
     linear: z.ZodOptional<z.ZodObject<{
@@ -1320,6 +1338,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.$strip>;
     }, z.core.$strip>>;
     linear: z.ZodOptional<z.ZodObject<{