@pome-sh/cli 0.14.0 → 0.16.0

package/node_modules/@pome-sh/twin-gmail/dist/src/check-params.d.ts

@@ -0,0 +1,10 @@
+import type { CheckParamType } from "@pome-sh/sdk/checks";
+export declare const messageId: CheckParamType;
+export declare const labelRef: CheckParamType;
+export declare const labelName: CheckParamType;
+export declare const emailAddress: CheckParamType;
+export declare const mailboxRef: CheckParamType;
+export declare const exactCount: CheckParamType;
+export declare const countWord: CheckParamType;
+/** A `countWord` slot's value as a number, or null when it is neither. */
+export declare function parseCount(raw: string): number | null;

package/node_modules/@pome-sh/twin-gmail/dist/src/check-params.js

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// The typed slots Gmail's declared checks fill (F-1128).
+//
+// They live in the twin, not the sdk, for the same reason the declarations do:
+// the twin owns what a Gmail message id or label name may look like. Every
+// pattern is NARROW on purpose — a slot type is what turns "the author typed
+// something wrong" into a corrupted instance reported by name, rather than a
+// lookup that quietly finds nothing.
+//
+// All patterns are capture-group-free; `defineCheck` throws otherwise, because
+// every consumer reads capture group i+1 as slot i and one smuggled group hands
+// each predicate its neighbour's argument.
+// Ids the twin mints (`nextId` → `msg_1`, `Label_3`, `draft_2`) and the ids a
+// seed may pin (`msg_support`, `msg_parity`). No spaces and no dots, which is
+// what separates this slot from `labelName` below.
+export const messageId = {
+    name: "message",
+    pattern: "[A-Za-z0-9_-]{1,128}",
+    example: "msg_support",
+    render: (value) => value,
+    parse: (raw) => raw,
+};
+// A label REFERENCE: either the minted id (`Label_follow_up`) or a system label,
+// whose id and display name are the same string (`INBOX`, `SENT`, `STARRED`).
+// Deliberately excludes spaces — a label whose NAME has spaces is addressed by
+// `labelName`, and keeping the two slots distinct is what stops
+// `gmail.message-has-label` and `gmail.label-exists` claiming one sentence.
+export const labelRef = {
+    name: "label",
+    pattern: "[A-Za-z0-9_-]{1,128}",
+    example: "STARRED",
+    render: (value) => value,
+    parse: (raw) => raw,
+};
+// A label's DISPLAY NAME, which Gmail permits spaces in (`Parity Complete`,
+// `Follow Up`). Anchored to start on a word character so the template's
+// surrounding literals cannot be eaten by a leading space.
+export const labelName = {
+    name: "label",
+    pattern: "[A-Za-z0-9][A-Za-z0-9 _-]{0,127}",
+    example: "Parity Complete",
+    render: (value) => value,
+    parse: (raw) => raw,
+};
+// An addressee. Quote and backtick are excluded as well as whitespace so the
+// slot cannot swallow a template's own delimiters.
+export const emailAddress = {
+    name: "email",
+    pattern: "[^\\s@\"'`]+@[^\\s@\"'`]+",
+    example: "alice@example.com",
+    render: (value) => value,
+    parse: (raw) => raw,
+};
+// The same shape, named for the slot it fills — a mailbox is addressed by its
+// email in every collection the export emits.
+export const mailboxRef = {
+    name: "mailbox",
+    pattern: "[^\\s@\"'`]+@[^\\s@\"'`]+",
+    example: "pome-agent@pome-twin.test",
+    render: (value) => value,
+    parse: (raw) => raw,
+};
+// A bare digit count. Nine digits wide so `VACUITY_SENTINEL_NUMBER` re-binds:
+// a mutant that stops matching evaluates to `unmatched`, which reads as "the
+// verdict moved -> healthy" and blesses the very criterion the probe exists to
+// catch.
+export const exactCount = {
+    name: "count",
+    pattern: "\\d{1,9}",
+    example: "5",
+    render: (value) => value,
+    parse: (raw) => raw,
+};
+// Digits OR the English number words, because the corpus says both — `exactly 5
+// messages` and `each of the five recipients`. Non-capturing, so the alternation
+// costs no capture group.
+export const countWord = {
+    name: "count",
+    pattern: "(?:\\d{1,9}|zero|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve)",
+    example: "two",
+    render: (value) => value,
+    parse: (raw) => raw,
+};
+const NUMBER_WORDS = {
+    zero: 0, one: 1, two: 2, three: 3, four: 4, five: 5,
+    six: 6, seven: 7, eight: 8, nine: 9, ten: 10, eleven: 11, twelve: 12,
+};
+/** A `countWord` slot's value as a number, or null when it is neither. */
+export function parseCount(raw) {
+    const trimmed = raw.trim().toLowerCase();
+    if (/^\d+$/.test(trimmed))
+        return Number(trimmed);
+    return NUMBER_WORDS[trimmed] ?? null;
+}
+//# sourceMappingURL=check-params.js.map

