@intentius/chant 0.91.0 → 0.93.0

package/src/workspace/work-history.schema.json

@@ -0,0 +1,349 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://intentius.io/chant/schemas/workspace/work-history/v1/work-history.schema.json",
+  "title": "chant workspace work history output",
+  "description": "What `chant workspace work history <id> --json` prints (#2785): one work item's lease history, read from _leases/<id>.jsonl on chant/lifecycle in the ledger of the member that owns the work kind, folded into claims, one per fencing token, each with how it ended. A runner counts failed attempts from it. It reads the local branch and lease refs and never fetches. Version 1 of the read contract. Readers ignore fields they do not know; a field is only ever added within a version. The error codes are a closed list, each in the one closed list of `reason-codes.ts`.",
+  "oneOf": [
+    {
+      "$ref": "#/$defs/result"
+    },
+    {
+      "$ref": "#/$defs/failure"
+    }
+  ],
+  "$defs": {
+    "event": {
+      "type": "object",
+      "description": "One line of the history, as written by a claim, renew or release.",
+      "required": [
+        "version",
+        "event",
+        "item",
+        "holder",
+        "by",
+        "token",
+        "acquiredAt",
+        "expiresAt",
+        "timestamp"
+      ],
+      "properties": {
+        "version": {
+          "const": 1
+        },
+        "event": {
+          "enum": [
+            "claim",
+            "renew",
+            "release"
+          ]
+        },
+        "item": {
+          "type": "string"
+        },
+        "holder": {
+          "type": "string",
+          "description": "The lease's holder."
+        },
+        "by": {
+          "type": "string",
+          "description": "Who wrote the line: the holder, or, for the release of an expired lease, whoever closed it out."
+        },
+        "token": {
+          "type": "string",
+          "description": "The fencing token: new on every claim, kept by every renew."
+        },
+        "acquiredAt": {
+          "type": "string"
+        },
+        "expiresAt": {
+          "type": "string",
+          "description": "The lease's expiry after this event; a release keeps the expiry it had."
+        },
+        "timestamp": {
+          "type": "string",
+          "description": "When the event happened, ISO 8601."
+        },
+        "outcome": {
+          "type": "string",
+          "description": "How the work ended, on a release. Free text such as done, not_done, gated or waiting."
+        },
+        "note": {
+          "type": "string"
+        }
+      }
+    },
+    "claim": {
+      "type": "object",
+      "description": "One claim of the item: one fencing token, from its claim to how it ended.",
+      "required": [
+        "token",
+        "holder",
+        "acquiredAt",
+        "expiresAt",
+        "renewals",
+        "ended",
+        "release"
+      ],
+      "properties": {
+        "token": {
+          "type": "string"
+        },
+        "holder": {
+          "type": "string"
+        },
+        "acquiredAt": {
+          "type": "string"
+        },
+        "expiresAt": {
+          "type": "string",
+          "description": "The expiry its last claim or renew set."
+        },
+        "renewals": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "ended": {
+          "enum": [
+            "released",
+            "held",
+            "expired",
+            "lost"
+          ],
+          "description": "released: given back, with release.outcome when one was given. held: it is the live lease now. expired: it ran out, and nobody released it or claimed the item since. lost: it ran out unreleased, and a later claim took the item."
+        },
+        "release": {
+          "oneOf": [
+            {
+              "type": "null"
+            },
+            {
+              "type": "object",
+              "required": [
+                "by",
+                "at",
+                "outcome",
+                "note"
+              ],
+              "properties": {
+                "by": {
+                  "type": "string"
+                },
+                "at": {
+                  "type": "string"
+                },
+                "outcome": {
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                },
+                "note": {
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                }
+              }
+            }
+          ]
+        }
+      }
+    },
+    "result": {
+      "type": "object",
+      "description": "The history was read. Exit code 0. An item never claimed has no claims.",
+      "required": [
+        "$schema",
+        "contract",
+        "chant",
+        "item",
+        "kind",
+        "ref",
+        "ledger",
+        "lease",
+        "claims",
+        "events",
+        "malformed",
+        "summary"
+      ],
+      "properties": {
+        "$schema": {
+          "const": "https://intentius.io/chant/schemas/workspace/work-history/v1/work-history.schema.json"
+        },
+        "contract": {
+          "const": 1
+        },
+        "chant": {
+          "type": "string"
+        },
+        "item": {
+          "type": "string"
+        },
+        "kind": {
+          "type": "string",
+          "description": "The work kind file, from the repository root."
+        },
+        "ref": {
+          "type": "string",
+          "description": "The lease ref: refs/chant/lease/[_members/<member>/]work/<id>."
+        },
+        "ledger": {
+          "type": "object",
+          "required": [
+            "branch",
+            "path"
+          ],
+          "properties": {
+            "branch": {
+              "const": "chant/lifecycle"
+            },
+            "path": {
+              "type": "string",
+              "description": "The history file on the branch: [_members/<member>/]_leases/<id>.jsonl."
+            }
+          }
+        },
+        "lease": {
+          "description": "The lease ref's record now, live or expired, or null when there is none. Read from the local ref and the remote's as last fetched.",
+          "oneOf": [
+            {
+              "type": "null"
+            },
+            {
+              "type": "object",
+              "required": [
+                "holder",
+                "token",
+                "acquiredAt",
+                "expiresAt",
+                "state"
+              ],
+              "properties": {
+                "holder": {
+                  "type": "string"
+                },
+                "token": {
+                  "type": "string"
+                },
+                "acquiredAt": {
+                  "type": "string"
+                },
+                "expiresAt": {
+                  "type": "string"
+                },
+                "state": {
+                  "enum": [
+                    "active",
+                    "expired"
+                  ]
+                }
+              }
+            }
+          ]
+        },
+        "claims": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/claim"
+          },
+          "description": "Each claim, oldest first."
+        },
+        "events": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/event"
+          },
+          "description": "Every line of the history, oldest first."
+        },
+        "malformed": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Lines that are not lease events, left out."
+        },
+        "summary": {
+          "type": "object",
+          "required": [
+            "claims",
+            "released",
+            "held",
+            "expired",
+            "lost",
+            "outcomes"
+          ],
+          "properties": {
+            "claims": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "released": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "held": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "expired": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "lost": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "outcomes": {
+              "type": "object",
+              "additionalProperties": {
+                "type": "integer",
+                "minimum": 1
+              },
+              "description": "How many released claims gave each outcome."
+            }
+          }
+        }
+      }
+    },
+    "failure": {
+      "type": "object",
+      "description": "The history could not be read. Exit code 1.",
+      "required": [
+        "$schema",
+        "contract",
+        "chant",
+        "error"
+      ],
+      "properties": {
+        "$schema": {
+          "const": "https://intentius.io/chant/schemas/workspace/work-history/v1/work-history.schema.json"
+        },
+        "contract": {
+          "const": 1
+        },
+        "chant": {
+          "type": "string"
+        },
+        "error": {
+          "type": "object",
+          "required": [
+            "code",
+            "message"
+          ],
+          "properties": {
+            "code": {
+              "enum": [
+                "kind-unreadable",
+                "work-kind-missing",
+                "work-kind-ambiguous",
+                "work-item-unknown",
+                "not-a-git-repository"
+              ]
+            },
+            "message": {
+              "type": "string"
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/src/workspace/work-history.test.ts

@@ -0,0 +1,156 @@
+/**
+ * #2785 — `chant workspace work history <id>`: a work item's lease history,
+ * each claim with how it ended, from the ledger of the member that owns the
+ * work kind, so a runner counts failed builds without reading git itself.
+ */
+
+import { readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { cleanScratch, contract, git, REPO, repo } from "./__fixtures__/contract-repo";
+import { claimWorkLease, releaseWorkLease, renewWorkLease, type LeaseHistoryRecord } from "../lifecycle/work-lease";
+import { claimsOf, formatWorkHistory, workHistory, type WorkHistoryDocument } from "./work-cli";
+import historySchema from "./work-history.schema.json";
+
+const REF = join(REPO, "reference-workspace");
+const { expectValid } = contract(historySchema);
+
+function work(id: string): string {
+  const data = { schema: 1, id, title: `Work ${id}`, state: "open", implements: [], needs: [], constrains: ["path:app/server.mjs"], evidence: [], opened_on: "2026-09-25", source: { kind: "workspace", member: "app" }, supersedes: [] };
+  return `---\n${JSON.stringify(data, null, 2)}\n---\n\n# ${id}\n`;
+}
+
+let root: string;
+let kindDir: string;
+
+beforeAll(() => {
+  // The work kind sits in the design member, so its leases are in that member's ledger.
+  root = repo({
+    "chant.workspace.json": JSON.stringify(
+      {
+        name: "studio",
+        schema: 1,
+        members: [
+          { name: "app", dir: "app", kind: "other", because: "a plain Node server" },
+          { name: "design", dir: "design", kind: "other", because: "records only" },
+        ],
+        records: [{ kind: "design/decisions/decision.kind.mjs" }, { kind: "design/work/work.kind.mjs" }],
+      },
+      null,
+      2,
+    ),
+    "app/server.mjs": "export const port = 8080;\n",
+    "design/decisions/decision.kind.mjs": readFileSync(join(REF, "decisions", "decision.kind.mjs"), "utf-8"),
+    "design/decisions/decision.schema.json": readFileSync(join(REF, "decisions", "decision.schema.json"), "utf-8"),
+    "design/work/work.kind.mjs": readFileSync(join(REF, "work", "work.kind.mjs"), "utf-8"),
+    "design/work/work.schema.json": readFileSync(join(REF, "work", "work.schema.json"), "utf-8"),
+    "design/work/W-001-one.md": work("W-001"),
+    "design/work/W-002-two.md": work("W-002"),
+  });
+  git(root, "config", "user.name", "History Test");
+  git(root, "config", "user.email", "history@example.com");
+  git(root, "add", "-A");
+  git(root, "commit", "-q", "-m", "the queue");
+  kindDir = join(root, "design", "work");
+});
+afterAll(cleanScratch);
+
+const at = (min: number) => () => new Date(Date.UTC(2020, 0, 1, 12, min));
+
+describe("workspace work history (#2785)", () => {
+  test("each claim with its token and holder, and how it ended: released with an outcome, lost, expired or held", async () => {
+    const opts = (min: number) => ({ cwd: kindDir, now: at(min), ttlMs: 10 * 60_000 });
+    // A build that ended not_done.
+    const first = await claimWorkLease("W-001", "steward/dispatch@1", opts(0));
+    if (!first.ok) throw new Error(first.message);
+    await renewWorkLease("W-001", "steward/dispatch@1", { ...opts(3), token: first.lease.token });
+    await releaseWorkLease("W-001", "steward/dispatch@1", { cwd: kindDir, now: at(5), token: first.lease.token, outcome: "not_done" });
+    // A build whose lease ran out unreleased, and another worker then claimed the item.
+    const second = await claimWorkLease("W-001", "steward/dispatch@2", opts(10));
+    if (!second.ok) throw new Error(second.message);
+    const third = await claimWorkLease("W-001", "steward/dispatch@3", opts(30));
+    if (!third.ok) throw new Error(third.message);
+
+    const doc = await workHistory({ id: "W-001", cwd: root });
+    expectValid(doc);
+    if ("error" in doc) throw new Error(doc.error.message);
+    expect(doc).toMatchObject({
+      item: "W-001",
+      kind: "design/work/work.kind.mjs",
+      ref: "refs/chant/lease/_members/design/work/W-001",
+      ledger: { branch: "chant/lifecycle", path: "_members/design/_leases/W-001.jsonl" },
+      malformed: 0,
+    });
+    expect(doc.claims.map((c) => [c.holder, c.token, c.ended, c.renewals, c.release?.outcome ?? null])).toEqual([
+      ["steward/dispatch@1", first.lease.token, "released", 1, "not_done"],
+      ["steward/dispatch@2", second.lease.token, "lost", 0, null],
+      ["steward/dispatch@3", third.lease.token, "expired", 0, null],
+    ]);
+    expect(doc.events.map((e) => e.event)).toEqual(["claim", "renew", "release", "claim", "claim"]);
+    expect(doc.summary).toEqual({ claims: 3, released: 1, held: 0, expired: 1, lost: 1, outcomes: { not_done: 1 } });
+    // The history file is where git would find it, under the member's prefix.
+    expect(git(root, "show", `chant/lifecycle:${doc.ledger.path}`).split("\n")).toHaveLength(5);
+    expect(formatWorkHistory(doc)).toContain("released not_done by steward/dispatch@1");
+  });
+
+  test("a live claim is held, and a done release is counted by outcome", async () => {
+    const now = () => new Date();
+    const done = await claimWorkLease("W-002", "worker-a", { cwd: kindDir, now });
+    if (!done.ok) throw new Error(done.message);
+    await releaseWorkLease("W-002", "worker-a", { cwd: kindDir, now, token: done.lease.token, outcome: "done" });
+    const live = await claimWorkLease("W-002", "worker-b", { cwd: kindDir, now });
+    if (!live.ok) throw new Error(live.message);
+
+    const doc = await workHistory({ id: "W-002", cwd: kindDir, kind: join(kindDir, "work.kind.mjs") });
+    expectValid(doc);
+    if ("error" in doc) throw new Error(doc.error.message);
+    expect(doc.claims.map((c) => c.ended)).toEqual(["released", "held"]);
+    expect(doc.lease).toMatchObject({ holder: "worker-b", token: live.lease.token, state: "active" });
+    expect(doc.summary.outcomes).toEqual({ done: 1 });
+  });
+
+  test("an item never claimed has no claims; an unknown item is an error", async () => {
+    const W3 = join(kindDir, "W-003-three.md");
+    writeFileSync(W3, work("W-003"));
+    try {
+      const none = await workHistory({ id: "W-003", cwd: root });
+      expectValid(none);
+      expect(none).toMatchObject({ claims: [], events: [], lease: null, summary: { claims: 0 } });
+    } finally {
+      rmSync(W3);
+    }
+    const unknown = await workHistory({ id: "W-404", cwd: root });
+    expectValid(unknown);
+    expect(unknown).toMatchObject({ error: { code: "work-item-unknown" } });
+    const bad = await workHistory({ id: "../x", cwd: root });
+    expect((bad as Extract<WorkHistoryDocument, { error: unknown }>).error.code).toBe("work-item-unknown");
+  });
+});
+
+describe("claimsOf", () => {
+  const e = (event: LeaseHistoryRecord["event"], token: string, extra: Partial<LeaseHistoryRecord> = {}): LeaseHistoryRecord => ({
+    version: 1,
+    event,
+    item: "W",
+    holder: `h-${token}`,
+    by: `h-${token}`,
+    token,
+    acquiredAt: "2026-09-25T00:00:00.000Z",
+    expiresAt: "2026-09-25T00:10:00.000Z",
+    timestamp: "2026-09-25T00:00:00.000Z",
+    ...extra,
+  });
+
+  test("a release by someone closing out an expired lease keeps the holder and records who released it", () => {
+    const claims = claimsOf([e("claim", "a"), e("release", "a", { by: "janitor", outcome: "expired" })], null);
+    expect(claims).toEqual([
+      { token: "a", holder: "h-a", acquiredAt: "2026-09-25T00:00:00.000Z", expiresAt: "2026-09-25T00:10:00.000Z", renewals: 0, ended: "released", release: { by: "janitor", at: "2026-09-25T00:00:00.000Z", outcome: "expired", note: null } },
+    ]);
+  });
+
+  test("the live ref decides between held and expired for the newest claim", () => {
+    expect(claimsOf([e("claim", "a")], { token: "a", state: "active" })[0].ended).toBe("held");
+    expect(claimsOf([e("claim", "a")], { token: "a", state: "expired" })[0].ended).toBe("expired");
+    expect(claimsOf([e("claim", "a"), e("claim", "b")], { token: "b", state: "active" }).map((c) => c.ended)).toEqual(["lost", "held"]);
+  });
+});

package/src/workspace/work.test.ts

@@ -32,6 +32,7 @@ import { queryRecords } from "./records-cli";
 import { amendRecord, newRecord, resolveWriteKind, reviewRecord } from "./records-write";
 import recordsSchema from "./records.schema.json";
 import { WORK_WARNING_CODES } from "./work";
+import { CHANGES_FINDING_CODES } from "./changes";
 
 const REF = join(REPO, "reference-workspace");
 const DECISION = (() => {
@@ -227,9 +228,9 @@ describe("work records on read (#2683)", () => {
     expect("error" in doc && doc.error.code).toBe("kind-invalid");
   });
 
-  test("the reference work schema's finding codes are the intent graph's", () => {
+  test("the reference work schema's finding codes are the intent graph's and the change check's (#2773)", () => {
     const schema = JSON.parse(readFileSync(join(REF, "work", "work.schema.json"), "utf-8")) as { definitions: { sourceGap: { properties: { finding: { anyOf: [{ enum: string[] }] } } } } };
-    expect(schema.definitions.sourceGap.properties.finding.anyOf[0].enum).toEqual([...INTENT_FINDING_CODES]);
+    expect(schema.definitions.sourceGap.properties.finding.anyOf[0].enum).toEqual([...INTENT_FINDING_CODES, ...CHANGES_FINDING_CODES]);
   });
 });
 

package/src/workspace/work.ts

@@ -15,6 +15,8 @@
  *   record is valid and not superseded;
  * - `blockedBy`: each need that is not done, with its state;
  * - `implements`: each decision it names, with that decision's state;
+ * - `acceptance`, for a kind with acceptance criteria (#2772): how many of the
+ *   record's criteria passing evidence of the expected verification meets;
  *
  * and each decision `implementedBy`, the work records naming it. The
  * warnings are closed codes. `work-done-gap-open` is not raised here: it
@@ -24,7 +26,7 @@
 
 import { dirname } from "node:path";
 import type { ReasonCode } from "./reason-codes";
-import { loadRecordKind, readRecords, type LoadedRecordKind, type ReadRecordsOptions, type RecordEntry } from "./records";
+import { loadRecordKind, normalisePrincipal, readRecords, type LoadedRecordKind, type ReadRecordsOptions, type RecordEntry } from "./records";
 
 /** Why a work record carries a warning. Closed, like the record warning codes. */
 export const WORK_WARNING_CODES = [
@@ -42,6 +44,10 @@ export const WORK_WARNING_CODES = [
   "work-closed-without-date",
   /** The record is done, and the finding it came from (`source.finding`) still fires on its region. Raised by `graph --intent`, and by `records` through a walk of that region (#2686). */
   "work-done-gap-open",
+  /** The record is done, and an acceptance criterion has no passing evidence of the verification it expects (#2772). `check` fails on it (WSP117). */
+  "work-acceptance-unmet",
+  /** A passing `manual` verdict on a criterion names the record's implementer, so it does not count: a manual verdict comes from someone else (#2772). */
+  "work-acceptance-self-verified",
 ] as const satisfies readonly ReasonCode[];
 export type WorkWarningCode = (typeof WORK_WARNING_CODES)[number];
 
@@ -61,6 +67,82 @@ export interface DecisionWork {
   implementedBy: WorkLink[];
 }
 
+/** How a criterion is to be verified (#2772): by a unit, integration or end-to-end test, by the running system, or by a person. */
+export const VERIFICATION_TYPES = ["unit", "integration", "e2e", "runtime", "manual"] as const;
+export type VerificationType = (typeof VERIFICATION_TYPES)[number];
+
+/** The results a piece of evidence for a criterion can carry. */
+export const EVIDENCE_RESULTS = ["pass", "fail"] as const;
+export type EvidenceResult = (typeof EVIDENCE_RESULTS)[number];
+
+/** One acceptance criterion as a work record states it. */
+export interface Criterion {
+  id: string;
+  text: string;
+  verification: VerificationType;
+}
+
+/** One criterion on read: whether passing evidence of its verification meets it. */
+export interface CriterionState {
+  id: string;
+  verification: VerificationType;
+  met: boolean;
+}
+
+/** A work record's acceptance criteria on read (#2772): how many are met, of how many. */
+export interface WorkAcceptance {
+  met: number;
+  total: number;
+  criteria: CriterionState[];
+}
+
+/** The acceptance criteria a record lists in `field`, leaving out entries without a string id and a known verification (the schema reports those). */
+export function acceptanceCriteria(data: Record<string, unknown> | null, field: string): Criterion[] {
+  const v = data?.[field];
+  if (!Array.isArray(v)) return [];
+  return v.filter(
+    (c): c is Criterion =>
+      c !== null && typeof c === "object" && typeof c.id === "string" && typeof c.text === "string" && (VERIFICATION_TYPES as readonly string[]).includes(c.verification),
+  );
+}
+
+/**
+ * Which of a record's criteria its evidence meets. Evidence meets a criterion
+ * when it names the criterion, its result is `pass` and its verification is
+ * the criterion's. A `manual` verdict also names who gave it in `by`, and
+ * counts only when that is not the record's implementer; one that is lands in
+ * `selfVerified`. `acceptance` is null when the record lists no criteria.
+ */
+export function workAcceptance(
+  data: Record<string, unknown> | null,
+  spec: { field: string; implementer: string },
+  pinsField: string,
+): { acceptance: WorkAcceptance | null; selfVerified: string[] } {
+  if (!Array.isArray(data?.[spec.field])) return { acceptance: null, selfVerified: [] };
+  const criteria = acceptanceCriteria(data, spec.field);
+  const implementer = typeof data?.[spec.implementer] === "string" ? normalisePrincipal(data[spec.implementer] as string) : null;
+  const evidence = Array.isArray(data?.[pinsField]) ? (data![pinsField] as unknown[]) : [];
+  const selfVerified: string[] = [];
+  const states = criteria.map((c): CriterionState => {
+    let met = false;
+    for (const e of evidence) {
+      if (e === null || typeof e !== "object") continue;
+      const ev = e as Record<string, unknown>;
+      if (ev.criterion !== c.id || ev.result !== "pass" || ev.verification !== c.verification) continue;
+      if (c.verification === "manual") {
+        if (typeof ev.by !== "string") continue;
+        if (implementer !== null && normalisePrincipal(ev.by) === implementer) {
+          if (!selfVerified.includes(c.id)) selfVerified.push(c.id);
+          continue;
+        }
+      }
+      met = true;
+    }
+    return { id: c.id, verification: c.verification, met };
+  });
+  return { acceptance: { met: states.filter((c) => c.met).length, total: states.length, criteria: states }, selfVerified };
+}
+
 /** The strings of a front-matter list, or none. */
 export function idList(data: Record<string, unknown> | null, field: string): string[] {
   const v = data?.[field];
@@ -143,6 +225,23 @@ export async function applyWork(loaded: LoadedRecordKind, entries: RecordEntry[]
     if (e.state === work.done && kind.pins && !(Array.isArray(evidence) && evidence.length > 0)) {
       e.warnings.push({ code: "work-done-unpinned", message: `${e.id ?? e.path} is ${work.done} and ${kind.pins.field} is empty or missing: nothing shows the work was done` });
     }
+    if (work.acceptance && kind.pins) {
+      const { acceptance, selfVerified } = workAcceptance(e.data, work.acceptance, kind.pins.field);
+      e.acceptance = acceptance;
+      if (selfVerified.length > 0) {
+        e.warnings.push({
+          code: "work-acceptance-self-verified",
+          message: `the manual verdict on ${selfVerified.join(", ")} is by ${String(e.data[work.acceptance.implementer])}, the implementer, so it does not count: a manual verdict comes from someone else`,
+        });
+      }
+      const unmet = acceptance?.criteria.filter((c) => !c.met) ?? [];
+      if (e.state === work.done && unmet.length > 0) {
+        e.warnings.push({
+          code: "work-acceptance-unmet",
+          message: `${e.id ?? e.path} is ${work.done}, and no passing evidence meets ${unmet.map((c) => `${c.id} (${c.verification})`).join(", ")}`,
+        });
+      }
+    }
     if (e.state !== null && closed.has(e.state) && typeof e.data[work.closedOn] !== "string") {
       e.warnings.push({ code: "work-closed-without-date", message: `${e.id ?? e.path} is ${e.state} and has no ${work.closedOn}` });
     }