@intentius/chant 0.85.0 → 0.87.0

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

@@ -0,0 +1,108 @@
+/**
+ * Review sessions as a record kind (#2673, #2650 C10), read through the
+ * reference workspace's session kind: a closed session's seal is checked on
+ * read, each verdict names a decision that exists, and each session lists the
+ * decision reviews that cite it.
+ */
+
+import { execFileSync } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { afterAll, describe, expect, test } from "vitest";
+import { cleanScratch, commitAll, contract, REPO } from "./__fixtures__/contract-repo";
+import { reviewed, sessionText, SESSIONS_KIND as SESSIONS, sessionsRepo as fixture } from "./__fixtures__/sessions";
+import { sessionSeal } from "./record-sessions";
+import { queryRecords, type RecordsDocument } from "./records-cli";
+import recordsSchema from "./records.schema.json";
+
+afterAll(cleanScratch);
+
+const { expectValid } = contract(recordsSchema);
+
+async function read(root: string, at?: string): Promise<Extract<RecordsDocument, { records: unknown }>> {
+  const doc = await queryRecords({ kind: SESSIONS, cwd: root, ...(at ? { at } : {}) });
+  expectValid(doc);
+  if ("error" in doc) throw new Error(`${doc.error.code}: ${doc.error.message}`);
+  return doc;
+}
+
+describe("the session kind (#2673)", () => {
+  test("the reference workspace's session is closed, sealed and valid, and cited by nothing", async () => {
+    const doc = await read(join(REPO, "reference-workspace"));
+    expect(doc.kind.name).toBe("session");
+    expect(doc.records.map((r) => [r.id, r.state, r.valid])).toEqual([["S-0001", "closed", true]]);
+    expect(doc.records[0].citedBy).toEqual([]);
+  });
+
+  test("the seal is the awk recipe the docs give", () => {
+    const file = join(REPO, "reference-workspace", "design", "sessions", "S-0001-first-walk-of-the-reference-decisions.md");
+    const awk = execFileSync("sh", ["-c", `awk 'NR==1&&/^---$/{f=1;print;next} f&&/^---$/{f=0} f&&/^closed_digest:/{next} {print}' "$1" | shasum -a 256`, "sh", file], { encoding: "utf-8" });
+    const text = readFileSync(file, "utf-8");
+    expect(awk.split(" ")[0]).toBe(sessionSeal(text, "closed_digest"));
+    expect(text).toContain(`closed_digest: "${sessionSeal(text, "closed_digest")}"`);
+    // CRLF line endings hash as LF.
+    expect(sessionSeal(text.replace(/\n/g, "\r\n"), "closed_digest")).toBe(sessionSeal(text, "closed_digest"));
+  });
+
+  test("a closed session edited after it closed is session-seal-mismatch", async () => {
+    const root = fixture();
+    const file = join(root, "design", "sessions", "S-0001-first-walk-of-the-reference-decisions.md");
+    writeFileSync(file, readFileSync(file, "utf-8").replace("First walk", "Second walk"));
+    const s1 = (await read(root)).records[0];
+    expect(s1.valid).toBe(false);
+    expect(s1.reasons.map((r) => r.code)).toEqual(["session-seal-mismatch"]);
+  });
+
+  test("an open session with a seal, or a closed one without, is schema-invalid", async () => {
+    const root = fixture();
+    const dir = join(root, "design", "sessions");
+    writeFileSync(join(dir, "S-0002-open.md"), sessionText({ id: "S-0002", state: "open" }).replace("verdicts: []", 'verdicts: []\nclosed_digest: "' + "0".repeat(64) + '"'));
+    writeFileSync(join(dir, "S-0003-closed.md"), sessionText({ id: "S-0003", state: "closed" }).replace(/^closed_digest: .*\n/m, ""));
+    const doc = await read(root);
+    expect(doc.records.filter((r) => r.id !== "S-0001").map((r) => [r.id, r.reasons.map((x) => x.code)])).toEqual([
+      ["S-0002", ["record-schema-invalid"]],
+      ["S-0003", ["record-schema-invalid"]],
+    ]);
+  });
+
+  test("a verdict naming a record no decision has is session-verdict-unknown-record", async () => {
+    const root = fixture();
+    writeFileSync(
+      join(root, "design", "sessions", "S-0002-walk.md"),
+      sessionText({ id: "S-0002", state: "closed", verdicts: [{ record: "ref-001", principal: "alice", verdict: "agree" }, { record: "ref-999", principal: "alice", verdict: "agree" }] }),
+    );
+    const s2 = (await read(root)).records.find((r) => r.id === "S-0002")!;
+    expect(s2.valid).toBe(false);
+    expect(s2.reasons).toEqual([{ code: "session-verdict-unknown-record", message: expect.stringContaining("verdicts[1] names ref-999") }]);
+  });
+
+  test("each session lists the decision reviews that name it, and --at reads both kinds at the revision", async () => {
+    const root = fixture();
+    writeFileSync(join(root, "design", "sessions", "S-0002-walk.md"), sessionText({ id: "S-0002", state: "open" }));
+    const open = commitAll(root, "open S-0002");
+    reviewed(root, ["alice", "bob"], "S-0002");
+    writeFileSync(
+      join(root, "design", "sessions", "S-0002-walk.md"),
+      sessionText({ id: "S-0002", state: "closed", verdicts: [{ record: "ref-001", principal: "alice", verdict: "agree" }, { record: "ref-001", principal: "bob", verdict: "agree" }] }),
+    );
+    const doc = await read(root);
+    expect(doc.summary.invalid).toBe(0);
+    const s2 = doc.records.find((r) => r.id === "S-0002")!;
+    expect(s2.citedBy).toEqual([
+      { id: "ref-001", path: "decisions/ref-001-how-the-app-is-deployed.md", index: 0, reviewer: "alice", verdict: "agree" },
+      { id: "ref-001", path: "decisions/ref-001-how-the-app-is-deployed.md", index: 1, reviewer: "bob", verdict: "agree" },
+    ]);
+    expect(doc.records.find((r) => r.id === "S-0001")!.citedBy).toEqual([]);
+    const then = await read(root, open);
+    expect(then.records.find((r) => r.id === "S-0002")).toMatchObject({ state: "open", valid: true, citedBy: [] });
+  });
+
+  test("the decision kind accepts a review entry naming its session", async () => {
+    const root = fixture();
+    reviewed(root, ["alice"], "S-0001");
+    const doc = await queryRecords({ kind: "decisions/decision.kind.mjs", cwd: root });
+    if ("error" in doc) throw new Error(doc.error.message);
+    expect(doc.records.find((r) => r.id === "ref-001")).toMatchObject({ valid: true });
+    expect((await read(root)).records[0].citedBy).toEqual([expect.objectContaining({ id: "ref-001", reviewer: "alice" })]);
+  });
+});

