omp-conductor 0.3.21 → 0.3.23

package/src/board.ts

@@ -14,6 +14,7 @@ import { probeCodeGraph, type CodeGraphHealth } from "./graph-health.ts";
 import { healthCheck, livingDaemon } from "./lifecycle.ts";
 import { dbPath, openStore } from "./store.ts";
 import { formatTranscriptLine } from "./transcript.ts";
+import { makeTracker } from "./tracker/github.ts";
 import type { AdmissionHoldReason, ProjectConfig, RunRecord, RunState, Store } from "./types.ts";
 
 const REFRESH_MS = 1_000;
@@ -35,23 +36,52 @@ const YELLOW = `${CSI}33m`;
 const RED = `${CSI}31m`;
 const MAGENTA = `${CSI}35m`;
 
+/**
+ * The board's lanes, in operator reading order.
+ *
+ * Each entry used to carry the `RunState[]` that filled it, which is the defect
+ * #109 reports: a lane filled from the newest run row answers "what happened
+ * last" under a heading an operator reads as "what needs action". Membership is
+ * now decided once, by {@link laneOf}, from state that is true right now.
+ */
 const COLUMN_DEFS = [
-  { key: "queue", title: "QUEUE", states: [] },
-  { key: "claimed", title: "CLAIMED", states: ["claimed"] },
-  { key: "running", title: "RUNNING", states: ["running"] },
-  { key: "green", title: "GREEN", states: ["pushed-pending", "pushed-green"] },
-  { key: "blocked", title: "BLOCKED", states: ["blocked"] },
-  { key: "failed", title: "FAILED", states: ["failed", "killed", "orphaned"] },
-  { key: "merged", title: "MERGED", states: ["merged"] },
-] as const satisfies readonly { key: string; title: string; states: readonly RunState[] }[];
-
-type ColumnKey = (typeof COLUMN_DEFS)[number]["key"];
+  { key: "queue", title: "QUEUE" },
+  { key: "claimed", title: "CLAIMED" },
+  { key: "running", title: "RUNNING" },
+  { key: "green", title: "GREEN" },
+  { key: "blocked", title: "BLOCKED" },
+  { key: "failed", title: "FAILED" },
+  { key: "orphaned", title: "ORPHANED" },
+  { key: "merged", title: "MERGED" },
+  { key: "history", title: "HISTORY" },
+] as const satisfies readonly { key: string; title: string }[];
+
+export type BoardLane = (typeof COLUMN_DEFS)[number]["key"];
+
+/** Run states that mean a worker process or an open pull request exists *now*,
+ *  and the lane each is drawn in. Being in this table is why the store outranks
+ *  every label in {@link laneOf}: no label is more current than a live run. */
+const LIVE_LANES: Partial<Record<RunState, BoardLane>> = {
+  claimed: "claimed",
+  running: "running",
+  "pushed-pending": "green",
+  "pushed-green": "green",
+};
+
 type DaemonBoardState = "stopped" | "ok" | "unreachable" | "other-project";
 
