@intentius/chant 0.89.0 → 0.91.0

package/src/workspace/source-block.test.ts

@@ -0,0 +1,167 @@
+/**
+ * A record's stored source block (#2708): the decision schema documents it,
+ * records new writes it and records returns it unchanged, a harvested record
+ * opens proposed, and records warns source-transcript-drift when the pinned
+ * transcript is here and hashes to something else.
+ */
+
+import { createHash } from "node:crypto";
+import { cpSync, mkdirSync, mkdtempSync, 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, type RecordEntry } from "./records";
+import { queryRecords } from "./records-cli";
+import { newRecord, renderRecord, stableJson } from "./records-write";
+import { sourceBlockProblems, transcriptDrift, transcriptFile } from "./source-block";
+
+const REPO = join(import.meta.dirname, "..", "..", "..", "..");
+const DECISIONS = join(REPO, "docs", "design", "decisions");
+const KIND = "decisions/decision.kind.mjs";
+
+type Data = Record<string, unknown>;
+
+const SAMPLE = (() => {
+  const fm = parseFrontMatter(readFileSync(join(DECISIONS, "ws-003-seal-scope.md"), "utf-8"));
+  if (!fm.ok) throw new Error(fm.message);
+  return fm.value;
+})();
+
+/** A proposed decision like ws-003, with `over` laid on top. */
+function proposal(over: Data = {}): Data {
+  const d: Data = { ...structuredClone(SAMPLE), state: "proposed", choice: null, decided_by: null, decided_on: null, reviews: [], ...over };
+  delete d.id;
+  return d;
+}
+
+const sha = (text: string) => createHash("sha256").update(text).digest("hex");
+const TRANSCRIPT = '{"turn":1,"role":"user","text":"which way do we deploy?"}\n';
+
+const HARNESS = {
+  via: "mcp",
+  client: { name: "claude-code", version: "2.1.0" },
+  harness: "claude-code",
+  model: "claude-opus-5-5",
+  session: { id: "0f4c2a", record: "S-0002" },
+  turns: { from: 12, to: 18 },
+  transcript: { path: "transcripts/0f4c2a.jsonl", sha256: sha(TRANSCRIPT) },
+};
+
+let dir: string;
+beforeEach(() => {
+  dir = realpathSync(mkdtempSync(join(tmpdir(), "chant-source-block-")));
+  mkdirSync(join(dir, "decisions"));
+  mkdirSync(join(dir, "transcripts"));
+  cpSync(join(DECISIONS, "decision.kind.mjs"), join(dir, "decisions", "decision.kind.mjs"));
+  cpSync(join(DECISIONS, "decision.schema.json"), join(dir, "decisions", "decision.schema.json"));
+  writeFileSync(join(dir, "decisions", "ws-001-one.md"), renderRecord({ ...proposal({ title: "One" }), id: "ws-001" }, "\n# One\n"));
+  writeFileSync(join(dir, "transcripts", "0f4c2a.jsonl"), TRANSCRIPT);
+});
+afterEach(() => rmSync(dir, { recursive: true, force: true }));
+
+const code = (doc: object) => ("error" in doc ? (doc as { error: { code: string } }).error.code : "ok");
+
+async function read(): Promise<RecordEntry[]> {
+  const doc = await queryRecords({ kind: KIND, cwd: dir });
+  if (!("records" in doc)) throw new Error(JSON.stringify(doc));
+  return doc.records;
+}
+
+async function write(source: unknown, over: Data = {}) {
+  return newRecord({ kind: KIND, fields: JSON.stringify(proposal({ title: "Two", source, ...over })), cwd: dir });
+}
+
+describe("the decision schema documents the block", () => {
+  test("each form takes the proposal fields, and a harness form needs via", async () => {
+    for (const source of [
+      HARNESS,
+      { ...HARNESS, issue: "INTENTIUS/chant#2708" },
+      { issue: "INTENTIUS/chant#2708", row: "Source", revision: null, ...HARNESS },
+      { kind: "workspace", member: "app", ...HARNESS, session: "S-0001" },
+      { via: "cli" },
+    ]) {
+      const doc = await write(source, { title: `T ${Math.random()}` });
+      expect(code(doc), JSON.stringify(source)).toBe("ok");
+    }
+    const { via: _via, ...noVia } = HARNESS;
+    for (const source of [
+      noVia,
+      { ...HARNESS, via: "email" },
+      { ...HARNESS, transcript: { path: "a", uri: "file:///a", sha256: sha("a") } },
+      { ...HARNESS, transcript: { path: "a", sha256: "ABC" } },
+      { ...HARNESS, turns: { from: 3 } },
+      { ...HARNESS, session: {} },
+      { ...HARNESS, client: { version: "1" } },
+      { ...HARNESS, row: "a row without an issue" },
+    ]) {
+      const doc = await write(source);
+      expect(code(doc), JSON.stringify(source)).toBe("record-schema-invalid");
+    }
+  });
+
+  test("chant checks the shapes the schema can't: turns that end before they start", async () => {
+    const doc = await write({ ...HARNESS, turns: { from: 18, to: 12 } });
+    expect(doc).toMatchObject({ error: { code: "record-schema-invalid", message: expect.stringContaining("/source/turns ends before it starts") } });
+    expect(sourceBlockProblems({ ...HARNESS, turns: { from: 18, to: 12 } }, "source")).toEqual(["/source/turns ends before it starts"]);
+    expect(sourceBlockProblems({ issue: "o/r#1", row: "anything the kind says" }, "source")).toEqual([]);
+  });
+});
+
+describe("records new and records", () => {
+  test("records new --from with a source block writes it, and records --json returns it unchanged", async () => {
+    const doc = await write(HARNESS);
+    expect(code(doc)).toBe("ok");
+    const written = (await read()).find((r) => r.id === "ws-002");
+    expect(stableJson(written?.data?.source)).toBe(stableJson(HARNESS));
+    expect(written?.valid).toBe(true);
+    expect(written?.warnings.map((w) => w.code)).not.toContain("source-transcript-drift");
+  });
+
+  test("a harvested record opens proposed; any other state is refused with a remedy", async () => {
+    const decided = await write(
+      { ...HARNESS, via: "harvest" },
+      { state: "decided", choice: SAMPLE.choice, decided_by: "alice", decided_on: "2026-09-25" },
+    );
+    expect(decided).toMatchObject({ error: { code: "source-harvest-not-proposed", message: expect.stringContaining('write it with state "proposed"') } });
+    const withdrawn = await write({ ...HARNESS, via: "harvest" }, { state: "withdrawn" });
+    expect(code(withdrawn)).toBe("source-harvest-not-proposed");
+    expect(code(await write({ ...HARNESS, via: "harvest" }))).toBe("ok");
+    // Only a harvest opens proposed: a decision written at the CLI may still be decided in one go.
+    const cli = await write({ via: "cli" }, { title: "Three", state: "decided", choice: SAMPLE.choice, decided_by: "alice", decided_on: "2026-09-25" });
+    expect(code(cli)).toBe("ok");
+  });
+});
+
+describe("source-transcript-drift", () => {
+  test("warns when the transcript is here and its bytes changed, and not when they match or it is missing", async () => {
+    expect(code(await write(HARNESS))).toBe("ok");
+    const drift = async () => (await read()).find((r) => r.id === "ws-002")!.warnings.filter((w) => w.code === "source-transcript-drift");
+    expect(await drift()).toEqual([]);
+    writeFileSync(join(dir, "transcripts", "0f4c2a.jsonl"), TRANSCRIPT + '{"turn":2}\n');
+    const warned = await drift();
+    expect(warned).toHaveLength(1);
+    expect(warned[0].message).toContain("transcripts/0f4c2a.jsonl is pinned at sha256");
+    rmSync(join(dir, "transcripts", "0f4c2a.jsonl"));
+    expect(await drift()).toEqual([]);
+  });
+
+  test("reads an absolute path, ~/ and file: URIs, and never fetches another URI", () => {
+    const file = join(dir, "transcripts", "0f4c2a.jsonl");
+    const bad = "0".repeat(64);
+    expect(transcriptDrift({ transcript: { path: file, sha256: sha(TRANSCRIPT) } }, "source", "/nowhere")).toBeUndefined();
+    expect(transcriptDrift({ transcript: { path: file, sha256: bad } }, "source", "/nowhere")).toContain("is pinned at sha256 000000000000");
+    expect(transcriptDrift({ transcript: { uri: pathToFileURL(file).href, sha256: bad } }, "source", "/nowhere")).toContain("file:");
+    expect(transcriptDrift({ transcript: { uri: "https://example.com/t.jsonl", sha256: bad } }, "source", dir)).toBeUndefined();
+    expect(transcriptFile({ path: "~/t.jsonl" }, dir)).toMatch(/\/t\.jsonl$/);
+    expect(transcriptFile({ path: "t.jsonl" }, dir)).toBe(join(dir, "t.jsonl"));
+  });
+
+  test("a kind that does not opt in is not checked", async () => {
+    const kindFile = join(dir, "decisions", "decision.kind.mjs");
+    writeFileSync(kindFile, readFileSync(kindFile, "utf-8").replace(/\n\s*source: \{ field: "source" \},/, ""));
+    expect(code(await write({ ...HARNESS, turns: { from: 18, to: 12 } }))).toBe("ok");
+    writeFileSync(join(dir, "transcripts", "0f4c2a.jsonl"), "changed");
+    expect((await read()).flatMap((r) => r.warnings.map((w) => w.code))).not.toContain("source-transcript-drift");
+  });
+});