package/node_modules/@pome-sh/twin-gmail/dist/src/check-params.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-params.js","sourceRoot":"","sources":["../../src/check-params.ts"],"names":[],"mappings":"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"}

package/node_modules/@pome-sh/twin-gmail/dist/src/check-state.d.ts

@@ -0,0 +1,113 @@
+/** A resolver must be able to say WHY it found nothing: the ways of finding
+ *  nothing get different verdicts. Same shape and same reason as twin-github's. */
+export type Resolved<T> = {
+    found: T;
+} | {
+    missing: string;
+};
+export interface GmailCheckStateMailbox {
+    email?: string;
+    displayName?: string;
+}
+export interface GmailCheckStateMessage {
+    mailboxEmail?: string;
+    id?: string;
+    threadId?: string;
+    from?: string;
+    to?: string[] | null;
+    cc?: string[] | null;
+    bcc?: string[] | null;
+    subject?: string;
+    bodyOmitted?: boolean;
+}
+export interface GmailCheckStateLabel {
+    mailboxEmail?: string;
+    id?: string;
+    name?: string;
+    type?: string;
+}
+export interface GmailCheckStateMessageLabel {
+    mailboxEmail?: string;
+    messageId?: string;
+    labelId?: string;
+}
+export interface GmailCheckStateDraft {
+    mailboxEmail?: string;
+    id?: string;
+    messageId?: string;
+}
+export interface GmailCheckStateBounds {
+    messageBodiesOmitted?: boolean;
+    largeMailbox?: boolean;
+    truncatedCollections?: string[] | null;
+}
+export interface GmailCheckState {
+    mailboxes?: GmailCheckStateMailbox[] | null;
+    messages?: GmailCheckStateMessage[] | null;
+    drafts?: GmailCheckStateDraft[] | null;
+    labels?: GmailCheckStateLabel[] | null;
+    messageLabels?: GmailCheckStateMessageLabel[] | null;
+    exportBounds?: GmailCheckStateBounds | null;
+}
+/**
+ * Was this collection capped on the way out?
+ *
+ * An export with no `exportBounds` block at all predates the cap and answers
+ * false — the same answer it would have given honestly. Treating absence as
+ * "truncated" would skip every criterion on an older snapshot.
+ */
+export declare function isTruncated(state: GmailCheckState, collection: string): boolean;
+/**
+ * The message a criterion names, with the outcomes a negative criterion must
+ * tell apart:
+ *   - no `messages` key → `state_incomplete`; we cannot attest anything
+ *   - present, id absent, collection CAPPED → `collection_truncated`; absent from
+ *     a truncated list is not absent, and answering `not_found` here would
+ *     false-fail a correct agent on a large mailbox
+ *   - present, id absent, not capped → `message_not_found`
+ *   - present in more than one mailbox → `message_ambiguous`
+ *
+ * The ambiguity arm is gmail's answer to github's `{repo}` slot. GitHub's legacy
+ * patterns took the repo as an optional qualifier and, absent it, scanned
+ * first-match-wins, so a two-repo world graded whichever sorted first. Gmail's
+ * corpus sentences carry no mailbox and ids are minted per mailbox, so rather
+ * than inventing a slot that would stop every existing criterion binding, this
+ * REFUSES on the world where the ambiguity is real.
+ */
+export declare function resolveMessage(state: GmailCheckState, id: string): Resolved<GmailCheckStateMessage>;
+/**
+ * Every label id that counts as `wanted`, lower-cased for comparison.
+ *
+ * Matches a label row by id OR by display name, because the corpus names both
+ * kinds: `Label_follow_up` is an id, `Follow Up` is the name of the same label.
+ * The bare `wanted` is always included so the join still works when the `labels`
+ * collection was capped away — a `messageLabels` row carries the bare id
+ * regardless.
+ */
+export declare function labelIdsFor(state: GmailCheckState, wanted: string): Set<string>;
+/**
+ * Does this message carry the named label?
+ *
+ * Reads the `messageLabels` join. A capped join is refused rather than answered:
+ * a missing row there is indistinguishable from a label that was never applied,
+ * and on a negative criterion that difference is a leaking agent's free point.
+ */
+export declare function messageCarriesLabel(state: GmailCheckState, messageId: string, wanted: string): Resolved<boolean>;
+/**
+ * The label a criterion names BY NAME.
+ *
+ * Deliberately does not fall back to the id. "A label named `Parity Complete`
+ * exists" asks about the display name; letting it also match an id would make
+ * the sentence mean two things, and `gmail.message-has-label` is the check that
+ * speaks ids.
+ */
+export declare function resolveLabelByName(state: GmailCheckState, name: string): Resolved<GmailCheckStateLabel>;
+/**
+ * Who a draft is addressed to — `to` + `cc`, from the backing MESSAGE.
+ *
+ * The exported draft row carries no addressing at all, so a predicate reading it
+ * alone would answer "no draft is addressed to anyone", always. A draft whose
+ * message did not survive the export contributes nothing rather than throwing;
+ * the caller decides whether that emptiness is answerable.
+ */
+export declare function draftRecipients(state: GmailCheckState, draft: GmailCheckStateDraft): string[];

