@intentius/chant 0.91.0 → 0.93.0

package/src/workspace/records-write.test.ts

@@ -2,14 +2,13 @@
  * `chant workspace records new|amend|review` (#2670): each command validates
  * before it writes, writes exactly one file or none, and refuses with a closed
  * code. Run in a directory outside git holding a copy of the decision kind.
+ * The same commands through the CLI are in records-write.e2e.test.ts (#2817).
  */
 
-import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { cpSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { pathToFileURL } from "node:url";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import { parseFrontMatter, recordTextDigest } from "./records";
 import { allocateId, amendRecord, newRecord, renderRecord, reviewRecord, toYaml } from "./records-write";
@@ -187,7 +186,7 @@ describe("records new", () => {
   });
 
   test("keeps the width of the ids it follows", () => {
-    const entry = (id: string) => ({ id, path: `d/${id}-x.md`, state: null, valid: true, reasons: [], supersededBy: null, data: {}, digest: "", assets: [], warnings: [] });
+    const entry = (id: string) => ({ id, path: `d/${id}-x.md`, state: null, valid: true, reasons: [], supersededBy: null, remediatedBy: [], data: {}, digest: "", assets: [], warnings: [] });
     expect(allocateId([entry("s-0009"), entry("s-0010")], undefined, "k")).toBe("s-0011");
     expect(allocateId([entry("s-999")], undefined, "k")).toBe("s-1000");
     // Case and padding come from the records (#2683).
@@ -225,6 +224,35 @@ describe("records new", () => {
   test("a kind that can't be read is its read error", async () => {
     expect(code(await newRecord({ kind: "missing.kind.mjs", fields: fields(fresh()), cwd: dir }))).toBe("kind-unreadable");
   });
+
+  test("--by names the proposer of a record that opens proposed, apart from decided_by (#2756)", async () => {
+    const { id: _id, ...freshProposal } = proposal({ title: "Filed by someone" });
+    const proposed = await newRecord({ kind: KIND, fields: fields(freshProposal), by: "carol", cwd: dir });
+    expect(code(proposed)).toBe("ok");
+    const proposedPath = (proposed as { path: string }).path.replace("decisions/", "");
+    expect(data(proposedPath)).toMatchObject({ proposed_by: "carol", decided_by: null });
+
+    // A conflicting proposed_by given in the fields is refused, same as a conflicting decided_by is today.
+    const conflict = await newRecord({ kind: KIND, fields: fields({ ...freshProposal, title: "Two proposers", proposed_by: "dave" }), by: "carol", cwd: dir });
+    expect(code(conflict)).toBe("write-input-invalid");
+  });
+
+  test("--by names the decider when a new record opens straight into a later state", async () => {
+    const { id: _id, decided_by: _db, ...freshDecided } = decision({ title: "Decided at once" });
+    const decidedDoc = await newRecord({ kind: KIND, fields: fields({ ...freshDecided, decided_by: null }), by: "dana", cwd: dir });
+    expect(code(decidedDoc)).toBe("ok");
+    const decidedPath = (decidedDoc as { path: string }).path.replace("decisions/", "");
+    expect(data(decidedPath)).toMatchObject({ decided_by: "dana" });
+    expect(data(decidedPath)).not.toHaveProperty("proposed_by");
+  });
+
+  test("--by is refused for a kind whose new record opens decided and declares no reviews", async () => {
+    const kindFile = join(dir, "decisions", "decision.kind.mjs");
+    writeFileSync(kindFile, readFileSync(kindFile, "utf-8").replace(/^\s*reviews: \{[^}]*\},?\n/m, ""));
+    const { id: _id, decided_by: _db, ...freshDecided } = decision({ title: "No reviews declared" });
+    const doc = await newRecord({ kind: KIND, fields: fields({ ...freshDecided, decided_by: null }), by: "erin", cwd: dir });
+    expect(code(doc)).toBe("write-usage-invalid");
+  });
 });
 
 describe("records amend", () => {
@@ -336,40 +364,3 @@ describe("records review", () => {
     expect(code(await reviewRecord({ kind: KIND, id: "ws-001", verdict: "agree", by: "a", cwd: dir }))).toBe("review-unsupported");
   });
 });
-
-describe("the command line", () => {
-  const cli = (args: string[], input?: string) => {
-    const loader = pathToFileURL(join(REPO, "node_modules", "tsx", "dist", "loader.mjs")).href;
-    try {
-      const out = execFileSync(process.execPath, ["--import", loader, join(REPO, "packages", "core", "src", "cli", "main.ts"), "workspace", "records", ...args], {
-        cwd: dir,
-        input,
-        encoding: "utf-8",
-        env: { ...process.env, TSX_DISABLE_CACHE: "1" },
-        stdio: ["pipe", "pipe", "pipe"],
-      });
-      return { status: 0, doc: JSON.parse(out) };
-    } catch (err) {
-      const e = err as { status: number; stdout: string };
-      return { status: e.status, doc: JSON.parse(e.stdout) };
-    }
-  };
-
-  test(
-    "new reads fields from standard input, review appends, and a refusal exits 1 with its code",
-    () => {
-      const { id: _id, ...rest } = decision({ title: "From stdin" });
-      const made = cli(["new", KIND, "--from", "-"], JSON.stringify(rest));
-      expect(made).toMatchObject({ status: 0, doc: { id: "ws-004", path: "decisions/ws-004-from-stdin.md" } });
-      expect(existsSync(join(dir, "decisions", "ws-004-from-stdin.md"))).toBe(true);
-      const reviewed = cli(["review", "ws-004", "--kind", KIND, "--verdict", "agree", "--by", "alice"]);
-      expect(reviewed).toMatchObject({ status: 0, doc: { review: { reviewer: "alice", verdict: "agree" } } });
-      const refused = cli(["review", "ws-004", "--kind", KIND, "--verdict", "dissent", "--by", "bob"]);
-      expect(refused).toMatchObject({ status: 1, doc: { error: { code: "review-note-required" } } });
-      writeFileSync(join(dir, "patch.json"), JSON.stringify({ title: "Changed" }));
-      expect(cli(["amend", "ws-004", "--kind", KIND, "--set", "patch.json"])).toMatchObject({ status: 1, doc: { error: { code: "amend-supersede-instead" } } });
-      expect(cli(["amend", "ws-004", "--set", "patch.json"])).toMatchObject({ status: 1, doc: { error: { code: "write-usage-invalid" } } });
-    },
-    120_000,
-  );
-});

package/src/workspace/records-write.ts

@@ -629,9 +629,15 @@ export interface WriteChannel {
   opensInitial?: boolean;
 }
 
-/** What a channel's write adds to the command line's: who the author is, and how it came. */
+/** What a channel's write adds to the command line's: who named the author, and how it came. */
 export interface ChannelOptions {
-  /** The record's author, written to the kind's `reviews.decider` field: the person or agent that decided. */
+  /**
+   * Who the caller names as the record's author (#2756). Written to the
+   * kind's `proposedBy` field when the kind declares one and the record
+   * opens (or stays) in its first state — a proposal naming its proposer.
+   * Otherwise written to `reviews.decider`, as before: a record opening (or
+   * moving) straight to another state names who decided it.
+   */
   by?: string;
   through?: WriteChannel;
 }
@@ -640,18 +646,8 @@ export interface ChannelOptions {
 function applyChannel(o: Opened, fields: Record<string, unknown>, opts: ChannelOptions, isNew: boolean, flag: string): Record<string, unknown> {
   const { kind } = o.loaded;
   const out = { ...fields };
-  if (opts.by !== undefined) {
-    if (!kind.reviews) throw new RecordWriteError("write-usage-invalid", `by names a record's author, the kind's reviews.decider field, and the ${kind.name} kind declares no reviews`);
-    if (opts.by.trim() === "") throw new RecordWriteError("write-usage-invalid", "by needs the name of the person or agent that decided");
-    const f = kind.reviews.decider;
-    if (out[f] !== undefined && out[f] !== null && out[f] !== opts.by) {
-      throw new RecordWriteError("write-input-invalid", `the fields given with ${flag} set ${f} to ${JSON.stringify(out[f])}, and by names ${JSON.stringify(opts.by)}: give one author`);
-    }
-    out[f] = opts.by;
-  }
   const through = opts.through;
-  if (!through) return out;
-  if (isNew && through.opensInitial && kind.states && kind.stateField !== undefined) {
+  if (isNew && through?.opensInitial && kind.states && kind.stateField !== undefined) {
     const first = kind.states[0];
     const state = out[kind.stateField];
     if (state === undefined) out[kind.stateField] = first;
@@ -662,6 +658,27 @@ function applyChannel(o: Opened, fields: Record<string, unknown>, opts: ChannelO
       );
     }
   }
+  if (opts.by !== undefined) {
+    if (opts.by.trim() === "") throw new RecordWriteError("write-usage-invalid", "by needs the name of the person or agent that proposed or decided");
+    // A new record that opens in the kind's first state is a proposal, when the kind opts in with proposedBy (#2756):
+    // by names the proposer, kept apart from reviews.decider, which stays null until the record is decided.
+    const opensInitial = isNew && !!kind.states && kind.stateField !== undefined && (out[kind.stateField] === undefined || out[kind.stateField] === kind.states[0]);
+    if (kind.proposedBy && opensInitial) {
+      const f = kind.proposedBy.field;
+      if (out[f] !== undefined && out[f] !== null && out[f] !== opts.by) {
+        throw new RecordWriteError("write-input-invalid", `the fields given with ${flag} set ${f} to ${JSON.stringify(out[f])}, and by names ${JSON.stringify(opts.by)}: give one proposer`);
+      }
+      out[f] = opts.by;
+    } else {
+      if (!kind.reviews) throw new RecordWriteError("write-usage-invalid", `by names a record's author, the kind's reviews.decider field, and the ${kind.name} kind declares no reviews`);
+      const f = kind.reviews.decider;
+      if (out[f] !== undefined && out[f] !== null && out[f] !== opts.by) {
+        throw new RecordWriteError("write-input-invalid", `the fields given with ${flag} set ${f} to ${JSON.stringify(out[f])}, and by names ${JSON.stringify(opts.by)}: give one author`);
+      }
+      out[f] = opts.by;
+    }
+  }
+  if (!through) return out;
   if (kind.source && (isNew || kind.source.field in out)) {
     const f = kind.source.field;
     const block = out[f];
@@ -984,7 +1001,7 @@ async function seal(sign: string | true, cwd: string, v: { record: string; diges
 // ── The command ──────────────────────────────────────────────────────────────
 
 export const WRITE_USAGE = [
-  "chant workspace records new [<kind file or declared kind>] --from <file|-> [--prefix <prefix>] [--sign [<key file>]] [--dry-run]",
+  "chant workspace records new [<kind file or declared kind>] --from <file|-> [--prefix <prefix>] [--by <name>] [--sign [<key file>]] [--dry-run]",
   "chant workspace records amend <id> [--kind <kind file>] --set <file|-> [--sign [<key file>]] [--dry-run]",
   "chant workspace records review <id> [--kind <kind file>] --verdict agree|dissent|abstain --by <principal> [--note <text>] [--session <id>] [--sign [<key file>]] [--dry-run]",
   "chant workspace records close <session id> [--kind <session kind file>] [--dry-run]",
@@ -1087,7 +1104,7 @@ export async function runRecordsWrite(ctx: CommandContext): Promise<number> {
     if (typeof kind !== "string") return print(kind);
     const input = readInput(RECORDS_NEW_SCHEMA_ID, "--from", args.migrateFrom, cwd);
     if (typeof input !== "string") return print(input);
-    return print(await newRecord({ kind, fields: input, prefix: args.prefix, sign: args.sign, dryRun: args.dryRun, cwd }));
+    return print(await newRecord({ kind, fields: input, prefix: args.prefix, by: args.by, sign: args.sign, dryRun: args.dryRun, cwd }));
   }
   const schema = verb === "amend" ? RECORDS_AMEND_SCHEMA_ID : RECORDS_REVIEW_SCHEMA_ID;
   const id = args.extraPositional2;
@@ -1095,6 +1112,7 @@ export async function runRecordsWrite(ctx: CommandContext): Promise<number> {
   const kind = args.kind !== undefined ? resolveWriteKind(args.kind, cwd) : declaredWriteKind(schema, cwd, "--kind <kind file> is required");
   if (typeof kind !== "string") return print(kind);
   if (verb === "amend") {
+    if (args.by !== undefined) return print(usage(schema, "--by is not taken by amend: set decided_by, or a kind's proposedBy field, with --set"));
     const input = readInput(schema, "--set", args.set, cwd);
     if (typeof input !== "string") return print(input);
     return print(await amendRecord({ kind, id, fields: input, sign: args.sign, dryRun: args.dryRun, cwd }));

package/src/workspace/records.schema.json

@@ -116,7 +116,7 @@
     },
     "record": {
       "type": "object",
-      "required": ["id", "path", "state", "valid", "reasons", "supersededBy", "data"],
+      "required": ["id", "path", "state", "valid", "reasons", "supersededBy", "remediatedBy", "data"],
       "properties": {
         "id": { "type": ["string", "null"], "description": "Null when the record could not be parsed or has no string id. For a content-addressed kind (idFrom sha256, added by #2664), the lowercase hex SHA-256 of the file's bytes, the same string a pin of the file carries." },
         "path": { "type": "string", "description": "From the repository root, with / separators." },
@@ -127,6 +127,11 @@
           "type": ["string", "null"],
           "description": "The id of the closed record whose supersedes link replaces this one. Derived from that record's link, never from this record's own fields."
         },
+        "remediatedBy": {
+          "description": "Added in contract 1 by #2774. The ids of records whose remediates link names this one, in path order. Unlike supersededBy, several records may remediate the same one, and a remediation never changes this record's state or supersededBy: it stays exactly as current as it was.",
+          "type": "array",
+          "items": { "type": "string" }
+        },
         "data": {
           "type": ["object", "null"],
           "description": "The record's structured core as JSON: the front matter, or for a kind of format json the whole file (#2664). It follows the kind's schema when valid is true. Null when it could not be parsed."
@@ -138,7 +143,7 @@
           "items": { "$ref": "#/$defs/asset" }
         },
         "warnings": {
-          "description": "Added in contract 1 by #2549. Findings that leave the record valid: a pinned file that changed, went missing or did not follow a superseding decision, a supersedes link that has no effect yet, (added by #2654) an evidence list that is empty, (added by #2672) a verdict that names no digest, or (added by #2683) a work record's links and dates, or (added by #2688) a record whose author seal is not attested under a signers file at base. A work record never carries record-no-evidence; a done one with no evidence carries work-done-unpinned. valid and --current do not look at them.",
+          "description": "Added in contract 1 by #2549. Findings that leave the record valid: a pinned file that changed, went missing or did not follow a superseding decision, a supersedes link that has no effect yet, (added by #2654) an evidence list that is empty, (added by #2672) a verdict that names no digest, or (added by #2683) a work record's links and dates, or (added by #2688) a record whose author seal is not attested under a signers file at base, or (added by #2772) a work record's acceptance criteria unmet when it is done, or met by a manual verdict from its implementer. A work record never carries record-no-evidence; a done one with no evidence carries work-done-unpinned. valid and --current do not look at them.",
           "type": "array",
           "items": { "$ref": "#/$defs/warning" }
         },
@@ -178,6 +183,10 @@
           "type": "array",
           "items": { "$ref": "#/$defs/workLink" }
         },
+        "acceptance": {
+          "description": "Added in contract 1 by #2772, on every parsed record of a work kind whose work block names acceptance criteria. How many of the record's criteria passing evidence meets: evidence naming the criterion, with result pass and the criterion's verification, and for a manual criterion a by other than the implementer. Null when the record lists no criteria, so a record without them reads as before.",
+          "oneOf": [{ "type": "null" }, { "$ref": "#/$defs/workAcceptance" }]
+        },
         "lease": {
           "description": "Added in contract 1 by #2732, on every record of a work kind with an id, read in the working tree (absent under --at). The item's active work lease (chant workspace work claim), or null when nobody holds one live. Read from the local lease refs, refs/chant/lease/[_members/<member>/]work/<id> and the remote's as last fetched, of the ledger owning the work kind file; records never fetches.",
           "oneOf": [{ "type": "null" }, { "$ref": "#/$defs/workLease" }]
@@ -191,6 +200,27 @@
         }
       ]
     },
+    "workAcceptance": {
+      "type": "object",
+      "required": ["met", "total", "criteria"],
+      "properties": {
+        "met": { "type": "integer", "minimum": 0, "description": "How many criteria passing evidence meets." },
+        "total": { "type": "integer", "minimum": 0, "description": "How many criteria the record lists." },
+        "criteria": {
+          "type": "array",
+          "description": "Each criterion, in the record's order.",
+          "items": {
+            "type": "object",
+            "required": ["id", "verification", "met"],
+            "properties": {
+              "id": { "type": "string" },
+              "verification": { "enum": ["unit", "integration", "e2e", "runtime", "manual"], "description": "The verification the criterion expects." },
+              "met": { "type": "boolean" }
+            }
+          }
+        }
+      }
+    },
     "workLease": {
       "type": "object",
       "required": ["holder", "token", "acquiredAt", "expiresAt"],
@@ -231,6 +261,8 @@
             "work-done-unpinned",
             "work-closed-without-date",
             "work-done-gap-open",
+            "work-acceptance-unmet",
+            "work-acceptance-self-verified",
             "answer-points-unreadable",
             "answer-point-unknown",
             "answer-point-changed",
@@ -372,6 +404,8 @@
             "record-id-duplicate",
             "record-supersedes-unknown",
             "record-supersedes-conflict",
+            "record-remediates-unknown",
+            "record-remediates-not-closed",
             "session-seal-mismatch",
             "session-verdict-unknown-record"
           ]

package/src/workspace/records.test.ts

@@ -11,12 +11,17 @@ const REPO = join(import.meta.dirname, "..", "..", "..", "..");
 const DECISIONS = join(REPO, "docs", "design", "decisions");
 const SAMPLE = readFileSync(join(DECISIONS, "ws-003-seal-scope.md"), "utf-8");
 
-/** A copy of a real decision with its id, state and supersedes links replaced. */
-function decision(id: string, state = "decided", supersedes: string[] = []): string {
+/** A copy of a real decision with its id, state, supersedes and remediates links replaced. */
+function decision(id: string, state = "decided", supersedes: string[] = [], remediates: string[] = []): string {
   const links = supersedes.length === 0 ? "supersedes: []" : `supersedes:\n${supersedes.map((d) => `  - decision: "${d}"`).join("\n")}`;
-  return SAMPLE.replace(/^id: .*$/m, `id: "${id}"`)
+  let text = SAMPLE.replace(/^id: .*$/m, `id: "${id}"`)
     .replace(/^state: .*$/m, `state: "${state}"`)
     .replace(/^supersedes:(?: \[\])?\n(?:  .*\n)*/m, `${links}\n`);
+  if (remediates.length > 0) {
+    const block = `remediates:\n${remediates.map((d) => `  - decision: "${d}"`).join("\n")}\n`;
+    text = text.replace(/^evidence:/m, `${block}evidence:`);
+  }
+  return text;
 }
 
 let dir: string;
@@ -235,6 +240,46 @@ describe("readRecords", () => {
     expect(codes(records[2])).toEqual(["record-supersedes-conflict"]);
   });
 
+  test("a remediates link to a missing id is record-remediates-unknown", async () => {
+    write("ws-002-b.md", decision("ws-002", "decided", [], ["ws-404"]));
+    const [r] = (await read()).records;
+    expect(codes(r)).toEqual(["record-remediates-unknown"]);
+  });
+
+  test("a remediates link to an open record is record-remediates-not-closed: a record still open is amended instead", async () => {
+    write("ws-001-a.md", decision("ws-001", "decided"));
+    write("ws-002-b.md", decision("ws-002", "ratified", [], ["ws-001"]));
+    const [ws001, ws002] = (await read()).records;
+    expect(codes(ws002)).toEqual(["record-remediates-not-closed"]);
+    expect(ws001.remediatedBy).toEqual([]);
+  });
+
+  test("remediation leaves the target current and its state unchanged, and several records may remediate the same one (#2774)", async () => {
+    write("ws-001-a.md", decision("ws-001", "ratified"));
+    write("ws-002-b.md", decision("ws-002", "ratified", [], ["ws-001"]));
+    write("ws-003-c.md", decision("ws-003", "ratified", [], ["ws-001"]));
+    const all = await read();
+    const [ws001] = all.records;
+    expect(ws001.state).toBe("ratified");
+    expect(ws001.supersededBy).toBeNull();
+    expect(ws001.remediatedBy).toEqual(["ws-002", "ws-003"]);
+    expect(all.summary.superseded).toBe(0);
+    const current = await read({ current: true });
+    expect(current.records.map((r) => r.id)).toEqual(["ws-001", "ws-002", "ws-003"]);
+  });
+
+  test("remediates and supersedes are independent links, and a record may carry both to different targets (#2774)", async () => {
+    write("ws-001-a.md", decision("ws-001", "ratified"));
+    write("ws-002-b.md", decision("ws-002", "ratified"));
+    write("ws-003-c.md", decision("ws-003", "ratified", ["ws-002"], ["ws-001"]));
+    const all = await read();
+    expect(all.records.map((r) => [r.id, r.supersededBy, r.remediatedBy])).toEqual([
+      ["ws-001", null, ["ws-003"]],
+      ["ws-002", "ws-003", []],
+      ["ws-003", null, []],
+    ]);
+  });
+
   test("a missing records directory is location-missing", async () => {
     const loaded = await loadRecordKind(join(dir, "decisions", "decision.kind.mjs"));
     const moved: LoadedRecordKind = { ...loaded, dir: join(dir, "nowhere") };

package/src/workspace/records.ts

@@ -6,8 +6,10 @@
  * record a kind locates, parses its structured core (the front matter, as the
  * JSON subset of YAML, or the whole file as one I-JSON object, ws-053),
  * validates it against the kind's schema and derives supersession from the
- * records' own `supersedes` links. It never writes a record; `records-write.ts`
- * does, through the rules here (#2670).
+ * records' own `supersedes` links, and remediation from their `remediates`
+ * links (#2774): a later record fixing a closed one's consequence without
+ * replacing it, which leaves the closed record's status unchanged. It never
+ * writes a record; `records-write.ts` does, through the rules here (#2670).
  *
  * A record that fails any of that is still returned, with reason codes, and the
  * read succeeds. Only a failure to read the kind, its schema or the revision is
@@ -31,7 +33,7 @@ import { joinSessions, type SessionCitation } from "./record-sessions";
 import type { RecordSource } from "./record-source";
 import { sourceBlock, sourceBlockProblems, transcriptDrift } from "./source-block";
 import type { WorkspaceTree } from "./tree";
-import type { DecisionWork, WorkLink, WorkWarningCode } from "./work";
+import type { DecisionWork, WorkAcceptance, WorkLink, WorkWarningCode } from "./work";
 import type { AnswerWarningCode } from "./points";
 
 // ── Reason codes ─────────────────────────────────────────────────────────────
@@ -51,6 +53,10 @@ export const RECORD_REASON_CODES = [
   "record-supersedes-unknown",
   /** A second closed record supersedes a record another one already superseded. */
   "record-supersedes-conflict",
+  /** A `remediates` link names an id no record has (#2774). */
+  "record-remediates-unknown",
+  /** A `remediates` link names a record that isn't closed: a record still open is amended instead (#2774). */
+  "record-remediates-not-closed",
   /** A closed session's seal is not the digest of its text: it changed after it closed (#2673). */
   "session-seal-mismatch",
   /** A session's verdict names a record the kind's subject records do not have (#2673). */
@@ -279,6 +285,16 @@ export const recordKindSchema = z
      * (ws-053). Optional, and only on a kind with states.
      */
     supersedes: z.object({ field: z.string().min(1), key: z.string().min(1).optional() }).strict().optional(),
+    /**
+     * The field of links to records this one remediates: a later fix to a
+     * closed record's consequence, that leaves the closed record's status
+     * unchanged (#2774). Shaped like `supersedes`: with `key`, a list of
+     * objects whose `key` holds the target id; without it, one id or a list
+     * of ids. Optional, and only on a kind with states. A link is valid only
+     * when the target exists and is in one of `closedStates`; a target still
+     * open is amended instead, never remediated.
+     */
+    remediates: z.object({ field: z.string().min(1), key: z.string().min(1).optional() }).strict().optional(),
     /**
      * How strongly each state is approved (#2524 D4). With it, a supersedes
      * link takes effect when the new record's rank is above 0 and at least the
@@ -298,6 +314,15 @@ export const recordKindSchema = z
      * (#2549). Optional.
      */
     constrains: z.object({ field: z.string().min(1) }).strict().optional(),
+    /**
+     * The front-matter list of workspace paths a record puts out of scope
+     * (#2773): a file or a directory, from the workspace root. `chant
+     * workspace check --changes` reports a change to one as
+     * `change-out-of-scope` when the record is in hand for the change, and
+     * the record does not cover it even where its constrains would.
+     * Optional.
+     */
+    outOfScope: z.object({ field: z.string().min(1) }).strict().optional(),
     /**
      * The front-matter list of review verdicts and the field naming the
      * decider (#2671, #2672). With it, each record gets a digest of its text
@@ -307,6 +332,17 @@ export const recordKindSchema = z
      * `withdrawn_on`. Optional.
      */
     reviews: z.object({ field: z.string().min(1), decider: z.string().min(1) }).strict().optional(),
+    /**
+     * The front-matter field a new record's proposer is named on, when the
+     * kind opts in (#2756). `records new --by` and the MCP `records-new`
+     * tool's `by` write it for a record that opens in the kind's first
+     * state — a proposal naming who proposed it — instead of
+     * `reviews.decider`'s field, which `by` fills only when a new record
+     * opens straight into another state. Requires `states`. Optional: a kind
+     * without it keeps `by` writing `reviews.decider` for every new record,
+     * as before #2756.
+     */
+    proposedBy: z.object({ field: z.string().min(1) }).strict().optional(),
     /**
      * The front-matter object that says where a record came from, opted in
      * to the stored source block (#2708): `via`, `client`, `harness`,
@@ -349,6 +385,15 @@ export const recordKindSchema = z
      * date. With it, `work.ts` gives each record `ready`, `blockedBy` and
      * `implements`, and the read lists each decision with `implementedBy`.
      * Optional.
+     *
+     * `acceptance` (#2772) names the front-matter list of a record's
+     * acceptance criteria, each an `id`, `text` and the `verification` it
+     * expects (`unit`, `integration`, `e2e`, `runtime` or `manual`), and the
+     * field naming the record's implementer, whose own `manual` verdict never
+     * counts. With it, each record gets `acceptance` (met and total), and a
+     * done record with a criterion that no passing evidence meets is warned
+     * `work-acceptance-unmet`, which `check` fails on (WSP117). Optional, and
+     * a record without the list is read as before.
      */
     work: z
       .object({
@@ -358,6 +403,7 @@ export const recordKindSchema = z
         open: z.string().min(1),
         done: z.string().min(1),
         closedOn: z.string().min(1),
+        acceptance: z.object({ field: z.string().min(1), implementer: z.string().min(1) }).strict().optional(),
       })
       .strict()
       .optional(),
@@ -386,6 +432,10 @@ export const recordKindSchema = z
     message: "a kind without states cannot have supersedes: a link takes effect only from a closed or ranked state",
     path: ["supersedes"],
   })
+  .refine((k) => k.states !== undefined || k.remediates === undefined, {
+    message: "a kind without states cannot have remediates: a link only ever targets a record in a closed state",
+    path: ["remediates"],
+  })
   .refine((k) => k.states !== undefined || k.session === undefined, {
     message: "a session kind must have states: a session is sealed when it reaches a closed state",
     path: ["session"],
@@ -394,6 +444,10 @@ export const recordKindSchema = z
     message: "a kind without states cannot have approval ranks",
     path: ["approval"],
   })
+  .refine((k) => k.states !== undefined || k.proposedBy === undefined, {
+    message: "a kind without states cannot have proposedBy: there is no first state for a record to open in",
+    path: ["proposedBy"],
+  })
   .refine((k) => (k.closedStates ?? []).every((s) => (k.states ?? []).includes(s)), {
     message: "every closed state must be listed in states",
     path: ["closedStates"],
@@ -406,6 +460,10 @@ export const recordKindSchema = z
     message: "a work kind must have states, and its work open and done states must be listed in them",
     path: ["work"],
   })
+  .refine((k) => !k.work?.acceptance || k.pins !== undefined, {
+    message: "a work kind with acceptance criteria must have pins: a criterion is met by the evidence in its pins field",
+    path: ["work", "acceptance"],
+  })
   .refine(
     (k) =>
       !k.answers ||
@@ -961,6 +1019,13 @@ export interface RecordEntry {
   reasons: RecordReason[];
   /** The id of the closed record whose `supersedes` link replaces this one, or null. */
   supersededBy: string | null;
+  /**
+   * The ids of records whose `remediates` link names this one (#2774), in
+   * path order. Unlike `supersededBy`, several records may remediate the
+   * same one, and a remediation never changes this record's state or
+   * `supersededBy`: it stays exactly as current as it was.
+   */
+  remediatedBy: string[];
   /** The record's structured core as JSON (the front matter, or the whole JSON file), or null when it could not be parsed. */
   data: Record<string, unknown> | null;
   /**
@@ -981,6 +1046,8 @@ export interface RecordEntry {
   blockedBy?: WorkLink[];
   /** For a work kind: each decision the record implements, with its state, or null when no decision has the id. */
   implements?: WorkLink[];
+  /** For a work kind with acceptance criteria (#2772): how many of the record's criteria passing evidence meets, or null when it lists none. */
+  acceptance?: WorkAcceptance | null;
 }
 
 export interface ReadRecordsOptions {
@@ -1100,6 +1167,20 @@ export function supersedesTargets(kind: Pick<RecordKind, "supersedes">, data: Re
   return ids.filter((x): x is string => typeof x === "string");
 }
 
+/**
+ * The ids a record's remediates field names (#2774), read the same way
+ * {@link supersedesTargets} reads `supersedes`.
+ */
+export function remediatesTargets(kind: Pick<RecordKind, "remediates">, data: Record<string, unknown> | null): string[] {
+  if (!kind.remediates || data === null) return [];
+  const { field, key } = kind.remediates;
+  const value = data[field];
+  if (key === undefined && typeof value === "string") return [value];
+  if (!Array.isArray(value)) return [];
+  const ids = key === undefined ? value : value.map((l) => (l !== null && typeof l === "object" ? (l as Record<string, unknown>)[key] : undefined));
+  return ids.filter((x): x is string => typeof x === "string");
+}
+
 /** The stem of a file name: the name up to its first `.`, the hash a content-addressed record's name claims (ws-053). */
 function nameStem(path: string): string {
   const name = path.slice(path.lastIndexOf("/") + 1);
@@ -1135,6 +1216,7 @@ export async function readRecords(loaded: LoadedRecordKind, options: ReadRecords
       valid: true,
       reasons: [],
       supersededBy: null,
+      remediatedBy: [],
       data: null,
       assets: [],
       warnings: [],
@@ -1254,6 +1336,30 @@ export async function readRecords(loaded: LoadedRecordKind, options: ReadRecords
     }
   }
 
+  // Remediation (#2774): a later record fixes a consequence of a closed one
+  // without replacing it. The target's status, and its supersededBy, never
+  // change; several records may remediate the same one. Unlike supersedes,
+  // this needs no approval rank: the target is closed or it isn't, and a
+  // still-open target is amended instead of remediated.
+  for (const e of entries) {
+    for (const target of remediatesTargets(kind, e.data)) {
+      const old = byId.get(target);
+      if (!old) {
+        e.reasons.push({ code: "record-remediates-unknown", message: `remediates ${target}, which no record has` });
+        continue;
+      }
+      if (old === e) continue;
+      if (old.state === null || !closed.has(old.state)) {
+        e.reasons.push({
+          code: "record-remediates-not-closed",
+          message: `remediates ${target}, which is ${old.state ?? "stateless"}, not closed; a record still open is amended instead`,
+        });
+        continue;
+      }
+      if (e.id !== null && !old.remediatedBy.includes(e.id)) old.remediatedBy.push(e.id);
+    }
+  }
+
   // A pin that still matches, at the hash a record this one supersedes
   // pinned, while the file has not changed since this record was recorded:
   // the decision moved on and the artifact did not (#2549).

package/src/workspace/status-contract.test.ts

@@ -419,7 +419,7 @@ describe("gate state in chant workspace status --json (#2674)", () => {
         expiresAt: "2026-12-31T00:00:00.000Z",
         approvals: [{ principal: "alice", channel: "cli", at: "2026-09-20T01:00:00.000Z" }],
         needed: 1,
-        approve: "chant approve web deploy --env staging",
+        approve: `chant approve web deploy --env staging --plan ${D("1")}`,
       },
       {
         component: "web",
@@ -431,7 +431,7 @@ describe("gate state in chant workspace status --json (#2674)", () => {
         expiresAt: "2026-12-31T00:00:00.000Z",
         approvals: [],
         needed: 1,
-        approve: "chant approve web deploy --env prod",
+        approve: `chant approve web deploy --env prod --plan ${D("2")}`,
       },
       {
         component: "web",
@@ -444,15 +444,15 @@ describe("gate state in chant workspace status --json (#2674)", () => {
         // The agent's approval doesn't count toward the quorum.
         approvals: [{ principal: "bob", channel: "cli", at: "2026-09-20T02:00:00.000Z" }],
         needed: 2,
-        approve: "chant approve web review --env staging",
+        approve: `chant approve web review --env staging --plan ${D("4")}`,
       },
     ]);
     // api and the root member both read the flat _gates/.
     expect(api.gateLedger).toEqual({ layout: "flat", path: "_gates", shared: true, malformed: 1, reason: null });
     expect(site.gates).toEqual(api.gates);
     expect(api.gates.map((g) => [g.component, g.name, g.env, g.state, g.approve])).toEqual([
-      ["api", "deploy", "staging", "expired", "chant approve api deploy --env staging"],
-      ["api", "smoke", "staging", "superseded", "chant approve api smoke --env staging"],
+      ["api", "deploy", "staging", "expired", `chant approve api deploy --env staging --plan ${D("5")}`],
+      ["api", "smoke", "staging", "superseded", `chant approve api smoke --env staging --plan ${D("6")}`],
       ["nightly", "confirm", null, "approved", "chant approve nightly confirm"],
     ]);
     // The superseding approval named another plan, so it isn't listed as one that counts.
@@ -514,7 +514,7 @@ describe("gate state in chant workspace status --json (#2674)", () => {
       expect(await runWorkspaceStatus({ args: { extraPositional: "staging", extraPositional2: root, json: true } } as unknown as CommandContext)).toBe(0);
       const printed = JSON.parse(String(log.mock.calls.at(-1)?.[0])) as StatusDocument;
       expectValid(printed);
-      expect(result(printed).members.find((m) => m.name === "web")!.gates.map((g) => g.approve)).toContain("chant approve web deploy --env staging");
+      expect(result(printed).members.find((m) => m.name === "web")!.gates.map((g) => g.approve)).toContain(`chant approve web deploy --env staging --plan ${D("1")}`);
     } finally {
       log.mockRestore();
     }
@@ -594,16 +594,19 @@ describe("stewards in chant workspace status --json (#2731)", () => {
         name: "box-converge",
         schedule: { cron: "* * * * *", overlap: "skip" },
         env: "local",
-        lastRun: { id: expect.any(String), status: "ok", started: "2026-09-25T10:00:00.000Z", ended: "2026-09-25T10:00:05.000Z", gate: null },
+        lastRun: { id: expect.any(String), status: "ok", started: "2026-09-25T10:00:00.000Z", ended: "2026-09-25T10:00:05.000Z", gate: null, point: null },
+        // #2778: not a ConvergeOp (no Converge label), so no tick.
+        lastTick: null,
         changesCheckout: false,
         workLease: null,
       },
-      { name: "box-release", schedule: null, env: "local", lastRun: null, changesCheckout: false, workLease: null },
+      { name: "box-release", schedule: null, env: "local", lastRun: null, lastTick: null, changesCheckout: false, workLease: null },
       {
         name: "box-dispatch",
         schedule: { cron: "*/5 * * * *", overlap: "skip" },
         env: "local",
         lastRun: null,
+        lastTick: null,
         changesCheckout: true,
         workLease: {
           kind: null,
@@ -620,6 +623,8 @@ describe("stewards in chant workspace status --json (#2731)", () => {
         },
       },
     ]);
+    // #2749: nothing the steward runs waits on a decision point.
+    expect(s.waiting).toEqual([]);
 
     const k3d = result(await workspaceStatus({ cwd: root, env: "fountain-k3d", now: "2026-09-25T11:00:00.000Z" }));
     expectValid(k3d);