@pome-sh/checks 0.1.0

package/dist/chunk-GYFGMULG.js

@@ -0,0 +1,1138 @@
+import { statePath, defineCheck, VACUITY_SENTINEL, childStatePath, VACUITY_SENTINEL_NUMBER } from './chunk-4WXX5VPA.js';
+import { z } from 'zod';
+
+// ../twin-gmail/dist/src/check-params.js
+var messageId = {
+  name: "message",
+  pattern: "[A-Za-z0-9_-]{1,128}",
+  example: "msg_support",
+  render: (value) => value,
+  parse: (raw) => raw
+};
+var labelRef = {
+  name: "label",
+  pattern: "[A-Za-z0-9_-]{1,128}",
+  example: "STARRED",
+  render: (value) => value,
+  parse: (raw) => raw
+};
+var labelName = {
+  name: "label",
+  pattern: "[A-Za-z0-9][A-Za-z0-9 _-]{0,127}",
+  example: "Parity Complete",
+  render: (value) => value,
+  parse: (raw) => raw
+};
+var emailAddress = {
+  name: "email",
+  pattern: "[^\\s@\"'`]+@[^\\s@\"'`]+",
+  example: "alice@example.com",
+  render: (value) => value,
+  parse: (raw) => raw
+};
+var mailboxRef = {
+  name: "mailbox",
+  pattern: "[^\\s@\"'`]+@[^\\s@\"'`]+",
+  example: "pome-agent@pome-twin.test",
+  render: (value) => value,
+  parse: (raw) => raw
+};
+var exactCount = {
+  name: "count",
+  pattern: "\\d{1,9}",
+  example: "5",
+  render: (value) => value,
+  parse: (raw) => raw
+};
+var 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
+};
+var 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
+};
+function parseCount(raw) {
+  const trimmed = raw.trim().toLowerCase();
+  if (/^\d+$/.test(trimmed))
+    return Number(trimmed);
+  return NUMBER_WORDS[trimmed] ?? null;
+}
+
+// ../twin-gmail/dist/src/check-state.js
+var MESSAGES_PATH = statePath("messages");
+var DRAFTS_PATH = statePath("drafts");
+var LABELS_PATH = statePath("labels");
+var MESSAGE_LABELS_PATH = statePath("messageLabels");
+function missSkip(miss) {
+  const outcome = { passed: false, status: "skipped", reason: miss.missing };
+  if (miss.searched === void 0)
+    return outcome;
+  return { ...outcome, evidenceStatePaths: [miss.searched] };
+}
+var lower = (value) => (value ?? "").toLowerCase();
+function isTruncated(state, collection) {
+  return (state.exportBounds?.truncatedCollections ?? []).includes(collection);
+}
+function resolveMessage(state, id2) {
+  if (state.messages == null)
+    return { missing: "state_incomplete" };
+  const indices = state.messages.map((message2, index) => lower(message2.id) === lower(id2) ? index : -1).filter((index) => index >= 0);
+  if (indices.length > 1) {
+    return {
+      missing: `message_ambiguous ("${id2}" exists in ${indices.length} mailboxes)`,
+      searched: MESSAGES_PATH
+    };
+  }
+  if (indices.length === 1) {
+    const index = indices[0];
+    return { found: state.messages[index], path: childStatePath(MESSAGES_PATH, index) };
+  }
+  if (isTruncated(state, "messages")) {
+    return { missing: 'collection_truncated ("messages")', searched: MESSAGES_PATH };
+  }
+  return { missing: `message_not_found ("${id2}")`, searched: MESSAGES_PATH };
+}
+function labelIdsFor(state, wanted) {
+  const ids = /* @__PURE__ */ 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;
+}
+function messageCarriesLabel(state, messageId2, wanted) {
+  if (state.messageLabels == null)
+    return { missing: "state_incomplete" };
+  const ids = labelIdsFor(state, wanted);
+  const carried = state.messageLabels.some((row) => lower(row.messageId) === lower(messageId2) && ids.has(lower(row.labelId)));
+  if (!carried && isTruncated(state, "messageLabels")) {
+    return { missing: 'collection_truncated ("messageLabels")', searched: MESSAGE_LABELS_PATH };
+  }
+  return { found: carried, path: MESSAGE_LABELS_PATH };
+}
+function resolveLabelByName(state, name) {
+  if (state.labels == null)
+    return { missing: "state_incomplete" };
+  const index = state.labels.findIndex((label) => lower(label.name) === lower(name));
+  if (index >= 0) {
+    return { found: state.labels[index], path: childStatePath(LABELS_PATH, index) };
+  }
+  if (isTruncated(state, "labels")) {
+    return { missing: 'collection_truncated ("labels")', searched: LABELS_PATH };
+  }
+  return { missing: `label_not_found ("${name}")`, searched: LABELS_PATH };
+}
+function draftRecipients(state, draft2) {
+  const message2 = (state.messages ?? []).find((candidate) => lower(candidate.id) === lower(draft2.messageId));
+  if (!message2)
+    return [];
+  return [...message2.to ?? [], ...message2.cc ?? []];
+}
+
+// ../twin-gmail/dist/src/check-worlds.js
+var FIXTURE_MAILBOX = "pome-agent@pome-twin.test";
+function gmailState(parts = {}) {
+  return {
+    mailboxes: [{ email: FIXTURE_MAILBOX }],
+    messages: [],
+    drafts: [],
+    labels: [],
+    messageLabels: [],
+    exportBounds: { messageBodiesOmitted: true, largeMailbox: false, truncatedCollections: [] },
+    ...parts
+  };
+}
+function finalWorld(final) {
+  return { seed: null, final, tape: null };
+}
+function tapeWorld(tape) {
+  return { seed: null, final: gmailState(), tape };
+}
+function message(id2, parts = {}) {
+  return { mailboxEmail: FIXTURE_MAILBOX, id: id2, to: [FIXTURE_MAILBOX], bodyOmitted: true, ...parts };
+}
+function systemLabel(name) {
+  return { mailboxEmail: FIXTURE_MAILBOX, id: name, name, type: "system" };
+}
+function userLabel(id2, name) {
+  return { mailboxEmail: FIXTURE_MAILBOX, id: id2, name, type: "user" };
+}
+function messageLabel(messageId2, labelId) {
+  return { mailboxEmail: FIXTURE_MAILBOX, messageId: messageId2, labelId };
+}
+function draft(id2, messageId2) {
+  return { mailboxEmail: FIXTURE_MAILBOX, id: id2, messageId: messageId2 };
+}
+function draftAddressedTo(id2, recipients) {
+  const messageId2 = `${id2}_message`;
+  return {
+    draft: draft(id2, messageId2),
+    message: message(messageId2, { to: recipients })
+  };
+}
+
+// ../twin-gmail/dist/src/check-drafts.js
+var draftAddressedTo2 = defineCheck({
+  id: "gmail.draft-addressed-to",
+  description: "Joins every draft to its backing message and asks whether any of them addresses this recipient in `to` or `cc`, compared case-insensitively as an EXACT address rather than a substring. It asserts nothing about the draft's body \u2014 message bodies are digested out of the state export unconditionally, so no check on this twin can read one \u2014 and nothing about whether the draft was left unsent, which is a separate claim. A draft whose backing message did not survive the export contributes no recipients rather than throwing.",
+  template: "A draft addressed to {email} exists",
+  params: { email: emailAddress },
+  substrate: "final",
+  // An achievement: the seeded mailbox already contains a draft with a
+  // recipient, so an examinee that does nothing does not satisfy this.
+  polarity: () => "positive",
+  //
+  // THE LOAD-BEARING DECLARATION ON THIS CHECK.
+  //
+  // `subject` names the value the assertion is actually about, and on this check
+  // that value is an email address — squarely inside what a redaction config may
+  // legitimately destroy before an evaluator ever sees the state. Declaring it
+  // is what lets a consumer detect that the comparison has become impossible and
+  // record an honest skip. Without it there is nothing to detect: the address is
+  // simply absent, the comparison silently cannot match, and the criterion
+  // reports a vacuous verdict that reads like a real one.
+  subject: ({ email: email2 }) => email2,
+  // The address is the scanned literal, so the mutant points at it. It stays
+  // email-shaped so it re-binds to this same check: a mutant that stops matching
+  // evaluates to `unmatched`, which reads as "the verdict moved -> healthy" and
+  // hands the criterion a clean bill it did not earn.
+  vacuityMutant: (args) => ({ ...args, email: `${VACUITY_SENTINEL}@example.invalid` }),
+  discriminatingWorlds: ({ email: email2 }) => {
+    const wanted = draftAddressedTo("draft_target", [email2]);
+    const other = draftAddressedTo("draft_other", ["someone-else@example.com"]);
+    return {
+      passing: finalWorld(gmailState({ drafts: [wanted.draft], messages: [wanted.message] })),
+      failing: finalWorld(gmailState({ drafts: [other.draft], messages: [other.message] }))
+    };
+  },
+  evaluate({ email: email2 }, { final }) {
+    if (final.drafts == null || final.messages == null) {
+      return { passed: false, status: "skipped", reason: "state_incomplete" };
+    }
+    const wanted = email2.toLowerCase();
+    const index = final.drafts.findIndex((entry) => draftRecipients(final, entry).some((to) => to.toLowerCase() === wanted));
+    if (index >= 0) {
+      const hit = final.drafts[index];
+      return {
+        passed: true,
+        reason: `draft ${hit.id ?? "?"} is addressed to ${email2}`,
+        // The DRAFT row, not the backing message that actually holds the
+        // address. A reader following this pointer lands on the thing the
+        // sentence is about — "a draft addressed to X" — and the join to the
+        // message is an implementation detail of how the twin exports, not the
+        // claim.
+        evidenceStatePaths: [childStatePath(DRAFTS_PATH, index)]
+      };
+    }
+    if (isTruncated(final, "drafts") || isTruncated(final, "messages")) {
+      return { passed: false, status: "skipped", reason: "collection_truncated" };
+    }
+    return {
+      passed: false,
+      reason: `no draft is addressed to ${email2} (${final.drafts.length} draft(s) inspected)`,
+      evidenceStatePaths: [DRAFTS_PATH]
+    };
+  }
+});
+var draftCountAtLeast = defineCheck({
+  id: "gmail.draft-count-at-least",
+  description: "Counts the rows in the exported `drafts` collection and asserts there are AT LEAST this many \u2014 a lower bound, so a mailbox with more drafts than asked still passes. It counts drafts the SEED placed there as well as any the examinee created, which means a criterion whose number the seed already satisfies can be passed by an agent that does nothing. That is a property of the task, not of this check, and `measure-criterion-discrimination` is where it surfaces.",
+  template: "At least {count} drafts exist",
+  params: { count: countWord },
+  substrate: "final",
+  polarity: () => "positive",
+  // A threshold, not a literal hunted for inside state — there is nothing here a
+  // redactor could silently delete.
+  subject: () => null,
+  //
+  // The NUMERIC sentinel, and the argument D10 demands before it may be used.
+  //
+  // In every other pattern a numeric capture is a SELECTOR — an issue number, a
+  // PR number — that the predicate RESOLVES before it scans anything, so
+  // falsifying it early-returns "not found" and moves the verdict for a reason
+  // that never reaches the assertion. Here the count is the ONLY slot and there
+  // is nothing to resolve: it is compared directly against a cardinality the
+  // predicate computes, so falsifying it moves the verdict THROUGH the
+  // assertion. That is the same argument `stripe.payment-intent-amount` makes,
+  // and it is why a numeric sentinel is admissible on this check and on very few
+  // others: an evaluator that allowlists the numeric sentinel per check should
+  // expect these two.
+  vacuityMutant: (args) => ({ ...args, count: String(VACUITY_SENTINEL_NUMBER) }),
+  discriminatingWorlds: ({ count }) => {
+    const wanted = parseCount(count) ?? 1;
+    const build = (n) => {
+      const pairs = Array.from({ length: n }, (_, i) => draftAddressedTo(`draft_${i}`, ["a@example.com"]));
+      return gmailState({
+        drafts: pairs.map((p) => p.draft),
+        messages: pairs.map((p) => p.message)
+      });
+    };
+    return { passing: finalWorld(build(wanted)), failing: finalWorld(build(Math.max(0, wanted - 1))) };
+  },
+  evaluate({ count }, { final }) {
+    const wanted = parseCount(count);
+    if (wanted === null) {
+      return { passed: false, status: "skipped", reason: `uncountable ("${count}")` };
+    }
+    if (final.drafts == null)
+      return { passed: false, status: "skipped", reason: "state_incomplete" };
+    const total = final.drafts.length;
+    if (total < wanted && isTruncated(final, "drafts")) {
+      return { passed: false, status: "skipped", reason: 'collection_truncated ("drafts")' };
+    }
+    return {
+      passed: total >= wanted,
+      reason: `${total} draft(s) exist (wanted at least ${wanted})`,
+      // The collection whose LENGTH is the assertion. There is no narrower
+      // address for a cardinality.
+      evidenceStatePaths: [DRAFTS_PATH]
+    };
+  }
+});
+
+// ../twin-gmail/dist/src/check-labels.js
+var labelExists = defineCheck({
+  id: "gmail.label-exists",
+  description: "Asks whether the mailbox defines a label with this DISPLAY NAME, compared case-insensitively the way the twin's own seeder keys its uniqueness lookup. It reads the `labels` collection only \u2014 a label that exists but has been applied to nothing still passes, and a message carrying a label is `gmail.message-has-label`'s question, not this one. It deliberately does NOT match on the minted id: `Label_follow_up` is an id and `Follow Up` is the name of that same label, and letting one sentence mean both would make the assertion unreadable.",
+  // The name slot admits spaces, which is what the corpus needs (`Parity
+  // Complete`) and what separates this template from `gmail.message-has-label`'s
+  // id slot. The two cannot claim one sentence: this one says "A label named",
+  // that one says "Message ... has label".
+  template: "A label named {label} exists",
+  params: { label: labelName },
+  substrate: "final",
+  // An achievement — the seed defines no `Parity Complete`, so the
+  // examinee has to create it.
+  polarity: () => "positive",
+  // The name is a caller-supplied literal compared against state.
+  subject: ({ label }) => label,
+  vacuityMutant: (args) => ({ ...args, label: VACUITY_SENTINEL }),
+  discriminatingWorlds: ({ label }) => ({
+    // Both worlds carry a non-empty `labels` collection, so the failing world
+    // fails on the ASSERTION (`label_not_found`) rather than reproducing the
+    // `state_incomplete` an empty world gives — the degenerate arm the probe
+    // rejects.
+    passing: finalWorld(gmailState({ labels: [systemLabel("INBOX"), userLabel("Label_1", label)] })),
+    failing: finalWorld(gmailState({ labels: [systemLabel("INBOX")] }))
+  }),
+  evaluate({ label }, { final }) {
+    const found = resolveLabelByName(final, label);
+    if ("missing" in found) {
+      if (found.missing.startsWith("label_not_found")) {
+        return {
+          passed: false,
+          reason: `no label named "${label}" exists`,
+          // The label COLLECTION — the honest citation for a lookup that found
+          // nothing, and the arm a reader most wants to open: see for yourself
+          // that the name is not in it.
+          ...found.searched === void 0 ? {} : { evidenceStatePaths: [found.searched] }
+        };
+      }
+      return missSkip(found);
+    }
+    return {
+      passed: true,
+      reason: `label "${label}" exists (id ${found.found.id ?? "?"})`,
+      evidenceStatePaths: [found.path]
+    };
+  }
+});
+
+// ../twin-gmail/dist/src/check-messages.js
+var messageHasLabel = defineCheck({
+  id: "gmail.message-has-label",
+  description: "Looks the message up by id, then asks the `messageLabels` JOIN whether any row links it to the named label. The label may be given as its minted id (`Label_follow_up`) or as the display name of the same label (`Follow Up`); a system label carries both as one string (`INBOX`, `STARRED`). It asserts nothing about the message's OTHER labels \u2014 a message carrying the named label plus five more passes. A message the export does not carry is a SKIP, not a fail, and so is a label collection the export truncated: absent from a capped list is not absent.",
+  template: "Message {message} has label {label}",
+  params: { message: messageId, label: labelRef },
+  substrate: "final",
+  // An achievement. The seed leaves `msg_support` on INBOX/UNREAD only, so the
+  // examinee has to act for this to hold.
+  polarity: () => "positive",
+  // The label is a caller-supplied literal compared against state, so it is
+  // declared. No first-party redactor pattern touches a Gmail label id, which is
+  // exactly why declaring it keeps that a verified fact rather than an
+  // assumption — a team's own redaction config is not first-party.
+  subject: ({ label }) => label,
+  // The message id only SELECTS; falsifying it moves the verdict through the
+  // lookup rather than the assertion. The label is the scanned literal.
+  vacuityMutant: (args) => ({ ...args, label: VACUITY_SENTINEL }),
+  discriminatingWorlds: ({ message: id2, label }) => {
+    const labels = [systemLabel("INBOX"), userLabel(label, label)];
+    const base = { messages: [message(id2)], labels };
+    return {
+      passing: finalWorld(gmailState({ ...base, messageLabels: [messageLabel(id2, "INBOX"), messageLabel(id2, label)] })),
+      failing: finalWorld(gmailState({ ...base, messageLabels: [messageLabel(id2, "INBOX")] }))
+    };
+  },
+  evaluate({ message: id2, label }, { final }) {
+    const found = resolveMessage(final, id2);
+    if ("missing" in found)
+      return missSkip(found);
+    const carried = messageCarriesLabel(final, id2, label);
+    if ("missing" in carried)
+      return missSkip(carried);
+    return {
+      passed: carried.found,
+      reason: carried.found ? `message ${id2} carries label ${label}` : `message ${id2} does not carry label ${label}`,
+      // BOTH halves of the lookup, because the predicate really does read two
+      // places: the message row it resolved by id, and the join table it then
+      // questioned. Labels are not nested under their message in this export —
+      // that is the whole reason `messageCarriesLabel` exists — so one pointer
+      // could not say where this verdict came from.
+      evidenceStatePaths: [found.path, carried.path]
+    };
+  }
+});
+var mailboxLabelCount = defineCheck({
+  id: "gmail.mailbox-label-count",
+  description: "Counts the messages in the named mailbox that the `messageLabels` JOIN links to the named label, and asserts the total is EXACTLY the number given. Not 'at least' \u2014 a mailbox with six SENT messages fails a criterion asking for five, which is what makes it able to catch a duplicate send. A mailbox the export lists but does not contain is a SKIP; so is a truncated collection.",
+  template: "The mailbox `{mailbox}` has exactly {count} messages labeled {label}",
+  params: { mailbox: mailboxRef, count: exactCount, label: labelRef },
+  substrate: "final",
+  // The count carries the direction: asserting zero is a prohibition, any
+  // other count is work the examinee must do. Preserved from the legacy rule,
+  // which computed the same thing per match.
+  polarity: ({ count }) => Number(count) === 0 ? "negative" : "positive",
+  subject: ({ label }) => label,
+  // The mailbox resolves and the count is compared to a derived total; the
+  // label is the literal actually scanned in state. Pointing the mutant at the
+  // count would falsify a threshold rather than a lookup — see
+  // `gmail.draft-count-at-least`, where the count IS the only slot.
+  vacuityMutant: (args) => ({ ...args, label: VACUITY_SENTINEL }),
+  discriminatingWorlds: ({ mailbox, count, label }) => {
+    const wanted = Number(count);
+    const world = (n) => {
+      const messages = Array.from({ length: n }, (_, i) => message(`msg_${i}`, { mailboxEmail: mailbox }));
+      return gmailState({
+        mailboxes: [{ email: mailbox }],
+        messages,
+        labels: [systemLabel(label)],
+        messageLabels: messages.map((m) => ({ mailboxEmail: mailbox, messageId: m.id, labelId: label }))
+      });
+    };
+    return { passing: finalWorld(world(wanted)), failing: finalWorld(world(wanted + 1)) };
+  },
+  evaluate({ mailbox, count, label }, { final }) {
+    const wanted = Number(count);
+    if (final.messages == null || final.messageLabels == null) {
+      return { passed: false, status: "skipped", reason: "state_incomplete" };
+    }
+    if (isTruncated(final, "messages") || isTruncated(final, "messageLabels")) {
+      return { passed: false, status: "skipped", reason: "collection_truncated" };
+    }
+    if (final.mailboxes != null && !final.mailboxes.some((mb) => (mb.email ?? "").toLowerCase() === mailbox.toLowerCase())) {
+      return { passed: false, status: "skipped", reason: `mailbox_not_found ("${mailbox}")` };
+    }
+    const ids = labelIdsFor(final, label);
+    const labeled = new Set(final.messageLabels.filter((row) => ids.has((row.labelId ?? "").toLowerCase())).map((row) => (row.messageId ?? "").toLowerCase()));
+    const total = final.messages.filter((msg) => (msg.mailboxEmail ?? "").toLowerCase() === mailbox.toLowerCase() && msg.id != null && labeled.has(msg.id.toLowerCase())).length;
+    return {
+      passed: total === wanted,
+      reason: `mailbox "${mailbox}" has ${total} message(s) labeled ${label} (wanted ${wanted})`,
+      // The two collections the count is computed FROM. The count itself lives
+      // nowhere in the tree, so there is no narrower honest address — and the
+      // guards above already established that both collections are present and
+      // un-capped, which is what makes these pointers resolve.
+      evidenceStatePaths: [MESSAGES_PATH, MESSAGE_LABELS_PATH]
+    };
+  }
+});
+var oneMessagePerRecipient = defineCheck({
+  id: "gmail.one-message-per-recipient",
+  description: "Flattens every addressee across the messages carrying the named label and asserts each address appears EXACTLY ONCE \u2014 and, when a count is named, that there are that many messages, that many distinct recipients, and no more addressee slots than that. It is the assertion that separates 'sent to everyone' from 'sent to everyone, some of them twice', which an exact total alone cannot do.",
+  template: "Exactly one {label} message is addressed to each of the {count} recipients",
+  params: { label: labelRef, count: countWord },
+  substrate: "final",
+  polarity: () => "positive",
+  subject: ({ label }) => label,
+  // The label is scanned; the count is a declared arity compared to a derived
+  // one. Same argument as `mailboxLabelCount`.
+  vacuityMutant: (args) => ({ ...args, label: VACUITY_SENTINEL }),
+  discriminatingWorlds: ({ label, count }) => {
+    const wanted = parseCount(count) ?? 1;
+    const recipients = Array.from({ length: wanted }, (_, i) => `user${i}@example.com`);
+    const build = (addressees) => {
+      const messages = addressees.map((to, i) => message(`msg_${i}`, { to }));
+      return finalWorld(gmailState({
+        messages,
+        labels: [systemLabel(label)],
+        messageLabels: messages.map((m) => messageLabel(m.id, label))
+      }));
+    };
+    return {
+      passing: build(recipients.map((r) => [r])),
+      // The DUPLICATE SEND, not a missing one: the same number of messages, one
+      // recipient served twice and another not at all. A world with fewer
+      // messages would fail on arity, which the exact-count check already covers.
+      failing: build([[recipients[0]], ...recipients.slice(2).map((r) => [r]), [recipients[0]]])
+    };
+  },
+  evaluate({ label, count }, { final }) {
+    const wanted = parseCount(count);
+    if (final.messages == null || final.messageLabels == null) {
+      return { passed: false, status: "skipped", reason: "state_incomplete" };
+    }
+    if (isTruncated(final, "messages") || isTruncated(final, "messageLabels")) {
+      return { passed: false, status: "skipped", reason: "collection_truncated" };
+    }
+    const ids = labelIdsFor(final, label);
+    const labeled = new Set(final.messageLabels.filter((row) => ids.has((row.labelId ?? "").toLowerCase())).map((row) => (row.messageId ?? "").toLowerCase()));
+    const sent = final.messages.filter((msg) => msg.id != null && labeled.has(msg.id.toLowerCase()));
+    const addressees = sent.flatMap((msg) => (msg.to ?? []).map((to) => to.toLowerCase()));
+    const distinct = new Set(addressees);
+    const noDuplicates = addressees.length === distinct.size;
+    const arityOk = wanted == null ? sent.length === distinct.size : sent.length === wanted && distinct.size === wanted && addressees.length === wanted;
+    const passed = noDuplicates && arityOk;
+    return {
+      passed,
+      reason: passed ? `${sent.length} ${label} message(s), one per distinct recipient, no duplicates` : `${sent.length} ${label} message(s) to ${distinct.size} distinct recipient(s) (${addressees.length} addressee slot(s)${wanted == null ? "" : `, wanted ${wanted}`}${noDuplicates ? "" : ", duplicate send detected"})`,
+      // Same two collections, same reason: the duplicate this check exists to
+      // catch is a property of the addressee lists across `messages`, filtered
+      // by `messageLabels`, and neither the flattened list nor its distinct set
+      // is anything the tree holds.
+      evidenceStatePaths: [MESSAGES_PATH, MESSAGE_LABELS_PATH]
+    };
+  }
+});
+
+// ../twin-gmail/dist/src/check-tape.js
+var noUnsupportedEndpoint = defineCheck({
+  id: "gmail.no-unsupported-endpoint",
+  description: 'Scans the recorded call tape for any request the twin answered with fidelity "unsupported" \u2014 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 \u2014 which matters here, because a single task may run 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 }) {
+    if (tape === null)
+      return { passed: false, reason: "tape_missing", status: "skipped" };
+    const unsupported = tape.filter((event) => event.fidelity === "unsupported");
+    if (unsupported.length === 0) {
+      return {
+        passed: true,
+        reason: `no unsupported Gmail endpoint was called (${tape.length} call(s) inspected)`
+      };
+    }
+    const evidenceEventIds = unsupported.map((event) => event.event_id).filter((id2) => typeof id2 === "string" && id2 !== "");
+    const outcome = {
+      passed: false,
+      reason: `${unsupported.length} unsupported Gmail call(s): [${unsupported.map((event) => event.path ?? "?").join(", ")}]`
+    };
+    return evidenceEventIds.length > 0 ? { ...outcome, evidenceEventIds } : outcome;
+  }
+});
+
+// ../twin-gmail/dist/src/checks.js
+var GMAIL_CHECKS = [
+  messageHasLabel,
+  labelExists,
+  draftAddressedTo2,
+  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
+];
+var GmailError = class extends Error {
+  status;
+  reason;
+  constructor(status, reason, message2) {
+    super(message2);
+    this.status = status;
+    this.reason = reason;
+    this.name = "GmailError";
+  }
+};
+function invalidArgument(message2) {
+  throw new GmailError(400, "invalidArgument", message2);
+}
+
+// ../twin-gmail/dist/src/faults.js
+var KNOWN_FAULT_NAMES = ["rate-limited"];
+var gmailFaultSchema = z.object({
+  name: z.enum(KNOWN_FAULT_NAMES),
+  target: z.string().min(1).max(128).default("messages.send"),
+  succeedFirst: z.number().int().nonnegative().max(1e3).default(2),
+  throttleFor: z.number().int().positive().max(1e3).default(3),
+  retryAfterSeconds: z.number().int().positive().max(3600).default(1)
+}).strict();
+
+// ../twin-gmail/dist/src/search-parse.js
+var MAX_QUERY_BYTES = 4096;
+var MAX_TOKENS = 256;
+var MAX_DEPTH = 20;
+var MAX_BRANCHES = 256;
+var KNOWN_FIELDS = /* @__PURE__ */ new Set([
+  "from",
+  "to",
+  "cc",
+  "bcc",
+  "deliveredto",
+  "list",
+  "subject",
+  "rfc822msgid",
+  "filename",
+  "after",
+  "newer",
+  "before",
+  "older",
+  "newer_than",
+  "older_than",
+  "size",
+  "larger",
+  "smaller",
+  "label",
+  "category",
+  "in",
+  "is",
+  "has"
+]);
+var CATEGORY_LABELS = {
+  primary: "CATEGORY_PERSONAL",
+  personal: "CATEGORY_PERSONAL",
+  social: "CATEGORY_SOCIAL",
+  promotions: "CATEGORY_PROMOTIONS",
+  updates: "CATEGORY_UPDATES",
+  forums: "CATEGORY_FORUMS"
+};
+function validateSearchQuery(query) {
+  const node = parseSearchQuery(query);
+  const walk = (current) => {
+    switch (current.type) {
+      case "and":
+      case "or":
+        for (const child of current.children)
+          walk(child);
+        return;
+      case "not":
+        walk(current.child);
+        return;
+      case "around":
+        return;
+      case "term":
+        assertSearchTerm(current.field, current.value);
+        return;
+    }
+  };
+  walk(node);
+  return node;
+}
+function assertSearchTerm(field, value) {
+  if (!field)
+    return;
+  if (!KNOWN_FIELDS.has(field)) {
+    invalidArgument(`Unsupported search operator: ${field}`);
+  }
+  if (field === "category") {
+    if (!CATEGORY_LABELS[value.toLocaleLowerCase("en-US")]) {
+      invalidArgument(`Unsupported search category: ${value}`);
+    }
+    return;
+  }
+  if (field === "after" || field === "newer" || field === "before" || field === "older") {
+    parseDate(value);
+    return;
+  }
+  if (field === "newer_than" || field === "older_than") {
+    parseDuration(value);
+    return;
+  }
+  if (field === "size" || field === "larger" || field === "smaller") {
+    parseSize(value);
+    return;
+  }
+  if (field === "has") {
+    assertHasOperator(value);
+  }
+}
+function parseSearchQuery(query) {
+  if (Buffer.byteLength(query) > MAX_QUERY_BYTES)
+    invalidArgument("Search query exceeds limit");
+  const tokens = tokenize(query);
+  if (tokens.length > MAX_TOKENS)
+    invalidArgument("Search query has too many tokens");
+  if (tokens.length === 0)
+    return { type: "and", children: [] };
+  let position = 0;
+  const parseExpression = (depth, stop) => {
+    if (depth > MAX_DEPTH)
+      invalidArgument("Search query nesting exceeds limit");
+    const alternatives = [];
+    let conjunction = [];
+    const flush = () => {
+      alternatives.push(conjunction.length === 1 ? conjunction[0] : { type: "and", children: conjunction });
+      conjunction = [];
+    };
+    while (position < tokens.length) {
+      const token = tokens[position];
+      if (stop && token.value === stop)
+        break;
+      if (token.value.toUpperCase() === "OR") {
+        position++;
+        if (!conjunction.length)
+          invalidArgument("OR requires a left expression");
+        flush();
+        continue;
+      }
+      if (token.value.toUpperCase() === "AND") {
+        position++;
+        continue;
+      }
+      conjunction.push(parsePrimary(depth + 1));
+    }
+    if (conjunction.length)
+      flush();
+    if (!alternatives.length)
+      return { type: "and", children: [] };
+    return alternatives.length === 1 ? alternatives[0] : { type: "or", children: alternatives };
+  };
+  const parsePrimary = (depth) => {
+    const token = tokens[position++];
+    if (token.value === "(" || token.value === "{") {
+      const end = token.value === "(" ? ")" : "}";
+      const child = parseExpression(depth, end);
+      if (tokens[position]?.value !== end)
+        invalidArgument(`Unclosed ${token.value}`);
+      position++;
+      return token.value === "{" ? makeImplicitOr(child) : child;
+    }
+    if (token.value === ")" || token.value === "}")
+      invalidArgument(`Unexpected ${token.value}`);
+    let value = token.value;
+    let negate = false;
+    if (value === "-") {
+      negate = true;
+      const next = tokens[position++];
+      if (!next)
+        invalidArgument("Negation requires an expression");
+      position--;
+      const child = parsePrimary(depth + 1);
+      return { type: "not", child };
+    }
+    if (value.startsWith("-") && value.length > 1) {
+      negate = true;
+      value = value.slice(1);
+    }
+    const around = tokens[position]?.value.toUpperCase() === "AROUND";
+    if (around) {
+      position++;
+      const distance = Number(tokens[position++]?.value);
+      const right = tokens[position++]?.value;
+      if (!Number.isInteger(distance) || distance < 1 || distance > 100 || !right) {
+        invalidArgument("AROUND requires a distance and right term");
+      }
+      const node2 = { type: "around", left: value, right, distance };
+      return negate ? { type: "not", child: node2 } : node2;
+    }
+    const colon = value.indexOf(":");
+    let node;
+    if (colon > 0) {
+      const field = value.slice(0, colon).toLowerCase();
+      let fieldValue = value.slice(colon + 1);
+      if (!fieldValue && (tokens[position]?.value === "(" || tokens[position]?.value === "{")) {
+        node = parseFieldGroup(field, depth + 1);
+        return negate ? { type: "not", child: node } : node;
+      }
+      if (!fieldValue && tokens[position] && !["AND", "OR", ")", "}"].includes(tokens[position].value.toUpperCase())) {
+        fieldValue = tokens[position++].value;
+      }
+      node = { type: "term", field, value: fieldValue, exact: token.quoted };
+    } else {
+      node = { type: "term", value: value.startsWith("+") ? value.slice(1) : value, exact: token.quoted || value.startsWith("+") };
+    }
+    return negate ? { type: "not", child: node } : node;
+  };
+  const parseFieldGroup = (field, depth) => {
+    if (depth > MAX_DEPTH)
+      invalidArgument("Search query nesting exceeds limit");
+    const opening = tokens[position++].value;
+    const end = opening === "(" ? ")" : "}";
+    const groups = [[]];
+    while (position < tokens.length && tokens[position].value !== end) {
+      const token = tokens[position++];
+      if (token.value.toUpperCase() === "OR") {
+        groups.push([]);
+        continue;
+      }
+      if (token.value.toUpperCase() === "AND")
+        continue;
+      if (["(", "{", ")", "}"].includes(token.value))
+        invalidArgument("Nested field groups are unsupported");
+      let value = token.value;
+      let negate = false;
+      if (value.startsWith("-")) {
+        negate = true;
+        value = value.slice(1);
+      }
+      const term = { type: "term", field, value, exact: token.quoted };
+      groups.at(-1).push(negate ? { type: "not", child: term } : term);
+    }
+    if (tokens[position]?.value !== end)
+      invalidArgument(`Unclosed ${opening}`);
+    position++;
+    const nodes = groups.map((children) => children.length === 1 ? children[0] : { type: "and", children });
+    const useOr = opening === "{" || nodes.length > 1;
+    return useOr ? { type: "or", children: nodes } : nodes[0] ?? { type: "and", children: [] };
+  };
+  const root = parseExpression(0);
+  if (position !== tokens.length)
+    invalidArgument("Unexpected search token");
+  if (countBranches(root) > MAX_BRANCHES)
+    invalidArgument("Search query has too many branches");
+  return root;
+}
+function assertHasOperator(value) {
+  const normalized = value.toLocaleLowerCase("en-US");
+  if (normalized.endsWith("-star")) {
+    invalidArgument(`Unsupported colored-star operator: has:${value}; twin maps only STARRED via is:starred`);
+  }
+}
+function parseDate(value) {
+  const normalized = /^\d{4}\/\d{1,2}\/\d{1,2}$/.test(value) ? value.replaceAll("/", "-") : value;
+  const date = Date.parse(`${normalized}${/^\d{4}-\d/.test(normalized) ? "T00:00:00Z" : ""}`);
+  if (Number.isNaN(date))
+    invalidArgument(`Invalid search date: ${value}`);
+  return date;
+}
+function parseDuration(value) {
+  const match = value.match(/^(\d+)([dmy])$/i);
+  if (!match)
+    invalidArgument(`Invalid search duration: ${value}`);
+  const units = { d: 864e5, m: 30 * 864e5, y: 365 * 864e5 };
+  return Number(match[1]) * units[match[2].toLowerCase()];
+}
+function parseSize(value) {
+  const match = value.match(/^(\d+(?:\.\d+)?)([kmg])?$/i);
+  if (!match)
+    invalidArgument(`Invalid search size: ${value}`);
+  const scale = { k: 1024, m: 1024 ** 2, g: 1024 ** 3 };
+  return Math.floor(Number(match[1]) * (match[2] ? scale[match[2].toLowerCase()] : 1));
+}
+function countBranches(node) {
+  switch (node.type) {
+    case "and":
+    case "or":
+      return node.children.reduce((sum, child) => sum + countBranches(child), 0);
+    case "not":
+      return countBranches(node.child);
+    case "around":
+    case "term":
+      return 1;
+  }
+}
+function tokenize(query) {
+  const out = [];
+  let index = 0;
+  while (index < query.length) {
+    if (/\s/.test(query[index])) {
+      index++;
+      continue;
+    }
+    const char = query[index];
+    if ("(){}".includes(char)) {
+      out.push({ value: char });
+      index++;
+      continue;
+    }
+    let value = "";
+    let quoted = false;
+    while (index < query.length && !/\s/.test(query[index]) && !"(){}".includes(query[index])) {
+      if (query[index] === '"') {
+        quoted = true;
+        index++;
+        while (index < query.length && query[index] !== '"') {
+          if (query[index] === "\\" && index + 1 < query.length)
+            index++;
+          value += query[index++];
+        }
+        if (query[index] !== '"')
+          invalidArgument("Unclosed search quote");
+        index++;
+      } else {
+        value += query[index++];
+      }
+    }
+    if (value)
+      out.push({ value, quoted });
+  }
+  return out;
+}
+function makeImplicitOr(node) {
+  return node.type === "and" ? { type: "or", children: node.children } : node;
+}
+
+// ../twin-gmail/dist/src/seed.js
+var email = z.string().trim().email().transform((value) => value.toLowerCase());
+var id = z.string().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/);
+var attachmentSchema = z.object({
+  filename: z.string().max(512),
+  mimeType: z.string().min(1).max(255).default("application/octet-stream"),
+  disposition: z.enum(["attachment", "inline"]).default("attachment"),
+  contentId: z.string().max(998).optional(),
+  data: z.string().max(5e7)
+}).strict();
+var messageFields = {
+  id: id.optional(),
+  threadId: id.optional(),
+  raw: z.string().max(5e7).optional(),
+  from: email.optional(),
+  to: z.array(email).max(500).default([]),
+  cc: z.array(email).max(500).default([]),
+  bcc: z.array(email).max(500).default([]),
+  subject: z.string().max(998).default(""),
+  text: z.string().max(25e6).default(""),
+  html: z.string().max(25e6).default(""),
+  date: z.string().datetime({ offset: true }).optional(),
+  messageId: z.string().min(3).max(998).optional(),
+  inReplyTo: z.string().max(998).optional(),
+  references: z.array(z.string().max(998)).max(100).default([]),
+  attachments: z.array(attachmentSchema).max(100).default([])
+};
+var messageSchema = z.object({
+  ...messageFields,
+  labels: z.array(z.string().min(1).max(255)).max(100).default([])
+}).strict();
+var draftSchema = z.object(messageFields).strict();
+var labelSchema = z.object({
+  id: id.optional(),
+  name: z.string().trim().min(1).max(225),
+  color: z.object({
+    textColor: z.string().max(32).optional(),
+    backgroundColor: z.string().max(32).optional()
+  }).strict().optional()
+}).strict();
+var filterSchema = z.object({
+  id: id.optional(),
+  criteria: z.object({
+    from: z.string().max(998).optional(),
+    to: z.string().max(998).optional(),
+    subject: z.string().max(998).optional(),
+    query: z.string().max(4096).optional(),
+    negatedQuery: z.string().max(4096).optional(),
+    hasAttachment: z.boolean().optional(),
+    excludeChats: z.boolean().optional(),
+    size: z.number().int().nonnegative().optional(),
+    sizeComparison: z.enum(["larger", "smaller"]).optional()
+  }).strict().default({}),
+  action: z.object({
+    addLabelIds: z.array(z.string().min(1)).max(100).default([]),
+    removeLabelIds: z.array(z.string().min(1)).max(100).default([]),
+    forward: email.optional()
+  }).strict().default({ addLabelIds: [], removeLabelIds: [] })
+}).strict();
+var sendAsSchema = z.object({
+  sendAsEmail: email,
+  displayName: z.string().max(256).default(""),
+  replyToAddress: email.optional(),
+  isPrimary: z.boolean().default(false),
+  isDefault: z.boolean().default(false),
+  verificationStatus: z.enum(["accepted", "pending"]).default("accepted")
+}).strict();
+var mailboxSchema = z.object({
+  email,
+  displayName: z.string().max(256).default(""),
+  labels: z.array(labelSchema).max(5e3).default([]),
+  messages: z.array(messageSchema).max(1e4).default([]),
+  drafts: z.array(draftSchema).max(5e3).default([]),
+  filters: z.array(filterSchema).max(1e3).default([]),
+  forwardingAddresses: z.array(z.object({
+    forwardingEmail: email,
+    verificationStatus: z.enum(["accepted", "pending"]).default("pending")
+  }).strict()).max(1e3).default([]),
+  sendAs: z.array(sendAsSchema).max(1e3).default([])
+}).strict();
+var gmailSeedSchema = z.object({
+  primaryMailbox: mailboxSchema,
+  mailboxes: z.array(mailboxSchema).max(100).default([]),
+  deliveryMode: z.enum(["sender-only", "seeded-mailboxes"]).default("sender-only"),
+  clock: z.string().datetime({ offset: true }).default("2025-01-01T00:00:00.000Z"),
+  faults: z.array(gmailFaultSchema).max(50).default([])
+}).strict().superRefine((seed, ctx) => {
+  const emails = [seed.primaryMailbox.email, ...seed.mailboxes.map((mailbox) => mailbox.email)];
+  const seen = /* @__PURE__ */ new Set();
+  for (const mailboxEmail of emails) {
+    if (seen.has(mailboxEmail)) {
+      ctx.addIssue({ code: "custom", message: `Duplicate mailbox: ${mailboxEmail}` });
+    }
+    seen.add(mailboxEmail);
+  }
+  for (const mailbox of [seed.primaryMailbox, ...seed.mailboxes]) {
+    const labelNames = /* @__PURE__ */ new Set();
+    for (const label of mailbox.labels) {
+      const key = label.name.toLowerCase();
+      if (labelNames.has(key)) {
+        ctx.addIssue({ code: "custom", message: `Duplicate label in ${mailbox.email}: ${label.name}` });
+      }
+      labelNames.add(key);
+    }
+    for (const filter of mailbox.filters) {
+      if (filter.action.forward) {
+        ctx.addIssue({
+          code: "custom",
+          message: `Filter forwarding is unsupported: ${mailbox.email}`
+        });
+      }
+      for (const key of ["query", "negatedQuery"]) {
+        const value = filter.criteria[key];
+        if (!value)
+          continue;
+        try {
+          validateSearchQuery(value);
+        } catch (error) {
+          ctx.addIssue({
+            code: "custom",
+            message: `Invalid filter ${key} in ${mailbox.email}: ${error.message}`
+          });
+        }
+      }
+    }
+  }
+});
+function parseSeed(input) {
+  return gmailSeedSchema.parse(input);
+}
+var DEFAULT_GMAIL_AGENT_EMAIL = "pome-agent@pome-twin.test";
+function agentPathInboxMailbox(email2 = DEFAULT_GMAIL_AGENT_EMAIL) {
+  return {
+    email: email2,
+    displayName: "Pome Agent",
+    labels: [
+      { id: "Label_follow_up", name: "Follow Up" },
+      { id: "Label_build", name: "Build" }
+    ],
+    messages: [
+      {
+        id: "msg_welcome",
+        threadId: "thread_welcome",
+        from: "welcome@pome-twin.test",
+        to: [email2],
+        subject: "Welcome to your Pome Gmail twin",
+        text: "Your deterministic inbox is ready for agent testing.",
+        html: "<p>Your deterministic inbox is ready for agent testing.</p>",
+        date: "2026-07-18T09:00:00.000Z",
+        messageId: "welcome@pome-twin.test",
+        labels: ["INBOX"]
+      },
+      {
+        id: "msg_build",
+        threadId: "thread_build",
+        from: "ci@example.com",
+        to: [email2],
+        subject: "Build failed on main",
+        text: "The nightly build failed. See the attached log.",
+        date: "2026-07-19T10:00:00.000Z",
+        messageId: "build-001@example.com",
+        labels: ["INBOX", "UNREAD", "Build"],
+        attachments: [
+          {
+            filename: "build.log",
+            mimeType: "text/plain",
+            data: Buffer.from("BUILD FAILED step=test\n", "utf8").toString("base64")
+          }
+        ]
+      },
+      {
+        id: "msg_build_reply",
+        threadId: "thread_build",
+        from: email2,
+        to: ["ci@example.com"],
+        subject: "Re: Build failed on main",
+        text: "Looking into the failure now.",
+        date: "2026-07-19T11:00:00.000Z",
+        messageId: "build-reply@pome-twin.test",
+        inReplyTo: "build-001@example.com",
+        references: ["build-001@example.com"],
+        labels: ["SENT"]
+      },
+      {
+        id: "msg_support",
+        threadId: "thread_support",
+        from: "alice@example.com",
+        to: [email2],
+        subject: "Production export is stuck",
+        text: "Our production export has been stuck for an hour. Can you investigate?",
+        date: "2026-07-19T12:00:00.000Z",
+        messageId: "support-001@example.com",
+        labels: ["INBOX", "UNREAD"]
+      }
+    ],
+    drafts: [
+      {
+        id: "draft_ack",
+        threadId: "thread_draft_ack",
+        to: ["bob@example.com"],
+        subject: "Draft acknowledgment",
+        text: "Thanks \u2014 I'll follow up shortly.",
+        date: "2026-07-19T13:00:00.000Z",
+        messageId: "draft-ack@pome-twin.test"
+      }
+    ],
+    filters: [],
+    forwardingAddresses: [],
+    sendAs: []
+  };
+}
+function defaultSeedState() {
+  return {
+    primaryMailbox: agentPathInboxMailbox(),
+    mailboxes: [],
+    deliveryMode: "sender-only",
+    clock: "2026-07-20T00:00:00.000Z"
+  };
+}
+
+export { GMAIL_CHECKS, defaultSeedState, gmailSeedSchema, parseSeed };