catherd-cli 1.4.0 → 2.0.0-beta.20261022113309

package/src/services/milestones.ts

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { CatherdError } from "../domain/errors.ts";
 import type { RunRecord } from "../domain/record.ts";
-import { git } from "../infra/git.ts";
+import { commitExists, git } from "../infra/git.ts";
 import { nonBlankLines } from "../infra/store.ts";
 import { listDispatches } from "./dispatches.ts";
 import { readAgentRuns, readRecords, readRoutes, type Run, runPaths } from "./run-store.ts";
@@ -50,27 +50,99 @@ export interface MilestoneReviewer {
   record: RunRecord | null;
 }
 
-/**
- * The milestone's latest passing reviewer since its lanes started: a dispatch named reviewer-<m>…, status
- * ok; or a record_agent_run row with role reviewer and the same name, status ok. Null when there is none.
- */
-export function milestoneReviewer(
+/** Every reviewer attempt of the milestone since its lanes started that ended ok, oldest first, partial or not. */
+function reviewerAttempts(
   run: Run,
   m: string,
-  start = milestoneStart(run, m),
-): MilestoneReviewer | null {
-  const found: MilestoneReviewer[] = [
+  start: string | null,
+): (MilestoneReviewer & { partial: boolean })[] {
+  return [
     ...readRecords(run)
       .records.filter((r) => reviewsMilestone(r.name, m) && r.status === "ok" && since(r.endedAt, start))
-      .map((r) => ({ name: r.name, at: r.endedAt, record: r })),
+      .map((r) => ({ name: r.name, at: r.endedAt, record: r, partial: r.replyStatus === "partial" })),
     ...readAgentRuns(run)
       .filter(
         (a) =>
           a.role === "reviewer" && reviewsMilestone(a.name, m) && a.status === "ok" && since(a.at, start),
       )
-      .map((a) => ({ name: a.name, at: a.at, record: null })),
-  ];
-  return found.sort((a, b) => Date.parse(a.at) - Date.parse(b.at)).at(-1) ?? null;
+      .map((a) => ({ name: a.name, at: a.at, record: null, partial: a.replyStatus === "partial" })),
+  ].sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+}
+
+/**
+ * The milestone's latest passing reviewer since its lanes started: a dispatch named reviewer-<m>…, status
+ * ok; or a record_agent_run row with role reviewer and the same name, status ok. A reply of STATUS: partial
+ * read only part of the diff and is not the milestone's review (plan 23). Null when there is none.
+ */
+export function milestoneReviewer(
+  run: Run,
+  m: string,
+  start = milestoneStart(run, m),
+): MilestoneReviewer | null {
+  const full = reviewerAttempts(run, m, start).filter((a) => !a.partial);
+  const last = full.at(-1);
+  return last ? { name: last.name, at: last.at, record: last.record } : null;
+}
+
+/** Plan 23: the milestone's latest reviewer that stopped at STATUS: partial, when no full review stands; else null. */
+export function partialReviewer(
+  run: Run,
+  m: string,
+  start = milestoneStart(run, m),
+): MilestoneReviewer | null {
+  if (milestoneReviewer(run, m, start)) return null;
+  const last = reviewerAttempts(run, m, start)
+    .filter((a) => a.partial)
+    .at(-1);
+  return last ? { name: last.name, at: last.at, record: last.record } : null;
+}
+
+/** Plan 28: the milestone's full reviewer passes since its lanes started (a partial pass is not a round). */
+export const reviewRounds = (run: Run, m: string): number =>
+  reviewerAttempts(run, m, milestoneStart(run, m)).filter((a) => !a.partial).length;
+
+export const FINDING = /^\s*(?:[-*]\s*)?(BLOCKER|BUG|NIT)\b/;
+
+/** A reviewer reply's findings by severity; null when there is no reply to read. */
+export function countFindings(run: Run, r: RunRecord): { BLOCKER: number; BUG: number; NIT: number } | null {
+  const file = join(run.dir, r.replyPath);
+  if (!r.replyPath || !existsSync(file)) return null;
+  const n = { BLOCKER: 0, BUG: 0, NIT: 0 };
+  for (const line of readFileSync(file, "utf8").split("\n")) {
+    const k = FINDING.exec(line)?.[1] as keyof typeof n | undefined;
+    if (k) n[k]++;
+  }
+  return n;
+}
+
+/** The roles a fix round runs as. */
+const FIX_ROLES = new Set(["worker", "writer", "artist"]);
+
+/**
+ * Plan 23: the milestone reviewer's BLOCKER and BUG lines while no fix round has ended since (a worker,
+ * writer or artist of the milestone, ended ok after the review); null when there are none, or for a native
+ * reviewer, whose reply catherd does not keep.
+ */
+export function openFindings(
+  run: Run,
+  m: string,
+  start = milestoneStart(run, m),
+): { name: string; blocker: number; bug: number } | null {
+  const reviewer = milestoneReviewer(run, m, start);
+  if (!reviewer?.record) return null;
+  const n = countFindings(run, reviewer.record);
+  if (!n || n.BLOCKER + n.BUG === 0) return null;
+  const after = (at: string) => Date.parse(at) > Date.parse(reviewer.at);
+  const ofM = (name: string, lane: string | null | undefined) =>
+    inMilestone(lane, m) || namesMilestone(name, m);
+  const fixed =
+    readRecords(run).records.some(
+      (r) => FIX_ROLES.has(r.role) && r.status === "ok" && ofM(r.name, r.lane) && after(r.endedAt),
+    ) ||
+    readAgentRuns(run).some(
+      (a) => FIX_ROLES.has(a.role) && a.status === "ok" && ofM(a.name, a.lane) && after(a.at),
+    );
+  return fixed ? null : { name: reviewer.name, blocker: n.BLOCKER, bug: n.BUG };
 }
 
 /** A reviewer record for the milestone since its lanes started (see milestoneReviewer). */
@@ -80,6 +152,15 @@ export const reviewerPassed = (run: Run, m: string, start = milestoneStart(run,
 /** The verifier's contract puts `VERDICT: PASS` or `VERDICT: FAIL` on the reply's first line (role-prompts.ts). */
 const VERDICT_PASS = /^VERDICT: PASS\b/;
 
+/**
+ * Plan 23: `VERDICT: BLOCKED: environment — <the probe that proves it>`, a verdict on the machine, not on the
+ * work. Its probe, or null when `line` is no such verdict ("" when it names none).
+ */
+export function blockedByEnvironment(line: string | null | undefined): string | null {
+  const m = /^VERDICT:\s*BLOCKED:\s*environment\b\s*(?:—|–|-|:)?\s*(.*)$/i.exec(line?.trim() ?? "");
+  return m ? (m[1] ?? "").trim() : null;
+}
+
 /** A headless verifier's reply: its first non-blank line, trimmed; null when there is no reply to read. */
 export function replyVerdict(run: Run, r: RunRecord): string | null {
   const file = join(run.dir, r.replyPath);
@@ -106,11 +187,19 @@ export interface MilestoneVerifier {
   passed: boolean;
   /** what the attempt said: a native row's status, or a headless reply's first non-blank line ("no reply") */
   verdict: string;
+  /** plan 23: the probe of a `VERDICT: BLOCKED: environment` attempt ("" when it named none); null otherwise */
+  blocked: string | null;
+  /** plan 30b: the commit the verdict says it checked (a headless reply's `HEAD:` line); null for a native row */
+  head: string | null;
 }
 
+/** The one name a milestone's verifier is counted under (spec 1.5 "The ledger"): verifier-<m>, exactly. */
+export const verifierName = (m: string): string => `verifier-${m}`;
+
 /**
  * The milestone's latest verifier attempt since its lanes started, whatever it said: a record_agent_run row
- * with role verifier whose name names the milestone (the skill records a FAIL as failed), passing when its
+ * with role verifier named exactly verifier-<m> (the skill records a FAIL as failed; verifier-M2-pre or
+ * verifier-M2-gate1 is not M2's verifier), passing when its
  * status is ok; or a headless verifier's dispatch record of the same shape, passing when it exited ok and its
  * reply opens VERDICT: PASS (status ok means only the CLI exited). A later FAIL undoes an earlier PASS. Null
  * when there is none.
@@ -122,16 +211,22 @@ export function milestoneVerifier(
 ): MilestoneVerifier | null {
   const found: MilestoneVerifier[] = [
     ...readAgentRuns(run)
-      .filter((a) => a.role === "verifier" && namesMilestone(a.name, m) && since(a.at, start))
-      .map((a) => ({
-        name: a.name,
-        at: a.at,
-        headless: false,
-        passed: a.status === "ok",
-        verdict: a.status,
-      })),
+      .filter((a) => a.role === "verifier" && a.name === verifierName(m) && since(a.at, start))
+      .map((a) => {
+        // plan 23: a native verifier's verdict line, when record_agent_run passed it
+        const blocked = a.status === "ok" ? null : blockedByEnvironment(a.verdict);
+        return {
+          name: a.name,
+          at: a.at,
+          headless: false,
+          passed: a.status === "ok",
+          verdict: blocked === null ? a.status : (a.verdict ?? a.status),
+          blocked,
+          head: null,
+        };
+      }),
     ...readRecords(run)
-      .records.filter((r) => r.role === "verifier" && namesMilestone(r.name, m) && since(r.endedAt, start))
+      .records.filter((r) => r.role === "verifier" && r.name === verifierName(m) && since(r.endedAt, start))
       .map((r) => {
         const first = replyVerdict(run, r);
         const passed = r.status === "ok" && first !== null && VERDICT_PASS.test(first);
@@ -142,6 +237,8 @@ export function milestoneVerifier(
           headless: true,
           passed,
           verdict: r.status === "ok" ? said : `${r.status}, ${said}`,
+          blocked: r.status === "ok" ? blockedByEnvironment(first) : null,
+          head: r.head ?? null,
         };
       }),
   ];
@@ -161,6 +258,16 @@ export function landedCommits(run: Run): string[] {
     .filter((c) => /^[0-9a-f]{7,40}$/.test(c));
 }
 
+/** The commit the ledger holds for `m`, its latest landing; null when it never landed or the row has no commit. */
+export function landedCommitOf(run: Run, m: string): string | null {
+  const rows = nonBlankLines(runPaths(run.dir).ledger)
+    .slice(1)
+    .map((row) => row.split(" | "))
+    .filter((cells) => cells[0]?.trim() === m);
+  const commit = rows.at(-1)?.[2]?.trim() ?? "";
+  return /^[0-9a-f]{7,40}$/.test(commit) ? commit : null;
+}
+
 /** The milestones the ledger holds, in landing order. */
 export function landedMilestones(run: Run): string[] {
   return nonBlankLines(runPaths(run.dir).ledger)
@@ -169,16 +276,29 @@ export function landedMilestones(run: Run): string[] {
     .filter(Boolean);
 }
 
+/** The 1.5 range: see milestoneFiles. */
+async function oneFiveFiles(run: Run, commit: string): ReturnType<typeof git> {
+  const repo = run.meta.repo;
+  const start = run.meta.startHead;
+  const base =
+    landedCommits(run).at(-1) ??
+    (start && (await commitExists(repo, start).catch(() => false)) ? start : undefined);
+  return base
+    ? await git(repo, ["diff", "--name-only", base, commit])
+    : await git(repo, ["show", "--name-only", "--format=", "--first-parent", commit]);
+}
+
 /**
- * The files the milestone's commit range changed: from the previous landed commit (else the commit's own
- * parent) to `commit`. Throws E_IO_UNEXPECTED when git cannot say.
+ * The files the milestone's commit range changed: from the previous landed commit, else the HEAD the run
+ * started on (meta.json `startHead`, when that commit is still there), else the commit's own parent, to
+ * `commit`. A base run's milestone is its branch since origin's base (plan 35). Throws E_IO_UNEXPECTED when git cannot say.
  */
 export async function milestoneFiles(run: Run, commit: string): Promise<string[]> {
-  const base = landedCommits(run).at(-1);
   const repo = run.meta.repo;
-  const r = base
-    ? await git(repo, ["diff", "--name-only", base, commit])
-    : await git(repo, ["show", "--name-only", "--format=", "--first-parent", commit]);
+  const r = run.meta.base
+    ? // plan 35: a base run's milestone is its branch since origin's base; three dots, since other milestones land on the base meanwhile
+      await git(repo, ["diff", "--name-only", `origin/${run.meta.base}...${commit}`])
+    : await oneFiveFiles(run, commit);
   if (r.kind !== "ok")
     throw new CatherdError("E_IO_UNEXPECTED", `git could not list the files ${commit} changed`, {
       fix: `check that git works in ${repo}`,
@@ -186,6 +306,24 @@ export async function milestoneFiles(run: Run, commit: string): Promise<string[]
   return r.out.split("\n").filter(Boolean);
 }
 
+/** The most commits a digest lists; the rest are counted. */
+const DIGEST_COMMITS = 20;
+
+/**
+ * The commits the milestone lands, `<short hash> <subject>`, oldest first: from the previous landed commit
+ * (else the commit alone) to `commit`. Just the hash when git cannot say: a digest never fails a landing.
+ */
+export async function milestoneCommits(run: Run, commit: string): Promise<string[]> {
+  const base = run.meta.base ? `origin/${run.meta.base}` : landedCommits(run).at(-1);
+  const range = base ? [`${base}..${commit}`] : ["-1", commit];
+  const r = await git(run.meta.repo, ["log", "--reverse", "--format=%h %s", ...range]);
+  if (r.kind !== "ok") return [commit.slice(0, 7)];
+  const all = r.out.split("\n").filter(Boolean);
+  return all.length > DIGEST_COMMITS
+    ? [...all.slice(-DIGEST_COMMITS), `and ${all.length - DIGEST_COMMITS} earlier`]
+    : all;
+}
+
 /** `rev`'s full commit hash in the run's repo. Throws E_IO_UNEXPECTED when git cannot say. */
 export async function fullCommit(run: Run, rev: string): Promise<string> {
   const r = await git(run.meta.repo, ["rev-parse", "--verify", "--quiet", `${rev}^{commit}`]);

package/src/services/notifier.ts

@@ -1,5 +1,7 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
+import { adapterFor } from "../adapters/registry.ts";
+import "../adapters/all.ts";
 import { CatherdError, errorMessage } from "../domain/errors.ts";
 import { envelope, formatNotices, type Notice, type NoticePriority, priorityOf } from "../domain/notice.ts";
 import { sessionKey, type HostSessionRef } from "../domain/host.ts";
@@ -7,15 +9,17 @@ import { sendToCodexQueue, type QueueSendResult } from "../infra/codex-queue.ts"
 import {
   deliveryState,
   readDelivery,
+  ROLE_THREAD_REFUSAL,
   writeDeliveryAttempt,
   type DeliveryAttempt,
 } from "../infra/delivery.ts";
 import type { RunRecord } from "../domain/record.ts";
+import type { RunEvent } from "../domain/run-events.ts";
 import { awaitsCollect, dispatchPaths } from "../infra/dispatch-dir.ts";
 import { tryLock } from "../infra/filelock.ts";
 import { log } from "../infra/log.ts";
 import { type SendResult, sendToInbox } from "../infra/peer-inbox.ts";
-import { writeJsonAtomic } from "../infra/store.ts";
+import { ensurePrivateDir, nonBlankLines, writeJsonAtomic } from "../infra/store.ts";
 import {
   readStallQuietMs,
   type Settled,
@@ -23,8 +27,9 @@ import {
   type Stalled,
   stallHooks,
 } from "./dispatch-service.ts";
-import { type Dispatch, listDispatches, readFailover } from "./dispatches.ts";
+import { type Dispatch, listDispatches, readFailover, roleThreadOf } from "./dispatches.ts";
 import type { Deps } from "./ports.ts";
+import { eventsFile, isDaemonRun, readEvents } from "./run-events-store.ts";
 import { listRuns, readRecords, type Run } from "./run-store.ts";
 import { currentSession, ownsRun, readSessionRows, runOwner } from "./sessions.ts";
 
@@ -32,6 +37,8 @@ export interface NotifierOptions {
   /** notices this close to each other go as one message (spec: 3 s); tests shorten it */
   coalesceMs?: number;
   sendCodex?: (target: HostSessionRef, content: string) => Promise<QueueSendResult>;
+  /** how often the reports of the session's 2.0 runs are looked for between scans; 0 (the default) never */
+  reportPollMs?: number;
   /** the sender; tests may replace it */
   send?: (
     target: { socketPath: string | null; token: string | null },
@@ -76,7 +83,8 @@ function legacyNotified(q: Queued, target: HostSessionRef): boolean {
   }
 }
 
-function recoverSubmission(dir: string, eventId: string): void {
+/** A "submitting" claim left by a sender that died is ambiguous: retrying it may duplicate input. Under the notify lock. */
+export function recoverSubmission(dir: string, eventId: string): void {
   for (const a of readDelivery(dir)) {
     if (a.status === "submitting" && a.eventIds.includes(eventId))
       writeDeliveryAttempt(dir, {
@@ -119,6 +127,7 @@ export function finishedNotice(run: Run, d: Dispatch, r: RunRecord): Notice {
     name: r.name,
     role: r.role,
     lane: r.lane,
+    thread: r.thread,
     rung: r.rung,
     status,
     replyStatus: r.replyStatus,
@@ -129,6 +138,43 @@ export function finishedNotice(run: Run, d: Dispatch, r: RunRecord): Notice {
   };
 }
 
+/** One report of a 2.0 run, as the session is told of it: the unit, what kind it is, its text. */
+export function reportNotice(run: Run, e: Extract<RunEvent, { type: "report.posted" }>): Notice {
+  return {
+    kind: "report",
+    eventId: JSON.stringify([run.id, `report-${e.seq}`, "report"]),
+    runId: run.id,
+    runTitle: run.meta.title,
+    dispatchId: `report-${e.seq}`,
+    name: e.unit,
+    role: "run",
+    lane: null,
+    thread: null,
+    rung: "",
+    status: e.kind,
+    replyStatus: null,
+    secs: 0,
+    changedOwned: 0,
+    reply: e.text,
+    priority: e.kind === "parked" || e.kind === "failed" ? "next" : "later",
+  };
+}
+
+/** A live fresh role's thread, as its CLI named it early in its stream; null before it did. */
+function streamThread(d: Dispatch): string | null {
+  const a = adapterFor(d.admit.backend);
+  if (!a) return null;
+  for (const line of nonBlankLines(dispatchPaths(d.dir).events)) {
+    try {
+      const t = a.parse(line).thread;
+      if (t) return t;
+    } catch {
+      // a line the adapter cannot read names no thread
+    }
+  }
+  return null;
+}
+
 /** Spec §3.6: a live role that went quiet, once, at `next`. */
 export function stalledNotice(run: Run, d: Dispatch, quietMs: number, now: number): Notice {
   return {
@@ -140,6 +186,7 @@ export function stalledNotice(run: Run, d: Dispatch, quietMs: number, now: numbe
     name: d.admit.name,
     role: d.admit.role,
     lane: d.admit.lane,
+    thread: d.admit.thread ?? streamThread(d),
     rung: d.admit.rung,
     status: `stalled: no output for ${Math.max(1, Math.round(quietMs / 60_000))} min`,
     replyStatus: null,
@@ -242,6 +289,38 @@ function notifierFor(deps: Deps, o: NotifierOptions, retryEvent?: string): Notif
           log("warn", "notify", { error: errorMessage(e), dispatch: q.notice.dispatchId });
         }
       }
+      // spec 1.5 plan 21: a notice never goes to a role's own thread (a `codex exec` thread exits after its turn,
+      // so what is queued there is lost). It fails loudly, and `status` says so, instead of enqueue-accepted.
+      const roles = new Map(due.map((q) => [q, roleThreadOf(q.run, target.sessionId)]));
+      for (const [q, role] of roles) {
+        if (role === null) continue;
+        due.splice(due.indexOf(q), 1);
+        const reason = `${ROLE_THREAD_REFUSAL} (${role}, ${target.host} ${target.sessionId}), not the orchestrator's; peek(run) from the orchestrator's session takes the run back`;
+        log("error", "notify", {
+          run: q.run.id,
+          dispatch: q.notice.dispatchId,
+          target: target.sessionId,
+          reason,
+        });
+        try {
+          writeDeliveryAttempt(q.dir, {
+            attemptId: crypto.randomUUID(),
+            target: {
+              host: target.host,
+              sessionId: target.sessionId,
+              hostSessionId: target.hostSessionId,
+              name: target.name,
+            },
+            eventIds: [q.notice.eventId],
+            at: new Date(deps.now()).toISOString(),
+            status: "failed",
+            msgId: null,
+            reason,
+          });
+        } catch (e) {
+          log("warn", "notify", { error: errorMessage(e), dispatch: q.notice.dispatchId });
+        }
+      }
       // nothing is sent unless every notice's claim is on disk. A claim that cannot be written rolls the batch's
       // written claims back to failed (provably not submitted, so still deliverable), keeps that notice for a
       // later pass, and claims the rest again at once: one bad file never holds back the others
@@ -430,7 +509,35 @@ function notifierFor(deps: Deps, o: NotifierOptions, retryEvent?: string): Notif
     }
   };
 
+  /** The reports of a 2.0 run this session owns: queued once each, under `<run>/reports/<seq>/`. */
+  const reportSizes = new Map<string, number>();
+  const enqueueReports = (run: Run, force: boolean): void => {
+    const size = statSync(eventsFile(run)).size;
+    if (!force && reportSizes.get(run.id) === size) return;
+    reportSizes.set(run.id, size);
+    for (const e of readEvents(run)) {
+      if (e.type !== "report.posted") continue;
+      const dir = join(run.dir, "reports", String(e.seq));
+      ensurePrivateDir(dir);
+      const notice = reportNotice(run, e);
+      queueNotice({ key: notice.eventId, run, dir, notice, mark: join(dir, "notified"), due: () => true });
+    }
+  };
+
+  const scanReports = (force: boolean): void => {
+    if (stopped || !currentSession(deps)) return;
+    for (const run of listRuns().runs) {
+      try {
+        if (isDaemonRun(run) && owned(run)) enqueueReports(run, force);
+      } catch (e) {
+        log("warn", "notify", { run: run.id, error: errorMessage(e) });
+      }
+    }
+  };
+
   const onSettled = (s: Settled): void => {
+    // the run's reports tell the session of a 2.0 run, not each role's finish
+    if (isDaemonRun(s.run)) return;
     try {
       enqueue(s.run, s.d, s.record);
     } catch (e) {
@@ -446,6 +553,10 @@ function notifierFor(deps: Deps, o: NotifierOptions, retryEvent?: string): Notif
       for (const run of listRuns().runs) {
         try {
           if (!owned(run)) continue;
+          if (isDaemonRun(run)) {
+            enqueueReports(run, true);
+            continue;
+          }
           const records = new Map(readRecords(run).records.map((r) => [r.dispatchId, r]));
           for (const d of listDispatches(run)) {
             // one dispatch's damaged evidence stays ambiguous for it alone: the rest of the run is still scanned
@@ -499,6 +610,15 @@ function notifierFor(deps: Deps, o: NotifierOptions, retryEvent?: string): Notif
     settledHooks.add(onSettled);
     stallHooks.add(onStall);
   }
+  if (!retryEvent && o.reportPollMs) {
+    const poll = setInterval(() => scanReports(false), o.reportPollMs);
+    poll.unref();
+    const stopRest = n.stop;
+    n.stop = () => {
+      clearInterval(poll);
+      stopRest();
+    };
+  }
   return n;
 }
 

package/src/services/notify-service.ts

@@ -0,0 +1,26 @@
+import { notifyMessage } from "../domain/notify.ts";
+import type { NotifyMoment } from "../domain/profile.ts";
+import { postNotify } from "../infra/ntfy.ts";
+import type { Deps } from "./ports.ts";
+import { runProfile } from "./run-pin.ts";
+import type { Run } from "./run-store.ts";
+
+/**
+ * Tells the owner's phone about a moment of a run, when the run's profile lists that moment. False when it is
+ * not listed, or the message did not go out; it never throws.
+ */
+export async function sendRunNotice(
+  deps: Deps,
+  run: Run,
+  i: { unit: string; moment: NotifyMoment },
+  o: { fetch?: typeof fetch; timeoutMs?: number } = {},
+): Promise<boolean> {
+  if (!runProfile(deps, run).notify.includes(i.moment)) return false;
+  // CATHERD_NO_END_PUSH=1 (the test preload sets it) keeps every real send off; a test's own fetch still goes
+  if (process.env.CATHERD_NO_END_PUSH === "1" && !o.fetch) return false;
+  return postNotify(
+    deps.profiles.notifyUrl(),
+    notifyMessage({ runId: run.id, runTitle: run.meta.title, unit: i.unit, moment: i.moment }),
+    o,
+  );
+}

package/src/services/orchestrator-wait.ts

@@ -0,0 +1,82 @@
+import type { RunRecord } from "../domain/record.ts";
+import { liveSessionFile, readSessionFiles, type SessionFile } from "../infra/claude-session.ts";
+import { awaitsCollect } from "../infra/dispatch-dir.ts";
+import { listDispatches, liveDispatches } from "./dispatches.ts";
+import { readRecords, type Run } from "./run-store.ts";
+import { runOwner } from "./sessions.ts";
+
+export const ORCHESTRATOR_STALL_MS = 5 * 60_000;
+
+/**
+ * Plan 22 (#42 finding 3): the line shows only for a current owner (its Claude Code session live, or seen in the
+ * last day) and an unread record that ended in the last day, so an abandoned run never reads "stalled" forever.
+ */
+export const WAIT_WINDOW_MS = 24 * 3_600_000;
+
+export interface OrchestratorWait {
+  since: string;
+  seconds: number;
+  stalled: boolean;
+  unread: number;
+  /** when the line stops showing, unless the owner is seen again or another record ends */
+  until: string;
+}
+
+/**
+ * When the owner was last seen acting on the run: it took the run (`since`), or one of the run's dispatches was
+ * admitted from its session.
+ */
+function ownerSeen(run: Run, owner: { sessionId: string; since: string }): number {
+  let seen = Date.parse(owner.since) || 0;
+  for (const d of listDispatches(run))
+    if (d.admit.sessionId?.toLowerCase() === owner.sessionId.toLowerCase())
+      seen = Math.max(seen, Date.parse(d.admit.admittedAt) || 0);
+  return seen;
+}
+
+/**
+ * Pure diagnostic: queue acceptance cannot show that the orchestrator processed a completion. Null unless the
+ * run has a current owner, no live role, and an unread record that ended within WAIT_WINDOW_MS.
+ */
+export function orchestratorWait(
+  run: Run,
+  now: number,
+  records: RunRecord[] = readRecords(run).records,
+  hasLive = liveDispatches(run, now).length > 0,
+  files: () => SessionFile[] = readSessionFiles,
+): OrchestratorWait | null {
+  const owner = runOwner(run);
+  if (!owner || hasLive) return null;
+  const unread = new Set(
+    listDispatches(run)
+      .filter((d) => awaitsCollect(d.dir))
+      .map((d) => d.admit.dispatchId),
+  );
+  const recent = records.filter(
+    (r) => unread.has(r.dispatchId) && now - (Date.parse(r.endedAt) || 0) < WAIT_WINDOW_MS,
+  );
+  if (!recent.length) return null;
+  const ended = Math.max(...recent.map((r) => Date.parse(r.endedAt) || 0));
+  const live = owner.host === "claude-code" && liveSessionFile(owner.sessionId, files()) !== null;
+  const seen = live ? now : ownerSeen(run, owner);
+  if (now - seen >= WAIT_WINDOW_MS) return null;
+  const since = Math.max(ended, Date.parse(owner.since) || 0);
+  const elapsed = Math.max(0, now - since);
+  return {
+    since: new Date(since).toISOString(),
+    seconds: Math.floor(elapsed / 1000),
+    stalled: elapsed >= ORCHESTRATOR_STALL_MS,
+    unread: records.filter((r) => unread.has(r.dispatchId)).length,
+    until: new Date(Math.min(ended, seen) + WAIT_WINDOW_MS).toISOString(),
+  };
+}
+
+/**
+ * The one "waiting for orchestrator" line every view shows (#42 finding 7): seconds and `stalled` from `since` at
+ * `now`, so a memoised wait stays true between recomputes; null once it is past `until`.
+ */
+export function waitingLine(w: OrchestratorWait | null | undefined, now: number): string | null {
+  if (!w || now >= Date.parse(w.until)) return null;
+  const elapsed = Math.max(0, now - Date.parse(w.since));
+  return `${elapsed >= ORCHESTRATOR_STALL_MS ? "stalled · " : ""}waiting for orchestrator ${Math.floor(elapsed / 1000)}s`;
+}