pome-sh 0.6.6

package/dist/src/scenario/parseScenario.js

@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: Apache-2.0
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { basename, extname } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+import { defaultSeedState, parseSeedState } from "../twin/github/domain/seed.js";
+import { scenarioConfigSchema, scenarioSchema, slackSeedStateSchema, stripeSeedStateSchema } from "./scenarioSchema.js";
+export async function parseScenarioFile(path) {
+    const markdown = await readFile(path, "utf8");
+    const sidecarSeed = await readSidecarSeed(path);
+    return parseScenario(markdown, slugFromPath(path), sidecarSeed, path);
+}
+export function parseScenario(markdown, slug = "scenario", sidecarSeed, scenarioPath) {
+    const title = markdown.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? slug;
+    const sections = splitSections(markdown);
+    const prompt = sections.get("prompt") ?? sections.get("task") ?? "";
+    const criteriaText = sections.get("success criteria") ?? sections.get("checks") ?? "";
+    const configText = sections.get("config") ?? "";
+    const seedText = sections.get("seed state") ?? "";
+    const config = configText.trim() ? scenarioConfigSchema.parse(parseFencedYaml(configText)) : scenarioConfigSchema.parse({});
+    const criteria = parseCriteria(criteriaText);
+    const seedState = resolveSeedState({ sidecarSeed, seedText, config, scenarioPath });
+    return scenarioSchema.parse({
+        slug,
+        title,
+        setup: sections.get("setup") ?? "",
+        prompt,
+        expectedBehavior: sections.get("expected behavior") ?? "",
+        criteria,
+        config,
+        seedState
+    });
+}
+function resolveSeedState(args) {
+    // Sidecar wins when present — it's the compile-seeds output, already
+    // validated against the in-memory twin. The `_meta` key (source hash,
+    // model, etc.) is stripped before schema parsing.
+    if (args.sidecarSeed !== undefined) {
+        return parseSeedStateForScenario(stripSidecarMeta(args.sidecarSeed), args.config);
+    }
+    if (args.seedText.trim()) {
+        const raw = stripFence(args.seedText);
+        // Prose ## Seed State sections are the post-2026-05-22 contract; they're
+        // meant to be compiled to <name>.seed.json via `pome compile-seeds`. If we
+        // got here, the sidecar is missing — tell the user what to do instead of
+        // letting JSON.parse surface "Unexpected token 'A'".
+        if (!/^[\[{]/.test(raw)) {
+            throw new Error(missingSidecarMessage(args.scenarioPath));
+        }
+        try {
+            return parseSeedStateForScenario(JSON.parse(raw), args.config);
+        }
+        catch (err) {
+            if (err instanceof SyntaxError) {
+                throw new Error(`Inline JSON seed in ## Seed State is malformed: ${err.message}`);
+            }
+            throw err;
+        }
+    }
+    return defaultSeedStateForConfig(args.config.twins);
+}
+function missingSidecarMessage(scenarioPath) {
+    const pathLabel = scenarioPath ?? "<scenario>.md";
+    const sidecarLabel = scenarioPath
+        ? scenarioPath.replace(/\.md$/i, ".seed.json")
+        : "<scenario>.seed.json";
+    return [
+        `Scenario has a prose ## Seed State section but no compiled sidecar (${sidecarLabel}). Run:`,
+        "",
+        `    pome compile-seeds ${pathLabel}`,
+        "",
+        "then re-run the scenario. (See `pome docs scenarios-github`.)",
+    ].join("\n");
+}
+function stripSidecarMeta(seed) {
+    if (seed && typeof seed === "object" && !Array.isArray(seed)) {
+        const { _meta, ...rest } = seed;
+        return rest;
+    }
+    return seed;
+}
+async function readSidecarSeed(scenarioPath) {
+    const sidecarPath = scenarioPath.replace(/\.md$/i, ".seed.json");
+    if (sidecarPath === scenarioPath || !existsSync(sidecarPath))
+        return undefined;
+    const raw = await readFile(sidecarPath, "utf8");
+    try {
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Sidecar seed ${sidecarPath} is not valid JSON: ${err.message}`);
+    }
+}
+function splitSections(markdown) {
+    const sections = new Map();
+    const headingPattern = /^##\s+(.+)$/gm;
+    const headings = [...markdown.matchAll(headingPattern)].map((match) => ({
+        title: match[1].trim().toLowerCase(),
+        start: match.index + match[0].length
+    }));
+    for (let i = 0; i < headings.length; i += 1) {
+        const heading = headings[i];
+        const next = headings[i + 1]?.start;
+        const contentStart = heading.start;
+        const contentEnd = next ? markdown.lastIndexOf("##", next - 1) : markdown.length;
+        sections.set(heading.title, markdown.slice(contentStart, contentEnd).trim());
+    }
+    return sections;
+}
+function parseCriteria(input) {
+    return input
+        .split("\n")
+        .map((line) => line.trim())
+        .map((line) => line.match(/^[-*]\s+\[([DP])\]\s+(.+)$/))
+        .filter((match) => Boolean(match))
+        .map((match) => ({
+        type: match[1],
+        text: match[2].trim()
+    }));
+}
+function parseFencedYaml(input) {
+    return parseYaml(stripFence(input));
+}
+// FDRS-365: scenario seed shape is FLAT per twin, disambiguated by config.twins.
+// Stripe-only scenarios parse with the Stripe schema; everything else (default
+// `["github"]`, or explicit github) parses with the GitHub schema.
+function parseSeedStateForScenario(input, config) {
+    if (isStripeOnly(config.twins))
+        return stripeSeedStateSchema.parse(input);
+    if (isSlackOnly(config.twins))
+        return slackSeedStateSchema.parse(input);
+    return parseSeedState(input);
+}
+function defaultSeedStateForConfig(twins) {
+    if (isStripeOnly(twins)) {
+        return stripeSeedStateSchema.parse({
+            api_keys: [{ key: "sk_test_pome_default", sid: "default", account_id: "acct_default" }]
+        });
+    }
+    if (isSlackOnly(twins)) {
+        // Empty Slack seed — the twin's own `parseSeed`/`defaultSeedState` fills the
+        // world at boot. Scenarios always ship a sidecar, so this is just the
+        // schema-valid floor.
+        return slackSeedStateSchema.parse({});
+    }
+    return defaultSeedState();
+}
+function isStripeOnly(twins) {
+    return twins.includes("stripe") && !twins.includes("github");
+}
+function isSlackOnly(twins) {
+    return twins.includes("slack") && !twins.includes("github") && !twins.includes("stripe");
+}
+function stripFence(input) {
+    const fence = input.match(/```(?:json|yaml)?\s*([\s\S]*?)```/i);
+    return (fence?.[1] ?? input).trim();
+}
+function slugFromPath(path) {
+    return basename(path, extname(path))
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+export function formatScenarioError(error, filePath) {
+    if (error instanceof z.ZodError) {
+        return `Invalid scenario ${filePath}: ${error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`;
+    }
+    if (error instanceof Error) {
+        return `Invalid scenario ${filePath}: ${error.message}`;
+    }
+    return `Invalid scenario ${filePath}`;
+}

package/dist/src/scenario/scenarioSchema.d.ts

@@ -0,0 +1,278 @@
+import { z } from "zod";
+import { seedStateSchema as githubSeedStateSchema } from "../twin/github/domain/seed.js";
+export declare const criterionSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        D: "D";
+        P: "P";
+    }>;
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const scenarioConfigSchema: z.ZodObject<{
+    twins: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    runs: z.ZodDefault<z.ZodNumber>;
+    passThreshold: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const stripeFailureInjectionRuleSchema: z.ZodObject<{
+    method: z.ZodString;
+    path: z.ZodString;
+    attempt: z.ZodNumber;
+    mode: z.ZodDefault<z.ZodEnum<{
+        before_handler: "before_handler";
+        after_handler: "after_handler";
+    }>>;
+    status: z.ZodNumber;
+    body: z.ZodUnknown;
+}, z.core.$strip>;
+export declare const stripeSeedStateSchema: z.ZodObject<{
+    api_keys: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodDefault<z.ZodString>;
+        sid: z.ZodDefault<z.ZodString>;
+        account_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    customers: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    products: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    prices: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    payment_intents: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    charges: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    events: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    balances: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    failure_injection: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        method: z.ZodString;
+        path: z.ZodString;
+        attempt: z.ZodNumber;
+        mode: z.ZodDefault<z.ZodEnum<{
+            before_handler: "before_handler";
+            after_handler: "after_handler";
+        }>>;
+        status: z.ZodNumber;
+        body: z.ZodUnknown;
+    }, z.core.$strip>>>;
+}, z.core.$strict>;
+export declare const slackSeedStateSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    users: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    channels: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strict>;
+export declare const seedStateSchema: z.ZodUnion<readonly [z.ZodObject<{
+    team: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    users: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    channels: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strict>, z.ZodObject<{
+    users: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        login: z.ZodString;
+        type: z.ZodDefault<z.ZodEnum<{
+            User: "User";
+            Organization: "Organization";
+        }>>;
+        name: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+    repositories: z.ZodArray<z.ZodObject<{
+        owner: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        default_branch: z.ZodOptional<z.ZodString>;
+        labels: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            color: z.ZodDefault<z.ZodString>;
+            description: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        collaborators: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+            branch: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        issues: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            number: z.ZodNumber;
+            title: z.ZodString;
+            body: z.ZodDefault<z.ZodString>;
+            state: z.ZodDefault<z.ZodEnum<{
+                open: "open";
+                closed: "closed";
+            }>>;
+            labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            assignee: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        pull_requests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            number: z.ZodOptional<z.ZodNumber>;
+            title: z.ZodString;
+            body: z.ZodDefault<z.ZodString>;
+            head: z.ZodString;
+            base: z.ZodDefault<z.ZodString>;
+            state: z.ZodDefault<z.ZodEnum<{
+                open: "open";
+                closed: "closed";
+            }>>;
+            author: z.ZodOptional<z.ZodString>;
+            reviews: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                author: z.ZodString;
+                state: z.ZodDefault<z.ZodEnum<{
+                    APPROVED: "APPROVED";
+                    CHANGES_REQUESTED: "CHANGES_REQUESTED";
+                    COMMENTED: "COMMENTED";
+                }>>;
+                body: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>>>;
+            statuses: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                context: z.ZodDefault<z.ZodString>;
+                state: z.ZodDefault<z.ZodEnum<{
+                    error: "error";
+                    success: "success";
+                    failure: "failure";
+                    pending: "pending";
+                }>>;
+                description: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    api_keys: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodDefault<z.ZodString>;
+        sid: z.ZodDefault<z.ZodString>;
+        account_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    customers: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    products: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    prices: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    payment_intents: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    charges: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    events: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    balances: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    failure_injection: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        method: z.ZodString;
+        path: z.ZodString;
+        attempt: z.ZodNumber;
+        mode: z.ZodDefault<z.ZodEnum<{
+            before_handler: "before_handler";
+            after_handler: "after_handler";
+        }>>;
+        status: z.ZodNumber;
+        body: z.ZodUnknown;
+    }, z.core.$strip>>>;
+}, z.core.$strict>]>;
+export declare const scenarioSchema: z.ZodObject<{
+    slug: z.ZodString;
+    title: z.ZodString;
+    setup: z.ZodDefault<z.ZodString>;
+    prompt: z.ZodString;
+    expectedBehavior: z.ZodDefault<z.ZodString>;
+    criteria: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            D: "D";
+            P: "P";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    config: z.ZodObject<{
+        twins: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        timeout: z.ZodDefault<z.ZodNumber>;
+        runs: z.ZodDefault<z.ZodNumber>;
+        passThreshold: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    seedState: z.ZodUnion<readonly [z.ZodObject<{
+        team: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        users: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        channels: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        users: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            login: z.ZodString;
+            type: z.ZodDefault<z.ZodEnum<{
+                User: "User";
+                Organization: "Organization";
+            }>>;
+            name: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        repositories: z.ZodArray<z.ZodObject<{
+            owner: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            default_branch: z.ZodOptional<z.ZodString>;
+            labels: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                color: z.ZodDefault<z.ZodString>;
+                description: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>>>;
+            collaborators: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                content: z.ZodString;
+                branch: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            issues: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                number: z.ZodNumber;
+                title: z.ZodString;
+                body: z.ZodDefault<z.ZodString>;
+                state: z.ZodDefault<z.ZodEnum<{
+                    open: "open";
+                    closed: "closed";
+                }>>;
+                labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                assignee: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>;
+            pull_requests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                number: z.ZodOptional<z.ZodNumber>;
+                title: z.ZodString;
+                body: z.ZodDefault<z.ZodString>;
+                head: z.ZodString;
+                base: z.ZodDefault<z.ZodString>;
+                state: z.ZodDefault<z.ZodEnum<{
+                    open: "open";
+                    closed: "closed";
+                }>>;
+                author: z.ZodOptional<z.ZodString>;
+                reviews: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    author: z.ZodString;
+                    state: z.ZodDefault<z.ZodEnum<{
+                        APPROVED: "APPROVED";
+                        CHANGES_REQUESTED: "CHANGES_REQUESTED";
+                        COMMENTED: "COMMENTED";
+                    }>>;
+                    body: z.ZodDefault<z.ZodString>;
+                }, z.core.$strip>>>;
+                statuses: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    context: z.ZodDefault<z.ZodString>;
+                    state: z.ZodDefault<z.ZodEnum<{
+                        error: "error";
+                        success: "success";
+                        failure: "failure";
+                        pending: "pending";
+                    }>>;
+                    description: z.ZodDefault<z.ZodString>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        api_keys: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            key: z.ZodDefault<z.ZodString>;
+            sid: z.ZodDefault<z.ZodString>;
+            account_id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        customers: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        products: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        prices: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        payment_intents: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        charges: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        events: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        balances: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        failure_injection: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            method: z.ZodString;
+            path: z.ZodString;
+            attempt: z.ZodNumber;
+            mode: z.ZodDefault<z.ZodEnum<{
+                before_handler: "before_handler";
+                after_handler: "after_handler";
+            }>>;
+            status: z.ZodNumber;
+            body: z.ZodUnknown;
+        }, z.core.$strip>>>;
+    }, z.core.$strict>]>;
+}, z.core.$strip>;
+export type Criterion = z.infer<typeof criterionSchema>;
+export type ScenarioConfig = z.infer<typeof scenarioConfigSchema>;
+export type GithubSeedState = z.infer<typeof githubSeedStateSchema>;
+export type StripeSeedState = z.infer<typeof stripeSeedStateSchema>;
+export type SlackSeedState = z.infer<typeof slackSeedStateSchema>;
+export type StripeFailureInjectionRule = z.infer<typeof stripeFailureInjectionRuleSchema>;
+export type SeedState = z.infer<typeof seedStateSchema>;
+export type Scenario = z.infer<typeof scenarioSchema>;

package/dist/src/scenario/scenarioSchema.js

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: Apache-2.0
+import { z } from "zod";
+import { seedStateSchema as githubSeedStateSchema } from "../twin/github/domain/seed.js";
+export const criterionSchema = z.object({
+    type: z.enum(["D", "P"]),
+    text: z.string().min(1)
+});
+export const scenarioConfigSchema = z.object({
+    twins: z.array(z.string()).default(["github"]),
+    timeout: z.number().int().positive().default(60),
+    runs: z.number().int().positive().default(1),
+    passThreshold: z.number().min(0).max(100).default(100)
+});
+// FDRS-339: scenario-level failure injection. Mirrors the packaged
+// twin-stripe `failureInjectionRuleSchema` without importing it into the
+// parser, so scenario validation stays decoupled from twin boot/runtime code.
+export const stripeFailureInjectionRuleSchema = z.object({
+    method: z.string().min(1),
+    path: z.string().min(1),
+    attempt: z.number().int().positive(),
+    mode: z.enum(["before_handler", "after_handler"]).default("after_handler"),
+    status: z.number().int().min(100).max(599),
+    body: z.unknown()
+});
+// `.strict()` at the top level: unknown keys (notably the legacy
+// `stripe: { seed: ... }` wrapper rejected by FDRS-365) fail parsing loudly
+// instead of silently being stripped to an empty seed.
+export const stripeSeedStateSchema = z
+    .object({
+    api_keys: z
+        .array(z.object({
+        key: z.string().min(1).default("sk_test_pome_default"),
+        sid: z.string().min(1).default("default"),
+        account_id: z.string().min(1).optional()
+    }))
+        .default([]),
+    customers: z.array(z.record(z.string(), z.unknown())).default([]),
+    products: z.array(z.record(z.string(), z.unknown())).default([]),
+    prices: z.array(z.record(z.string(), z.unknown())).default([]),
+    payment_intents: z.array(z.record(z.string(), z.unknown())).default([]),
+    charges: z.array(z.record(z.string(), z.unknown())).default([]),
+    events: z.array(z.record(z.string(), z.unknown())).default([]),
+    balances: z.array(z.record(z.string(), z.unknown())).default([]),
+    failure_injection: z.array(stripeFailureInjectionRuleSchema).default([])
+})
+    .strict();
+// FDRS-529: Slack seed shape (`{ team?, users: [...], channels: [...] }`).
+// Kept LOCAL and permissive (arrays of records) for the same reason the Stripe
+// schema is — the scenario parser shouldn't take a structural dep on twin
+// internals; the vendored `cli/src/twin-slack` `parseSeed` does the strict,
+// regex-level validation at boot. `.strict()` is load-bearing: it makes this
+// arm reject any object carrying a GitHub (`repositories`) or Stripe
+// (`api_keys`, `charges`, …) discriminator, so placing it FIRST in the union
+// (below) can't greedily mis-match a non-Slack seed.
+export const slackSeedStateSchema = z
+    .object({
+    team: z.record(z.string(), z.unknown()).optional(),
+    users: z.array(z.record(z.string(), z.unknown())).default([]),
+    channels: z.array(z.record(z.string(), z.unknown())).default([])
+})
+    .strict();
+// FDRS-365 [DECISION 2026-05-12]: scenario seeds are FLAT per twin.
+// GitHub scenarios use the GitHub seed shape (`{ repositories: [...] }`),
+// Stripe scenarios use the Stripe seed shape (`{ api_keys: [...], ... }`),
+// Slack scenarios use the Slack seed shape (`{ users, channels, ... }`).
+// Multi-twin scenarios are not a current requirement; the wrapped
+// `{ <twin>: { seed: ... } }` form was rejected here to keep one canonical
+// shape that twin parsers already speak natively. parseScenario disambiguates
+// the union by `config.twins`.
+//
+// Slack arm is FIRST because it is the only `.strict()` arm: a GitHub/Stripe
+// seed carries keys it rejects, so it never mis-matches them; while a Slack
+// seed would otherwise be silently key-stripped by the non-strict GitHub arm.
+export const seedStateSchema = z.union([
+    slackSeedStateSchema,
+    githubSeedStateSchema,
+    stripeSeedStateSchema
+]);
+export const scenarioSchema = z.object({
+    slug: z.string().min(1),
+    title: z.string().min(1),
+    setup: z.string().default(""),
+    prompt: z.string().min(1),
+    expectedBehavior: z.string().default(""),
+    criteria: z.array(criterionSchema).min(1),
+    config: scenarioConfigSchema,
+    seedState: seedStateSchema
+});

package/dist/src/scenario/seed-compiler-hosted.d.ts

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

package/dist/src/scenario/seed-compiler-hosted.js

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Hosted variant of the seed compiler. Routes through the cloud control-plane's
+ * `POST /v1/scenarios/compile-seed` endpoint instead of calling Anthropic
+ * directly. Same `CompileResult` shape as the local compiler — callers can swap
+ * one for the other transparently.
+ *
+ * Use cases:
+ *  - users without an `ANTHROPIC_API_KEY` (let Pome bill it via subscription)
+ *  - centralized model upgrades (cloud picks the model)
+ *  - the future web-based scenario editor on app.pome.sh
+ *
+ * Endpoint contract: see `docs/agents/compile-seed-api.md`.
+ */
+import { z } from "zod";
+import { resolveCredentials } from "../cli/credentials.js";
+import { HostedAuthError, HostedOrchError, HostedQuotaError } from "../hosted/errors.js";
+import { seedStateSchema } from "../twin/github/domain/seed.js";
+const DEFAULT_TIMEOUT_MS = 60_000;
+const responseSchema = z.object({
+    seed: z.unknown(),
+    source_hash: z.string(),
+    model: z.string(),
+    compiled_at: z.string(),
+    cached: z.boolean().optional(),
+    // Server can return usage metadata for transparency. Optional — older
+    // server versions or cache-hit responses may omit it.
+    input_tokens: z.number().int().nonnegative().optional(),
+    output_tokens: z.number().int().nonnegative().optional(),
+    cost_cents: z.number().nonnegative().optional()
+});
+// Cloud's REST envelope is `{ error: { type, message, request_id } }` (see
+// `cli/src/hosted/client.ts:110` for the canonical comment). Keep it permissive
+// — older or unrelated origins (Hono default 401, edge errors) may not match.
+const errorBodySchema = z.object({
+    error: z
+        .object({
+        type: z.string().optional(),
+        message: z.string().optional(),
+        request_id: z.string().optional()
+    })
+        .optional()
+});
+export async function compileSeedHosted(prose, opts) {
+    const creds = await resolveCredentials({ apiBaseUrl: opts.apiBaseUrl });
+    const t0 = Date.now();
+    const controller = new AbortController();
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let res;
+    try {
+        res = await fetch(`${creds.apiBaseUrl}/v1/scenarios/compile-seed`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-api-key": creds.apiKey,
+                "user-agent": "pome-cli"
+            },
+            body: JSON.stringify({
+                prose,
+                twin: opts.twin ?? "github",
+                scenario_path: opts.scenarioPath
+            }),
+            signal: controller.signal
+        });
+    }
+    catch (err) {
+        throw new HostedOrchError(`Could not reach the Pome control plane at ${creds.apiBaseUrl}: ${err.message}`);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    const durationMs = Date.now() - t0;
+    if (!res.ok) {
+        await throwForStatus(res);
+    }
+    let parsed;
+    try {
+        const body = await res.json();
+        parsed = responseSchema.parse(body);
+    }
+    catch (err) {
+        throw new HostedOrchError(`Control plane returned a response we could not parse: ${err.message}`);
+    }
+    // Re-validate the seed locally with the CLI's own schema. Catches transport
+    // corruption and the (unlikely) case where cloud and CLI drift on schema.
+    const seed = seedStateSchema.parse(parsed.seed);
+    return {
+        seed,
+        inputTokens: parsed.input_tokens ?? 0,
+        outputTokens: parsed.output_tokens ?? 0,
+        model: parsed.model,
+        durationMs
+    };
+}
+async function throwForStatus(res) {
+    let body = {};
+    try {
+        body = errorBodySchema.parse(await res.json());
+    }
+    catch {
+        /* opaque body — fall through with empty */
+    }
+    const detail = body.error?.message ?? `HTTP ${res.status}`;
+    const requestId = body.error?.request_id ?? res.headers.get("x-request-id") ?? undefined;
+    if (res.status === 401 || res.status === 403) {
+        throw new HostedAuthError(`Authentication failed: ${detail}`, requestId);
+    }
+    if (res.status === 402 || res.status === 429) {
+        throw new HostedQuotaError(`Quota or rate limit hit: ${detail}`, requestId);
+    }
+    // F29 — a 502 from `/v1/scenarios/compile-seed` is overwhelmingly the
+    // Vercel AI Gateway free-tier capacity error. The raw `detail` includes
+    // a "vercel.com/d?to=..." URL and "Free tier users do not have access to
+    // this model" verbiage — both leak vendor internals to the end-user and
+    // tell them nothing actionable. Wrap with a concrete next step.
+    if (res.status === 502) {
+        throw new HostedOrchError(`Pome's hosted seed compiler hit a temporary capacity limit. ` +
+            `Drop \`--hosted\` (or set ANTHROPIC_API_KEY then re-run \`pome compile-seeds --force\`) to compile locally via BYOK, or retry in a minute.`, requestId);
+    }
+    throw new HostedOrchError(`Compile-seed failed (HTTP ${res.status}): ${detail}`, requestId);
+}

package/dist/src/scenario/seed-compiler.d.ts

@@ -0,0 +1,11 @@
+export declare const COMPILER_MODEL = "claude-opus-4-7";
+export interface CompileResult {
+    seed: unknown;
+    inputTokens: number;
+    outputTokens: number;
+    model: string;
+    durationMs: number;
+}
+export declare function compileSeed(prose: string, opts?: {
+    model?: string;
+}): Promise<CompileResult>;