omp-conductor 0.6.0 → 0.7.0

package/README.md

@@ -1918,6 +1918,7 @@ omp-conductor release-pane [--project NAME]
 omp-conductor tail <issue> [--project NAME]
 omp-conductor extend <issue> --turns N [--project NAME]
 omp-conductor unblock <issue> [--force] [--project NAME]
+omp-conductor verb <conductor_*> [--project NAME] [--arg k=v ...]
 omp-conductor friction <escalation-digest|report-noise|report-surprise> --detail TEXT [--issue N] [--project NAME]
 omp-conductor report --text TEXT [--kind material|digest] [--project NAME]
 omp-conductor decision open --question TEXT [--blocks TEXT] [--resolves-when COND] [--project NAME]
@@ -1949,6 +1950,7 @@ omp-conductor help
 | `tail <issue>` | Follow the newest run for that issue: the worker's assistant text as `assistant: …` and each tool it calls as `tool: <name>`, printed as they land. Workers are omp sessions inside the daemon rather than terminals, so this is the only way to watch one live — a herdr pane running it becomes an observation window. Starts from the top of the transcript, not the end, so attaching to a run that is already ten turns in shows those ten turns. Exits `1` with `no run recorded for #N` when the issue has never been dispatched, or `no transcript yet (state: …)` when the attempt has not opened one. Otherwise it runs until `Ctrl-C`, or until the run has finished and its transcript has been silent for five seconds, and prints `run ended: <state>`. |
 | `extend <issue> --turns N [--project NAME]` | Monotonically raise that live worker's effective turn ceiling through its owning daemon. The current omp session keeps running; no restart or continuation is created. The daemon persists the new ceiling for `status` and rejects missing, settled, cap-killed, equal, or lower requests instead of implying that an immutable session changed. |
 | `unblock <issue> [--force]` | Remove that issue's `blocked` and `failed` labels so an answered escalation can be claimed again. `agent:in-progress` comes off too, but only when the newest recorded run is terminal — that row is the proof no worker still owns the issue, so a live run keeps the label, and so does an issue with no run row at all. Run history remains intact: blocks consume the independent continuation budget, not failed implementation attempts. The output reports both budgets and warns when either will make the next tick escalate instead of dispatch. **Refuses, clearing nothing and exiting `3`, when the newest attempt's work could not be committed and its worktree is the only copy** — re-claiming removes that tree. `--force` records the operator's acceptance on the run row and then clears; the salvage failure stays in history. Exits `2` when the issue number is missing or malformed. |
+| `verb <conductor_*> [--arg k=v ...]` | Run one [mediated verb](#the-mediated-verbs-126) as the orchestrator, from the CLI — the external-orchestrator half of the verb surface. Every argument goes in as a `--arg k=v` string; an orchestrator can merge (`conductor_pr_merge`), label (`conductor_label`), release (`conductor_release`), update a branch (`conductor_pr_update_branch`) or title/body (`conductor_pr_update`), or read PR state (`conductor_pr_status`). The daemon applies the same checks and writes the same ledger rows a session's call would; a missing `--arg` is refused exactly as a missing tool argument is, worker-only verbs (`conductor_push`, `conductor_pr_create`) are refused with `role-not-allowed`, and a refusal exits `3`. An unknown verb exits `2`. |
 | `friction <kind> --detail TEXT [--issue N]` | Record one bounded judgment the daemon cannot infer: an escalation belonged in a digest, or a tick report was noise/surprising. The detail is limited to 160 characters. One event never changes policy; three observations inside seven days make the aggregate eligible for one Learning-loop prompt, followed by a seven-day cooldown. |
 | `report --text TEXT [--kind material|digest]` | Hand a rendered report to the daemon's durable outbox. The text is persisted **before** anything is sent and the command prints a report id; the daemon then owns delivery, retries on a bounded backoff, and records the Telegram message id it actually got back. Delivery is [at-least-once](#report-delivery-the-outbox) — a crash mid-send is retried and the retry says it may be a repeat — so `delivered` is never proof of exactly one message. `--kind digest` is accepted at most once per local day, decided from the ledger rather than from what the session remembers sending; an unknown `--kind` exits `2` rather than quietly becoming a material report. Anything undelivered shows in `status` with its age. |
 | `decision open --question TEXT [--blocks TEXT] [--resolves-when COND]` | Record a question the orchestrator has put to you, and print its id. A question that lives only in a session's context is lost at the next compaction — after which it is either asked twice or dropped silently. `--resolves-when` attaches a machine-checkable condition: `pr-merged:<https url>`, `issue-closed:<n>`, or `npm-version:<pkg>@<version>`; anything else exits `2` listing the three forms. See [The decision ledger](#the-decision-ledger-136). |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omp-conductor",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "license": "MIT",
   "description": "A 24/7 dispatcher that takes ready GitHub issues to green, mergeable PRs using omp coding sessions, with tiered escalation first to an orchestrator session and then to a human.",

package/src/approval-surface.ts

@@ -55,7 +55,12 @@ import { dirname, join } from "node:path";
  *  says whether it can be called must name the same thing. */
 export const TELEGRAM_APPROVAL_TOOL = "telegram_ask";
 
-export type ApprovalSurface = { kind: "ready" } | { kind: "missing"; reason: string };
+export type ApprovalSurface =
+  | { kind: "ready"; /** `notifyMode` from access.json, when the surface read it
+                        (#169): whether end-of-turn text reaches the operator's
+                        chat, so the tick's delivery rule can say so truthfully. */
+      notifyMode?: string }
+  | { kind: "missing"; reason: string };
 
 /** Whether the Telegram bridge is running the headless contract, or merely
  *  configured well enough to answer a question.
@@ -257,7 +262,7 @@ export function readApprovalSurface(path: string): ApprovalSurface {
           "set notifyChat to the paired owner id",
       };
     }
-    return { kind: "ready" };
+    return { kind: "ready", notifyMode: mode === undefined ? undefined : String(mode) };
   }
 
   // A group destination needs a policy entry, and that policy must admit the
@@ -283,7 +288,7 @@ export function readApprovalSurface(path: string): ApprovalSurface {
         `paired owner (${owner}) in its allowFrom, so their answer would be rejected`,
     };
   }
-  return { kind: "ready" };
+  return { kind: "ready", notifyMode: mode === undefined ? undefined : String(mode) };
 }
 
 /**

package/src/board.ts

@@ -1,4 +1,4 @@
-import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { closeSync, existsSync, openSync, readSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { emitKeypressEvents } from "node:readline";
 import { findProject, loadConfig, resolveCaps } from "./config.ts";
@@ -16,10 +16,21 @@ import { dbPath, openStore } from "./store.ts";
 import { formatTranscriptLine } from "./transcript.ts";
 import { makeTracker } from "./tracker/github.ts";
 import { planUsageBadge, readPlanUsage, sharedUsageSource } from "./usage.ts";
-import type { AdmissionHoldReason, ProjectConfig, RunRecord, RunState, Store } from "./types.ts";
+import type {
+  AdmissionHoldReason,
+  PrVerification,
+  ProjectConfig,
+  RunRecord,
+  RunState,
+  Store,
+} from "./types.ts";
 
 const REFRESH_MS = 1_000;
 const HEALTH_REFRESH_MS = 10_000;
+/** Cadence for re-verifying pushed rows against GitHub — deliberately slower
+ *  than the board's health/label probe: it is one `gh` call per pushed row, and
+ *  pull-request state does not move at 1 Hz. #173. */
+const PR_REFRESH_MS = 60_000;
 const MERGED_HISTORY_MS = 24 * 60 * 60_000;
 const TRANSCRIPT_BYTES = 64 * 1024;
 const MIN_WIDTH = 50;
@@ -53,6 +64,7 @@ const COLUMN_DEFS = [
   { key: "blocked", title: "BLOCKED" },
   { key: "failed", title: "FAILED" },
   { key: "orphaned", title: "ORPHANED" },
+  { key: "parked", title: "PARKED" },
   { key: "merged", title: "MERGED" },
   { key: "history", title: "HISTORY" },
 ] as const satisfies readonly { key: string; title: string }[];
@@ -69,6 +81,23 @@ const LIVE_LANES: Partial<Record<RunState, BoardLane>> = {
   "pushed-green": "green",
 };
 
+/** Terminal run states that park an issue nobody has acted on: a human cleared
+ *  the state labels but the issue is still open, so its last run is the story
+ *  that has to stay visible — #173. Differs from {@link LIVE_LANES} in that
+ *  these are rows, never current work, and from MERGED in that they are not a
+ *  happy resolution. */
+const PARKED_STATES = new Set<RunState>(["blocked", "failed", "killed", "orphaned"]);
+
+/** Whether a terminal blocked/failed run is wearing its own state label. When
+ *  the label is absent the run row is the only record of what happened, so the
+ *  card and detail header say "last run: <state>" rather than presenting it as
+ *  current — #173, the same distinction that parks the lane. */
+function isLastRun(run: RunRecord, labels: BoardLabels): boolean {
+  if (run.state === "blocked") return !labels.blocked.has(run.issue);
+  if (run.state === "failed") return !labels.failed.has(run.issue);
+  return false;
+}
+
 type DaemonBoardState = "stopped" | "ok" | "unreachable" | "other-project";
 
 /**
@@ -114,6 +143,11 @@ export interface BoardLabels {
   inProgress: ReadonlySet<number>;
   blocked: ReadonlySet<number>;
   failed: ReadonlySet<number>;
+  /** Issues whose newest run is terminal and unlabelled but that are still open
+   *  on the tracker — the PARKED lane (#173), probed on the same 10s cadence as
+   *  the label sets. An issue missing from this set (closed, or the probe could
+   *  not tell) keeps today's HISTORY/undefined behaviour rather than parking. */
+  open: ReadonlySet<number>;
   /** Epoch ms of the last read that succeeded; 0 when none has. */
   readAt: number;
   /** Message from the most recent failed read. The sets above are then the last
@@ -129,6 +163,7 @@ const UNREAD_LABELS: BoardLabels = {
   inProgress: new Set<number>(),
   blocked: new Set<number>(),
   failed: new Set<number>(),
+  open: new Set<number>(),
   readAt: 0,
 };
 
@@ -137,10 +172,18 @@ export interface BoardSnapshot {
   status: StatusSnapshot;
   health: BoardHealth;
   labels: BoardLabels;
+  /** Live re-verification of pushed rows (#173): run id → what the tracker says
+   *  the PR looks like now. Rendered as a `now:` suffix on the card. */
+  pr: ReadonlyMap<string, { status: PrVerification["status"]; reason: string }>;
   runs: RunRecord[];
   now: number;
 }
 