package/src/workspace/source-block.ts

@@ -0,0 +1,129 @@
+/**
+ * A record's stored source block (#2708): where a proposal came from.
+ *
+ * chant's provenance (`trust/provenance.ts`) is computed from git: who
+ * committed a record, and with which key. It says nothing about the harness,
+ * model and session a decision was proposed in, or the conversation behind it.
+ * A record kind that declares `source: { field }` opts in to a stored block
+ * holding that, next to whatever else its source field says (a decision's
+ * issue row or workspace member, a work item's finding):
+ *
+ * - `via`: how the record reached the workspace, `cli`, `mcp` or `harvest`;
+ * - `client`: the MCP client's `clientInfo` (`name`, `version`), or the CLI;
+ * - `harness`: the harness's id, such as `claude-code` or `codex`;
+ * - `model`: the model id the harness reports;
+ * - `session`: the harness's session or conversation id, as a string, or as
+ *   `{ id, record }` with the chant session record it was held in (#2697);
+ * - `turns`: the turn range the decision was made in, `{ from, to }`;
+ * - `transcript`: `{ path | uri, sha256 }`, pinning a transcript by hash and
+ *   never copying it, the way evidence pins a file.
+ *
+ * Every field is optional, and the block is data about the proposal, not
+ * trust: nothing here raises or lowers a record's standing. The rules are
+ * three. The fields that are present must have these shapes
+ * (`record-schema-invalid` otherwise, beside the kind's own schema). A record
+ * written with `via: "harvest"` must open in the kind's first state, since a
+ * harvest proposes and a person decides (`source-harvest-not-proposed`, a
+ * write refusal). And `records` warns `source-transcript-drift` when the
+ * pinned transcript can be read here and its bytes hash to something else.
+ */
+
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { sha256Hex } from "../content-digest";
+
+/** How a record reached the workspace. Closed. */
+export const SOURCE_VIAS = ["cli", "mcp", "harvest"] as const;
+export type SourceVia = (typeof SOURCE_VIAS)[number];
+
+const text = z.string().min(1);
+const sha256 = z.string().regex(/^[0-9a-f]{64}$/, "must be the lowercase hex SHA-256 of the transcript's bytes");
+
+/** The proposal fields of a source block. Other fields of the block are the kind's, and left to its schema. */
+export const sourceBlockSchema = z.object({
+  via: z.enum(SOURCE_VIAS).optional(),
+  client: z.object({ name: text, version: text.optional(), title: text.optional() }).strict().optional(),
+  harness: text.optional(),
+  model: text.optional(),
+  session: z
+    .union([
+      text,
+      z.null(),
+      z
+        .object({ id: text.optional(), record: text.optional() })
+        .strict()
+        .refine((s) => s.id !== undefined || s.record !== undefined, { message: "names neither the harness's session id nor a chant session record" }),
+    ])
+    .optional(),
+  turns: z
+    .object({ from: z.number().int().min(0), to: z.number().int().min(0) })
+    .strict()
+    .refine((t) => t.to >= t.from, { message: "ends before it starts" })
+    .optional(),
+  transcript: z
+    .union([z.object({ path: text, sha256 }).strict(), z.object({ uri: text, sha256 }).strict()])
+    .optional(),
+});
+
+export type SourceBlock = z.infer<typeof sourceBlockSchema>;
+
+/** The source block of `data`, when `field` holds an object. */
+export function sourceBlock(data: Record<string, unknown> | null, field: string): Record<string, unknown> | undefined {
+  const v = data?.[field];
+  return v !== null && typeof v === "object" && !Array.isArray(v) ? (v as Record<string, unknown>) : undefined;
+}
+
+/** What is wrong with the proposal fields of `block`, as `<path> <message>` lines. Empty when nothing is. */
+export function sourceBlockProblems(block: Record<string, unknown>, field: string): string[] {
+  const parsed = sourceBlockSchema.safeParse(block);
+  if (parsed.success) return [];
+  return parsed.error.issues.map((i) => `/${[field, ...i.path].join("/")} ${i.message}`);
+}
+
+/**
+ * The file a transcript pin names, when it can be read here: a `path`
+ * (absolute, `~/` from the home directory, or else from the workspace root)
+ * or a `file:` URI. Any other URI is not fetched, so it is never reachable.
+ */
+export function transcriptFile(transcript: { path?: string; uri?: string }, workspaceDir: string): string | undefined {
+  if (transcript.path !== undefined) {
+    const p = transcript.path;
+    if (p === "~" || p.startsWith("~/")) return join(homedir(), p.slice(1));
+    return isAbsolute(p) ? p : resolve(workspaceDir, p);
+  }
+  if (transcript.uri !== undefined && transcript.uri.startsWith("file:")) {
+    try {
+      return fileURLToPath(transcript.uri);
+    } catch {
+      return undefined;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * The `source-transcript-drift` message for `block`, or undefined: when its
+ * transcript pin is well formed, the file it names can be read here, and its
+ * bytes hash to something other than the pin. A transcript that can't be
+ * read says nothing either way.
+ */
+export function transcriptDrift(block: Record<string, unknown>, field: string, workspaceDir: string): string | undefined {
+  const parsed = sourceBlockSchema.shape.transcript.safeParse(block.transcript);
+  if (!parsed.success || parsed.data === undefined) return undefined;
+  const t = parsed.data as { path?: string; uri?: string; sha256: string };
+  const file = transcriptFile(t, workspaceDir);
+  if (file === undefined) return undefined;
+  let bytes: Uint8Array;
+  try {
+    bytes = readFileSync(file);
+  } catch {
+    return undefined;
+  }
+  const actual = sha256Hex(bytes);
+  if (actual === t.sha256) return undefined;
+  const named = t.path ?? t.uri!;
+  return `${field}.transcript ${named} is pinned at sha256 ${t.sha256.slice(0, 12)}, and the file here hashes to ${actual.slice(0, 12)}: it is not the transcript the record means`;
+}

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

@@ -22,10 +22,15 @@ import {
   STATUS_GATE_REASON_CODES,
   STATUS_OUTPUT_SCHEMA_ID,
   STATUS_REASON_CODES,
+  STATUS_STEWARD_REASON_CODES,
   workspaceStatus,
   type StatusDocument,
 } from "./status";
 import schema from "./status.schema.json";
+import { appendRunRecord } from "../lifecycle/run-ledger";
+import { acquireStewardLease } from "../op/operator";
+import { stewardWorkHolder } from "../op/work-lease-run";
+import { claimWorkLease } from "../lifecycle/work-lease";
 
 const REPO = join(import.meta.dirname, "..", "..", "..", "..");
 
@@ -148,6 +153,7 @@ describe("status output schema", () => {
     expect(schema.$defs.environment.properties.reason.oneOf[1].properties!.code.enum).toEqual([...STATUS_REASON_CODES]);
     expect(schema.$defs.failure.properties.error.properties.code.enum).toEqual([...STATUS_ERROR_CODES]);
     expect(schema.$defs.gateLedger.properties.reason.oneOf[1].properties!.code.enum).toEqual([...STATUS_GATE_REASON_CODES]);
+    expect(schema.$defs.member.properties.stewardReasons.items.properties.code.enum).toEqual([...STATUS_STEWARD_REASON_CODES]);
   });
 });
 
@@ -163,6 +169,8 @@ describe("chant workspace status on built workspaces", () => {
     expect(web.environments[0].ledger).toEqual({ layout: "members", path: "_members/web/staging/releases.jsonl", shared: false });
     // The later of the two records wins.
     expect(web.environments[0].releases.map((r) => [r.component, r.digest, r.gitSha])).toEqual([["web", D("a"), "a".repeat(40)]]);
+    // No plan was ever written for these digests (ws-055, #2733): the field is present, and null.
+    expect(web.environments[0].releases.map((r) => r.plan)).toEqual([null]);
     // api has no _members/api/ yet, so it falls back to the flat ledger, which the root member reads too.
     expect(api.environments[0].ledger).toEqual({ layout: "flat", path: "staging/releases.jsonl", shared: true });
     expect(site.environments[0].ledger).toEqual({ layout: "flat", path: "staging/releases.jsonl", shared: true });
@@ -199,6 +207,33 @@ describe("chant workspace status on built workspaces", () => {
     expect(text).toContain("3 members, 3 with a release in staging, 2 differ from prod, 0 unreadable");
   });
 
+  test("resolves a release's plan from _plans/<digest>.json, member-scoped per #2524 D7 (ws-055, #2733)", async () => {
+    const root = repo({
+      "chant.workspace.json": declaration([
+        { name: "site", dir: ".", kind: "other", because: "the root project" },
+        { name: "web", dir: "apps/web", kind: "chant" },
+      ]),
+      "apps/web/chant.config.ts": "",
+    });
+    const webPlan = { digest: D("a"), release: "r-web", units: [{ id: "w-1" }] };
+    const apiPlan = { digest: D("b"), release: "r-api", units: [] };
+    lifecycle(root, {
+      "_members/web/staging/releases.jsonl": jsonl(release("web", "staging", D("a"), "a".repeat(40))),
+      [`_members/web/_plans/sha256_${"a".repeat(64)}.json`]: JSON.stringify(webPlan),
+      "staging/releases.jsonl": jsonl(release("api", "staging", D("b"), "b".repeat(40)), release("worker", "staging", D("c"), "c".repeat(40))),
+      [`_plans/sha256_${"b".repeat(64)}.json`]: JSON.stringify(apiPlan),
+    });
+    const doc = result(await workspaceStatus({ cwd: root, env: "staging" }));
+    expectValid(doc);
+    const web = doc.members.find((m) => m.name === "web")!;
+    const site = doc.members.find((m) => m.name === "site")!;
+    expect(web.environments[0].releases[0].plan).toEqual(webPlan);
+    const byComponent = new Map(site.environments[0].releases.map((r) => [r.component, r]));
+    expect(byComponent.get("api")?.plan).toEqual(apiPlan);
+    // worker has no plan stored under its digest: reads null, not an error.
+    expect(byComponent.get("worker")?.plan).toBeNull();
+  });
+
   test("compares on the input digest when a release has one", async () => {
     const root = repo({ "chant.workspace.json": declaration([{ name: "chart", dir: "chart", kind: "other", because: "helm" }]) });
     lifecycle(root, {
@@ -253,6 +288,33 @@ describe("chant workspace status on built workspaces", () => {
     expect(formatStatus(doc)).toContain("web     -          no release");
   });
 
+  test("each member lists its box block: the capability, its broker and its scope (#2726)", async () => {
+    const root = repo({
+      "chant.workspace.json": declaration([
+        { name: "web", dir: "web", kind: "chant" },
+        {
+          name: "box",
+          dir: "box",
+          kind: "other",
+          because: "the box's declarations",
+          box: { capabilities: [{ name: "fountain", broker: "lobby", scope: ["agent", "vault", "conversations", "sandboxes"] }, { name: "inference" }] },
+        },
+      ]),
+    });
+    const doc = result(await workspaceStatus({ cwd: root, env: "prod" }));
+    expectValid(doc);
+    expect(doc.members.map((m) => m.box)).toEqual([
+      null,
+      {
+        capabilities: [
+          { name: "fountain", broker: "lobby", scope: ["agent", "vault", "conversations", "sandboxes"] },
+          { name: "inference", broker: null, scope: [] },
+        ],
+        isolation: null,
+      },
+    ]);
+  });
+
   test("every failure validates with its code", async () => {
     const empty = repo({});
     const outside = realpathSync(mkdtempSync(join(tmpdir(), "chant-status-nogit-")));
@@ -459,6 +521,122 @@ describe("gate state in chant workspace status --json (#2674)", () => {
   });
 });
 
+describe("stewards in chant workspace status --json (#2731)", () => {
+  const op = (name: string, cron?: string) => ({
+    name,
+    overview: name,
+    phases: [{ name: "Run", steps: [{ kind: "activity", fn: "noop", args: {} }] }],
+    ...(cron ? { schedule: { cron, overlap: "skip" } } : {}),
+  });
+
+  /** A box member declaring one steward, local by default and fountain on fountain-k3d. */
+  function stewarded(): string {
+    const steward = {
+      kind: "Chant::Steward",
+      name: "box-steward",
+      ops: [
+        op("box-converge", "* * * * *"),
+        op("box-release"),
+        { ...op("box-dispatch", "*/5 * * * *"), workLease: { item: ["W-1", "W-2"] }, changesCheckout: true },
+      ],
+      form: { default: "local", environments: { "fountain-k3d": "fountain" } },
+      capabilities: ["fountain", "inference"],
+      vault: null,
+    };
+    const root = repo({
+      "chant.workspace.json": declaration([
+        { name: "box", dir: "box", kind: "chant", box: { capabilities: [{ name: "fountain", broker: "lobby", scope: ["agent", "vault"] }] } },
+        { name: "notes", dir: "notes", kind: "other", because: "prose" },
+      ]),
+      "box/chant.config.ts": "export default {};\n",
+      "box/ops/steward.op.ts": `export const steward = ${JSON.stringify(steward)};\n`,
+      "notes/README.md": "notes\n",
+    });
+    lifecycle(root, { "README": "ledger\n" });
+    return root;
+  }
+
+  test("names the steward, its form in the environment asked for, its Ops, schedules, last runs and lease", async () => {
+    const root = stewarded();
+    const box = join(root, "box");
+    await appendRunRecord(
+      { op: "box-converge", env: "local", started: "2026-09-25T10:00:00.000Z", ended: "2026-09-25T10:00:05.000Z", status: "ok", labels: {}, outcomes: {}, phases: [] },
+      { cwd: box },
+    );
+    expect((await acquireStewardLease("box-steward", "box-host:1:abc", { cwd: box, now: () => new Date("2026-09-25T10:00:00.000Z") })).acquired).toBe(true);
+    // #2748: the dispatch turn holds W-1; someone else holds W-2.
+    const turn = await claimWorkLease("W-1", stewardWorkHolder("box-steward", "box-dispatch", "box-host:1:abc"), { cwd: box, ttlMs: 600_000, now: () => new Date("2026-09-25T10:00:30.000Z") });
+    expect(turn.ok).toBe(true);
+    expect((await claimWorkLease("W-2", "someone-else", { cwd: box, ttlMs: 600_000, now: () => new Date("2026-09-25T10:00:30.000Z") })).ok).toBe(true);
+
+    const doc = result(await workspaceStatus({ cwd: root, env: "minimal", now: "2026-09-25T10:01:00.000Z" }));
+    expectValid(doc);
+    const [boxMember, notes] = doc.members;
+    expect(notes.stewards).toEqual([]);
+    expect(boxMember.stewardReasons).toEqual([]);
+    expect(boxMember.stewards).toHaveLength(1);
+    const s = boxMember.stewards[0];
+    expect(s).toMatchObject({
+      name: "box-steward",
+      file: "ops/steward.op.ts",
+      form: "local",
+      forms: { default: "local", environments: { "fountain-k3d": "fountain" } },
+      // #2726: the steward holds no credential; its capabilities join the box block.
+      vault: null,
+      capabilities: [
+        { name: "fountain", broker: "lobby", declared: true },
+        { name: "inference", broker: null, declared: false },
+      ],
+      lease: { holder: "box-host:1:abc", acquiredAt: "2026-09-25T10:00:00.000Z", live: true },
+    });
+    expect(s.ops).toEqual([
+      {
+        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 },
+        changesCheckout: false,
+        workLease: null,
+      },
+      { name: "box-release", schedule: null, env: "local", lastRun: null, changesCheckout: false, workLease: null },
+      {
+        name: "box-dispatch",
+        schedule: { cron: "*/5 * * * *", overlap: "skip" },
+        env: "local",
+        lastRun: null,
+        changesCheckout: true,
+        workLease: {
+          kind: null,
+          held: [
+            {
+              item: "W-1",
+              holder: "box-steward/box-dispatch@box-host:1:abc",
+              token: turn.ok ? turn.lease.token : "",
+              acquiredAt: "2026-09-25T10:00:30.000Z",
+              expiresAt: "2026-09-25T10:10:30.000Z",
+              state: "active",
+            },
+          ],
+        },
+      },
+    ]);
+
+    const k3d = result(await workspaceStatus({ cwd: root, env: "fountain-k3d", now: "2026-09-25T11:00:00.000Z" }));
+    expectValid(k3d);
+    expect(k3d.members[0].stewards[0].form).toBe("fountain");
+    expect(k3d.members[0].stewards[0].lease!.live).toBe(false);
+  });
+
+  test("an op file that can't be imported is a reason, and the read still succeeds", async () => {
+    const root = stewarded();
+    writeFileSync(join(root, "box", "ops", "broken.op.ts"), "export const x = ;\n");
+    const doc = result(await workspaceStatus({ cwd: root, env: "minimal" }));
+    expectValid(doc);
+    expect(doc.members[0].stewards.map((s) => s.name)).toEqual(["box-steward"]);
+    expect(doc.members[0].stewardReasons.map((r) => r.code)).toEqual(["stewards-unreadable"]);
+  });
+});
+
 describe("chant workspace status on the chant repo (#2557)", () => {
   test("validates and lists every declared member", async () => {
     const doc = result(await workspaceStatus({ cwd: join(REPO, "packages", "core"), env: "prod", compareTo: "staging" }));