@intentius/chant 0.90.0 → 0.93.0

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

package/src/workspace/status-gates.ts

@@ -103,9 +103,14 @@ export const defaultGateLedgerReader: GateLedgerReader = async (dir, commit, cwd
   return files;
 };
 
-/** The exact `chant approve` line for a gate. */
-export function approveCommand(component: string, gate: string, env: string | null): string {
-  return `chant approve ${component} ${gate}${env !== null ? ` --env ${env}` : ""}`;
+/**
+ * The exact `chant approve` line for a gate. A gate bound to a plan (#2300)
+ * gets `--plan <digest>` too (#2832), so running the line back approves the
+ * plan this read showed and not whatever happens to be pending by the time
+ * someone runs it.
+ */
+export function approveCommand(component: string, gate: string, env: string | null, planDigest?: string | null): string {
+  return `chant approve ${component} ${gate}${env !== null ? ` --env ${env}` : ""}${planDigest ? ` --plan ${planDigest}` : ""}`;
 }
 
 const approvalOf = (r: GateResolutionRecord): StatusGateApproval => ({ principal: r.resolvedBy, channel: r.origin ?? null, at: r.timestamp });
@@ -150,7 +155,7 @@ function decide(component: string, standing: PendingGateRecord, resolutions: Gat
     expiresAt: standing.expiresAt,
     approvals: approvals.map(approvalOf),
     needed,
-    approve: approveCommand(component, gate, env),
+    approve: approveCommand(component, gate, env, planDigest),
   };
 }
 

package/src/workspace/status-stewards.ts