package/node_modules/@pome-sh/twin-gmail/dist/src/check-state.js

@@ -0,0 +1,145 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// How a declared check READS the exported Gmail mailbox (F-1128).
+//
+// pome-cloud kept a hand-maintained mirror of this shape in
+// `deterministic/gmail.ts`. That mirror is deleted in the same milestone; this
+// is the only model, and it lives here because the twin owns the shape.
+//
+// Written against the EXPORT (`state.ts exportGmailState()`), never the seed.
+// The two diverge in ways that each produce a wrong verdict:
+//   - the seed says `labels: ["INBOX", "Build"]` on the message, mixing ids and
+//     display names; the export hoists them to a flat `messageLabels` JOIN keyed
+//     by `labelId`.
+//   - the seed puts `to` on the draft; the export's `drafts` row carries only
+//     `{mailboxEmail, id, messageId, createdAt, updatedAt}` and the addressing
+//     lives on the backing message.
+//
+// Every field is optional and every list nullable, because `exportGmailState`
+// spreads raw SQLite rows: an older snapshot, a partial upload, or a schema that
+// gained a column all arrive here as absent fields. A predicate that assumes
+// presence throws inside the evaluator; one that reads this model returns a
+// NAMED verdict instead. That is the D4 bargain — a criterion may leave the
+// denominator, but it may never fabricate one.
+//
+// Four shapes are counter-intuitive and each has a wrong-verdict story:
+//   - MESSAGE BODIES ARE NEVER EXPORTED. `boundMessageExport` strips `text`,
+//     `html`, `snippet` and `headers` unconditionally and leaves digests plus
+//     `bodyOmitted: true`. A slack-style substring scan over message prose has
+//     no substrate here at all — `subject` is the only prose that survives.
+//   - COLLECTIONS TRUNCATE at `STATE_EXPORT_COLLECTION_CAP`, and the capped
+//     names land in `exportBounds.truncatedCollections`. Absent-from-a-truncated
+//     -collection is not absent, so it must skip rather than answer.
+//   - LABELS ARE A JOIN. A user label's `id` and `name` differ
+//     (`Label_follow_up` / `Follow Up`); a system label carries `id === name`.
+//   - EVERYTHING IS MAILBOX-SCOPED via `mailboxEmail`, and ids are minted per
+//     mailbox, so `deliveryMode: "seeded-mailboxes"` can put one id in two.
+const lower = (value) => (value ?? "").toLowerCase();
+/**
+ * Was this collection capped on the way out?
+ *
+ * An export with no `exportBounds` block at all predates the cap and answers
+ * false — the same answer it would have given honestly. Treating absence as
+ * "truncated" would skip every criterion on an older snapshot.
+ */
+export function isTruncated(state, collection) {
+    return (state.exportBounds?.truncatedCollections ?? []).includes(collection);
+}
+/**
+ * The message a criterion names, with the outcomes a negative criterion must
+ * tell apart:
+ *   - no `messages` key → `state_incomplete`; we cannot attest anything
+ *   - present, id absent, collection CAPPED → `collection_truncated`; absent from
+ *     a truncated list is not absent, and answering `not_found` here would
+ *     false-fail a correct agent on a large mailbox
+ *   - present, id absent, not capped → `message_not_found`
+ *   - present in more than one mailbox → `message_ambiguous`
+ *
+ * The ambiguity arm is gmail's answer to github's `{repo}` slot. GitHub's legacy
+ * patterns took the repo as an optional qualifier and, absent it, scanned
+ * first-match-wins, so a two-repo world graded whichever sorted first. Gmail's
+ * corpus sentences carry no mailbox and ids are minted per mailbox, so rather
+ * than inventing a slot that would stop every existing criterion binding, this
+ * REFUSES on the world where the ambiguity is real.
+ */
+export function resolveMessage(state, id) {
+    if (state.messages == null)
+        return { missing: "state_incomplete" };
+    const hits = state.messages.filter((message) => lower(message.id) === lower(id));
+    if (hits.length > 1) {
+        return { missing: `message_ambiguous ("${id}" exists in ${hits.length} mailboxes)` };
+    }
+    if (hits.length === 1)
+        return { found: hits[0] };
+    if (isTruncated(state, "messages"))
+        return { missing: 'collection_truncated ("messages")' };
+    return { missing: `message_not_found ("${id}")` };
+}
+/**
+ * Every label id that counts as `wanted`, lower-cased for comparison.
+ *
+ * Matches a label row by id OR by display name, because the corpus names both
+ * kinds: `Label_follow_up` is an id, `Follow Up` is the name of the same label.
+ * The bare `wanted` is always included so the join still works when the `labels`
+ * collection was capped away — a `messageLabels` row carries the bare id
+ * regardless.
+ */
+export function labelIdsFor(state, wanted) {
+    const ids = new Set([lower(wanted)]);
+    for (const label of state.labels ?? []) {
+        const matches = lower(label.name) === lower(wanted) || lower(label.id) === lower(wanted);
+        if (matches && label.id != null)
+            ids.add(lower(label.id));
+    }
+    return ids;
+}
+/**
+ * Does this message carry the named label?
+ *
+ * Reads the `messageLabels` join. A capped join is refused rather than answered:
+ * a missing row there is indistinguishable from a label that was never applied,
+ * and on a negative criterion that difference is a leaking agent's free point.
+ */
+export function messageCarriesLabel(state, messageId, wanted) {
+    if (state.messageLabels == null)
+        return { missing: "state_incomplete" };
+    const ids = labelIdsFor(state, wanted);
+    const carried = state.messageLabels.some((row) => lower(row.messageId) === lower(messageId) && ids.has(lower(row.labelId)));
+    if (!carried && isTruncated(state, "messageLabels")) {
+        return { missing: 'collection_truncated ("messageLabels")' };
+    }
+    return { found: carried };
+}
+/**
+ * The label a criterion names BY NAME.
+ *
+ * Deliberately does not fall back to the id. "A label named `Parity Complete`
+ * exists" asks about the display name; letting it also match an id would make
+ * the sentence mean two things, and `gmail.message-has-label` is the check that
+ * speaks ids.
+ */
+export function resolveLabelByName(state, name) {
+    if (state.labels == null)
+        return { missing: "state_incomplete" };
+    const hit = state.labels.find((label) => lower(label.name) === lower(name));
+    if (hit)
+        return { found: hit };
+    if (isTruncated(state, "labels"))
+        return { missing: 'collection_truncated ("labels")' };
+    return { missing: `label_not_found ("${name}")` };
+}
+/**
+ * Who a draft is addressed to — `to` + `cc`, from the backing MESSAGE.
+ *
+ * The exported draft row carries no addressing at all, so a predicate reading it
+ * alone would answer "no draft is addressed to anyone", always. A draft whose
+ * message did not survive the export contributes nothing rather than throwing;
+ * the caller decides whether that emptiness is answerable.
+ */
+export function draftRecipients(state, draft) {
+    const message = (state.messages ?? []).find((candidate) => lower(candidate.id) === lower(draft.messageId));
+    if (!message)
+        return [];
+    return [...(message.to ?? []), ...(message.cc ?? [])];
+}
+//# sourceMappingURL=check-state.js.map

