omp-conductor 0.19.7 → 0.20.0

package/src/status-render.ts

@@ -19,7 +19,13 @@
 
 import { formatZonedMinute } from "./availability.ts";
 import { spendTelemetryDetail, type SpendTelemetryVerdict } from "./spend-telemetry.ts";
-import type { DaemonStop, GroomingRecord, InstallSurfaceObservation, RunRecord } from "./types.ts";
+import type {
+  DaemonStop,
+  GroomingRecord,
+  InstallSurfaceObservation,
+  ReviewCorrectionRound,
+  RunRecord,
+} from "./types.ts";
 import { settlementFlagSummary } from "./diff-flags.ts";
 import type { CodeGraphHealth } from "./graph-health.ts";
 import { formatDigestBacklog, formatOpenReports } from "./reports.ts";
@@ -28,6 +34,12 @@ import { planUsageLine } from "./usage.ts";
 import { HEALTH_TIMEOUT_MS, SYSTEMD_UNIT, type UnitOwnership } from "./lifecycle.ts";
 import type { WorkerPauseView } from "./fleet.ts";
 import { formatRss, rssBytesFromHealthz } from "./host.ts";
+// One constant, two readers: the durable in-flight to-spec launch marker
+// (#777) is written by the daemon's grooming launcher and read here, so the
+// reason string is imported rather than hand-copied — the copy that used to
+// live in this file was a second source of truth for a row shape nobody
+// audits.
+import { TO_SPEC_IN_FLIGHT_REASON } from "./groom.ts";
 import {
   formatBaseHealth,
   formatDispatchSummary,
@@ -252,10 +264,6 @@ const REFUSED_GROOMING_REASONS: Record<string, true> = {
   "stale-source": true,
 };
 
-/** The durable in-flight launch marker (#777) — a batch is running right now.
- *  Mirrors `TO_SPEC_IN_FLIGHT_REASON` in `orchestrator-tick.ts`. */
-const GROOMING_IN_FLIGHT_REASON = "in-flight";
-
 /**
  * One project's durable grooming state as status lines, or nothing when there
  * is nothing to report (#809).
@@ -332,7 +340,7 @@ export function formatGroomingStatus(input: GroomingStatusInput): string | undef
       row.verdict === "blocked" &&
       MECHANICAL_GROOMING_REASONS[row.reason] !== true &&
       REFUSED_GROOMING_REASONS[row.reason] !== true &&
-      row.reason !== GROOMING_IN_FLIGHT_REASON,
+      row.reason !== TO_SPEC_IN_FLIGHT_REASON,
   );
   const mechanical = records.filter(
     (row) => row.verdict === "blocked" && MECHANICAL_GROOMING_REASONS[row.reason] === true,
@@ -341,7 +349,7 @@ export function formatGroomingStatus(input: GroomingStatusInput): string | undef
     (row) => row.verdict === "blocked" && REFUSED_GROOMING_REASONS[row.reason] === true,
   );
   const inFlight = records.filter(
-    (row) => row.verdict === "blocked" && row.reason === GROOMING_IN_FLIGHT_REASON,
+    (row) => row.verdict === "blocked" && row.reason === TO_SPEC_IN_FLIGHT_REASON,
   );
   const awaiting = Math.max(0, routed - records.length);
   const lines: string[] = [];
@@ -662,6 +670,143 @@ function formatSiblingLive(siblings: { project: string; live: number }[]): strin
   return `shared    daemon also serves ${siblings.length} other project(s): ${counts}`;
 }
 
+// review-correction provenance (#1048)
+// ---------------------------------------------------------------------------
+
+/**
+ * How many rounds of one run's correction chain print. A review ceiling is low
+ * single digits, so this bounds a pathological row rather than routinely
+ * truncating — and the last line printed says how many rounds it stands for,
+ * because a silently shortened chain is how a repeating pattern hides.
+ */
+const CORRECTION_CHAIN_LINES = 3;
+
+/**
+ * A session lineage as a status row carries it. A ref is a session file path,
+ * and the leading directories are the same for every session in a fleet: the
+ * identifying half is the run and the file, so the line prints those and marks
+ * what it dropped with `…/` — the same honesty `firstLine` uses above, and the
+ * full ref stays in the durable row this line is projected from. Two lineages
+ * plus two models on one row is already at the width `omp-conductor status`
+ * can be read at; a full 60-character path twice is not.
+ *
+ * An absent ref reads `unrecorded`: rows written before #1045 know nothing
+ * about their own launch, and saying so is the only honest projection of one.
+ */
+function correctionRef(ref: string | undefined): string {
+  const value = ref?.trim() ?? "";
+  if (value === "") return "unrecorded";
+  const segments = value.split("/").filter((segment) => segment !== "");
+  const tail = segments.slice(-2).join("/");
+  return firstLine(segments.length > 2 ? `…/${tail}` : value, 60);
+}
+
+/**
+ * The models of one correction round: what the daemon asked for and what the
+ * harness actually resolved. Those two differing is the whole finding — in
+ * #1035 the fleet had already switched worker models while every correction
+ * round replayed the exhausted session under the old one — so the arrow form is
+ * kept whenever they differ and collapsed only when they agree.
+ *
+ * A resumed round is worded differently on purpose. `resolvedModel` is written
+ * only by `Store.recordReviewCorrectionSession`, which refuses a round decided
+ * `resume-original` (a resumed round *is* its origin session), so a resume
+ * durably has a request and no resolution. Rendering that through the fresh
+ * wording — `requested X → ran unrecorded` — would read as a launch that lost
+ * its model, when what actually happened is that the daemon asked the harness
+ * to continue an existing transcript on X and nothing re-recorded the
+ * resolution.
+ *
+ * Every branch reads the round's OWN recorded values. The project config is
+ * deliberately not a parameter: rendering it would make a round dispatched
+ * under a since-replaced model report the replacement, which is exactly the
+ * silent fake #1048 names.
+ */
+function correctionModels(round: ReviewCorrectionRound): string {
+  const { requestedModel: requested, resolvedModel: resolved } = round;
+  if (round.launchMode === "resume-original") {
+    if (resolved !== undefined)
+      return requested === undefined || requested === resolved
+        ? `ran ${resolved}`
+        : `ran ${resolved} (asked ${requested})`;
+    if (requested !== undefined)
+      return round.state === "pending"
+        ? `to continue on ${requested}, not launched yet`
+        : `asked to continue on ${requested}`;
+    return "model unrecorded";
+  }
+  if (requested !== undefined && resolved !== undefined)
+    return requested === resolved ? `model ${resolved} as requested` : `requested ${requested} → ran ${resolved}`;
+  if (requested !== undefined)
+    return round.state === "pending"
+      ? `requested ${requested}, not launched yet`
+      : `requested ${requested} → ran unrecorded`;
+  // A resolution with no request: the harness named what it ran, the decision
+  // row that asked for it predates #1045. Still not a guess in either direction.
+  if (resolved !== undefined) return `ran ${resolved} (request unrecorded)`;
+  return "model unrecorded";
+}
+
+/**
+ * One run's review-correction chain as status lines (#1048), newest round
+ * first, six-space indented like every other run annotation.
+ *
+ * Before this, a correction round rendered as `review-revision N` and a
+ * dispatch age: an operator could not tell whether conductor had resumed the
+ * diagnosed implementation transcript or launched a fresh correction, nor under
+ * which model — which is why #1035 read as idle while an exhausted session
+ * consumed every round the fleet's new model was never asked to run.
+ *
+ * The per-line `current`/`prior` marker is where the runtime/history split
+ * lives: `current` is the newest round that has not settled, the one whose
+ * elapsed time and cumulative turns the run line above reports; every other
+ * line is chain history and carries no runtime at all. That is deliberately a
+ * property of each line rather than a header, because a header explaining how
+ * to read the following lines is a line nobody reads.
+ *
+ * Exported so the projection can be asserted directly on hand-built rounds:
+ * the interesting cases (a differing requested/resolved pair, a legacy row with
+ * no provenance) are properties of one row, not of a whole fleet.
+ */
+export function formatReviewCorrections(rounds: readonly ReviewCorrectionRound[]): string[] {
+  if (rounds.length === 0) return [];
+  const newestFirst = [...rounds].sort((a, b) => b.round - a.round);
+  const shown = newestFirst.slice(0, CORRECTION_CHAIN_LINES);
+  const hidden = newestFirst.length - shown.length;
+  return shown.map((round, index) => {
+    const current = index === 0 && round.state !== "settled";
+    // The round's lifecycle as one phrase. `queued` covers both a round nobody
+    // has dispatched yet and one a restart returned to the queue — durably they
+    // are the same row, and status must not invent a distinction the store does
+    // not keep.
+    const state =
+      round.state === "settled"
+        ? `settled ${round.outcome ?? "outcome unrecorded"}`
+        : round.state === "pending"
+          ? "queued"
+          : "dispatched";
+    const provenance =
+      round.launchMode === undefined
+        ? // A row written before #1045 recorded no launch decision. Status says
+          // so and stops: the alternative — reading today's configuration back
+          // as though it had been this round's — is a fabricated provenance,
+          // and an operator auditing #1035 would have believed it.
+          "provenance unknown (pre-#1045 round)"
+        : round.launchMode === "resume-original"
+          ? // A resume continues one lineage, so there is one session to name:
+            // the implementation transcript the review diagnosed.
+            `resume-original  resumed session ${correctionRef(round.originSessionRef)}  ${correctionModels(round)}`
+          : // A fresh correction has two: the transcript that was reviewed, and
+            // the new session doing the correcting. Naming only one of them is
+            // how "fresh" became indistinguishable from "resumed".
+            `fresh-correction  new session ${correctionRef(round.correctionSessionRef)} (diagnosed ${correctionRef(
+              round.originSessionRef,
+            )})  ${correctionModels(round)}`;
+    const tail = index === shown.length - 1 && hidden > 0 ? `  (+${hidden} earlier round(s))` : "";
+    return `      correction round ${round.round} ${current ? "current" : "prior"} (${state})  ${provenance}${tail}`;
+  });
+}
+
 
 function formatProjectBody(
   s: StatusSnapshot,
@@ -867,6 +1012,12 @@ function formatProjectBody(
               : "failed at this head"
         } — unresolved findings; push a corrected head, or record a conductor_pr_review_clear for this exact head, before merge`,
       );
+    // The correction chain (#1048), rendered from the same annotation helper as
+    // the merge blocker above so it reaches BOTH surfaces that show a run: the
+    // live lease and the preserved artifact. A round whose worker has finished
+    // leaves the lease list, and that is precisely when an operator asks what
+    // the last correction actually did.
+    out.push(...formatReviewCorrections(s.reviewCorrections?.[r.id] ?? []));
     return out;
   };
   if (s.activeRuns.length === 0) {