@@ -0,0 +1,329 @@
+/**
+ * Stewards in `chant workspace status --json` (#2731): which steward runs a
+ * member's operational work, the form it takes in the environment asked for,
+ * its Ops with their schedules, and each Op's last run.
+ *
+ * The steward itself is read from its declaration, the same `*.op.ts` files
+ * `chant operator --steward` reads (`../op/discover.ts`), and only for a member
+ * of kind `chant` that is a chant project of its own (a `chant.config.ts` or
+ * `.json` in its directory), so a member never lists a parent project's
+ * steward. Everything
+ * else is read from the local `chant/lifecycle` branch and refs, never
+ * fetched, as the rest of status is:
+ *
+ * - each Op's last run is the newest record in its run ledger,
+ *   `<env>/runs__<op>.jsonl` under the member's ledger prefix, where `<env>`
+ *   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;
+ * - `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;
+ * - an Op's `workLease.held` is the work leases its turns hold (#2748): those
+ *   whose holder is `<steward>/<op>@...` (`stewardWorkHolder`), read from the
+ *   ledger of the Op's work kind, or the member's own.
+ */
+
+import { existsSync, realpathSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { 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";
+import { leaseRef } from "../lifecycle/lease";
+import { readBlobBySha, readRefSha } from "../lifecycle/git";
+import { resolveMemberLedger } from "../lifecycle/member-ledger";
+import { listWorkLeases } from "../lifecycle/work-lease";
+import { stewardWorkHolder } from "../op/work-lease-run";
+import type { OpConfig } from "../op/types";
+import type { OpRunRecord } from "../op/runtime";
+import { approveCommand } from "./status-gates";
+import type { ReasonCode } from "./reason-codes";
+
+/** Why a member's stewards can't be fully listed. Closed: a new code is a contract change. */
+export const STEWARD_REASON_CODES = [
+  /** An `*.op.ts` file could not be imported, so a steward it declares may be missing. */
+  "stewards-unreadable",
+  /** A steward was dropped: its name, or an Op it lists, belongs to another steward. */
+  "stewards-conflict",
+  /** Reading an Op's run ledger, or a ConvergeOp's converge ledger, failed, so its last run or last tick is null. */
+  "steward-runs-unreadable",
+] as const satisfies readonly ReasonCode[];
+export type StewardReasonCode = (typeof STEWARD_REASON_CODES)[number];
+
+export interface StatusStewardRun {
+  id: string;
+  status: OpRunRecord["status"];
+  started: string;
+  ended: string;
+  /**
+   * The gate the run stopped at, for a `gated` run: its name, when the run
+   * stopped there, the op it is recorded under (the Op's own, or the
+   * command's for a step whose command stopped at its own gate, #2779, such
+   * as `workspace-upgrade`), and the command that approves it.
+   */
+  gate: { name: string; since: string; op: string; approve: string } | null;
+  /** The open decision point the run stopped on, for a `waiting` run (#2749). */
+  point: StatusStewardWait | null;
+}
+
+/** An open decision point a steward's run stopped on (#2749), as the run ledger records it. */
+export interface StatusStewardWait {
+  /** The answer record's id: what `points --open` lists and `points answer` names. */
+  id: string;
+  point: string;
+  /** The question's state when the run stopped. */
+  state: "escalated" | "proposed";
+  path: string;
+  subject: string | null;
+  since: string;
+}
+
+/** A ConvergeOp's newest tick on the converge ledger (#2778). */
+export interface StatusStewardTick {
+  /** The tick's id, or null for a tick recorded before ticks had ids. */
+  id: string | null;
+  timestamp: string;
+  /** The tick's one log line. */
+  log: string;
+  /** Every rule that fired. */
+  firedRuleIds: string[];
+  /** What each fired rule did, and for which resource on a ConvergeOp with an observer step. */
+  outcomes: {
+    ruleId: string;
+    action: ConvergeTickRecord["outcomes"][number]["action"];
+    op: string | null;
+    resource: string | null;
+    reason: string | null;
+  }[];
+  /** What the observer step reported, or null for a ConvergeOp that observes a lexicon environment. */
+  resources: { name: string; status: "in-sync" | "drifted" | "unknown"; detail: string | null }[] | null;
+}
+
+export interface StatusStewardOp {
+  name: string;
+  /** The Op's cadence, or null for an Op the steward runs only when asked. */
+  schedule: { cron: string; overlap: "skip" } | null;
+  /** The environment its runs are recorded under: its `labels.Env`, or `local`. */
+  env: string;
+  /** The newest run in its run ledger, or null when it has none. */
+  lastRun: StatusStewardRun | null;
+  /** For a ConvergeOp, its newest tick on the converge ledger (#2778); null for any other Op, or before its first tick. */
+  lastTick: StatusStewardTick | null;
+  /** Whether the Op changes the checkout, and so runs under a work lease on a branch of its own (#2748). */
+  changesCheckout: boolean;
+  /**
+   * The Op's work lease (#2748), or null when it declares none: the work kind
+   * file whose ledger holds it (null for the member's own), and the leases
+   * the steward's turns of this Op hold, a live one while a turn runs.
+   */
+  workLease: { kind: string | null; held: StatusStewardWorkLease[] } | null;
+}
+
+/** A work lease a steward's turn holds (#2748). */
+export interface StatusStewardWorkLease {
+  item: string;
+  holder: string;
+  token: string;
+  acquiredAt: string;
+  expiresAt: string;
+  state: "active" | "expired";
+}
+
+export interface StatusSteward {
+  name: string;
+  /** The `*.op.ts` file declaring it, relative to the member's directory. */
+  file: string;
+  /** Its form in the environment status was asked for. */
+  form: StewardForm;
+  /** The declared form: a default and the environments that differ from it. */
+  forms: { default: StewardForm; environments: Record<string, StewardForm> };
+  /** The vault the steward holds on Fountain, by name, or null. */
+  vault: string | null;
+  /**
+   * The box capabilities the steward reaches through a broker (#2726), joined
+   * with the member's box block: `broker` is the block's, and `declared` is
+   * false when the block doesn't list the capability (or there is no block).
+   */
+  capabilities: { name: string; broker: string | null; declared: boolean }[];
+  /** The local steward's own lease, or null when no local operator has held it. */
+  lease: { holder: string; acquiredAt: string; expiresAt: string; live: boolean } | null;
+  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.
+   */
+  waiting: (StatusStewardWait & { op: string; run: string })[];
+}
+
+export interface MemberStewards {
+  stewards: StatusSteward[];
+  reasons: { code: StewardReasonCode; message: string }[];
+}
+
+function waitOf(p: NonNullable<OpRunRecord["point"]>): StatusStewardWait {
+  return {
+    id: p.id,
+    point: p.point,
+    state: p.state === "proposed" ? "proposed" : "escalated",
+    path: p.path,
+    subject: p.subject ?? null,
+    since: p.since,
+  };
+}
+
+function gateOf(g: NonNullable<OpRunRecord["gate"]>, opName: string): NonNullable<StatusStewardRun["gate"]> {
+  const op = g.op ?? opName;
+  return { name: g.name, since: g.since, op, approve: approveCommand(op, g.name, null) };
+}
+
+function tickOf(t: ConvergeTickRecord): StatusStewardTick {
+  return {
+    id: t.id ?? null,
+    timestamp: t.timestamp,
+    log: t.log,
+    firedRuleIds: [...t.firedRuleIds],
+    outcomes: t.outcomes.map((o) => ({
+      ruleId: o.ruleId,
+      action: o.action,
+      op: o.op ?? null,
+      resource: o.resource ?? null,
+      reason: o.reason ?? null,
+    })),
+    resources: t.resources ? t.resources.map((r) => ({ name: r.name, status: r.status, detail: r.detail ?? null })) : null,
+  };
+}
+
+/** Whether a directory is a chant project of its own. */
+function isChantProject(dir: string): boolean {
+  return existsSync(join(dir, "chant.config.ts")) || existsSync(join(dir, "chant.config.json"));
+}
+
+async function readStewardLease(name: string, memberDir: string, now: string): Promise<StatusSteward["lease"]> {
+  try {
+    const { prefix } = await resolveMemberLedger(memberDir);
+    const sha = await readRefSha(leaseRef(stewardLeaseName(name), prefix), { cwd: memberDir });
+    if (!sha) return null;
+    const record = JSON.parse((await readBlobBySha(sha, { cwd: memberDir })) ?? "") as Record<string, unknown>;
+    if (typeof record.holder !== "string" || typeof record.expiresAt !== "string" || typeof record.acquiredAt !== "string") return null;
+    return {
+      holder: record.holder,
+      acquiredAt: record.acquiredAt,
+      expiresAt: record.expiresAt,
+      live: new Date(record.expiresAt).getTime() > new Date(now).getTime(),
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** The work leases `steward`'s turns of `op` hold, from the ledger of the Op's kind or the member's. */
+async function readHeldWorkLeases(steward: string, op: OpConfig, memberDir: string, now: string): Promise<StatusStewardWorkLease[]> {
+  try {
+    const kind = op.workLease?.kind;
+    const cwd = kind ? dirname(resolve(memberDir, kind)) : memberDir;
+    const { prefix } = await resolveMemberLedger(cwd);
+    const mine = stewardWorkHolder(steward, op.name, "");
+    return (await listWorkLeases({ cwd, memberPrefix: prefix, now: new Date(now) }))
+      .filter((l) => l.holder.startsWith(mine))
+      .map((l) => ({ item: l.item, holder: l.holder, token: l.token, acquiredAt: l.acquiredAt, expiresAt: l.expiresAt, state: l.state }));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * The stewards declared in one member, for `env`. `memberDir` is absolute.
+ * Only a member of kind `chant` with a config of its own is read.
+ */
+export async function readMemberStewards(
+  memberDir: string,
+  env: string,
+  now: string,
+  kind = "chant",
+  box: { capabilities: { name: string; broker: string | null }[] } | null = null,
+): Promise<MemberStewards> {
+  const reasons: MemberStewards["reasons"] = [];
+  if (kind !== "chant" || !isChantProject(memberDir)) return { stewards: [], reasons };
+
+  let discovered: Awaited<ReturnType<typeof discoverStewards>>;
+  try {
+    discovered = await discoverStewards({ cwd: memberDir });
+  } catch (err) {
+    reasons.push({ code: "stewards-unreadable", message: err instanceof Error ? err.message.split("\n")[0] : String(err) });
+    return { stewards: [], reasons };
+  }
+  const { stewards: found, errors, conflicts } = discovered;
+  for (const message of errors) reasons.push({ code: "stewards-unreadable", message });
+  for (const message of conflicts) reasons.push({ code: "stewards-conflict", message });
+
+  const stewards: StatusSteward[] = [];
+  for (const { declaration, filePath } of [...found.values()].sort((a, b) => a.declaration.name.localeCompare(b.declaration.name))) {
+    const ops: StatusStewardOp[] = [];
+    const waiting: StatusSteward["waiting"] = [];
+    for (const op of declaration.ops) {
+      const opEnv = runEnvOf(op);
+      let lastRun: StatusStewardRun | null = null;
+      try {
+        const newest = (await readRunLedger(opEnv, op.name, { cwd: memberDir })).records.at(-1);
+        if (newest) {
+          lastRun = {
+            id: newest.id,
+            status: newest.status,
+            started: newest.started,
+            ended: newest.ended,
+            gate: newest.gate ? gateOf(newest.gate, op.name) : null,
+            point: newest.point ? waitOf(newest.point) : null,
+          };
+          if (newest.status === "waiting" && lastRun.point && newest.steward === declaration.name) {
+            waiting.push({ op: op.name, run: newest.id, ...lastRun.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)}`,
+        });
+      }
+      let lastTick: StatusStewardTick | null = null;
+      if (op.labels?.Converge === "true") {
+        try {
+          const newest = (await readConvergeLedger(opEnv, { cwd: memberDir })).records.filter((r) => r.op === op.name).at(-1);
+          if (newest) lastTick = tickOf(newest);
+        } catch (err) {
+          reasons.push({
+            code: "steward-runs-unreadable",
+            message: `${opEnv}/converge.jsonl: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`,
+          });
+        }
+      }
+      ops.push({
+        name: op.name,
+        schedule: op.schedule ? { cron: op.schedule.cron, overlap: "skip" } : null,
+        env: opEnv,
+        lastRun,
+        lastTick,
+        changesCheckout: op.changesCheckout === true,
+        workLease: op.workLease
+          ? { kind: op.workLease.kind ?? null, held: await readHeldWorkLeases(declaration.name, op, memberDir, now) }
+          : null,
+      });
+    }
+    stewards.push({
+      name: declaration.name,
+      file: relative(realpathSync(memberDir), realpathSync(filePath)).split("\\").join("/"),
+      form: stewardFormFor(declaration, env),
+      forms: { default: declaration.form.default, environments: { ...declaration.form.environments } },
+      vault: typeof declaration.vault === "string" ? declaration.vault : null,
+      capabilities: (Array.isArray(declaration.capabilities) ? declaration.capabilities : []).map((name) => {
+        const declared = box?.capabilities.find((c) => c.name === name);
+        return { name, broker: declared?.broker ?? null, declared: declared !== undefined };
+      }),
+      lease: await readStewardLease(declaration.name, memberDir, now),
+      ops,
+      waiting,
+    });
+  }
+  return { stewards, reasons };
+}