@intentius/chant 0.95.1 → 0.96.0

package/src/workspace/reason-codes.ts

@@ -150,6 +150,7 @@ export const REASONS = {
   "since-session-open": "--since names a session that is still open, so the comparison runs to the working tree.",
   // The intent graph (graph --intent, #2651): a read that fails.
   "intent-region-invalid": "The region's path, or its line range, does not exist in the tree read.",
+  "intent-record-unknown": "graph --intent --record names an id that no record of a decision kind read has.",
   // The intent graph: part of the walk that can't be read. The document is still printed.
   "intent-history-shallow": "The repository is a shallow clone, so the region's history stops at the clone's boundary.",
   "intent-plugin-failed": "A kind file's commitJoins, which joins commits to units, contracts and evidence, failed for a commit.",
@@ -174,6 +175,8 @@ export const REASONS = {
   // The forward coverage check (check --changes, #2773): findings, one per changed path.
   "change-uncovered": "A path the diff changes is covered by no current decided record and no open work item, by path or by its member.",
   "change-out-of-scope": "A record in hand for the change, such as the work item it is for or a decision that item implements, lists a path the diff changes in its out_of_scope.",
+  // The patch read (workspace patch): a read that fails.
+  "patch-path-invalid": "workspace patch --path names a path that is not relative and inside the workspace.",
   // Composite instances joined to components (graph --composites, #2662): why the list is empty or has no component.
   "composites-no-chant-member": "No member of kind chant was read, so nothing declares a composite instance or a component.",
   "composites-none-declared": "The members read declare no composite instance.",

package/src/workspace/record-decided.ts

@@ -0,0 +1,107 @@
+/**
+ * The commit that decided a record: the commit reachable from a revision that
+ * last moved the record's file into an approved state and kept it there. A
+ * record added in an approved state was decided by the commit that added it.
+ *
+ * "Approved" is `isDecided` from `work.ts`: a state the kind's `approval`
+ * ranks above 0, or, for a kind with no `approval`, one of its
+ * `closedStates`. For the decision kind that is decided, ratified and
+ * superseded, and not proposed or withdrawn. Walking the file's history
+ * newest first, the commit is the oldest one in the unbroken run of approved
+ * versions that ends at the revision: a record decided, then ratified, keeps
+ * the commit that decided it, and one withdrawn and decided again gets the
+ * second decision.
+ *
+ * The intent graph's windows open here (`intent.ts`): a commit made while a
+ * record was only proposed is not in its window. A record that is not
+ * approved at the revision has no deciding commit, and its window opens at
+ * the commit that added it, as it always did.
+ *
+ * History is read with two git processes for any number of records: one
+ * `git log` over their paths and one `git cat-file --batch` for the versions.
+ */
+
+import { execFileSync } from "node:child_process";
+import { parseRecord, type LoadedRecordKind } from "./records";
+import { isDecided } from "./work";
+
+export interface DecidedIn {
+  sha: string;
+  /** The author date, ISO 8601. */
+  date: string;
+  subject: string;
+}
+
+function tryGit(top: string, args: string[], input?: string): Buffer | undefined {
+  try {
+    return execFileSync("git", args, { cwd: top, input, stdio: [input === undefined ? "ignore" : "pipe", "pipe", "pipe"], maxBuffer: 512 * 1024 * 1024 });
+  } catch {
+    return undefined;
+  }
+}
+
+/** Each `sha:path` blob's text, or undefined when git has none. */
+function blobs(top: string, names: string[]): Map<string, string> {
+  const out = new Map<string, string>();
+  if (names.length === 0) return out;
+  const buf = tryGit(top, ["cat-file", "--batch"], `${names.join("\n")}\n`);
+  if (!buf) return out;
+  let at = 0;
+  for (const name of names) {
+    const nl = buf.indexOf(0x0a, at);
+    if (nl < 0) break;
+    const header = buf.subarray(at, nl).toString("utf-8");
+    at = nl + 1;
+    const m = header.match(/^[0-9a-f]+ (\w+) (\d+)$/);
+    if (!m) continue; // "<name> missing"
+    const size = Number(m[2]);
+    if (m[1] === "blob") out.set(name, buf.subarray(at, at + size).toString("utf-8"));
+    at += size + 1;
+  }
+  return out;
+}
+
+/**
+ * For each record path (from the repository root), the commit reachable from
+ * `rev` that decided it, or null when the record is not approved at `rev` or
+ * has no history there.
+ */
+export function decidedCommits(top: string, rev: string, paths: string[], kind: LoadedRecordKind["kind"]): Map<string, DecidedIn | null> {
+  const out = new Map<string, DecidedIn | null>(paths.map((p) => [p, null]));
+  const stateField = kind.stateField;
+  if (!stateField || paths.length === 0) return out;
+  const log = tryGit(top, ["log", "--no-renames", "--format=%x00%H%x1f%aI%x1f%s", "--name-only", rev, "--", ...paths])?.toString("utf-8");
+  if (log === undefined) return out;
+  const wanted = new Set(paths);
+  const commits = new Map<string, { date: string; subject: string }>();
+  /** Each path's commits, newest first. */
+  const history = new Map<string, string[]>();
+  for (const chunk of log.split("\0")) {
+    if (!chunk) continue;
+    const nl = chunk.indexOf("\n");
+    const [sha, date, subject] = (nl < 0 ? chunk : chunk.slice(0, nl)).split("\x1f");
+    commits.set(sha, { date, subject });
+    for (const f of (nl < 0 ? "" : chunk.slice(nl + 1)).split("\n")) {
+      if (!wanted.has(f)) continue;
+      const list = history.get(f) ?? [];
+      list.push(sha);
+      history.set(f, list);
+    }
+  }
+  const texts = blobs(
+    top,
+    [...history].flatMap(([p, shas]) => shas.map((s) => `${s}:${p}`)),
+  );
+  for (const [path, shas] of history) {
+    let decided: string | null = null;
+    for (const sha of shas) {
+      const text = texts.get(`${sha}:${path}`);
+      const fm = text === undefined ? undefined : parseRecord(kind.format, text);
+      const state = fm?.ok ? fm.value[stateField] : undefined;
+      if (typeof state !== "string" || !isDecided(kind, state)) break;
+      decided = sha;
+    }
+    if (decided) out.set(path, { sha: decided, ...commits.get(decided)! });
+  }
+  return out;
+}

package/src/workspace/records-cli.ts

@@ -24,6 +24,7 @@ import { formatError } from "../cli/format";
 import type { CommandContext } from "../cli/registry";
 import { findWorkspaceRoot } from "../project-root";
 import { fileDigest, isWorkspacePath } from "./record-assets";
+import { decidedCommits, type DecidedIn } from "./record-decided";
 import { gitRevisionSource, gitRoot, resolveRevision, workingTreeSource, type RecordSource } from "./record-source";
 import { declaredRecordKinds, readDeclaration, WorkspaceReadError, type RecordKindDeclaration } from "./declaration";
 import { declaredKindFile } from "./declared-kinds";
@@ -100,6 +101,13 @@ export type RecordView = RecordEntry & {
    * lease is live state and not part of a revision.
    */
   lease?: { holder: string; token: string; acquiredAt: string; expiresAt: string } | null;
+  /**
+   * For a kind with approval ranks that is not a work kind, read in git: the
+   * commit that last moved the record into an approved state and kept it
+   * there, or null when the record is not approved in the history read
+   * (`record-decided.ts`). The intent graph's windows open at this commit.
+   */
+  decidedIn?: DecidedIn | null;
 };
 
 /** The role in the trust policy whose holders' verdicts the quorum does not count (#2671). */
@@ -327,6 +335,10 @@ export async function queryRecords(query: RecordsQuery): Promise<RecordsDocument
       ...(quorumOptions ? { quorum: computeQuorum(loaded.kind, r, quorumOptions) } : {}),
       ...(seals ? authorSeal(loaded.kind, r, policy, seals.checkRecordSeal) : {}),
     }));
