@pome-sh/cli 0.12.0 → 0.14.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "package": "pome-sh",
-  "version": "0.12.0",
-  "git_sha": "255ba763f78f424368749baed6aa19b5a3f5c444",
-  "build_time": "2026-07-29T18:54:35.706Z"
+  "version": "0.14.0",
+  "git_sha": "b98c3e5e10075ddd82165517117cf1deeea524b4",
+  "build_time": "2026-07-30T15:54:30.489Z"
 }

package/dist/src/cli/checks-add.js

@@ -21,6 +21,7 @@ import { readConfigTwins } from "../task/parseTask.js";
 import { resolveSeams } from "./agent-resolver.js";
 import { SUBSTRATE_HELP, checksFor, displaySentence, findCheck, localDigest, pinnedVersion, twinOf, } from "./checks.js";
 import { resolveCredentials } from "./credentials.js";
+import { auditCodeCriteria, formatBindingReport } from "./criterion-binding.js";
 export function parseArgFlags(pairs) {
     const args = {};
     for (const pair of pairs) {
@@ -233,4 +234,19 @@ export async function runChecksAddCommand(file, opts) {
     console.log(picked.polarity(args) === "negative"
         ? "  negative — this should PASS on an untouched seed; only the examinee can break it."
         : "  positive — this should FAIL on an untouched seed; the examinee has to make it true.");
+    // F-1134 — audit the WHOLE block, not just the line just appended. A
+    // hand-edited criterion binds nothing and leaves the score denominator in
+    // silence, and this is the one moment a local-only author is looking at the
+    // file. Audits `next`, so the sentence just written is included and has to come
+    // back bound — it was rendered from a declaration, so it always does.
+    //
+    // WARN, never refuse, and after the summary rather than before it: declining to
+    // append because of an unrelated pre-existing line would be obnoxious and would
+    // tempt authors back to typing sentences by hand, which is the defect. Deliberately
+    // does not touch `process.exitCode` — `pome checks lint` is the surface that fails.
+    const { findings } = auditCodeCriteria(next);
+    if (findings.length > 0) {
+        console.error("");
+        console.error(formatBindingReport(findings, file));
+    }
 }

package/dist/src/cli/checks-lint.d.ts

@@ -0,0 +1 @@
+export declare function runChecksLintCommand(files: string[]): Promise<void>;

package/dist/src/cli/checks-lint.js

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * `pome checks lint <file...>` — do this task's `[code]` criteria bind to a check
+ * their twin declares? (F-1134)
+ *
+ * `pome checks add` warns about the block it writes into, which covers an author
+ * mid-edit. This covers the rest: a file already on disk, a whole directory of
+ * them via a shell glob, and a builder's own CI. Before this, the only doors that
+ * refused a non-binding criterion were `save_task` and `validate_task` over the
+ * hosted MCP and the corpus gate in this repo's CI — so a builder authoring tasks
+ * in their own repo had no way to ask the question at all, and their first signal
+ * was a run whose score had quietly dropped a criterion.
+ *
+ * OFFLINE. Reads only the CLI's own pinned declarations, so the answer does not
+ * depend on reaching the cloud — which is the point, since the gap this closes
+ * lives in exactly the mode where the cloud is not there.
+ */
+import { readFile } from "node:fs/promises";
+import { auditCodeCriteria, formatBindingReport } from "./criterion-binding.js";
+function count(n, singular, plural) {
+    return `${n} [code] ${n === 1 ? singular : plural}`;
+}
+export async function runChecksLintCommand(files) {
+    let unreadable = false;
+    let failing = false;
+    for (const file of files) {
+        let source;
+        try {
+            source = await readFile(file, "utf8");
+        }
+        catch {
+            // Never a silent pass: a file we could not open is the one case where
+            // saying nothing would read as a clean bill.
+            console.error(`Could not read ${file}.`);
+            unreadable = true;
+            continue;
+        }
+        const { bound, unanswerable, findings } = auditCodeCriteria(source);
+        if (findings.length > 0) {
+            console.error(formatBindingReport(findings, file));
+            console.error("");
+            failing = true;
+            continue;
+        }
+        const notes = [`${count(bound, "criterion binds", "criteria bind")}`];
+        if (unanswerable.length > 0) {
+            const twins = [...new Set(unanswerable.map((c) => c.twin))].sort();
+            notes.push(`${unanswerable.length} unanswerable (${twins.join(", ")} ` +
+                `declare${twins.length === 1 ? "s" : ""} no checks yet)`);
+        }
+        console.log(`✓ ${file} — ${notes.join(", ")}`);
+    }
+    // A file we could not read outranks a criterion that will not be graded: one is
+    // "the question was not asked", the other is an answer.
+    if (unreadable)
+        process.exitCode = 2;
+    else if (failing)
+        process.exitCode = 1;
+}

package/dist/src/cli/checks.js

@@ -12,14 +12,16 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { checksDigest, templateSlots } from "@pome-sh/sdk/checks";
 import { GITHUB_CHECKS } from "@pome-sh/twin-github/checks";
+import { SLACK_CHECKS } from "@pome-sh/twin-slack/checks";
 import { resolvePackageRoot } from "./resolve-package-root.js";
 const REGISTRIES = {
     github: GITHUB_CHECKS,
+    slack: SLACK_CHECKS,
 };
 // Twins that EXIST but declare nothing yet. Listed separately so `pome checks
-// slack` answers "not migrated yet" instead of "no such twin" — a typo and an
-// empty vocabulary are different facts.
-const TWINS_WITHOUT_CHECKS = ["slack", "stripe", "gmail", "linear"];
+// stripe` answers "not migrated yet" instead of "no such twin" — a typo and an
+// empty vocabulary are different facts. F-1126 removed slack.
+const TWINS_WITHOUT_CHECKS = ["stripe", "gmail", "linear"];
 export function twinsWithChecks() {
     return Object.keys(REGISTRIES).sort();
 }
@@ -147,4 +149,12 @@ export async function runChecksCommand(twinArg, opts) {
         console.log(`    ${dim(`pome checks add <file> --check ${def.id} ${argFlagsFor(def)}`)}`);
         console.log("");
     }
+    // F-1126 — the digest, shown rather than only computed.
+    //
+    // `checks add` already refuses to write a sentence when this disagrees with
+    // the control plane's (`checks-add.ts`), and that refusal is correct but
+    // opaque: an author who hits it has no way to see WHICH side moved. Printing
+    // it here turns "the digest handshake refuses" into something a user can
+    // compare against `GET /v1/checks?twin=<twin>` themselves.
+    console.log(dim(`digest ${localDigest(twin)}`));
 }

package/dist/src/cli/criterion-binding.d.ts

@@ -0,0 +1,41 @@
+import { type CodeCriterion } from "../task/parseTask.js";
+export type CriterionBinding = {
+    kind: "bound";
+    checkId: string;
+} | {
+    kind: "corrupted";
+    checkId: string;
+    slot: string;
+    value: string;
+    example: string;
+} | {
+    kind: "unbound";
+} | {
+    kind: "no-vocabulary";
+};
+export declare function bindCriterion(criterion: CodeCriterion): CriterionBinding;
+export interface BindingFinding {
+    criterion: CodeCriterion;
+    binding: Extract<CriterionBinding, {
+        kind: "corrupted" | "unbound";
+    }>;
+}
+export interface BindingAudit {
+    /** How many criteria bind. A count, not a list — a pass line needs the number. */
+    bound: number;
+    /** Criteria whose twin has not migrated its vocabulary. NEITHER a pass nor a
+     *  failure: this CLI holds no declaration to judge them by, and folding them
+     *  into either bucket would be the false clean bill the vocabulary exists to
+     *  remove. Kept separate so a caller has to decide what to say about them. */
+    unanswerable: CodeCriterion[];
+    /** The criteria that will not be graded. */
+    findings: BindingFinding[];
+}
+/** Classify every `[code]` criterion in a task file. Three buckets, because the
+ *  interesting one is the third and lumping the second into the first is how a
+ *  tool ends up promising more than it checked. */
+export declare function auditCodeCriteria(markdown: string): BindingAudit;
+/** The author-facing report, one block per finding. Names the file so it stands
+ *  on its own in a scrollback that already carries a write summary, and echoes
+ *  each sentence verbatim so the author can find the line. */
+export declare function formatBindingReport(findings: BindingFinding[], file: string): string;

package/dist/src/cli/criterion-binding.js

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * F-1134 — does a `[code]` criterion bind to a check its twin declares?
+ *
+ * A criterion that binds nothing is not an error anywhere: the grader skips it
+ * and the score is computed over the rest, so the denominator moves for a reason
+ * nobody wrote down. Three doors already refuse one — `save_task` and
+ * `validate_task` over the hosted MCP, and the corpus gate in CI — and a
+ * local-only author authoring tasks in their own repo reaches none of them.
+ * `pome` is meant to work offline, so a gap that only appears offline is a gap.
+ *
+ * OFFLINE BY CONSTRUCTION. Nothing here consults the cloud. Binding is a
+ * question about the sentence and the CLI's own pinned declaration, and any
+ * answer that needed the network would inherit F-1132's skew problem in the one
+ * mode where this gap lives. The digest handshake in `checks-add.ts` remains the
+ * place where the two pins are compared — that is a question about WRITING a
+ * sentence, and it is a different question from whether one already binds.
+ *
+ * Resolution comes from `./checks.js` and nowhere else. That module is already a
+ * deliberate SECOND resolution point (pome-cloud's registry is the first); a
+ * third would be a third thing that can silently resolve nothing, which is
+ * F-989's lesson.
+ */
+import { checkNearMissPattern, checkPattern, templateSlots } from "@pome-sh/sdk/checks";
+import { readCodeCriteria } from "../task/parseTask.js";
+import { checksFor } from "./checks.js";
+export function bindCriterion(criterion) {
+    const declared = checksFor(criterion.twin);
+    if (declared.length === 0)
+        return { kind: "no-vocabulary" };
+    const text = criterion.text.trim();
+    // EVERY exact pattern first, across the whole twin, before any near-miss. A
+    // near-miss opens each slot to `.+?`, so one check's near-miss can swallow
+    // another's perfectly valid sentence; interleaving the two passes would report
+    // a criterion that grades fine as a corrupted instance of its neighbour.
+    for (const def of declared) {
+        if (checkPattern(def).test(text))
+            return { kind: "bound", checkId: def.id };
+    }
+    for (const def of declared) {
+        const near = text.match(checkNearMissPattern(def));
+        if (!near)
+            continue;
+        const offender = firstInvalidSlot(def, near);
+        // A near-miss whose every slot value is valid would have matched the exact
+        // pattern, unless the non-greedy split landed elsewhere than the typed one
+        // would. Keep looking rather than reporting a corruption we cannot name.
+        if (offender)
+            return { kind: "corrupted", checkId: def.id, ...offender };
+    }
+    return { kind: "unbound" };
+}
+/** Which slot the sentence filled with something its type rejects. Group `i + 1`
+ *  is slot `i` — `defineCheck` asserts every slot pattern is group-free so those
+ *  indices cannot shift, and the near-miss pattern's `.+?` is group-free too. */
+function firstInvalidSlot(def, match) {
+    const { params } = templateSlots(def.template);
+    for (const [index, name] of params.entries()) {
+        const type = def.params[name];
+        const value = match[index + 1];
+        if (!new RegExp(`^${type.pattern}$`).test(value)) {
+            return { slot: name, value, example: type.example };
+        }
+    }
+    return undefined;
+}
+/** Classify every `[code]` criterion in a task file. Three buckets, because the
+ *  interesting one is the third and lumping the second into the first is how a
+ *  tool ends up promising more than it checked. */
+export function auditCodeCriteria(markdown) {
+    const audit = { bound: 0, unanswerable: [], findings: [] };
+    for (const criterion of readCodeCriteria(markdown)) {
+        const binding = bindCriterion(criterion);
+        if (binding.kind === "bound")
+            audit.bound += 1;
+        else if (binding.kind === "no-vocabulary")
+            audit.unanswerable.push(criterion);
+        else
+            audit.findings.push({ criterion, binding });
+    }
+    return audit;
+}
+/** The author-facing report, one block per finding. Names the file so it stands
+ *  on its own in a scrollback that already carries a write summary, and echoes
+ *  each sentence verbatim so the author can find the line. */
+export function formatBindingReport(findings, file) {
+    const count = findings.length;
+    const blocks = findings.flatMap(({ criterion, binding }) => [
+        `    - ${criterion.marker} ${criterion.text}`,
+        ...(binding.kind === "unbound"
+            ? [
+                `      Binds nothing ${criterion.twin} declares, so the grader skips it and`,
+                `      the score is computed without it.`,
+            ]
+            : [
+                `      Says ${binding.checkId}, but \`${binding.slot}\` = ${JSON.stringify(binding.value)} is not a valid`,
+                `      value for that slot (e.g. ${binding.example}). It will be reported as`,
+                `      corrupted_check_instance:${binding.checkId}.`,
+            ]),
+        "",
+    ]);
+    const twins = [...new Set(findings.map((f) => f.criterion.twin))].sort();
+    return [
+        `⚠ ${file} — ${count} [code] ${count === 1 ? "criterion" : "criteria"} will not be graded:`,
+        "",
+        ...blocks,
+        `  Run ${twins.map((t) => `\`pome checks ${t}\``).join(", ")} to see the sentences that do bind,`,
+        `  then \`pome checks add\` to write one — pome renders the English, so a`,
+        `  criterion it wrote cannot fail to bind.`,
+    ].join("\n");
+}

