@@ -6,9 +6,11 @@ import { describe, expect, test } from "bun:test";
 import { withTestRenderer } from "./harness";
 import {
   chromeComposeCount,
+  clearWorkerWait,
   paintChrome,
   setLockupFrame,
   setStatusFlash,
+  setWorkerWaitAsks,
 } from "./shell/chrome";
 import { createAppShell } from "./shell/index";
 import type { AppShell } from "./shell/internals";
@@ -112,4 +114,43 @@ describe("chrome repaint gate", () => {
       expect(chromeComposeCount(shell)).toBe(baseline + 2);
     });
   });
+
+  test("worker wait snapshots recompose on change and never on a repeat", async () => {
+    await withShell((shell) => {
+      const ask = {
+        sessionId: "sess-1",
+        agentId: "builder",
+        description: "copy assets",
+        question: "Which destination path should I use?",
+        questionId: "q1",
+      };
+      paintChrome(shell);
+      const baseline = chromeComposeCount(shell);
+
+      setWorkerWaitAsks(shell, [ask]);
+      const shown = chromeComposeCount(shell);
+      expect(shown).toBeGreaterThan(baseline);
+      expect(shell.workerWaitRow.visible).toBe(true);
+
+      // Repeat reports of the same identity and idle ticks cost nothing.
+      setWorkerWaitAsks(shell, [ask]);
+      setWorkerWaitAsks(shell, [{ ...ask }]);
+      for (let tick = 0; tick < 5; tick++) paintChrome(shell);
+      expect(chromeComposeCount(shell)).toBe(shown);
+
+      // A replacement question changes the composed strip: one recompose.
+      setWorkerWaitAsks(shell, [
+        { ...ask, questionId: "q2", question: "Overwrite?" },
+      ]);
+      expect(chromeComposeCount(shell)).toBe(shown + 1);
+
+      // The final removal recomposes and hands the row back.
+      setWorkerWaitAsks(shell, []);
+      expect(chromeComposeCount(shell)).toBeGreaterThan(shown + 1);
+      expect(shell.workerWaitRow.visible).toBe(false);
+      const cleared = chromeComposeCount(shell);
+      clearWorkerWait(shell);
+      expect(chromeComposeCount(shell)).toBe(cleared);
+    });
+  });
 });
@@ -34,6 +34,32 @@ describe("zone registry", () => {
   });
 });
 
