pome-sh 0.6.6

package/dist/src/cli/compile-seeds.js

@@ -0,0 +1,214 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * `pome compile-seeds` — translate the prose `## Seed State` section of a
+ * scenario markdown file into a sidecar JSON seed via the Claude API, verify
+ * it loads cleanly into the GitHub twin, and write the result next to the
+ * scenario.
+ *
+ * See `docs/agents/scenario-prose-seed.md` for the prose convention and the
+ * defense layers (schema validation, twin-load verification, PR review).
+ */
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { extname, join, resolve } from "node:path";
+import { z } from "zod";
+import { compileSeed, COMPILER_MODEL } from "../scenario/seed-compiler.js";
+import { compileSeedHosted } from "../scenario/seed-compiler-hosted.js";
+import { verifySeedWithTwin } from "../scenario/seed-verifier.js";
+import { exitCodeFor } from "../hosted/errors.js";
+const SIDECAR_META_VERSION = 1;
+export async function runCompileSeeds(target, opts) {
+    const files = await resolveScenarioFiles(target ?? "scenarios");
+    if (files.length === 0) {
+        console.error(`No scenario .md files found at ${target ?? "scenarios"}.`);
+        return 2;
+    }
+    const results = [];
+    for (const file of files) {
+        results.push(await compileOne(file, opts));
+    }
+    for (const r of results) {
+        const stamp = statusStamp(r.status);
+        const tail = r.message ? ` — ${r.message}` : "";
+        const cost = r.inputTokens !== undefined ? ` (${r.inputTokens} in / ${r.outputTokens} out, ${r.durationMs}ms)` : "";
+        console.error(`${stamp} ${r.path}${tail}${cost}`);
+    }
+    const errors = results.filter((r) => r.status === "error");
+    if (errors.length > 0) {
+        console.error(`\n${errors.length} error(s).`);
+        // Propagate the worst hosted exit code (e.g. 3=auth, 4=quota) so CI scripts
+        // can branch on the reason. Falls back to 1 for local-only failures.
+        const worstHosted = errors.reduce((max, r) => Math.max(max, r.exitCode ?? 0), 0);
+        return worstHosted > 0 ? worstHosted : 1;
+    }
+    return 0;
+}
+async function compileOne(scenarioPath, opts) {
+    let markdown;
+    try {
+        markdown = await readFile(scenarioPath, "utf8");
+    }
+    catch (err) {
+        return { path: scenarioPath, status: "error", message: `read failed: ${err.message}` };
+    }
+    const seedText = extractSeedSection(markdown).trim();
+    if (seedText.length === 0) {
+        return { path: scenarioPath, status: "skipped-no-seed", message: "no ## Seed State section" };
+    }
+    // Stripe scenarios use a different schema; v1 only supports github. Check
+    // twin first so Stripe scenarios are silently skipped without surfacing
+    // misleading "still on inline JSON" warnings.
+    const twins = readTwinsFromConfig(markdown);
+    if (twins.length > 0 && !twins.includes("github")) {
+        return {
+            path: scenarioPath,
+            status: "skipped-unsupported-twin",
+            message: `twins=${twins.join(",")} not supported yet`
+        };
+    }
+    // Heuristic: if the section is a fenced JSON block, this scenario is still
+    // on the legacy inline format. Authors must replace the block with prose
+    // before compile-seeds can take over.
+    if (looksLikeJsonBlock(seedText)) {
+        return {
+            path: scenarioPath,
+            status: "skipped-inline-json",
+            message: "still on inline JSON — replace the fenced JSON with prose"
+        };
+    }
+    const sidecarPath = sidecarPathFor(scenarioPath);
+    const proseHash = hashProse(seedText);
+    // Cache check only applies to local compile — hosted callers may have
+    // different model versions than the locally-pinned COMPILER_MODEL, and the
+    // cloud has its own edge cache to avoid duplicate work anyway.
+    if (!opts.force && !opts.hosted && existsSync(sidecarPath)) {
+        const cached = await readSidecarMeta(sidecarPath);
+        if (cached && cached.source_hash === proseHash && cached.model === COMPILER_MODEL) {
+            return { path: scenarioPath, status: "skipped-cached", message: `up-to-date (${sidecarPath})` };
+        }
+    }
+    let result;
+    try {
+        result = opts.hosted
+            ? await compileSeedHosted(seedText, { apiBaseUrl: opts.apiBaseUrl, scenarioPath })
+            : await compileSeed(seedText);
+    }
+    catch (err) {
+        return {
+            path: scenarioPath,
+            status: "error",
+            message: `compile failed: ${err.message}`,
+            exitCode: opts.hosted ? exitCodeFor(err) : undefined
+        };
+    }
+    try {
+        verifySeedWithTwin(result.seed);
+    }
+    catch (err) {
+        return { path: scenarioPath, status: "error", message: err.message };
+    }
+    const payload = {
+        _meta: {
+            version: SIDECAR_META_VERSION,
+            source_hash: proseHash,
+            model: result.model,
+            compiled_at: new Date().toISOString()
+        },
+        ...result.seed
+    };
+    await writeFile(sidecarPath, JSON.stringify(payload, null, 2) + "\n");
+    return {
+        path: scenarioPath,
+        status: "compiled",
+        message: `→ ${sidecarPath}`,
+        inputTokens: result.inputTokens,
+        outputTokens: result.outputTokens,
+        durationMs: result.durationMs
+    };
+}
+function extractSeedSection(markdown) {
+    // Mirrors the H2-section logic in parseScenario.ts: find the "## Seed State"
+    // heading and return everything until the next H2.
+    const headingRegex = /^##\s+seed state\s*$/im;
+    const m = markdown.match(headingRegex);
+    if (!m)
+        return "";
+    const start = m.index + m[0].length;
+    const rest = markdown.slice(start);
+    const nextHeading = rest.match(/^##\s+/m);
+    return nextHeading ? rest.slice(0, nextHeading.index).trim() : rest.trim();
+}
+function readTwinsFromConfig(markdown) {
+    // Find the `## Config` heading and read everything until the next `##` or
+    // end of file. JS regex has no `\Z`, so we use a lookahead-or-EOF approach.
+    const headingMatch = markdown.match(/^##\s+config\s*$/im);
+    if (!headingMatch)
+        return [];
+    const rest = markdown.slice(headingMatch.index + headingMatch[0].length);
+    const nextHeading = rest.match(/^##\s+/m);
+    const block = nextHeading ? rest.slice(0, nextHeading.index) : rest;
+    const twinsLine = block.match(/^\s*twins\s*:\s*\[(.+?)\]/m);
+    if (!twinsLine)
+        return [];
+    return twinsLine[1]
+        .split(",")
+        .map((s) => s.trim().replace(/^["']|["']$/g, ""))
+        .filter(Boolean);
+}
+function looksLikeJsonBlock(input) {
+    return /^```(?:json)?\s*\{/m.test(input.trim());
+}
+function sidecarPathFor(scenarioPath) {
+    const ext = extname(scenarioPath);
+    return scenarioPath.slice(0, -ext.length) + ".seed.json";
+}
+function hashProse(input) {
+    return "sha256:" + createHash("sha256").update(input.replace(/\s+$/g, "")).digest("hex");
+}
+const sidecarMetaSchema = z.object({
+    _meta: z.object({
+        version: z.number().int(),
+        source_hash: z.string(),
+        model: z.string(),
+        compiled_at: z.string()
+    })
+});
+async function readSidecarMeta(path) {
+    try {
+        const raw = await readFile(path, "utf8");
+        const parsed = sidecarMetaSchema.safeParse(JSON.parse(raw));
+        if (!parsed.success)
+            return null;
+        return { source_hash: parsed.data._meta.source_hash, model: parsed.data._meta.model };
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveScenarioFiles(target) {
+    const abs = resolve(target);
+    if (!existsSync(abs))
+        throw new Error(`Path not found: ${target}`);
+    const st = await stat(abs);
+    if (st.isFile())
+        return [abs];
+    const entries = await readdir(abs);
+    return entries.filter((e) => e.endsWith(".md")).sort().map((e) => join(abs, e));
+}
+function statusStamp(status) {
+    switch (status) {
+        case "compiled":
+            return "OK  ";
+        case "skipped-cached":
+            return "skip";
+        case "skipped-no-seed":
+            return "skip";
+        case "skipped-unsupported-twin":
+            return "skip";
+        case "skipped-inline-json":
+            return "warn";
+        case "error":
+            return "FAIL";
+    }
+}

package/dist/src/cli/credentials.d.ts

@@ -0,0 +1,28 @@
+export interface ResolveCredentialsInput {
+    /** Optional. If set, wins over any stored `api_url`. Callers should pass
+     *  the resolved `--api-url` flag value (which Commander defaults to the
+     *  POME_API_URL env var or `DEFAULT_CONTROL_PLANE_URL`). Leave undefined
+     *  to fall back to the stored value. */
+    apiBaseUrl?: string;
+    credentialsPath?: string;
+}
+export interface ResolvedCredentials {
+    apiKey: string;
+    apiBaseUrl: string;
+}
+export interface CredentialsFile {
+    api_key?: string;
+    api_url?: string;
+    dashboard_url?: string;
+    team_id?: string;
+    created_at?: string;
+}
+export declare function defaultCredentialsPath(): string;
+/** Store after successful login: Keychain on macOS when possible, else file. */
+export declare function persistCredentialsAfterLogin(credentials: Required<Pick<CredentialsFile, "api_key" | "api_url" | "dashboard_url" | "team_id">>, path?: string): Promise<{
+    stored: "keychain" | "file";
+    path?: string;
+}>;
+export declare function clearLocalCredentials(path?: string): Promise<void>;
+export declare function resolveCredentials(input: ResolveCredentialsInput): Promise<ResolvedCredentials>;
+export declare function writeCredentialsFile(credentials: Required<Pick<CredentialsFile, "api_key" | "api_url" | "dashboard_url" | "team_id">>, path?: string): Promise<void>;

package/dist/src/cli/credentials.js

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: Apache-2.0
+import { chmod, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { HostedAuthError } from "../hosted/errors.js";
+import { deleteKeychainCredentials, keychainSupported, readKeychainCredentials, writeKeychainCredentials, } from "./keychain.js";
+const DEFAULT_PATH = () => join(homedir(), ".pome", "credentials.json");
+export function defaultCredentialsPath() {
+    return DEFAULT_PATH();
+}
+/** Store after successful login: Keychain on macOS when possible, else file. */
+export async function persistCredentialsAfterLogin(credentials, path = DEFAULT_PATH()) {
+    if (keychainSupported()) {
+        try {
+            await writeKeychainCredentials(credentials);
+            try {
+                await rm(path, { force: true });
+            }
+            catch {
+                /* ignore */
+            }
+            return { stored: "keychain" };
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    await writeCredentialsFile(credentials, path);
+    return { stored: "file", path };
+}
+export async function clearLocalCredentials(path = DEFAULT_PATH()) {
+    await deleteKeychainCredentials();
+    try {
+        await rm(path, { force: true });
+    }
+    catch {
+        /* ignore */
+    }
+}
+export async function resolveCredentials(input) {
+    const envKey = process.env.POME_API_KEY;
+    if (envKey && envKey.trim().length > 0) {
+        const apiBaseUrl = resolveApiBaseUrl(input.apiBaseUrl, undefined);
+        return { apiKey: envKey.trim(), apiBaseUrl };
+    }
+    const keychain = await readKeychainCredentials();
+    if (keychain &&
+        typeof keychain.api_key === "string" &&
+        keychain.api_key.trim().length > 0) {
+        return {
+            apiKey: keychain.api_key.trim(),
+            apiBaseUrl: resolveApiBaseUrl(input.apiBaseUrl, keychain.api_url),
+        };
+    }
+    const path = input.credentialsPath ?? DEFAULT_PATH();
+    let raw;
+    try {
+        await assertSafeCredentialFileMode(path);
+        raw = await readFile(path, "utf8");
+    }
+    catch (err) {
+        if (err instanceof Error &&
+            err.code === "ENOENT") {
+            // F0-5c — surface this as a HostedAuthError so the top-level
+            // exit-code mapper returns the documented 3 ("auth"). The previous
+            // plain `Error` propagated to Commander's fallback and got
+            // demoted to exit 2 ("twin/orch").
+            throw new HostedAuthError("Hosted mode requires authentication. Run `pome login`, set POME_API_KEY in your " +
+                `environment, or sign in on macOS to store credentials in Keychain. Expected file: ${path}.`);
+        }
+        throw err;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`${path} is not valid JSON.`);
+    }
+    if (typeof parsed.api_key !== "string" ||
+        parsed.api_key.trim().length === 0) {
+        throw new Error(`${path} is missing "api_key".`);
+    }
+    return {
+        apiKey: parsed.api_key.trim(),
+        apiBaseUrl: resolveApiBaseUrl(input.apiBaseUrl, parsed.api_url),
+    };
+}
+function resolveApiBaseUrl(callerInput, storedApiUrl) {
+    const candidate = callerInput ?? storedApiUrl;
+    if (typeof candidate !== "string" || candidate.trim().length === 0) {
+        throw new Error("Refusing to resolve hosted credentials: no apiBaseUrl supplied and no stored api_url found.");
+    }
+    return normalizeBaseUrl(candidate);
+}
+async function assertSafeCredentialFileMode(path) {
+    const st = await stat(path);
+    const perm = st.mode & 0o777;
+    if ((perm & 0o077) !== 0) {
+        throw new Error(`Refusing to read credentials at ${path}: mode 0${perm.toString(8)} is too permissive (group/other bits must be 0). Run: chmod 600 ${path}`);
+    }
+}
+export async function writeCredentialsFile(credentials, path = DEFAULT_PATH()) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, `${JSON.stringify({
+        ...credentials,
+        created_at: new Date().toISOString(),
+    }, null, 2)}\n`, { mode: 0o600 });
+    await chmod(path, 0o600);
+}
+function normalizeBaseUrl(raw) {
+    return new URL(raw).toString().replace(/\/$/, "");
+}

package/dist/src/cli/default-task.d.ts

@@ -0,0 +1,38 @@
+/** Design default k for "run yours" (moment 05: "Their agent · k=5"). */
+export declare const DEFAULT_TASK_TRIALS = 5;
+export declare const DEFAULT_TASK_DIR = "scenarios";
+export declare const DEFAULT_TASK_FILENAME = "first-run-demo.md";
+export interface DefaultTaskResolution {
+    /** Absolute path of the task markdown to run. */
+    path: string;
+    /** Project-relative path, for terminal copy. */
+    relativePath: string;
+    /** True when this call dropped the copy (first use). */
+    copied: boolean;
+    /** False when the packaged md's Config fence couldn't be located, so the
+     *  k=5 default could not be pinned into the copy. */
+    trialsApplied: boolean;
+}
+/** Pin `runs: N` inside the ## Config yaml fence. No-op (applied=true) when
+ *  the fence already sets runs; applied=false when no fence exists. */
+export declare function withDefaultTrials(source: string, runs?: number): {
+    content: string;
+    applied: boolean;
+};
+/** Swap the packaged maintainer preamble (the CANONICAL/lockstep warning —
+ *  true of the packaged md, wrong and confusing in the user's copy) for the
+ *  user-facing comment. When no preamble exists, insert after the H1. */
+export declare function withUserCopyComment(source: string): string;
+/**
+ * Resolve the bare-`pome run` default task, dropping the user copy on first
+ * use. Never clobbers an existing scenarios/first-run-demo.md — that file is
+ * the user's (possibly edited) task from a prior bare run.
+ */
+export declare function ensureDefaultTask(cwd?: string): Promise<DefaultTaskResolution>;
+export declare function copyAnnounceLine(res: DefaultTaskResolution): string;
+/** Printed when the Config fence couldn't be found in the packaged md, so
+ *  the copy runs k=1 unless the user passes -n (honest, never silent). */
+export declare function trialsPinFallbackLine(): string;
+/** Moment-05 frame ("that was ours, run yours"), printed once the doctor
+ *  gate and credential resolution have passed, ahead of the run output. */
+export declare function runYoursFrameLines(): string[];

package/dist/src/cli/default-task.js

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: Apache-2.0
+// FDRS-645 — "run yours": bare `pome run` (no path) defaults to the demo
+// task, closing the demo → run-yours seam (north-star moment 05: their
+// agent, k=5, the same task they just watched the demo agent attempt).
+//
+// The default is a USER-VISIBLE COPY at scenarios/first-run-demo.md, dropped
+// on first use from the packaged demo task (src/demo/first-run-demo.md plus
+// its compiled seed sidecar — the client parser requires the sidecar when a
+// prose ## Seed State section is present). The copy — never the canonical
+// packaged md — gains `runs: 5`, so the design's k=5 default rides the
+// existing scenario-config `runs` mechanism (an explicit -n still wins) and
+// the packaged md stays byte-identical to the server-owned judge definition
+// regenerated from it (pome-cloud#209 lockstep).
+//
+// The packaged md's maintainer comment (the CANONICAL/lockstep warning) is
+// swapped for a user-facing one in the copy: the copy is the user's file —
+// authenticated runs are judged against the criteria declared in it.
+import { constants, existsSync, statSync } from "node:fs";
+import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { DEMO_TASK_NAME, demoTaskPath } from "../demo/task.js";
+import { HostedUsageError } from "../hosted/errors.js";
+/** Design default k for "run yours" (moment 05: "Their agent · k=5"). */
+export const DEFAULT_TASK_TRIALS = 5;
+export const DEFAULT_TASK_DIR = "scenarios";
+export const DEFAULT_TASK_FILENAME = `${DEMO_TASK_NAME}.md`;
+const USER_COPY_COMMENT = `<!--
+Copied into your project by \`pome run\` — the "run yours" default: the same
+task the demo agent just attempted, now for your agent. This copy is yours.
+Edit the prompt/criteria freely (your runs are judged against the criteria
+declared in this file), or delete it and the next bare \`pome run\` re-copies
+the original. Config pins runs: ${DEFAULT_TASK_TRIALS} — an explicit -n overrides it.
+-->`;
+/** The ## Config section's fenced yaml block: (heading + everything up to
+ *  and including the opening fence line)(fence body)(closing fence). The
+ *  gap between heading and fence never crosses into another ## section. */
+const CONFIG_FENCE_RE = /(##[ \t]*config[^\n]*\n(?:(?!\n##[ \t])[\s\S])*?```(?:yaml)?[ \t]*\n)([\s\S]*?)(```)/i;
+/** Pin `runs: N` inside the ## Config yaml fence. No-op (applied=true) when
+ *  the fence already sets runs; applied=false when no fence exists. */
+export function withDefaultTrials(source, runs = DEFAULT_TASK_TRIALS) {
+    const match = CONFIG_FENCE_RE.exec(source);
+    if (!match)
+        return { content: source, applied: false };
+    const [whole, head, body, tail] = match;
+    if (/^[ \t]*runs[ \t]*:/m.test(body))
+        return { content: source, applied: true };
+    const glue = body === "" || body.endsWith("\n") ? "" : "\n";
+    const content = source.slice(0, match.index) +
+        head +
+        body +
+        `${glue}runs: ${runs}\n` +
+        tail +
+        source.slice(match.index + whole.length);
+    return { content, applied: true };
+}
+/** Swap the packaged maintainer preamble (the CANONICAL/lockstep warning —
+ *  true of the packaged md, wrong and confusing in the user's copy) for the
+ *  user-facing comment. When no preamble exists, insert after the H1. */
+export function withUserCopyComment(source) {
+    const commentRe = /<!--[\s\S]*?-->/;
+    const comment = commentRe.exec(source);
+    const firstSection = source.search(/^##[ \t]/m);
+    if (comment && (firstSection === -1 || comment.index < firstSection)) {
+        return (source.slice(0, comment.index) +
+            USER_COPY_COMMENT +
+            source.slice(comment.index + comment[0].length));
+    }
+    const h1 = /^#[ \t].+$/m.exec(source);
+    if (!h1)
+        return `${USER_COPY_COMMENT}\n\n${source}`;
+    const insertAt = h1.index + h1[0].length;
+    return `${source.slice(0, insertAt)}\n\n${USER_COPY_COMMENT}${source.slice(insertAt)}`;
+}
+/**
+ * Resolve the bare-`pome run` default task, dropping the user copy on first
+ * use. Never clobbers an existing scenarios/first-run-demo.md — that file is
+ * the user's (possibly edited) task from a prior bare run.
+ */
+export async function ensureDefaultTask(cwd = process.cwd()) {
+    const relativePath = join(DEFAULT_TASK_DIR, DEFAULT_TASK_FILENAME);
+    const target = join(cwd, relativePath);
+    if (existsSync(target)) {
+        return { path: target, relativePath, copied: false, trialsApplied: true };
+    }
+    // A `scenarios` path that exists as a FILE would make the mkdir below
+    // throw a raw EEXIST (exit 2). Name the actual problem as a usage error.
+    const dir = join(cwd, DEFAULT_TASK_DIR);
+    if (existsSync(dir) && !statSync(dir).isDirectory()) {
+        throw new HostedUsageError(`\`${DEFAULT_TASK_DIR}\` exists as a file in this project — the bare \`pome run\` default drops its task into a ${DEFAULT_TASK_DIR}/ directory. Move the file aside, or pass a task path explicitly.`);
+    }
+    const packagedMd = demoTaskPath();
+    const packagedSeed = packagedMd.replace(/\.md$/, ".seed.json");
+    if (!existsSync(packagedSeed)) {
+        throw new Error(`Packaged demo seed not found at ${packagedSeed}. This is a packaging ` +
+            "bug — scripts/copy-prompts.mjs ships src/demo/ (task md + seed " +
+            "sidecar) into dist/.");
+    }
+    const raw = await readFile(packagedMd, "utf8");
+    const pinned = withDefaultTrials(withUserCopyComment(raw));
+    await mkdir(dir, { recursive: true });
+    // Seed first, md last: the md's presence is the commit point (the parser
+    // hard-requires the sidecar once the md's prose ## Seed State is seen), so
+    // a crash between the two writes never strands a half-usable default.
+    // COPYFILE_EXCL: NO file under scenarios/ is ever overwritten — a user who
+    // deleted only the md but kept an edited seed keeps their seed.
+    try {
+        await copyFile(packagedSeed, target.replace(/\.md$/, ".seed.json"), constants.COPYFILE_EXCL);
+    }
+    catch (err) {
+        if (err.code !== "EEXIST")
+            throw err;
+    }
+    try {
+        // "wx": never overwrite — if a concurrent run raced the copy in, theirs
+        // wins and this invocation just runs it.
+        await writeFile(target, pinned.content, { encoding: "utf8", flag: "wx" });
+    }
+    catch (err) {
+        if (err.code === "EEXIST") {
+            return { path: target, relativePath, copied: false, trialsApplied: true };
+        }
+        throw err;
+    }
+    return { path: target, relativePath, copied: true, trialsApplied: pinned.applied };
+}
+export function copyAnnounceLine(res) {
+    return `copied the demo task into ${res.relativePath} — this copy is yours to edit`;
+}
+/** Printed when the Config fence couldn't be found in the packaged md, so
+ *  the copy runs k=1 unless the user passes -n (honest, never silent). */
+export function trialsPinFallbackLine() {
+    return `couldn't pin runs: ${DEFAULT_TASK_TRIALS} in the copy — pass -n ${DEFAULT_TASK_TRIALS} for the design default`;
+}
+/** Moment-05 frame ("that was ours, run yours"), printed once the doctor
+ *  gate and credential resolution have passed, ahead of the run output. */
+export function runYoursFrameLines() {
+    return [
+        `run yours · ${DEMO_TASK_NAME}`,
+        "that was ours — now it's your agent on the same task the demo just ran.",
+    ];
+}

package/dist/src/cli/defaults.d.ts

@@ -0,0 +1,4 @@
+/** Production defaults (override with env / CLI flags at call sites). */
+export declare const DEFAULT_CONTROL_PLANE_URL = "https://api.pome.sh";
+export declare const DEFAULT_DASHBOARD_URL = "https://app.pome.sh";
+export declare const DEFAULT_DOCS_SITE_ORIGIN = "https://docs.pome.sh";

package/dist/src/cli/defaults.js

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+/** Production defaults (override with env / CLI flags at call sites). */
+export const DEFAULT_CONTROL_PLANE_URL = "https://api.pome.sh";
+export const DEFAULT_DASHBOARD_URL = "https://app.pome.sh";
+export const DEFAULT_DOCS_SITE_ORIGIN = "https://docs.pome.sh";

package/dist/src/cli/docs-topics.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Static index of public Mintlify pages on docs.pome.sh — avoids scraping HTML.
+ * The authored docs live in the `pome` repo and publish through Mintlify; this
+ * package keeps only topic metadata for URL navigation.
+ */
+export interface DocsTopic {
+    id: string;
+    title: string;
+    /** Path on the docs site, e.g. /getting-started */
+    path: string;
+    keywords: string[];
+}
+export declare const DOCS_TOPICS: DocsTopic[];

package/dist/src/cli/docs-topics.js

@@ -0,0 +1,116 @@
+export const DOCS_TOPICS = [
+    {
+        id: "pome",
+        title: "Pome",
+        path: "/introduction",
+        keywords: ["overview", "what is pome", "platform", "agents"],
+    },
+    {
+        id: "getting-started",
+        title: "Quickstart",
+        path: "/getting-started",
+        keywords: ["install", "quickstart", "setup", "begin"],
+    },
+    {
+        id: "how-pome-works",
+        title: "How Pome works",
+        path: "/docs/how-pome-works",
+        keywords: ["twins", "scenarios", "runs", "scoring", "artifacts", "loop"],
+    },
+    {
+        id: "skills-setup",
+        title: "/setup",
+        path: "/docs/skills/setup",
+        keywords: ["pome-setup", "setup", "/setup", "register", "wire"],
+    },
+    {
+        id: "skills-test",
+        title: "/test-with-pome",
+        path: "/docs/skills/test-with-pome",
+        keywords: ["pome-test", "test-with-pome", "/test-with-pome", "run scenarios", "eval"],
+    },
+    {
+        id: "dashboard",
+        title: "Pome Dashboard",
+        path: "/docs/dashboard",
+        keywords: ["runs", "agents", "clones", "judge", "web"],
+    },
+    {
+        id: "twins",
+        title: "Twins overview",
+        path: "/docs/twins/index",
+        keywords: ["sandbox", "digital twin", "hosted"],
+    },
+    {
+        id: "github",
+        title: "GitHub twin",
+        path: "/docs/twins/github",
+        keywords: ["git", "repo", "issues", "mcp", "scenarios"],
+    },
+    {
+        id: "stripe",
+        title: "Stripe twin",
+        path: "/docs/twins/stripe",
+        keywords: ["payments", "x402", "refund", "payment intent", "stripe"],
+    },
+    {
+        id: "slack",
+        title: "Slack twin",
+        path: "/docs/twins/slack",
+        keywords: ["messaging", "channels", "workspace", "slack", "exfiltration"],
+    },
+    {
+        id: "cli",
+        title: "Command Line Interface",
+        path: "/docs/cli",
+        keywords: ["commands", "flags", "pome run", "reference"],
+    },
+    {
+        id: "cli-run",
+        title: "pome run",
+        path: "/docs/cli/run",
+        keywords: ["run", "scenario", "agent", "flags", "artifacts", "default", "demo task", "run yours"],
+    },
+    {
+        id: "cli-session",
+        title: "pome session",
+        path: "/docs/cli/session",
+        keywords: ["session", "hosted", "sandbox", "twin"],
+    },
+    {
+        id: "cli-scenarios",
+        title: "pome scenarios",
+        path: "/docs/cli/scenarios",
+        keywords: ["scenarios", "catalog", "copy", "library", "twin"],
+    },
+    {
+        id: "cli-compile-seeds",
+        title: "pome compile-seeds",
+        path: "/docs/cli/compile-seeds",
+        keywords: ["compile-seeds", "seed", "sidecar", "compiler", "anthropic"],
+    },
+    {
+        id: "cli-inspect",
+        title: "pome inspect",
+        path: "/docs/cli/inspect",
+        keywords: ["inspect", "score", "trace", "artifacts", "verdicts"],
+    },
+    {
+        id: "cli-init",
+        title: "pome init",
+        path: "/docs/cli/init",
+        keywords: ["init", "scaffold", "pome.config.json", "project"],
+    },
+    {
+        id: "troubleshooting",
+        title: "Troubleshooting",
+        path: "/docs/troubleshooting",
+        keywords: ["errors", "help", "fix", "debug"],
+    },
+    {
+        id: "changelog",
+        title: "Changelog",
+        path: "/changelog",
+        keywords: ["release", "version", "news"],
+    },
+];