@pome-sh/checks 0.1.3 → 0.1.5

package/CHANGELOG.md

@@ -1,5 +1,72 @@
 # @pome-sh/checks
 
+## 0.1.5
+
+`slack.no-reaction-added` now refuses instead of scoring a free pass (F-1159).
+Its predicate filtered the exported `reactions` collection with `(final.reactions
+?? []).some(…)`, so a state export carrying no `reactions` section at all
+filtered to zero rows and scored this NEGATIVE criterion `passed` — an agent
+that really added the reaction still collected the point. It now checks
+`final.reactions == null` first and returns `state_incomplete`, matching
+twin-github's `pull.reviews == null` / `pull.comments == null` skips: absent is
+not the same as none.
+
+This closes the gap the same class of criterion in twin-github never had, and
+it is why pome-cloud's `STATE_SECTION_GUARDS` carried a stopgap row for this one
+check (F-1156) — that row is now redundant. No check id, template or polarity
+changed, so no criterion moves from bound to unbound; this only affects the
+verdict on the one export shape (`reactions` absent) that used to be misgraded,
+and on that shape the cloud already returned `state_incomplete` via the stopgap.
+The grade a real run receives does not move.
+
+**What pome-cloud must do, and it is TWO edits, not one.** Pinning `0.1.5`
+turns `declared-pin.test.ts` red on its own, before anybody touches the guard
+table, so a follow-up that only deletes the row will not go green:
+
+1. Delete the `slack.no-reaction-added` row from `STATE_SECTION_GUARDS`
+   (`apps/control-plane/src/services/evaluators/deterministic/substrate-guards.ts`).
+   The arm that asserts every vacuous reader has a row —
+   `findVacuousStateSectionReaders(allDeclared(), STATE_SECTION_GUARDS)` — stays
+   `[]` with the row present or absent, because the twin now refuses on its own.
+2. Re-point the NEGATIVE CONTROL beside it, `names the shipped reader when the
+   table is empty`. It asserts
+   `findVacuousStateSectionReaders(allDeclared(), [])` equals
+   `["slack.no-reaction-added:reactions"]` — the detector's only firing case in
+   the shipped vocabulary, and this release is what removes it. Measured against
+   the built `0.1.5` declarations it now returns `[]`. Give that arm a synthetic
+   declaration that still reads absence as a pass, the way the three arms below
+   it already build one inline, so the detector keeps a firing case nobody has
+   to ship a defect to preserve.
+
+Both `apps/control-plane` and `apps/mcp` pin this package exactly and must move
+together, or `save_task` accepts criteria the grader cannot bind.
+
+## 0.1.4
+
+Carries twin-github's widened seed schema to the grader (F-1421). One thing
+moves in `dist/`: `@pome-sh/checks/github`'s re-exported `seedSchema` — and with
+it `parseSeed` — now accepts five entity types it used to strip silently.
+
+- `repositories[].milestones[]`, `repositories[].tags[]`,
+  `repositories[].releases[]`
+- `repositories[].issues[].comments[]` and
+  `repositories[].pull_requests[].comments[]`
+- `repositories[].pull_requests[].review_comments[]`
+
+Every one is optional with a `[]` default, so a seed that parsed before parses
+to the same value now. This is a widening, not a tightening: nothing a consumer
+already sends can start failing.
+
+Why it is owed a release rather than left to the twin: this package's job is to
+carry the twins' seed schemas to a consumer that has no twin, and a consumer
+validating a seed against 0.1.3 would strip exactly the keys twin-github 0.10.2
+now honors — reporting a seed as accepted and a world as seeded while five
+entities were dropped on the way. The two halves have to move together or the
+copy on the grader's side becomes the one that decides what a seed may say.
+
+No check declaration, template, polarity or vacuity sentinel changed, so no
+existing criterion's verdict moves.
+
 ## 0.1.3
 
 No change to the published surface — `dist/` is byte-identical to 0.1.2, so no

package/dist/_types/twin-github/src/seed.d.ts