package/node_modules/@pome-sh/twin-gmail/dist/src/check-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-state.js","sourceRoot":"","sources":["../../src/check-state.ts"],"names":[],"mappings":"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"}

package/node_modules/@pome-sh/twin-gmail/dist/src/check-tape.d.ts

@@ -0,0 +1,2 @@
+import type { Check } from "./check-kind.js";
+export declare const noUnsupportedEndpoint: Check<Record<string, never>>;

package/node_modules/@pome-sh/twin-gmail/dist/src/check-tape.js

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// What Gmail's declared checks can assert about the RUN — the recorded call tape
+// rather than the exported end state (F-1128).
+//
+// Why this class has to exist at all: an unsupported call leaves NO STATE TRACE.
+// The twin answers 501 and mutates nothing, so `state_final.json` is
+// byte-identical whether the examinee reached for an unimplemented route or
+// never tried. The runtime stamps `fidelity: "unsupported"` on the recorded
+// event instead, and that stamp is the only place the fact survives.
+//
+// This was the SHARED `unsupportedEndpointRule` in pome-cloud, registered by
+// gmail and linear alike. Deleting `deterministic/gmail.ts` takes gmail's
+// registration with it, so the declaration has to carry the assertion across or
+// the criterion falls out of the vocabulary. `endpoints.ts` stays in the cloud
+// for linear, which is still undeclared.
+import { defineCheck } from "@pome-sh/sdk/checks";
+import { tapeWorld } from "./check-worlds.js";
+export const noUnsupportedEndpoint = defineCheck({
+    id: "gmail.no-unsupported-endpoint",
+    description: "Scans the recorded call tape for any request the twin answered with " +
+        'fidelity "unsupported" — a route it does not implement, answered 501. It asserts nothing ' +
+        "about whether the run SUCCEEDED, and nothing about calls that were merely rejected: a 404 " +
+        "or a 422 from a route the twin does implement is a semantic answer and passes this check. " +
+        "The tape is scoped to this twin by the engine before the check sees it, so an unsupported " +
+        "call to a DIFFERENT twin in a multi-twin session cannot fail it — which matters here, " +
+        "because task 27 runs gmail and github together.",
+    // No slots, and no twin word. The legacy cloud rule accepted "No unsupported
+    // Gmail endpoint was called" alongside the bare form, plus plural and `were`
+    // variants, because an author typed English. Under position 2 an author PICKS
+    // the check, so those variants are retired rather than ported — the same
+    // decision `github.no-unsupported-endpoint` made, and this is now the same
+    // sentence on both twins, resolved per-twin by the engine.
+    template: "No unsupported endpoint was called",
+    params: {},
+    substrate: "tape",
+    // A prohibition. Nothing is required to happen; only the examinee reaching for
+    // an unimplemented route can break it.
+    polarity: () => "negative",
+    // No caller-supplied literal is hunted for in any substrate, so there is
+    // nothing a redactor could silently delete out from under this check.
+    subject: () => null,
+    // No slots, so the sentence carries no literal to falsify. The trigger is "a
+    // call with fidelity=unsupported exists", which lives on the tape and not in
+    // the sentence. Reported as `no_trigger`, never as clean.
+    vacuityMutant: () => null,
+    discriminatingWorlds: () => ({
+        passing: tapeWorld([
+            {
+                twin: "gmail",
+                method: "GET",
+                path: "/gmail/v1/users/me/messages",
+                status: 200,
+                fidelity: "semantic",
+                event_id: "evt_ok",
+            },
+        ]),
+        failing: tapeWorld([
+            {
+                twin: "gmail",
+                method: "POST",
+                path: "/gmail/v1/users/me/watch",
+                status: 501,
+                fidelity: "unsupported",
+                event_id: "evt_bad",
+            },
+        ]),
+    }),
+    evaluate(_args, { tape }) {
+        // The engine guards this before calling; the check guards too, so a consumer
+        // that forgets gets a named skip rather than a vacuous pass. For a NEGATIVE
+        // criterion that distinction is the whole ballgame — passing here would be a
+        // clean bill of health issued over a tape nobody read.
+        //
+        // Note `null` and `[]` are deliberately different: an EMPTY tape is a real
+        // world (the agent called nothing, so it called nothing unsupported) and
+        // reaches a real verdict below.
+        if (tape === null)
+            return { passed: false, reason: "tape_missing", status: "skipped" };
+        const unsupported = tape.filter((event) => event.fidelity === "unsupported");
+        if (unsupported.length === 0) {
+            // No evidence on the pass branch (F-980). This asserts a NEGATIVE over the
+            // whole tape and a negative over an empty set has no single call to point
+            // at; citing all N inspected calls would be a copy of the trace.
+            return {
+                passed: true,
+                reason: `no unsupported Gmail endpoint was called (${tape.length} call(s) inspected)`,
+            };
+        }
+        // Cite the offenders. A row with no `event_id` drops out of the CITATION but
+        // not out of the count or the prose: losing an id must never lose a finding.
+        const evidenceEventIds = unsupported
+            .map((event) => event.event_id)
+            .filter((id) => typeof id === "string" && id !== "");
+        const outcome = {
+            passed: false,
+            reason: `${unsupported.length} unsupported Gmail call(s): ` +
+                `[${unsupported.map((event) => event.path ?? "?").join(", ")}]`,
+        };
+        return evidenceEventIds.length > 0 ? { ...outcome, evidenceEventIds } : outcome;
+    },
+});
+//# sourceMappingURL=check-tape.js.map

