pi-straw-boss 0.59.0 → 0.59.1

package/dist/server/main.mjs

@@ -8036,8 +8036,8 @@ function createGuiHost(o) {
     dialogs: () => ({
       hub: theHub(),
       read: async () => void await (forwardNet ??= netSource({ ...o.tower ? { services: (workspace) => o.tower.view(workspace) } : {}, run: cfg.run, world: cfg.world, sessions, hub: theHub() })).read(),
-      /** The pane of a unit by the key the hub gives its dialogs (known after a `read`). */
-      paneOf: (key2) => forwardNet?.lookup(key2)?.pane
+      /** The unit the hub files dialogs under `key` (known after a `read`): its pane for the dispatcher, its name and role for the label a controller is told. */
+      lookup: (key2) => forwardNet?.lookup(key2)
     }),
     /** At the server's start: the GUI on the recorded ports unless it was stopped on purpose (which only the boss's own command undoes). */
     async start() {
@@ -8446,6 +8446,9 @@ var MAX_SEEN = 1024;
 var UNANSWERED_MS = 30 * 6e4;
 var REFRESH_MS = 10 * 6e4;
 var UNKNOWN_RECHECK_MS = 15e3;
+var PASS_STUCK_MS = 6e4;
+var CLOSE_TRIES = 5;
+var MAX_CLOSES = 256;
 var DialogForwarder = class {
   d;
   open = /* @__PURE__ */ new Map();
@@ -8453,12 +8456,29 @@ var DialogForwarder = class {
   seen = /* @__PURE__ */ new Set();
   off;
   polling;
+  /** The closes not posted yet, per controller and dialog, drained by every pass until each is posted. */
+  closes = /* @__PURE__ */ new Map();
+  /** The passes let go as stuck that have not returned; at most one is outstanding, so a call that never returns costs one pending pass and not one a minute. */
+  released = /* @__PURE__ */ new Set();
+  /** The line that a second stuck pass is not let go was written for this stretch. */
+  hung = false;
   again = false;
+  /** The pass that counts: a pass let go as stuck has an older number and stops at its next turn. */
+  gen = 0;
+  /** When the pass in flight began, and the call it waits at (`dialog-pass-stuck` names it). */
+  passAt = 0;
+  step = "idle";
+  /** What the last `dialog-controllers` line said, so a line is written when it changes and not at every pass. */
+  counted;
+  /** The room for open questions was used up, and the line that says so was written. */
+  full = false;
   constructor(d) {
     this.d = d;
   }
   start() {
-    this.off ??= this.d.hub.onChange(() => void this.poll());
+    if (this.off) return;
+    this.off = this.d.hub.onChange(() => void this.poll());
+    this.d.log({ event: "dialog-forwarder", state: "started" });
   }
   stop() {
     this.off?.();
@@ -8468,19 +8488,37 @@ var DialogForwarder = class {
   tick() {
     return this.poll();
   }
-  /** Looks at the hub now; calls that overlap run once more after the one in flight. */
+  /** Looks at the hub now; calls that overlap run once more after the one in flight, and a pass in flight for `PASS_STUCK_MS` is let go (its next look is a new pass). */
   poll() {
-    if (this.polling) return this.again = true, this.polling;
+    if (this.polling) {
+      if (this.now() - this.passAt < PASS_STUCK_MS) return this.again = true, this.polling;
+      if (this.released.size) {
+        if (!this.hung) this.d.log({ event: "dialog-pass-hung", step: this.step, ms: this.now() - this.passAt });
+        this.hung = true;
+        return this.again = true, this.polling;
+      }
+      this.d.log({ event: "dialog-pass-stuck", step: this.step, ms: this.now() - this.passAt });
+      this.gen++;
+      this.released.add(this.polling);
+      this.polling = void 0;
+      for (const d of this.open.values()) d.sent.clear();
+    }
+    const gen = this.gen;
     const run3 = (async () => {
       do {
         this.again = false;
+        this.passAt = this.now();
         try {
-          await this.pass();
+          await this.pass(gen);
         } catch (error) {
-          this.d.log({ event: "dialog-forward-failed", error: String(error.message).slice(0, 200) });
+          this.d.log({ event: "dialog-forward-failed", step: this.step, error: String(error.message).slice(0, 200) });
         }
-      } while (this.again);
-    })().finally(() => this.polling = void 0);
+      } while (this.again && gen === this.gen);
+    })().finally(() => {
+      if (this.polling === run3) this.polling = void 0;
+      this.released.delete(run3);
+      if (!this.released.size) this.hung = false;
+    });
     return this.polling = run3;
   }
   /** Whose unit asked: looked up until it is known, then kept. A lookup that fails leaves it unknown, which is the admins' alone. */
@@ -8492,10 +8530,27 @@ var DialogForwarder = class {
   scopeOf(d) {
     return this.d.dispatcher ? d.who ? { device: d.who.device, ...d.who.team !== void 0 ? { team: d.who.team } : {} } : {} : EVERYONE;
   }
-  async pass() {
+  /** Records where the pass in flight waits (`dialog-pass-stuck` names it); a pass let go as stuck no longer writes it. */
+  at(gen, step) {
+    if (gen === this.gen) this.step = step;
+  }
+  /** One line when the controllers the forwarder sees change in number or in whether the list is complete, so a box with nobody to tell says so once (and the first pass says how it starts). */
+  count(controllers, known2) {
+    const line2 = `${controllers}/${known2}`;
+    if (line2 === this.counted) return;
+    this.counted = line2;
+    this.d.log({ event: "dialog-controllers", count: controllers, known: known2, open: this.open.size });
+  }
+  async pass(gen) {
     const to = this.d.controllers();
+    this.count(to.length, this.d.controllersKnown?.() ?? true);
+    if (this.closes.size && !await this.drain(gen)) return;
     if (!to.length && !this.open.size) return;
-    if (to.length) await this.d.read();
+    if (to.length) {
+      this.at(gen, "read");
+      await this.d.read();
+      if (gen !== this.gen) return;
+    }
     for (const o of to.length ? this.d.hub.answerable() : []) {
       const id = o.target.answer.dialog;
       if (this.open.has(id) || this.skipped.has(id)) continue;
@@ -8504,19 +8559,32 @@ var DialogForwarder = class {
         this.skipped.add(id);
         this.d.log({ event: "dialog-oversize", dialog: id, bytes: Buffer.byteLength(text5) });
         const unit = { key: o.key };
+        this.at(gen, "dispatcher");
         await this.whose(unit);
-        await this.d.notice?.(`oversize/${id}`, { kind: "dialog-oversize", unit: o.key, text: `A question of ${o.owner} was not forwarded: it is ${Buffer.byteLength(text5)} bytes, over the ${LIMITS2.dialog} the link carries. It waits at the device.` }, this.scopeOf(unit));
+        this.at(gen, "notice");
+        await this.d.notice?.(`oversize/${id}`, { kind: "dialog-oversize", unit: o.key, text: `A question of ${this.labelOf(o.key, o.owner)} was not forwarded: it is ${Buffer.byteLength(text5)} bytes, over the ${LIMITS2.dialog} the link carries. It waits at the device.` }, this.scopeOf(unit));
+        if (gen !== this.gen) return;
+        continue;
+      }
+      if (this.open.size >= MAX_OPEN2) {
+        if (!this.full) this.d.log({ event: "dialog-full", open: this.open.size });
+        this.full = true;
         continue;
       }
-      if (this.open.size >= MAX_OPEN2) continue;
-      this.open.set(id, { key: o.key, target: o.target, owner: o.owner, text: text5, sent: /* @__PURE__ */ new Map(), away: /* @__PURE__ */ new Set(), claimed: false, since: this.now(), told: false });
+      this.open.set(id, { key: o.key, target: o.target, owner: o.owner, label: this.labelOf(o.key, o.owner), text: text5, sent: /* @__PURE__ */ new Map(), away: /* @__PURE__ */ new Set(), claimed: false, since: this.now(), told: false });
+      this.d.log({ event: "dialog-seen", dialog: id, unit: o.key, owner: o.owner });
     }
     for (const [id, d] of [...this.open]) {
+      this.at(gen, "dispatcher");
       await this.whose(d);
+      if (gen !== this.gen) return;
       const state = this.d.hub.outcome(id);
       if (!state.open) {
         this.open.delete(id);
-        for (const k of d.sent.keys()) await this.send(k, "dialog-close", { dialogId: id, by: state.by });
+        this.full = false;
+        this.d.log({ event: "dialog-ended", dialog: id, by: state.by, sent: d.sent.size });
+        for (const k of d.sent.keys()) this.hold(k, id, state.by);
+        if (!await this.drain(gen)) return;
         continue;
       }
       if (d.claimed && d.unknownAt !== void 0 && this.now() - d.unknownAt >= UNKNOWN_RECHECK_MS) {
@@ -8529,10 +8597,13 @@ var DialogForwarder = class {
         if (mine.some((c) => `${c.team}
 ${c.device}` === k)) continue;
         d.sent.delete(k);
-        await this.send(k, "dialog-close", { dialogId: id, by: "withdrawn" });
+        this.hold(k, id, "withdrawn");
+        if (!await this.drain(gen)) return;
       }
       if (!d.told && !d.claimed && to.length && this.now() - d.since >= UNANSWERED_MS) {
-        const sent = await this.d.notice?.(`unanswered/${id}`, { kind: "dialog-unanswered", unit: d.key, text: `A question of ${d.owner} has waited ${Math.round((this.now() - d.since) / 6e4)} minutes for an answer.` }, this.scopeOf(d));
+        this.at(gen, "notice");
+        const sent = await this.d.notice?.(`unanswered/${id}`, { kind: "dialog-unanswered", unit: d.key, text: `A question of ${d.label} has waited ${Math.round((this.now() - d.since) / 6e4)} minutes for an answer.` }, this.scopeOf(d));
+        if (gen !== this.gen) return;
         d.told = sent !== false;
       }
       if (!mine.length && !d.unrouted) {
@@ -8548,16 +8619,53 @@ ${c.device}`;
           if (at !== void 0) continue;
         } else if (at !== void 0 && !d.away.delete(k) && this.now() - at < REFRESH_MS) continue;
         d.sent.set(k, this.now());
-        if (!await this.send(k, "dialog-open", { dialogId: id, digest: d.target.answer.digest, owner: d.owner, dialog: d.text })) d.sent.delete(k);
+        this.at(gen, "post");
+        const posted = await this.send(k, "dialog-open", { dialogId: id, digest: d.target.answer.digest, owner: d.label, dialog: d.text });
+        if (gen !== this.gen) return;
+        if (!posted) d.sent.delete(k);
       }
     }
     for (const id of [...this.skipped]) if (!this.d.hub.outcome(id).open) this.skipped.delete(id);
   }
+  /** Keeps a close to post: the oldest is given up when the room is used up. */
+  hold(k, dialogId, by) {
+    this.closes.set(`${k}
+${dialogId}`, { k, dialogId, by, at: this.now(), tries: 0 });
+    for (const [key2, c] of this.closes) {
+      if (this.closes.size <= MAX_CLOSES) break;
+      this.closes.delete(key2);
+      this.d.log({ event: "dialog-close-dropped", dialog: c.dialogId, reason: "full" });
+    }
+  }
+  /** Posts the held closes, each removed once posted. One that failed `CLOSE_TRIES` times, or whose card has expired at the controller (`OPEN_STALE_MS`), is given up with a line. False when this pass was let go meanwhile. */
+  async drain(gen) {
+    for (const [key2, c] of [...this.closes]) {
+      if (this.now() - c.at > OPEN_STALE_MS) {
+        this.closes.delete(key2);
+        this.d.log({ event: "dialog-close-dropped", dialog: c.dialogId, reason: "stale" });
+        continue;
+      }
+      this.at(gen, "post");
+      const posted = await this.send(c.k, "dialog-close", { dialogId: c.dialogId, by: c.by });
+      if (posted) this.closes.delete(key2);
+      else if (++c.tries >= CLOSE_TRIES) {
+        this.closes.delete(key2);
+        this.d.log({ event: "dialog-close-dropped", dialog: c.dialogId, reason: "failed" });
+      }
+      if (gen !== this.gen) return false;
+    }
+    return true;
+  }
   now = () => this.d.now?.() ?? Date.now();
+  /** What the controllers are told asks: the unit's name when it is known, else the owner of the dialog. */
+  labelOf(key2, owner) {
+    return this.d.unit?.(key2) || owner;
+  }
   async send(k, kind, payload) {
     const [team, device] = k.split("\n");
     try {
       await this.d.post(team, device, kind, payload);
+      this.d.log({ event: "dialog-sent", kind, dialog: payload.dialogId, team, to: device });
       return true;
     } catch (error) {
       this.d.log({ event: "dialog-post-failed", kind, dialog: payload.dialogId, error: String(error.message).slice(0, 200) });
@@ -8664,6 +8772,13 @@ function dispatcherLookup(d) {
     return panes3 ? dispatcherOf(pane, panes3, d.allyPanes()) : void 0;
   };
 }
+var KIND = { main: "main", member: "member", subagent: "subagent", ally: "ally run", run: "run" };
+function unitLabel(found) {
+  const name2 = allyLabel(found?.name);
+  if (!found || !/[\p{L}\p{N}]/u.test(name2)) return void 0;
+  const kind = KIND[found.role];
+  return kind ? `${kind} - ${name2}` : name2;
+}
 
 // src/server/opentower.ts
 import { realpathSync as realpathSync7 } from "node:fs";
@@ -11353,6 +11468,7 @@ ${Buffer5.from(header2.id).toString("hex")}`).digest("hex").slice(0, 16);
     const sender = roster.members.get(header2.from);
     if (!(this.o.attended?.() ?? true) || !sender || sender.attended) return void this.o.store.log({ event: "drop", team: run3.team, reason: "dialog-open-unexpected", from: header2.from, kind: "dialog-open" });
     const fresh = this.dialogViews.put({ team: run3.team, device: header2.from, dialogId: p.dialogId, digest: p.digest, owner: p.owner, dialog: p.dialog, at: this.now() });
+    this.o.store.log({ event: "dialog-in", team: run3.team, from: header2.from, dialog: p.dialogId, fresh });
     if (fresh) this.o.notify(`Straw Link: ${sender.label} asks a question (${restrictLabel(p.owner)})`, "warning");
   }
   takeDialogClose(header2, p) {
@@ -18847,11 +18963,12 @@ async function runServer(o) {
   const dialogsOut = () => forwarder ??= new DialogForwarder({
     hub: guiHost.dialogs().hub,
     read: guiHost.dialogs().read,
-    dispatcher: dispatcherLookup({ paneOf: (key2) => guiHost.dialogs().paneOf(key2), list: () => panes(cfg.run), allyPanes: () => towers?.runs.allyPanes() ?? [], now }),
+    dispatcher: dispatcherLookup({ paneOf: (key2) => guiHost.dialogs().lookup(key2)?.pane, list: () => panes(cfg.run), allyPanes: () => towers?.runs.allyPanes() ?? [], now }),
     admin: (team, device) => link?.holder?.isAdmin(team, device) ?? false,
     controllers: () => link?.holder?.dialogControllers() ?? [],
     online: (team, device) => link?.holder?.deviceOnline(team, device) ?? false,
     controllersKnown: () => link?.holder?.controllersKnown() ?? false,
+    unit: (key2) => unitLabel(guiHost.dialogs().lookup(key2)),
     post: async (team, device, kind, payload) => {
       if (!link?.holder) throw new Error("The link holder is not running");
       await link.holder.sendDialog(team, device, kind, payload);
@@ -18971,7 +19088,7 @@ ${unit}`), note = ws ? readNotes(slot, ws).at(-1) : void 0, sent = ws ? link?.ho
   if (slot.primary && !leaving && phase === "starting") {
     dialogsOut().start();
     timers2.push(setInterval(() => void Promise.all([dialogsOut().tick(), unitsOut().tick()]), o.unitsMs ?? 15e3));
-  }
+  } else log.line("dialog-forwarder", { state: "skipped", primary: slot.primary, leaving: Boolean(leaving), phase });
   if (phase === "starting") {
     phase = "ready";
     const stale = own.lastError !== void 0 && own.lastError === prior?.lastError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-straw-boss",
-  "version": "0.59.0",
+  "version": "0.59.1",
   "description": "Straw Boss coordination for pi in Herdr: sessions join a tab's net by choice, the first joiner is its main agent, a workspace tower opens on demand with a live monitoring dashboard, and boss_broadcast reaches the rest",
   "type": "module",
   "license": "MIT",

package/src/link/dialogs-out.ts

@@ -19,7 +19,8 @@ export interface RemoteDialog { select?: unknown; questions?: unknown; cancel?:
 export type RemoteAnswer = { choice: number } | { answers: unknown[] } | { cancel: true };
 
 /** The most dialogs one device keeps open for forwarding, and the answer ids it remembers. */
-const MAX_OPEN = 32, MAX_SEEN = 1024;
+export const MAX_OPEN = 32;
+const MAX_SEEN = 1024;
 
 export interface DialogsOutDeps {
 	hub: Pick<Hub, "onChange" | "answerable" | "outcome" | "send">;
@@ -44,6 +45,11 @@ export interface DialogsOutDeps {
 	dispatcher?(key: string): Promise<{ device: string; team?: string } | undefined>;
 	/** Whether `device` is an admin of `team`'s roster now: an admin is a recipient of every question. Absent: nobody is. */
 	admin?(team: string, device: string): boolean;
+	/**
+	 * What a controller is told asks the question in the unit `key`: the unit's name, scrubbed for leaving the box (known after a `read`). Nothing: the dialog's owner, the package that opened it (`rpiv`), is told instead, which names
+	 * no unit. Absent: the owner.
+	 */
+	unit?(key: string): string | undefined;
 }
 /** A dialog nobody has answered this long is told to the controllers, once. */
 export const UNANSWERED_MS = 30 * 60_000;
@@ -51,9 +57,17 @@ export const UNANSWERED_MS = 30 * 60_000;
 export const REFRESH_MS = 10 * 60_000;
 /** How long an answer that no session confirmed (`unknown`) is trusted to have landed before a dialog that is still open is taken as unanswered. */
 export const UNKNOWN_RECHECK_MS = 15_000;
+/** A pass that has not finished this long is stuck: the next look logs where it waits (`dialog-pass-stuck`), lets it go, and starts a pass of its own, so one call that never returns cannot end forwarding for good. */
+export const PASS_STUCK_MS = 60_000;
+/** A close that failed to post is tried at this many passes, then given up (the card expires at the controller anyway). */
+export const CLOSE_TRIES = 5;
+/** The most closes held to be posted; the oldest is given up when more come. */
+const MAX_CLOSES = 256;
+/** A `dialog-close` (an end, or a withdrawal) not yet posted to a controller: it is kept apart from the open dialog, which is gone from `open` once it ends, so a pass let go as stuck leaves it for the next to post. */
+interface PendingClose { k: string; dialogId: string; by: string; at: number; tries: number }
 export interface DialogAnswerInput { team: string; from: string; dialogId: string; digest: string; answer: string; answerId: string }
 /** `sent` is where the dialog was last sent, per controller, and when; `claimed` is set while an answer is on its way or has been accepted; `unknownAt` is when an answer no session confirmed was sent. */
-interface Open { key: string; target: Parameters<Hub["send"]>[1]; owner: string; text: string; sent: Map<string, number>; away: Set<string>; claimed: boolean; unknownAt?: number; since: number; told: boolean; /** The log line that nobody can be told of this question was written. */ unrouted?: boolean; /** Whose unit asked, once it is known (`dispatcher`). */ who?: { device: string; team?: string } }
+interface Open { key: string; target: Parameters<Hub["send"]>[1]; /** The package that owns the dialog (`rpiv`). */ owner: string; /** What the controllers are told asks: the unit's name when the box can say it, else `owner`. */ label: string; text: string; sent: Map<string, number>; away: Set<string>; claimed: boolean; unknownAt?: number; since: number; told: boolean; /** The log line that nobody can be told of this question was written. */ unrouted?: boolean; /** Whose unit asked, once it is known (`dispatcher`). */ who?: { device: string; team?: string } }
 
 export class DialogForwarder {
 	private readonly d: DialogsOutDeps;
@@ -62,12 +76,29 @@ export class DialogForwarder {
 	private seen = new Set<string>();
 	private off: (() => void) | undefined;
 	private polling: Promise<void> | undefined;
+	/** The closes not posted yet, per controller and dialog, drained by every pass until each is posted. */
+	private closes = new Map<string, PendingClose>();
+	/** The passes let go as stuck that have not returned; at most one is outstanding, so a call that never returns costs one pending pass and not one a minute. */
+	private released = new Set<Promise<void>>();
+	/** The line that a second stuck pass is not let go was written for this stretch. */
+	private hung = false;
 	private again = false;
+	/** The pass that counts: a pass let go as stuck has an older number and stops at its next turn. */
+	private gen = 0;
+	/** When the pass in flight began, and the call it waits at (`dialog-pass-stuck` names it). */
+	private passAt = 0;
+	private step = "idle";
+	/** What the last `dialog-controllers` line said, so a line is written when it changes and not at every pass. */
+	private counted: string | undefined;
+	/** The room for open questions was used up, and the line that says so was written. */
+	private full = false;
 	constructor(d: DialogsOutDeps) {
 		this.d = d;
 	}
 	start(): void {
-		this.off ??= this.d.hub.onChange(() => void this.poll());
+		if (this.off) return;
+		this.off = this.d.hub.onChange(() => void this.poll());
+		this.d.log({ event: "dialog-forwarder", state: "started" });
 	}
 	stop(): void {
 		this.off?.();
@@ -77,19 +108,39 @@ export class DialogForwarder {
 	tick(): Promise<void> {
 		return this.poll();
 	}
-	/** Looks at the hub now; calls that overlap run once more after the one in flight. */
+	/** Looks at the hub now; calls that overlap run once more after the one in flight, and a pass in flight for `PASS_STUCK_MS` is let go (its next look is a new pass). */
 	poll(): Promise<void> {
-		if (this.polling) return ((this.again = true), this.polling);
-		const run = (async () => {
+		if (this.polling) {
+			if (this.now() - this.passAt < PASS_STUCK_MS) return ((this.again = true), this.polling);
+			if (this.released.size) {
+				// A pass let go has not returned: its call may never, and another release would leave one more pending pass behind. The pass in flight is waited on until that one ends.
+				if (!this.hung) this.d.log({ event: "dialog-pass-hung", step: this.step, ms: this.now() - this.passAt });
+				this.hung = true;
+				return ((this.again = true), this.polling);
+			}
+			this.d.log({ event: "dialog-pass-stuck", step: this.step, ms: this.now() - this.passAt });
+			this.gen++;
+			this.released.add(this.polling);
+			this.polling = undefined;
+			// What the pass let go marked as sent may never have left (it waited at the post): the controllers get every open question again.
+			for (const d of this.open.values()) d.sent.clear();
+		}
+		const gen = this.gen;
+		const run: Promise<void> = (async () => {
 			do {
 				this.again = false;
+				this.passAt = this.now();
 				try {
-					await this.pass();
+					await this.pass(gen);
 				} catch (error) {
-					this.d.log({ event: "dialog-forward-failed", error: String((error as Error).message).slice(0, 200) });
+					this.d.log({ event: "dialog-forward-failed", step: this.step, error: String((error as Error).message).slice(0, 200) });
 				}
-			} while (this.again);
-		})().finally(() => (this.polling = undefined));
+			} while (this.again && gen === this.gen);
+		})().finally(() => {
+			if (this.polling === run) this.polling = undefined;
+			this.released.delete(run);
+			if (!this.released.size) this.hung = false;
+		});
 		return (this.polling = run);
 	}
 	/** Whose unit asked: looked up until it is known, then kept. A lookup that fails leaves it unknown, which is the admins' alone. */
@@ -101,10 +152,27 @@ export class DialogForwarder {
 	private scopeOf(d: Open): Scope {
 		return this.d.dispatcher ? (d.who ? { device: d.who.device, ...(d.who.team !== undefined ? { team: d.who.team } : {}) } : {}) : EVERYONE;
 	}
-	private async pass(): Promise<void> {
+	/** Records where the pass in flight waits (`dialog-pass-stuck` names it); a pass let go as stuck no longer writes it. */
+	private at(gen: number, step: string): void {
+		if (gen === this.gen) this.step = step;
+	}
+	/** One line when the controllers the forwarder sees change in number or in whether the list is complete, so a box with nobody to tell says so once (and the first pass says how it starts). */
+	private count(controllers: number, known: boolean): void {
+		const line = `${controllers}/${known}`;
+		if (line === this.counted) return;
+		this.counted = line;
+		this.d.log({ event: "dialog-controllers", count: controllers, known, open: this.open.size });
+	}
+	private async pass(gen: number): Promise<void> {
 		const to = this.d.controllers();
+		this.count(to.length, this.d.controllersKnown?.() ?? true);
+		if (this.closes.size && !(await this.drain(gen))) return;
 		if (!to.length && !this.open.size) return;
-		if (to.length) await this.d.read();
+		if (to.length) {
+			this.at(gen, "read");
+			await this.d.read();
+			if (gen !== this.gen) return;
+		}
 		for (const o of to.length ? this.d.hub.answerable() : []) {
 			const id = o.target.answer.dialog;
 			if (this.open.has(id) || this.skipped.has(id)) continue;
@@ -113,19 +181,33 @@ export class DialogForwarder {
 				this.skipped.add(id);
 				this.d.log({ event: "dialog-oversize", dialog: id, bytes: Buffer.byteLength(text) });
 				const unit = { key: o.key } as Open;
+				this.at(gen, "dispatcher");
 				await this.whose(unit);
-				await this.d.notice?.(`oversize/${id}`, { kind: "dialog-oversize", unit: o.key, text: `A question of ${o.owner} was not forwarded: it is ${Buffer.byteLength(text)} bytes, over the ${LIMITS.dialog} the link carries. It waits at the device.` }, this.scopeOf(unit));
+				this.at(gen, "notice");
+				await this.d.notice?.(`oversize/${id}`, { kind: "dialog-oversize", unit: o.key, text: `A question of ${this.labelOf(o.key, o.owner)} was not forwarded: it is ${Buffer.byteLength(text)} bytes, over the ${LIMITS.dialog} the link carries. It waits at the device.` }, this.scopeOf(unit));
+				if (gen !== this.gen) return;
+				continue;
+			}
+			if (this.open.size >= MAX_OPEN) {
+				// The one case where a question is left unforwarded with no line of its own: the line says the room is used up, once until it frees.
+				if (!this.full) this.d.log({ event: "dialog-full", open: this.open.size });
+				this.full = true;
 				continue;
 			}
-			if (this.open.size >= MAX_OPEN) continue;
-			this.open.set(id, { key: o.key, target: o.target, owner: o.owner, text, sent: new Map(), away: new Set(), claimed: false, since: this.now(), told: false });
+			this.open.set(id, { key: o.key, target: o.target, owner: o.owner, label: this.labelOf(o.key, o.owner), text, sent: new Map(), away: new Set(), claimed: false, since: this.now(), told: false });
+			this.d.log({ event: "dialog-seen", dialog: id, unit: o.key, owner: o.owner });
 		}
 		for (const [id, d] of [...this.open]) {
+			this.at(gen, "dispatcher");
 			await this.whose(d);
+			if (gen !== this.gen) return;
 			const state = this.d.hub.outcome(id);
 			if (!state.open) {
 				this.open.delete(id);
-				for (const k of d.sent.keys()) await this.send(k, "dialog-close", { dialogId: id, by: state.by });
+				this.full = false;
+				this.d.log({ event: "dialog-ended", dialog: id, by: state.by, sent: d.sent.size });
+				for (const k of d.sent.keys()) this.hold(k, id, state.by);
+				if (!(await this.drain(gen))) return;
 				continue;
 			}
 			// An answer no session confirmed, and the dialog is still open a while after: it did not land, so the next valid answer may win and the controllers get the question open again.
@@ -140,11 +222,14 @@ export class DialogForwarder {
 			for (const k of this.d.controllersKnown?.() === false ? [] : [...d.sent.keys()]) {
 				if (mine.some((c) => `${c.team}\n${c.device}` === k)) continue;
 				d.sent.delete(k);
-				await this.send(k, "dialog-close", { dialogId: id, by: "withdrawn" });
+				this.hold(k, id, "withdrawn");
+				if (!(await this.drain(gen))) return;
 			}
 			if (!d.told && !d.claimed && to.length && this.now() - d.since >= UNANSWERED_MS) {
 				// Marked told only once the notice reached somebody: with no admin at `dispatch` it is tried again at the next pass (g346-F005).
-				const sent = await this.d.notice?.(`unanswered/${id}`, { kind: "dialog-unanswered", unit: d.key, text: `A question of ${d.owner} has waited ${Math.round((this.now() - d.since) / 60_000)} minutes for an answer.` }, this.scopeOf(d));
+				this.at(gen, "notice");
+				const sent = await this.d.notice?.(`unanswered/${id}`, { kind: "dialog-unanswered", unit: d.key, text: `A question of ${d.label} has waited ${Math.round((this.now() - d.since) / 60_000)} minutes for an answer.` }, this.scopeOf(d));
+				if (gen !== this.gen) return;
 				d.told = sent !== false;
 			}
 			// A question no controller can be told of (an unattributed unit, and no admin at `dispatch`) stays open and is never widened to the others; the box's own log says it waits.
@@ -160,16 +245,53 @@ export class DialogForwarder {
 					if (at !== undefined) continue;
 				} else if (at !== undefined && !d.away.delete(k) && this.now() - at < REFRESH_MS) continue;
 				d.sent.set(k, this.now());
-				if (!(await this.send(k, "dialog-open", { dialogId: id, digest: d.target.answer.digest, owner: d.owner, dialog: d.text }))) d.sent.delete(k);
+				this.at(gen, "post");
+				const posted = await this.send(k, "dialog-open", { dialogId: id, digest: d.target.answer.digest, owner: d.label, dialog: d.text });
+				// A pass let go no longer owns `sent`: the pass that replaced it has marked what it posted.
+				if (gen !== this.gen) return;
+				if (!posted) d.sent.delete(k);
 			}
 		}
 		for (const id of [...this.skipped]) if (!this.d.hub.outcome(id).open) this.skipped.delete(id);
 	}
+	/** Keeps a close to post: the oldest is given up when the room is used up. */
+	private hold(k: string, dialogId: string, by: string): void {
+		this.closes.set(`${k}\n${dialogId}`, { k, dialogId, by, at: this.now(), tries: 0 });
+		for (const [key, c] of this.closes) {
+			if (this.closes.size <= MAX_CLOSES) break;
+			this.closes.delete(key);
+			this.d.log({ event: "dialog-close-dropped", dialog: c.dialogId, reason: "full" });
+		}
+	}
+	/** Posts the held closes, each removed once posted. One that failed `CLOSE_TRIES` times, or whose card has expired at the controller (`OPEN_STALE_MS`), is given up with a line. False when this pass was let go meanwhile. */
+	private async drain(gen: number): Promise<boolean> {
+		for (const [key, c] of [...this.closes]) {
+			if (this.now() - c.at > OPEN_STALE_MS) {
+				this.closes.delete(key);
+				this.d.log({ event: "dialog-close-dropped", dialog: c.dialogId, reason: "stale" });
+				continue;
+			}
+			this.at(gen, "post");
+			const posted = await this.send(c.k, "dialog-close", { dialogId: c.dialogId, by: c.by });
+			if (posted) this.closes.delete(key);
+			else if (++c.tries >= CLOSE_TRIES) {
+				this.closes.delete(key);
+				this.d.log({ event: "dialog-close-dropped", dialog: c.dialogId, reason: "failed" });
+			}
+			if (gen !== this.gen) return false;
+		}
+		return true;
+	}
 	private now = () => this.d.now?.() ?? Date.now();
+	/** What the controllers are told asks: the unit's name when it is known, else the owner of the dialog. */
+	private labelOf(key: string, owner: string): string {
+		return this.d.unit?.(key) || owner;
+	}
 	private async send(k: string, kind: "dialog-open" | "dialog-close", payload: DialogOpen | DialogClose): Promise<boolean> {
 		const [team, device] = k.split("\n") as [string, string];
 		try {
 			await this.d.post(team, device, kind, payload);
+			this.d.log({ event: "dialog-sent", kind, dialog: payload.dialogId, team, to: device });
 			return true;
 		} catch (error) {
 			this.d.log({ event: "dialog-post-failed", kind, dialog: payload.dialogId, error: String((error as Error).message).slice(0, 200) });

package/src/link/holder.ts

@@ -1129,6 +1129,7 @@ export class LinkHolder {
 		// Only an attended device shows a question; only an unattended member of the team asks one (the envelope check enforces the kind's sender rule, this keeps the receiver honest on its own).
 		if (!(this.o.attended?.() ?? true) || !sender || sender.attended) return void this.o.store.log({ event: "drop", team: run.team, reason: "dialog-open-unexpected", from: header.from, kind: "dialog-open" });
 		const fresh = this.dialogViews.put({ team: run.team, device: header.from, dialogId: p.dialogId, digest: p.digest, owner: p.owner, dialog: p.dialog, at: this.now() });
+		this.o.store.log({ event: "dialog-in", team: run.team, from: header.from, dialog: p.dialogId, fresh });
 		if (fresh) this.o.notify(`Straw Link: ${sender.label} asks a question (${restrictLabel(p.owner)})`, "warning");
 	}
 	private takeDialogClose(header: Header, p: DialogClose): void {

package/src/server/dispatcher.ts

@@ -1,6 +1,7 @@
+import { allyLabel } from "../boardauto.ts";
 import type { Pane } from "../herdr.ts";
 
-// Whose unit a pane is (docs/specs/2026-11-05-link-shared-box.md, Who is told): the controller that dispatched the work done in it. The box has two kinds of unit that a controller starts: an ally run, whose pane the
+// Whose unit a pane is (docs/specs/2026-11-05-link-shared-box.md, Who is told): the controller that dispatched the work done in it, and what the controller is told the unit is called (`unitLabel`). The box has two kinds of unit that a controller starts: an ally run, whose pane the
 // server itself split off (and keeps in its own record), and a main a run opened with `boss_open_main`, in a tab of its own whose pane carries `sb_opened_by=link:<device id>` from before its pi starts. Everything else
 // (the tower's own runs, a session the boss opened on the box) is nobody's. The token is Herdr state any process of the box's user can write, the same trust the main's close and the route table already place in it;
 // this scope is a matter of whom the box bothers and whom it believes, not a wall between users of one account.
@@ -26,3 +27,17 @@ export function dispatcherLookup(d: { paneOf(key: string): string | undefined; l
 		return panes ? dispatcherOf(pane, panes, d.allyPanes()) : undefined;
 	};
 }
+
+/**
+ * The roles whose name alone does not say what the unit is: `main - docs`, `subagent - scout`. The others (a tower, an outside pi) are their name. The separator is ASCII because the controller's holder writes the label into its notice through
+ * `restrictLabel` (letters, digits, space, `.`, `_`, `-`; anything else becomes `_`, cut at 40), so the separator survives it. The name does not always: the card shows it whole, the notice restricted.
+ */
+const KIND: Record<string, string> = { main: "main", member: "member", subagent: "subagent", ally: "ally run", run: "run" };
+
+/** The unit's name for a controller, or nothing when the unit has none left after the scrub (a name that was all path or token is a bare mark). `found` is what the net's registry holds for the unit's key. */
+export function unitLabel(found: { name: string; role: string } | undefined): string | undefined {
+	const name = allyLabel(found?.name);
+	if (!found || !/[\p{L}\p{N}]/u.test(name)) return undefined;
+	const kind = KIND[found.role];
+	return kind ? `${kind} - ${name}` : name;
+}

package/src/server/guihost.ts

@@ -353,7 +353,7 @@ export function createGuiHost(o: GuiHostOptions) {
 	let forwardNet: ReturnType<typeof netSource> | undefined;
 	return {
 		/** The hub and a net reading that binds its dialogs, for the forwarder an unattended device runs. */
-		dialogs: () => ({ hub: theHub(), read: async () => void (await (forwardNet ??= netSource({ ...(o.tower ? { services: (workspace: string) => o.tower!.view(workspace) } : {}), run: cfg.run, world: cfg.world, sessions, hub: theHub() })).read()), /** The pane of a unit by the key the hub gives its dialogs (known after a `read`). */ paneOf: (key: string) => forwardNet?.lookup(key)?.pane }),
+		dialogs: () => ({ hub: theHub(), read: async () => void (await (forwardNet ??= netSource({ ...(o.tower ? { services: (workspace: string) => o.tower!.view(workspace) } : {}), run: cfg.run, world: cfg.world, sessions, hub: theHub() })).read()), /** The unit the hub files dialogs under `key` (known after a `read`): its pane for the dispatcher, its name and role for the label a controller is told. */ lookup: (key: string) => forwardNet?.lookup(key) }),
 		/** At the server's start: the GUI on the recorded ports unless it was stopped on purpose (which only the boss's own command undoes). */
 		async start(): Promise<void> {
 			// The gates' tracking does not depend on the page: a GUI stopped on purpose, or one that could not bind, still has the Allows of the boss's yes in the terminal.

package/src/server/main.ts

@@ -18,7 +18,7 @@ import { createAsks } from "./asks.ts";
 import { cliBeside, createGuiHost, spawnRestart } from "./guihost.ts";
 import { type IntercomModule, loadIntercom, LoaderError } from "./intercom.ts";
 import { DialogForwarder } from "../link/dialogs-out.ts";
-import { dispatcherLookup } from "./dispatcher.ts";
+import { dispatcherLookup, unitLabel } from "./dispatcher.ts";
 import { openTower } from "./opentower.ts";
 import { createLinkService, type LinkService, type ServiceDeps } from "../link/service.ts";
 import { createLog, tailLog } from "./log.ts";
@@ -563,7 +563,7 @@ export async function runServer(o: ServerOptions): Promise<ServerHandle> {
 	// pi-intercom: the server's own session, reconnecting with the sidecar's backoff (1, 2, 5, 10, then 30 s). While it is disconnected its identities are not live.
 	// The link holder (B3): the primary server only, built once the first connection is attached (the kit's channel needs a client). A computer with no team set up gets no channel, election, or files.
 	const dialogsOut = () => (forwarder ??= new DialogForwarder({
-		hub: guiHost!.dialogs().hub, read: guiHost!.dialogs().read, dispatcher: dispatcherLookup({ paneOf: (key) => guiHost!.dialogs().paneOf(key), list: () => panes(cfg.run), allyPanes: () => towers?.runs.allyPanes() ?? [], now }), admin: (team, device) => link?.holder?.isAdmin(team, device) ?? false, controllers: () => link?.holder?.dialogControllers() ?? [], online: (team, device) => link?.holder?.deviceOnline(team, device) ?? false, controllersKnown: () => link?.holder?.controllersKnown() ?? false,
+		hub: guiHost!.dialogs().hub, read: guiHost!.dialogs().read, dispatcher: dispatcherLookup({ paneOf: (key) => guiHost!.dialogs().lookup(key)?.pane, list: () => panes(cfg.run), allyPanes: () => towers?.runs.allyPanes() ?? [], now }), admin: (team, device) => link?.holder?.isAdmin(team, device) ?? false, controllers: () => link?.holder?.dialogControllers() ?? [], online: (team, device) => link?.holder?.deviceOnline(team, device) ?? false, controllersKnown: () => link?.holder?.controllersKnown() ?? false, unit: (key) => unitLabel(guiHost!.dialogs().lookup(key)),
 		post: async (team, device, kind, payload) => { if (!link?.holder) throw new Error("The link holder is not running"); await link.holder.sendDialog(team, device, kind, payload); },
 		log: ({ event, ...rest }) => log.line(String(event), Object.fromEntries(Object.entries(rest).map(([k, v]) => [k, typeof v === "number" || typeof v === "boolean" ? v : phrase(v, 200)]))),
 		now, notice: (key, notice, scope) => unitsOut().notify(key, notice, scope),
@@ -664,7 +664,7 @@ export async function runServer(o: ServerOptions): Promise<ServerHandle> {
 		dialogsOut().start();
 		// A controller that gained `dispatch` mid-dialog gets it, a dialog unanswered for 30 minutes is told, and each controller's unit-status goes out when it changed or a minute has passed.
 		timers.push(setInterval(() => void Promise.all([dialogsOut().tick(), unitsOut().tick()]), o.unitsMs ?? 15_000));
-	}
+	} else log.line("dialog-forwarder", { state: "skipped", primary: slot.primary, leaving: Boolean(leaving), phase });
 
 	// Ready: `restarting` goes, and the start-error of this attempt (and any before it) with it.
 	if (phase === "starting") {