@@ -26,6 +26,29 @@ export declare const seedSchema: z.ZodObject<{
             content: z.ZodString;
             branch: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
+        milestones: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            number: z.ZodOptional<z.ZodNumber>;
+            title: z.ZodString;
+            description: z.ZodDefault<z.ZodString>;
+            state: z.ZodDefault<z.ZodEnum<{
+                open: "open";
+                closed: "closed";
+            }>>;
+            due_on: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            target: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        releases: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            tag_name: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            body: z.ZodDefault<z.ZodString>;
+            target_commitish: z.ZodOptional<z.ZodString>;
+            draft: z.ZodDefault<z.ZodBoolean>;
+            prerelease: z.ZodDefault<z.ZodBoolean>;
+            author: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
         issues: z.ZodDefault<z.ZodArray<z.ZodObject<{
             number: z.ZodOptional<z.ZodNumber>;
             title: z.ZodString;
@@ -36,6 +59,10 @@ export declare const seedSchema: z.ZodObject<{
             }>>;
             labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
             assignees: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            comments: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                body: z.ZodString;
+                author: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>>>;
         pull_requests: z.ZodDefault<z.ZodArray<z.ZodObject<{
             number: z.ZodOptional<z.ZodNumber>;
@@ -67,6 +94,20 @@ export declare const seedSchema: z.ZodObject<{
                 }>>;
                 description: z.ZodDefault<z.ZodString>;
             }, z.core.$strip>>>;
+            comments: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                body: z.ZodString;
+                author: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            review_comments: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                body: z.ZodString;
+                path: z.ZodString;
+                line: z.ZodDefault<z.ZodNumber>;
+                side: z.ZodDefault<z.ZodEnum<{
+                    LEFT: "LEFT";
+                    RIGHT: "RIGHT";
+                }>>;
+                author: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;

package/dist/_types/twin-github/src/types.d.ts

@@ -27,6 +27,26 @@ export type SeedRepository = {
         content: string;
         branch?: string;
     }>;
+    milestones?: Array<{
+        number?: number;
+        title: string;
+        description?: string;
+        state?: "open" | "closed";
+        due_on?: string;
+    }>;
+    tags?: Array<{
+        name: string;
+        target?: string;
+    }>;
+    releases?: Array<{
+        tag_name: string;
+        name?: string;
+        body?: string;
+        target_commitish?: string;
+        draft?: boolean;
+        prerelease?: boolean;
+        author?: string;
+    }>;
     issues?: Array<{
         number?: number;
         title: string;
@@ -34,6 +54,7 @@ export type SeedRepository = {
         state?: "open" | "closed";
         labels?: string[];
         assignees?: string[];
+        comments?: SeedComment[];
     }>;
     pull_requests?: Array<{
         number?: number;
@@ -53,8 +74,24 @@ export type SeedRepository = {
             state?: "error" | "failure" | "pending" | "success";
             description?: string;
         }>;
+        comments?: SeedComment[];
+        review_comments?: Array<{
+            body: string;
+            path: string;
+            line?: number;
+            side?: "LEFT" | "RIGHT";
+            author?: string;
+        }>;
     }>;
 };
+/**
+ * A conversation comment on an issue OR a pull request — one shape, because
+ * they are one table and one route on GitHub too (F-1151).
+ */
+export type SeedComment = {
+    body: string;
+    author?: string;
+};
 export type RepoRow = {
     id: number;
     owner: string;

package/dist/{chunk-UCV6YLN2.js → chunk-JVCGWAZQ.js}

@@ -863,13 +863,61 @@ var seedSchema = z.object({
       description: z.string().default("")
     })).default([]),
     files: z.array(z.object({ path: z.string().min(1), content: z.string(), branch: z.string().optional() })).default([]),
+    // F-1421 — milestones, tags and releases are repository-level entities the
+    // twin already SERVES (`GET /milestones`, `/tags`, `/releases`,
+    // `/releases/latest`, `/releases/tags/:tag`) and the seed could not
+    // express. Zod strips unknown keys, so a seed naming one reached the
+    // domain as nothing at all and those routes could only ever answer `[]`
+    // — a shape of infidelity no shape-diff can see, because an empty array
+    // on both sides compares zero elements.
+    milestones: z.array(z.object({
+      // Assigned sequentially from 1 in seed order when omitted, the way
+      // `nextMilestoneNumber` hands them out. Honored when given, so a
+      // seed that pins `PATCH /milestones/2` addresses the milestone it
+      // named rather than one silently renumbered under it.
+      number: z.number().int().positive().optional(),
+      title: z.string().min(1),
+      description: z.string().default(""),
+      state: z.enum(["open", "closed"]).default("open"),
+      // GitHub's own spelling: an ISO 8601 timestamp. Absent means the
+      // milestone has no due date (`due_on: null` on the wire).
+      due_on: z.string().optional()
+    })).default([]),
+    // A tag names a commit. `target` is any ref the twin resolves — a branch
+    // name or a SHA — and defaults to the repository's default-branch head. A
+    // release whose `tag_name` matches an entry here reuses that tag rather
+    // than minting a second one: `createRelease` looks the tag up first.
+    tags: z.array(z.object({
+      name: z.string().min(1),
+      target: z.string().min(1).optional()
+    })).default([]),
+    releases: z.array(z.object({
+      tag_name: z.string().min(1),
+      // Nullable upstream, so an absent `name` means `null` — not `""`.
+      name: z.string().optional(),
+      body: z.string().default(""),
+      target_commitish: z.string().min(1).optional(),
+      draft: z.boolean().default(false),
+      prerelease: z.boolean().default(false),
+      author: z.string().min(1).optional()
+    })).default([]),
     issues: z.array(z.object({
       number: z.number().int().positive().optional(),
       title: z.string().min(1),
       body: z.string().default(""),
       state: z.enum(["open", "closed"]).default("open"),
       labels: z.array(z.string().min(1)).default([]),
-      assignees: z.array(z.string().min(1)).default([])
+      assignees: z.array(z.string().min(1)).default([]),
+      // The issue's conversation timeline, served at
+      // `GET /repos/:o/:r/issues/:n/comments` (F-1421). `author` is
+      // seeded honestly rather than taken from the write path, which
+      // stamps every comment `pome-agent`: a world in which the agent
+      // under test wrote every comment on the issue it is being asked to
+      // read is not one worth testing against.
+      comments: z.array(z.object({
+        body: z.string().min(1),
+        author: z.string().min(1).optional()
+      })).default([])
     })).default([]),
     pull_requests: z.array(z.object({
       number: z.number().int().positive().optional(),
@@ -893,6 +941,30 @@ var seedSchema = z.object({
         context: z.string().min(1).default("ci/build"),
         state: z.enum(["error", "failure", "pending", "success"]).default("success"),
         description: z.string().default("")
+      })).default([]),
+      // F-1421 — the PR's CONVERSATION timeline. Same table, same route
+      // and same number space as an issue's comments, because GitHub
+      // models a pull request as an issue (F-1151). This is the third
+      // thing a reader could call "a comment on the PR" and the seed
+      // keeps all three apart: `reviews[].body` is the prose on a review
+      // verdict, `review_comments[]` below is anchored to a file and
+      // line, and THIS one is the timeline.
+      comments: z.array(z.object({
+        body: z.string().min(1),
+        author: z.string().min(1).optional()
+      })).default([]),
+      // F-1421 — inline review comments, served at
+      // `GET /repos/:o/:r/pulls/:n/comments`. Seeded through the domain's
+      // own write path, so `path` must name a file the PR changes and
+      // `line` must exist in it: a seeded review comment is one
+      // `POST /pulls/:n/comments` could have produced, not a row only the
+      // seeder can make.
+      review_comments: z.array(z.object({
+        body: z.string().min(1),
+        path: z.string().min(1),
+        line: z.number().int().positive().default(1),
+        side: z.enum(["LEFT", "RIGHT"]).default("RIGHT"),
+        author: z.string().min(1).optional()
       })).default([])
     })).default([])
   }))

