iterate 0.2.7 → 0.3.0

package/dist/starter-apps/flake-dashboard/worker.d.ts

@@ -0,0 +1,4607 @@
+import type { z } from "zod";
+import { StreamProcessor, type ProcessEventArgs, type ReduceArgs } from "../../processors/index.ts";
+import { StreamProcessorDurableObject, type ProcessorHostDeps, type StreamEvent } from "../../sdk.ts";
+import { FlakeDashboardProcessorContract, type FlakeDashboardRenderResult, type FlakeDashboardState } from "./contract.ts";
+/**
+ * Where a project's CI artifacts live. Supplied by the config worker
+ * (FlakeDashboardApp.create's config) — the starter app itself carries no
+ * organization identity. secretPath names a project secret holding a
+ * Depot org API read token.
+ */
+export interface DepotIngestionConfig {
+    orgId: string;
+    secretPath: string;
+}
+/**
+ * The whole app is this worker: everything is processEvent and reduce.
+ * `FlakeDashboardApp.processEvent` ingests workflow_run webhooks (CI's
+ * credential-free reporting signal) into run-recorded events and wakes the
+ * processor for /flakes events; `FlakeDashboardProcessor.reduce` folds them;
+ * the processor's own processEvent drives the issue render and transition
+ * proposals. No HTTP is served.
+ */
+export declare class FlakeDashboardApp extends StreamProcessorDurableObject<FlakeDashboardState> {
+    #private;
+    protected readonly streamPath = "/flakes";
+    protected readonly recovery = true;
+    protected createProcessor(deps: ProcessorHostDeps): FlakeDashboardProcessor;
+    /**
+     * Every flake-relevant event lands here — the same override point the
+     * platform's own delivery uses (widened public so the config worker can
+     * forward events over RPC). A /flakes event is a wake hint: catch-up
+     * re-reads committed events from the stream and owns validation, ordering,
+     * checkpointing, and dedupe.
+     */
+    processEvent(event: StreamEvent, options?: {
+        depot?: DepotIngestionConfig;
+    }): Promise<void>;
+    /** Internal RPC surface used by smoke checks and debugging. */
+    getState(): Promise<FlakeDashboardState>;
+}
+type FlakeDashboardProcessorDeps = {
+    /**
+     * Upsert the GitHub dashboard issue from folded state. Injected so the
+     * harness tests run against a fake; the worker builds the real one over
+     * itx's GitHub integration. Throwing settles the render as failed.
+     */
+    renderDashboard: (state: FlakeDashboardState) => Promise<Extract<FlakeDashboardRenderResult, {
+        status: "succeeded";
+    }>>;
+};
+/**
+ * One instance runs on the project's `/flakes` stream. CI appends
+ * `run-recorded` events; this processor folds them into per-test stats, owns
+ * the GitHub issue render as its durable obligation, and proposes lifecycle
+ * transitions when a default-branch streak crosses a threshold.
+ */
+export declare class FlakeDashboardProcessor extends StreamProcessor<FlakeDashboardProcessorContract, FlakeDashboardProcessorDeps> {
+    #private;
+    readonly contract: {
+        slug: string;
+        version: string;
+        description: string;
+        stateSchema: z.ZodObject<{
+            birthCertificate: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                config: z.ZodObject<{
+                    repository: z.ZodObject<{
+                        owner: z.ZodString;
+                        repo: z.ZodString;
+                    }, z.core.$strip>;
+                    issueTitle: z.ZodString;
+                    defaultBranch: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>>>;
+            tests: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+                kind: z.ZodDefault<z.ZodEnum<{
+                    unknown: "unknown";
+                    flake: "flake";
+                    failing: "failing";
+                }>>;
+                pattern: z.ZodDefault<z.ZodString>;
+                suites: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                lastSeenOffset: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+                recent: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        pass: "pass";
+                        "flake-fail": "flake-fail";
+                        "unexpected-error": "unexpected-error";
+                        "pinned-fail": "pinned-fail";
+                        "unexpected-pass": "unexpected-pass";
+                        "retried-pass": "retried-pass";
+                    }>;
+                    commit: z.ZodString;
+                    at: z.ZodString;
+                }, z.core.$strip>>>;
+                counts: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+                recentErrors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    error: z.ZodString;
+                    commit: z.ZodString;
+                    at: z.ZodString;
+                }, z.core.$strip>>>;
+                lastFlakeAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                firstRecordedAt: z.ZodString;
+                lastRecordedAt: z.ZodString;
+                defaultBranchStreak: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        pass: "pass";
+                        "flake-fail": "flake-fail";
+                        "unexpected-error": "unexpected-error";
+                        "pinned-fail": "pinned-fail";
+                        "unexpected-pass": "unexpected-pass";
+                        "retried-pass": "retried-pass";
+                    }>;
+                    runs: z.ZodNumber;
+                    firstAt: z.ZodString;
+                    lastAt: z.ZodString;
+                }, z.core.$strip>>>;
+                lastMainWrapperAt: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+                proposed: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+            unknownFlakes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+                record: z.ZodObject<{
+                    name: z.ZodString;
+                    kind: z.ZodDefault<z.ZodEnum<{
+                        unknown: "unknown";
+                        flake: "flake";
+                        failing: "failing";
+                    }>>;
+                    outcome: z.ZodEnum<{
+                        pass: "pass";
+                        "flake-fail": "flake-fail";
+                        "unexpected-error": "unexpected-error";
+                        "pinned-fail": "pinned-fail";
+                        "unexpected-pass": "unexpected-pass";
+                        "retried-pass": "retried-pass";
+                    }>;
+                    pattern: z.ZodOptional<z.ZodString>;
+                    durationMs: z.ZodNumber;
+                    at: z.ZodString;
+                    error: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                passStreak: z.ZodNumber;
+                lastRunAt: z.ZodString;
+                recent: z.ZodArray<z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        pass: "pass";
+                        "flake-fail": "flake-fail";
+                        "unexpected-error": "unexpected-error";
+                        "pinned-fail": "pinned-fail";
+                        "unexpected-pass": "unexpected-pass";
+                        "retried-pass": "retried-pass";
+                    }>;
+                    commit: z.ZodString;
+                    at: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>>;
+            mainRuns: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+                latest: z.ZodObject<{
+                    runId: z.ZodString;
+                    commit: z.ZodString;
+                    summary: z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                complete: z.ZodNullable<z.ZodObject<{
+                    runId: z.ZodString;
+                    commit: z.ZodString;
+                    summary: z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>;
+                inventory: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                    startedAt: z.ZodISODateTime;
+                    names: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>>;
+            suites: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+                recentRunOffsets: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+            }, z.core.$strip>>>;
+            lastDataOffset: z.ZodDefault<z.ZodNumber>;
+            render: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                throughOffset: z.ZodNumber;
+                issueNumber: z.ZodNullable<z.ZodNumber>;
+                issueUrl: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        processorDeps?: readonly [] | undefined;
+        events: {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        };
+        consumes: readonly ("events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled")[];
+        emits: readonly ["events.iterate.com/flakes/transition-proposed", "events.iterate.com/flakes/dashboard-render-settled"];
+        buildEvent: <const Event extends ((Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: "events.iterate.com/flakes/transition-proposed";
+            payload: {
+                testName: string;
+                transition: "unwrap" | "switch-to-failing" | "unwrap-failing";
+                evidence: {
+                    consecutiveRuns: number;
+                    firstAt: string;
+                    lastAt: string;
+                };
+            };
+        }) | (Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: "events.iterate.com/flakes/dashboard-render-settled";
+            payload: {
+                throughOffset: number;
+                result: {
+                    status: "succeeded";
+                    issueNumber: number;
+                    issueUrl: string;
+                } | {
+                    status: "failed";
+                    error: string;
+                };
+            };
+        }) | (Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: "events.iterate.com/flakes/created";
+            payload: {
+                config: {
+                    repository: {
+                        owner: string;
+                        repo: string;
+                    };
+                    issueTitle: string;
+                    defaultBranch: string;
+                };
+            };
+        }) | (Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: "events.iterate.com/flakes/run-recorded";
+            payload: {
+                runId: string;
+                suite: string;
+                branch: string;
+                commit: string;
+                records: {
+                    name: string;
+                    outcome: "pass" | "flake-fail" | "unexpected-error" | "pinned-fail" | "unexpected-pass" | "retried-pass";
+                    durationMs: number;
+                    at: string;
+                    kind?: "unknown" | "flake" | "failing" | undefined;
+                    pattern?: string | undefined;
+                    error?: string | undefined;
+                }[];
+                summary?: {
+                    headSha: string;
+                    branch: string;
+                    status: "incomplete" | "complete";
+                    startedAt: string;
+                    finishedAt: string;
+                    testCount: number;
+                    unknownFlakeCount: number;
+                    failedCount: number;
+                    diagnostics: string[];
+                    runUrl: string;
+                    tests?: {
+                        name: string;
+                        outcome: "skip" | "pass" | "fail";
+                    }[] | undefined;
+                } | undefined;
+            };
+        })) & {
+            type: string;
+        }>(event: Event) => Event extends unknown ? Omit<Event, "payload"> & Pick<Event["type"] extends infer T ? T extends Event["type"] ? T extends unknown ? (T extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T] : never) extends import("../../processors/processor-contracts.ts").EventDefinition<infer PayloadOutput, unknown> ? Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: T;
+            payload: PayloadOutput;
+        } & {
+            payload: PayloadOutput;
+        } & (import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T] : never) extends infer T_1 ? T_1 extends import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T] : never) ? T_1 extends {
+            ephemeral: true;
+        } ? {
+            ephemeral: true;
+        } : unknown : never : never) : never : never : never : never, "payload"> & ((Event["type"] extends infer T_2 ? T_2 extends Event["type"] ? T_2 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_2] : never : never : never) extends infer T_3 ? T_3 extends (Event["type"] extends infer T_4 ? T_4 extends Event["type"] ? T_4 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_4] : never : never : never) ? T_3 extends {
+            ephemeral: true;
+        } ? {
+            ephemeral: true;
+        } : unknown : never : never) : never;
+        parseEvent: <const Event extends import("../../processors/schemas.ts").StreamEvent>(event: Event) => (Extract<"events.iterate.com/flakes/created", Event["type"]> extends infer T ? T extends Extract<"events.iterate.com/flakes/created", Event["type"]> ? T extends unknown ? (T extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T] : never) extends import("../../processors/processor-contracts.ts").EventDefinition<infer PayloadOutput, unknown> ? Omit<{
+            type: string;
+            offset: number;
+            createdAt: string;
+            path: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: T;
+            payload: PayloadOutput;
+        } & {
+            payload: PayloadOutput;
+        } & (import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T] : never) extends infer T_1 ? T_1 extends import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T] : never) ? T_1 extends {
+            ephemeral: true;
+        } ? {
+            ephemeral: true;
+        } : unknown : never : never) : never : never : never : never) | (Extract<"events.iterate.com/flakes/run-recorded", Event["type"]> extends infer T_2 ? T_2 extends Extract<"events.iterate.com/flakes/run-recorded", Event["type"]> ? T_2 extends unknown ? (T_2 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_2] : never) extends import("../../processors/processor-contracts.ts").EventDefinition<infer PayloadOutput, unknown> ? Omit<{
+            type: string;
+            offset: number;
+            createdAt: string;
+            path: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: T_2;
+            payload: PayloadOutput;
+        } & {
+            payload: PayloadOutput;
+        } & (import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T_2 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_2] : never) extends infer T_3 ? T_3 extends import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T_2 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_2] : never) ? T_3 extends {
+            ephemeral: true;
+        } ? {
+            ephemeral: true;
+        } : unknown : never : never) : never : never : never : never) | (Extract<"events.iterate.com/flakes/transition-proposed", Event["type"]> extends infer T_4 ? T_4 extends Extract<"events.iterate.com/flakes/transition-proposed", Event["type"]> ? T_4 extends unknown ? (T_4 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_4] : never) extends import("../../processors/processor-contracts.ts").EventDefinition<infer PayloadOutput, unknown> ? Omit<{
+            type: string;
+            offset: number;
+            createdAt: string;
+            path: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: T_4;
+            payload: PayloadOutput;
+        } & {
+            payload: PayloadOutput;
+        } & (import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T_4 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_4] : never) extends infer T_5 ? T_5 extends import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T_4 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_4] : never) ? T_5 extends {
+            ephemeral: true;
+        } ? {
+            ephemeral: true;
+        } : unknown : never : never) : never : never : never : never) | (Extract<"events.iterate.com/flakes/dashboard-render-settled", Event["type"]> extends infer T_6 ? T_6 extends Extract<"events.iterate.com/flakes/dashboard-render-settled", Event["type"]> ? T_6 extends unknown ? (T_6 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_6] : never) extends import("../../processors/processor-contracts.ts").EventDefinition<infer PayloadOutput, unknown> ? Omit<{
+            type: string;
+            offset: number;
+            createdAt: string;
+            path: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: T_6;
+            payload: PayloadOutput;
+        } & {
+            payload: PayloadOutput;
+        } & (import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T_6 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_6] : never) extends infer T_7 ? T_7 extends import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T_6 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_6] : never) ? T_7 extends {
+            ephemeral: true;
+        } ? {
+            ephemeral: true;
+        } : unknown : never : never) : never : never : never : never);
+        parseEventInput: <const Event extends import("../../processors/schemas.ts").StreamEventInput>(event: Event) => (Extract<"events.iterate.com/flakes/created", Event["type"]> extends infer T ? T extends Extract<"events.iterate.com/flakes/created", Event["type"]> ? T extends unknown ? (T extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T] : never) extends import("../../processors/processor-contracts.ts").EventDefinition<infer PayloadOutput, unknown> ? Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: T;
+            payload: PayloadOutput;
+        } & {
+            payload: PayloadOutput;
+        } & (import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T] : never) extends infer T_1 ? T_1 extends import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T] : never) ? T_1 extends {
+            ephemeral: true;
+        } ? {
+            ephemeral: true;
+        } : unknown : never : never) : never : never : never : never) | (Extract<"events.iterate.com/flakes/run-recorded", Event["type"]> extends infer T_2 ? T_2 extends Extract<"events.iterate.com/flakes/run-recorded", Event["type"]> ? T_2 extends unknown ? (T_2 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_2] : never) extends import("../../processors/processor-contracts.ts").EventDefinition<infer PayloadOutput, unknown> ? Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: T_2;
+            payload: PayloadOutput;
+        } & {
+            payload: PayloadOutput;
+        } & (import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T_2 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_2] : never) extends infer T_3 ? T_3 extends import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T_2 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_2] : never) ? T_3 extends {
+            ephemeral: true;
+        } ? {
+            ephemeral: true;
+        } : unknown : never : never) : never : never : never : never) | (Extract<"events.iterate.com/flakes/transition-proposed", Event["type"]> extends infer T_4 ? T_4 extends Extract<"events.iterate.com/flakes/transition-proposed", Event["type"]> ? T_4 extends unknown ? (T_4 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_4] : never) extends import("../../processors/processor-contracts.ts").EventDefinition<infer PayloadOutput, unknown> ? Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: T_4;
+            payload: PayloadOutput;
+        } & {
+            payload: PayloadOutput;
+        } & (import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T_4 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_4] : never) extends infer T_5 ? T_5 extends import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T_4 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_4] : never) ? T_5 extends {
+            ephemeral: true;
+        } ? {
+            ephemeral: true;
+        } : unknown : never : never) : never : never : never : never) | (Extract<"events.iterate.com/flakes/dashboard-render-settled", Event["type"]> extends infer T_6 ? T_6 extends Extract<"events.iterate.com/flakes/dashboard-render-settled", Event["type"]> ? T_6 extends unknown ? (T_6 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_6] : never) extends import("../../processors/processor-contracts.ts").EventDefinition<infer PayloadOutput, unknown> ? Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: T_6;
+            payload: PayloadOutput;
+        } & {
+            payload: PayloadOutput;
+        } & (import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T_6 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_6] : never) extends infer T_7 ? T_7 extends import("../../processors/processor-contracts.ts").EventDefinition<PayloadOutput, unknown> & (T_6 extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[T_6] : never) ? T_7 extends {
+            ephemeral: true;
+        } ? {
+            ephemeral: true;
+        } : unknown : never : never) : never : never : never : never);
+        parseConsumedInput: <const Event extends (Omit<Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: "events.iterate.com/flakes/created";
+            payload: {
+                config: {
+                    repository: {
+                        owner: string;
+                        repo: string;
+                    };
+                    issueTitle: string;
+                    defaultBranch: string;
+                };
+            };
+        }, "ephemeral"> & {
+            ephemeral?: never;
+        }) | (Omit<Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: "events.iterate.com/flakes/run-recorded";
+            payload: {
+                runId: string;
+                suite: string;
+                branch: string;
+                commit: string;
+                records: {
+                    name: string;
+                    outcome: "pass" | "flake-fail" | "unexpected-error" | "pinned-fail" | "unexpected-pass" | "retried-pass";
+                    durationMs: number;
+                    at: string;
+                    kind?: "unknown" | "flake" | "failing" | undefined;
+                    pattern?: string | undefined;
+                    error?: string | undefined;
+                }[];
+                summary?: {
+                    headSha: string;
+                    branch: string;
+                    status: "incomplete" | "complete";
+                    startedAt: string;
+                    finishedAt: string;
+                    testCount: number;
+                    unknownFlakeCount: number;
+                    failedCount: number;
+                    diagnostics: string[];
+                    runUrl: string;
+                    tests?: {
+                        name: string;
+                        outcome: "skip" | "pass" | "fail";
+                    }[] | undefined;
+                } | undefined;
+            };
+        }, "ephemeral"> & {
+            ephemeral?: never;
+        }) | (Omit<Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: "events.iterate.com/flakes/transition-proposed";
+            payload: {
+                testName: string;
+                transition: "unwrap" | "switch-to-failing" | "unwrap-failing";
+                evidence: {
+                    consecutiveRuns: number;
+                    firstAt: string;
+                    lastAt: string;
+                };
+            };
+        }, "ephemeral"> & {
+            ephemeral?: never;
+        }) | (Omit<Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: "events.iterate.com/flakes/dashboard-render-settled";
+            payload: {
+                throughOffset: number;
+                result: {
+                    status: "succeeded";
+                    issueNumber: number;
+                    issueUrl: string;
+                } | {
+                    status: "failed";
+                    error: string;
+                };
+            };
+        }, "ephemeral"> & {
+            ephemeral?: never;
+        })>(event: Event) => "*" extends Extract<"events.iterate.com/flakes/created", Event["type"]> | Extract<"events.iterate.com/flakes/run-recorded", Event["type"]> | Extract<"events.iterate.com/flakes/transition-proposed", Event["type"]> | Extract<"events.iterate.com/flakes/dashboard-render-settled", Event["type"]> ? Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "ephemeral"> & {
+            ephemeral?: never;
+        } : Extract<"events.iterate.com/flakes/created", Event["type"]> | Extract<"events.iterate.com/flakes/run-recorded", Event["type"]> | Extract<"events.iterate.com/flakes/transition-proposed", Event["type"]> | Extract<"events.iterate.com/flakes/dashboard-render-settled", Event["type"]> extends infer Type extends string ? (Type extends "events.iterate.com/flakes/created" | "events.iterate.com/flakes/run-recorded" | "events.iterate.com/flakes/transition-proposed" | "events.iterate.com/flakes/dashboard-render-settled" ? {
+            readonly "events.iterate.com/flakes/created": {
+                readonly description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.";
+                readonly payloadSchema: z.ZodObject<{
+                    config: z.ZodObject<{
+                        repository: z.ZodObject<{
+                            owner: z.ZodString;
+                            repo: z.ZodString;
+                        }, z.core.$strip>;
+                        issueTitle: z.ZodString;
+                        defaultBranch: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                readonly examples: readonly [{
+                    readonly description: "The dogfood dashboard for this repo.";
+                    readonly payload: {
+                        readonly config: {
+                            readonly repository: {
+                                readonly owner: "iterate";
+                                readonly repo: "iterate";
+                            };
+                            readonly issueTitle: "Flake dashboard";
+                            readonly defaultBranch: "main";
+                        };
+                    };
+                }];
+            };
+            readonly "events.iterate.com/flakes/run-recorded": {
+                readonly description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.";
+                readonly payloadSchema: z.ZodObject<{
+                    runId: z.ZodString;
+                    suite: z.ZodString;
+                    branch: z.ZodString;
+                    commit: z.ZodString;
+                    records: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodDefault<z.ZodEnum<{
+                            unknown: "unknown";
+                            flake: "flake";
+                            failing: "failing";
+                        }>>;
+                        outcome: z.ZodEnum<{
+                            pass: "pass";
+                            "flake-fail": "flake-fail";
+                            "unexpected-error": "unexpected-error";
+                            "pinned-fail": "pinned-fail";
+                            "unexpected-pass": "unexpected-pass";
+                            "retried-pass": "retried-pass";
+                        }>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                        durationMs: z.ZodNumber;
+                        at: z.ZodString;
+                        error: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    summary: z.ZodOptional<z.ZodObject<{
+                        headSha: z.ZodString;
+                        branch: z.ZodString;
+                        status: z.ZodEnum<{
+                            incomplete: "incomplete";
+                            complete: "complete";
+                        }>;
+                        startedAt: z.ZodISODateTime;
+                        finishedAt: z.ZodISODateTime;
+                        testCount: z.ZodNumber;
+                        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            outcome: z.ZodEnum<{
+                                skip: "skip";
+                                pass: "pass";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strip>>>;
+                        unknownFlakeCount: z.ZodNumber;
+                        failedCount: z.ZodNumber;
+                        diagnostics: z.ZodArray<z.ZodString>;
+                        runUrl: z.ZodURL;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/transition-proposed": {
+                readonly description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.";
+                readonly payloadSchema: z.ZodObject<{
+                    testName: z.ZodString;
+                    transition: z.ZodEnum<{
+                        unwrap: "unwrap";
+                        "switch-to-failing": "switch-to-failing";
+                        "unwrap-failing": "unwrap-failing";
+                    }>;
+                    evidence: z.ZodObject<{
+                        consecutiveRuns: z.ZodNumber;
+                        firstAt: z.ZodString;
+                        lastAt: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            };
+            readonly "events.iterate.com/flakes/dashboard-render-settled": {
+                readonly description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.";
+                readonly payloadSchema: z.ZodObject<{
+                    throughOffset: z.ZodNumber;
+                    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        status: z.ZodLiteral<"succeeded">;
+                        issueNumber: z.ZodNumber;
+                        issueUrl: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        status: z.ZodLiteral<"failed">;
+                        error: z.ZodString;
+                    }, z.core.$strip>], "status">;
+                }, z.core.$strip>;
+            };
+        }[Type] : never) extends import("../../processors/processor-contracts.ts").EventDefinition<infer PayloadOutput, unknown> ? Omit<Omit<{
+            type: string;
+            payload?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            source?: {
+                processor?: {
+                    slug: string;
+                    version: string;
+                    stream: {
+                        path: string;
+                        projectId: string | null;
+                        streamId: string;
+                    };
+                    whileProcessing?: {
+                        offset: number;
+                        type: string;
+                    } | undefined;
+                } | undefined;
+                copiedFrom?: {
+                    name: string;
+                    streamId: string;
+                    streamCreatedAt: string;
+                    cursorChangedAtSourceOffset: number;
+                    createdAt: string;
+                    offset: number;
+                    path: string;
+                    projectId: string | null;
+                    type: string;
+                }[] | undefined;
+            } | undefined;
+            idempotencyKey?: string | undefined;
+            ephemeral?: true | undefined;
+        }, "payload" | "type"> & {
+            type: Type;
+            payload: PayloadOutput;
+        }, "ephemeral"> & {
+            ephemeral?: never;
+        } : never : never;
+    };
+    protected reduce({ event, state, }: ReduceArgs<FlakeDashboardProcessorContract>): FlakeDashboardState;
+    protected processEvent(args: ProcessEventArgs<FlakeDashboardProcessorContract>): undefined;
+}
+/** Exported for tests: the table is a pure projection of folded state. */
+export declare function renderBody(state: FlakeDashboardState): string;
+export {};