package/dist/src/cli/main.js

@@ -19,6 +19,7 @@ import { runCompileSeeds } from "./compile-seeds.js";
 import { runTasksCommand } from "./tasks.js";
 import { runChecksCommand } from "./checks.js";
 import { runChecksAddCommand } from "./checks-add.js";
+import { runChecksLintCommand } from "./checks-lint.js";
 import { runEvalCommand } from "./eval.js";
 import { copyAnnounceLine, ensureDefaultTask, runYoursFrameLines, trialsPinFallbackLine, } from "./default-task.js";
 import { findTwin, runnableTasks, } from "./tasks-catalog.js";
@@ -273,6 +274,17 @@ export function createProgram() {
             apiBaseUrl: opts.apiUrl,
         });
     });
+    // F-1134 — the read-only half. `checks add` warns about the block it writes
+    // into, which covers an author mid-edit; this answers the same question about a
+    // file already on disk, which is what a builder's own CI needs. Offline: it
+    // reads this CLI's pinned declarations and never calls the cloud.
+    checks
+        .command("lint")
+        .argument("<file...>", "Task markdown file(s) — shell globs work: tasks/*.md")
+        .description("Report [code] criteria that bind no declared check, so are never graded")
+        .action(async (files) => {
+        await runChecksLintCommand(files);
+    });
     program
         .command("compile-seeds")
         .argument("[target]", "Task .md file or directory (defaults to ./tasks)")

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