package/src/workspace/records-since.schema.json

@@ -0,0 +1,193 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://intentius.io/chant/schemas/workspace/records-since/v1/records-since.schema.json",
+  "title": "chant workspace records --since output",
+  "description": "What `chant workspace records --kind <kind file> --since <rev> --json` prints (#2673, #2650 C11): what changed in a kind's records between the commit --since names and the tree --at names, or the working tree without it. Records are matched by id; a record whose id could not be read is not compared. Between a review session's open and close commits, the changes are what the session did. Readers ignore fields they do not know; a field is only ever added within a version. The change kinds and the error codes are closed lists. Contract version 1 is written by chant 0.81.0 and newer, and this document was added to it by #2673; a chant without --since on records refuses the flag. Every code is in the one closed list of `reason-codes.ts`.",
+  "oneOf": [{ "$ref": "#/$defs/result" }, { "$ref": "#/$defs/failure" }, { "$ref": "#/$defs/set" }],
+  "$defs": {
+    "set": {
+      "description": "Added in contract 1 by #2680. What records --since prints without --kind when the workspace declaration names record kinds: one result or failure per declared kind, in the declaration's order (the workspace's own kinds, then each member's in member order). Exit code 1 when any kind's read failed; the others are still compared and listed.",
+      "type": "object",
+      "required": ["$schema", "contract", "kinds"],
+      "properties": {
+        "$schema": { "const": "https://intentius.io/chant/schemas/workspace/records-since/v1/records-since.schema.json" },
+        "contract": { "const": 1 },
+        "kinds": {
+          "type": "array",
+          "items": {
+            "allOf": [
+              { "oneOf": [{ "$ref": "#/$defs/result" }, { "$ref": "#/$defs/failure" }] },
+              {
+                "type": "object",
+                "required": ["declared"],
+                "properties": {
+                  "declared": {
+                    "description": "The declaration's entry for the kind, as in the records set.",
+                    "type": "object",
+                    "required": ["member", "path", "name"],
+                    "properties": {
+                      "member": { "type": ["string", "null"] },
+                      "path": { "type": "string" },
+                      "name": { "type": ["string", "null"] }
+                    }
+                  }
+                }
+              }
+            ]
+          }
+        },
+        "kind": false,
+        "changes": false,
+        "error": false
+      }
+    },
+    "result": {
+      "description": "Both revisions were read. Exit code 0, whatever changed.",
+      "type": "object",
+      "required": ["$schema", "contract", "kind", "since", "at", "changes", "summary"],
+      "properties": {
+        "$schema": { "const": "https://intentius.io/chant/schemas/workspace/records-since/v1/records-since.schema.json" },
+        "contract": { "const": 1 },
+        "kind": {
+          "type": "object",
+          "required": ["name", "schema", "file"],
+          "properties": {
+            "name": { "type": "string", "description": "The kind's name, such as \"decision\" or \"session\"." },
+            "schema": { "type": "string", "description": "The `$id` of the kind's record schema." },
+            "file": { "type": "string", "description": "The kind file, relative to the repository root, with / separators. It is read from the working tree for both revisions." }
+          }
+        },
+        "since": { "type": "string", "pattern": "^[0-9a-f]{40,64}$", "description": "The full commit id --since names." },
+        "at": { "type": ["string", "null"], "pattern": "^[0-9a-f]{40,64}$", "description": "The full commit id --at names, or null for the working tree." },
+        "error": false,
+        "changes": {
+          "description": "In the order new, removed, state, verdict, supersession, pin, and by id within each.",
+          "type": "array",
+          "items": { "$ref": "#/$defs/change" }
+        },
+        "summary": {
+          "description": "How many changes of each kind.",
+          "type": "object",
+          "required": ["new", "removed", "state", "verdict", "supersession", "pin"],
+          "properties": {
+            "new": { "type": "integer", "minimum": 0 },
+            "removed": { "type": "integer", "minimum": 0 },
+            "state": { "type": "integer", "minimum": 0 },
+            "verdict": { "type": "integer", "minimum": 0 },
+            "supersession": { "type": "integer", "minimum": 0 },
+            "pin": { "type": "integer", "minimum": 0 }
+          }
+        }
+      }
+    },
+    "change": {
+      "oneOf": [
+        { "$ref": "#/$defs/new" },
+        { "$ref": "#/$defs/removed" },
+        { "$ref": "#/$defs/state" },
+        { "$ref": "#/$defs/verdict" },
+        { "$ref": "#/$defs/supersession" },
+        { "$ref": "#/$defs/pin" }
+      ]
+    },
+    "new": {
+      "description": "A record with an id no record had at --since. A directory that did not exist at --since held no records, so every record in it is new.",
+      "type": "object",
+      "required": ["change", "id", "path", "state"],
+      "properties": {
+        "change": { "const": "new" },
+        "id": { "type": "string" },
+        "path": { "type": "string", "description": "From the repository root, with / separators." },
+        "state": { "type": ["string", "null"] }
+      }
+    },
+    "removed": {
+      "description": "A record whose id no record has any more.",
+      "type": "object",
+      "required": ["change", "id", "path", "state"],
+      "properties": {
+        "change": { "const": "removed" },
+        "id": { "type": "string" },
+        "path": { "type": "string", "description": "Where it was at --since." },
+        "state": { "type": ["string", "null"], "description": "Its state at --since." }
+      }
+    },
+    "state": {
+      "description": "A state transition, such as decided to ratified, or a session open to closed.",
+      "type": "object",
+      "required": ["change", "id", "from", "to"],
+      "properties": {
+        "change": { "const": "state" },
+        "id": { "type": "string" },
+        "from": { "type": ["string", "null"] },
+        "to": { "type": ["string", "null"] }
+      }
+    },
+    "verdict": {
+      "description": "A verdict the record did not have at --since, including every verdict on a new record. On a session it is an entry of the session's verdict list, with the record it judged in record; on any other record, an entry of its reviews list, with the session it was given in when it names one. Two entries are the same verdict when they name the same principal, verdict, date, session and record, so a dissent that later gains addressed_by is not a new one.",
+      "type": "object",
+      "required": ["change", "id", "principal", "verdict", "index"],
+      "properties": {
+        "change": { "const": "verdict" },
+        "id": { "type": "string", "description": "The record holding the verdict." },
+        "principal": { "type": ["string", "null"], "description": "Who gave it, as written: a review's reviewer, or a session verdict's principal." },
+        "verdict": { "type": ["string", "null"], "description": "agree, dissent or abstain, as written." },
+        "index": { "type": "integer", "minimum": 0, "description": "Its position in the list, from 0." },
+        "record": { "type": "string", "description": "On a session's verdict, the record it judged." },
+        "session": { "type": "string", "description": "On a review entry, the session it names." }
+      }
+    },
+    "supersession": {
+      "description": "A supersession that took effect since --since, derived by the same rule as records' supersededBy, so a pending link that is now approved counts.",
+      "type": "object",
+      "required": ["change", "id", "supersedes"],
+      "properties": {
+        "change": { "const": "supersession" },
+        "id": { "type": "string", "description": "The superseding record." },
+        "supersedes": { "type": "string", "description": "The record it now supersedes." }
+      }
+    },
+    "pin": {
+      "description": "A pinned file whose pinned sha256 changed on a record that exists at both revisions: from is null for a pin added, and to is null for a pin removed.",
+      "type": "object",
+      "required": ["change", "id", "path", "from", "to"],
+      "properties": {
+        "change": { "const": "pin" },
+        "id": { "type": "string" },
+        "path": { "type": "string", "description": "From the workspace root, as the pin writes it." },
+        "from": { "type": ["string", "null"], "pattern": "^[0-9a-f]{64}$" },
+        "to": { "type": ["string", "null"], "pattern": "^[0-9a-f]{64}$" }
+      }
+    },
+    "failure": {
+      "description": "A revision or the kind could not be read. Exit code 1.",
+      "type": "object",
+      "required": ["$schema", "contract", "error"],
+      "properties": {
+        "$schema": { "const": "https://intentius.io/chant/schemas/workspace/records-since/v1/records-since.schema.json" },
+        "contract": { "const": 1 },
+        "error": {
+          "type": "object",
+          "required": ["code", "message"],
+          "properties": {
+            "code": {
+              "enum": [
+                "kind-unreadable",
+                "kind-invalid",
+                "schema-unreadable",
+                "schema-id-mismatch",
+                "schema-invalid",
+                "location-missing",
+                "not-a-git-repository",
+                "revision-unknown",
+                "since-rev-unknown"
+              ]
+            },
+            "message": { "type": "string" }
+          }
+        },
+        "changes": false
+      }
+    }
+  }
+}

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

