@intentius/chant 0.91.0 → 0.94.0

package/src/workspace/records.ts

@@ -6,8 +6,10 @@
  * record a kind locates, parses its structured core (the front matter, as the
  * JSON subset of YAML, or the whole file as one I-JSON object, ws-053),
  * validates it against the kind's schema and derives supersession from the
- * records' own `supersedes` links. It never writes a record; `records-write.ts`
- * does, through the rules here (#2670).
+ * records' own `supersedes` links, and remediation from their `remediates`
+ * links (#2774): a later record fixing a closed one's consequence without
+ * replacing it, which leaves the closed record's status unchanged. It never
+ * writes a record; `records-write.ts` does, through the rules here (#2670).
  *
  * A record that fails any of that is still returned, with reason codes, and the
  * read succeeds. Only a failure to read the kind, its schema or the revision is
@@ -31,7 +33,7 @@ import { joinSessions, type SessionCitation } from "./record-sessions";
 import type { RecordSource } from "./record-source";
 import { sourceBlock, sourceBlockProblems, transcriptDrift } from "./source-block";
 import type { WorkspaceTree } from "./tree";
-import type { DecisionWork, WorkLink, WorkWarningCode } from "./work";
+import type { DecisionWork, WorkAcceptance, WorkLink, WorkWarningCode } from "./work";
 import type { AnswerWarningCode } from "./points";
 
 // ── Reason codes ─────────────────────────────────────────────────────────────
@@ -51,6 +53,10 @@ export const RECORD_REASON_CODES = [
   "record-supersedes-unknown",
   /** A second closed record supersedes a record another one already superseded. */
   "record-supersedes-conflict",
+  /** A `remediates` link names an id no record has (#2774). */
+  "record-remediates-unknown",
+  /** A `remediates` link names a record that isn't closed: a record still open is amended instead (#2774). */
+  "record-remediates-not-closed",
   /** A closed session's seal is not the digest of its text: it changed after it closed (#2673). */
   "session-seal-mismatch",
   /** A session's verdict names a record the kind's subject records do not have (#2673). */
@@ -279,6 +285,16 @@ export const recordKindSchema = z
      * (ws-053). Optional, and only on a kind with states.
      */
     supersedes: z.object({ field: z.string().min(1), key: z.string().min(1).optional() }).strict().optional(),
+    /**
+     * The field of links to records this one remediates: a later fix to a
+     * closed record's consequence, that leaves the closed record's status
+     * unchanged (#2774). Shaped like `supersedes`: with `key`, a list of
+     * objects whose `key` holds the target id; without it, one id or a list
+     * of ids. Optional, and only on a kind with states. A link is valid only
+     * when the target exists and is in one of `closedStates`; a target still
+     * open is amended instead, never remediated.
+     */
+    remediates: z.object({ field: z.string().min(1), key: z.string().min(1).optional() }).strict().optional(),
     /**
      * How strongly each state is approved (#2524 D4). With it, a supersedes
      * link takes effect when the new record's rank is above 0 and at least the
@@ -298,6 +314,15 @@ export const recordKindSchema = z
      * (#2549). Optional.
      */
     constrains: z.object({ field: z.string().min(1) }).strict().optional(),
+    /**
+     * The front-matter list of workspace paths a record puts out of scope
+     * (#2773): a file or a directory, from the workspace root. `chant
+     * workspace check --changes` reports a change to one as
+     * `change-out-of-scope` when the record is in hand for the change, and
+     * the record does not cover it even where its constrains would.
+     * Optional.
+     */
+    outOfScope: z.object({ field: z.string().min(1) }).strict().optional(),
     /**
      * The front-matter list of review verdicts and the field naming the
      * decider (#2671, #2672). With it, each record gets a digest of its text
@@ -307,6 +332,17 @@ export const recordKindSchema = z
      * `withdrawn_on`. Optional.
      */
     reviews: z.object({ field: z.string().min(1), decider: z.string().min(1) }).strict().optional(),
+    /**
+     * The front-matter field a new record's proposer is named on, when the
+     * kind opts in (#2756). `records new --by` and the MCP `records-new`
+     * tool's `by` write it for a record that opens in the kind's first
+     * state — a proposal naming who proposed it — instead of
+     * `reviews.decider`'s field, which `by` fills only when a new record
+     * opens straight into another state. Requires `states`. Optional: a kind
+     * without it keeps `by` writing `reviews.decider` for every new record,
+     * as before #2756.
+     */
+    proposedBy: z.object({ field: z.string().min(1) }).strict().optional(),
     /**
      * The front-matter object that says where a record came from, opted in
      * to the stored source block (#2708): `via`, `client`, `harness`,
@@ -349,6 +385,15 @@ export const recordKindSchema = z
      * date. With it, `work.ts` gives each record `ready`, `blockedBy` and
      * `implements`, and the read lists each decision with `implementedBy`.
      * Optional.
+     *
+     * `acceptance` (#2772) names the front-matter list of a record's
+     * acceptance criteria, each an `id`, `text` and the `verification` it
+     * expects (`unit`, `integration`, `e2e`, `runtime` or `manual`), and the
+     * field naming the record's implementer, whose own `manual` verdict never
+     * counts. With it, each record gets `acceptance` (met and total), and a
+     * done record with a criterion that no passing evidence meets is warned
+     * `work-acceptance-unmet`, which `check` fails on (WSP117). Optional, and
+     * a record without the list is read as before.
      */
     work: z
       .object({
@@ -358,6 +403,7 @@ export const recordKindSchema = z
         open: z.string().min(1),
         done: z.string().min(1),
         closedOn: z.string().min(1),
+        acceptance: z.object({ field: z.string().min(1), implementer: z.string().min(1) }).strict().optional(),
       })
       .strict()
       .optional(),
@@ -386,6 +432,10 @@ export const recordKindSchema = z
     message: "a kind without states cannot have supersedes: a link takes effect only from a closed or ranked state",
     path: ["supersedes"],
   })
+  .refine((k) => k.states !== undefined || k.remediates === undefined, {
+    message: "a kind without states cannot have remediates: a link only ever targets a record in a closed state",
+    path: ["remediates"],
+  })
   .refine((k) => k.states !== undefined || k.session === undefined, {
     message: "a session kind must have states: a session is sealed when it reaches a closed state",
     path: ["session"],
@@ -394,6 +444,10 @@ export const recordKindSchema = z
     message: "a kind without states cannot have approval ranks",
     path: ["approval"],
   })
+  .refine((k) => k.states !== undefined || k.proposedBy === undefined, {
+    message: "a kind without states cannot have proposedBy: there is no first state for a record to open in",
+    path: ["proposedBy"],
+  })
   .refine((k) => (k.closedStates ?? []).every((s) => (k.states ?? []).includes(s)), {
     message: "every closed state must be listed in states",
     path: ["closedStates"],
@@ -406,6 +460,10 @@ export const recordKindSchema = z
     message: "a work kind must have states, and its work open and done states must be listed in them",
     path: ["work"],
   })
+  .refine((k) => !k.work?.acceptance || k.pins !== undefined, {
+    message: "a work kind with acceptance criteria must have pins: a criterion is met by the evidence in its pins field",
+    path: ["work", "acceptance"],
+  })
   .refine(
     (k) =>
       !k.answers ||
@@ -961,6 +1019,13 @@ export interface RecordEntry {
   reasons: RecordReason[];
   /** The id of the closed record whose `supersedes` link replaces this one, or null. */
   supersededBy: string | null;
+  /**
+   * The ids of records whose `remediates` link names this one (#2774), in
+   * path order. Unlike `supersededBy`, several records may remediate the
+   * same one, and a remediation never changes this record's state or
+   * `supersededBy`: it stays exactly as current as it was.
+   */
+  remediatedBy: string[];
   /** The record's structured core as JSON (the front matter, or the whole JSON file), or null when it could not be parsed. */
   data: Record<string, unknown> | null;
   /**
@@ -981,6 +1046,8 @@ export interface RecordEntry {
   blockedBy?: WorkLink[];
   /** For a work kind: each decision the record implements, with its state, or null when no decision has the id. */
   implements?: WorkLink[];
+  /** For a work kind with acceptance criteria (#2772): how many of the record's criteria passing evidence meets, or null when it lists none. */
+  acceptance?: WorkAcceptance | null;
 }
 
 export interface ReadRecordsOptions {
@@ -1100,6 +1167,20 @@ export function supersedesTargets(kind: Pick<RecordKind, "supersedes">, data: Re
   return ids.filter((x): x is string => typeof x === "string");
 }
 
+/**
+ * The ids a record's remediates field names (#2774), read the same way
+ * {@link supersedesTargets} reads `supersedes`.
+ */
+export function remediatesTargets(kind: Pick<RecordKind, "remediates">, data: Record<string, unknown> | null): string[] {
+  if (!kind.remediates || data === null) return [];
+  const { field, key } = kind.remediates;
+  const value = data[field];
+  if (key === undefined && typeof value === "string") return [value];
+  if (!Array.isArray(value)) return [];
+  const ids = key === undefined ? value : value.map((l) => (l !== null && typeof l === "object" ? (l as Record<string, unknown>)[key] : undefined));
+  return ids.filter((x): x is string => typeof x === "string");
+}
+
 /** The stem of a file name: the name up to its first `.`, the hash a content-addressed record's name claims (ws-053). */
 function nameStem(path: string): string {
   const name = path.slice(path.lastIndexOf("/") + 1);
@@ -1135,6 +1216,7 @@ export async function readRecords(loaded: LoadedRecordKind, options: ReadRecords
       valid: true,
       reasons: [],
       supersededBy: null,
+      remediatedBy: [],
       data: null,
       assets: [],
       warnings: [],
@@ -1254,6 +1336,30 @@ export async function readRecords(loaded: LoadedRecordKind, options: ReadRecords
     }
   }
 
+  // Remediation (#2774): a later record fixes a consequence of a closed one
+  // without replacing it. The target's status, and its supersededBy, never
+  // change; several records may remediate the same one. Unlike supersedes,
+  // this needs no approval rank: the target is closed or it isn't, and a
+  // still-open target is amended instead of remediated.
+  for (const e of entries) {
+    for (const target of remediatesTargets(kind, e.data)) {
+      const old = byId.get(target);
+      if (!old) {
+        e.reasons.push({ code: "record-remediates-unknown", message: `remediates ${target}, which no record has` });
+        continue;
+      }
+      if (old === e) continue;
+      if (old.state === null || !closed.has(old.state)) {
+        e.reasons.push({
+          code: "record-remediates-not-closed",
+          message: `remediates ${target}, which is ${old.state ?? "stateless"}, not closed; a record still open is amended instead`,
+        });
+        continue;
+      }
+      if (e.id !== null && !old.remediatedBy.includes(e.id)) old.remediatedBy.push(e.id);
+    }
+  }
+
   // A pin that still matches, at the hash a record this one supersedes
   // pinned, while the file has not changed since this record was recorded:
   // the decision moved on and the artifact did not (#2549).

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,
       },
     ]);
   });