-interface QueueCard {
-  kind: "queue";
+/**
+ * A card the board can only describe from tracker state, because the store has
+ * no run row for the issue: it was placed by a label it currently carries, or
+ * by an admission hold recorded in the latest tick.
+ */
+interface IssueCard {
+  kind: "issue";
   issue: number;
-  reason: AdmissionHoldReason;
+  /** Why it is in this lane: the hold keeping it out of dispatch, or the label. */
+  reason: string;
+  /** Where that fact came from, in one short line. */
+  note: string;
 }
 
 interface RunCard {
@@ -59,7 +89,7 @@ interface RunCard {
   run: RunRecord;
 }
 
-type BoardCard = QueueCard | RunCard;
+type BoardCard = IssueCard | RunCard;
 
 export interface BoardHealth {
   layers: FleetLayers;
@@ -68,10 +98,44 @@ export interface BoardHealth {
   codeGraph?: CodeGraphHealth;
 }
 
+/**
+ * Which issues currently carry each label the board reasons about, read from
+ * the tracker rather than inferred from run rows.
+ *
+ * The store cannot answer this. It only knows what it did itself, so a label a
+ * human added or removed, and an issue closed out from under a run row, are
+ * both invisible to it — which is how eleven historical terminal runs were
+ * drawn as failed work on 2026-08-08 (#109).
+ */
+export interface BoardLabels {
+  /** Open issues carrying `ProjectConfig.queueLabel` — what dispatches next. */
+  queued: ReadonlySet<number>;
+  inProgress: ReadonlySet<number>;
+  blocked: ReadonlySet<number>;
+  failed: 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
+   *  good ones: blanking QUEUE and FAILED is a louder lie than showing them
+   *  stale, so the failure is reported in the header instead. */
+  error?: string;
+}
+
+/** The sets before the first read lands, and the fallback when a read has never
+ *  succeeded. `readAt: 0` is what {@link labelFact} reads as "unread". */
+const UNREAD_LABELS: BoardLabels = {
+  queued: new Set<number>(),
+  inProgress: new Set<number>(),
+  blocked: new Set<number>(),
+  failed: new Set<number>(),
+  readAt: 0,
+};
+
 export interface BoardSnapshot {
   project: ProjectConfig;
   status: StatusSnapshot;
   health: BoardHealth;
+  labels: BoardLabels;
   runs: RunRecord[];
   now: number;
 }
@@ -91,7 +155,7 @@ interface KeyInput {
   ctrl?: boolean;
 }
 
-function ansiColor(key: ColumnKey): string {
+function ansiColor(key: BoardLane): string {
   switch (key) {
     case "running":
       return CYAN;
@@ -100,9 +164,12 @@ function ansiColor(key: ColumnKey): string {
       return GREEN;
     case "claimed":
     case "blocked":
+    case "orphaned":
       return YELLOW;
     case "failed":
       return RED;
+    case "history":
+      return DIM;
     default:
       return MAGENTA;
   }
@@ -147,36 +214,145 @@ function humanDuration(ms: number): string {
   return `${Math.floor(hours / 24)}d ${hours % 24}h`;
 }
 
-function queueCards(snapshot: BoardSnapshot): QueueCard[] {
-  const cards: QueueCard[] = [];
-  const seen = new Set<number>();
+/**
+ * The board's single lane rule.
+ *
+ * `omp-conductor board` answers one operator question — "what needs action, and
+ * what will dispatch next?" — so every lane has to be a statement about state
+ * *now*. What an issue's newest run row last did is a different question, and
+ * answering it under an operational heading is the 2026-08-08 dogfood failure
+ * in #109: the board read `FAILED 11` on conductor 0.3.19 while the tracker
+ * carried four `agent:failed` issues (#82, #140, #297, #307). The other seven
+ * were two requeued issues also drawn in QUEUE (#43, #321), a deliberately
+ * protected dirty orphan (#319), two closed issues (#135, #310) and two open
+ * parent issues a human had already cleared (#81, #86) — every one of them a
+ * historical terminal run, not one of them failed work.
+ *
+ * So: the store decides the live lanes, because a running worker is the most
+ * current fact there is; the tracker's current labels decide every stopped
+ * lane; each issue matches exactly once, first branch wins; and last-run
+ * history is answered in HISTORY, under its own name.
+ */
+function laneOf(
+  snapshot: BoardSnapshot,
+  issue: number,
+  run: RunRecord | undefined,
+  queued: ReadonlySet<number>,
+): BoardLane | undefined {
+  const live = run === undefined ? undefined : LIVE_LANES[run.state];
+  if (live !== undefined) return live;
+
+  const { labels } = snapshot;
+  // State labels outrank the queue label, because that is the order
+  // `routing.isEligible` reads them in: it requires the queue label AND the
+  // absence of all three state labels, so an issue carrying both will never be
+  // dispatched no matter how queued it looks. Drawing it under QUEUE — "waiting
+  // for dispatch" — is the same class of lie as #109 itself, just inverted, and
+  // it is not hypothetical: veltro#319 on 2026-08-09 carried `ready-for-agent`
+  // and `agent:in-progress` together, so a queue-first rule puts the protected
+  // dirty orphan back in the queue lane this issue moved it out of.
+  if (labels.failed.has(issue)) return "failed";
+  if (labels.blocked.has(issue)) return "blocked";
+  // The tracker says a worker owns this issue and the store says none is
+  // running. Nothing will touch it until a human does, and its worktree is kept
+  // because it may hold uncommitted work: that is a protected orphan, and
+  // calling it a failure is what put #319 under FAILED.
+  if (labels.inProgress.has(issue)) return "orphaned";
+  // What is left carrying the queue label really is next up, held or not.
+  // Requeued work is queued work: #43 and #321 carried `ready-for-agent` and a
+  // terminal newest run at the same time, and with no state label on them the
+  // label is the whole of what happens next.
+  if (queued.has(issue)) return "queue";
+  if (run?.state === "merged") return "merged";
+  if (run === undefined) return undefined;
+  // 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.
+  return (run.endedAt ?? run.startedAt) >= snapshot.now - MERGED_HISTORY_MS ? "history" : undefined;
+}
+
+/** Description lines for an issue the store has no run row for. Only the lanes
+ *  a label or a hold can place on their own reach this: queue, failed, blocked
+ *  and orphaned. */
+function issueCard(
+  snapshot: BoardSnapshot,
+  issue: number,
+  lane: BoardLane,
+  holds: ReadonlyMap<number, AdmissionHoldReason>,
+): IssueCard {
+  const hold = holds.get(issue);
+  if (lane === "queue") {
+    return hold === undefined
+      ? { kind: "issue", issue, reason: "queued", note: "waiting for dispatch" }
+      : { kind: "issue", issue, reason: hold.replaceAll("-", " "), note: "held in latest tick" };
+  }
+  const { blocked, failed, inProgress } = snapshot.project.stateLabels;
+  const label = lane === "failed" ? failed : lane === "blocked" ? blocked : inProgress;
+  return { kind: "issue", issue, reason: label, note: "no run recorded" };
+}
+
+/** The whole board, partitioned. Rebuilt per call rather than cached: it is
+ *  tens of issues wide and redraws once a second, so a cache would buy nothing
+ *  and would go stale the moment a caller mutated a snapshot in place. */
+function laneCards(snapshot: BoardSnapshot): Map<BoardLane, BoardCard[]> {
+  const lanes = new Map<BoardLane, BoardCard[]>();
+  for (const column of COLUMN_DEFS) lanes.set(column.key, []);
+
+  // `recentRuns` already yields the newest attempt per issue; indexing it keeps
+  // one card per issue even if a caller hands over a wider run list.
+  const newest = new Map<number, RunRecord>();
+  for (const run of snapshot.runs) if (!newest.has(run.issue)) newest.set(run.issue, run);
+
+  // Holds name issues the latest dispatch pass looked at and kept back, so they
+  // are queue members by definition. They join the label set rather than
+  // replacing it: the label read is authoritative and uncapped, while the hold
+  // sample is bounded to five per reason but survives a tracker read that just
+  // failed.
+  const queued = new Set<number>(snapshot.labels.queued);
+  const holds = new Map<number, AdmissionHoldReason>();
   for (const hold of snapshot.status.dispatch?.holds ?? []) {
     for (const issue of hold.issues) {
-      if (seen.has(issue)) continue;
-      seen.add(issue);
-      cards.push({ kind: "queue", issue, reason: hold.reason });
+      queued.add(issue);
+      if (!holds.has(issue)) holds.set(issue, hold.reason);
     }
   }
-  return cards;
+
+  const place = (issue: number, run: RunRecord | undefined): void => {
+    const lane = laneOf(snapshot, issue, run, queued);
+    if (lane === undefined) return;
+    lanes.get(lane)!.push(run === undefined ? issueCard(snapshot, issue, lane, holds) : { kind: "run", run });
+  };
+
+  for (const [issue, run] of newest) place(issue, run);
+  // Issues the tracker knows about that this store never ran, or whose run rows
+  // have aged out. FAILED has to count them: the operator is asking how many
+  // issues are failed, not how many failures this database still remembers.
+  const labelled = [...queued, ...snapshot.labels.failed, ...snapshot.labels.blocked, ...snapshot.labels.inProgress];
+  for (const issue of [...new Set(labelled)].sort((a, b) => a - b)) {
+    if (!newest.has(issue)) place(issue, undefined);
+  }
+  return lanes;
 }
 
-function cardsFor(snapshot: BoardSnapshot, key: ColumnKey): BoardCard[] {
-  if (key === "queue") return queueCards(snapshot);
-  const states: readonly RunState[] = COLUMN_DEFS.find((column) => column.key === key)?.states ?? [];
-  return snapshot.runs.filter((run) => states.includes(run.state)).map((run) => ({ kind: "run", run }));
+function cardsFor(snapshot: BoardSnapshot, key: BoardLane): BoardCard[] {
+  return laneCards(snapshot).get(key) ?? [];
 }
 
-function columnCount(snapshot: BoardSnapshot, key: ColumnKey): number {
-  if (key === "queue") return snapshot.status.dispatch?.ready ?? 0;
-  return cardsFor(snapshot, key).length;
+/** Issue numbers per lane, in render order. Exported so the lane rule can be
+ *  asserted directly — including that no issue is in two lanes, the defect this
+ *  model exists to make impossible. */
+export function boardLanes(snapshot: BoardSnapshot): Map<BoardLane, number[]> {
+  const lanes = new Map<BoardLane, number[]>();
+  for (const [lane, cards] of laneCards(snapshot)) lanes.set(lane, cards.map(cardIssue));
+  return lanes;
 }
 
 function cardIssue(card: BoardCard): number {
-  return card.kind === "queue" ? card.issue : card.run.issue;
+  return card.kind === "issue" ? card.issue : card.run.issue;
 }
 
 function cardKey(card: BoardCard): string {
-  return card.kind === "queue" ? `queue:${card.issue}` : `run:${card.run.id}`;
+  return card.kind === "issue" ? `issue:${card.issue}` : `run:${card.run.id}`;
 }
 
 function focusedCard(snapshot: BoardSnapshot, cursor: BoardCursor): BoardCard | undefined {
@@ -249,13 +425,9 @@ function runCardLines(run: RunRecord, snapshot: BoardSnapshot): string[] {
   return lines;
 }
 
-function queueCardLines(card: QueueCard): string[] {
-  return [`#${card.issue}`, card.reason.replaceAll("-", " "), "held in latest tick"];
-}
-
 function renderColumn(
   snapshot: BoardSnapshot,
-  key: ColumnKey,
+  key: BoardLane,
   title: string,
   selectedColumn: boolean,
   selectedCard: number,
@@ -263,7 +435,6 @@ function renderColumn(
   height: number,
 ): string[] {
   const cards = cardsFor(snapshot, key);
-  const count = columnCount(snapshot, key);
   const color = ansiColor(key);
   const slots = Math.max(1, Math.floor(Math.max(0, height - 2) / 5));
   const start = selectedColumn
@@ -271,16 +442,15 @@ function renderColumn(
     : 0;
   const shown = cards.slice(start, start + slots);
   const lines = [
-    styledCell(` ${title} ${count}`, width, `${BOLD}${color}`),
+    styledCell(` ${title} ${cards.length}`, width, `${BOLD}${color}`),
     styledCell(start === 0 ? "─".repeat(width) : ` ↑ ${start} earlier`, width, DIM),
   ];
 
   if (cards.length === 0) {
-    const empty = key === "queue" && count > 0 ? `${count} ready; no hold sample` : "(empty)";
-    lines.push(styledCell(` ${empty}`, width, DIM));
+    lines.push(styledCell(" (empty)", width, DIM));
   } else {
     for (const [offset, card] of shown.entries()) {
-      const raw = card.kind === "run" ? runCardLines(card.run, snapshot) : queueCardLines(card);
+      const raw = card.kind === "run" ? runCardLines(card.run, snapshot) : [`#${card.issue}`, card.reason, card.note];
       while (raw.length < 4) raw.push("");
       const selected = selectedColumn && start + offset === selectedCard;
       for (const [lineIndex, value] of raw.entries()) {
@@ -315,13 +485,24 @@ function healthLine(snapshot: BoardSnapshot): string {
   ].join("  ·  ");
 }
 
+/** How current the label sets behind the lanes are. A lane rule is only as
+ *  authoritative as its last successful read, so a stale one says so instead of
+ *  letting an empty QUEUE read as an empty queue. */
+function labelFact(snapshot: BoardSnapshot): string {
+  const { readAt, error } = snapshot.labels;
+  if (error === undefined) return "tracker ok";
+  const detail = error.replace(/\s+/g, " ").slice(0, 80);
+  if (readAt === 0) return `tracker unread — ${detail}`;
+  return `tracker stale ${humanDuration(snapshot.now - readAt)} — ${detail}`;
+}
+
 function integrationLine(snapshot: BoardSnapshot): string {
   const { telegram, codeGraph } = snapshot.health;
   const graph = codeGraph?.configured
     ? `${codeGraph.status} ${codeGraph.repos.filter((repo) => repo.index === "present").length}/${codeGraph.repos.length} indexed`
     : "off";
   const telegramDetail = telegram.detail?.replace(/\s+/g, " ").slice(0, 80);
-  return `graph ${graph}  ·  telegram ${telegram.kind}${telegramDetail === undefined ? "" : ` — ${telegramDetail}`}`;
+  return `graph ${graph}  ·  telegram ${telegram.kind}${telegramDetail === undefined ? "" : ` — ${telegramDetail}`}  ·  ${labelFact(snapshot)}`;
 }
 
 function admissionLine(snapshot: BoardSnapshot): string {
@@ -408,12 +589,12 @@ function wrap(value: string, width: number): string[] {
 function renderDetail(snapshot: BoardSnapshot, cursor: BoardCursor, width: number, height: number): string[] {
   const card = focusedCard(snapshot, cursor);
   if (card === undefined) return [styledCell("No card selected.", width, DIM)];
-  if (card.kind === "queue") {
+  if (card.kind === "issue") {
     return [
-      styledCell(` QUEUED ISSUE #${card.issue} `, width, `${BOLD}${REVERSE}`),
-      styledCell(`Latest hold: ${card.reason}`, width),
+      styledCell(` ISSUE #${card.issue} `, width, `${BOLD}${REVERSE}`),
+      styledCell(`${card.reason} — ${card.note}`, width),
       "",
-      styledCell("No run exists yet, so there is no transcript to inspect.", width, DIM),
+      styledCell("The store has no run row for this issue, so there is no transcript to inspect.", width, DIM),
     ];
   }
 
@@ -441,7 +622,7 @@ function renderHelp(width: number, height: number): string[] {
     "←/→ or h/l   select column",
     "↑/↓ or k/j   select card",
     "Enter         inspect/follow transcript",
-    "u             unblock selected failed or blocked issue",
+    "u             unblock selected blocked, failed or orphaned issue",
     "i             open selected issue",
     "p             open selected pull request",
     "r             refresh health now",
@@ -520,6 +701,45 @@ async function probeBoardHealth(project: ProjectConfig): Promise<BoardHealth> {
   return { layers, telegram, daemon, codeGraph: cachedGraph ?? (await probeCodeGraph(project)) };
 }
 
+/**
+ * The label sets behind every stopped lane.
+ *
+ * Reading them is the whole of the #109 fix: the store only knows what it did
+ * itself, so a label a human added or removed — and an issue closed out from
+ * under a run row — are invisible to it, and a board built from run rows alone
+ * reports last-run history as current work.
+ *
+ * "Open issues carrying label L" is a read the tracker port spells exactly
+ * once, as `listReady`, taking the label from `queueLabel`. Substituting the
+ * label reuses that one read for the state labels rather than adding a twelfth
+ * method every future adapter would have to implement for a read-only surface.
+ * Four `gh` calls in parallel, on the ten-second health cadence and never on
+ * the one-second redraw path: the same order of cost as the health probe it
+ * runs beside.
+ *
+ * Never throws. A failed read keeps the previous sets on screen and records
+ * 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> {
+  const openIssuesLabelled = async (label: string): Promise<Set<number>> =>
+    new Set((await makeTracker({ ...project, queueLabel: label }).listReady()).map((issue) => issue.number));
+  try {
+    const [queued, inProgress, blocked, failed] = await Promise.all([
+      openIssuesLabelled(project.queueLabel),
+      openIssuesLabelled(project.stateLabels.inProgress),
+      openIssuesLabelled(project.stateLabels.blocked),
+      openIssuesLabelled(project.stateLabels.failed),
+    ]);
+    return { queued, inProgress, blocked, failed, readAt: Date.now() };
+  } catch (err) {
+    return {
+      ...(previous ?? UNREAD_LABELS),
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
 function issueUrl(project: ProjectConfig, issue: number): string {
   return `https://github.com/${project.tracker.repo}/issues/${issue}`;
 }
@@ -587,7 +807,7 @@ export async function runBoard(projectName?: string): Promise<void> {
   let stopping = false;
   let help = false;
   let notice = "";
-  let health = await probeBoardHealth(project);
+  let [health, labels] = await Promise.all([probeBoardHealth(project), probeBoardLabels(project)]);
   let healthAt = Date.now();
   let healthRefresh: Promise<void> | undefined;
 
@@ -611,9 +831,10 @@ export async function runBoard(projectName?: string): Promise<void> {
       const now = Date.now();
       if (now - healthAt >= HEALTH_REFRESH_MS && healthRefresh === undefined) {
         healthAt = now;
-        healthRefresh = probeBoardHealth(project)
-          .then((next) => {
-            health = next;
+        healthRefresh = Promise.all([probeBoardHealth(project), probeBoardLabels(project, labels)])
+          .then(([nextHealth, nextLabels]) => {
+            health = nextHealth;
+            labels = nextLabels;
             enqueue(queue, { name: "refresh" }, wake);
           })
           .catch((err: unknown) => {
@@ -627,6 +848,7 @@ export async function runBoard(projectName?: string): Promise<void> {
         project,
         status: statusSnapshotFromStore(project, caps, store),
         health,
+        labels,
         runs: store.recentRuns(project.name, now - MERGED_HISTORY_MS),
         now,
       };
@@ -712,11 +934,26 @@ export async function runBoard(projectName?: string): Promise<void> {
         continue;
       }
       if (name === "u") {
-        const state = card?.kind === "run" ? card.run.state : undefined;
-        if (card === undefined || card.kind !== "run" || !["blocked", "failed", "killed", "orphaned"].includes(state!)) {
-          notice = "unblock is available for blocked or failed runs";
+        // Lane, not run state. `unblock` clears the blocked and failed labels
+        // unconditionally and the in-progress label once the newest run row is
+        // terminal (#18), so it is meaningful for exactly the three lanes those
+        // labels define — including an issue with no run row at all, which the
+        // old newest-run check could not reach.
+        //
+        // On an ORPHANED card backed by an `orphaned` row this is the release
+        // path: that row is terminal, so the in-progress label finally comes
+        // off. On an ORPHANED card with no run row it is not, and `unblock`
+        // says so itself rather than being talked out of it here — a missing
+        // row cannot be told apart from a claim that raced the store write, so
+        // it leaves the label in place by design and prints that line. Being
+        // wrong the other way is two workers on one issue; the exit for a card
+        // stuck like that is escalation, not a wider gate here. Both outcomes
+        // are worth offering; neither is promised.
+        const lane = COLUMN_DEFS[cursor.column]?.key;
+        if (card === undefined || (lane !== "blocked" && lane !== "failed" && lane !== "orphaned")) {
+          notice = "unblock is available for blocked, failed or orphaned issues";
         } else {
-          notice = await unblock(project, card.run.issue);
+          notice = await unblock(project, cardIssue(card));
           healthAt = 0;
         }
       }

package/src/briefs/orchestrator.md

@@ -87,7 +87,8 @@ checked in this order:
   `merged`. Never release the label: the open-PR guard only objects to an *open*
   PR, so a re-claim would re-implement a PR that is already on the base branch.
   Close the issue if the merge satisfied it (a merge with no closing keyword
-  leaves it open), take the queue label off, and remove the in-progress label last.
+  leaves it open) and take the queue label off. The in-progress label is not
+  yours to strip: the conductor releases it when the run row settles.
 - **A PR closed without merging.** A human read the work and said no; the row says
   `failed`. Read the rejection before you touch anything — most of the time a
   review comment is a spec change. Fold what it says into the issue, then release
@@ -114,6 +115,16 @@ checked in this order:
 - **Genuinely nothing** (clean tree, no commits, no PR). Release the label and let
   the next tick re-claim it clean.
 
+Releasing a label, in any of these cases, is `omp-conductor unblock <n>` — never
+a hand edit, for the reason above: the verb writes through the same tracker the
+dispatcher does. It takes the blocked and failed labels off unconditionally, and
+`agent:in-progress` too once the newest run row is terminal — which includes the
+`orphaned` row a daemon restart writes for a worker that died with it, so that is
+the usual answer here. Two situations leave in-progress in place, and it says
+which in its output: a run that is genuinely still live, where declining is the
+correct answer, and no run row at all to prove the worker is gone. In that second
+case, escalate the stuck issue rather than editing its labels.
+
 Never leave an orphan holding a slot "to be safe": a label nobody is working under
 is not safety, it is a deadlocked fleet that looks busy.
 
@@ -151,6 +162,13 @@ actually asked, in one message, from evidence you already hold or go and fetch.
 Then stop. Do not continue loop narration in the same reply, and do not restate
 in-progress work unless they asked for it. The loop resumes on the next tick.
 
+A message may also reach you **mid-tick** (delivery is steering: it arrives
+between two of your tool calls). Treat it as an interrupt, not a new tick:
+answer it immediately with `telegram_send` in one message, then return to the
+duty you were in the middle of and finish it. Never abandon or restart the tick
+because a message arrived, and never batch the answer "for the report" — the
+person is waiting now.
+
 ## Escalation tiers
 
 | Tier | Meaning | Handled by |
@@ -234,7 +252,11 @@ The protocol, in order:
    text is what you *apply* on a yes — it is not what you send.
 2. **Ask, once — a single yes/no question, written for a phone.** Explicitly
    call `telegram_ask`; never use the generic `ask` UI. Confirm that the tool
-   delivered the question to the configured Telegram chat. Telegram renders
+   delivered the question to the configured Telegram chat. It is mounted on a
+   locally injected tick only once your operator has configured the bridge's
+   notify destination, and a tick that lacks it says so in its own text. When it
+   does, send the same single yes/no question with `telegram_send` and treat
+   your operator's later reply as the answer — never assume one. Telegram renders
    none of your markdown, so asterisks and backticks arrive as literal characters:
    - Lead with one plain sentence: what changes, and why, in your own words.
    - Then show only the lines that actually change, compact, under two short