@@ -75,7 +75,7 @@ export declare function runTask(options: RunTaskOptions): Promise<{
                     }[];
                     statuses: {
                         context: string;
-                        state: "error" | "failure" | "pending" | "success";
+                        state: "error" | "success" | "failure" | "pending";
                         description: string;
                     }[];
                     number?: number | undefined;
@@ -470,7 +470,7 @@ export declare function runTask(options: RunTaskOptions): Promise<{
                     }[];
                     statuses: {
                         context: string;
-                        state: "error" | "failure" | "pending" | "success";
+                        state: "error" | "success" | "failure" | "pending";
                         description: string;
                     }[];
                     number?: number | undefined;

package/dist/src/task/insertCriterion.js

@@ -57,6 +57,11 @@ export function insertCriterion(source, line, path = "this task file") {
         // like every shipped task instead of butting against the heading.
         insertAt = lines[start + 1]?.trim() === "" ? start + 2 : start + 1;
     }
-    lines.splice(insertAt, 0, line);
+    // F-1134 — a section whose only content is its blank line puts `insertAt` on
+    // the NEXT heading, so the criterion would land against it with nothing
+    // between. Cosmetic (it parses either way), but this is the very first write
+    // into a freshly scaffolded task, which is the file an author reads hardest.
+    const blankAfter = NEXT_HEADING_RE.test(lines[insertAt] ?? "") ? [""] : [];
+    lines.splice(insertAt, 0, line, ...blankAfter);
     return lines.join("\n");
 }

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

