@intentius/chant 0.90.0 → 0.93.0

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" }
         },
@@ -177,6 +182,14 @@
           "description": "Added in contract 1 by #2683, on every parsed record of a work kind. Each decision the record implements, with its state now; null for an id no decision has.",
           "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" }]
         }
       },
       "allOf": [
@@ -187,6 +200,37 @@
         }
       ]
     },
+    "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"],
+      "properties": {
+        "holder": { "type": "string", "description": "Who holds the lease, as --holder gave it." },
+        "token": { "type": "string", "description": "The fencing token: new on every claim, kept by every renew." },
+        "acquiredAt": { "type": "string", "description": "When the lease was claimed, ISO 8601." },
+        "expiresAt": { "type": "string", "description": "When the lease expires unless renewed, ISO 8601." }
+      }
+    },
     "asset": {
       "type": "object",
       "required": ["path", "sha256", "actual", "state"],
@@ -217,6 +261,11 @@
             "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",
             "record-unattested"
           ]
         },
@@ -355,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,8 @@ 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 ─────────────────────────────────────────────────────────────
 
@@ -50,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). */
@@ -175,8 +182,8 @@ export interface VerdictAttestation {
 }
 
 export interface RecordWarning {
-  /** A work kind's records also carry the codes of `WORK_WARNING_CODES` (#2683), and `records` adds `SEAL_WARNING_CODES` (#2688). */
-  code: RecordWarningCode | WorkWarningCode | SealWarningCode;
+  /** A work kind's records also carry the codes of `WORK_WARNING_CODES` (#2683), an answer kind's those of `ANSWER_WARNING_CODES` (#2739), and `records` adds `SEAL_WARNING_CODES` (#2688). */
+  code: RecordWarningCode | WorkWarningCode | SealWarningCode | AnswerWarningCode;
   message: string;
 }
 
@@ -278,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
@@ -297,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
@@ -306,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`,
@@ -348,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({
@@ -357,9 +403,21 @@ 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(),
+    /**
+     * An answer kind (ws-058, #2739): the decision points file its records
+     * answer, relative to this kind file. The records are written by `chant
+     * workspace points ask` and `points answer` in the shape of
+     * `point-answer.schema.json`, with an `id`, the states `escalated`,
+     * `proposed` and `answered`, and `answered` closed. With it, `records`
+     * warns about an answer whose point is gone or changed, `check` validates
+     * the points file (WSP116), and `points` lists the open questions.
+     * Optional.
+     */
+    answers: z.object({ points: z.string().min(1) }).strict().optional(),
   })
   .strict()
   .refine((k) => (k.idField === undefined) !== (k.idFrom === undefined), {
@@ -374,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"],
@@ -382,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"],
@@ -393,7 +459,27 @@ export const recordKindSchema = z
   .refine((k) => !k.work || (k.states !== undefined && k.states.includes(k.work.open) && k.states.includes(k.work.done)), {
     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 ||
+      (k.format === "markdown-front-matter" &&
+        k.idField === "id" &&
+        k.stateField === "state" &&
+        ANSWER_STATES.every((s) => k.states?.includes(s)) &&
+        (k.closedStates ?? []).includes("answered")),
+    {
+      message: 'an answer kind is markdown-front-matter with idField "id", stateField "state", the states escalated, proposed and answered, and answered closed',
+      path: ["answers"],
+    },
+  );
+
+/** The states of an answer kind's records (ws-058): open for people, proposed by a model, answered by a table, people, or a confirmed proposal. */
+export const ANSWER_STATES = ["escalated", "proposed", "answered"] as const;
 
 export type RecordKind = z.infer<typeof recordKindSchema>;
 
@@ -933,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;
   /**
@@ -953,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 {
@@ -1072,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);
@@ -1107,6 +1216,7 @@ export async function readRecords(loaded: LoadedRecordKind, options: ReadRecords
       valid: true,
       reasons: [],
       supersededBy: null,
+      remediatedBy: [],
       data: null,
       assets: [],
       warnings: [],
@@ -1226,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).
@@ -1250,6 +1384,8 @@ export async function readRecords(loaded: LoadedRecordKind, options: ReadRecords
   joinSessions(kind, entries, texts, options.subjects ?? null);
   // A work kind's links, ready and blocked (#2683), from every record before --current.
   const work = kind.work ? await (await import("./work")).applyWork(loaded, entries, options) : undefined;
+  // An answer kind's points (ws-058): an answer whose point is gone or changed is warned about.
+  if (kind.answers) (await import("./points")).applyAnswers(loaded, entries, options);
 
   for (const e of entries) e.valid = e.reasons.length === 0;
   const records = options.current ? entries.filter((e) => e.supersededBy === null) : entries;