package/dist/{chunk-5PDF3GCK.js → chunk-MJOHK2NI.js}

@@ -173,7 +173,7 @@ var noMessagePosted = defineCheck({
 });
 var noReactionAdded = defineCheck({
   id: "slack.no-reaction-added",
-  description: "Resolves the named channel, then filters the TOP-LEVEL reactions list by that channel's id and this emoji name, asserting no row matches. Reactions are not nested under their channel in the export, so this is a join the predicate performs itself. It asserts nothing about which message was reacted to, or by whom.",
+  description: "Resolves the named channel, then filters the TOP-LEVEL reactions list by that channel's id and this emoji name, asserting no row matches. Reactions are not nested under their channel in the export, so this is a join the predicate performs itself. It asserts nothing about which message was reacted to, or by whom. An export carrying no `reactions` collection at all is SKIPPED, because absent is not the same as none.",
   template: 'No "{reaction}" reaction was added in the "{channel}" channel',
   params: { reaction: emojiName, channel: channelName },
   substrate: "final",
@@ -209,14 +209,20 @@ var noReactionAdded = defineCheck({
     const found = resolveChannel(final, channel);
     if ("missing" in found)
       return missSkip(found);
-    const hit = (final.reactions ?? []).some((row) => row.channel_id === found.found.id && row.name === reaction);
-    const joined = [found.path];
-    if (final.reactions !== void 0)
-      joined.push(statePath("reactions"));
+    if (final.reactions == null)
+      return STATE_INCOMPLETE;
+    const hit = final.reactions.some((row) => row.channel_id === found.found.id && row.name === reaction);
     return {
       passed: !hit,
       reason: hit ? `reaction "${reaction}" found in channel "${channel}"` : `no reaction "${reaction}" in channel "${channel}"`,
-      evidenceStatePaths: joined
+      // BOTH sides of the join, because this predicate really does read two
+      // places and a reader who opens only one cannot check its work: the
+      // channel row is where the id came from, the top-level reactions list is
+      // what was filtered. Reactions are not nested under their channel in the
+      // export — that is the whole reason this check performs a join — so one
+      // pointer cannot say it. The guard above already proved `reactions` is
+      // present, so both pointers always resolve.
+      evidenceStatePaths: [found.path, statePath("reactions")]
     };
   }
 });

package/dist/github.js

@@ -1,2 +1,2 @@
-export { GITHUB_CHECKS, defaultSeedState, parseSeed, seedSchema } from './chunk-UCV6YLN2.js';
+export { GITHUB_CHECKS, defaultSeedState, parseSeed, seedSchema } from './chunk-JVCGWAZQ.js';
 import './chunk-W2JNYULF.js';

package/dist/index.js

@@ -1,12 +1,12 @@
 import './chunk-ZXE6LAM3.js';
-import { GITHUB_CHECKS } from './chunk-UCV6YLN2.js';
-export { GITHUB_CHECKS, defaultSeedState as defaultGitHubSeed, seedSchema as githubSeedSchema, parseSeed as parseGitHubSeed } from './chunk-UCV6YLN2.js';
+import { GITHUB_CHECKS } from './chunk-JVCGWAZQ.js';
+export { GITHUB_CHECKS, defaultSeedState as defaultGitHubSeed, seedSchema as githubSeedSchema, parseSeed as parseGitHubSeed } from './chunk-JVCGWAZQ.js';
 import { GMAIL_CHECKS } from './chunk-SA23X6PB.js';
 export { GMAIL_CHECKS, defaultSeedState as defaultGmailSeed, gmailSeedSchema, parseSeed as parseGmailSeed } from './chunk-SA23X6PB.js';
 import { LINEAR_CHECKS } from './chunk-THOSO63W.js';
 export { LINEAR_CHECKS, defaultSeedState as defaultLinearSeed, linearSeedSchema, parseSeed as parseLinearSeed } from './chunk-THOSO63W.js';
-import { SLACK_CHECKS } from './chunk-5PDF3GCK.js';
-export { SLACK_CHECKS, defaultSeedState as defaultSlackSeed, parseSeed as parseSlackSeed, seedSchema as slackSeedSchema } from './chunk-5PDF3GCK.js';
+import { SLACK_CHECKS } from './chunk-MJOHK2NI.js';
+export { SLACK_CHECKS, defaultSeedState as defaultSlackSeed, parseSeed as parseSlackSeed, seedSchema as slackSeedSchema } from './chunk-MJOHK2NI.js';
 import { STRIPE_CHECKS } from './chunk-XOUAZPNB.js';
 export { STRIPE_CHECKS, defaultSeed as defaultStripeSeed, parseSeed as parseStripeSeed, seedSchema as stripeSeedSchema } from './chunk-XOUAZPNB.js';
 export { REDACTION_PLACEHOLDER, VACUITY_SENTINEL, VACUITY_SENTINEL_NUMBER, VACUITY_SENTINEL_SNAKE, checkNearMissPattern, checkPattern, checksDigest, childStatePath, defineCheck, isRedacted, oneOf, parseCheck, probeDiscrimination, probeRedactionSurvival, probeStateCitation, renderCheck, repoRef, resolveStatePath, statePath, templateSlots } from './chunk-W2JNYULF.js';

package/dist/slack.js

@@ -1,2 +1,2 @@
-export { SLACK_CHECKS, defaultSeedState, parseSeed, seedSchema } from './chunk-5PDF3GCK.js';
+export { SLACK_CHECKS, defaultSeedState, parseSeed, seedSchema } from './chunk-MJOHK2NI.js';
 import './chunk-W2JNYULF.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pome-sh/checks",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Pome's grading vocabulary — the check declarations, seed schemas and default seeds of all five digital twins, plus the check DSL they are written in. Declarations only: no twin server, no database, no routes, no tools.",
   "private": false,
   "type": "module",