@intentius/chant 0.93.0 → 0.94.0

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

@@ -3,11 +3,11 @@
  * kinds without a lifecycle, a supersedes field of bare ids, schema files a
  * schema `$ref`s, and content-addressed ids.
  *
- * The fixtures are shaped like chud's records (jhgaylor/chud#78: units,
- * evidence named by the hash of its bytes, sessions, driver closures and
- * Markdown contracts, with draft-07 schemas that `$ref` a shared
- * `defs.schema.json`), trimmed to the fields that matter here. Each one reads
- * through a kind file alone: no reader code.
+ * The fixtures are shaped like a development-model plugin's records (ported
+ * from chud, jhgaylor/chud#78: units, evidence named by the hash of its
+ * bytes, sessions, driver closures and Markdown contracts, with draft-07
+ * schemas that `$ref` a shared `defs.schema.json`), trimmed to the fields
+ * that matter here. Each one reads through a kind file alone: no reader code.
  */
 
 import { execFileSync } from "node:child_process";
@@ -29,7 +29,7 @@ const validateOutput = new Ajv2020({ strict: true, allErrors: true }).compile(sc
 let root: string;
 beforeEach(() => {
   root = realpathSync(mkdtempSync(join(tmpdir(), "chant-record-formats-")));
-  writeChudModel();
+  writeAcmeModel();
 });
 afterEach(() => rmSync(root, { recursive: true, force: true }));
 
@@ -72,9 +72,9 @@ async function failure(kind: string): Promise<{ code: string; message: string }>
 const codes = (r: { reasons: Array<{ code: string }> }) => r.reasons.map((x) => x.code);
 const warned = (r: { warnings: Array<{ code: string }> }) => r.warnings.map((x) => x.code);
 
-// ── chud's model, as kind files ──────────────────────────────────────────────
+// ── acme's model, as kind files ──────────────────────────────────────────────
 
-const BASE = "https://schemas.example.test/chud-runtime/v0";
+const BASE = "https://schemas.example.test/acme-runtime/v0";
 const ref = (name: string) => ({ $ref: `defs.schema.json#/definitions/${name}` });
 
 const DEFS = {
@@ -106,7 +106,7 @@ const UNIT_SCHEMA = {
     scope: { type: "array", minItems: 1, items: ref("text") },
     base_commit: ref("gitId"),
     result: { type: "object", required: ["commit", "ref"], properties: { commit: { type: ["string", "null"] }, ref: { type: ["string", "null"] } } },
-    // A bare hash, as chud writes today, or a pin chant checks.
+    // A bare hash, as acme writes today, or a pin chant checks.
     evidence: {
       type: "array",
       items: { anyOf: [ref("sha256"), { type: "object", required: ["path", "sha256"], properties: { path: ref("text"), sha256: ref("sha256") } }] },
@@ -178,7 +178,7 @@ const CONTRACT_SCHEMA = {
   },
 };
 
-/** A kind file: data only, the way chud's model package would ship it. */
+/** A kind file: data only, the way acme's model package would ship it. */
 function kindFile(kind: Record<string, unknown>): string {
   return `export const recordKind = ${JSON.stringify(kind, null, 2)};\n`;
 }
@@ -235,7 +235,7 @@ const KINDS: Record<string, Record<string, unknown>> = {
   },
 };
 
-function writeChudModel(): void {
+function writeAcmeModel(): void {
   write("design/schemas/defs.schema.json", json(DEFS));
   write("design/schemas/unit.schema.json", json(UNIT_SCHEMA));
   write("design/schemas/evidence.schema.json", json(EVIDENCE_SCHEMA));
@@ -304,7 +304,7 @@ test("the output schema lists exactly the formats a kind file may name", () => {
 });
 
 describe("format json", () => {
-  test("chud's units, sessions and driver closures read through kind files alone", async () => {
+  test("acme's units, sessions and driver closures read through kind files alone", async () => {
     write("design/units/U-0001.json", json(unit("U-0001", { outcome: "done", closed_at: "2026-09-24T11:00:00.000Z" })));
     write("design/units/U-0002.json", json(unit("U-0002")));
     write("design/sessions/S-0001.json", json(SESSION));
@@ -407,7 +407,7 @@ describe("the write commands through a declared kind (#2680)", () => {
   test.each(["unit", "evidence"])("refuse the declared %s kind with write-usage-invalid", async (kind) => {
     write(
       "chant.workspace.json",
-      json({ name: "chud", schema: 1, members: [{ name: "design", dir: "design", kind: "other", because: "chud's records" }], records: [{ kind: `design/${kind}.kind.mjs` }] }),
+      json({ name: "acme", schema: 1, members: [{ name: "design", dir: "design", kind: "other", because: "acme's records" }], records: [{ kind: `design/${kind}.kind.mjs` }] }),
     );
     write("design/units/U-0001.json", json(unit("U-0001")));
     write("fields.json", "{}\n");
@@ -510,7 +510,7 @@ describe("kinds without a lifecycle", () => {
   const contract = (id: string, status: string, supersedes?: string | string[]) =>
     `---\nid: "${id}"\nstatus: "${status}"\n${supersedes === undefined ? "" : `supersedes: ${JSON.stringify(supersedes)}\n`}---\n\n# ${id}\n`;
 
-  test("supersedes as one id, as chud's contracts write it, derives supersededBy under approval ranks", async () => {
+  test("supersedes as one id, as acme's contracts write it, derives supersededBy under approval ranks", async () => {
     write("design/contracts/C-001-first.md", contract("C-001", "approved"));
     write("design/contracts/C-002-second.md", contract("C-002", "approved", "C-001"));
     write("design/contracts/C-003-draft.md", contract("C-003", "draft", "C-002"));
@@ -588,7 +588,7 @@ describe("schema.refs", () => {
 // ── 4. Content-addressed ids ─────────────────────────────────────────────────
 
 describe("idFrom sha256", () => {
-  test("chud's evidence reads with the hash of its bytes as its id, in the tree and under --at", async () => {
+  test("acme's evidence reads with the hash of its bytes as its id, in the tree and under --at", async () => {
     const h = writeEvidence();
     const bytes = readFileSync(join(root, "design", "evidence", `${h}.json`));
     expect(createHash("sha256").update(bytes).digest("hex")).toBe(h);

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

@@ -3,7 +3,8 @@
  * and the comparison. The fixture is a repository with commits for a review
  * session's open and close: between them the session closes with two
  * verdicts, ref-001 gains the two reviews that name it and is ratified,
- * a new decision supersedes ref-002, and ref-002's pin moves. Every document
+ * a new decision (ref-004, after the reference workspace's own ref-003)
+ * supersedes ref-002, and ref-002's pin moves. Every document
  * validates against records-since.schema.json.
  */
 
@@ -56,8 +57,8 @@ function sessionHistory(): { root: string; before: string; open: string; close:
   const text = readFileSync(ref002, "utf-8");
   writeFileSync(ref002, text.replace(/sha256: "[0-9a-f]{64}"/, `sha256: "${"a".repeat(64)}"`));
   writeFileSync(
-    join(root, "decisions", "ref-003-a-successor.md"),
-    text.replace(/^id: .*$/m, 'id: "ref-003"').replace(/^supersedes: \[\]$/m, 'supersedes:\n  - decision: "ref-002"'),
+    join(root, "decisions", "ref-004-a-successor.md"),
+    text.replace(/^id: .*$/m, 'id: "ref-004"').replace(/^supersedes: \[\]$/m, 'supersedes:\n  - decision: "ref-002"'),
   );
   const close = commitAll(root, "close S-0002");
   return { root, before, open, close };
@@ -85,11 +86,11 @@ describe("records --since (#2673)", () => {
     expect(doc.at).toBe(h.close);
     expect(doc.kind).toEqual({ name: "decision", schema: "urn:intentius:chant:decision:1", file: "decisions/decision.kind.mjs" });
     expect(doc.changes).toEqual([
-      { change: "new", id: "ref-003", path: "decisions/ref-003-a-successor.md", state: "decided" },
+      { change: "new", id: "ref-004", path: "decisions/ref-004-a-successor.md", state: "decided" },
       { change: "state", id: "ref-001", from: "decided", to: "ratified" },
       { change: "verdict", id: "ref-001", principal: "alice", verdict: "agree", index: 0, session: "S-0002" },
       { change: "verdict", id: "ref-001", principal: "bob", verdict: "agree", index: 1, session: "S-0002" },
-      { change: "supersession", id: "ref-003", supersedes: "ref-002" },
+      { change: "supersession", id: "ref-004", supersedes: "ref-002" },
       { change: "pin", id: "ref-002", path: "design/screens/home.json", from: expect.stringMatching(/^[0-9a-f]{64}$/), to: "a".repeat(64) },
     ]);
     expect(doc.summary).toEqual({ new: 1, removed: 0, state: 1, verdict: 2, supersession: 1, pin: 1 });
@@ -105,11 +106,11 @@ describe("records --since (#2673)", () => {
   });
 
   test("without --at it compares with the working tree, and a record deleted there is removed", async () => {
-    rmSync(join(h.root, "decisions", "ref-003-a-successor.md"));
+    rmSync(join(h.root, "decisions", "ref-004-a-successor.md"));
     try {
       const doc = ok(await since({ kind: DECISIONS_KIND, since: h.close, cwd: h.root }));
       expect(doc.at).toBeNull();
-      expect(doc.changes).toEqual([{ change: "removed", id: "ref-003", path: "decisions/ref-003-a-successor.md", state: "decided" }]);
+      expect(doc.changes).toEqual([{ change: "removed", id: "ref-004", path: "decisions/ref-004-a-successor.md", state: "decided" }]);
     } finally {
       git(h.root, "checkout", "--", "decisions");
     }

package/src/workspace/records.test.ts

@@ -311,7 +311,7 @@ describe("a decision that originates in the workspace (#2654)", () => {
 
   test("takes a session and an issue, and nothing else", async () => {
     const base = workspaceDecision("ws-001");
-    write("ws-001-a.md", base.replace('  member: "app"\n', '  member: "app"\n  session: "S-0001"\n  issue: "jhgaylor/chud#77"\n'));
+    write("ws-001-a.md", base.replace('  member: "app"\n', '  member: "app"\n  session: "S-0001"\n  issue: "acme/example#77"\n'));
     write("ws-002-b.md", base.replace('id: "ws-001"', 'id: "ws-002"').replace('  member: "app"\n', '  member: "app"\n  session: null\n'));
     write("ws-003-c.md", base.replace('id: "ws-001"', 'id: "ws-003"').replace('  member: "app"\n', '  member: "app"\n  row: "Sort order"\n'));
     write("ws-004-d.md", base.replace('id: "ws-001"', 'id: "ws-004"').replace('  member: "app"\n', ""));

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

@@ -311,6 +311,7 @@ describe("chant workspace status on built workspaces", () => {
           { name: "inference", broker: null, scope: [] },
         ],
         isolation: null,
+        intent: null,
       },
     ]);
   });

package/src/workspace/status-stewards.ts

@@ -16,7 +16,11 @@
  *   is the Op's own `labels.Env` or `local`;
  * - `waiting` lists the open decision points the steward waits on (#2749):
  *   each Op whose newest run is the steward's own and stopped on a question,
- *   as the run ledger records it. The question's state now is `points`'s;
+ *   as the run ledger records it. The question's state now is `points`'s.
+ *   A run is the steward's when its record names it (`steward`, written for
+ *   a run started in the steward's turn or under `CHANT_STEWARD`), so this
+ *   also covers the member's other Ops, those no steward lists, that such a
+ *   run belongs to, such as an Op the steward's process starts itself;
  * - `lease` is the local steward's own lease ref
  *   (`refs/chant/lease/[<prefix>]_stewards/<name>`), present while a
  *   `chant operator --steward` holds it or until it expires;
@@ -27,7 +31,7 @@
 
 import { existsSync, realpathSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
-import { discoverStewards } from "../op/discover";
+import { discoverOps, discoverStewards } from "../op/discover";
 import { stewardFormFor, stewardLeaseName, type StewardForm } from "../op/steward";
 import { readRunLedger, runEnvOf } from "../lifecycle/run-ledger";
 import { readConvergeLedger, type ConvergeTickRecord } from "../lifecycle/converge-ledger";
@@ -152,7 +156,9 @@ export interface StatusSteward {
   ops: StatusStewardOp[];
   /**
    * The open decision points the steward waits on (#2749): each Op whose
-   * newest run is the steward's own and stopped on a question.
+   * newest run is the steward's own and stopped on a question. Its declared
+   * Ops come first, in `ops` order, then any other Op of the member whose
+   * newest run names the steward, by Op name.
    */
   waiting: (StatusStewardWait & { op: string; run: string })[];
 }
@@ -325,5 +331,45 @@ export async function readMemberStewards(
       waiting,
     });
   }
+  if (stewards.length > 0) await addUndeclaredWaits(memberDir, stewards, found, reasons);
   return { stewards, reasons };
 }
+
+/**
+ * The waiting runs of the member's Ops that no steward lists, each under the
+ * steward its record names. A steward's process can start an Op itself
+ * with `CHANT_STEWARD` set (studio#137), and the run ledger then records
+ * the run as the steward's though the declaration does not list the Op.
+ * Import failures are left out here: `discoverStewards` read the same files
+ * and reported them as `stewards-unreadable`.
+ */
+async function addUndeclaredWaits(
+  memberDir: string,
+  stewards: StatusSteward[],
+  found: Awaited<ReturnType<typeof discoverStewards>>["stewards"],
+  reasons: MemberStewards["reasons"],
+): Promise<void> {
+  const declared = new Set([...found.values()].flatMap(({ declaration }) => declaration.ops.map((op) => op.name)));
+  let ops: OpConfig[];
+  try {
+    ops = [...(await discoverOps({ cwd: memberDir })).ops.values()].map((d) => d.config).filter((op) => !declared.has(op.name));
+  } catch {
+    return;
+  }
+  const byName = new Map(stewards.map((s) => [s.name, s]));
+  for (const op of ops.sort((a, b) => a.name.localeCompare(b.name))) {
+    const opEnv = runEnvOf(op);
+    try {
+      const newest = (await readRunLedger(opEnv, op.name, { cwd: memberDir })).records.at(-1);
+      const steward = newest?.steward ? byName.get(newest.steward) : undefined;
+      if (steward && newest?.status === "waiting" && newest.point) {
+        steward.waiting.push({ op: op.name, run: newest.id, ...waitOf(newest.point) });
+      }
+    } catch (err) {
+      reasons.push({
+        code: "steward-runs-unreadable",
+        message: `${opEnv}/runs__${op.name}.jsonl: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`,
+      });
+    }
+  }
+}

package/src/workspace/status.schema.json

@@ -335,7 +335,7 @@
           }
         },
         "waiting": {
-          "description": "The open decision points the steward waits on (#2749): one for each of its Ops whose newest run is the steward's own and stopped on a question, in ops order. The state is the question's when the run stopped; `chant workspace points --open` has its state now, and hud asks a person there. The steward never answers one, and runs the Op again on the first round after it is answered.",
+          "description": "The open decision points the steward waits on (#2749): one for each Op whose newest run is the steward's own (its ledger record names the steward) and stopped on a question: the steward's own Ops in ops order, then any other Op of the member, such as one the steward's process starts itself (studio#137), by name. The state is the question's when the run stopped; `chant workspace points --open` has its state now, and hud asks a person there. The steward never answers one, and runs an Op it lists again on the first round after it is answered.",
           "type": "array",
           "items": {
             "allOf": [
@@ -362,10 +362,27 @@
         "since": { "type": "string", "description": "When the run stopped on it." }
       }
     },
+    "intent": {
+      "type": "object",
+      "required": ["id", "state", "question", "choice", "answer", "decided_by", "decided_on"],
+      "properties": {
+        "id": { "type": "string", "description": "The record's id, as the box block names it." },
+        "state": { "type": ["string", "null"], "description": "The record's state as written, such as proposed or decided, or null when no decision record has the id." },
+        "question": { "type": ["string", "null"], "description": "The question the record answers." },
+        "choice": { "description": "The record's choice as written, such as { option, reason }, or null while the record is proposed." },
+        "answer": { "type": ["string", "null"], "description": "The chosen option's label, from options[]'s entry whose id is choice.option, or null while no option is chosen (#2855). Added by chant 0.94.0." },
+        "decided_by": { "type": ["string", "null"], "description": "Who decided it, or null while it is proposed." },
+        "decided_on": { "type": ["string", "null"], "description": "The day it was decided, or null while it is proposed." }
+      }
+    },
     "box": {
       "type": "object",
-      "required": ["capabilities", "isolation"],
+      "required": ["capabilities", "isolation", "intent"],
       "properties": {
+        "intent": {
+          "description": "The decision record the box block names as the box's intent (#2850), or null when it names none. A box starts as a question: the record is proposed with a null choice, and decided when the person who answered it amends it. Read from the working tree, from the declared record kinds named decision. When no decision record has the id, every field but id is null and chant workspace check fails (WSP126). Added by chant 0.94.0.",
+          "oneOf": [{ "type": "null" }, { "$ref": "#/$defs/intent" }]
+        },
         "isolation": {
           "description": "The box's isolation resolved from its identity, its host, the member's name and its slot (#2727), or null when the block declares no host. A runtime that plants or starts the box sets these values instead of choosing its own. The same for every environment.",
           "oneOf": [{ "type": "null" }, { "$ref": "#/$defs/isolation" }]

package/src/workspace/status.ts

@@ -43,6 +43,7 @@ import { readReleasePlan, type ReleasePlan } from "../lifecycle/plan-ledger";
 import { listWorkLeases, type WorkLeaseState } from "../lifecycle/work-lease";
 import { findWorkspaceRoot } from "../project-root";
 import { resolveBoxes, type ResolvedIsolation } from "./box-isolation";
+import { resolveBoxIntents, unresolvedIntent, type BoxIntent } from "./box-intent";
 import { declaredRecordKinds, readDeclaration, readerVersion, WorkspaceReadError, type Declaration, type ErrorLocation, type Member } from "./declaration";
 import type { ReasonCode } from "./reason-codes";
 import { GATE_REASON_CODES, readMemberGates, type GateLedgerReader, type StatusGate, type StatusGateLedger } from "./status-gates";
@@ -178,6 +179,13 @@ export interface StatusBox {
   capabilities: { name: string; broker: string | null; scope: string[] }[];
   /** The box's ports, state paths and cookie names, resolved from its identity, or null when the block declares no host (#2727). */
   isolation: ResolvedIsolation | null;
+  /**
+   * The decision record the block names as the box's intent (#2850): its id,
+   * state, question, choice, answer (the chosen option's label), decided_by
+   * and decided_on. Null when the block names none; every field but the id
+   * is null when no decision record has the id (WSP126).
+   */
+  intent: BoxIntent | null;
 }
 
 /**
@@ -377,6 +385,7 @@ export async function workspaceStatus(query: StatusQuery): Promise<StatusDocumen
     const now = query.now ?? new Date().toISOString();
 
     const isolation = new Map(resolveBoxes(declaration).map((b) => [b.member.name, b.isolation]));
+    const intents = new Map((await resolveBoxIntents(declaration, found.dir)).map((i) => [i.member, i.record?.intent ?? unresolvedIntent(i.id)]));
     const members: StatusMember[] = [];
     for (const m of declaration.members) {
       const environments: StatusEnvironment[] = [];
@@ -399,6 +408,7 @@ export async function workspaceStatus(query: StatusQuery): Promise<StatusDocumen
             : {
                 capabilities: m.box.capabilities.map((c) => ({ name: c.name, broker: c.broker, scope: [...c.scope] })),
                 isolation: isolation.get(m.name) ?? null,
+                intent: intents.get(m.name) ?? null,
               },
         stewards: stewards.stewards,
         stewardReasons: stewards.reasons,

package/src/workspace/{work-readiness-chud.test.ts → work-readiness.test.ts}

@@ -1,11 +1,10 @@
 /**
- * The work kind's `ready`/`blockedBy` against chud's ready queue (ws-055,
- * #2734).
- *
- * chud's `readyQueue` (packages/runtime/src/ready.mjs at jhgaylor/chud
- * 43afcf1) puts a contract in the ready set once it is approved and in
- * force, every `depends_on` id is `met` (drivers.mjs's `memberState`), and no
- * unit is open against it; a contract that is itself met leaves the queue.
+ * The work kind's `ready`/`blockedBy` against a reference ready-queue rule
+ * (ws-055, #2734), ported from chud's `readyQueue`
+ * (packages/runtime/src/ready.mjs at jhgaylor/chud 43afcf1): a contract
+ * enters the ready set once it is approved and in force, every `depends_on`
+ * id is `met` (drivers.mjs's `memberState`), and no unit is open against it;
+ * a contract that is itself met leaves the queue.
  *
  * Of those rules, the work kind's `ready` and `blockedBy` (work.ts) can
  * express two directly, with no new field:
@@ -17,22 +16,21 @@
  *   retired contract does.
  * - a record that is itself already `done` (or `dropped`, or merely
  *   `in-progress`) is not `ready`: `ready` requires `state === "open"`, the
- *   same "already met/already running leaves the queue" rule ready.mjs
- *   states for a contract that is itself met.
+ *   same "already met/already running leaves the queue" rule the reference
+ *   rule states for a contract that is itself met.
  *
- * The rules ready.mjs adds on top -- approval before a dependency counts
- * (memberState's draft/failing cases), re-checking that a `met` dependency's
- * newest evidence still passes, and refusing a contract while a unit is open
- * against it -- have no equivalent in a `needs` link. The full table of
- * every ready.mjs rule and its home (a `needs` link, the runner, or "not
+ * The rules the reference rule adds on top -- approval before a dependency
+ * counts (memberState's draft/failing cases), re-checking that a `met`
+ * dependency's newest evidence still passes, and refusing a contract while a
+ * unit is open against it -- have no equivalent in a `needs` link. The full
+ * table of every rule and its home (a `needs` link, the runner, or "not
  * applicable") is on INTENTIUS/chant#2734.
  *
- * This fixture mirrors a small chud contract graph as work items and checks
- * `queryRecords`'s `ready`/`blockedBy` against a minimal, local
- * re-implementation of the expressible subset of ready.mjs's rule (met
- * depends_on, self not already met), so a regression in either the work
- * kind's readiness formula or this reading of ready.mjs's rule shows up as a
- * mismatch.
+ * This fixture mirrors a small reference contract graph as work items and
+ * checks `queryRecords`'s `ready`/`blockedBy` against a minimal, local
+ * re-implementation of the expressible subset of that rule (met depends_on,
+ * self not already met), so a regression in either the work kind's readiness
+ * formula or this reading of the reference rule shows up as a mismatch.
  */
 
 import { readFileSync } from "node:fs";
@@ -63,13 +61,13 @@ function work(id: string, fields: Record<string, unknown>): string {
 }
 
 /**
- * The expressible subset of ready.mjs's rule, on a graph shaped like
+ * The expressible subset of the reference rule, on a graph shaped like
  * `depends_on`: ready once the item is `open` (not already met, not already
- * running) and every dependency is `done` (chud's "met"). A dependency that
- * is `dropped` never becomes done, so it blocks forever -- the same effect
- * ready.mjs gets from a retired dependency.
+ * running) and every dependency is `done` (the reference rule's "met"). A
+ * dependency that is `dropped` never becomes done, so it blocks forever --
+ * the same effect the reference rule gets from a retired dependency.
  */
-function chudReadyIsh(items: { id: string; state: string; needs: string[] }[]): { ready: Set<string>; blockedBy: Map<string, string[]> } {
+function referenceReadyIsh(items: { id: string; state: string; needs: string[] }[]): { ready: Set<string>; blockedBy: Map<string, string[]> } {
   const stateOf = new Map(items.map((i) => [i.id, i.state]));
   const ready = new Set<string>();
   const blockedBy = new Map<string, string[]>();
@@ -90,13 +88,13 @@ beforeAll(() => {
     "decisions/decision.schema.json": readFileSync(join(REF, "decisions", "decision.schema.json"), "utf-8"),
     "work/work.kind.mjs": readFileSync(join(REF, "work", "work.kind.mjs"), "utf-8"),
     "work/work.schema.json": readFileSync(join(REF, "work", "work.schema.json"), "utf-8"),
-    // W-001: already done, so it leaves the ready queue -- ready.mjs's "a
-    // contract that is itself met is done, not ready".
+    // W-001: already done, so it leaves the ready queue -- the reference
+    // rule's "a contract that is itself met is done, not ready".
     "work/W-001-base.md": work("W-001", { state: "done", closed_on: "2026-09-24", evidence: [{ title: "shipped", url: "https://example.com/w1" }] }),
     // W-002: needs W-001, which is done -- both rules agree this is ready.
     "work/W-002-after-base.md": work("W-002", { needs: ["W-001"] }),
     // W-003: needs W-004, which is dropped and so never turns done -- blocked
-    // forever, the same as a retired dependency in ready.mjs.
+    // forever, the same as a retired dependency in the reference rule.
     "work/W-003-needs-dropped.md": work("W-003", { needs: ["W-004"] }),
     "work/W-004-dropped.md": work("W-004", { state: "dropped", closed_on: "2026-09-24" }),
     // W-005: needs W-002, which is open (not done yet) -- blocked.
@@ -111,22 +109,22 @@ beforeAll(() => {
 });
 afterAll(cleanScratch);
 
-describe("work kind ready/blockedBy vs. chud's ready queue, expressible rules (#2734)", () => {
+describe("work kind ready/blockedBy vs. a reference ready-queue rule, expressible rules (#2734)", () => {
   test("matches on every item, for the rules a needs link can express", async () => {
     const doc = await queryRecords({ kind: WORK, cwd: root });
     if ("error" in doc) throw new Error(doc.error.message);
     expect(doc.summary).toEqual({ total: 7, valid: 7, invalid: 0, superseded: 0 });
 
     const items = doc.records.map((r) => ({ id: r.id!, state: r.state!, needs: (r.data as { needs?: string[] }).needs ?? [] }));
-    const chud = chudReadyIsh(items);
+    const reference = referenceReadyIsh(items);
 
     for (const r of doc.records) {
       const id = r.id!;
-      expect(r.ready, `${id}.ready`).toBe(chud.ready.has(id));
+      expect(r.ready, `${id}.ready`).toBe(reference.ready.has(id));
       expect(
         (r.blockedBy ?? []).map((b) => b.id),
         `${id}.blockedBy`,
-      ).toEqual(chud.blockedBy.get(id));
+      ).toEqual(reference.blockedBy.get(id));
     }
   });
 

package/src/workspace/work.test.ts

@@ -370,6 +370,13 @@ describe("writing work items on a copy of the reference workspace (#2683)", () =
     expect("error" in doc && doc.error.code).toBe("record-schema-invalid");
   });
 
+  test("records new refuses an ask source with no said or by (#2851)", async () => {
+    const noSaid = await newRecord({ kind: "work/work.kind.mjs", fields: fresh({ source: { ask: { by: "morgan", at: "2026-09-25T10:00:00Z", via: "hud" } } }), dryRun: true, cwd: copy });
+    expect("error" in noSaid && noSaid.error.code).toBe("record-schema-invalid");
+    const noBy = await newRecord({ kind: "work/work.kind.mjs", fields: fresh({ source: { ask: { said: "Can we add a dark mode toggle?", at: "2026-09-25T10:00:00Z", via: "hud" } } }), dryRun: true, cwd: copy });
+    expect("error" in noBy && noBy.error.code).toBe("record-schema-invalid");
+  });
+
   test("records new with a fresh prefix takes --prefix W", async () => {
     const doc = await newRecord({ kind: "work/work.kind.mjs", fields: fresh(), prefix: "W", dryRun: true, cwd: copy });
     expect(doc).toMatchObject({ id: "W-004" });
@@ -388,4 +395,14 @@ describe("writing work items on a copy of the reference workspace (#2683)", () =
     const doc = await reviewRecord({ kind: "work/work.kind.mjs", id: "W-003", verdict: "agree", by: "alice", cwd: copy });
     expect("error" in doc && doc.error.code).toBe("review-unsupported");
   });
+
+  test("records new with an ask source round-trips through records --json (#2851)", async () => {
+    const ask = { said: "Can we add a dark mode toggle to the wireframe?", by: "morgan", at: "2026-09-25T10:00:00Z", via: "hud", session: "hud-9f2" };
+    const doc = await newRecord({ kind: resolveWriteKind("work", copy), fields: fresh({ source: { ask } }), cwd: copy });
+    if ("error" in doc) throw new Error(`${doc.error.code}: ${doc.error.message}`);
+    const read = await queryRecords({ kind: "work/work.kind.mjs", cwd: copy });
+    records.expectValid(read);
+    if ("error" in read) throw new Error(read.error.message);
+    expect(read.records.find((r) => r.id === doc.id)).toMatchObject({ valid: true, data: { source: { ask } } });
+  });
 });