+    if (loaded.kind.approval && !loaded.kind.work && top) {
+      const decided = decidedCommits(top, at ?? "HEAD", records.map((r) => r.path), loaded.kind);
+      for (const r of records) r.decidedIn = decided.get(r.path) ?? null;
+    }
     if (loaded.kind.work && query.workGaps !== false && top) await raiseWorkGaps(loaded, records, { root, workspaceRoot, at: query.at });
     if (loaded.kind.work && at === null && top) {
       const { activeWorkLeases } = await import("../lifecycle/work-lease");

package/src/workspace/records.schema.json

@@ -5,6 +5,17 @@
   "description": "What `chant workspace records --json` prints, version 1 of the read contract for records (#2536). This is the first-test slice (#2546): records are unsealed and there is no workspace declaration yet. Readers ignore fields they do not know; a field is only ever added within a version. The reason and error codes are closed lists: a new code is a new contract version. Contract version 1 is written by chant 0.81.0 and newer; a reader that needs it refuses output whose `contract` it doesn't know. Every code is in the one closed list of `reason-codes.ts`.",
   "oneOf": [{ "$ref": "#/$defs/result" }, { "$ref": "#/$defs/failure" }, { "$ref": "#/$defs/set" }],
   "$defs": {
+    "decidedIn": {
+      "description": "The commit that last moved the record into an approved state and kept it there: a state the kind's approval ranks above 0, or one of its closedStates when it has no approval. Read from the history of the record's file reachable from the revision read, or HEAD in the working tree. A record added approved was decided by the commit that added it. Null when the record is not approved in that history.",
+      "type": ["object", "null"],
+      "required": ["sha", "date", "subject"],
+      "additionalProperties": false,
+      "properties": {
+        "sha": { "type": "string", "pattern": "^[0-9a-f]{40,64}$" },
+        "date": { "type": "string", "description": "The author date, ISO 8601." },
+        "subject": { "type": "string" }
+      }
+    },
     "set": {
       "description": "Added in contract 1 by #2680. What records 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 read and listed.",
       "type": "object",
@@ -132,6 +143,10 @@
           "type": "array",
           "items": { "type": "string" }
         },
+        "decidedIn": {
+          "description": "Added in contract 1. Present for a kind with approval ranks that is not a work kind, read in a git repository.",
+          "$ref": "#/$defs/decidedIn"
+        },
         "data": {
           "type": ["object", "null"],
           "description": "The record's structured core as JSON: the front matter, or for a kind of format json the whole file (#2664). It follows the kind's schema when valid is true. Null when it could not be parsed."

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

@@ -31,6 +31,9 @@ import { appendRunRecord } from "../lifecycle/run-ledger";
 import { acquireStewardLease } from "../op/operator";
 import { stewardWorkHolder } from "../op/work-lease-run";
 import { claimWorkLease } from "../lifecycle/work-lease";
+import { runOpLocally } from "../op/local-executor";
+import { shellCmd } from "../op/activities/shell";
+import type { OpConfig } from "../op/types";
 
 const REPO = join(import.meta.dirname, "..", "..", "..", "..");
 
@@ -623,19 +626,21 @@ 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, point: 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, phases: [] },
+        inFlight: null,
         // #2778: not a ConvergeOp (no Converge label), so no tick.
         lastTick: null,
         changesCheckout: false,
         workLease: null,
         beside: null,
       },
-      { name: "box-release", schedule: null, env: "local", lastRun: null, lastTick: null, changesCheckout: false, workLease: null, beside: null },
+      { name: "box-release", schedule: null, env: "local", lastRun: null, inFlight: null, lastTick: null, changesCheckout: false, workLease: null, beside: null },
       {
         name: "box-dispatch",
         schedule: { cron: "*/5 * * * *", overlap: "skip" },
         env: "local",
         lastRun: null,
+        inFlight: null,
         lastTick: null,
         changesCheckout: true,
         workLease: {
@@ -663,6 +668,75 @@ describe("stewards in chant workspace status --json (#2731)", () => {
     expect(k3d.members[0].stewards[0].lease!.live).toBe(false);
   });
 
+  test("an Op's run in flight: its phase, step, finished phases and activity, then its phases' times once it settles", async () => {
+    const root = stewarded();
+    const box = join(root, "box");
+    let during: StatusDocument | undefined;
+    const release: OpConfig = {
+      name: "box-release",
+      overview: "release",
+      phases: [
+        { name: "Prep", steps: [{ kind: "activity", fn: "shellCmd", args: { cmd: 'echo "Edit app/a.js" >> "$CHANT_RUN_ACTIVITY"; printf \'{"at":"2026-09-25T10:00:00.000Z","text":"Bash npm test"}\\n\' >> "$CHANT_RUN_ACTIVITY"' } }] },
+        {
+          name: "Build",
+          steps: [
+            {
+              kind: "activity",
+              fn: "probe",
+              id: "build",
+              args: {},
+            },
+          ],
+        },
+      ],
+    } as unknown as OpConfig;
+    const activities = new Map<string, (args: Record<string, unknown>, signal?: AbortSignal) => Promise<unknown>>([
+      ["shellCmd", (args, signal) => shellCmd(args as never, signal)],
+      [
+        "probe",
+        async () => {
+          during = await workspaceStatus({ cwd: root, env: "minimal" });
+          return {};
+        },
+      ],
+    ]);
+    const run = await runOpLocally(release, activities as never, {}, undefined, { runId: "run-live-1", ledger: { cwd: box }, cwd: box, steward: "box-steward" });
+    expect(run.status).toBe("ok");
+
+    const inRun = result(during!);
+    expectValid(inRun);
+    const flying = inRun.members[0].stewards[0].ops.find((o) => o.name === "box-release")!;
+    expect(flying.lastRun).toBeNull();
+    expect(flying.inFlight).toMatchObject({
+      id: "run-live-1",
+      steward: "box-steward",
+      item: null,
+      phase: { name: "Build" },
+      step: { name: "build", fn: "probe" },
+      phases: [{ name: "Prep", status: "ok", durationMs: expect.any(Number) }],
+      activity: {
+        total: 2,
+        lines: [
+          { seq: 1, at: null, text: "Edit app/a.js" },
+          { seq: 2, at: "2026-09-25T10:00:00.000Z", text: "Bash npm test" },
+        ],
+      },
+    });
+
+    const after = result(await workspaceStatus({ cwd: root, env: "minimal" }));
+    expectValid(after);
+    const settled = after.members[0].stewards[0].ops.find((o) => o.name === "box-release")!;
+    expect(settled.inFlight).toBeNull();
+    expect(settled.lastRun).toMatchObject({
+      id: "run-live-1",
+      status: "ok",
+      phases: [
+        { name: "Prep", status: "ok", durationMs: expect.any(Number) },
+        { name: "Build", status: "ok", durationMs: expect.any(Number) },
+      ],
+    });
+  });
+
   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");

package/src/workspace/status-stewards.ts

@@ -14,13 +14,25 @@
  * - 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`;
+ * - an Op's `inFlight` is the run of it in flight now, from the record a
+ *   run keeps beside the checkout's git directory while it runs
+ *   (`../op/run-live.ts`): its phase and step, the phases it has finished and
+ *   its newest activity lines. Null once the run's ledger record is written,
+ *   or when the process that wrote it is gone;
  * - `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;
+ *   each Op whose newest run is the steward's own and stopped on a question
+ *   that is still open. The question's state is read now, the way `points`
+ *   reads it (`readQuestionStates`), not copied from the run ledger, which
+ *   keeps the state the run stopped with. A question answered since, or
+ *   whose record is gone, is not waited on; nor is one whose Op has a newer
+ *   run in flight that has not written its record yet: the Op's lease or one
+ *   of its work leases was taken after the waiting run ended
+ *   (`newerRunInFlight`). When the questions can't be read, the ledger's
+ *   state stands, as the operator's does. 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;
@@ -46,6 +58,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 { readInFlightRun } from "../op/run-live";
 import { approveCommand } from "./status-gates";
 import type { ReasonCode } from "./reason-codes";
 
@@ -72,17 +85,53 @@ export interface StatusStewardRun {
    * 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). */
+  /**
+   * The decision point the run stopped on, for a `waiting` run (#2749). Its
+   * state is the question's now, `answered` once a person has answered it.
+   */
   point: StatusStewardWait | null;
+  /** Each phase in execution order, with its wall-clock time, or the sum of its steps' for a record that kept none. */
+  phases: StatusStewardPhase[];
+}
+
+/** A phase of a run: its verdict and how long it took. */
+export interface StatusStewardPhase {
+  name: string;
+  status: "ok" | "fail" | "skipped";
+  durationMs: number;
+}
+
+/**
+ * The run of an Op in flight now (../op/run-live.ts): what it is doing while
+ * its ledger record is not yet written.
+ */
+export interface StatusStewardInFlight {
+  id: string;
+  started: string;
+  /** When the run last changed its record. */
+  updated: string;
+  steward: string | null;
+  /** The work item the run's lease holds, once it is claimed. */
+  item: string | null;
+  phase: { name: string; started: string } | null;
+  step: { name: string; fn: string; started: string } | null;
+  /** The phases it has finished, in order. */
+  phases: StatusStewardPhase[];
+  /** The newest activity lines its steps reported; `total` counts every line of the run. */
+  activity: { total: number; lines: { seq: number; at: string | null; text: string }[] };
 }
 
-/** An open decision point a steward's run stopped on (#2749), as the run ledger records it. */
+/** A decision point a steward's run stopped on (#2749). */
 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";
+  /**
+   * The question's state now, as `points` reads it. The state the run
+   * stopped with when the questions can't be read or its record is gone.
+   * Never `answered` in a steward's `waiting`.
+   */
+  state: "escalated" | "proposed" | "answered";
   path: string;
   subject: string | null;
   since: string;
@@ -117,6 +166,8 @@ export interface StatusStewardOp {
   env: string;
   /** The newest run in its run ledger, or null when it has none. */
   lastRun: StatusStewardRun | null;
+  /** The run in flight now, or null when none is. */
+  inFlight: StatusStewardInFlight | 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). */
@@ -175,7 +226,8 @@ export interface StatusSteward {
   ops: StatusStewardOp[];
   /**
    * The open decision points the steward waits on (#2749): each Op whose
-   * newest run is the steward's own and stopped on a question. Its declared
+   * newest run is the steward's own and stopped on a question still open,
+   * with no newer run of the Op in flight. Its declared
    * Ops come first, in `ops` order, then any other Op of the member whose
    * newest run names the steward, by Op name.
    */
@@ -187,17 +239,62 @@ export interface MemberStewards {
   reasons: { code: StewardReasonCode; message: string }[];
 }
 
-function waitOf(p: NonNullable<OpRunRecord["point"]>): StatusStewardWait {
+/** Every question's state in the workspace by id, or null when they can't all be read. */
+export type ReadQuestionStates = (cwd: string) => Promise<Map<string, string> | null>;
+
+async function readQuestionStates(cwd: string): Promise<Map<string, string> | null> {
+  const { readQuestionStates: read } = await import("./points-cli");
+  return read(cwd);
+}
+
+/**
+ * The point a run stopped on, with the question's state now and whether it
+ * is still open. A question whose record is gone is not open, as the
+ * operator reads it (`stewardWaits` in `../op/operator.ts`); when the
+ * questions can't be read, the run ledger's state stands and it is open.
+ */
+function pointOf(p: NonNullable<OpRunRecord["point"]>, states: Map<string, string> | null): { wait: StatusStewardWait; open: boolean } {
+  const recorded = p.state === "proposed" ? "proposed" : "escalated";
+  const now = states?.get(p.id);
+  const state = now === "escalated" || now === "proposed" || now === "answered" ? now : recorded;
   return {
-    id: p.id,
-    point: p.point,
-    state: p.state === "proposed" ? "proposed" : "escalated",
-    path: p.path,
-    subject: p.subject ?? null,
-    since: p.since,
+    wait: { id: p.id, point: p.point, state, path: p.path, subject: p.subject ?? null, since: p.since },
+    open: states === null || (now !== undefined && now !== "answered"),
   };
 }
 
+/**
+ * Whether a newer run of the Op is in flight than the one that ended at
+ * `ended`: the Op's own lease is live, or one of its work leases is active,
+ * and was taken after that run ended. A run writes its record when it ends,
+ * so until then the ledger's newest record is the older run's.
+ */
+function newerRunInFlight(ended: string, lease: StatusStewardLease | null, held: StatusStewardWorkLease[]): boolean {
+  const after = (at: string) => Date.parse(at) >= Date.parse(ended);
+  return (lease?.live === true && after(lease.acquiredAt)) || held.some((l) => l.state === "active" && after(l.acquiredAt));
+}
+
+/** The Op's run in flight, unless its ledger record is already the newest. Never throws. */
+async function inFlightOf(memberDir: string, env: string, op: string, lastRunId: string | null): Promise<StatusStewardInFlight | null> {
+  try {
+    const run = await readInFlightRun(memberDir, env, op);
+    if (!run || run.id === lastRunId) return null;
+    return {
+      id: run.id,
+      started: run.started,
+      updated: run.updated,
+      steward: run.steward,
+      item: run.item,
+      phase: run.phase,
+      step: run.step,
+      phases: run.phases.map((p) => ({ name: p.name, status: p.status, durationMs: p.durationMs })),
+      activity: run.activity,
+    };
+  } catch {
+    return null;
+  }
+}
+
 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) };
@@ -281,8 +378,12 @@ export async function readMemberStewards(
   now: string,
   kind = "chant",
   box: { capabilities: { name: string; broker: string | null }[] } | null = null,
+  deps: { readQuestions?: ReadQuestionStates } = {},
 ): Promise<MemberStewards> {
   const reasons: MemberStewards["reasons"] = [];
+  // Read once per member, and only when a run stopped on a question.
+  let states: Promise<Map<string, string> | null> | undefined;
+  const questionStates = () => (states ??= (deps.readQuestions ?? readQuestionStates)(memberDir));
   if (kind !== "chant" || !isChantProject(memberDir)) return { stewards: [], reasons };
 
   let discovered: Awaited<ReturnType<typeof discoverStewards>>;
@@ -302,20 +403,35 @@ export async function readMemberStewards(
     const waiting: StatusSteward["waiting"] = [];
     for (const op of declaration.ops) {
       const opEnv = runEnvOf(op);
+      const workLease = op.workLease
+        ? { kind: op.workLease.kind ?? null, held: await readHeldWorkLeases(declaration.name, op, memberDir, now) }
+        : null;
+      const beside = await besideOf(declaration, op.name, memberDir, now);
       let lastRun: StatusStewardRun | null = null;
       try {
         const newest = (await readRunLedger(opEnv, op.name, { cwd: memberDir })).records.at(-1);
         if (newest) {
+          const point = newest.point ? pointOf(newest.point, await questionStates()) : null;
           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,
+            point: point?.wait ?? null,
+            phases: newest.phases.map((p) => ({
+              name: p.name,
+              status: p.status,
+              durationMs: p.durationMs ?? p.steps.reduce((sum, st) => sum + st.durationMs, 0),
+            })),
           };
-          if (newest.status === "waiting" && lastRun.point && newest.steward === declaration.name) {
-            waiting.push({ op: op.name, run: newest.id, ...lastRun.point });
+          if (
+            newest.status === "waiting" &&
+            point?.open &&
+            newest.steward === declaration.name &&
+            !newerRunInFlight(newest.ended, beside?.lease ?? null, workLease?.held ?? [])
+          ) {
+            waiting.push({ op: op.name, run: newest.id, ...point.wait });
           }
         }
       } catch (err) {
@@ -324,6 +440,7 @@ export async function readMemberStewards(
           message: `${opEnv}/runs__${op.name}.jsonl: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`,
         });
       }
+      const inFlight = await inFlightOf(memberDir, opEnv, op.name, lastRun?.id ?? null);
       let lastTick: StatusStewardTick | null = null;
       if (op.labels?.Converge === "true") {
         try {
@@ -341,12 +458,11 @@ export async function readMemberStewards(
         schedule: op.schedule ? { cron: op.schedule.cron, overlap: "skip" } : null,
         env: opEnv,
         lastRun,
+        inFlight,
         lastTick,
         changesCheckout: op.changesCheckout === true,
-        workLease: op.workLease
-          ? { kind: op.workLease.kind ?? null, held: await readHeldWorkLeases(declaration.name, op, memberDir, now) }
-          : null,
-        beside: await besideOf(declaration, op.name, memberDir, now),
+        workLease,
+        beside,
       });
     }
     stewards.push({
@@ -364,7 +480,7 @@ export async function readMemberStewards(
       waiting,
     });
   }
-  if (stewards.length > 0) await addUndeclaredWaits(memberDir, stewards, found, reasons);
+  if (stewards.length > 0) await addUndeclaredWaits(memberDir, stewards, found, reasons, now, questionStates);
   return { stewards, reasons };
 }
 
@@ -381,6 +497,8 @@ async function addUndeclaredWaits(
   stewards: StatusSteward[],
   found: Awaited<ReturnType<typeof discoverStewards>>["stewards"],
   reasons: MemberStewards["reasons"],
+  now: string,
+  questionStates: () => Promise<Map<string, string> | null>,
 ): Promise<void> {
   const declared = new Set([...found.values()].flatMap(({ declaration }) => declaration.ops.map((op) => op.name)));
   let ops: OpConfig[];
@@ -396,7 +514,11 @@ async function addUndeclaredWaits(
       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) });
+        const point = pointOf(newest.point, await questionStates());
+        const held = op.workLease ? await readHeldWorkLeases(steward.name, op, memberDir, now) : [];
+        if (point.open && !newerRunInFlight(newest.ended, await readLeaseRef(op.name, memberDir, now), held)) {
+          steward.waiting.push({ op: op.name, run: newest.id, ...point.wait });
+        }
       }
     } catch (err) {
       reasons.push({