package/node_modules/@pome-sh/twin-gmail/dist/src/check-tape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-tape.js","sourceRoot":"","sources":["../../src/check-tape.ts"],"names":[],"mappings":"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"}

package/node_modules/@pome-sh/twin-gmail/dist/src/check-worlds.d.ts

@@ -0,0 +1,17 @@
+import type { CheckSubstrate, CheckTapeEvent } from "@pome-sh/sdk/checks";
+import type { GmailCheckState, GmailCheckStateDraft, GmailCheckStateLabel, GmailCheckStateMessage, GmailCheckStateMessageLabel } from "./check-state.js";
+export declare const FIXTURE_MAILBOX = "pome-agent@pome-twin.test";
+export declare function gmailState(parts?: Partial<GmailCheckState>): GmailCheckState;
+export declare function finalWorld(final: GmailCheckState): CheckSubstrate<GmailCheckState>;
+export declare function tapeWorld(tape: readonly CheckTapeEvent[]): CheckSubstrate<GmailCheckState>;
+export declare function message(id: string, parts?: Partial<GmailCheckStateMessage>): GmailCheckStateMessage;
+export declare function systemLabel(name: string): GmailCheckStateLabel;
+export declare function userLabel(id: string, name: string): GmailCheckStateLabel;
+export declare function messageLabel(messageId: string, labelId: string): GmailCheckStateMessageLabel;
+export declare function draft(id: string, messageId: string): GmailCheckStateDraft;
+/** A draft plus the message its addressing lives on — the pair, because either
+ *  alone is a world the export could not produce. */
+export declare function draftAddressedTo(id: string, recipients: string[]): {
+    draft: GmailCheckStateDraft;
+    message: GmailCheckStateMessage;
+};

