@intentius/chant 0.91.0 → 0.94.0

package/src/workspace/status.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://intentius.io/chant/schemas/workspace/status/v1/status.schema.json",
   "title": "chant workspace status output",
-  "description": "What `chant workspace status <env> --json` prints, version 1 of the read contract for releases across members (#2524 D15, D19, #2544). Readers ignore fields they do not know; a field is only ever added within a version. The reason and error codes are closed lists: a new code is a new contract version. Contract version 1 is written by chant 0.81.0 and newer; a reader that needs it refuses output whose `contract` it doesn't know. Every code is in the one closed list of `reason-codes.ts`. Each member's gates, read from its gate ledger on the same branch, are in the JSON only (#2674), and so is each member's box block, from the declaration (#2726), with its isolation resolved (#2727). So are its stewards, their Ops and each Op's last run (#2731), and the work lease each Op's turn holds (#2748).",
+  "description": "What `chant workspace status <env> --json` prints, version 1 of the read contract for releases across members (#2524 D15, D19, #2544). Readers ignore fields they do not know; a field is only ever added within a version. The reason and error codes are closed lists: a new code is a new contract version. Contract version 1 is written by chant 0.81.0 and newer; a reader that needs it refuses output whose `contract` it doesn't know. Every code is in the one closed list of `reason-codes.ts`. Each member's gates, read from its gate ledger on the same branch, are in the JSON only (#2674), and so is each member's box block, from the declaration (#2726), with its isolation resolved (#2727). So are its stewards, their Ops and each Op's last run (#2731), the work lease each Op's turn holds (#2748), and the open decision points a steward waits on (#2749).",
   "oneOf": [{ "$ref": "#/$defs/result" }, { "$ref": "#/$defs/failure" }],
   "$defs": {
     "result": {
@@ -50,6 +50,11 @@
           "type": "array",
           "items": { "$ref": "#/$defs/lease" }
         },
+        "acceptance": {
+          "description": "Added in contract 1 by #2772. Each current work item of a declared work kind whose work block names acceptance criteria, when the item lists some, by declared kind and then item, read in the working tree: how many of its criteria passing evidence meets. Empty when no declared work kind has criteria. A done item with a criterion unmet is what chant workspace check fails on (WSP117).",
+          "type": "array",
+          "items": { "$ref": "#/$defs/acceptance" }
+        },
         "summary": {
           "type": "object",
           "required": ["members", "released", "unreadable", "differing"],
@@ -66,6 +71,18 @@
         }
       }
     },