@@ -419,7 +420,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",
@@ -431,7 +432,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",
@@ -444,15 +445,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.
@@ -514,7 +515,7 @@ 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();
     }
@@ -594,16 +595,19 @@ describe("stewards in chant workspace status --json (#2731)", () => {
         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 },
+        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, 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,
@@ -620,6 +624,8 @@ describe("stewards in chant workspace status --json (#2731)", () => {
         },
       },
     ]);
+    // #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);

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

@@ -14,6 +14,13 @@
  * - 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.
+ *   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;
@@ -24,9 +31,10 @@
 
 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";
 import { leaseRef } from "../lifecycle/lease";
 import { readBlobBySha, readRefSha } from "../lifecycle/git";
 import { resolveMemberLedger } from "../lifecycle/member-ledger";
@@ -34,6 +42,7 @@ 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. */
@@ -42,7 +51,7 @@ export const STEWARD_REASON_CODES = [
   "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 failed, so its last run is null. */
+  /** 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];
@@ -52,8 +61,48 @@ export interface StatusStewardRun {
   status: OpRunRecord["status"];
   started: string;
   ended: string;
-  /** The gate the run stopped at, for a `gated` run. */
-  gate: { name: string; since: string } | null;
+  /**
+   * 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 {
@@ -64,6 +113,8 @@ export interface StatusStewardOp {
   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;
   /**
@@ -103,6 +154,13 @@ export interface StatusSteward {
   /** 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. 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 })[];
 }
 
 export interface MemberStewards {
@@ -110,6 +168,39 @@ export interface MemberStewards {
   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"));
@@ -176,6 +267,7 @@ export async function readMemberStewards(
   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;
@@ -187,8 +279,12 @@ export async function readMemberStewards(
             status: newest.status,
             started: newest.started,
             ended: newest.ended,
-            gate: newest.gate ? { name: newest.gate.name, since: newest.gate.since } : null,
+            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({
@@ -196,11 +292,24 @@ export async function readMemberStewards(
           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) }
@@ -219,7 +328,48 @@ export async function readMemberStewards(
       }),
       lease: await readStewardLease(declaration.name, memberDir, now),
       ops,
+      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)}`,
+      });
+    }
+  }
+}