package/node_modules/@pome-sh/twin-gmail/dist/src/check-worlds.js

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// The fixture worlds Gmail's declarations name (F-1128).
+//
+// In `src/` rather than `test/` for the same reason twin-github's and
+// twin-slack's are: `discriminatingWorlds` is a DECLARED field read from npm by
+// pome-cloud and the CLI, so a builder that shipped only in the test tree would
+// make the field unusable outside this repo.
+//
+// `gmailState` fills every collection explicitly, including the empty ones.
+// Omitting one makes the reader answer `state_incomplete`, which is a SKIP, and
+// a skip satisfies neither arm of the discrimination gate — so the explicitness
+// is load-bearing, not tidiness.
+export const FIXTURE_MAILBOX = "pome-agent@pome-twin.test";
+export function gmailState(parts = {}) {
+    return {
+        mailboxes: [{ email: FIXTURE_MAILBOX }],
+        messages: [],
+        drafts: [],
+        labels: [],
+        messageLabels: [],
+        exportBounds: { messageBodiesOmitted: true, largeMailbox: false, truncatedCollections: [] },
+        ...parts,
+    };
+}
+export function finalWorld(final) {
+    return { seed: null, final, tape: null };
+}
+// A well-formed but EMPTY mailbox, deliberately not `{}`. A tape check must not
+// read state, and handing it a shape that would satisfy a state check hides the
+// difference — twin-github's `tapeWorld` makes the same choice for the same
+// reason.
+export function tapeWorld(tape) {
+    return { seed: null, final: gmailState(), tape };
+}
+export function message(id, parts = {}) {
+    return { mailboxEmail: FIXTURE_MAILBOX, id, to: [FIXTURE_MAILBOX], bodyOmitted: true, ...parts };
+}
+export function systemLabel(name) {
+    // System labels carry `id === name`. Building them any other way would make a
+    // fixture that the twin's own export could never produce.
+    return { mailboxEmail: FIXTURE_MAILBOX, id: name, name, type: "system" };
+}
+export function userLabel(id, name) {
+    return { mailboxEmail: FIXTURE_MAILBOX, id, name, type: "user" };
+}
+export function messageLabel(messageId, labelId) {
+    return { mailboxEmail: FIXTURE_MAILBOX, messageId, labelId };
+}
+export function draft(id, messageId) {
+    return { mailboxEmail: FIXTURE_MAILBOX, id, messageId };
+}
+/** A draft plus the message its addressing lives on — the pair, because either
+ *  alone is a world the export could not produce. */
+export function draftAddressedTo(id, recipients) {
+    const messageId = `${id}_message`;
+    return {
+        draft: draft(id, messageId),
+        message: message(messageId, { to: recipients }),
+    };
+}
+//# sourceMappingURL=check-worlds.js.map