+/** The card state a {@link PrVerification.status} reads as in the UI. */
+function prLabel(status: PrVerification["status"]): string {
+  return status === "green" ? "green" : status === "failed" ? "red" : "pending";
+}
+
 export interface BoardCursor {
   column: number;
   card: number;
@@ -166,6 +209,7 @@ function ansiColor(key: BoardLane): string {
     case "claimed":
     case "blocked":
     case "orphaned":
+    case "parked":
       return YELLOW;
     case "failed":
       return RED;
@@ -266,6 +310,13 @@ function laneOf(
   if (queued.has(issue)) return "queue";
   if (run?.state === "merged") return "merged";
   if (run === undefined) return undefined;
+  // PARKED (#173): a terminal run row with no state or queue label left on it,
+  // on an issue the tracker says is still open. A human cleared the labels but
+  // has not acted — the blank lane the four labels used to imply is a lie, and
+  // closed or unreadable issues keep the HISTORY/undefined fallthrough below.
+  // Deliberately not subject to MERGED_HISTORY_MS: parked work does not stop
+  // being the issue's last word after 24 hours.
+  if (PARKED_STATES.has(run.state) && labels.open.has(issue)) return "parked";
   // What is left is a terminal run row with no current claim on it — a closed
   // issue, or one a human already cleared. Recent rows stay readable under
   // HISTORY for the same 24 hours MERGED uses; older ones are not news.
@@ -424,6 +475,21 @@ function runCardLines(run: RunRecord, snapshot: BoardSnapshot): string[] {
     `attempt ${run.attempt} · ${run.turns}/${run.maxTurns}t`,
     `$${run.spendUsd.toFixed(2)} · ${duration}`,
   ];
+  // #173: a live re-verification of a pushed row, when the 60s probe has one.
+  // Guarded on the pushed states: a stale entry must not follow a row that
+  // settled into another lane and keep claiming "now: green" about a PR that
+  // already merged or failed.
+  const live =
+    run.state === "pushed-green" || run.state === "pushed-pending" ? snapshot.pr.get(run.id) : undefined;
+  if (live !== undefined) {
+    const reason = live.reason.split(/\s+/, 1)[0] ?? "";
+    lines.push(
+      live.status === "failed" ? `now: red — ${reason === "" ? "failed" : reason}` : `now: ${prLabel(live.status)}`,
+    );
+  }
+  // #173: a terminal blocked/failed run whose state label is gone reads as the
+  // lane it sits in — which the label being absent made PARKED, not the truth.
+  if (isLastRun(run, snapshot.labels)) lines.push(`last run: ${run.state}`);
   // Ordered by what needs a human first. An unsalvaged tree outranks even a
   // last error: the error describes a run that is over, the tree is work that
   // is still at risk and an issue that will not dispatch (#118).
@@ -567,6 +633,9 @@ function renderBoardColumns(snapshot: BoardSnapshot, cursor: BoardCursor, width:
 
 function readTranscript(run: RunRecord): string[] {
   if (run.sessionFile === undefined) return [`No transcript yet (state: ${run.state}).`];
+  // #172: a row name that never materialised is "not yet", not a read error —
+  // rendering it as `Transcript unavailable` would blame the file for existing.
+  if (!existsSync(run.sessionFile)) return [`No transcript yet (state: ${run.state}).`];
   let fd: number | undefined;
   try {
     const size = statSync(run.sessionFile).size;
@@ -617,8 +686,11 @@ function renderDetail(snapshot: BoardSnapshot, cursor: BoardCursor, width: numbe
   }
 
   const run = card.run;
+  // #173: a blocked/failed run whose label is gone is the reason this card is
+  // parked; the header says so rather than presenting the state as current.
+  const stateShown = isLastRun(run, snapshot.labels) ? `last run: ${run.state}` : run.state;
   const metadata = [
-    styledCell(` RUN #${run.issue}  ${run.repo}  ${run.state} `, width, `${BOLD}${REVERSE}`),
+    styledCell(` RUN #${run.issue}  ${run.repo}  ${stateShown} `, width, `${BOLD}${REVERSE}`),
     styledCell(`attempt ${run.attempt}  ·  ${run.turns}/${run.maxTurns} turns  ·  $${run.spendUsd.toFixed(2)}  ·  ${humanDuration((run.endedAt ?? snapshot.now) - run.startedAt)}`, width),
     styledCell(`branch ${run.branch}`, width, DIM),
     styledCell(`worktree ${run.worktree || "removed"}`, width, DIM),
@@ -739,7 +811,11 @@ async function probeBoardHealth(project: ProjectConfig): Promise<BoardHealth> {
  * why, because blanking QUEUE and FAILED is a louder lie than showing them
  * stale — {@link labelFact} puts the staleness in the header.
  */
-async function probeBoardLabels(project: ProjectConfig, previous?: BoardLabels): Promise<BoardLabels> {
+async function probeBoardLabels(
+  project: ProjectConfig,
+  store: Store,
+  previous?: BoardLabels,
+): Promise<BoardLabels> {
   const openIssuesLabelled = async (label: string): Promise<Set<number>> =>
     new Set((await makeTracker({ ...project, queueLabel: label }).listReady()).map((issue) => issue.number));
   try {
@@ -749,7 +825,26 @@ async function probeBoardLabels(project: ProjectConfig, previous?: BoardLabels):
       openIssuesLabelled(project.stateLabels.blocked),
       openIssuesLabelled(project.stateLabels.failed),
     ]);
-    return { queued, inProgress, blocked, failed, readAt: Date.now() };
+    // PARKED candidates: the newest run per issue, terminal, non-merged, and
+    // wearing no state or queue label. Exactly the rows {@link laneOf} would
+    // otherwise fall through on. Bounded by `recentRuns`' own recentJobs limit,
+    // issued in parallel, and cached: a failed read keeps the last set.
+    const labelled = new Set([...queued, ...inProgress, ...blocked, ...failed]);
+    const newestRun = new Map<number, RunRecord>();
+    for (const run of store.recentRuns(project.name, Date.now() - MERGED_HISTORY_MS)) {
+      if (!newestRun.has(run.issue)) newestRun.set(run.issue, run);
+    }
+    const parkedCandidates = [...newestRun.values()].filter(
+      (run) => PARKED_STATES.has(run.state) && !labelled.has(run.issue),
+    );
+    const open = new Set<number>();
+    await Promise.all(
+      parkedCandidates.map(async (run) => {
+        const state = await makeTracker(project).issueState(run.issue);
+        if (state === "open") open.add(run.issue);
+      }),
+    );
+    return { queued, inProgress, blocked, failed, open, readAt: Date.now() };
   } catch (err) {
     return {
       ...(previous ?? UNREAD_LABELS),
@@ -827,11 +922,17 @@ export async function runBoard(projectName?: string): Promise<void> {
   let notice = "";
   let [health, labels, planUsage] = await Promise.all([
     probeBoardHealth(project),
-    probeBoardLabels(project),
+    probeBoardLabels(project, store),
     readPlanUsage(caps.planUsage, sharedUsageSource()),
   ]);
   let healthAt = Date.now();
   let healthRefresh: Promise<void> | undefined;
+  // Live re-verification of pushed rows (#173): cached per run id, refreshed on
+  // the slow PR cadence so a `gh` call per pushed row does not ride the 1 Hz
+  // repaint or the 10 s health gate.
+  const prProbe = new Map<string, { status: PrVerification["status"]; reason: string }>();
+  let prProbeAt = 0;
+  let prProbeRun: Promise<void> | undefined;
 
   emitKeypressEvents(process.stdin);
   const onKey = (_text: string, key: KeyInput): void => enqueue(queue, key, wake);
@@ -855,7 +956,7 @@ export async function runBoard(projectName?: string): Promise<void> {
         healthAt = now;
         healthRefresh = Promise.all([
           probeBoardHealth(project),
-          probeBoardLabels(project, labels),
+          probeBoardLabels(project, store, labels),
           // On the health cadence, not the 1s repaint: the provider read is a
           // subprocess, and an allowance does not move at 1 Hz.
           readPlanUsage(caps.planUsage, sharedUsageSource()),
@@ -873,11 +974,37 @@ export async function runBoard(projectName?: string): Promise<void> {
             healthRefresh = undefined;
           });
       }
+      // #173: re-verify pushed rows against the tracker on their own slow
+      // cadence, so red-shown-as-green and a moved head surface without paying
+      // for the read every second. A failed probe leaves the last verdicts in
+      // place (blanking a card's `now:` is a quieter lie than nothing).
+      if (now - prProbeAt >= PR_REFRESH_MS && prProbeRun === undefined) {
+        prProbeAt = now;
+        const rows = store.recentRuns(project.name, now - MERGED_HISTORY_MS).filter(
+          (run) => (run.state === "pushed-green" || run.state === "pushed-pending") && run.prUrl !== undefined && run.headSha !== undefined,
+        );
+        prProbeRun = (async () => {
+          const tracker = makeTracker(project);
+          await Promise.all(
+            rows.map(async (run) => {
+              const verified = await tracker.verifyPr(run.prUrl!, run.headSha!);
+              if (verified !== undefined) prProbe.set(run.id, { status: verified.status, reason: verified.reason });
+            }),
+          );
+        })()
+          .catch((err: unknown) => {
+            notice = `PR probe failed: ${err instanceof Error ? err.message : String(err)}`;
+          })
+          .finally(() => {
+            prProbeRun = undefined;
+          });
+      }
       const snapshot: BoardSnapshot = {
         project,
         status: statusSnapshotFromStore(project, caps, store, planUsage),
         health,
         labels,
+        pr: prProbe,
         runs: store.recentRuns(project.name, now - MERGED_HISTORY_MS),
         now,
       };

package/src/briefs/orchestrator.md

@@ -290,6 +290,22 @@ what you asked for and what it decided — readable with `omp-conductor ledger`,
 including the refusals. That record is the point: a merge or a release the
 dispatcher did not perform is one nobody can account for afterwards.
 
+An external orchestrator (a session outside the daemon) runs the same verbs, with
+the same checks and the same ledger rows, through the CLI:
+
+```
+omp-conductor verb conductor_pr_merge --arg prUrl=<url> --arg headSha=<sha> --arg reason=<reason>
+omp-conductor verb conductor_label --arg issueUrl=<url> --arg label=<name> --arg action=add --arg reason=<reason>
+omp-conductor verb conductor_release --arg shape=git-tag --arg repo=<name> --arg reason=<reason> --arg tag=<tag>
+omp-conductor verb conductor_pr_update_branch --arg prUrl=<url>
+omp-conductor verb conductor_pr_update --arg prUrl=<url> --arg title=<title>
+```
+
+Each `--arg k=v` is one argument, read as a string. Worker-only verbs
+(`conductor_push`, `conductor_pr_create`) are refused with `role-not-allowed` —
+an external orchestrator never pushes or opens a PR, exactly as this floor's
+sessions do not.
+
 | Tool | Yours when | What the dispatcher checks before acting |
 | --- | --- | --- |
 | `conductor_pr_status` | always | Nothing to gate: it reads. |

package/src/cli.ts

@@ -23,7 +23,7 @@ import {
 } from "./brief-upgrade.ts";
 import { findProject, loadConfig, resolveCaps, stateDir } from "./config.ts";
 import { CONDITION_FORMS, parseCondition } from "./decisions.ts";
-import { runDaemon, setPaused } from "./daemon.ts";
+import { isPaused, pausedAt, runDaemon, setPaused } from "./daemon.ts";
 import {
   armTicks,
   clearPaneHalt,
@@ -58,7 +58,9 @@ import { dbPath, LIVE_STATES, openStore } from "./store.ts";
 import { formatTranscriptLine } from "./transcript.ts";
 import { formatVerbLedgerEntry } from "./verbs/ledger.ts";
 import { makeTracker } from "./tracker/github.ts";
-import { REPORT_KINDS } from "./types.ts";
+import { githubVerbActions } from "./verbs/actions.ts";
+import { handleVerbCall, type VerbChannel } from "./verbs/server.ts";
+import { REPORT_KINDS, VERB_NAMES } from "./types.ts";
 import type { ProjectConfig, ReportKind } from "./types.ts";
 import { formatUnblock, unblockIssue } from "./unblock.ts";
 import { upgradeConductor } from "./upgrade.ts";
@@ -100,6 +102,7 @@ usage:
   omp-conductor tail <issue> [--project NAME]
   omp-conductor extend <issue> --turns N [--project NAME]
   omp-conductor unblock <issue> [--force] [--project NAME]
+  omp-conductor verb <conductor_*> [--project NAME] [--arg k=v ...]
   omp-conductor daemon [--once] [--port N] [--project NAME]
   omp-conductor pause
   omp-conductor resume
@@ -168,6 +171,13 @@ usage:
            Refuses when the newest attempt's work could not be committed and
            its worktree is the only copy: re-claiming removes that tree. Use
            --force once you have recovered it or accepted the loss.
+  verb     run one conductor_* verb as the orchestrator, from the CLI: the same
+           checks and the same ledger rows a session's call would get. This is
+           how an external orchestrator merges, labels, releases or reads PR
+           state without a raw gh call that skips every gate. Arguments are
+           strings, one per --arg (e.g. --arg prUrl=https://x --arg headSha=y).
+           A refusal exits 3. See conductor_pr_merge/conductor_label/
+           conductor_release/conductor_pr_update_branch in the brief.
   report   hand a rendered report to the daemon's durable outbox. The report is
            persisted before anything is sent, delivered by the daemon with
            bounded retries, and shown by status until it lands. Delivery is
@@ -732,6 +742,89 @@ try {
       break;
     }
 
+    /**
+     * The external-orchestrator half of the verbs (#167): run any
+     * `conductor_*` verb from the CLI, through the daemon's own checks and
+     * ledger. An orchestrator that merges, labels or releases through this
+     * gets exactly the same refusals a session would and writes the same
+     * ledger rows — the raw `gh pr merge` a session reaches for instead is
+     * invisible to both.
+     *
+     * Worker-only verbs (conductor_push, conductor_pr_create) refuse with
+     * `role-not-allowed` — correct, and deliberately not special-cased here.
+     *
+     * Accepted limitation: the daemon's in-process one-merge-per-project slot
+     * does not span the daemon and a concurrent CLI merge. The execution-time
+     * head re-read (`--match-head-commit` in prMergeVerb) is the cross-process
+     * guard, so a CLI merge races a daemon merge exactly as two daemon merges
+     * would.
+     */
+    case "verb": {
+      const name = argv[1];
+      if (name === undefined || !VERB_NAMES.some((n) => n === name)) {
+        process.stderr.write(
+          `omp-conductor: unknown verb "${name ?? ""}". Known verbs: ${VERB_NAMES.join(", ")}\n`,
+        );
+        process.exit(2);
+      }
+      const cfg = loadConfig();
+      const project = findProject(cfg, flag(argv, "project"));
+      const args: Record<string, string> = {};
+      for (let i = 2; i < argv.length; i++) {
+        const token = argv[i];
+        if (token === "--arg") {
+          const pair = argv[i + 1];
+          if (pair === undefined || !pair.includes("=")) {
+            process.stderr.write(`omp-conductor: verb --arg needs k=v, got "${pair ?? ""}"\n`);
+            process.exit(2);
+          }
+          const eq = pair.indexOf("=");
+          args[pair.slice(0, eq)] = pair.slice(eq + 1);
+          i++;
+        } else if (token === "--project" || token?.startsWith("--project=") === true) {
+          // Consumed by `flag(argv, "project")` above; both spellings skip here.
+          if (token === "--project") i++;
+        } else {
+          process.stderr.write(
+            `omp-conductor: verb: unexpected argument "${token ?? ""}" (pass verb arguments as --arg k=v)\n`,
+          );
+          process.exit(2);
+        }
+      }
+      const store = openStore(dbPath());
+      try {
+        const channel: VerbChannel = {
+          kind: "orchestrator",
+          path: "cli",
+          project: project.name,
+          role: "orchestrator",
+        };
+        const reply = await handleVerbCall(
+          {
+            project: () => findProject(loadConfig(), project.name),
+            store,
+            tracker: makeTracker(project),
+            actions: githubVerbActions(project),
+            fleetStop: () =>
+              isPaused()
+                ? "claiming is paused for this fleet (omp-conductor pause, hold or halt)"
+                : undefined,
+            pausedAt,
+            log: (m) => process.stderr.write(`${m}\n`),
+            now: () => Date.now(),
+          },
+          channel,
+          { verb: name, args },
+        );
+        process.stdout.write(`${reply.text}\n`);
+        // A refusal must not read as success to a script calling this.
+        if (!reply.ok) process.exitCode = 3;
+      } finally {
+        store.close();
+      }
+      break;
+    }
+
     /**
      * The handover point. Authorship stays with the model; from here the daemon
      * owns delivery, so "I sent the report" stops being a claim the model makes

package/src/daemon.ts

@@ -102,6 +102,11 @@ const GRAPH_HEALTH_INTERVAL_MS = 60_000;
  *  report an operator is waiting on must not sit in the outbox for the length of
  *  a poll interval, and delivery is owed even while claiming is paused (#123). */
 const REPORT_DELIVERY_INTERVAL_MS = 30_000;
+/** A dispatch-infra run (turn-0 git failure) is requeued so the next tick
+ *  retries — but only a bounded number of times. Three strikes for one issue
+ *  means the mirror itself is broken, not unlucky, and the sweep escalates
+ *  instead of burning a turn-0 run per tick forever (#168, #177). */
+const DISPATCH_INFRA_MAX_STRIKES = 3;
 const DEFAULT_PORT = 8787;
 const BRIEF_TEMPLATE_PATH = join(import.meta.dir, "briefs", "worker.md");
 
@@ -121,8 +126,13 @@ export interface DaemonOpts {
   project?: string;
 }
 
-/** Everything one tick touches, resolved once at startup so a tick never
- *  re-reads config mid-flight and changes its own limits underneath itself. */
+/** Everything one tick touches. `project` and `caps` are re-resolved at each
+ *  tick boundary so an operator's config edit applies on the next tick rather
+ *  than the next daemon restart (#170); a tick and the runs it admits see one
+ *  consistent snapshot, and a mid-run edit never changes a live run's labels,
+ *  model or caps — `handleIssue` destructures them at dispatch time. The rest
+ *  are resolved once at startup so a tick never re-reads config mid-flight and
+ *  changes its own limits underneath itself. */
 interface Deps {
   project: ProjectConfig;
   caps: Caps;
@@ -176,6 +186,7 @@ export function verbDeps(d: Pick<Deps, "project" | "store" | "tracker" | "verbAc
       isPaused()
         ? "claiming is paused for this fleet (omp-conductor pause, hold or halt)"
         : undefined,
+    pausedAt,
     log,
     now: () => Date.now(),
   };
@@ -288,6 +299,30 @@ export function isPaused(): boolean {
   return existsSync(join(stateDir(), "paused"));
 }
 
+/**
+ * The epoch-ms timestamp at which the current pause began, read from the same
+ * sentinel file {@link setPaused} writes (`<stateDir()>/paused`). Returns
+ * `undefined` when the fleet is not paused, or when the file's first line does
+ * not parse as a date — a legacy/blank sentinel keeps today's refuse-everything
+ * behavior, because a run admitted before an *unknown* pause cannot be proven
+ * innocent. {@link isPaused} is the authority on *whether*; this answers
+ * *since when*.
+ */
+export function pausedAt(): number | undefined {
+  const f = join(stateDir(), "paused");
+  if (!existsSync(f)) return undefined;
+  try {
+    const first = readFileSync(f, "utf8").split("\n")[0]?.trim();
+    if (first === undefined || first === "") return undefined;
+    const t = Date.parse(first);
+    return Number.isNaN(t) ? undefined : t;
+  } catch {
+    // Unreadable sentinel (permissions, corruption): fail closed like an
+    // unparseable line — refuse mutations while the pause is unprovable.
+    return undefined;
+  }
+}
+
 export function setPaused(v: boolean): void {
   const f = join(stateDir(), "paused");
   if (v) {
@@ -1709,8 +1744,19 @@ export async function admitCandidates(
   slots: number,
 ): Promise<AdmissionPass> {
   const { project, caps, tracker, store } = d;
-  const busyIssues = store.activeRuns(project.name).map((r) => r.issue);
+  const activeRuns = store.activeRuns(project.name);
+  const busyIssues = activeRuns.map((r) => r.issue);
   const busy = new Set(busyIssues);
+  // issue -> its active run rows, for the pushed-green admission bypass (#175):
+  // only a worker-free pushed-green row may be bypassed, and only when *every*
+  // active run for the issue is worker-free. A live (claimed/running) row still
+  // holds unconditionally.
+  const activeByIssue = new Map<number, RunRecord[]>();
+  for (const run of activeRuns) {
+    const list = activeByIssue.get(run.issue);
+    if (list === undefined) activeByIssue.set(run.issue, [run]);
+    else list.push(run);
+  }
   const holds: AdmissionHold[] = [];
   const hold = (issue: number, reason: AdmissionHoldReason): void => {
     holds.push({ issue, reason });
@@ -1769,8 +1815,17 @@ export async function admitCandidates(
       continue;
     }
     if (busy.has(issue)) {
-      hold(issue, "issue-active");
-      continue;
+      // A pushed-green row is worker-free by definition (it is not in
+      // LIVE_STATES): its PR is live but no process is writing to its branch.
+      // So an issue whose active runs are ALL pushed-green is not actually
+      // occupied — the corrective attempt the operator unblocked may be
+      // admitted as a continuation of that PR, and the open-PR gate below
+      // decides the identity. Any live row still holds (#175).
+      const allWorkerFree = (activeByIssue.get(issue) ?? []).every((r) => r.state === "pushed-green");
+      if (!allWorkerFree) {
+        hold(issue, "issue-active");
+        continue;
+      }
     }
 
     const priorRuns = store.attemptsFor(project.name, issue);
@@ -1888,7 +1943,8 @@ export async function admitCandidates(
         latest?.state === "blocked" ||
         latest?.state === "failed" ||
         latest?.state === "killed" ||
-        latest?.state === "orphaned"
+        latest?.state === "orphaned" ||
+        latest?.state === "pushed-green"
           ? latest
           : undefined;
       // The second half asks "is this open PR our retained work", and accepts
@@ -1966,6 +2022,24 @@ export async function dispatchAdmissions(
 // ----------------------------------------------------------------------- a tick
 
 export async function tick(d: Deps, workers?: WorkerPool): Promise<void> {
+  // A config edit takes effect on the next tick, not the next daemon restart
+  // (#170). Re-resolve the project and its caps at the tick boundary so a tick
+  // and every run it admits see one consistent snapshot; a failed read keeps
+  // the boot values rather than wedging the tick, and the next tick tries
+  // again.
+  try {
+    const cfg = loadConfig();
+    const fresh = findProject(cfg, d.project.name);
+    const freshCaps = resolveCaps(fresh, cfg.defaults);
+    if (JSON.stringify(fresh) !== JSON.stringify(d.project) || JSON.stringify(freshCaps) !== JSON.stringify(d.caps)) {
+      log(`config reloaded: project ${d.project.name} changed on disk — applying from this tick`);
+    }
+    d.project = fresh;
+    d.caps = freshCaps;
+  } catch (err) {
+    log(`config reload failed (${errText(err)}) — continuing with the values loaded at boot`);
+  }
+
   // Before the pause check, deliberately. This one is not about dispatch: the
   // orchestrator is a different process, and it can be wedged while this fleet
   // is paused — which is exactly the state the reference fleet was in when the
@@ -2643,6 +2717,14 @@ export async function classifyAndRecover(d: Deps): Promise<void> {
         }
         if (run.state === "failed" && facts.pr === "open") {
           facts.checks = await tracker.checkConclusions(run.prUrl);
+          // When a check failed with a reachable log, pull its tail so the
+          // table can tell an infra outage (#177) from a real test failure by
+          // the log's own words. First failure wins; a log that cannot be
+          // fetched is left undefined and classification stays conservative.
+          const firstFailure = facts.checks.find((c) => c.state === "failure" && c.link !== undefined);
+          if (firstFailure?.link !== undefined) {
+            facts.failingLog = await tracker.checkLog(firstFailure.link);
+          }
         }
       }
     } catch (err) {
@@ -2730,6 +2812,26 @@ async function recoverRun(
   }
 
   if (recovery === "requeue") {
+    // A dispatch-infra requeue that keeps landing on the same issue means the
+    // mirror for its repo is persistently broken — a ref-lock that retry already
+    // exhausted, a dead remote. Requeueing forever spends a turn-0 run per tick
+    // with no chance of success, so after a bounded number of strikes this
+    // escalates to a human instead (#168, #177).
+    if (cls === "dispatch-infra" && store.classCountFor(project.name, run.issue, "dispatch-infra") >= DISPATCH_INFRA_MAX_STRIKES) {
+      await safeEscalate(d, {
+        tier: 1,
+        project: project.name,
+        issue: run.issue,
+        summary: `[dispatch-infra] #${run.issue}: the mirror for ${run.repo} is failing persistently — ${evidence}`,
+        detail: [
+          `The dispatcher could not provision a worktree for #${run.issue} ${DISPATCH_INFRA_MAX_STRIKES} times in a row, all before the worker's first turn.`,
+          "The mirror on this host needs attention (check disk, SSH/HTTPS credentials, and the mirror root).",
+        ].join("\n"),
+      });
+      store.updateRun(run.id, { recoveredAt: Date.now() });
+      log(`#${run.issue} escalated from persistent ${cls}: ${evidence}`);
+      return;
+    }
     // Only when the tracker still shows this issue as ours to hand back. An
     // issue that is closed, or has no state label, was resolved by another route
     // and requeueing it would dispatch work nobody asked for.
@@ -2772,7 +2874,15 @@ async function recoverRun(
       );
     }
     if (run.lastError !== undefined && cls !== "question") detail.push(run.lastError);
-    detail.push(`Session: ${run.sessionFile ?? "(no transcript)"}`);
+    // #172: an unwritten transcript is "the run died before it flushed", not a
+    // link to a file the operator will open and find missing.
+    detail.push(
+      run.sessionFile === undefined
+        ? "Session: (no transcript)"
+        : existsSync(run.sessionFile)
+          ? `Session: ${run.sessionFile}`
+          : `Session: ${run.sessionFile} (file was never written — the run died before its transcript was flushed)`,
+    );
     // The class and the run are in the summary, which is what the notifications
     // ledger dedupes on — so one class escalates once per run rather than every
     // five minutes.

package/src/failure-class.ts

@@ -22,6 +22,10 @@ export interface ClassifyFacts {
   pr?: "open" | "merged" | "closed";
   mergeable?: "conflicting" | "clean" | "unknown";
   checks?: { name: string; state: string; link?: string }[];
+  /** Tail (ANSI-stripped) of the first failed check's log, when one was
+   *  reachable. Lets the table tell an infrastructure outage (#177) from a
+   *  deterministic test failure by the log's own words. */
+  failingLog?: string;
 }
 
 export interface Classification {
@@ -50,6 +54,24 @@ const INFRA_CHECK_STATES: Record<string, true> = {
 /** States that mean "this check has a verdict and it is good". */
 const SUCCESS_CHECK_STATES: Record<string, true> = { success: true, neutral: true };
 
+/**
+ * Substrings in a failed check's log that prove the failure was infrastructure,
+ * not the diff (#177). Each is a registry/docker/runner fault a worker cannot
+ * have introduced: a rate limit, an image-manifest resolution failure, a runner
+ * being torn down under the job, or a DNS failure. Matched lowercased against
+ * the log tail.
+ *
+ * Deliberately *not* matching bare `failed to solve:` — a docker build failure
+ * often prints it with a real resolution error, so the closing words carry the
+ * signal, not the phrase.
+ */
+const INFRA_LOG_SIGNATURES = [
+  "429 too many requests",
+  "failed to resolve source metadata for",
+  "the runner has received a shutdown signal",
+  "could not resolve host",
+];
+
 function normalise(state: string): string {
   return state.trim().toLowerCase();
 }
@@ -161,6 +183,28 @@ export function classifyRun(run: RunRecord, facts: ClassifyFacts): Classificatio
     }
   }
 
+  // Dispatch infra: the conductor's own git path failed before the worker's
+  // first turn — a mirror ref-lock (#168), a dead mirror, a transiently
+  // unreachable host. The worker never touched the issue, so this should not
+  // charge an implementation attempt. `lastError` here is written only by the
+  // dispatch catch (`errText(err)` = the stack, which prefixes the thrown
+  // "git … exited N: …" message with "Error: ") and by state messages — never
+  // by a worker — so that shape is proof of the daemon's own git, not a
+  // worker's failed push.
+  if (
+    run.state === "failed" &&
+    run.turns === 0 &&
+    !hasArtifacts &&
+    run.lastError !== undefined &&
+    /^(?:Error: )?git .+ exited \d+/s.test(run.lastError)
+  ) {
+    return {
+      cls: "dispatch-infra",
+      recovery: "requeue",
+      evidence: `dispatch failed in the conductor's own git path before turn 1: ${run.lastError.split("\n")[0]}`,
+    };
+  }
+
   if (run.state === "blocked") {
     return {
       cls: "question",
@@ -215,6 +259,24 @@ export function classifyRun(run: RunRecord, facts: ClassifyFacts): Classificatio
     const checks = facts.checks ?? [];
     const unresolved = checks.filter((c) => !SUCCESS_CHECK_STATES[normalise(c.state)] === true);
     if (checks.length > 0 && unresolved.length > 0) {
+      // A failed check whose *log* smells like infrastructure — a registry 429,
+      // a runner shutdown, a DNS failure (#177). The check has a verdict, so
+      // the check-state table above cannot call it infra; only the log can. It
+      // beats ci-deterministic because charging an implementation attempt for a
+      // rate limit is exactly the waste that class exists to prevent.
+      if (facts.failingLog !== undefined) {
+        const lower = facts.failingLog.toLowerCase();
+        for (const signature of INFRA_LOG_SIGNATURES) {
+          if (lower.includes(signature)) {
+            const check = checks.find((c) => normalise(c.state) === "failure");
+            return {
+              cls: "ci-infra",
+              recovery: "rerun-checks",
+              evidence: `infrastructure signature in ${check?.name === undefined ? "failed check" : check.name} log: "${signature}"`,
+            };
+          }
+        }
+      }
       const failing = unresolved.filter((c) => normalise(c.state) === "failure");
       if (failing.length > 0) {
         return {

package/src/orchestrator-tick.ts

@@ -400,6 +400,16 @@ export const TICK_SCOPE_CONSTRAINTS: { readonly [K in ReportScope]: string } = {
 export const TICK_DELIVERY_RULE =
   "This tick was injected locally, not sent from Telegram, so your end-of-turn text does NOT reach your operator. Hand anything reportable this turn to the durable outbox by running `omp-conductor report --text \"<the whole report>\"` (add `--kind digest` for the daily digest) and confirming it printed a report id; the daemon then owns delivery and retries until it lands. Never claim a report was sent otherwise, and never use telegram_send for a report -- that path leaves no record that it went out.";
 
+/** The {@link TICK_DELIVERY_RULE} variant for a fleet whose bridge actually
+ *  delivers the tick's ending text (#169). That is a narrower class than the
+ *  approval surface being ready: `notifyMode: "always"` has to be set, and the
+ *  profile has to be `interactive` — a `daemon` profile suppresses the
+ *  `agent_end` notify post, so its end-of-turn text reaches nobody and the
+ *  durable-outbox rule above is the honest one there. Everything here keeps the
+ *  outbox as the message; only the opening claim about delivery differs. */
+export const TICK_DELIVERY_RULE_BRIDGED =
+  "Your end-of-turn text IS delivered to the operator by the Telegram bridge (notifyMode: always). Still hand anything reportable to the durable outbox with omp-conductor report — and then close with at most one short line. The report is the message; never restate it in your closing text.";
+
 /** Re-exported so the tick's own contract stays readable from one file: the
  *  constant itself lives beside the check that decides whether it is callable. */
 export { TELEGRAM_APPROVAL_TOOL };
@@ -1195,6 +1205,29 @@ function tick(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSe
   refreshComposedBriefBestEffort();
 
   const scope = resolveTickScope();
+  // The transport contract, read once from the same file at the same moment so
+  // the approval line, the delivery rule and the narration line cannot disagree
+  // (#169, #179). No access file means no fleet channel to judge; a session
+  // with no bound bridge token means omp-telegram posts nothing, so both halves
+  // fail toward "not delivered" — the durable outbox instruction — rather than
+  // asserting a delivery the bridge cannot make.
+  const approval =
+    config.accessFile === undefined
+      ? undefined
+      : session.bridgeTokenAtStart
+        ? readApprovalSurface(config.accessFile)
+        : ({
+            kind: "missing",
+            reason:
+              `${TELEGRAM_APPROVAL_TOOL} unavailable on local ticks: omp-telegram had no bot token when this ` +
+              "session started, so it bound none and its tools stay dead however complete the access file looks " +
+              "now — run `/telegram on` in this session, or restart it, to rebind the bridge",
+          } as const);
+  const profile =
+    config.accessFile === undefined || !session.bridgeTokenAtStart
+      ? undefined
+      : readDaemonProfile(config.accessFile);
+
   // A configured message owns the ordinary reporting and delivery clauses.
   // Mechanical evidence is different: release-policy drift and repeated
   // operational friction must not disappear because an operator customized the
@@ -1205,7 +1238,8 @@ function tick(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSe
       session.scopeFallbackLogged = true;
       pi.logger.info(`[omp-conductor] tick reporting scope: using ${DEFAULT_REPORT_SCOPE} — ${scope.fallback}`);
     }
-    content = `${defaultTickMessage(new Date(), scope.briefPath, scope.policyPath)}\n${TICK_SCOPE_CONSTRAINTS[scope.scope]}\n${TICK_DELIVERY_RULE}`;
+    const bridged = approval?.kind === "ready" && approval.notifyMode === "always" && profile?.kind === "interactive";
+    content = `${defaultTickMessage(new Date(), scope.briefPath, scope.policyPath)}\n${TICK_SCOPE_CONSTRAINTS[scope.scope]}\n${bridged ? TICK_DELIVERY_RULE_BRIDGED : TICK_DELIVERY_RULE}`;
   }
   let frictionStore: Store | undefined;
   let frictionSignals: FrictionSignal[] = [];
@@ -1275,18 +1309,6 @@ function tick(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSe
   // `telegram_ask` and `telegram_send` dead until `/telegram on`. Trusting the
   // file alone there puts the tick straight back to mandating a call its surface
   // cannot make, which is #114 exactly.
-  const approval =
-    config.accessFile === undefined
-      ? undefined
-      : session.bridgeTokenAtStart
-        ? readApprovalSurface(config.accessFile)
-        : ({
-            kind: "missing",
-            reason:
-              `${TELEGRAM_APPROVAL_TOOL} unavailable on local ticks: omp-telegram had no bot token when this ` +
-              "session started, so it bound none and its tools stay dead however complete the access file looks " +
-              "now — run `/telegram on` in this session, or restart it, to rebind the bridge",
-          } as const);
   if (approval?.kind === "missing") {
     content = `${content}\n${TICK_APPROVAL_UNAVAILABLE_RULE}`;
     if (!session.approvalToolMissingLogged) {
@@ -1318,10 +1340,6 @@ function tick(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSe
   // live bridge whose profile is not `daemon`.
   //
   // No `accessFile` means no fleet bridge to judge, exactly as above.
-  const profile =
-    config.accessFile === undefined || !session.bridgeTokenAtStart
-      ? undefined
-      : readDaemonProfile(config.accessFile);
   if (profile?.kind === "interactive") content = `${content}\n${TICK_NARRATION_RULE}`;
 
   try {

package/src/store.ts

@@ -61,7 +61,7 @@ export const LIVE_STATES: readonly RunState[] = ["claimed", "running"];
  * worktrees removed, so they must not consume slots, while their live PRs must
  * still block duplicate attempts.
  */
-const ACTIVE_STATES: readonly RunState[] = [...LIVE_STATES, "pushed-pending", "pushed-green"];
+export const ACTIVE_STATES: readonly RunState[] = [...LIVE_STATES, "pushed-pending", "pushed-green"];
 
 const LIVE_PLACEHOLDERS = LIVE_STATES.map(() => "?").join(", ");
 const ACTIVE_PLACEHOLDERS = ACTIVE_STATES.map(() => "?").join(", ");
@@ -773,12 +773,19 @@ export function openStore(dbPath: string): Store {
   const countFailures = db.query<{ n: number }, [string, number]>(
     `SELECT COUNT(*) AS n FROM runs
       WHERE project = ? AND issue = ? AND state = 'failed'
-        AND (failureClass IS NULL OR failureClass NOT IN ('ci-infra', 'settlement-stuck', 'env-start-failure'))`,
+        AND (failureClass IS NULL OR failureClass NOT IN ('ci-infra', 'settlement-stuck', 'env-start-failure', 'dispatch-infra'))`,
   );
   const countContinuations = db.query<{ n: number }, [string, number]>(
     `SELECT COUNT(*) AS n FROM runs
       WHERE project = ? AND issue = ? AND state IN ('killed', 'orphaned', 'blocked')
-        AND (failureClass IS NULL OR failureClass NOT IN ('admin-kill', 'settlement-stuck', 'env-start-failure'))`,
+        AND (failureClass IS NULL OR failureClass NOT IN ('admin-kill', 'settlement-stuck', 'env-start-failure', 'dispatch-infra'))`,
+  );
+  // How many times one issue reached a given class. Recovery uses it to bound a
+  // retry loop whose cause is persistent (e.g. a mirror that will not refresh):
+  // after `DISPATCH_INFRA_MAX_STRIKES` the daemon escalates instead of looping.
+  const countByClass = db.query<{ n: number }, [string, number, FailureClass]>(
+    `SELECT COUNT(*) AS n FROM runs
+      WHERE project = ? AND issue = ? AND failureClass = ?`,
   );
   // Newest first, and bounded: every row this returns costs `gh` calls to gather
   // facts for, so a fleet with a long unclassified history classifies over
@@ -1142,6 +1149,10 @@ export function openStore(dbPath: string): Store {
       return countContinuations.get(project, issue)?.n ?? 0;
     },
 
+    classCountFor(project: string, issue: number, cls: FailureClass): number {
+      return countByClass.get(project, issue, cls)?.n ?? 0;
+    },
+
     latestRun(project: string, issue: number): RunRecord | undefined {
       const row = selectLatestRun.get(project, issue);
       return row ? toRecord(row) : undefined;

package/src/tracker/github.ts

@@ -695,6 +695,22 @@ export function makeTracker(p: ProjectConfig, runGh: typeof gh = gh): Tracker {
       }
     },
 
+    async checkLog(detailsUrl: string): Promise<string | undefined> {
+      const args = runLogArgs(detailsUrl);
+      if (args === undefined) return undefined;
+      try {
+        const raw = await runGh(args);
+        const lines = raw.replaceAll(/\u001b\[[0-9;]*m/g, "").split("\n");
+        return lines.slice(-400).join("\n");
+      } catch {
+        // Best-effort, never throws: a revoked token, a deleted run or a flaky
+        // network must not error the classifier out of gathering facts. The
+        // caller treats `undefined` as "could not read the log" and classifies
+        // conservatively (#177).
+        return undefined;
+      }
+    },
+
     async mergeable(prUrl: string): Promise<"conflicting" | "clean" | "unknown"> {
       if (!PR_URL.test(prUrl)) return "unknown";
       try {

package/src/types.ts

@@ -766,6 +766,12 @@ export interface Tracker {
    * port: nothing downstream may read it as "no checks failed".
    */
   checkConclusions(prUrl: string): Promise<{ name: string; state: string; link?: string }[]>;
+  /** The tail of a failed workflow run's log, ANSI stripped, or `undefined`
+   *  when it cannot be fetched. Best-effort, never throws: the classifier uses
+   *  it to tell an infrastructure outage from a deterministic test failure
+   *  (#177), and "could not read the log" must fall through to the existing
+   *  conservative classification rather than error out of fact-gathering. */
+  checkLog(detailsUrl: string): Promise<string | undefined>;
   /** Whether the PR can merge into its base. `unknown` on any doubt, so a
    *  mergeability nobody could read never becomes a conflict recovery. */
   mergeable(prUrl: string): Promise<"conflicting" | "clean" | "unknown">;
@@ -803,6 +809,7 @@ export const FAILURE_CLASSES = [
   "admin-kill",
   "ci-infra",
   "ci-deterministic",
+  "dispatch-infra",
   "merge-conflict",
   "question",
   "orphan-clean",
@@ -1155,6 +1162,10 @@ export interface Store {
   failuresFor(project: string, issue: number): number;
   /** Operational stops that require a bounded continuation resume. */
   continuationsFor(project: string, issue: number): number;
+  /** How many times one issue has reached a given failure class. A recovery
+   *  that keeps landing on the same class (e.g. a persistently broken mirror)
+   *  uses this to escalate instead of retrying forever. */
+  classCountFor(project: string, issue: number, cls: FailureClass): number;
   /** Newest attempt for one issue, whatever state it reached. `omp-conductor
    *  tail` resolves an issue number to a transcript through this; the number is
    *  what an operator has, the run id is not. */
@@ -1321,6 +1332,7 @@ export const VERB_NAMES = [
   "conductor_push",
   "conductor_pr_create",
   "conductor_pr_update_branch",
+  "conductor_pr_update",
   "conductor_pr_merge",
   "conductor_label",
   "conductor_release",

package/src/unblock.ts

@@ -40,6 +40,10 @@ export interface UnblockOutcome {
   continuationsUsed: number;
   /** Newest attempt, when the store has one for this issue at all. */
   latest?: RunRecord;
+  /** Whether any run for the issue is still in an active state — the answer
+   *  to "will the dispatcher hold this issue as issue-active?" that #178
+   *  found this verb guessing at. */
+  active: boolean;
   /** Set when nothing was cleared because the newest attempt's work exists
    *  only in its worktree. Carries the salvage failure verbatim. */
   refused?: string;
@@ -92,10 +96,12 @@ export async function unblockIssue(
   // for clearing in-progress, so the row that carries it decides the set.
   const latest = store.latestRun(project.name, issue);
   const terminal = latest !== undefined && !LIVE_STATES.includes(latest.state);
+  const active = store.activeRuns(project.name).some((r) => r.issue === issue);
   const counts = {
     attemptsUsed: store.attemptsFor(project.name, issue),
     failuresUsed: store.failuresFor(project.name, issue),
     continuationsUsed: store.continuationsFor(project.name, issue),
+    active,
   };
 
   // The one case where this verb refuses. Clearing the labels here re-queues an
@@ -205,8 +211,31 @@ export function formatUnblock(
         `run row to prove the worker is gone, "${project.stateLabels.inProgress}" was left in place, and ` +
         "on its own it keeps the issue ineligible",
     );
+  } else if (latest.state === "pushed-green" || latest.state === "pushed-pending") {
+    // #178: an unblocked issue whose newest run pushed a green PR is not "free
+    // for a fresh attempt" — the dispatcher continues the pushed run's branch,
+    // and only once the PR resolves does the issue settle (#175). Say that
+    // instead of promising a re-claim the next tick withholds.
+    lines.push(
+      latest.prUrl === undefined
+        ? `  next tick  eligible again, as long as the issue still carries "${project.queueLabel}" ` +
+            `(newest run is ${latest.state} with no recorded PR; the dispatcher still applies its open-PR check at claim time)`
+        : `  next tick  eligible as a continuation of ${latest.prUrl} — the pushed run stays active until ` +
+            "that PR resolves; dispatch continues on its branch",
+    );
+  } else if (o.active) {
+    // A run other than the newest is still active (e.g. a live sibling under a
+    // terminal newest row), so the dispatcher will hold the issue as
+    // issue-active whatever the labels now say. #178's misleading case.
+    lines.push(
+      `  in flight  a run for this issue is still active, so the dispatcher holds the issue until it settles — ` +
+        `nothing is re-claimed before then ("${project.stateLabels.inProgress}" stays unless already released)`,
+    );
   } else {
-    lines.push(`  next tick  eligible again, as long as the issue still carries "${project.queueLabel}"`);
+    lines.push(
+      `  next tick  eligible again, as long as the issue still carries "${project.queueLabel}" ` +
+        "(the dispatcher still applies its open-PR check at claim time)",
+    );
   }
 
   return lines.join("\n");

package/src/verbs/actions.ts

@@ -97,6 +97,14 @@ export function githubVerbActions(project: ProjectConfig, run: CommandRunner = s
 
     updatePrBranch: (prUrl) => gh(["pr", "update-branch", prUrl]),
 
+    updatePr: async (prUrl, fields) => {
+      const argv = ["pr", "edit", prUrl];
+      if (fields.title !== undefined) argv.push("--title", fields.title);
+      if (fields.body !== undefined) argv.push("--body", fields.body);
+      const outcome = await gh(argv);
+      return outcome.ok ? { ok: true } : { ok: false, stderr: outcome.stderr };
+    },
+
     // `--match-head-commit` is the server-side half of the exact-head rule: the
     // daemon already re-read the head and refused a stale one, and this makes
     // GitHub refuse too if the branch moved in the milliseconds between. Belt

package/src/verbs/protocol.ts

@@ -145,6 +145,35 @@ export const VERB_SPECS: Readonly<Record<VerbName, VerbSpec>> = {
     },
     roleRefusalText: (role) => `conductor_pr_update_branch is not open to a ${role} session.`,
   },
+  conductor_pr_update: {
+    name: "conductor_pr_update",
+    mutating: true,
+    allowedRoles: ["worker", "orchestrator"],
+    description:
+      "Update this run's pull request title and/or body. Never touches base, head or state — " +
+      "a field you may not change is a field this verb refuses rather than renames. A worker " +
+      "may only name its own run's PR.",
+    args: {
+      prUrl: {
+        type: "string",
+        required: false,
+        description:
+          "Full pull request URL. Required on an orchestrator channel; a run channel infers its own PR.",
+      },
+      title: {
+        type: "string",
+        required: false,
+        description: "New pull request title. At least one of title/body must be a non-empty string.",
+      },
+      body: {
+        type: "string",
+        required: false,
+        description: "New pull request body. At least one of title/body must be a non-empty string.",
+      },
+      rationale: RATIONALE_ARG,
+    },
+    roleRefusalText: (role) => `conductor_pr_update is not open to a ${role} session.`,
+  },
   conductor_pr_merge: {
     name: "conductor_pr_merge",
     mutating: true,

package/src/verbs/server.ts

@@ -145,6 +145,10 @@ export interface VerbActions {
     opts: { title: string; body: string; base: string },
   ): Promise<{ ok: true; url: string } | { ok: false; stderr: string }>;
   updatePrBranch(prUrl: string): Promise<ActionOutcome>;
+  updatePr(
+    prUrl: string,
+    fields: { title?: string; body?: string },
+  ): Promise<{ ok: true } | { ok: false; stderr: string }>;
   mergePr(prUrl: string, headSha: string): Promise<ActionOutcome>;
   setLabel(issue: number, label: string, action: "add" | "remove"): Promise<ActionOutcome>;
   release(execution: ReleaseExecution): Promise<ActionOutcome>;
@@ -167,6 +171,14 @@ export interface VerbDeps {
    * sentinel alongside disarming ticks, so one read covers both.
    */
   fleetStop: () => string | undefined;
+  /**
+   * The epoch-ms timestamp the current pause began, or `undefined` when not
+   * paused (or when the sentinel does not parse). Lets the fleet-stop gate tell
+   * a mutating call from a run admitted *before* the pause — that run may
+   * finish — apart from one admitted after, which must be refused. Parallels
+   * {@link VerbDeps.fleetStop} by living behind the same per-call read.
+   */
+  pausedAt: () => number | undefined;
   log: (message: string) => void;
   now: () => number;
 }
@@ -387,17 +399,11 @@ async function decide(deps: VerbDeps, channel: VerbChannel, raw: unknown): Promi
     );
   }
 
-  // 3. Stop always wins, and is re-read here rather than remembered. Reads are
-  //    exempt: a run finishing its report during a `hold` still has to be able
-  //    to say what it saw, and refusing that would only make it guess.
-  const stopped = spec.mutating ? deps.fleetStop() : undefined;
-  if (stopped !== undefined) {
-    return refuse("fleet-paused", `refused: ${stopped}. Mutating verbs are refused while the fleet is stopped.`);
-  }
-
-  // 4. The run's own row, re-read. A worker whose run was killed, orphaned or
+  // 3. The run's own row, re-read. A worker whose run was killed, orphaned or
   //    settled between its last turn and this call is no longer holding
-  //    anything, and a push from it would land work nothing is tracking.
+  //    anything, and a push from it would land work nothing is tracking. Read
+  //    *before* the stop gate below, because the stop gate needs this row to
+  //    tell an in-flight run (which may finish) from a post-pause call.
   let run: RunRecord | undefined;
   if (channel.kind === "run") {
     run = deps.store.getRun(channel.runId);
@@ -409,6 +415,22 @@ async function decide(deps: VerbDeps, channel: VerbChannel, raw: unknown): Promi
     }
   }
 
+  // 4. Stop always wins, and is re-read here rather than remembered. Reads are
+  //    exempt: a run finishing its report during a `hold` still has to be able
+  //    to say what it saw, and refusing that would only make it guess. A run
+  //    admitted *before* the pause may finish its in-flight mutations — pause
+  //    stops new claims, not the work already running (#174) — so only a call
+  //    whose run started at or after the pause (or an orchestrator's call, with
+  //    no run row at all) is refused.
+  const stopped = spec.mutating ? deps.fleetStop() : undefined;
+  if (stopped !== undefined) {
+    const at = deps.pausedAt();
+    const admittedBeforePause = run !== undefined && at !== undefined && run.startedAt < at;
+    if (!admittedBeforePause) {
+      return refuse("fleet-paused", `refused: ${stopped}. The pause stops new claims and new mutations; a run admitted before the pause may finish.`);
+    }
+  }
+
   switch (verb) {
     case "conductor_push":
       return pushVerb(deps, channel, args, refuse, allow);
@@ -416,6 +438,8 @@ async function decide(deps: VerbDeps, channel: VerbChannel, raw: unknown): Promi
       return prCreateVerb(deps, project, channel, args, refuse, allow);
     case "conductor_pr_update_branch":
       return prUpdateBranchVerb(deps, project, channel, args, refuse, allow);
+    case "conductor_pr_update":
+      return prUpdateVerb(deps, project, channel, args, refuse, allow);
     case "conductor_pr_merge":
       return prMergeVerb(deps, project, channel, args, refuse, allow);
     case "conductor_label":
@@ -530,6 +554,18 @@ async function prCreateVerb(
     );
   }
   if (closer !== undefined) {
+    // Adoption (#176): a continuation run is never bound to its issue's existing
+    // PR — the old row owns the prUrl, and this new row's prUrl stayed NULL — so
+    // when the open PR was opened from *this* run's branch, it is the same work.
+    // Bind it to this run instead of refusing: pr_status then answers from the
+    // live PR, and a merge can act on it. Branch mismatch (or an empty headRefName,
+    // which is never identity) keeps the recorded refusal.
+    if (closer.headRefName !== "" && closer.headRefName === run.branch) {
+      deps.store.updateRun(run.runId, { prUrl: closer.url });
+      return allow(
+        `adopted ${closer.url} — already open for ${run.branch} and closes #${run.issue}; title/body arguments were not applied`,
+      );
+    }
     return refuse("open-pr-exists", `refused: ${closer.url} is already open and already closes #${run.issue}.`);
   }
 
@@ -925,6 +961,73 @@ async function prStatusVerb(
   return allow(`${prUrl} at ${headSha}: ${verification.status} — ${verification.reason}`, undefined, issue);
 }
 
+/**
+ * Update one pull request's title and/or body — nothing else.
+ *
+ * Same resolution as {@link prStatusVerb}: a worker edits its own run's PR (and
+ * only that one), an orchestrator names one this project's runs opened.
+ * `conductor_pr_update` exists so the floor's own edits go through the same
+ * checks and the same ledger as every other mutation, instead of a raw
+ * `gh pr edit` from a session that already disclosed it would do exactly that
+ * (#176).
+ */
+async function prUpdateVerb(
+  deps: VerbDeps,
+  project: ProjectConfig,
+  channel: VerbChannel,
+  args: Record<string, unknown>,
+  refuse: Refuse,
+  allow: Allow,
+): Promise<Verdict> {
+  const asked = args["prUrl"];
+  let prUrl: string;
+  let issue: number | undefined;
+
+  if (channel.kind === "run") {
+    const own = deps.store.getRun(channel.runId);
+    if (own?.prUrl === undefined) {
+      return refuse("pr-missing", "refused: this run has no pull request yet. Open one with conductor_pr_create.");
+    }
+    if (typeof asked === "string" && asked !== own.prUrl) {
+      return refuse(
+        "pr-not-this-run",
+        `refused: this socket belongs to the run for #${channel.issue}, whose pull request is ${own.prUrl}. ` +
+          "A worker edits only its own run's PR.",
+      );
+    }
+    prUrl = own.prUrl;
+    issue = channel.issue;
+  } else {
+    if (typeof asked !== "string") {
+      return refuse("malformed-argument", "refused: conductor_pr_update needs prUrl when it has no run to infer one from.");
+    }
+    const target = runForPr(deps, project.name, asked);
+    if (target === undefined) {
+      return refuse("pr-not-this-run", `refused: ${asked} is not a pull request any run in ${project.name} opened.`);
+    }
+    prUrl = asked;
+    issue = target.issue;
+  }
+
+  const title = args["title"];
+  const body = args["body"];
+  if (!(typeof title === "string" && title !== "") && !(typeof body === "string" && body !== "")) {
+    return refuse(
+      "malformed-argument",
+      "refused: conductor_pr_update changes nothing unless at least one of title or body is a non-empty string.",
+    );
+  }
+
+  const outcome = await deps.actions.updatePr(prUrl, {
+    ...(typeof title === "string" && title !== "" ? { title } : {}),
+    ...(typeof body === "string" && body !== "" ? { body } : {}),
+  });
+  if (!outcome.ok) {
+    return refuse("action-failed", `refused: gh could not update the pull request:\n${outcome.stderr}`, issue);
+  }
+  return allow(`updated ${prUrl}.`, undefined, issue);
+}
+
 // ------------------------------------------------------------------ the listener
 
 export interface VerbListener {

package/src/worktree.ts

@@ -108,6 +108,29 @@ async function gitSucceeds(args: string[], cwd?: string): Promise<boolean> {
   return code === 0;
 }
 
+/** Fences the block below so it can be found, replaced, and never duplicated. */
+const REF_LOCK_SIGNATURES = /cannot lock ref|unable to update local ref/i;
+
+/**
+ * Refreshes a bare mirror's refs from its remote. Two dispatch loops can race
+ * on git's *packed-refs* / ref locks for the same repo and one lands a transient
+ * `cannot lock ref` / `unable to update local ref` — that is not corruption, but
+ * an {@link ensureMirror} that throws on it aborts the whole dispatch at turn 0
+ * and chars a failed attempt (#168). Retry once after a short backoff; a second
+ * failure (or any non-ref-lock failure) propagates unchanged, so a genuinely
+ * broken mirror still surfaces loudly.
+ */
+async function refreshMirror(mirrorPath: string): Promise<string> {
+  try {
+    return await git(["remote", "update", "--prune"], mirrorPath);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (!REF_LOCK_SIGNATURES.test(message)) throw err;
+    await new Promise<void>((r) => setTimeout(r, 500));
+    return git(["remote", "update", "--prune"], mirrorPath);
+  }
+}
+
 /** Fences the block below so it can be found, replaced, and never duplicated. */
 const EXCLUDE_BEGIN = "# >>> omp-conductor (managed; edit outside this block)";
 const EXCLUDE_END = "# <<< omp-conductor";
@@ -262,7 +285,7 @@ export async function ensureMirror(
 
   if (existsSync(mirrorPath)) {
     await configureMirror(mirrorPath);
-    await git(["remote", "update", "--prune"], mirrorPath);
+    await refreshMirror(mirrorPath);
     return mirrorPath;
   }