@intentius/chant 0.90.0 → 0.93.0

package/src/workspace/status.ts

@@ -24,7 +24,11 @@
  * The JSON also lists each member's gates, read from its gate ledger on the
  * same branch (#2674, `status-gates.ts`): the state of each, the approvals
  * that count, and the `chant approve` line that answers it. The text view
- * doesn't show them.
+ * doesn't show them. So does each member's box block (#2726): the
+ * capabilities it reaches through a broker, with the broker and the scope a
+ * broker enforces, and, when the block names a host, the box's ports, state
+ * paths and cookie names resolved from its identity (#2727,
+ * `box-isolation.ts`), so a runtime reads them instead of choosing its own.
  */
 
 import { execFileSync } from "node:child_process";
@@ -35,10 +39,14 @@ import type { CommandContext } from "../cli/registry";
 import { GATES_DIR } from "../lifecycle/gate-ledger";
 import { readPathSha } from "../lifecycle/git";
 import { latestPerComponent, readReleaseLedger, type ReleaseRecord } from "../lifecycle/release-ledger";
+import { readReleasePlan, type ReleasePlan } from "../lifecycle/plan-ledger";
+import { listWorkLeases, type WorkLeaseState } from "../lifecycle/work-lease";
 import { findWorkspaceRoot } from "../project-root";
-import { readDeclaration, readerVersion, WorkspaceReadError, type ErrorLocation, type Member } from "./declaration";
+import { resolveBoxes, type ResolvedIsolation } from "./box-isolation";
+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";
 import { gitTop, workingTree } from "./tree";
 import { handToRootChant } from "./which-chant";
 
@@ -71,6 +79,9 @@ export type StatusReasonCode = (typeof STATUS_REASON_CODES)[number];
 /** Why a member's gates can't be listed (#2674). Closed, like {@link STATUS_REASON_CODES}. */
 export const STATUS_GATE_REASON_CODES = GATE_REASON_CODES;
 
+/** Why a member's stewards can't be fully listed (#2731). Closed, like {@link STATUS_REASON_CODES}. */
+export const STATUS_STEWARD_REASON_CODES = STEWARD_REASON_CODES;
+
 /**
  * Why the status couldn't be read at all. The declaration's own codes, except
  * the two that only `--at` returns, and one for the environment name.
@@ -104,6 +115,15 @@ export interface StatusRelease {
   actor: string;
   /** Read flags, such as `legacy-digest` (#2514). */
   flags: string[];
+  /**
+   * The release plan `digest` names, read from `_plans/<digest>.json` on
+   * chant/lifecycle (ws-055, #2733) — the work items and evidence this
+   * release shipped, without the runner's own files. Null when this
+   * checkout has no plan stored under that digest: an ordinary component
+   * release (most releases carry no plan at all), or a plan this checkout
+   * hasn't fetched yet.
+   */
+  plan: ReleasePlan | null;
 }
 
 export interface StatusLedger {
@@ -145,6 +165,44 @@ export interface StatusMember {
   gateLedger: StatusGateLedger;
   /** Each gate in the member's gate ledger, one per environment asked for, sorted by component then gate. */
   gates: StatusGate[];
+  /** The member's box block as declared, or null when it declares none (#2726). A broker reads the scopes it enforces here. */
+  box: StatusBox | null;
+  /** The stewards the member declares (#2731), with their form in `env`, their Ops and each Op's last run. Sorted by name. */
+  stewards: StatusSteward[];
+  /** Why a steward or a last run may be missing from `stewards`. */
+  stewardReasons: { code: StewardReasonCode; message: string }[];
+}
+
+/** A box's brokered capabilities, from the declaration (#2726). */
+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;
+}
+
+/**
+ * One work lease (#2732): a work item's lease ref in the ledger of the member
+ * that owns its work kind, read from the local refs without fetching.
+ */
+export interface StatusLease extends Omit<WorkLeaseState, "ref"> {
+  /** The member whose ledger holds the lease, or null for the flat ledger (the root member, or a kind no member owns). */
+  member: string | null;
+  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 =
@@ -157,6 +215,10 @@ export type StatusDocument =
       lifecycle: { ref: string; commit: string | null };
       workspace: { name: string; root: string; file: string };
       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 };
     }
   | {
@@ -179,6 +241,8 @@ export interface StatusQuery {
   readGates?: GateLedgerReader;
   /** The instant a gate's expiry is measured against; now by default. */
   now?: string;
+  /** Reads one member's stewards; the declaration and ledger reader unless a test swaps it. */
+  readStewards?: typeof readMemberStewards;
 }
 
 class StatusError extends Error {
@@ -240,8 +304,16 @@ async function readEnvironment(member: Member, env: string, cwd: string, read: L
       reason: { code: "ledger-unreadable", message: `${ledger.path}: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}` },
     };
   }
-  const releases = [...latestPerComponent(records).values()]
-    .map((r) => ({
+  // A member's plans live beside its other lifecycle stores (#2524 D7,
+  // #2538): _members/<member>/_plans/ for the "members" layout, the flat
+  // top-level _plans/ for "flat" — the same split ledger.path already
+  // resolved above for releases.jsonl, mirrored here since readReleasePlan
+  // reads through one process for every member without changing cwd per
+  // member (see plan-ledger.ts's readReleasePlan doc).
+  const planPrefix = ledger.layout === "members" ? `${MEMBERS_DIR}/${member.name}/` : "";
+  const latest = [...latestPerComponent(records).values()].sort((a, b) => (a.component < b.component ? -1 : a.component > b.component ? 1 : 0));
+  const releases: StatusRelease[] = await Promise.all(
+    latest.map(async (r) => ({
       component: r.component,
       digest: r.digest,
       gitSha: r.gitSha,
@@ -250,8 +322,9 @@ async function readEnvironment(member: Member, env: string, cwd: string, read: L
       timestamp: r.timestamp,
       actor: r.actor,
       flags: [...(r.flags ?? [])],
-    }))
-    .sort((a, b) => (a.component < b.component ? -1 : a.component > b.component ? 1 : 0));
+      plan: await readReleasePlan(r.digest, { cwd, prefix: planPrefix }),
+    })),
+  );
   return {
     env,
     ledger: { ...ledger, shared: false },
@@ -303,12 +376,14 @@ export async function workspaceStatus(query: StatusQuery): Promise<StatusDocumen
     const commit = lifecycleTip(found.dir);
     const now = query.now ?? new Date().toISOString();
 
+    const isolation = new Map(resolveBoxes(declaration).map((b) => [b.member.name, b.isolation]));
     const members: StatusMember[] = [];
     for (const m of declaration.members) {
       const environments: StatusEnvironment[] = [];
       for (const env of envs) environments.push(await readEnvironment(m, env, found.dir, read));
       const own = await hasMemberLedger(m, found.dir);
       const gates = await readMemberGates(own ? `${MEMBERS_DIR}/${m.name}/${GATES_DIR}` : GATES_DIR, own ? "members" : "flat", commit, envs, found.dir, now, query.readGates);
+      const stewards = await (query.readStewards ?? readMemberStewards)(resolve(found.dir, m.dir), query.env, now, m.kind, m.box);
       members.push({
         name: m.name,
         dir: m.dir,
@@ -318,6 +393,15 @@ export async function workspaceStatus(query: StatusQuery): Promise<StatusDocumen
         readable: environments.every((e) => e.reason === null),
         gateLedger: gates.ledger,
         gates: gates.gates,
+        box:
+          m.box === null
+            ? null
+            : {
+                capabilities: m.box.capabilities.map((c) => ({ name: c.name, broker: c.broker, scope: [...c.scope] })),
+                isolation: isolation.get(m.name) ?? null,
+              },
+        stewards: stewards.stewards,
+        stewardReasons: stewards.reasons,
       });
     }
     // Several members read from one flat ledger see the same records; say so.
@@ -327,6 +411,9 @@ export async function workspaceStatus(query: StatusQuery): Promise<StatusDocumen
     const flatGates = members.filter((m) => m.gateLedger.layout === "flat").length;
     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,
       env: query.env,
@@ -334,6 +421,8 @@ export async function workspaceStatus(query: StatusQuery): Promise<StatusDocumen
       lifecycle: { ref: LIFECYCLE_REF, commit },
       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,
@@ -351,6 +440,31 @@ export async function workspaceStatus(query: StatusQuery): Promise<StatusDocumen
   }
 }
 
+/**
+ * The work leases of the flat ledger and of each member's (#2732). Leases are
+ * env-independent, so the environment asked for doesn't narrow them. Never
+ * fetches: the remote's leases are the ones last fetched.
+ */
+async function readWorkspaceLeases(members: Member[], cwd: string, now: Date): Promise<StatusLease[]> {
+  const ledgers: { member: string | null; prefix: string }[] = [{ member: null, prefix: "" }];
+  for (const m of members) if (m.dir !== ".") ledgers.push({ member: m.name, prefix: `${MEMBERS_DIR}/${m.name}/` });
+  const out: StatusLease[] = [];
+  for (const l of ledgers) {
+    for (const lease of await listWorkLeases({ cwd, memberPrefix: l.prefix, now })) out.push({ ...lease, member: l.member });
+  }
+  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;
@@ -434,6 +548,28 @@ export function formatStatus(doc: Extract<StatusDocument, { members: unknown }>)
       for (const n of notes.get(i) ?? []) lines.push(n);
     });
   }
+  if (doc.leases.length > 0) {
+    lines.push("");
+    const rows: string[][] = [["WORK ITEM", "HOLDER", "EXPIRES", "STATE"]];
+    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("");
+    const rows: string[][] = [["BOX", "HOST", "SLOT", "PORTS", "STATE"]];
+    for (const m of boxes) {
+      const i = m.box!.isolation!;
+      rows.push([m.name, i.host, String(i.slot), `${i.portRange.from}-${i.portRange.to}`, i.stateDir]);
+    }
+    lines.push(...table(rows));
+  }
   const s = doc.summary;
   lines.push("");
   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" },
+    });
+  });
+});