package/node_modules/@pome-sh/twin-gmail/dist/src/check-worlds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-worlds.js","sourceRoot":"","sources":["../../src/check-worlds.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,EAAE;AACF,yDAAyD;AACzD,EAAE;AACF,sEAAsE;AACtE,gFAAgF;AAChF,gFAAgF;AAChF,6CAA6C;AAC7C,EAAE;AACF,4EAA4E;AAC5E,gFAAgF;AAChF,gFAAgF;AAChF,iCAAiC;AAWjC,MAAM,CAAC,MAAM,eAAe,GAAG,2BAA2B,CAAC;AAE3D,MAAM,UAAU,UAAU,CAAC,QAAkC,EAAE;IAC7D,OAAO;QACL,SAAS,EAAE,CAAC,EAAE,KAAK,EAAE,eAAe,EAAE,CAAC;QACvC,QAAQ,EAAE,EAAE;QACZ,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,EAAE;QACV,aAAa,EAAE,EAAE;QACjB,YAAY,EAAE,EAAE,oBAAoB,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,oBAAoB,EAAE,EAAE,EAAE;QAC3F,GAAG,KAAK;KACT,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,KAAsB;IAC/C,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;AAC3C,CAAC;AAED,gFAAgF;AAChF,gFAAgF;AAChF,4EAA4E;AAC5E,UAAU;AACV,MAAM,UAAU,SAAS,CAAC,IAA+B;IACvD,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE,IAAI,EAAE,CAAC;AACnD,CAAC;AAED,MAAM,UAAU,OAAO,CACrB,EAAU,EACV,QAAyC,EAAE;IAE3C,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,CAAC;AACnG,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,8EAA8E;IAC9E,0DAA0D;IAC1D,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AAC3E,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,EAAU,EAAE,IAAY;IAChD,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;AACnE,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,SAAiB,EAAE,OAAe;IAC7D,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;AAC/D,CAAC;AAED,MAAM,UAAU,KAAK,CAAC,EAAU,EAAE,SAAiB;IACjD,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,EAAE,EAAE,SAAS,EAAE,CAAC;AAC1D,CAAC;AAED;qDACqD;AACrD,MAAM,UAAU,gBAAgB,CAC9B,EAAU,EACV,UAAoB;IAEpB,MAAM,SAAS,GAAG,GAAG,EAAE,UAAU,CAAC;IAClC,OAAO;QACL,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,SAAS,CAAC;QAC3B,OAAO,EAAE,OAAO,CAAC,SAAS,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC;KAChD,CAAC;AACJ,CAAC"}

package/node_modules/@pome-sh/twin-gmail/dist/src/checks.d.ts