@@ -0,0 +1,174 @@
+/**
+ * `chant workspace records --since <rev>` (#2673, #2650 C11), the contract
+ * 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
+ * validates against records-since.schema.json.
+ */
+
+import { spawnSync } from "node:child_process";
+import { cpSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { afterAll, describe, expect, test } from "vitest";
+import { cleanScratch, commitAll, contract, git, REPO, scratchDir, validSchema } from "./__fixtures__/contract-repo";
+import { DECISIONS_KIND, reviewed, sessionText, SESSIONS_KIND, sessionsRepo } from "./__fixtures__/sessions";
+import { queryRecordsSince, RECORDS_SINCE_ERROR_CODES, RECORDS_SINCE_OUTPUT_SCHEMA_ID, SINCE_CHANGE_KINDS, type RecordsSinceDocument } from "./records-since";
+import schema from "./records-since.schema.json";
+
+afterAll(cleanScratch);
+
+const { expectValid } = contract(schema);
+
+async function since(q: { kind: string; since: string; at?: string; cwd: string }): Promise<RecordsSinceDocument> {
+  const doc = await queryRecordsSince(q);
+  expectValid(doc);
+  return doc;
+}
+
+function ok(doc: RecordsSinceDocument): Extract<RecordsSinceDocument, { changes: unknown }> {
+  if ("error" in doc) throw new Error(`${doc.error.code}: ${doc.error.message}`);
+  return doc;
+}
+
+/** The session fixture: returns the repository and its commits. */
+function sessionHistory(): { root: string; before: string; open: string; close: string } {
+  const root = sessionsRepo();
+  const before = git(root, "rev-parse", "HEAD");
+  writeFileSync(join(root, "design", "sessions", "S-0002-walk.md"), sessionText({ id: "S-0002", state: "open", agenda: ["ref-001", "ref-002"] }));
+  const open = commitAll(root, "open S-0002");
+
+  reviewed(root, ["alice", "bob"], "S-0002", "ratified");
+  writeFileSync(
+    join(root, "design", "sessions", "S-0002-walk.md"),
+    sessionText({
+      id: "S-0002",
+      state: "closed",
+      agenda: ["ref-001", "ref-002"],
+      verdicts: [
+        { record: "ref-001", principal: "alice", verdict: "agree" },
+        { record: "ref-001", principal: "bob", verdict: "agree" },
+      ],
+    }),
+  );
+  const ref002 = join(root, "decisions", "ref-002-where-the-screen-design-lives.md");
+  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"'),
+  );
+  const close = commitAll(root, "close S-0002");
+  return { root, before, open, close };
+}
+
+describe("records-since output schema", () => {
+  test("is a valid draft 2020-12 document with the published $id", () => {
+    expect(validSchema(schema)).toBe(true);
+    expect(schema.$id).toBe(RECORDS_SINCE_OUTPUT_SCHEMA_ID);
+  });
+
+  test("lists exactly the error codes and change kinds the code can return", () => {
+    expect(schema.$defs.failure.properties.error.properties.code.enum).toEqual([...RECORDS_SINCE_ERROR_CODES]);
+    expect(schema.$defs.change.oneOf.map((r) => (schema.$defs as unknown as Record<string, { properties: { change: { const: string } } }>)[r.$ref.replace("#/$defs/", "")].properties.change.const)).toEqual([...SINCE_CHANGE_KINDS]);
+    expect(Object.keys(schema.$defs.result.properties.summary.properties)).toEqual([...SINCE_CHANGE_KINDS]);
+  });
+});
+
+describe("records --since (#2673)", () => {
+  const h = sessionHistory();
+
+  test("between a session's open and close commits, the decisions show every verdict, state change, supersession and pin", async () => {
+    const doc = ok(await since({ kind: DECISIONS_KIND, since: h.open, at: h.close, cwd: h.root }));
+    expect(doc.since).toBe(h.open);
+    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: "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: "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 });
+  });
+
+  test("the session kind shows the session closing and the verdicts it produced", async () => {
+    const doc = ok(await since({ kind: SESSIONS_KIND, since: h.open, at: h.close, cwd: h.root }));
+    expect(doc.changes).toEqual([
+      { change: "state", id: "S-0002", from: "open", to: "closed" },
+      { change: "verdict", id: "S-0002", principal: "alice", verdict: "agree", index: 0, record: "ref-001" },
+      { change: "verdict", id: "S-0002", principal: "bob", verdict: "agree", index: 1, record: "ref-001" },
+    ]);
+  });
+
+  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"));
+    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" }]);
+    } finally {
+      git(h.root, "checkout", "--", "decisions");
+    }
+  });
+
+  test("a directory that did not exist at --since held no records, so every record in it is new", async () => {
+    const root = scratchDir("chant-since-empty-");
+    git(root, "init", "-q");
+    writeFileSync(join(root, "README.md"), "empty\n");
+    const first = commitAll(root, "empty");
+    const copy = sessionsRepo();
+    for (const d of ["decisions", "design"]) cpSync(join(copy, d), join(root, d), { recursive: true });
+    const doc = ok(await since({ kind: SESSIONS_KIND, since: first, cwd: root }));
+    expect(doc.changes).toEqual([{ change: "new", id: "S-0001", path: "design/sessions/S-0001-first-walk-of-the-reference-decisions.md", state: "closed" }]);
+  });
+
+  test("nothing changed is an empty list", async () => {
+    const doc = ok(await since({ kind: DECISIONS_KIND, since: h.close, at: "HEAD", cwd: h.root }));
+    expect(doc.changes).toEqual([]);
+  });
+
+  test("a --since that names no commit is since-rev-unknown, and a bad --at is revision-unknown", async () => {
+    const docs = [
+      await since({ kind: DECISIONS_KIND, since: "no-such-rev", cwd: h.root }),
+      await since({ kind: DECISIONS_KIND, since: "--all", cwd: h.root }),
+      await since({ kind: DECISIONS_KIND, since: h.open, at: "no-such-rev", cwd: h.root }),
+      await since({ kind: "missing.kind.mjs", since: h.open, cwd: h.root }),
+    ];
+    expect(docs.map((d) => ("error" in d ? d.error.code : "ok"))).toEqual(["since-rev-unknown", "since-rev-unknown", "revision-unknown", "kind-unreadable"]);
+  });
+
+  test("outside a git repository it is not-a-git-repository", async () => {
+    const root = scratchDir("chant-since-nogit-");
+    const doc = await since({ kind: DECISIONS_KIND, since: "HEAD", cwd: root });
+    expect("error" in doc && doc.error.code).toBe("not-a-git-repository");
+  });
+
+  test(
+    "through the CLI: --json prints the document, the text form a line per change, and a bad --since exits 1",
+    () => {
+      const run = (...args: string[]) =>
+        spawnSync(process.execPath, ["--import", pathToFileURL(join(REPO, "node_modules/tsx/dist/loader.mjs")).href, join(REPO, "packages/core/src/cli/main.ts"), "workspace", "records", ...args], {
+          cwd: h.root,
+          encoding: "utf-8",
+          env: { ...process.env, NO_COLOR: "1" },
+          timeout: 60_000,
+        });
+      const json = run("--kind", SESSIONS_KIND, "--since", h.open, "--at", h.close, "--json");
+      expect(json.status, json.stderr).toBe(0);
+      expectValid(JSON.parse(json.stdout));
+      const text = run("--kind", SESSIONS_KIND, "--since", h.open, "--at", h.close);
+      expect(text.stdout).toContain("S-0002  state open to closed");
+      expect(text.stdout).toContain("S-0002  verdict agree by alice on ref-001");
+      const bad = run("--kind", SESSIONS_KIND, "--since", "nope", "--json");
+      expect(bad.status).toBe(1);
+      expect(JSON.parse(bad.stdout).error.code).toBe("since-rev-unknown");
+      const mixed = run("--kind", SESSIONS_KIND, "--since", h.open, "--current");
+      expect(mixed.status).toBe(1);
+    },
+    120_000,
+  );
+});