+    "acceptance": {
+      "type": "object",
+      "required": ["member", "kind", "item", "state", "met", "total"],
+      "properties": {
+        "member": { "type": ["string", "null"], "description": "The member that declares the work kind, or null for the workspace's own." },
+        "kind": { "type": "string", "description": "The work kind file, from the workspace root." },
+        "item": { "type": "string", "description": "The work item's id." },
+        "state": { "type": ["string", "null"], "description": "The item's state." },
+        "met": { "type": "integer", "minimum": 0, "description": "Criteria met by evidence naming them, with result pass and the criterion's verification; a manual verdict counts only from someone other than the implementer." },
+        "total": { "type": "integer", "minimum": 0, "description": "Criteria the item lists." }
+      }
+    },
     "lease": {
       "type": "object",
       "required": ["item", "member", "ref", "holder", "token", "acquiredAt", "expiresAt", "state"],
@@ -135,7 +152,7 @@
     "stewardForm": { "enum": ["local", "fountain"] },
     "steward": {
       "type": "object",
-      "required": ["name", "file", "form", "forms", "vault", "capabilities", "lease", "ops"],
+      "required": ["name", "file", "form", "forms", "vault", "capabilities", "lease", "ops", "waiting"],
       "properties": {
         "name": { "type": "string", "description": "The steward's name; on Fountain, its Agent's and Teammate's." },
         "file": { "type": "string", "description": "The *.op.ts file that declares it, relative to the member's directory." },
@@ -187,7 +204,7 @@
           "type": "array",
           "items": {
             "type": "object",
-            "required": ["name", "schedule", "env", "lastRun", "changesCheckout", "workLease"],
+            "required": ["name", "schedule", "env", "lastRun", "lastTick", "changesCheckout", "workLease"],
             "properties": {
               "name": { "type": "string" },
               "schedule": {
@@ -208,16 +225,77 @@
                   { "type": "null" },
                   {
                     "type": "object",
-                    "required": ["id", "status", "started", "ended", "gate"],
+                    "required": ["id", "status", "started", "ended", "gate", "point"],
                     "properties": {
                       "id": { "type": "string" },
-                      "status": { "enum": ["ok", "fail", "gated"] },
+                      "status": { "enum": ["ok", "fail", "gated", "waiting"], "description": "waiting: an activity asked a decision point that is still open (#2749), and the run stopped there." },
                       "started": { "type": "string" },
                       "ended": { "type": "string" },
                       "gate": {
                         "oneOf": [
                           { "type": "null" },
-                          { "type": "object", "required": ["name", "since"], "properties": { "name": { "type": "string" }, "since": { "type": "string" } } }
+                          {
+                            "type": "object",
+                            "required": ["name", "since"],
+                            "properties": {
+                              "name": { "type": "string" },
+                              "since": { "type": "string" },
+                              "op": { "type": "string", "description": "The op the gate is recorded under: the Op's own, or the command's when a step's command stopped at a gate of its own (#2779), such as workspace-upgrade." },
+                              "approve": { "type": "string", "description": "The command that approves the gate, run in the member's directory." }
+                            }
+                          }
+                        ]
+                      },
+                      "point": {
+                        "description": "The open decision point a waiting run stopped on (#2749), as the run ledger records it, or null.",
+                        "oneOf": [{ "type": "null" }, { "$ref": "#/$defs/stewardWait" }]
+                      }
+                    }
+                  }
+                ]
+              },
+              "lastTick": {
+                "description": "For a ConvergeOp, its newest tick on the converge ledger (#2778): the rules that fired, what each did and for which resource, and what its observer step reported. null for any other Op, or before its first tick.",
+                "oneOf": [
+                  { "type": "null" },
+                  {
+                    "type": "object",
+                    "required": ["id", "timestamp", "log", "firedRuleIds", "outcomes", "resources"],
+                    "properties": {
+                      "id": { "type": ["string", "null"] },
+                      "timestamp": { "type": "string" },
+                      "log": { "type": "string" },
+                      "firedRuleIds": { "type": "array", "items": { "type": "string" } },
+                      "outcomes": {
+                        "type": "array",
+                        "items": {
+                          "type": "object",
+                          "required": ["ruleId", "action", "op", "resource", "reason"],
+                          "properties": {
+                            "ruleId": { "type": "string" },
+                            "action": { "enum": ["ran", "reported", "skipped-budget", "skipped-flap", "gated"] },
+                            "op": { "type": ["string", "null"] },
+                            "resource": { "type": ["string", "null"], "description": "The resource the rule fired for, on a ConvergeOp with an observer step." },
+                            "reason": { "type": ["string", "null"] }
+                          }
+                        }
+                      },
+                      "resources": {
+                        "description": "What the observer step reported, or null for a ConvergeOp that observes a lexicon environment.",
+                        "oneOf": [
+                          { "type": "null" },
+                          {
+                            "type": "array",
+                            "items": {
+                              "type": "object",
+                              "required": ["name", "status", "detail"],
+                              "properties": {
+                                "name": { "type": "string" },
+                                "status": { "enum": ["in-sync", "drifted", "unknown"] },
+                                "detail": { "type": ["string", "null"] }
+                              }
+                            }
+                          }
                         ]
                       }
                     }
@@ -255,13 +333,56 @@
               }
             }
           }
+        },
+        "waiting": {
+          "description": "The open decision points the steward waits on (#2749): one for each Op whose newest run is the steward's own (its ledger record names the steward) and stopped on a question: the steward's own Ops in ops order, then any other Op of the member, such as one the steward's process starts itself (studio#137), by name. The state is the question's when the run stopped; `chant workspace points --open` has its state now, and hud asks a person there. The steward never answers one, and runs an Op it lists again on the first round after it is answered.",
+          "type": "array",
+          "items": {
+            "allOf": [
+              { "$ref": "#/$defs/stewardWait" },
+              {
+                "type": "object",
+                "required": ["op", "run"],
+                "properties": { "op": { "type": "string" }, "run": { "type": "string", "description": "The waiting run's id." } }
+              }
+            ]
+          }
         }
       }
     },
+    "stewardWait": {
+      "type": "object",
+      "required": ["id", "point", "state", "path", "subject", "since"],
+      "properties": {
+        "id": { "type": "string", "description": "The answer record's id, as `points` lists the question and `points answer` names it." },
+        "point": { "type": "string" },
+        "state": { "enum": ["escalated", "proposed"] },
+        "path": { "type": "string", "description": "The answer record, from the repository root." },
+        "subject": { "type": ["string", "null"] },
+        "since": { "type": "string", "description": "When the run stopped on it." }
+      }
+    },
+    "intent": {
+      "type": "object",
+      "required": ["id", "state", "question", "choice", "answer", "decided_by", "decided_on"],
+      "properties": {
+        "id": { "type": "string", "description": "The record's id, as the box block names it." },
+        "state": { "type": ["string", "null"], "description": "The record's state as written, such as proposed or decided, or null when no decision record has the id." },
+        "question": { "type": ["string", "null"], "description": "The question the record answers." },
+        "choice": { "description": "The record's choice as written, such as { option, reason }, or null while the record is proposed." },
+        "answer": { "type": ["string", "null"], "description": "The chosen option's label, from options[]'s entry whose id is choice.option, or null while no option is chosen (#2855). Added by chant 0.94.0." },
+        "decided_by": { "type": ["string", "null"], "description": "Who decided it, or null while it is proposed." },
+        "decided_on": { "type": ["string", "null"], "description": "The day it was decided, or null while it is proposed." }
+      }
+    },
     "box": {
       "type": "object",
-      "required": ["capabilities", "isolation"],
+      "required": ["capabilities", "isolation", "intent"],
       "properties": {
+        "intent": {
+          "description": "The decision record the box block names as the box's intent (#2850), or null when it names none. A box starts as a question: the record is proposed with a null choice, and decided when the person who answered it amends it. Read from the working tree, from the declared record kinds named decision. When no decision record has the id, every field but id is null and chant workspace check fails (WSP126). Added by chant 0.94.0.",
+          "oneOf": [{ "type": "null" }, { "$ref": "#/$defs/intent" }]
+        },
         "isolation": {
           "description": "The box's isolation resolved from its identity, its host, the member's name and its slot (#2727), or null when the block declares no host. A runtime that plants or starts the box sets these values instead of choosing its own. The same for every environment.",
           "oneOf": [{ "type": "null" }, { "$ref": "#/$defs/isolation" }]
@@ -371,7 +492,7 @@
           }
         },
         "needed": { "type": "integer", "minimum": 1, "description": "The human approvals the gate needs: its quorum's count, 1 without one." },
-        "approve": { "type": "string", "description": "The chant approve line for the gate, run in the member's directory: chant approve <component> <gate>, with --env <env> when env is not null." }
+        "approve": { "type": "string", "description": "The chant approve line for the gate, run in the member's directory: chant approve <component> <gate>, with --env <env> when env is not null and --plan <planDigest> when planDigest is not null (#2832), so the line approves the plan this read showed." }
       }
     },
     "environment": {

package/src/workspace/status.ts

@@ -43,7 +43,8 @@ import { readReleasePlan, type ReleasePlan } from "../lifecycle/plan-ledger";
 import { listWorkLeases, type WorkLeaseState } from "../lifecycle/work-lease";
 import { findWorkspaceRoot } from "../project-root";
 import { resolveBoxes, type ResolvedIsolation } from "./box-isolation";
-import { readDeclaration, readerVersion, WorkspaceReadError, type ErrorLocation, type Member } from "./declaration";
+import { resolveBoxIntents, unresolvedIntent, type BoxIntent } from "./box-intent";
+import { declaredRecordKinds, readDeclaration, readerVersion, WorkspaceReadError, type Declaration, type ErrorLocation, type Member } from "./declaration";
 import type { ReasonCode } from "./reason-codes";
 import { GATE_REASON_CODES, readMemberGates, type GateLedgerReader, type StatusGate, type StatusGateLedger } from "./status-gates";
 import { STEWARD_REASON_CODES, readMemberStewards, type StatusSteward, type StewardReasonCode } from "./status-stewards";
@@ -178,6 +179,13 @@ export interface StatusBox {
   capabilities: { name: string; broker: string | null; scope: string[] }[];
   /** The box's ports, state paths and cookie names, resolved from its identity, or null when the block declares no host (#2727). */
   isolation: ResolvedIsolation | null;
+  /**
+   * The decision record the block names as the box's intent (#2850): its id,
+   * state, question, choice, answer (the chosen option's label), decided_by
+   * and decided_on. Null when the block names none; every field but the id
+   * is null when no decision record has the id (WSP126).
+   */
+  intent: BoxIntent | null;
 }
 
 /**
@@ -190,6 +198,21 @@ export interface StatusLease extends Omit<WorkLeaseState, "ref"> {
   ref: string;
 }
 
+/**
+ * One work item's acceptance criteria, counted (#2772): each current record
+ * of a declared work kind with acceptance criteria that lists some.
+ */
+export interface StatusAcceptance {
+  /** The member that declares the work kind, or null for the workspace's own. */
+  member: string | null;
+  /** The work kind file, from the workspace root. */
+  kind: string;
+  item: string;
+  state: string | null;
+  met: number;
+  total: number;
+}
+
 export type StatusDocument =
   | {
       $schema: string;
@@ -202,6 +225,8 @@ export type StatusDocument =
       members: StatusMember[];
       /** Every work lease in the workspace's ledgers, active and expired, by member then item (#2732). A released lease has no ref and is not listed. */
       leases: StatusLease[];
+      /** Each work item's acceptance criteria, met of total, by declared kind then item (#2772). Empty when no declared work kind has criteria. */
+      acceptance: StatusAcceptance[];
       summary: { members: number; released: number; unreadable: number; differing: number | null };
     }
   | {
@@ -360,6 +385,7 @@ export async function workspaceStatus(query: StatusQuery): Promise<StatusDocumen
     const now = query.now ?? new Date().toISOString();
 
     const isolation = new Map(resolveBoxes(declaration).map((b) => [b.member.name, b.isolation]));
+    const intents = new Map((await resolveBoxIntents(declaration, found.dir)).map((i) => [i.member, i.record?.intent ?? unresolvedIntent(i.id)]));
     const members: StatusMember[] = [];
     for (const m of declaration.members) {
       const environments: StatusEnvironment[] = [];
@@ -382,6 +408,7 @@ export async function workspaceStatus(query: StatusQuery): Promise<StatusDocumen
             : {
                 capabilities: m.box.capabilities.map((c) => ({ name: c.name, broker: c.broker, scope: [...c.scope] })),
                 isolation: isolation.get(m.name) ?? null,
+                intent: intents.get(m.name) ?? null,
               },
         stewards: stewards.stewards,
         stewardReasons: stewards.reasons,
@@ -395,6 +422,7 @@ export async function workspaceStatus(query: StatusQuery): Promise<StatusDocumen
     for (const m of members) m.gateLedger.shared = m.gateLedger.layout === "flat" && flatGates > 1;
 
     const leases = await readWorkspaceLeases(declaration.members, found.dir, new Date(now));
+    const acceptance = await readWorkspaceAcceptance(declaration, found.dir);
 
     return {
       ...head,
@@ -404,6 +432,7 @@ export async function workspaceStatus(query: StatusQuery): Promise<StatusDocumen
       workspace: { name: declaration.name, root: rootDir === "" ? "." : rootDir, file: declaration.file },
       members,
       leases,
+      acceptance,
       summary: {
         members: members.length,
         released: members.filter((m) => m.environments[0].releases.length > 0).length,
@@ -436,6 +465,16 @@ async function readWorkspaceLeases(members: Member[], cwd: string, now: Date): P
   return out;
 }
 
+/** The acceptance counts of every declared work kind with criteria (#2772), read in the working tree. */
+async function readWorkspaceAcceptance(declaration: Declaration, root: string): Promise<StatusAcceptance[]> {
+  if (declaredRecordKinds(declaration).length === 0) return [];
+  const { loadDeclaredKinds } = await import("./declared-kinds");
+  const kinds = await loadDeclaredKinds(declaration, workingTree(root), root, { acceptance: true });
+  return kinds.flatMap((k) =>
+    (k.acceptance ?? []).map((a) => ({ member: k.declared.member, kind: k.declared.path, item: a.item, state: a.state, met: a.met, total: a.total })),
+  );
+}
+
 export async function runWorkspaceStatus(ctx: CommandContext): Promise<number> {
   const { args } = ctx;
   const env = args.extraPositional;
@@ -525,6 +564,12 @@ export function formatStatus(doc: Extract<StatusDocument, { members: unknown }>)
     for (const l of doc.leases) rows.push([l.member ? `${l.member}/${l.item}` : l.item, l.holder, l.expiresAt, l.state]);
     lines.push(...table(rows));
   }
+  if (doc.acceptance.length > 0) {
+    lines.push("");
+    const rows: string[][] = [["WORK ITEM", "STATE", "CRITERIA MET"]];
+    for (const a of doc.acceptance) rows.push([a.member ? `${a.member}/${a.item}` : a.item, a.state ?? "-", `${a.met}/${a.total}`]);
+    lines.push(...table(rows));
+  }
   const boxes = doc.members.filter((m) => m.box?.isolation);
   if (boxes.length > 0) {
     lines.push("");

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

@@ -0,0 +1,274 @@
+/**
+ * Acceptance criteria on work records (#2772), on a workspace built from the
+ * reference workspace's decision and work kinds in a throwaway git repository.
+ *
+ * - W-001 is done, and passing evidence of each criterion's verification
+ *   meets both of them, the manual one by bob while alice owns the item: met.
+ * - W-002 is done, and its only evidence is a unit test for an e2e
+ *   criterion: unmet.
+ * - W-003 is done, and its manual criterion's verdict is by alice, its owner:
+ *   the verdict does not count, so it is unmet as well.
+ * - W-004 is done and lists no criteria: a legacy item, read as before.
+ * - W-005 is in progress. A steward's Op attaches evidence to it under its
+ *   work lease, and is refused on the manual criterion.
+ */
+
+import { readFileSync } 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 { runDeclarationChecks } from "./checks";
+import { listWorkspaceWithKinds } from "./ls";
+import lsSchema from "./ls.schema.json";
+import { queryRecords } from "./records-cli";
+import recordsSchema from "./records.schema.json";
+import { workspaceStatus } from "./status";
+import statusSchema from "./status.schema.json";
+import { attachWorkEvidence } from "./work-evidence";
+import workEvidenceSchema from "./work-evidence.schema.json";
+import { workEvidence } from "../op/builders";
+import { workEvidence as workEvidenceActivity } from "../op/activities";
+import { ACTIVITY_PROFILES } from "../op/activity-profiles";
+import { OpRunFailure, runOpLocally, type OpRunResult } from "../op/local-executor";
+import type { ActivityFn } from "../op/activity-registry";
+import type { OpConfig } from "../op/types";
+import { declareSteward } from "../op/steward";
+import { claimWorkLease, releaseWorkLease } from "../lifecycle/work-lease";
+
+const REF = join(REPO, "reference-workspace");
+const ref = (path: string) => readFileSync(join(REF, path), "utf-8");
+
+function work(id: string, fields: Record<string, unknown>): string {
+  const data = {
+    schema: 1,
+    id,
+    title: `Work ${id}`,
+    state: "done",
+    implements: [],
+    needs: [],
+    constrains: ["member:app"],
+    evidence: [],
+    owner: "alice",
+    opened_on: "2026-09-25",
+    closed_on: "2026-09-25",
+    source: { kind: "workspace", member: "app" },
+    supersedes: [],
+    ...fields,
+  };
+  return `---\n${JSON.stringify(data, null, 2)}\n---\n\n# ${id}\n`;
+}
+
+const link = (criterion: string, verification: string, result: string, extra: Record<string, unknown> = {}) => ({
+  title: `${criterion} ${verification}`,
+  url: `https://example.com/${criterion}`,
+  criterion,
+  verification,
+  result,
+  ...extra,
+});
+
+const KIND = "work/work.kind.mjs";
+let root: string;
+
+beforeAll(() => {
+  root = repo({
+    "chant.workspace.json": JSON.stringify(
+      {
+        name: "studio",
+        schema: 1,
+        members: [{ name: "app", dir: "app", kind: "other", because: "a plain Node server" }],
+        records: [{ kind: "decisions/decision.kind.mjs" }, { kind: KIND }],
+      },
+      null,
+      2,
+    ),
+    "app/server.mjs": "export const port = 8080;\n",
+    "decisions/decision.kind.mjs": ref("decisions/decision.kind.mjs"),
+    "decisions/decision.schema.json": ref("decisions/decision.schema.json"),
+    "decisions/ref-001-how-the-app-is-deployed.md": ref("decisions/ref-001-how-the-app-is-deployed.md"),
+    [KIND]: ref(KIND),
+    "work/work.schema.json": ref("work/work.schema.json"),
+    "work/W-001-met.md": work("W-001", {
+      acceptance: [
+        { id: "AC-1", text: "The server answers on its port", verification: "unit" },
+        { id: "AC-2", text: "A designer finds the page matches the spec", verification: "manual" },
+      ],
+      evidence: [link("AC-1", "unit", "fail"), link("AC-1", "unit", "pass"), link("AC-2", "manual", "pass", { by: "bob" })],
+    }),
+    "work/W-002-unmet.md": work("W-002", {
+      acceptance: [{ id: "AC-1", text: "The page loads in a browser", verification: "e2e" }],
+      evidence: [link("AC-1", "unit", "pass")],
+    }),
+    "work/W-003-self.md": work("W-003", {
+      acceptance: [{ id: "AC-1", text: "Someone else signs off", verification: "manual" }],
+      evidence: [link("AC-1", "manual", "pass", { by: "Alice" })],
+    }),
+    "work/W-004-legacy.md": work("W-004", { evidence: [{ title: "The review", url: "https://example.com/review" }] }),
+    "work/W-005-leased.md": work("W-005", {
+      state: "in-progress",
+      closed_on: null,
+      acceptance: [
+        { id: "AC-1", text: "The server's test passes", verification: "unit" },
+        { id: "AC-2", text: "A person tries it", verification: "manual" },
+      ],
+    }),
+  });
+  git(root, "config", "user.name", "t");
+  git(root, "config", "user.email", "t@example.com");
+  git(root, "config", "commit.gpgsign", "false");
+  git(root, "add", "-A");
+  git(root, "commit", "-q", "-m", "the work");
+});
+afterAll(cleanScratch);
+
+const records = contract(recordsSchema);
+
+async function read() {
+  const doc = await queryRecords({ kind: join(root, KIND), cwd: root, workGaps: false });
+  records.expectValid(doc);
+  if ("error" in doc || !("records" in doc)) throw new Error(JSON.stringify(doc));
+  return doc.records;
+}
+
+const codes = (r: { warnings: { code: string }[] }) => r.warnings.map((w) => w.code);
+
+describe("acceptance criteria on read (#2772)", () => {
+  test("met: each criterion has passing evidence of its verification, and the manual verdict is someone else's", async () => {
+    const w1 = (await read()).find((r) => r.id === "W-001")!;
+    expect(w1.valid).toBe(true);
+    expect(w1.acceptance).toEqual({
+      met: 2,
+      total: 2,
+      criteria: [
+        { id: "AC-1", verification: "unit", met: true },
+        { id: "AC-2", verification: "manual", met: true },
+      ],
+    });
+    expect(codes(w1)).toEqual([]);
+  });
+
+  test("unmet: evidence of another verification does not count, and the done item is warned", async () => {
+    const w2 = (await read()).find((r) => r.id === "W-002")!;
+    expect(w2.acceptance).toMatchObject({ met: 0, total: 1 });
+    expect(codes(w2)).toEqual(["work-acceptance-unmet"]);
+    expect(w2.warnings[0].message).toMatch(/AC-1 \(e2e\)/);
+  });
+
+  test("manual by the implementer: the verdict is refused, warned, and the criterion stays unmet", async () => {
+    const w3 = (await read()).find((r) => r.id === "W-003")!;
+    expect(w3.acceptance).toMatchObject({ met: 0, total: 1 });
+    expect(codes(w3)).toEqual(["work-acceptance-self-verified", "work-acceptance-unmet"]);
+  });
+
+  test("a legacy item without criteria is valid, reads acceptance null and gets no acceptance warning", async () => {
+    const w4 = (await read()).find((r) => r.id === "W-004")!;
+    expect(w4.valid).toBe(true);
+    expect(w4.acceptance).toBeNull();
+    expect(codes(w4)).toEqual([]);
+  });
+
+  test("an open item with criteria unmet is not warned: only done needs them met", async () => {
+    const w5 = (await read()).find((r) => r.id === "W-005")!;
+    expect(w5.acceptance).toMatchObject({ met: 0, total: 2 });
+    expect(codes(w5)).toEqual([]);
+  });
+
+  test("check fails with WSP117 and the reason code on each done item with a criterion unmet", async () => {
+    const report = await runDeclarationChecks(root);
+    const wsp117 = report.diagnostics.filter((d) => d.ruleId === "WSP117");
+    expect(wsp117.map((d) => [d.file, d.code, d.severity])).toEqual([
+      ["work/W-002-unmet.md", "work-acceptance-unmet", "error"],
+      ["work/W-003-self.md", "work-acceptance-unmet", "error"],
+    ]);
+    expect(report.ok).toBe(false);
+  });
+
+  test("ls --json and status --json count each item's criteria, met of total, in the read contract", async () => {
+    const ls = await listWorkspaceWithKinds({ cwd: root });
+    contract(lsSchema).expectValid(ls);
+    if ("error" in ls) throw new Error(ls.error.message);
+    const kinds = Object.fromEntries(ls.workspace.records.map((r) => [r.path, r.acceptance]));
+    expect(kinds["decisions/decision.kind.mjs"]).toBeNull();
+    expect(kinds[KIND]).toEqual([
+      { item: "W-001", state: "done", met: 2, total: 2 },
+      { item: "W-002", state: "done", met: 0, total: 1 },
+      { item: "W-003", state: "done", met: 0, total: 1 },
+      { item: "W-005", state: "in-progress", met: 0, total: 2 },
+    ]);
+
+    const status = await workspaceStatus({ cwd: root, env: "dev" });
+    contract(statusSchema).expectValid(status);
+    if ("error" in status) throw new Error(status.error.message);
+    expect(status.acceptance.map((a) => [a.member, a.kind, a.item, `${a.met}/${a.total}`])).toEqual([
+      [null, KIND, "W-001", "2/2"],
+      [null, KIND, "W-002", "0/1"],
+      [null, KIND, "W-003", "0/1"],
+      [null, KIND, "W-005", "0/2"],
+    ]);
+  });
+});
+
+describe("a steward Op under workLease attaches evidence to a criterion (#2772)", () => {
+  const evidenceDoc = contract(workEvidenceSchema);
+
+  async function run(config: OpConfig, holder: string): Promise<OpRunResult> {
+    const activities = new Map<string, ActivityFn>([["workEvidence", workEvidenceActivity as unknown as ActivityFn]]);
+    try {
+      return await runOpLocally(config, activities, ACTIVITY_PROFILES, undefined, { cwd: root, ledger: { cwd: root }, work: { holder } });
+    } catch (err) {
+      if (err instanceof OpRunFailure) return err.result;
+      throw err;
+    }
+  }
+
+  const op = (step: ReturnType<typeof workEvidence>): OpConfig => ({
+    name: "verify",
+    overview: "attach the test run to its criterion",
+    workLease: { item: "W-005", kind: KIND },
+    phases: [{ name: "Verify", steps: [step] }],
+  });
+
+  test("the run holding the lease appends passing evidence, and the criterion is met", async () => {
+    const config = op(workEvidence("AC-1", { result: "pass", title: "the server test", url: "https://example.com/ci/1", cwd: root }));
+    expect(declareSteward({ name: "box", ops: [config] }).ops).toHaveLength(1);
+    const result = await run(config, "box/verify@h1");
+    expect(result.status).toBe("ok");
+    expect(result.workLease).toMatchObject({ item: "W-005", released: true });
+    const w5 = (await read()).find((r) => r.id === "W-005")!;
+    expect(w5.acceptance).toMatchObject({ met: 1, total: 2 });
+    expect(w5.data!.evidence).toEqual([
+      expect.objectContaining({ url: "https://example.com/ci/1", criterion: "AC-1", verification: "unit", result: "pass", by: "box/verify@h1" }),
+    ]);
+  });
+
+  test("a manual criterion is refused: the run holding the lease is the implementer", async () => {
+    const result = await run(op(workEvidence("AC-2", { result: "pass", title: "tried it", url: "https://example.com/tried", cwd: root })), "box/verify@h2");
+    expect(result.status).toBe("fail");
+    expect(JSON.stringify(result.records)).toMatch(/work-acceptance-self-verified/);
+    expect((await read()).find((r) => r.id === "W-005")!.acceptance).toMatchObject({ met: 1, total: 2 });
+  });
+
+  test("without the live lease, or with another token or criterion, nothing is written", async () => {
+    const ask = (over: Partial<Parameters<typeof attachWorkEvidence>[0]>) =>
+      attachWorkEvidence({ cwd: root, item: "W-005", holder: "me", token: "t", criterion: "AC-1", result: "pass", title: "x", url: "https://example.com/x", ...over });
+    const unleased = await ask({});
+    evidenceDoc.expectValid(unleased);
+    expect("error" in unleased && unleased.error.code).toBe("lease-not-held");
+
+    const claimed = await claimWorkLease("W-005", "me", { cwd: join(root, "work") });
+    if (!claimed.ok) throw new Error(claimed.message);
+    try {
+      expect(await ask({ token: "other" })).toMatchObject({ error: { code: "lease-token-mismatch" } });
+      expect(await ask({ holder: "you", token: claimed.lease.token })).toMatchObject({ error: { code: "lease-held" } });
+      expect(await ask({ token: claimed.lease.token, criterion: "AC-9" })).toMatchObject({ error: { code: "work-criterion-unknown" } });
+      const ok = await ask({ token: claimed.lease.token, result: "fail" });
+      evidenceDoc.expectValid(ok);
+      expect(ok).toMatchObject({ item: "W-005", kind: KIND, path: "work/W-005-leased.md", acceptance: { met: 1, total: 2 } });
+    } finally {
+      await releaseWorkLease("W-005", "me", { cwd: join(root, "work"), token: claimed.lease.token });
+    }
+    expect(await attachWorkEvidence({ cwd: root, item: "W-004", holder: "me", token: "t", criterion: "AC-1", result: "pass", title: "x", url: "https://example.com/x" })).toMatchObject({
+      error: { code: "work-item-closed" },
+    });
+  });
+});

package/src/workspace/{work-cli.test.ts → work-cli.e2e.test.ts}

@@ -158,7 +158,7 @@ describe("chant workspace work (#2732)", () => {
     expect(json(closed).error.code).toBe("work-item-closed");
     const verb = await chant(root, ["workspace", "work", "grab", "W-001", "--holder", "a"]);
     expect(verb.code).toBe(1);
-    expect(verb.stderr).toContain("claim, renew or release");
+    expect(verb.stderr).toContain("claim, renew, release or history");
     const noHolder = await chant(root, ["workspace", "work", "claim", "W-001"]);
     expect(noHolder.code).toBe(1);
     expect(noHolder.stderr).toContain("--holder");