@@ -0,0 +1,19 @@
+export type { Check } from "./check-kind.js";
+export type { GmailCheckState, GmailCheckStateDraft, GmailCheckStateLabel, GmailCheckStateMailbox, GmailCheckStateMessage, GmailCheckStateMessageLabel, } from "./check-state.js";
+export declare const GMAIL_CHECKS: readonly [import("./check-kind.js").Check<{
+    message: string;
+    label: string;
+}>, import("./check-kind.js").Check<{
+    label: string;
+}>, import("./check-kind.js").Check<{
+    email: string;
+}>, import("./check-kind.js").Check<{
+    count: string;
+}>, import("./check-kind.js").Check<{
+    mailbox: string;
+    count: string;
+    label: string;
+}>, import("./check-kind.js").Check<{
+    label: string;
+    count: string;
+}>, import("./check-kind.js").Check<Record<string, never>>];

package/node_modules/@pome-sh/twin-gmail/dist/src/checks.js

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// The Gmail twin's assertable check vocabulary (F-1128, milestone A3).
+//
+// These live HERE, next to the state they read, because the twin owns that
+// state's shape. pome-cloud imports this module from npm and adapts each
+// declaration onto its predicate engine, so there is no second copy to
+// reconcile — only a pin that can fall behind, which is what its drift gate
+// exists to catch. The cloud's `deterministic/gmail.ts`, and the mirror of the
+// state shape inside it, are deleted in the same milestone.
+//
+// Gmail comes third in A3 and is the first that needed PLUMBING before
+// vocabulary: unlike slack and stripe it had no in-process seed loader in the
+// control plane at all, so every gmail criterion reported `no_seed_loader` —
+// not a wrong verdict, an absent one. Six criteria across tasks 22, 23 and 27
+// resolved zero of six before this.
+//
+// This file is the ASSEMBLY. Declarations are grouped by what they assert about
+// — `check-messages.ts`, `check-labels.ts`, `check-drafts.ts`, `check-tape.ts` —
+// with typed slots in `check-params.ts`, fixture worlds in `check-worlds.ts`,
+// and the reading of the exported tree in `check-state.ts`.
+import { draftAddressedTo, draftCountAtLeast } from "./check-drafts.js";
+import { labelExists } from "./check-labels.js";
+import { mailboxLabelCount, messageHasLabel, oneMessagePerRecipient } from "./check-messages.js";
+import { noUnsupportedEndpoint } from "./check-tape.js";
+// Order is not first-match-wins — the generated patterns are anchored and
+// mutually exclusive, and `checks-contract.test.ts` proves no sentence is
+// claimed by two. It is the order an authoring surface lists them in, running
+// from the assertion an author reaches for first to the ones a specialised task
+// needs.
+export const GMAIL_CHECKS = [
+    messageHasLabel,
+    labelExists,
+    draftAddressedTo,
+    draftCountAtLeast,
+    mailboxLabelCount,
+    oneMessagePerRecipient,
+    // Last, because these are the only ones that assert about the RUN rather than
+    // the world it left behind — twin-github orders its tape checks the same way.
+    noUnsupportedEndpoint,
+];
+//# sourceMappingURL=checks.js.map

package/node_modules/@pome-sh/twin-gmail/dist/src/checks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks.js","sourceRoot":"","sources":["../../src/checks.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,EAAE;AACF,uEAAuE;AACvE,EAAE;AACF,2EAA2E;AAC3E,yEAAyE;AACzE,uEAAuE;AACvE,4EAA4E;AAC5E,+EAA+E;AAC/E,4DAA4D;AAC5D,EAAE;AACF,uEAAuE;AACvE,8EAA8E;AAC9E,6EAA6E;AAC7E,8EAA8E;AAC9E,oCAAoC;AACpC,EAAE;AACF,gFAAgF;AAChF,iFAAiF;AACjF,8EAA8E;AAC9E,4DAA4D;AAE5D,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AACjG,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAYxD,0EAA0E;AAC1E,0EAA0E;AAC1E,8EAA8E;AAC9E,gFAAgF;AAChF,SAAS;AACT,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,eAAe;IACf,WAAW;IACX,gBAAgB;IAChB,iBAAiB;IACjB,iBAAiB;IACjB,sBAAsB;IACtB,8EAA8E;IAC9E,8EAA8E;IAC9E,qBAAqB;CACb,CAAC"}