+describe("worker wait zone", () => {
+  test("seats one row directly on the prompt box without shrinking it", () => {
+    const idle = idle80x24();
+    const layout = idle80x24({ visibility: { workerWait: true } });
+    const strip = defined(layout.regions.worker_wait, "worker_wait");
+    const prompt = defined(layout.regions.prompt, "prompt");
+    expect(strip.height).toBe(1);
+    expect(strip.y + strip.height).toBe(prompt.y);
+    expect(layout.heights.prompt).toBe(idle.heights.prompt);
+    expect(layout.transcriptHeight).toBe(idle.transcriptHeight - 1);
+  });
+
+  test("is the last optional row cut before prompt growth is reclaimed", () => {
+    expect(COLLAPSE_ORDER.indexOf("worker_wait")).toBe(
+      COLLAPSE_ORDER.indexOf("prompt") - 1,
+    );
+    const layout = resolveGeometry({
+      terminal: { columns: 80, rows: 18 },
+      visibility: { workerWait: true, notice: true, pending: 2 },
+    });
+    expect(layout.heights.notice).toBe(0);
+    expect(layout.heights.pending).toBe(0);
+    expect(layout.heights.worker_wait).toBe(1);
+  });
+});
+
 describe("resolveGeometry — 80×24 idle floor", () => {
   test("idle default chrome yields transcript ≥ 12", () => {
     const layout = idle80x24();
 
@@ -45,6 +45,8 @@ export interface ZoneVisibility {
   readonly notice?: boolean;
   /** Pending queue column: exact row count requested (bounded by the zone max). */
   readonly pending?: boolean | number;
+  /** WORKER WAITING strip on (default off). */
+  readonly workerWait?: boolean;
   /** Progress: false/omit = 0; true = 2; or explicit 1|2. */
   readonly progress?: boolean | 1 | 2;
   /** Progress divider (0–1). Default on when progress is shown. */
@@ -157,6 +159,7 @@ export function desiredHeights(input: GeometryInput): MutableHeights {
     progress_divider: progressDivider,
     notice: vis.notice === true ? 1 : ZONE_REGISTRY.notice.idleDefault,
     pending: clamp(boolOrRows(vis.pending, 1), 0, ZONE_REGISTRY.pending.max),
+    worker_wait: vis.workerWait === true ? 1 : 0,
     prompt: promptRows,
     task: clamp(boolOrRows(vis.task, 1), 0, ZONE_REGISTRY.task.max),
     // The board asks for exactly the rows it will paint; the fraction is what
 
@@ -8,6 +8,7 @@ const ZONE_IDS = [
   "progress_divider",
   "notice",
   "pending",
+  "worker_wait",
   "prompt",
   "task",
   "agents",
@@ -104,6 +105,15 @@ export const ZONE_REGISTRY: Readonly<Record<ZoneId, ZoneDeclaration>> = {
     idleDefault: 0,
     alwaysOn: false,
   },
+  // WORKER WAITING strip: one row on the prompt box while a root worker is
+  // parked on ask_director. Off whenever nothing is waiting.
+  worker_wait: {
+    id: "worker_wait",
+    min: 0,
+    max: 1,
+    idleDefault: 0,
+    alwaysOn: false,
+  },
   // Grows with what is being composed; the resolver caps it at PROMPT_CAP_FRACTION
   // and collapses it back toward min when the transcript would breach its floor.
   prompt: {
@@ -220,9 +230,13 @@ export const COLLAPSE_ORDER = [
   "progress",
   "progress_divider",
   "notice",
-  // Pending items are the operator's own queued words: cut last of the
-  // optionals, just ahead of prompt growth reclaim.
+  // Pending items are the operator's own queued words: cut late, after every
+  // banner and strip.
   "pending",
+  // A parked worker is standing state the operator cannot see anywhere else
+  // once the wake turn scrolls away, so its single row is the last optional
+  // cut, just ahead of prompt growth reclaim.
+  "worker_wait",
   // prompt growth reclaimed next (handled specially; never below PROMPT_BASE_ROWS)
   "prompt",
 ] as const satisfies readonly ZoneId[];
@@ -244,6 +258,7 @@ export const PAINT_ORDER = [
   "progress_divider",
   "notice",
   "pending",
+  "worker_wait",
   "prompt",
 ] as const satisfies readonly ZoneId[];
 
 
@@ -21,11 +21,13 @@ import {
 } from "./delivery-queue.js";
 import {
   appendStreamRow,
+  clearWorkerWait,
   paintChrome,
   paintLanding,
   replaceStreamRowAt,
   setLockupFrame,
   setStatusFlash,
+  setWorkerWaitAsks,
   truncateStreamRows,
 } from "./shell/chrome.js";
 import {
@@ -1534,6 +1536,9 @@ function applyInbound(
         bag.askWakeResurface.delete(sessionId);
       }
     }
+    // The strip reads the same reconciled snapshot the wake path does, never
+    // `deliveredAskWake`: delivery to the director is not resolution.
+    setWorkerWaitAsks(shell, [...bag.pendingAskWake.values()]);
     // Occupancy first on the idle-parent subscribe path. An open gate defers
     // both flushes to gateClosed so a wake cannot send before mail.
     // A fresh snapshot with nothing pending means no wake is owed, but a
@@ -2218,6 +2223,9 @@ export function attachSessionBridge(
     bag.pendingPromptRecoveries.length = 0;
     bag.liveFleet = 0;
     bag.pendingAskWake.clear();
+    // Session rotation and stop teardown: the waits belonged to workers that
+    // session owned, so the strip goes with them.
+    clearWorkerWait(shell);
     bag.deliveredAskWake.clear();
     // Stop teardown (CL-8016): with the queue gone no wake turn is owed, so
     // disarm the bound and drop the escalation counts — a later session
@@ -2503,6 +2511,7 @@ export function attachSessionBridge(
       bag.pendingDeliveries.clear();
       bag.pendingPromptRecoveries.length = 0;
       bag.pendingAskWake.clear();
+      clearWorkerWait(shell);
       bag.deliveredAskWake.clear();
       bag.askWakeTurnArmed = false;
       bag.askWakeResurface.clear();
 
@@ -88,6 +88,14 @@ import {
   overlayChromeRows,
 } from "../overlay-view.js";
 import { DECISION_CHOICE_ROWS } from "../overlay-body.js";
+import type { PendingAskWake } from "../../subagent/fleet-report.js";
+import {
+  composeWorkerWaitLine,
+  NO_WORKER_WAIT,
+  reduceWorkerWait,
+  type WorkerWaitPart,
+  type WorkerWaitRole,
+} from "../worker-wait.js";
 
 import {
   type AppShell,
@@ -165,6 +173,54 @@ export function setPluginNeedsAttention(shell: AppShell, needs: boolean): void {
   paintChrome(shell);
 }
 
+/**
+ * Fold the latest pending-ask snapshot into the WORKER WAITING strip.
+ *
+ * The snapshot is authoritative: an identity leaves only when a later
+ * snapshot omits it, never because its wake reached the director, a turn
+ * settled, or the operator typed. Repaints only when the view model moved.
+ */
+export function setWorkerWaitAsks(
+  shell: AppShell,
+  asks: readonly PendingAskWake[],
+): void {
+  const next = reduceWorkerWait(shell.workerWait, asks);
+  if (next === shell.workerWait) return;
+  shell.workerWait = next;
+  paintChrome(shell);
+}
+
+/** Teardown: drop every wait so the prompt box returns to normal chrome. */
+export function clearWorkerWait(shell: AppShell): void {
+  if (shell.workerWait === NO_WORKER_WAIT) return;
+  shell.workerWait = NO_WORKER_WAIT;
+  paintChrome(shell);
+}
+
+/**
+ * Wording carries the state (mark, label, routing copy); colour only lifts
+ * the label to the action emphasis the shell already uses for "act here".
+ */
+function workerWaitFg(role: WorkerWaitRole): string {
+  switch (role) {
+    case "mark":
+    case "label":
+      return UI.action;
+    case "routing":
+    case "question":
+      return UI.text;
+    case "requester":
+    case "more":
+      return UI.textDim;
+    case "separator":
+      return UI.textFaint;
+  }
+}
+
+function workerWaitChunks(parts: readonly WorkerWaitPart[]): TextChunk[] {
+  return parts.map((part) => fgChunk(workerWaitFg(part.role))(part.text));
+}
+
 /**
  * Every input the chrome compose paths read, as one comparable key. A missed
  * input here means stale chrome, so this list is exhaustive:
@@ -182,13 +238,20 @@ export function setPluginNeedsAttention(shell: AppShell, needs: boolean): void {
  *   `lockupChangedMs`, `lockupRampPhase`, `lockupStalledForMs`
  * - cost meter: band, percent label, cost label (or absence)
  * - landing suggestions: whether the prompt has text
+ * - WORKER WAITING strip: its composed text at the current width (folds in
+ *   the selected identity, its preview, and the additional count)
  *
  * Landing and zone paints read their own state and do not pass through here.
  */
-function chromeComposeKey(shell: AppShell, notice: string): string {
+function chromeComposeKey(
+  shell: AppShell,
+  notice: string,
+  workerWait: string,
+): string {
   const meter = shell.costContext;
   return [
     notice,
+    workerWait,
     pendingColumnRows(shell.session.items)
       .map((row) => `${row.tag ?? ""}:${row.text}`)
       .join("\u0001"),
@@ -240,7 +303,15 @@ export function paintChrome(
   if (shell.renderer.isDestroyed || shell.notice.isDestroyed) return;
   syncPending(shell);
   const notice = noticeText(shell);
-  const key = chromeComposeKey(shell, notice);
+  const workerWait = composeWorkerWaitLine(
+    shell.workerWait,
+    shell.layout.contentWidth,
+  );
+  const key = chromeComposeKey(
+    shell,
+    notice,
+    workerWait.map((part) => part.text).join(""),
+  );
   if (!opts?.force && paintedChromeKey.get(shell) === key) return;
   paintedChromeKey.set(shell, key);
   chromeComposeCounts.set(shell, chromeComposeCount(shell) + 1);
@@ -252,6 +323,20 @@ export function paintChrome(
   syncLandingSuggestions(shell);
   syncNoticeRow(shell, notice);
   syncPendingColumn(shell);
+  shell.workerWaitRow.content = new StyledText(workerWaitChunks(workerWait));
+  syncWorkerWaitRow(shell, workerWait.length > 0);
+}
+
+/**
+ * Give the WORKER WAITING strip its row while any worker is parked, and take
+ * it back once the final identity leaves the snapshot. Same transient
+ * contract as the notice row; the resolver seats it, so it never overlaps.
+ */
+function syncWorkerWaitRow(shell: AppShell, wanted: boolean): void {
+  const bag = shellInternals(shell);
+  if (bag === undefined) return;
+  if ((bag.visibility.workerWait ?? false) === wanted) return;
+  relayout(shell, { visibility: { ...bag.visibility, workerWait: wanted } });
 }
 
 /**
@@ -879,6 +964,10 @@ export function applyLayout(shell: AppShell, layout: GeometryLayout): void {
   shell.pendingBox.height = pendingH > 0 ? pendingH : 1;
   shell.pendingBox.visible = pendingH > 0;
 
+  const workerWaitH = Math.max(0, h.worker_wait);
+  shell.workerWaitRow.height = workerWaitH > 0 ? workerWaitH : 1;
+  shell.workerWaitRow.visible = workerWaitH > 0;
+
   const promptH = Math.max(0, h.prompt);
   shell.promptBox.height = promptH > 0 ? promptH : 1;
   shell.promptBox.visible = promptH > 0;
@@ -901,8 +990,9 @@ export function applyLayout(shell: AppShell, layout: GeometryLayout): void {
   // Rows the flow spends before the prompt box — where a floated host's bottom
   // edge has to land, since the landing's box sits mid-screen rather than at
   // the foot and covering it would hide the thing the operator types into.
-  // Stack: topPad, transcript, agents, task, then prompt (notice and the
-  // pending column omitted — both are transient chrome above the prompt).
+  // Stack: topPad, transcript, agents, task, then prompt (notice, the
+  // pending column and the worker-wait strip omitted: all transient chrome
+  // above the prompt, so the float ends above them rather than over them).
   const promptTop = padH + transcriptBody + agentsH + taskH;
   const hostH = floating
     ? Math.min(overlayH, Math.max(1, promptTop))
 
@@ -73,6 +73,7 @@ import {
   syncPromptHighlights,
 } from "./prompt.js";
 import { armMarkdownLinks } from "../url-links.js";
+import { NO_WORKER_WAIT } from "../worker-wait.js";
 import {
   createShellKeyHandlers,
   routePromptWheelToTranscript,
@@ -264,6 +265,15 @@ export function createAppShell(
     visible: layout.heights.pending > 0,
   });
 
+  // Off until a pending-ask snapshot names a parked root worker.
+  const workerWaitRow = new TextRenderable(ctx, {
+    id: "shell-worker-wait",
+    height: Math.max(1, layout.heights.worker_wait),
+    content: "",
+    fg: UI.textDim,
+    visible: layout.heights.worker_wait > 0,
+  });
+
   const promptBox = new BoxRenderable(ctx, {
     id: "shell-prompt-region",
     width: "100%",
@@ -325,6 +335,7 @@ export function createAppShell(
   root.add(taskBox);
   root.add(notice);
   root.add(pendingBox);
+  root.add(workerWaitRow);
   root.add(promptBox);
   root.add(landingBelow);
   root.add(bottomPad);
@@ -431,6 +442,7 @@ export function createAppShell(
     promptBottomRule,
     notice,
     pendingBox,
+    workerWaitRow,
     layout,
     focus: createFocusState(),
     session,
@@ -455,6 +467,7 @@ export function createAppShell(
     statusFlash: null,
     mcpNeedsAuth: [],
     pluginNeedsAttention: false,
+    workerWait: NO_WORKER_WAIT,
     lockupNowMs: 0,
     inFlightTool: null,
     lockupAnimating: false,