@pome-sh/cli 0.21.4 → 0.21.6

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "package": "pome-sh",
-  "version": "0.21.4",
-  "git_sha": "94294d2f36dfd3204a980ba5c55e7a0fdcb5580a",
-  "build_time": "2026-08-05T21:09:37.703Z"
+  "version": "0.21.6",
+  "git_sha": "ba15fcb28538fcf7b6e0717a9ec1b6ccf7a9bd10",
+  "build_time": "2026-08-06T00:27:44.532Z"
 }

package/dist/{checks-2AIHHQC2.js → checks-4GJB73YX.js}

@@ -183,7 +183,7 @@ async function checkTwinReachable(_configDir) {
   });
   let harness;
   try {
-    const { bootTwin } = await import('./twinHarness-YTU4427G.js');
+    const { bootTwin } = await import('./twinHarness-KFZ2ZNAX.js');
     harness = await bootTwin({
       twin: "github",
       seedState: void 0,

package/dist/{chunk-CLGRZY53.js → chunk-4ILBTPO4.js}

@@ -1,8 +1,8 @@
 import { criterionSchema, finalizeResponseSchema, HostedDiscardRefusedError, HostedOrchError, HostedAuthError, HostedQuotaError, submitResultResponseSchema, createEvalSessionResponseSchema, createSessionResponseSchema, sessionPublicSchema } from './chunk-PQYIAA6K.js';
-import { seedSchema, parseSeed, defaultSeedState as defaultSeedState$2 } from './chunk-OKDJRKJV.js';
-import { gmailSeedSchema, defaultSeedState } from './chunk-WVWV7DLA.js';
-import { linearSeedSchema, defaultSeedState as defaultSeedState$1 } from './chunk-APAS34RJ.js';
-import { isTwinName, TWIN_REGISTRY } from './chunk-MBM7LY7E.js';
+import { seedSchema, parseSeed, defaultSeedState as defaultSeedState$2 } from './chunk-SGDUD7KK.js';
+import { gmailSeedSchema, defaultSeedState } from './chunk-NJ246QPJ.js';
+import { linearSeedSchema, defaultSeedState as defaultSeedState$1 } from './chunk-ZKID2HS3.js';
+import { isTwinName, TWIN_REGISTRY } from './chunk-A3IDZXJY.js';
 import { toTwinHttpEventRow } from './chunk-LZIPGCQJ.js';
 import { redactEvent, redactSecrets } from './chunk-SG6ZTIMT.js';
 import { mkdir, appendFile, writeFile, readFile } from 'node:fs/promises';

package/dist/chunk-5ETJZJR6.js

@@ -0,0 +1,590 @@
+import { statePath, defineCheck, VACUITY_SENTINEL, childStatePath, VACUITY_SENTINEL_NUMBER } from './chunk-NY55QTVQ.js';
+
+// ../packages/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;
+}
+
+// ../packages/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, id) {
+  if (state.messages == null)
+    return { missing: "state_incomplete" };
+  const indices = state.messages.map((message2, index) => lower(message2.id) === lower(id) ? index : -1).filter((index) => index >= 0);
+  if (indices.length > 1) {
+    return {
+      missing: `message_ambiguous ("${id}" 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 ("${id}")`, 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 ?? []];
+}
+
+// ../packages/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(id, parts = {}) {
+  return { mailboxEmail: FIXTURE_MAILBOX, id, to: [FIXTURE_MAILBOX], bodyOmitted: true, ...parts };
+}
+function systemLabel(name) {
+  return { mailboxEmail: FIXTURE_MAILBOX, id: name, name, type: "system" };
+}
+function userLabel(id, name) {
+  return { mailboxEmail: FIXTURE_MAILBOX, id, name, type: "user" };
+}
+function messageLabel(messageId2, labelId) {
+  return { mailboxEmail: FIXTURE_MAILBOX, messageId: messageId2, labelId };
+}
+function draft(id, messageId2) {
+  return { mailboxEmail: FIXTURE_MAILBOX, id, messageId: messageId2 };
+}
+function draftAddressedTo(id, recipients) {
+  const messageId2 = `${id}_message`;
+  return {
+    draft: draft(id, messageId2),
+    message: message(messageId2, { to: recipients })
+  };
+}
+
+// ../packages/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: task 22's seed ships one draft addressed to bob, so an
+  // examinee that does nothing does not satisfy this.
+  polarity: () => "positive",
+  //
+  // THE LOAD-BEARING DECLARATION ON THIS CHECK.
+  //
+  // pome-cloud's `corpus.ts` has carried a prediction about this exact criterion
+  // since F-1028: `22-gmail-inbox-triage`'s `alice@example.com` "becomes visible
+  // here as 'unguarded' the day a gmail draft-recipient predicate lands without a
+  // `subject`, which is precisely when it starts to matter." An email address is
+  // squarely inside what a team's redaction config may destroy. Without this
+  // field the evaluator has no way to turn an impossible comparison into an
+  // honest skip, so the criterion scores a vacuous verdict at both doors
+  // instead — and the count of unguarded hazards must stay at zero.
+  subject: ({ email }) => email,
+  // 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 }) => {
+    const wanted = draftAddressedTo("draft_target", [email]);
+    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 }, { final }) {
+    if (final.drafts == null || final.messages == null) {
+      return { passed: false, status: "skipped", reason: "state_incomplete" };
+    }
+    const wanted = email.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 ${email}`,
+        // 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 (F-1197).
+        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 ${email} (${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 this check is the second entry in pome-cloud's
+  // `NUMERIC_SENTINEL_ALLOWED`.
+  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]
+    };
+  }
+});
+
+// ../packages/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 — task 23's 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 (F-1197).
+          ...found.searched === void 0 ? {} : { evidenceStatePaths: [found.searched] }
+        };
+      }
+      return missSkip(found);
+    }
+    return {
+      passed: true,
+      reason: `label "${label}" exists (id ${found.found.id ?? "?"})`,
+      evidenceStatePaths: [found.path]
+    };
+  }
+});
+
+// ../packages/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: id, label }) => {
+    const labels = [systemLabel("INBOX"), userLabel(label, label)];
+    const base = { messages: [message(id)], labels };
+    return {
+      passing: finalWorld(gmailState({ ...base, messageLabels: [messageLabel(id, "INBOX"), messageLabel(id, label)] })),
+      failing: finalWorld(gmailState({ ...base, messageLabels: [messageLabel(id, "INBOX")] }))
+    };
+  },
+  evaluate({ message: id, label }, { final }) {
+    const found = resolveMessage(final, id);
+    if ("missing" in found)
+      return missSkip(found);
+    const carried = messageCarriesLabel(final, id, label);
+    if ("missing" in carried)
+      return missSkip(carried);
+    return {
+      passed: carried.found,
+      reason: carried.found ? `message ${id} carries label ${label}` : `message ${id} 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 (F-1197).
+      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]
+    };
+  }
+});
+
+// ../packages/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 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 }) {
+    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((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;
+  }
+});
+
+// ../packages/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
+];
+
+export { GMAIL_CHECKS };