@pome-sh/cli 0.20.0 → 0.21.1

package/dist/src/task/parseTask.js

@@ -1,398 +0,0 @@
-// 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, seedSchema } from "@pome-sh/twin-github";
-import { defaultSeedState as defaultGmailSeedState, gmailSeedSchema, } from "@pome-sh/twin-gmail";
-import { defaultSeedState as defaultLinearSeedState, linearSeedSchema as linearSeedStateSchema, } from "@pome-sh/twin-linear";
-import { parseGitHubSeedState } from "./githubSeedCompat.js";
-import { criterionSchema, taskConfigSchema, taskSchema, slackSeedStateSchema, stripeSeedStateSchema } from "./taskSchema.js";
-export async function parseTaskFile(path) {
-    const markdown = await readFile(path, "utf8");
-    const sidecarSeed = await readSidecarSeed(path);
-    return parseTask(markdown, slugFromPath(path), sidecarSeed, path);
-}
-/** The task's declared twins, read WITHOUT requiring criteria (F-1074).
- *  `taskSchema` demands at least one criterion, and `pome checks add` needs the
- *  twin list BEFORE it has written one. Reuses this module's own section
- *  splitter and config schema, so it is not a second parser. */
-export function readConfigTwins(markdown) {
-    const configText = splitSections(markdown).get("config") ?? "";
-    const config = configText.trim()
-        ? taskConfigSchema.parse(parseFencedYaml(configText))
-        : taskConfigSchema.parse({});
-    return config.twins;
-}
-/** Which heading holds the criteria. ONE definition, shared by `parseTask` and
- *  `readCodeCriteria` (F-1134): a reader that knew fewer spellings than the parser
- *  would find zero criteria in a task that has several, and zero criteria reads as
- *  a clean bill. Blessing a file whose criteria were never looked at is the exact
- *  failure the binding check exists to remove. */
-function criteriaSection(sections) {
-    return sections.get("success criteria") ?? sections.get("checks") ?? "";
-}
-/** The task's `[code]` criteria with each one's attributed twin, read WITHOUT the
- *  full task schema (F-1134). Same reason `readConfigTwins` exists, one step
- *  further along: `pome checks add` and `pome checks lint` audit files that are
- *  mid-edit, and `taskSchema` refuses one carrying no criteria or no resolvable
- *  seed. Reuses this module's own section splitter and criterion grammar, so it
- *  is not a second parser.
- *
- *  TOLERANT BY DESIGN. `parseCriteria` throws on a retired marker or a tag naming
- *  no declared twin, and it is right to — it gates a run. This reader only warns,
- *  so a line it cannot understand is skipped instead: turning an author's
- *  half-finished file into a crash is how a warning surface stops being used. */
-export function readCodeCriteria(markdown) {
-    const criteriaText = criteriaSection(splitSections(markdown));
-    // A malformed ## Config block is `parseTask`'s error to report, not this
-    // reader's — fall back to the schema default so an audit still runs.
-    let twins;
-    try {
-        twins = readConfigTwins(markdown);
-    }
-    catch {
-        twins = taskConfigSchema.parse({}).twins;
-    }
-    const primary = twins[0];
-    if (primary === undefined)
-        return [];
-    const found = [];
-    for (const rawLine of criteriaText.split("\n")) {
-        const match = rawLine.trim().match(CRITERION_LINE_RE);
-        if (!match || match[1] !== "code")
-            continue;
-        const tag = match[2];
-        found.push({
-            marker: `[code${tag ? `:${tag}` : ""}]`,
-            twin: tag ?? primary,
-            text: match[3].trim(),
-        });
-    }
-    return found;
-}
-export function parseTask(markdown, slug = "scenario", sidecarSeed, taskPath) {
-    const title = markdown.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? slug;
-    const sections = splitSections(markdown);
-    const prompt = sections.get("prompt") ?? sections.get("task") ?? "";
-    const criteriaText = criteriaSection(sections);
-    const configText = sections.get("config") ?? "";
-    const seedText = sections.get("seed state") ?? "";
-    const config = configText.trim() ? taskConfigSchema.parse(parseFencedYaml(configText)) : taskConfigSchema.parse({});
-    const criteria = parseCriteria(criteriaText, config.twins);
-    const seedState = resolveSeedState({ sidecarSeed, seedText, config, taskPath });
-    return taskSchema.parse({
-        slug,
-        title,
-        setup: sections.get("setup") ?? "",
-        prompt,
-        expectedBehavior: sections.get("expected behavior") ?? "",
-        criteria,
-        config,
-        seedState
-    });
-}
-function resolveSeedState(args) {
-    // Multi-twin (M3): the seed is a per-twin envelope, decided from `config.twins`
-    // alone (envelope-iff-multi-twin — never by sniffing the seed shape).
-    if (args.config.twins.length > 1) {
-        return resolveMultiTwinSeedState(args);
-    }
-    // ── Single-twin: unchanged (byte-identical flat path). ──
-    // 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 parseSeedStateForTask(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.taskPath));
-        }
-        try {
-            return parseSeedStateForTask(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);
-}
-// Multi-twin (M3): the seed (sidecar OR inline) MUST be the per-twin envelope
-// `{ <twin>: <flat seed> }`. Envelope keys are a subset of the scenario's twins;
-// each present value is parsed with THAT twin's own flat schema, and a twin with
-// no envelope key falls back to its default seed. A key that is not one of the
-// scenario's twins is a loud error. When no seed is provided at all, every twin
-// gets its default.
-function resolveMultiTwinSeedState(args) {
-    const twins = args.config.twins;
-    let raw;
-    if (args.sidecarSeed !== undefined) {
-        raw = stripSidecarMeta(args.sidecarSeed);
-    }
-    else if (args.seedText.trim()) {
-        const text = stripFence(args.seedText);
-        if (!/^[\[{]/.test(text)) {
-            throw new Error(missingSidecarMessage(args.taskPath));
-        }
-        try {
-            raw = JSON.parse(text);
-        }
-        catch (err) {
-            if (err instanceof SyntaxError) {
-                throw new Error(`Inline JSON seed in ## Seed State is malformed: ${err.message}`);
-            }
-            throw err;
-        }
-    }
-    else {
-        raw = undefined;
-    }
-    return buildSeedEnvelope(raw, twins);
-}
-function buildSeedEnvelope(raw, twins) {
-    const envelope = {};
-    if (raw === undefined) {
-        for (const twin of twins)
-            envelope[twin] = defaultSeedForTwin(twin);
-        return envelope;
-    }
-    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-        throw new Error(`Multi-twin tasks need a per-twin seed envelope { <twin>: <seed> } for twins [${twins.join(", ")}], not a bare seed object.`);
-    }
-    const allowed = new Set(twins);
-    const provided = raw;
-    for (const key of Object.keys(provided)) {
-        if (!allowed.has(key)) {
-            throw new Error(`Seed envelope key "${key}" is not one of the task's twins [${twins.join(", ")}].`);
-        }
-    }
-    for (const twin of twins) {
-        envelope[twin] =
-            twin in provided ? parseSeedForTwin(twin, provided[twin]) : defaultSeedForTwin(twin);
-    }
-    return envelope;
-}
-// Parse one twin's flat seed with its own schema — the same schemas the
-// single-twin flat path uses, keyed by twin id. Unknown twins fall back to the
-// GitHub parse (mirrors the single-twin default).
-function parseSeedForTwin(twin, input) {
-    if (twin === "stripe")
-        return stripeSeedStateSchema.parse(input);
-    if (twin === "slack")
-        return slackSeedStateSchema.parse(input);
-    if (twin === "gmail")
-        return gmailSeedSchema.parse(input);
-    if (twin === "linear")
-        return linearSeedStateSchema.parse(input);
-    return parseGitHubSeedState(input);
-}
-function defaultSeedForTwin(twin) {
-    if (twin === "stripe") {
-        return stripeSeedStateSchema.parse({
-            api_keys: [{ key: "sk_test_pome_default", sid: "default", account_id: "acct_default" }]
-        });
-    }
-    if (twin === "slack") {
-        return slackSeedStateSchema.parse({});
-    }
-    if (twin === "gmail") {
-        return gmailSeedSchema.parse(defaultGmailSeedState());
-    }
-    if (twin === "linear") {
-        return linearSeedStateSchema.parse(defaultLinearSeedState());
-    }
-    return seedSchema.parse(defaultSeedState());
-}
-function missingSidecarMessage(taskPath) {
-    const pathLabel = taskPath ?? "<task>.md";
-    const sidecarLabel = taskPath
-        ? taskPath.replace(/\.md$/i, ".seed.json")
-        : "<task>.seed.json";
-    return [
-        `Task has a prose ## Seed State section but no compiled sidecar (${sidecarLabel}). Run:`,
-        "",
-        `    pome compile-seeds ${pathLabel}`,
-        "",
-        "then re-run the task. (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(taskPath) {
-    const sidecarPath = taskPath.replace(/\.md$/i, ".seed.json");
-    if (sidecarPath === taskPath || !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;
-}
-// Criterion marker grammar (F-778): `[code]` / `[model]` optionally carrying a
-// twin tag, `[code:<twin>]` / `[model:<twin>]`, where <twin> is
-// `[a-z][a-z0-9_-]*`. The marker spells the canonical criterion kind directly.
-// The tag lands on `criterion.twin`; a bare marker leaves it undefined
-// (attributes to the session's primary twin, `twins[0]`).
-const CRITERION_LINE_RE = /^[-*]\s+\[(code|model)(?::([a-z][a-z0-9_-]*))?\]\s+(.+)$/;
-// The retired pre-F-778 marker spelling, matched ONLY to fail loudly. Without
-// this guard a legacy `[D]`/`[P]` line would fall through the silent
-// skip-non-criterion path below and the scenario would "pass" with fewer
-// criteria than its author wrote.
-const LEGACY_CRITERION_LINE_RE = /^[-*]\s+\[([DP])(?::([a-z][a-z0-9_-]*))?\]\s+(.+)$/;
-function parseCriteria(input, twins) {
-    const multiTwin = twins.length > 1;
-    const allowed = new Set(twins);
-    const primary = twins[0];
-    const criteria = [];
-    for (const rawLine of input.split("\n")) {
-        const line = rawLine.trim();
-        const legacy = line.match(LEGACY_CRITERION_LINE_RE);
-        if (legacy) {
-            const legacyMarker = `[${legacy[1]}${legacy[2] ? `:${legacy[2]}` : ""}]`;
-            throw new Error(`Criterion "${legacyMarker} ${legacy[3].trim()}" uses a retired marker — markers were renamed [D]→[code] and [P]→[model] (tags carry over: [D:github]→[code:github]).`);
-        }
-        const match = line.match(CRITERION_LINE_RE);
-        if (!match)
-            continue;
-        const kind = match[1]; // "code" | "model"
-        const tag = match[2]; // twin tag or undefined
-        const text = match[3].trim();
-        // Reconstruct the human-facing marker for error messages.
-        const marker = `[${kind}${tag ? `:${tag}` : ""}]`;
-        if (tag !== undefined) {
-            if (!multiTwin) {
-                // Single-twin: an explicit tag is allowed but must equal the sole twin.
-                if (tag !== primary) {
-                    throw new Error(`Criterion "${marker} ${text}" tags twin "${tag}", but this single-twin task runs "${primary}". Drop the tag or set config.twins to include "${tag}".`);
-                }
-            }
-            else if (!allowed.has(tag)) {
-                // Multi-twin: an explicit tag must name one of the scenario's twins.
-                throw new Error(`Criterion "${marker} ${text}" tags twin "${tag}", which is not in the task's twins [${twins.join(", ")}].`);
-            }
-        }
-        else if (multiTwin && kind === "code") {
-            // Multi-twin: every [code] criterion MUST carry a tag so the cloud knows
-            // which twin's state to check it against. [model] may stay bare
-            // (attributes to the primary twin).
-            throw new Error(`Criterion "${marker} ${text}" needs a twin tag ([code:<twin>]) in a multi-twin task (twins [${twins.join(", ")}]).`);
-        }
-        // The marker spells the canonical kind; `criterionSchema` keeps accepting
-        // the legacy `D`/`P` enum values only for 0.3.0-era persisted artifacts
-        // (the published contract's tolerant reader), never from markdown.
-        // The optional `twin` rides through untouched.
-        criteria.push(criterionSchema.parse(tag !== undefined ? { type: kind, text, twin: tag } : { type: kind, text }));
-    }
-    return criteria;
-}
-/** The flat seed a single twin boots from. Single-twin scenarios return the
- *  flat `seedState` as-is; multi-twin scenarios return that twin's slice of the
- *  per-twin envelope (decided from `config.twins`, per the envelope-iff-multi-twin
- *  rule). Used by the local runner to seed each twin harness. */
-export function seedStateForTwin(scenario, twin) {
-    if (scenario.config.twins.length > 1) {
-        return scenario.seedState[twin];
-    }
-    return scenario.seedState;
-}
-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 parseSeedStateForTask(input, config) {
-    if (isStripeOnly(config.twins))
-        return stripeSeedStateSchema.parse(input);
-    if (isSlackOnly(config.twins))
-        return slackSeedStateSchema.parse(input);
-    if (isGmailOnly(config.twins))
-        return gmailSeedSchema.parse(input);
-    if (isLinearOnly(config.twins))
-        return linearSeedStateSchema.parse(input);
-    return parseGitHubSeedState(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. Tasks always ship a sidecar, so this is just the
-        // schema-valid floor.
-        return slackSeedStateSchema.parse({});
-    }
-    if (isGmailOnly(twins)) {
-        return gmailSeedSchema.parse(defaultGmailSeedState());
-    }
-    if (isLinearOnly(twins)) {
-        return linearSeedStateSchema.parse(defaultLinearSeedState());
-    }
-    return seedSchema.parse(defaultSeedState());
-}
-function isStripeOnly(twins) {
-    return twins.length === 1 && twins[0] === "stripe";
-}
-function isSlackOnly(twins) {
-    return twins.length === 1 && twins[0] === "slack";
-}
-function isGmailOnly(twins) {
-    return twins.length === 1 && twins[0] === "gmail";
-}
-function isLinearOnly(twins) {
-    return twins.length === 1 && twins[0] === "linear";
-}
-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 formatTaskError(error, filePath) {
-    if (error instanceof z.ZodError) {
-        return `Invalid task ${filePath}: ${error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`;
-    }
-    if (error instanceof Error) {
-        return `Invalid task ${filePath}: ${error.message}`;
-    }
-    return `Invalid task ${filePath}`;
-}

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

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

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

@@ -1,122 +0,0 @@
-// 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 { parseGitHubSeedState } from "./githubSeedCompat.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.taskPath
-            }),
-            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 = parseGitHubSeedState(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/task/seed-compiler.d.ts

@@ -1,11 +0,0 @@
-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>;

package/dist/src/task/seed-compiler.js

@@ -1,61 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Compile a prose seed description into a JSON seed object matching
- * `seedStateSchema`. Uses the Anthropic Messages API with structured
- * output (`output_config` + `zodOutputFormat`).
- *
- * See `docs/agents/scenario-prose-seed.md` for the prose convention.
- *
- * Why Messages API and not the Agent SDK: this is a pure prose-to-JSON
- * transform with no tools needed during generation, so the agent loop
- * adds only cost and variance. The bundled Claude Code system prompt
- * also pushes per-call cost up ~3-10×.
- */
-import Anthropic from "@anthropic-ai/sdk";
-import { zodOutputFormat } from "@anthropic-ai/sdk/helpers/zod";
-import { parseGitHubSeedState } from "./githubSeedCompat.js";
-import { seedSchema as seedStateSchema } from "@pome-sh/twin-github";
-export const COMPILER_MODEL = "claude-opus-4-7";
-const SYSTEM_PROMPT = `You convert natural-language descriptions of a GitHub twin's seed state into JSON matching the provided schema.
-
-Rules:
-1. Anything marked "(exact)" or "exact text" or shown inside an inline code block as a value must be copied character-for-character. Do NOT rephrase, normalize whitespace, or fix typos.
-2. For values described semantically (e.g. "GitHub-conventional colors", "a reasonable description"), pick realistic GitHub-style values.
-3. When the prose says "exactly N" or "and no others", do not add extras.
-4. When a field is not mentioned, omit it — schema defaults will fill in.
-5. Do not invent entities not mentioned. If the prose describes one issue, output exactly one issue.
-6. Issue \`number\` is required and must be set (use #N if the prose says so, otherwise start at 1).
-7. PR \`number\` is optional; set it when the prose says "#N".
-8. Issue \`assignees\` is an array of login strings; use [] when unassigned.
-9. Use fenced code blocks in the prose to indicate the exact content of \`files[].content\`. Preserve trailing newlines verbatim.`;
-export async function compileSeed(prose, opts = {}) {
-    if (!process.env.ANTHROPIC_API_KEY) {
-        throw new Error("ANTHROPIC_API_KEY is not set. Export your Anthropic API key before running `pome compile-seeds`.");
-    }
-    const model = opts.model ?? COMPILER_MODEL;
-    const client = new Anthropic();
-    const t0 = Date.now();
-    const response = await client.messages.parse({
-        model,
-        max_tokens: 8192,
-        system: SYSTEM_PROMPT,
-        messages: [{ role: "user", content: prose }],
-        output_config: { format: zodOutputFormat(seedStateSchema) }
-    });
-    const durationMs = Date.now() - t0;
-    if (!response.parsed_output) {
-        throw new Error(`Compiler returned no parsed_output (stop_reason=${response.stop_reason}). ` +
-            `This usually means the model produced output that failed schema validation.`);
-    }
-    // Re-validate locally to be safe — `parse()` already ran the schema, but
-    // running it again here gives us a stable error site for tests + ensures
-    // downstream code holds a `ParsedSeedState`-shaped value, not `unknown`.
-    const seed = parseGitHubSeedState(response.parsed_output);
-    return {
-        seed,
-        inputTokens: response.usage.input_tokens,
-        outputTokens: response.usage.output_tokens,
-        model,
-        durationMs
-    };
-}

package/dist/src/task/seed-verifier.d.ts

@@ -1 +0,0 @@
-export declare function verifySeedWithTwin(seed: unknown): void;

package/dist/src/task/seed-verifier.js

@@ -1,23 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Layer-3 defense for compile-seeds: boot an in-memory twin and load the
- * generated seed through its real `GitHubDomain.seed()` path. Catches the
- * cross-reference and domain-invariant errors that schema validation alone
- * cannot — e.g. issue.labels referencing a label not in repo.labels, PR head
- * referencing a branch with no files.
- *
- * Throws if the twin rejects the seed; otherwise returns silently.
- */
-import { GitHubDomain, openGitHubCloneDatabase } from "@pome-sh/twin-github";
-export function verifySeedWithTwin(seed) {
-    // `:memory:` SQLite — torn down when this function returns and `db`
-    // goes out of scope. No filesystem side-effects, no cleanup needed.
-    const db = openGitHubCloneDatabase(":memory:");
-    try {
-        new GitHubDomain(db).seed(seed);
-    }
-    catch (err) {
-        throw new Error(`Seed verification failed: the in-memory twin rejected the compiled seed. ` +
-            `Adjust the prose to fix the underlying problem.\n  ${err instanceof Error ? err.message : String(err)}`);
-    }
-}