@@ -5,6 +5,27 @@ export declare function parseTaskFile(path: string): Promise<Task>;
  *  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 declare function readConfigTwins(markdown: string): string[];
+/** One `[code]` criterion as an authoring surface sees it: the sentence, the twin
+ *  whose declared vocabulary is supposed to grade it, and the human-facing marker
+ *  reconstructed the way `parseCriteria` reconstructs it for error messages — so
+ *  a report can echo a line the author can find by searching the file. */
+export interface CodeCriterion {
+    marker: string;
+    twin: string;
+    text: string;
+}
+/** 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 declare function readCodeCriteria(markdown: string): CodeCriterion[];
 export declare function parseTask(markdown: string, slug?: string, sidecarSeed?: unknown, taskPath?: string): Task;
 /** 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

package/dist/src/task/parseTask.js

@@ -25,11 +25,58 @@ export function readConfigTwins(markdown) {
         : 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 = sections.get("success criteria") ?? sections.get("checks") ?? "";
+    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({});

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

@@ -141,8 +141,8 @@ export declare const seedStateSchema: z.ZodUnion<readonly [z.ZodObject<{
         forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
             forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                accepted: "accepted";
                 pending: "pending";
+                accepted: "accepted";
             }>>;
         }, z.core.$strict>>>;
         sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -152,8 +152,8 @@ export declare const seedStateSchema: z.ZodUnion<readonly [z.ZodObject<{
             isPrimary: z.ZodDefault<z.ZodBoolean>;
             isDefault: z.ZodDefault<z.ZodBoolean>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                accepted: "accepted";
                 pending: "pending";
+                accepted: "accepted";
             }>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>;
@@ -246,8 +246,8 @@ export declare const seedStateSchema: z.ZodUnion<readonly [z.ZodObject<{
         forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
             forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                accepted: "accepted";
                 pending: "pending";
+                accepted: "accepted";
             }>>;
         }, z.core.$strict>>>;
         sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -257,8 +257,8 @@ export declare const seedStateSchema: z.ZodUnion<readonly [z.ZodObject<{
             isPrimary: z.ZodDefault<z.ZodBoolean>;
             isDefault: z.ZodDefault<z.ZodBoolean>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                accepted: "accepted";
                 pending: "pending";
+                accepted: "accepted";
             }>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>>;
@@ -491,9 +491,9 @@ export declare const seedStateSchema: z.ZodUnion<readonly [z.ZodObject<{
                 context: z.ZodDefault<z.ZodString>;
                 state: z.ZodDefault<z.ZodEnum<{
                     error: "error";
+                    success: "success";
                     failure: "failure";
                     pending: "pending";
-                    success: "success";
                 }>>;
                 description: z.ZodDefault<z.ZodString>;
             }, z.core.$strip>>>;
@@ -614,8 +614,8 @@ export declare const seedEnvelopeSchema: z.ZodRecord<z.ZodString, z.ZodUnion<rea
         forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
             forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                accepted: "accepted";
                 pending: "pending";
+                accepted: "accepted";
             }>>;
         }, z.core.$strict>>>;
         sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -625,8 +625,8 @@ export declare const seedEnvelopeSchema: z.ZodRecord<z.ZodString, z.ZodUnion<rea
             isPrimary: z.ZodDefault<z.ZodBoolean>;
             isDefault: z.ZodDefault<z.ZodBoolean>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                accepted: "accepted";
                 pending: "pending";
+                accepted: "accepted";
             }>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>;
@@ -719,8 +719,8 @@ export declare const seedEnvelopeSchema: z.ZodRecord<z.ZodString, z.ZodUnion<rea
         forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
             forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                accepted: "accepted";
                 pending: "pending";
+                accepted: "accepted";
             }>>;
         }, z.core.$strict>>>;
         sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -730,8 +730,8 @@ export declare const seedEnvelopeSchema: z.ZodRecord<z.ZodString, z.ZodUnion<rea
             isPrimary: z.ZodDefault<z.ZodBoolean>;
             isDefault: z.ZodDefault<z.ZodBoolean>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                accepted: "accepted";
                 pending: "pending";
+                accepted: "accepted";
             }>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>>;
@@ -964,9 +964,9 @@ export declare const seedEnvelopeSchema: z.ZodRecord<z.ZodString, z.ZodUnion<rea
                 context: z.ZodDefault<z.ZodString>;
                 state: z.ZodDefault<z.ZodEnum<{
                     error: "error";
+                    success: "success";
                     failure: "failure";
                     pending: "pending";
-                    success: "success";
                 }>>;
                 description: z.ZodDefault<z.ZodString>;
             }, z.core.$strip>>>;
@@ -1109,8 +1109,8 @@ export declare const taskSchema: z.ZodObject<{
             forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                 verificationStatus: z.ZodDefault<z.ZodEnum<{
-                    accepted: "accepted";
                     pending: "pending";
+                    accepted: "accepted";
                 }>>;
             }, z.core.$strict>>>;
             sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -1120,8 +1120,8 @@ export declare const taskSchema: z.ZodObject<{
                 isPrimary: z.ZodDefault<z.ZodBoolean>;
                 isDefault: z.ZodDefault<z.ZodBoolean>;
                 verificationStatus: z.ZodDefault<z.ZodEnum<{
-                    accepted: "accepted";
                     pending: "pending";
+                    accepted: "accepted";
                 }>>;
             }, z.core.$strict>>>;
         }, z.core.$strict>;
@@ -1214,8 +1214,8 @@ export declare const taskSchema: z.ZodObject<{
             forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                 verificationStatus: z.ZodDefault<z.ZodEnum<{
-                    accepted: "accepted";
                     pending: "pending";
+                    accepted: "accepted";
                 }>>;
             }, z.core.$strict>>>;
             sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -1225,8 +1225,8 @@ export declare const taskSchema: z.ZodObject<{
                 isPrimary: z.ZodDefault<z.ZodBoolean>;
                 isDefault: z.ZodDefault<z.ZodBoolean>;
                 verificationStatus: z.ZodDefault<z.ZodEnum<{
-                    accepted: "accepted";
                     pending: "pending";
+                    accepted: "accepted";
                 }>>;
             }, z.core.$strict>>>;
         }, z.core.$strict>>>;
@@ -1459,9 +1459,9 @@ export declare const taskSchema: z.ZodObject<{
                     context: z.ZodDefault<z.ZodString>;
                     state: z.ZodDefault<z.ZodEnum<{
                         error: "error";
+                        success: "success";
                         failure: "failure";
                         pending: "pending";
-                        success: "success";
                     }>>;
                     description: z.ZodDefault<z.ZodString>;
                 }, z.core.$strip>>>;
@@ -1581,8 +1581,8 @@ export declare const taskSchema: z.ZodObject<{
             forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                 verificationStatus: z.ZodDefault<z.ZodEnum<{
-                    accepted: "accepted";
                     pending: "pending";
+                    accepted: "accepted";
                 }>>;
             }, z.core.$strict>>>;
             sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -1592,8 +1592,8 @@ export declare const taskSchema: z.ZodObject<{
                 isPrimary: z.ZodDefault<z.ZodBoolean>;
                 isDefault: z.ZodDefault<z.ZodBoolean>;
                 verificationStatus: z.ZodDefault<z.ZodEnum<{
-                    accepted: "accepted";
                     pending: "pending";
+                    accepted: "accepted";
                 }>>;
             }, z.core.$strict>>>;
         }, z.core.$strict>;
@@ -1686,8 +1686,8 @@ export declare const taskSchema: z.ZodObject<{
             forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                 verificationStatus: z.ZodDefault<z.ZodEnum<{
-                    accepted: "accepted";
                     pending: "pending";
+                    accepted: "accepted";
                 }>>;
             }, z.core.$strict>>>;
             sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -1697,8 +1697,8 @@ export declare const taskSchema: z.ZodObject<{
                 isPrimary: z.ZodDefault<z.ZodBoolean>;
                 isDefault: z.ZodDefault<z.ZodBoolean>;
                 verificationStatus: z.ZodDefault<z.ZodEnum<{
-                    accepted: "accepted";
                     pending: "pending";
+                    accepted: "accepted";
                 }>>;
             }, z.core.$strict>>>;
         }, z.core.$strict>>>;
@@ -1931,9 +1931,9 @@ export declare const taskSchema: z.ZodObject<{
                     context: z.ZodDefault<z.ZodString>;
                     state: z.ZodDefault<z.ZodEnum<{
                         error: "error";
+                        success: "success";
                         failure: "failure";
                         pending: "pending";
-                        success: "success";
                     }>>;
                     description: z.ZodDefault<z.ZodString>;
                 }, z.core.$strip>>>;

package/node_modules/@pome-sh/sdk/dist/check-discrimination.d.ts

@@ -0,0 +1,7 @@
+import type { CheckDefinition, DiscriminationVerdict } from "./checks.js";
+/**
+ * Run a check against the worlds it names and say whether they actually
+ * discriminate. Pure: no vitest, no ledger — each twin's contract test owns the
+ * ledger half, so an empty ledger cannot silently excuse anything.
+ */
+export declare function probeDiscrimination<TState, TArgs extends Record<string, string>>(def: CheckDefinition<TState, TArgs>, args: TArgs): DiscriminationVerdict;